less verbose categorized logging, move to ecm module later

It's uninitialized if the else {} is hit.

CMakeLists.txt

@@ -2,7 +2,11 @@ cmake_minimum_required(VERSION 2.8.12)
 
 project(KImageFormats)
 
-find_package(ECM 1.1.0 REQUIRED NO_MODULE)
+include(FeatureSummary)
+find_package(ECM 5.13.0  NO_MODULE)
+set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
+feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
+
 
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
@@ -10,17 +14,17 @@ include(KDEInstallDirs)
 include(KDEFrameworkCompilerSettings)
 include(KDECMakeSettings)
 
-include(FeatureSummary)
+
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.2.0)
+set(REQUIRED_QT_VERSION 5.3.0)
 find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
 # EPS support depends on the gs utility; non-UNIX systems are unlikely to have
 # this available in PATH
 set(BUILD_EPS_PLUGIN FALSE)
 if (UNIX)
-    find_package(Qt5PrintSupport 5.2.0 NO_MODULE)
+    find_package(Qt5PrintSupport ${REQUIRED_QT_VERSION} NO_MODULE)
     set_package_properties(Qt5PrintSupport PROPERTIES
         PURPOSE "Required for the QImage plugin for EPS images"
         TYPE OPTIONAL
@@ -30,13 +34,17 @@ if (UNIX)
     endif()
 endif()
 
-find_package(Jasper)
-set_package_properties(Jasper PROPERTIES
-    DESCRIPTION "A library for handling JPEG-2000 images"
-    PURPOSE "Required for the QImage plugin for JPEG-2000 images"
-    URL "http://www.ece.uvic.ca/~mdadams/jasper"
-    TYPE OPTIONAL
-)
+# QtImageFormats 5.3 comes with a JPEG-2000 plugin; don't duplicate it here
+# TODO: remove our JPEG-2000 plugin when we depend on Qt 5.3.
+if (Qt5Gui_VERSION VERSION_LESS 5.3.0)
+    find_package(Jasper)
+    set_package_properties(Jasper PROPERTIES
+        DESCRIPTION "A library for handling JPEG-2000 images"
+        PURPOSE "Required for the QImage plugin for JPEG-2000 images"
+        URL "http://www.ece.uvic.ca/~mdadams/jasper"
+        TYPE OPTIONAL
+    )
+endif()
 
 find_package(OpenEXR)
 set_package_properties(OpenEXR PROPERTIES

README.md

@@ -1,6 +1,6 @@
 # KImageFormats
 
-Image format plugins for Qt
+Plugins to allow QImage to support extra file formats.
 
 ## Introduction
 
@@ -63,9 +63,3 @@ This framework is licensed under the
 The CMake code in this framework is licensed under the
 [BSD license](http://opensource.org/licenses/BSD-3-Clause).
 
-## Links
-
-- Home page: <https://projects.kde.org/projects/frameworks/kimageformats>
-- Mailing list: <https://mail.kde.org/mailman/listinfo/kde-frameworks-devel>
-- IRC channel: \#kde-devel on Freenode
-- Git repository: <https://projects.kde.org/projects/frameworks/kimageformats/repository>

metainfo.yaml

@@ -1,5 +1,5 @@
 maintainer: alexmerry
-description: Plugins to allow QImage to support extra file formats
+description: Image format plugins for Qt
 tier: 1
 type: functional
 platforms:

src/imageformats/CMakeLists.txt

@@ -2,11 +2,15 @@
 
 ##################################
 
-add_library(kimg_dds MODULE dds.cpp)
-target_link_libraries(kimg_dds Qt5::Gui)
+if (Qt5Gui_VERSION VERSION_LESS 5.3.0)
+    add_library(kimg_dds MODULE dds.cpp)
+    target_link_libraries(kimg_dds Qt5::Gui)
 
-install(TARGETS kimg_dds  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES dds.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    install(TARGETS kimg_dds  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    install(FILES dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+else()
+    install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+endif()
 
 ##################################
 
@@ -15,8 +19,8 @@ if (BUILD_EPS_PLUGIN)
         add_library(kimg_eps MODULE eps.cpp)
         target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
 
-        install(TARGETS kimg_eps  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-        install(FILES eps.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+        install(TARGETS kimg_eps  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
     endif()
 endif()
 
@@ -32,8 +36,11 @@ if(JASPER_FOUND)
     target_include_directories(kimg_jp2 PRIVATE ${JASPER_INCLUDE_DIR})
     target_link_libraries(kimg_jp2  Qt5::Gui ${JASPER_LIBRARIES})
 
-    install(TARGETS kimg_jp2  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES jp2.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    install(TARGETS kimg_jp2  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+elseif (NOT Qt5Gui_VERSION VERSION_LESS 5.3.0)
+    # need this for Qt's version of the plugin
+    install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()
 
 ##################################
@@ -43,8 +50,8 @@ if(OpenEXR_FOUND)
     target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(TARGETS kimg_exr  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES exr.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    install(TARGETS kimg_exr  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()
 
 ##################################
@@ -52,54 +59,54 @@ endif()
 add_library(kimg_pcx MODULE pcx.cpp)
 target_link_libraries(kimg_pcx  Qt5::Gui)
 
-install(TARGETS kimg_pcx  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pcx.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_pcx  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_pic MODULE pic.cpp)
 target_link_libraries(kimg_pic Qt5::Gui)
 
-install(TARGETS kimg_pic  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pic.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_pic  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_psd MODULE psd.cpp)
 target_link_libraries(kimg_psd Qt5::Gui)
 
-install(TARGETS kimg_psd  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES psd.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_psd  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_ras MODULE ras.cpp)
 target_link_libraries(kimg_ras  Qt5::Gui)
 
-install(TARGETS kimg_ras  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES ras.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_ras  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_rgb MODULE rgb.cpp)
 target_link_libraries(kimg_rgb  Qt5::Gui)
 
-install(TARGETS kimg_rgb  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES rgb.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_rgb  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_tga MODULE tga.cpp)
 target_link_libraries(kimg_tga  Qt5::Gui)
 
-install(TARGETS kimg_tga  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES tga.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_tga  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_xcf MODULE xcf.cpp)
 target_link_libraries(kimg_xcf Qt5::Gui)
 
-install(TARGETS kimg_xcf  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES xcf.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_xcf  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 

src/imageformats/dds-qt.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Service
+X-KDE-ServiceTypes=QImageIOPlugins
+X-KDE-ImageFormat=dds
+X-KDE-MimeType=image/x-dds
+X-KDE-Read=true
+X-KDE-Write=true

src/imageformats/dds.cpp

@@ -19,7 +19,7 @@
  *     rgb dds files only -- TODO
  */
 
-#include "dds.h"
+#include "dds_p.h"
 
 #include <QtCore/QStringList>
 #include <QImage>

src/imageformats/eps.cpp

@@ -6,7 +6,7 @@
 *
 * This library is distributed under the conditions of the GNU LGPL.
 */
-#include "eps.h"
+#include "eps_p.h"
 
 #include <QDebug>
 #include <QImage>
@@ -17,7 +17,13 @@
 #include <QProcess>
 #include <QTemporaryFile>
 
+#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
+// logging category for this framework, default: log stuff >= warning
+Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin", QtWarningMsg)
+#else
 Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin")
+#endif
+
 //#define EPS_PERFORMANCE_DEBUG 1
 
 #define BBOX_BUFLEN 200

src/imageformats/eps_p.h

@@ -14,9 +14,9 @@ class EPSHandler : public QImageIOHandler
 public:
     EPSHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool write(const QImage &image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -27,8 +27,8 @@ class EPSPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "eps.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_EPS_H

src/imageformats/exr.cpp

@@ -7,7 +7,7 @@
 * This library is distributed under the conditions of the GNU LGPL.
 */
 
-#include "exr.h"
+#include "exr_p.h"
 
 #include <ImfRgbaFile.h>
 #include <ImfStandardAttributes.h>
@@ -41,10 +41,10 @@ public:
     {
     }
 
-    virtual bool  read(char c[], int n);
-    virtual Imf::Int64 tellg();
-    virtual void seekg(Imf::Int64 pos);
-    virtual void clear();
+    bool  read(char c[], int n) Q_DECL_OVERRIDE;
+    Imf::Int64 tellg() Q_DECL_OVERRIDE;
+    void seekg(Imf::Int64 pos) Q_DECL_OVERRIDE;
+    void clear() Q_DECL_OVERRIDE;
 
 private:
     QIODevice *m_dev;

src/imageformats/exr_p.h

@@ -18,8 +18,8 @@ class EXRHandler : public QImageIOHandler
 public:
     EXRHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *outImage);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *outImage) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class EXRPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "exr.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_EXR_H

src/imageformats/hdr.cpp

@@ -8,7 +8,7 @@
    version 2 of the License, or (at your option) any later version.
 */
 
-#include "hdr.h"
+#include "hdr_p.h"
 
 #include <QImage>
 #include <QtCore/QDataStream>

src/imageformats/jp2.cpp

@@ -5,7 +5,7 @@
 * This library is distributed under the conditions of the GNU LGPL.
 */
 
-#include "jp2.h"
+#include "jp2_p.h"
 
 #include <config-jp2.h>
 

src/imageformats/pcx.cpp

@@ -7,7 +7,7 @@
    version 2 of the License, or (at your option) any later version.
 */
 
-#include "pcx.h"
+#include "pcx_p.h"
 
 #include <QColor>
 #include <QDataStream>

src/imageformats/pcx_p.h

@@ -17,9 +17,9 @@ class PCXHandler : public QImageIOHandler
 public:
     PCXHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool write(const QImage &image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class PCXPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pcx.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_PCX_H

src/imageformats/pic.cpp

@@ -1,5 +1,6 @@
 /*
- * Softimage PIC support for QImage
+ * Softimage PIC support for QImage.
+ *
  * Copyright 1998 Halfdan Ingvarsson
  * Copyright 2007 Ruben Lopez <r.lopez@bren.es>
  * Copyright 2014 Alex Merry <alex.merry@kde.org>
@@ -25,7 +26,9 @@
  * with his permission.
  */
 
-#include "pic.h"
+#include "pic_p.h"
+
+#include "rle_p.h"
 
 #include <QDataStream>
 #include <QDebug>
@@ -167,82 +170,6 @@ static QDataStream &operator<< (QDataStream &s, const QList<PicChannel> &channel
     return s;
 }
 
-/**
- * Decodes data written in mixed run-length encoding format.
- *
- * This is intended to be used with lambda functions.
- *
- * Note that this functions expects that, at the current location in @p stream,
- * exactly @p length items have been encoded as a unit (and so it will not be
- * partway through a run when it has decoded @p length items). If this is not
- * the case, it will return @c false.
- *
- * @param stream      The stream to read the data from.
- * @param data        The location to write the data.
- * @param length      The number of items to read.
- * @param readItem    A function that takes a QDataStream reference and reads a
- *                    single item.
- * @param updateItem  A function that takes an item from @p data and an item
- *                    read by @p readItem and produces the item that should be
- *                    written to @p data.
- *
- * @returns @c true if @p length items in mixed RLE were successfully read
- *          into @p data, @c false otherwise.
- */
-template<typename Item, typename Func1, typename Func2>
-static bool decodeMixedRLEData(QDataStream &stream,
-                               Item *data,
-                               quint16 length,
-                               Func1 readItem,
-                               Func2 updateItem)
-{
-    unsigned offset = 0; // in data
-    while (offset < length) {
-        unsigned remaining = length - offset;
-        quint8 count1;
-        stream >> count1;
-
-        if (count1 >= 128u) {
-            unsigned length;
-            if (count1 == 128u) {
-                // If the value is exactly 128, it means that it is more than
-                // 127 repetitions
-                quint16 count2;
-                stream >> count2;
-                length = count2;
-            } else {
-                // If last bit is 1, then it is 2 to 127 repetitions
-                length = count1 - 127u;
-            }
-            if (length > remaining) {
-                qDebug() << "Row overrun:" << length << ">" << remaining;
-                return false;
-            }
-            Item item = readItem(stream);
-            for (unsigned i = offset; i < offset + length; ++i) {
-                data[i] = updateItem(data[i], item);
-            }
-            offset += length;
-        } else {
-            // No repetitions
-            unsigned length = count1 + 1u;
-            if (length > remaining) {
-                qDebug() << "Row overrun:" << length << ">" << remaining;
-                return false;
-            }
-            for (unsigned i = offset; i < offset + length; ++i) {
-                Item item = readItem(stream);
-                data[i] = updateItem(data[i], item);
-            }
-            offset += length;
-        }
-    }
-    if (stream.status() != QDataStream::Ok) {
-        qDebug() << "DataStream status was" << stream.status();;;;
-    }
-    return stream.status() == QDataStream::Ok;
-}
-
 static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChannel> channels)
 {
     Q_FOREACH(const PicChannel &channel, channels) {
@@ -273,8 +200,10 @@ static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChan
                 qAlpha((channel.code & ALPHA) ? newPixel : oldPixel));
         };
         if (channel.encoding == MixedRLE) {
-            if (!decodeMixedRLEData(stream, row, width, readPixel, updatePixel)) {
-                qDebug() << "decodeMixedRLEData failed";
+            bool success = decodeRLEData(RLEVariant::PIC, stream, row, width,
+                                         readPixel, updatePixel);
+            if (!success) {
+                qDebug() << "decodeRLEData failed";
                 return false;
             }
         } else if (channel.encoding == Uncompressed) {
@@ -294,67 +223,6 @@ static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChan
     return stream.status() == QDataStream::Ok;
 }
 
-/**
- * Encodes data in mixed run-length encoding format.
- *
- * This is intended to be used with lambda functions.
- *
- * @param stream      The stream to write the data to.
- * @param data        The data to be written.
- * @param length      The number of items to write.
- * @param itemsEqual  A function that takes two items and returns whether
- *                    @p writeItem would write them identically.
- * @param writeItem   A function that takes a QDataStream reference and an item
- *                    and writes the item to the data stream.
- */
-template<typename Item, typename Func1, typename Func2>
-static void encodeMixedRLEData(QDataStream &stream, const Item *data, unsigned length, Func1 itemsEqual, Func2 writeItem)
-{
-    unsigned offset = 0;
-    while (offset < length) {
-        const Item *chunkStart = data + offset;
-        unsigned maxChunk = qMin(length - offset, 65535u);
-
-        const Item *chunkEnd = chunkStart + 1;
-        quint16 chunkLength = 1;
-        while (chunkLength < maxChunk && itemsEqual(*chunkStart, *chunkEnd)) {
-            ++chunkEnd;
-            ++chunkLength;
-        }
-
-        if (chunkLength > 127) {
-            // Sequence of > 127 identical pixels
-            stream << quint8(128);
-            stream << quint16(chunkLength);
-            writeItem(stream, *chunkStart);
-        } else if (chunkLength > 1) {
-            // Sequence of < 128 identical pixels
-            stream << quint8(chunkLength + 127);
-            writeItem(stream, *chunkStart);
-        } else {
-            // find a string of up to 128 values, each different from the one
-            // that follows it
-            if (maxChunk > 128) {
-                maxChunk = 128;
-            }
-            chunkLength = 1;
-            chunkEnd = chunkStart + 1;
-            while (chunkLength < maxChunk &&
-                    (chunkLength + 1u == maxChunk ||
-                     !itemsEqual(*chunkEnd, *(chunkEnd+1))))
-            {
-                ++chunkEnd;
-                ++chunkLength;
-            }
-            stream << quint8(chunkLength - 1);
-            for (unsigned i = 0; i < chunkLength; ++i) {
-                writeItem(stream, *(chunkStart + i));
-            }
-        }
-        offset += chunkLength;
-    }
-}
-
 bool SoftimagePICHandler::canRead() const
 {
     if (!SoftimagePICHandler::canRead(device())) {
@@ -445,7 +313,8 @@ bool SoftimagePICHandler::write(const QImage &_image)
                 << quint8(qBlue(pixel));
         };
         if (m_compression) {
-            encodeMixedRLEData(stream, row, image.width(), rgbEqual, writeRgb);
+            encodeRLEData(RLEVariant::PIC, stream, row, image.width(),
+                          rgbEqual, writeRgb);
         } else {
             for (int i = 0; i < image.width(); ++i) {
                 writeRgb(stream, row[i]);
@@ -461,7 +330,8 @@ bool SoftimagePICHandler::write(const QImage &_image)
                 str << quint8(qAlpha(pixel));
             };
             if (m_compression) {
-                encodeMixedRLEData(stream, row, image.width(), alphaEqual, writeAlpha);
+                encodeRLEData(RLEVariant::PIC, stream, row, image.width(),
+                              alphaEqual, writeAlpha);
             } else {
                 for (int i = 0; i < image.width(); ++i) {
                     writeAlpha(stream, row[i]);

src/imageformats/pic_p.h

@@ -22,6 +22,7 @@
 #define KIMG_PIC_H
 
 #include <QImageIOPlugin>
+#include <QDataStream>
 
 /**
  * The magic number at the start of a SoftImage PIC file.
@@ -194,8 +195,8 @@ class SoftimagePICPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pic.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_PIC_H

src/imageformats/psd.cpp

@@ -1,27 +1,41 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Ignacio Castaño <castano@ludicon.com>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This code is based on Thacher Ulrich PSD loading code released
-   on public domain. See: http://tulrich.com/geekstuff/
-*/
-
-/* this code supports:
- * reading:
- *     rle and raw psd files
- * writing:
- *     not supported
+/*
+ * Photoshop File Format support for QImage.
+ *
+ * Copyright 2003 Ignacio Castaño <castano@ludicon.com>
+ * Copyright 2015 Alex Merry <alex.merry@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "psd.h"
+/*
+ * This code is based on Thacher Ulrich PSD loading code released
+ * into the public domain. See: http://tulrich.com/geekstuff/
+ */
 
+/*
+ * Documentation on this file format is available at
+ * http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/
+ */
+
+#include "psd_p.h"
+
+#include "rle_p.h"
+
+#include <QDataStream>
+#include <QDebug>
 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
 
 typedef quint32 uint;
 typedef quint16 ushort;
@@ -66,20 +80,6 @@ static QDataStream &operator>> (QDataStream &s, PSDHeader &header)
     s >> header.color_mode;
     return s;
 }
-static bool seekBy(QDataStream &s, unsigned int bytes)
-{
-    char buf[4096];
-    while (bytes) {
-        unsigned int num = qMin(bytes, (unsigned int)sizeof(buf));
-        unsigned int l = num;
-        s.readRawData(buf, l);
-        if (l != num) {
-            return false;
-        }
-        bytes -= num;
-    }
-    return true;
-}
 
 // Check that the header is a valid PSD.
 static bool IsValid(const PSDHeader &header)
@@ -108,125 +108,107 @@ static bool IsSupported(const PSDHeader &header)
     return true;
 }
 
-// Load the PSD image.
-static bool LoadPSD(QDataStream &s, const PSDHeader &header, QImage &img)
+static void skip_section(QDataStream &s)
 {
-    // Create dst image.
-    img = QImage(header.width, header.height, QImage::Format_RGB32);
-
-    uint tmp;
-
+    quint32 section_length;
     // Skip mode data.
-    s >> tmp;
-    s.device()->seek(s.device()->pos() + tmp);
+    s >> section_length;
+    s.skipRawData(section_length);
+}
 
-    // Skip image resources.
-    s >> tmp;
-    s.device()->seek(s.device()->pos() + tmp);
+static quint8 readPixel(QDataStream &stream) {
+    quint8 pixel;
+    stream >> pixel;
+    return pixel;
+};
+static QRgb updateRed(QRgb oldPixel, quint8 redPixel) {
+    return qRgba(redPixel, qGreen(oldPixel), qBlue(oldPixel), qAlpha(oldPixel));
+};
+static QRgb updateGreen(QRgb oldPixel, quint8 greenPixel) {
+    return qRgba(qRed(oldPixel), greenPixel, qBlue(oldPixel), qAlpha(oldPixel));
+};
+static QRgb updateBlue(QRgb oldPixel, quint8 bluePixel) {
+    return qRgba(qRed(oldPixel), qGreen(oldPixel), bluePixel, qAlpha(oldPixel));
+};
+static QRgb updateAlpha(QRgb oldPixel, quint8 alphaPixel) {
+    return qRgba(qRed(oldPixel), qGreen(oldPixel), qBlue(oldPixel), alphaPixel);
+};
+typedef QRgb(*channelUpdater)(QRgb,quint8);
 
-    // Skip the reserved data.
-    s >> tmp;
-    s.device()->seek(s.device()->pos() + tmp);
+// Load the PSD image.
+static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)
+{
+    // Mode data
+    skip_section(stream);
+
+    // Image resources
+    skip_section(stream);
+
+    // Reserved data
+    skip_section(stream);
 
     // Find out if the data is compressed.
     // Known values:
     //   0: no compression
     //   1: RLE compressed
-    ushort compression;
-    s >> compression;
+    quint16 compression;
+    stream >> compression;
 
     if (compression > 1) {
-        // Unknown compression type.
+        qDebug() << "Unknown compression type";
         return false;
     }
 
-    uint channel_num = header.channel_count;
+    quint32 channel_num = header.channel_count;
 
+    QImage::Format fmt = QImage::Format_RGB32;
     // Clear the image.
-    if (channel_num < 4) {
-        img.fill(qRgba(0, 0, 0, 0xFF));
-    } else {
+    if (channel_num >= 4) {
         // Enable alpha.
-        img = img.convertToFormat(QImage::Format_ARGB32);
+        fmt = QImage::Format_ARGB32;
 
         // Ignore the other channels.
         channel_num = 4;
     }
+    img = QImage(header.width, header.height, fmt);
+    img.fill(qRgb(0,0,0));
 
-    const uint pixel_count = header.height * header.width;
+    const quint32 pixel_count = header.height * header.width;
 
-    static const uint components[4] = {2, 1, 0, 3}; // @@ Is this endian dependant?
+    QRgb *image_data = reinterpret_cast<QRgb*>(img.bits());
+
+    static const channelUpdater updaters[4] = {
+        updateRed,
+        updateGreen,
+        updateBlue,
+        updateAlpha
+    };
 
     if (compression) {
-
         // Skip row lengths.
-        if (!seekBy(s, header.height * header.channel_count * sizeof(ushort))) {
+        int skip_count = header.height * header.channel_count * sizeof(quint16);
+        if (stream.skipRawData(skip_count) != skip_count) {
             return false;
         }
 
-        // Read RLE data.
-        for (uint channel = 0; channel < channel_num; channel++) {
-
-            uchar *ptr = img.bits() + components[channel];
-
-            uint count = 0;
-            while (count < pixel_count) {
-                uchar c;
-                if (s.atEnd()) {
-                    return false;
-                }
-                s >> c;
-                uint len = c;
-
-                if (len < 128) {
-                    // Copy next len+1 bytes literally.
-                    len++;
-                    count += len;
-                    if (count > pixel_count) {
-                        return false;
-                    }
-
-                    while (len != 0) {
-                        s >> *ptr;
-                        ptr += 4;
-                        len--;
-                    }
-                } else if (len > 128) {
-                    // Next -len+1 bytes in the dest are replicated from next source byte.
-                    // (Interpret len as a negative 8-bit int.)
-                    len ^= 0xFF;
-                    len += 2;
-                    count += len;
-                    if (s.atEnd() || count > pixel_count) {
-                        return false;
-                    }
-                    uchar val;
-                    s >> val;
-                    while (len != 0) {
-                        *ptr = val;
-                        ptr += 4;
-                        len--;
-                    }
-                } else if (len == 128) {
-                    // No-op.
-                }
+        for (unsigned short channel = 0; channel < channel_num; channel++) {
+            bool success = decodeRLEData(RLEVariant::PackBits, stream,
+			                 image_data, pixel_count,
+					 &readPixel, updaters[channel]);
+            if (!success) {
+                qDebug() << "decodeRLEData on channel" << channel << "failed";
+                return false;
             }
         }
     } else {
-        // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
-        // where each channel consists of an 8-bit value for each pixel in the image.
-
-        // Read the data by channel.
-        for (uint channel = 0; channel < channel_num; channel++) {
-
-            uchar *ptr = img.bits() + components[channel];
-
-            // Read the data.
-            uint count = pixel_count;
-            while (count != 0) {
-                s >> *ptr;
-                ptr += 4;
-                count--;
+        for (unsigned short channel = 0; channel < channel_num; channel++) {
+            for (unsigned i = 0; i < pixel_count; ++i) {
+                image_data[i] = updaters[channel](image_data[i], readPixel(stream));
+            }
+            // make sure we didn't try to read past the end of the stream
+            if (stream.status() != QDataStream::Ok) {
+                qDebug() << "DataStream status was" << stream.status();
+                return false;
             }
         }
     }

src/imageformats/psd_p.h

@@ -17,8 +17,8 @@ class PSDHandler : public QImageIOHandler
 public:
     PSDHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -29,8 +29,8 @@ class PSDPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "psd.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_PSD_H

src/imageformats/ras.cpp

@@ -9,7 +9,7 @@
    version 2 of the License, or (at your option) any later version.
 */
 
-#include "ras.h"
+#include "ras_p.h"
 
 #include <QImage>
 #include <QtCore/QDataStream>
@@ -219,7 +219,7 @@ bool RASHandler::canRead(QIODevice *device)
     }
 
     if (device->isSequential()) {
-        qWarning("Reading ras files from sequential devices not supported");
+        // qWarning("Reading ras files from sequential devices not supported");
         return false;
     }
 

src/imageformats/ras_p.h

@@ -18,8 +18,8 @@ class RASHandler : public QImageIOHandler
 public:
     RASHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class RASPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ras.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_RAS_H

src/imageformats/rgb.cpp

@@ -21,7 +21,7 @@
  * saved by this filter.
  */
 
-#include "rgb.h"
+#include "rgb_p.h"
 
 #include <QtCore/QMap>
 #include <QtCore/QVector>

src/imageformats/rgb_p.h

@@ -17,9 +17,9 @@ class RGBHandler : public QImageIOHandler
 public:
     RGBHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool write(const QImage &image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class RGBPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "rgb.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_RGB_H

src/imageformats/rle_p.h

@@ -0,0 +1,223 @@
+/*
+ * Run-Length Encoding utilities.
+ * Copyright 2014-2015 Alex Merry <alex.merry@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef KIMAGEFORMATS_RLE_H
+#define KIMAGEFORMATS_RLE_H
+
+#include <QDebug>
+#include <QDataStream>
+
+/**
+ * The RLEVariant to use.
+ *
+ * This mostly concerns what to do values >= 128.
+ */
+enum class RLEVariant {
+    /**
+     * PackBits-style RLE
+     *
+     * Value 128 is ignored, 129 indicates a repetition
+     * of size 2, 130 of size 3, up to 255 of size 128.
+     */
+    PackBits,
+    /**
+     * PIC-style RLE
+     *
+     * Value 128 indicates a 16-bit repetition count
+     * follows, while 129 indicates a repetition
+     * of size 128, 130 of size 127, down to 255 of
+     * size 2.
+     */
+    PIC
+};
+
+/**
+ * Decodes data written in run-length encoding format.
+ *
+ * This is intended to be used with lambda functions.
+ *
+ * Note that this functions expects that, at the current location in @p stream,
+ * exactly @p length items have been encoded as a unit (and so it will not be
+ * partway through a run when it has decoded @p length items). If this is not
+ * the case, it will return @c false.
+ *
+ * @param variant     The RLE variant to decode.
+ * @param stream      The stream to read the data from.
+ * @param buf         The location to write the decoded data.
+ * @param length      The number of items to read.
+ * @param readData    A function that takes a QDataStream reference and reads a
+ *                    single value.
+ * @param updateItem  A function that takes an item from @p buf and the result
+ *                    of a readData call, and produces the item that should be
+ *                    written to @p buf.
+ *
+ * @returns @c true if @p length items in mixed RLE were successfully read
+ *          into @p buf, @c false otherwise.
+ */
+template<typename Item, typename Func1, typename Func2>
+static inline bool decodeRLEData(RLEVariant variant,
+                                 QDataStream &stream,
+                                 Item *dest,
+                                 quint16 length,
+                                 Func1 readData,
+                                 Func2 updateItem)
+{
+    unsigned offset = 0; // in dest
+    while (offset < length) {
+        unsigned remaining = length - offset;
+        quint8 count1;
+        stream >> count1;
+
+        if (count1 >= 128u) {
+            unsigned length = 0;
+            if (variant == RLEVariant::PIC) {
+                if (count1 == 128u) {
+                    // If the value is exactly 128, it means that it is more than
+                    // 127 repetitions
+                    quint16 count2;
+                    stream >> count2;
+                    length = count2;
+                } else {
+                    // 2 to 128 repetitions
+                    length = count1 - 127u;
+                }
+            } else if (variant == RLEVariant::PackBits) {
+                if (count1 == 128u) {
+                    // Ignore value 128
+                    continue;
+                } else {
+                    // 128 to 2 repetitions
+                    length = 257u - count1;
+                }
+            } else {
+                Q_ASSERT(false);
+            }
+            if (length > remaining) {
+                qDebug() << "Row overrun:" << length << ">" << remaining;
+                return false;
+            }
+            auto datum = readData(stream);
+            for (unsigned i = offset; i < offset + length; ++i) {
+                dest[i] = updateItem(dest[i], datum);
+            }
+            offset += length;
+        } else {
+            // No repetitions
+            unsigned length = count1 + 1u;
+            if (length > remaining) {
+                qDebug() << "Row overrun:" << length << ">" << remaining;
+                return false;
+            }
+            for (unsigned i = offset; i < offset + length; ++i) {
+                auto datum = readData(stream);
+                dest[i] = updateItem(dest[i], datum);
+            }
+            offset += length;
+        }
+    }
+    if (stream.status() != QDataStream::Ok) {
+        qDebug() << "DataStream status was" << stream.status();
+    }
+    return stream.status() == QDataStream::Ok;
+}
+
+
+/**
+ * Encodes data in run-length encoding format.
+ *
+ * This is intended to be used with lambda functions.
+ *
+ * @param variant     The RLE variant to encode in.
+ * @param stream      The stream to write the data to.
+ * @param data        The data to be written.
+ * @param length      The number of items to write.
+ * @param itemsEqual  A function that takes two items and returns whether
+ *                    @p writeItem would write them identically.
+ * @param writeItem   A function that takes a QDataStream reference and an item
+ *                    and writes the item to the data stream.
+ */
+template<typename Item, typename Func1, typename Func2>
+static inline void encodeRLEData(RLEVariant variant,
+                                 QDataStream &stream,
+		                 const Item *data,
+				 unsigned length,
+				 Func1 itemsEqual,
+				 Func2 writeItem)
+{
+    unsigned offset = 0;
+    const unsigned maxEncodableChunk =
+        (variant == RLEVariant::PIC)
+        ? 65535u
+        : 128;
+    while (offset < length) {
+        const Item *chunkStart = data + offset;
+        unsigned maxChunk = qMin(length - offset, maxEncodableChunk);
+
+        const Item *chunkEnd = chunkStart + 1;
+        quint16 chunkLength = 1;
+        while (chunkLength < maxChunk && itemsEqual(*chunkStart, *chunkEnd)) {
+            ++chunkEnd;
+            ++chunkLength;
+        }
+
+        if (chunkLength > 128) {
+            // Sequence of > 128 identical pixels
+            Q_ASSERT(variant == RLEVariant::PIC);
+            stream << quint8(128);
+            stream << quint16(chunkLength);
+            writeItem(stream, *chunkStart);
+        } else if (chunkLength > 1) {
+            // Sequence of <= 128 identical pixels
+            quint8 encodedLength;
+            if (variant == RLEVariant::PIC) {
+                encodedLength = quint8(chunkLength + 127);
+            } else if (variant == RLEVariant::PackBits) {
+                encodedLength = quint8(257 - chunkLength);
+            } else {
+                Q_ASSERT(false);
+                encodedLength = 0;
+            }
+            stream << encodedLength;
+            writeItem(stream, *chunkStart);
+        } else {
+            // find a string of up to 128 values, each different from the one
+            // that follows it
+            if (maxChunk > 128) {
+                maxChunk = 128;
+            }
+            chunkLength = 1;
+            chunkEnd = chunkStart + 1;
+            while (chunkLength < maxChunk &&
+                    (chunkLength + 1u == maxChunk ||
+                     !itemsEqual(*chunkEnd, *(chunkEnd+1))))
+            {
+                ++chunkEnd;
+                ++chunkLength;
+            }
+            stream << quint8(chunkLength - 1);
+            for (unsigned i = 0; i < chunkLength; ++i) {
+                writeItem(stream, *(chunkStart + i));
+            }
+        }
+        offset += chunkLength;
+    }
+}
+
+#endif // KIMAGEFORMATS_RLE_H

src/imageformats/tga.cpp

@@ -18,7 +18,7 @@
  *     uncompressed true color tga files
  */
 
-#include "tga.h"
+#include "tga_p.h"
 
 #include <assert.h>
 

src/imageformats/tga_p.h

@@ -17,9 +17,9 @@ class TGAHandler : public QImageIOHandler
 public:
     TGAHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool write(const QImage &image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class TGAPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "tga.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_TGA_H

src/imageformats/xcf.cpp

@@ -19,7 +19,7 @@
  *
  */
 
-#include "xcf.h"
+#include "xcf_p.h"
 
 #include <stdlib.h>
 #include <QImage>
@@ -29,7 +29,7 @@
 #include <QtCore/QVector>
 // #include <QDebug>
 
-#include "gimp.h"
+#include "gimp_p.h"
 
 const float INCHESPERMETER = (100.0f / 2.54f);
 

src/imageformats/xcf_p.h

@@ -29,9 +29,9 @@ class XCFHandler : public QImageIOHandler
 public:
     XCFHandler();
 
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool write(const QImage &image) Q_DECL_OVERRIDE;
 
     static bool canRead(QIODevice *device);
 };
@@ -42,8 +42,8 @@ class XCFPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "xcf.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
 };
 
 #endif // KIMG_XCF_H