Upgrade ECM and KF5 version requirements for 5.15.0 release.

Testing Done:
Build on OS X 10.8

Reviewed at https://git.reviewboard.kde.org/r/125025/

CMakeLists.txt

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

README.md

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

autotests/CMakeLists.txt

@@ -86,22 +86,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)

metainfo.yaml

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

src/imageformats/CMakeLists.txt

@@ -2,11 +2,7 @@
 
 ##################################
 
-add_library(kimg_dds MODULE dds.cpp)
-target_link_libraries(kimg_dds Qt5::Gui)
-
-install(TARGETS kimg_dds  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES dds.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
@@ -15,26 +11,16 @@ if (BUILD_EPS_PLUGIN)
         add_library(kimg_eps MODULE eps.cpp)
         target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
 
-        install(TARGETS kimg_eps  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-        install(FILES eps.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+        install(TARGETS kimg_eps  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+        install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
-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 ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES jp2.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
-endif()
+# need this for Qt's version of the plugin
+install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
@@ -43,8 +29,8 @@ if(OpenEXR_FOUND)
     target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(TARGETS kimg_exr  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-    install(FILES exr.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+    install(TARGETS kimg_exr  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()
 
 ##################################
@@ -52,54 +38,54 @@ endif()
 add_library(kimg_pcx MODULE pcx.cpp)
 target_link_libraries(kimg_pcx  Qt5::Gui)
 
-install(TARGETS kimg_pcx  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pcx.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_pcx  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_pic MODULE pic.cpp)
 target_link_libraries(kimg_pic Qt5::Gui)
 
-install(TARGETS kimg_pic  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES pic.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_pic  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_psd MODULE psd.cpp)
 target_link_libraries(kimg_psd Qt5::Gui)
 
-install(TARGETS kimg_psd  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES psd.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_psd  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_ras MODULE ras.cpp)
 target_link_libraries(kimg_ras  Qt5::Gui)
 
-install(TARGETS kimg_ras  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES ras.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_ras  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_rgb MODULE rgb.cpp)
 target_link_libraries(kimg_rgb  Qt5::Gui)
 
-install(TARGETS kimg_rgb  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES rgb.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_rgb  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_tga MODULE tga.cpp)
 target_link_libraries(kimg_tga  Qt5::Gui)
 
-install(TARGETS kimg_tga  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES tga.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_tga  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 add_library(kimg_xcf MODULE xcf.cpp)
 target_link_libraries(kimg_xcf Qt5::Gui)
 
-install(TARGETS kimg_xcf  DESTINATION ${QT_PLUGIN_INSTALL_DIR}/imageformats/)
-install(FILES xcf.desktop DESTINATION ${SERVICES_INSTALL_DIR}/qimageioplugins/)
+install(TARGETS kimg_xcf  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 

src/imageformats/config-jp2.h.cmake

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

src/imageformats/dds-qt.desktop

@@ -4,4 +4,4 @@ X-KDE-ServiceTypes=QImageIOPlugins
 X-KDE-ImageFormat=dds
 X-KDE-MimeType=image/x-dds
 X-KDE-Read=true
-X-KDE-Write=false
+X-KDE-Write=true

src/imageformats/dds.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/dds.json

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

src/imageformats/eps.cpp

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

src/imageformats/eps_p.h

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

src/imageformats/exr.cpp

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

src/imageformats/exr_p.h

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

src/imageformats/hdr.cpp

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

src/imageformats/jp2.cpp

@@ -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.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.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/jp2.json

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

src/imageformats/pcx.cpp

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

src/imageformats/pcx_p.h

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

src/imageformats/pic.cpp

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

src/imageformats/pic_p.h

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

src/imageformats/psd.cpp

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

src/imageformats/psd_p.h

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

src/imageformats/ras.cpp

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

src/imageformats/ras_p.h

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

src/imageformats/rgb.cpp

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

src/imageformats/rgb_p.h

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

src/imageformats/rle_p.h

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

src/imageformats/tga.cpp

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

src/imageformats/tga_p.h

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

src/imageformats/xcf.cpp

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

src/imageformats/xcf_p.h

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