Fix condition for installing desktop files

(cherry picked from commit 9ad82ed608)

.gitlab-ci.yml

@@ -6,5 +6,9 @@ include:
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/linux-static.yml
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/android.yml
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/freebsd.yml
+  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/linux-qt6.yml
+  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/android-qt6.yml
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/windows.yml
   - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/windows-static.yml
+  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/freebsd-qt6.yml
+  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/windows-qt6.yml

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.16)
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.108.0  NO_MODULE)
+find_package(ECM 5.100.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)
 
@@ -65,8 +65,8 @@ add_feature_info(LibHeif LibHeif_FOUND "required for the QImage plugin for HEIF/
 
 option(KIMAGEFORMATS_JXL "Enable plugin for JPEG XL format" ON)
 if(KIMAGEFORMATS_JXL)
-    pkg_check_modules(LibJXL IMPORTED_TARGET libjxl>=0.7.0)
-    pkg_check_modules(LibJXLThreads IMPORTED_TARGET libjxl_threads>=0.7.0)
+    pkg_check_modules(LibJXL IMPORTED_TARGET libjxl>=0.6.1)
+    pkg_check_modules(LibJXLThreads IMPORTED_TARGET libjxl_threads>=0.6.1)
 endif()
 add_feature_info(LibJXL LibJXL_FOUND "required for the QImage plugin for JPEG XL images")
 

autotests/readtest.cpp

@@ -159,22 +159,17 @@ int main(int argc, char **argv)
             QTextStream(stdout) << "* Run on RANDOM ACCESS device\n";
         }
         for (const QFileInfo &fi : lstImgDir) {
-            if (!fi.suffix().compare("png", Qt::CaseInsensitive) || !fi.suffix().compare("tif", Qt::CaseInsensitive)) {
+            if (!fi.suffix().compare("png", Qt::CaseInsensitive)) {
                 continue;
             }
             int suffixPos = fi.filePath().count() - suffix.count();
             QString inputfile = fi.filePath();
-            QString fmt = QStringLiteral("png");
-            QString expfile = fi.filePath().replace(suffixPos, suffix.count(), fmt);
-            if (!QFile::exists(expfile)) { // try with tiff
-                fmt = QStringLiteral("tif");
-                expfile = fi.filePath().replace(suffixPos, suffix.count(), fmt);
-            }
+            QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
             QString expfilename = QFileInfo(expfile).fileName();
 
             std::unique_ptr<QIODevice> inputDevice(seq ? new SequentialFile(inputfile) : new QFile(inputfile));
             QImageReader inputReader(inputDevice.get(), format);
-            QImageReader expReader(expfile, fmt.toLatin1());
+            QImageReader expReader(expfile, "png");
 
             QImage inputImage;
             QImage expImage;

src/imageformats/CMakeLists.txt

@@ -93,6 +93,7 @@ endif()
 if (LibHeif_FOUND)
     kimageformats_add_plugin(kimg_heif SOURCES heif.cpp)
     target_link_libraries(kimg_heif PkgConfig::LibHeif)
+    kde_target_enable_exceptions(kimg_heif PRIVATE)
 
     if (QT_MAJOR_VERSION STREQUAL "5")
         install(FILES heif.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)
@@ -104,6 +105,9 @@ endif()
 if (LibJXL_FOUND AND LibJXLThreads_FOUND)
     kimageformats_add_plugin(kimg_jxl SOURCES jxl.cpp)
     target_link_libraries(kimg_jxl PkgConfig::LibJXL PkgConfig::LibJXLThreads)
+    if (LibJXL_VERSION VERSION_GREATER_EQUAL "0.7.0")
+        target_compile_definitions(kimg_jxl PRIVATE KIMG_JXL_API_VERSION=70)
+    endif()
 
     if (QT_MAJOR_VERSION STREQUAL "5")
         install(FILES jxl.desktop DESTINATION ${KDE_INSTALL_KSERVICESDIR}/qimageioplugins/)

src/imageformats/avif.cpp

@@ -63,7 +63,7 @@ bool QAVIFHandler::canRead(QIODevice *device)
     }
 
     avifROData input;
-    input.data = reinterpret_cast<const uint8_t *>(header.constData());
+    input.data = (const uint8_t *)header.constData();
     input.size = header.size();
 
     if (avifPeekCompatibleFileType(&input)) {
@@ -116,7 +116,7 @@ bool QAVIFHandler::ensureDecoder()
 
     m_rawData = device()->readAll();
 
-    m_rawAvifData.data = reinterpret_cast<const uint8_t *>(m_rawData.constData());
+    m_rawAvifData.data = (const uint8_t *)m_rawData.constData();
     m_rawAvifData.size = m_rawData.size();
 
     if (avifPeekCompatibleFileType(&m_rawAvifData) == AVIF_FALSE) {
@@ -1057,26 +1057,12 @@ QPointF QAVIFHandler::CompatibleChromacity(qreal chrX, qreal chrY)
 
 QImageIOPlugin::Capabilities QAVIFPlugin::capabilities(QIODevice *device, const QByteArray &format) const
 {
-    static const bool isAvifDecoderAvailable(avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_DECODE) != nullptr);
-    static const bool isAvifEncoderAvailable(avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_ENCODE) != nullptr);
-
     if (format == "avif") {
-        Capabilities format_cap;
-        if (isAvifDecoderAvailable) {
-            format_cap |= CanRead;
-        }
-        if (isAvifEncoderAvailable) {
-            format_cap |= CanWrite;
-        }
-        return format_cap;
+        return Capabilities(CanRead | CanWrite);
     }
 
     if (format == "avifs") {
-        Capabilities format_cap;
-        if (isAvifDecoderAvailable) {
-            format_cap |= CanRead;
-        }
-        return format_cap;
+        return Capabilities(CanRead);
     }
 
     if (!format.isEmpty()) {
@@ -1087,10 +1073,10 @@ QImageIOPlugin::Capabilities QAVIFPlugin::capabilities(QIODevice *device, const
     }
 
     Capabilities cap;
-    if (device->isReadable() && QAVIFHandler::canRead(device) && isAvifDecoderAvailable) {
+    if (device->isReadable() && QAVIFHandler::canRead(device)) {
         cap |= CanRead;
     }
-    if (device->isWritable() && isAvifEncoderAvailable) {
+    if (device->isWritable()) {
         cap |= CanWrite;
     }
     return cap;

src/imageformats/fastmath_p.h

@@ -1,35 +0,0 @@
-/*
-    Approximated math functions used into conversions.
-
-    SPDX-FileCopyrightText: Edward Kmett
-    SPDX-FileCopyrightText: 2023 Mirco Miranda <mircomir@outlook.com>
-
-    SPDX-License-Identifier: BSD-3-Clause
-*/
-#ifndef FASTMATH_P_H
-#define FASTMATH_P_H
-
-#include <QtGlobal>
-
-/*!
- * \brief fastPow
- * Based on Edward Kmett code released into the public domain.
- * See also: https://github.com/ekmett/approximate
- */
-inline double fastPow(double x, double y)
-{
-    union {
-        double d;
-        qint32 i[2];
-    } u = {x};
-#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-    u.i[1] = qint32(y * (u.i[1] - 1072632447) + 1072632447);
-    u.i[0] = 0;
-#else // never tested
-    u.i[0] = qint32(y * (u.i[0] - 1072632447) + 1072632447);
-    u.i[1] = 0;
-#endif
-    return u.d;
-}
-
-#endif // FASTMATH_P_H

src/imageformats/jxl.cpp

@@ -150,7 +150,9 @@ bool QJpegXLHandler::ensureDecoder()
         return false;
     }
 
+#ifdef KIMG_JXL_API_VERSION
     JxlDecoderCloseInput(m_decoder);
+#endif
 
     JxlDecoderStatus status = JxlDecoderSubscribeEvents(m_decoder, JXL_DEC_BASIC_INFO | JXL_DEC_COLOR_ENCODING | JXL_DEC_FRAME);
     if (status == JXL_DEC_ERROR) {
@@ -267,31 +269,18 @@ bool QJpegXLHandler::countALLFrames()
         }
     }
 
-    status = JxlDecoderGetColorAsEncodedProfile(m_decoder,
-#if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0, 9, 0)
-                                                &m_input_pixel_format,
-#endif
-                                                JXL_COLOR_PROFILE_TARGET_DATA,
-                                                &color_encoding);
+    status = JxlDecoderGetColorAsEncodedProfile(m_decoder, &m_input_pixel_format, JXL_COLOR_PROFILE_TARGET_DATA, &color_encoding);
 
     if (status == JXL_DEC_SUCCESS && color_encoding.color_space == JXL_COLOR_SPACE_RGB && color_encoding.white_point == JXL_WHITE_POINT_D65
         && color_encoding.primaries == JXL_PRIMARIES_SRGB && color_encoding.transfer_function == JXL_TRANSFER_FUNCTION_SRGB) {
         m_colorspace = QColorSpace(QColorSpace::SRgb);
     } else {
         size_t icc_size = 0;
-        if (JxlDecoderGetICCProfileSize(m_decoder,
-#if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0, 9, 0)
-                                        &m_input_pixel_format,
-#endif
-                                        JXL_COLOR_PROFILE_TARGET_DATA,
-                                        &icc_size)
-            == JXL_DEC_SUCCESS) {
+        if (JxlDecoderGetICCProfileSize(m_decoder, &m_input_pixel_format, JXL_COLOR_PROFILE_TARGET_DATA, &icc_size) == JXL_DEC_SUCCESS) {
             if (icc_size > 0) {
                 QByteArray icc_data(icc_size, 0);
                 if (JxlDecoderGetColorAsICCProfile(m_decoder,
-#if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0, 9, 0)
                                                    &m_input_pixel_format,
-#endif
                                                    JXL_COLOR_PROFILE_TARGET_DATA,
                                                    reinterpret_cast<uint8_t *>(icc_data.data()),
                                                    icc_data.size())
@@ -545,7 +534,9 @@ bool QJpegXLHandler::write(const QImage &image)
     if (save_depth == 16 && (image.hasAlphaChannel() || output_info.uses_original_profile)) {
         output_info.have_container = JXL_TRUE;
         JxlEncoderUseContainer(encoder, JXL_TRUE);
+#ifdef KIMG_JXL_API_VERSION
         JxlEncoderSetCodestreamLevel(encoder, 10);
+#endif
     }
 
     void *runner = nullptr;
@@ -659,11 +650,19 @@ bool QJpegXLHandler::write(const QImage &image)
         }
     }
 
+#ifdef KIMG_JXL_API_VERSION
     JxlEncoderFrameSettings *encoder_options = JxlEncoderFrameSettingsCreate(encoder, nullptr);
 
     JxlEncoderSetFrameDistance(encoder_options, (100.0f - m_quality) / 10.0f);
 
     JxlEncoderSetFrameLossless(encoder_options, (m_quality == 100) ? JXL_TRUE : JXL_FALSE);
+#else
+    JxlEncoderOptions *encoder_options = JxlEncoderOptionsCreate(encoder, nullptr);
+
+    JxlEncoderOptionsSetDistance(encoder_options, (100.0f - m_quality) / 10.0f);
+
+    JxlEncoderOptionsSetLossless(encoder_options, (m_quality == 100) ? JXL_TRUE : JXL_FALSE);
+#endif
 
     if (image.hasAlphaChannel() || ((save_depth == 8) && (xsize % 4 == 0))) {
         status = JxlEncoderAddImageFrame(encoder_options, &pixel_format, static_cast<const void *>(tmpimage.constBits()), buffer_size);
@@ -958,7 +957,9 @@ bool QJpegXLHandler::rewind()
         return false;
     }
 
+#ifdef KIMG_JXL_API_VERSION
     JxlDecoderCloseInput(m_decoder);
+#endif
 
     if (m_basicinfo.uses_original_profile) {
         if (JxlDecoderSubscribeEvents(m_decoder, JXL_DEC_FULL_IMAGE) != JXL_DEC_SUCCESS) {

src/imageformats/pcx.cpp

@@ -230,7 +230,7 @@ PCXHEADER::PCXHEADER()
     s >> *this;
 }
 
-static bool readLine(QDataStream &s, QByteArray &buf, const PCXHEADER &header)
+static void readLine(QDataStream &s, QByteArray &buf, const PCXHEADER &header)
 {
     quint32 i = 0;
     quint32 size = buf.size();
@@ -257,11 +257,9 @@ static bool readLine(QDataStream &s, QByteArray &buf, const PCXHEADER &header)
             buf[i++] = byte;
         }
     }
-
-    return (s.status() == QDataStream::Ok);
 }
 
-static bool readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
+static void readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
 {
     QByteArray buf(header.BytesPerLine, 0);
 
@@ -270,18 +268,16 @@ static bool readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
-        return false;
+        return;
     }
 
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
-            return false;
-        }
-
-        if (!readLine(s, buf, header)) {
-            return false;
+            img = QImage();
+            return;
         }
 
+        readLine(s, buf, header);
         uchar *p = img.scanLine(y);
         unsigned int bpl = qMin((quint16)((header.width() + 7) / 8), header.BytesPerLine);
         for (unsigned int x = 0; x < bpl; ++x) {
@@ -292,11 +288,9 @@ static bool readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
     // Set the color palette
     img.setColor(0, qRgb(0, 0, 0));
     img.setColor(1, qRgb(255, 255, 255));
-
-    return true;
 }
 
-static bool readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
+static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
 {
     QByteArray buf(header.BytesPerLine * 4, 0);
     QByteArray pixbuf(header.width(), 0);
@@ -305,18 +299,17 @@ static bool readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
     img.setColorCount(16);
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
-        return false;
+        return;
     }
 
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
-            return false;
+            img = QImage();
+            return;
         }
 
         pixbuf.fill(0);
-        if (!readLine(s, buf, header)) {
-            return false;
-        }
+        readLine(s, buf, header);
 
         for (int i = 0; i < 4; i++) {
             quint32 offset = i * header.BytesPerLine;
@@ -340,11 +333,9 @@ static bool readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
     for (int i = 0; i < 16; ++i) {
         img.setColor(i, header.ColorMap.color(i));
     }
-
-    return true;
 }
 
-static bool readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
+static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
 {
     QByteArray buf(header.BytesPerLine, 0);
 
@@ -353,21 +344,21 @@ static bool readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
-        return false;
+        return;
     }
 
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
-            return false;
+            img = QImage();
+            return;
         }
 
-        if (!readLine(s, buf, header)) {
-            return false;
-        }
+        readLine(s, buf, header);
 
         uchar *p = img.scanLine(y);
+
         if (!p) {
-            return false;
+            return;
         }
 
         unsigned int bpl = qMin(header.BytesPerLine, (quint16)header.width());
@@ -376,21 +367,10 @@ static bool readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
         }
     }
 
-    // by specification, the extended palette starts at file.size() - 769
-    quint8 flag = 0;
-    if (auto device = s.device()) {
-        if (device->isSequential()) {
-            while (flag != 12 && s.status() == QDataStream::Ok) {
-                s >> flag;
-            }
-        }
-        else {
-            device->seek(device->size() - 769);
-            s >> flag;
-        }
-    }
-
+    quint8 flag;
+    s >> flag;
     //   qDebug() << "Palette Flag: " << flag;
+
     if (flag == 12 && (header.Version == 5 || header.Version == 2)) {
         // Read the palette
         quint8 r;
@@ -401,11 +381,9 @@ static bool readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
             img.setColor(i, qRgb(r, g, b));
         }
     }
-
-    return (s.status() == QDataStream::Ok);
 }
 
-static bool readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
+static void readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
 {
     QByteArray r_buf(header.BytesPerLine, 0);
     QByteArray g_buf(header.BytesPerLine, 0);
@@ -415,34 +393,27 @@ static bool readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     if (img.isNull()) {
         qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
-        return false;
+        return;
     }
 
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
-            return false;
+            img = QImage();
+            return;
         }
 
-        if (!readLine(s, r_buf, header)) {
-            return false;
-        }
-        if (!readLine(s, g_buf, header)) {
-            return false;
-        }
-        if (!readLine(s, b_buf, header)) {
-            return false;
-        }
+        readLine(s, r_buf, header);
+        readLine(s, g_buf, header);
+        readLine(s, b_buf, header);
 
         uint *p = (uint *)img.scanLine(y);
         for (int x = 0; x < header.width(); ++x) {
             p[x] = qRgb(r_buf[x], g_buf[x], b_buf[x]);
         }
     }
-
-    return true;
 }
 
-static bool writeLine(QDataStream &s, QByteArray &buf)
+static void writeLine(QDataStream &s, QByteArray &buf)
 {
     quint32 i = 0;
     quint32 size = buf.size();
@@ -468,26 +439,15 @@ static bool writeLine(QDataStream &s, QByteArray &buf)
 
         s << data;
     }
-    return (s.status() == QDataStream::Ok);
 }
 
-static bool writeImage1(QImage &img, QDataStream &s, PCXHEADER &header)
+static void writeImage1(QImage &img, QDataStream &s, PCXHEADER &header)
 {
-    if (img.format() != QImage::Format_Mono) {
-        img = img.convertToFormat(QImage::Format_Mono);
-    }
-    if (img.isNull() || img.colorCount() < 1) {
-        return false;
-    }
-    auto rgb = img.color(0);
-    auto minIsBlack = (qRed(rgb) + qGreen(rgb) + qBlue(rgb)) / 3 < 127;
+    img = img.convertToFormat(QImage::Format_Mono);
 
     header.Bpp = 1;
     header.NPlanes = 1;
     header.BytesPerLine = img.bytesPerLine();
-    if (header.BytesPerLine == 0) {
-        return false;
-    }
 
     s << header;
 
@@ -498,24 +458,18 @@ static bool writeImage1(QImage &img, QDataStream &s, PCXHEADER &header)
 
         // Invert as QImage uses reverse palette for monochrome images?
         for (int i = 0; i < header.BytesPerLine; ++i) {
-            buf[i] = minIsBlack ? p[i] : ~p[i];
+            buf[i] = ~p[i];
         }
 
-        if (!writeLine(s, buf)) {
-            return false;
-        }
+        writeLine(s, buf);
     }
-    return true;
 }
 
-static bool writeImage4(QImage &img, QDataStream &s, PCXHEADER &header)
+static void writeImage4(QImage &img, QDataStream &s, PCXHEADER &header)
 {
     header.Bpp = 1;
     header.NPlanes = 4;
     header.BytesPerLine = header.width() / 8;
-    if (header.BytesPerLine == 0) {
-        return false;
-    }
 
     for (int i = 0; i < 16; ++i) {
         header.ColorMap.setColor(i, img.color(i));
@@ -545,22 +499,16 @@ static bool writeImage4(QImage &img, QDataStream &s, PCXHEADER &header)
         }
 
         for (int i = 0; i < 4; ++i) {
-            if (!writeLine(s, buf[i])) {
-                return false;
-            }
+            writeLine(s, buf[i]);
         }
     }
-    return true;
 }
 
-static bool writeImage8(QImage &img, QDataStream &s, PCXHEADER &header)
+static void writeImage8(QImage &img, QDataStream &s, PCXHEADER &header)
 {
     header.Bpp = 8;
     header.NPlanes = 1;
     header.BytesPerLine = img.bytesPerLine();
-    if (header.BytesPerLine == 0) {
-        return false;
-    }
 
     s << header;
 
@@ -573,9 +521,7 @@ static bool writeImage8(QImage &img, QDataStream &s, PCXHEADER &header)
             buf[i] = p[i];
         }
 
-        if (!writeLine(s, buf)) {
-            return false;
-        }
+        writeLine(s, buf);
     }
 
     // Write palette flag
@@ -586,25 +532,13 @@ static bool writeImage8(QImage &img, QDataStream &s, PCXHEADER &header)
     for (int i = 0; i < 256; ++i) {
         s << RGB::from(img.color(i));
     }
-
-    return (s.status() == QDataStream::Ok);
 }
 
-static bool writeImage24(QImage &img, QDataStream &s, PCXHEADER &header)
+static void writeImage24(QImage &img, QDataStream &s, PCXHEADER &header)
 {
     header.Bpp = 8;
     header.NPlanes = 3;
     header.BytesPerLine = header.width();
-    if (header.BytesPerLine == 0) {
-        return false;
-    }
-
-    if (img.format() != QImage::Format_ARGB32 && img.format() != QImage::Format_RGB32) {
-        img = img.convertToFormat(QImage::Format_RGB32);
-    }
-    if (img.isNull()) {
-        return false;
-    }
 
     s << header;
 
@@ -613,7 +547,7 @@ static bool writeImage24(QImage &img, QDataStream &s, PCXHEADER &header)
     QByteArray b_buf(header.width(), 0);
 
     for (int y = 0; y < header.height(); ++y) {
-        auto p = (QRgb*)img.scanLine(y);
+        uint *p = (uint *)img.scanLine(y);
 
         for (int x = 0; x < header.width(); ++x) {
             QRgb rgb = *p++;
@@ -622,18 +556,10 @@ static bool writeImage24(QImage &img, QDataStream &s, PCXHEADER &header)
             b_buf[x] = qBlue(rgb);
         }
 
-        if (!writeLine(s, r_buf)) {
-            return false;
-        }
-        if (!writeLine(s, g_buf)) {
-            return false;
-        }
-        if (!writeLine(s, b_buf)) {
-            return false;
-        }
+        writeLine(s, r_buf);
+        writeLine(s, g_buf);
+        writeLine(s, b_buf);
     }
-
-    return true;
 }
 
 PCXHandler::PCXHandler()
@@ -662,30 +588,46 @@ bool PCXHandler::read(QImage *outImage)
 
     s >> header;
 
-    if (header.Manufacturer != 10 || header.BytesPerLine == 0 || s.atEnd()) {
+    if (header.Manufacturer != 10 || s.atEnd()) {
         return false;
     }
 
-    auto ok = false;
+    //   int w = header.width();
+    //   int h = header.height();
+
+    //   qDebug() << "Manufacturer: " << header.Manufacturer;
+    //   qDebug() << "Version: " << header.Version;
+    //   qDebug() << "Encoding: " << header.Encoding;
+    //   qDebug() << "Bpp: " << header.Bpp;
+    //   qDebug() << "Width: " << w;
+    //   qDebug() << "Height: " << h;
+    //   qDebug() << "Window: " << header.XMin << "," << header.XMax << ","
+    //                  << header.YMin << "," << header.YMax << endl;
+    //   qDebug() << "BytesPerLine: " << header.BytesPerLine;
+    //   qDebug() << "NPlanes: " << header.NPlanes;
+
     QImage img;
+
     if (header.Bpp == 1 && header.NPlanes == 1) {
-        ok = readImage1(img, s, header);
+        readImage1(img, s, header);
     } else if (header.Bpp == 1 && header.NPlanes == 4) {
-        ok = readImage4(img, s, header);
+        readImage4(img, s, header);
     } else if (header.Bpp == 8 && header.NPlanes == 1) {
-        ok = readImage8(img, s, header);
+        readImage8(img, s, header);
     } else if (header.Bpp == 8 && header.NPlanes == 3) {
-        ok = readImage24(img, s, header);
+        readImage24(img, s, header);
     }
 
-    if (img.isNull() || !ok) {
+    //   qDebug() << "Image Bytes: " << img.numBytes();
+    //   qDebug() << "Image Bytes Per Line: " << img.bytesPerLine();
+    //   qDebug() << "Image Depth: " << img.depth();
+
+    if (!img.isNull()) {
+        *outImage = img;
+        return true;
+    } else {
         return false;
     }
-
-    img.setDotsPerMeterX(qRound(header.HDpi / 25.4 * 1000));
-    img.setDotsPerMeterY(qRound(header.YDpi / 25.4 * 1000));
-    *outImage = img;
-    return true;
 }
 
 bool PCXHandler::write(const QImage &image)
@@ -702,6 +644,12 @@ bool PCXHandler::write(const QImage &image)
         return false;
     }
 
+    //   qDebug() << "Width: " << w;
+    //   qDebug() << "Height: " << h;
+    //   qDebug() << "Depth: " << img.depth();
+    //   qDebug() << "BytesPerLine: " << img.bytesPerLine();
+    //   qDebug() << "Color Count: " << img.colorCount();
+
     PCXHEADER header;
 
     header.Manufacturer = 10;
@@ -711,23 +659,22 @@ bool PCXHandler::write(const QImage &image)
     header.YMin = 0;
     header.XMax = w - 1;
     header.YMax = h - 1;
-    header.HDpi = qRound(image.dotsPerMeterX() * 25.4 / 1000);
-    header.YDpi = qRound(image.dotsPerMeterY() * 25.4 / 1000);
+    header.HDpi = 300;
+    header.YDpi = 300;
     header.Reserved = 0;
     header.PaletteInfo = 1;
 
-    auto ok = false;
     if (img.depth() == 1) {
-        ok = writeImage1(img, s, header);
+        writeImage1(img, s, header);
     } else if (img.depth() == 8 && img.colorCount() <= 16) {
-        ok = writeImage4(img, s, header);
+        writeImage4(img, s, header);
     } else if (img.depth() == 8) {
-        ok = writeImage8(img, s, header);
-    } else if (img.depth() >= 24) {
-        ok = writeImage24(img, s, header);
+        writeImage8(img, s, header);
+    } else if (img.depth() == 32) {
+        writeImage24(img, s, header);
     }
 
-    return ok;
+    return true;
 }
 
 bool PCXHandler::canRead(QIODevice *device)

src/imageformats/psd.cpp

@@ -3,14 +3,14 @@
 
     SPDX-FileCopyrightText: 2003 Ignacio Castaño <castano@ludicon.com>
     SPDX-FileCopyrightText: 2015 Alex Merry <alex.merry@kde.org>
-    SPDX-FileCopyrightText: 2022-2023 Mirco Miranda <mircomir@outlook.com>
+    SPDX-FileCopyrightText: 2022 Mirco Miranda <mircomir@outlook.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 /*
- * The early version of this code was based on Thacher Ulrich PSD loading code
- * released into the public domain. See: http://tulrich.com/geekstuff/
+ * This code is based on Thacher Ulrich PSD loading code released
+ * into the public domain. See: http://tulrich.com/geekstuff/
  */
 
 /*
@@ -21,6 +21,7 @@
 /*
  * Limitations of the current code:
  * - 32-bit float image are converted to 16-bit integer image.
+ *   NOTE: Qt 6.2 allow 32-bit float images (RGB only)
  * - Other color spaces cannot directly be read due to lack of QImage support for
  *   color spaces other than RGB (and Grayscale). Where possible, a conversion
  *   to RGB is done:
@@ -32,7 +33,6 @@
  *   color management engine (e.g. LittleCMS).
  */
 
-#include "fastmath_p.h"
 #include "psd_p.h"
 #include "util_p.h"
 
@@ -51,7 +51,7 @@ typedef quint8 uchar;
  * This should not be a problem because the Qt's QColorSpace supports the linear
  * sRgb colorspace.
  *
- * Using linear conversion, the loading speed is slightly improved. Anyway, if you are using
+ * Using linear conversion, the loading speed is improved by 4x. Anyway, if you are using
  * an software that discard color info, you should comment it.
  *
  * At the time I'm writing (07/2022), Gwenview and Krita supports linear sRgb but KDE
@@ -646,9 +646,6 @@ static bool IsValid(const PSDHeader &header)
 // Check that the header is supported by this plugin.
 static bool IsSupported(const PSDHeader &header)
 {
-    if (!IsValid(header)) {
-        return false;
-    }
     if (header.version != 1 && header.version != 2) {
         return false;
     }
@@ -663,15 +660,10 @@ static bool IsSupported(const PSDHeader &header)
         header.color_mode != CM_INDEXED &&
         header.color_mode != CM_DUOTONE &&
         header.color_mode != CM_CMYK &&
-        header.color_mode != CM_MULTICHANNEL &&
         header.color_mode != CM_LABCOLOR &&
         header.color_mode != CM_BITMAP) {
         return false;
     }
-    if (header.color_mode == CM_MULTICHANNEL &&
-        header.channel_count < 4) {
-        return false;
-    }
     return true;
 }
 
@@ -733,18 +725,17 @@ static QImage::Format imageFormat(const PSDHeader &header, bool alpha)
     switch(header.color_mode) {
     case CM_RGB:
         if (header.depth == 16 || header.depth == 32)
-            format = header.channel_count < 4 || !alpha ? QImage::Format_RGBX64 : QImage::Format_RGBA64_Premultiplied;
+            format = header.channel_count < 4 || !alpha ? QImage::Format_RGBX64 : QImage::Format_RGBA64;
         else
-            format = header.channel_count < 4 || !alpha ? QImage::Format_RGB888 : QImage::Format_RGBA8888_Premultiplied;
+            format = header.channel_count < 4 || !alpha ? QImage::Format_RGB888 : QImage::Format_RGBA8888;
         break;
-    case CM_MULTICHANNEL:       // Treat MCH as CMYK (number of channel check is done in IsSupported())
-    case CM_CMYK:               // Photoshop supports CMYK/MCH 8-bits and 16-bits only
+    case CM_CMYK:       // Photoshop supports CMYK 8-bits and 16-bits only
         if (header.depth == 16)
             format = header.channel_count < 5 || !alpha ? QImage::Format_RGBX64 : QImage::Format_RGBA64;
         else if (header.depth == 8)
             format = header.channel_count < 5 || !alpha ? QImage::Format_RGB888 : QImage::Format_RGBA8888;
         break;
-    case CM_LABCOLOR:           // Photoshop supports LAB 8-bits and 16-bits only
+    case CM_LABCOLOR:   // Photoshop supports LAB 8-bits and 16-bits only
         if (header.depth == 16)
             format = header.channel_count < 4 || !alpha ? QImage::Format_RGBX64 : QImage::Format_RGBA64;
         else if (header.depth == 8)
@@ -814,7 +805,7 @@ inline void planarToChunchy(uchar *target, const char *source, qint32 width, qin
     auto s = reinterpret_cast<const T*>(source);
     auto t = reinterpret_cast<T*>(target);
     for (qint32 x = 0; x < width; ++x) {
-        t[x * cn + c] = xchg(s[x]);
+        t[x*cn+c] = xchg(s[x]);
     }
 }
 
@@ -826,44 +817,7 @@ inline void planarToChunchyFloat(uchar *target, const char *source, qint32 width
     for (qint32 x = 0; x < width; ++x) {
         auto tmp = xchg(s[x]);
         auto ftmp = (*reinterpret_cast<float*>(&tmp) - double(min)) / (double(max) - double(min));
-        t[x * cn + c] = quint16(std::min(ftmp * std::numeric_limits<quint16>::max() + 0.5, double(std::numeric_limits<quint16>::max())));
-    }
-}
-
-enum class PremulConversion {
-    PS2P, // Photoshop premul to qimage premul (required by RGB)
-    PS2A, // Photoshop premul to unassociated alpha (required by RGB, CMYK and L* components of LAB)
-    PSLab2A // Photoshop premul to unassociated alpha (required by a* and b* components of LAB)
-};
-
-template<class T>
-inline void premulConversion(char *stride, qint32 width, qint32 ac, qint32 cn, const PremulConversion &conv)
-{
-    auto s = reinterpret_cast<T *>(stride);
-    auto max = qint64(std::numeric_limits<T>::max());
-
-    for (qint32 c = 0; c < ac; ++c) {
-        if (conv == PremulConversion::PS2P) {
-            for (qint32 x = 0; x < width; ++x) {
-                auto xcn = x * cn;
-                auto alpha = *(s + xcn + ac);
-                *(s + xcn + c) = *(s + xcn + c) + alpha - max;
-            }
-        } else if (conv == PremulConversion::PS2A || (conv == PremulConversion::PSLab2A && c == 0)) {
-            for (qint32 x = 0; x < width; ++x) {
-                auto xcn = x * cn;
-                auto alpha = *(s + xcn + ac);
-                if (alpha > 0)
-                    *(s + xcn + c) = ((*(s + xcn + c) + alpha - max) * max + alpha / 2) / alpha;
-            }
-        } else if (conv == PremulConversion::PSLab2A) {
-            for (qint32 x = 0; x < width; ++x) {
-                auto xcn = x * cn;
-                auto alpha = *(s + xcn + ac);
-                if (alpha > 0)
-                    *(s + xcn + c) = ((*(s + xcn + c) + (alpha - max + 1) / 2) * max + alpha / 2) / alpha;
-            }
-        }
+        t[x*cn+c] = quint16(std::min(ftmp * std::numeric_limits<quint16>::max() + 0.5, double(std::numeric_limits<quint16>::max())));
     }
 }
 
@@ -876,25 +830,12 @@ inline void monoInvert(uchar *target, const char* source, qint32 bytes)
     }
 }
 
-template<class T>
-inline void rawChannelsCopy(uchar *target, qint32 targetChannels, const char *source, qint32 sourceChannels, qint32 width)
-{
-    auto s = reinterpret_cast<const T *>(source);
-    auto t = reinterpret_cast<T *>(target);
-    for (qint32 c = 0, cs = std::min(targetChannels, sourceChannels); c < cs; ++c) {
-        for (qint32 x = 0; x < width; ++x) {
-            t[x * targetChannels + c] = s[x * sourceChannels + c];
-        }
-    }
-}
-
 template<class T>
 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);
     auto max = double(std::numeric_limits<T>::max());
-    auto invmax = 1.0 / max; // speed improvements by ~10%
 
     if (sourceChannels < 4) {
         qDebug() << "cmykToRgb: image is not a valid CMYK!";
@@ -903,10 +844,10 @@ inline void cmykToRgb(uchar *target, qint32 targetChannels, const char *source,
 
     for (qint32 w = 0; w < width; ++w) {
         auto ps = s + sourceChannels * w;
-        auto C = 1 - *(ps + 0) * invmax;
-        auto M = 1 - *(ps + 1) * invmax;
-        auto Y = 1 - *(ps + 2) * invmax;
-        auto K = 1 - *(ps + 3) * invmax;
+        auto C = 1 - *(ps + 0) / max;
+        auto M = 1 - *(ps + 1) / max;
+        auto Y = 1 - *(ps + 2) / max;
+        auto K = 1 - *(ps + 3) / max;
 
         auto pt = t + targetChannels * w;
         *(pt + 0) = T(std::min(max - (C * (1 - K) + K) * max + 0.5, max));
@@ -931,9 +872,8 @@ inline double gammaCorrection(double linear)
 #ifdef PSD_FAST_LAB_CONVERSION
     return linear;
 #else
-    // Replacing fastPow with std::pow the conversion time is 2/3 times longer: using fastPow
-    // there are minimal differences in the conversion that are not visually noticeable.
-    return (linear > 0.0031308 ? 1.055 * fastPow(linear, 1.0 / 2.4) - 0.055 : 12.92 * linear);
+    // NOTE: pow() slow down the performance by a 4 factor :(
+    return (linear > 0.0031308 ? 1.055 * std::pow(linear, 1.0 / 2.4) - 0.055 : 12.92 * linear);
 #endif
 }
 
@@ -943,7 +883,6 @@ inline void labToRgb(uchar *target, qint32 targetChannels, const char *source, q
     auto s = reinterpret_cast<const T*>(source);
     auto t = reinterpret_cast<T*>(target);
     auto max = double(std::numeric_limits<T>::max());
-    auto invmax = 1.0 / max;
 
     if (sourceChannels < 3) {
         qDebug() << "labToRgb: image is not a valid LAB!";
@@ -952,14 +891,14 @@ inline void labToRgb(uchar *target, qint32 targetChannels, const char *source, q
 
     for (qint32 w = 0; w < width; ++w) {
         auto ps = s + sourceChannels * w;
-        auto L = (*(ps + 0) * invmax) * 100.0;
-        auto A = (*(ps + 1) * invmax) * 255.0 - 128.0;
-        auto B = (*(ps + 2) * invmax) * 255.0 - 128.0;
+        auto L = (*(ps + 0) / max) * 100.0;
+        auto A = (*(ps + 1) / max) * 255.0 - 128.0;
+        auto B = (*(ps + 2) / max) * 255.0 - 128.0;
 
         // converting LAB to XYZ (D65 illuminant)
-        auto Y = (L + 16.0) * (1.0 / 116.0);
-        auto X = A * (1.0 / 500.0) + Y;
-        auto Z = Y - B * (1.0 / 200.0);
+        auto Y = (L + 16.0) / 116.0;
+        auto X = A / 500.0 + Y;
+        auto Z = Y - B / 200.0;
 
         // NOTE: use the constants of the illuminant of the target RGB color space
         X = finv(X) * 0.9504;   // D50: * 0.9642
@@ -1109,15 +1048,7 @@ static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)
     QByteArray rawStride;
     rawStride.resize(raw_count);
 
-    // clang-format off
-    // checks the need of color conversion (that requires random access to the image)
-    auto randomAccess = (header.color_mode == CM_CMYK) ||
-        (header.color_mode == CM_LABCOLOR) ||
-        (header.color_mode == CM_MULTICHANNEL) ||
-        (header.color_mode != CM_INDEXED && img.hasAlphaChannel());
-    // clang-format on
-
-    if (randomAccess) {
+    if (header.color_mode == CM_CMYK || header.color_mode == CM_LABCOLOR || header.color_mode == CM_MULTICHANNEL) {
         // In order to make a colorspace transformation, we need all channels of a scanline
         QByteArray psdScanline;
         psdScanline.resize(qsizetype(header.width * std::min(header.depth, quint16(16)) * header.channel_count + 7) / 8);
@@ -1137,56 +1068,31 @@ static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)
                 auto scanLine = reinterpret_cast<unsigned char*>(psdScanline.data());
                 if (header.depth == 8) {
                     planarToChunchy<quint8>(scanLine, rawStride.data(), header.width, c, header.channel_count);
-                } else if (header.depth == 16) {
+                }
+                else if (header.depth == 16) {
                     planarToChunchy<quint16>(scanLine, rawStride.data(), header.width, c, header.channel_count);
-                } else if (header.depth == 32) {
+                }
+                else if (header.depth == 32) { // Not currently used
                     planarToChunchyFloat<quint32>(scanLine, rawStride.data(), header.width, c, header.channel_count);
                 }
             }
 
-            // Convert premultiplied data to unassociated data
-            if (img.hasAlphaChannel()) {
-                if (header.color_mode == CM_CMYK) {
-                    if (header.depth == 8)
-                        premulConversion<quint8>(psdScanline.data(), header.width, 4, header.channel_count, PremulConversion::PS2A);
-                    else if (header.depth == 16)
-                        premulConversion<quint16>(psdScanline.data(), header.width, 4, header.channel_count, PremulConversion::PS2A);
-                }
-                if (header.color_mode == CM_LABCOLOR) {
-                    if (header.depth == 8)
-                        premulConversion<quint8>(psdScanline.data(), header.width, 3, header.channel_count, PremulConversion::PSLab2A);
-                    else if (header.depth == 16)
-                        premulConversion<quint16>(psdScanline.data(), header.width, 3, header.channel_count, PremulConversion::PSLab2A);
-                }
-                if (header.color_mode == CM_RGB) {
-                    if (header.depth == 8)
-                        premulConversion<quint8>(psdScanline.data(), header.width, 3, header.channel_count, PremulConversion::PS2P);
-                    else if (header.depth == 16 || header.depth == 32)
-                        premulConversion<quint16>(psdScanline.data(), header.width, 3, header.channel_count, PremulConversion::PS2P);
-                }
-            }
-
             // Conversion to RGB
-            if (header.color_mode == CM_CMYK || header.color_mode == CM_MULTICHANNEL) {
+            if (header.color_mode == CM_CMYK) {
                 if (header.depth == 8)
                     cmykToRgb<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
-                else if (header.depth == 16)
+                else
                     cmykToRgb<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
             }
             if (header.color_mode == CM_LABCOLOR) {
                 if (header.depth == 8)
                     labToRgb<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
-                else if (header.depth == 16)
+                else
                     labToRgb<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width, alpha);
             }
-            if (header.color_mode == CM_RGB) {
-                if (header.depth == 8)
-                    rawChannelsCopy<quint8>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width);
-                else if (header.depth == 16 || header.depth == 32)
-                    rawChannelsCopy<quint16>(img.scanLine(y), imgChannels, psdScanline.data(), header.channel_count, header.width);
-            }
         }
-    } else {
+    }
+    else {
         // Linear read (no position jumps): optimized code usable only for the colorspaces supported by QImage
         for (qint32 c = 0; c < channel_num; ++c) {
             for (qint32 y = 0, h = header.height; y < h; ++y) {
@@ -1197,13 +1103,16 @@ static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)
                 }
 
                 auto scanLine = img.scanLine(y);
-                if (header.depth == 1) { // Bitmap
+                if (header.depth == 1) {        // Bitmap
                     monoInvert(scanLine, rawStride.data(), std::min(rawStride.size(), img.bytesPerLine()));
-                } else if (header.depth == 8) { // 8-bits images: Indexed, Grayscale, RGB/RGBA
+                }
+                else if (header.depth == 8) {   // 8-bits images: Indexed, Grayscale, RGB/RGBA
                     planarToChunchy<quint8>(scanLine, rawStride.data(), header.width, c, imgChannels);
-                } else if (header.depth == 16) { // 16-bits integer images: Grayscale, RGB/RGBA
+                }
+                else if (header.depth == 16) {  // 16-bits integer images: Grayscale, RGB/RGBA
                     planarToChunchy<quint16>(scanLine, rawStride.data(), header.width, c, imgChannels);
-                } else if (header.depth == 32) { // 32-bits float images: Grayscale, RGB/RGBA (coverted to equivalent integer 16-bits)
+                }
+                else if (header.depth == 32) {  // 32-bits float images: Grayscale, RGB/RGBA (coverted to equivalent integer 16-bits)
                     planarToChunchyFloat<quint32>(scanLine, rawStride.data(), header.width, c, imgChannels);
                 }
             }
@@ -1346,12 +1255,9 @@ bool PSDHandler::canRead(QIODevice *device)
         if (header.color_mode == CM_CMYK || header.color_mode == CM_LABCOLOR || header.color_mode == CM_MULTICHANNEL) {
             return false;
         }
-        if (header.color_mode == CM_RGB && header.channel_count > 3) {
-            return false; // supposing extra channel as alpha
-        }
     }
 
-    return IsSupported(header);
+    return IsValid(header);
 }
 
 QImageIOPlugin::Capabilities PSDPlugin::capabilities(QIODevice *device, const QByteArray &format) const

src/imageformats/raw.cpp

@@ -45,6 +45,7 @@ const auto supported_formats = QSet<QByteArray>{
     "dcs", "dc2", "dcr", "dng", "drf", "dxo",
     "eip", "erf",
     "fff",
+    "hdr",
     "iiq",
     "k25", "kc2", "kdc",
     "mdc", "mef", "mfw", "mos", "mrw",
@@ -110,20 +111,10 @@ public:
     }
     virtual int read(void *ptr, size_t sz, size_t nmemb) override
     {
-        qint64 read = 0;
-        if (sz == 0) {
+        auto read = m_device->read(reinterpret_cast<char *>(ptr), sz * nmemb);
+        if (read < 1) {
             return 0;
         }
-        auto data = reinterpret_cast<char*>(ptr);
-        for (qint64 r = 0, size = sz * nmemb; read < size; read += r) {
-            if (m_device->atEnd()) {
-                break;
-            }
-            r = m_device->read(data + read, size - read);
-            if (r < 1) {
-                break;
-            }
-        }
         return read / sz;
     }
     virtual int eof() override
@@ -140,7 +131,7 @@ public:
         if (whence == SEEK_END) {
             pos = size + o;
         }
-        if (pos < 0 || m_device->isSequential()) {
+        if (pos < 0 || pos > size || m_device->isSequential()) {
             return -1;
         }
         return m_device->seek(pos) ? 0 : -1;
@@ -675,9 +666,6 @@ bool LoadRAW(QImageIOHandler *handler, QImage &img)
         if (params.output_color == 4) {
             img.setColorSpace(QColorSpace(QColorSpace::ProPhotoRgb));
         }
-        if (params.output_color == 7) {
-            img.setColorSpace(QColorSpace(QColorSpace::DisplayP3));
-        }
     }
 
     // *** Set the metadata

src/imageformats/raw.json

@@ -7,6 +7,7 @@
         "dcs", "dc2", "dcr", "dng", "drf", "dxo",
         "eip", "erf",
         "fff",
+        "hdr",
         "iiq",
         "k25", "kdc", "kc2",
         "mdc", "mef", "mfw", "mos", "mrw",
@@ -26,6 +27,7 @@
         "image/x-kodak-dcs", "image/x-dc2", "image/x-kodak-dcr", "image/x-adobe-dng", "image/x-drf", "image/x-dxo",
         "image/x-epson-eip", "image/x-epson-erf",
         "image/x-fff",
+        "image/x-hdr",
         "image/x-iiq",
         "image/x-kodak-k25", "image/x-kodak-kdc", "image/x-kodak-kc2",
         "image/x-minolta-mdc", "image/x-mamiya-mef", "image/x-mfw", "image/x-aptus-mos", "image/x-minolta-mrw",

src/imageformats/rgb.cpp

@@ -672,16 +672,11 @@ bool SGIImage::writeImage(const QImage &image)
         _dim = 3, _zsize = 3;
     }
 
-    auto hasAlpha = img.hasAlphaChannel();
-    if (hasAlpha) {
+    if (img.format() == QImage::Format_ARGB32) {
         _dim = 3, _zsize++;
     }
 
-    if (hasAlpha && img.format() != QImage::Format_ARGB32) {
-        img = img.convertToFormat(QImage::Format_ARGB32);
-    } else if (!hasAlpha && img.format() != QImage::Format_RGB32) {
-        img = img.convertToFormat(QImage::Format_RGB32);
-    }
+    img = img.convertToFormat(QImage::Format_RGB32);
     if (img.isNull()) {
         //         qDebug() << "can't convert image to depth 32";
         return false;
@@ -690,7 +685,7 @@ bool SGIImage::writeImage(const QImage &image)
     const int w = img.width();
     const int h = img.height();
 
-    if (w > 65535 || h > 65535) {
+    if (w > 65536 || h > 65536) {
         return false;
     }
 
@@ -717,6 +712,12 @@ bool SGIImage::writeImage(const QImage &image)
         rle_size += _rlevector[i]->size();
     }
 
+    //     qDebug() << "minimum intensity: " << _pixmin;
+    //     qDebug() << "maximum intensity: " << _pixmax;
+    //     qDebug() << "saved scanlines: " << _numrows - _rlemap.size();
+    //     qDebug() << "total savings: " << (verbatim_size - rle_size) << " bytes";
+    //     qDebug() << "compression: " << (rle_size * 100.0 / verbatim_size) << '%';
+
     if (verbatim_size <= rle_size) {
         writeVerbatim(img);
     } else {

src/imageformats/tga.cpp

@@ -428,20 +428,8 @@ bool TGAHandler::write(const QImage &image)
     QDataStream s(device());
     s.setByteOrder(QDataStream::LittleEndian);
 
-    QImage img(image);
-    const bool hasAlpha = img.hasAlphaChannel();
-    if (hasAlpha && img.format() != QImage::Format_ARGB32) {
-        img = img.convertToFormat(QImage::Format_ARGB32);
-    } else if (!hasAlpha && img.format() != QImage::Format_RGB32) {
-        img = img.convertToFormat(QImage::Format_RGB32);
-    }
-    if (img.isNull()) {
-        qDebug() << "TGAHandler::write: image conversion to 32 bits failed!";
-        return false;
-    }
-    static constexpr quint8 originTopLeft = TGA_ORIGIN_UPPER + TGA_ORIGIN_LEFT; // 0x20
-    static constexpr quint8 alphaChannel8Bits = 0x08;
-
+    const QImage &img = image;
+    const bool hasAlpha = (img.format() == QImage::Format_ARGB32);
     for (int i = 0; i < 12; i++) {
         s << targaMagic[i];
     }
@@ -450,12 +438,11 @@ bool TGAHandler::write(const QImage &image)
     s << quint16(img.width()); // width
     s << quint16(img.height()); // height
     s << quint8(hasAlpha ? 32 : 24); // depth (24 bit RGB + 8 bit alpha)
-    s << quint8(hasAlpha ? originTopLeft + alphaChannel8Bits : originTopLeft);   // top left image (0x20) + 8 bit alpha (0x8)
+    s << quint8(hasAlpha ? 0x24 : 0x20); // top left image (0x20) + 8 bit alpha (0x4)
 
     for (int y = 0; y < img.height(); y++) {
-        auto ptr = reinterpret_cast<QRgb *>(img.scanLine(y));
         for (int x = 0; x < img.width(); x++) {
-            auto color = *(ptr + x);
+            const QRgb color = img.pixel(x, y);
             s << quint8(qBlue(color));
             s << quint8(qGreen(color));
             s << quint8(qRed(color));