GIT_SILENT Upgrade ECM and KF5 version requirements for 5.68.0 release.

Use the generic redirect commits.kde.org.

Change discussed on the kde-frameworks-devel list:
https://mail.kde.org/pipermail/kde-frameworks-devel/2019-November/097564.html

.gitignore

@@ -19,3 +19,4 @@ random_seed
 /build*/
 CMakeLists.txt.user*
 *.unc-backup*
+.cmake/

CMakeLists.txt

@@ -3,8 +3,8 @@ cmake_minimum_required(VERSION 3.5)
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.62.0  NO_MODULE)
-set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
+find_package(ECM 5.68.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)
 
 
@@ -17,7 +17,7 @@ include(KDECMakeSettings)
 
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.11.0)
+set(REQUIRED_QT_VERSION 5.12.0)
 find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
 find_package(KF5Archive)
@@ -46,6 +46,10 @@ set_package_properties(OpenEXR PROPERTIES
     PURPOSE "Required for the QImage plugin for OpenEXR images"
 )
 add_definitions(-DQT_NO_FOREACH)
+# 050d00 (5.13) triggers a BIC in qimageiohandler.h, in Qt 5.13, so do not enable that until we can require 5.14
+# https://codereview.qt-project.org/c/qt/qtbase/+/279215
+add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050c00)
+add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054300)
 add_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)

autotests/CMakeLists.txt

@@ -55,6 +55,7 @@ endmacro()
 # Loads each <format> image in read/<format>/, and compares the
 # result against the data read from the corresponding png file
 kimageformats_read_tests(
+    hdr
     pcx
     psd
     ras

src/imageformats/CMakeLists.txt

@@ -53,6 +53,11 @@ endif()
 
 ##################################
 
+kimageformats_add_plugin(kimg_hdr JSON "hdr.json" SOURCES hdr.cpp)
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+##################################
+
 kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
 install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 

src/imageformats/hdr.cpp

@@ -15,7 +15,7 @@
 
 #include <QDebug>
 
-typedef Q_UINT8 uchar;
+typedef unsigned char uchar;
 
 namespace   // Private.
 {
@@ -93,19 +93,22 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
     uchar val, code;
 
     // Create dst image.
-    if (!img.create(width, height, 32)) {
+    img = QImage(width, height, QImage::Format_RGB32);
+    if (img.isNull()) {
         return false;
     }
 
-    QMemArray<uchar> image(width * 4);
+    QByteArray lineArray;
+    lineArray.resize(4 * width);
+    uchar *image = (uchar *) lineArray.data();
 
     for (int cline = 0; cline < height; cline++) {
         QRgb *scanline = (QRgb *) img.scanLine(cline);
 
         // determine scanline type
         if ((width < MINELEN) || (MAXELEN < width)) {
-            Read_Old_Line(image.data(), width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            Read_Old_Line(image, width, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -116,9 +119,9 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
         }
 
         if (val != 2) {
-            s.device()->at(s.device()->at() - 1);
-            Read_Old_Line(image.data(), width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            s.device()->ungetChar(val);
+            Read_Old_Line(image, width, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -132,8 +135,8 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
 
         if ((image[1] != 2) || (image[2] & 128)) {
             image[0] = 2;
-            Read_Old_Line(image.data() + 4, width - 1, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            Read_Old_Line(image + 4, width - 1, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -168,7 +171,7 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
             }
         }
 
-        RGBE_To_QRgbLine(image.data(), scanline, width);
+        RGBE_To_QRgbLine(image, scanline, width);
     }
 
     return true;
@@ -176,7 +179,7 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
 
 } // namespace
 
-Q_DECL_EXPORT void kimgio_hdr_read(QImageIO *io)
+bool HDRHandler::read(QImage *outImage)
 {
     int len;
     char line[MAXLINE];
@@ -185,7 +188,7 @@ Q_DECL_EXPORT void kimgio_hdr_read(QImageIO *io)
 
     // Parse header
     do {
-        len = io->ioDevice()->readLine(line, MAXLINE);
+        len = device()->readLine(line, MAXLINE);
 
         /*if (strcmp(line, "#?RADIANCE\n") == 0 || strcmp(line, "#?RGBE\n") == 0)
         {
@@ -199,12 +202,10 @@ Q_DECL_EXPORT void kimgio_hdr_read(QImageIO *io)
 
     if (/*!validHeader ||*/ !validFormat) {
         // qDebug() << "Unknown HDR format.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+        return false;
     }
 
-    io->ioDevice()->readLine(line, MAXLINE);
+    device()->readLine(line, MAXLINE);
 
     char s1[3], s2[3];
     int width, height;
@@ -212,27 +213,67 @@ Q_DECL_EXPORT void kimgio_hdr_read(QImageIO *io)
         //if( sscanf(line, "-Y %d +X %d", &height, &width) < 2 )
     {
         // qDebug() << "Invalid HDR file.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+        return false;
     }
 
-    QDataStream s(io->ioDevice());
+    QDataStream s(device());
 
     QImage img;
     if (!LoadHDR(s, width, height, img)) {
         // qDebug() << "Error loading HDR file.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+        return false;
     }
 
-    io->setImage(img);
-    io->setStatus(0);
+    *outImage = img;
+    return true;
 }
 
-Q_DECL_EXPORT void kimgio_hdr_write(QImageIO *)
+HDRHandler::HDRHandler()
 {
-    // intentionally not implemented (since writing low dynamic range data to a HDR file is nonsense.)
 }
 
+bool HDRHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("hdr");
+        return true;
+    }
+    return false;
+}
+
+bool HDRHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("HDRHandler::canRead() called with no device");
+        return false;
+    }
+
+    return device->peek(11) == "#?RADIANCE\n" || device->peek(7) == "#?RGBE\n";
+}
+
+QImageIOPlugin::Capabilities HDRPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "hdr") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && HDRHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *HDRPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new HDRHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/hdr.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "hdr" ],
+    "MimeTypes": [ "image/x-hdr", "image/vnd.radiance" ]
+}

src/imageformats/hdr_p.h

@@ -10,12 +10,27 @@
 #ifndef KIMG_HDR_P_H
 #define KIMG_HDR_P_H
 
-class QImageIO;
+#include <QImageIOPlugin>
 
-extern "C" {
-    void kimgio_hdr_read(QImageIO *);
-    void kimgio_hdr_write(QImageIO *);
-}
+class HDRHandler : public QImageIOHandler
+{
+public:
+    HDRHandler();
 
-#endif
+    bool canRead() const override;
+    bool read(QImage *outImage) override;
 
+    static bool canRead(QIODevice *device);
+};
+
+class HDRPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "hdr.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+#endif // KIMG_HDR_P_H

src/imageformats/pic.cpp

@@ -130,9 +130,7 @@ static QDataStream &operator>> (QDataStream &s, QList<PicChannel> &channels)
         PicChannel channel;
         s >> chained;
         s >> channel.size;
-        quint8 encoding;
-        s >> encoding;
-        channel.encoding = PicChannelEncoding(encoding);
+        s >> channel.encoding;
         s >> channel.code;
         channels << channel;
         ++count;

src/imageformats/pic_p.h

@@ -119,7 +119,7 @@ struct PicHeader {
  */
 struct PicChannel {
     quint8 size; /**< Bits per component per pixel. */
-    PicChannelEncoding encoding; /**< How the channel's data is encoded. */
+    quint8 encoding; /**< How the channel's data is encoded. */
     quint8 code; /**< Flag field to describe which components are encoded in
                       this channel. */
 

src/imageformats/xcf.cpp

@@ -414,6 +414,7 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
             break;
 
         case PROP_RESOLUTION:
+            property.setFloatingPointPrecision(QDataStream::SinglePrecision);
             property >> xcf_image.x_resolution >> xcf_image.y_resolution;
             break;
 
@@ -484,9 +485,15 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
  * \return true if there were no IO errors.  */
 bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArray &bytes, quint32 &rawType)
 {
+    quint32 size;
+
     xcf_io >> rawType;
     if (rawType >= MAX_SUPPORTED_PROPTYPE) {
         type = MAX_SUPPORTED_PROPTYPE;
+        // we don't support the property, but we still need to read from the device, assume it's like all the
+        // non custom properties that is data_length + data
+        xcf_io >> size;
+        xcf_io.skipRawData(size);
         // return true because we don't really want to totally fail on an unsupported property since it may not be fatal
         return true;
     }
@@ -494,7 +501,6 @@ bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArra
     type = PropType(rawType);
 
     char *data = nullptr;
-    quint32 size;
 
     // The colormap property size is not the correct number of bytes:
     // The GIMP source xcf.c has size = 4 + ncolors, but it should be