QImage: use rvalue overloads more

to reuse internal buffers

.git-blame-ignore-revs

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

.gitattributes

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

.gitignore

@@ -22,3 +22,7 @@ CMakeLists.txt.user*
 .cmake/
 /.clang-format
 /compile_commands.json
+.clangd
+.idea
+/cmake-build*
+.cache

.gitlab-ci.yml

@@ -0,0 +1,8 @@
+# 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-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/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

@@ -1,29 +1,29 @@
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.16)
 
 project(KImageFormats)
 
-set (CMAKE_CXX_STANDARD 14)
-
 include(FeatureSummary)
-find_package(ECM 5.80.0  NO_MODULE)
+find_package(ECM 5.240.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.14.0)
-find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
+set(REQUIRED_QT_VERSION 6.5.0)
+find_package(Qt6Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
-find_package(KF5Archive)
-set_package_properties(KF5Archive PROPERTIES
+find_package(KF6Archive)
+set_package_properties(KF6Archive PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Required for the QImage plugin for Krita and OpenRaster images"
 )
@@ -32,23 +32,29 @@ 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(Qt6PrintSupport ${REQUIRED_QT_VERSION} NO_MODULE)
+    set_package_properties(Qt6PrintSupport PROPERTIES
         PURPOSE "Required for the QImage plugin for EPS images"
         TYPE OPTIONAL
     )
-    if (Qt5PrintSupport_FOUND)
+    if (TARGET Qt6::PrintSupport)
         set(BUILD_EPS_PLUGIN TRUE)
     endif()
 endif()
 
-find_package(OpenEXR)
+find_package(OpenEXR 3.0 CONFIG QUIET)
+if(NOT OpenEXR_FOUND)
+    find_package(OpenEXR)
+endif()
 set_package_properties(OpenEXR PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Required for the QImage plugin for OpenEXR images"
 )
 
-find_package(libavif 0.8.2 CONFIG)
+find_package(libavif 0.8.2 CONFIG QUIET)
+if(NOT libavif_FOUND)
+    find_package(libavif 1 CONFIG)
+endif()
 set_package_properties(libavif PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Required for the QImage plugin for AVIF images"
@@ -56,16 +62,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")
 
-add_definitions(-DQT_NO_FOREACH)
-# 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=0x050e00)
-add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054F00)
+option(KIMAGEFORMATS_JXL "Enable plugin for JPEG XL format" ON)
+if(KIMAGEFORMATS_JXL)
+    pkg_check_modules(LibJXL IMPORTED_TARGET libjxl>=0.7.0)
+    pkg_check_modules(LibJXLThreads IMPORTED_TARGET libjxl_threads>=0.7.0)
+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 6.4
+    KF 5.102
+)
+
 add_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)
@@ -73,3 +92,5 @@ if (BUILD_TESTING)
 endif()
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
+
+kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)

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

@@ -14,20 +14,26 @@ image formats.
 The following image formats have read-only support:
 
 - Animated Windows cursors (ani)
+- Camera RAW images (arw, cr2, cr3, dcs, dng, ...)
 - Gimp (xcf)
+- Krita (kra)
 - OpenEXR (exr)
-- Photoshop documents (psd)
-- Sun Raster (ras)
+- OpenRaster (ora)
+- Photoshop documents (psd, psb, pdd, psdt)
+- Radiance HDR (hdr)
+- Sun Raster (im1, im8, im24, im32, ras, sun)
 
 The following image formats have read and write support:
 
 - AV1 Image File Format (AVIF)
 - Encapsulated PostScript (eps)
+- High Efficiency Image File Format (heif). Can be enabled with the KIMAGEFORMATS_HEIF build option.
+- JPEG XL (jxl)
 - Personal Computer Exchange (pcx)
+- Quite OK Image format (qoi)
 - SGI images (rgb, rgba, sgi, bw)
 - Softimage PIC (pic)
 - Targa (tga): supports more formats than Qt's version
-- XView (xv)
 
 ## Contributing
 

autotests/CMakeLists.txt

@@ -1,7 +1,4 @@
-#find_package(Qt5Test ${REQUIRED_QT_VERSION} NO_MODULE)
-
 include(ECMMarkAsTest)
-include(CMakeParseArguments)
 
 add_definitions(-DPLUGIN_DIR="${CMAKE_CURRENT_BINARY_DIR}/../bin")
 remove_definitions(-DQT_NO_CAST_FROM_ASCII)
@@ -15,7 +12,7 @@ macro(kimageformats_read_tests)
 
     if (NOT TARGET readtest)
         add_executable(readtest readtest.cpp)
-        target_link_libraries(readtest Qt5::Gui)
+        target_link_libraries(readtest Qt6::Gui)
         target_compile_definitions(readtest
             PRIVATE IMAGEDIR="${CMAKE_CURRENT_SOURCE_DIR}/read")
         ecm_mark_as_test(readtest)
@@ -30,23 +27,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 Qt6::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()
@@ -58,12 +67,13 @@ kimageformats_read_tests(
     hdr
     pcx
     psd
+    qoi
     ras
     rgb
     tga
 )
 
-if (KF5Archive_FOUND)
+if (KF6Archive_FOUND)
     kimageformats_read_tests(
         kra
         ora
@@ -74,12 +84,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
@@ -97,6 +123,7 @@ kimageformats_read_tests(FUZZ 1
 kimageformats_write_tests(
     pcx-lossless
     pic-lossless
+    qoi-lossless
     rgb-lossless
     tga # fixme: the alpha images appear not to be written properly
 )
@@ -108,22 +135,30 @@ kimageformats_write_tests(
 #    kimageformats_write_tests(eps)
 #endif()
 if (OpenEXR_FOUND)
-    # FIXME: OpenEXR tests
+    kimageformats_read_tests(
+        exr
+    )
 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(Qt6Test ${REQUIRED_QT_VERSION} CONFIG QUIET)
+
+if(NOT TARGET Qt6::Test)
+    message(STATUS "Qt6Test 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 Qt6::Gui Qt6::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 Qt6::Gui Qt6::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/pictest.cpp

@@ -35,61 +35,27 @@ private:
         QTest::addColumn<QImage::Format>("pngformat");
         QTest::addColumn<bool>("compress");
 
-        QTest::newRow("4x4 no alpha RLE")
-            << QFINDTESTDATA("pic/4x4-simple-color.pic")
-            << QFINDTESTDATA("pic/4x4-simple-color.png")
-            << QString()
-            << false
-            << QImage::Format_RGB32
-            << true;
+        QTest::newRow("4x4 no alpha RLE") << QFINDTESTDATA("pic/4x4-simple-color.pic") << QFINDTESTDATA("pic/4x4-simple-color.png") << QString() << false
+                                          << QImage::Format_RGB32 << true;
 
-        QTest::newRow("4x4 no alpha raw")
-            << QFINDTESTDATA("pic/4x4-simple-color-uncompressed.pic")
-            << QFINDTESTDATA("pic/4x4-simple-color.png")
-            << QString()
-            << false
-            << QImage::Format_RGB32
-            << false;
+        QTest::newRow("4x4 no alpha raw") << QFINDTESTDATA("pic/4x4-simple-color-uncompressed.pic") << QFINDTESTDATA("pic/4x4-simple-color.png") << QString()
+                                          << false << QImage::Format_RGB32 << false;
 
-        QTest::newRow("Short comment")
-            << QFINDTESTDATA("pic/short-comment.pic")
-            << QFINDTESTDATA("pic/4x4-simple-color.png")
-            << QStringLiteral("Test comment value")
-            << false
-            << QImage::Format_RGB32
-            << true;
+        QTest::newRow("Short comment") << QFINDTESTDATA("pic/short-comment.pic") << QFINDTESTDATA("pic/4x4-simple-color.png")
+                                       << QStringLiteral("Test comment value") << false << QImage::Format_RGB32 << true;
 
-        QTest::newRow("Long comment")
-            << QFINDTESTDATA("pic/long-comment.pic")
-            << QFINDTESTDATA("pic/4x4-simple-color.png")
-            << QStringLiteral("Test comment value that goes right up to the end of the comment field and has no")
-            << false
-            << QImage::Format_RGB32
-            << true;
+        QTest::newRow("Long comment") << QFINDTESTDATA("pic/long-comment.pic") << QFINDTESTDATA("pic/4x4-simple-color.png")
+                                      << QStringLiteral("Test comment value that goes right up to the end of the comment field and has no") << false
+                                      << QImage::Format_RGB32 << true;
 
-        QTest::newRow("Long run-lengths")
-            << QFINDTESTDATA("pic/long-runs.pic")
-            << QFINDTESTDATA("pic/long-runs.png")
-            << QString()
-            << false
-            << QImage::Format_RGB32
-            << true;
+        QTest::newRow("Long run-lengths") << QFINDTESTDATA("pic/long-runs.pic") << QFINDTESTDATA("pic/long-runs.png") << QString() << false
+                                          << QImage::Format_RGB32 << true;
 
-        QTest::newRow("4x4 with alpha RLE")
-            << QFINDTESTDATA("pic/4x4-alpha.pic")
-            << QFINDTESTDATA("pic/4x4-alpha.png")
-            << QString()
-            << true
-            << QImage::Format_ARGB32
-            << true;
+        QTest::newRow("4x4 with alpha RLE") << QFINDTESTDATA("pic/4x4-alpha.pic") << QFINDTESTDATA("pic/4x4-alpha.png") << QString() << true
+                                            << QImage::Format_ARGB32 << true;
 
-        QTest::newRow("4x4 with alpha raw")
-            << QFINDTESTDATA("pic/4x4-alpha-uncompressed.pic")
-            << QFINDTESTDATA("pic/4x4-alpha.png")
-            << QString()
-            << true
-            << QImage::Format_ARGB32
-            << false;
+        QTest::newRow("4x4 with alpha raw") << QFINDTESTDATA("pic/4x4-alpha-uncompressed.pic") << QFINDTESTDATA("pic/4x4-alpha.png") << QString() << true
+                                            << QImage::Format_ARGB32 << false;
     }
 
 private Q_SLOTS:
@@ -106,13 +72,8 @@ private Q_SLOTS:
         //     so there is no actual data loss in converting to RGB16.
         //     This just tests that the pic plugin can deal with different
         //     input formats.
-        QTest::newRow("altered format")
-            << QFINDTESTDATA("pic/4x4-simple-color.pic")
-            << QFINDTESTDATA("pic/4x4-simple-color.png")
-            << QString()
-            << false
-            << QImage::Format_RGB16
-            << true;
+        QTest::newRow("altered format") << QFINDTESTDATA("pic/4x4-simple-color.pic") << QFINDTESTDATA("pic/4x4-simple-color.png") << QString() << false
+                                        << QImage::Format_RGB16 << true;
     }
 
     void testRead_data()
@@ -148,17 +109,12 @@ private Q_SLOTS:
         imgWriter.write(pngImage);
 
         if (expData != picData) {
-            QString fileNameBase = QUuid::createUuid().toString()
-                .remove(QLatin1Char('{'))
-                .remove(QLatin1Char('}'));
+            QString fileNameBase = QUuid::createUuid().toString().remove(QLatin1Char('{')).remove(QLatin1Char('}'));
             QFile dumpFile(fileNameBase + QStringLiteral(".pic"));
             QVERIFY2(dumpFile.open(QIODevice::WriteOnly), qPrintable(dumpFile.errorString()));
             dumpFile.write(picData);
-            QString msg = QStringLiteral("Written data (")
-                        + dumpFile.fileName()
-                        + QStringLiteral(") differed from expected data (")
-                        + picfile
-                        + QLatin1Char(')');
+            QString msg =
+                QStringLiteral("Written data (") + dumpFile.fileName() + QStringLiteral(") differed from expected data (") + picfile + QLatin1Char(')');
             QFAIL(qPrintable(msg));
         }
     }
@@ -182,29 +138,20 @@ private Q_SLOTS:
         QCOMPARE(inputImage.width(), expImage.width());
         QCOMPARE(inputImage.height(), expImage.height());
         QCOMPARE(inputImage.hasAlphaChannel(), alpha);
-        QCOMPARE(inputImage.format(), alpha ? QImage::Format_ARGB32
-                                            : QImage::Format_RGB32);
+        QCOMPARE(inputImage.format(), alpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
 
         expImage = expImage.convertToFormat(pngformat);
-        expImage = expImage.convertToFormat(alpha ? QImage::Format_ARGB32
-                                                  : QImage::Format_RGB32);
+        expImage = expImage.convertToFormat(alpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
         if (inputImage != expImage) {
-            QString fileNameBase = QUuid::createUuid().toString()
-                .remove(QLatin1Char('{'))
-                .remove(QLatin1Char('}'));
+            QString fileNameBase = QUuid::createUuid().toString().remove(QLatin1Char('{')).remove(QLatin1Char('}'));
             QFile picDumpFile(fileNameBase + QStringLiteral("-expected.data"));
             QVERIFY2(picDumpFile.open(QIODevice::WriteOnly), qPrintable(picDumpFile.errorString()));
-            picDumpFile.write(reinterpret_cast<const char *>(inputImage.bits()),
-                              inputImage.sizeInBytes());
+            picDumpFile.write(reinterpret_cast<const char *>(inputImage.bits()), inputImage.sizeInBytes());
             QFile pngDumpFile(fileNameBase + QStringLiteral("-actual.data"));
             QVERIFY2(pngDumpFile.open(QIODevice::WriteOnly), qPrintable(pngDumpFile.errorString()));
-            pngDumpFile.write(reinterpret_cast<const char *>(expImage.bits()),
-                              expImage.sizeInBytes());
-            QString msg = QStringLiteral("Read image (")
-                        + picDumpFile.fileName()
-                        + QStringLiteral(") differed from expected image (")
-                        + pngDumpFile.fileName()
-                        + QLatin1Char(')');
+            pngDumpFile.write(reinterpret_cast<const char *>(expImage.bits()), expImage.sizeInBytes());
+            QString msg = QStringLiteral("Read image (") + picDumpFile.fileName() + QStringLiteral(") differed from expected image (") + pngDumpFile.fileName()
+                + QLatin1Char(')');
             QFAIL(qPrintable(msg));
         }
     }
@@ -252,8 +199,7 @@ private Q_SLOTS:
 
         QImageReader inputReader(picfile, "pic");
 
-        QCOMPARE(inputReader.imageFormat(),
-                 alpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
+        QCOMPARE(inputReader.imageFormat(), alpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
     }
 };