Update dependency version to 6.30.0

unique_ptr will call delete which is not the right thing to do with
memory allocated with new[]

BUGS: 525120

.gitlab-ci.yml

@@ -12,10 +12,11 @@ include:
       - /gitlab-templates/windows-qt6.yml
       - /gitlab-templates/xml-lint.yml
       - /gitlab-templates/yaml-lint.yml
+      - /gitlab-templates/oss-fuzz.yml
 
 image_json_validate:
   stage: validate
-  image: invent-registry.kde.org/sysadmin/ci-images/suse-qt68:latest
+  image: invent-registry.kde.org/sysadmin/ci-images/suse-qt611:latest
   tags:
     - Linux
   script:

.kde-ci.yml

@@ -7,5 +7,5 @@ Dependencies:
 Options:
  test-before-installing: True
  require-passing-tests-on: ['Linux', 'FreeBSD', 'Windows']
- cmake-options: "-DKIMAGEFORMATS_DDS=ON -DKIMAGEFORMATS_JXR=ON"
+ cmake-options: "-DKIMAGEFORMATS_WITH_KNOWN_CRASHES_JXR=ON -DKIMAGEFORMATS_HEIF=ON -DKIMAGEFORMATS_HEIC_TEST:STRING=OFF -DKIMAGEFORMATS_HEIF_TEST:STRING=OFF -DKIMAGEFORMATS_HEJ2_TEST:STRING=OFF -DKIMAGEFORMATS_AVCI_TEST:STRING=OFF"
  per-test-timeout: 90

CMakeLists.txt

@@ -1,11 +1,11 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.29)
 
-set(KF_VERSION "6.12.0") # handled by release scripts
-set(KF_DEP_VERSION "6.12.0") # handled by release scripts
+set(KF_VERSION "6.30.0") # handled by release scripts
+set(KF_DEP_VERSION "6.30.0") # handled by release scripts
 project(KImageFormats VERSION ${KF_VERSION})
 
 include(FeatureSummary)
-find_package(ECM 6.12.0  NO_MODULE)
+find_package(ECM 6.30.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)
 
@@ -21,7 +21,7 @@ include(ECMDeprecationSettings)
 include(CheckIncludeFiles)
 include(FindPkgConfig)
 
-set(REQUIRED_QT_VERSION 6.6.0)
+set(REQUIRED_QT_VERSION 6.9.0)
 find_package(Qt6Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
 find_package(KF6Archive ${KF_DEP_VERSION})
@@ -53,10 +53,7 @@ set_package_properties(OpenEXR PROPERTIES
     PURPOSE "Required for the QImage plugin for OpenEXR images"
 )
 
-find_package(libavif 0.8.2 CONFIG QUIET)
-if(NOT libavif_FOUND)
-    find_package(libavif 1 CONFIG)
-endif()
+find_package(libavif 1 CONFIG)
 set_package_properties(libavif PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Required for the QImage plugin for AVIF images"
@@ -65,8 +62,16 @@ set_package_properties(libavif PROPERTIES
 option(KIMAGEFORMATS_DDS "Enable plugin for DDS format" ON)
 
 option(KIMAGEFORMATS_HEIF "Enable plugin for HEIF format" OFF)
+set(KIMAGEFORMATS_HEIC_TEST "ALL" CACHE STRING "Enable HEIC tests: OFF, READ_ONLY, ALL")
+set_property(CACHE KIMAGEFORMATS_HEIC_TEST PROPERTY STRINGS "OFF" "READ_ONLY" "ALL")
+set(KIMAGEFORMATS_HEIF_TEST "ALL" CACHE STRING "Enable HEIF tests: OFF, ALL")
+set_property(CACHE KIMAGEFORMATS_HEIF_TEST PROPERTY STRINGS "OFF" "ALL")
+set(KIMAGEFORMATS_HEJ2_TEST "ALL" CACHE STRING "Enable HEJ2 tests: OFF, READ_ONLY, ALL")
+set_property(CACHE KIMAGEFORMATS_HEJ2_TEST PROPERTY STRINGS "OFF" "READ_ONLY" "ALL")
+set(KIMAGEFORMATS_AVCI_TEST "ALL" CACHE STRING "Enable AVCI tests: OFF, ALL")
+set_property(CACHE KIMAGEFORMATS_AVCI_TEST PROPERTY STRINGS "OFF" "ALL")
 if(KIMAGEFORMATS_HEIF)
-    pkg_check_modules(LibHeif IMPORTED_TARGET libheif>=1.10.0)
+    pkg_check_modules(LibHeif IMPORTED_TARGET libheif>=1.17.0)
 endif()
 add_feature_info(LibHeif LibHeif_FOUND "required for the QImage plugin for HEIF/HEIC images")
 
@@ -91,16 +96,17 @@ set_package_properties(LibRaw PROPERTIES
     PURPOSE "Required for the QImage plugin for RAW images"
 )
 
-# JXR plugin disabled by default due to security issues
-option(KIMAGEFORMATS_JXR "Enable plugin for JPEG XR format" OFF)
-if(KIMAGEFORMATS_JXR)
+# JXR plugin disabled by default due to security issues.
+# You should not enable it unless you know what you are doing.
+option(KIMAGEFORMATS_WITH_KNOWN_CRASHES_JXR "Enable plugin for JPEG XR format" OFF)
+if(KIMAGEFORMATS_WITH_KNOWN_CRASHES_JXR)
     find_package(LibJXR)
 endif()
 add_feature_info(LibJXR LibJXR_FOUND "required for the QImage plugin for JPEG XR images")
 
 ecm_set_disabled_deprecation_versions(
-    QT 6.8.0
-    KF 6.11.0
+    QT 6.11.0
+    KF 6.27.0
 )
 
 add_subdirectory(src)
@@ -109,6 +115,28 @@ if (BUILD_TESTING)
     add_subdirectory(tests)
 endif()
 
+set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF6ImageFormats")
+include(CMakePackageConfigHelpers)
+
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/KF6ImageFormatsConfigVersion.cmake"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY AnyNewerVersion
+)
+
+configure_package_config_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/KF6ImageFormatsConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/KF6ImageFormatsConfig.cmake"
+    INSTALL_DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
+)
+
+install(FILES
+  "${CMAKE_CURRENT_BINARY_DIR}/KF6ImageFormatsConfig.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/KF6ImageFormatsConfigVersion.cmake"
+  DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
+  COMPONENT Devel
+)
+
 include(ECMFeatureSummary)
 ecm_feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 

KF6ImageFormatsConfig.cmake.in

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2025 Xaver Hugl <[email protected]>
+# SPDX-License-Identifier: BSD-2-Clause
+
+@PACKAGE_INIT@
+# empty, because this is plugins for Qt instead of a library to link against

LICENSES/Apache-2.0.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -16,10 +16,13 @@ The following image formats have read-only support:
 
 - Animated Windows cursors (ani)
 - Camera RAW images (arw, cr2, cr3, dcs, dng, ...)
+- Farbfeld (ff)
 - Gimp (xcf)
+- Interchange Format Files (iff, ilbm, lbm)
 - Krita (kra)
 - OpenRaster (ora)
 - Pixar raster (pxr)
+- PlayStation graphics (tim)
 - Portable FloatMap/HalfMap (pfm, phm)
 - Photoshop documents (psd, psb, pdd, psdt)
 - Radiance HDR (hdr)
@@ -28,13 +31,13 @@ The following image formats have read-only support:
 
 The following image formats have read and write support:
 
-- AV1 Image File Format (avif)
+- AV1 Image File Format (avif, avifs<sup>1</sup>)
 - DirectDraw Surface (dds)
 - Encapsulated PostScript (eps)
-- High Efficiency Image File Format (heif)
-- JPEG 2000 (jp2, j2k, jpf)
+- High Efficiency Image File Format (avci<sup>2</sup>, heic<sup>2</sup>, heif<sup>2</sup>, hej2<sup>2</sup>, hif<sup>2</sup>)
+- JPEG 2000 (jp2, j2k, jpf<sup>1</sup>)
 - JPEG XL (jxl)
-- JPEG XR (jxr)
+- JPEG XR (jxr, hdp<sup>1</sup>, wdp<sup>1</sup>)
 - OpenEXR (exr)
 - Personal Computer Exchange (pcx)
 - Quite OK Image format (qoi)
@@ -42,6 +45,11 @@ The following image formats have read and write support:
 - Softimage PIC (pic)
 - Targa (tga): supports more formats than Qt's version
 
+Footnotes:
+1. Read only support.
+2. It depends on the HEIF plugins installed. 
+
+
 ## Contributing
 
 See the [`QImageIOPlugin`](https://doc.qt.io/qt-6/qimageioplugin.html)
@@ -53,11 +61,19 @@ willing to sign the Qt Project contributor agreement, it may be better to
 submit the plugin directly to the Qt Project.
 
 To be accepted, contributions must:
-- Contain the test images needed to verify that the changes work correctly
-- Pass the tests successfully
+- Contain the test images needed to verify that the changes work correctly.
+- Pass the tests successfully.
+- Use Qt logging categories for Debug messages.
+
+For more info about tests, see also [Autotests README](autotests/README.md).
 
 ## Duplicated Plugins
 
+> [!important]
+> To ensure you are using the correct plugin, the unwanted one should be 
+renamed or deleted. If several plugins support the same capability, Qt will 
+select one arbitrarily.
+
 ### The TGA plugin
 
 The TGA plugin supports more formats than Qt's own TGA plugin;
@@ -135,6 +151,7 @@ About the image:
   scanned.
 - `HostComputer`: The computer and/or operating system in use at the time 
   of image creation.
+- `Keywords`: Keywords, separated by semicolons, that represent the image.
 - `Latitude`: Floating-point number indicating the latitude in degrees 
   north of the equator (e.g. 27.717).
 - `Longitude`: Floating-point number indicating the longitude in degrees 
@@ -143,10 +160,35 @@ About the image:
   without milliseconds (e.g. 2024-03-23T15:30:43). This value should be 
   updated every time the image is saved.
 - `Owner`: Name of the owner of the image.
+- `Rating`: Integer number indicating the image rating (usually between 1 
+  and 5).
 - `Software`: Name and version number of the software package(s) used to 
   create the image.
+- `Speed`: Floating-point number indicating the speed of GPS receiver 
+  movement in Km/h (e.g. 30.2).
 - `Title`: The title of the image.
 
+About the shot:
+- `DigitalZoomRatio`: Floating-point number indicating the digital zoom ratio
+  when the image was shot.
+- `ExposureMode`: Integer number indicating the exposure mode set when the 
+  image was shot as reported in the EXIF ​​specifications.
+- `ExposureProgram`: Integer number indicating the class of the program used 
+  by the camera to set exposure when the picture is taken as reported in the 
+  EXIF ​​specifications.
+- `ExposureTime`: Floating-point number indicating the exposure time, 
+  given in seconds (s).
+- `Flash`: Integer number indicating the status of flash when the image 
+  was shot as reported in the EXIF ​​specifications.
+- `FNumber`: Floating-point number indicating the F number.
+- `FocalLength`: Floating-point number indicating the actual focal length 
+  of the lens, in millimeters (mm).
+- `ISOSpeedRatings`: Integer number indicating the sensitivity of the camera 
+  or input device when the image was shot as reported in the EXIF 
+  ​​specifications.
+- `WhiteBalance`: Integer number indicating the white balance mode set when 
+  the image was shot as reported in the EXIF ​​specifications.
+
 About the camera:
 - `Manufacturer`: The manufacturer of the recording equipment.
 - `Model`: The model name or model number of the recording equipment.
@@ -209,32 +251,41 @@ RGB.
 
 Where possible, plugins support large images. By convention, many of the
 large image plugins are limited to a maximum of 300,000 x 300,000 pixels.
-Anyway, all plugins are also limited by the 
-`QImageIOReader::allocationLimit()`. Below are the maximum sizes for each
-plugin ('n/a' means no limit, i.e. the limit depends on the format encoding).
+Anyway, all plugins are also limited by the
+`QImageReader::allocationLimit()`.
 
-- ANI: n/a
+> [!note]
+> You can change the maximum limit of 300000 pixels by setting the constant
+> `KIF_LARGE_IMAGE_PIXEL_LIMIT` to the desired value in the cmake file. It 
+> cannot be less than 65536.
+
+Below are the maximum sizes for each plugin ('n/a' means no limit, i.e. the 
+limit depends on the format encoding).
+- ANI: same size as Qt's ICO plugin
 - AVIF: 32,768 x 32,768 pixels, in any case no larger than 256 megapixels
-- DDS: n/a
+- DDS: 300,000 x 300,000 pixels
 - EXR: 300,000 x 300,000 pixels
-- EPS: n/a
-- HDR: n/a (large image)
-- HEIF: n/a
+- EPS: same size as Qt's JPG plugin
+- FF: 300,000 x 300,000 pixels
+- HDR: 300,000 x 300,000 pixels
+- HEIF: 65,535 x 65,535 pixels
+- IFF: 65,535 x 65,535 pixels
 - JP2: 300,000 x 300,000 pixels, in any case no larger than 2 gigapixels
 - JXL: 262,144 x 262,144 pixels, in any case no larger than 256 megapixels
-- JXR: n/a, in any case no larger than 4 GB
+- JXR: 300,000 x 300,000 pixels, in any case no larger than 4 GB
 - KRA: same size as Qt's PNG plugin
 - ORA: same size as Qt's PNG plugin
 - PCX: 65,535 x 65,535 pixels
-- PFM: n/a (large image)
+- PFM: 300,000 x 300,000 pixels
 - PIC: 65,535 x 65,535 pixels
 - PSD: 300,000 x 300,000 pixels
 - PXR: 65,535 x 65,535 pixels
 - QOI: 300,000 x 300,000 pixels
-- RAS: n/a (large image)
-- RAW: n/a (depends on the RAW format loaded)
+- RAS: 300,000 x 300,000 pixels
+- RAW: 65,535 x 65,535 pixels
 - RGB: 65,535 x 65,535 pixels
 - SCT: 300,000 x 300,000 pixels
+- TIM: 65,535 x 65,535 pixels
 - TGA: 65,535 x 65,535 pixels
 - XCF: 300,000 x 300,000 pixels
 
@@ -257,8 +308,18 @@ consumption proportional to the size of the image to be saved.
 Normally this is not a source of problems because the affected plugins
 are limited to maximum images of 2GiB or less.
 
+Note that the value of `QImageReader::allocationLimit()` is only used when 
+allocating a new `QImage`. Since this parameter was created to limit damage 
+caused by corrupted files, any conversion of `QImage` (for example, with 
+`QImage::convertTo()`) is not subject to this limit.
+
 On plugins for formats that support large images, progressive conversion has
 been used or the maximum size of the image that can be saved has been limited.
+Plugins that use external libraries don't always allow progressive decoding 
+(e.g., the JPEG series). In these cases, the memory required for reading 
+may be much larger than the entire decoded image. When the external library has 
+a maximum memory limit function, the value of `QImageReader::allocationLimit()` 
+is set.
 
 ### Non-RGB formats
 
@@ -275,9 +336,14 @@ in your cmake options.**
 
 The following defines can be defined in cmake to modify the behavior of the 
 plugin:
-- `DDS_DISABLE_STRIDE_ALIGNMENT`: disable the stride aligment based on DDS 
+- `DDS_DISABLE_STRIDE_ALIGNMENT`: disable the stride alignment based on DDS 
   pitch: it is known that some writers do not set it correctly.
 
+When writing, it is possible to set which pixel format to use by setting the
+subtypes. The default is `Automatic` which chooses the most appropriate format
+based on the image. For a complete list of subformats, please use the
+appropriate [`QImageWriter`](https://doc.qt.io/qt-6/qimagewriter.html) APIs.
+
 ### The HEIF plugin
 
 **This plugin is disabled by default. It can be enabled by settings
@@ -288,6 +354,30 @@ distributions. In particular, it is necessary that the HEIF library has
 support for HEVC codec. If HEVC codec is not available the plugin
 will compile but will fail the tests.
 
+The following defines can be defined in cmake to modify the behavior of the 
+plugin:
+- `HEIF_DISABLE_QT_TRANSFORMATION`: HEIF transformations, in addition to 
+  rotations and reflections, also support image cropping. Consequently, the 
+  Qt plugin, must also honor the crop. This define is useful in case 
+  of problems: activating it disables Qt's support for transformations, 
+  delegating them to the HEIF libraries (which will therefore always apply 
+  them regardless of what is requested from Qt).
+
+**If you are interested in compiling the plugin without running the tests, 
+also use the following string options:**
+- `KIMAGEFORMATS_HEIC_TEST` to change the behaviour of HEIC tests. Set to
+`"OFF"` (no test at all) or `"READ_ONLY"` (run read tests only).
+Required codecs: HEVC / H.265.
+- `KIMAGEFORMATS_HEIF_TEST` to change the behaviour of HEIF tests. Set to
+`"OFF"` (no test at all).
+Required codecs: uncompressed, deflate, zlib, brotli, jpeg.
+- `KIMAGEFORMATS_HEJ2_TEST` to change the behaviour of HEJ2 tests. Set to 
+`"OFF"` (no test at all) or `"READ_ONLY"` (run read tests only).
+Required codecs: JPEG 2000.
+- `KIMAGEFORMATS_AVCI_TEST` to change the behaviour of AVCI tests. Set to 
+`"OFF"` (no test at all).
+Required codecs: Advanced Video Coding / H.264.
+
 ### The EXR plugin
 
 The following defines can be defined in cmake to modify the behavior of the 
@@ -298,6 +388,10 @@ plugin:
   attribute named "xmp". Note that Gimp reads the "xmp" attribute and Darktable 
   writes it as well.
 
+The plugin can set the following additional metadata:
+- `EXRLayerName`: A string containing the name of the EXR layer used to decode 
+   the image.
+
 ### The EPS plugin
 
 The plugin uses `Ghostscript` to convert the raster image. When reading it
@@ -313,6 +407,37 @@ plugin:
 - `HDR_HALF_QUALITY`: on read, a 16-bit float image is returned instead of a 
   32-bit float one.
 
+
+### The IFF plugin
+
+Interchange File Format is a chunk-based format. Since the original 1985
+version, various extensions have been created over time.
+
+The plugin supports the following image data:
+- FORM ILBM (Interleaved Bitmap): Electronic Arts’ IFF standard for
+  Interchange File Format (EA IFF 1985). ILBM is a format to handle raster
+  images, specifically an InterLeaved bitplane BitMap image with color map.
+  It supports from 1 to 8-bit indexed images with HAM, Halfbride, and normal
+  encoding. It also supports interleaved 24-bit RGB and 32-bit RGBA 
+  extension without color map.
+- FORM ILBM 64: ILBM extension to support 48-bit RGB and 64-bit RGBA encoding.
+- FORM ACBM (Amiga Contiguous BitMap): It supports uncompressed ACBMs by 
+  converting them to ILBMs at runtime.
+- FORM RGBN / RGB8: It supports 13-bit and 25-bit RGB images with compression 
+  type 4.
+- FORM PBM: PBM is a chunky version of IFF pictures. It supports 8-bit images 
+  with color map only.
+- FORM IMAG (Compact Disc-Interactive): It supports CLut4, CLut7, CLut8, Rle7
+  and DYuv formats.
+- FORM RGFX: It supports uncompressed and ZIP compressed images.
+- FORM DEEP: It supports uncompressed, RLE and TVDC images.
+- FOR4 CIMG (Maya Image File Format): It supports 24/48-bit RGB and 32/64-bit 
+  RGBA images.
+
+> [!note]
+> The plugin only supports the IFF, ILBM, and LBM file extensions. You'll 
+> need to rename files with different extensions to open them.
+
 ### The JP2 plugin
 
 **This plugin can be disabled by setting `KIMAGEFORMATS_JP2` to `OFF` 
@@ -323,6 +448,11 @@ JP2 plugin has the following limitations due to the lack of support by OpenJPEG:
 - Image resolution is not supported.
 - To write ICC profiles you need OpenJPEG V2.5.4 or higher
 
+When writing, it is possible to set which format to use by setting the 
+following subtypes:
+- `JP2` (default): Save data using the JP2 container.
+- `J2K`: Save only the compressed codestream.
+
 ### The JXL plugin
 
 **The current version of the plugin limits the image size to 256 megapixels
@@ -338,13 +468,23 @@ plugin:
 ### The JXR plugin
 
 **This plugin is disabled by default. It can be enabled by settings
-`KIMAGEFORMATS_JXR` to `ON` in your cmake options.**
+`KIMAGEFORMATS_WITH_KNOWN_CRASHES_JXR` to `ON` in your cmake options.**
+
+> [!caution]
+> The plugin disabled by default due to security issues in [jxrlib](https://github.com/4creators/jxrlib): 
+> the upstream jxrlib is dead and there is no "hope" they will fix the issues.
+>
+> **You should not enable it unless you know what you are doing.**
+
+> [!note]
+> Security issues in the jxrlib discovered by the [KImageFormats OSS-Fuzz project](https://github.com/google/oss-fuzz/tree/master/projects/kimageformats) 
+> should be fixed in this [jxrlib fork](https://github.com/mircomir/jxrlib).
 
 The following defines can be defined in cmake to modify the behavior of the 
 plugin:
 - `JXR_DENY_FLOAT_IMAGE`: disables the use of float images and consequently 
   any HDR data will be lost.
-- `JXR_DISABLE_DEPTH_CONVERSION`: remove the neeeds of additional memory by 
+- `JXR_DISABLE_DEPTH_CONVERSION`: remove the needs of additional memory by 
   disabling the conversion between different color depths (e.g. RGBA64bpp to 
   RGBA32bpp) at the cost of reduced compatibility.
 - `JXR_DISABLE_BGRA_HACK`: Windows displays and opens JXR files correctly out 
@@ -352,20 +492,11 @@ plugin:
   it only wants (P)BGRA32bpp files (a format not supported by Qt). Only for 
   this format an hack is activated to guarantee total compatibility of the 
   plugin with Windows.
-- `JXR_ENABLE_ADVANCED_METADATA`: enable metadata support (e.g. XMP). Some 
-  distributions use an incomplete JXR library that does not allow reading 
-  metadata, causing compilation errors.
 
-### The KRA plugin
+### The KRA and ORA plugin
 
-The KRA format is a ZIP archive containing image data. In particular, the
-rendered image in PNG format is saved in the root: the plugin reads this 
-image.
-
-### The ORA plugin
-
-The ORA format is a ZIP archive containing image data. In particular, the
-rendered image in PNG format is saved in the root: the plugin reads this 
+Both KRA and ORA formats are ZIP archives containing image data. Specifically,
+the rendered PNG image is saved in the root directory: the plugin reads this
 image.
 
 ### The PSD plugin
@@ -376,6 +507,8 @@ PSD support has the following limitations:
 - Multichannel images are treated as CMYK if they have 2 or more channels.
 - Multichannel images are treated as Grayscale if they have 1 channel.
 - Duotone images are treated as grayscale images.
+- Grayscale images with alpha channel or at 32 bit depth are converted to 
+  RGBA due to the lack of the appropriate Qt grayscale container.
 - Extra channels other than alpha are discarded.
 
 The following defines can be defined in cmake to modify the behavior of the 
@@ -385,6 +518,13 @@ plugin:
 - `PSD_NATIVE_CMYK_SUPPORT_DISABLED`: disable native support for CMYK images 
   when compiled with Qt 6.8+
 
+The plugin can set the following additional metadata:
+  - `PSDDuotoneOptions`: Byte array in hexadecimal format of color data of the 
+     duotone specification (the format of which is not documented). From the PSD 
+     specification: *"Other applications that read Photoshop files can treat a 
+     duotone image as a gray image, and just preserve the contents of the duotone 
+     information when reading and writing the file."*
+
 ### The RAW plugin
 
 Loading RAW images always requires a conversion. To allow the user to
@@ -395,6 +535,25 @@ selectively change the conversion (see also [raw_p.h](./src/imageformats/raw_p.h
 
 The default setting tries to balance quality and conversion speed.
 
+### The TGA plugin
+
+TGA plugin supports both version 1 and version 2 of TGA files. When writing,
+it is possible to force which version to use by setting the following subtypes:
+- `TGAv1`: force TGA v1.0. No metadata.
+- `TGAv2` (default): force TGA v2.0 (strict). Adds the TGA Extension Area.
+- `TGAv2E`: force TGA v2.0 (enhanced). Same as TGA v2.0 (strict) but with the 
+  addition of the TGA v2.0 Developer Area with info like, for e.g., Exif data, 
+  XMP packet and the ICC profile.
+
+They are all TGA specs compliant. While for versions 1 and 2 (strict) it is 
+possible to decode all the information with the TGA specification alone, for 
+version 2 (enhanced) it is necessary to know how the additional data is
+encoded.
+
+The following defines can be defined in cmake to modify the behavior of the 
+plugin:
+- `TGA_V2E_AS_DEFAULT`: change the default version of the plugin to `TGAv2E`.
+
 ### The XCF plugin
 
 XCF support has the following limitations:

autotests/CMakeLists.txt

@@ -76,7 +76,9 @@ endmacro()
 # Loads each <format> image in read/<format>/, and compares the
 # result against the data read from the corresponding png file
 kimageformats_read_tests(
+    ff
     hdr
+    iff
     pcx
     pfm
     psd
@@ -85,6 +87,7 @@ kimageformats_read_tests(
     ras
     rgb
     sct
+    tim
     tga
 )
 
@@ -101,34 +104,59 @@ if (KF6Archive_FOUND)
 endif()
 
 if (TARGET avif)
-    kimageformats_read_tests(
-        avif
-    )
+    if(${libavif_VERSION} VERSION_GREATER_EQUAL "1.2.0")
+        kimageformats_read_tests(
+            avif
+        )
+    else()
+        message(WARNING "libavif ${libavif_VERSION} doesn't support decoding new AVIF files!\n"
+                        "AVIF read tests are disabled, consider updating libavif.")
+    endif()
+
     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
-    )
-
-    if (LibHeif_VERSION VERSION_GREATER_EQUAL "1.17.0")
-        kimageformats_read_tests(FUZZ 1
-            hej2
+    if (KIMAGEFORMATS_HEIC_TEST STREQUAL "ALL" OR KIMAGEFORMATS_HEIC_TEST STREQUAL "READ_ONLY")
+        kimageformats_read_tests(
+            heic
+        )
+    endif()
+    if (KIMAGEFORMATS_HEIC_TEST STREQUAL "ALL")
+        # because the plug-ins use RGB->YUV conversion which sometimes results in 1 value difference.
+        kimageformats_write_tests(FUZZ 1
+            heic-nodatacheck-lossless
         )
     endif()
 
-    if (LibHeif_VERSION VERSION_GREATER_EQUAL "1.19.0")
-        kimageformats_read_tests(FUZZ 4
-            avci
+    if (KIMAGEFORMATS_HEIF_TEST STREQUAL "ALL")
+        kimageformats_read_tests(
+            heif
         )
     endif()
+
+    if (LibHeif_VERSION VERSION_GREATER_EQUAL "1.17.0")
+        if (KIMAGEFORMATS_HEJ2_TEST STREQUAL "ALL" OR KIMAGEFORMATS_HEJ2_TEST STREQUAL "READ_ONLY")
+            kimageformats_read_tests(FUZZ 1
+                hej2
+            )
+        endif()
+        if (KIMAGEFORMATS_HEJ2_TEST STREQUAL "ALL")
+            kimageformats_write_tests(FUZZ 1
+                hej2-nodatacheck-lossless
+            )
+        endif()
+    endif()
+
+    if (LibHeif_VERSION VERSION_GREATER_EQUAL "1.19.6")
+        if (KIMAGEFORMATS_AVCI_TEST STREQUAL "ALL")
+            kimageformats_read_tests(FUZZ 4
+                avci
+            )
+        endif()
+    endif()
 endif()
 
 if (OpenJPEG_FOUND)
@@ -185,7 +213,7 @@ kimageformats_write_tests(
     pic-lossless
     qoi-lossless
     rgb-lossless
-    tga # fixme: the alpha images appear not to be written properly
+    tga-nodatacheck
 )
 
 # EPS read tests depend on the vagaries of GhostScript

autotests/README.md

@@ -0,0 +1,264 @@
+# Autotests
+
+Automated testing for plugins to allow 
+[`QImage`](https://doc.qt.io/qt-6/qimage.html) to support
+extra file formats.
+
+## Introduction
+
+The testing part is essential for the correct functioning of the plugins. 
+There are generic read/write tests and specific tests for the plugins that
+require them.
+
+## Read tests
+
+The generic reading tests are contained in the `read` folder. Inside the 
+`read` folder, there are one or more folders for each plugin to be tested.
+A plugin can support multiple image file types, and if you need different 
+parameters for each type, you need to create a folder for each type supported
+by the plugin (see e.g. HEIF plugin). If all formats supported by the plugin 
+do not require different parameters, a single folder approach is simpler (see 
+e.g. PSD plugin).
+
+The reading tests are mainly based on comparing the image read by the plugin 
+with a template in a known and working format. For this reason, the template 
+formats chosen are those distributed by the Qt project: PNG in the first 
+instance, TIFF for image formats not supported by PNG (e.g. CMYK images) and, 
+as a last choice, lossy JPG for large images.
+
+> [!important]
+> Keep the size of individual test images on the order of a few tens of KiB.
+
+Some image options such as `QImageIOHandler::Size`, 
+`QImageIOHandler::ImageFormat` and `QImageIOHandler::ImageTransformation` are 
+also checked. If supported by the plugin, the resulting image is checked to 
+see if it is compatible with the option's specification.
+
+Optionally, for each image, you can also create a JSON file to modify the test 
+behavior and/or verify data other than image pixels, such as metadata.
+
+Finally, two tests are run for each test case:
+- On a random access device: this test must not fail.
+- On a sequential access device: a plugin may not support sequential operation. 
+In this case, the test is skipped. However, if an image is returned, the test 
+must succeed.
+
+### The readtest command
+
+To start a test, run the `readtest` command with the format to test as an 
+argument. The format is one of those supported by plugins and a folder with 
+the name of the format must be present inside the `read` folder.
+Depending on the format, you can specify the following additional options.
+
+- `--help`: Displays help on commandline options.
+- `--fuzz <max>`: The fuzziness. Used to add some deviation in ARGB data 
+(normally used on lossy codec).
+- `--perceptive-fuzz`: Used to scale dynamically the fuzziness based on 
+the alpha channel value. This is useful on images with pre-multiplied and 
+small alphas. Qt can use different roundings based on optimizations resulting 
+in very different RGB values. Since the alpha is small visually there is no 
+difference (so it is not considered an error).
+- `--skip-optional-tests`: Used to skip the optional test such as metadata 
+and resolution tests.
+
+Note that some tests may fail if the correct options are not used. The correct
+options for each test are defined in [CMakeLists.txt](CMakeLists.txt).
+See also [Add a test to CMakeLists.txt](#add-a-test-to-cmakeliststxt).
+
+### Test image nomenclature
+
+Each test consists of the image to test, the verification image(s) (template)
+and, optionally, the additional JSON file.
+To be a test, the names of these files must be the same (except for 
+the extension). A test for a JXL image would be, for example, composed like 
+this:
+- `testRGB.jxl`: The image to test.
+- `testRGB.jxl.json`: The test behavior modifier (note that it must contain 
+the double extension).
+- `testRGB.png`: How the image should look (template). The template name 
+can be different if specified in the JSON file.
+
+Although there is no precise rule for the name of a test, it is good to have 
+a name that is explanatory.
+
+### JSON behavior file
+
+The behavior file was initially introduced to solve compatibility issues 
+between different versions of Qt supported by the framework. It was later 
+extended to also check image metadata.
+
+The JSON file consists of an array of JSON objects. The objects in the array 
+are iterated sequentially and the first object that matches the requirements 
+is used for testing (successes are ignored).
+
+Supported values ​​for JSON objects:
+- `colorSpace` : Type `object`. An object with the `description` (type 
+`string`), `primaries` (type `string`), `transferFunction` (type `string`), 
+`colorModel` (type `string`) and `gamma` (type `double`) values ​​of the
+image color space.
+- `comment`: Type `string`. A string shown by the test when a condition occurs.
+- `description`: Type `string`. A description of the object. Not used by the 
+test.
+- `disableAutoTransform`: Type `boolean`. By default, tests are run with 
+autotransform enabled (i.e. rotation is applied if the plugin supports it).
+Set to `true` to disable autotransform.
+- `fileName`: Type `string`. Name of the template file to use. E.g. 
+"testRGB_Qt_6_2.png".
+- `fuzziness`: Type `integer`. Set the fuzziness only if not already set on the 
+command line. The value set on the command line wins over the one in the JSON 
+file.
+- `maxQtVersion`: Type `string`. Maximum Qt version this object is compatible 
+with (if not set means all). E.g. "6.2.99".
+- `metadata`: Type `array`. An array of key/value objects (string type) 
+containing the image metadata as returned by `QImage::text`.
+- `minQtVersion`: Type `string`. Minimum Qt version this object is compatible 
+with (if not set means all). E.g. "6.2.0".
+- `perceptiveFuzziness` Type `boolean`. Set the perceptive fuzziness only if not
+already set on the command line. The value set on the command line wins over 
+the one in the JSON file.
+- `resolution`: Type `object`. An object with the `dotsPerMeterX` (type `integer`)
+and `dotsPerMeterY` (type `integer`) values ​​of the image.
+- `seeAlso`: Type `string`. More info about the object. Normally used to point
+to bug reports. Not used by the test.
+- `skipSequential`: Type `boolean`. Skip the test on sequential access device.
+Some plugins may have limited functionality on sequential devices (e.g., 
+not reading metadata).
+- `unsupportedFormat`: Type `boolean`. When true, the test is skipped.
+
+Some examples:
+- Example 1: [Runs only on Qt without alpha bug on float formats](read/jxl/testcard_rgba_fp16.jxl.json)
+- Example 2: [Rotation disabled](read/jxl/orientation6_notranfs.jxl.json)
+- Example 3: [Metadata](read/psd/metadata.psd.json)
+- Example 4: [Check Qt version, resolution and metadata](read/psd/mch-16bits.psd.json)
+- Example 5: [Fuzziness setting](read/xcf/birthday16.xcf.json)
+- Example 6: [Color space](read/dds/rgba_f16.dds.json)
+ 
+These are just a few examples. More examples can be found in the test folders.
+
+## Write tests
+
+The generic writing tests are contained in the `write/basic` and 
+`write/format` folders. Similar to the read tests, they verify the written 
+(and then reread) image with a template.
+
+The write test is composed of several phases:
+- Basic test: Uses the `write/basic` folder and checks the most common images 
+and, optionally, metadata and resolution via a JSON properties file.
+- Format test: Uses the `write/format` folder and checks that all QImage image
+formats are written correctly.
+- Dimensional test: Uses the `write/format` folder and check images of 
+different sizes (odd numbers, prime numbers, etc.) to verify internal 
+alignments.
+- Null device test: Verify that there are no crashes if the device is null.
+
+### The writetest command
+
+To start a test, run the `writetest` command with the format to test as an 
+argument. The format is one of those supported by plugins, a folder with 
+the name of the format must be present inside the `write/format` folder and 
+may need a template image in `write/basic`.
+Depending on the format, you can specify the following additional options.
+
+- `--help`: Displays help on commandline options.
+- `--create-format-templates`: Create template images for all formats 
+supported by the QImage in `write/format`. Command to simplify the creation of
+format test images when adding a new plugin or modifying an old one. This 
+command is not intended to be used from the CMakeLists file as it must be used
+manually and the generated images must be verified one by one.
+- `--fuzz <max>`: The fuzziness. Used to add some deviation in ARGB data 
+(nornally used on lossy codec).
+- `--lossless`: Check that reading back the data gives the same image.
+- `--no-data-check`: Don't check that write data is exactly the same.
+- `--skip-optional-tests`: Skip optional data tests (metadata, resolution,
+etc...).
+
+Note that some tests may fail if the correct options are not used. The correct
+options for each test are defined in [CMakeLists.txt](CMakeLists.txt).
+See also [Add a test to CMakeLists.txt](#add-a-test-to-cmakeliststxt).
+
+### JSON properties file
+
+The properties file must be located in `write/basic` and must have the name 
+of the file format (e.g. jxl.json). It is a JSON object composed of the 
+following values:
+- `format`: Type `string`. The format tested.
+- `metadata`: Type `array`. An array of key/value objects (string type) 
+containing the image metadata as returned by `QImage::text`.
+- `resolution`: Type `object`. An object with the `dotsPerMeterX` and `
+dotsPerMeterY` (integer) values ​​of the image.
+- `subType`: type `string`. The image writer subtype to set when testing.
+
+[This is an example](write/basic/jxl.json) of property file.
+
+
+## Custom tests
+
+If the generic read/write tests do not meet the requirements of a plugin, 
+it is possible to write a custom test. 
+In general it makes sense to write a dedicated test for a format if and 
+only if you are testing unique features not present in other plugins.
+
+### The PIC test
+
+The PIC test is generated using Qt Test class. For more information 
+see [Qt Test](https://doc.qt.io/qt-6/qttest-index.html).
+
+### The ANI test
+
+The ANI test is generated using Qt Test class. For more information 
+see [Qt Test](https://doc.qt.io/qt-6/qttest-index.html).
+
+
+## Add a test to CMakeLists.txt
+
+To add a test to CMake use the `kimageformats_read_tests` and 
+`kimageformats_write_tests` functions. For example, to add the read 
+tests for the PSD you just write `kimageformats_read_tests(psd)`.
+
+It is also possible to pass command line arguments to the test by 
+appropriately composing the string passed to the test functions.
+For boolean parameters you need to add a string starting with '-' 
+after the image format. For example, to pass `--skip-optional-tests` 
+to the PSD plugin write `kimageformats_read_tests(psd-skipoptional)`.
+
+To add a fuzziness of 4, you must first set it as follows: 
+`kimageformats_read_tests(FUZZ 4 psd-skipoptional)`.
+
+The possible modifiers for `kimageformats_read_tests` are as follows:
+- `-skipoptional`: Add the `--skip-optional-tests` command line parameter.
+
+The possible modifiers for `kimageformats_write_tests` are as follows:
+- `-lossless`: Add the `--lossless` command line parameter.
+- `-nodatacheck`: Add the `--no-data-check` command line parameter.
+- `-skipoptional`: Add the `--skip-optional-tests` command line parameter.
+
+To set multiple parameters, you can enter multiple modifiers. For example:
+```
+kimageformats_write_tests(FUZZ 1
+    hej2-nodatacheck-lossless
+)
+```
+
+## OSS-Fuzz
+
+Plugins are also tested with [OSS-Fuzz](https://google.github.io/oss-fuzz/)
+project to identify possible security issues. When adding a new plugin it is 
+also necessary to add it to the test in the [ossfuzz](ossfuzz) directory.
+
+## TODO
+
+List of tests not implemented or only partially implemented.
+
+### Color Profiles Test
+
+Many plugins support color profiles via [`QColorSpace`](https://doc.qt.io/qt-6/qcolorspace.html). 
+Checking for correct color management is increasingly necessary especially now
+that monitors are HDR and other than RGB color spaces have been added to Qt.
+
+Furthermore, lossy plugins often have different color management behaviors 
+depending on how the image is saved.
+
+### Animations Test
+
+Few plugins support animations. There are currently no plans for 
+implementation.

autotests/anitest.cpp

@@ -48,7 +48,7 @@ private Q_SLOTS:
         QCOMPARE(reader.text(QStringLiteral("Author")), QStringLiteral("KDE Community"));
     }
 
-    void textRead()
+    void testRead()
     {
         QImageReader reader(QFINDTESTDATA("ani/test.ani"));
         QVERIFY(reader.canRead());

autotests/ossfuzz/build_fuzzers.sh

@@ -0,0 +1,198 @@
+#!/bin/bash -eu
+#
+# SPDX-FileCopyrightText: 2020 Google LLC
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+LDFLAGS=""
+if [[ $FUZZING_ENGINE == "afl" ]]; then
+    LDFLAGS="-fuse-ld=lld"
+fi
+export LDFLAGS
+
+# build zstd
+cd $SRC/zstd
+cmake -G Ninja -S build/cmake -DBUILD_SHARED_LIBS=OFF -DZSTD_BUILD_PROGRAMS=OFF -DBUILD_TESTING=OFF
+ninja install
+
+# Build zlib
+cd $SRC/zlib
+./configure --static
+make install -j$(nproc)
+
+# Build bzip2
+# Inspired from ../bzip2/build
+cd $SRC
+tar xzf bzip2-*.tar.gz && rm -f bzip2-*.tar.gz
+cd bzip2-*
+SRCL=(blocksort.o huffman.o crctable.o randtable.o compress.o decompress.o bzlib.o)
+
+for source in ${SRCL[@]}; do
+    name=$(basename $source .o)
+    $CC $CFLAGS -c ${name}.c
+done
+rm -f libbz2.a
+ar cq libbz2.a ${SRCL[@]}
+cp -f bzlib.h /usr/local/include
+cp -f libbz2.a /usr/local/lib
+
+# Build xz
+export ORIG_CFLAGS="${CFLAGS}"
+export ORIG_CXXFLAGS="${CXXFLAGS}"
+unset CFLAGS
+unset CXXFLAGS
+cd $SRC/xz
+./autogen.sh --no-po4a --no-doxygen
+./configure --enable-static --disable-debug --disable-shared --disable-xz --disable-xzdec --disable-lzmainfo
+make install -j$(nproc)
+export CFLAGS="${ORIG_CFLAGS}"
+export CXXFLAGS="${ORIG_CXXFLAGS}"
+
+# Build qt
+cd $SRC/qtbase
+./configure -no-glib -qt-libpng -qt-pcre -opensource -confirm-license -static -no-opengl -no-icu -platform linux-clang-libc++ -debug -prefix /usr -no-feature-widgets -no-feature-sql -no-feature-network  -no-feature-xml -no-feature-dbus -no-feature-printsupport
+cmake --build . --parallel $(nproc)
+cmake --install .
+
+# Build extra-cmake-modules
+cd $SRC/extra-cmake-modules
+cmake -G Ninja . -DBUILD_TESTING=OFF -DBUILD_DOC=OFF
+ninja install
+
+cd $SRC/karchive
+rm -rf poqm
+cmake -G Ninja . -DBUILD_SHARED_LIBS=OFF -DBUILD_TESTING=OFF -DCMAKE_INSTALL_PREFIX=/usr/local
+ninja install
+
+# Build JXRlib
+cd $SRC/jxrlib
+make -j$(nproc)
+
+# Build LibRaw
+cd $SRC/LibRaw
+TMP_CFLAGS=$CFLAGS
+TMP_CXXFLAGS=$CXXFLAGS
+CFLAGS="$CFLAGS -fno-sanitize=function,vptr"
+CXXFLAGS="$CXXFLAGS -fno-sanitize=function,vptr"
+autoreconf --install
+./configure --disable-examples
+make -j$(nproc)
+make install -j$(nproc)
+CFLAGS=$TMP_CFLAGS
+CXXFLAGS=$TMP_CXXFLAGS
+
+
+# Build aom
+cd $SRC/aom
+mkdir build.libavif
+cd build.libavif
+extra_libaom_flags='-DAOM_MAX_ALLOCABLE_MEMORY=536870912 -DDO_RANGE_CHECK_CLAMP=1'
+cmake -G Ninja -DBUILD_SHARED_LIBS=0 -DENABLE_DOCS=0 -DENABLE_EXAMPLES=0 -DENABLE_TESTDATA=0 -DENABLE_TESTS=0 -DENABLE_TOOLS=0 -DCONFIG_PIC=1 -DAOM_TARGET_CPU=generic -DCONFIG_SIZE_LIMIT=1 -DDECODE_HEIGHT_LIMIT=12288 -DDECODE_WIDTH_LIMIT=12288 -DAOM_EXTRA_C_FLAGS="${extra_libaom_flags}" -DAOM_EXTRA_CXX_FLAGS="${extra_libaom_flags}" ..
+ninja install
+
+# Build libavif
+cd $SRC/libavif
+ln -s "$SRC/aom" "$SRC/libavif/ext/"
+mkdir build
+cd build
+CFLAGS="$CFLAGS -fPIC" cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DAVIF_ENABLE_WERROR=OFF -DAVIF_CODEC_AOM=LOCAL -DAVIF_LIBYUV=OFF ..
+ninja
+
+# Build libde265
+cd $SRC/libde265
+cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DENABLE_SDL=OFF -DENABLE_SIMD=OFF -DENABLE_AVX2=OFF -DENABLE_AVX512=OFF .
+ninja install
+
+# Build openjpeg
+cd $SRC/openjpeg
+mkdir build
+cd build
+cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DBUILD_STATIC_LIBS=ON -DBUILD_CODEC=OFF ..
+ninja install
+
+# build openh264
+cd $SRC/openh264
+make USE_ASM=No BUILDTYPE=Debug install-static -j$(nproc)
+
+# Build openexr
+cd $SRC/openexr
+mkdir _build
+cd _build
+cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DBUILD_TESTING=OFF -DOPENEXR_BUILD_TOOLS=OFF -DOPENEXR_INSTALL_TOOLS=OFF -DOPENEXR_BUILD_EXAMPLES=OFF -DOPENEXR_TEST_LIBRARIES=OFF -DOPENEXR_TEST_TOOLS=OFF -DOPENEXR_TEST_PYTHON=OFF ..
+ninja install
+
+# Build libjxl
+cd $SRC/libjxl
+mkdir build
+cd build
+CXXFLAGS="$CXXFLAGS -DHWY_COMPILE_ONLY_SCALAR" cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DBUILD_TESTING=OFF -DJPEGXL_ENABLE_BENCHMARK=OFF -DJPEGXL_ENABLE_DOXYGEN=OFF -DJPEGXL_ENABLE_EXAMPLES=OFF -DJPEGXL_ENABLE_JNI=OFF  -DJPEGXL_ENABLE_MANPAGES=OFF -DJPEGXL_ENABLE_OPENEXR=OFF -DJPEGXL_ENABLE_PLUGINS=OFF -DJPEGXL_ENABLE_SJPEG=OFF -DJPEGXL_ENABLE_SKCMS=ON -DJPEGXL_ENABLE_TCMALLOC=OFF -DJPEGXL_ENABLE_TOOLS=OFF -DJPEGXL_ENABLE_FUZZERS=OFF ..
+ninja install
+
+# Build libheif
+cd $SRC/libheif
+#Reduce max width and height to avoid allocating too much memory
+sed -i "s/static const int MAX_IMAGE_WIDTH = 32768;/static const int MAX_IMAGE_WIDTH = 8192;/g" libheif/security_limits.h
+sed -i "s/static const int MAX_IMAGE_HEIGHT = 32768;/static const int MAX_IMAGE_HEIGHT = 8192;/g" libheif/security_limits.h
+mkdir build
+cd build
+cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DBUILD_TESTING=OFF -DENABLE_PLUGIN_LOADING=OFF -DWITH_EXAMPLES=OFF -DBUILD_DOCUMENTATION=OFF -DWITH_LIBSHARPYUV=OFF -DWITH_UNCOMPRESSED_CODEC=ON -DWITH_DAV1D=OFF -DWITH_EXAMPLES=OFF -DWITH_LIBDE265=ON -DWITH_RAV1E=OFF -DWITH_RAV1E_PLUGIN=OFF -DWITH_SvtEnc=OFF -DWITH_SvtEnc_PLUGIN=OFF -DWITH_X265=OFF -DWITH_X264=OFF -DWITH_OpenJPEG_DECODER=ON -DWITH_OpenH264_DECODER=ON ..
+ninja install
+
+cd $SRC/kimageformats
+HANDLER_TYPES="ani
+        avif
+        dds
+        exr
+        ff
+        hdr
+        heif
+        iff
+        jp2
+        jxl
+        jxr
+        kra
+        pcx
+        pfm
+        pic
+        psd
+        pxr
+        qoi
+        ras
+        raw
+        rgb
+        sct
+        tim
+        tga
+        xcf"
+
+echo "$HANDLER_TYPES" | while read format; do
+(
+  fuzz_target_name=kimgio_${format}_fuzzer
+
+  /usr/libexec/moc $SRC/kimageformats/src/imageformats/$format.cpp -o $format.moc
+  header=`ls $SRC/kimageformats/src/imageformats/$format*.h`
+  /usr/libexec/moc $header -o moc_`basename $header .h`.cpp
+  $CXX $CXXFLAGS $LDFLAGS -fPIC -DKIMG_FUZZER_${format}=1 -std=c++17 autotests/ossfuzz/kimgio_fuzzer.cc $SRC/kimageformats/src/imageformats/$format.cpp $SRC/kimageformats/src/imageformats/scanlineconverter.cpp $SRC/kimageformats/src/imageformats/microexif.cpp $SRC/kimageformats/src/imageformats/chunks.cpp -o $OUT/$fuzz_target_name -DJXL_STATIC_DEFINE -DJXL_THREADS_STATIC_DEFINE -DJXL_CMS_STATIC_DEFINE -D__ANSI__ -I $SRC/kimageformats/src/imageformats/ -I $SRC/libavif/include/ -I $SRC/libjxl/build/lib/include/ -I $SRC/libjxl/lib/include/ -I /usr/local/include/OpenEXR/ -I /usr/local/include/KF6/KArchive/ -I /usr/local/include/openjpeg-2.5 -I /usr/local/include/Imath -I $SRC/jxrlib/common/include -I $SRC/jxrlib/jxrgluelib -I $SRC/jxrlib/image/sys -I /usr/include/QtCore/ -I /usr/include/QtGui/ -I . $SRC/libavif/build/libavif.a /usr/local/lib/libheif.a /usr/local/lib/libde265.a /usr/local/lib/libopenh264.a $SRC/aom/build.libavif/libaom.a $SRC/libjxl/build/lib/libjxl_threads.a $SRC/libjxl/build/lib/libjxl.a $SRC/libjxl/build/lib/libjxl_cms.a $SRC/libjxl/build/third_party/highway/libhwy.a $SRC/libjxl/build/third_party/brotli/libbrotlidec.a $SRC/libjxl/build/third_party/brotli/libbrotlienc.a $SRC/libjxl/build/third_party/brotli/libbrotlicommon.a -lQt6Gui -lQt6Core -lQt6BundledLibpng -lQt6BundledHarfbuzz -lm -lQt6BundledPcre2 -ldl -lpthread $LIB_FUZZING_ENGINE /usr/local/lib/libz.a /usr/local/lib/x86_64-linux-gnu/libKF6Archive.a /usr/local/lib/libz.a /usr/local/lib/libraw.a /usr/local/lib/libOpenEXR-3_4.a /usr/local/lib/libIex-3_4.a /usr/local/lib/libImath-3_2.a /usr/local/lib/libIlmThread-3_4.a /usr/local/lib/libOpenEXRCore-3_4.a /usr/local/lib/libOpenEXRUtil-3_4.a /usr/local/lib/libopenjp2.a /usr/local/lib/libzstd.a $SRC/jxrlib/build/libjxrglue.a $SRC/jxrlib/build/libjpegxr.a /usr/local/lib/liblzma.a /usr/local/lib/libbz2.a -lclang_rt.builtins
+
+  # -lclang_rt.builtins in the previous line is a temporary workaround to avoid a linker error "undefined reference to __truncsfhf2". Investigate why this is needed here, but not anywhere else, and possibly remove it.
+
+  find . -name "*.${format}" | zip -q $OUT/${fuzz_target_name}_seed_corpus.zip -@
+)
+done
+
+# Manually add other supported extensions to HEIF seed corpus
+find . -type f \( -name "*.avci" -o -name "*.heic" -o -name "*.hej2" \) | zip -q $OUT/kimgio_heif_fuzzer_seed_corpus.zip -@

autotests/ossfuzz/kimgio_fuzzer.cc

@@ -0,0 +1,153 @@
+/*
+# SPDX-FileCopyrightText: 2018 Google Inc.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2018 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+*/
+
+/*
+  Usage:
+    python infra/helper.py build_image kimageformats
+    python infra/helper.py build_fuzzers --sanitizer undefined|address|memory kimageformats
+    python infra/helper.py run_fuzzer kimageformats kimgio_[ani|avif|dds|exr|ff|hdr|heif|iff|jp2|jxl|jxr|kra|pcx|pfm|pic|psd|pxr|qoi|ras|raw|rgb|sct|tim|tga|xcf]_fuzzer
+*/
+
+#include <QBuffer>
+#include <QCoreApplication>
+#include <QImage>
+#include <QImageReader>
+
+#if defined KIMG_FUZZER_ani
+#include "ani_p.h"
+#define HANDLER ANIHandler
+#elif defined KIMG_FUZZER_avif
+#include "avif_p.h"
+#define HANDLER QAVIFHandler
+#elif defined KIMG_FUZZER_dds
+#include "dds_p.h"
+#define HANDLER QDDSHandler
+#elif defined KIMG_FUZZER_exr
+#include "exr_p.h"
+#define HANDLER EXRHandler
+#elif defined KIMG_FUZZER_ff
+#include "ff_p.h"
+#define HANDLER FFHandler
+#elif defined KIMG_FUZZER_hdr
+#include "hdr_p.h"
+#define HANDLER HDRHandler
+#elif defined KIMG_FUZZER_heif
+#include "heif_p.h"
+#define HANDLER HEIFHandler
+#elif defined KIMG_FUZZER_iff
+#include "iff_p.h"
+#define HANDLER IFFHandler
+#elif defined KIMG_FUZZER_jp2
+#include "jp2_p.h"
+#define HANDLER JP2Handler
+#elif defined KIMG_FUZZER_jxl
+#include "jxl_p.h"
+#define HANDLER QJpegXLHandler
+#elif defined KIMG_FUZZER_jxr
+#include "jxr_p.h"
+#define HANDLER JXRHandler
+#elif defined KIMG_FUZZER_kra
+#include "kra_p.h"
+#define HANDLER KraHandler
+#elif defined KIMG_FUZZER_pcx
+#include "pcx_p.h"
+#define HANDLER PCXHandler
+#elif defined KIMG_FUZZER_pfm
+#include "pfm_p.h"
+#define HANDLER PFMHandler
+#elif defined KIMG_FUZZER_pic
+#include "pic_p.h"
+#define HANDLER SoftimagePICHandler
+#elif defined KIMG_FUZZER_psd
+#include "psd_p.h"
+#define HANDLER PSDHandler
+#elif defined KIMG_FUZZER_pxr
+#include "pxr_p.h"
+#define HANDLER PXRHandler
+#elif defined KIMG_FUZZER_qoi
+#include "qoi_p.h"
+#define HANDLER QOIHandler
+#elif defined KIMG_FUZZER_ras
+#include "ras_p.h"
+#define HANDLER RASHandler
+#elif defined KIMG_FUZZER_raw
+#include "raw_p.h"
+#define HANDLER RAWHandler
+#elif defined KIMG_FUZZER_rgb
+#include "rgb_p.h"
+#define HANDLER RGBHandler
+#elif defined KIMG_FUZZER_sct
+#include "sct_p.h"
+#define HANDLER ScitexHandler
+#elif defined KIMG_FUZZER_tim
+#include "tim_p.h"
+#define HANDLER TIMHandler
+#elif defined KIMG_FUZZER_tga
+#include "tga_p.h"
+#define HANDLER TGAHandler
+#elif defined KIMG_FUZZER_xcf
+#include "xcf_p.h"
+#define HANDLER XCFHandler
+#else
+#error "KIMG_FUZZER_format not defined!"
+#endif
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    int argc = 0;
+    QCoreApplication a(argc, nullptr);
+
+    QImageReader::setAllocationLimit(512);
+
+    QImageIOHandler *handler = new HANDLER();
+
+    QImage i;
+    QBuffer b;
+    b.setData((const char *)data, size);
+    b.open(QIODevice::ReadOnly);
+    handler->setDevice(&b);
+    handler->canRead();
+
+    bool is_animated = false;
+    if (handler->supportsOption(QImageIOHandler::Animation)) {
+        is_animated = handler->option(QImageIOHandler::Animation).toBool();
+    }
+
+    if (is_animated) { // animated image
+        if (handler->supportsOption(QImageIOHandler::Size)) {
+            handler->option(QImageIOHandler::Size).toSize();
+        }
+
+        handler->imageCount();
+        handler->loopCount();
+        handler->read(&i);
+        handler->nextImageDelay();
+        handler->currentImageNumber();
+        handler->jumpToImage(0);
+        handler->jumpToNextImage();
+    } else { // static image
+        handler->read(&i);
+    }
+
+    delete handler;
+
+    return 0;
+}

autotests/ossfuzz/prepare_build.sh

@@ -0,0 +1,44 @@
+#!/bin/bash -eu
+#
+# SPDX-FileCopyrightText: 2018 Google Inc.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Based on https://github.com/google/oss-fuzz/blob/33aab4a70dc4b5811143d214536584a8c8cb3924/projects/kimageformats/Dockerfile
+# Copyright 2018 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+apt-get update && \
+    apt-get install -y cmake make autoconf automake autopoint libtool \
+    wget po4a ninja-build pkgconf
+
+git clone --depth 1 https://github.com/madler/zlib.git
+git clone --depth 1 -b v1.5.7 https://github.com/facebook/zstd.git
+wget https://sourceware.org/pub/bzip2/bzip2-1.0.8.tar.gz
+git clone --depth 1 https://github.com/tukaani-project/xz.git
+git clone --depth 1 --branch=RB-3.4 https://github.com/AcademySoftwareFoundation/openexr.git
+git clone --depth 1 -b master https://invent.kde.org/frameworks/extra-cmake-modules.git
+git clone --depth 1 --branch=dev git://code.qt.io/qt/qtbase.git
+git clone --depth 1 --branch=dev git://code.qt.io/qt/qttools.git
+git clone --depth 1 -b master https://invent.kde.org/frameworks/karchive.git
+git clone --depth 1 -b v3.14.1 https://aomedia.googlesource.com/aom
+git clone --depth 1 -b v1.4.2 https://github.com/AOMediaCodec/libavif.git
+git clone --depth 1 https://github.com/strukturag/libde265.git
+git clone --depth 1 -b v2.5.4 https://github.com/uclouvain/openjpeg.git
+git clone --depth 1 https://github.com/strukturag/libheif.git
+git clone --depth=1 --recursive --shallow-submodules https://github.com/libjxl/libjxl.git
+git clone --depth 1 https://github.com/LibRaw/LibRaw
+git clone --depth 1 https://github.com/mircomir/jxrlib.git
+git clone --depth 1 -b v2.6.0 https://github.com/cisco/openh264.git

autotests/read/avif/invalid-exif.avif.json

@@ -0,0 +1,7 @@
+[
+    {
+        "fileName": "invalid-exif.jpg",
+        "fuzziness": 30,
+        "description": "Minimum fuzziness value to pass the test on all architectures."
+    }
+]

autotests/read/avif/metadata.avif.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "metadata.png",
+        "colorSpace" : {
+            "description" : "sRGB build-in",
+            "primaries" : "SRgb",
+            "transferFunction" : "SRgb",
+            "gamma" : 0
+        },
         "metadata" : [
             {
                 "key" : "ModificationDate",

autotests/read/avif/profile_gray.avif.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "profile_gray.png",
+        "colorSpace" : {
+            "colorModel" : "Gray",
+            "primaries" : "Custom",
+            "transferFunction" : "SRgb",
+            "gamma" : 2.31
+        }
+    }
+]

autotests/read/avif/profile_gray_gamma22.avif.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "profile_gray_gamma22.png",
+        "colorSpace" : {
+            "colorModel" : "Gray",
+            "primaries" : "Custom",
+            "transferFunction" : "Gamma",
+            "gamma" : 2.2
+        }
+    }
+]

autotests/read/avif/profile_gray_gamma28.avif.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "profile_gray_gamma28.png",
+        "colorSpace" : {
+            "colorModel" : "Gray",
+            "primaries" : "Custom",
+            "transferFunction" : "Gamma",
+            "gamma" : 2.8
+        }
+    }
+]

autotests/read/avif/profile_gray_linear.avif.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "profile_gray_linear.png",
+        "colorSpace" : {
+            "colorModel" : "Gray",
+            "primaries" : "Custom",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        }
+    }
+]

autotests/read/avif/profile_gray_prophoto.avif.json

@@ -0,0 +1,12 @@
+[
+    {
+        "fileName" : "profile_gray_prophoto.png",
+        "colorSpace" : {
+            "description" : "grayscale D50 with ProPhoto TRC",
+            "colorModel" : "Gray",
+            "primaries" : "Custom",
+            "transferFunction" : "Custom",
+            "gamma" : 0
+        }
+    }
+]

autotests/read/dds/rgba_f16.dds.json

@@ -2,6 +2,12 @@
     {
         "fileName" : "rgba_f16.png",
         "fuzziness" : 1,
-        "description" : "Minimum fuzziness value to pass the test on all architectures."
+        "description" : "Minimum fuzziness value to pass the test on all architectures.",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        }
     }
 ]

autotests/read/exr/ps2026_testcard_rgb.exr.json

@@ -0,0 +1,15 @@
+[
+    {
+        "fileName" : "ps2026_testcard_rgb.png",
+        "colorSpace" : {
+            "description" : "sRGB build-in (Profilo RGB lineare)",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
+        "resolution" : {
+            "dotsPerMeterX" : 3937,
+            "dotsPerMeterY" : 3937
+        }
+    }
+]

autotests/read/exr/rgb-gimp.exr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "rgb-gimp.png",
+        "colorSpace" : {
+            "description" : "Embedded RGB (linear)",
+            "primaries" : "Custom",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "resolution" : {
             "dotsPerMeterX" : 3937,
             "dotsPerMeterY" : 3937

autotests/read/hdr/orientation1.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation2.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation3.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation4.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation5.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation6.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation7.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/hdr/orientation8.hdr.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "Linear sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "Linear",
+            "gamma" : 1
+        },
         "metadata" : [
             {
                 "key" : "Software" ,

autotests/read/heic/konqi.heic.json

@@ -0,0 +1,7 @@
+[
+    {
+        "fileName": "konqi.jpg",
+        "fuzziness": 72,
+        "description": "Minimum fuzziness value to pass the test on all architectures."
+    }
+]

autotests/read/heic/metadata.heic.json

@@ -1,6 +1,12 @@
 [
     {
         "fileName" : "metadata.png",
+        "colorSpace" : {
+            "description" : "sRGB build-in",
+            "primaries" : "SRgb",
+            "transferFunction" : "SRgb",
+            "gamma" : 0
+        },
         "metadata" : [
             {
                 "key" : "ModificationDate",

autotests/read/heic/orientation1.heic.json

@@ -0,0 +1,17 @@
+[
+    {
+        "fileName" : "orientation_all.png",
+        "colorSpace" : {
+            "description" : "GIMP built-in sRGB",
+            "primaries" : "SRgb",
+            "transferFunction" : "SRgb",
+            "gamma" : 0
+        },
+        "metadata" : [
+            {
+                "key" : "Software" ,
+                "value" : "LIFE Pro 2.20.35 (Linux)"
+            }
+        ]
+    }
+]

autotests/read/heic/orientation2.heic.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "orientation_all.png",
+        "metadata" : [
+            {
+                "key" : "Software" ,
+                "value" : "LIFE Pro 2.20.35 (Linux)"
+            }
+        ]
+    }
+]

autotests/read/heic/orientation3.heic.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "orientation_all.png",
+        "metadata" : [
+            {
+                "key" : "Software" ,
+                "value" : "LIFE Pro 2.20.35 (Linux)"
+            }
+        ]
+    }
+]

autotests/read/heic/orientation4.heic.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "orientation_all.png",
+        "metadata" : [
+            {
+                "key" : "Software" ,
+                "value" : "LIFE Pro 2.20.35 (Linux)"
+            }
+        ]
+    }
+]

autotests/read/heic/orientation5.heic.json

@@ -0,0 +1,11 @@
+[
+    {
+        "fileName" : "orientation_all.png",
+        "metadata" : [
+            {
+                "key" : "Software" ,
+                "value" : "LIFE Pro 2.20.35 (Linux)"
+            }
+        ]
+    }
+]