mirror/kimageformats
1
0
Fork 0
mirror of https://invent.kde.org/frameworks/kimageformats.git synced 2025-07-18 03:54:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

Make PSD image reader endianess-agnostic.

Browse Source 
By using the same strategy as the SoftImage PIC handler (and sharing
some code with it), we should avoid reading the image data incorrectly
on big-endian architectures.

REVIEW: 122650
BUG: 337918
This commit is contained in:
Alex Merry
2015-02-20 18:11:37 +00:00
parent ac2b63046f
commit 47e8043d45
4 changed files with 332 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
src/imageformats/psd.cpp
View File

@ -1,27 +1,41 @@
/* This file is part of the KDE project
Copyright (C) 2003 Ignacio Castaño <castano@ludicon.com>
/*
* Photoshop File Format support for QImage.
*
* Copyright 2003 Ignacio Castaño <castano@ludicon.com>
* Copyright 2015 Alex Merry <alex.merry@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
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
* into the public domain. See: http://tulrich.com/geekstuff/
*/
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 @@ 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;
}
}
}