GIT_SILENT Upgrade ECM and KF5 version requirements for 5.72.0 release.

Since QImage does sanity checking for overflows and stuff wrt.
dimensions and depth, check for QImage::isNull() as early as possible to
see if there's some funky business going on.

Also tried to add some checks wherever we wrote to "raw" memory.

Unit tests pass, and tested converting some files from
https://samples.ffmpeg.org/image-samples/ to pngs, and that seemed to
work.

Reviewed By: aacid

Differential Revision: https://phabricator.kde.org/D24367

.gitignore

@@ -0,0 +1,22 @@
+# 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*
+.cmake/

.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,25 +1,33 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)
 
 project(KImageFormats)
 
+set (CMAKE_CXX_STANDARD 14)
+
 include(FeatureSummary)
-find_package(ECM 5.13.0  NO_MODULE)
-set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
+find_package(ECM 5.72.0  NO_MODULE)
+set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://commits.kde.org/extra-cmake-modules")
 feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 
-set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
+set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 
 include(KDEInstallDirs)
-include(KDEFrameworkCompilerSettings)
+include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
 
 
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.3.0)
+set(REQUIRED_QT_VERSION 5.12.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)
@@ -34,24 +42,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=0x054700)
 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());
-        if (written == image.byteCount()) {
+        qint64 written = file.write(reinterpret_cast<const char *>(image.bits()), image.sizeInBytes());
+        if (written == image.sizeInBytes()) {
             QTextStream(stdout) << "       " << name
                                 << " written to " << filename << "\n";
         } else {
@@ -75,6 +75,7 @@ static bool fuzzyeq(const QImage &im1, const QImage &im2, uchar fuzziness)
 int main(int argc, char ** argv)
 {
     QCoreApplication app(argc, argv);
+    QCoreApplication::removeLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
     QCoreApplication::setApplicationName(QStringLiteral("readtest"));
     QCoreApplication::setApplicationVersion(QStringLiteral("1.0.0"));
@@ -126,13 +127,20 @@ int main(int argc, char ** argv)
         << "Starting basic read tests for "
         << suffix << " images *********\n";
 
-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    const QList<QByteArray> formats = QImageReader::supportedImageFormats();
+    QStringList formatStrings;
+    formatStrings.reserve(formats.size());
+    std::transform(formats.begin(), formats.end(), std::back_inserter(formatStrings), [](const QByteArray &format) { return QString(format); });
+    QTextStream(stdout) << "QImageReader::supportedImageFormats: " << formatStrings.join(", ") << "\n";
+
+    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());
+        QImageReader inputReader(inputfile, format);
         QImageReader expReader(expfile, "png");
 
         QImage inputImage;
@@ -146,6 +154,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";
-
-    foreach (QFileInfo fi, imgdir.entryInfoList()) {
+    const QFileInfoList lstImgDir = imgdir.entryInfoList();
+    for (const QFileInfo &fi : lstImgDir) {
         int suffixPos = fi.filePath().count() - suffix.count();
-        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), "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)
-    add_library(kimg_dds MODULE dds.cpp)
-    target_link_libraries(kimg_dds Qt5::Gui)
+function(kimageformats_add_plugin plugin)
+    set(options)
+    set(oneValueArgs JSON)
+    set(multiValueArgs SOURCES)
+    cmake_parse_arguments(KIF_ADD_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    if(NOT KIF_ADD_PLUGIN_SOURCES)
+        message(FATAL_ERROR "kimageformats_add_plugin called without SOURCES parameter")
+    endif()
+    get_filename_component(json "${KIF_ADD_PLUGIN_JSON}" REALPATH)
+    if(NOT KIF_ADD_PLUGIN_JSON OR NOT EXISTS ${json})
+        message(FATAL_ERROR "JSON file doesn't exist: ${json}")
+    endif()
 
-    install(TARGETS kimg_dds  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
-    install(FILES dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-else()
-    install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-endif()
+    add_library(${plugin} MODULE ${KIF_ADD_PLUGIN_SOURCES})
+    set_property(TARGET ${plugin} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS ${json})
+    set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/imageformats")
+    target_link_libraries(${plugin} Qt5::Gui)
+    install(TARGETS ${plugin} DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats)
+endfunction()
+
+##################################
+
+install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 if (BUILD_EPS_PLUGIN)
     if (Qt5PrintSupport_FOUND)
-        add_library(kimg_eps MODULE eps.cpp)
-        target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
-
-        install(TARGETS kimg_eps  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+        kimageformats_add_plugin(kimg_eps JSON "eps.json" SOURCES eps.cpp)
+        target_link_libraries(kimg_eps Qt5::PrintSupport)
         install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
-check_include_files(sys/types.h   HAVE_SYS_TYPES_H)
-check_include_files(stdint.h      HAVE_STDINT_H)
-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 ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
-    install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-elseif (NOT Qt5Gui_VERSION VERSION_LESS 5.3.0)
-    # need this for Qt's version of the plugin
-    install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
-endif()
+# need this for Qt's version of the plugin
+install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 if(OpenEXR_FOUND)
-    add_library(kimg_exr MODULE exr.cpp)
-    target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
+    kimageformats_add_plugin(kimg_exr JSON "exr.json" SOURCES exr.cpp)
+    target_link_libraries(kimg_exr OpenEXR::IlmImf)
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(TARGETS kimg_exr  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
     install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-add_library(kimg_pcx MODULE pcx.cpp)
-target_link_libraries(kimg_pcx  Qt5::Gui)
+kimageformats_add_plugin(kimg_hdr JSON "hdr.json" SOURCES hdr.cpp)
+install(FILES hdr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
-install(TARGETS kimg_pcx  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+##################################
+
+kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
 install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_pic MODULE pic.cpp)
-target_link_libraries(kimg_pic Qt5::Gui)
-
-install(TARGETS kimg_pic  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_pic JSON "pic.json" SOURCES pic.cpp)
 install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_psd MODULE psd.cpp)
-target_link_libraries(kimg_psd Qt5::Gui)
-
-install(TARGETS kimg_psd  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_psd JSON "psd.json" SOURCES psd.cpp)
 install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_ras MODULE ras.cpp)
-target_link_libraries(kimg_ras  Qt5::Gui)
-
-install(TARGETS kimg_ras  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_ras JSON "ras.json" SOURCES ras.cpp)
 install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_rgb MODULE rgb.cpp)
-target_link_libraries(kimg_rgb  Qt5::Gui)
-
-install(TARGETS kimg_rgb  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_rgb JSON "rgb.json" SOURCES rgb.cpp)
 install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_tga MODULE tga.cpp)
-target_link_libraries(kimg_tga  Qt5::Gui)
-
-install(TARGETS kimg_tga  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_tga JSON "tga.json" SOURCES tga.cpp)
 install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_xcf MODULE xcf.cpp)
-target_link_libraries(kimg_xcf Qt5::Gui)
-
-install(TARGETS kimg_xcf  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_xcf JSON "xcf.json" SOURCES xcf.cpp)
 install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
+##################################
+
+if (KF5Archive_FOUND)
+
+    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,21 +8,16 @@
 */
 #include "eps_p.h"
 
-#include <QDebug>
 #include <QImage>
 #include <QImageReader>
-#include <QLoggingCategory>
 #include <QPainter>
 #include <QPrinter>
 #include <QProcess>
 #include <QTemporaryFile>
+#include <QCoreApplication>
 
-#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
 // logging category for this framework, default: log stuff >= warning
-Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin", QtWarningMsg)
-#else
-Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin")
-#endif
+Q_LOGGING_CATEGORY(EPSPLUGIN, "kf5.kimageformats.epsplugin", QtWarningMsg)
 
 //#define EPS_PERFORMANCE_DEBUG 1
 
@@ -162,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();
@@ -204,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;
     }
 
@@ -303,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;
         }
     }
@@ -318,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;
     }
 
@@ -339,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
-#define KIMG_EPS_H
+#ifndef KIMG_EPS_P_H
+#define KIMG_EPS_P_H
 
 #include <QImageIOPlugin>
+#include <QLoggingCategory>
 
 class EPSHandler : public QImageIOHandler
 {
 public:
     EPSHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -27,9 +28,11 @@ class EPSPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "eps.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#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:
     {
     }
 
-    bool  read(char c[], int n) Q_DECL_OVERRIDE;
-    Imf::Int64 tellg() Q_DECL_OVERRIDE;
-    void seekg(Imf::Int64 pos) Q_DECL_OVERRIDE;
-    void clear() Q_DECL_OVERRIDE;
+    bool  read(char c[], int n) override;
+    Imf::Int64 tellg() override;
+    void seekg(Imf::Int64 pos) override;
+    void clear() override;
 
 private:
     QIODevice *m_dev;
@@ -82,7 +82,7 @@ void K_IStream::clear()
  * format into the normal 32 bit pixel format. Process is from the
  * ILM code.
  */
-QRgb RgbaToQrgba(struct Imf::Rgba imagePixel)
+QRgb RgbaToQrgba(struct Imf::Rgba &imagePixel)
 {
     float r, g, b, a;
 
@@ -172,17 +172,18 @@ bool EXRHandler::read(QImage *outImage)
         width  = dw.max.x - dw.min.x + 1;
         height = dw.max.y - dw.min.y + 1;
 
+        QImage image(width, height, QImage::Format_RGB32);
+        if (image.isNull()) {
+            qWarning() << "Failed to allocate image, invalid size?" << QSize(width, height);
+            return false;
+        }
+
         Imf::Array2D<Imf::Rgba> pixels;
         pixels.resizeErase(height, width);
 
         file.setFrameBuffer(&pixels[0][0] - dw.min.x - dw.min.y * width, 1, width);
         file.readPixels(dw.min.y, dw.max.y);
 
-        QImage image(width, height, QImage::Format_RGB32);
-        if (image.isNull()) {
-            return false;
-        }
-
         // somehow copy pixels into image
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
@@ -218,10 +219,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
-#define KIMG_EXR_H
+#ifndef KIMG_EXR_P_H
+#define KIMG_EXR_P_H
 
 #include <QImageIOPlugin>
 
@@ -18,8 +18,8 @@ class EXRHandler : public QImageIOHandler
 public:
     EXRHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *outImage) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *outImage) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class EXRPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "exr.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_EXR_H
+#endif // KIMG_EXR_P_H

src/imageformats/gimp_p.h

@@ -56,16 +56,6 @@ typedef enum {
     INDEXED
 } GimpImageBaseType;
 
-//! Type of individual layers in an XCF file.
-
-typedef enum {
-    RGB_GIMAGE,
-    RGBA_GIMAGE,
-    GRAY_GIMAGE,
-    GRAYA_GIMAGE,
-    INDEXED_GIMAGE,
-    INDEXEDA_GIMAGE
-} GimpImageType;
 
 // From GIMP "libgimp/gimpenums.h" v2.4
 
@@ -96,48 +86,6 @@ typedef enum {
     GRAIN_MERGE_MODE
 } LayerModeEffects;
 
-// From GIMP "xcf.c" v1.2
-
-//! Properties which can be stored in an XCF file.
-
-typedef enum {
-    PROP_END = 0,
-    PROP_COLORMAP = 1,
-    PROP_ACTIVE_LAYER = 2,
-    PROP_ACTIVE_CHANNEL = 3,
-    PROP_SELECTION = 4,
-    PROP_FLOATING_SELECTION = 5,
-    PROP_OPACITY = 6,
-    PROP_MODE = 7,
-    PROP_VISIBLE = 8,
-    PROP_LINKED = 9,
-    PROP_PRESERVE_TRANSPARENCY = 10,
-    PROP_APPLY_MASK = 11,
-    PROP_EDIT_MASK = 12,
-    PROP_SHOW_MASK = 13,
-    PROP_SHOW_MASKED = 14,
-    PROP_OFFSETS = 15,
-    PROP_COLOR = 16,
-    PROP_COMPRESSION = 17,
-    PROP_GUIDES = 18,
-    PROP_RESOLUTION = 19,
-    PROP_TATTOO = 20,
-    PROP_PARASITES = 21,
-    PROP_UNIT = 22,
-    PROP_PATHS = 23,
-    PROP_USER_UNIT = 24
-} PropType;
-
-// From GIMP "xcf.c" v1.2
-
-//! Compression type used in layer tiles.
-
-typedef enum {
-    COMPRESS_NONE = 0,
-    COMPRESS_RLE = 1,
-    COMPRESS_ZLIB = 2,
-    COMPRESS_FRACTAL = 3  /* Unused. */
-} CompressionType;
 
 // From GIMP "paint_funcs.c" v1.2
 

src/imageformats/hdr.cpp

@@ -11,11 +11,15 @@
 #include "hdr_p.h"
 
 #include <QImage>
-#include <QtCore/QDataStream>
+#include <QDataStream>
+#include <QLoggingCategory>
+#include <QRegularExpressionMatch>
 
 #include <QDebug>
 
-typedef Q_UINT8 uchar;
+typedef unsigned char uchar;
+
+Q_LOGGING_CATEGORY(HDRPLUGIN, "kf5.kimageformats.hdrplugin", QtWarningMsg)
 
 namespace   // Private.
 {
@@ -93,19 +97,23 @@ 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()) {
+        qCDebug(HDRPLUGIN) << "Couldn't create image with size" << width << height << "and format RGB32";
         return false;
     }
 
-    QMemArray<uchar> image(width * 4);
+    QByteArray lineArray;
+    lineArray.resize(4 * width);
+    uchar *image = (uchar *) lineArray.data();
 
     for (int cline = 0; cline < height; cline++) {
         QRgb *scanline = (QRgb *) img.scanLine(cline);
 
         // determine scanline type
         if ((width < MINELEN) || (MAXELEN < width)) {
-            Read_Old_Line(image.data(), width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            Read_Old_Line(image, width, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -116,9 +124,9 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
         }
 
         if (val != 2) {
-            s.device()->at(s.device()->at() - 1);
-            Read_Old_Line(image.data(), width, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            s.device()->ungetChar(val);
+            Read_Old_Line(image, width, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
@@ -132,12 +140,13 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
 
         if ((image[1] != 2) || (image[2] & 128)) {
             image[0] = 2;
-            Read_Old_Line(image.data() + 4, width - 1, s);
-            RGBE_To_QRgbLine(image.data(), scanline, width);
+            Read_Old_Line(image + 4, width - 1, s);
+            RGBE_To_QRgbLine(image, scanline, width);
             continue;
         }
 
         if ((image[2] << 8 | image[3]) != width) {
+            qCDebug(HDRPLUGIN) << "Line of pixels had width" << (image[2] << 8 | image[3]) << "instead of" << width;
             return false;
         }
 
@@ -146,6 +155,7 @@ static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &i
             for (int j = 0; j < width;) {
                 s >> code;
                 if (s.atEnd()) {
+                    qCDebug(HDRPLUGIN) << "Truncated HDR file";
                     return false;
                 }
                 if (code > 128) {
@@ -168,7 +178,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,63 +186,110 @@ 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];
-    //bool validHeader = false;
-    bool validFormat = false;
+    QByteArray line(MAXLINE + 1, Qt::Uninitialized);
+    QByteArray format;
 
     // Parse header
     do {
-        len = io->ioDevice()->readLine(line, MAXLINE);
+        len = device()->readLine(line.data(), MAXLINE);
 
-        /*if (strcmp(line, "#?RADIANCE\n") == 0 || strcmp(line, "#?RGBE\n") == 0)
-        {
-            validHeader = true;
-        }*/
-        if (strcmp(line, "FORMAT=32-bit_rle_rgbe\n") == 0) {
-            validFormat = true;
+        if (line.startsWith("FORMAT=")) {
+            format = line.mid(7, len - 7 - 1 /*\n*/);
         }
 
     } while ((len > 0) && (line[0] != '\n'));
 
-    if (/*!validHeader ||*/ !validFormat) {
-        // qDebug() << "Unknown HDR format.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+    if (format != "32-bit_rle_rgbe") {
+        qCDebug(HDRPLUGIN) << "Unknown HDR format:" << format;
+        return false;
     }
 
-    io->ioDevice()->readLine(line, MAXLINE);
+    len = device()->readLine(line.data(), MAXLINE);
+    line.resize(len);
 
-    char s1[3], s2[3];
-    int width, height;
-    if (sscanf(line, "%2[+-XY] %d %2[+-XY] %d\n", s1, &height, s2, &width) != 4)
-        //if( sscanf(line, "-Y %d +X %d", &height, &width) < 2 )
-    {
-        // qDebug() << "Invalid HDR file.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+    /*
+       TODO: handle flipping and rotation, as per the spec below
+       The single resolution line consists of 4 values, a X and Y label each followed by a numerical
+       integer value. The X and Y are immediately preceded by a sign which can be used to indicate
+       flipping, the order of the X and Y indicate rotation. The standard coordinate system for
+       Radiance images would have the following resolution string -Y N +X N. This indicates that the
+       vertical axis runs down the file and the X axis is to the right (imagining the image as a
+       rectangular block of data). A -X would indicate a horizontal flip of the image. A +Y would
+       indicate a vertical flip. If the X value appears before the Y value then that indicates that
+       the image is stored in column order rather than row order, that is, it is rotated by 90 degrees.
+       The reader can convince themselves that the 8 combinations cover all the possible image orientations
+       and rotations.
+    */
+    QRegularExpression resolutionRegExp(QStringLiteral("([+\\-][XY]) ([0-9]+) ([+\\-][XY]) ([0-9]+)\n"));
+    QRegularExpressionMatch match = resolutionRegExp.match(QString::fromLatin1(line));
+    if (!match.hasMatch()) {
+        qCDebug(HDRPLUGIN) << "Invalid HDR file, the first line after the header didn't have the expected format:" << line;
+        return false;
     }
+    const int width = match.captured(2).toInt();
+    const int height = match.captured(4).toInt();
 
-    QDataStream s(io->ioDevice());
+    QDataStream s(device());
 
     QImage img;
     if (!LoadHDR(s, width, height, img)) {
         // qDebug() << "Error loading HDR file.";
-        io->setImage(0);
-        io->setStatus(-1);
-        return;
+        return false;
     }
 
-    io->setImage(img);
-    io->setStatus(0);
+    *outImage = img;
+    return true;
 }
 
-Q_DECL_EXPORT void kimgio_hdr_write(QImageIO *)
+HDRHandler::HDRHandler()
 {
-    // intentionally not implemented (since writing low dynamic range data to a HDR file is nonsense.)
 }
 
+bool HDRHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("hdr");
+        return true;
+    }
+    return false;
+}
+
+bool HDRHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("HDRHandler::canRead() called with no device");
+        return false;
+    }
+
+    return device->peek(11) == "#?RADIANCE\n" || device->peek(7) == "#?RGBE\n";
+}
+
+QImageIOPlugin::Capabilities HDRPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "hdr") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && HDRHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *HDRPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new HDRHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/hdr.json

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

src/imageformats/hdr_p.h

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

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-MimeType=image/x-portable-anymap
+X-KDE-ImageFormat=kra
+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-MimeType=image/x-dds
+X-KDE-ImageFormat=ora
+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,11 @@ 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()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
+
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
             img = QImage();
@@ -279,6 +284,10 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     img = QImage(header.width(), header.height(), QImage::Format_Indexed8);
     img.setColorCount(16);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
 
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
@@ -298,6 +307,9 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
         }
 
         uchar *p = img.scanLine(y);
+        if (!p) {
+            qWarning() << "Failed to get scanline for" << y << "might be out of bounds";
+        }
         for (int x = 0; x < header.width(); ++x) {
             p[ x ] = pixbuf[ x ];
         }
@@ -316,6 +328,11 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
     img = QImage(header.width(), header.height(), QImage::Format_Indexed8);
     img.setColorCount(256);
 
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
+
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
             img = QImage();
@@ -325,6 +342,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 ];
@@ -353,6 +374,11 @@ static void readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
 
     img = QImage(header.width(), header.height(), QImage::Format_RGB32);
 
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width(), header.height());
+        return;
+    }
+
     for (int y = 0; y < header.height(); ++y) {
         if (s.atEnd()) {
             img = QImage();
@@ -667,10 +693,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
-#define KIMG_PCX_H
+#ifndef KIMG_PCX_P_H
+#define KIMG_PCX_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +17,9 @@ class PCXHandler : public QImageIOHandler
 public:
     PCXHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class PCXPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pcx.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PCX_H
+#endif // KIMG_PCX_P_H

src/imageformats/pic.cpp

@@ -17,7 +17,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  * ----------------------------------------------------------------------------
  */
 
@@ -59,7 +59,10 @@ static QDataStream &operator>> (QDataStream &s, PicHeader &header)
     header.comment = QByteArray(comment);
 
     header.id.resize(4);
-    s.readRawData(header.id.data(), 4);
+    const int bytesRead = s.readRawData(header.id.data(), 4);
+    if (bytesRead != 4) {
+        header.id.resize(bytesRead);
+    }
 
     s >> header.width;
     s >> header.height;
@@ -127,9 +130,7 @@ static QDataStream &operator>> (QDataStream &s, QList<PicChannel> &channels)
         PicChannel channel;
         s >> chained;
         s >> channel.size;
-        quint8 encoding;
-        s >> encoding;
-        channel.encoding = PicChannelEncoding(encoding);
+        s >> channel.encoding;
         s >> channel.code;
         channels << channel;
         ++count;
@@ -170,9 +171,9 @@ static QDataStream &operator<< (QDataStream &s, const QList<PicChannel> &channel
     return s;
 }
 
-static bool readRow(QDataStream &stream, QRgb *row, quint16 width, QList<PicChannel> channels)
+static bool readRow(QDataStream &stream, QRgb *row, quint16 width, const QList<PicChannel> &channels)
 {
-    Q_FOREACH(const PicChannel &channel, channels) {
+    for(const PicChannel &channel : channels) {
         auto readPixel = [&] (QDataStream &str) -> QRgb {
             quint8 red = 0;
             if (channel.code & RED) {
@@ -239,7 +240,7 @@ bool SoftimagePICHandler::read(QImage *image)
     }
 
     QImage::Format fmt = QImage::Format_RGB32;
-    Q_FOREACH(const PicChannel &channel, m_channels) {
+    for (const PicChannel &channel : qAsConst(m_channels)) {
         if (channel.size != 8) {
             // we cannot read images that do not come in bytes
             qDebug() << "Channel size was" << channel.size;
@@ -252,6 +253,11 @@ bool SoftimagePICHandler::read(QImage *image)
     }
 
     QImage img(m_header.width, m_header.height, fmt);
+    if (img.isNull()) {
+        qDebug() << "Failed to allocate image, invalid dimensions?" << QSize(m_header.width, m_header.height) << fmt;
+        return false;
+    }
+
     img.fill(qRgb(0,0,0));
 
     for (int y = 0; y < m_header.height; y++) {
@@ -361,6 +367,7 @@ bool SoftimagePICHandler::readHeader()
             m_state = ReadHeader;
         }
     }
+
     return m_state != Error;
 }
 
@@ -385,8 +392,8 @@ void SoftimagePICHandler::setOption(ImageOption option, const QVariant &value)
             break;
         case Description: {
             m_description.clear();
-            QStringList entries = value.toString().split(QStringLiteral("\n\n"));
-            Q_FOREACH(const QString entry, entries) {
+            const QStringList entries = value.toString().split(QStringLiteral("\n\n"));
+            for (const QString &entry : entries) {
                 if (entry.startsWith(QStringLiteral("Description: "))) {
                     m_description = entry.mid(13).simplified().toUtf8();
                 }
@@ -422,7 +429,7 @@ QVariant SoftimagePICHandler::option(ImageOption option) const
             return QString();
         case ImageFormat:
             if (const_cast<SoftimagePICHandler*>(this)->readChannels()) {
-                Q_FOREACH (const PicChannel &channel, m_channels) {
+                for (const PicChannel &channel : qAsConst(m_channels)) {
                     if (channel.code & ALPHA) {
                         return QImage::Format_ARGB32;
                     }
@@ -449,10 +456,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,12 +14,12 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  * ----------------------------------------------------------------------------
  */
 
-#ifndef KIMG_PIC_H
-#define KIMG_PIC_H
+#ifndef KIMG_PIC_P_H
+#define KIMG_PIC_P_H
 
 #include <QImageIOPlugin>
 #include <QDataStream>
@@ -119,7 +119,7 @@ struct PicHeader {
  */
 struct PicChannel {
     quint8 size; /**< Bits per component per pixel. */
-    PicChannelEncoding encoding; /**< How the channel's data is encoded. */
+    quint8 encoding; /**< How the channel's data is encoded. */
     quint8 code; /**< Flag field to describe which components are encoded in
                       this channel. */
 
@@ -154,13 +154,13 @@ struct PicChannel {
 class SoftimagePICHandler : public QImageIOHandler
 {
 public:
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &) override;
 
-    QVariant option(ImageOption option) const Q_DECL_OVERRIDE;
-    void setOption(ImageOption option, const QVariant &value) Q_DECL_OVERRIDE;
-    bool supportsOption(ImageOption option) const Q_DECL_OVERRIDE;
+    QVariant option(ImageOption option) const override;
+    void setOption(ImageOption option, const QVariant &value) override;
+    bool supportsOption(ImageOption option) const override;
 
     static bool canRead(QIODevice *device);
 
@@ -195,8 +195,8 @@ class SoftimagePICPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "pic.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PIC_H
+#endif // KIMG_PIC_P_H

src/imageformats/psd.cpp

@@ -16,7 +16,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 /*
@@ -120,19 +120,19 @@ static quint8 readPixel(QDataStream &stream) {
     quint8 pixel;
     stream >> pixel;
     return pixel;
-};
+}
 static QRgb updateRed(QRgb oldPixel, quint8 redPixel) {
     return qRgba(redPixel, qGreen(oldPixel), qBlue(oldPixel), qAlpha(oldPixel));
-};
+}
 static QRgb updateGreen(QRgb oldPixel, quint8 greenPixel) {
     return qRgba(qRed(oldPixel), greenPixel, qBlue(oldPixel), qAlpha(oldPixel));
-};
+}
 static QRgb updateBlue(QRgb oldPixel, quint8 bluePixel) {
     return qRgba(qRed(oldPixel), qGreen(oldPixel), bluePixel, qAlpha(oldPixel));
-};
+}
 static QRgb updateAlpha(QRgb oldPixel, quint8 alphaPixel) {
     return qRgba(qRed(oldPixel), qGreen(oldPixel), qBlue(oldPixel), alphaPixel);
-};
+}
 typedef QRgb(*channelUpdater)(QRgb,quint8);
 
 // Load the PSD image.
@@ -171,12 +171,26 @@ static bool LoadPSD(QDataStream &stream, const PSDHeader &header, QImage &img)
         channel_num = 4;
     }
     img = QImage(header.width, header.height, fmt);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(header.width, header.height);
+        return false;
+    }
     img.fill(qRgb(0,0,0));
 
     const quint32 pixel_count = header.height * header.width;
 
+    // Verify this, as this is used to write into the memory of the QImage
+    if (pixel_count > img.sizeInBytes() / sizeof(QRgb)) {
+        qWarning() << "Invalid pixel count!" << pixel_count << "bytes available:" << img.sizeInBytes();
+        return false;
+    }
+
     QRgb *image_data = reinterpret_cast<QRgb*>(img.bits());
 
+    if (!image_data) {
+        return false;
+    }
+
     static const channelUpdater updaters[4] = {
         updateRed,
         updateGreen,
@@ -272,6 +286,11 @@ bool PSDHandler::canRead(QIODevice *device)
 
     char head[4];
     qint64 readBytes = device->read(head, sizeof(head));
+    if (readBytes < 0) {
+        qWarning() << "Read failed" << device->errorString();
+        return false;
+    }
+
     if (readBytes != sizeof(head)) {
         if (device->isSequential()) {
             while (readBytes > 0) {
@@ -300,10 +319,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
-#define KIMG_PSD_H
+#ifndef KIMG_PSD_P_H
+#define KIMG_PSD_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,8 +17,8 @@ class PSDHandler : public QImageIOHandler
 public:
     PSDHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -29,9 +29,9 @@ class PSDPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "psd.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_PSD_H
+#endif // KIMG_PSD_P_H
 

src/imageformats/ras.cpp

@@ -12,8 +12,8 @@
 #include "ras_p.h"
 
 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
+#include <QDataStream>
+#include <QDebug>
 
 namespace   // Private.
 {
@@ -102,6 +102,13 @@ static bool IsSupported(const RasHeader &head)
 static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
 {
     s.device()->seek(RasHeader::SIZE);
+
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.ColorMapLength > std::numeric_limits<int>::max() - 32) {
+        qWarning() << "LoadRAS() unsupported image color map length in file header" << ras.ColorMapLength;
+        return false;
+    }
+
     // Read palette if needed.
     QVector<quint8> palette(ras.ColorMapLength);
     if (ras.ColorMapType == 1) {
@@ -110,19 +117,36 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
         }
     }
 
+    const int bpp = ras.Depth / 8;
+    if (ras.Height == 0) {
+        return false;
+    }
+    if (bpp == 0) {
+        return false;
+    }
+    if (ras.Length / ras.Height / bpp < ras.Width) {
+        qWarning() << "LoadRAS() mistmatch between height and width" << ras.Width << ras.Height << ras.Length << ras.Depth;
+        return false;
+    }
+    // QVector uses some extra space for stuff, hence the 32 here suggested by thiago
+    if (ras.Length > std::numeric_limits<int>::max() - 32) {
+        qWarning() << "LoadRAS() unsupported image length in file header" << ras.Length;
+        return false;
+    }
+
     // each line must be a factor of 16 bits, so they may contain padding
     // this will be 1 if padding required, 0 otherwise
-    int paddingrequired = (ras.Width * (ras.Depth / 8) % 2);
+    const int paddingrequired = (ras.Width * bpp % 2);
 
     // qDebug() << "paddingrequired: " << paddingrequired;
     // don't trust ras.Length
     QVector<quint8> input(ras.Length);
 
     int i = 0;
-    while (! s.atEnd()) {
+    while (! s.atEnd() && i < input.size()) {
         s >> input[i];
         // I guess we need to find out if we're at the end of a line
-        if (paddingrequired && i != 0 && !(i % (ras.Width * (ras.Depth / 8)))) {
+        if (paddingrequired && i != 0 && !(i % (ras.Width * bpp))) {
             s >> input[i];
         }
         i++;
@@ -131,15 +155,18 @@ static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
     // Allocate image
     img = QImage(ras.Width, ras.Height, QImage::Format_ARGB32);
 
+    if (img.isNull())
+        return false;
+
     // Reconstruct image from RGB palette if we have a palette
     // TODO: make generic so it works with 24bit or 32bit palettes
     if (ras.ColorMapType == 1 && ras.Depth == 8) {
         quint8 red, green, blue;
         for (quint32 y = 0; y < ras.Height; y++) {
             for (quint32 x = 0; x < ras.Width; x++) {
-                red = palette[(int)input[y * ras.Width + x]];
-                green = palette[(int)input[y * ras.Width + x] + (ras.ColorMapLength / 3)];
-                blue = palette[(int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3)];
+                red = palette.value((int)input[y * ras.Width + x]);
+                green = palette.value((int)input[y * ras.Width + x] + (ras.ColorMapLength / 3));
+                blue = palette.value((int)input[y * ras.Width + x] + 2 * (ras.ColorMapLength / 3));
                 img.setPixel(x, y, qRgb(red, green, blue));
             }
         }
@@ -248,6 +275,10 @@ bool RASHandler::read(QImage *outImage)
     // Read image header.
     RasHeader ras;
     s >> ras;
+
+    if (ras.ColorMapLength > std::numeric_limits<int>::max())
+        return false;
+
     // TODO: add support for old versions of RAS where Length may be zero in header
     s.device()->seek(RasHeader::SIZE + ras.Length + ras.ColorMapLength);
 
@@ -282,10 +313,10 @@ QImageIOPlugin::Capabilities RASPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/ras_p.h

@@ -8,8 +8,8 @@
    version 2 of the License, or (at your option) any later version.
 */
 
-#ifndef KIMG_RAS_H
-#define KIMG_RAS_H
+#ifndef KIMG_RAS_P_H
+#define KIMG_RAS_P_H
 
 #include <QImageIOPlugin>
 
@@ -18,8 +18,8 @@ class RASHandler : public QImageIOHandler
 public:
     RASHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,9 +30,9 @@ class RASPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ras.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_RAS_H
+#endif // KIMG_RAS_P_H
 

src/imageformats/rgb.cpp

@@ -23,11 +23,11 @@
 
 #include "rgb_p.h"
 
-#include <QtCore/QMap>
-#include <QtCore/QVector>
+#include <QMap>
+#include <QVector>
 
 #include <QImage>
-// #include <QDebug>
+#include <QDebug>
 
 class RLEData : public QVector<uchar>
 {
@@ -111,8 +111,8 @@ private:
 };
 
 SGIImage::SGIImage(QIODevice *io) :
-    _starttab(0),
-    _lengthtab(0)
+    _starttab(nullptr),
+    _lengthtab(nullptr)
 {
     _dev = io;
     _stream.setDevice(_dev);
@@ -144,13 +144,16 @@ bool SGIImage::getRow(uchar *dest)
         if (_bpc == 2) {
             _pos++;
         }
+        if (_pos >= _data.end()) {
+            return false;
+        }
         n = *_pos & 0x7f;
         if (!n) {
             break;
         }
 
         if (*_pos++ & 0x80) {
-            for (; i < _xsize && n--; i++) {
+            for (; i < _xsize && _pos < _data.end() && n--; i++) {
                 *dest++ = *_pos;
                 _pos += _bpc;
             }
@@ -309,16 +312,27 @@ bool SGIImage::readImage(QImage &img)
         return false;
     }
 
-    _numrows = _ysize * _zsize;
-
     img = QImage(_xsize, _ysize, QImage::Format_RGB32);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(_xsize, _ysize);
+        return false;
+    }
+
+    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 +340,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++) {
@@ -457,7 +474,14 @@ bool SGIImage::scanData(const QImage &img)
     uint len;
 
     for (y = 0; y < _ysize; y++) {
-        c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+        const int yPos = _ysize - y - 1; // scanline doesn't do any sanity checking
+        if (yPos >= img.height()) {
+            qWarning() << "Failed to get scanline for" << yPos;
+            return false;
+        }
+
+        c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
+
         for (x = 0; x < _xsize; x++) {
             buf[x] = intensity(qRed(*c++));
         }
@@ -471,7 +495,13 @@ bool SGIImage::scanData(const QImage &img)
 
     if (_zsize != 2) {
         for (y = 0; y < _ysize; y++) {
-            c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+            const int yPos = _ysize - y - 1;
+            if (yPos >= img.height()) {
+                qWarning() << "Failed to get scanline for" << yPos;
+                return false;
+            }
+
+            c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
             for (x = 0; x < _xsize; x++) {
                 buf[x] = intensity(qGreen(*c++));
             }
@@ -480,7 +510,13 @@ bool SGIImage::scanData(const QImage &img)
         }
 
         for (y = 0; y < _ysize; y++) {
-            c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+            const int yPos = _ysize - y - 1;
+            if (yPos >= img.height()) {
+                qWarning() << "Failed to get scanline for" << yPos;
+                return false;
+            }
+
+            c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
             for (x = 0; x < _xsize; x++) {
                 buf[x] = intensity(qBlue(*c++));
             }
@@ -494,7 +530,13 @@ bool SGIImage::scanData(const QImage &img)
     }
 
     for (y = 0; y < _ysize; y++) {
-        c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
+        const int yPos = _ysize - y - 1;
+        if (yPos >= img.height()) {
+            qWarning() << "Failed to get scanline for" << yPos;
+            return false;
+        }
+
+        c = reinterpret_cast<const QRgb *>(img.scanLine(yPos));
         for (x = 0; x < _xsize; x++) {
             buf[x] = intensity(qAlpha(*c++));
         }
@@ -686,8 +728,8 @@ bool RGBHandler::canRead(QIODevice *device)
         return false;
     }
 
-    qint64 oldPos = device->pos();
-    QByteArray head = device->readLine(64);
+    const qint64 oldPos = device->pos();
+    const QByteArray head = device->readLine(64);
     int readBytes = head.size();
 
     if (device->isSequential()) {
@@ -699,10 +741,7 @@ bool RGBHandler::canRead(QIODevice *device)
         device->seek(oldPos);
     }
 
-    const QRegExp regexp(QLatin1String("^\x01\xda\x01[\x01\x02]"));
-    QString data(QString::fromLocal8Bit(head));
-
-    return data.contains(regexp);
+    return head.size() >= 4 && head.startsWith("\x01\xda") && (head[2] == 0 || head[2] == 1) && (head[3] == 1 || head[3] == 2);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -714,10 +753,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
-#define KIMG_RGB_H
+#ifndef KIMG_RGB_P_H
+#define KIMG_RGB_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +17,9 @@ class RGBHandler : public QImageIOHandler
 public:
     RGBHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,9 +30,9 @@ class RGBPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "rgb.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_RGB_H
+#endif // KIMG_RGB_P_H
 

src/imageformats/rle_p.h

@@ -14,12 +14,12 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  * ----------------------------------------------------------------------------
  */
 
-#ifndef KIMAGEFORMATS_RLE_H
-#define KIMAGEFORMATS_RLE_H
+#ifndef KIMAGEFORMATS_RLE_P_H
+#define KIMAGEFORMATS_RLE_P_H
 
 #include <QDebug>
 #include <QDataStream>
@@ -75,7 +75,7 @@ template<typename Item, typename Func1, typename Func2>
 static inline bool decodeRLEData(RLEVariant variant,
                                  QDataStream &stream,
                                  Item *dest,
-                                 quint16 length,
+                                 quint32 length,
                                  Func1 readData,
                                  Func2 updateItem)
 {
@@ -220,4 +220,4 @@ static inline void encodeRLEData(RLEVariant variant,
     }
 }
 
-#endif // KIMAGEFORMATS_RLE_H
+#endif // KIMAGEFORMATS_RLE_P_H

src/imageformats/tga.cpp

@@ -23,8 +23,8 @@
 #include <assert.h>
 
 #include <QImage>
-#include <QtCore/QDataStream>
-// #include <QDebug>
+#include <QDataStream>
+#include <QDebug>
 
 typedef quint32 uint;
 typedef quint16 ushort;
@@ -145,6 +145,7 @@ struct TgaHeaderInfo {
         switch (tga.image_type) {
         case TGA_TYPE_RLE_INDEXED:
             rle = true;
+        Q_FALLTHROUGH();
         // no break is intended!
         case TGA_TYPE_INDEXED:
             pal = true;
@@ -152,6 +153,7 @@ struct TgaHeaderInfo {
 
         case TGA_TYPE_RLE_RGB:
             rle = true;
+        Q_FALLTHROUGH();
         // no break is intended!
         case TGA_TYPE_RGB:
             rgb = true;
@@ -159,6 +161,7 @@ struct TgaHeaderInfo {
 
         case TGA_TYPE_RLE_GREY:
             rle = true;
+        Q_FALLTHROUGH();
         // no break is intended!
         case TGA_TYPE_GREY:
             grey = true;
@@ -175,6 +178,10 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
 {
     // Create image.
     img = QImage(tga.width, tga.height, QImage::Format_RGB32);
+    if (img.isNull()) {
+        qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(tga.width, tga.height);
+        return false;
+    }
 
     TgaHeaderInfo info(tga);
 
@@ -183,10 +190,18 @@ 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 (img.isNull()) {
+            qWarning() << "Failed to allocate image, invalid dimensions?" << QSize(tga.width, tga.height);
+            return false;
+        }
+
+        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,47 +209,110 @@ 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;
+        char *imgEnd = dst + size;
+        qint64 num = size;
+
+        while (num > 0 && valid) {
+            if (s.atEnd()) {
+                valid = false;
+                break;
+            }
 
-        while (num > 0) {
             // 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 {
+                    if (dst + pixel_size > imgEnd) {
+                        qWarning() << "Trying to write out of bounds!" << ptrdiff_t(dst) << (ptrdiff_t(imgEnd) - ptrdiff_t(pixel_size));
+                        valid = false;
+                        break;
+                    }
+
                     memcpy(dst, pixel, pixel_size);
                     dst += pixel_size;
                 } while (--count);
             } 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) {
+                    const size_t toCopy = count - dataRead;
+                    if (&dst[dataRead] + toCopy > imgEnd) {
+                        qWarning() << "Trying to write out of bounds!" << ptrdiff_t(image) << ptrdiff_t(&dst[dataRead]);;
+                        valid = false;
+                        break;
+                    }
+
+                    memset(&dst[dataRead], 0, toCopy);
+                }
                 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 +369,7 @@ static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
     }
 
     // Free image.
-    delete [] image;
+    free(image);
 
     return true;
 }
@@ -414,10 +492,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
-#define KIMG_TGA_H
+#ifndef KIMG_TGA_P_H
+#define KIMG_TGA_P_H
 
 #include <QImageIOPlugin>
 
@@ -17,9 +17,9 @@ class TGAHandler : public QImageIOHandler
 public:
     TGAHandler();
 
-    bool canRead() const Q_DECL_OVERRIDE;
-    bool read(QImage *image) Q_DECL_OVERRIDE;
-    bool write(const QImage &image) Q_DECL_OVERRIDE;
+    bool canRead() const override;
+    bool read(QImage *image) override;
+    bool write(const QImage &image) override;
 
     static bool canRead(QIODevice *device);
 };
@@ -30,8 +30,8 @@ class TGAPlugin : public QImageIOPlugin
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "tga.json")
 
 public:
-    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
-    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const override;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const override;
 };
 
-#endif // KIMG_TGA_H
+#endif // KIMG_TGA_P_H

src/imageformats/xcf_p.h

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

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::setApplicationName(QLatin1String("imageconverter"));
-    QCoreApplication::setApplicationVersion(QLatin1String("1.01.01.0"));
+    QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
+    QCoreApplication::setApplicationName(QStringLiteral("imageconverter"));
+    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(QLatin1String("out"), QLatin1String("output image file"));
+    parser.addPositionalArgument(QStringLiteral("in"), QStringLiteral("input image file"));
+    parser.addPositionalArgument(QStringLiteral("out"), QStringLiteral("output image file"));
     QCommandLineOption informat(
-        QStringList() << QLatin1String("i") << QLatin1String("informat"),
-        QLatin1String("Image format for input file"),
-        QLatin1String("format"));
+        QStringList() << QStringLiteral("i") << QStringLiteral("informat"),
+        QStringLiteral("Image format for input file"),
+        QStringLiteral("format"));
     parser.addOption(informat);
     QCommandLineOption outformat(
-        QStringList() << QLatin1String("o") << QLatin1String("outformat"),
-        QLatin1String("Image format for output file"),
-        QLatin1String("format"));
+        QStringList() << QStringLiteral("o") << QStringLiteral("outformat"),
+        QStringLiteral("Image format for output file"),
+        QStringLiteral("format"));
     parser.addOption(outformat);
     QCommandLineOption listformats(
-        QStringList() << QLatin1String("l") << QLatin1String("list"),
-        QLatin1String("List supported image formats"));
+        QStringList() << QStringLiteral("l") << QStringLiteral("list"),
+        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());
-    if (written != img.byteCount()) {
+    qint64 written = output.write(reinterpret_cast<const char *>(img.bits()), img.sizeInBytes());
+    if (written != img.sizeInBytes()) {
         QTextStream(stderr) << "Could not write image data to " << files.at(1)
                             << ":" << output.errorString() << "\n";
         return 5;