GIT_SILENT Upgrade ECM and KF5 version requirements for 5.67.0 release.

GIT_SILENT Bump KF5 deprecation level to 5.66
GIT_SILENT Upgrade ECM and KF5 version requirements for 5.66.0 release.
2025-07-15 11:14:18 -04:00 · 2020-02-01 09:04:07 +00:00 · 2020-01-12 12:46:21 +01:00 · 2020-01-03 23:12:09 +00:00 · 2019-12-21 12:34:54 +01:00 · 2019-12-15 22:42:38 +01:00
48 changed files with 686 additions and 366 deletions
--- a/.arcconfig
+++ b/.arcconfig
@ -0,0 +1,3 @@
+{
+  "phabricator.uri" : "https://phabricator.kde.org/"
+}
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,21 @@
+# Ignore the following files
+*~
+*.[oa]
+*.diff
+*.kate-swp
+*.kdev4
+.kdev_include_paths
+*.kdevelop.pcs
+*.moc
+*.moc.cpp
+*.orig
+*.user
+.*.swp
+.swp.*
+Doxyfile
+Makefile
+avail
+random_seed
+/build*/
+CMakeLists.txt.user*
+*.unc-backup*
--- a/.reviewboardrc
+++ b/.reviewboardrc
@ -1,5 +0,0 @@
-REVIEWBOARD_URL = "https://git.reviewboard.kde.org"
-REPOSITORY = 'git://anongit.kde.org/kimageformats'
-BRANCH = 'master'
-TARGET_GROUPS = 'kdeframeworks'
-TARGET_PEOPLE = 'alexmerry'
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,14 +1,14 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)

 project(KImageFormats)

 include(FeatureSummary)
-find_package(ECM 5.24.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.67.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)


-set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
+set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

 include(KDEInstallDirs)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
@ -17,7 +17,7 @@ include(KDECMakeSettings)

 include(CheckIncludeFiles)

-set(REQUIRED_QT_VERSION 5.4.0)
+set(REQUIRED_QT_VERSION 5.12.0)
 find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)

 find_package(KF5Archive)
@ -45,7 +45,11 @@ set_package_properties(OpenEXR PROPERTIES
    TYPE OPTIONAL
    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=0x054200)
 add_subdirectory(src)
 if (BUILD_TESTING)
    add_subdirectory(autotests)
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@ -3,7 +3,7 @@
 include(ECMMarkAsTest)
 include(CMakeParseArguments)

-add_definitions(-DPLUGIN_DIR="${CMAKE_CURRENT_BINARY_DIR}/../src")
+add_definitions(-DPLUGIN_DIR="${CMAKE_CURRENT_BINARY_DIR}/../bin")
 remove_definitions(-DQT_NO_CAST_FROM_ASCII)

 macro(kimageformats_read_tests)
@ -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
--- a/autotests/pictest.cpp
+++ b/autotests/pictest.cpp
@ -210,11 +210,11 @@ private Q_SLOTS:
            QFile picDumpFile(fileNameBase + QStringLiteral("-expected.data"));
            QVERIFY2(picDumpFile.open(QIODevice::WriteOnly), qPrintable(picDumpFile.errorString()));
            picDumpFile.write(reinterpret_cast<const char *>(inputImage.bits()),
-                              inputImage.byteCount());
+                              inputImage.sizeInBytes());
            QFile pngDumpFile(fileNameBase + QStringLiteral("-actual.data"));
            QVERIFY2(pngDumpFile.open(QIODevice::WriteOnly), qPrintable(pngDumpFile.errorString()));
            pngDumpFile.write(reinterpret_cast<const char *>(expImage.bits()),
-                              expImage.byteCount());
+                              expImage.sizeInBytes());
            QString msg = QStringLiteral("Read image (")
                        + picDumpFile.fileName()
                        + QStringLiteral(") differed from expected image (")
--- a/autotests/read/hdr/rgb.hdr
+++ b/autotests/read/hdr/rgb.hdr
--- a/autotests/read/hdr/rgb.png
+++ b/autotests/read/hdr/rgb.png
--- a/autotests/read/xcf/bug411327.png
+++ b/autotests/read/xcf/bug411327.png
--- a/autotests/read/xcf/bug411327.xcf
+++ b/autotests/read/xcf/bug411327.xcf
--- a/autotests/read/xcf/simple-rgba-gimp-2.8.10.png
+++ b/autotests/read/xcf/simple-rgba-gimp-2.8.10.png
--- a/autotests/readtest.cpp
+++ b/autotests/readtest.cpp
@ -35,8 +35,8 @@ static void writeImageData(const char *name, const QString &filename, const QIma
 {
    QFile file(filename);
    if (file.open(QIODevice::WriteOnly)) {
-        qint64 written = file.write(reinterpret_cast<const char *>(image.bits()), image.byteCount());
-        if (written == image.byteCount()) {
+        qint64 written = file.write(reinterpret_cast<const char *>(image.bits()), image.sizeInBytes());
+        if (written == image.sizeInBytes()) {
            QTextStream(stdout) << "       " << name
                                << " written to " << filename << "\n";
        } else {
@ -75,6 +75,7 @@ static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
 int main(int argc, char ** argv)
 {
    QCoreApplication app(argc, argv);
+    QCoreApplication::removeLibraryPath(QStringLiteral(PLUGIN_DIR));
    QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
    QCoreApplication::setApplicationName(QStringLiteral("readtest"));
    QCoreApplication::setApplicationVersion(QStringLiteral("1.0.0"));
@ -126,7 +127,8 @@ int main(int argc, char ** argv)
        << "Starting basic read tests for "
        << suffix << " images *********\n";

-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    const QFileInfoList lstImgDir = imgdir.entryInfoList();
+    for (const QFileInfo &fi : lstImgDir) {
        int suffixPos = fi.filePath().count() - suffix.count();
        QString inputfile = fi.filePath();
        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
@ -146,6 +148,14 @@ int main(int argc, char ** argv)
            ++failed;
            continue;
        }
+        if (!inputReader.canRead()) {
+            QTextStream(stdout) << "FAIL : " << fi.fileName()
+                << ": failed can read: "
+                << inputReader.errorString()
+                << "\n";
+            ++failed;
+            continue;
+        }
        if (!inputReader.read(&inputImage)) {
            QTextStream(stdout) << "FAIL : " << fi.fileName()
                << ": failed to load: "
--- a/autotests/writetest.cpp
+++ b/autotests/writetest.cpp
@ -34,6 +34,7 @@
 int main(int argc, char ** argv)
 {
    QCoreApplication app(argc, argv);
+    QCoreApplication::removeLibraryPath(QStringLiteral(PLUGIN_DIR));
    QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
    QCoreApplication::setApplicationName(QStringLiteral("readtest"));
    QCoreApplication::setApplicationVersion(QStringLiteral("1.0.0"));
@ -72,8 +73,8 @@ int main(int argc, char ** argv)
    QTextStream(stdout) << "********* "
        << "Starting basic write tests for "
        << suffix << " images *********\n";
-
-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    const QFileInfoList lstImgDir = imgdir.entryInfoList();
+    for (const QFileInfo &fi : lstImgDir) {
        int suffixPos = fi.filePath().count() - suffix.count();
        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
        QString pngfilename = QFileInfo(pngfile).fileName();
--- a/metainfo.yaml
+++ b/metainfo.yaml
@ -4,6 +4,7 @@ tier: 2
 type: functional
 platforms:
    - name: Linux
+    - name: FreeBSD
    - name: MacOSX
    - name: Windows
      note: No EPS support on Windows
--- a/src/imageformats/CMakeLists.txt
+++ b/src/imageformats/CMakeLists.txt
@ -2,107 +2,105 @@

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

+function(kimageformats_add_plugin plugin)
+    set(options)
+    set(oneValueArgs JSON)
+    set(multiValueArgs SOURCES)
+    cmake_parse_arguments(KIF_ADD_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    if(NOT KIF_ADD_PLUGIN_SOURCES)
+        message(FATAL_ERROR "kimageformats_add_plugin called without SOURCES parameter")
+    endif()
+    get_filename_component(json "${KIF_ADD_PLUGIN_JSON}" REALPATH)
+    if(NOT KIF_ADD_PLUGIN_JSON OR NOT EXISTS ${json})
+        message(FATAL_ERROR "JSON file doesn't exist: ${json}")
+    endif()
+
+    add_library(${plugin} MODULE ${KIF_ADD_PLUGIN_SOURCES})
+    set_property(TARGET ${plugin} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS ${json})
+    set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/imageformats")
+    target_link_libraries(${plugin} Qt5::Gui)
+    install(TARGETS ${plugin} DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats)
+endfunction()
+
+##################################
+
 install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)

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

 if (BUILD_EPS_PLUGIN)
    if (Qt5PrintSupport_FOUND)
-        add_library(kimg_eps MODULE eps.cpp)
-        target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
-
-        install(TARGETS kimg_eps  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+        kimageformats_add_plugin(kimg_eps JSON "eps.json" SOURCES eps.cpp)
+        target_link_libraries(kimg_eps Qt5::PrintSupport)
        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
    endif()
 endif()

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

-
 # need this for Qt's version of the plugin
 install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)

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

 if(OpenEXR_FOUND)
-    add_library(kimg_exr MODULE exr.cpp)
-    target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
+    kimageformats_add_plugin(kimg_exr JSON "exr.json" SOURCES exr.cpp)
+    target_link_libraries(kimg_exr OpenEXR::IlmImf)
    kde_target_enable_exceptions(kimg_exr PRIVATE)

-    install(TARGETS kimg_exr  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()

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

-add_library(kimg_pcx MODULE pcx.cpp)
-target_link_libraries(kimg_pcx  Qt5::Gui)
+kimageformats_add_plugin(kimg_hdr JSON "hdr.json" SOURCES hdr.cpp)
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)

-install(TARGETS kimg_pcx  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+##################################
+
+kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
 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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_pic JSON "pic.json" SOURCES pic.cpp)
 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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_psd JSON "psd.json" SOURCES psd.cpp)
 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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_ras JSON "ras.json" SOURCES ras.cpp)
 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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_rgb JSON "rgb.json" SOURCES rgb.cpp)
 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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_tga JSON "tga.json" SOURCES tga.cpp)
 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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_xcf JSON "xcf.json" SOURCES xcf.cpp)
 install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)

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

 if (KF5Archive_FOUND)

-    add_library(kimg_kra MODULE kra.cpp)
-    target_link_libraries(kimg_kra Qt5::Gui KF5::Archive)
-
-    install(TARGETS kimg_kra  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    kimageformats_add_plugin(kimg_kra JSON "kra.json" SOURCES kra.cpp)
+    target_link_libraries(kimg_kra KF5::Archive)
    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)

-    add_library(kimg_ora MODULE ora.cpp)
-    target_link_libraries(kimg_ora Qt5::Gui KF5::Archive)
-
-    install(TARGETS kimg_ora  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    kimageformats_add_plugin(kimg_ora JSON "ora.json" SOURCES ora.cpp)
+    target_link_libraries(kimg_ora KF5::Archive)
    install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)

 endif()
--- a/src/imageformats/eps.cpp
+++ b/src/imageformats/eps.cpp
@ -14,13 +14,10 @@
 #include <QPrinter>
 #include <QProcess>
 #include <QTemporaryFile>
+#include <QCoreApplication>

-#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

@ -160,7 +157,7 @@ bool EPSHandler::read(QImage *image)

    QTemporaryFile tmpFile;
    if (!tmpFile.open()) {
-        qWarning() << "Could not create the temporary file" << tmpFile.fileName();
+        qCWarning(EPSPLUGIN) << "Could not create the temporary file" << tmpFile.fileName();
        return false;
    }
    qCDebug(EPSPLUGIN) << "temporary file:" << tmpFile.fileName();
@ -202,7 +199,7 @@ bool EPSHandler::read(QImage *image)
    converter.setProcessChannelMode(QProcess::ForwardedErrorChannel);
    converter.start(QStringLiteral("gs"), gsArgs);
    if (!converter.waitForStarted(3000)) {
-        qWarning() << "Reading EPS files requires gs (from GhostScript)";
+        qCWarning(EPSPLUGIN) << "Reading EPS files requires gs (from GhostScript)";
        return false;
    }

@ -301,7 +298,7 @@ bool EPSHandler::write(const QImage &image)
        converter.start(QStringLiteral("gs"), gsArgs);

        if (!converter.waitForStarted(3000)) {
-            qWarning() << "Creating EPS files requires pdftops (from Poppler) or gs (from GhostScript)";
+            qCWarning(EPSPLUGIN) << "Creating EPS files requires pdftops (from Poppler) or gs (from GhostScript)";
            return false;
        }
    }
@ -316,7 +313,7 @@ bool EPSHandler::write(const QImage &image)
 bool EPSHandler::canRead(QIODevice *device)
 {
    if (!device) {
-        qWarning("EPSHandler::canRead() called with no device");
+        qCWarning(EPSPLUGIN) << "EPSHandler::canRead() called with no device";
        return false;
    }

@ -337,14 +334,23 @@ bool EPSHandler::canRead(QIODevice *device)

 QImageIOPlugin::Capabilities EPSPlugin::capabilities(QIODevice *device, const QByteArray &format) const
 {
+    // prevent bug #397040: when on app shutdown the clipboard content is to be copied to survive end of the app,
+    // QXcbIntegration looks for some QImageIOHandler to apply, querying the capabilities and picking any first.
+    // At that point this plugin no longer has its requirements e.g. to run the external process, so we have to deny.
+    // The capabilities seem to be queried on demand in Qt code and not cached, so it's fine to report based
+    // in current dynamic state
+    if (!QCoreApplication::instance()) {
+        return {};
+    }
+
    if (format == "eps" || format == "epsi" || format == "epsf") {
        return Capabilities(CanRead | CanWrite);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/eps_p.h
+++ b/src/imageformats/eps_p.h
@ -4,8 +4,8 @@
 *
 * This library is distributed under the conditions of the GNU LGPL.
 */
-#ifndef KIMG_EPS_H
-#define KIMG_EPS_H
+#ifndef KIMG_EPS_P_H
+#define KIMG_EPS_P_H

 #include <QImageIOPlugin>
 #include <QLoggingCategory>
@ -15,9 +15,9 @@ class EPSHandler : public QImageIOHandler
 public:
    EPSHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;

    static bool canRead(QIODevice *device);
 };
@ -28,11 +28,11 @@ class EPSPlugin : public QImageIOPlugin
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "eps.json")

 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

 Q_DECLARE_LOGGING_CATEGORY(EPSPLUGIN)

-#endif // KIMG_EPS_H
+#endif // KIMG_EPS_P_H

--- a/src/imageformats/exr.cpp
+++ b/src/imageformats/exr.cpp
@ -30,7 +30,7 @@

 #include <QImage>
 #include <QDataStream>
-// #include <QDebug>
+#include <QDebug>
 #include <QImageIOPlugin>

 class K_IStream: public Imf::IStream
@ -41,10 +41,10 @@ public:
    {
    }

-    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;
+    bool  read(char c[], int n) override;
+    Imf::Int64 tellg() override;
+    void seekg(Imf::Int64 pos) override;
+    void clear() override;

 private:
    QIODevice *m_dev;
@ -82,7 +82,7 @@ void K_IStream::clear()
 * format into the normal 32 bit pixel format. Process is from the
 * ILM code.
 */
-QRgb RgbaToQrgba(struct Imf::Rgba imagePixel)
+QRgb RgbaToQrgba(struct Imf::Rgba &imagePixel)
 {
    float r, g, b, a;

@ -218,10 +218,10 @@ QImageIOPlugin::Capabilities EXRPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/exr_p.h
+++ b/src/imageformats/exr_p.h
@ -8,8 +8,8 @@
 *
 */

-#ifndef KIMG_EXR_H
-#define KIMG_EXR_H
+#ifndef KIMG_EXR_P_H
+#define KIMG_EXR_P_H

 #include <QImageIOPlugin>

@ -18,8 +18,8 @@ class EXRHandler : public QImageIOHandler
 public:
    EXRHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *outImage) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *outImage) 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:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_EXR_H
+#endif // KIMG_EXR_P_H
--- a/src/imageformats/gimp_p.h
+++ b/src/imageformats/gimp_p.h
@ -125,7 +125,8 @@ typedef enum {
    PROP_PARASITES = 21,
    PROP_UNIT = 22,
    PROP_PATHS = 23,
-    PROP_USER_UNIT = 24
+    PROP_USER_UNIT = 24,
+    MAX_SUPPORTED_PROPTYPE // should always be at the end so its value is last + 1
 } PropType;

 // From GIMP "xcf.c" v1.2
--- a/src/imageformats/hdr.cpp
+++ b/src/imageformats/hdr.cpp
@ -11,11 +11,11 @@
 #include "hdr_p.h"

 #include <QImage>
-#include <QtCore/QDataStream>
+#include <QDataStream>

 #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;
+}
--- a/src/imageformats/hdr.json
+++ b/src/imageformats/hdr.json
@ -0,0 +1,4 @@
+{
+    "Keys": [ "hdr" ],
+    "MimeTypes": [ "image/x-hdr", "image/vnd.radiance" ]
+}
--- a/src/imageformats/hdr_p.h
+++ b/src/imageformats/hdr_p.h
@ -7,15 +7,30 @@
   version 2 of the License, or (at your option) any later version.
 */

-#ifndef KIMG_HDR_H
-#define KIMG_HDR_H
+#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
--- a/src/imageformats/kra.cpp
+++ b/src/imageformats/kra.cpp
@ -18,6 +18,9 @@
 #include <QIODevice>
 #include <QFile>

+static constexpr char s_magic[] = "application/x-krita";
+static constexpr int s_magic_size = sizeof(s_magic) - 1; // -1 to remove the last \0
+
 KraHandler::KraHandler()
 {
 }
@ -36,7 +39,7 @@ bool KraHandler::read(QImage *image)
    KZip zip(device());
    if (!zip.open(QIODevice::ReadOnly)) return false;

-    const KArchiveEntry *entry = zip.directory()->entry(QLatin1String("mergedimage.png"));
+    const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
    if (!entry || !entry->isFile()) return false;

    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
@ -55,7 +58,7 @@ bool KraHandler::canRead(QIODevice *device)

    char buff[57];
    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
-        return qstrcmp(buff + 0x26, "application/x-krita") == 0;
+        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;

    return false;
 }
@ -66,10 +69,10 @@ QImageIOPlugin::Capabilities KraPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/kra.h
+++ b/src/imageformats/kra.h
@ -17,8 +17,8 @@ class KraHandler : public QImageIOHandler
 public:
    KraHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image)  Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image)  override;

    static bool canRead(QIODevice *device);
 };
@ -29,11 +29,10 @@ class KraPlugin : public QImageIOPlugin
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "kra.json")

 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };



 #endif
-
--- a/src/imageformats/kra.json
+++ b/src/imageformats/kra.json
@ -1,5 +1,4 @@
 {
    "Keys": [ "kra" ],
-    "MimeTypes": [ "application/x-krita", "application/x-krita" ]
+    "MimeTypes": [ "application/x-krita" ]
 }
-
--- a/src/imageformats/ora.cpp
+++ b/src/imageformats/ora.cpp
@ -17,6 +17,9 @@

 #include <kzip.h>

+static constexpr char s_magic[] = "image/openraster";
+static constexpr int s_magic_size = sizeof(s_magic) - 1; // -1 to remove the last \0
+
 OraHandler::OraHandler()
 {
 }
@ -35,7 +38,7 @@ bool OraHandler::read(QImage *image)
    KZip zip(device());
    if (!zip.open(QIODevice::ReadOnly)) return false;

-    const KArchiveEntry *entry = zip.directory()->entry(QLatin1String("mergedimage.png"));
+    const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
    if (!entry || !entry->isFile()) return false;

    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
@ -54,7 +57,7 @@ bool OraHandler::canRead(QIODevice *device)

    char buff[54];
    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
-        return qstrcmp(buff + 0x26, "image/openraster") == 0;
+        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;

    return false;
 }
@ -65,10 +68,10 @@ QImageIOPlugin::Capabilities OraPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/ora.h
+++ b/src/imageformats/ora.h
@ -17,8 +17,8 @@ class OraHandler : public QImageIOHandler
 public:
    OraHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image)  Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image)  override;

    static bool canRead(QIODevice *device);
 };
@ -29,8 +29,8 @@ class OraPlugin : public QImageIOPlugin
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ora.json")
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };


--- a/src/imageformats/ora.json
+++ b/src/imageformats/ora.json
@ -1,5 +1,4 @@
 {
    "Keys": [ "ora" ],
-    "MimeTypes": [ "image/openraster", "image/openraster" ]
+    "MimeTypes": [ "image/openraster" ]
 }
-
--- a/src/imageformats/pcx.cpp
+++ b/src/imageformats/pcx.cpp
@ -11,7 +11,7 @@

 #include <QColor>
 #include <QDataStream>
-// #include <QDebug>
+#include <QDebug>
 #include <QImage>


@ -23,7 +23,7 @@ public:
    quint8 g;
    quint8 b;

-    static RGB from(const QRgb &color)
+    static RGB from(const QRgb color)
    {
        RGB c;
        c.r = qRed(color);
@ -169,7 +169,7 @@ static QDataStream &operator>>(QDataStream &s, PCXHEADER &ph)
    return s;
 }

-static QDataStream &operator<<(QDataStream &s, const RGB &rgb)
+static QDataStream &operator<<(QDataStream &s, const RGB rgb)
 {
    s << rgb.r << rgb.g << rgb.b;

@ -253,6 +253,9 @@ static void readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
    img = QImage(header.width(), header.height(), QImage::Format_Mono);
    img.setColorCount(2);

+    if (img.isNull())
+        return;
+
    for (int y = 0; y < header.height(); ++y) {
        if (s.atEnd()) {
            img = QImage();
@ -325,6 +328,10 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
        readLine(s, buf, header);

        uchar *p = img.scanLine(y);
+
+        if (!p)
+            return;
+
        unsigned int bpl = qMin(header.BytesPerLine, (quint16)header.width());
        for (unsigned int x = 0; x < bpl; ++x) {
            p[ x ] = buf[ x ];
@ -667,10 +674,10 @@ QImageIOPlugin::Capabilities PCXPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead | CanWrite);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/pcx_p.h
+++ b/src/imageformats/pcx_p.h
@ -7,8 +7,8 @@
   version 2 of the License, or (at your option) any later version.
 */

-#ifndef KIMG_PCX_H
-#define KIMG_PCX_H
+#ifndef KIMG_PCX_P_H
+#define KIMG_PCX_P_H

 #include <QImageIOPlugin>

@ -17,9 +17,9 @@ class PCXHandler : public QImageIOHandler
 public:
    PCXHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) 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:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_PCX_H
+#endif // KIMG_PCX_P_H
--- a/src/imageformats/pic.cpp
+++ b/src/imageformats/pic.cpp
@ -17,7 +17,7 @@
 *
 * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * ----------------------------------------------------------------------------
 */

@ -59,7 +59,10 @@ static QDataStream &operator>> (QDataStream &s, PicHeader &header)
    header.comment = QByteArray(comment);

    header.id.resize(4);
-    s.readRawData(header.id.data(), 4);
+    const int bytesRead = s.readRawData(header.id.data(), 4);
+    if (bytesRead != 4) {
+        header.id.resize(bytesRead);
+    }

    s >> header.width;
    s >> header.height;
@ -127,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;
@ -170,9 +171,9 @@ static QDataStream &operator<< (QDataStream &s, const QList<PicChannel> &channel
    return s;
 }

-static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChannel> channels)
+static bool readRow(QDataStream &stream, QRgb *row, quint16 width, const QList<PicChannel> &channels)
 {
-    Q_FOREACH(const PicChannel &channel, channels) {
+    for(const PicChannel &channel : channels) {
        auto readPixel = [&] (QDataStream &str) -> QRgb {
            quint8 red = 0;
            if (channel.code & RED) {
@ -239,7 +240,7 @@ bool SoftimagePICHandler::read(QImage *image)
    }

    QImage::Format fmt = QImage::Format_RGB32;
-    Q_FOREACH(const PicChannel &channel, m_channels) {
+    for (const PicChannel &channel : qAsConst(m_channels)) {
        if (channel.size != 8) {
            // we cannot read images that do not come in bytes
            qDebug() << "Channel size was" << channel.size;
@ -385,8 +386,8 @@ void SoftimagePICHandler::setOption(ImageOption option, const QVariant &value)
            break;
        case Description: {
            m_description.clear();
-            QStringList entries = value.toString().split(QStringLiteral("\n\n"));
-            Q_FOREACH(const QString entry, entries) {
+            const QStringList entries = value.toString().split(QStringLiteral("\n\n"));
+            for (const QString &entry : entries) {
                if (entry.startsWith(QStringLiteral("Description: "))) {
                    m_description = entry.mid(13).simplified().toUtf8();
                }
@ -422,7 +423,7 @@ QVariant SoftimagePICHandler::option(ImageOption option) const
            return QString();
        case ImageFormat:
            if (const_cast<SoftimagePICHandler*>(this)->readChannels()) {
-                Q_FOREACH (const PicChannel &channel, m_channels) {
+                for (const PicChannel &channel : qAsConst(m_channels)) {
                    if (channel.code & ALPHA) {
                        return QImage::Format_ARGB32;
                    }
@ -449,10 +450,10 @@ QImageIOPlugin::Capabilities SoftimagePICPlugin::capabilities(QIODevice *device,
        return Capabilities(CanRead | CanWrite);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/pic_p.h
+++ b/src/imageformats/pic_p.h
@ -14,12 +14,12 @@
 *
 * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * ----------------------------------------------------------------------------
 */

-#ifndef KIMG_PIC_H
-#define KIMG_PIC_H
+#ifndef KIMG_PIC_P_H
+#define KIMG_PIC_P_H

 #include <QImageIOPlugin>
 #include <QDataStream>
@ -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. */

@ -154,13 +154,13 @@ struct PicChannel {
 class SoftimagePICHandler : public QImageIOHandler
 {
 public:
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &) override;

-    QVariant option(ImageOption option) const Q_DECL_OVERRIDE;
-    void setOption(ImageOption option, const QVariant &value) Q_DECL_OVERRIDE;
-    bool supportsOption(ImageOption option) const Q_DECL_OVERRIDE;
+    QVariant option(ImageOption option) const override;
+    void setOption(ImageOption option, const QVariant &value) override;
+    bool supportsOption(ImageOption option) const override;

    static bool canRead(QIODevice *device);

@ -195,8 +195,8 @@ class SoftimagePICPlugin : public QImageIOPlugin
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pic.json")

 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_PIC_H
+#endif // KIMG_PIC_P_H
--- a/src/imageformats/pnm.desktop
+++ b/src/imageformats/pnm.desktop
@ -1,7 +0,0 @@
-[Desktop Entry]
-Type=Service
-X-KDE-ServiceTypes=QImageIOPlugins
-X-KDE-ImageFormat=pnm
-X-KDE-MimeType=image/x-portable-anymap
-X-KDE-Read=true
-X-KDE-Write=false
--- a/src/imageformats/psd.cpp
+++ b/src/imageformats/psd.cpp
@ -16,7 +16,7 @@
 *
 * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

 /*
@ -177,6 +177,10 @@ static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)

    QRgb *image_data = reinterpret_cast<QRgb*>(img.bits());

+    if (!image_data) {
+        return false;
+    }
+
    static const channelUpdater updaters[4] = {
        updateRed,
        updateGreen,
@ -300,10 +304,10 @@ QImageIOPlugin::Capabilities PSDPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/psd_p.h
+++ b/src/imageformats/psd_p.h
@ -7,8 +7,8 @@
   version 2 of the License, or (at your option) any later version.
 */

-#ifndef KIMG_PSD_H
-#define KIMG_PSD_H
+#ifndef KIMG_PSD_P_H
+#define KIMG_PSD_P_H

 #include <QImageIOPlugin>

@ -17,8 +17,8 @@ class PSDHandler : public QImageIOHandler
 public:
    PSDHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;

    static bool canRead(QIODevice *device);
 };
@ -29,9 +29,9 @@ class PSDPlugin : public QImageIOPlugin
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "psd.json")

 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_PSD_H
+#endif // KIMG_PSD_P_H

--- a/src/imageformats/ras.cpp
+++ b/src/imageformats/ras.cpp
@ -12,8 +12,8 @@
 #include "ras_p.h"

 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
+#include <QDataStream>
+#include <QDebug>

 namespace   // Private.
 {
@ -102,6 +102,13 @@ static bool IsSupported(const RasHeader &head)
 static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
 {
    s.device()->seek(RasHeader::SIZE);
+
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.ColorMapLength > std::numeric_limits<int>::max() - 32) {
+        qWarning() << "LoadRAS() unsupported image color map length in file header" << ras.ColorMapLength;
+        return false;
+    }
+
    // Read palette if needed.
    QVector<quint8> palette(ras.ColorMapLength);
    if (ras.ColorMapType == 1) {
@ -110,19 +117,36 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
        }
    }

+    const int bpp = ras.Depth / 8;
+    if (ras.Height == 0) {
+        return false;
+    }
+    if (bpp == 0) {
+        return false;
+    }
+    if (ras.Length / ras.Height / bpp < ras.Width) {
+        qWarning() << "LoadRAS() mistmatch between height and width" << ras.Width << ras.Height << ras.Length << ras.Depth;
+        return false;
+    }
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.Length > std::numeric_limits<int>::max() - 32) {
+        qWarning() << "LoadRAS() unsupported image length in file header" << ras.Length;
+        return false;
+    }
+
    // each line must be a factor of 16 bits, so they may contain padding
    // this will be 1 if padding required, 0 otherwise
-    int paddingrequired = (ras.Width * (ras.Depth / 8) % 2);
+    const int paddingrequired = (ras.Width * bpp % 2);

    // qDebug() << "paddingrequired: " << paddingrequired;
    // don't trust ras.Length
    QVector<quint8> input(ras.Length);

    int i = 0;
-    while (! s.atEnd()) {
+    while (! s.atEnd() && i < input.size()) {
        s >> input[i];
        // I guess we need to find out if we're at the end of a line
-        if (paddingrequired && i != 0 && !(i % (ras.Width * (ras.Depth / 8)))) {
+        if (paddingrequired && i != 0 && !(i % (ras.Width * bpp))) {
            s >> input[i];
        }
        i++;
@ -131,15 +155,18 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
    // Allocate image
    img = QImage(ras.Width, ras.Height, QImage::Format_ARGB32);

+    if (img.isNull())
+        return false;
+
    // Reconstruct image from RGB palette if we have a palette
    // TODO: make generic so it works with 24bit or 32bit palettes
    if (ras.ColorMapType == 1 && ras.Depth == 8) {
        quint8 red, green, blue;
        for (quint32 y = 0; y < ras.Height; y++) {
            for (quint32 x = 0; x < ras.Width; x++) {
-                red = palette[(int)input[y * ras.Width + x]];
-                green = palette[(int)input[y * ras.Width + x] + (ras.ColorMapLength / 3)];
-                blue = palette[(int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3)];
+                red = palette.value((int)input[y * ras.Width + x]);
+                green = palette.value((int)input[y * ras.Width + x] + (ras.ColorMapLength / 3));
+                blue = palette.value((int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3));
                img.setPixel(x, y, qRgb(red, green, blue));
            }
        }
@ -248,6 +275,10 @@ bool RASHandler::read(QImage *outImage)
    // Read image header.
    RasHeader ras;
    s >> ras;
+
+    if (ras.ColorMapLength > std::numeric_limits<int>::max())
+        return false;
+
    // TODO: add support for old versions of RAS where Length may be zero in header
    s.device()->seek(RasHeader::SIZE + ras.Length + ras.ColorMapLength);

@ -282,10 +313,10 @@ QImageIOPlugin::Capabilities RASPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/ras_p.h
+++ b/src/imageformats/ras_p.h
@ -8,8 +8,8 @@
   version 2 of the License, or (at your option) any later version.
 */

-#ifndef KIMG_RAS_H
-#define KIMG_RAS_H
+#ifndef KIMG_RAS_P_H
+#define KIMG_RAS_P_H

 #include <QImageIOPlugin>

@ -18,8 +18,8 @@ class RASHandler : public QImageIOHandler
 public:
    RASHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;

    static bool canRead(QIODevice *device);
 };
@ -30,9 +30,9 @@ class RASPlugin : public QImageIOPlugin
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ras.json")

 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_RAS_H
+#endif // KIMG_RAS_P_H

--- a/src/imageformats/rgb.cpp
+++ b/src/imageformats/rgb.cpp
@ -23,11 +23,11 @@

 #include "rgb_p.h"

-#include <QtCore/QMap>
-#include <QtCore/QVector>
+#include <QMap>
+#include <QVector>

 #include <QImage>
-// #include <QDebug>
+#include <QDebug>

 class RLEData : public QVector<uchar>
 {
@ -111,8 +111,8 @@ private:
 };

 SGIImage::SGIImage(QIODevice *io) :
-    _starttab(0),
-    _lengthtab(0)
+    _starttab(nullptr),
+    _lengthtab(nullptr)
 {
    _dev = io;
    _stream.setDevice(_dev);
@ -144,13 +144,16 @@ bool SGIImage::getRow(uchar *dest)
        if (_bpc == 2) {
            _pos++;
        }
+        if (_pos >= _data.end()) {
+            return false;
+        }
        n = *_pos & 0x7f;
        if (!n) {
            break;
        }

        if (*_pos++ & 0x80) {
-            for (; i < _xsize && n--; i++) {
+            for (; i < _xsize && _pos < _data.end() && n--; i++) {
                *dest++ = *_pos;
                _pos += _bpc;
            }
@ -309,16 +312,23 @@ bool SGIImage::readImage(QImage &img)
        return false;
    }

-    _numrows = _ysize * _zsize;
-
    img = QImage(_xsize, _ysize, QImage::Format_RGB32);

+    if (_zsize == 0 )
+        return false;
+
    if (_zsize == 2 || _zsize == 4) {
        img = img.convertToFormat(QImage::Format_ARGB32);
    } else if (_zsize > 4) {
 //         qDebug() << "using first 4 of " << _zsize << " channels";
+        // Only let this continue if it won't cause a int overflow later
+        // this is most likely a broken file anyway
+        if (_ysize > std::numeric_limits<int>::max() / _zsize)
+            return false;
    }

+    _numrows = _ysize * _zsize;
+
    if (_rle) {
        uint l;
        _starttab = new quint32[_numrows];
@ -326,6 +336,9 @@ bool SGIImage::readImage(QImage &img)
            _stream >> _starttab[l];
            _starttab[l] -= 512 + _numrows * 2 * sizeof(quint32);
        }
+        for (; l < _numrows; l++) {
+            _starttab[l] = 0;
+        }

        _lengthtab = new quint32[_numrows];
        for (l = 0; l < _numrows; l++) {
@ -686,8 +699,8 @@ bool RGBHandler::canRead(QIODevice *device)
        return false;
    }

-    qint64 oldPos = device->pos();
-    QByteArray head = device->readLine(64);
+    const qint64 oldPos = device->pos();
+    const QByteArray head = device->readLine(64);
    int readBytes = head.size();

    if (device->isSequential()) {
@ -699,10 +712,7 @@ bool RGBHandler::canRead(QIODevice *device)
        device->seek(oldPos);
    }

-    const QRegExp regexp(QLatin1String("^\x01\xda\x01[\x01\x02]"));
-    QString data(QString::fromLocal8Bit(head));
-
-    return data.contains(regexp);
+    return head.size() >= 4 && head.startsWith("\x01\xda") && (head[2] == 0 || head[2] == 1) && (head[3] == 1 || head[3] == 2);
 }

 ///////////////////////////////////////////////////////////////////////////////
@ -714,10 +724,10 @@ QImageIOPlugin::Capabilities RGBPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead | CanWrite);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/rgb_p.h
+++ b/src/imageformats/rgb_p.h
@ -7,8 +7,8 @@
 // published by the Free Software Foundation; either version 2 of the
 // License, or (at your option) any later version.

-#ifndef KIMG_RGB_H
-#define KIMG_RGB_H
+#ifndef KIMG_RGB_P_H
+#define KIMG_RGB_P_H

 #include <QImageIOPlugin>

@ -17,9 +17,9 @@ class RGBHandler : public QImageIOHandler
 public:
    RGBHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;

    static bool canRead(QIODevice *device);
 };
@ -30,9 +30,9 @@ class RGBPlugin : public QImageIOPlugin
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "rgb.json")

 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_RGB_H
+#endif // KIMG_RGB_P_H

--- a/src/imageformats/rle_p.h
+++ b/src/imageformats/rle_p.h
@ -14,12 +14,12 @@
 *
 * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * ----------------------------------------------------------------------------
 */

-#ifndef KIMAGEFORMATS_RLE_H
-#define KIMAGEFORMATS_RLE_H
+#ifndef KIMAGEFORMATS_RLE_P_H
+#define KIMAGEFORMATS_RLE_P_H

 #include <QDebug>
 #include <QDataStream>
@ -220,4 +220,4 @@ static inline void encodeRLEData(RLEVariant variant,
    }
 }

-#endif // KIMAGEFORMATS_RLE_H
+#endif // KIMAGEFORMATS_RLE_P_H
--- a/src/imageformats/tga.cpp
+++ b/src/imageformats/tga.cpp
@ -23,8 +23,8 @@
 #include <assert.h>

 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
+#include <QDataStream>
+#include <QDebug>

 typedef quint32 uint;
 typedef quint16 ushort;
@ -145,6 +145,7 @@ struct TgaHeaderInfo {
        switch (tga.image_type) {
        case TGA_TYPE_RLE_INDEXED:
            rle = true;
+        Q_FALLTHROUGH();
        // no break is intended!
        case TGA_TYPE_INDEXED:
            pal = true;
@ -152,6 +153,7 @@ struct TgaHeaderInfo {

        case TGA_TYPE_RLE_RGB:
            rle = true;
+        Q_FALLTHROUGH();
        // no break is intended!
        case TGA_TYPE_RGB:
            rgb = true;
@ -159,6 +161,7 @@ struct TgaHeaderInfo {

        case TGA_TYPE_RLE_GREY:
            rle = true;
+        Q_FALLTHROUGH();
        // no break is intended!
        case TGA_TYPE_GREY:
            grey = true;
@ -183,10 +186,14 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
    // However alpha exists only in the 32 bit format.
    if ((tga.pixel_size == 32) && (tga.flags & 0xf)) {
        img = QImage(tga.width, tga.height, QImage::Format_ARGB32);
+
+        if (numAlphaBits > 8) {
+            return false;
+        }
    }

    uint pixel_size = (tga.pixel_size / 8);
-    uint size = tga.width * tga.height * pixel_size;
+    qint64 size = qint64(tga.width) * qint64(tga.height) * pixel_size;

    if (size < 1) {
 //          qDebug() << "This TGA file is broken with size " << size;
@ -194,33 +201,61 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
    }

    // Read palette.
-    char palette[768];
+    static const int max_palette_size = 768;
+    char palette[max_palette_size];
    if (info.pal) {
        // @todo Support palettes in other formats!
-        s.readRawData(palette, 3 * tga.colormap_length);
+        const int palette_size = 3 * tga.colormap_length;
+        if (palette_size > max_palette_size) {
+            return false;
+        }
+        const int dataRead = s.readRawData(palette, palette_size);
+        if (dataRead < 0) {
+            return false;
+        }
+        if (dataRead < max_palette_size) {
+            memset(&palette[dataRead], 0, max_palette_size - dataRead);
+        }
    }

    // Allocate image.
-    uchar *const image = new uchar[size];
+    uchar *const image = reinterpret_cast<uchar*>(malloc(size));
+    if (!image) {
+        return false;
+    }
+
+    bool valid = true;

    if (info.rle) {
        // Decode image.
        char *dst = (char *)image;
-        int num = size;
+        qint64 num = size;

        while (num > 0) {
+            if (s.atEnd()) {
+                valid = false;
+                break;
+            }
+
            // Get packet header.
            uchar c;
            s >> c;

            uint count = (c & 0x7f) + 1;
            num -= count * pixel_size;
+            if (num < 0) {
+                valid = false;
+                break;
+            }

            if (c & 0x80) {
                // RLE pixels.
                assert(pixel_size <= 8);
                char pixel[8];
-                s.readRawData(pixel, pixel_size);
+                const int dataRead = s.readRawData(pixel, pixel_size);
+                if (dataRead < (int)pixel_size) {
+                    memset(&pixel[dataRead], 0, pixel_size - dataRead);
+                }
                do {
                    memcpy(dst, pixel, pixel_size);
                    dst += pixel_size;
@ -228,13 +263,32 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
            } else {
                // Raw pixels.
                count *= pixel_size;
-                s.readRawData(dst, count);
+                const int dataRead = s.readRawData(dst, count);
+                if (dataRead < 0) {
+                    free(image);
+                    return false;
+                }
+                if ((uint)dataRead < count) {
+                    memset(&dst[dataRead], 0, count - dataRead);
+                }
                dst += count;
            }
        }
    } else {
        // Read raw image.
-        s.readRawData((char *)image, size);
+        const int dataRead = s.readRawData((char *)image, size);
+        if (dataRead < 0) {
+            free(image);
+            return false;
+        }
+        if (dataRead < size) {
+            memset(&image[dataRead], 0, size - dataRead);
+        }
+    }
+
+    if (!valid) {
+        free(image);
+        return false;
    }

    // Convert image to internal format.
@ -291,7 +345,7 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
    }

    // Free image.
-    delete [] image;
+    free(image);

    return true;
 }
@ -414,10 +468,10 @@ QImageIOPlugin::Capabilities TGAPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead | CanWrite);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/tga_p.h
+++ b/src/imageformats/tga_p.h
@ -7,8 +7,8 @@
   version 2 of the License, or (at your option) any later version.
 */

-#ifndef KIMG_TGA_H
-#define KIMG_TGA_H
+#ifndef KIMG_TGA_P_H
+#define KIMG_TGA_P_H

 #include <QImageIOPlugin>

@ -17,9 +17,9 @@ class TGAHandler : public QImageIOHandler
 public:
    TGAHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) 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:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_TGA_H
+#endif // KIMG_TGA_P_H
--- a/src/imageformats/xcf.cpp
+++ b/src/imageformats/xcf.cpp
@ -24,10 +24,12 @@
 #include <stdlib.h>
 #include <QImage>
 #include <QPainter>
-#include <QtCore/QIODevice>
-#include <QtCore/QStack>
-#include <QtCore/QVector>
-// #include <QDebug>
+#include <QIODevice>
+#include <QStack>
+#include <QVector>
+#include <QDebug>
+
+#include <string.h>

 #include "gimp_p.h"

@ -86,16 +88,17 @@ private:
        } mask_channel;

        bool active;            //!< Is this layer the active layer?
-        quint32 opacity;        //!< The opacity of the layer
-        quint32 visible;        //!< Is the layer visible?
+        quint32 opacity = 255;  //!< The opacity of the layer
+        quint32 visible = 1;    //!< Is the layer visible?
        quint32 linked;     //!< Is this layer linked (geometrically)
        quint32 preserve_transparency; //!< Preserve alpha when drawing on layer?
-        quint32 apply_mask;     //!< Apply the layer mask?
+        quint32 apply_mask = 9; //!< Apply the layer mask? Use 9 as "uninitilized". Spec says "If the property does not appear for a layer which has a layer mask, it defaults to true (1).
+                                //   Robust readers should force this to false if the layer has no layer mask.
        quint32 edit_mask;      //!< Is the layer mask the being edited?
        quint32 show_mask;      //!< Show the layer mask rather than the image?
-        qint32 x_offset;        //!< x offset of the layer relative to the image
-        qint32 y_offset;        //!< y offset of the layer relative to the image
-        quint32 mode;           //!< Combining mode of layer (LayerModeEffects)
+        qint32 x_offset = 0;    //!< x offset of the layer relative to the image
+        qint32 y_offset = 0;    //!< y offset of the layer relative to the image
+        quint32 mode = 0;       //!< Combining mode of layer (LayerModeEffects)
        quint32 tattoo;     //!< (unique identifier?)

        //! As each tile is read from the file, it is buffered here.
@ -107,11 +110,14 @@ private:
        //! copied in different ways.
        void (*assignBytes)(Layer &layer, uint i, uint j);

-        Layer(void) : name(0) {}
+        Layer(void) : name(nullptr) {}
        ~Layer(void)
        {
            delete[] name;
        }
+
+        Layer(const Layer &) = delete;
+        Layer &operator=(const Layer &) = delete;
    };

    /*!
@ -126,11 +132,11 @@ private:
        qint32 type;            //!< type of the XCF image (GimpImageBaseType)

        quint8 compression;     //!< tile compression method (CompressionType)
-        float x_resolution;     //!< x resolution in dots per inch
-        float y_resolution;     //!< y resolution in dots per inch
+        float x_resolution = -1;//!< x resolution in dots per inch
+        float y_resolution = -1;//!< y resolution in dots per inch
        qint32 tattoo;          //!< (unique identifier?)
        quint32 unit;           //!< Units of The GIMP (inch, mm, pica, etc...)
-        qint32 num_colors;      //!< number of colors in an indexed image
+        qint32 num_colors = 0;  //!< number of colors in an indexed image
        QVector<QRgb> palette;          //!< indexed image color palette

        int num_layers;         //!< number of layers
@ -161,11 +167,11 @@ private:

    //! The bottom-most layer is copied into the final QImage by this
    //! routine.
-    typedef void (*PixelCopyOperation)(Layer &layer, uint i, uint j, int k, int l,
+    typedef void (*PixelCopyOperation)(const Layer &layer, uint i, uint j, int k, int l,
                                       QImage &image, int m, int n);

    //! Higher layers are merged into the final QImage by this routine.
-    typedef void (*PixelMergeOperation)(Layer &layer, uint i, uint j, int k, int l,
+    typedef void (*PixelMergeOperation)(const Layer &layer, uint i, uint j, int k, int l,
                                        QImage &image, int m, int n);

    //! Layer mode static data.
@ -178,7 +184,7 @@ private:
    static const LayerModes layer_modes[];

    bool loadImageProperties(QDataStream &xcf_io, XCFImage &image);
-    bool loadProperty(QDataStream &xcf_io, PropType &type, QByteArray &bytes);
+    bool loadProperty(QDataStream &xcf_io, PropType &type, QByteArray &bytes, quint32 &rawType);
    bool loadLayer(QDataStream &xcf_io, XCFImage &xcf_image);
    bool loadLayerProperties(QDataStream &xcf_io, Layer &layer);
    bool composeTiles(XCFImage &xcf_image);
@ -195,37 +201,37 @@ private:
                     int data_length, qint32 bpp);

    static void copyLayerToImage(XCFImage &xcf_image);
-    static void copyRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void copyRGBToRGB(const Layer &layer, uint i, uint j, int k, int l,
                             QImage &image, int m, int n);
-    static void copyGrayToGray(Layer &layer, uint i, uint j, int k, int l,
+    static void copyGrayToGray(const Layer &layer, uint i, uint j, int k, int l,
                               QImage &image, int m, int n);
-    static void copyGrayToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void copyGrayToRGB(const Layer &layer, uint i, uint j, int k, int l,
                              QImage &image, int m, int n);
-    static void copyGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void copyGrayAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                               QImage &image, int m, int n);
-    static void copyIndexedToIndexed(Layer &layer, uint i, uint j, int k, int l,
+    static void copyIndexedToIndexed(const Layer &layer, uint i, uint j, int k, int l,
                                     QImage &image, int m, int n);
-    static void copyIndexedAToIndexed(Layer &layer, uint i, uint j, int k, int l,
+    static void copyIndexedAToIndexed(const Layer &layer, uint i, uint j, int k, int l,
                                      QImage &image, int m, int n);
-    static void copyIndexedAToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void copyIndexedAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                  QImage &image, int m, int n);

    static void mergeLayerIntoImage(XCFImage &xcf_image);
-    static void mergeRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeRGBToRGB(const Layer &layer, uint i, uint j, int k, int l,
                              QImage &image, int m, int n);
-    static void mergeGrayToGray(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeGrayToGray(const Layer &layer, uint i, uint j, int k, int l,
                                QImage &image, int m, int n);
-    static void mergeGrayAToGray(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeGrayAToGray(const Layer &layer, uint i, uint j, int k, int l,
                                 QImage &image, int m, int n);
-    static void mergeGrayToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeGrayToRGB(const Layer &layer, uint i, uint j, int k, int l,
                               QImage &image, int m, int n);
-    static void mergeGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeGrayAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                QImage &image, int m, int n);
-    static void mergeIndexedToIndexed(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeIndexedToIndexed(const Layer &layer, uint i, uint j, int k, int l,
                                      QImage &image, int m, int n);
-    static void mergeIndexedAToIndexed(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeIndexedAToIndexed(const Layer &layer, uint i, uint j, int k, int l,
                                       QImage &image, int m, int n);
-    static void mergeIndexedAToRGB(Layer &layer, uint i, uint j, int k, int l,
+    static void mergeIndexedAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                   QImage &image, int m, int n);

    static void initializeRandomTable();
@ -238,6 +244,12 @@ bool XCFImageFormat::random_table_initialized;

 QVector<QRgb> XCFImageFormat::grayTable;

+template <typename T, size_t N>
+constexpr size_t countof(T(&)[N])
+{
+    return N;
+}
+
 const XCFImageFormat::LayerModes XCFImageFormat::layer_modes[] = {
    {true},     // NORMAL_MODE
    {true},     // DISSOLVE_MODE
@ -264,7 +276,7 @@ const XCFImageFormat::LayerModes XCFImageFormat::layer_modes[] = {
 };

 //! Change a QRgb value's alpha only.
-inline QRgb qRgba(const QRgb &rgb, int a)
+inline QRgb qRgba(const QRgb rgb, int a)
 {
    return ((a & 0xff) << 24 | (rgb & RGB_MASK));
 }
@ -384,8 +396,9 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
    while (true) {
        PropType type;
        QByteArray bytes;
+        quint32 rawType;

-        if (!loadProperty(xcf_io, type, bytes)) {
+        if (!loadProperty(xcf_io, type, bytes, rawType)) {
 //          qDebug() << "XCF: error loading global image properties";
            return false;
        }
@ -401,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;

@ -416,7 +430,7 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
                property.readBytes(tag, size);

                quint32 flags;
-                char *data = 0;
+                char *data = nullptr;
                property >> flags >> data;

                if (tag && strncmp(tag, "gimp-comment", strlen("gimp-comment")) == 0) {
@ -444,6 +458,7 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
                return false;
            }

+            xcf_image.palette = QVector<QRgb>();
            xcf_image.palette.reserve(xcf_image.num_colors);

            for (int i = 0; i < xcf_image.num_colors; i++) {
@ -454,7 +469,7 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
            break;

        default:
-//                  qDebug() << "XCF: unimplemented image property" << type
+//                  qDebug() << "XCF: unimplemented image property" << rawType
 //                          << ", size " << bytes.size() << endl;
            break;
        }
@ -468,15 +483,25 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
 * \param type returns with the property type.
 * \param bytes returns with the property data.
 * \return true if there were no IO errors.  */
-bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArray &bytes)
+bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArray &bytes, quint32 &rawType)
 {
-    quint32 foo;
-    xcf_io >> foo;
-    type = PropType(foo); // TODO urks
-
-    char *data = 0;
    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;
+    }
+
+    type = PropType(rawType);
+
+    char *data = nullptr;
+
    // The colormap property size is not the correct number of bytes:
    // The GIMP source xcf.c has size = 4 + ncolors, but it should be
    // 4 + 3 * ncolors
@ -486,11 +511,12 @@ bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArra
        quint32 ncolors;
        xcf_io >> ncolors;

+        size = 3 * ncolors + 4;
+
        if (size > 65535 || size < 4) {
            return false;
        }

-        size = 3 * ncolors + 4;
        data = new char[size];

        // since we already read "ncolors" from the stream, we put that data back
@ -528,7 +554,11 @@ bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArra
            return false;
        }
        data = new char[size];
-        xcf_io.readRawData(data, size);
+        const quint32 dataRead = xcf_io.readRawData(data, size);
+        if (dataRead < size) {
+//          qDebug() << "XCF: loadProperty read less data than expected" << data_length << dataRead;
+            memset(&data[dataRead], 0, size - dataRead);
+        }
    }

    if (size != 0 && data) {
@ -595,11 +625,19 @@ bool XCFImageFormat::loadLayer(QDataStream &xcf_io, XCFImage &xcf_image)
    }

    if (layer.mask_offset != 0) {
+        // 9 means its not on the file. Spec says "If the property does not appear for a layer which has a layer mask, it defaults to true (1).
+        if (layer.apply_mask == 9) {
+            layer.apply_mask = 1;
+        }
+
        xcf_io.device()->seek(layer.mask_offset);

        if (!loadMask(xcf_io, layer)) {
            return false;
        }
+    } else {
+        // Spec says "Robust readers should force this to false if the layer has no layer mask."
+        layer.apply_mask = 0;
    }

    // Now we should have enough information to initialize the final
@ -631,8 +669,9 @@ bool XCFImageFormat::loadLayerProperties(QDataStream &xcf_io, Layer &layer)
    while (true) {
        PropType type;
        QByteArray bytes;
+        quint32 rawType;

-        if (!loadProperty(xcf_io, type, bytes)) {
+        if (!loadProperty(xcf_io, type, bytes, rawType)) {
 //          qDebug() << "XCF: error loading layer properties";
            return false;
        }
@ -649,6 +688,7 @@ bool XCFImageFormat::loadLayerProperties(QDataStream &xcf_io, Layer &layer)

        case PROP_OPACITY:
            property >> layer.opacity;
+            layer.opacity = std::min(layer.opacity, 255u);
            break;

        case PROP_VISIBLE:
@ -681,6 +721,10 @@ bool XCFImageFormat::loadLayerProperties(QDataStream &xcf_io, Layer &layer)

        case PROP_MODE:
            property >> layer.mode;
+            if (layer.mode >= countof(layer_modes)) {
+                qWarning() << "Found layer with unsupported mode" << layer.mode << "Defaulting to mode 0";
+                layer.mode = 0;
+            }
            break;

        case PROP_TATTOO:
@ -688,7 +732,7 @@ bool XCFImageFormat::loadLayerProperties(QDataStream &xcf_io, Layer &layer)
            break;

        default:
-//              qDebug() << "XCF: unimplemented layer property " << type
+//              qDebug() << "XCF: unimplemented layer property " << rawType
 //                      << ", size " << bytes.size() << endl;
            break;
        }
@ -713,7 +757,8 @@ bool XCFImageFormat::composeTiles(XCFImage &xcf_image)

    // SANITY CHECK: Catch corrupted XCF image file where the width or height
    // of a tile is reported are bogus. See Bug# 234030.
-    if (layer.width > 32767 || layer.height > 32767 || layer.width * layer.height > 16384 * 16384) {
+    if (layer.width > 32767 || layer.height > 32767
+        || (sizeof(void *) == 4 && layer.width * layer.height > 16384 * 16384)) {
        return false;
    }

@ -872,7 +917,7 @@ void XCFImageFormat::setPalette(XCFImage &xcf_image, QImage &image)
 void XCFImageFormat::assignImageBytes(Layer &layer, uint i, uint j)
 {
    QImage &image = layer.image_tiles[j][i];
-    uchar *tile = layer.tile;
+    const uchar *tile = layer.tile;
    const int width = image.width();
    const int height = image.height();
    const int bytesPerLine = image.bytesPerLine();
@ -952,6 +997,46 @@ bool XCFImageFormat::loadHierarchy(QDataStream &xcf_io, Layer &layer)

    xcf_io >> width >> height >> bpp >> offset;

+    // make sure bpp is correct and complain if it is not
+    switch (layer.type) {
+        case RGB_GIMAGE:
+            if (bpp != 3) {
+                qWarning() << "Found layer of type RGB but with bpp != 3" << bpp;
+                bpp = 3;
+            }
+            break;
+        case RGBA_GIMAGE:
+            if (bpp != 4) {
+                qWarning() << "Found layer of type RGBA but with bpp != 4" << bpp;
+                bpp = 4;
+            }
+            break;
+        case GRAY_GIMAGE:
+            if (bpp != 1) {
+                qWarning() << "Found layer of type Gray but with bpp != 1" << bpp;
+                bpp = 1;
+            }
+            break;
+        case GRAYA_GIMAGE:
+            if (bpp != 2) {
+                qWarning() << "Found layer of type Gray+Alpha but with bpp != 2" << bpp;
+                bpp = 2;
+            }
+            break;
+        case INDEXED_GIMAGE:
+            if (bpp != 1) {
+                qWarning() << "Found layer of type Indexed but with bpp != 1" << bpp;
+                bpp = 1;
+            }
+            break;
+        case INDEXEDA_GIMAGE:
+            if (bpp != 2) {
+                qWarning() << "Found layer of type Indexed+Alpha but with bpp != 2" << bpp;
+                bpp = 2;
+            }
+            break;
+    }
+
    // GIMP stores images in a "mipmap"-like format (multiple levels of
    // increasingly lower resolution). Only the top level is used here,
    // however.
@ -994,6 +1079,16 @@ bool XCFImageFormat::loadLevel(QDataStream &xcf_io, Layer &layer, qint32 bpp)
    xcf_io >> width >> height >> offset;

    if (offset == 0) {
+        // offset 0 with rowsxcols != 0 is probably an error since it means we have tiles
+        // without data but just clear the bits for now instead of returning false
+        for (uint j = 0; j < layer.nrows; j++) {
+            for (uint i = 0; i < layer.ncols; i++) {
+                layer.image_tiles[j][i].fill(Qt::transparent);
+                if (layer.type == GRAYA_GIMAGE || layer.type == INDEXEDA_GIMAGE) {
+                    layer.alpha_tiles[j][i].fill(Qt::transparent);
+                }
+            }
+        }
        return true;
    }

@ -1108,7 +1203,11 @@ bool XCFImageFormat::loadTileRLE(QDataStream &xcf_io, uchar *tile, int image_siz

    xcfdata = xcfodata = new uchar[data_length];

-    xcf_io.readRawData((char *)xcfdata, data_length);
+    const int dataRead = xcf_io.readRawData((char *)xcfdata, data_length);
+    if (dataRead < data_length) {
+//      qDebug() << "XCF: read less data than expected" << data_length << dataRead;
+        memset(&xcfdata[dataRead], 0, data_length - dataRead);
+    }

    if (!xcf_io.device()->isOpen()) {
        delete[] xcfodata;
@ -1214,8 +1313,9 @@ bool XCFImageFormat::loadChannelProperties(QDataStream &xcf_io, Layer &layer)
    while (true) {
        PropType type;
        QByteArray bytes;
+        quint32 rawType;

-        if (!loadProperty(xcf_io, type, bytes)) {
+        if (!loadProperty(xcf_io, type, bytes, rawType)) {
 //          qDebug() << "XCF: error loading channel properties";
            return false;
        }
@ -1228,6 +1328,7 @@ bool XCFImageFormat::loadChannelProperties(QDataStream &xcf_io, Layer &layer)

        case PROP_OPACITY:
            property >> layer.mask_channel.opacity;
+            layer.mask_channel.opacity = std::min(layer.mask_channel.opacity, 255u);
            break;

        case PROP_VISIBLE:
@ -1248,7 +1349,7 @@ bool XCFImageFormat::loadChannelProperties(QDataStream &xcf_io, Layer &layer)
            break;

        default:
-//              qDebug() << "XCF: unimplemented channel property " << type
+//              qDebug() << "XCF: unimplemented channel property " << rawType
 //                      << ", size " << bytes.size() << endl;
            break;
        }
@ -1323,7 +1424,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
            image.fill(qRgb(255, 255, 255));
            break;
        } // else, fall through to 32-bit representation
-
+        Q_FALLTHROUGH();
    case RGBA_GIMAGE:
        image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
        if (image.isNull()) {
@ -1343,7 +1444,7 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
            image.fill(255);
            break;
        } // else, fall through to 32-bit representation
-
+        Q_FALLTHROUGH();
    case GRAYA_GIMAGE:
        image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
        if (image.isNull()) {
@ -1428,8 +1529,16 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
        break;
    }

-    image.setDotsPerMeterX((int)(xcf_image.x_resolution * INCHESPERMETER));
-    image.setDotsPerMeterY((int)(xcf_image.y_resolution * INCHESPERMETER));
+    if (xcf_image.x_resolution > 0 && xcf_image.y_resolution > 0) {
+        const float dpmx = xcf_image.x_resolution * INCHESPERMETER;
+        if (dpmx > std::numeric_limits<int>::max())
+            return false;
+        const float dpmy = xcf_image.y_resolution * INCHESPERMETER;
+        if (dpmy > std::numeric_limits<int>::max())
+            return false;
+        image.setDotsPerMeterX((int)dpmx);
+        image.setDotsPerMeterY((int)dpmy);
+    }
    return true;
 }

@ -1442,7 +1551,7 @@ void XCFImageFormat::copyLayerToImage(XCFImage &xcf_image)
 {
    Layer &layer(xcf_image.layer);
    QImage &image(xcf_image.image);
-    PixelCopyOperation copy = 0;
+    PixelCopyOperation copy = nullptr;

    switch (layer.type) {
    case RGB_GIMAGE:
@ -1540,7 +1649,7 @@ void XCFImageFormat::copyLayerToImage(XCFImage &xcf_image)
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyRGBToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                  QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -1571,7 +1680,7 @@ void XCFImageFormat::copyRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyGrayToGray(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyGrayToGray(const Layer &layer, uint i, uint j, int k, int l,
                                    QImage &image, int m, int n)
 {
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
@ -1591,7 +1700,7 @@ void XCFImageFormat::copyGrayToGray(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyGrayToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyGrayToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                   QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -1612,7 +1721,7 @@ void XCFImageFormat::copyGrayToRGB(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyGrayAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                    QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -1640,7 +1749,7 @@ void XCFImageFormat::copyGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyIndexedToIndexed(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyIndexedToIndexed(const Layer &layer, uint i, uint j, int k, int l,
        QImage &image, int m, int n)
 {
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
@ -1658,7 +1767,7 @@ void XCFImageFormat::copyIndexedToIndexed(Layer &layer, uint i, uint j, int k, i
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyIndexedAToIndexed(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyIndexedAToIndexed(const Layer &layer, uint i, uint j, int k, int l,
        QImage &image, int m, int n)
 {
    uchar src = layer.image_tiles[j][i].pixelIndex(k, l);
@ -1693,7 +1802,7 @@ void XCFImageFormat::copyIndexedAToIndexed(Layer &layer, uint i, uint j, int k,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::copyIndexedAToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::copyIndexedAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                       QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -1725,7 +1834,7 @@ void XCFImageFormat::mergeLayerIntoImage(XCFImage &xcf_image)
    Layer &layer(xcf_image.layer);
    QImage &image(xcf_image.image);

-    PixelMergeOperation merge = 0;
+    PixelMergeOperation merge = nullptr;

    if (!layer.opacity) {
        return;    // don't bother doing anything
@ -1830,7 +1939,7 @@ void XCFImageFormat::mergeLayerIntoImage(XCFImage &xcf_image)
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeRGBToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                   QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -2131,7 +2240,7 @@ void XCFImageFormat::mergeRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
    uchar new_r, new_g, new_b, new_a;
    new_a = dst_a + INT_MULT(OPAQUE_OPACITY - dst_a, src_a);

-    float src_ratio = (float)src_a / new_a;
+    const float src_ratio = new_a == 0 ? 1.0 : (float)src_a / new_a;
    float dst_ratio = 1.0 - src_ratio;

    new_r = (uchar)(src_ratio * src_r + dst_ratio * dst_r + EPSILON);
@ -2156,7 +2265,7 @@ void XCFImageFormat::mergeRGBToRGB(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeGrayToGray(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeGrayToGray(const Layer &layer, uint i, uint j, int k, int l,
                                     QImage &image, int m, int n)
 {
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
@ -2174,7 +2283,7 @@ void XCFImageFormat::mergeGrayToGray(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeGrayAToGray(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeGrayAToGray(const Layer &layer, uint i, uint j, int k, int l,
                                      QImage &image, int m, int n)
 {
    int src = qGray(layer.image_tiles[j][i].pixel(k, l));
@ -2290,7 +2399,7 @@ void XCFImageFormat::mergeGrayAToGray(Layer &layer, uint i, uint j, int k, int l

    uchar new_a = OPAQUE_OPACITY;

-    float src_ratio = (float)src_a / new_a;
+    const float src_ratio = new_a == 0 ? 1.0 : (float)src_a / new_a;
    float dst_ratio = 1.0 - src_ratio;

    uchar new_g = (uchar)(src_ratio * src + dst_ratio * dst + EPSILON);
@ -2311,7 +2420,7 @@ void XCFImageFormat::mergeGrayAToGray(Layer &layer, uint i, uint j, int k, int l
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeGrayToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeGrayToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                    QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -2332,7 +2441,7 @@ void XCFImageFormat::mergeGrayToRGB(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeGrayAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                     QImage &image, int m, int n)
 {
    int src = qGray(layer.image_tiles[j][i].pixel(k, l));
@ -2463,7 +2572,7 @@ void XCFImageFormat::mergeGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,

    uchar new_a = dst_a + INT_MULT(OPAQUE_OPACITY - dst_a, src_a);

-    float src_ratio = (float)src_a / new_a;
+    const float src_ratio = new_a == 0 ? 1.0 : (float)src_a / new_a;
    float dst_ratio = 1.0 - src_ratio;

    uchar new_g = (uchar)(src_ratio * src + dst_ratio * dst + EPSILON);
@ -2486,7 +2595,7 @@ void XCFImageFormat::mergeGrayAToRGB(Layer &layer, uint i, uint j, int k, int l,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeIndexedToIndexed(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeIndexedToIndexed(const Layer &layer, uint i, uint j, int k, int l,
        QImage &image, int m, int n)
 {
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
@ -2504,7 +2613,7 @@ void XCFImageFormat::mergeIndexedToIndexed(Layer &layer, uint i, uint j, int k,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeIndexedAToIndexed(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeIndexedAToIndexed(const Layer &layer, uint i, uint j, int k, int l,
        QImage &image, int m, int n)
 {
    uchar src = layer.image_tiles[j][i].pixelIndex(k, l);
@ -2536,7 +2645,7 @@ void XCFImageFormat::mergeIndexedAToIndexed(Layer &layer, uint i, uint j, int k,
 * \param m x pixel of destination image.
 * \param n y pixel of destination image.
 */
-void XCFImageFormat::mergeIndexedAToRGB(Layer &layer, uint i, uint j, int k, int l,
+void XCFImageFormat::mergeIndexedAToRGB(const Layer &layer, uint i, uint j, int k, int l,
                                        QImage &image, int m, int n)
 {
    QRgb src = layer.image_tiles[j][i].pixel(k, l);
@ -2686,10 +2795,10 @@ QImageIOPlugin::Capabilities XCFPlugin::capabilities(QIODevice *device, const QB
        return Capabilities(CanRead);
    }
    if (!format.isEmpty()) {
-        return 0;
+        return {};
    }
    if (!device->isOpen()) {
-        return 0;
+        return {};
    }

    Capabilities cap;
--- a/src/imageformats/xcf_p.h
+++ b/src/imageformats/xcf_p.h
@ -19,8 +19,8 @@
 *
 */

-#ifndef KIMG_XCF_H
-#define KIMG_XCF_H
+#ifndef KIMG_XCF_P_H
+#define KIMG_XCF_P_H

 #include <QImageIOPlugin>

@ -29,9 +29,9 @@ class XCFHandler : public QImageIOHandler
 public:
    XCFHandler();

-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) 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:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };

-#endif // KIMG_XCF_H
+#endif // KIMG_XCF_P_H
--- a/tests/format-enum.h
+++ b/tests/format-enum.h
@ -19,6 +19,9 @@
 * <http://www.gnu.org/licenses/>.
 */

+#ifndef FORMAT_ENUM_H
+#define FORMAT_ENUM_H
+
 #include <QImage>

 // Generated from QImage::Format enum
@ -71,3 +74,4 @@ QString formatToString(QImage::Format format)
        QLatin1String(">");
 }

+#endif
--- a/tests/imageconverter.cpp
+++ b/tests/imageconverter.cpp
@ -64,11 +64,13 @@ int main(int argc, char **argv)
    if (parser.isSet(listformats)) {
        QTextStream out(stdout);
        out << "Input formats:\n";
-        foreach (const QByteArray &fmt, QImageReader::supportedImageFormats()) {
+        const auto lstReaderSupportedFormats = QImageReader::supportedImageFormats();
+        for (const QByteArray &fmt : lstReaderSupportedFormats) {
            out << "  " << fmt << '\n';
        }
        out << "Output formats:\n";
-        foreach (const QByteArray &fmt, QImageWriter::supportedImageFormats()) {
+        const auto lstWriterSupportedFormats = QImageWriter::supportedImageFormats();
+        for (const QByteArray &fmt : lstWriterSupportedFormats) {
            out << "  " << fmt << '\n';
        }
        return 0;
--- a/tests/imagedump.cpp
+++ b/tests/imagedump.cpp
@ -72,7 +72,8 @@ int main(int argc, char **argv)
    if (parser.isSet(listformats)) {
        QTextStream out(stdout);
        out << "File formats:\n";
-        foreach (const QByteArray &fmt, QImageReader::supportedImageFormats()) {
+        const auto lstSupportedFormats = QImageReader::supportedImageFormats();
+        for (const auto &fmt : lstSupportedFormats) {
            out << "  " << fmt << '\n';
        }
        return 0;
@ -115,8 +116,8 @@ int main(int argc, char **argv)
        }
        img = img.convertToFormat(qformat);
    }
-    qint64 written = output.write(reinterpret_cast<const char *>(img.bits()), img.byteCount());
-    if (written != img.byteCount()) {
+    qint64 written = output.write(reinterpret_cast<const char *>(img.bits()), img.sizeInBytes());
+    if (written != img.sizeInBytes()) {
        QTextStream(stderr) << "Could not write image data to " << files.at(1)
                            << ":" << output.errorString() << "\n";
        return 5;