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.107.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,96 +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) || !fi.suffix().compare("tif", Qt::CaseInsensitive)) {
-                continue;
-            }
-            int suffixPos = fi.filePath().count() - suffix.count();
-            QString inputfile = fi.filePath();
-            QString fmt = QStringLiteral("png");
-            QString expfile = fi.filePath().replace(suffixPos, suffix.count(), fmt);
-            if (!QFile::exists(expfile)) { // try with tiff
-                fmt = QStringLiteral("tif");
-                expfile = fi.filePath().replace(suffixPos, suffix.count(), fmt);
-            }
-            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, fmt.toLatin1());
-
-            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";