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.105.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,27 +64,21 @@ 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/)
 
 ##################################
 
 if (LibHeif_FOUND)
     kimageformats_add_plugin(kimg_heif SOURCES heif.cpp)
     target_link_libraries(kimg_heif PkgConfig::LibHeif)
-
-    if (QT_MAJOR_VERSION STREQUAL "5")
-        install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
-    endif()
+    kde_target_enable_exceptions(kimg_heif PRIVATE)
+    install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
@@ -104,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/)
 
 ##################################
 
@@ -179,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()