PsdPixelUtils Namespace Reference

Classes
struct	ChannelWritingInfo

Typedefs
using	PixelFunc = std::function<void(int, const QMap<quint16, QByteArray> &, int, quint8 *)>

Functions
template<class Traits >
Traits::channels_type	convertByteOrder (typename Traits::channels_type value)
template<>
float	convertByteOrder< AlphaF32Traits > (float value)
template<>
quint16	convertByteOrder< AlphaU16Traits > (quint16 value)
template<>
quint8	convertByteOrder< AlphaU8Traits > (quint8 value)
template<>
quint16	convertByteOrder< KoBgrU16Traits > (quint16 value)
template<>
quint32	convertByteOrder< KoBgrU32Traits > (quint32 value)
template<>
quint8	convertByteOrder< KoBgrU8Traits > (quint8 value)
template<>
float	convertByteOrder< KoCmykF32Traits > (float value)
template<>
quint16	convertByteOrder< KoCmykU16Traits > (quint16 value)
template<>
quint8	convertByteOrder< KoCmykU8Traits > (quint8 value)
template<>
quint16	convertByteOrder< KoGrayU16Traits > (quint16 value)
template<>
quint32	convertByteOrder< KoGrayU32Traits > (quint32 value)
template<>
quint8	convertByteOrder< KoGrayU8Traits > (quint8 value)
template<>
float	convertByteOrder< KoLabF32Traits > (float value)
template<>
quint16	convertByteOrder< KoLabU16Traits > (quint16 value)
template<>
quint8	convertByteOrder< KoLabU8Traits > (quint8 value)
QMap< quint16, QByteArray >	fetchChannelsBytes (QIODevice &io, QVector< ChannelInfo * > channelInfoRecords, int row, int width, int channelSize, bool processMasks)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	preparePixelForWrite (quint8 *dataPlane, int numPixels, int channelSize, int channelId, psd_color_mode colorMode)
void	readAlphaMaskChannels (QIODevice &io, KisPaintDeviceSP device, int channelSize, const QRect &layerRect, QVector< ChannelInfo * > infoRecords, psd_byte_order byteOrder)
template<psd_byte_order byteOrder>
void	readAlphaMaskChannelsImpl (QIODevice &io, KisPaintDeviceSP device, int channelSize, const QRect &layerRect, QVector< ChannelInfo * > infoRecords)
template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	readAlphaMaskPixel (const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<psd_byte_order byteOrder>
void	readAlphaMaskPixelCommon (int channelSize, const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
void	readChannels (QIODevice &io, KisPaintDeviceSP device, psd_color_mode colorMode, int channelSize, const QRect &layerRect, QVector< ChannelInfo * > infoRecords, psd_byte_order byteOrder)
template<psd_byte_order byteOrder>
void	readChannelsImpl (QIODevice &io, KisPaintDeviceSP device, psd_color_mode colorMode, int channelSize, const QRect &layerRect, QVector< ChannelInfo * > infoRecords)
template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
Traits::channels_type	readChannelValue (const QMap< quint16, QByteArray > &channelBytes, quint16 channelId, int col, typename Traits::channels_type defaultValue)
template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	readCmykPixel (const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<psd_byte_order byteOrder>
void	readCmykPixelCommon (int channelSize, const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
void	readCommon (KisPaintDeviceSP dev, QIODevice &io, const QRect &layerRect, QVector< ChannelInfo * > infoRecords, int channelSize, PixelFunc pixelFunc, bool processMasks)
template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	readGrayPixel (const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<psd_byte_order byteOrder>
void	readGrayPixelCommon (int channelSize, const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	readLabPixel (const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<psd_byte_order byteOrder>
void	readLabPixelCommon (int channelSize, const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	readRgbPixel (const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<psd_byte_order byteOrder>
void	readRgbPixelCommon (int channelSize, const QMap< quint16, QByteArray > &channelBytes, int col, quint8 *dstPtr)
template<class Traits >
quint8	truncateToOpacity (typename Traits::channels_type value)
template<>
quint8	truncateToOpacity< AlphaF32Traits > (typename AlphaF32Traits::channels_type value)
template<>
quint8	truncateToOpacity< AlphaU16Traits > (typename AlphaU16Traits::channels_type value)
template<>
quint8	truncateToOpacity< AlphaU8Traits > (typename AlphaU8Traits::channels_type value)
void	writeChannelDataRLE (QIODevice &io, const quint8 *plane, const int channelSize, const QRect &rc, const qint64 sizeFieldOffset, const qint64 rleBlockOffset, const bool writeCompressionType, psd_byte_order byteOrder)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	writeChannelDataRLEImpl (QIODevice &io, const quint8 *plane, const int channelSize, const QRect &rc, const qint64 sizeFieldOffset, const qint64 rleBlockOffset, const bool writeCompressionType)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	writeChannelDataZIPImpl (QIODevice &io, const quint8 *plane, const int channelSize, const QRect &rc, const qint64 sizeFieldOffset, const bool writeCompressionType)
void	writePixelDataCommon (QIODevice &io, KisPaintDeviceSP dev, const QRect &rc, psd_color_mode colorMode, int channelSize, bool alphaFirst, const bool writeCompressionType, QVector< ChannelWritingInfo > &writingInfoList, psd_compression_type compressionType, psd_byte_order byteOrder)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	writePixelDataCommonImpl (QIODevice &io, KisPaintDeviceSP dev, const QRect &rc, psd_color_mode colorMode, int channelSize, bool alphaFirst, const bool writeCompressionType, QVector< ChannelWritingInfo > &writingInfoList, psd_compression_type compressionType)

Typedef Documentation

PixelFunc

using PsdPixelUtils::PixelFunc = std::function<void(int, const QMap<quint16, QByteArray> &, int, quint8 *)>

Definition at line 334 of file psd_pixel_utils.cpp.

Function Documentation

convertByteOrder()

template<class Traits >

Traits::channels_type PsdPixelUtils::convertByteOrder

(

typename Traits::channels_type

value

)

convertByteOrder< AlphaF32Traits >()

template<>

float PsdPixelUtils::convertByteOrder< AlphaF32Traits > ( float value )

inline

Definition at line 48 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint32)value);
}

References value().

convertByteOrder< AlphaU16Traits >()

template<>

quint16 PsdPixelUtils::convertByteOrder< AlphaU16Traits > ( quint16 value )

inline

Definition at line 42 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint16)value);
}

References value().

convertByteOrder< AlphaU8Traits >()

template<>

quint8 PsdPixelUtils::convertByteOrder< AlphaU8Traits > ( quint8 value )

inline

Definition at line 36 of file psd_pixel_utils.cpp.

{
    return value;
}

References value().

convertByteOrder< KoBgrU16Traits >()

template<>

quint16 PsdPixelUtils::convertByteOrder< KoBgrU16Traits > ( quint16 value )

inline

Definition at line 78 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint16)value);
}

References value().

convertByteOrder< KoBgrU32Traits >()

template<>

quint32 PsdPixelUtils::convertByteOrder< KoBgrU32Traits > ( quint32 value )

inline

Definition at line 84 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint32)value);
}

References value().

convertByteOrder< KoBgrU8Traits >()

template<>

quint8 PsdPixelUtils::convertByteOrder< KoBgrU8Traits > ( quint8 value )

inline

Definition at line 72 of file psd_pixel_utils.cpp.

{
    return value;
}

References value().

convertByteOrder< KoCmykF32Traits >()

template<>

float PsdPixelUtils::convertByteOrder< KoCmykF32Traits > ( float value )

inline

Definition at line 102 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint32)value);
}

References value().

convertByteOrder< KoCmykU16Traits >()

template<>

quint16 PsdPixelUtils::convertByteOrder< KoCmykU16Traits > ( quint16 value )

inline

Definition at line 96 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint16)value);
}

References value().

convertByteOrder< KoCmykU8Traits >()

template<>

quint8 PsdPixelUtils::convertByteOrder< KoCmykU8Traits > ( quint8 value )

inline

Definition at line 90 of file psd_pixel_utils.cpp.

{
    return value;
}

References value().

convertByteOrder< KoGrayU16Traits >()

template<>

quint16 PsdPixelUtils::convertByteOrder< KoGrayU16Traits > ( quint16 value )

inline

Definition at line 60 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint16)value);
}

References value().

convertByteOrder< KoGrayU32Traits >()

template<>

quint32 PsdPixelUtils::convertByteOrder< KoGrayU32Traits > ( quint32 value )

inline

Definition at line 66 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint32)value);
}

References value().

convertByteOrder< KoGrayU8Traits >()

template<>

quint8 PsdPixelUtils::convertByteOrder< KoGrayU8Traits > ( quint8 value )

inline

Definition at line 54 of file psd_pixel_utils.cpp.

{
    return value;
}

References value().

convertByteOrder< KoLabF32Traits >()

template<>

float PsdPixelUtils::convertByteOrder< KoLabF32Traits > ( float value )

inline

Definition at line 120 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint32)value);
}

References value().

convertByteOrder< KoLabU16Traits >()

template<>

quint16 PsdPixelUtils::convertByteOrder< KoLabU16Traits > ( quint16 value )

inline

Definition at line 114 of file psd_pixel_utils.cpp.

{
    return qFromBigEndian((quint16)value);
}

References value().

convertByteOrder< KoLabU8Traits >()

template<>

quint8 PsdPixelUtils::convertByteOrder< KoLabU8Traits > ( quint8 value )

inline

Definition at line 108 of file psd_pixel_utils.cpp.

{
    return value;
}

References value().

fetchChannelsBytes()

QMap< quint16, QByteArray > PsdPixelUtils::fetchChannelsBytes	(	QIODevice &	io,
		QVector< ChannelInfo * >	channelInfoRecords,
		int	row,
		int	width,
		int	channelSize,
		bool	processMasks )

Definition at line 301 of file psd_pixel_utils.cpp.

{
    const int uncompressedLength = width * channelSize;
 
    QMap<quint16, QByteArray> channelBytes;
 
    Q_FOREACH (ChannelInfo *channelInfo, channelInfoRecords) {
        // user supplied masks are ignored here
        if (!processMasks && channelInfo->channelId < -1)
            continue;
 
        io.seek(channelInfo->channelDataStart + channelInfo->channelOffset);
 
        if (channelInfo->compressionType == psd_compression_type::Uncompressed) {
            channelBytes[channelInfo->channelId] = io.read(uncompressedLength);
            channelInfo->channelOffset += uncompressedLength;
        } else if (channelInfo->compressionType == psd_compression_type::RLE) {
            int rleLength = channelInfo->rleRowLengths[row];
            QByteArray compressedBytes = io.read(rleLength);
            QByteArray uncompressedBytes = Compression::uncompress(uncompressedLength, compressedBytes, channelInfo->compressionType);
            channelBytes.insert(channelInfo->channelId, uncompressedBytes);
            channelInfo->channelOffset += rleLength;
        } else {
            QString error = QString("Unsupported Compression mode: %1")
                                .arg(static_cast<std::uint16_t>(channelInfo->compressionType));
            dbgFile << "ERROR: fetchChannelsBytes:" << error;
            throw KisAslReaderUtils::ASLParseException(error);
        }
    }
 
    return channelBytes;
}

References ChannelInfo::channelDataStart, ChannelInfo::channelId, ChannelInfo::channelOffset, ChannelInfo::compressionType, dbgFile, RLE, ChannelInfo::rleRowLengths, Compression::uncompress(), and Uncompressed.

preparePixelForWrite()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::preparePixelForWrite ( quint8 * dataPlane, int numPixels, int channelSize, int channelId, psd_color_mode colorMode )

inline

Definition at line 573 of file psd_pixel_utils.cpp.

{
    // if the bitdepth > 8, place the bytes in the right order
    // if cmyk, invert the pixel value
    if (channelSize == 1) {
        if (channelId >= 0 && (colorMode == CMYK || colorMode == CMYK64)) {
            for (int i = 0; i < numPixels; ++i) {
                dataPlane[i] = 255 - dataPlane[i];
            }
        }
    } else if (channelSize == 2) {
        quint16 val;
        for (int i = 0; i < numPixels; ++i) {
            quint16 *pixelPtr = reinterpret_cast<quint16 *>(dataPlane) + i;
 
            val = *pixelPtr;
            if (byteOrder == psd_byte_order::psdBigEndian)
                val = qFromBigEndian(val);
            if (channelId >= 0 && (colorMode == CMYK || colorMode == CMYK64)) {
                val = quint16_MAX - val;
            }
            *pixelPtr = val;
        }
    } else if (channelSize == 4) {
        quint32 val;
        for (int i = 0; i < numPixels; ++i) {
            quint32 *pixelPtr = reinterpret_cast<quint32 *>(dataPlane) + i;
 
            val = *pixelPtr;
            if (byteOrder == psd_byte_order::psdBigEndian)
                val = qFromBigEndian(val);
            if (channelId >= 0 && (colorMode == CMYK || colorMode == CMYK64)) {
                val = std::numeric_limits<quint32>::max() - val;
            }
            *pixelPtr = val;
        }
    }
}

References CMYK, CMYK64, psdBigEndian, and quint16_MAX.

readAlphaMaskChannels()

void KRITAPSD_EXPORT PsdPixelUtils::readAlphaMaskChannels	(	QIODevice &	io,
		KisPaintDeviceSP	device,
		int	channelSize,
		const QRect &	layerRect,
		QVector< ChannelInfo * >	infoRecords,
		psd_byte_order	byteOrder )

Definition at line 461 of file psd_pixel_utils.cpp.

{
    switch (byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return readAlphaMaskChannelsImpl<psd_byte_order::psdLittleEndian>(io, device, channelSize, layerRect, infoRecords);
    default:
        return readAlphaMaskChannelsImpl<psd_byte_order::psdBigEndian>(io, device, channelSize, layerRect, infoRecords);
    }
}

References psdLittleEndian.

readAlphaMaskChannelsImpl()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readAlphaMaskChannelsImpl	(	QIODevice &	io,
		KisPaintDeviceSP	device,
		int	channelSize,
		const QRect &	layerRect,
		QVector< ChannelInfo * >	infoRecords )

Definition at line 455 of file psd_pixel_utils.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(infoRecords.size() == 1);
    readCommon(device, io, layerRect, infoRecords, channelSize, &readAlphaMaskPixelCommon<byteOrder>, true);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, and readCommon().

readAlphaMaskPixel()

template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::readAlphaMaskPixel	(	const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 147 of file psd_pixel_utils.cpp.

{
    using channels_type = typename Traits::channels_type;
 
    const channels_type data = reinterpret_cast<const channels_type *>(channelBytes.first().constData())[col];
    if (byteOrder == psd_byte_order::psdBigEndian) {
        *dstPtr = truncateToOpacity<Traits>(convertByteOrder<Traits>(data));
    } else {
        *dstPtr = truncateToOpacity<Traits>(data);
    }
}

References psdBigEndian.

readAlphaMaskPixelCommon()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readAlphaMaskPixelCommon	(	int	channelSize,
		const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 290 of file psd_pixel_utils.cpp.

{
    if (channelSize == 1) {
        readAlphaMaskPixel<AlphaU8Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 2) {
        readAlphaMaskPixel<AlphaU16Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 4) {
        readAlphaMaskPixel<AlphaF32Traits, byteOrder>(channelBytes, col, dstPtr);
    }
}

readChannels()

void KRITAPSD_EXPORT PsdPixelUtils::readChannels	(	QIODevice &	io,
		KisPaintDeviceSP	device,
		psd_color_mode	colorMode,
		int	channelSize,
		const QRect &	layerRect,
		QVector< ChannelInfo * >	infoRecords,
		psd_byte_order	byteOrder )

Definition at line 438 of file psd_pixel_utils.cpp.

{
    switch (byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return readChannelsImpl<psd_byte_order::psdLittleEndian>(io, device, colorMode, channelSize, layerRect, infoRecords);
    default:
        return readChannelsImpl<psd_byte_order::psdBigEndian>(io, device, colorMode, channelSize, layerRect, infoRecords);
    }
}

References psdLittleEndian.

readChannelsImpl()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readChannelsImpl	(	QIODevice &	io,
		KisPaintDeviceSP	device,
		psd_color_mode	colorMode,
		int	channelSize,
		const QRect &	layerRect,
		QVector< ChannelInfo * >	infoRecords )

Definition at line 407 of file psd_pixel_utils.cpp.

{
    switch (colorMode) {
    case Grayscale:
        readCommon(device, io, layerRect, infoRecords, channelSize, &readGrayPixelCommon<byteOrder>, false);
        break;
    case RGB:
        readCommon(device, io, layerRect, infoRecords, channelSize, &readRgbPixelCommon<byteOrder>, false);
        break;
    case CMYK:
        readCommon(device, io, layerRect, infoRecords, channelSize, &readCmykPixelCommon<byteOrder>, false);
        break;
    case Lab:
        readCommon(device, io, layerRect, infoRecords, channelSize, &readLabPixelCommon<byteOrder>, false);
        break;
    case Bitmap:
    case Indexed:
    case MultiChannel:
    case DuoTone:
    case COLORMODE_UNKNOWN:
    default:
        QString error = QString("Unsupported color mode: %1").arg(colorMode);
        throw KisAslReaderUtils::ASLParseException(error);
    }
}

References Bitmap, CMYK, COLORMODE_UNKNOWN, DuoTone, Grayscale, Indexed, Lab, MultiChannel, readCommon(), and RGB.

readChannelValue()

template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

Traits::channels_type PsdPixelUtils::readChannelValue ( const QMap< quint16, QByteArray > & channelBytes, quint16 channelId, int col, typename Traits::channels_type defaultValue )

inline

Definition at line 161 of file psd_pixel_utils.cpp.

{
    using channels_type = typename Traits::channels_type;
 
    if (channelBytes.contains(channelId)) {
        const QByteArray &bytes = channelBytes[channelId];
        if (col < bytes.size()) {
            const channels_type data = reinterpret_cast<const channels_type *>(bytes.constData())[col];
            if (byteOrder == psd_byte_order::psdBigEndian) {
                return convertByteOrder<Traits>(data);
            } else {
                return data;
            }
        }
 
        dbgFile << "col index out of range channelId: " << channelId << " col:" << col;
    }
 
    return defaultValue;
}

References dbgFile, and psdBigEndian.

readCmykPixel()

template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::readCmykPixel	(	const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 211 of file psd_pixel_utils.cpp.

{
    using Pixel = typename Traits::Pixel;
    using channels_type = typename Traits::channels_type;
 
    const channels_type unitValue = KoColorSpaceMathsTraits<channels_type>::unitValue;
    Pixel *pixelPtr = reinterpret_cast<Pixel *>(dstPtr);
 
    pixelPtr->cyan = unitValue - readChannelValue<Traits, byteOrder>(channelBytes, 0, col, unitValue);
    pixelPtr->magenta = unitValue - readChannelValue<Traits, byteOrder>(channelBytes, 1, col, unitValue);
    pixelPtr->yellow = unitValue - readChannelValue<Traits, byteOrder>(channelBytes, 2, col, unitValue);
    pixelPtr->black = unitValue - readChannelValue<Traits, byteOrder>(channelBytes, 3, col, unitValue);
    pixelPtr->alpha = readChannelValue<Traits, byteOrder>(channelBytes, -1, col, unitValue);
}

readCmykPixelCommon()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readCmykPixelCommon	(	int	channelSize,
		const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 266 of file psd_pixel_utils.cpp.

{
    if (channelSize == 1) {
        readCmykPixel<KoCmykU8Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 2) {
        readCmykPixel<KoCmykU16Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 4) {
        readCmykPixel<KoCmykF32Traits, byteOrder>(channelBytes, col, dstPtr);
    }
}

readCommon()

void PsdPixelUtils::readCommon	(	KisPaintDeviceSP	dev,
		QIODevice &	io,
		const QRect &	layerRect,
		QVector< ChannelInfo * >	infoRecords,
		int	channelSize,
		PixelFunc	pixelFunc,
		bool	processMasks )

don't write-access the row right after the the end of the read area

Definition at line 336 of file psd_pixel_utils.cpp.

{
    KisOffsetKeeper keeper(io);
 
    if (layerRect.isEmpty()) {
        dbgFile << "Empty layer!";
        return;
    }
 
    if (infoRecords.first()->compressionType == psd_compression_type::ZIP || infoRecords.first()->compressionType == psd_compression_type::ZIPWithPrediction) {
        const int numPixels = channelSize * layerRect.width() * layerRect.height();
 
        QMap<quint16, QByteArray> channelBytes;
 
        Q_FOREACH (ChannelInfo *info, infoRecords) {
            io.seek(info->channelDataStart);
            QByteArray compressedBytes = io.read(info->channelDataLength);
            QByteArray uncompressedBytes;
 
            uncompressedBytes = Compression::uncompress(numPixels, compressedBytes, infoRecords.first()->compressionType, layerRect.width(), channelSize * 8);
 
            if (uncompressedBytes.size() != numPixels) {
                QString error = QString("Failed to unzip channel data: id = %1, compression = %2")
                                    .arg(info->channelId)
                                    .arg(static_cast<std::uint16_t>(info->compressionType));
                dbgFile << "ERROR:" << error;
                dbgFile << "      " << ppVar(info->channelId);
                dbgFile << "      " << ppVar(info->channelDataStart);
                dbgFile << "      " << ppVar(info->channelDataLength);
                dbgFile << "      " << ppVar(info->compressionType);
                throw KisAslReaderUtils::ASLParseException(error);
            }
 
            channelBytes.insert(info->channelId, uncompressedBytes);
        }
 
        KisSequentialIterator it(dev, layerRect);
        int col = 0;
        while (it.nextPixel()) {
            pixelFunc(channelSize, channelBytes, col, it.rawData());
            col++;
        }
 
    } else {
        KisHLineIteratorSP it = dev->createHLineIteratorNG(layerRect.left(), layerRect.top(), layerRect.width());
        for (int i = 0; i < layerRect.height(); i++) {
            QMap<quint16, QByteArray> channelBytes;
 
            channelBytes = fetchChannelsBytes(io, infoRecords, i, layerRect.width(), channelSize, processMasks);
 
            for (int col = 0; col < layerRect.width(); col++) {
                pixelFunc(channelSize, channelBytes, col, it->rawData());
                it->nextPixel();
            }
 
            if (i < layerRect.height() - 1) {
                it->nextRow();
            }
        }
    }
}

References ChannelInfo::channelDataLength, ChannelInfo::channelDataStart, ChannelInfo::channelId, ChannelInfo::compressionType, KisPaintDevice::createHLineIteratorNG(), dbgFile, fetchChannelsBytes(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), ppVar, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), Compression::uncompress(), ZIP, and ZIPWithPrediction.

readGrayPixel()

template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::readGrayPixel	(	const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 183 of file psd_pixel_utils.cpp.

{
    using Pixel = typename Traits::Pixel;
    using channels_type = typename Traits::channels_type;
 
    const channels_type unitValue = KoColorSpaceMathsTraits<channels_type>::unitValue;
    Pixel *pixelPtr = reinterpret_cast<Pixel *>(dstPtr);
 
    pixelPtr->gray = readChannelValue<Traits, byteOrder>(channelBytes, 0, col, unitValue);
    pixelPtr->alpha = readChannelValue<Traits, byteOrder>(channelBytes, -1, col, unitValue);
}

readGrayPixelCommon()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readGrayPixelCommon	(	int	channelSize,
		const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 254 of file psd_pixel_utils.cpp.

{
    if (channelSize == 1) {
        readGrayPixel<KoGrayU8Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 2) {
        readGrayPixel<KoGrayU16Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 4) {
        readGrayPixel<KoGrayU32Traits, byteOrder>(channelBytes, col, dstPtr);
    }
}

readLabPixel()

template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::readLabPixel	(	const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 227 of file psd_pixel_utils.cpp.

{
    using Pixel = typename Traits::Pixel;
    using channels_type = typename Traits::channels_type;
 
    const channels_type unitValue = KoColorSpaceMathsTraits<channels_type>::unitValue;
    Pixel *pixelPtr = reinterpret_cast<Pixel *>(dstPtr);
 
    pixelPtr->L = readChannelValue<Traits, byteOrder>(channelBytes, 0, col, unitValue);
    pixelPtr->a = readChannelValue<Traits, byteOrder>(channelBytes, 1, col, unitValue);
    pixelPtr->b = readChannelValue<Traits, byteOrder>(channelBytes, 2, col, unitValue);
    pixelPtr->alpha = readChannelValue<Traits, byteOrder>(channelBytes, -1, col, unitValue);
}

readLabPixelCommon()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readLabPixelCommon	(	int	channelSize,
		const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 278 of file psd_pixel_utils.cpp.

{
    if (channelSize == 1) {
        readLabPixel<KoLabU8Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 2) {
        readLabPixel<KoLabU16Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 4) {
        readLabPixel<KoLabF32Traits, byteOrder>(channelBytes, col, dstPtr);
    }
}

readRgbPixel()

template<class Traits , psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::readRgbPixel	(	const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 196 of file psd_pixel_utils.cpp.

{
    using Pixel = typename Traits::Pixel;
    using channels_type = typename Traits::channels_type;
 
    const channels_type unitValue = KoColorSpaceMathsTraits<channels_type>::unitValue;
    Pixel *pixelPtr = reinterpret_cast<Pixel *>(dstPtr);
 
    pixelPtr->blue = readChannelValue<Traits, byteOrder>(channelBytes, 2, col, unitValue);
    pixelPtr->green = readChannelValue<Traits, byteOrder>(channelBytes, 1, col, unitValue);
    pixelPtr->red = readChannelValue<Traits, byteOrder>(channelBytes, 0, col, unitValue);
    pixelPtr->alpha = readChannelValue<Traits, byteOrder>(channelBytes, -1, col, unitValue);
}

readRgbPixelCommon()

template<psd_byte_order byteOrder>

void PsdPixelUtils::readRgbPixelCommon	(	int	channelSize,
		const QMap< quint16, QByteArray > &	channelBytes,
		int	col,
		quint8 *	dstPtr )

Definition at line 242 of file psd_pixel_utils.cpp.

{
    if (channelSize == 1) {
        readRgbPixel<KoBgrU8Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 2) {
        readRgbPixel<KoBgrU16Traits, byteOrder>(channelBytes, col, dstPtr);
    } else if (channelSize == 4) {
        readRgbPixel<KoBgrU16Traits, byteOrder>(channelBytes, col, dstPtr);
    }
}

truncateToOpacity()

template<class Traits >

quint8 PsdPixelUtils::truncateToOpacity ( typename Traits::channels_type value )

inline

truncateToOpacity< AlphaF32Traits >()

template<>

quint8 PsdPixelUtils::truncateToOpacity< AlphaF32Traits > ( typename AlphaF32Traits::channels_type value )

inline

Definition at line 141 of file psd_pixel_utils.cpp.

{
    return static_cast<quint8>(value * 255U);
}

References value().

truncateToOpacity< AlphaU16Traits >()

template<>

quint8 PsdPixelUtils::truncateToOpacity< AlphaU16Traits > ( typename AlphaU16Traits::channels_type value )

inline

Definition at line 135 of file psd_pixel_utils.cpp.

{
    return value >> 8;
}

References value().

truncateToOpacity< AlphaU8Traits >()

template<>

quint8 PsdPixelUtils::truncateToOpacity< AlphaU8Traits > ( typename AlphaU8Traits::channels_type value )

inline

Definition at line 129 of file psd_pixel_utils.cpp.

{
    return value;
}

References value().

writeChannelDataRLE()

void KRITAPSD_EXPORT PsdPixelUtils::writeChannelDataRLE	(	QIODevice &	io,
		const quint8 *	plane,
		const int	channelSize,
		const QRect &	rc,
		const qint64	sizeFieldOffset,
		const qint64	rleBlockOffset,
		const bool	writeCompressionType,
		psd_byte_order	byteOrder )

Definition at line 555 of file psd_pixel_utils.cpp.

{
    switch (byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return writeChannelDataRLEImpl<psd_byte_order::psdLittleEndian>(io, plane, channelSize, rc, sizeFieldOffset, rleBlockOffset, writeCompressionType);
    default:
        return writeChannelDataRLEImpl(io, plane, channelSize, rc, sizeFieldOffset, rleBlockOffset, writeCompressionType);
    }
}

References psdLittleEndian, and writeChannelDataRLEImpl().

writeChannelDataRLEImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::writeChannelDataRLEImpl	(	QIODevice &	io,
		const quint8 *	plane,
		const int	channelSize,
		const QRect &	rc,
		const qint64	sizeFieldOffset,
		const qint64	rleBlockOffset,
		const bool	writeCompressionType )

Definition at line 477 of file psd_pixel_utils.cpp.

{
    using Pusher = KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder>;
    QScopedPointer<Pusher> channelBlockSizeExternalTag;
    if (sizeFieldOffset >= 0) {
        channelBlockSizeExternalTag.reset(new Pusher(io, 0, sizeFieldOffset));
    }
 
    if (writeCompressionType) {
        SAFE_WRITE_EX(byteOrder, io, static_cast<quint16>(psd_compression_type::RLE));
    }
 
    const bool externalRleBlock = rleBlockOffset >= 0;
 
    // the start of RLE sizes block
    const qint64 channelRLESizePos = externalRleBlock ? rleBlockOffset : io.pos();
 
    {
        QScopedPointer<KisOffsetKeeper> rleOffsetKeeper;
 
        if (externalRleBlock) {
            rleOffsetKeeper.reset(new KisOffsetKeeper(io));
            io.seek(rleBlockOffset);
        }
 
        // write zero's for the channel lengths block
        for (int i = 0; i < rc.height(); ++i) {
            // XXX: choose size for PSB!
            const quint16 fakeRLEBLockSize = 0;
            SAFE_WRITE_EX(byteOrder, io, fakeRLEBLockSize);
        }
    }
 
    const int stride = channelSize * rc.width();
    for (qint32 row = 0; row < rc.height(); ++row) {
        QByteArray uncompressed = QByteArray::fromRawData((const char *)plane + row * stride, stride);
        QByteArray compressed = Compression::compress(uncompressed, psd_compression_type::RLE);
 
        KisAslWriterUtils::OffsetStreamPusher<quint16, byteOrder> rleExternalTag(io, 0, channelRLESizePos + row * static_cast<qint64>(sizeof(quint16)));
 
        if (io.write(compressed) != compressed.size()) {
            throw KisAslWriterUtils::ASLWriteException("Failed to write image data");
        }
    }
}

References Compression::compress(), RLE, and SAFE_WRITE_EX.

writeChannelDataZIPImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::writeChannelDataZIPImpl	(	QIODevice &	io,
		const quint8 *	plane,
		const int	channelSize,
		const QRect &	rc,
		const qint64	sizeFieldOffset,
		const bool	writeCompressionType )

Definition at line 530 of file psd_pixel_utils.cpp.

{
    using Pusher = KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder>;
    QScopedPointer<Pusher> channelBlockSizeExternalTag;
    if (sizeFieldOffset >= 0) {
        channelBlockSizeExternalTag.reset(new Pusher(io, 0, sizeFieldOffset));
    }
 
    if (writeCompressionType) {
        SAFE_WRITE_EX(byteOrder, io, static_cast<quint16>(psd_compression_type::ZIP));
    }
 
    QByteArray uncompressed(reinterpret_cast<const char *>(plane), rc.width() * rc.height() * channelSize);
    QByteArray compressed(Compression::compress(uncompressed, psd_compression_type::ZIP));
 
    if (compressed.size() == 0 || io.write(compressed) != compressed.size()) {
        throw KisAslWriterUtils::ASLWriteException("Failed to write image data");
    }
}

References Compression::compress(), SAFE_WRITE_EX, and ZIP.

writePixelDataCommon()

void KRITAPSD_EXPORT PsdPixelUtils::writePixelDataCommon	(	QIODevice &	io,
		KisPaintDeviceSP	dev,
		const QRect &	rc,
		psd_color_mode	colorMode,
		int	channelSize,
		bool	alphaFirst,
		const bool	writeCompressionType,
		QVector< ChannelWritingInfo > &	writingInfoList,
		psd_compression_type	compressionType,
		psd_byte_order	byteOrder )

Definition at line 709 of file psd_pixel_utils.cpp.

{
    switch (byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return writePixelDataCommonImpl<psd_byte_order::psdLittleEndian>(io,
                                                                         dev,
                                                                         rc,
                                                                         colorMode,
                                                                         channelSize,
                                                                         alphaFirst,
                                                                         writeCompressionType,
                                                                         writingInfoList,
                                                                         compressionType);
    default:
        return writePixelDataCommonImpl(io, dev, rc, colorMode, channelSize, alphaFirst, writeCompressionType, writingInfoList, compressionType);
    }
}

References psdLittleEndian, and writePixelDataCommonImpl().

writePixelDataCommonImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>

void PsdPixelUtils::writePixelDataCommonImpl	(	QIODevice &	io,
		KisPaintDeviceSP	dev,
		const QRect &	rc,
		psd_color_mode	colorMode,
		int	channelSize,
		bool	alphaFirst,
		const bool	writeCompressionType,
		QVector< ChannelWritingInfo > &	writingInfoList,
		psd_compression_type	compressionType )

Definition at line 613 of file psd_pixel_utils.cpp.

{
    // Empty rects must be processed separately on a higher level!
    KIS_ASSERT_RECOVER_RETURN(!rc.isEmpty());
 
    QVector<quint8 *> tmp = dev->readPlanarBytes(rc.x() - dev->x(), rc.y() - dev->y(), rc.width(), rc.height());
    const KoColorSpace *colorSpace = dev->colorSpace();
 
    QVector<quint8 *> planes;
 
    { // prepare 'planes' array
 
        quint8 *alphaPlanePtr = 0;
 
        const QList<KoChannelInfo *> origChannels = colorSpace->channels();
        Q_FOREACH (KoChannelInfo *ch, KoChannelInfo::displayOrderSorted(origChannels)) {
            int channelIndex = KoChannelInfo::displayPositionToChannelIndex(ch->displayPosition(), origChannels);
 
            quint8 *holder = 0;
            std::swap(holder, tmp[channelIndex]);
 
            if (ch->channelType() == KoChannelInfo::ALPHA) {
                std::swap(holder, alphaPlanePtr);
            } else {
                planes.append(holder);
            }
        }
 
        if (alphaPlanePtr) {
            if (alphaFirst) {
                planes.insert(0, alphaPlanePtr);
                KIS_ASSERT_RECOVER_NOOP(writingInfoList.first().channelId == -1);
            } else {
                planes.append(alphaPlanePtr);
                KIS_ASSERT_RECOVER_NOOP((writingInfoList.size() == planes.size() - 1) || (writingInfoList.last().channelId == -1));
            }
        }
 
        // now planes are holding pointers to quint8 arrays
        tmp.clear();
    }
 
    KIS_ASSERT_RECOVER_RETURN(planes.size() >= writingInfoList.size());
 
    const int numPixels = rc.width() * rc.height();
 
    // write down the planes
 
    try {
        for (int i = 0; i < writingInfoList.size(); i++) {
            const ChannelWritingInfo &info = writingInfoList[i];
 
            dbgFile << "\tWriting channel" << i << "psd channel id" << info.channelId;
 
            // WARNING: Pixel data is ALWAYS in big endian!!!
            preparePixelForWrite<psd_byte_order::psdBigEndian>(planes[i], numPixels, channelSize, info.channelId, colorMode);
 
            dbgFile << "\t\tchannel start" << ppVar(io.pos()) << ", compression type" << compressionType;
 
            switch (compressionType) {
            case psd_compression_type::ZIP:
            case psd_compression_type::ZIPWithPrediction: {
                writeChannelDataZIPImpl<byteOrder>(io, planes[i], channelSize, rc, info.sizeFieldOffset, writeCompressionType);
                break;
            }
            case psd_compression_type::RLE:
            default: {
                writeChannelDataRLEImpl<byteOrder>(io, planes[i], channelSize, rc, info.sizeFieldOffset, info.rleBlockOffset, writeCompressionType);
                break;
            }
            }
        }
 
    } catch (KisAslWriterUtils::ASLWriteException &e) {
        Q_FOREACH (quint8 *plane, planes) {
            delete[] plane;
        }
        planes.clear();
 
        throw KisAslWriterUtils::ASLWriteException(PREPEND_METHOD(e.what()));
    }
 
    Q_FOREACH (quint8 *plane, planes) {
        delete[] plane;
    }
    planes.clear();
}

References KoChannelInfo::ALPHA, PsdPixelUtils::ChannelWritingInfo::channelId, KoColorSpace::channels, KoChannelInfo::channelType(), KisPaintDevice::colorSpace(), dbgFile, KoChannelInfo::displayOrderSorted(), KoChannelInfo::displayPosition(), KoChannelInfo::displayPositionToChannelIndex(), KIS_ASSERT_RECOVER_NOOP, KIS_ASSERT_RECOVER_RETURN, ppVar, PREPEND_METHOD, KisPaintDevice::readPlanarBytes(), RLE, PsdPixelUtils::ChannelWritingInfo::rleBlockOffset, PsdPixelUtils::ChannelWritingInfo::sizeFieldOffset, KisPaintDevice::x(), KisPaintDevice::y(), ZIP, and ZIPWithPrediction.