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.

.gitattributes

@@ -1 +0,0 @@
-autotests/read/raw/RAW_KODAK_C330_FORMAT_NONE_YRGB.raw binary

.gitlab-ci.yml

@@ -3,12 +3,5 @@
 
 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/linux-static.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
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/windows-static.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/freebsd-qt6.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/windows-qt6.yml

.kde-ci.yml

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

CMakeLists.txt

@@ -3,19 +3,19 @@ cmake_minimum_required(VERSION 3.16)
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.101.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)
 
 
-set(CMAKE_MODULE_PATH ${KImageFormats_SOURCE_DIR}/cmake/find-modules ${ECM_MODULE_PATH})
+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,18 +70,8 @@ if(KIMAGEFORMATS_JXL)
 endif()
 add_feature_info(LibJXL LibJXL_FOUND "required for the QImage plugin for JPEG XL images")
 
-# note: module FindLibRaw missing from https://invent.kde.org/frameworks/extra-cmake-modules
-find_package(LibRaw 0.20.2)
-set_package_properties(LibRaw PROPERTIES
-    TYPE OPTIONAL
-    PURPOSE "Required for the QImage plugin for RAW 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,9 +16,8 @@ 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)
-- Camera RAW images (arw, cr2, cr3, dcs, dng, ...)
 
 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
@@ -136,15 +114,7 @@ kimageformats_write_tests(
 #    kimageformats_write_tests(eps)
 #endif()
 if (OpenEXR_FOUND)
-    kimageformats_read_tests(
-        exr
-    )
-endif()
-
-if (LibRaw_FOUND)
-    kimageformats_read_tests(
-        raw
-    )
+    # FIXME: OpenEXR tests
 endif()
 
 find_package(Qt${QT_MAJOR_VERSION}Test ${REQUIRED_QT_VERSION} CONFIG QUIET)

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

@@ -9,7 +9,6 @@
 #include <QCommandLineParser>
 #include <QCoreApplication>
 #include <QDir>
-#include <QFile>
 #include <QFileInfo>
 #include <QImage>
 #include <QImageReader>
@@ -17,46 +16,6 @@
 
 #include "../tests/format-enum.h"
 
-#include "fuzzyeq.cpp"
-
-/**
- * @brief The SequentialFile class
- * Class to make a file a sequential access device. This class is used to check if the plugins could works
- * on a sequential device such as a socket.
- */
-class SequentialFile : public QFile
-{
-public:
-    SequentialFile()
-        : QFile()
-    {
-    }
-    explicit SequentialFile(const QString &name)
-        : QFile(name)
-    {
-    }
-#ifndef QT_NO_QOBJECT
-    explicit SequentialFile(QObject *parent)
-        : QFile(parent)
-    {
-    }
-    SequentialFile(const QString &name, QObject *parent)
-        : QFile(name, parent)
-    {
-    }
-#endif
-
-    bool isSequential() const override
-    {
-        return true;
-    }
-
-    qint64 size() const override
-    {
-        return bytesAvailable();
-    }
-};
-
 static void writeImageData(const char *name, const QString &filename, const QImage &image)
 {
     QFile file(filename);
@@ -72,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.
@@ -95,7 +86,7 @@ int main(int argc, char **argv)
     QCoreApplication::removeLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::setApplicationName(QStringLiteral("readtest"));
-    QCoreApplication::setApplicationVersion(QStringLiteral("1.1.0"));
+    QCoreApplication::setApplicationVersion(QStringLiteral("1.0.0"));
 
     QCommandLineParser parser;
     parser.setApplicationDescription(QStringLiteral("Performs basic image conversion checking."));
@@ -133,11 +124,11 @@ int main(int argc, char **argv)
     QByteArray format = suffix.toLatin1();
 
     QDir imgdir(QLatin1String(IMAGEDIR "/") + suffix);
+    imgdir.setNameFilters(QStringList(QLatin1String("*.") + suffix));
     imgdir.setFilter(QDir::Files);
 
     int passed = 0;
     int failed = 0;
-    int skipped = 0;
 
     QTextStream(stdout) << "********* "
                         << "Starting basic read tests for " << suffix << " images *********\n";
@@ -151,91 +142,69 @@ int main(int argc, char **argv)
     QTextStream(stdout) << "QImageReader::supportedImageFormats: " << formatStrings.join(", ") << "\n";
 
     const QFileInfoList lstImgDir = imgdir.entryInfoList();
-    // Launch 2 runs for each test: first run on a random access device, second run on a sequential access device
-    for (int seq = 0; seq < 2; ++seq) {
-        if (seq) {
-            QTextStream(stdout) << "* Run on SEQUENTIAL ACCESS device\n";
-        } else {
-            QTextStream(stdout) << "* Run on RANDOM ACCESS device\n";
+    for (const QFileInfo &fi : lstImgDir) {
+        int suffixPos = fi.filePath().count() - suffix.count();
+        QString inputfile = fi.filePath();
+        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
+        QString expfilename = QFileInfo(expfile).fileName();
+
+        QImageReader inputReader(inputfile, format);
+        QImageReader expReader(expfile, "png");
+
+        QImage inputImage;
+        QImage expImage;
+
+        if (!expReader.read(&expImage)) {
+            QTextStream(stdout) << "ERROR: " << fi.fileName() << ": could not load " << expfilename << ": " << expReader.errorString() << "\n";
+            ++failed;
+            continue;
         }
-        for (const QFileInfo &fi : lstImgDir) {
-            if (!fi.suffix().compare("png", Qt::CaseInsensitive)) {
-                continue;
-            }
-            int suffixPos = fi.filePath().count() - suffix.count();
-            QString inputfile = fi.filePath();
-            QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
-            QString expfilename = QFileInfo(expfile).fileName();
+        if (!inputReader.canRead()) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName() << ": failed can read: " << inputReader.errorString() << "\n";
+            ++failed;
+            continue;
+        }
+        if (!inputReader.read(&inputImage)) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName() << ": failed to load: " << inputReader.errorString() << "\n";
+            ++failed;
+            continue;
+        }
+        if (expImage.width() != inputImage.width()) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName() << ": width was " << inputImage.width() << " but " << expfilename << " width was "
+                                << expImage.width() << "\n";
+            ++failed;
+        } else if (expImage.height() != inputImage.height()) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName() << ": height was " << inputImage.height() << " but " << expfilename << " height was "
+                                << expImage.height() << "\n";
+            ++failed;
+        } else {
+            QImage::Format inputFormat = preferredFormat(inputImage.format());
+            QImage::Format expFormat = preferredFormat(expImage.format());
+            QImage::Format cmpFormat = inputFormat == expFormat ? inputFormat : QImage::Format_ARGB32;
 
-            std::unique_ptr<QIODevice> inputDevice(seq ? new SequentialFile(inputfile) : new QFile(inputfile));
-            QImageReader inputReader(inputDevice.get(), format);
-            QImageReader expReader(expfile, "png");
-
-            QImage inputImage;
-            QImage expImage;
-
-            // inputImage is auto-rotated to final orientation
-            inputReader.setAutoTransform(true);
-
-            if (!expReader.read(&expImage)) {
-                QTextStream(stdout) << "ERROR: " << fi.fileName() << ": could not load " << expfilename << ": " << expReader.errorString() << "\n";
-                ++failed;
-                continue;
+            if (inputImage.format() != cmpFormat) {
+                QTextStream(stdout) << "INFO : " << fi.fileName() << ": converting " << fi.fileName() << " from " << formatToString(inputImage.format())
+                                    << " to " << formatToString(cmpFormat) << '\n';
+                inputImage = inputImage.convertToFormat(cmpFormat);
             }
-            if (!inputReader.canRead()) {
-                // All plugins must pass the test on a random device.
-                // canRead() must also return false if the plugin is unable to run on a sequential device.
-                if (inputDevice->isSequential()) {
-                    QTextStream(stdout) << "SKIP : " << fi.fileName() << ": cannot read on a sequential device (don't worry, it's ok)\n";
-                    ++skipped;
-                } else {
-                    QTextStream(stdout) << "FAIL : " << fi.fileName() << ": failed can read: " << inputReader.errorString() << "\n";
-                    ++failed;
-                }
-                continue;
+            if (expImage.format() != cmpFormat) {
+                QTextStream(stdout) << "INFO : " << fi.fileName() << ": converting " << expfilename << " from " << formatToString(expImage.format()) << " to "
+                                    << formatToString(cmpFormat) << '\n';
+                expImage = expImage.convertToFormat(cmpFormat);
             }
-            if (!inputReader.read(&inputImage)) {
-                QTextStream(stdout) << "FAIL : " << fi.fileName() << ": failed to load: " << inputReader.errorString() << "\n";
-                ++failed;
-                continue;
-            }
-            if (expImage.width() != inputImage.width()) {
-                QTextStream(stdout) << "FAIL : " << fi.fileName() << ": width was " << inputImage.width() << " but " << expfilename << " width was "
-                                    << expImage.width() << "\n";
-                ++failed;
-            } else if (expImage.height() != inputImage.height()) {
-                QTextStream(stdout) << "FAIL : " << fi.fileName() << ": height was " << inputImage.height() << " but " << expfilename << " height was "
-                                    << expImage.height() << "\n";
-                ++failed;
+            if (fuzzyeq(inputImage, expImage, fuzziness)) {
+                QTextStream(stdout) << "PASS : " << fi.fileName() << "\n";
+                ++passed;
             } else {
-                QImage::Format inputFormat = preferredFormat(inputImage.format());
-                QImage::Format expFormat = preferredFormat(expImage.format());
-                QImage::Format cmpFormat = inputFormat == expFormat ? inputFormat : QImage::Format_ARGB32;
-
-                if (inputImage.format() != cmpFormat) {
-                    QTextStream(stdout) << "INFO : " << fi.fileName() << ": converting " << fi.fileName() << " from " << formatToString(inputImage.format())
-                                        << " to " << formatToString(cmpFormat) << '\n';
-                    inputImage = inputImage.convertToFormat(cmpFormat);
-                }
-                if (expImage.format() != cmpFormat) {
-                    QTextStream(stdout) << "INFO : " << fi.fileName() << ": converting " << expfilename << " from " << formatToString(expImage.format())
-                                        << " to " << formatToString(cmpFormat) << '\n';
-                    expImage = expImage.convertToFormat(cmpFormat);
-                }
-                if (fuzzyeq(inputImage, expImage, fuzziness)) {
-                    QTextStream(stdout) << "PASS : " << fi.fileName() << "\n";
-                    ++passed;
-                } else {
-                    QTextStream(stdout) << "FAIL : " << fi.fileName() << ": differs from " << expfilename << "\n";
-                    writeImageData("expected data", fi.fileName() + QLatin1String("-expected.data"), expImage);
-                    writeImageData("actual data", fi.fileName() + QLatin1String("-actual.data"), inputImage);
-                    ++failed;
-                }
+                QTextStream(stdout) << "FAIL : " << fi.fileName() << ": differs from " << expfilename << "\n";
+                writeImageData("expected data", fi.fileName() + QLatin1String("-expected.data"), expImage);
+                writeImageData("actual data", fi.fileName() + QLatin1String("-actual.data"), inputImage);
+                ++failed;
             }
         }
     }
 
-    QTextStream(stdout) << "Totals: " << passed << " passed, " << skipped << " skipped, " << failed << " failed\n";
+    QTextStream(stdout) << "Totals: " << passed << " passed, " << failed << " failed\n";
     QTextStream(stdout) << "********* "
                         << "Finished basic read tests for " << suffix << " images *********\n";
 

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;
             }

cmake/find-modules/FindLibRaw.cmake

@@ -1,86 +0,0 @@
-# - Find LibRaw
-# Find the LibRaw library <https://www.libraw.org>
-# This module defines
-#  LibRaw_VERSION, the version string of LibRaw
-#  LibRaw_INCLUDE_DIR, where to find libraw/libraw.h
-#  LibRaw_LIBRARIES, the libraries needed to use LibRaw (non-thread-safe)
-#  LibRaw_r_LIBRARIES, the libraries needed to use LibRaw (thread-safe)
-#  LibRaw_DEFINITIONS, the definitions needed to use LibRaw (non-thread-safe)
-#  LibRaw_r_DEFINITIONS, the definitions needed to use LibRaw (thread-safe)
-#
-# SPDX-FileCopyrightText: 2013 Pino Toscano <pino at kde dot org>
-# SPDX-FileCopyrightText: 2013 Gilles Caulier <caulier dot gilles at gmail dot com>
-#
-# SPDX-License-Identifier: BSD-3-Clause
-
-FIND_PACKAGE(PkgConfig)
-
-IF(PKG_CONFIG_FOUND)
-   PKG_CHECK_MODULES(PC_LIBRAW libraw)
-   SET(LibRaw_DEFINITIONS ${PC_LIBRAW_CFLAGS_OTHER})
-
-   PKG_CHECK_MODULES(PC_LIBRAW_R libraw_r)
-   SET(LibRaw_r_DEFINITIONS ${PC_LIBRAW_R_CFLAGS_OTHER})   
-ENDIF()
-
-FIND_PATH(LibRaw_INCLUDE_DIR libraw/libraw.h
-          HINTS
-          ${PC_LIBRAW_INCLUDEDIR}
-          ${PC_LibRaw_INCLUDE_DIRS}
-         )
-
-FIND_LIBRARY(LibRaw_LIBRARIES NAMES raw
-             HINTS
-             ${PC_LIBRAW_LIBDIR}
-             ${PC_LIBRAW_LIBRARY_DIRS}
-            )
-
-FIND_LIBRARY(LibRaw_r_LIBRARIES NAMES raw_r
-             HINTS
-             ${PC_LIBRAW_R_LIBDIR}
-             ${PC_LIBRAW_R_LIBRARY_DIRS}
-            )
-
-IF(LibRaw_INCLUDE_DIR)
-   FILE(READ ${LibRaw_INCLUDE_DIR}/libraw/libraw_version.h _libraw_version_content)
-   
-   STRING(REGEX MATCH "#define LIBRAW_MAJOR_VERSION[ \t]*([0-9]*)\n" _version_major_match ${_libraw_version_content})
-   SET(_libraw_version_major "${CMAKE_MATCH_1}")
-   
-   STRING(REGEX MATCH "#define LIBRAW_MINOR_VERSION[ \t]*([0-9]*)\n" _version_minor_match ${_libraw_version_content})
-   SET(_libraw_version_minor "${CMAKE_MATCH_1}")
-   
-   STRING(REGEX MATCH "#define LIBRAW_PATCH_VERSION[ \t]*([0-9]*)\n" _version_patch_match ${_libraw_version_content})
-   SET(_libraw_version_patch "${CMAKE_MATCH_1}")
-   
-   IF(_version_major_match AND _version_minor_match AND _version_patch_match)
-      SET(LibRaw_VERSION "${_libraw_version_major}.${_libraw_version_minor}.${_libraw_version_patch}")
-   ELSE()
-      IF(NOT LibRaw_FIND_QUIETLY)
-         MESSAGE(STATUS "Failed to get version information from ${LibRaw_INCLUDE_DIR}/libraw/libraw_version.h")
-      ENDIF()
-   ENDIF()
-ENDIF()
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibRaw
-                                  REQUIRED_VARS LibRaw_LIBRARIES LibRaw_INCLUDE_DIR
-                                  VERSION_VAR LibRaw_VERSION
-                                 )
-
-MARK_AS_ADVANCED(LibRaw_VERSION
-                 LibRaw_INCLUDE_DIR
-                 LibRaw_LIBRARIES
-                 LibRaw_r_LIBRARIES
-                 LibRaw_DEFINITIONS
-                 LibRaw_r_DEFINITIONS
-                 )
-
-if(LibRaw_FOUND AND NOT TARGET LibRaw::LibRaw)
-    add_library(LibRaw::LibRaw UNKNOWN IMPORTED)
-    set_target_properties(LibRaw::LibRaw PROPERTIES
-        IMPORTED_LOCATION "${LibRaw_LIBRARIES}"
-        INTERFACE_COMPILE_OPTIONS "${LibRaw_DEFINITIONS}"
-        INTERFACE_INCLUDE_DIRECTORIES "${LibRaw_INCLUDE_DIR}"
-    )
-endif()

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)
@@ -20,26 +19,19 @@ endfunction()
 ##################################
 
 kimageformats_add_plugin(kimg_ani SOURCES ani.cpp)
-
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES ani.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES ani.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 if (TARGET avif)
     kimageformats_add_plugin(kimg_avif SOURCES "avif.cpp")
     target_link_libraries(kimg_avif "avif")
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES avif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    install(FILES avif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
@@ -47,18 +39,14 @@ if (BUILD_EPS_PLUGIN)
     if (TARGET Qt${QT_MAJOR_VERSION}::PrintSupport)
         kimageformats_add_plugin(kimg_eps SOURCES eps.cpp)
         target_link_libraries(kimg_eps Qt${QT_MAJOR_VERSION}::PrintSupport)
-        if (QT_MAJOR_VERSION STREQUAL "5")
-            install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-        endif()
+        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
-if (QT_MAJOR_VERSION STREQUAL "5")
-    # need this for Qt's version of the plugin
-    install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+# need this for Qt's version of the plugin
+install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
@@ -76,17 +64,13 @@ if(OpenEXR_FOUND)
     endif()
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
 
 kimageformats_add_plugin(kimg_hdr SOURCES hdr.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
@@ -94,10 +78,7 @@ if (LibHeif_FOUND)
     kimageformats_add_plugin(kimg_heif SOURCES heif.cpp)
     target_link_libraries(kimg_heif PkgConfig::LibHeif)
     kde_target_enable_exceptions(kimg_heif PRIVATE)
-
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
@@ -105,74 +86,43 @@ 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()
-
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES jxl.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    install(FILES jxl.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
 
 kimageformats_add_plugin(kimg_pcx SOURCES pcx.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 kimageformats_add_plugin(kimg_pic SOURCES pic.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 kimageformats_add_plugin(kimg_psd SOURCES psd.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 kimageformats_add_plugin(kimg_ras SOURCES ras.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 kimageformats_add_plugin(kimg_rgb SOURCES rgb.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 kimageformats_add_plugin(kimg_tga SOURCES tga.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
+install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 kimageformats_add_plugin(kimg_xcf SOURCES xcf.cpp)
-if (QT_MAJOR_VERSION STREQUAL "5")
-    install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-endif()
-
-##################################
-
-if (LibRaw_FOUND)
-    kimageformats_add_plugin(kimg_raw SOURCES raw.cpp)
-    kde_enable_exceptions()
-    target_link_libraries(kimg_raw LibRaw::LibRaw)
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES raw.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
-endif()
+install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
@@ -180,14 +130,10 @@ if (KF5Archive_FOUND)
 
     kimageformats_add_plugin(kimg_kra SOURCES kra.cpp)
     target_link_libraries(kimg_kra KF5::Archive)
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
     kimageformats_add_plugin(kimg_ora SOURCES ora.cpp)
     target_link_libraries(kimg_ora KF5::Archive)
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    install(FILES ora.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") {
@@ -521,9 +519,6 @@ bool ANIHandler::canRead(QIODevice *device)
         qWarning("ANIHandler::canRead() called with no device");
         return false;
     }
-    if (device->isSequential()) {
-        return false;
-    }
 
     const QByteArray riffIntro = device->peek(12);
 

src/imageformats/avif.cpp

@@ -12,8 +12,6 @@
 #include <QColorSpace>
 
 #include "avif_p.h"
-#include "util_p.h"
-
 #include <cfloat>
 
 QAVIFHandler::QAVIFHandler()
@@ -42,11 +40,6 @@ bool QAVIFHandler::canRead() const
 
     if (m_parseState != ParseAvifError) {
         setFormat("avif");
-
-        if (m_parseState == ParseAvifFinished) {
-            return false;
-        }
-
         return true;
     }
     return false;
@@ -63,7 +56,7 @@ bool QAVIFHandler::canRead(QIODevice *device)
     }
 
     avifROData input;
-    input.data = reinterpret_cast<const uint8_t *>(header.constData());
+    input.data = (const uint8_t *)header.constData();
     input.size = header.size();
 
     if (avifPeekCompatibleFileType(&input)) {
@@ -74,7 +67,7 @@ bool QAVIFHandler::canRead(QIODevice *device)
 
 bool QAVIFHandler::ensureParsed() const
 {
-    if (m_parseState == ParseAvifSuccess || m_parseState == ParseAvifMetadata || m_parseState == ParseAvifFinished) {
+    if (m_parseState == ParseAvifSuccess) {
         return true;
     }
     if (m_parseState == ParseAvifError) {
@@ -86,28 +79,6 @@ bool QAVIFHandler::ensureParsed() const
     return that->ensureDecoder();
 }
 
-bool QAVIFHandler::ensureOpened() const
-{
-    if (m_parseState == ParseAvifSuccess || m_parseState == ParseAvifFinished) {
-        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) {
@@ -116,7 +87,7 @@ bool QAVIFHandler::ensureDecoder()
 
     m_rawData = device()->readAll();
 
-    m_rawAvifData.data = reinterpret_cast<const uint8_t *>(m_rawData.constData());
+    m_rawAvifData.data = (const uint8_t *)m_rawData.constData();
     m_rawAvifData.size = m_rawData.size();
 
     if (avifPeekCompatibleFileType(&m_rawAvifData) == AVIF_FALSE) {
@@ -126,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
@@ -137,10 +105,6 @@ bool QAVIFHandler::ensureDecoder()
     m_decoder->strictFlags = AVIF_STRICT_DISABLED;
 #endif
 
-#if AVIF_VERSION >= 110000
-    m_decoder->imageDimensionLimit = 65535;
-#endif
-
     avifResult decodeResult;
 
     decodeResult = avifDecoderSetIOMemory(m_decoder, m_rawAvifData.data, m_rawAvifData.size);
@@ -163,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()
@@ -241,13 +186,13 @@ 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);
 
-    QImage result = imageAlloc(m_decoder->image->width, m_decoder->image->height, resultformat);
     if (result.isNull()) {
         qWarning("Memory cannot be allocated");
         return false;
@@ -255,7 +200,7 @@ bool QAVIFHandler::decode_one_frame()
 
     QColorSpace colorspace;
     if (m_decoder->image->icc.data && (m_decoder->image->icc.size > 0)) {
-        const QByteArray icc_data(reinterpret_cast<const char *>(m_decoder->image->icc.data), m_decoder->image->icc.size);
+        const QByteArray icc_data((const char *)m_decoder->image->icc.data, (int)m_decoder->image->icc.size);
         colorspace = QColorSpace::fromIccProfile(icc_data);
         if (!colorspace.isValid()) {
             qWarning("AVIF image has Qt-unsupported or invalid ICC profile!");
@@ -334,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) {
@@ -352,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;
+            }
         }
     }
 
@@ -444,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;
     }
 
@@ -463,13 +410,6 @@ bool QAVIFHandler::read(QImage *image)
     *image = m_current_image;
     if (imageCount() >= 2) {
         m_must_jump_to_next_image = true;
-        if (m_decoder->imageIndex >= m_decoder->imageCount - 1) {
-            // all frames in animation have been read
-            m_parseState = ParseAvifFinished;
-        }
-    } else {
-        // the static image has been read
-        m_parseState = ParseAvifFinished;
     }
     return true;
 }
@@ -477,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;
@@ -707,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
@@ -757,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;
 
@@ -767,7 +671,7 @@ bool QAVIFHandler::write(const QImage &image)
         avif->transferCharacteristics = transfer_to_save;
 
         if (iccprofile.size() > 0) {
-            avifImageSetProfileICC(avif, reinterpret_cast<const uint8_t *>(iccprofile.constData()), iccprofile.size());
+            avifImageSetProfileICC(avif, (const uint8_t *)iccprofile.constData(), iccprofile.size());
         }
 
         avifRGBImage rgb;
@@ -778,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;
             }
 
@@ -788,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;
             }
@@ -811,14 +718,14 @@ bool QAVIFHandler::write(const QImage &image)
         encoder->maxQuantizerAlpha = maxQuantizerAlpha;
     }
 
-    encoder->speed = 6;
+    encoder->speed = 7;
 
     res = avifEncoderWrite(encoder, avif, &raw);
     avifEncoderDestroy(encoder);
     avifImageDestroy(avif);
 
     if (res == AVIF_RESULT_OK) {
-        qint64 status = device()->write(reinterpret_cast<const char *>(raw.data), raw.size);
+        qint64 status = device()->write((const char *)raw.data, raw.size);
         avifRWDataFree(&raw);
 
         if (status > 0) {
@@ -846,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;
@@ -902,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;
 }
 
@@ -919,15 +818,12 @@ bool QAVIFHandler::jumpToNextImage()
         return false;
     }
 
-    if (m_decoder->imageIndex >= 0) {
-        if (m_decoder->imageCount < 2) {
-            m_parseState = ParseAvifSuccess;
-            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);
@@ -950,7 +846,6 @@ bool QAVIFHandler::jumpToNextImage()
     }
 
     if (decode_one_frame()) {
-        m_parseState = ParseAvifSuccess;
         return true;
     } else {
         m_parseState = ParseAvifError;
@@ -966,21 +861,17 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
 
     if (m_decoder->imageCount < 2) { // not an animation
         if (imageNumber == 0) {
-            if (ensureOpened()) {
-                m_parseState = ParseAvifSuccess;
-                return true;
-            }
+            return true;
+        } else {
+            return false;
         }
-        return false;
     }
 
     if (imageNumber < 0 || imageNumber >= m_decoder->imageCount) { // wrong index
         return false;
     }
 
-    if (imageNumber == m_decoder->imageIndex) { // we are here already
-        m_must_jump_to_next_image = false;
-        m_parseState = ParseAvifSuccess;
+    if (imageNumber == m_decoder->imageCount) { // we are here already
         return true;
     }
 
@@ -1004,7 +895,6 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
     }
 
     if (decode_one_frame()) {
-        m_parseState = ParseAvifSuccess;
         return true;
     } else {
         m_parseState = ParseAvifError;
@@ -1014,7 +904,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
 
 int QAVIFHandler::nextImageDelay() const
 {
-    if (!ensureOpened()) {
+    if (!ensureParsed()) {
         return 0;
     }
 
@@ -1039,8 +929,7 @@ int QAVIFHandler::loopCount() const
         return 0;
     }
 
-    // Endless loop to work around https://github.com/AOMediaCodec/libavif/issues/347
-    return -1;
+    return 1;
 }
 
 QPointF QAVIFHandler::CompatibleChromacity(qreal chrX, qreal chrY)
@@ -1057,26 +946,12 @@ QPointF QAVIFHandler::CompatibleChromacity(qreal chrX, qreal chrY)
 
 QImageIOPlugin::Capabilities QAVIFPlugin::capabilities(QIODevice *device, const QByteArray &format) const
 {
-    static const bool isAvifDecoderAvailable(avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_DECODE) != nullptr);
-    static const bool isAvifEncoderAvailable(avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_ENCODE) != nullptr);
-
     if (format == "avif") {
-        Capabilities format_cap;
-        if (isAvifDecoderAvailable) {
-            format_cap |= CanRead;
-        }
-        if (isAvifEncoderAvailable) {
-            format_cap |= CanWrite;
-        }
-        return format_cap;
+        return Capabilities(CanRead | CanWrite);
     }
 
     if (format == "avifs") {
-        Capabilities format_cap;
-        if (isAvifDecoderAvailable) {
-            format_cap |= CanRead;
-        }
-        return format_cap;
+        return Capabilities(CanRead);
     }
 
     if (!format.isEmpty()) {
@@ -1087,10 +962,10 @@ QImageIOPlugin::Capabilities QAVIFPlugin::capabilities(QIODevice *device, const
     }
 
     Capabilities cap;
-    if (device->isReadable() && QAVIFHandler::canRead(device) && isAvifDecoderAvailable) {
+    if (device->isReadable() && QAVIFHandler::canRead(device)) {
         cap |= CanRead;
     }
-    if (device->isWritable() && isAvifEncoderAvailable) {
+    if (device->isWritable()) {
         cap |= CanWrite;
     }
     return cap;

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,8 +52,6 @@ private:
         ParseAvifError = -1,
         ParseAvifNotParsed = 0,
         ParseAvifSuccess = 1,
-        ParseAvifMetadata = 2,
-        ParseAvifFinished = 3,
     };
 
     ParseAvifState m_parseState;
@@ -63,7 +59,6 @@ private:
 
     uint32_t m_container_width;
     uint32_t m_container_height;
-    QSize m_estimated_dimensions;
 
     QByteArray m_rawData;
     avifROData m_rawAvifData;