Add XCursor image format plug-in

Allows to read XCursor files, including ones with animation. The cursor hotspot is set in QImage textKeys as "HotspotX" and "HotspotY". The "Sizes" textKey contains a list of available sizes in this file.
2026-06-16 03:29:09 -04:00 · 2026-01-30 19:24:56 +01:00
59 changed files with 715 additions and 1357 deletions
--- a/.kde-ci.yml
+++ b/.kde-ci.yml
@@ -7,5 +7,5 @@ Dependencies:
 Options:
 test-before-installing: True
 require-passing-tests-on: ['Linux', 'FreeBSD', 'Windows']
- cmake-options: "-DKIMAGEFORMATS_WITH_KNOWN_CRASHES_JXR=ON -DKIMAGEFORMATS_HEIF=ON -DKIMAGEFORMATS_HEIF_TEST:STRING=OFF -DKIMAGEFORMATS_HEJ2_TEST:STRING=OFF -DKIMAGEFORMATS_AVCI_TEST:STRING=OFF"
+ cmake-options: "-DKIMAGEFORMATS_JXR=ON -DKIMAGEFORMATS_HEIF=ON -DKIMAGEFORMATS_HEIF_TEST:STRING=OFF -DKIMAGEFORMATS_HEJ2_TEST:STRING=OFF -DKIMAGEFORMATS_AVCI_TEST:STRING=OFF"
 per-test-timeout: 90
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,11 +1,11 @@
-cmake_minimum_required(VERSION 3.29)
+cmake_minimum_required(VERSION 3.27)

-set(KF_VERSION "6.26.0") # handled by release scripts
-set(KF_DEP_VERSION "6.26.0") # handled by release scripts
+set(KF_VERSION "6.23.0") # handled by release scripts
+set(KF_DEP_VERSION "6.22.0") # handled by release scripts
 project(KImageFormats VERSION ${KF_VERSION})

 include(FeatureSummary)
-find_package(ECM 6.26.0  NO_MODULE)
+find_package(ECM 6.22.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.9.0)
+set(REQUIRED_QT_VERSION 6.8.0)
 find_package(Qt6Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)

 find_package(KF6Archive ${KF_DEP_VERSION})
@@ -97,17 +97,16 @@ set_package_properties(LibRaw PROPERTIES
    PURPOSE "Required for the QImage plugin for RAW images"
 )

-# 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)
+# JXR plugin disabled by default due to security issues
+option(KIMAGEFORMATS_JXR "Enable plugin for JPEG XR format" OFF)
+if(KIMAGEFORMATS_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.11.0
-    KF 6.23.0
+    KF 6.21.0
 )

 add_subdirectory(src)
--- a/README.md
+++ b/README.md
@@ -21,7 +21,6 @@ The following image formats have read-only support:
 - Krita (kra)
 - OpenRaster (ora)
 - Pixar raster (pxr)
- PlayStation graphics (tim)
 - Portable FloatMap/HalfMap (pfm, phm)
 - Photoshop documents (psd, psb, pdd, psdt)
 - Radiance HDR (hdr)
@@ -155,31 +154,8 @@ About the image:
 - `Owner`: Name of the owner of the image.
 - `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.
@@ -274,7 +250,6 @@ limit depends on the format encoding).
 - 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

@@ -318,11 +293,6 @@ plugin:
 - `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
@@ -352,10 +322,6 @@ 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
@@ -411,11 +377,6 @@ 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
@@ -431,12 +392,7 @@ plugin:
 ### The JXR plugin

 **This plugin is disabled by default. It can be enabled by settings
-`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.**
+`KIMAGEFORMATS_JXR` to `ON` in your cmake options.**

 The following defines can be defined in cmake to modify the behavior of the 
 plugin:
@@ -485,13 +441,6 @@ 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
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -86,7 +86,6 @@ kimageformats_read_tests(
    ras
    rgb
    sct
-    tim
    tga
 )

@@ -248,3 +247,8 @@ add_executable(anitest anitest.cpp)
 target_link_libraries(anitest Qt6::Gui Qt6::Test)
 ecm_mark_as_test(anitest)
 add_test(NAME kimageformats-ani COMMAND anitest)
+
+add_executable(xcursortest xcursortest.cpp)
+target_link_libraries(xcursortest Qt6::Gui Qt6::Test)
+ecm_mark_as_test(xcursortest)
+add_test(NAME kimageformats-xcursortest COMMAND xcursortest)
--- a/autotests/README.md
+++ b/autotests/README.md
@@ -48,7 +48,7 @@ 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).
+(nornally 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 
--- a/autotests/ossfuzz/build_fuzzers.sh
+++ b/autotests/ossfuzz/build_fuzzers.sh
@@ -18,11 +18,6 @@
 # limitations under the License.
 #
 ################################################################################
-LDFLAGS=""
-if [[ $FUZZING_ENGINE == "afl" ]]; then
-    LDFLAGS="-fuse-ld=lld"
-fi
-export LDFLAGS

 # build zstd
 cd $SRC/zstd
@@ -180,7 +175,6 @@ HANDLER_TYPES="ANIHandler ani
        RAWHandler raw
        RGBHandler rgb
        ScitexHandler sct
-        TIMHandler tim
        TGAHandler tga
        XCFHandler xcf"

@@ -191,7 +185,7 @@ echo "$HANDLER_TYPES" | while read class format; do
  /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 -DHANDLER=$class -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 -DINITGUID -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_3.a /usr/local/lib/libIex-3_3.a /usr/local/lib/libImath-3_1.a /usr/local/lib/libIlmThread-3_3.a /usr/local/lib/libOpenEXRCore-3_3.a /usr/local/lib/libOpenEXRUtil-3_3.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
+  $CXX $CXXFLAGS -fPIC -DHANDLER=$class -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 -DINITGUID -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 -lKF6Archive /usr/local/lib/libz.a /usr/local/lib/libraw.a /usr/local/lib/libOpenEXR-3_3.a /usr/local/lib/libIex-3_3.a /usr/local/lib/libImath-3_1.a /usr/local/lib/libIlmThread-3_3.a /usr/local/lib/libOpenEXRCore-3_3.a /usr/local/lib/libOpenEXRUtil-3_3.a /usr/local/lib/libopenjp2.a /usr/local/lib/libzstd.a $SRC/jxrlib/build/libjxrglue.a $SRC/jxrlib/build/libjpegxr.a -llzma /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.

--- a/autotests/ossfuzz/kimgio_fuzzer.cc
+++ b/autotests/ossfuzz/kimgio_fuzzer.cc
@@ -23,7 +23,7 @@
  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|hdr|heif|iff|jp2|jxl|jxr|kra|ora|pcx|pfm|pic|psd|pxr|qoi|ras|raw|rgb|sct|tim|tga|xcf]_fuzzer
+    python infra/helper.py run_fuzzer kimageformats kimgio_[ani|avif|dds|exr|hdr|heif|iff|jp2|jxl|jxr|kra|ora|pcx|pfm|pic|psd|pxr|qoi|ras|raw|rgb|sct|tga|xcf]_fuzzer
 */

 #include <QBuffer>
@@ -52,7 +52,6 @@
 #include "raw_p.h"
 #include "rgb_p.h"
 #include "sct_p.h"
-#include "tim_p.h"
 #include "tga_p.h"
 #include "xcf_p.h"

--- a/autotests/ossfuzz/prepare_build.sh
+++ b/autotests/ossfuzz/prepare_build.sh
@@ -33,10 +33,10 @@ git clone --depth 1 -b master https://invent.kde.org/frameworks/extra-cmake-modu
 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.13.1 https://aomedia.googlesource.com/aom
-git clone --depth 1 -b v1.3.0 https://github.com/AOMediaCodec/libavif.git
+git clone --depth 1 -b v3.12.0 https://aomedia.googlesource.com/aom
+git clone --depth 1 -b v1.2.1 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 -b v2.5.3 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
--- a/autotests/read/exr/ps2026_testcard_rgb.exr
+++ b/autotests/read/exr/ps2026_testcard_rgb.exr
--- a/autotests/read/exr/ps2026_testcard_rgb.exr.json
+++ b/autotests/read/exr/ps2026_testcard_rgb.exr.json
@@ -1,15 +0,0 @@
-[
-    {
-        "fileName" : "ps2026_testcard_rgb.png",
-        "colorSpace" : {
-            "description" : "sRGB build-in (Profilo RGB lineare)",
-            "primaries" : "SRgb",
-            "transferFunction" : "Linear",
-            "gamma" : 1
-        },
-        "resolution" : {
-            "dotsPerMeterX" : 3937,
-            "dotsPerMeterY" : 3937
-        }
-    }
-]
--- a/autotests/read/exr/ps2026_testcard_rgb.png
+++ b/autotests/read/exr/ps2026_testcard_rgb.png
--- a/autotests/read/exr/rgb-gimp.exr.json
+++ b/autotests/read/exr/rgb-gimp.exr.json
@@ -2,7 +2,7 @@
    {
        "fileName" : "rgb-gimp.png",
        "colorSpace" : {
-            "description" : "Embedded RGB (linear)",
+            "description" : "",
            "primaries" : "Custom",
            "transferFunction" : "Linear",
            "gamma" : 1
--- a/autotests/read/jxr/metadata.jxr
+++ b/autotests/read/jxr/metadata.jxr
--- a/autotests/read/jxr/metadata.jxr.json
+++ b/autotests/read/jxr/metadata.jxr.json
@@ -14,7 +14,7 @@
            },
            {
                "key" : "Software" ,
-                "value" : "LIFE Pro 2.20.35"
+                "value" : "LIFE Pro 2.18.10"
            },
            {
                "key" : "Altitude",
@@ -32,10 +32,6 @@
                "key" : "Description",
                "value" : "TV broadcast test image."
            },
-            {
-                "key" : "HostComputer",
-                "value" : "Windows 11 Enterprise (25H2)"
-            },
            {
                "key" : "Latitude",
                "value" : "44.6478"
--- a/autotests/read/tim/testcard_idx4.png
+++ b/autotests/read/tim/testcard_idx4.png
--- a/autotests/read/tim/testcard_idx4.tim
+++ b/autotests/read/tim/testcard_idx4.tim
--- a/autotests/read/tim/testcard_idx8.png
+++ b/autotests/read/tim/testcard_idx8.png
--- a/autotests/read/tim/testcard_idx8.tim
+++ b/autotests/read/tim/testcard_idx8.tim
--- a/autotests/read/tim/testcard_rgb16.png
+++ b/autotests/read/tim/testcard_rgb16.png
--- a/autotests/read/tim/testcard_rgb16.tim
+++ b/autotests/read/tim/testcard_rgb16.tim
--- a/autotests/read/tim/testcard_rgb24.png
+++ b/autotests/read/tim/testcard_rgb24.png
--- a/autotests/read/tim/testcard_rgb24.tim
+++ b/autotests/read/tim/testcard_rgb24.tim
--- a/autotests/write/basic/jxl.json
+++ b/autotests/write/basic/jxl.json
@@ -13,18 +13,14 @@
            "key" : "ModificationDate",
            "value" : "2025-02-14T15:58:44+01:00"
        },
+        {
+            "key" : "Software" ,
+            "value" : "Adobe Photoshop 26.2 (Windows)"
+        },
        {
            "key" : "Altitude",
            "value" : "34"
        },
-        {
-            "key" : "Title",
-            "value" : "A test"
-        },
-        {
-            "key" : "Software",
-            "value" : "KImageFormats write test"
-        },
        {
            "key" : "Author",
            "value" : "KDE Project"
@@ -49,10 +45,6 @@
            "key" : "LensModel",
            "value" : "A1234"
        },
-        {
-            "key" : "LensSerialNumber",
-            "value" : "S/N:1234567"
-        },
        {
            "key" : "Longitude",
            "value" : "10.9254"
@@ -64,50 +56,6 @@
        {
            "key" : "Model",
            "value" : "KImageFormats"
-        },
-        {
-            "key" : "SerialNumber",
-            "value" : "S/N:7654321"
-        },
-        {
-            "key" : "Speed",
-            "value" : "13.2"
-        },
-        {
-            "key" : "DigitalZoomRatio",
-            "value" : "3.4"
-        },
-        {
-            "key" : "ExposureMode",
-            "value" : "2"
-        },
-        {
-            "key" : "ExposureProgram",
-            "value" : "6"
-        },
-        {
-            "key" : "ExposureTime",
-            "value" : "0.004"
-        },
-        {
-            "key" : "Flash",
-            "value" : "16"
-        },
-        {
-            "key" : "FNumber",
-            "value" : "1.6"
-        },
-        {
-            "key" : "FocalLength",
-            "value" : "5.96"
-        },
-        {
-            "key" : "ISOSpeedRatings",
-            "value" : "50"
-        },
-        {
-            "key" : "WhiteBalance",
-            "value" : "1"
        }
    ],
    "resolution" : {
--- a/autotests/write/basic/jxr.json
+++ b/autotests/write/basic/jxr.json
@@ -41,10 +41,6 @@
            "key" : "LensModel",
            "value" : "A1234"
        },
-        {
-            "key" : "LensSerialNumber",
-            "value" : "S/N:1234567"
-        },
        {
            "key" : "Longitude",
            "value" : "10.9254"
@@ -56,50 +52,6 @@
        {
            "key" : "Model",
            "value" : "KImageFormats"
-        },
-        {
-            "key" : "SerialNumber",
-            "value" : "S/N:7654321"
-        },
-        {
-            "key" : "Speed",
-            "value" : "13.2"
-        },
-        {
-            "key" : "DigitalZoomRatio",
-            "value" : "3.4"
-        },
-        {
-            "key" : "ExposureMode",
-            "value" : "2"
-        },
-        {
-            "key" : "ExposureProgram",
-            "value" : "6"
-        },
-        {
-            "key" : "ExposureTime",
-            "value" : "0.004"
-        },
-        {
-            "key" : "Flash",
-            "value" : "16"
-        },
-        {
-            "key" : "FNumber",
-            "value" : "1.6"
-        },
-        {
-            "key" : "FocalLength",
-            "value" : "5.96"
-        },
-        {
-            "key" : "ISOSpeedRatings",
-            "value" : "50"
-        },
-        {
-            "key" : "WhiteBalance",
-            "value" : "1"
        }
    ],
    "resolution" : {
--- a/autotests/writetest.cpp
+++ b/autotests/writetest.cpp
@@ -62,7 +62,7 @@ void setOptionalInfo(QImage &image, const QString &suffix)

    // Set metadata
    auto meta = obj.value("metadata").toArray();
-    for (auto &&jv : meta) {
+    for (auto jv : meta) {
        auto obj = jv.toObject();
        auto key = obj.value("key").toString();
        auto val = obj.value("value").toString();
@@ -106,7 +106,7 @@ bool checkOptionalInfo(QImage &image, const QString &suffix)

    // Test metadata
    auto meta = obj.value("metadata").toArray();
-    for (auto &&jv : meta) {
+    for (auto jv : meta) {
        auto obj = jv.toObject();
        auto key = obj.value("key").toString();
        auto val = obj.value("value").toString();
--- a/autotests/xcursor/wait
+++ b/autotests/xcursor/wait
--- a/autotests/xcursor/wait_24_1.png
+++ b/autotests/xcursor/wait_24_1.png
--- a/autotests/xcursor/wait_24_2.png
+++ b/autotests/xcursor/wait_24_2.png
--- a/autotests/xcursor/wait_24_3.png
+++ b/autotests/xcursor/wait_24_3.png
--- a/autotests/xcursor/wait_48_1.png
+++ b/autotests/xcursor/wait_48_1.png
--- a/autotests/xcursor/wait_48_2.png
+++ b/autotests/xcursor/wait_48_2.png
--- a/autotests/xcursor/wait_48_3.png
+++ b/autotests/xcursor/wait_48_3.png
--- a/autotests/xcursor/wait_72_1.png
+++ b/autotests/xcursor/wait_72_1.png
--- a/autotests/xcursor/wait_72_2.png
+++ b/autotests/xcursor/wait_72_2.png
--- a/autotests/xcursor/wait_72_3.png
+++ b/autotests/xcursor/wait_72_3.png
--- a/autotests/xcursortest.cpp
+++ b/autotests/xcursortest.cpp
@@ -0,0 +1,129 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Kai Uwe Broulik <kde@broulik.de>
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+ */
+
+#include <QImage>
+#include <QImageReader>
+#include <QTest>
+
+using namespace Qt::StringLiterals;
+
+static bool imgEquals(const QImage &im1, const QImage &im2)
+{
+    const int height = im1.height();
+    const int width = im1.width();
+    for (int i = 0; i < height; ++i) {
+        const auto *line1 = reinterpret_cast<const quint8 *>(im1.scanLine(i));
+        const auto *line2 = reinterpret_cast<const quint8 *>(im2.scanLine(i));
+        for (int j = 0; j < width; ++j) {
+            if (line1[j] - line2[j] != 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+class XCursorTests : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
+    }
+
+    void testReadMetadata()
+    {
+        QImageReader reader(QFINDTESTDATA("xcursor/wait"));
+
+        QVERIFY(reader.canRead());
+
+        QCOMPARE(reader.imageCount(), 18);
+
+        // By default it chooses the largest size
+        QCOMPARE(reader.size(), QSize(72, 72));
+
+        QCOMPARE(reader.text(u"Sizes"_s), u"24,48,72"_s);
+    }
+
+    void testRead_data()
+    {
+        QTest::addColumn<int>("size");
+        QTest::addColumn<int>("reference");
+
+        // It prefers downsampling over upsampling.
+        QTest::newRow("12px") << 12 << 24;
+        QTest::newRow("24px") << 24 << 24;
+        QTest::newRow("48px") << 48 << 48;
+        QTest::newRow("50px") << 50 << 72;
+        QTest::newRow("72px") << 72 << 72;
+        QTest::newRow("default") << 0 << 72;
+    }
+
+    void testRead()
+    {
+        QFETCH(int, size);
+        QFETCH(int, reference);
+
+        QImageReader reader(QFINDTESTDATA("xcursor/wait"));
+        QVERIFY(reader.canRead());
+        QCOMPARE(reader.currentImageNumber(), 0);
+
+        if (size) {
+            reader.setScaledSize(QSize(size, size));
+        }
+
+        QCOMPARE(reader.size(), QSize(reference, reference));
+
+        QImage aniFrame;
+        QVERIFY(reader.read(&aniFrame));
+
+        QImage img1(QFINDTESTDATA(u"xcursor/wait_%1_1.png"_s.arg(reference)));
+        img1.convertTo(aniFrame.format());
+
+        QVERIFY(imgEquals(aniFrame, img1));
+
+        QCOMPARE(reader.nextImageDelay(), 40);
+        QCOMPARE(reader.text(u"HotspotX"_s), u"48"_s);
+        QCOMPARE(reader.text(u"HotspotY"_s), u"48"_s);
+
+        QVERIFY(reader.canRead());
+        // that read() above should have advanced us to the next frame
+        QCOMPARE(reader.currentImageNumber(), 1);
+
+        QVERIFY(reader.read(&aniFrame));
+        QImage img2(QFINDTESTDATA(u"xcursor/wait_%1_2.png"_s.arg(reference)));
+        img2.convertTo(aniFrame.format());
+
+        QVERIFY(imgEquals(aniFrame, img2));
+
+        // Would be nice to have a cursor with variable delay and hotspot :-)
+        QCOMPARE(reader.nextImageDelay(), 40);
+        QCOMPARE(reader.text(u"HotspotX"_s), u"48"_s);
+        QCOMPARE(reader.text(u"HotspotY"_s), u"48"_s);
+
+        QVERIFY(reader.canRead());
+        QCOMPARE(reader.currentImageNumber(), 2);
+
+        QVERIFY(reader.read(&aniFrame));
+        QImage img3(QFINDTESTDATA(u"xcursor/wait_%1_3.png"_s.arg(reference)));
+        img3.convertTo(aniFrame.format());
+
+        QVERIFY(imgEquals(aniFrame, img3));
+
+        QCOMPARE(reader.text(u"HotspotX"_s), u"48"_s);
+        QCOMPARE(reader.text(u"HotspotY"_s), u"48"_s);
+        QCOMPARE(reader.nextImageDelay(), 40);
+
+        QVERIFY(reader.canRead());
+        QCOMPARE(reader.currentImageNumber(), 3);
+    }
+};
+
+QTEST_MAIN(XCursorTests)
+
+#include "xcursortest.moc"
--- a/src/imageformats/CMakeLists.txt
+++ b/src/imageformats/CMakeLists.txt
@@ -137,10 +137,6 @@ kimageformats_add_plugin(kimg_sct SOURCES sct.cpp)

 ##################################

-kimageformats_add_plugin(kimg_tim SOURCES tim.cpp)
-
-##################################
-
 kimageformats_add_plugin(kimg_tga SOURCES tga.cpp microexif.cpp scanlineconverter.cpp)

 ##################################
@@ -149,6 +145,10 @@ kimageformats_add_plugin(kimg_xcf SOURCES xcf.cpp)

 ##################################

+kimageformats_add_plugin(kimg_xcursor SOURCES xcursor.cpp)
+
+##################################
+
 if (LibRaw_FOUND)
    kimageformats_add_plugin(kimg_raw SOURCES raw.cpp)
    kde_enable_exceptions()
--- a/src/imageformats/ani.cpp
+++ b/src/imageformats/ani.cpp
@@ -5,7 +5,6 @@
 */

 #include "ani_p.h"
-#include "util_p.h"

 #include <QImage>
 #include <QLoggingCategory>
@@ -102,7 +101,7 @@ bool ANIHandler::read(QImage *outImage)
    }

    const auto frameSize = *(reinterpret_cast<const quint32_le *>(frameSizeData.data()));
-    if (!frameSize || frameSize > quint32(kMaxQVectorSize)) {
+    if (!frameSize) {
        return false;
    }

@@ -418,9 +417,6 @@ bool ANIHandler::ensureScanned() const
            // IART and INAM are technically inside LIST->INFO but "INFO" is supposedly optional
            // so just handle those two attributes wherever we encounter them
        } else if (chunkId == "INAM" || chunkId == "IART") {
-            if (chunkSize > kMaxQVectorSize) {
-                return false;
-            }
            const QByteArray value = device()->read(chunkSize);

            if (static_cast<quint32_le>(value.size()) != chunkSize) {
--- a/src/imageformats/avif.cpp
+++ b/src/imageformats/avif.cpp
@@ -513,12 +513,21 @@ bool QAVIFHandler::decode_one_frame()
 #else
        switch (m_decoder->image->imir.axis) {
 #endif
+#if QT_VERSION < QT_VERSION_CHECK(6, 9, 0)
+        case 0: // top-to-bottom
+            result = result.mirrored(false, true);
+            break;
+        case 1: // left-to-right
+            result = result.mirrored(true, false);
+            break;
+#else
        case 0: // top-to-bottom
            result = result.flipped(Qt::Vertical);
            break;
        case 1: // left-to-right
            result = result.flipped(Qt::Horizontal);
            break;
+#endif
        }
    }

--- a/src/imageformats/chunks.cpp
+++ b/src/imageformats/chunks.cpp
@@ -1080,7 +1080,6 @@ QByteArray BODYChunk::deinterleave(const QByteArray &planes, qint32 y, const BMH
            //        (red and green modify operations are unavailable)
            auto ctlbits = bitplanes > 5 ? 2 : 1;
            auto max = (1 << (bitplanes - ctlbits)) - 1;
-            auto wrongIdx = false;
            quint8 prev[3] = {};
            for (qint32 i = 0, cnt = 0; i < rowLen; ++i) {
                for (qint32 j = 0; j < 8; ++j, ++cnt) {
@@ -1112,7 +1111,7 @@ QByteArray BODYChunk::deinterleave(const QByteArray &planes, qint32 y, const BMH
                            prev[1] = qGreen(pal.at(idx));
                            prev[2] = qBlue(pal.at(idx));
                        } else {
-                            wrongIdx = true;
+                            qCWarning(LOG_IFFPLUGIN) << "BODYChunk::deinterleave(): palette index" << idx << "is out of range";
                        }
                        break;
                    }
@@ -1122,9 +1121,6 @@ QByteArray BODYChunk::deinterleave(const QByteArray &planes, qint32 y, const BMH
                    ba[cnt3 + 2] = char(prev[2]);
                }
            }
-            if (wrongIdx) {
-                qCWarning(LOG_IFFPLUGIN) << "BODYChunk::deinterleave(): HAM palette index out of range!";
-            }
        } else if ((modeId & CAMGChunk::ModeId::HalfBrite) && (cmap) &&
                   (bitplanes >= BITPLANES_HALFBRIDE_MIN && bitplanes <= BITPLANES_HALFBRIDE_MAX)) {
            // From A Quick Introduction to IFF.txt:
@@ -1137,7 +1133,6 @@ QByteArray BODYChunk::deinterleave(const QByteArray &planes, qint32 y, const BMH
            // absolute colors.
            ba = QByteArray(rowLen * 8, char());
            auto palSize = cmap->count();
-            auto wrongIdx = false;
            for (qint32 i = 0, cnt = 0; i < rowLen; ++i) {
                for (qint32 j = 0; j < 8; ++j, ++cnt) {
                    quint8 idx = 0, ctl = 0;
@@ -1152,13 +1147,10 @@ QByteArray BODYChunk::deinterleave(const QByteArray &planes, qint32 y, const BMH
                    if (idx < palSize) {
                        ba[cnt] = ctl ? idx + palSize : idx;
                    } else {
-                        wrongIdx = true;
+                        qCWarning(LOG_IFFPLUGIN) << "BODYChunk::deinterleave(): palette index" << idx << "is out of range";
                    }
                }
            }
-            if (wrongIdx) {
-                qCWarning(LOG_IFFPLUGIN) << "BODYChunk::deinterleave(): HalfBrite palette index out of range!";
-            }
        } else {
            // From A Quick Introduction to IFF.txt:
            //
@@ -2546,7 +2538,7 @@ static QByteArray decompressVdat(const QByteArray &comp)
 static QByteArray vdatToIlbmPlane(const QByteArray &vdatData, const BMHDChunk *header)
 {
    QByteArray ba(vdatData.size(), char());
-    auto rowLen = qint32(header->rowLen());
+    auto rowLen = header->rowLen();
    for (auto x = 0, n = 0; x < rowLen; x += 2) {
        for (auto y = 0, off = x, h = header->height(); y < h; y++, off += rowLen) {
            if ((off + 1 >= ba.size()) || n + 1 >= vdatData.size()) {
@@ -2852,7 +2844,7 @@ bool PLTEChunk::isValid() const
    if (dataBytes() < 4) {
        return false;
    }
-    if (dataBytes() - 4 < quint32(total()) * 3) {
+    if (dataBytes() - 4 < total() * 3) {
        return false;
    }
    return chunkId() == PLTEChunk::defaultChunkId();
@@ -3012,7 +3004,7 @@ QByteArray IDATChunk::strideRead(QIODevice *d, qint32 y, const IHDRChunk *header
        }

        if (header->model() == IHDRChunk::CLut4) {
-            if (rr.size() < (qint64(header->width()) + 1) / 2) {
+            if (rr.size() < header->width() / 2) {
                return {};
            }
            QByteArray tmp(header->width(), char());
@@ -3092,8 +3084,7 @@ quint32 IDATChunk::strideSize(const IHDRChunk *header) const
        return 0;
    }

-    // width() and depth() are at most 65535
-    auto rs = (quint32(header->width()) * header->depth() + 7) / 8;
+    auto rs = (header->width() * header->depth() + 7) / 8;

    // No padding bytes are inserted in the data.
    if (header->model() == IHDRChunk::Rgb888) {
--- a/src/imageformats/exr.cpp
+++ b/src/imageformats/exr.cpp
@@ -58,7 +58,6 @@
 #include <ImathBox.h>
 #include <ImfArray.h>
 #include <ImfBoxAttribute.h>
-#include <ImfOpaqueAttribute.h>
 #include <ImfChannelListAttribute.h>
 #include <ImfCompressionAttribute.h>
 #include <ImfConvert.h>
@@ -228,57 +227,25 @@ static QImage::Format imageFormat(const Imf::RgbaInputFile &file)

 /*!
 * \brief viewList
- * \param header The image header.
+ * \param header
 * \return The list of available views.
- * \note This plugin does not support compositing layers which are returned as single images.
 */
 static QStringList viewList(const Imf::Header &h)
 {
    QStringList l;
    if (auto views = h.findTypedAttribute<Imf::StringVectorAttribute>("multiView")) {
-        // Internally OpenEXR first checks if the multiView attribute is present:
-        // if present, I have no other layers.
        for (auto &&v : views->value()) {
            l << QString::fromStdString(v);
        }
-    } else {
-        // Recent versions of Photoshop save images by setting the layer.
-        // Channels are named Layer 1.A, Layer 1.B, etc., so I have to set
-        // the layer or the images will appear black.
-        auto channels = h.channels();
-        for (auto i = channels.begin(); i != channels.end(); ++i) {
-            auto name = QString::fromLatin1(i.name(), -1);
-            auto idx = name.indexOf(QChar(u'.'));
-            if (idx > -1)
-                l << name.left(idx);
-        }
-        l.removeDuplicates();
    }
    return l;
 }

-static QString setLayerName(Imf::RgbaInputFile &file, qint32 imageNumber = -1)
-{
-    // set the image to load
-    QString layerName;
-    auto &&header = file.header();
-    if (imageNumber > -1) {
-        auto views = viewList(header);
-        if (imageNumber < views.count())
-            layerName = views.at(imageNumber);
-    }
-    // set the layer name
-    if (!layerName.isEmpty()) {
-        file.setLayerName(layerName.toStdString());
-    }
-    return layerName;
-}
-
 #ifdef QT_DEBUG
 static void printAttributes(const Imf::Header &h)
 {
    for (auto i = h.begin(); i != h.end(); ++i) {
-        qCDebug(LOG_EXRPLUGIN) << i.name() << i.attribute().typeName();
+        qCDebug(LOG_EXRPLUGIN) << i.name();
    }
 }
 #endif
@@ -373,29 +340,15 @@ static void readColorSpace(const Imf::Header &header, QImage &image)
 {
    // final color operations
    QColorSpace cs;
-
-    // Photoshop 2026 allow to save the ICC profile as "iccProfile" attribute
-    if (auto iccProfile = header.findTypedAttribute<Imf::OpaqueAttribute>("iccProfile")) {
-        auto &&v = iccProfile->data();
-        cs = QColorSpace::fromIccProfile(QByteArray::fromRawData(v, v.size()));
+    if (auto chroma = header.findTypedAttribute<Imf::ChromaticitiesAttribute>("chromaticities")) {
+        auto &&v = chroma->value();
+        cs = QColorSpace(QPointF(v.white.x, v.white.y),
+                         QPointF(v.red.x, v.red.y),
+                         QPointF(v.green.x, v.green.y),
+                         QPointF(v.blue.x, v.blue.y),
+                         QColorSpace::TransferFunction::Linear);
    }
-
    if (!cs.isValid()) {
-        // Creating the ICC profile from Chromaticities
-        if (auto chroma = header.findTypedAttribute<Imf::ChromaticitiesAttribute>("chromaticities")) {
-            auto &&v = chroma->value();
-            cs = QColorSpace(QPointF(v.white.x, v.white.y),
-                             QPointF(v.red.x, v.red.y),
-                             QPointF(v.green.x, v.green.y),
-                             QPointF(v.blue.x, v.blue.y),
-                             QColorSpace::TransferFunction::Linear);
-            if (cs.isValid())
-                cs.setDescription(QStringLiteral("Embedded RGB (linear)"));
-        }
-    }
-
-    if (!cs.isValid()) {
-        // Use a linear profile
        cs = QColorSpace(QColorSpace::SRgbLinear);
    }
    image.setColorSpace(cs);
@@ -424,7 +377,12 @@ bool EXRHandler::read(QImage *outImage)
        auto &&header = file.header();

        // set the image to load
-        auto layerName = setLayerName(file, m_imageNumber);
+        if (m_imageNumber > -1) {
+            auto views = viewList(header);
+            if (m_imageNumber < views.count()) {
+                file.setLayerName(views.at(m_imageNumber).toStdString());
+            }
+        }

        // get image info
        Imath::Box2i dw = file.dataWindow();
@@ -443,9 +401,6 @@ bool EXRHandler::read(QImage *outImage)
            qCWarning(LOG_EXRPLUGIN) << "Failed to allocate image, invalid size?" << QSize(width, height);
            return false;
        }
-        if (!layerName.isEmpty()) {
-            image.setText(QStringLiteral("EXRLayerName"), layerName);
-        }

        Imf::Array2D<Imf::Rgba> pixels;
        pixels.resizeErase(EXR_LINES_PER_BLOCK, width);
@@ -733,7 +688,12 @@ QVariant EXRHandler::option(ImageOption option) const
            try {
                K_IStream istr(d);
                Imf::RgbaInputFile file(istr);
-                setLayerName(file, m_imageNumber);
+                if (m_imageNumber > -1) { // set the image to read
+                    auto views = viewList(file.header());
+                    if (m_imageNumber < views.count()) {
+                        file.setLayerName(views.at(m_imageNumber).toStdString());
+                    }
+                }
                Imath::Box2i dw = file.dataWindow();
                v = QVariant(QSize(dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1));
            } catch (const std::exception &) {
@@ -753,7 +713,6 @@ QVariant EXRHandler::option(ImageOption option) const
            try {
                K_IStream istr(d);
                Imf::RgbaInputFile file(istr);
-                setLayerName(file, m_imageNumber);
                v = QVariant::fromValue(imageFormat(file));
            } catch (const std::exception &) {
                // broken file or unsupported version
@@ -828,9 +787,12 @@ bool EXRHandler::canRead(QIODevice *device)
        return false;
    }

+#if OPENEXR_VERSION_MAJOR == 3 && OPENEXR_VERSION_MINOR > 2
+    // openexpr >= 3.3 uses seek and tell extensively
    if (device->isSequential()) {
        return false;
    }
+#endif

    const QByteArray head = device->peek(4);

--- a/src/imageformats/exr_p.h
+++ b/src/imageformats/exr_p.h
@@ -86,8 +86,6 @@ private:
     * - 7: lossy 4-by-4 pixel block compression, fields are compressed more
     * - 8: lossy DCT based compression, in blocks of 32 scanlines. More efficient for partial buffer access.
     * - 9: lossy DCT based compression, in blocks of 256 scanlines. More efficient space wise and faster to decode full frames than DWAA_COMPRESSION.
-     * - 10: High-Throughput JPEG2000 (HTJ2K), 256 scanlines (requires OpenEXR 3.4+).
-     * - 11: High-Throughput JPEG2000 (HTJ2K), 32 scanlines (requires OpenEXR 3.4+).
     */
    qint32 m_compressionRatio;

--- a/src/imageformats/hdr.cpp
+++ b/src/imageformats/hdr.cpp
@@ -54,10 +54,10 @@ public:
    {
        return width() > 0 && height() > 0 && width() <= HDR_MAX_IMAGE_WIDTH && height() <= HDR_MAX_IMAGE_HEIGHT;
    }
-    qint32 width() const { return m_size.width(); }
-    qint32 height() const { return m_size.height(); }
-    QString software() const { return m_software; }
-    QImageIOHandler::Transformations transformation() const { return m_transformation; }
+    qint32 width() const { return(m_size.width()); }
+    qint32 height() const { return(m_size.height()); }
+    QString software() const { return(m_software); }
+    QImageIOHandler::Transformations transformation() const { return(m_transformation); }

    /*!
     * \brief colorSpace
@@ -73,7 +73,7 @@ public:
     * 0.600 0.150 0.060 0.333 0.333" for red, green, blue
     * and white, respectively.
     */
-    QColorSpace colorSpace() const { return m_colorSpace; }
+    QColorSpace colorSpace() const { return(m_colorSpace); }

    /*!
     * \brief exposure
@@ -247,7 +247,7 @@ static bool Read_Old_Line(uchar *image, int width, QDataStream &s)
        s >> image[2];
        s >> image[3];

-        if (s.status() != QDataStream::Ok) {
+        if (s.atEnd()) {
            return false;
        }

@@ -340,24 +340,20 @@ static bool LoadHDR(QDataStream &s, const Header& h, QImage &img)

        // determine scanline type
        if ((width < MINELEN) || (MAXELEN < width)) {
-            if (!Read_Old_Line(image, width, s)) {
-                return false;
-            }
+            Read_Old_Line(image, width, s);
            RGBE_To_QRgbLine(image, scanline, h);
            continue;
        }

        s >> val;

-        if (s.status() != QDataStream::Ok) {
-            return false;
+        if (s.atEnd()) {
+            return true;
        }

        if (val != 2) {
            s.device()->ungetChar(val);
-            if (!Read_Old_Line(image, width, s)) {
-                return false;
-            }
+            Read_Old_Line(image, width, s);
            RGBE_To_QRgbLine(image, scanline, h);
            continue;
        }
@@ -366,15 +362,13 @@ static bool LoadHDR(QDataStream &s, const Header& h, QImage &img)
        s >> image[2];
        s >> image[3];

-        if (s.status() != QDataStream::Ok) {
-            return false;
+        if (s.atEnd()) {
+            return true;
        }

        if ((image[1] != 2) || (image[2] & 128)) {
            image[0] = 2;
-            if (!Read_Old_Line(image + 4, width - 1, s)) {
-                return false;
-            }
+            Read_Old_Line(image + 4, width - 1, s);
            RGBE_To_QRgbLine(image, scanline, h);
            continue;
        }
@@ -388,7 +382,7 @@ static bool LoadHDR(QDataStream &s, const Header& h, QImage &img)
        for (int i = 0, len = int(lineArray.size()); i < 4; i++) {
            for (int j = 0; j < width;) {
                s >> code;
-                if (s.status() != QDataStream::Ok) {
+                if (s.atEnd()) {
                    qCDebug(HDRPLUGIN) << "Truncated HDR file";
                    return false;
                }
@@ -516,7 +510,7 @@ bool HDRHandler::canRead(QIODevice *device)
    }

    // the .pic taken from official test cases does not start with this string but can be loaded.
-    if (device->peek(11) == "#?RADIANCE\n" || device->peek(7) == "#?RGBE\n") {
+    if(device->peek(11) == "#?RADIANCE\n" || device->peek(7) == "#?RGBE\n") {
        return true;
    }

--- a/src/imageformats/iff.cpp
+++ b/src/imageformats/iff.cpp
@@ -474,7 +474,11 @@ bool IFFHandler::readMayaImage(QImage *image)
        painter.setCompositionMode(QPainter::CompositionMode_Source);
        painter.drawImage(tp, ti);
    }
+#if QT_VERSION < QT_VERSION_CHECK(6, 9, 0)
+    img.mirror(false, true);
+#else
    img.flip(Qt::Orientation::Vertical);
+#endif
    addMetadata(img, form);

    *image = img;
--- a/src/imageformats/jp2.cpp
+++ b/src/imageformats/jp2.cpp
@@ -253,27 +253,20 @@ public:
    bool jp2ToImage(QImage *img) const
    {
        Q_ASSERT(img->depth() == 8 * sizeof(T) || img->depth() == 32 * sizeof(T));
-        if (img->width() < 1 || img->height() < 1) {
-            return false;
-        }
-        auto maxChannels = qint32(img->bytesPerLine() / sizeof(T) / img->width());
-        for (qint32 c = 0, cc = std::min(qint32(m_jp2_image->numcomps), maxChannels); c < cc; ++c) {
-            auto cs = std::min(cc == 1 ? 1 : 4, maxChannels);
+        for (qint32 c = 0, cc = m_jp2_image->numcomps; c < cc; ++c) {
+            auto cs = cc == 1 ? 1 : 4;
            auto &&jc = m_jp2_image->comps[c];
-            if (jc.data == nullptr) {
+            if (jc.data == nullptr)
                return false;
-            }
-            if (qint32(jc.w) != img->width() || qint32(jc.h) != img->height()) {
+            if (qint32(jc.w) != img->width() || qint32(jc.h) != img->height())
                return false;
-            }

            // discriminate between int and float (avoid complicating things by creating classes with template specializations)
            if (std::numeric_limits<T>::is_integer) {
-                auto divisor = 1ull;
-                auto prec = std::min(size_t(jc.prec), sizeof(*jc.data) * 8);
-                if (prec > sizeof(T) * 8 && prec < 64) {
+                auto divisor = 1;
+                if (jc.prec > sizeof(T) * 8) {
                    // convert to the wanted precision (e.g. 16-bit -> 8-bit: divisor = 65535 / 255 = 257)
-                    divisor = std::max(1ull, (((1ull << prec) - 1) / ((1ull << (sizeof(T) * 8)) - 1)));
+                    divisor = std::max(1, int(((1ll << jc.prec) - 1) / ((1ll << (sizeof(T) * 8)) - 1)));
                }
                for (qint32 y = 0, h = img->height(); y < h; ++y) {
                    auto ptr = reinterpret_cast<T *>(img->scanLine(y));
--- a/src/imageformats/jxl.cpp
+++ b/src/imageformats/jxl.cpp
@@ -2008,11 +2008,6 @@ bool QJpegXLHandler::extractBox(QByteArray &output, size_t container_size)
        return false;
    }

-    if (rawboxsize > 8388608) { // 8MB limit
-        qCWarning(LOG_JXLPLUGIN, "Skipped decoding of big JXL metadata box");
-        return true;
-    }
-
    output.resize(rawboxsize);
    status = JxlDecoderSetBoxBuffer(m_decoder, reinterpret_cast<uint8_t *>(output.data()), output.size());
    if (status != JXL_DEC_SUCCESS) {
@@ -2026,7 +2021,7 @@ bool QJpegXLHandler::extractBox(QByteArray &output, size_t container_size)
        if (status == JXL_DEC_BOX_NEED_MORE_OUTPUT) {
            size_t bytes_remains = JxlDecoderReleaseBoxBuffer(m_decoder);

-            if (output.size() > 33554432) { // approx. 32MB (4*8) limit for decompressed metadata box
+            if (output.size() > 4194304) { // approx. 4MB limit for decompressed metadata box
                qCWarning(LOG_JXLPLUGIN, "JXL metadata box is too large");
                m_parseState = ParseJpegXLError;
                return false;
--- a/src/imageformats/jxr.cpp
+++ b/src/imageformats/jxr.cpp
@@ -35,19 +35,14 @@
 #include <cstring>

 Q_DECLARE_LOGGING_CATEGORY(LOG_JXRPLUGIN)
-
-#ifdef QT_DEBUG
-Q_LOGGING_CATEGORY(LOG_JXRPLUGIN, "kf.imageformats.plugins.jxr", QtDebugMsg)
-#else
 Q_LOGGING_CATEGORY(LOG_JXRPLUGIN, "kf.imageformats.plugins.jxr", QtWarningMsg)
-#endif

 /*!
 * Support for float images
 *
 * NOTE: Float images have values greater than 1 so they need an additional in place conversion.
 */
-// #define JXR_DENY_FLOAT_IMAGE // default commented
+// #define JXR_DENY_FLOAT_IMAGE

 /*!
 * Remove the needs of additional memory by disabling the conversion between
@@ -117,35 +112,28 @@ public:
        , m_transformations(QImageIOHandler::TransformationNone)
    {
        m_tempDir = QSharedPointer<QTemporaryDir>(new QTemporaryDir);
-        if (auto err = PKCreateFactory(&pFactory, PK_SDK_VERSION)) {
-            qCCritical(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() error while initializing the JXR factory:" << err;
-        } else if (auto err = PKCreateCodecFactory(&pCodecFactory, WMP_SDK_VERSION)) {
-            qCCritical(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() error while initializing the JXR codec factory:" << err;
+        if (PKCreateFactory(&pFactory, PK_SDK_VERSION) == WMP_errSuccess) {
+            PKCreateCodecFactory(&pCodecFactory, WMP_SDK_VERSION);
+        }
+        if (pFactory == nullptr || pCodecFactory == nullptr) {
+            qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() initialization error of JXR library!";
        }
    }
    JXRHandlerPrivate(const JXRHandlerPrivate &other) = default;

    ~JXRHandlerPrivate()
    {
-        if (pDecoder) {
-            if (auto err = pDecoder->Release(&pDecoder)) {
-                qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() error while releasing the decoder:" << err;
-            }
-        }
-        if (pEncoder) {
-            if (auto err = pEncoder->Release(&pEncoder)) {
-                qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() error while releasing the encoder:" << err;
-            }
-        }
        if (pCodecFactory) {
-            if (auto err = pCodecFactory->Release(&pCodecFactory)) {
-                qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() error while releasing the codec factory:" << err;
-            }
+            PKCreateCodecFactory_Release(&pCodecFactory);
        }
        if (pFactory) {
-            if (auto err = pFactory->Release(&pFactory)) {
-                qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::JXRHandlerPrivate() error while releasing the factory:" << err;
-            }
+            PKCreateFactory_Release(&pFactory);
+        }
+        if (pDecoder) {
+            PKImageDecode_Release(&pDecoder);
+        }
+        if (pEncoder) {
+            PKImageEncode_Release(&pEncoder);
        }
    }

@@ -290,12 +278,8 @@ public:
    PKPixelFormatGUID jxrFormat() const
    {
        PKPixelFormatGUID pixelFormatGUID = GUID_PKPixelFormatUndefined;
-        if (pDecoder == nullptr) {
-            return pixelFormatGUID;
-        }
-        if (auto err = pDecoder->GetPixelFormat(pDecoder, &pixelFormatGUID)) {
-            qCCritical(LOG_JXRPLUGIN) << "JXRHandlerPrivate::jxrFormat() error while getting pixel format:" << err;
-            return GUID_PKPixelFormatUndefined;
+        if (pDecoder) {
+            pDecoder->GetPixelFormat(pDecoder, &pixelFormatGUID);
        }
        return pixelFormatGUID;
    }
@@ -319,12 +303,6 @@ public:
            return qtFormat;
        }

-        // *** MCH could be RGB, CMYK ***
-        qtFormat = multichannelFormat(jxrfmt, colorSpace());
-        if (qtFormat != QImage::Format_Invalid) {
-            return qtFormat;
-        }
-
        // *** CONVERSION WITH THE SAME DEPTH ***
        // IMPORTANT: For supported conversions see JXRGluePFC.c

@@ -415,20 +393,17 @@ public:
     */
    QSize imageSize() const
    {
-        if (pDecoder == nullptr) {
-            return {};
+        if (pDecoder) {
+            qint32 w, h;
+            pDecoder->GetSize(pDecoder, &w, &h);
+            if (w > JXR_MAX_IMAGE_WIDTH || h > JXR_MAX_IMAGE_HEIGHT || w < 1 || h < 1) {
+                qCCritical(LOG_JXRPLUGIN) << "JXRHandlerPrivate::imageSize() Maximum image size is limited to" << JXR_MAX_IMAGE_WIDTH << "x"
+                                          << JXR_MAX_IMAGE_HEIGHT << "pixels";
+                return {};
+            }
+            return QSize(w, h);
        }
-        qint32 w = 0, h = 0;
-        if (auto err = pDecoder->GetSize(pDecoder, &w, &h)) {
-            qCCritical(LOG_JXRPLUGIN) << "JXRHandlerPrivate::imageSize() error while getting the image size:" << err;
-            return {};
-        }
-        if (w > JXR_MAX_IMAGE_WIDTH || h > JXR_MAX_IMAGE_HEIGHT || w < 1 || h < 1) {
-            qCCritical(LOG_JXRPLUGIN) << "JXRHandlerPrivate::imageSize() Maximum image size is limited to" << JXR_MAX_IMAGE_WIDTH << "x"
-                                      << JXR_MAX_IMAGE_HEIGHT << "pixels";
-            return {};
-        }
-        return QSize(w, h);
+        return {};
    }

    /*!
@@ -441,8 +416,8 @@ public:
        if (pDecoder == nullptr) {
            return cs;
        }
-        quint32 size = 0;
-        if (!pDecoder->GetColorContext(pDecoder, nullptr, &size) && size > 0 && size < kMaxQVectorSize) {
+        quint32 size;
+        if (!pDecoder->GetColorContext(pDecoder, nullptr, &size) && size) {
            QByteArray ba(size, 0);
            if (!pDecoder->GetColorContext(pDecoder, reinterpret_cast<quint8 *>(ba.data()), &size)) {
                cs = QColorSpace::fromIccProfile(ba);
@@ -462,7 +437,7 @@ public:
            return xmp;
        }
 #ifdef JXR_ENABLE_ADVANCED_METADATA
-        quint32 size = 0;
+        quint32 size;
        if (!PKImageDecode_GetXMPMetadata_WMP(pDecoder, nullptr, &size) && size > 0 && size < JXR_MAX_METADATA_SIZE) {
            QByteArray ba(size, 0);
            if (!PKImageDecode_GetXMPMetadata_WMP(pDecoder, reinterpret_cast<quint8 *>(ba.data()), &size)) {
@@ -523,7 +498,7 @@ public:
        }
        auto host = hostComputer();
        if (!host.isEmpty()) {
-            image.setText(QStringLiteral(META_KEY_HOSTCOMPUTER), host);
+            image.setText(QStringLiteral(META_KEY_HOSTCOMPUTER), capt);
        }
        auto docn = documentName();
        if (!docn.isEmpty()) {
@@ -581,11 +556,7 @@ public:
        if (device == nullptr || pEncoder == nullptr) {
            return false;
        }
-        if (auto err = pEncoder->Terminate(pEncoder)) {
-            qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::finalizeWriting() error while terminating the encoder:" << err;
-            return false;
-        }
-        if (auto err = pEncoder->Release(&pEncoder)) {
+        if (auto err = PKImageEncode_Release(&pEncoder)) {
            qCWarning(LOG_JXRPLUGIN) << "JXRHandlerPrivate::finalizeWriting() error while releasing the encoder:" << err;
            return false;
        }
@@ -825,47 +796,6 @@ public:
        return GUID_PKPixelFormatUndefined;
    }

-    /*!
-     * \brief multichannelFormat
-     * I can only decide how to interpret multichannels by checking the color profile.
-     * If it's not present, I assume CMYK for 4 channels and RGB for 3 channels (like
-     * Windows does).
-     * \param jxrFormat Format to be converted.
-     * \param cs The color space of the image.
-     * \return A valid Qt format or QImage::Format_Invalid if there is no match
-     */
-    static QImage::Format multichannelFormat(const PKPixelFormatGUID &jxrFormat, const QColorSpace& cs)
-    {
-        auto model = QColorSpace::ColorModel::Undefined;
-        if (cs.isValid()) {
-            model = cs.colorModel();
-        } else if (!cs.iccProfile().isEmpty()) {
-            model = QColorSpace::ColorModel::Gray; // means invalid
-        }
-
-        if (IsEqualGUID(GUID_PKPixelFormat24bpp3Channels, jxrFormat)) {
-            if (model == QColorSpace::ColorModel::Rgb || model == QColorSpace::ColorModel::Undefined)
-                return QImage::Format_RGB888;
-        }
-
-        if (IsEqualGUID(GUID_PKPixelFormat32bpp4Channels, jxrFormat)) {
-            if (model == QColorSpace::ColorModel::Cmyk || model == QColorSpace::ColorModel::Undefined)
-                return QImage::Format_CMYK8888;
-        }
-
-        if (IsEqualGUID(GUID_PKPixelFormat32bpp3ChannelsAlpha, jxrFormat)) {
-            if (model == QColorSpace::ColorModel::Rgb || model == QColorSpace::ColorModel::Undefined)
-                return QImage::Format_RGBA8888;
-        }
-
-        if (IsEqualGUID(GUID_PKPixelFormat64bpp3ChannelsAlpha, jxrFormat)) {
-            if (model == QColorSpace::ColorModel::Rgb || model == QColorSpace::ColorModel::Undefined)
-                return QImage::Format_RGBA64;
-        }
-
-        return QImage::Format_Invalid;
-    }
-
 private:
    static QList<std::pair<QImage::Format, PKPixelFormatGUID>> exactMatchingFormats()
    {
@@ -1037,7 +967,7 @@ bool JXRHandler::read(QImage *outImage)
    }

    // resolution
-    float hres = 0, vres = 0;
+    float hres, vres;
    if (auto err = d->pDecoder->GetResolution(d->pDecoder, &hres, &vres)) {
        qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() error while reading resolution:" << err;
    } else {
@@ -1069,18 +999,14 @@ bool JXRHandler::read(QImage *outImage)
            return false;
        }
        if (auto err = pConverter->Initialize(pConverter, d->pDecoder, nullptr, convFmt)) {
+            PKFormatConverter_Release(&pConverter);
            qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() unable to initialize the converter:" << err;
-            if (auto err = pConverter->Release(&pConverter)) {
-                qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() error while releasing the converter:" << err;
-            }
            return false;
        }
        if (d->pDecoder->WMP.wmiI.cBitsPerUnit == size_t(img.depth())) { // in place conversion
            if (auto err = pConverter->Copy(pConverter, &rect, img.bits(), img.bytesPerLine())) {
+                PKFormatConverter_Release(&pConverter);
                qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() unable to copy converted data:" << err;
-                if (auto err = pConverter->Release(&pConverter)) {
-                    qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() error while releasing the converter:" << err;
-                }
                return false;
            }
        } else { // additional buffer needed
@@ -1089,26 +1015,19 @@ bool JXRHandler::read(QImage *outImage)
            qint64 limit = QImageReader::allocationLimit();
            if (limit && (buffSize + img.sizeInBytes()) > limit * 1024 * 1024) {
                qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() unable to covert due to allocation limit set:" << limit << "MiB";
-                if (auto err = pConverter->Release(&pConverter)) {
-                    qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() error while releasing the converter:" << err;
-                }
                return false;
            }
            QVector<quint8> ba(buffSize);
            if (auto err = pConverter->Copy(pConverter, &rect, ba.data(), convStrideSize)) {
+                PKFormatConverter_Release(&pConverter);
                qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() unable to copy converted data:" << err;
-                if (auto err = pConverter->Release(&pConverter)) {
-                    qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() error while releasing the converter:" << err;
-                }
                return false;
            }
            for (qint32 y = 0, h = img.height(); y < h; ++y) {
                std::memcpy(img.scanLine(y), ba.data() + convStrideSize * y, (std::min)(convStrideSize, qint64(img.bytesPerLine())));
            }
        }
-        if (auto err = pConverter->Release(&pConverter)) {
-            qCWarning(LOG_JXRPLUGIN) << "JXRHandler::read() error while releasing the converter:" << err;
-        }
+        PKFormatConverter_Release(&pConverter);
    }

    // Metadata (e.g.: icc profile, description, etc...)
--- a/src/imageformats/microexif.cpp
+++ b/src/imageformats/microexif.cpp
@@ -36,26 +36,17 @@
 #define TIFF_VAL_URES_CENTIMETER 3

 // EXIF 3 specs
-#define EXIF_EXPOSURETIME 0x829A
-#define EXIF_FNUMBER 0x829D
 #define EXIF_EXIFIFD 0x8769
-#define EXIF_EXPOSUREPROGRAM 0x8822
 #define EXIF_GPSIFD 0x8825
-#define EXIF_ISOSPEEDRATINGS 0x8827
 #define EXIF_EXIFVERSION 0x9000
 #define EXIF_DATETIMEORIGINAL 0x9003
 #define EXIF_DATETIMEDIGITIZED 0x9004
 #define EXIF_OFFSETTIME 0x9010
 #define EXIF_OFFSETTIMEORIGINAL 0x9011
 #define EXIF_OFFSETTIMEDIGITIZED 0x9012
-#define EXIF_FLASH 0x9209
-#define EXIF_FOCALLENGTH 0x920A
 #define EXIF_COLORSPACE 0xA001
 #define EXIF_PIXELXDIM 0xA002
 #define EXIF_PIXELYDIM 0xA003
-#define EXIF_EXPOSUREMODE 0xA402
-#define EXIF_WHITEBALANCE 0xA403
-#define EXIF_DIGITALZOOMRATIO 0xA404
 #define EXIF_IMAGEUNIQUEID 0xA420
 #define EXIF_BODYSERIALNUMBER 0xA431
 #define EXIF_LENSMAKE 0xA433
@@ -73,8 +64,6 @@
 #define GPS_LONGITUDE 4
 #define GPS_ALTITUDEREF 5
 #define GPS_ALTITUDE 6
-#define GPS_SPEEDREF 12
-#define GPS_SPEED 13
 #define GPS_IMGDIRECTIONREF 16
 #define GPS_IMGDIRECTION 17
 #define EXIF_TAG_VALUE(n, byteSize) (((n) << 6) | ((byteSize) & 0x3F))
@@ -134,25 +123,16 @@ static const KnownTags staticTagTypes = {
    TagInfo(TIFF_ARTIST, ExifTagType::Utf8),
    TagInfo(TIFF_DATETIME, ExifTagType::Ascii),
    TagInfo(TIFF_COPYRIGHT, ExifTagType::Utf8),
-    TagInfo(EXIF_EXPOSURETIME, ExifTagType::Rational),
-    TagInfo(EXIF_FNUMBER, ExifTagType::Rational),
    TagInfo(EXIF_EXIFIFD, ExifTagType::Long),
-    TagInfo(EXIF_EXPOSUREPROGRAM, ExifTagType::Short),
    TagInfo(EXIF_GPSIFD, ExifTagType::Long),
-    TagInfo(EXIF_ISOSPEEDRATINGS, ExifTagType::Short),
    TagInfo(EXIF_DATETIMEORIGINAL, ExifTagType::Ascii),
-    TagInfo(EXIF_DATETIMEDIGITIZED, ExifTagType::Ascii),
+    TagInfo(EXIF_OFFSETTIMEDIGITIZED, ExifTagType::Ascii),
    TagInfo(EXIF_OFFSETTIME, ExifTagType::Ascii),
    TagInfo(EXIF_OFFSETTIMEORIGINAL, ExifTagType::Ascii),
    TagInfo(EXIF_OFFSETTIMEDIGITIZED, ExifTagType::Ascii),
-    TagInfo(EXIF_FLASH, ExifTagType::Short),
-    TagInfo(EXIF_FOCALLENGTH, ExifTagType::Rational),
    TagInfo(EXIF_COLORSPACE, ExifTagType::Short),
    TagInfo(EXIF_PIXELXDIM, ExifTagType::Long),
    TagInfo(EXIF_PIXELYDIM, ExifTagType::Long),
-    TagInfo(EXIF_EXPOSUREMODE, ExifTagType::Short),
-    TagInfo(EXIF_WHITEBALANCE, ExifTagType::Short),
-    TagInfo(EXIF_DIGITALZOOMRATIO, ExifTagType::Rational),
    TagInfo(EXIF_IMAGEUNIQUEID, ExifTagType::Ascii),
    TagInfo(EXIF_BODYSERIALNUMBER, ExifTagType::Ascii),
    TagInfo(EXIF_LENSMAKE, ExifTagType::Utf8),
@@ -175,8 +155,6 @@ static const KnownTags staticGpsTagTypes = {
    TagInfo(GPS_LONGITUDE, ExifTagType::Rational),
    TagInfo(GPS_ALTITUDEREF, ExifTagType::Byte),
    TagInfo(GPS_ALTITUDE, ExifTagType::Rational),
-    TagInfo(GPS_SPEEDREF, ExifTagType::Ascii),
-    TagInfo(GPS_SPEED, ExifTagType::Rational),
    TagInfo(GPS_IMGDIRECTIONREF, ExifTagType::Ascii),
    TagInfo(GPS_IMGDIRECTION, ExifTagType::Rational)
 };
@@ -339,7 +317,7 @@ static void writeList(QDataStream &ds, const QVariant &value)
 inline qint32 rationalPrecision(double v)
 {
    v = qAbs(v);
-    return v < 1 ? 8 : 8 - qBound(0, int(std::log10(v)), 8);
+    return 8 - qBound(0, v < 1 ? 8 : int(std::log10(v)), 8);
 }

 template<class T>
@@ -906,7 +884,7 @@ QDateTime MicroExif::dateTime() const
    auto ofTag = exifString(EXIF_OFFSETTIME);
    if (dt.isValid() && !ofTag.isEmpty())
        dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(timeOffset(ofTag) * 60));
-    return dt;
+    return(dt);
 }

 void MicroExif::setDateTime(const QDateTime &dt)
@@ -926,7 +904,7 @@ QDateTime MicroExif::dateTimeOriginal() const
    auto ofTag = exifString(EXIF_OFFSETTIMEORIGINAL);
    if (dt.isValid() && !ofTag.isEmpty())
        dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(timeOffset(ofTag) * 60));
-    return dt;
+    return(dt);
 }

 void MicroExif::setDateTimeOriginal(const QDateTime &dt)
@@ -946,7 +924,7 @@ QDateTime MicroExif::dateTimeDigitized() const
    auto ofTag = exifString(EXIF_OFFSETTIMEDIGITIZED);
    if (dt.isValid() && !ofTag.isEmpty())
        dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(timeOffset(ofTag) * 60));
-    return dt;
+    return(dt);
 }

 void MicroExif::setDateTimeDigitized(const QDateTime &dt)
@@ -988,138 +966,6 @@ void MicroExif::setUniqueId(const QUuid &uuid)
        setExifString(EXIF_IMAGEUNIQUEID, uuid.toString(QUuid::WithoutBraces).replace(QStringLiteral("-"), QString()));
 }

-double MicroExif::digitalZoomRatio() const
-{
-    if (!m_exifTags.contains(EXIF_DIGITALZOOMRATIO))
-        return qQNaN();
-    return m_exifTags.value(EXIF_DIGITALZOOMRATIO).toDouble();
-
-}
-
-void MicroExif::setDigitalZoomRatio(double zoom)
-{
-    if (qIsNaN(zoom))
-        m_exifTags.remove(EXIF_DIGITALZOOMRATIO);
-    else
-        m_exifTags.insert(EXIF_DIGITALZOOMRATIO, zoom);
-}
-
-quint16 MicroExif::isoSpeedRatings() const
-{
-    return quint16(m_exifTags.value(EXIF_ISOSPEEDRATINGS).toUInt());
-}
-
-void MicroExif::setIsoSpeedRatings(quint16 iso)
-{
-    if (iso == 0)
-        m_exifTags.remove(EXIF_ISOSPEEDRATINGS);
-    else
-        m_exifTags.insert(EXIF_ISOSPEEDRATINGS, iso);
-}
-
-ExposureMode MicroExif::exposureMode() const
-{
-    auto ok = false;
-    auto v = m_exifTags.value(EXIF_EXPOSUREMODE).toUInt(&ok);
-    return ok ? ExposureMode(v) : ExposureMode::NotSet;
-}
-
-void MicroExif::setExposureMode(const ExposureMode &em)
-{
-    if (em == ExposureMode::NotSet)
-        m_exifTags.remove(EXIF_EXPOSUREMODE);
-    else
-        m_exifTags.insert(EXIF_EXPOSUREMODE, quint16(em));
-}
-
-ExposureProgram MicroExif::exposureProgram() const
-{
-    auto ok = false;
-    auto v = m_exifTags.value(EXIF_EXPOSUREPROGRAM).toUInt(&ok);
-    return ok ? ExposureProgram(v) : ExposureProgram::NotSet;
-}
-
-void MicroExif::setExposureProgram(const ExposureProgram &ep)
-{
-    if (ep == ExposureProgram::NotSet)
-        m_exifTags.remove(EXIF_EXPOSUREPROGRAM);
-    else
-        m_exifTags.insert(EXIF_EXPOSUREPROGRAM, quint16(ep));
-}
-
-double MicroExif::exposureTime() const
-{
-    if (!m_exifTags.contains(EXIF_EXPOSURETIME))
-        return qQNaN();
-    return m_exifTags.value(EXIF_EXPOSURETIME).toDouble();
-}
-
-void MicroExif::setExposureTime(double et)
-{
-    if (qIsNaN(et))
-        m_exifTags.remove(EXIF_EXPOSURETIME);
-    else
-        m_exifTags.insert(EXIF_EXPOSURETIME, et);
-}
-
-double MicroExif::fNumber() const
-{
-    if (!m_exifTags.contains(EXIF_FNUMBER))
-        return qQNaN();
-    return m_exifTags.value(EXIF_FNUMBER).toDouble();
-}
-
-void MicroExif::setFNumber(double f)
-{
-    if (qIsNaN(f))
-        m_exifTags.remove(EXIF_FNUMBER);
-    else
-        m_exifTags.insert(EXIF_FNUMBER, f);
-}
-
-double MicroExif::focalLength() const
-{
-    if (!m_exifTags.contains(EXIF_FOCALLENGTH))
-        return qQNaN();
-    return m_exifTags.value(EXIF_FOCALLENGTH).toDouble();
-}
-
-void MicroExif::setFocalLength(double fl)
-{
-    if (qIsNaN(fl))
-        m_exifTags.remove(EXIF_FOCALLENGTH);
-    else
-        m_exifTags.insert(EXIF_FOCALLENGTH, fl);
-}
-
-FlashFlags MicroExif::flash() const
-{
-    return FlashFlags(m_exifTags.value(EXIF_FLASH).toUInt());
-}
-
-void MicroExif::setFlash(const FlashFlags &flash)
-{
-    if (flash == Flash::NotSet)
-        m_exifTags.remove(EXIF_FLASH);
-    else
-        m_exifTags.insert(EXIF_FLASH, quint16(flash));
-}
-
-WhiteBalance MicroExif::whiteBalance() const
-{
-    auto ok = false;
-    auto v = m_exifTags.value(EXIF_WHITEBALANCE).toUInt(&ok);
-    return ok ? WhiteBalance(v) : WhiteBalance::NotSet;
-}
-
-void MicroExif::setWhiteBalance(const WhiteBalance &wb)
-{
-    if (wb == WhiteBalance::NotSet)
-        m_exifTags.remove(EXIF_WHITEBALANCE);
-    else
-        m_exifTags.insert(EXIF_WHITEBALANCE, quint16(wb));
-}
-
 double MicroExif::latitude() const
 {
    auto ref = gpsString(GPS_LATITUDEREF).toUpper();
@@ -1199,30 +1045,6 @@ void MicroExif::setAltitude(double meters)
    m_gpsTags.insert(GPS_ALTITUDE, meters);
 }

-double MicroExif::imageSpeed() const
-{
-    if (!m_gpsTags.contains(GPS_SPEED))
-        return qQNaN();
-    auto ref = gpsString(GPS_SPEEDREF).toUpper();
-    auto speed = m_gpsTags.value(GPS_SPEED).toDouble();
-    if (ref == QStringLiteral("M"))
-        speed *= 1.60934;
-    else if (ref == QStringLiteral("N"))
-        speed *= 1.852;
-    return speed;
-}
-
-void MicroExif::setImageSpeed(double kmh)
-{
-    if (qIsNaN(kmh)) {
-        m_gpsTags.remove(GPS_SPEEDREF);
-        m_gpsTags.remove(GPS_SPEED);
-        return;
-    }
-    m_gpsTags.insert(GPS_SPEEDREF, QStringLiteral("K"));
-    m_gpsTags.insert(GPS_SPEED, kmh);
-}
-
 double MicroExif::imageDirection(bool *isMagnetic) const
 {
    auto tmp = false;
@@ -1369,58 +1191,6 @@ void MicroExif::updateImageMetadata(QImage &targetImage, bool replaceExisting) c
        if (!qIsNaN(v))
            targetImage.setText(QStringLiteral(META_KEY_DIRECTION), QStringLiteral("%1").arg(v, 0, 'g', 9));
    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_SPEED)).isEmpty()) {
-        auto v = imageSpeed();
-        if (!qIsNaN(v))
-            targetImage.setText(QStringLiteral(META_KEY_SPEED), QStringLiteral("%1").arg(v, 0, 'g', 9));
-    }
-
-    // shot info
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_DIGITALZOOMRATIO)).isEmpty()) {
-        auto v = digitalZoomRatio();
-        if (!qIsNaN(v))
-            targetImage.setText(QStringLiteral(META_KEY_DIGITALZOOMRATIO), QStringLiteral("%1").arg(v, 0, 'g', 9));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_EXPOSUREMODE)).isEmpty()) {
-        auto v = exposureMode();
-        if (v != ExposureMode::NotSet)
-            targetImage.setText(QStringLiteral(META_KEY_EXPOSUREMODE), QStringLiteral("%1").arg(quint16(v)));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_EXPOSUREPROGRAM)).isEmpty()) {
-        auto v = exposureProgram();
-        if (v != ExposureProgram::NotSet)
-            targetImage.setText(QStringLiteral(META_KEY_EXPOSUREPROGRAM), QStringLiteral("%1").arg(quint16(v)));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_EXPOSURETIME)).isEmpty()) {
-        auto v = exposureTime();
-        if (!qIsNaN(v))
-            targetImage.setText(QStringLiteral(META_KEY_EXPOSURETIME), QStringLiteral("%1").arg(v, 0, 'g', 9));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_FLASH)).isEmpty()) {
-        auto v = flash();
-        if (v != Flash::NotSet)
-            targetImage.setText(QStringLiteral(META_KEY_FLASH), QStringLiteral("%1").arg(quint16(v)));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_FNUMBER)).isEmpty()) {
-        auto v = fNumber();
-        if (!qIsNaN(v))
-            targetImage.setText(QStringLiteral(META_KEY_FNUMBER), QStringLiteral("%1").arg(v, 0, 'g', 9));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_FOCALLENGTH)).isEmpty()) {
-        auto v = focalLength();
-        if (!qIsNaN(v))
-            targetImage.setText(QStringLiteral(META_KEY_FOCALLENGTH), QStringLiteral("%1").arg(v, 0, 'g', 9));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_ISOSPEEDRATINGS)).isEmpty()) {
-        auto v = isoSpeedRatings();
-        if (v != 0)
-            targetImage.setText(QStringLiteral(META_KEY_ISOSPEEDRATINGS), QStringLiteral("%1").arg(v));
-    }
-    if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_WHITEBALANCE)).isEmpty()) {
-        auto v = whiteBalance();
-        if (v != WhiteBalance::NotSet)
-            targetImage.setText(QStringLiteral(META_KEY_WHITEBALANCE), QStringLiteral("%1").arg(quint16(v)));
-    }
 }

 bool MicroExif::updateImageResolution(QImage &targetImage)
@@ -1447,7 +1217,7 @@ MicroExif MicroExif::fromByteArray(const QByteArray &ba, bool searchHeader)
            idx = std::min(idxLE, idxBE);
        else
            idx = idxLE > -1 ? idxLE : idxBE;
-        if (idx > 0)
+        if(idx > 0)
            ba0 = ba0.mid(idx);
    }
    QBuffer buf;
@@ -1538,7 +1308,7 @@ MicroExif MicroExif::fromImage(const QImage &image)
        dt = QDateTime::currentDateTime();
    exif.setDateTimeOriginal(dt);

-    // GPS info
+    // GPS Info
    auto ok = false;
    auto alt = image.text(QStringLiteral(META_KEY_ALTITUDE)).toDouble(&ok);
    if (ok)
@@ -1552,38 +1322,6 @@ MicroExif MicroExif::fromImage(const QImage &image)
    auto dir = image.text(QStringLiteral(META_KEY_DIRECTION)).toDouble(&ok);
    if (ok)
        exif.setImageDirection(dir);
-    auto spd = image.text(QStringLiteral(META_KEY_SPEED)).toDouble(&ok);
-    if (ok)
-        exif.setImageSpeed(spd);
-
-    // EXIF shot info
-    auto zoom = image.text(QStringLiteral(META_KEY_DIGITALZOOMRATIO)).toDouble(&ok);
-    if (ok)
-        exif.setDigitalZoomRatio(zoom);
-    auto expm = image.text(QStringLiteral(META_KEY_EXPOSUREMODE)).toUShort(&ok);
-    if (ok)
-        exif.setExposureMode(ExposureMode(expm));
-    auto expp = image.text(QStringLiteral(META_KEY_EXPOSUREPROGRAM)).toUShort(&ok);
-    if (ok)
-        exif.setExposureProgram(ExposureProgram(expp));
-    auto expt = image.text(QStringLiteral(META_KEY_EXPOSURETIME)).toDouble(&ok);
-    if (ok)
-        exif.setExposureTime(expt);
-    auto flsh = image.text(QStringLiteral(META_KEY_FLASH)).toUShort(&ok);
-    if (ok)
-        exif.setFlash(FlashFlags(flsh));
-    auto fnum = image.text(QStringLiteral(META_KEY_FNUMBER)).toDouble(&ok);
-    if (ok)
-        exif.setFNumber(fnum);
-    auto flen = image.text(QStringLiteral(META_KEY_FOCALLENGTH)).toDouble(&ok);
-    if (ok)
-        exif.setFocalLength(flen);
-    auto isos = image.text(QStringLiteral(META_KEY_ISOSPEEDRATINGS)).toUShort(&ok);
-    if (ok)
-        exif.setIsoSpeedRatings(isos);
-    auto whtb = image.text(QStringLiteral(META_KEY_WHITEBALANCE)).toUShort(&ok);
-    if (ok)
-        exif.setWhiteBalance(WhiteBalance(whtb));

    return exif;
 }
--- a/src/imageformats/microexif_p.h
+++ b/src/imageformats/microexif_p.h
@@ -24,85 +24,6 @@
 #define EXIF_DEFAULT_BYTEORDER QDataStream::BigEndian
 #endif

-/*!
-     * \brief The Flash enum
-     */
-enum class Flash : quint16 {
-    NotSet = 0,
-
-    // Values for bit 0 indicating whether the flash fired.
-    // 0b = Flash did not fire.
-    // 1b = Flash fired.
-    Fired = 1,
-
-    // Values for bits 1 and 2 indicating the status of returned light.
-    // 00b = No strobe return detection function
-    // 01b = reserved
-    // 10b = Strobe return light not detected.
-    // 11b = Strobe return light detected.
-    ReturnLightNotDetected = 2 << 1,
-    ReturnLightDetected = 3 << 1,
-
-    // Values for bits 3 and 4 indicating the camera's flash mode.
-    // 00b = unknown
-    // 01b = Compulsory flash firing
-    // 10b = Compulsory flash suppression
-    // 11b = Auto mode
-    CompulsoryFiring = 1 << 3,
-    CompulsorySuppression = 2 << 3,
-    AutoMode = 3 << 3,
-
-    // Values for bit 5 indicating the presence of a flash function.
-    // 0b = Flash function present
-    // 1b = No flash function
-    FlashNotAvailable = 1 << 5,
-
-    // Values for bit 6 indicating the camera's red-eye mode.
-    // 0b = No red-eye reduction mode or unknown
-    // 1b = Red-eye reduction supported
-    RedEyeReductionSupported = 1 << 6,
-};
-Q_DECLARE_FLAGS(FlashFlags, Flash)
-Q_DECLARE_OPERATORS_FOR_FLAGS(FlashFlags)
-
-/*!
-     * \brief The ExposureMode enum
-     */
-enum class ExposureMode : quint16 {
-    Auto,
-    Manual,
-    AutoBracket,
-
-    NotSet = 65535
-};
-
-/*!
-     * \brief The ExposureProgram enum
-     */
-enum class ExposureProgram : quint16 {
-    NotDefined,
-    Manual,
-    Normal,
-    AperturePriority,
-    ShutterPriority,
-    Creative,
-    Action,
-    PortraitMode,
-    LandscapeMode,
-
-    NotSet = 65535
-};
-
-/*!
-     * \brief The WhiteBalance enum
-     */
-enum class WhiteBalance : quint16 {
-    Auto,
-    Manual,
-
-    NotSet = 65535
-};
-
 /*!
 * \brief The MicroExif class
 * Class to extract / write minimal EXIF data (e.g. resolution, rotation,
@@ -315,69 +236,6 @@ public:
    QUuid uniqueId() const;
    void setUniqueId(const QUuid &uuid);

-    /*!
-     * \brief digitalZoomRatio
-     * \return The digital zoom ratio when the image was shot or NaN if not set.
-     */
-    double digitalZoomRatio() const;
-    void setDigitalZoomRatio(double zoom);
-
-    /*!
-     * \brief exposureMode
-     * \return The exposure mode set when the image was shot. In auto-bracketing mode, the camera shoots a series of frames of the same scene at different exposure settings.
-     */
-    ExposureMode exposureMode() const;
-    void setExposureMode(const ExposureMode& em);
-
-    /*!
-     * \brief exposureProgram
-     * \return The class of the program used by the camera to set exposure when the picture is taken.
-     */
-    ExposureProgram exposureProgram() const;
-    void setExposureProgram(const ExposureProgram& ep);
-
-    /*!
-     * \brief exposureTime
-     * \return Exposure time, given in seconds (sec) or NaN if not set.
-     */
-    double exposureTime() const;
-    void setExposureTime(double et);
-
-    /*!
-     * \brief fNumber
-     * \return The F number or NaN if not set.
-     */
-    double fNumber() const;
-    void setFNumber(double f);
-
-    /*!
-     * \brief focalLength
-     * \return The actual focal length of the lens, in mm.
-     */
-    double focalLength() const;
-    void setFocalLength(double fl);
-
-    /*!
-     * \brief flash
-     * \return The status of flash when the image was shot.
-     */
-    FlashFlags flash() const;
-    void setFlash(const FlashFlags& flash);
-
-    /*!
-     * \brief isoSpeedRatings
-     * \return The sensitivity of the camera or input device when the image was shot.
-     */
-    quint16 isoSpeedRatings() const;
-    void setIsoSpeedRatings(quint16 iso);
-
-    /*!
-     * \brief whiteBalance
-     * \return The white balance mode set when the image was shot.
-     */
-    WhiteBalance whiteBalance() const;
-    void setWhiteBalance(const WhiteBalance& wb);
-
    /*!
     * \brief latitude
     * \return Floating-point number indicating the latitude in degrees north of the equator (e.g. 27.717) or NaN if not set.
@@ -400,13 +258,6 @@ public:
    double altitude() const;
    void setAltitude(double meters);

-    /*!
-     * \brief imageSpeed
-     * \return The speed in Km/h or NaN if not set.
-     */
-    double imageSpeed() const;
-    void setImageSpeed(double kmh);
-
    /*!
     * \brief imageDirection
     * \param isMagnetic Set to true if the direction is relative to magnetic north, false if it is relative to true north. Leave nullptr if is not of interest.
--- a/src/imageformats/psd.cpp
+++ b/src/imageformats/psd.cpp
@@ -1017,7 +1017,7 @@ inline void rawChannelCopy(uchar *target, qint32 targetChannels, qint32 targetCh


 template<class T>
-inline bool cmykToRgb(uchar *target, qint32 targetChannels, const char *source, qint32 sourceChannels, qint32 width, bool alpha = false)
+inline void cmykToRgb(uchar *target, qint32 targetChannels, const char *source, qint32 sourceChannels, qint32 width, bool alpha = false)
 {
    auto s = reinterpret_cast<const T*>(source);
    auto t = reinterpret_cast<T*>(target);
@@ -1026,7 +1026,7 @@ inline bool cmykToRgb(uchar *target, qint32 targetChannels, const char *source,

    if (sourceChannels < 2) {
        qCDebug(LOG_PSDPLUGIN) << "cmykToRgb: image is not a valid MCH/CMYK!";
-        return false;
+        return;
    }

    for (qint32 w = 0; w < width; ++w) {
@@ -1047,7 +1047,6 @@ inline bool cmykToRgb(uchar *target, qint32 targetChannels, const char *source,
                *(pt + 3) = std::numeric_limits<T>::max();
        }
    }
-    return true;
 }

 inline double finv(double v)
@@ -1067,7 +1066,7 @@ inline double gammaCorrection(double linear)
 }

 template<class T>
-inline bool labToRgb(uchar *target, qint32 targetChannels, const char *source, qint32 sourceChannels, qint32 width, bool alpha = false)
+inline void labToRgb(uchar *target, qint32 targetChannels, const char *source, qint32 sourceChannels, qint32 width, bool alpha = false)
 {
    auto s = reinterpret_cast<const T*>(source);
    auto t = reinterpret_cast<T*>(target);
@@ -1076,7 +1075,7 @@ inline bool labToRgb(uchar *target, qint32 targetChannels, const char *source, q

    if (sourceChannels < 3) {
        qCDebug(LOG_PSDPLUGIN) << "labToRgb: image is not a valid LAB!";
-        return false;
+        return;
    }

    for (qint32 w = 0; w < width; ++w) {
@@ -1111,7 +1110,6 @@ inline bool labToRgb(uchar *target, qint32 targetChannels, const char *source, q
                *(pt + 3) = std::numeric_limits<T>::max();
        }
    }
-    return true;
 }

 bool readChannel(QByteArray &target, QDataStream &stream, quint32 compressedSize, quint16 compression)
@@ -1452,13 +1450,10 @@ bool PSDHandler::read(QImage *image)
            // Conversion to RGB
            if (header.color_mode == CM_CMYK || header.color_mode == CM_MULTICHANNEL) {
                if (tmpCmyk.isNull()) {
-                    if (header.depth == 8) {
-                        if (!cmykToRgb<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha))
-                            return false;
-                    } else if (header.depth == 16) {
-                        if (!cmykToRgb<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha))
-                            return false;
-                    }
+                    if (header.depth == 8)
+                        cmykToRgb<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
+                    else if (header.depth == 16)
+                        cmykToRgb<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
                } else if (header.depth == 8) {
                    rawChannelsCopyToCMYK<quint8>(tmpCmyk.bits(), 4, psdScanline.data(), header.channel_count, header.width);
                    if (auto rgbPtr = iccConv.convertedScanLine(tmpCmyk, 0))
@@ -1474,13 +1469,10 @@ bool PSDHandler::read(QImage *image)
                }
            }
            if (header.color_mode == CM_LABCOLOR) {
-                if (header.depth == 8) {
-                    if (!labToRgb<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha))
-                        return false;
-                } else if (header.depth == 16) {
-                    if (!labToRgb<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha))
-                        return false;
-                }
+                if (header.depth == 8)
+                    labToRgb<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
+                else if (header.depth == 16)
+                    labToRgb<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
            }
            if (header.color_mode == CM_RGB) {
                if (header.depth == 8)
--- a/src/imageformats/rgb.cpp
+++ b/src/imageformats/rgb.cpp
@@ -319,10 +319,7 @@ bool SGIImagePrivate::readImage(QImage &img)

    if (_rle) {
        uint l;
-        _starttab = new (std::nothrow) quint32[_numrows];
-        if (_starttab == nullptr) {
-            return false;
-        }
+        _starttab = new quint32[_numrows];
        for (l = 0; !_stream.atEnd() && l < _numrows; l++) {
            _stream >> _starttab[l];
            _starttab[l] -= 512 + _numrows * 2 * sizeof(quint32);
@@ -334,10 +331,7 @@ bool SGIImagePrivate::readImage(QImage &img)
            _starttab[l] = 0;
        }

-        _lengthtab = new (std::nothrow) quint32[_numrows];
-        if (_lengthtab == nullptr) {
-            return false;
-        }
+        _lengthtab = new quint32[_numrows];
        for (l = 0; !_stream.atEnd() && l < _numrows; l++) {
            _stream >> _lengthtab[l];
            if (_stream.status() != QDataStream::Ok) {
@@ -800,10 +794,7 @@ bool SGIImagePrivate::writeImage(const QImage &image)
    _pixmax = 0;
    _colormap = NORMAL;
    _numrows = _ysize * _zsize;
-    _starttab = new (std::nothrow) quint32[_numrows];
-    if (_starttab == nullptr) {
-        return false;
-    }
+    _starttab = new quint32[_numrows];
    _rlemap.setBaseOffset(512 + _numrows * 2 * sizeof(quint32));

    if (!scanData(image, tfmt, tcs)) {
--- a/src/imageformats/tga.cpp
+++ b/src/imageformats/tga.cpp
@@ -731,7 +731,7 @@ static bool LoadTGA(QIODevice *dev, const TgaHeader &tga, QImage &img)
                if (div == 0)
                    hasAlpha = false;
                for (int x = x_start; x != x_end; x += x_step) {
-                    const int alpha = hasAlpha ? int(quint8(src[3]) << (8 - numAlphaBits)) * 255 / div : 255;
+                    const int alpha = hasAlpha ? int((src[3]) << (8 - numAlphaBits)) * 255 / div : 255;
                    scanline[x] = qRgba(src[2], src[1], src[0], alpha);
                    src += 4;
                }
--- a/src/imageformats/tim.cpp
+++ b/src/imageformats/tim.cpp
@@ -1,398 +0,0 @@
-/*
-    This file is part of the KDE project
-    SPDX-FileCopyrightText: 2026 Mirco Miranda <mircomir@outlook.com>
-
-    SPDX-License-Identifier: LGPL-2.0-or-later
-*/
-
-#include "tim_p.h"
-#include "util_p.h"
-
-#include <QIODevice>
-#include <QImage>
-#include <QLoggingCategory>
-
-Q_DECLARE_LOGGING_CATEGORY(LOG_TIMPLUGIN)
-Q_LOGGING_CATEGORY(LOG_TIMPLUGIN, "kf.imageformats.plugins.tim", QtWarningMsg)
-
-#define TYPE_4BPP 0 // never seen
-#define TYPE_IDX_4BPP 8
-#define TYPE_8BPP 1 // never seen
-#define TYPE_IDX_8BPP 9
-#define TYPE_16BPP 2
-#define TYPE_24BPP 3
-
-#define HEADER_SIZE 20
-
-class TIMHeader
-{
-private:
-    QByteArray m_rawHeader;
-
-    quint16 ui16(quint8 c1, quint8 c2) const {
-        return (quint16(c2) << 8) | quint16(c1);
-    }
-
-    quint32 ui32(quint8 c1, quint8 c2, quint8 c3, quint8 c4) const {
-        return (quint32(c4) << 24) | (quint32(c3) << 16) | (quint32(c2) << 8) | quint32(c1);
-    }
-
-public:
-    TIMHeader()
-    {
-
-    }
-
-    quint32 type() const
-    {
-        if (m_rawHeader.size() < HEADER_SIZE) {
-            return 0;
-        }
-        return ui32(m_rawHeader.at(4), m_rawHeader.at(5), m_rawHeader.at(6), m_rawHeader.at(7)) & 0xF;
-    }
-
-    quint32 offset() const
-    {
-        if (m_rawHeader.size() < HEADER_SIZE) {
-            return 0;
-        }
-        auto o = quint32(HEADER_SIZE);
-        auto t = type();
-        if (t == TYPE_IDX_4BPP || t == TYPE_IDX_8BPP) { // indexed
-            o += ui32(m_rawHeader.at(8), m_rawHeader.at(9), m_rawHeader.at(10), m_rawHeader.at(11));
-        }
-        return o;
-    }
-
-    bool isValid(quint32 size = 0) const
-    {
-        if (m_rawHeader.size() < HEADER_SIZE) {
-            return false;
-        }
-        if (size == 0) {
-            size = offset();
-        }
-        if (m_rawHeader.size() < size) {
-            return false;
-        }
-        return (m_rawHeader.startsWith(QByteArray::fromRawData("\x10\x00\x00\x00", 4)));
-    }
-
-    bool isSupported() const
-    {
-        return format() != QImage::Format_Invalid;
-    }
-
-    qint32 width() const
-    {
-        auto strideLen = strideSize();
-        auto t = type();
-        if (t == TYPE_4BPP || t == TYPE_IDX_4BPP) {
-            return strideLen * 2;
-        }
-        if (t == TYPE_8BPP || t == TYPE_IDX_8BPP) {
-            return strideLen;
-        }
-        if (t == TYPE_24BPP) {
-            return strideLen / 3;
-        }
-        return strideLen / 2;
-    }
-
-    qint32 height() const
-    {
-        auto o = offset();
-        if (!isValid(o)) {
-            return 0;
-        }
-        return qint32(ui16(m_rawHeader.at(o - 2), m_rawHeader.at(o - 1)));
-    }
-
-    QSize size() const
-    {
-        return QSize(width(), height());
-    }
-
-    QImage::Format format() const
-    {
-        auto t = type();
-        if (t == TYPE_IDX_4BPP || t == TYPE_IDX_8BPP || t == TYPE_4BPP) {
-            return QImage::Format_Indexed8;
-        }
-        if (t == TYPE_IDX_8BPP) {
-            return QImage::Format_Grayscale8;
-        }
-        if (t == TYPE_16BPP) {
-            return QImage::Format_RGB555;
-        }
-        if (t == TYPE_24BPP) {
-            return QImage::Format_RGB888;
-        }
-        return QImage::Format_Invalid;
-    }
-
-    quint32 strideSize() const
-    {
-        auto o = offset();
-        if (!isValid(o)) {
-            return 0;
-        }
-        return ui16(m_rawHeader.at(o - 4), m_rawHeader.at(o - 3)) * 2;
-    }
-
-    qint32 paletteColors() const
-    {
-        if (this->format() != QImage::Format_Indexed8) {
-            return 0;
-        }
-        return qint32(ui16(m_rawHeader.at(16), m_rawHeader.at(17)));
-    }
-
-    qint32 paletteCount() const
-    {
-        if (this->format() != QImage::Format_Indexed8) {
-            return 0;
-        }
-        return qint32(ui16(m_rawHeader.at(18), m_rawHeader.at(19)));
-    }
-
-    QList<QRgb> palette() const
-    {
-        if (format() != QImage::Format_Indexed8) {
-            return {};
-        }
-
-        // 4bpp without CLUT is treated  as indexed
-        if (type() == TYPE_4BPP) {
-            QList<QRgb> pal;
-            for (auto i = 0; i < 16; ++i) {
-                auto v = i * 17;
-                pal << qRgb(v, v, v);
-            }
-            return pal;
-        }
-
-        // read the first paette only
-        auto len = paletteColors();
-        if (!isValid(HEADER_SIZE + len * 2)) {
-            return {};
-        }
-        QList<QRgb> clut;
-        for (auto i = 0; i < len; ++i) {
-            auto v = ui16(m_rawHeader.at(HEADER_SIZE + i * 2), m_rawHeader.at(HEADER_SIZE + i * 2 + 1));
-            // in some specs, the bit 15 is the alpha but with the image sample used, transparencies appear
-            // where there shouldn't be any (so, disabled for now)
-            clut << qRgba((v & 0x1F) * 255 / 31, ((v >> 5) & 0x1F) * 255 / 31, ((v >> 10) & 0x1F) * 255 / 31, 255);
-        }
-        return clut;
-    }
-
-    bool read(QIODevice *d)
-    {
-        m_rawHeader = d->read(HEADER_SIZE);
-        if (m_rawHeader.size() != HEADER_SIZE) {
-            return false;
-        }
-        auto o = offset() - HEADER_SIZE;
-        if (o > kMaxQVectorSize - HEADER_SIZE) {
-            return false;
-        }
-        m_rawHeader.append(d->read(o));
-        return isValid();
-    }
-
-    bool peek(QIODevice *d)
-    {
-        m_rawHeader = d->peek(HEADER_SIZE);
-        if (m_rawHeader.size() != HEADER_SIZE) {
-            return false;
-        }
-        auto o = offset();
-        if (o > kMaxQVectorSize - HEADER_SIZE) {
-            return false;
-        }
-        if (o > m_rawHeader.size()) {
-            m_rawHeader = d->peek(o);
-        }
-        return isValid();
-    }
-
-    bool jumpToImageData(QIODevice *d) const
-    {
-        if (d->isSequential()) {
-            if (auto sz = std::max(offset() - quint32(m_rawHeader.size()), quint32())) {
-                return d->read(sz).size() == sz;
-            }
-            return true;
-        }
-        return d->seek(offset());
-    }
-};
-
-class TIMHandlerPrivate
-{
-public:
-    TIMHandlerPrivate() {}
-    ~TIMHandlerPrivate() {}
-
-    TIMHeader m_header;
-};
-
-TIMHandler::TIMHandler()
-    : QImageIOHandler()
-    , d(new TIMHandlerPrivate)
-{
-}
-
-bool TIMHandler::canRead() const
-{
-    if (canRead(device())) {
-        setFormat("tim");
-        return true;
-    }
-    return false;
-}
-
-bool TIMHandler::canRead(QIODevice *device)
-{
-    if (!device) {
-        qCWarning(LOG_TIMPLUGIN) << "TIMHandler::canRead() called with no device";
-        return false;
-    }
-
-    TIMHeader h;
-    if (!h.peek(device)) {
-        return false;
-    }
-
-    return h.isSupported();
-}
-
-bool TIMHandler::read(QImage *image)
-{
-    auto&& header = d->m_header;
-
-    if (!header.read(device())) {
-        qCWarning(LOG_TIMPLUGIN) << "TIMHandler::read() invalid header";
-        return false;
-    }
-
-    auto img = imageAlloc(header.size(), header.format());
-    if (img.isNull()) {
-        qCWarning(LOG_TIMPLUGIN) << "TIMHandler::read() error while allocating the image";
-        return false;
-    }
-
-    if (img.format() == QImage::Format_Indexed8) {
-        auto pal = header.palette();
-        if (pal.isEmpty()) {
-            qCWarning(LOG_TIMPLUGIN) << "TIMHandler::read() error while reading the palette";
-            return false;
-        }
-        img.setColorTable(pal);
-    }
-
-    auto d = device();
-    if (!header.jumpToImageData(d)) {
-        qCWarning(LOG_TIMPLUGIN) << "TIMHandler::read() error while seeking image data";
-        return false;
-    }
-
-    auto size = std::min(img.bytesPerLine(), qsizetype(header.strideSize()));
-    QByteArray tmpBuff;
-    auto conv_4bpp = (header.type() == TYPE_4BPP || header.type() == TYPE_IDX_4BPP);
-    if (conv_4bpp && size * 2 <= img.bytesPerLine()) {
-        tmpBuff.resize(size);
-    }
-    for (auto y = 0, h = img.height(); y < h; ++y) {
-        auto line = reinterpret_cast<char*>(img.scanLine(y));
-        auto tbuf = tmpBuff.isEmpty() ? line : tmpBuff.data();
-        if (d->read(tbuf, size) != size) {
-            qCWarning(LOG_TIMPLUGIN) << "TIMHandler::read() error while reading image scanline";
-            return false;
-        }
-        if (conv_4bpp) {
-            for (auto x = 0, w = qint32(tmpBuff.size()); x < w; ++x) {
-                auto &&v = tmpBuff.at(x);
-                line[x * 2 + 1] = (v >> 4) & 0xF;
-                line[x * 2] = v & 0xF;
-            }
-        }
-    }
-
-    if (img.format() == QImage::Format_RGB555) {
-        img.rgbSwap();
-    }
-
-    *image = img;
-    return true;
-}
-
-bool TIMHandler::supportsOption(ImageOption option) const
-{
-    if (option == QImageIOHandler::Size) {
-        return true;
-    }
-    if (option == QImageIOHandler::ImageFormat) {
-        return true;
-    }
-    return false;
-}
-
-QVariant TIMHandler::option(ImageOption option) const
-{
-    QVariant v;
-
-    if (option == QImageIOHandler::Size) {
-        auto&& h = d->m_header;
-        if (h.isValid()) {
-            v = QVariant::fromValue(h.size());
-        } else if (auto d = device()) {
-            if (h.peek(d)) {
-                v = QVariant::fromValue(h.size());
-            }
-        }
-    }
-
-    if (option == QImageIOHandler::ImageFormat) {
-        auto&& h = d->m_header;
-        if (h.isValid()) {
-            v = QVariant::fromValue(h.format());
-        } else if (auto d = device()) {
-            if (h.peek(d)) {
-                v = QVariant::fromValue(h.format());
-            }
-        }
-    }
-
-    return v;
-}
-
-QImageIOPlugin::Capabilities TIMPlugin::capabilities(QIODevice *device, const QByteArray &format) const
-{
-    if (format == "tim") {
-        return Capabilities(CanRead);
-    }
-    if (!format.isEmpty()) {
-        return {};
-    }
-    if (!device->isOpen()) {
-        return {};
-    }
-
-    Capabilities cap;
-    if (device->isReadable() && TIMHandler::canRead(device)) {
-        cap |= CanRead;
-    }
-    return cap;
-}
-
-QImageIOHandler *TIMPlugin::create(QIODevice *device, const QByteArray &format) const
-{
-    QImageIOHandler *handler = new TIMHandler;
-    handler->setDevice(device);
-    handler->setFormat(format);
-    return handler;
-}
-
-#include "moc_tim_p.cpp"
--- a/src/imageformats/tim.json
+++ b/src/imageformats/tim.json
@@ -1,4 +0,0 @@
-{
-    "Keys": [ "tim" ],
-    "MimeTypes": [ "image/x-tim" ]
-}
--- a/src/imageformats/tim_p.h
+++ b/src/imageformats/tim_p.h
@@ -1,42 +0,0 @@
-/*
-    This file is part of the KDE project
-    SPDX-FileCopyrightText: 2026 Mirco Miranda <mircomir@outlook.com>
-
-    SPDX-License-Identifier: LGPL-2.0-or-later
-*/
-
-#ifndef KIMG_TIM_P_H
-#define KIMG_TIM_P_H
-
-#include <QImageIOPlugin>
-#include <QScopedPointer>
-
-class TIMHandlerPrivate;
-class TIMHandler : public QImageIOHandler
-{
-public:
-    TIMHandler();
-
-    bool canRead() const override;
-    bool read(QImage *image) override;
-
-    bool supportsOption(QImageIOHandler::ImageOption option) const override;
-    QVariant option(QImageIOHandler::ImageOption option) const override;
-
-    static bool canRead(QIODevice *device);
-
-private:
-    const QScopedPointer<TIMHandlerPrivate> d;
-};
-
-class TIMPlugin : public QImageIOPlugin
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "tim.json")
-
-public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
-};
-
-#endif // KIMG_TIM_P_H
--- a/src/imageformats/util_p.h
+++ b/src/imageformats/util_p.h
@@ -34,22 +34,10 @@
 #define META_KEY_MODIFICATIONDATE "ModificationDate"
 #define META_KEY_OWNER "Owner"
 #define META_KEY_SOFTWARE "Software"
-#define META_KEY_SPEED "Speed"
 #define META_KEY_TITLE "Title"
 #define META_KEY_XML_GIMP "XML:org.gimp.xml"
 #define META_KEY_XMP_ADOBE "XML:com.adobe.xmp"

-// Shot info metadata keys
-#define META_KEY_DIGITALZOOMRATIO "DigitalZoomRatio"
-#define META_KEY_EXPOSUREMODE "ExposureMode"
-#define META_KEY_EXPOSUREPROGRAM "ExposureProgram"
-#define META_KEY_EXPOSURETIME "ExposureTime"
-#define META_KEY_FLASH "Flash"
-#define META_KEY_FNUMBER "FNumber"
-#define META_KEY_FOCALLENGTH "FocalLength"
-#define META_KEY_ISOSPEEDRATINGS "ISOSpeedRatings"
-#define META_KEY_WHITEBALANCE "WhiteBalance"
-
 // Camera info metadata keys
 #define META_KEY_MANUFACTURER "Manufacturer"
 #define META_KEY_MODEL "Model"
--- a/src/imageformats/xcursor.cpp
+++ b/src/imageformats/xcursor.cpp
@@ -0,0 +1,349 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Kai Uwe Broulik <kde@broulik.de>
+ *
+ * SPDX-License-Identifier: LGPL-2.0-or-later
+ */
+
+#include "xcursor_p.h"
+
+#include <QImage>
+#include <QLoggingCategory>
+#include <QScopeGuard>
+#include <QVariant>
+
+#include <algorithm>
+
+#include "util_p.h"
+
+#ifdef QT_DEBUG
+Q_LOGGING_CATEGORY(LOG_XCURSORPLUGIN, "kf.imageformats.plugins.xcursor", QtDebugMsg)
+#else
+Q_LOGGING_CATEGORY(LOG_XCURSORPLUGIN, "kf.imageformats.plugins.xcursor", QtWarningMsg)
+#endif
+
+using namespace Qt::StringLiterals;
+
+static constexpr quint32 XCURSOR_MAGIC = 0x72756358; // "Xcur"
+static constexpr quint32 XCURSOR_IMAGE_TYPE = 0xfffd0002;
+
+XCursorHandler::XCursorHandler() = default;
+
+bool XCursorHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("xcursor");
+        return true;
+    }
+
+    // Check if there's another frame coming.
+    QDataStream stream(device());
+    stream.setByteOrder(QDataStream::LittleEndian);
+
+    // no peek on QDataStream...
+    const auto oldPos = device()->pos();
+    auto cleanup = qScopeGuard([this, oldPos] {
+        device()->seek(oldPos);
+    });
+
+    quint32 headerSize, type, subtype, version, width, height, xhot, yhot, delay;
+    stream >> headerSize >> type >> subtype >> version >> width >> height >> xhot >> yhot >> delay;
+
+    if (type != XCURSOR_IMAGE_TYPE || width == 0 || height == 0) {
+        return false;
+    }
+
+    return true;
+}
+
+bool XCursorHandler::read(QImage *outImage)
+{
+    if (!ensureScanned()) {
+        return false;
+    }
+
+    const auto firstFrameOffset = m_images.value(m_currentSize).first();
+    if (device()->pos() < firstFrameOffset) {
+        device()->seek(firstFrameOffset);
+    }
+
+    QDataStream stream(device());
+    stream.setByteOrder(QDataStream::LittleEndian);
+
+    quint32 headerSize, type, subtype, version, width, height, xhot, yhot, delay;
+    stream >> headerSize >> type >> subtype >> version >> width >> height >> xhot >> yhot >> delay;
+
+    if (type != XCURSOR_IMAGE_TYPE || width == 0 || height == 0) {
+        return false;
+    }
+
+    QImage image = imageAlloc(width, height, QImage::Format_ARGB32);
+    if (image.isNull()) {
+        return false;
+    }
+
+    const qsizetype byteCount = width * height * sizeof(quint32);
+    if (stream.readRawData(reinterpret_cast<char *>(image.bits()), byteCount) != byteCount) {
+        return false;
+    }
+
+    *outImage = image;
+    ++m_currentImageNumber;
+    m_nextImageDelay = delay;
+    m_hotspot = QPoint(xhot, yhot);
+
+    return !image.isNull();
+}
+
+int XCursorHandler::currentImageNumber() const
+{
+    if (!ensureScanned()) {
+        return 0;
+    }
+    return m_currentImageNumber;
+}
+
+int XCursorHandler::imageCount() const
+{
+    if (!ensureScanned()) {
+        return 0;
+    }
+    return m_images.value(m_currentSize).count();
+}
+
+bool XCursorHandler::jumpToImage(int imageNumber)
+{
+    if (!ensureScanned()) {
+        return false;
+    }
+
+    if (imageNumber < 0) {
+        return false;
+    }
+
+    if (imageNumber == m_currentImageNumber) {
+        return true;
+    }
+
+    if (imageNumber >= imageCount()) {
+        return false;
+    }
+
+    if (!device()->seek(m_images.value(m_currentSize).at(imageNumber))) {
+        return false;
+    }
+
+    return true;
+}
+
+bool XCursorHandler::jumpToNextImage()
+{
+    if (!ensureScanned()) {
+        return false;
+    }
+    return jumpToImage(m_currentImageNumber + 1);
+}
+
+int XCursorHandler::loopCount() const
+{
+    if (!ensureScanned()) {
+        return 0;
+    }
+    return -1;
+}
+
+int XCursorHandler::nextImageDelay() const
+{
+    if (!ensureScanned()) {
+        return 0;
+    }
+    return m_nextImageDelay;
+}
+
+bool XCursorHandler::supportsOption(ImageOption option) const
+{
+    return option == Size || option == ScaledSize || option == Description || option == Animation;
+}
+
+QVariant XCursorHandler::option(ImageOption option) const
+{
+    if (!supportsOption(option) || !ensureScanned()) {
+        return QVariant();
+    }
+
+    switch (option) {
+    case QImageIOHandler::Size:
+        return QSize(m_currentSize, m_currentSize);
+    case QImageIOHandler::Description: {
+        QString description;
+
+        if (m_hotspot.has_value()) {
+            description.append(u"HotspotX: %1\n\n"_s.arg(m_hotspot->x()));
+            description.append(u"HotspotY: %1\n\n"_s.arg(m_hotspot->y()));
+        }
+
+        // TODO std::transform...
+        QStringList stringSizes;
+        stringSizes.reserve(m_images.size());
+        for (auto it = m_images.keyBegin(); it != m_images.keyEnd(); ++it) {
+            stringSizes.append(QString::number(*it));
+        }
+        description.append(u"Sizes: %1\n\n"_s.arg(stringSizes.join(','_L1)));
+
+        return description;
+    }
+
+    case QImageIOHandler::Animation:
+        return imageCount() > 1;
+    default:
+        break;
+    }
+
+    return QVariant();
+}
+
+void XCursorHandler::setOption(ImageOption option, const QVariant &value)
+{
+    switch (option) {
+    case QImageIOHandler::ScaledSize:
+        m_scaledSize = value.toSize();
+        pickSize();
+        break;
+    default:
+        break;
+    }
+}
+
+bool XCursorHandler::ensureScanned() const
+{
+    if (m_scanned) {
+        return true;
+    }
+
+    if (device()->isSequential()) {
+        return false;
+    }
+
+    auto *mutableThis = const_cast<XCursorHandler *>(this);
+
+    const auto oldPos = device()->pos();
+    auto cleanup = qScopeGuard([this, oldPos] {
+        device()->seek(oldPos);
+    });
+
+    device()->seek(0);
+
+    const QByteArray intro = device()->read(4);
+    if (intro != "Xcur") {
+        return false;
+    }
+
+    QDataStream stream(device());
+    stream.setByteOrder(QDataStream::LittleEndian);
+
+    quint32 headerSize, version, ntoc;
+    stream >> headerSize >> version >> ntoc;
+
+    // TODO headerSize
+    // TODO version
+
+    if (!ntoc) {
+        return false;
+    }
+
+    mutableThis->m_images.clear();
+
+    for (quint32 i = 0; i < ntoc; ++i) {
+        quint32 type, size, position;
+        stream >> type >> size >> position;
+
+        if (type != XCURSOR_IMAGE_TYPE) {
+            continue;
+        }
+
+        mutableThis->m_images[size].append(position);
+    }
+
+    mutableThis->pickSize();
+
+    return !m_images.isEmpty();
+}
+
+void XCursorHandler::pickSize()
+{
+    if (m_images.isEmpty()) {
+        return;
+    }
+
+    // If a scaled size was requested, find the closest match.
+    const auto sizes = m_images.keys();
+    // If no scaled size is specified, use the biggest one available.
+    m_currentSize = sizes.last();
+
+    if (!m_scaledSize.isEmpty()) {
+        // TODO Use some clever algo iterator thing instead of keys()...
+        const int wantedSize = std::max(m_scaledSize.width(), m_scaledSize.height());
+        // Prefer downsampling over upsampling.
+        for (int i = sizes.size() - 1; i >= 0; --i) {
+            const int size = sizes.at(i);
+            if (size < wantedSize) {
+                break;
+            }
+
+            m_currentSize = size;
+        }
+    }
+}
+
+bool XCursorHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qCWarning(LOG_XCURSORPLUGIN) << "XCurosorHandler::canRead() called with no device";
+        return false;
+    }
+    if (device->isSequential()) {
+        return false;
+    }
+
+    const QByteArray intro = device->peek(4 * 4);
+
+    if (intro.length() != 4 * 4) {
+        return false;
+    }
+
+    if (!intro.startsWith("Xcur")) {
+        return false;
+    }
+
+    // TODO sanity check sizes?
+
+    return true;
+}
+
+QImageIOPlugin::Capabilities XCursorPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "xcursor") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && XCursorHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *XCursorPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new XCursorHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}
+
+#include "moc_xcursor_p.cpp"
--- a/src/imageformats/xcursor.json
+++ b/src/imageformats/xcursor.json
@@ -0,0 +1,8 @@
+{
+    "Keys": [
+        "xcursor"
+    ],
+    "MimeTypes": [
+        "image/x-xcursor"
+    ]
+}
--- a/src/imageformats/xcursor_p.h
+++ b/src/imageformats/xcursor_p.h
@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Kai Uwe Broulik <kde@broulik.de>
+ *
+ * SPDX-License-Identifier: LGPL-2.0-or-later
+ */
+
+#ifndef KIMG_XCURSOR_P_H
+#define KIMG_XCURSOR_P_H
+
+#include <QImageIOPlugin>
+#include <QSize>
+
+#include <optional>
+
+struct XCursorImage {
+    qint64 offset;
+    quint32 delay;
+};
+
+class XCursorHandler : public QImageIOHandler
+{
+public:
+    XCursorHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image) override;
+
+    int currentImageNumber() const override;
+    int imageCount() const override;
+    bool jumpToImage(int imageNumber) override;
+    bool jumpToNextImage() override;
+
+    int loopCount() const override;
+    int nextImageDelay() const override;
+
+    bool supportsOption(ImageOption option) const override;
+    QVariant option(ImageOption option) const override;
+    void setOption(ImageOption option, const QVariant &value) override;
+
+    static bool canRead(QIODevice *device);
+
+private:
+    bool ensureScanned() const;
+    void pickSize();
+
+    bool m_scanned = false;
+
+    int m_currentImageNumber = 0;
+
+    QSize m_scaledSize;
+    int m_currentSize = 0;
+
+    QMap<int /*size*/, QVector<qint64 /*offset*/>> m_images;
+
+    int m_nextImageDelay = 0;
+    std::optional<QPoint> m_hotspot;
+};
+
+class XCursorPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "xcursor.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+#endif // KIMG_XCURSOR_P_H