GIT_SILENT Upgrade ECM and KF version requirements for 5.99.0 release.

We need QIODevice::pos() to work in QDataStream &operator>>.

BUG: 459541

.git-blame-ignore-revs

@@ -1,2 +1,3 @@
-#clang-format
+#clang-format/tidy
 1169859b07f25c865ee0bfc2a7dc97a431651776
+eaca33bec8b19498c3621fc3a20a8c55a2812462

.gitattributes

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

.gitlab-ci.yml

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org>
+# SPDX-License-Identifier: CC0-1.0
+
+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

@@ -0,0 +1,9 @@
+Dependencies:
+- 'on': ['Linux', 'FreeBSD', 'macOS', 'Windows']
+  'require':
+    'frameworks/extra-cmake-modules': '@same'
+    'frameworks/karchive' : '@same'
+
+Options:
+  test-before-installing: True
+  require-passing-tests-on: [ 'Linux', 'FreeBSD', 'Windows' ]

CMakeLists.txt

@@ -3,23 +3,24 @@ cmake_minimum_required(VERSION 3.16)
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.85.0  NO_MODULE)
+find_package(ECM 5.99.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 ${ECM_MODULE_PATH})
+set(CMAKE_MODULE_PATH ${KImageFormats_SOURCE_DIR}/cmake/find-modules ${ECM_MODULE_PATH})
 
 include(KDEInstallDirs)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
+
 include(KDEGitCommitHooks)
-
-
+include(ECMDeprecationSettings)
 include(CheckIncludeFiles)
+include(FindPkgConfig)
 
-set(REQUIRED_QT_VERSION 5.15.0)
-find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
+set(REQUIRED_QT_VERSION 5.15.2)
+find_package(Qt${QT_MAJOR_VERSION}Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
 find_package(KF5Archive)
 set_package_properties(KF5Archive PROPERTIES
@@ -31,12 +32,12 @@ set_package_properties(KF5Archive PROPERTIES
 # this available in PATH
 set(BUILD_EPS_PLUGIN FALSE)
 if (UNIX)
-    find_package(Qt5PrintSupport ${REQUIRED_QT_VERSION} NO_MODULE)
-    set_package_properties(Qt5PrintSupport PROPERTIES
+    find_package(Qt${QT_MAJOR_VERSION}PrintSupport ${REQUIRED_QT_VERSION} NO_MODULE)
+    set_package_properties(Qt${QT_MAJOR_VERSION}PrintSupport PROPERTIES
         PURPOSE "Required for the QImage plugin for EPS images"
         TYPE OPTIONAL
     )
-    if (Qt5PrintSupport_FOUND)
+    if (TARGET Qt${QT_MAJOR_VERSION}::PrintSupport)
         set(BUILD_EPS_PLUGIN TRUE)
     endif()
 endif()
@@ -58,15 +59,29 @@ set_package_properties(libavif PROPERTIES
 
 option(KIMAGEFORMATS_HEIF "Enable plugin for HEIF format" OFF)
 if(KIMAGEFORMATS_HEIF)
-    include(FindPkgConfig)
     pkg_check_modules(LibHeif IMPORTED_TARGET libheif>=1.10.0)
 endif()
 add_feature_info(LibHeif LibHeif_FOUND "required for the QImage plugin for HEIF/HEIC images")
 
-# 050d00 (5.13) triggers a BIC in qimageiohandler.h, in Qt 5.13, so do not enable that until we can require 5.14
-# https://codereview.qt-project.org/c/qt/qtbase/+/279215
-add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f00)
-add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055100)
+option(KIMAGEFORMATS_JXL "Enable plugin for JPEG XL format" ON)
+if(KIMAGEFORMATS_JXL)
+    pkg_check_modules(LibJXL IMPORTED_TARGET libjxl>=0.6.1)
+    pkg_check_modules(LibJXLThreads IMPORTED_TARGET libjxl_threads>=0.6.1)
+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_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)

LICENSES/CC0-1.0.txt

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

README.md

@@ -16,13 +16,15 @@ The following image formats have read-only support:
 - Animated Windows cursors (ani)
 - Gimp (xcf)
 - OpenEXR (exr)
-- Photoshop documents (psd)
+- Photoshop documents (psd, psb, pdd, psdt)
 - Sun Raster (ras)
+- Camera RAW images (arw, cr2, cr3, dcs, dng, ...)
 
 The following image formats have read and write support:
 
 - AV1 Image File Format (AVIF)
 - Encapsulated PostScript (eps)
+- JPEG XL (jxl)
 - Personal Computer Exchange (pcx)
 - SGI images (rgb, rgba, sgi, bw)
 - Softimage PIC (pic)

autotests/CMakeLists.txt

@@ -15,7 +15,7 @@ macro(kimageformats_read_tests)
 
     if (NOT TARGET readtest)
         add_executable(readtest readtest.cpp)
-        target_link_libraries(readtest Qt5::Gui)
+        target_link_libraries(readtest Qt${QT_MAJOR_VERSION}::Gui)
         target_compile_definitions(readtest
             PRIVATE IMAGEDIR="${CMAKE_CURRENT_SOURCE_DIR}/read")
         ecm_mark_as_test(readtest)
@@ -30,23 +30,35 @@ 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 Qt5::Gui)
+        target_link_libraries(writetest Qt${QT_MAJOR_VERSION}::Gui)
         target_compile_definitions(writetest
             PRIVATE IMAGEDIR="${CMAKE_CURRENT_SOURCE_DIR}/write")
         ecm_mark_as_test(writetest)
     endif()
-    foreach(_testname ${ARGN})
+    foreach(_testname ${KIF_RT_UNPARSED_ARGUMENTS})
         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} ${_testname}
+            COMMAND writetest ${lossless_arg} ${no_data_check_arg} ${_fuzzarg} ${_testname}
         )
     endforeach(_testname)
 endmacro()
@@ -74,12 +86,28 @@ 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
@@ -111,19 +139,25 @@ if (OpenEXR_FOUND)
     # FIXME: OpenEXR tests
 endif()
 
-find_package(Qt5Test ${REQUIRED_QT_VERSION} CONFIG QUIET)
+if (LibRaw_FOUND)
+    kimageformats_read_tests(
+        raw
+    )
+endif()
 
-if(NOT Qt5Test_FOUND)
-    message(STATUS "Qt5Test not found, some autotests will not be built.")
+find_package(Qt${QT_MAJOR_VERSION}Test ${REQUIRED_QT_VERSION} CONFIG QUIET)
+
+if(NOT TARGET Qt${QT_MAJOR_VERSION}::Test)
+    message(STATUS "Qt${QT_MAJOR_VERSION}Test not found, some autotests will not be built.")
     return()
 endif()
 
 add_executable(pictest pictest.cpp)
-target_link_libraries(pictest Qt5::Gui Qt5::Test)
+target_link_libraries(pictest Qt${QT_MAJOR_VERSION}::Gui Qt${QT_MAJOR_VERSION}::Test)
 ecm_mark_as_test(pictest)
 add_test(NAME kimageformats-pic COMMAND pictest)
 
 add_executable(anitest anitest.cpp)
-target_link_libraries(anitest Qt5::Gui Qt5::Test)
+target_link_libraries(anitest Qt${QT_MAJOR_VERSION}::Gui Qt${QT_MAJOR_VERSION}::Test)
 ecm_mark_as_test(anitest)
 add_test(NAME kimageformats-ani COMMAND anitest)

autotests/fuzzyeq.cpp

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

autotests/readtest.cpp

@@ -16,6 +16,8 @@
 
 #include "../tests/format-enum.h"
 
+#include "fuzzyeq.cpp"
+
 static void writeImageData(const char *name, const QString &filename, const QImage &image)
 {
     QFile file(filename);
@@ -31,36 +33,6 @@ 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.
@@ -122,7 +94,6 @@ 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;
@@ -141,6 +112,9 @@ int main(int argc, char **argv)
 
     const QFileInfoList lstImgDir = imgdir.entryInfoList();
     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"));

autotests/writetest.cpp

@@ -16,6 +16,8 @@
 #include <QImageWriter>
 #include <QTextStream>
 
+#include "fuzzyeq.cpp"
+
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
@@ -31,7 +33,13 @@ 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);
 
@@ -44,11 +52,26 @@ 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));
-    imgdir.setNameFilters(QStringList(QLatin1String("*.") + suffix));
+    if (parser.isSet(ignoreDataCheck)) {
+        imgdir.setNameFilters({QLatin1String("*.png")});
+    } else {
+        imgdir.setNameFilters(QStringList(QLatin1String("*.") + suffix));
+    }
     imgdir.setFilter(QDir::Files);
 
     int passed = 0;
@@ -58,8 +81,13 @@ int main(int argc, char **argv)
                         << "Starting basic write tests for " << suffix << " images *********\n";
     const QFileInfoList lstImgDir = imgdir.entryInfoList();
     for (const QFileInfo &fi : lstImgDir) {
-        int suffixPos = fi.filePath().count() - suffix.count();
-        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
+        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"));
+        }
         QString pngfilename = QFileInfo(pngfile).fileName();
 
         QImageReader pngReader(pngfile, "png");
@@ -70,29 +98,13 @@ 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;
@@ -100,10 +112,31 @@ int main(int argc, char **argv)
             }
         }
 
-        if (expData != writtenData) {
-            QTextStream(stdout) << "FAIL : " << fi.fileName() << ": written data differs from " << fi.fileName() << "\n";
-            ++failed;
-            continue;
+        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;
+            }
         }
 
         QImage reReadImage;
@@ -119,8 +152,18 @@ int main(int argc, char **argv)
         }
 
         if (parser.isSet(lossless)) {
-            if (pngImage != reReadImage) {
+            if (!fuzzyeq(pngImage, reReadImage, fuzziness)) {
                 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

@@ -0,0 +1,87 @@
+# - 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.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.h
+          HINTS
+          ${PC_LIBRAW_INCLUDEDIR}
+          ${PC_LibRaw_INCLUDE_DIRS}
+          PATH_SUFFIXES libraw
+         )
+
+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_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_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()

metainfo.yaml

@@ -5,7 +5,7 @@ type: functional
 platforms:
     - name: Linux
     - name: FreeBSD
-    - name: MacOSX
+    - name: macOS
     - name: Windows
       note: No EPS support on Windows
     - name: Android

src/imageformats/CMakeLists.txt

@@ -4,60 +4,55 @@
 
 function(kimageformats_add_plugin plugin)
     set(options)
-    set(oneValueArgs JSON)
+    set(oneValueArgs)
     set(multiValueArgs SOURCES)
     cmake_parse_arguments(KIF_ADD_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
     if(NOT KIF_ADD_PLUGIN_SOURCES)
         message(FATAL_ERROR "kimageformats_add_plugin called without SOURCES parameter")
     endif()
-    get_filename_component(json "${KIF_ADD_PLUGIN_JSON}" REALPATH)
-    if(NOT KIF_ADD_PLUGIN_JSON OR NOT EXISTS ${json})
-        message(FATAL_ERROR "JSON file doesn't exist: ${json}")
-    endif()
 
     add_library(${plugin} MODULE ${KIF_ADD_PLUGIN_SOURCES})
-    set_property(TARGET ${plugin} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS ${json})
     set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/imageformats")
-    target_link_libraries(${plugin} Qt5::Gui)
+    target_link_libraries(${plugin} Qt${QT_MAJOR_VERSION}::Gui)
     install(TARGETS ${plugin} DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats)
 endfunction()
 
 ##################################
 
-kimageformats_add_plugin(kimg_ani JSON "ani.json" SOURCES ani.cpp)
-install(FILES ani.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_ani SOURCES ani.cpp)
+install(FILES ani.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 if (TARGET avif)
-    kimageformats_add_plugin(kimg_avif JSON "avif.json" SOURCES "avif.cpp")
+    kimageformats_add_plugin(kimg_avif SOURCES "avif.cpp")
     target_link_libraries(kimg_avif "avif")
-    install(FILES avif.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+    install(FILES avif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 if (BUILD_EPS_PLUGIN)
-    if (Qt5PrintSupport_FOUND)
-        kimageformats_add_plugin(kimg_eps JSON "eps.json" SOURCES eps.cpp)
-        target_link_libraries(kimg_eps Qt5::PrintSupport)
-        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+    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)
+        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
 # need this for Qt's version of the plugin
-install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 if(OpenEXR_FOUND)
-    kimageformats_add_plugin(kimg_exr JSON "exr.json" SOURCES exr.cpp)
+    kimageformats_add_plugin(kimg_exr SOURCES exr.cpp)
     if(TARGET OpenEXR::OpenEXR)
         target_link_libraries(kimg_exr OpenEXR::OpenEXR)
     else()
@@ -70,68 +65,88 @@ if(OpenEXR_FOUND)
     endif()
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-kimageformats_add_plugin(kimg_hdr JSON "hdr.json" SOURCES hdr.cpp)
-install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_hdr SOURCES hdr.cpp)
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
 if (LibHeif_FOUND)
-    kimageformats_add_plugin(kimg_heif JSON "heif.json" SOURCES heif.cpp)
+    kimageformats_add_plugin(kimg_heif SOURCES heif.cpp)
     target_link_libraries(kimg_heif PkgConfig::LibHeif)
     kde_target_enable_exceptions(kimg_heif PRIVATE)
-    install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+    install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
-install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+if (LibJXL_FOUND AND LibJXLThreads_FOUND)
+    kimageformats_add_plugin(kimg_jxl SOURCES jxl.cpp)
+    target_link_libraries(kimg_jxl PkgConfig::LibJXL PkgConfig::LibJXLThreads)
+    if (LibJXL_VERSION VERSION_GREATER_EQUAL "0.7.0")
+        target_compile_definitions(kimg_jxl PRIVATE KIMG_JXL_API_VERSION=70)
+    endif()
+    install(FILES jxl.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
+endif()
 
 ##################################
 
-kimageformats_add_plugin(kimg_pic JSON "pic.json" SOURCES pic.cpp)
-install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_pcx SOURCES pcx.cpp)
+install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
-kimageformats_add_plugin(kimg_psd JSON "psd.json" SOURCES psd.cpp)
-install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_pic SOURCES pic.cpp)
+install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
-kimageformats_add_plugin(kimg_ras JSON "ras.json" SOURCES ras.cpp)
-install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_psd SOURCES psd.cpp)
+install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
-kimageformats_add_plugin(kimg_rgb JSON "rgb.json" SOURCES rgb.cpp)
-install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_ras SOURCES ras.cpp)
+install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
-kimageformats_add_plugin(kimg_tga JSON "tga.json" SOURCES tga.cpp)
-install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_rgb SOURCES rgb.cpp)
+install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 ##################################
 
-kimageformats_add_plugin(kimg_xcf JSON "xcf.json" SOURCES xcf.cpp)
-install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+kimageformats_add_plugin(kimg_tga SOURCES tga.cpp)
+install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
+
+##################################
+
+kimageformats_add_plugin(kimg_xcf SOURCES xcf.cpp)
+install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
+
+##################################
+
+if (LibRaw_FOUND)
+    kimageformats_add_plugin(kimg_raw SOURCES raw.cpp)
+    kde_enable_exceptions()
+    target_link_libraries(kimg_raw LibRaw::LibRaw)
+    install(FILES raw.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
+endif()
 
 ##################################
 
 if (KF5Archive_FOUND)
 
-    kimageformats_add_plugin(kimg_kra JSON "kra.json" SOURCES kra.cpp)
+    kimageformats_add_plugin(kimg_kra SOURCES kra.cpp)
     target_link_libraries(kimg_kra KF5::Archive)
-    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
-    kimageformats_add_plugin(kimg_ora JSON "ora.json" SOURCES ora.cpp)
+    kimageformats_add_plugin(kimg_ora SOURCES ora.cpp)
     target_link_libraries(kimg_ora KF5::Archive)
-    install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+    install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
 
 endif()

src/imageformats/ani.cpp

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

src/imageformats/avif.cpp

@@ -12,6 +12,8 @@
 #include <QColorSpace>
 
 #include "avif_p.h"
+#include "util_p.h"
+
 #include <cfloat>
 
 QAVIFHandler::QAVIFHandler()
@@ -67,7 +69,7 @@ bool QAVIFHandler::canRead(QIODevice *device)
 
 bool QAVIFHandler::ensureParsed() const
 {
-    if (m_parseState == ParseAvifSuccess) {
+    if (m_parseState == ParseAvifSuccess || m_parseState == ParseAvifMetadata) {
         return true;
     }
     if (m_parseState == ParseAvifError) {
@@ -79,6 +81,28 @@ bool QAVIFHandler::ensureParsed() const
     return that->ensureDecoder();
 }
 
+bool QAVIFHandler::ensureOpened() const
+{
+    if (m_parseState == ParseAvifSuccess) {
+        return true;
+    }
+    if (m_parseState == ParseAvifError) {
+        return false;
+    }
+
+    QAVIFHandler *that = const_cast<QAVIFHandler *>(this);
+    if (ensureParsed()) {
+        if (m_parseState == ParseAvifMetadata) {
+            bool success = that->jumpToNextImage();
+            that->m_parseState = success ? ParseAvifSuccess : ParseAvifError;
+            return success;
+        }
+    }
+
+    that->m_parseState = ParseAvifError;
+    return false;
+}
+
 bool QAVIFHandler::ensureDecoder()
 {
     if (m_decoder) {
@@ -97,6 +121,13 @@ 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
+
 #if AVIF_VERSION >= 90100
     m_decoder->strictFlags = AVIF_STRICT_DISABLED;
 #endif
@@ -123,39 +154,58 @@ bool QAVIFHandler::ensureDecoder()
         return false;
     }
 
-    decodeResult = avifDecoderNextImage(m_decoder);
+    m_container_width = m_decoder->image->width;
+    m_container_height = m_decoder->image->height;
 
-    if (decodeResult == AVIF_RESULT_OK) {
-        m_container_width = m_decoder->image->width;
-        m_container_height = m_decoder->image->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_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));
+    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;
     }
 
-    avifDecoderDestroy(m_decoder);
-    m_decoder = nullptr;
-    m_parseState = ParseAvifError;
-    return false;
+    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_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;
+        }
+    }
+
+    m_estimated_dimensions.setWidth(new_width);
+    m_estimated_dimensions.setHeight(new_height);
+
+    m_parseState = ParseAvifMetadata;
+    return true;
 }
 
 bool QAVIFHandler::decode_one_frame()
@@ -182,13 +232,13 @@ bool QAVIFHandler::decode_one_frame()
         }
     } else {
         if (loadalpha) {
-            resultformat = QImage::Format_RGBA8888;
+            resultformat = QImage::Format_ARGB32;
         } else {
-            resultformat = QImage::Format_RGB888;
+            resultformat = QImage::Format_RGB32;
         }
     }
-    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;
@@ -275,33 +325,38 @@ bool QAVIFHandler::decode_one_frame()
         rgb.depth = 16;
         rgb.format = AVIF_RGB_FORMAT_RGBA;
 
-        if (!loadalpha) {
-            rgb.ignoreAlpha = AVIF_TRUE;
-            result.fill(Qt::black);
-            if (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-                resultformat = QImage::Format_Grayscale16;
-            }
+        if (!loadalpha && (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)) {
+            resultformat = QImage::Format_Grayscale16;
         }
     } else {
         rgb.depth = 8;
-        if (loadalpha) {
-            rgb.format = AVIF_RGB_FORMAT_RGBA;
-            resultformat = QImage::Format_ARGB32;
-        } else {
-            rgb.format = AVIF_RGB_FORMAT_RGB;
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+        rgb.format = AVIF_RGB_FORMAT_BGRA;
+#else
+        rgb.format = AVIF_RGB_FORMAT_ARGB;
+#endif
 
-            if (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
-                resultformat = QImage::Format_Grayscale8;
-            } else {
-                resultformat = QImage::Format_RGB32;
-            }
+#if (AVIF_VERSION >= 80400) && (AVIF_VERSION <= 100100)
+        if (m_decoder->imageCount > 1) {
+            /* accelerate animated AVIF */
+            rgb.chromaUpsampling = AVIF_CHROMA_UPSAMPLING_FASTEST;
+        }
+#endif
+
+        if (!loadalpha && (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)) {
+            resultformat = QImage::Format_Grayscale8;
         }
     }
 
     rgb.rowBytes = result.bytesPerLine();
     rgb.pixels = result.bits();
 
+#if AVIF_VERSION >= 100101
+    // use faster decoding for animations
+    avifResult res = avifImageYUVToRGB(m_decoder->image, &rgb, (m_decoder->imageCount > 1) ? AVIF_CHROMA_UPSAMPLING_NEAREST : AVIF_YUV_TO_RGB_DEFAULT);
+#else
     avifResult res = avifImageYUVToRGB(m_decoder->image, &rgb);
+#endif
     if (res != AVIF_RESULT_OK) {
         qWarning("ERROR in avifImageYUVToRGB: %s", avifResultToString(res));
         return false;
@@ -310,27 +365,27 @@ bool QAVIFHandler::decode_one_frame()
     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 new_width, new_height, offx, offy;
-
-            new_width = (int)((double)(m_decoder->image->clap.widthN) / (m_decoder->image->clap.widthD) + 0.5);
+            int new_width = (int)((double)(m_decoder->image->clap.widthN) / (m_decoder->image->clap.widthD) + 0.5);
             if (new_width > result.width()) {
                 new_width = result.width();
             }
 
-            new_height = (int)((double)(m_decoder->image->clap.heightN) / (m_decoder->image->clap.heightD) + 0.5);
+            int new_height = (int)((double)(m_decoder->image->clap.heightN) / (m_decoder->image->clap.heightD) + 0.5);
             if (new_height > result.height()) {
                 new_height = result.height();
             }
 
             if (new_width > 0 && new_height > 0) {
-                offx = ((double)((int32_t)m_decoder->image->clap.horizOffN)) / (m_decoder->image->clap.horizOffD) + (result.width() - new_width) / 2.0 + 0.5;
+                int offx =
+                    ((double)((int32_t)m_decoder->image->clap.horizOffN)) / (m_decoder->image->clap.horizOffD) + (result.width() - new_width) / 2.0 + 0.5;
                 if (offx < 0) {
                     offx = 0;
                 } else if (offx > (result.width() - new_width)) {
                     offx = result.width() - new_width;
                 }
 
-                offy = ((double)((int32_t)m_decoder->image->clap.vertOffN)) / (m_decoder->image->clap.vertOffD) + (result.height() - new_height) / 2.0 + 0.5;
+                int offy =
+                    ((double)((int32_t)m_decoder->image->clap.vertOffN)) / (m_decoder->image->clap.vertOffD) + (result.height() - new_height) / 2.0 + 0.5;
                 if (offy < 0) {
                     offy = 0;
                 } else if (offy > (result.height() - new_height)) {
@@ -385,13 +440,15 @@ 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 (!ensureParsed()) {
+    if (!ensureOpened()) {
         return false;
     }
 
@@ -409,15 +466,44 @@ 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() > 32768) || (image.height() > 32768)) {
-        qWarning("Image is too large");
+    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!");
         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;
@@ -610,43 +696,47 @@ bool QAVIFHandler::write(const QImage &image)
 
             // in case primaries or trc were not identified
             if ((primaries_to_save == 2) || (transfer_to_save == 2)) {
-                // 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 (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);
+                        }
                     }
-                }
 
-                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));
+                        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;
-                        break;
+                        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 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
@@ -656,6 +746,9 @@ 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;
 
@@ -674,9 +767,7 @@ bool QAVIFHandler::write(const QImage &image)
         if (save_depth > 8) { // 10bit depth
             rgb.depth = 16;
 
-            if (tmpcolorimage.hasAlphaChannel()) {
-                avif->alphaRange = AVIF_RANGE_FULL;
-            } else {
+            if (!tmpcolorimage.hasAlphaChannel()) {
                 rgb.ignoreAlpha = AVIF_TRUE;
             }
 
@@ -686,13 +777,16 @@ 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;
             }
         }
 
+#if AVIF_VERSION >= 100101
+        res = avifImageRGBToYUV(avif, &rgb, AVIF_RGB_TO_YUV_DEFAULT);
+#else
         res = avifImageRGBToYUV(avif, &rgb);
+#endif
         if (res != AVIF_RESULT_OK) {
             qWarning("ERROR in avifImageRGBToYUV: %s", avifResultToString(res));
             return false;
@@ -710,14 +804,14 @@ bool QAVIFHandler::write(const QImage &image)
         encoder->maxQuantizerAlpha = maxQuantizerAlpha;
     }
 
-    encoder->speed = 8;
+    encoder->speed = 6;
 
     res = avifEncoderWrite(encoder, avif, &raw);
     avifEncoderDestroy(encoder);
     avifImageDestroy(avif);
 
     if (res == AVIF_RESULT_OK) {
-        qint64 status = device()->write((const char *)raw.data, raw.size);
+        qint64 status = device()->write(reinterpret_cast<const char *>(raw.data), raw.size);
         avifRWDataFree(&raw);
 
         if (status > 0) {
@@ -745,7 +839,7 @@ QVariant QAVIFHandler::option(ImageOption option) const
 
     switch (option) {
     case Size:
-        return m_current_image.size();
+        return m_estimated_dimensions;
     case Animation:
         if (imageCount() >= 2) {
             return true;
@@ -801,6 +895,14 @@ int QAVIFHandler::currentImageNumber() const
         return 0;
     }
 
+    if (m_parseState == ParseAvifMetadata) {
+        if (m_decoder->imageCount >= 2) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+
     return m_decoder->imageIndex;
 }
 
@@ -810,12 +912,14 @@ bool QAVIFHandler::jumpToNextImage()
         return false;
     }
 
-    if (m_decoder->imageCount < 2) {
-        return true;
-    }
+    if (m_decoder->imageIndex >= 0) {
+        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);
@@ -838,6 +942,7 @@ bool QAVIFHandler::jumpToNextImage()
     }
 
     if (decode_one_frame()) {
+        m_parseState = ParseAvifSuccess;
         return true;
     } else {
         m_parseState = ParseAvifError;
@@ -853,7 +958,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
 
     if (m_decoder->imageCount < 2) { // not an animation
         if (imageNumber == 0) {
-            return true;
+            return ensureOpened();
         } else {
             return false;
         }
@@ -863,7 +968,8 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
         return false;
     }
 
-    if (imageNumber == m_decoder->imageCount) { // we are here already
+    if (imageNumber == m_decoder->imageIndex) { // we are here already
+        m_must_jump_to_next_image = false;
         return true;
     }
 
@@ -887,6 +993,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
     }
 
     if (decode_one_frame()) {
+        m_parseState = ParseAvifSuccess;
         return true;
     } else {
         m_parseState = ParseAvifError;
@@ -896,7 +1003,7 @@ bool QAVIFHandler::jumpToImage(int imageNumber)
 
 int QAVIFHandler::nextImageDelay() const
 {
-    if (!ensureParsed()) {
+    if (!ensureOpened()) {
         return 0;
     }
 

src/imageformats/avif.json

@@ -1,4 +1,4 @@
 {
     "Keys": [ "avif", "avifs" ],
-    "MimeTypes": [ "image/avif", "image/avif-sequence" ]
+    "MimeTypes": [ "image/avif", "image/avif" ]
 }

src/imageformats/avif_p.h

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

src/imageformats/eps.cpp

@@ -15,6 +15,7 @@
 #include <QPainter>
 #include <QPrinter>
 #include <QProcess>
+#include <QStandardPaths>
 #include <QTemporaryFile>
 
 // logging category for this framework, default: log stuff >= warning
@@ -94,7 +95,10 @@ static bool bbox(QIODevice *io, int *x1, int *y1, int *x2, int *y2)
         if (strncmp(buf, BBOX, BBOX_LEN) == 0) {
             // Some EPS files have non-integer values for the bbox
             // We don't support that currently, but at least we parse it
-            float _x1, _y1, _x2, _y2;
+            float _x1;
+            float _y1;
+            float _x2;
+            float _y2;
             if (sscanf(buf, "%*s %f %f %f %f", &_x1, &_y1, &_x2, &_y2) == 4) {
                 qCDebug(EPSPLUGIN) << "BBOX: " << _x1 << " " << _y1 << " " << _x2 << " " << _y2;
                 *x1 = int(_x1);
@@ -127,14 +131,18 @@ bool EPSHandler::read(QImage *image)
 {
     qCDebug(EPSPLUGIN) << "starting...";
 
-    int x1, y1, x2, y2;
+    int x1;
+    int y1;
+    int x2;
+    int y2;
 #ifdef EPS_PERFORMANCE_DEBUG
     QTime dt;
     dt.start();
 #endif
 
     QIODevice *io = device();
-    qint64 ps_offset, ps_size;
+    qint64 ps_offset;
+    qint64 ps_size;
 
     // find start of PostScript code
     if (!seekToCodeStart(io, ps_offset, ps_size)) {
@@ -169,6 +177,12 @@ bool EPSHandler::read(QImage *image)
 
     // create GS command line
 
+    const QString gsExec = QStandardPaths::findExecutable(QStringLiteral("gs"));
+    if (gsExec.isEmpty()) {
+        qCWarning(EPSPLUGIN) << "Couldn't find gs exectuable (from GhostScript) in PATH.";
+        return false;
+    }
+
     QStringList gsArgs;
     gsArgs << QLatin1String("-sOutputFile=") + tmpFile.fileName() << QStringLiteral("-q") << QStringLiteral("-g%1x%2").arg(wantedWidth).arg(wantedHeight)
            << QStringLiteral("-dSAFER") << QStringLiteral("-dPARANOIDSAFER") << QStringLiteral("-dNOPAUSE") << QStringLiteral("-sDEVICE=ppm")
@@ -185,7 +199,7 @@ bool EPSHandler::read(QImage *image)
 
     QProcess converter;
     converter.setProcessChannelMode(QProcess::ForwardedErrorChannel);
-    converter.start(QStringLiteral("gs"), gsArgs);
+    converter.start(gsExec, gsArgs);
     if (!converter.waitForStarted(3000)) {
         qCWarning(EPSPLUGIN) << "Reading EPS files requires gs (from GhostScript)";
         return false;

src/imageformats/exr.cpp

@@ -8,6 +8,7 @@
 */
 
 #include "exr_p.h"
+#include "util_p.h"
 
 #include <IexThrowErrnoExc.h>
 #include <ImathBox.h>
@@ -99,7 +100,10 @@ void K_IStream::clear()
  */
 QRgb RgbaToQrgba(struct Imf::Rgba &imagePixel)
 {
-    float r, g, b, a;
+    float r;
+    float g;
+    float b;
+    float a;
 
     //  1) Compensate for fogging by subtracting defog
     //     from the raw pixel values.
@@ -132,24 +136,24 @@ QRgb RgbaToQrgba(struct Imf::Rgba &imagePixel)
     //     maximum intensity).
     // Response: kneeLow = 0.0 (2^0.0 => 1); kneeHigh = 5.0 (2^5 =>32)
     if (r > 1.0) {
-        r = 1.0 + Imath::Math<float>::log((r - 1.0) * 0.184874 + 1) / 0.184874;
+        r = 1.0 + std::log((r - 1.0) * 0.184874 + 1) / 0.184874;
     }
     if (g > 1.0) {
-        g = 1.0 + Imath::Math<float>::log((g - 1.0) * 0.184874 + 1) / 0.184874;
+        g = 1.0 + std::log((g - 1.0) * 0.184874 + 1) / 0.184874;
     }
     if (b > 1.0) {
-        b = 1.0 + Imath::Math<float>::log((b - 1.0) * 0.184874 + 1) / 0.184874;
+        b = 1.0 + std::log((b - 1.0) * 0.184874 + 1) / 0.184874;
     }
     if (a > 1.0) {
-        a = 1.0 + Imath::Math<float>::log((a - 1.0) * 0.184874 + 1) / 0.184874;
+        a = 1.0 + std::log((a - 1.0) * 0.184874 + 1) / 0.184874;
     }
     //
     //  5) Gamma-correct the pixel values, assuming that the
     //     screen's gamma is 0.4545 (or 1/2.2).
-    r = Imath::Math<float>::pow(r, 0.4545);
-    g = Imath::Math<float>::pow(g, 0.4545);
-    b = Imath::Math<float>::pow(b, 0.4545);
-    a = Imath::Math<float>::pow(a, 0.4545);
+    r = std::pow(r, 0.4545);
+    g = std::pow(g, 0.4545);
+    b = std::pow(b, 0.4545);
+    a = std::pow(a, 0.4545);
 
     //  6) Scale the values such that pixels middle gray
     //     pixels are mapped to 84.66 (or 3.5 f-stops below
@@ -178,7 +182,8 @@ bool EXRHandler::canRead() const
 bool EXRHandler::read(QImage *outImage)
 {
     try {
-        int width, height;
+        int width;
+        int height;
 
         K_IStream istr(device(), QByteArray());
         Imf::RgbaInputFile file(istr);
@@ -187,7 +192,7 @@ bool EXRHandler::read(QImage *outImage)
         width = dw.max.x - dw.min.x + 1;
         height = dw.max.y - dw.min.y + 1;
 
-        QImage image(width, height, QImage::Format_RGB32);
+        QImage image = imageAlloc(width, height, QImage::Format_RGB32);
         if (image.isNull()) {
             qWarning() << "Failed to allocate image, invalid size?" << QSize(width, height);
             return false;

src/imageformats/hdr.cpp

@@ -7,6 +7,7 @@
 */
 
 #include "hdr_p.h"
+#include "util_p.h"
 
 #include <QDataStream>
 #include <QImage>
@@ -89,10 +90,11 @@ static void RGBE_To_QRgbLine(uchar *image, QRgb *scanline, int width)
 // Load the HDR image.
 static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &img)
 {
-    uchar val, code;
+    uchar val;
+    uchar code;
 
     // Create dst image.
-    img = QImage(width, height, QImage::Format_RGB32);
+    img = imageAlloc(width, height, QImage::Format_RGB32);
     if (img.isNull()) {
         qCDebug(HDRPLUGIN) << "Couldn't create image with size" << width << height << "and format RGB32";
         return false;

src/imageformats/heif.cpp

@@ -9,6 +9,7 @@
 
 #include "heif_p.h"
 #include "libheif/heif_cxx.h"
+#include "util_p.h"
 
 #include <QColorSpace>
 #include <QDebug>
@@ -432,7 +433,7 @@ bool HEIFHandler::ensureDecoder()
             return false;
         }
 
-        m_current_image = QImage(imageSize, target_image_format);
+        m_current_image = imageAlloc(imageSize, target_image_format);
         if (m_current_image.isNull()) {
             m_parseState = ParseHeicError;
             qWarning() << "Unable to allocate memory!";

src/imageformats/jxl.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Service
+X-KDE-ServiceTypes=QImageIOPlugins
+X-KDE-ImageFormat=jxl
+X-KDE-MimeType=image/jxl
+X-KDE-Read=true
+X-KDE-Write=true

src/imageformats/jxl.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "jxl" ],
+    "MimeTypes": [ "image/jxl" ]
+}

src/imageformats/jxl_p.h

@@ -0,0 +1,96 @@
+/*
+    JPEG XL (JXL) support for QImage.
+
+    SPDX-FileCopyrightText: 2021 Daniel Novomesky <dnovomesky@gmail.com>
+
+    SPDX-License-Identifier: BSD-2-Clause
+*/
+
+#ifndef KIMG_JXL_P_H
+#define KIMG_JXL_P_H
+
+#include <QByteArray>
+#include <QColorSpace>
+#include <QImage>
+#include <QImageIOHandler>
+#include <QImageIOPlugin>
+#include <QVariant>
+#include <QVector>
+
+#include <jxl/decode.h>
+
+class QJpegXLHandler : public QImageIOHandler
+{
+public:
+    QJpegXLHandler();
+    ~QJpegXLHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
+
+    static bool canRead(QIODevice *device);
+
+    QVariant option(ImageOption option) const override;
+    void setOption(ImageOption option, const QVariant &value) override;
+    bool supportsOption(ImageOption option) const override;
+
+    int imageCount() const override;
+    int currentImageNumber() const override;
+    bool jumpToNextImage() override;
+    bool jumpToImage(int imageNumber) override;
+
+    int nextImageDelay() const override;
+
+    int loopCount() const override;
+
+private:
+    bool ensureParsed() const;
+    bool ensureALLCounted() const;
+    bool ensureDecoder();
+    bool countALLFrames();
+    bool decode_one_frame();
+    bool rewind();
+
+    enum ParseJpegXLState {
+        ParseJpegXLError = -1,
+        ParseJpegXLNotParsed = 0,
+        ParseJpegXLSuccess = 1,
+        ParseJpegXLBasicInfoParsed = 2,
+    };
+
+    ParseJpegXLState m_parseState;
+    int m_quality;
+    int m_currentimage_index;
+    int m_previousimage_index;
+
+    QByteArray m_rawData;
+
+    JxlDecoder *m_decoder;
+    void *m_runner;
+    JxlBasicInfo m_basicinfo;
+
+    QVector<int> m_framedelays;
+    int m_next_image_delay;
+
+    QImage m_current_image;
+    QColorSpace m_colorspace;
+
+    QImage::Format m_input_image_format;
+    QImage::Format m_target_image_format;
+
+    JxlPixelFormat m_input_pixel_format;
+    size_t m_buffer_size;
+};
+
+class QJpegXLPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "jxl.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+#endif // KIMG_JXL_P_H

src/imageformats/kra.cpp

@@ -35,12 +35,14 @@ bool KraHandler::canRead() const
 bool KraHandler::read(QImage *image)
 {
     KZip zip(device());
-    if (!zip.open(QIODevice::ReadOnly))
+    if (!zip.open(QIODevice::ReadOnly)) {
         return false;
+    }
 
     const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
-    if (!entry || !entry->isFile())
+    if (!entry || !entry->isFile()) {
         return false;
+    }
 
     const KZipFileEntry *fileZipEntry = static_cast<const KZipFileEntry *>(entry);
 
@@ -57,8 +59,9 @@ bool KraHandler::canRead(QIODevice *device)
     }
 
     char buff[57];
-    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff)) {
         return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
+    }
 
     return false;
 }

src/imageformats/ora.cpp

@@ -34,12 +34,14 @@ bool OraHandler::canRead() const
 bool OraHandler::read(QImage *image)
 {
     KZip zip(device());
-    if (!zip.open(QIODevice::ReadOnly))
+    if (!zip.open(QIODevice::ReadOnly)) {
         return false;
+    }
 
     const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
-    if (!entry || !entry->isFile())
+    if (!entry || !entry->isFile()) {
         return false;
+    }
 
     const KZipFileEntry *fileZipEntry = static_cast<const KZipFileEntry *>(entry);
 
@@ -56,8 +58,9 @@ bool OraHandler::canRead(QIODevice *device)
     }
 
     char buff[54];
-    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff)) {
         return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
+    }
 
     return false;
 }

src/imageformats/pcx.cpp

@@ -6,6 +6,7 @@
 */
 
 #include "pcx_p.h"
+#include "util_p.h"
 
 #include <QColor>
 #include <QDataStream>
@@ -105,7 +106,9 @@ public:
 
 static QDataStream &operator>>(QDataStream &s, RGB &rgb)
 {
-    quint8 r, g, b;
+    quint8 r;
+    quint8 g;
+    quint8 b;
 
     s >> r >> g >> b;
     rgb.r = r;
@@ -126,24 +129,32 @@ static QDataStream &operator>>(QDataStream &s, Palette &pal)
 
 static QDataStream &operator>>(QDataStream &s, PCXHEADER &ph)
 {
-    quint8 m, ver, enc, bpp;
+    quint8 m;
+    quint8 ver;
+    quint8 enc;
+    quint8 bpp;
     s >> m >> ver >> enc >> bpp;
     ph.Manufacturer = m;
     ph.Version = ver;
     ph.Encoding = enc;
     ph.Bpp = bpp;
-    quint16 xmin, ymin, xmax, ymax;
+    quint16 xmin;
+    quint16 ymin;
+    quint16 xmax;
+    quint16 ymax;
     s >> xmin >> ymin >> xmax >> ymax;
     ph.XMin = xmin;
     ph.YMin = ymin;
     ph.XMax = xmax;
     ph.YMax = ymax;
-    quint16 hdpi, ydpi;
+    quint16 hdpi;
+    quint16 ydpi;
     s >> hdpi >> ydpi;
     ph.HDpi = hdpi;
     ph.YDpi = ydpi;
     Palette colorMap;
-    quint8 res, np;
+    quint8 res;
+    quint8 np;
     s >> colorMap >> res >> np;
     ph.ColorMap = colorMap;
     ph.Reserved = res;
@@ -154,7 +165,8 @@ static QDataStream &operator>>(QDataStream &s, PCXHEADER &ph)
     quint16 paletteinfo;
     s >> paletteinfo;
     ph.PaletteInfo = paletteinfo;
-    quint16 hscreensize, vscreensize;
+    quint16 hscreensize;
+    quint16 vscreensize;
     s >> hscreensize;
     ph.HScreenSize = hscreensize;
     s >> vscreensize;
@@ -222,7 +234,8 @@ static void readLine(QDataStream &s, QByteArray &buf, const PCXHEADER &header)
 {
     quint32 i = 0;
     quint32 size = buf.size();
-    quint8 byte, count;
+    quint8 byte;
+    quint8 count;
 
     if (header.isCompressed()) {
         // Uncompress the image data
@@ -250,7 +263,7 @@ static void readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
 {
     QByteArray buf(header.BytesPerLine, 0);
 
-    img = QImage(header.width(), header.height(), QImage::Format_Mono);
+    img = imageAlloc(header.width(), header.height(), QImage::Format_Mono);
     img.setColorCount(2);
 
     if (img.isNull()) {
@@ -282,7 +295,7 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
     QByteArray buf(header.BytesPerLine * 4, 0);
     QByteArray pixbuf(header.width(), 0);
 
-    img = QImage(header.width(), header.height(), QImage::Format_Indexed8);
+    img = imageAlloc(header.width(), header.height(), QImage::Format_Indexed8);
     img.setColorCount(16);
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
@@ -300,10 +313,11 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
 
         for (int i = 0; i < 4; i++) {
             quint32 offset = i * header.BytesPerLine;
-            for (int x = 0; x < header.width(); ++x)
+            for (int x = 0; x < header.width(); ++x) {
                 if (buf[offset + (x / 8)] & (128 >> (x % 8))) {
                     pixbuf[x] = (int)(pixbuf[x]) + (1 << i);
                 }
+            }
         }
 
         uchar *p = img.scanLine(y);
@@ -325,7 +339,7 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
 {
     QByteArray buf(header.BytesPerLine, 0);
 
-    img = QImage(header.width(), header.height(), QImage::Format_Indexed8);
+    img = imageAlloc(header.width(), header.height(), QImage::Format_Indexed8);
     img.setColorCount(256);
 
     if (img.isNull()) {
@@ -343,8 +357,9 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
 
         uchar *p = img.scanLine(y);
 
-        if (!p)
+        if (!p) {
             return;
+        }
 
         unsigned int bpl = qMin(header.BytesPerLine, (quint16)header.width());
         for (unsigned int x = 0; x < bpl; ++x) {
@@ -358,7 +373,9 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     if (flag == 12 && (header.Version == 5 || header.Version == 2)) {
         // Read the palette
-        quint8 r, g, b;
+        quint8 r;
+        quint8 g;
+        quint8 b;
         for (int i = 0; i < 256; ++i) {
             s >> r >> g >> b;
             img.setColor(i, qRgb(r, g, b));
@@ -372,7 +389,7 @@ static void readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
     QByteArray g_buf(header.BytesPerLine, 0);
     QByteArray b_buf(header.BytesPerLine, 0);
 
-    img = QImage(header.width(), header.height(), QImage::Format_RGB32);
+    img = imageAlloc(header.width(), header.height(), QImage::Format_RGB32);
 
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
@@ -400,7 +417,8 @@ static void writeLine(QDataStream &s, QByteArray &buf)
 {
     quint32 i = 0;
     quint32 size = buf.size();
-    quint8 count, data;
+    quint8 count;
+    quint8 data;
     char byte;
 
     while (i < size) {
@@ -473,10 +491,11 @@ static void writeImage4(QImage &img, QDataStream &s, PCXHEADER &header)
         }
 
         for (int x = 0; x < header.width(); ++x) {
-            for (int i = 0; i < 4; ++i)
+            for (int i = 0; i < 4; ++i) {
                 if (*(p + x) & (1 << i)) {
                     buf[i][x / 8] = (int)(buf[i][x / 8]) | 1 << (7 - x % 8);
                 }
+            }
         }
 
         for (int i = 0; i < 4; ++i) {
@@ -618,8 +637,12 @@ bool PCXHandler::write(const QImage &image)
 
     QImage img = image;
 
-    int w = img.width();
-    int h = img.height();
+    const int w = img.width();
+    const int h = img.height();
+
+    if (w > 65536 || h > 65536) {
+        return false;
+    }
 
     //   qDebug() << "Width: " << w;
     //   qDebug() << "Height: " << h;
@@ -661,6 +684,12 @@ bool PCXHandler::canRead(QIODevice *device)
         return false;
     }
 
+    // We do not support sequential images
+    // We need to know the current position to properly read the header
+    if (device->isSequential()) {
+        return false;
+    }
+
     qint64 oldPos = device->pos();
 
     char head[1];

src/imageformats/pic.cpp

@@ -14,8 +14,8 @@
  */
 
 #include "pic_p.h"
-
 #include "rle_p.h"
+#include "util_p.h"
 
 #include <QDataStream>
 #include <QDebug>
@@ -24,6 +24,7 @@
 #include <algorithm>
 #include <functional>
 #include <qendian.h>
+#include <utility>
 
 /**
  * Reads a PIC file header from a data stream.
@@ -225,7 +226,7 @@ bool SoftimagePICHandler::read(QImage *image)
     }
 
     QImage::Format fmt = QImage::Format_RGB32;
-    for (const PicChannel &channel : qAsConst(m_channels)) {
+    for (const PicChannel &channel : std::as_const(m_channels)) {
         if (channel.size != 8) {
             // we cannot read images that do not come in bytes
             qDebug() << "Channel size was" << channel.size;
@@ -237,7 +238,7 @@ bool SoftimagePICHandler::read(QImage *image)
         }
     }
 
-    QImage img(m_header.width, m_header.height, fmt);
+    QImage img = imageAlloc(m_header.width, m_header.height, fmt);
     if (img.isNull()) {
         qDebug() << "Failed to allocate image, invalid dimensions?" << QSize(m_header.width, m_header.height) << fmt;
         return false;
@@ -404,7 +405,7 @@ QVariant SoftimagePICHandler::option(ImageOption option) const
         return QString();
     case ImageFormat:
         if (const_cast<SoftimagePICHandler *>(this)->readChannels()) {
-            for (const PicChannel &channel : qAsConst(m_channels)) {
+            for (const PicChannel &channel : std::as_const(m_channels)) {
                 if (channel.code & ALPHA) {
                     return QImage::Format_ARGB32;
                 }

src/imageformats/psd.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
-X-KDE-ImageFormat=psd
+X-KDE-ImageFormat=psd,psb,pdd,psdt
 X-KDE-MimeType=image/vnd.adobe.photoshop
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/psd.json

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

src/imageformats/psd_p.h

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

src/imageformats/ras.cpp

@@ -8,6 +8,7 @@
 */
 
 #include "ras_p.h"
+#include "util_p.h"
 
 #include <QDataStream>
 #include <QDebug>
@@ -102,8 +103,7 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
 {
     s.device()->seek(RasHeader::SIZE);
 
-    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
-    if (ras.ColorMapLength > std::numeric_limits<int>::max() - 32) {
+    if (ras.ColorMapLength > kMaxQVectorSize) {
         qWarning() << "LoadRAS() unsupported image color map length in file header" << ras.ColorMapLength;
         return false;
     }
@@ -127,8 +127,7 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
         qWarning() << "LoadRAS() mistmatch between height and width" << ras.Width << ras.Height << ras.Length << ras.Depth;
         return false;
     }
-    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
-    if (ras.Length > std::numeric_limits<int>::max() - 32) {
+    if (ras.Length > kMaxQVectorSize) {
         qWarning() << "LoadRAS() unsupported image length in file header" << ras.Length;
         return false;
     }
@@ -152,15 +151,17 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     }
 
     // Allocate image
-    img = QImage(ras.Width, ras.Height, QImage::Format_ARGB32);
-
-    if (img.isNull())
+    img = imageAlloc(ras.Width, ras.Height, QImage::Format_ARGB32);
+    if (img.isNull()) {
         return false;
+    }
 
     // Reconstruct image from RGB palette if we have a palette
     // TODO: make generic so it works with 24bit or 32bit palettes
     if (ras.ColorMapType == 1 && ras.Depth == 8) {
-        quint8 red, green, blue;
+        quint8 red;
+        quint8 green;
+        quint8 blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
                 red = palette.value((int)input[y * ras.Width + x]);
@@ -172,7 +173,9 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     }
 
     if (ras.ColorMapType == 0 && ras.Depth == 24 && (ras.Type == 1 || ras.Type == 2)) {
-        quint8 red, green, blue;
+        quint8 red;
+        quint8 green;
+        quint8 blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
                 red = input[y * 3 * ras.Width + x * 3 + 2];
@@ -184,7 +187,9 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     }
 
     if (ras.ColorMapType == 0 && ras.Depth == 24 && ras.Type == 3) {
-        quint8 red, green, blue;
+        quint8 red;
+        quint8 green;
+        quint8 blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
                 red = input[y * 3 * ras.Width + x * 3];
@@ -196,7 +201,9 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     }
 
     if (ras.ColorMapType == 0 && ras.Depth == 32 && (ras.Type == 1 || ras.Type == 2)) {
-        quint8 red, green, blue;
+        quint8 red;
+        quint8 green;
+        quint8 blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
                 red = input[y * 4 * ras.Width + x * 4 + 3];
@@ -208,7 +215,9 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     }
 
     if (ras.ColorMapType == 0 && ras.Depth == 32 && ras.Type == 3) {
-        quint8 red, green, blue;
+        quint8 red;
+        quint8 green;
+        quint8 blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
                 red = input[y * 4 * ras.Width + x * 4 + 1];
@@ -274,8 +283,9 @@ bool RASHandler::read(QImage *outImage)
     RasHeader ras;
     s >> ras;
 
-    if (ras.ColorMapLength > std::numeric_limits<int>::max())
+    if (ras.ColorMapLength > std::numeric_limits<int>::max()) {
         return false;
+    }
 
     // TODO: add support for old versions of RAS where Length may be zero in header
     s.device()->seek(RasHeader::SIZE + ras.Length + ras.ColorMapLength);

src/imageformats/raw.cpp

@@ -0,0 +1,899 @@
+/*
+    RAW support for QImage.
+
+    SPDX-FileCopyrightText: 2022 Mirco Miranda <mircomir@outlook.com>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#include "raw_p.h"
+#include "util_p.h"
+
+#include <QColorSpace>
+#include <QDateTime>
+#include <QDebug>
+#include <QImage>
+#include <QSet>
+
+#if defined(Q_OS_WINDOWS) && !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+
+#if defined(Q_OS_WINDOWS)
+#include <libraw.h>
+#else
+#include <libraw/libraw.h>
+#endif
+
+#ifdef QT_DEBUG
+// This should be used to exclude the local QIODevice wrapper of the LibRaw_abstract_datastream interface.
+// If the result changes then the problem is in the local wrapper and must be corrected.
+// WARNING: using the LibRaw's streams instead of the local wrapper from a Qt program falls in the LOCALE
+//          bug when the RAW file needs the scanf_one() function (e.g. *.MOS files). See also raw_scanf_one().
+//#define EXCLUDE_LibRaw_QIODevice // Uncomment this code if you think that the problem is LibRaw_QIODevice (default commented)
+#endif
+
+namespace // Private.
+{
+
+// smart pointer for processed image
+using pi_unique_ptr = std::unique_ptr<libraw_processed_image_t, std::function<void(libraw_processed_image_t *)>>;
+
+// clang-format off
+// Known formats supported by LibRaw (in alphabetical order and lower case)
+const auto supported_formats = QSet<QByteArray>{
+    "3fr",
+    "arw", "arq",
+    "bay", "bmq",
+    "cr2", "cr3", "cap", "cine", "cs1", "crw",
+    "dcs", "dc2", "dcr", "dng", "drf", "dxo",
+    "eip", "erf",
+    "fff",
+    "hdr",
+    "iiq",
+    "k25", "kc2", "kdc",
+    "mdc", "mef", "mfw", "mos", "mrw",
+    "nef", "nrw",
+    "obm", "orf", "ori",
+    "pef", "ptx", "pxn",
+    "qtk",
+    "r3d", "raf", "raw", "rdc", "rw2", "rwl", "rwz",
+    "sr2", "srf", "srw", "sti",
+    "x3f"
+};
+// clang-format on
+
+inline int raw_scanf_one(const QByteArray &ba, const char *fmt, void *val)
+{
+    // WARNING: Here it would be nice to use sscanf like LibRaw does but there
+    //          is a Big Trouble: THE LOCALE! LibRaw is also affected by the
+    //          issue if used in a Qt program:
+    //          If you use sscanf here the conversion is wrong when performed
+    //          with Italian locale (where the decimal separator is the comma).
+    // The solution should be to use std::locale::global() but it's global!
+    // I don't want to do it. So, don't use code like that:
+    // return sscanf(QByteArray(ba).append('\0').data(), fmt, val);
+
+    // LibRaw is asking only "%d" and "%f" for now. This code is not affected
+    // by the LOCALE bug.
+    auto s = QString::fromLatin1(ba);
+    if (strcmp(fmt, "%d") == 0) {
+        auto ok = false;
+        auto d = QLocale::c().toInt(s, &ok);
+        if (!ok) {
+            return EOF;
+        }
+        *(static_cast<int *>(val)) = d;
+    } else {
+        auto ok = false;
+        auto f = QLocale::c().toFloat(s, &ok);
+        if (!ok) {
+            return EOF;
+        }
+        *(static_cast<float *>(val)) = f;
+    }
+    return 1;
+}
+
+/**
+ * @brief The LibRaw_QIODevice class
+ * Implementation of the LibRaw stream interface over a QIODevice.
+ */
+class LibRaw_QIODevice : public LibRaw_abstract_datastream
+{
+public:
+    explicit LibRaw_QIODevice(QIODevice *device)
+    {
+        m_device = device;
+    }
+    virtual ~LibRaw_QIODevice() override
+    {
+    }
+    virtual int valid() override
+    {
+        return m_device != nullptr;
+    }
+    virtual int read(void *ptr, size_t sz, size_t nmemb) override
+    {
+        auto read = m_device->read(reinterpret_cast<char *>(ptr), sz * nmemb);
+        if (read < 1) {
+            return 0;
+        }
+        if (auto o = read % sz) {
+            seek(-(sz - o), SEEK_CUR);
+        }
+        return read / sz;
+    }
+    virtual int eof() override
+    {
+        return m_device->atEnd() ? 1 : 0;
+    }
+    virtual int seek(INT64 o, int whence) override
+    {
+        auto pos = o;
+        auto size = m_device->size();
+        if (whence == SEEK_CUR) {
+            pos = m_device->pos() + o;
+        }
+        if (whence == SEEK_END) {
+            pos = size + o;
+        }
+        if (pos < 0 || pos > size || m_device->isSequential()) {
+            return -1;
+        }
+        return m_device->seek(pos) ? 0 : -1;
+    }
+    virtual INT64 tell() override
+    {
+        return m_device->pos();
+    }
+    virtual INT64 size() override
+    {
+        return m_device->size();
+    }
+    virtual char *gets(char *s, int sz) override
+    {
+        if (m_device->readLine(s, sz) > 0) {
+            return s;
+        }
+        return nullptr;
+    }
+    virtual int scanf_one(const char *fmt, void *val) override
+    {
+        QByteArray ba;
+        for (int xcnt = 0; xcnt < 24 && !m_device->atEnd(); ++xcnt) {
+            char c;
+            if (!m_device->getChar(&c)) {
+                return EOF;
+            }
+            if (ba.isEmpty() && (c == ' ' || c == '\t')) {
+                continue;
+            }
+            if (c == '\0' || c == ' ' || c == '\t' || c == '\n') {
+                break;
+            }
+            ba.append(c);
+        }
+        return raw_scanf_one(ba, fmt, val);
+    }
+    virtual int get_char() override
+    {
+        unsigned char c;
+        if (!m_device->getChar(reinterpret_cast<char *>(&c))) {
+            return EOF;
+        }
+        return int(c);
+    }
+#if (LIBRAW_VERSION < LIBRAW_MAKE_VERSION(0, 21, 0)) || defined(LIBRAW_OLD_VIDEO_SUPPORT)
+    virtual void *make_jas_stream() override
+    {
+        return nullptr;
+    }
+#endif
+
+private:
+    QIODevice *m_device;
+};
+
+bool addTag(const QString &tag, QStringList &lines)
+{
+    auto ok = !tag.isEmpty();
+    if (ok) {
+        lines << tag;
+    }
+    return ok;
+}
+
+QString createTag(QString value, const char *tag)
+{
+    if (!value.isEmpty()) {
+        value = QStringLiteral("<%1>%2</%1>").arg(QString::fromLatin1(tag), value);
+    }
+    return value;
+}
+
+QString createTag(char *asciiz, const char *tag)
+{
+    auto value = QString::fromUtf8(asciiz);
+    return createTag(value, tag);
+}
+
+QString createTimeTag(time_t time, const char *tag)
+{
+    auto value = QDateTime::fromSecsSinceEpoch(time, Qt::UTC);
+    if (value.isValid() && time > 0) {
+        return createTag(value.toString(Qt::ISODate), tag);
+    }
+    return QString();
+}
+
+QString createFlashTag(short flash, const char *tag)
+{
+    QStringList l;
+    auto lc = QLocale::c();
+    // EXIF specifications
+    auto t = QStringLiteral("true");
+    auto f = QStringLiteral("false");
+    l << QStringLiteral("<exif:Fired>%1</exif:Fired>").arg((flash & 1) ? t : f);
+    l << QStringLiteral("<exif:Function>%1</exif:Function>").arg((flash & (1 << 5)) ? t : f);
+    l << QStringLiteral("<exif:RedEyeMode>%1</exif:RedEyeMode>").arg((flash & (1 << 6)) ? t : f);
+    l << QStringLiteral("<exif:Mode>%1</exif:Mode>").arg(lc.toString((int(flash) >> 3) & 3));
+    l << QStringLiteral("<exif:Return>%1</exif:Return>").arg(lc.toString((int(flash) >> 1) & 3));
+    return createTag(l.join(QChar()), tag);
+}
+
+QString createTag(quint64 n, const char *tag, quint64 invalid = 0)
+{
+    if (n != invalid) {
+        return createTag(QLocale::c().toString(n), tag);
+    }
+    return QString();
+}
+
+QString createTag(qint16 n, const char *tag, qint16 invalid = 0)
+{
+    if (n != invalid) {
+        return createTag(QLocale::c().toString(n), tag);
+    }
+    return QString();
+}
+
+QString createTag(quint16 n, const char *tag, quint16 invalid = 0)
+{
+    if (n != invalid) {
+        return createTag(QLocale::c().toString(n), tag);
+    }
+    return QString();
+}
+
+QString createTag(float f, const char *tag, qint32 mul = 1)
+{
+    if (f != 0) {
+        if (mul > 1)
+            return QStringLiteral("<%1>%2/%3</%1>").arg(QString::fromLatin1(tag), QLocale::c().toString(int(f * mul))).arg(mul);
+        return QStringLiteral("<%1>%2</%1>").arg(QString::fromLatin1(tag), QLocale::c().toString(f));
+    }
+    return QString();
+}
+
+QString createTag(libraw_gps_info_t gps, const char *tag)
+{
+    auto tmp = QString::fromLatin1(tag);
+    if (tmp.contains(QStringLiteral("Latitude"), Qt::CaseInsensitive)) {
+        if (gps.latref != '\0') {
+            auto lc = QLocale::c();
+            auto value = QStringLiteral("%1,%2%3")
+                             .arg(lc.toString(gps.latitude[0], 'f', 0))
+                             .arg(lc.toString(gps.latitude[1] + gps.latitude[2] / 60, 'f', 4))
+                             .arg(QChar::fromLatin1(gps.latref));
+            return createTag(value, tag);
+        }
+    }
+    if (tmp.contains(QStringLiteral("Longitude"), Qt::CaseInsensitive)) {
+        if (gps.longref != '\0') {
+            auto lc = QLocale::c();
+            auto value = QStringLiteral("%1,%2%3")
+                             .arg(lc.toString(gps.longitude[0], 'f', 0))
+                             .arg(lc.toString(gps.longitude[1] + gps.longitude[2] / 60, 'f', 4))
+                             .arg(QChar::fromLatin1(gps.longref));
+            return createTag(value, tag);
+        }
+    }
+    if (tmp.contains(QStringLiteral("Altitude"), Qt::CaseInsensitive)) {
+        if (gps.altitude != 0) {
+            return createTag(gps.altitude, tag, 1000);
+        }
+    }
+    return QString();
+}
+
+QString createXmpPacket()
+{
+    QStringList lines;
+    lines << QStringLiteral("<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>");
+    lines << QStringLiteral("<x:xmpmeta xmlns:x=\"adobe:ns:meta/\" x:xmptk=\"KIMG RAW Plugin\">");
+    lines << QStringLiteral("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">");
+    lines << QStringLiteral("</rdf:RDF>");
+    lines << QStringLiteral("</x:xmpmeta>");
+    for (auto i = 30; i > 0; --i)
+        lines << QString::fromLatin1(QByteArray(80, ' '));
+    lines << QStringLiteral("<?xpacket end=\"w\"?>");
+    return lines.join(QChar::fromLatin1('\n'));
+}
+
+QString updateXmpPacket(const QString &xmpPacket, LibRaw *rawProcessor)
+{
+    auto rdfEnd = xmpPacket.indexOf(QStringLiteral("</rdf:RDF>"), Qt::CaseInsensitive);
+    if (rdfEnd < 0) {
+        return updateXmpPacket(createXmpPacket(), rawProcessor);
+    }
+
+    auto lines = QStringList() << xmpPacket.left(rdfEnd);
+    lines << QStringLiteral("<rdf:Description rdf:about=\"\"");
+    lines << QStringLiteral("      xmlns:xmp=\"http://ns.adobe.com/xap/1.0/\"");
+    lines << QStringLiteral("      xmlns:dc=\"http://purl.org/dc/elements/1.1/\"");
+    lines << QStringLiteral("      xmlns:aux=\"http://ns.adobe.com/exif/1.0/aux/\"");
+    lines << QStringLiteral("      xmlns:xmpMM=\"http://ns.adobe.com/xap/1.0/mm/\"");
+    lines << QStringLiteral("      xmlns:stEvt=\"http://ns.adobe.com/xap/1.0/sType/ResourceEvent#\"");
+    lines << QStringLiteral("      xmlns:stRef=\"http://ns.adobe.com/xap/1.0/sType/ResourceRef#\"");
+    lines << QStringLiteral("      xmlns:tiff=\"http://ns.adobe.com/tiff/1.0/\"");
+    lines << QStringLiteral("      xmlns:exif=\"http://ns.adobe.com/exif/1.0/\"");
+    lines << QStringLiteral("      xmlns:xmpRights=\"http://ns.adobe.com/xap/1.0/rights/\">");
+    lines << QStringLiteral("<xmpMM:History>");
+    lines << QStringLiteral("<rdf:Seq>");
+    lines << QStringLiteral("<rdf:li rdf:parseType=\"Resource\">");
+    lines << QStringLiteral("<stEvt:action>converted</stEvt:action>");
+    lines << QStringLiteral("<stEvt:parameters>Converted from RAW to Qt Image using KIMG RAW plugin</stEvt:parameters>");
+    lines << QStringLiteral("<stEvt:softwareAgent>LibRaw %1</stEvt:softwareAgent>").arg(QString::fromLatin1(LibRaw::version()));
+    lines << QStringLiteral("<stEvt:when>%1</stEvt:when>").arg(QDateTime::currentDateTimeUtc().toString(Qt::ISODate));
+    lines << QStringLiteral("</rdf:li>");
+    lines << QStringLiteral("</rdf:Seq>");
+    lines << QStringLiteral("</xmpMM:History>");
+
+    auto &&iparams = rawProcessor->imgdata.idata;
+    addTag(createTag(iparams.normalized_model, "tiff:Model"), lines);
+    addTag(createTag(iparams.normalized_make, "tiff:Make"), lines);
+    addTag(createTag(iparams.software, "xmp:CreatorTool"), lines);
+
+    auto &&iother = rawProcessor->imgdata.other;
+    addTag(createTag(createTag(createTag(iother.desc, "rdf:li"), "rdf:Alt"), "dc:description"), lines);
+    addTag(createTag(createTag(createTag(iother.artist, "rdf:li"), "rdf:Seq"), "dc:creator"), lines);
+    addTag(createTag(createTag(createTag(iother.iso_speed, "rdf:li"), "rdf:Seq"), "exif:ISOSpeedRatings"), lines);
+    addTag(createTag(iother.shutter, "exif:ExposureTime", 1000), lines);
+    addTag(createTag(iother.aperture, "exif:ApertureValue", 1000), lines);
+    addTag(createTag(iother.focal_len, "exif:FocalLength", 1000), lines);
+    addTag(createTimeTag(iother.timestamp, "xmp:CreateDate"), lines);
+    addTag(createTag(iother.parsed_gps, "exif:GPSLatitude"), lines);
+    addTag(createTag(iother.parsed_gps, "exif:GPSLongitude"), lines);
+    addTag(createTag(iother.parsed_gps, "exif:GPSAltitude"), lines);
+
+    auto &&shotinfo = rawProcessor->imgdata.shootinginfo;
+    addTag(createTag(shotinfo.ExposureMode, "exif:ExposureMode", short(-1)), lines);
+    addTag(createTag(shotinfo.MeteringMode, "exif:MeteringMode", short(-1)), lines);
+    addTag(createTag(shotinfo.BodySerial, "aux:SerialNumber"), lines);
+
+    auto &&color = rawProcessor->imgdata.color;
+    addTag(createFlashTag(color.flash_used, "exif:Flash"), lines);
+
+    auto &&lens = rawProcessor->imgdata.lens;
+    addTag(createTag(lens.FocalLengthIn35mmFormat, "exif:FocalLengthIn35mmFilm"), lines);
+    addTag(createTag(lens.Lens, "aux:Lens"), lines);
+    addTag(createTag(lens.LensSerial, "aux:LensSerialNumber"), lines);
+    addTag(createTag(lens.nikon.LensIDNumber ? quint64(lens.nikon.LensIDNumber) : lens.makernotes.LensID, "aux:LensID"), lines);
+
+    auto &&makernotes = rawProcessor->imgdata.makernotes;
+    addTag(createTag(makernotes.common.firmware, "aux:Firmware"), lines);
+
+    lines << QStringLiteral("</rdf:Description>");
+    lines << xmpPacket.mid(rdfEnd);
+
+    return lines.join(QChar::fromLatin1('\n'));
+}
+
+template<class T>
+inline void rgbToRgbX(uchar *target, const uchar *source, qint32 targetSize, qint32 sourceSize)
+{
+    auto s = reinterpret_cast<const T *>(source);
+    auto t = reinterpret_cast<T *>(target);
+    auto width = std::min(targetSize / 4, sourceSize / 3) / qint32(sizeof(T));
+    for (qint32 x = 0; x < width; ++x) {
+        t[x * 4 + 0] = s[x * 3 + 0];
+        t[x * 4 + 1] = s[x * 3 + 1];
+        t[x * 4 + 2] = s[x * 3 + 2];
+        t[x * 4 + 3] = std::numeric_limits<T>::max();
+    }
+}
+
+// clang-format off
+#define C_IQ(a) (((a) & 0xF) << 4)
+#define C_OC(a) (((a) & 0xF) << 8)
+#define C_CW(a) (((a) & 0x1) << 12)
+#define C_AW(a) (((a) & 0x1) << 13)
+#define C_BT(a) (((a) & 0x1) << 14)
+#define C_HS(a) (((a) & 0x1) << 15)
+#define C_CE(a) (((a) & 0x1) << 16)
+#define C_NR(a) (((a) & 0x3) << 17)
+#define C_FC(a) (((a) & 0x1) << 19)
+#define C_SR(a) (((a) & 0x1) << 20)
+#define C_PRESET(a) ((a) & 0xF)
+
+#define T_IQ(a) (((a) >> 4) & 0xF)
+#define T_OC(a) (((a) >> 8) & 0xF)
+#define T_CW(a) (((a) >> 12) & 0x1)
+#define T_AW(a) (((a) >> 13) & 0x1)
+#define T_BT(a) (((a) >> 14) & 0x1)
+#define T_HS(a) (((a) >> 15) & 0x1)
+#define T_CE(a) (((a) >> 16) & 0x1)
+#define T_NR(a) (((a) >> 17) & 0x3)
+#define T_FC(a) (((a) >> 19) & 0x1)
+#define T_SR(a) (((a) >> 20) & 0x1)
+#define T_PRESET(a) ((a) & 0xF)
+// clang-format on
+
+#define DEFAULT_QUALITY (C_IQ(3) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0))
+
+void setParams(QImageIOHandler *handler, LibRaw *rawProcessor)
+{
+    // *** Set raw params
+#if (LIBRAW_VERSION < LIBRAW_MAKE_VERSION(0, 21, 0))
+    auto &&rawparams = rawProcessor->imgdata.params;
+#else
+    auto &&rawparams = rawProcessor->imgdata.rawparams;
+#endif
+    // Select one raw image from input file (0 - first, ...)
+    rawparams.shot_select = handler->currentImageNumber();
+
+    // *** Set processing parameters
+
+    // NOTE: The default value set below are the ones that gave the best results
+    // on a large sample of images (https://raw.pixls.us/data/)
+
+    /**
+     * @brief quality
+     * Plugin quality option.
+     */
+    qint32 quality = -1;
+    if (handler->supportsOption(QImageIOHandler::Quality)) {
+        quality = handler->option(QImageIOHandler::Quality).toInt();
+    }
+    if (quality < 0) {
+        quality = DEFAULT_QUALITY;
+    }
+
+    switch (T_PRESET(quality)) {
+    case 0:
+        break;
+    case 1:
+        quality = C_IQ(0) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(0) | C_HS(1);
+        break;
+    case 2:
+        quality = C_IQ(0) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(0) | C_HS(0);
+        break;
+    case 3:
+        quality = C_IQ(3) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(0) | C_HS(0);
+        break;
+    case 4:
+        quality = C_IQ(3) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0);
+        break;
+    case 5:
+        quality = C_IQ(3) | C_OC(2) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0);
+        break;
+    case 6:
+        quality = C_IQ(3) | C_OC(4) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0);
+        break;
+    case 7:
+        quality = C_IQ(11) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(0) | C_HS(0);
+        break;
+    case 8:
+        quality = C_IQ(11) | C_OC(1) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0);
+        break;
+    case 9:
+        quality = C_IQ(11) | C_OC(2) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0);
+        break;
+    case 10:
+        quality = C_IQ(11) | C_OC(4) | C_CW(1) | C_AW(1) | C_BT(1) | C_HS(0);
+        break;
+    default:
+        quality = DEFAULT_QUALITY;
+        break;
+    }
+
+    auto &&params = rawProcessor->imgdata.params;
+
+    /**
+     * @brief use_camera_wb
+     * Use camera white balance, if possible (0 - off, 1 - on)
+     *
+     * This should to be set. Alternatively, a calibrated white balance should be set on each camera.
+     */
+    params.use_camera_wb = T_CW(quality);
+
+    /*!
+     * \brief use_auto_wb
+     * Average the whole image for white balance (0 - off, 1 - on)
+     *
+     * This is usefull if no camera white balance is available.
+     */
+    params.use_auto_wb = T_AW(quality);
+
+    /**
+     * @brief output_bps
+     * Bits per pixel (8 or 16)
+     *
+     * Professional cameras (and even some smartphones) generate images at 10 or more bits per sample.
+     * When using 16-bit images, the highest quality should be maintained.
+     */
+    params.output_bps = T_BT(quality) ? 16 : 8;
+
+    /**
+     * @brief output_color
+     * Output colorspace (0 - raw, 1 - sRGB, 2 - Adobe, 3 - Wide, 4 - ProPhoto, 5 - XYZ, 6 - ACES, 7 - DCI-P3, 8 - Rec2020)
+     *
+     * sRGB allows you to view images correctly on programs that do not support ICC profiles. When most
+     * Programs will support icc profiles, ProPhoto may be a better choice.
+     * @note sRgb is the LibRaw default: if grayscale image is loaded, LibRaw switches to 0 (Raw) automatically.
+     */
+    params.output_color = T_OC(quality);
+
+    /**
+     * @brief user_qual
+     * Interpolation quality (0 - linear, 1 - VNG, 2 - PPG, 3 - AHD, 4 - DCB, 11 - DHT, 12 - AAHD)
+     *
+     * DHT seems the best option - See In-Depth Demosaicing Algorithm Analysis (https://www.libraw.org/node/2306)
+     * but, when used, some FUJI RAF files of my library are poorly rendered (e.g. completely green). This is the
+     * why I used AHD: a good compromise between quality and performance with no rendering errors.
+     */
+    params.user_qual = T_IQ(quality);
+
+    /**
+     * @brief half_size
+     * Generate an half-size image (0 - off, 1 - on)
+     *
+     * Very fast and useful for generating previews.
+     */
+    params.half_size = T_HS(quality);
+
+    /**
+     * @dcb_enhance_fl
+     * DCB color enhance filter (0 - off, 1 - on)
+     */
+    params.dcb_enhance_fl = T_CE(quality);
+
+    /**
+     * @fbdd_noiserd
+     * FBDD noise reduction (0 - off, 1 - light, 2 - full)
+     */
+    params.fbdd_noiserd = std::min(2, T_NR(quality));
+
+    /**
+     * @four_color_rgb
+     * Interpolate RGGB as four colors (0 - off, 1 - on)
+     */
+    params.four_color_rgb = T_FC(quality);
+
+    /**
+     * @use_fuji_rotate
+     * Don't stretch or rotate raw pixels (0 - off, 1 - on)
+     */
+    params.use_fuji_rotate = T_SR(quality) ? 0 : 1;
+}
+
+bool LoadRAW(QImageIOHandler *handler, QImage &img)
+{
+    std::unique_ptr<LibRaw> rawProcessor(new LibRaw);
+
+    // *** Set parameters
+    setParams(handler, rawProcessor.get());
+
+    // *** Open the stream
+    auto device = handler->device();
+#ifndef EXCLUDE_LibRaw_QIODevice
+    LibRaw_QIODevice stream(device);
+    if (rawProcessor->open_datastream(&stream) != LIBRAW_SUCCESS) {
+        return false;
+    }
+#else
+    auto ba = device->readAll();
+    if (rawProcessor->open_buffer(ba.data(), ba.size()) != LIBRAW_SUCCESS) {
+        return false;
+    }
+#endif
+
+    // *** Unpacking selected image
+    if (rawProcessor->unpack() != LIBRAW_SUCCESS) {
+        return false;
+    }
+
+    // *** Process selected image
+    if (rawProcessor->dcraw_process() != LIBRAW_SUCCESS) {
+        return false;
+    }
+
+    // *** Convert to QImage
+    pi_unique_ptr processedImage(rawProcessor->dcraw_make_mem_image(), LibRaw::dcraw_clear_mem);
+    if (processedImage == nullptr) {
+        return false;
+    }
+
+    // clang-format off
+    if ((processedImage->type != LIBRAW_IMAGE_BITMAP) ||
+        (processedImage->colors != 1 && processedImage->colors != 3 && processedImage->colors != 4) ||
+        (processedImage->bits != 8 && processedImage->bits != 16)) {
+        return false;
+    }
+    // clang-format on
+
+    auto format = QImage::Format_Invalid;
+    switch (processedImage->colors) {
+    case 1: // Gray images (tested with image attached on https://bugs.kde.org/show_bug.cgi?id=401371)
+        format = processedImage->bits == 8 ? QImage::Format_Grayscale8 : QImage::Format_Grayscale16;
+        break;
+    case 3: // Images with R G B components
+        format = processedImage->bits == 8 ? QImage::Format_RGB888 : QImage::Format_RGBX64;
+        break;
+    case 4: // Images with R G B components + Alpha (never seen)
+        format = processedImage->bits == 8 ? QImage::Format_RGBA8888 : QImage::Format_RGBA64;
+        break;
+    }
+
+    if (format == QImage::Format_Invalid) {
+        return false;
+    }
+
+    img = imageAlloc(processedImage->width, processedImage->height, format);
+    if (img.isNull()) {
+        return false;
+    }
+
+    auto rawBytesPerLine = qint32(processedImage->width * processedImage->bits * processedImage->colors + 7) / 8;
+    auto lineSize = std::min(qint32(img.bytesPerLine()), rawBytesPerLine);
+    for (int y = 0, h = img.height(); y < h; ++y) {
+        auto scanline = img.scanLine(y);
+        if (format == QImage::Format_RGBX64)
+            rgbToRgbX<quint16>(scanline, processedImage->data + rawBytesPerLine * y, img.bytesPerLine(), rawBytesPerLine);
+        else
+            memcpy(scanline, processedImage->data + rawBytesPerLine * y, lineSize);
+    }
+
+    // *** Set the color space
+    auto &&params = rawProcessor->imgdata.params;
+    if (params.output_color == 0) {
+        auto &&color = rawProcessor->imgdata.color;
+        if (auto profile = reinterpret_cast<char *>(color.profile)) {
+            img.setColorSpace(QColorSpace::fromIccProfile(QByteArray(profile, color.profile_length)));
+        }
+    }
+    if (processedImage->colors >= 3) {
+        if (params.output_color == 1) {
+            img.setColorSpace(QColorSpace(QColorSpace::SRgb));
+        }
+        if (params.output_color == 2) {
+            img.setColorSpace(QColorSpace(QColorSpace::AdobeRgb));
+        }
+        if (params.output_color == 4) {
+            img.setColorSpace(QColorSpace(QColorSpace::ProPhotoRgb));
+        }
+    }
+
+    // *** Set the metadata
+    auto &&iparams = rawProcessor->imgdata.idata;
+
+    auto xmpPacket = QString();
+    if (auto xmpdata = iparams.xmpdata) {
+        if (auto xmplen = iparams.xmplen)
+            xmpPacket = QString::fromUtf8(xmpdata, xmplen);
+    }
+    // Add info from LibRAW structs (e.g. GPS position, info about lens, info about shot and flash, etc...)
+    img.setText(QStringLiteral("XML:com.adobe.xmp"), updateXmpPacket(xmpPacket, rawProcessor.get()));
+
+    auto model = QString::fromUtf8(iparams.normalized_model);
+    if (!model.isEmpty()) {
+        img.setText(QStringLiteral("Model"), model);
+    }
+    auto manufacturer = QString::fromUtf8(iparams.normalized_make);
+    if (!manufacturer.isEmpty()) {
+        img.setText(QStringLiteral("Manufacturer"), manufacturer);
+    }
+    auto software = QString::fromUtf8(iparams.software);
+    if (!software.isEmpty()) {
+        img.setText(QStringLiteral("Software"), software);
+    }
+
+    auto &&iother = rawProcessor->imgdata.other;
+    auto description = QString::fromUtf8(iother.desc);
+    if (!description.isEmpty()) {
+        img.setText(QStringLiteral("Description"), description);
+    }
+    auto artist = QString::fromUtf8(iother.artist);
+    if (!artist.isEmpty()) {
+        img.setText(QStringLiteral("Author"), artist);
+    }
+
+    return true;
+}
+
+} // Private
+
+RAWHandler::RAWHandler()
+    : m_imageNumber(0)
+    , m_imageCount(0)
+    , m_quality(-1)
+{
+}
+
+bool RAWHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("raw");
+        return true;
+    }
+    return false;
+}
+
+bool RAWHandler::read(QImage *image)
+{
+    auto dev = device();
+
+    // Check image file format.
+    if (dev->atEnd()) {
+        return false;
+    }
+
+    QImage img;
+    if (!LoadRAW(this, img)) {
+        return false;
+    }
+
+    *image = img;
+    return true;
+}
+
+void RAWHandler::setOption(ImageOption option, const QVariant &value)
+{
+    if (option == QImageIOHandler::Quality) {
+        bool ok = false;
+        auto q = value.toInt(&ok);
+        if (ok) {
+            m_quality = q;
+        }
+    }
+}
+
+bool RAWHandler::supportsOption(ImageOption option) const
+{
+#ifndef EXCLUDE_LibRaw_QIODevice
+    if (option == QImageIOHandler::Size) {
+        return true;
+    }
+#endif
+
+    if (option == QImageIOHandler::Quality) {
+        return true;
+    }
+
+    return false;
+}
+
+QVariant RAWHandler::option(ImageOption option) const
+{
+    QVariant v;
+
+#ifndef EXCLUDE_LibRaw_QIODevice
+    if (option == QImageIOHandler::Size) {
+        auto d = device();
+        d->startTransaction();
+        std::unique_ptr<LibRaw> rawProcessor(new LibRaw);
+        LibRaw_QIODevice stream(d);
+#if (LIBRAW_VERSION < LIBRAW_MAKE_VERSION(0, 21, 0))
+        rawProcessor->imgdata.params.shot_select = currentImageNumber();
+#else
+        rawProcessor->imgdata.rawparams.shot_select = currentImageNumber();
+#endif
+        if (rawProcessor->open_datastream(&stream) == LIBRAW_SUCCESS) {
+            if (rawProcessor->unpack() == LIBRAW_SUCCESS) {
+                auto w = libraw_get_iwidth(&rawProcessor->imgdata);
+                auto h = libraw_get_iheight(&rawProcessor->imgdata);
+                // flip & 4: taken from LibRaw code
+                v = (rawProcessor->imgdata.sizes.flip & 4) ? QSize(h, w) : QSize(w, h);
+            }
+        }
+        d->rollbackTransaction();
+    }
+#endif
+
+    if (option == QImageIOHandler::Quality) {
+        v = m_quality;
+    }
+
+    return v;
+}
+
+bool RAWHandler::jumpToNextImage()
+{
+    return jumpToImage(m_imageNumber + 1);
+}
+
+bool RAWHandler::jumpToImage(int imageNumber)
+{
+    if (imageNumber >= imageCount()) {
+        return false;
+    }
+    m_imageNumber = imageNumber;
+    return true;
+}
+
+int RAWHandler::imageCount() const
+{
+    // NOTE: image count is cached for performance reason
+    auto &&count = m_imageCount;
+    if (count > 0) {
+        return count;
+    }
+
+    count = QImageIOHandler::imageCount();
+
+#ifndef EXCLUDE_LibRaw_QIODevice
+    auto d = device();
+    d->startTransaction();
+
+    std::unique_ptr<LibRaw> rawProcessor(new LibRaw);
+    LibRaw_QIODevice stream(d);
+    if (rawProcessor->open_datastream(&stream) == LIBRAW_SUCCESS) {
+        count = rawProcessor->imgdata.rawdata.iparams.raw_count;
+    }
+
+    d->rollbackTransaction();
+#endif
+
+    return count;
+}
+
+int RAWHandler::currentImageNumber() const
+{
+    return m_imageNumber;
+}
+
+bool RAWHandler::canRead(QIODevice *device)
+{
+    device->startTransaction();
+
+    std::unique_ptr<LibRaw> rawProcessor(new LibRaw);
+
+#ifndef EXCLUDE_LibRaw_QIODevice
+    LibRaw_QIODevice stream(device);
+    auto ok = rawProcessor->open_datastream(&stream) == LIBRAW_SUCCESS;
+#else
+    auto ba = device->readAll();
+    auto ok = rawProcessor->open_buffer(ba.data(), ba.size()) == LIBRAW_SUCCESS;
+#endif
+
+    device->rollbackTransaction();
+    return ok;
+}
+
+QImageIOPlugin::Capabilities RAWPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (supported_formats.contains(QByteArray(format).toLower())) {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && RAWHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *RAWPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new RAWHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/raw.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Service
+X-KDE-ServiceTypes=QImageIOPlugins
+X-KDE-ImageFormat=3fr,arw,arq,bay,bmq,crw,cr2,cr3,cap,cine,cs1,dcs,dc2,dcr,dng,drf,dxo,eip,erf,fff,hdr,iiq,k25,kdc,kc2,mdc,mef,mfw,mos,mrw,nef,nrw,obm,orf,ori,pef,ptx,pxn,qtk,r3d,raf,raw,rdc,rwl,rw2,rwz,sr2,srf,srw,sti,x3f
+X-KDE-MimeType=image/x-hasselblad-3fr,image/x-sony-arw,image/x-arq,image/x-bay,image/x-bmq,image/x-canon-crw,image/x-canon-cr2,image/x-canon-cr3,image/x-cap,image/x-cine,image/x-cs1,image/x-kodak-dcs,image/x-dc2,image/x-kodak-dcr,image/x-adobe-dng,image/x-drf,image/x-dxo,image/x-epson-eip,image/x-epson-erf,image/x-fff,image/x-hdr,image/x-iiq,image/x-kodak-k25,image/x-kodak-kdc,image/x-kodak-kc2,image/x-minolta-mdc,image/x-mamiya-mef,image/x-mfw,image/x-aptus-mos,image/x-minolta-mrw,image/x-nikon-nef,image/x-nikon-nrw,image/x-obm,image/x-olympus-orf,image/x-ori,image/x-pentax-pef,image/x-ptx,image/x-pxn,image/x-qtk,image/x-r3d,image/x-fuji-raf,image/x-raw,image/x-rdc,image/x-rwl,image/x-panasonic-rw2,image/x-rwz,image/x-sony-sr2,image/x-sony-srf,image/x-samsung-srw,image/x-sti,image/x-sigma-x3f
+X-KDE-Read=true
+X-KDE-Write=false

src/imageformats/raw.json

@@ -0,0 +1,42 @@
+{
+    "Keys": [
+        "3fr",
+        "arw", "arq",
+        "bay", "bmq",
+        "crw", "cr2", "cr3", "cap", "cine", "cs1",
+        "dcs", "dc2", "dcr", "dng", "drf", "dxo",
+        "eip", "erf",
+        "fff",
+        "hdr",
+        "iiq",
+        "k25", "kdc", "kc2",
+        "mdc", "mef", "mfw", "mos", "mrw",
+        "nef", "nrw",
+        "obm", "orf", "ori",
+        "pef", "ptx", "pxn",
+        "qtk",
+        "r3d", "raf", "raw", "rdc", "rwl", "rw2", "rwz",
+        "sr2", "srf", "srw", "sti",
+        "x3f"
+    ],
+    "MimeTypes": [
+        "image/x-hasselblad-3fr",
+        "image/x-sony-arw", "image/x-arq",
+        "image/x-bay", "image/x-bmq",
+        "image/x-canon-crw", "image/x-canon-cr2", "image/x-canon-cr3", "image/x-cap", "image/x-cine", "image/x-cs1",
+        "image/x-kodak-dcs", "image/x-dc2", "image/x-kodak-dcr", "image/x-adobe-dng", "image/x-drf", "image/x-dxo",
+        "image/x-epson-eip", "image/x-epson-erf",
+        "image/x-fff",
+        "image/x-hdr",
+        "image/x-iiq",
+        "image/x-kodak-k25", "image/x-kodak-kdc", "image/x-kodak-kc2",
+        "image/x-minolta-mdc", "image/x-mamiya-mef", "image/x-mfw", "image/x-aptus-mos", "image/x-minolta-mrw",
+        "image/x-nikon-nef", "image/x-nikon-nrw",
+        "image/x-obm", "image/x-olympus-orf", "image/x-ori",
+        "image/x-pentax-pef", "image/x-ptx", "image/x-pxn",
+        "image/x-qtk",
+        "image/x-r3d", "image/x-fuji-raf", "image/x-raw", "image/x-rdc", "image/x-rwl", "image/x-panasonic-rw2", "image/x-rwz",
+        "image/x-sony-sr2", "image/x-sony-srf", "image/x-samsung-srw", "image/x-sti",
+        "image/x-sigma-x3f"
+    ]
+}

src/imageformats/raw_p.h

@@ -0,0 +1,93 @@
+/*
+    This file is part of the KDE project
+
+    SPDX-FileCopyrightText: 2022 Mirco Miranda <mircomir@outlook.com>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef KIMG_RAW_P_H
+#define KIMG_RAW_P_H
+
+#include <QImageIOPlugin>
+
+class RAWHandler : public QImageIOHandler
+{
+public:
+    RAWHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image) override;
+
+    void setOption(ImageOption option, const QVariant &value) override;
+    bool supportsOption(QImageIOHandler::ImageOption option) const override;
+    QVariant option(QImageIOHandler::ImageOption option) const override;
+
+    bool jumpToNextImage() override;
+    bool jumpToImage(int imageNumber) override;
+    int imageCount() const override;
+    int currentImageNumber() const override;
+
+    static bool canRead(QIODevice *device);
+
+private:
+    qint32 m_imageNumber;
+
+    mutable qint32 m_imageCount;
+
+    /**
+     * @brief m_quality
+     * Change the quality of the conversion. If -1, default quality is used.
+     * @note Verify that the quality change support has been compiled with supportsOption()
+     *
+     *   3                   2                 1           0
+     * 1 0 9 8 7 6 5 4 3 2 1 0 9 87 6 5 4 3 2 1098 7654 3210
+     * _ _ _ _ _ _ _ _ _ _ _ S F NN E H B A W CCCC IIII PPPP
+     *
+     * Where:
+     *
+     * _: reserved
+     * P: preset values: *** if set, other flags are ignored! ***
+     * -  0: Use other flags (no preset)
+     * -  1: I =  0, C = 1, B = 0, W = 1, A = 1, H = 1 (Linear, sRGB, 8-bits, Camera White, Auto White, Half-size)
+     * -  2: I =  0, C = 1, B = 0, W = 1, A = 1, H = 0 (Linear, sRGB, 8-bits, Camera White, Auto White)
+     * -  3: I =  3, C = 1, B = 0, W = 1, A = 1, H = 0 (AHD, sRGB, 8-bits, Camera White, Auto White)
+     * -  4: I =  3, C = 1, B = 1, W = 1, A = 1, H = 0 (AHD, sRGB, 16-bits, Camera White, Auto White)
+     * -  5: I =  3, C = 2, B = 1, W = 1, A = 1, H = 0 (AHD, Adobe, 16-bits, Camera White, Auto White)
+     * -  6: I =  3, C = 4, B = 1, W = 1, A = 1, H = 0 (AHD, ProPhoto, 16-bits, Camera White, Auto White)
+     * -  7: I = 11, C = 1, B = 0, W = 1, A = 1, H = 0 (DHT, sRGB, 8-bits, Camera White, Auto White)
+     * -  8: I = 11, C = 1, B = 1, W = 1, A = 1, H = 0 (DHT, sRGB, 16-bits, Camera White, Auto White)
+     * -  9: I = 11, C = 2, B = 1, W = 1, A = 1, H = 0 (DHT, Adobe, 16-bits, Camera White, Auto White)
+     * - 10: I = 11, C = 4, B = 1, W = 1, A = 1, H = 0 (DHT, ProPhoto, 16-bits, Camera White, Auto White)
+     * - 11: reserved
+     * - 12: reserved
+     * - 13: reserved
+     * - 14: reserved
+     * - 15: reserved
+     * I: interpolation quality (0 - linear, 1 - VNG, 2 - PPG, 3 - AHD, 4 - DCB, 11 - DHT, 12 - AAHD)
+     * C: output colorspace (0 - raw, 1 - sRGB, 2 - Adobe, 3 - Wide, 4 - ProPhoto, 5 - XYZ, 6 - ACES, 7 - DCI-P3, 8 - Rec2020)
+     * W: use camera white balace (0 - off, 1 - on)
+     * A: use auto white balance (0 - off, 1 - on)
+     * B: output bit per sample (0 - 8-bits, 1 - 16-bits)
+     * H: half size image (0 - off, 1 - on)
+     * E: DCB color enhance (0 - off, 1 - on)
+     * N: FBDD noise reduction (0 - off, 1 - light, 2 - full)
+     * F: Interpolate RGGB as four colors (0 - off, 1 - on)
+     * S: Don't stretch or rotate raw pixels (0 - rotate and stretch, 1 - don't rotate and stretch)
+     *
+     * @note It is safe to set both W and A: W is used if camera white balance is found, otherwise A is used.
+     */
+    qint32 m_quality;
+};
+
+class RAWPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "raw.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+#endif // KIMG_RAW_P_H

src/imageformats/rgb.cpp

@@ -20,6 +20,7 @@
  */
 
 #include "rgb_p.h"
+#include "util_p.h"
 
 #include <QMap>
 #include <QVector>
@@ -138,7 +139,8 @@ SGIImage::~SGIImage()
 
 bool SGIImage::getRow(uchar *dest)
 {
-    int n, i;
+    int n;
+    int i;
     if (!_rle) {
         for (i = 0; i < _xsize; i++) {
             if (_pos >= _data.end()) {
@@ -184,7 +186,8 @@ bool SGIImage::readData(QImage &img)
     quint32 *start = _starttab;
     QByteArray lguard(_xsize, 0);
     uchar *line = (uchar *)lguard.data();
-    unsigned x, y;
+    unsigned x;
+    unsigned y;
 
     if (!_rle) {
         _pos = _data.begin();
@@ -279,9 +282,9 @@ bool SGIImage::readImage(QImage &img)
     // bytes per channel
     _stream >> _bpc;
     //     qDebug() << "bytes per channel: " << int(_bpc);
-    if (_bpc == 1)
+    if (_bpc == 1) {
         ;
-    else if (_bpc == 2) {
+    } else if (_bpc == 2) {
         //         qDebug() << "dropping least significant byte";
     } else {
         return false;
@@ -322,14 +325,15 @@ bool SGIImage::readImage(QImage &img)
         return false;
     }
 
-    img = QImage(_xsize, _ysize, QImage::Format_RGB32);
+    img = imageAlloc(_xsize, _ysize, QImage::Format_RGB32);
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(_xsize, _ysize);
         return false;
     }
 
-    if (_zsize == 0)
+    if (_zsize == 0) {
         return false;
+    }
 
     if (_zsize == 2 || _zsize == 4) {
         img = img.convertToFormat(QImage::Format_ARGB32);
@@ -337,8 +341,9 @@ bool SGIImage::readImage(QImage &img)
         //         qDebug() << "using first 4 of " << _zsize << " channels";
         // Only let this continue if it won't cause a int overflow later
         // this is most likely a broken file anyway
-        if (_ysize > std::numeric_limits<int>::max() / _zsize)
+        if (_ysize > std::numeric_limits<int>::max() / _zsize) {
             return false;
+        }
     }
 
     _numrows = _ysize * _zsize;
@@ -363,13 +368,15 @@ bool SGIImage::readImage(QImage &img)
     _data = _dev->readAll();
 
     // sanity check
-    if (_rle)
-        for (uint o = 0; o < _numrows; o++)
+    if (_rle) {
+        for (uint o = 0; o < _numrows; o++) {
             // don't change to greater-or-equal!
             if (_starttab[o] + _lengthtab[o] > (uint)_data.size()) {
                 //                 qDebug() << "image corrupt (sanity check failed)";
                 return false;
             }
+        }
+    }
 
     if (!readData(img)) {
         //         qDebug() << "image corrupt (incomplete scanline)";
@@ -390,7 +397,8 @@ void RLEData::write(QDataStream &s)
 
 bool RLEData::operator<(const RLEData &b) const
 {
-    uchar ac, bc;
+    uchar ac;
+    uchar bc;
     for (int i = 0; i < qMin(size(), b.size()); i++) {
         ac = at(i);
         bc = b[i];
@@ -436,8 +444,13 @@ uchar SGIImage::intensity(uchar c)
 
 uint SGIImage::compact(uchar *d, uchar *s)
 {
-    uchar *dest = d, *src = s, patt, *t, *end = s + _xsize;
-    int i, n;
+    uchar *dest = d;
+    uchar *src = s;
+    uchar patt;
+    uchar *t;
+    uchar *end = s + _xsize;
+    int i;
+    int n;
     while (src < end) {
         for (n = 0, t = src; t + 2 < end && !(*t == t[1] && *t == t[2]); t++) {
             n++;
@@ -480,7 +493,8 @@ bool SGIImage::scanData(const QImage &img)
     uchar *line = (uchar *)lineguard.data();
     uchar *buf = (uchar *)bufguard.data();
     const QRgb *c;
-    unsigned x, y;
+    unsigned x;
+    unsigned y;
     uint len;
 
     for (y = 0; y < _ysize; y++) {
@@ -606,7 +620,8 @@ void SGIImage::writeVerbatim(const QImage &img)
     writeHeader();
 
     const QRgb *c;
-    unsigned x, y;
+    unsigned x;
+    unsigned y;
 
     for (y = 0; y < _ysize; y++) {
         c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
@@ -667,9 +682,16 @@ bool SGIImage::writeImage(const QImage &image)
         return false;
     }
 
+    const int w = img.width();
+    const int h = img.height();
+
+    if (w > 65536 || h > 65536) {
+        return false;
+    }
+
     _bpc = 1;
-    _xsize = img.width();
-    _ysize = img.height();
+    _xsize = w;
+    _ysize = h;
     _pixmin = ~0u;
     _pixmax = 0;
     _colormap = NORMAL;

src/imageformats/tga.cpp

@@ -17,6 +17,7 @@
  */
 
 #include "tga_p.h"
+#include "util_p.h"
 
 #include <assert.h>
 
@@ -172,7 +173,7 @@ struct TgaHeaderInfo {
 static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
 {
     // Create image.
-    img = QImage(tga.width, tga.height, QImage::Format_RGB32);
+    img = imageAlloc(tga.width, tga.height, QImage::Format_RGB32);
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(tga.width, tga.height);
         return false;
@@ -184,7 +185,7 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
     const int numAlphaBits = tga.flags & 0xf;
     // However alpha exists only in the 32 bit format.
     if ((tga.pixel_size == 32) && (tga.flags & 0xf)) {
-        img = QImage(tga.width, tga.height, QImage::Format_ARGB32);
+        img = imageAlloc(tga.width, tga.height, QImage::Format_ARGB32);
         if (img.isNull()) {
             qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(tga.width, tga.height);
             return false;
@@ -311,7 +312,9 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
     }
 
     // Convert image to internal format.
-    int y_start, y_step, y_end;
+    int y_start;
+    int y_step;
+    int y_end;
     if (tga.flags & TGA_ORIGIN_UPPER) {
         y_start = 0;
         y_step = 1;
@@ -437,7 +440,7 @@ bool TGAHandler::write(const QImage &image)
     s << quint8(hasAlpha ? 32 : 24); // depth (24 bit RGB + 8 bit alpha)
     s << quint8(hasAlpha ? 0x24 : 0x20); // top left image (0x20) + 8 bit alpha (0x4)
 
-    for (int y = 0; y < img.height(); y++)
+    for (int y = 0; y < img.height(); y++) {
         for (int x = 0; x < img.width(); x++) {
             const QRgb color = img.pixel(x, y);
             s << quint8(qBlue(color));
@@ -447,6 +450,7 @@ bool TGAHandler::write(const QImage &image)
                 s << quint8(qAlpha(color));
             }
         }
+    }
 
     return true;
 }

src/imageformats/util_p.h

@@ -0,0 +1,42 @@
+/*
+    SPDX-FileCopyrightText: 2022 Albert Astals Cid <aacid@kde.org>
+    SPDX-FileCopyrightText: 2022 Mirco Miranda <mircomir@outlook.com>
+
+    SPDX-License-Identifier: LGPL-2.0-or-later
+*/
+
+#ifndef UTIL_P_H
+#define UTIL_P_H
+
+#include <limits>
+
+#include <QImage>
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#include <QImageIOHandler>
+#endif
+
+// QVector uses some extra space for stuff, hence the 32 here suggested by Thiago Macieira
+static constexpr int kMaxQVectorSize = std::numeric_limits<int>::max() - 32;
+
+// On Qt 6 to make the plugins fail to allocate if the image size is greater than QImageReader::allocationLimit()
+// it is necessary to allocate the image with QImageIOHandler::allocateImage().
+inline QImage imageAlloc(const QSize &size, const QImage::Format &format)
+{
+    QImage img;
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    img = QImage(size, format);
+#else
+    if (!QImageIOHandler::allocateImage(size, format, &img)) {
+        img = QImage(); // paranoia
+    }
+#endif
+    return img;
+}
+
+inline QImage imageAlloc(qint32 width, qint32 height, const QImage::Format &format)
+{
+    return imageAlloc(QSize(width, height), format);
+}
+
+#endif // UTIL_P_H

src/imageformats/xcf.cpp

@@ -6,6 +6,7 @@
     SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
+#include "util_p.h"
 #include "xcf_p.h"
 
 #include <QDebug>
@@ -16,8 +17,12 @@
 #include <QStack>
 #include <QVector>
 #include <QtEndian>
-#include <stdlib.h>
+#include <QColorSpace>
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#include <QImageReader>
+#endif
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "gimp_p.h"
@@ -134,7 +139,7 @@ public:
         PROP_SAMPLE_POINTS = 39,
         MAX_SUPPORTED_PROPTYPE, // should always be at the end so its value is last + 1
     };
-    Q_ENUM(PropType);
+    Q_ENUM(PropType)
 
     //! Compression type used in layer tiles.
     enum XcfCompressionType {
@@ -144,7 +149,7 @@ public:
         COMPRESS_ZLIB = 2, /* unused */
         COMPRESS_FRACTAL = 3, /* unused */
     };
-    Q_ENUM(XcfCompressionType);
+    Q_ENUM(XcfCompressionType)
 
     enum LayerModeType {
         GIMP_LAYER_MODE_NORMAL_LEGACY,
@@ -211,7 +216,7 @@ public:
         GIMP_LAYER_MODE_PASS_THROUGH,
         GIMP_LAYER_MODE_COUNT,
     };
-    Q_ENUM(LayerModeType);
+    Q_ENUM(LayerModeType)
 
     //! Type of individual layers in an XCF file.
     enum GimpImageType {
@@ -222,7 +227,7 @@ public:
         INDEXED_GIMAGE,
         INDEXEDA_GIMAGE,
     };
-    Q_ENUM(GimpImageType);
+    Q_ENUM(GimpImageType)
 
     //! Type of individual layers in an XCF file.
     enum GimpColorSpace {
@@ -351,6 +356,8 @@ private:
         bool initialized; //!< Is the QImage initialized?
         QImage image; //!< final QImage
 
+        QHash<QString,QByteArray> parasites;    //!< parasites data
+
         XCFImage(void)
             : initialized(false)
         {
@@ -405,6 +412,7 @@ private:
     bool composeTiles(XCFImage &xcf_image);
     void setGrayPalette(QImage &image);
     void setPalette(XCFImage &xcf_image, QImage &image);
+    void setImageParasites(const XCFImage &xcf_image, QImage &image);
     static void assignImageBytes(Layer &layer, uint i, uint j);
     bool loadHierarchy(QDataStream &xcf_io, Layer &layer);
     bool loadLevel(QDataStream &xcf_io, Layer &layer, qint32 bpp);
@@ -665,6 +673,9 @@ bool XCFImageFormat::readXCF(QIODevice *device, QImage *outImage)
         return false;
     }
 
+    // The image was created: now I can set metadata and ICC color profile inside it.
+    setImageParasites(xcf_image, xcf_image.image);
+
     *outImage = xcf_image.image;
     return true;
 }
@@ -715,15 +726,15 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
                 property.readBytes(tag, size);
 
                 quint32 flags;
-                char *data = nullptr;
+                QByteArray data;
                 property >> flags >> data;
 
-                if (tag && strncmp(tag, "gimp-comment", strlen("gimp-comment")) == 0) {
-                    xcf_image.image.setText(QStringLiteral("Comment"), QString::fromUtf8(data));
-                }
+                // WARNING: you cannot add metadata to QImage here because it can be null.
+                // Adding a metadata to a QImage when it is null, does nothing (metas are lost).
+                if(tag) // store metadata for future use
+                    xcf_image.parasites.insert(QString::fromUtf8(tag), data);
 
                 delete[] tag;
-                delete[] data;
             }
             break;
 
@@ -747,7 +758,9 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
             xcf_image.palette.reserve(xcf_image.num_colors);
 
             for (int i = 0; i < xcf_image.num_colors; i++) {
-                uchar r, g, b;
+                uchar r;
+                uchar g;
+                uchar b;
                 property >> r >> g >> b;
                 xcf_image.palette.push_back(qRgb(r, g, b));
             }
@@ -1084,12 +1097,27 @@ bool XCFImageFormat::composeTiles(XCFImage &xcf_image)
     qCDebug(XCFPLUGIN) << "LAYER: height=" << layer.height << ", width=" << layer.width;
     qCDebug(XCFPLUGIN) << "LAYER: rows=" << layer.nrows << ", columns=" << layer.ncols;
 
+    // NOTE: starting from GIMP 2.10, images can be very large. The 32K limit for width and height is obsolete
+    //       and it was changed to 300000 (the same as Photoshop Big image). This plugin was able to open an RGB
+    //       image of 108000x40000 pixels saved with GIMP 2.10
     // SANITY CHECK: Catch corrupted XCF image file where the width or height
     // of a tile is reported are bogus. See Bug# 234030.
-    if (layer.width > 32767 || layer.height > 32767 || (sizeof(void *) == 4 && layer.width * layer.height > 16384 * 16384)) {
+    if (layer.width > 300000 || layer.height > 300000 || (sizeof(void *) == 4 && layer.width * layer.height > 16384 * 16384)) {
         return false;
     }
 
+    // Qt 6 image allocation limit calculation: we have to check the limit here because the image is splitted in
+    // tiles of 64x64 pixels. The required memory to build the image is at least doubled because tiles are loaded
+    // and then the final image is created by copying the tiles inside it.
+    // NOTE: on Windows to open a 10GiB image the plugin uses 28GiB of RAM
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    qint64 channels = 1 + (layer.type == RGB_GIMAGE ? 2 : 0) + (layer.type == RGBA_GIMAGE ? 3 : 0);
+    if (qint64(layer.width) * qint64(layer.height) * channels * 2ll / 1024ll / 1024ll > QImageReader::allocationLimit()) {
+        qCDebug(XCFPLUGIN) << "Rejecting image as it exceeds the current allocation limit of" << QImageReader::allocationLimit() << "megabytes";
+        return false;
+    }
+#endif
+
     layer.image_tiles.resize(layer.nrows);
 
     if (layer.type == GRAYA_GIMAGE || layer.type == INDEXEDA_GIMAGE) {
@@ -1232,6 +1260,77 @@ void XCFImageFormat::setPalette(XCFImage &xcf_image, QImage &image)
     image.setColorTable(xcf_image.palette);
 }
 
+/*!
+ * Copy the parasites info to QImage.
+ * \param xcf_image XCF image containing the parasites read from the data stream.
+ * \param image image to apply the parasites data.
+ * \note Some comment taken from https://gitlab.gnome.org/GNOME/gimp/-/blob/master/devel-docs/parasites.txt
+ */
+void XCFImageFormat::setImageParasites(const XCFImage &xcf_image, QImage &image)
+{
+    auto&& p = xcf_image.parasites;
+    auto keys = p.keys();
+    for (auto &&key : std::as_const(keys)) {
+        auto value = p.value(key);
+        if(value.isEmpty())
+            continue;
+
+        // "icc-profile" (IMAGE, PERSISTENT | UNDOABLE)
+        //     This contains an ICC profile describing the color space the
+        //     image was produced in. TIFF images stored in PhotoShop do
+        //     oftentimes contain embedded profiles. An experimental color
+        //     manager exists to use this parasite, and it will be used
+        //     for interchange between TIFF and PNG (identical profiles)
+        if (key == QStringLiteral("icc-profile")) {
+            auto cs = QColorSpace::fromIccProfile(value);
+            if(cs.isValid())
+                image.setColorSpace(cs);
+            continue;
+        }
+
+        // "gimp-comment" (IMAGE, PERSISTENT)
+        //    Standard GIF-style image comments.  This parasite should be
+        //    human-readable text in UTF-8 encoding.  A trailing \0 might
+        //    be included and is not part of the comment.  Note that image
+        //    comments may also be present in the "gimp-metadata" parasite.
+        if (key == QStringLiteral("gimp-comment")) {
+            value.replace('\0', QByteArray());
+            image.setText(QStringLiteral("Comment"), QString::fromUtf8(value));
+            continue;
+        }
+
+        // "gimp-image-metadata"
+        //     Saved by GIMP 2.10.30 but it is not mentioned in the specification.
+        //     It is an XML block with the properties set using GIMP.
+        if (key == QStringLiteral("gimp-image-metadata")) {
+            // NOTE: I arbitrary defined the metadata "XML:org.gimp.xml" because it seems
+            //       a GIMP proprietary XML format (no xmlns defined)
+            value.replace('\0', QByteArray());
+            image.setText(QStringLiteral("XML:org.gimp.xml"), QString::fromUtf8(value));
+            continue;
+        }
+
+#if 0   // Unable to generate it using latest GIMP version
+        // "gimp-metadata" (IMAGE, PERSISTENT)
+        //     The metadata associated with the image, serialized as one XMP
+        //     packet.  This metadata includes the contents of any XMP, EXIF
+        //     and IPTC blocks from the original image, as well as
+        //     user-specified values such as image comment, copyright,
+        //     license, etc.
+        if (key == QStringLiteral("gimp-metadata")) {
+            // NOTE: "XML:com.adobe.xmp" is the meta set by Qt reader when an
+            //       XMP packet is found (e.g. when reading a PNG saved by Photoshop).
+            //       I reused the same key because some programs could search for it.
+            value.replace('\0', QByteArray());
+            image.setText(QStringLiteral("XML:com.adobe.xmp"), QString::fromUtf8(value));
+            continue;
+        }
+#endif
+
+    }
+}
+
+
 /*!
  * Copy the bytes from the tile buffer into the image tile QImage, taking into
  * account all the myriad different modes.
@@ -1837,7 +1936,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
     switch (layer.type) {
     case RGB_GIMAGE:
         if (layer.opacity == OPAQUE_OPACITY) {
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_RGB32);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_RGB32);
             if (image.isNull()) {
                 return false;
             }
@@ -1846,7 +1945,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
         } // else, fall through to 32-bit representation
         Q_FALLTHROUGH();
     case RGBA_GIMAGE:
-        image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
+        image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
         if (image.isNull()) {
             return false;
         }
@@ -1855,7 +1954,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
 
     case GRAY_GIMAGE:
         if (layer.opacity == OPAQUE_OPACITY) {
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_Indexed8);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_Indexed8);
             image.setColorCount(256);
             if (image.isNull()) {
                 return false;
@@ -1866,7 +1965,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
         } // else, fall through to 32-bit representation
         Q_FALLTHROUGH();
     case GRAYA_GIMAGE:
-        image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
+        image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
         if (image.isNull()) {
             return false;
         }
@@ -1887,7 +1986,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
         // or two-color palette. Have to ask about this...
 
         if (xcf_image.num_colors <= 2) {
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_MonoLSB);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_MonoLSB);
             image.setColorCount(xcf_image.num_colors);
             if (image.isNull()) {
                 return false;
@@ -1895,7 +1994,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
             image.fill(0);
             setPalette(xcf_image, image);
         } else if (xcf_image.num_colors <= 256) {
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_Indexed8);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_Indexed8);
             image.setColorCount(xcf_image.num_colors);
             if (image.isNull()) {
                 return false;
@@ -1913,7 +2012,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
             xcf_image.palette[1] = xcf_image.palette[0];
             xcf_image.palette[0] = qRgba(255, 255, 255, 0);
 
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_MonoLSB);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_MonoLSB);
             image.setColorCount(xcf_image.num_colors);
             if (image.isNull()) {
                 return false;
@@ -1929,7 +2028,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
             }
 
             xcf_image.palette[0] = qRgba(255, 255, 255, 0);
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_Indexed8);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_Indexed8);
             image.setColorCount(xcf_image.num_colors);
             if (image.isNull()) {
                 return false;
@@ -1940,7 +2039,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
             // No room for a transparent color, so this has to be promoted to
             // true color. (There is no equivalent PNG representation output
             // from The GIMP as of v1.2.)
-            image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
+            image = imageAlloc(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
             if (image.isNull()) {
                 return false;
             }
@@ -1951,11 +2050,13 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
 
     if (xcf_image.x_resolution > 0 && xcf_image.y_resolution > 0) {
         const float dpmx = xcf_image.x_resolution * INCHESPERMETER;
-        if (dpmx > std::numeric_limits<int>::max())
+        if (dpmx > float(std::numeric_limits<int>::max())) {
             return false;
+        }
         const float dpmy = xcf_image.y_resolution * INCHESPERMETER;
-        if (dpmy > std::numeric_limits<int>::max())
+        if (dpmy > float(std::numeric_limits<int>::max())) {
             return false;
+        }
         image.setDotsPerMeterX((int)dpmx);
         image.setDotsPerMeterY((int)dpmy);
     }
@@ -2639,7 +2740,8 @@ void XCFImageFormat::mergeRGBToRGB(const Layer &layer, uint i, uint j, int k, in
         src_a = qMin(src_a, dst_a);
     } break;
     case GIMP_LAYER_MODE_SOFTLIGHT_LEGACY: {
-        uint tmpS, tmpM;
+        uint tmpS;
+        uint tmpM;
 
         tmpM = INT_MULT(dst_r, src_r);
         tmpS = 255 - INT_MULT((255 - dst_r), (255 - src_r));
@@ -2707,7 +2809,10 @@ void XCFImageFormat::mergeRGBToRGB(const Layer &layer, uint i, uint j, int k, in
         src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
     }
 
-    uchar new_r, new_g, new_b, new_a;
+    uchar new_r;
+    uchar new_g;
+    uchar new_b;
+    uchar new_a;
     new_a = dst_a + INT_MULT(OPAQUE_OPACITY - dst_a, src_a);
 
     const float src_ratio = new_a == 0 ? 1.0 : (float)src_a / new_a;
@@ -2813,7 +2918,8 @@ void XCFImageFormat::mergeGrayAToGray(const Layer &layer, uint i, uint j, int k,
         }
     } break;
     case SOFTLIGHT_MODE: {
-        uint tmpS, tmpM;
+        uint tmpS;
+        uint tmpM;
 
         tmpM = INT_MULT(dst, src);
         tmpS = 255 - INT_MULT((255 - dst), (255 - src));
@@ -2965,7 +3071,8 @@ void XCFImageFormat::mergeGrayAToRGB(const Layer &layer, uint i, uint j, int k,
         src_a = qMin(src_a, dst_a);
     } break;
     case SOFTLIGHT_MODE: {
-        uint tmpS, tmpM;
+        uint tmpS;
+        uint tmpM;
 
         tmpM = INT_MULT(dst, src);
         tmpS = 255 - INT_MULT((255 - dst), (255 - src));
@@ -3182,6 +3289,52 @@ bool XCFHandler::write(const QImage &)
     return false;
 }
 
+bool XCFHandler::supportsOption(ImageOption option) const
+{
+    if (option == QImageIOHandler::Size)
+        return true;
+    return false;
+}
+
+QVariant XCFHandler::option(ImageOption option) const
+{
+    QVariant v;
+
+    if (option == QImageIOHandler::Size) {
+        /*
+         * The image structure always starts at offset 0 in the XCF file.
+         * byte[9]     "gimp xcf " File type identification
+         * byte[4]     version     XCF version
+         *                          "file": version 0
+         *                          "v001": version 1
+         *                          "v002": version 2
+         *                          "v003": version 3
+         * byte        0            Zero marks the end of the version tag.
+         * uint32      width        Width of canvas
+         * uint32      height       Height of canvas
+         */
+        if (auto d = device()) {
+            // transactions works on both random and sequential devices
+            d->startTransaction();
+            auto ba9 = d->read(9);      // "gimp xcf "
+            auto ba5 = d->read(4+1);    // version + null terminator
+            auto ba = d->read(8);       // width and height
+            d->rollbackTransaction();
+            if (ba9 == QByteArray("gimp xcf ") && ba5.size() == 5) {
+                QDataStream ds(ba);
+                quint32 width;
+                ds >> width;
+                quint32 height;
+                ds >> height;
+                if (ds.status() == QDataStream::Ok)
+                    v = QVariant::fromValue(QSize(width, height));
+            }
+        }
+    }
+
+    return v;
+}
+
 bool XCFHandler::canRead(QIODevice *device)
 {
     if (!device) {

src/imageformats/xcf_p.h

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

tests/CMakeLists.txt

@@ -5,7 +5,7 @@ include(ECMMarkAsTest)
 macro(kimageformats_executable_tests)
     foreach(_testname ${ARGN})
         add_executable(${_testname} ${_testname}.cpp)
-        target_link_libraries(${_testname} Qt5::Gui)
+        target_link_libraries(${_testname} Qt${QT_MAJOR_VERSION}::Gui)
         ecm_mark_as_test(${_testname})
     endforeach(_testname)
 endmacro()