Hello community, here is the log from the commit of package kimageformats for openSUSE:Factory checked in at 2015-03-16 09:31:58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/kimageformats (Old) and /work/SRC/openSUSE:Factory/.kimageformats.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "kimageformats" Changes: -------- --- /work/SRC/openSUSE:Factory/kimageformats/kimageformats.changes 2015-02-16 17:31:32.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.kimageformats.new/kimageformats.changes 2015-03-16 09:31:59.000000000 +0100 @@ -1,0 +2,8 @@ +Sat Mar 7 16:58:48 UTC 2015 - [email protected] + +- Update to 5.8.0 + * Make PSD image reader endianess-agnostic. + * For more details please see: + https://www.kde.org/announcements/kde-frameworks-5.8.0.php + +------------------------------------------------------------------- Old: ---- kimageformats-5.7.0.tar.xz New: ---- kimageformats-5.8.0.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ kimageformats.spec ++++++ --- /var/tmp/diff_new_pack.H1FvyE/_old 2015-03-16 09:32:00.000000000 +0100 +++ /var/tmp/diff_new_pack.H1FvyE/_new 2015-03-16 09:32:00.000000000 +0100 @@ -16,12 +16,12 @@ # -%define _tar_path 5.7 +%define _tar_path 5.8 Name: kimageformats Version: %{_tar_path}.0 Release: 0 BuildRequires: cmake >= 2.8.12 -BuildRequires: extra-cmake-modules >= 1.7.0 +BuildRequires: extra-cmake-modules >= 1.8.0 BuildRequires: fdupes BuildRequires: kf5-filesystem BuildRequires: openexr ++++++ kimageformats-5.7.0.tar.xz -> kimageformats-5.8.0.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/CMakeLists.txt new/kimageformats-5.8.0/CMakeLists.txt --- old/kimageformats-5.7.0/CMakeLists.txt 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/CMakeLists.txt 2015-02-27 19:03:29.000000000 +0100 @@ -2,7 +2,7 @@ project(KImageFormats) -find_package(ECM 1.7.0 REQUIRED NO_MODULE) +find_package(ECM 1.8.0 REQUIRED NO_MODULE) set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR}) Files old/kimageformats-5.7.0/autotests/pic/long-runs.pic and new/kimageformats-5.8.0/autotests/pic/long-runs.pic differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/eps_p.h new/kimageformats-5.8.0/src/imageformats/eps_p.h --- old/kimageformats-5.7.0/src/imageformats/eps_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/eps_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -14,9 +14,9 @@ public: EPSHandler(); - virtual bool canRead() const; - virtual bool read(QImage *image); - virtual bool write(const QImage &image); + bool canRead() const Q_DECL_OVERRIDE; + bool read(QImage *image) Q_DECL_OVERRIDE; + bool write(const QImage &image) Q_DECL_OVERRIDE; static bool canRead(QIODevice *device); }; @@ -27,8 +27,8 @@ Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "eps.json") public: - virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const; - virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const; + Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE; + QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE; }; #endif // KIMG_EPS_H diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/exr.cpp new/kimageformats-5.8.0/src/imageformats/exr.cpp --- old/kimageformats-5.7.0/src/imageformats/exr.cpp 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/exr.cpp 2015-02-27 19:03:29.000000000 +0100 @@ -41,10 +41,10 @@ { } - 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; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/exr_p.h new/kimageformats-5.8.0/src/imageformats/exr_p.h --- old/kimageformats-5.7.0/src/imageformats/exr_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/exr_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -18,8 +18,8 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/pcx_p.h new/kimageformats-5.8.0/src/imageformats/pcx_p.h --- old/kimageformats-5.7.0/src/imageformats/pcx_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/pcx_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -17,9 +17,9 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/pic.cpp new/kimageformats-5.8.0/src/imageformats/pic.cpp --- old/kimageformats-5.7.0/src/imageformats/pic.cpp 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/pic.cpp 2015-02-27 19:03:29.000000000 +0100 @@ -1,5 +1,6 @@ /* - * Softimage PIC support for QImage + * Softimage PIC support for QImage. + * * Copyright 1998 Halfdan Ingvarsson * Copyright 2007 Ruben Lopez <[email protected]> * Copyright 2014 Alex Merry <[email protected]> @@ -27,6 +28,8 @@ #include "pic_p.h" +#include "rle_p.h" + #include <QDataStream> #include <QDebug> #include <QImage> @@ -167,82 +170,6 @@ 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 @@ 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 @@ 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 @@ << 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 @@ 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]); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/pic_p.h new/kimageformats-5.8.0/src/imageformats/pic_p.h --- old/kimageformats-5.7.0/src/imageformats/pic_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/pic_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -195,8 +195,8 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/psd.cpp new/kimageformats-5.8.0/src/imageformats/psd.cpp --- old/kimageformats-5.7.0/src/imageformats/psd.cpp 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/psd.cpp 2015-02-27 19:03:29.000000000 +0100 @@ -1,27 +1,41 @@ -/* This file is part of the KDE project - Copyright (C) 2003 Ignacio Castaño <[email protected]> +/* + * Photoshop File Format support for QImage. + * + * Copyright 2003 Ignacio Castaño <[email protected]> + * Copyright 2015 Alex Merry <[email protected]> + * + * 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 + */ + +/* + * This code is based on Thacher Ulrich PSD loading code released + * into the public domain. See: http://tulrich.com/geekstuff/ + */ - 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 +/* + * 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 @@ 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 @@ 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); + quint32 section_length; + // Skip mode data. + s >> section_length; + s.skipRawData(section_length); +} - uint 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 mode 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); - // Skip image resources. - s >> tmp; - s.device()->seek(s.device()->pos() + tmp); - - // Skip the reserved data. - s >> tmp; - s.device()->seek(s.device()->pos() + tmp); + // 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()); - if (compression) { + 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; } } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/psd_p.h new/kimageformats-5.8.0/src/imageformats/psd_p.h --- old/kimageformats-5.7.0/src/imageformats/psd_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/psd_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -17,8 +17,8 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/ras_p.h new/kimageformats-5.8.0/src/imageformats/ras_p.h --- old/kimageformats-5.7.0/src/imageformats/ras_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/ras_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -18,8 +18,8 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/rgb_p.h new/kimageformats-5.8.0/src/imageformats/rgb_p.h --- old/kimageformats-5.7.0/src/imageformats/rgb_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/rgb_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -17,9 +17,9 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/rle_p.h new/kimageformats-5.8.0/src/imageformats/rle_p.h --- old/kimageformats-5.7.0/src/imageformats/rle_p.h 1970-01-01 01:00:00.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/rle_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -0,0 +1,223 @@ +/* + * Run-Length Encoding utilities. + * Copyright 2014-2015 Alex Merry <[email protected]> + * + * 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; + 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/tga_p.h new/kimageformats-5.8.0/src/imageformats/tga_p.h --- old/kimageformats-5.7.0/src/imageformats/tga_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/tga_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -17,9 +17,9 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/kimageformats-5.7.0/src/imageformats/xcf_p.h new/kimageformats-5.8.0/src/imageformats/xcf_p.h --- old/kimageformats-5.7.0/src/imageformats/xcf_p.h 2015-01-23 21:40:27.000000000 +0100 +++ new/kimageformats-5.8.0/src/imageformats/xcf_p.h 2015-02-27 19:03:29.000000000 +0100 @@ -29,9 +29,9 @@ 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 @@ 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 -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
