Deal with different offsets in kra and ora

Because of a change in zip library, the location of the mimetype
is different for different versions of krita.

.gitlab-ci.yml

@@ -5,6 +5,3 @@ include:
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/linux.yml
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/android.yml
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/freebsd.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/linux-qt6.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/android-qt6.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/windows.yml

.kde-ci.yml

@@ -6,4 +6,3 @@ Dependencies:
 
 Options:
   test-before-installing: True
-  require-passing-tests-on: [ 'Linux', 'FreeBSD', 'Windows' ]

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.16)
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.96.0  NO_MODULE)
+find_package(ECM 5.90.0  NO_MODULE)
 set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://commits.kde.org/extra-cmake-modules")
 feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
@@ -13,9 +13,9 @@ set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 include(KDEInstallDirs)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
-
 include(KDEGitCommitHooks)
-include(ECMDeprecationSettings)
+
+
 include(CheckIncludeFiles)
 include(FindPkgConfig)
 
@@ -70,11 +70,8 @@ if(KIMAGEFORMATS_JXL)
 endif()
 add_feature_info(LibJXL LibJXL_FOUND "required for the QImage plugin for JPEG XL images")
 
-ecm_set_disabled_deprecation_versions(
-    QT 5.15.2
-    KF 5.95
-)
-
+add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f02)
+add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055900)
 add_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)

README.md

@@ -16,7 +16,7 @@ The following image formats have read-only support:
 - Animated Windows cursors (ani)
 - Gimp (xcf)
 - OpenEXR (exr)
-- Photoshop documents (psd, psb, pdd, psdt)
+- Photoshop documents (psd)
 - Sun Raster (ras)
 
 The following image formats have read and write support:

autotests/CMakeLists.txt

@@ -30,12 +30,6 @@ macro(kimageformats_read_tests)
 endmacro()
 
 macro(kimageformats_write_tests)
-    cmake_parse_arguments(KIF_RT "" "FUZZ" "" ${ARGN})
-    set(_fuzzarg)
-    if (KIF_RT_FUZZ)
-        set(_fuzzarg -f ${KIF_RT_FUZZ})
-    endif()
-
     if (NOT TARGET writetest)
         add_executable(writetest writetest.cpp)
         target_link_libraries(writetest Qt${QT_MAJOR_VERSION}::Gui)
@@ -43,22 +37,16 @@ macro(kimageformats_write_tests)
             PRIVATE IMAGEDIR="${CMAKE_CURRENT_SOURCE_DIR}/write")
         ecm_mark_as_test(writetest)
     endif()
-    foreach(_testname ${KIF_RT_UNPARSED_ARGUMENTS})
+    foreach(_testname ${ARGN})
         string(REGEX MATCH "-lossless$" _is_lossless "${_testname}")
-        string(REGEX MATCH "-nodatacheck" _is_no_data_check "${_testname}")
         unset(lossless_arg)
-        unset(no_data_check_arg)
         if (_is_lossless)
             set(lossless_arg "--lossless")
             string(REGEX REPLACE "-lossless$" "" _testname "${_testname}")
         endif()
-        if (_is_no_data_check)
-            set(no_data_check_arg "--no-data-check")
-            string(REGEX REPLACE "-nodatacheck$" "" _testname "${_testname}")
-        endif()
         add_test(
             NAME kimageformats-write-${_testname}
-            COMMAND writetest ${lossless_arg} ${no_data_check_arg} ${_fuzzarg} ${_testname}
+            COMMAND writetest ${lossless_arg} ${_testname}
         )
     endforeach(_testname)
 endmacro()
@@ -86,28 +74,18 @@ if (TARGET avif)
     kimageformats_read_tests(
         avif
     )
-    kimageformats_write_tests(
-        avif-nodatacheck-lossless
-    )
 endif()
 
 if (LibHeif_FOUND)
     kimageformats_read_tests(
         heif
     )
-    # because the plug-ins use RGB->YUV conversion which sometimes results in 1 value difference.
-    kimageformats_write_tests(FUZZ 1
-        heif-nodatacheck-lossless
-    )
 endif()
 
 if (LibJXL_FOUND AND LibJXLThreads_FOUND)
     kimageformats_read_tests(
         jxl
     )
-    kimageformats_write_tests(
-        jxl-nodatacheck-lossless
-    )
 endif()
 
 # Allow some fuzziness when reading this formats, to allow for

autotests/fuzzyeq.cpp

@@ -1,37 +0,0 @@
-/*
-    SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kdemail.net>
-
-    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
-*/
-
-template<class Trait>
-static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
-{
-    Q_ASSERT(im1.format() == im2.format());
-    Q_ASSERT(im1.depth() == 24 || im1.depth() == 32 || im1.depth() == 64);
-
-    const int height = im1.height();
-    const int width = im1.width();
-    for (int i = 0; i < height; ++i) {
-        const Trait *line1 = reinterpret_cast<const Trait *>(im1.scanLine(i));
-        const Trait *line2 = reinterpret_cast<const Trait *>(im2.scanLine(i));
-        for (int j = 0; j < width; ++j) {
-            if (line1[j] > line2[j]) {
-                if (line1[j] - line2[j] > fuzziness) {
-                    return false;
-                }
-            } else {
-                if (line2[j] - line1[j] > fuzziness) {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-}
-
-// allow each byte to be different by up to 1, to allow for rounding errors
-static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
-{
-    return (im1.depth() == 64) ? fuzzyeq<quint16>(im1, im2, fuzziness) : fuzzyeq<quint8>(im1, im2, fuzziness);
-}

autotests/readtest.cpp

@@ -16,8 +16,6 @@
 
 #include "../tests/format-enum.h"
 
-#include "fuzzyeq.cpp"
-
 static void writeImageData(const char *name, const QString &filename, const QImage &image)
 {
     QFile file(filename);
@@ -33,6 +31,38 @@ static void writeImageData(const char *name, const QString &filename, const QIma
     }
 }
 
+template<class Trait>
+static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
+{
+    Q_ASSERT(im1.format() == im2.format());
+    Q_ASSERT(im1.depth() == 24 || im1.depth() == 32 || im1.depth() == 64);
+
+    const int height = im1.height();
+    const int width = im1.width();
+    for (int i = 0; i < height; ++i) {
+        const Trait *line1 = reinterpret_cast<const Trait *>(im1.scanLine(i));
+        const Trait *line2 = reinterpret_cast<const Trait *>(im2.scanLine(i));
+        for (int j = 0; j < width; ++j) {
+            if (line1[j] > line2[j]) {
+                if (line1[j] - line2[j] > fuzziness) {
+                    return false;
+                }
+            } else {
+                if (line2[j] - line1[j] > fuzziness) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+// allow each byte to be different by up to 1, to allow for rounding errors
+static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
+{
+    return (im1.depth() == 64) ? fuzzyeq<quint16>(im1, im2, fuzziness) : fuzzyeq<quint8>(im1, im2, fuzziness);
+}
+
 // Returns the original format if we support, or returns
 // format which we preferred to use for `fuzzyeq()`.
 // We do only support formats with 8-bits/16-bits pre pixel.

autotests/writetest.cpp

@@ -16,8 +16,6 @@
 #include <QImageWriter>
 #include <QTextStream>
 
-#include "fuzzyeq.cpp"
-
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
@@ -33,13 +31,7 @@ int main(int argc, char **argv)
     parser.addPositionalArgument(QStringLiteral("format"), QStringLiteral("format to test."));
     QCommandLineOption lossless(QStringList() << QStringLiteral("l") << QStringLiteral("lossless"),
                                 QStringLiteral("Check that reading back the data gives the same image."));
-    QCommandLineOption ignoreDataCheck({QStringLiteral("no-data-check")}, QStringLiteral("Don't check that write data is exactly the same."));
-    QCommandLineOption fuzz(QStringList() << QStringLiteral("f") << QStringLiteral("fuzz"),
-                            QStringLiteral("Allow for some deviation in ARGB data."),
-                            QStringLiteral("max"));
     parser.addOption(lossless);
-    parser.addOption(ignoreDataCheck);
-    parser.addOption(fuzz);
 
     parser.process(app);
 
@@ -52,26 +44,11 @@ int main(int argc, char **argv)
         parser.showHelp(1);
     }
 
-    uchar fuzziness = 0;
-    if (parser.isSet(fuzz)) {
-        bool ok;
-        uint fuzzarg = parser.value(fuzz).toUInt(&ok);
-        if (!ok || fuzzarg > 255) {
-            QTextStream(stderr) << "Error: max fuzz argument must be a number between 0 and 255\n";
-            parser.showHelp(1);
-        }
-        fuzziness = uchar(fuzzarg);
-    }
-
     QString suffix = args.at(0);
     QByteArray format = suffix.toLatin1();
 
     QDir imgdir(QStringLiteral(IMAGEDIR));
-    if (parser.isSet(ignoreDataCheck)) {
-        imgdir.setNameFilters({QLatin1String("*.png")});
-    } else {
-        imgdir.setNameFilters(QStringList(QLatin1String("*.") + suffix));
-    }
+    imgdir.setNameFilters(QStringList(QLatin1String("*.") + suffix));
     imgdir.setFilter(QDir::Files);
 
     int passed = 0;
@@ -81,13 +58,8 @@ int main(int argc, char **argv)
                         << "Starting basic write tests for " << suffix << " images *********\n";
     const QFileInfoList lstImgDir = imgdir.entryInfoList();
     for (const QFileInfo &fi : lstImgDir) {
-        QString pngfile;
-        if (parser.isSet(ignoreDataCheck)) {
-            pngfile = fi.filePath();
-        } else {
-            int suffixPos = fi.filePath().count() - suffix.count();
-            pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
-        }
+        int suffixPos = fi.filePath().count() - suffix.count();
+        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString pngfilename = QFileInfo(pngfile).fileName();
 
         QImageReader pngReader(pngfile, "png");
@@ -98,13 +70,29 @@ int main(int argc, char **argv)
             continue;
         }
 
+        QFile expFile(fi.filePath());
+        if (!expFile.open(QIODevice::ReadOnly)) {
+            QTextStream(stdout) << "ERROR: " << fi.fileName() << ": could not open " << fi.fileName() << ": " << expFile.errorString() << "\n";
+            ++failed;
+            continue;
+        }
+        QByteArray expData = expFile.readAll();
+        if (expData.isEmpty()) {
+            // check if there was actually anything to read
+            expFile.reset();
+            char buf[1];
+            qint64 result = expFile.read(buf, 1);
+            if (result < 0) {
+                QTextStream(stdout) << "ERROR: " << fi.fileName() << ": could not load " << fi.fileName() << ": " << expFile.errorString() << "\n";
+                ++failed;
+                continue;
+            }
+        }
+
         QByteArray writtenData;
         {
             QBuffer buffer(&writtenData);
             QImageWriter imgWriter(&buffer, format.constData());
-            if (parser.isSet(lossless)) {
-                imgWriter.setQuality(100);
-            }
             if (!imgWriter.write(pngImage)) {
                 QTextStream(stdout) << "FAIL : " << fi.fileName() << ": failed to write image data\n";
                 ++failed;
@@ -112,31 +100,10 @@ int main(int argc, char **argv)
             }
         }
 
-        if (!parser.isSet(ignoreDataCheck)) {
-            QFile expFile(fi.filePath());
-            if (!expFile.open(QIODevice::ReadOnly)) {
-                QTextStream(stdout) << "ERROR: " << fi.fileName() << ": could not open " << fi.fileName() << ": " << expFile.errorString() << "\n";
-                ++failed;
-                continue;
-            }
-            QByteArray expData = expFile.readAll();
-            if (expData.isEmpty()) {
-                // check if there was actually anything to read
-                expFile.reset();
-                char buf[1];
-                qint64 result = expFile.read(buf, 1);
-                if (result < 0) {
-                    QTextStream(stdout) << "ERROR: " << fi.fileName() << ": could not load " << fi.fileName() << ": " << expFile.errorString() << "\n";
-                    ++failed;
-                    continue;
-                }
-            }
-
-            if (expData != writtenData) {
-                QTextStream(stdout) << "FAIL : " << fi.fileName() << ": written data differs from " << fi.fileName() << "\n";
-                ++failed;
-                continue;
-            }
+        if (expData != writtenData) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName() << ": written data differs from " << fi.fileName() << "\n";
+            ++failed;
+            continue;
         }
 
         QImage reReadImage;
@@ -152,18 +119,8 @@ int main(int argc, char **argv)
         }
 
         if (parser.isSet(lossless)) {
-            if (!fuzzyeq(pngImage, reReadImage, fuzziness)) {
+            if (pngImage != reReadImage) {
                 QTextStream(stdout) << "FAIL : " << fi.fileName() << ": re-reading the data resulted in a different image\n";
-                if (pngImage.size() == reReadImage.size()) {
-                    for (int i = 0; i < pngImage.width(); ++i) {
-                        for (int j = 0; j < pngImage.height(); ++j) {
-                            if (pngImage.pixel(i, j) != reReadImage.pixel(i, j)) {
-                                QTextStream(stdout) << "Pixel is different " << i << ',' << j << ' ' << pngImage.pixel(i, j) << ' ' << reReadImage.pixel(i, j)
-                                                    << '\n';
-                            }
-                        }
-                    }
-                }
                 ++failed;
                 continue;
             }

src/imageformats/CMakeLists.txt

@@ -4,7 +4,6 @@
 
 function(kimageformats_add_plugin plugin)
     set(options)
-    set(oneValueArgs)
     set(multiValueArgs SOURCES)
     cmake_parse_arguments(KIF_ADD_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
     if(NOT KIF_ADD_PLUGIN_SOURCES)
@@ -87,9 +86,6 @@ endif()
 if (LibJXL_FOUND AND LibJXLThreads_FOUND)
     kimageformats_add_plugin(kimg_jxl SOURCES jxl.cpp)
     target_link_libraries(kimg_jxl PkgConfig::LibJXL PkgConfig::LibJXLThreads)
-    if (LibJXL_VERSION VERSION_GREATER_EQUAL "0.7.0")
-        target_compile_definitions(kimg_jxl PRIVATE KIMG_JXL_API_VERSION=70)
-    endif()
     install(FILES jxl.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 

src/imageformats/ani.cpp

@@ -12,8 +12,6 @@
 #include <QVariant>
 #include <QtEndian>
 
-#include <cstring>
-
 namespace
 {
 struct ChunkHeader {
@@ -421,7 +419,7 @@ bool ANIHandler::ensureScanned() const
             }
 
             // FIXME encoding
-            const QString stringValue = QString::fromLocal8Bit(value.constData(), std::strlen(value.constData()));
+            const QString stringValue = QString::fromLocal8Bit(value);
             if (chunkId == "INAM") {
                 mutableThis->m_name = stringValue;
             } else if (chunkId == "IART") {

src/imageformats/avif.cpp

@@ -67,7 +67,7 @@ bool QAVIFHandler::canRead(QIODevice *device)
 
 bool QAVIFHandler::ensureParsed() const
 {
-    if (m_parseState == ParseAvifSuccess || m_parseState == ParseAvifMetadata) {
+    if (m_parseState == ParseAvifSuccess) {
         return true;
     }
     if (m_parseState == ParseAvifError) {
@@ -79,28 +79,6 @@ bool QAVIFHandler::ensureParsed() const
     return that->ensureDecoder();
 }
 
-bool QAVIFHandler::ensureOpened() const
-{
-    if (m_parseState == ParseAvifSuccess) {
-        return true;
-    }
-    if (m_parseState == ParseAvifError) {
-        return false;
-    }
-
-    QAVIFHandler *that = const_cast<QAVIFHandler *>(this);
-    if (ensureParsed()) {
-        if (m_parseState == ParseAvifMetadata) {
-            bool success = that->jumpToNextImage();
-            that->m_parseState = success ? ParseAvifSuccess : ParseAvifError;
-            return success;
-        }
-    }
-
-    that->m_parseState = ParseAvifError;
-    return false;
-}
-
 bool QAVIFHandler::ensureDecoder()
 {
     if (m_decoder) {
@@ -119,9 +97,6 @@ bool QAVIFHandler::ensureDecoder()
 
     m_decoder = avifDecoderCreate();
 
-    m_decoder->ignoreExif = AVIF_TRUE;
-    m_decoder->ignoreXMP = AVIF_TRUE;
-
 #if AVIF_VERSION >= 80400
     m_decoder->maxThreads = qBound(1, QThread::idealThreadCount(), 64);
 #endif
@@ -152,58 +127,39 @@ bool QAVIFHandler::ensureDecoder()
         return false;
     }
 
-    m_container_width = m_decoder->image->width;
-    m_container_height = m_decoder->image->height;
+    decodeResult = avifDecoderNextImage(m_decoder);
 
-    if ((m_container_width > 65535) || (m_container_height > 65535)) {
-        qWarning("AVIF image (%dx%d) is too large!", m_container_width, m_container_height);
-        m_parseState = ParseAvifError;
-        return false;
-    }
+    if (decodeResult == AVIF_RESULT_OK) {
+        m_container_width = m_decoder->image->width;
+        m_container_height = m_decoder->image->height;
 
-    if ((m_container_width == 0) || (m_container_height == 0)) {
-        qWarning("Empty image, nothing to decode");
-        m_parseState = ParseAvifError;
-        return false;
-    }
-
-    if (m_container_width > ((16384 * 16384) / m_container_height)) {
-        qWarning("AVIF image (%dx%d) has more than 256 megapixels!", m_container_width, m_container_height);
-        m_parseState = ParseAvifError;
-        return false;
-    }
-
-    // calculate final dimensions with crop and rotate operations applied
-    int new_width = m_container_width;
-    int new_height = m_container_height;
-
-    if (m_decoder->image->transformFlags & AVIF_TRANSFORM_CLAP) {
-        if ((m_decoder->image->clap.widthD > 0) && (m_decoder->image->clap.heightD > 0) && (m_decoder->image->clap.horizOffD > 0)
-            && (m_decoder->image->clap.vertOffD > 0)) {
-            int crop_width = (int)((double)(m_decoder->image->clap.widthN) / (m_decoder->image->clap.widthD) + 0.5);
-            if (crop_width < new_width && crop_width > 0) {
-                new_width = crop_width;
-            }
-            int crop_height = (int)((double)(m_decoder->image->clap.heightN) / (m_decoder->image->clap.heightD) + 0.5);
-            if (crop_height < new_height && crop_height > 0) {
-                new_height = crop_height;
-            }
+        if ((m_container_width > 32768) || (m_container_height > 32768)) {
+            qWarning("AVIF image (%dx%d) is too large!", m_container_width, m_container_height);
+            m_parseState = ParseAvifError;
+            return false;
         }
-    }
 
-    if (m_decoder->image->transformFlags & AVIF_TRANSFORM_IROT) {
-        if (m_decoder->image->irot.angle == 1 || m_decoder->image->irot.angle == 3) {
-            int tmp = new_width;
-            new_width = new_height;
-            new_height = tmp;
+        if ((m_container_width == 0) || (m_container_height == 0)) {
+            qWarning("Empty image, nothing to decode");
+            m_parseState = ParseAvifError;
+            return false;
         }
+
+        m_parseState = ParseAvifSuccess;
+        if (decode_one_frame()) {
+            return true;
+        } else {
+            m_parseState = ParseAvifError;
+            return false;
+        }
+    } else {
+        qWarning("ERROR: Failed to decode image: %s", avifResultToString(decodeResult));
     }
 
-    m_estimated_dimensions.setWidth(new_width);
-    m_estimated_dimensions.setHeight(new_height);
-
-    m_parseState = ParseAvifMetadata;
-    return true;
+    avifDecoderDestroy(m_decoder);
+    m_decoder = nullptr;
+    m_parseState = ParseAvifError;
+    return false;
 }
 
 bool QAVIFHandler::decode_one_frame()
@@ -230,9 +186,9 @@ bool QAVIFHandler::decode_one_frame()
         }
     } else {
         if (loadalpha) {
-            resultformat = QImage::Format_ARGB32;
+            resultformat = QImage::Format_RGBA8888;
         } else {
-            resultformat = QImage::Format_RGB32;
+            resultformat = QImage::Format_RGBX8888;
         }
     }
     QImage result(m_decoder->image->width, m_decoder->image->height, resultformat);
@@ -323,16 +279,14 @@ bool QAVIFHandler::decode_one_frame()
         rgb.depth = 16;
         rgb.format = AVIF_RGB_FORMAT_RGBA;
 
-        if (!loadalpha && (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)) {
-            resultformat = QImage::Format_Grayscale16;
+        if (!loadalpha) {
+            if (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
+                resultformat = QImage::Format_Grayscale16;
+            }
         }
     } else {
         rgb.depth = 8;
-#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-        rgb.format = AVIF_RGB_FORMAT_BGRA;
-#else
-        rgb.format = AVIF_RGB_FORMAT_ARGB;
-#endif
+        rgb.format = AVIF_RGB_FORMAT_RGBA;
 
 #if AVIF_VERSION >= 80400
         if (m_decoder->imageCount > 1) {
@@ -341,8 +295,14 @@ bool QAVIFHandler::decode_one_frame()
         }
 #endif
 
-        if (!loadalpha && (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)) {
-            resultformat = QImage::Format_Grayscale8;
+        if (loadalpha) {
+            resultformat = QImage::Format_ARGB32;
+        } else {
+            if (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
+                resultformat = QImage::Format_Grayscale8;
+            } else {
+                resultformat = QImage::Format_RGB32;
+            }
         }
     }
 
@@ -433,15 +393,13 @@ bool QAVIFHandler::decode_one_frame()
         m_current_image = result.convertToFormat(resultformat);
     }
 
-    m_estimated_dimensions = m_current_image.size();
-
     m_must_jump_to_next_image = false;
     return true;
 }
 
 bool QAVIFHandler::read(QImage *image)
 {
-    if (!ensureOpened()) {
+    if (!ensureParsed()) {
         return false;
     }
 
@@ -459,44 +417,15 @@ bool QAVIFHandler::read(QImage *image)
 bool QAVIFHandler::write(const QImage &image)
 {
     if (image.format() == QImage::Format_Invalid) {
-        qWarning("No image data to save!");
+        qWarning("No image data to save");
         return false;
     }
 
-    if ((image.width() > 0) && (image.height() > 0)) {
-        if ((image.width() > 65535) || (image.height() > 65535)) {
-            qWarning("Image (%dx%d) is too large to save!", image.width(), image.height());
-            return false;
-        }
-
-        if (image.width() > ((16384 * 16384) / image.height())) {
-            qWarning("Image (%dx%d) will not be saved because it has more than 256 megapixels!", image.width(), image.height());
-            return false;
-        }
-
-        if ((image.width() > 32768) || (image.height() > 32768)) {
-            qWarning("Image (%dx%d) has a dimension above 32768 pixels, saved AVIF may not work in other software!", image.width(), image.height());
-        }
-    } else {
-        qWarning("Image has zero dimension!");
+    if ((image.width() > 32768) || (image.height() > 32768)) {
+        qWarning("Image is too large");
         return false;
     }
 
-    const char *encoder_name = avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_ENCODE);
-    if (!encoder_name) {
-        qWarning("Cannot save AVIF images because libavif was built without AV1 encoders!");
-        return false;
-    }
-
-    bool lossless = false;
-    if (m_quality >= 100) {
-        if (avifCodecName(AVIF_CODEC_CHOICE_AOM, AVIF_CODEC_FLAG_CAN_ENCODE)) {
-            lossless = true;
-        } else {
-            qWarning("You are using %s encoder. It is recommended to enable libAOM encoder in libavif to use lossless compression.", encoder_name);
-        }
-    }
-
     int maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY * (100 - qBound(0, m_quality, 100)) / 100;
     int minQuantizer = 0;
     int maxQuantizerAlpha = 0;
@@ -689,47 +618,43 @@ bool QAVIFHandler::write(const QImage &image)
 
             // in case primaries or trc were not identified
             if ((primaries_to_save == 2) || (transfer_to_save == 2)) {
-                if (lossless) {
-                    iccprofile = tmpcolorimage.colorSpace().iccProfile();
-                } else {
-                    // upgrade image to higher bit depth
-                    if (save_depth == 8) {
-                        save_depth = 10;
-                        if (tmpcolorimage.hasAlphaChannel()) {
-                            tmpcolorimage = tmpcolorimage.convertToFormat(QImage::Format_RGBA64);
-                        } else {
-                            tmpcolorimage = tmpcolorimage.convertToFormat(QImage::Format_RGBX64);
-                        }
+                // upgrade image to higher bit depth
+                if (save_depth == 8) {
+                    save_depth = 10;
+                    if (tmpcolorimage.hasAlphaChannel()) {
+                        tmpcolorimage = tmpcolorimage.convertToFormat(QImage::Format_RGBA64);
+                    } else {
+                        tmpcolorimage = tmpcolorimage.convertToFormat(QImage::Format_RGBX64);
                     }
+                }
 
-                    if ((primaries_to_save == 2) && (transfer_to_save != 2)) { // other primaries but known trc
-                        primaries_to_save = (avifColorPrimaries)1; // AVIF_COLOR_PRIMARIES_BT709
-                        matrix_to_save = (avifMatrixCoefficients)1; // AVIF_MATRIX_COEFFICIENTS_BT709
+                if ((primaries_to_save == 2) && (transfer_to_save != 2)) { // other primaries but known trc
+                    primaries_to_save = (avifColorPrimaries)1; // AVIF_COLOR_PRIMARIES_BT709
+                    matrix_to_save = (avifMatrixCoefficients)1; // AVIF_MATRIX_COEFFICIENTS_BT709
 
-                        switch (transfer_to_save) {
-                        case 8: // AVIF_TRANSFER_CHARACTERISTICS_LINEAR
-                            tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::Linear));
-                            break;
-                        case 4: // AVIF_TRANSFER_CHARACTERISTICS_BT470M
-                            tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, 2.2f));
-                            break;
-                        case 5: // AVIF_TRANSFER_CHARACTERISTICS_BT470BG
-                            tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, 2.8f));
-                            break;
-                        default: // AVIF_TRANSFER_CHARACTERISTICS_SRGB + any other
-                            tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::SRgb));
-                            transfer_to_save = (avifTransferCharacteristics)13;
-                            break;
-                        }
-                    } else if ((primaries_to_save != 2) && (transfer_to_save == 2)) { // recognized primaries but other trc
-                        transfer_to_save = (avifTransferCharacteristics)13;
-                        tmpcolorimage.convertToColorSpace(tmpcolorimage.colorSpace().withTransferFunction(QColorSpace::TransferFunction::SRgb));
-                    } else { // unrecognized profile
-                        primaries_to_save = (avifColorPrimaries)1; // AVIF_COLOR_PRIMARIES_BT709
-                        transfer_to_save = (avifTransferCharacteristics)13;
-                        matrix_to_save = (avifMatrixCoefficients)1; // AVIF_MATRIX_COEFFICIENTS_BT709
+                    switch (transfer_to_save) {
+                    case 8: // AVIF_TRANSFER_CHARACTERISTICS_LINEAR
+                        tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::Linear));
+                        break;
+                    case 4: // AVIF_TRANSFER_CHARACTERISTICS_BT470M
+                        tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, 2.2f));
+                        break;
+                    case 5: // AVIF_TRANSFER_CHARACTERISTICS_BT470BG
+                        tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, 2.8f));
+                        break;
+                    default: // AVIF_TRANSFER_CHARACTERISTICS_SRGB + any other
                         tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::SRgb));
+                        transfer_to_save = (avifTransferCharacteristics)13;
+                        break;
                     }
+                } else if ((primaries_to_save != 2) && (transfer_to_save == 2)) { // recognized primaries but other trc
+                    transfer_to_save = (avifTransferCharacteristics)13;
+                    tmpcolorimage.convertToColorSpace(tmpcolorimage.colorSpace().withTransferFunction(QColorSpace::TransferFunction::SRgb));
+                } else { // unrecognized profile
+                    primaries_to_save = (avifColorPrimaries)1; // AVIF_COLOR_PRIMARIES_BT709
+                    transfer_to_save = (avifTransferCharacteristics)13;
+                    matrix_to_save = (avifMatrixCoefficients)1; // AVIF_MATRIX_COEFFICIENTS_BT709
+                    tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::SRgb));
                 }
             }
         } else { // profile is unsupported by Qt
@@ -739,9 +664,6 @@ bool QAVIFHandler::write(const QImage &image)
             }
         }
 
-        if (lossless && pixel_format == AVIF_PIXEL_FORMAT_YUV444) {
-            matrix_to_save = (avifMatrixCoefficients)0;
-        }
         avif = avifImageCreate(tmpcolorimage.width(), tmpcolorimage.height(), save_depth, pixel_format);
         avif->matrixCoefficients = matrix_to_save;
 
@@ -760,7 +682,9 @@ bool QAVIFHandler::write(const QImage &image)
         if (save_depth > 8) { // 10bit depth
             rgb.depth = 16;
 
-            if (!tmpcolorimage.hasAlphaChannel()) {
+            if (tmpcolorimage.hasAlphaChannel()) {
+                avif->alphaRange = AVIF_RANGE_FULL;
+            } else {
                 rgb.ignoreAlpha = AVIF_TRUE;
             }
 
@@ -770,6 +694,7 @@ bool QAVIFHandler::write(const QImage &image)
 
             if (tmpcolorimage.hasAlphaChannel()) {
                 rgb.format = AVIF_RGB_FORMAT_RGBA;
+                avif->alphaRange = AVIF_RANGE_FULL;
             } else {
                 rgb.format = AVIF_RGB_FORMAT_RGB;
             }
@@ -793,7 +718,7 @@ bool QAVIFHandler::write(const QImage &image)
         encoder->maxQuantizerAlpha = maxQuantizerAlpha;
     }
 
-    encoder->speed = 6;
+    encoder->speed = 7;
 
     res = avifEncoderWrite(encoder, avif, &raw);
     avifEncoderDestroy(encoder);
@@ -828,7 +753,7 @@ QVariant QAVIFHandler::option(ImageOption option) const
 
     switch (option) {
     case Size:
-        return m_estimated_dimensions;
+        return m_current_image.size();
     case Animation:
         if (imageCount() >= 2) {
             return true;
@@ -884,14 +809,6 @@ int QAVIFHandler::currentImageNumber() const
         return 0;
     }
 
-    if (m_parseState == ParseAvifMetadata) {
-        if (m_decoder->imageCount >= 2) {
-            return -1;
-        } else {
-            return 0;
-        }
-    }
-
     return m_decoder->imageIndex;
 }
 
@@ -901,14 +818,12 @@ bool QAVIFHandler::jumpToNextImage()
         return false;
     }
 
-    if (m_decoder->imageIndex >= 0) {
-        if (m_decoder->imageCount < 2) {
-            return true;
-        }
+    if (m_decoder->imageCount < 2) {
+        return true;
+    }
 
-        if (m_decoder->imageIndex >= m_decoder->imageCount - 1) { // start from beginning
-            avifDecoderReset(m_decoder);
-        }
+    if (m_decoder->imageIndex >= m_decoder->imageCount - 1) { // start from beginning
+        avifDecoderReset(m_decoder);
     }
 
     avifResult decodeResult = avifDecoderNextImage(m_decoder);
@@ -931,7 +846,6 @@ bool QAVIFHandler::jumpToNextImage()
     }
 
     if (decode_one_frame()) {
-        m_parseState = ParseAvifSuccess;
         return true;
     } else {
         m_parseState = ParseAvifError;
@@ -947,7 +861,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
 
     if (m_decoder->imageCount < 2) { // not an animation
         if (imageNumber == 0) {
-            return ensureOpened();
+            return true;
         } else {
             return false;
         }
@@ -957,8 +871,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
         return false;
     }
 
-    if (imageNumber == m_decoder->imageIndex) { // we are here already
-        m_must_jump_to_next_image = false;
+    if (imageNumber == m_decoder->imageCount) { // we are here already
         return true;
     }
 
@@ -982,7 +895,6 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
     }
 
     if (decode_one_frame()) {
-        m_parseState = ParseAvifSuccess;
         return true;
     } else {
         m_parseState = ParseAvifError;
@@ -992,7 +904,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
 
 int QAVIFHandler::nextImageDelay() const
 {
-    if (!ensureOpened()) {
+    if (!ensureParsed()) {
         return 0;
     }
 

src/imageformats/avif_p.h

@@ -13,7 +13,6 @@
 #include <QImage>
 #include <QImageIOPlugin>
 #include <QPointF>
-#include <QSize>
 #include <QVariant>
 #include <avif/avif.h>
 #include <qimageiohandler.h>
@@ -46,7 +45,6 @@ public:
 private:
     static QPointF CompatibleChromacity(qreal chrX, qreal chrY);
     bool ensureParsed() const;
-    bool ensureOpened() const;
     bool ensureDecoder();
     bool decode_one_frame();
 
@@ -54,7 +52,6 @@ private:
         ParseAvifError = -1,
         ParseAvifNotParsed = 0,
         ParseAvifSuccess = 1,
-        ParseAvifMetadata = 2,
     };
 
     ParseAvifState m_parseState;
@@ -62,7 +59,6 @@ private:
 
     uint32_t m_container_width;
     uint32_t m_container_height;
-    QSize m_estimated_dimensions;
 
     QByteArray m_rawData;
     avifROData m_rawAvifData;

src/imageformats/eps.cpp

@@ -15,7 +15,6 @@
 #include <QPainter>
 #include <QPrinter>
 #include <QProcess>
-#include <QStandardPaths>
 #include <QTemporaryFile>
 
 // logging category for this framework, default: log stuff >= warning
@@ -177,12 +176,6 @@ bool EPSHandler::read(QImage *image)
 
     // create GS command line
 
-    const QString gsExec = QStandardPaths::findExecutable(QStringLiteral("gs"));
-    if (gsExec.isEmpty()) {
-        qCWarning(EPSPLUGIN) << "Couldn't find gs exectuable (from GhostScript) in PATH.";
-        return false;
-    }
-
     QStringList gsArgs;
     gsArgs << QLatin1String("-sOutputFile=") + tmpFile.fileName() << QStringLiteral("-q") << QStringLiteral("-g%1x%2").arg(wantedWidth).arg(wantedHeight)
            << QStringLiteral("-dSAFER") << QStringLiteral("-dPARANOIDSAFER") << QStringLiteral("-dNOPAUSE") << QStringLiteral("-sDEVICE=ppm")
@@ -199,7 +192,7 @@ bool EPSHandler::read(QImage *image)
 
     QProcess converter;
     converter.setProcessChannelMode(QProcess::ForwardedErrorChannel);
-    converter.start(gsExec, gsArgs);
+    converter.start(QStringLiteral("gs"), gsArgs);
     if (!converter.waitForStarted(3000)) {
         qCWarning(EPSPLUGIN) << "Reading EPS files requires gs (from GhostScript)";
         return false;

src/imageformats/jxl.cpp

@@ -12,7 +12,6 @@
 #include "jxl_p.h"
 #include <jxl/encode.h>
 #include <jxl/thread_parallel_runner.h>
-#include <string.h>
 
 QJpegXLHandler::QJpegXLHandler()
     : m_parseState(ParseJpegXLNotParsed)
@@ -143,10 +142,6 @@ bool QJpegXLHandler::ensureDecoder()
         return false;
     }
 
-#ifdef KIMG_JXL_API_VERSION
-    JxlDecoderCloseInput(m_decoder);
-#endif
-
     JxlDecoderStatus status = JxlDecoderSubscribeEvents(m_decoder, JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FRAME);
     if (status == JXL_DEC_ERROR) {
         qWarning("ERROR: JxlDecoderSubscribeEvents failed");
@@ -179,30 +174,19 @@ bool QJpegXLHandler::ensureDecoder()
         return false;
     }
 
-    if (m_basicinfo.xsize > 65535 || m_basicinfo.ysize > 65535) {
+    if (m_basicinfo.xsize > 32768 || m_basicinfo.ysize > 32768) {
         qWarning("JXL image (%dx%d) is too large", m_basicinfo.xsize, m_basicinfo.ysize);
         m_parseState = ParseJpegXLError;
         return false;
-    }
-
-    if (sizeof(void *) <= 4) {
+    } else if (sizeof(void *) <= 4) {
         /* On 32bit systems, there is limited address space.
          * We skip imagess bigger than 8192 x 8192 pixels.
          * If we don't do it, abort() in libjxl may close whole application */
-        if (m_basicinfo.xsize > ((8192 * 8192) / m_basicinfo.ysize)) {
+        if ((m_basicinfo.xsize * m_basicinfo.ysize) > 67108864) {
             qWarning("JXL image (%dx%d) is too large for 32bit build of the plug-in", m_basicinfo.xsize, m_basicinfo.ysize);
             m_parseState = ParseJpegXLError;
             return false;
         }
-    } else {
-        /* On 64bit systems
-         * We skip images bigger than 16384 x 16384 pixels.
-         * It is an artificial limit not to use extreme amount of memory */
-        if (m_basicinfo.xsize > ((16384 * 16384) / m_basicinfo.ysize)) {
-            qWarning("JXL image (%dx%d) is bigger than security limit 256 megapixels", m_basicinfo.xsize, m_basicinfo.ysize);
-            m_parseState = ParseJpegXLError;
-            return false;
-        }
     }
 
     m_parseState = ParseJpegXLBasicInfoParsed;
@@ -427,99 +411,17 @@ bool QJpegXLHandler::write(const QImage &image)
         return false;
     }
 
-    if ((image.width() > 0) && (image.height() > 0)) {
-        if ((image.width() > 65535) || (image.height() > 65535)) {
-            qWarning("Image (%dx%d) is too large to save!", image.width(), image.height());
-            return false;
-        }
-
-        if (sizeof(void *) <= 4) {
-            if (image.width() > ((8192 * 8192) / image.height())) {
-                qWarning("Image (%dx%d) is too large save via 32bit build of JXL plug-in", image.width(), image.height());
-                return false;
-            }
-        } else {
-            if (image.width() > ((16384 * 16384) / image.height())) {
-                qWarning("Image (%dx%d) will not be saved because it has more than 256 megapixels", image.width(), image.height());
-                return false;
-            }
-        }
-    } else {
-        qWarning("Image has zero dimension!");
+    if ((image.width() > 32768) || (image.height() > 32768)) {
+        qWarning("Image is too large");
         return false;
     }
 
-    int save_depth = 8; // 8 or 16
-    // depth detection
-    switch (image.format()) {
-    case QImage::Format_BGR30:
-    case QImage::Format_A2BGR30_Premultiplied:
-    case QImage::Format_RGB30:
-    case QImage::Format_A2RGB30_Premultiplied:
-    case QImage::Format_Grayscale16:
-    case QImage::Format_RGBX64:
-    case QImage::Format_RGBA64:
-    case QImage::Format_RGBA64_Premultiplied:
-        save_depth = 16;
-        break;
-    case QImage::Format_RGB32:
-    case QImage::Format_ARGB32:
-    case QImage::Format_ARGB32_Premultiplied:
-    case QImage::Format_RGB888:
-    case QImage::Format_RGBX8888:
-    case QImage::Format_RGBA8888:
-    case QImage::Format_RGBA8888_Premultiplied:
-        save_depth = 8;
-        break;
-    default:
-        if (image.depth() > 32) {
-            save_depth = 16;
-        } else {
-            save_depth = 8;
-        }
-        break;
-    }
-
     JxlEncoder *encoder = JxlEncoderCreate(nullptr);
     if (!encoder) {
         qWarning("Failed to create Jxl encoder");
         return false;
     }
 
-    if (m_quality > 100) {
-        m_quality = 100;
-    } else if (m_quality < 0) {
-        m_quality = 90;
-    }
-
-    JxlBasicInfo output_info;
-    JxlEncoderInitBasicInfo(&output_info);
-
-    bool convert_color_profile;
-    QByteArray iccprofile;
-
-    if (image.colorSpace().isValid() && (m_quality < 100)) {
-        if (image.colorSpace().primaries() != QColorSpace::Primaries::SRgb || image.colorSpace().transferFunction() != QColorSpace::TransferFunction::SRgb) {
-            convert_color_profile = true;
-        } else {
-            convert_color_profile = false;
-        }
-    } else { // lossless or no profile or Qt-unsupported ICC profile
-        convert_color_profile = false;
-        iccprofile = image.colorSpace().iccProfile();
-        if (iccprofile.size() > 0 || m_quality == 100) {
-            output_info.uses_original_profile = JXL_TRUE;
-        }
-    }
-
-    if (save_depth == 16 && (image.hasAlphaChannel() || output_info.uses_original_profile)) {
-        output_info.have_container = JXL_TRUE;
-        JxlEncoderUseContainer(encoder, JXL_TRUE);
-#ifdef KIMG_JXL_API_VERSION
-        JxlEncoderSetCodestreamLevel(encoder, 10);
-#endif
-    }
-
     void *runner = nullptr;
     int num_worker_threads = qBound(1, QThread::idealThreadCount(), 64);
 
@@ -533,48 +435,58 @@ bool QJpegXLHandler::write(const QImage &image)
         }
     }
 
+    JxlEncoderOptions *encoder_options = JxlEncoderOptionsCreate(encoder, nullptr);
+
+    if (m_quality > 100) {
+        m_quality = 100;
+    } else if (m_quality < 0) {
+        m_quality = 90;
+    }
+
+    JxlEncoderOptionsSetDistance(encoder_options, (100.0f - m_quality) / 10.0f);
+
+    JxlEncoderOptionsSetLossless(encoder_options, (m_quality == 100) ? JXL_TRUE : JXL_FALSE);
+
+    JxlBasicInfo output_info;
+    JxlEncoderInitBasicInfo(&output_info);
+
+    JxlColorEncoding color_profile;
+    JxlColorEncodingSetToSRGB(&color_profile, JXL_FALSE);
+
+    bool convert_color_profile;
+    QByteArray iccprofile;
+
+    if (image.colorSpace().isValid()) {
+        if (image.colorSpace().primaries() != QColorSpace::Primaries::SRgb || image.colorSpace().transferFunction() != QColorSpace::TransferFunction::SRgb) {
+            convert_color_profile = true;
+        } else {
+            convert_color_profile = false;
+        }
+    } else { // no profile or Qt-unsupported ICC profile
+        convert_color_profile = false;
+        iccprofile = image.colorSpace().iccProfile();
+        if (iccprofile.size() > 0) {
+            output_info.uses_original_profile = 1;
+        }
+    }
+
     JxlPixelFormat pixel_format;
     QImage::Format tmpformat;
     JxlEncoderStatus status;
 
+    pixel_format.data_type = JXL_TYPE_UINT16;
     pixel_format.endianness = JXL_NATIVE_ENDIAN;
     pixel_format.align = 0;
 
-    output_info.orientation = JXL_ORIENT_IDENTITY;
-    output_info.num_color_channels = 3;
-    output_info.animation.tps_numerator = 10;
-    output_info.animation.tps_denominator = 1;
-
-    if (save_depth > 8) { // 16bit depth
-        pixel_format.data_type = JXL_TYPE_UINT16;
-
-        output_info.bits_per_sample = 16;
-
-        if (image.hasAlphaChannel()) {
-            tmpformat = QImage::Format_RGBA64;
-            pixel_format.num_channels = 4;
-            output_info.alpha_bits = 16;
-            output_info.num_extra_channels = 1;
-        } else {
-            tmpformat = QImage::Format_RGBX64;
-            pixel_format.num_channels = 3;
-            output_info.alpha_bits = 0;
-        }
-    } else { // 8bit depth
-        pixel_format.data_type = JXL_TYPE_UINT8;
-
-        output_info.bits_per_sample = 8;
-
-        if (image.hasAlphaChannel()) {
-            tmpformat = QImage::Format_RGBA8888;
-            pixel_format.num_channels = 4;
-            output_info.alpha_bits = 8;
-            output_info.num_extra_channels = 1;
-        } else {
-            tmpformat = QImage::Format_RGB888;
-            pixel_format.num_channels = 3;
-            output_info.alpha_bits = 0;
-        }
+    if (image.hasAlphaChannel()) {
+        tmpformat = QImage::Format_RGBA64;
+        pixel_format.num_channels = 4;
+        output_info.alpha_bits = 16;
+        output_info.num_extra_channels = 1;
+    } else {
+        tmpformat = QImage::Format_RGBX64;
+        pixel_format.num_channels = 3;
+        output_info.alpha_bits = 0;
     }
 
     const QImage tmpimage =
@@ -582,7 +494,7 @@ bool QJpegXLHandler::write(const QImage &image)
 
     const size_t xsize = tmpimage.width();
     const size_t ysize = tmpimage.height();
-    const size_t buffer_size = (save_depth > 8) ? (2 * pixel_format.num_channels * xsize * ysize) : (pixel_format.num_channels * xsize * ysize);
+    const size_t buffer_size = 2 * pixel_format.num_channels * xsize * ysize;
 
     if (xsize == 0 || ysize == 0 || tmpimage.isNull()) {
         qWarning("Unable to allocate memory for output image");
@@ -595,6 +507,12 @@ bool QJpegXLHandler::write(const QImage &image)
 
     output_info.xsize = tmpimage.width();
     output_info.ysize = tmpimage.height();
+    output_info.bits_per_sample = 16;
+    output_info.intensity_target = 255.0f;
+    output_info.orientation = JXL_ORIENT_IDENTITY;
+    output_info.num_color_channels = 3;
+    output_info.animation.tps_numerator = 10;
+    output_info.animation.tps_denominator = 1;
 
     status = JxlEncoderSetBasicInfo(encoder, &output_info);
     if (status != JXL_ENC_SUCCESS) {
@@ -617,9 +535,6 @@ bool QJpegXLHandler::write(const QImage &image)
             return false;
         }
     } else {
-        JxlColorEncoding color_profile;
-        JxlColorEncodingSetToSRGB(&color_profile, JXL_FALSE);
-
         status = JxlEncoderSetColorEncoding(encoder, &color_profile);
         if (status != JXL_ENC_SUCCESS) {
             qWarning("JxlEncoderSetColorEncoding failed!");
@@ -631,74 +546,39 @@ bool QJpegXLHandler::write(const QImage &image)
         }
     }
 
-#ifdef KIMG_JXL_API_VERSION
-    JxlEncoderFrameSettings *encoder_options = JxlEncoderFrameSettingsCreate(encoder, nullptr);
-
-    JxlEncoderSetFrameDistance(encoder_options, (100.0f - m_quality) / 10.0f);
-
-    JxlEncoderSetFrameLossless(encoder_options, (m_quality == 100) ? JXL_TRUE : JXL_FALSE);
-#else
-    JxlEncoderOptions *encoder_options = JxlEncoderOptionsCreate(encoder, nullptr);
-
-    JxlEncoderOptionsSetDistance(encoder_options, (100.0f - m_quality) / 10.0f);
-
-    JxlEncoderOptionsSetLossless(encoder_options, (m_quality == 100) ? JXL_TRUE : JXL_FALSE);
-#endif
-
-    if (image.hasAlphaChannel() || ((save_depth == 8) && (xsize % 4 == 0))) {
+    if (image.hasAlphaChannel()) {
         status = JxlEncoderAddImageFrame(encoder_options, &pixel_format, (void *)tmpimage.constBits(), buffer_size);
     } else {
-        if (save_depth > 8) { // 16bit depth without alpha channel
-            uint16_t *tmp_buffer = new (std::nothrow) uint16_t[3 * xsize * ysize];
-            if (!tmp_buffer) {
-                qWarning("Memory allocation error");
-                if (runner) {
-                    JxlThreadParallelRunnerDestroy(runner);
-                }
-                JxlEncoderDestroy(encoder);
-                return false;
+        uint16_t *tmp_buffer = new (std::nothrow) uint16_t[3 * xsize * ysize];
+        if (!tmp_buffer) {
+            qWarning("Memory allocation error");
+            if (runner) {
+                JxlThreadParallelRunnerDestroy(runner);
             }
-
-            uint16_t *dest_pixels = tmp_buffer;
-            for (int y = 0; y < tmpimage.height(); y++) {
-                const uint16_t *src_pixels = reinterpret_cast<const uint16_t *>(tmpimage.constScanLine(y));
-                for (int x = 0; x < tmpimage.width(); x++) {
-                    // R
-                    *dest_pixels = *src_pixels;
-                    dest_pixels++;
-                    src_pixels++;
-                    // G
-                    *dest_pixels = *src_pixels;
-                    dest_pixels++;
-                    src_pixels++;
-                    // B
-                    *dest_pixels = *src_pixels;
-                    dest_pixels++;
-                    src_pixels += 2; // skipalpha
-                }
-            }
-            status = JxlEncoderAddImageFrame(encoder_options, &pixel_format, (void *)tmp_buffer, buffer_size);
-            delete[] tmp_buffer;
-        } else { // 8bit depth without alpha channel
-            uchar *tmp_buffer8 = new (std::nothrow) uchar[3 * xsize * ysize];
-            if (!tmp_buffer8) {
-                qWarning("Memory allocation error");
-                if (runner) {
-                    JxlThreadParallelRunnerDestroy(runner);
-                }
-                JxlEncoderDestroy(encoder);
-                return false;
-            }
-
-            uchar *dest_pixels8 = tmp_buffer8;
-            const size_t rowbytes = 3 * xsize;
-            for (int y = 0; y < tmpimage.height(); y++) {
-                memcpy(dest_pixels8, tmpimage.constScanLine(y), rowbytes);
-                dest_pixels8 += rowbytes;
-            }
-            status = JxlEncoderAddImageFrame(encoder_options, &pixel_format, (void *)tmp_buffer8, buffer_size);
-            delete[] tmp_buffer8;
+            JxlEncoderDestroy(encoder);
+            return false;
         }
+
+        uint16_t *dest_pixels = tmp_buffer;
+        for (int y = 0; y < tmpimage.height(); y++) {
+            const uint16_t *src_pixels = reinterpret_cast<const uint16_t *>(tmpimage.constScanLine(y));
+            for (int x = 0; x < tmpimage.width(); x++) {
+                // R
+                *dest_pixels = *src_pixels;
+                dest_pixels++;
+                src_pixels++;
+                // G
+                *dest_pixels = *src_pixels;
+                dest_pixels++;
+                src_pixels++;
+                // B
+                *dest_pixels = *src_pixels;
+                dest_pixels++;
+                src_pixels += 2; // skipalpha
+            }
+        }
+        status = JxlEncoderAddImageFrame(encoder_options, &pixel_format, (void *)tmp_buffer, buffer_size);
+        delete[] tmp_buffer;
     }
 
     if (status == JXL_ENC_ERROR) {
@@ -934,10 +814,6 @@ bool QJpegXLHandler::rewind()
         return false;
     }
 
-#ifdef KIMG_JXL_API_VERSION
-    JxlDecoderCloseInput(m_decoder);
-#endif
-
     if (m_basicinfo.uses_original_profile) {
         if (JxlDecoderSubscribeEvents(m_decoder, JXL_DEC_FULL_IMAGE) != JXL_DEC_SUCCESS) {
             qWarning("ERROR: JxlDecoderSubscribeEvents failed");

src/imageformats/kra.cpp

@@ -18,6 +18,11 @@
 
 static constexpr char s_magic[] = "application/x-krita";
 static constexpr int s_magic_size = sizeof(s_magic) - 1; // -1 to remove the last \0
+static constexpr int s_krita3_offset = 0x26;
+static constexpr int s_krita4_offset = 0x2B;
+static constexpr int s_krita4_64_offset = 0x40;
+static constexpr int s_krita5_offset = 0x26;
+static constexpr int s_krita5_64_offset = 0x3A;
 
 KraHandler::KraHandler()
 {
@@ -58,10 +63,8 @@ bool KraHandler::canRead(QIODevice *device)
         return false;
     }
 
-    char buff[57];
-    if (device->peek(buff, sizeof(buff)) == sizeof(buff)) {
-        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
-    }
+    ByteArray ba = device->peek(43 + s_magic_size);
+    return (ba.contains(s_magic));
 
     return false;
 }

src/imageformats/ora.cpp

@@ -17,6 +17,11 @@
 
 static constexpr char s_magic[] = "image/openraster";
 static constexpr int s_magic_size = sizeof(s_magic) - 1; // -1 to remove the last \0
+static constexpr int s_krita3_offset = 0x26;
+static constexpr int s_krita4_offset = 0x2B;
+static constexpr int s_krita4_64_offset = 0x40;
+static constexpr int s_krita5_offset = 0x26;
+static constexpr int s_krita5_64_offset = 0x3A;
 
 OraHandler::OraHandler()
 {
@@ -57,10 +62,11 @@ bool OraHandler::canRead(QIODevice *device)
         return false;
     }
 
-    char buff[54];
-    if (device->peek(buff, sizeof(buff)) == sizeof(buff)) {
-        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
-    }
+    if (device->peek(s_krita3_offset + s_magic_size).contains(s_magic)) return true;
+    if (device->peek(s_krita4_offset + s_magic_size).contains(s_magic)) return true;
+    if (device->peek(s_krita4_64_offset + s_magic_size).contains(s_magic)) return true;
+    if (device->peek(s_krita5_offset + s_magic_size).contains(s_magic)) return true;
+    if (device->peek(s_krita5_64_offset + s_magic_size).contains(s_magic)) return true;
 
     return false;
 }

src/imageformats/psd.json

@@ -1,4 +1,4 @@
 {
-    "Keys": [ "psd", "psb", "pdd", "psdt" ],
-    "MimeTypes": [ "image/vnd.adobe.photoshop", "image/vnd.adobe.photoshop", "image/vnd.adobe.photoshop", "image/vnd.adobe.photoshop" ]
+    "Keys": [ "psd" ],
+    "MimeTypes": [ "image/vnd.adobe.photoshop" ]
 }

src/imageformats/psd_p.h

@@ -18,9 +18,6 @@ public:
     bool canRead() const override;
     bool read(QImage *image) override;
 
-    bool supportsOption(QImageIOHandler::ImageOption option) const override;
-    QVariant option(QImageIOHandler::ImageOption option) const override;
-
     static bool canRead(QIODevice *device);
 };
 

src/imageformats/ras.cpp

@@ -9,8 +9,6 @@
 
 #include "ras_p.h"
 
-#include "util_p.h"
-
 #include <QDataStream>
 #include <QDebug>
 #include <QImage>
@@ -104,7 +102,8 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
 {
     s.device()->seek(RasHeader::SIZE);
 
-    if (ras.ColorMapLength > kMaxQVectorSize) {
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.ColorMapLength > std::numeric_limits<int>::max() - 32) {
         qWarning() << "LoadRAS() unsupported image color map length in file header" << ras.ColorMapLength;
         return false;
     }
@@ -128,7 +127,8 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
         qWarning() << "LoadRAS() mistmatch between height and width" << ras.Width << ras.Height << ras.Length << ras.Depth;
         return false;
     }
-    if (ras.Length > kMaxQVectorSize) {
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.Length > std::numeric_limits<int>::max() - 32) {
         qWarning() << "LoadRAS() unsupported image length in file header" << ras.Length;
         return false;
     }

src/imageformats/util_p.h

@@ -1,10 +0,0 @@
-/*
-    SPDX-FileCopyrightText: 2022 Albert Astals Cid <aacid@kde.org>
-
-    SPDX-License-Identifier: LGPL-2.0-or-later
-*/
-
-#include <limits>
-
-// QVector uses some extra space for stuff, hence the 32 here suggested by Thiago Macieira
-static constexpr int kMaxQVectorSize = std::numeric_limits<int>::max() - 32;

src/imageformats/xcf.cpp

@@ -16,9 +16,8 @@
 #include <QStack>
 #include <QVector>
 #include <QtEndian>
-#include <QColorSpace>
-
 #include <stdlib.h>
+
 #include <string.h>
 
 #include "gimp_p.h"
@@ -135,7 +134,7 @@ public:
         PROP_SAMPLE_POINTS = 39,
         MAX_SUPPORTED_PROPTYPE, // should always be at the end so its value is last + 1
     };
-    Q_ENUM(PropType)
+    Q_ENUM(PropType);
 
     //! Compression type used in layer tiles.
     enum XcfCompressionType {
@@ -145,7 +144,7 @@ public:
         COMPRESS_ZLIB = 2, /* unused */
         COMPRESS_FRACTAL = 3, /* unused */
     };
-    Q_ENUM(XcfCompressionType)
+    Q_ENUM(XcfCompressionType);
 
     enum LayerModeType {
         GIMP_LAYER_MODE_NORMAL_LEGACY,
@@ -212,7 +211,7 @@ public:
         GIMP_LAYER_MODE_PASS_THROUGH,
         GIMP_LAYER_MODE_COUNT,
     };
-    Q_ENUM(LayerModeType)
+    Q_ENUM(LayerModeType);
 
     //! Type of individual layers in an XCF file.
     enum GimpImageType {
@@ -223,7 +222,7 @@ public:
         INDEXED_GIMAGE,
         INDEXEDA_GIMAGE,
     };
-    Q_ENUM(GimpImageType)
+    Q_ENUM(GimpImageType);
 
     //! Type of individual layers in an XCF file.
     enum GimpColorSpace {
@@ -352,8 +351,6 @@ private:
         bool initialized; //!< Is the QImage initialized?
         QImage image; //!< final QImage
 
-        QHash<QString,QByteArray> parasites;    //!< parasites data
-
         XCFImage(void)
             : initialized(false)
         {
@@ -408,7 +405,6 @@ private:
     bool composeTiles(XCFImage &xcf_image);
     void setGrayPalette(QImage &image);
     void setPalette(XCFImage &xcf_image, QImage &image);
-    void setImageParasites(const XCFImage &xcf_image, QImage &image);
     static void assignImageBytes(Layer &layer, uint i, uint j);
     bool loadHierarchy(QDataStream &xcf_io, Layer &layer);
     bool loadLevel(QDataStream &xcf_io, Layer &layer, qint32 bpp);
@@ -669,9 +665,6 @@ bool XCFImageFormat::readXCF(QIODevice *device, QImage *outImage)
         return false;
     }
 
-    // The image was created: now I can set metadata and ICC color profile inside it.
-    setImageParasites(xcf_image, xcf_image.image);
-
     *outImage = xcf_image.image;
     return true;
 }
@@ -722,15 +715,15 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
                 property.readBytes(tag, size);
 
                 quint32 flags;
-                QByteArray data;
+                char *data = nullptr;
                 property >> flags >> data;
 
-                // WARNING: you cannot add metadata to QImage here because it can be null.
-                // Adding a metadata to a QImage when it is null, does nothing (metas are lost).
-                if(tag) // store metadata for future use
-                    xcf_image.parasites.insert(QString::fromUtf8(tag), data);
+                if (tag && strncmp(tag, "gimp-comment", strlen("gimp-comment")) == 0) {
+                    xcf_image.image.setText(QStringLiteral("Comment"), QString::fromUtf8(data));
+                }
 
                 delete[] tag;
+                delete[] data;
             }
             break;
 
@@ -1241,77 +1234,6 @@ void XCFImageFormat::setPalette(XCFImage &xcf_image, QImage &image)
     image.setColorTable(xcf_image.palette);
 }
 
-/*!
- * Copy the parasites info to QImage.
- * \param xcf_image XCF image containing the parasites read from the data stream.
- * \param image image to apply the parasites data.
- * \note Some comment taken from https://gitlab.gnome.org/GNOME/gimp/-/blob/master/devel-docs/parasites.txt
- */
-void XCFImageFormat::setImageParasites(const XCFImage &xcf_image, QImage &image)
-{
-    auto&& p = xcf_image.parasites;
-    auto keys = p.keys();
-    for (auto&& key : qAsConst(keys)) {
-        auto value = p.value(key);
-        if(value.isEmpty())
-            continue;
-
-        // "icc-profile" (IMAGE, PERSISTENT | UNDOABLE)
-        //     This contains an ICC profile describing the color space the
-        //     image was produced in. TIFF images stored in PhotoShop do
-        //     oftentimes contain embedded profiles. An experimental color
-        //     manager exists to use this parasite, and it will be used
-        //     for interchange between TIFF and PNG (identical profiles)
-        if (key == QStringLiteral("icc-profile")) {
-            auto cs = QColorSpace::fromIccProfile(value);
-            if(cs.isValid())
-                image.setColorSpace(cs);
-            continue;
-        }
-
-        // "gimp-comment" (IMAGE, PERSISTENT)
-        //    Standard GIF-style image comments.  This parasite should be
-        //    human-readable text in UTF-8 encoding.  A trailing \0 might
-        //    be included and is not part of the comment.  Note that image
-        //    comments may also be present in the "gimp-metadata" parasite.
-        if (key == QStringLiteral("gimp-comment")) {
-            value.replace('\0', QByteArray());
-            image.setText(QStringLiteral("Comment"), QString::fromUtf8(value));
-            continue;
-        }
-
-        // "gimp-image-metadata"
-        //     Saved by GIMP 2.10.30 but it is not mentioned in the specification.
-        //     It is an XML block with the properties set using GIMP.
-        if (key == QStringLiteral("gimp-image-metadata")) {
-            // NOTE: I arbitrary defined the metadata "XML:org.gimp.xml" because it seems
-            //       a GIMP proprietary XML format (no xmlns defined)
-            value.replace('\0', QByteArray());
-            image.setText(QStringLiteral("XML:org.gimp.xml"), QString::fromUtf8(value));
-            continue;
-        }
-
-#if 0   // Unable to generate it using latest GIMP version
-        // "gimp-metadata" (IMAGE, PERSISTENT)
-        //     The metadata associated with the image, serialized as one XMP
-        //     packet.  This metadata includes the contents of any XMP, EXIF
-        //     and IPTC blocks from the original image, as well as
-        //     user-specified values such as image comment, copyright,
-        //     license, etc.
-        if (key == QStringLiteral("gimp-metadata")) {
-            // NOTE: "XML:com.adobe.xmp" is the meta set by Qt reader when an
-            //       XMP packet is found (e.g. when reading a PNG saved by Photoshop).
-            //       I reused the same key because some programs could search for it.
-            value.replace('\0', QByteArray());
-            image.setText(QStringLiteral("XML:com.adobe.xmp"), QString::fromUtf8(value));
-            continue;
-        }
-#endif
-
-    }
-}
-
-
 /*!
  * Copy the bytes from the tile buffer into the image tile QImage, taking into
  * account all the myriad different modes.
@@ -3270,52 +3192,6 @@ bool XCFHandler::write(const QImage &)
     return false;
 }
 
-bool XCFHandler::supportsOption(ImageOption option) const
-{
-    if (option == QImageIOHandler::Size)
-        return true;
-    return false;
-}
-
-QVariant XCFHandler::option(ImageOption option) const
-{
-    QVariant v;
-
-    if (option == QImageIOHandler::Size) {
-        /*
-         * The image structure always starts at offset 0 in the XCF file.
-         * byte[9]     "gimp xcf " File type identification
-         * byte[4]     version     XCF version
-         *                          "file": version 0
-         *                          "v001": version 1
-         *                          "v002": version 2
-         *                          "v003": version 3
-         * byte        0            Zero marks the end of the version tag.
-         * uint32      width        Width of canvas
-         * uint32      height       Height of canvas
-         */
-        if (auto d = device()) {
-            // transactions works on both random and sequential devices
-            d->startTransaction();
-            auto ba9 = d->read(9);      // "gimp xcf "
-            auto ba5 = d->read(4+1);    // version + null terminator
-            auto ba = d->read(8);       // width and height
-            d->rollbackTransaction();
-            if (ba9 == QByteArray("gimp xcf ") && ba5.size() == 5) {
-                QDataStream ds(ba);
-                quint32 width;
-                ds >> width;
-                quint32 height;
-                ds >> height;
-                if (ds.status() == QDataStream::Ok)
-                    v = QVariant::fromValue(QSize(width, height));
-            }
-        }
-    }
-
-    return v;
-}
-
 bool XCFHandler::canRead(QIODevice *device)
 {
     if (!device) {

src/imageformats/xcf_p.h

@@ -20,9 +20,6 @@ public:
     bool read(QImage *image) override;
     bool write(const QImage &image) override;
 
-    bool supportsOption(QImageIOHandler::ImageOption option) const override;
-    QVariant option(QImageIOHandler::ImageOption option) const override;
-
     static bool canRead(QIODevice *device);
 };