GIT_SILENT Upgrade ECM and KF5 version requirements for 5.65.0 release.

https://codereview.qt-project.org/c/qt/qtbase/+/279215

NO_CHANGELOG

.arcconfig

@@ -0,0 +1,3 @@
+{
+  "phabricator.uri" : "https://phabricator.kde.org/"
+}

.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*

.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'

CMakeLists.txt

@@ -1,26 +1,36 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)
 
 project(KImageFormats)
 
-find_package(ECM 1.2.0 REQUIRED NO_MODULE)
+include(FeatureSummary)
+find_package(ECM 5.65.0  NO_MODULE)
+set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
+feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
-set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
+
+set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 
 include(KDEInstallDirs)
-include(KDEFrameworkCompilerSettings)
+include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
 
-include(FeatureSummary)
+
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.2.0)
+set(REQUIRED_QT_VERSION 5.11.0)
 find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
+find_package(KF5Archive)
+set_package_properties(KF5Archive PROPERTIES
+    TYPE OPTIONAL
+    PURPOSE "Required for the QImage plugin for Krita and OpenRaster images"
+)
+
 # EPS support depends on the gs utility; non-UNIX systems are unlikely to have
 # this available in PATH
 set(BUILD_EPS_PLUGIN FALSE)
 if (UNIX)
-    find_package(Qt5PrintSupport 5.2.0 NO_MODULE)
+    find_package(Qt5PrintSupport ${REQUIRED_QT_VERSION} NO_MODULE)
     set_package_properties(Qt5PrintSupport PROPERTIES
         PURPOSE "Required for the QImage plugin for EPS images"
         TYPE OPTIONAL
@@ -30,24 +40,16 @@ if (UNIX)
     endif()
 endif()
 
-# QtImageFormats 5.3 comes with a JPEG-2000 plugin; don't duplicate it here
-# TODO: remove our JPEG-2000 plugin when we depend on Qt 5.3.
-if (Qt5Gui_VERSION VERSION_LESS 5.3.0)
-    find_package(Jasper)
-    set_package_properties(Jasper PROPERTIES
-        DESCRIPTION "A library for handling JPEG-2000 images"
-        PURPOSE "Required for the QImage plugin for JPEG-2000 images"
-        URL "http://www.ece.uvic.ca/~mdadams/jasper"
-        TYPE OPTIONAL
-    )
-endif()
-
 find_package(OpenEXR)
 set_package_properties(OpenEXR PROPERTIES
     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=0x053f00)
 add_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)

README.md

@@ -13,7 +13,6 @@ image formats.
 
 The following image formats have read-only support:
 
-- DirectDraw Surface (dds)
 - Gimp (xcf)
 - OpenEXR (exr)
 - Photoshop documents (psd)
@@ -22,7 +21,6 @@ The following image formats have read-only support:
 The following image formats have read and write support:
 
 - Encapsulated PostScript (eps)
-- JPEG-2000 (jp2)
 - Personal Computer Exchange (pcx)
 - SGI images (rgb, rgba, sgi, bw)
 - Softimage PIC (pic)

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,12 +55,21 @@ 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
     rgb
     tga
 )
+
+if (KF5Archive_FOUND)
+    kimageformats_read_tests(
+        kra
+        ora
+    )
+endif()
+
 # Allow some fuzziness when reading this formats, to allow for
 # rounding errors (eg: in alpha blending).
 kimageformats_read_tests(FUZZ 1
@@ -86,22 +95,10 @@ kimageformats_write_tests(
 #    kimageformats_read_tests(eps)
 #    kimageformats_write_tests(eps)
 #endif()
-if (JASPER_FOUND)
-    # FIXME: when we read JPEG2000 files on different architectures
-    # (specifically x86_64 and i386), we get off-by-one errors. The
-    # jasper utility does not have the same problem, so it is not a
-    # problem inherent in the jasper library. For now, we just allow
-    # a little fuzziness to make sure it does not get any worse (being
-    # off by one in an image value is not noticable to the human eye,
-    # so it is not a release-blocking issue).
-    kimageformats_read_tests(FUZZ 1 jp2)
-    kimageformats_write_tests(jp2)
-endif()
 if (OpenEXR_FOUND)
     # FIXME: OpenEXR tests
 endif()
 
-
 find_package(Qt5Test ${REQUIRED_QT_VERSION} CONFIG QUIET)
 
 if(NOT Qt5Test_FOUND)

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 (")

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());
+        qint64 written = file.write(reinterpret_cast<const char *>(image.bits()), image.sizeInBytes());
-        if (written == image.byteCount()) {
+        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,10 +127,11 @@ 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(), "png");
+        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString expfilename = QFileInfo(expfile).fileName();
 
         QImageReader inputReader(inputfile, format.constData());
@@ -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: "

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,10 +73,10 @@ int main(int argc, char ** argv)
     QTextStream(stdout) << "********* "
         << "Starting basic write tests for "
         << suffix << " images *********\n";
-
+    const QFileInfoList lstImgDir = imgdir.entryInfoList();
-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    for (const QFileInfo &fi : lstImgDir) {
         int suffixPos = fi.filePath().count() - suffix.count();
-        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), "png");
+        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString pngfilename = QFileInfo(pngfile).fileName();
 
         QImageReader pngReader(pngfile, "png");

metainfo.yaml

@@ -1,12 +1,18 @@
 maintainer: alexmerry
 description: Image format plugins for Qt
-tier: 1
+tier: 2
 type: functional
 platforms:
     - name: Linux
+    - name: FreeBSD
     - name: MacOSX
     - name: Windows
       note: No EPS support on Windows
+    - name: Android
 portingAid: false
 deprecated: false
 release: true
+
+public_lib: true
+group: Frameworks
+subgroup: Tier 2

src/imageformats/CMakeLists.txt

@@ -2,111 +2,105 @@
 
 ##################################
 
-if (Qt5Gui_VERSION VERSION_LESS 5.3.0)
+function(kimageformats_add_plugin plugin)
-    add_library(kimg_dds MODULE dds.cpp)
+    set(options)
-    target_link_libraries(kimg_dds Qt5::Gui)
+    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()
 
-    install(TARGETS kimg_dds  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
+    add_library(${plugin} MODULE ${KIF_ADD_PLUGIN_SOURCES})
-    install(FILES dds.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    set_property(TARGET ${plugin} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS ${json})
-else()
+    set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/imageformats")
-    install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    target_link_libraries(${plugin} Qt5::Gui)
-endif()
+    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)
+        kimageformats_add_plugin(kimg_eps JSON "eps.json" SOURCES eps.cpp)
-        target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
+        target_link_libraries(kimg_eps Qt5::PrintSupport)
-
+        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-        install(TARGETS kimg_eps  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-        install(FILES eps.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
-check_include_files(sys/types.h   HAVE_SYS_TYPES_H)
+# need this for Qt's version of the plugin
-check_include_files(stdint.h      HAVE_STDINT_H)
+install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-configure_file(config-jp2.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-jp2.h)
-
-if(JASPER_FOUND)
-    add_library(kimg_jp2 MODULE jp2.cpp)
-    target_compile_options(kimg_jp2 PRIVATE ${JASPER_DEFINITIONS})
-    target_include_directories(kimg_jp2 PRIVATE ${JASPER_INCLUDE_DIR})
-    target_link_libraries(kimg_jp2  Qt5::Gui ${JASPER_LIBRARIES})
-
-    install(TARGETS kimg_jp2  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES jp2.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-elseif (NOT Qt5Gui_VERSION VERSION_LESS 5.3.0)
-    # need this for Qt's version of the plugin
-    install(FILES jp2.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-endif()
 
 ##################################
 
 if(OpenEXR_FOUND)
-    add_library(kimg_exr MODULE exr.cpp)
+    kimageformats_add_plugin(kimg_exr JSON "exr.json" SOURCES exr.cpp)
-    target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
+    target_link_libraries(kimg_exr OpenEXR::IlmImf)
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(TARGETS kimg_exr  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
+    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-    install(FILES exr.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-add_library(kimg_pcx MODULE pcx.cpp)
+kimageformats_add_plugin(kimg_hdr JSON "hdr.json" SOURCES hdr.cpp)
-target_link_libraries(kimg_pcx  Qt5::Gui)
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-
-install(TARGETS kimg_pcx  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pcx.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_pic MODULE pic.cpp)
+kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
-target_link_libraries(kimg_pic Qt5::Gui)
+install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-
-install(TARGETS kimg_pic  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pic.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_psd MODULE psd.cpp)
+kimageformats_add_plugin(kimg_pic JSON "pic.json" SOURCES pic.cpp)
-target_link_libraries(kimg_psd Qt5::Gui)
+install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-
-install(TARGETS kimg_psd  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES psd.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_ras MODULE ras.cpp)
+kimageformats_add_plugin(kimg_psd JSON "psd.json" SOURCES psd.cpp)
-target_link_libraries(kimg_ras  Qt5::Gui)
+install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-
-install(TARGETS kimg_ras  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES ras.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_rgb MODULE rgb.cpp)
+kimageformats_add_plugin(kimg_ras JSON "ras.json" SOURCES ras.cpp)
-target_link_libraries(kimg_rgb  Qt5::Gui)
+install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-
-install(TARGETS kimg_rgb  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES rgb.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_tga MODULE tga.cpp)
+kimageformats_add_plugin(kimg_rgb JSON "rgb.json" SOURCES rgb.cpp)
-target_link_libraries(kimg_tga  Qt5::Gui)
+install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-
-install(TARGETS kimg_tga  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES tga.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_xcf MODULE xcf.cpp)
+kimageformats_add_plugin(kimg_tga JSON "tga.json" SOURCES tga.cpp)
-target_link_libraries(kimg_xcf Qt5::Gui)
+install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
-install(TARGETS kimg_xcf  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
+##################################
-install(FILES xcf.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
 
+kimageformats_add_plugin(kimg_xcf JSON "xcf.json" SOURCES xcf.cpp)
+install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+##################################
+
+if (KF5Archive_FOUND)
+
+    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/)
+
+    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()

src/imageformats/config-jp2.h.cmake

@@ -1,2 +0,0 @@
-#cmakedefine01 HAVE_STDINT_H
-#cmakedefine01 HAVE_SYS_TYPES_H

src/imageformats/dds.json

@@ -1,4 +0,0 @@
-{
-    "Keys": [ "dds" ],
-    "MimeTypes": [ "image/x-dds" ]
-}

src/imageformats/dds_p.h

@@ -1,37 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003 Ignacio Castaño <castano@ludicon.com>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the Lesser GNU General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-*/
-
-#ifndef KIMG_DDS_H
-#define KIMG_DDS_H
-
-#include <QImageIOPlugin>
-
-class DDSHandler : public QImageIOHandler
-{
-public:
-    DDSHandler();
-
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-
-    static bool canRead(QIODevice *device);
-};
-
-class DDSPlugin : public QImageIOPlugin
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "dds.json")
-
-public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
-};
-
-#endif // KIMG_DDS_H
-

src/imageformats/eps.cpp

@@ -8,16 +8,17 @@
 */
 #include "eps_p.h"
 
-#include <QDebug>
 #include <QImage>
 #include <QImageReader>
-#include <QLoggingCategory>
 #include <QPainter>
 #include <QPrinter>
 #include <QProcess>
 #include <QTemporaryFile>
+#include <QCoreApplication>
+
+// logging category for this framework, default: log stuff >= warning
+Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin", QtWarningMsg)
 
-Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin")
 //#define EPS_PERFORMANCE_DEBUG 1
 
 #define BBOX_BUFLEN 200
@@ -156,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();
@@ -198,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;
     }
 
@@ -297,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;
         }
     }
@@ -312,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;
     }
 
@@ -333,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;

src/imageformats/eps_p.h

@@ -4,19 +4,20 @@
 *
 * This library is distributed under the conditions of the GNU LGPL.
 */
-#ifndef KIMG_EPS_H
+#ifndef KIMG_EPS_P_H
-#define KIMG_EPS_H
+#define KIMG_EPS_P_H
 
 #include <QImageIOPlugin>
+#include <QLoggingCategory>
 
 class EPSHandler : public QImageIOHandler
 {
 public:
     EPSHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    bool read(QImage *image) override;
-    virtual bool write(const QImage &image);
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -27,9 +28,11 @@ class EPSPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "eps.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_EPS_H
+Q_DECLARE_LOGGING_CATEGORY(EPSPLUGIN)
+
+#endif // KIMG_EPS_P_H
 

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

src/imageformats/exr_p.h

@@ -8,8 +8,8 @@
 *
 */
 
-#ifndef KIMG_EXR_H
+#ifndef KIMG_EXR_P_H
-#define KIMG_EXR_H
+#define KIMG_EXR_P_H
 
 #include <QImageIOPlugin>
 
@@ -18,8 +18,8 @@ class EXRHandler : public QImageIOHandler
 public:
     EXRHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *outImage);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_EXR_H
+#endif // KIMG_EXR_P_H

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

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);
+            Read_Old_Line(image, width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            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);
+            s.device()->ungetChar(val);
-            Read_Old_Line(image.data(), width, s);
+            Read_Old_Line(image, width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            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);
+            Read_Old_Line(image + 4, width - 1, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            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);
+        return false;
-        io->setStatus(-1);
-        return;
     }
 
-    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);
+        return false;
-        io->setStatus(-1);
-        return;
     }
 
-    QDataStream s(io->ioDevice());
+    QDataStream s(device());
 
     QImage img;
     if (!LoadHDR(s, width, height, img)) {
         // qDebug() << "Error loading HDR file.";
-        io->setImage(0);
+        return false;
-        io->setStatus(-1);
-        return;
     }
 
-    io->setImage(img);
+    *outImage = img;
-    io->setStatus(0);
+    return true;
 }
 
-Q_DECL_EXPORT void kimgio_hdr_write(QImageIO *)
+HDRHandler::HDRHandler()
 {
-    // intentionally not implemented (since writing low dynamic range data to a HDR file is nonsense.)
 }
 
+bool HDRHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("hdr");
+        return true;
+    }
+    return false;
+}
+
+bool HDRHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("HDRHandler::canRead() called with no device");
+        return false;
+    }
+
+    return device->peek(11) == "#?RADIANCE\n" || device->peek(7) == "#?RGBE\n";
+}
+
+QImageIOPlugin::Capabilities HDRPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "hdr") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && HDRHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *HDRPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new HDRHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/hdr.json

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

src/imageformats/hdr_p.h

@@ -7,15 +7,30 @@
    version 2 of the License, or (at your option) any later version.
 */
 
-#ifndef KIMG_HDR_H
+#ifndef KIMG_HDR_P_H
-#define KIMG_HDR_H
+#define KIMG_HDR_P_H
 
-class QImageIO;
+#include <QImageIOPlugin>
 
-extern "C" {
+class HDRHandler : public QImageIOHandler
-    void kimgio_hdr_read(QImageIO *);
+{
-    void kimgio_hdr_write(QImageIO *);
+public:
-}
+    HDRHandler();
 
-#endif
+    bool canRead() const override;
+    bool read(QImage *outImage) override;
 
+    static bool canRead(QIODevice *device);
+};
+
+class HDRPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "hdr.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+#endif // KIMG_HDR_P_H

src/imageformats/jp2.cpp

@@ -1,526 +0,0 @@
-/*
-* QImageIO Routines to read/write JPEG2000 images.
-* copyright (c) 2002 Michael Ritzert <michael@ritzert.de>
-*
-* This library is distributed under the conditions of the GNU LGPL.
-*/
-
-#include "jp2_p.h"
-
-#include <config-jp2.h>
-
-#if HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
-#if HAVE_STDINT_H
-#include <stdint.h>
-#endif
-
-#include <QImage>
-#include <QVariant>
-#include <QTextStream>
-
-// dirty, but avoids a warning because jasper.h includes jas_config.h.
-#undef PACKAGE
-#undef VERSION
-#include <jasper/jasper.h>
-
-// code taken in parts from JasPer's jiv.c
-
-#define DEFAULT_RATE 0.10
-#define MAXCMPTS 256
-
-/************************* JasPer QIODevice stream ***********************/
-
-//unfortunately this is declared as static in JasPer libraries
-static jas_stream_t *jas_stream_create()
-{
-    jas_stream_t *stream;
-
-    if (!(stream = (jas_stream_t *)jas_malloc(sizeof(jas_stream_t)))) {
-        return 0;
-    }
-    stream->openmode_ = 0;
-    stream->bufmode_ = 0;
-    stream->flags_ = 0;
-    stream->bufbase_ = 0;
-    stream->bufstart_ = 0;
-    stream->bufsize_ = 0;
-    stream->ptr_ = 0;
-    stream->cnt_ = 0;
-    stream->ops_ = 0;
-    stream->obj_ = 0;
-    stream->rwcnt_ = 0;
-    stream->rwlimit_ = -1;
-
-    return stream;
-}
-
-//unfortunately this is declared as static in JasPer libraries
-static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
-                               int bufsize)
-{
-    /* If this function is being called, the buffer should not have been
-      initialized yet. */
-    assert(!stream->bufbase_);
-
-    if (bufmode != JAS_STREAM_UNBUF) {
-        /* The full- or line-buffered mode is being employed. */
-        if (!buf) {
-            /* The caller has not specified a buffer to employ, so allocate
-              one. */
-            if ((stream->bufbase_ = (unsigned char *)jas_malloc(JAS_STREAM_BUFSIZE +
-                                    JAS_STREAM_MAXPUTBACK))) {
-                stream->bufmode_ |= JAS_STREAM_FREEBUF;
-                stream->bufsize_ = JAS_STREAM_BUFSIZE;
-            } else {
-                /* The buffer allocation has failed.  Resort to unbuffered
-                  operation. */
-                stream->bufbase_ = stream->tinybuf_;
-                stream->bufsize_ = 1;
-            }
-        } else {
-            /* The caller has specified a buffer to employ. */
-            /* The buffer must be large enough to accommodate maximum
-              putback. */
-            assert(bufsize > JAS_STREAM_MAXPUTBACK);
-            stream->bufbase_ = JAS_CAST(uchar *, buf);
-            stream->bufsize_ = bufsize - JAS_STREAM_MAXPUTBACK;
-        }
-    } else {
-        /* The unbuffered mode is being employed. */
-        /* A buffer should not have been supplied by the caller. */
-        assert(!buf);
-        /* Use a trivial one-character buffer. */
-        stream->bufbase_ = stream->tinybuf_;
-        stream->bufsize_ = 1;
-    }
-    stream->bufstart_ = &stream->bufbase_[JAS_STREAM_MAXPUTBACK];
-    stream->ptr_ = stream->bufstart_;
-    stream->cnt_ = 0;
-    stream->bufmode_ |= bufmode & JAS_STREAM_BUFMODEMASK;
-}
-
-static int qiodevice_read(jas_stream_obj_t *obj, char *buf, int cnt)
-{
-    QIODevice *io = (QIODevice *) obj;
-    return io->read(buf, cnt);
-}
-
-static int qiodevice_write(jas_stream_obj_t *obj, char *buf, int cnt)
-{
-    QIODevice *io = (QIODevice *) obj;
-    return io->write(buf, cnt);
-}
-
-static long qiodevice_seek(jas_stream_obj_t *obj, long offset, int origin)
-{
-    QIODevice *io = (QIODevice *) obj;
-    long newpos;
-
-    switch (origin) {
-    case SEEK_SET:
-        newpos = offset;
-        break;
-    case SEEK_END:
-        newpos = io->size() - offset;
-        break;
-    case SEEK_CUR:
-        newpos = io->pos() + offset;
-        break;
-    default:
-        return -1;
-    }
-    if (newpos < 0) {
-        return -1;
-    }
-    if (io->seek(newpos)) {
-        return newpos;
-    } else {
-        return -1;
-    }
-}
-
-static int qiodevice_close(jas_stream_obj_t *)
-{
-    return 0;
-}
-
-static jas_stream_ops_t jas_stream_qiodeviceops = {
-    qiodevice_read,
-    qiodevice_write,
-    qiodevice_seek,
-    qiodevice_close
-};
-
-static jas_stream_t *jas_stream_qiodevice(QIODevice *iodevice)
-{
-    jas_stream_t *stream;
-
-    if (!iodevice) {
-        return 0;
-    }
-    if (!(stream = jas_stream_create())) {
-        return 0;
-    }
-
-    /* A stream associated with a memory buffer is always opened
-    for both reading and writing in binary mode. */
-    stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;
-
-    jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
-
-    /* Select the operations for a memory stream. */
-    stream->obj_ = (void *)iodevice;
-    stream->ops_ = &jas_stream_qiodeviceops;
-
-    return stream;
-}
-
-/************************ End of JasPer QIODevice stream ****************/
-
-typedef struct {
-    jas_image_t *image;
-
-    int cmptlut[MAXCMPTS];
-
-    jas_image_t *altimage;
-} gs_t;
-
-static jas_image_t *
-read_image(QIODevice *io)
-{
-    jas_stream_t *in = 0;
-
-    in = jas_stream_qiodevice(io);
-
-    if (!in) {
-        return 0;
-    }
-
-    jas_image_t *image = jas_image_decode(in, -1, 0);
-    jas_stream_close(in);
-
-    // image may be 0, but that's Ok
-    return image;
-} // read_image
-
-static bool
-convert_colorspace(gs_t &gs)
-{
-    jas_cmprof_t *outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB);
-    if (!outprof) {
-        return false;
-    }
-
-    gs.altimage = jas_image_chclrspc(gs.image, outprof,
-                                     JAS_CMXFORM_INTENT_PER);
-    if (!gs.altimage) {
-        return false;
-    }
-
-    return true;
-} // convert_colorspace
-
-static bool
-render_view(gs_t &gs, QImage *outImage)
-{
-    if (!gs.altimage) {
-        return false;
-    }
-    QImage qti;
-    if ((gs.cmptlut[0] = jas_image_getcmptbytype(gs.altimage,
-                         JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
-            (gs.cmptlut[1] = jas_image_getcmptbytype(gs.altimage,
-                             JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0 ||
-            (gs.cmptlut[2] = jas_image_getcmptbytype(gs.altimage,
-                             JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0) {
-        return false;
-    } // if
-
-    const int *cmptlut = gs.cmptlut;
-    int v[3];
-
-    // check that all components have the same size.
-    const int width = jas_image_cmptwidth(gs.altimage, cmptlut[0]);
-    const int height = jas_image_cmptheight(gs.altimage, cmptlut[0]);
-    for (int i = 1; i < 3; ++i) {
-        if (jas_image_cmptwidth(gs.altimage, cmptlut[i]) != width ||
-                jas_image_cmptheight(gs.altimage, cmptlut[i]) != height) {
-            return false;
-        }
-    } // for
-
-    jas_matrix_t *cmptmatrix[3];
-    jas_seqent_t *buf[3];
-    int prec[3];
-
-    for (int k = 0; k < 3; ++k) {
-        prec[k] = jas_image_cmptprec(gs.altimage, cmptlut[k]);
-        if (!(cmptmatrix[k] = jas_matrix_create(1, width))) {
-            return false;
-        }
-    }
-
-    qti = QImage(jas_image_width(gs.altimage), jas_image_height(gs.altimage),
-                 QImage::Format_RGB32);
-    if (qti.isNull()) {
-        return false;
-    }
-    uint32_t *data = (uint32_t *)qti.bits();
-
-    for (int y = 0; y < height; ++y) {
-        for (int k = 0; k < 3; ++k) {
-            if (jas_image_readcmpt(gs.altimage, cmptlut[k], 0, y, width, 1, cmptmatrix[k])) {
-                return false;
-            }
-            buf[k] = jas_matrix_getref(cmptmatrix[k], 0, 0);
-        }
-        for (int x = 0; x < width; ++x) {
-            for (int k = 0; k < 3; ++k) {
-                v[k] = *buf[k];
-                // if the precision of the component is too small, increase
-                // it to use the complete value range.
-                v[k] <<= 8 - prec[k];
-
-                if (v[k] < 0) {
-                    v[k] = 0;
-                } else if (v[k] > 255) {
-                    v[k] = 255;
-                }
-                ++buf[k];
-            } // for k
-
-            *data++ = qRgb(v[0], v[1], v[2]);
-        } // for x
-    } // for y
-
-    for (int k = 0; k < 3; ++k) {
-        if (cmptmatrix[k]) {
-            jas_matrix_destroy(cmptmatrix[k]);
-        }
-    }
-
-    *outImage = qti;
-    return true;
-} // render_view
-
-static jas_image_t *
-create_image(const QImage &qi)
-{
-    // prepare the component parameters
-    jas_image_cmptparm_t *cmptparms = new jas_image_cmptparm_t[ 3 ];
-
-    for (int i = 0; i < 3; ++i) {
-        // x and y offset
-        cmptparms[i].tlx = 0;
-        cmptparms[i].tly = 0;
-
-        // the resulting image will be hstep*width x vstep*height !
-        cmptparms[i].hstep = 1;
-        cmptparms[i].vstep = 1;
-        cmptparms[i].width = qi.width();
-        cmptparms[i].height = qi.height();
-
-        // we write everything as 24bit truecolor ATM
-        cmptparms[i].prec = 8;
-        cmptparms[i].sgnd = false;
-    }
-
-    jas_image_t *ji = jas_image_create(3 /* number components */, cmptparms, JAS_CLRSPC_UNKNOWN);
-    delete[] cmptparms;
-
-    // returning 0 is ok
-    return ji;
-} // create_image
-
-static bool
-write_components(jas_image_t *ji, const QImage &qi)
-{
-    const unsigned height = qi.height();
-    const unsigned width = qi.width();
-
-    jas_matrix_t *m = jas_matrix_create(height, width);
-    if (!m) {
-        return false;
-    }
-
-    jas_image_setclrspc(ji, JAS_CLRSPC_SRGB);
-
-    jas_image_setcmpttype(ji, 0, JAS_IMAGE_CT_RGB_R);
-    for (uint y = 0; y < height; ++y)
-        for (uint x = 0; x < width; ++x) {
-            jas_matrix_set(m, y, x, qRed(qi.pixel(x, y)));
-        }
-    jas_image_writecmpt(ji, 0, 0, 0, width, height, m);
-
-    jas_image_setcmpttype(ji, 1, JAS_IMAGE_CT_RGB_G);
-    for (uint y = 0; y < height; ++y)
-        for (uint x = 0; x < width; ++x) {
-            jas_matrix_set(m, y, x, qGreen(qi.pixel(x, y)));
-        }
-    jas_image_writecmpt(ji, 1, 0, 0, width, height, m);
-
-    jas_image_setcmpttype(ji, 2, JAS_IMAGE_CT_RGB_B);
-    for (uint y = 0; y < height; ++y)
-        for (uint x = 0; x < width; ++x) {
-            jas_matrix_set(m, y, x, qBlue(qi.pixel(x, y)));
-        }
-    jas_image_writecmpt(ji, 2, 0, 0, width, height, m);
-    jas_matrix_destroy(m);
-
-    return true;
-} // write_components
-
-static bool
-write_image(const QImage &image, QIODevice *io, int quality)
-{
-    jas_stream_t *stream = 0;
-    stream = jas_stream_qiodevice(io);
-
-    // by here, a jas_stream_t is open
-    if (!stream) {
-        return false;
-    }
-
-    jas_image_t *ji = create_image(image);
-    if (!ji) {
-        jas_stream_close(stream);
-        return false;
-    } // if
-
-    if (!write_components(ji, image)) {
-        jas_stream_close(stream);
-        jas_image_destroy(ji);
-        return false;
-    } // if
-
-    // optstr:
-    // - rate=#B => the resulting file size is about # bytes
-    // - rate=0.0 .. 1.0 => the resulting file size is about the factor times
-    //                      the uncompressed size
-    // use sprintf for locale-aware string
-    char rateBuffer[16];
-    sprintf(rateBuffer, "rate=%.2g\n", (quality < 0) ? DEFAULT_RATE : quality / 100.0);
-    int i = jp2_encode(ji, stream, rateBuffer);
-
-    jas_image_destroy(ji);
-    jas_stream_close(stream);
-
-    if (i != 0) {
-        return false;
-    }
-
-    return true;
-}
-
-JP2Handler::JP2Handler()
-{
-    quality = 75;
-    jas_init();
-}
-
-JP2Handler::~JP2Handler()
-{
-    jas_cleanup();
-}
-
-bool JP2Handler::canRead() const
-{
-    if (canRead(device())) {
-        setFormat("jp2");
-        return true;
-    }
-    return false;
-}
-
-bool JP2Handler::canRead(QIODevice *device)
-{
-    if (!device) {
-        return false;
-    }
-    return device->peek(6) == QByteArray("\x00\x00\x00\x0C\x6A\x50", 6);
-}
-
-bool JP2Handler::read(QImage *image)
-{
-    if (!canRead()) {
-        return false;
-    }
-
-    gs_t gs;
-    if (!(gs.image = read_image(device()))) {
-        return false;
-    }
-
-    if (!convert_colorspace(gs)) {
-        return false;
-    }
-
-    render_view(gs, image);
-
-    if (gs.image) {
-        jas_image_destroy(gs.image);
-    }
-    if (gs.altimage) {
-        jas_image_destroy(gs.altimage);
-    }
-    return true;
-
-}
-
-bool JP2Handler::write(const QImage &image)
-{
-    return write_image(image, device(), quality);
-}
-
-bool JP2Handler::supportsOption(ImageOption option) const
-{
-    return option == Quality;
-}
-
-QVariant JP2Handler::option(ImageOption option) const
-{
-    if (option == Quality) {
-        return quality;
-    }
-    return QVariant();
-}
-
-void JP2Handler::setOption(ImageOption option, const QVariant &value)
-{
-    if (option == Quality) {
-        quality = qBound(-1, value.toInt(), 100);
-    }
-}
-
-QImageIOPlugin::Capabilities JP2Plugin::capabilities(QIODevice *device, const QByteArray &format) const
-{
-    if (format == "jp2") {
-        return Capabilities(CanRead | CanWrite);
-    }
-    if (!format.isEmpty()) {
-        return 0;
-    }
-    if (!device->isOpen()) {
-        return 0;
-    }
-
-    Capabilities cap;
-    if (device->isReadable() && JP2Handler::canRead(device)) {
-        cap |= CanRead;
-    }
-    if (device->isWritable()) {
-        cap |= CanWrite;
-    }
-    return cap;
-}
-
-QImageIOHandler *JP2Plugin::create(QIODevice *device, const QByteArray &format) const
-{
-    QImageIOHandler *handler = new JP2Handler;
-    handler->setDevice(device);
-    handler->setFormat(format);
-    return handler;
-}

src/imageformats/jp2.json

@@ -1,4 +0,0 @@
-{
-    "Keys": [ "jp2" ],
-    "MimeTypes": [ "image/jp2" ]
-}

src/imageformats/jp2_p.h

@@ -1,42 +0,0 @@
-/*
-* QImageIO Routines to read/write JPEG2000 images.
-* copyright (c) 2002 Michael Ritzert <michael@ritzert.de>
-*
-* This library is distributed under the conditions of the GNU LGPL.
-*/
-#ifndef KIMG_JP2_H
-#define KIMG_JP2_H
-
-#include <QImageIOPlugin>
-
-class JP2Handler : public QImageIOHandler
-{
-public:
-    JP2Handler();
-    virtual ~JP2Handler();
-
-    virtual bool canRead() const;
-    virtual bool read(QImage *image);
-    virtual bool write(const QImage &image);
-
-    virtual bool supportsOption(ImageOption option) const;
-    virtual QVariant option(ImageOption option) const;
-    virtual void setOption(ImageOption option, const QVariant &value);
-
-    static bool canRead(QIODevice *device);
-
-private:
-    int quality;
-};
-
-class JP2Plugin : public QImageIOPlugin
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "jp2.json")
-
-public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
-};
-
-#endif // KIMG_JP2_H

src/imageformats/kra.cpp

@@ -0,0 +1,91 @@
+/* This file is part of the KDE project
+   Copyright (C) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This code is based on Thacher Ulrich PSD loading code released
+   on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+#include "kra.h"
+
+#include <kzip.h>
+
+#include <QImage>
+#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()
+{
+}
+
+bool KraHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("kra");
+        return true;
+    }
+    return false;
+}
+
+bool KraHandler::read(QImage *image)
+{
+    KZip zip(device());
+    if (!zip.open(QIODevice::ReadOnly)) return false;
+
+    const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
+    if (!entry || !entry->isFile()) return false;
+
+    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
+
+    image->loadFromData(fileZipEntry->data(), "PNG");
+
+    return true;
+}
+
+bool KraHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("KraHandler::canRead() called with no device");
+        return false;
+    }
+
+    char buff[57];
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
+
+    return false;
+}
+
+QImageIOPlugin::Capabilities KraPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "kra" || format == "KRA") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && KraHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *KraPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new KraHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/kra.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
-X-KDE-ImageFormat=pnm
+X-KDE-ImageFormat=kra
-X-KDE-MimeType=image/x-portable-anymap
+X-KDE-MimeType=application/x-krita
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/kra.h

@@ -0,0 +1,38 @@
+/* This file is part of the KDE project
+   Copyright (c) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+*/
+
+#ifndef KIMG_KRA_H
+#define KIMG_KRA_H
+
+#include <QImageIOPlugin>
+
+class KraHandler : public QImageIOHandler
+{
+public:
+    KraHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image)  override;
+
+    static bool canRead(QIODevice *device);
+};
+
+class KraPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "kra.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+
+
+#endif

src/imageformats/kra.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "kra" ],
+    "MimeTypes": [ "application/x-krita" ]
+}

src/imageformats/ora.cpp

@@ -0,0 +1,90 @@
+/* This file is part of the KDE project
+   Copyright (C) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This code is based on Thacher Ulrich PSD loading code released
+   on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+#include "ora.h"
+
+#include <QImage>
+#include <QScopedPointer>
+
+#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()
+{
+}
+
+bool OraHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("ora");
+        return true;
+    }
+    return false;
+}
+
+bool OraHandler::read(QImage *image)
+{
+    KZip zip(device());
+    if (!zip.open(QIODevice::ReadOnly)) return false;
+
+    const KArchiveEntry *entry = zip.directory()->entry(QStringLiteral("mergedimage.png"));
+    if (!entry || !entry->isFile()) return false;
+
+    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
+
+    image->loadFromData(fileZipEntry->data(), "PNG");
+
+    return true;
+}
+
+bool OraHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("OraHandler::canRead() called with no device");
+        return false;
+    }
+
+    char buff[54];
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+        return memcmp(buff + 0x26, s_magic, s_magic_size) == 0;
+
+    return false;
+}
+
+QImageIOPlugin::Capabilities OraPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "ora" || format == "ORA") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && OraHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *OraPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new OraHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/ora.desktop

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

src/imageformats/ora.h

@@ -0,0 +1,38 @@
+/* This file is part of the KDE project
+   Copyright (c) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+*/
+
+#ifndef KIMG_ORA_H
+#define KIMG_ORA_H
+
+#include <QImageIOPlugin>
+
+class OraHandler : public QImageIOHandler
+{
+public:
+    OraHandler();
+
+    bool canRead() const override;
+    bool read(QImage *image)  override;
+
+    static bool canRead(QIODevice *device);
+};
+
+
+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 override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
+};
+
+
+#endif
+

src/imageformats/ora.json

@@ -0,0 +1,4 @@
+{
+    "Keys": [ "ora" ],
+    "MimeTypes": [ "image/openraster" ]
+}

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;

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
+#ifndef KIMG_PCX_P_H
-#define KIMG_PCX_H
+#define KIMG_PCX_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +17,9 @@ class PCXHandler : public QImageIOHandler
 public:
     PCXHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    bool read(QImage *image) override;
-    virtual bool write(const QImage &image);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PCX_H
+#endif // KIMG_PCX_P_H

src/imageformats/pic.cpp

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

src/imageformats/pic_p.h

@@ -14,14 +14,15 @@
  *
  * 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
+#ifndef KIMG_PIC_P_H
-#define KIMG_PIC_H
+#define KIMG_PIC_P_H
 
 #include <QImageIOPlugin>
+#include <QDataStream>
 
 /**
  * The magic number at the start of a SoftImage PIC file.
@@ -153,13 +154,13 @@ struct PicChannel {
 class SoftimagePICHandler : public QImageIOHandler
 {
 public:
-    bool canRead() const Q_DECL_OVERRIDE;
+    bool canRead() const override;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool read(QImage *image) override;
-    bool write(const QImage &) Q_DECL_OVERRIDE;
+    bool write(const QImage &) override;
 
-    QVariant option(ImageOption option) const Q_DECL_OVERRIDE;
+    QVariant option(ImageOption option) const override;
-    void setOption(ImageOption option, const QVariant &value) Q_DECL_OVERRIDE;
+    void setOption(ImageOption option, const QVariant &value) override;
-    bool supportsOption(ImageOption option) const Q_DECL_OVERRIDE;
+    bool supportsOption(ImageOption option) const override;
 
     static bool canRead(QIODevice *device);
 
@@ -194,8 +195,8 @@ class SoftimagePICPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pic.json")
 
 public:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PIC_H
+#endif // KIMG_PIC_P_H

src/imageformats/psd.cpp

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

src/imageformats/psd.desktop

@@ -2,6 +2,6 @@
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
 X-KDE-ImageFormat=psd
-X-KDE-MimeType=image/x-psd
+X-KDE-MimeType=image/vnd.adobe.photoshop
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/psd.json

@@ -1,4 +1,4 @@
 {
     "Keys": [ "psd" ],
-    "MimeTypes": [ "image/x-psd" ]
+    "MimeTypes": [ "image/vnd.adobe.photoshop" ]
 }

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
+#ifndef KIMG_PSD_P_H
-#define KIMG_PSD_H
+#define KIMG_PSD_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,8 +17,8 @@ class PSDHandler : public QImageIOHandler
 public:
     PSDHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PSD_H
+#endif // KIMG_PSD_P_H
 

src/imageformats/ras.cpp

@@ -12,8 +12,8 @@
 #include "ras_p.h"
 
 #include <QImage>
-#include <QtCore/QDataStream>
+#include <QDataStream>
-// #include <QDebug>
+#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]];
+                red = palette.value((int)input[y * ras.Width + x]);
-                green = palette[(int)input[y * ras.Width + x] + (ras.ColorMapLength / 3)];
+                green = palette.value((int)input[y * ras.Width + x] + (ras.ColorMapLength / 3));
-                blue = palette[(int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3)];
+                blue = palette.value((int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3));
                 img.setPixel(x, y, qRgb(red, green, blue));
             }
         }
@@ -219,7 +246,7 @@ bool RASHandler::canRead(QIODevice *device)
     }
 
     if (device->isSequential()) {
-        qWarning("Reading ras files from sequential devices not supported");
+        // qWarning("Reading ras files from sequential devices not supported");
         return false;
     }
 
@@ -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;

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
+#ifndef KIMG_RAS_P_H
-#define KIMG_RAS_H
+#define KIMG_RAS_P_H
 
 #include <QImageIOPlugin>
 
@@ -18,8 +18,8 @@ class RASHandler : public QImageIOHandler
 public:
     RASHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_RAS_H
+#endif // KIMG_RAS_P_H
 

src/imageformats/rgb.cpp

@@ -23,11 +23,11 @@
 
 #include "rgb_p.h"
 
-#include <QtCore/QMap>
+#include <QMap>
-#include <QtCore/QVector>
+#include <QVector>
 
 #include <QImage>
-// #include <QDebug>
+#include <QDebug>
 
 class RLEData : public QVector<uchar>
 {
@@ -111,8 +111,8 @@ private:
 };
 
 SGIImage::SGIImage(QIODevice *io) :
-    _starttab(0),
+    _starttab(nullptr),
-    _lengthtab(0)
+    _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();
+    const qint64 oldPos = device->pos();
-    QByteArray head = device->readLine(64);
+    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]"));
+    return head.size() >= 4 && head.startsWith("\x01\xda") && (head[2] == 0 || head[2] == 1) && (head[3] == 1 || head[3] == 2);
-    QString data(QString::fromLocal8Bit(head));
-
-    return data.contains(regexp);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -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;

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
+#ifndef KIMG_RGB_P_H
-#define KIMG_RGB_H
+#define KIMG_RGB_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +17,9 @@ class RGBHandler : public QImageIOHandler
 public:
     RGBHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    bool read(QImage *image) override;
-    virtual bool write(const QImage &image);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_RGB_H
+#endif // KIMG_RGB_P_H
 

src/imageformats/rle_p.h

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

src/imageformats/tga.cpp

@@ -23,8 +23,8 @@
 #include <assert.h>
 
 #include <QImage>
-#include <QtCore/QDataStream>
+#include <QDataStream>
-// #include <QDebug>
+#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;

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
+#ifndef KIMG_TGA_P_H
-#define KIMG_TGA_H
+#define KIMG_TGA_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +17,9 @@ class TGAHandler : public QImageIOHandler
 public:
     TGAHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    bool read(QImage *image) override;
-    virtual bool write(const QImage &image);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_TGA_H
+#endif // KIMG_TGA_P_H

src/imageformats/xcf.cpp

@@ -24,10 +24,12 @@
 #include <stdlib.h>
 #include <QImage>
 #include <QPainter>
-#include <QtCore/QIODevice>
+#include <QIODevice>
-#include <QtCore/QStack>
+#include <QStack>
-#include <QtCore/QVector>
+#include <QVector>
-// #include <QDebug>
+#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 opacity = 255;  //!< The opacity of the layer
-        quint32 visible;        //!< Is the layer visible?
+        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 x_offset = 0;    //!< x offset of the layer relative to the image
-        qint32 y_offset;        //!< y offset of the layer relative to the image
+        qint32 y_offset = 0;    //!< y offset of the layer relative to the image
-        quint32 mode;           //!< Combining mode of layer (LayerModeEffects)
+        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 x_resolution = -1;//!< x resolution in dots per inch
-        float y_resolution;     //!< y 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));
+    if (xcf_image.x_resolution > 0 && xcf_image.y_resolution > 0) {
-    image.setDotsPerMeterY((int)(xcf_image.y_resolution * INCHESPERMETER));
+        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;

src/imageformats/xcf_p.h

@@ -19,8 +19,8 @@
  *
  */
 
-#ifndef KIMG_XCF_H
+#ifndef KIMG_XCF_P_H
-#define KIMG_XCF_H
+#define KIMG_XCF_P_H
 
 #include <QImageIOPlugin>
 
@@ -29,9 +29,9 @@ class XCFHandler : public QImageIOHandler
 public:
     XCFHandler();
 
-    virtual bool canRead() const;
+    bool canRead() const override;
-    virtual bool read(QImage *image);
+    bool read(QImage *image) override;
-    virtual bool write(const QImage &image);
+    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:
-    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
-    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_XCF_H
+#endif // KIMG_XCF_P_H

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

tests/imageconverter.cpp

@@ -32,29 +32,29 @@
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
-    QCoreApplication::addLibraryPath(QLatin1String(PLUGIN_DIR));
+    QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
-    QCoreApplication::setApplicationName(QLatin1String("imageconverter"));
+    QCoreApplication::setApplicationName(QStringLiteral("imageconverter"));
-    QCoreApplication::setApplicationVersion(QLatin1String("1.01.01.0"));
+    QCoreApplication::setApplicationVersion(QStringLiteral("1.01.01.0"));
 
     QCommandLineParser parser;
-    parser.setApplicationDescription(QLatin1String("Converts images from one format to another"));
+    parser.setApplicationDescription(QStringLiteral("Converts images from one format to another"));
     parser.addHelpOption();
     parser.addVersionOption();
-    parser.addPositionalArgument(QLatin1String("in"), QLatin1String("input image file"));
+    parser.addPositionalArgument(QStringLiteral("in"), QStringLiteral("input image file"));
-    parser.addPositionalArgument(QLatin1String("out"), QLatin1String("output image file"));
+    parser.addPositionalArgument(QStringLiteral("out"), QStringLiteral("output image file"));
     QCommandLineOption informat(
-        QStringList() << QLatin1String("i") << QLatin1String("informat"),
+        QStringList() << QStringLiteral("i") << QStringLiteral("informat"),
-        QLatin1String("Image format for input file"),
+        QStringLiteral("Image format for input file"),
-        QLatin1String("format"));
+        QStringLiteral("format"));
     parser.addOption(informat);
     QCommandLineOption outformat(
-        QStringList() << QLatin1String("o") << QLatin1String("outformat"),
+        QStringList() << QStringLiteral("o") << QStringLiteral("outformat"),
-        QLatin1String("Image format for output file"),
+        QStringLiteral("Image format for output file"),
-        QLatin1String("format"));
+        QStringLiteral("format"));
     parser.addOption(outformat);
     QCommandLineOption listformats(
-        QStringList() << QLatin1String("l") << QLatin1String("list"),
+        QStringList() << QStringLiteral("l") << QStringLiteral("list"),
-        QLatin1String("List supported image formats"));
+        QStringLiteral("List supported image formats"));
     parser.addOption(listformats);
 
     parser.process(app);
@@ -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;

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());
+    qint64 written = output.write(reinterpret_cast<const char *>(img.bits()), img.sizeInBytes());
-    if (written != img.byteCount()) {
+    if (written != img.sizeInBytes()) {
         QTextStream(stderr) << "Could not write image data to " << files.at(1)
                             << ":" << output.errorString() << "\n";
         return 5;