PSDImageData Class Reference

#include <psd_image_data.h>

Public Member Functions
	PSDImageData (PSDHeader *header)
bool	read (QIODevice &io, KisPaintDeviceSP dev)
bool	write (QIODevice &io, KisPaintDeviceSP dev, bool hasAlpha, psd_compression_type compressionType)
virtual	~PSDImageData ()

Public Attributes
QString	error

Private Member Functions
bool	readCMYK (QIODevice &io, KisPaintDeviceSP dev)
bool	readGrayscale (QIODevice &io, KisPaintDeviceSP dev)
bool	readLAB (QIODevice &io, KisPaintDeviceSP dev)
bool	readRGB (QIODevice &io, KisPaintDeviceSP dev)

Private Attributes
quint64	m_channelDataLength {0}
QVector< ChannelInfo >	m_channelInfoRecords
QVector< int >	m_channelOffsets
quint32	m_channelSize {0}
quint16	m_compression {0}
PSDHeader *	m_header {nullptr}

Detailed Description

Definition at line 23 of file psd_image_data.h.

Constructor & Destructor Documentation

PSDImageData()

PSDImageData::PSDImageData

(

PSDHeader *

header

)

Definition at line 27 of file psd_image_data.cpp.

{
    m_header = header;
}

References m_header.

~PSDImageData()

PSDImageData::~PSDImageData ( )

virtual

Definition at line 32 of file psd_image_data.cpp.

                            {
 
}

Member Function Documentation

read()

bool PSDImageData::read	(	QIODevice &	io,
		KisPaintDeviceSP	dev )

Definition at line 36 of file psd_image_data.cpp.

{
    psdread(io, m_compression);
    quint64 start = io.pos();
    m_channelSize = m_header->channelDepth/8;
    m_channelDataLength = quint64(m_header->height) * m_header->width * m_channelSize;
 
    dbgFile << "Reading Image Data Block: compression" << m_compression << "channelsize" << m_channelSize << "number of channels" << m_header->nChannels;
 
    switch (m_compression) {
 
    case 0: // Uncompressed
 
        for (int channel = 0; channel < m_header->nChannels; channel++) {
            m_channelOffsets << 0;
            ChannelInfo channelInfo;
            channelInfo.channelId = channel;
            channelInfo.compressionType = psd_compression_type::Uncompressed;
            channelInfo.channelDataStart = start;
            channelInfo.channelDataLength = quint64(m_header->width) * m_header->height * m_channelSize;
            start += channelInfo.channelDataLength;
            m_channelInfoRecords.append(channelInfo);
 
        }
 
        break;
 
    case 1: // RLE
    {
        quint32 rlelength = 0;
 
        // The start of the actual channel data is _after_ the RLE rowlengths block
        if (m_header->version == 1) {
            start += quint64(m_header->nChannels) * m_header->height * 2;
        }
        else if (m_header->version == 2) {
            start += quint64(m_header->nChannels) * m_header->height * 4;
        }
 
        for (int channel = 0; channel < m_header->nChannels; channel++) {
            m_channelOffsets << 0;
            quint64 sumrlelength = 0;
            ChannelInfo channelInfo;
            channelInfo.channelId = channel;
            channelInfo.channelDataStart = start;
            channelInfo.compressionType = psd_compression_type::RLE;
            for (quint32 row = 0; row < m_header->height; row++ ) {
                if (m_header->version == 1) {
                    quint16 rlelength16 = 0; // use temporary variable to not cast pointers and not rely on endianness
                    psdread(io, rlelength16);
                    rlelength = rlelength16;
                }
                else if (m_header->version == 2) {
                    psdread(io, rlelength);
                }
                channelInfo.rleRowLengths.append(rlelength);
                sumrlelength += rlelength;
            }
            channelInfo.channelDataLength = sumrlelength;
            start += channelInfo.channelDataLength;
            m_channelInfoRecords.append(channelInfo);
        }
 
        break;
    }
    case 2: // ZIP without prediction
    case 3: // ZIP with prediction
    default:
        break;
    }
 
    if (!m_channelInfoRecords.isEmpty()) {
        QVector<ChannelInfo*> infoRecords;
 
        QVector<ChannelInfo>::iterator it = m_channelInfoRecords.begin();
        QVector<ChannelInfo>::iterator end = m_channelInfoRecords.end();
 
        for (; it != end; ++it) {
            infoRecords << &(*it);
        }
 
        const QRect imageRect(0, 0, m_header->width, m_header->height);
 
        try {
            PsdPixelUtils::readChannels(io, dev,
                                        m_header->colormode,
                                        m_channelSize,
                                        imageRect,
                                        infoRecords);
        } catch (KisAslReaderUtils::ASLParseException &) {
            dev->clear();
            return true;
        }
    }
 
    return true;
}

References ChannelInfo::channelDataLength, ChannelInfo::channelDataStart, PSDHeader::channelDepth, ChannelInfo::channelId, KisPaintDevice::clear(), PSDHeader::colormode, ChannelInfo::compressionType, dbgFile, PSDHeader::height, m_channelDataLength, m_channelInfoRecords, m_channelOffsets, m_channelSize, m_compression, m_header, PSDHeader::nChannels, psdread(), PsdPixelUtils::readChannels(), RLE, ChannelInfo::rleRowLengths, Uncompressed, PSDHeader::version, and PSDHeader::width.

readCMYK()

bool PSDImageData::readCMYK ( QIODevice & io, KisPaintDeviceSP dev )

private

readGrayscale()

bool PSDImageData::readGrayscale ( QIODevice & io, KisPaintDeviceSP dev )

private

readLAB()

bool PSDImageData::readLAB ( QIODevice & io, KisPaintDeviceSP dev )

private

readRGB()

bool PSDImageData::readRGB ( QIODevice & io, KisPaintDeviceSP dev )

private

write()

bool PSDImageData::write	(	QIODevice &	io,
		KisPaintDeviceSP	dev,
		bool	hasAlpha,
		psd_compression_type	compressionType )

Definition at line 134 of file psd_image_data.cpp.

{
    psdwrite(io, static_cast<quint16>(compressionType));
 
    // now write all the channels in display order
    // fill in the channel chooser, in the display order, but store the pixel index as well.
    QRect rc(0, 0, m_header->width, m_header->height);
 
    const int channelSize = m_header->channelDepth / 8;
    const psd_color_mode colorMode = m_header->colormode;
 
    QVector<PsdPixelUtils::ChannelWritingInfo> writingInfoList;
 
    bool writeAlpha = hasAlpha &&
        dev->colorSpace()->channelCount() != dev->colorSpace()->colorChannelCount();
 
    const int numChannels =
        writeAlpha ?
        dev->colorSpace()->channelCount() :
        dev->colorSpace()->colorChannelCount();
 
    for (int i = 0; i < numChannels; i++) {
        const int rleOffset = io.pos();
 
        int channelId = writeAlpha && i == numChannels - 1 ? -1 : i;
 
        writingInfoList <<
            PsdPixelUtils::ChannelWritingInfo(channelId, -1, rleOffset);
 
        io.seek(io.pos() + rc.height() * sizeof(quint16));
    }
 
    PsdPixelUtils::writePixelDataCommon(io, dev, rc, colorMode, channelSize, false, false, writingInfoList, compressionType);
    return true;
}

References KoColorSpace::channelCount(), PSDHeader::channelDepth, KoColorSpace::colorChannelCount(), PSDHeader::colormode, KisPaintDevice::colorSpace(), PSDHeader::height, m_header, psdwrite(), PSDHeader::width, and PsdPixelUtils::writePixelDataCommon().

Member Data Documentation

error

QString PSDImageData::error

Definition at line 33 of file psd_image_data.h.

m_channelDataLength

quint64 PSDImageData::m_channelDataLength {0}

private

Definition at line 44 of file psd_image_data.h.

{0};

m_channelInfoRecords

QVector<ChannelInfo> PSDImageData::m_channelInfoRecords

private

Definition at line 47 of file psd_image_data.h.

m_channelOffsets

QVector<int> PSDImageData::m_channelOffsets

private

Definition at line 48 of file psd_image_data.h.

m_channelSize

quint32 PSDImageData::m_channelSize {0}

private

Definition at line 45 of file psd_image_data.h.

{0};

m_compression

quint16 PSDImageData::m_compression {0}

private

Definition at line 43 of file psd_image_data.h.

{0};

m_header

PSDHeader* PSDImageData::m_header {nullptr}

private

Definition at line 41 of file psd_image_data.h.

{nullptr};

---

The documentation for this class was generated from the following files:

• plugins/impex/psd/psd_image_data.h
• plugins/impex/psd/psd_image_data.cpp