PSDLayerRecord Class Reference

#include <psd_layer_record.h>

Classes
struct	LayerBlendingRanges
struct	LayerMaskData

Public Member Functions
void	addPathShapeToPSDPath (psd_path &path, KoPathShape *shape, double shapeWidth, double shapeHeight)
	addPathShapeToPSDPath add all KoPathShape subpaths to the given psd_path struct.
QRect	channelRect (ChannelInfo *channel) const
KoPathShape *	constructPathShape (psd_path path, double shapeWidth, double shapeHeight)
	constructPathShape create a KoPathshape based on a psd_path struct, used in vector masks and path resources.
	PSDLayerRecord (const PSDHeader &header)
bool	read (QIODevice &io)
bool	readMask (QIODevice &io, KisPaintDeviceSP dev, ChannelInfo *channel)
bool	readPixelData (QIODevice &io, KisPaintDeviceSP device)
bool	valid ()
void	write (QIODevice &io, KisPaintDeviceSP layerContentDevice, KisNodeSP onlyTransparencyMask, const QRect &maskRect, psd_section_type sectionType, const QDomDocument &stylesXmlDoc, bool useLfxsLayerStyleFormat)
void	writePixelData (QIODevice &io, psd_compression_type compressionType)
	~PSDLayerRecord ()

Public Attributes
LayerBlendingRanges	blendingRanges
QString	blendModeKey
qint32	bottom {0}
QVector< ChannelInfo * >	channelInfoRecords
quint8	clipping {0}
QString	error
QDomDocument	fillConfig
psd_fill_type	fillType {psd_fill_solid_color}
PsdAdditionalLayerInfoBlock	infoBlocks
bool	irrelevant {false}
bool	isPassThrough {false}
int	labelColor {0}
LayerMaskData	layerMask
QString	layerName {"UNINITIALIZED"}
qint32	left {0}
quint16	nChannels {0}
quint8	opacity {0}
qint32	right {0}
psd_layer_type_shape	textShape
qint32	top {0}
bool	transparencyProtected {false}
psd_vector_mask	vectorMask
QDomDocument	vectorOriginationData
QDomDocument	vectorStroke
bool	visible {true}

Private Member Functions
KisPaintDeviceSP	convertMaskDeviceIfNeeded (KisPaintDeviceSP dev)
int	kritaColorLabelIndex (quint16 labelColor)
quint16	psdLabelColor (int colorLabelIndex)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
bool	readImpl (QIODevice &io)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	writeImpl (QIODevice &io, KisPaintDeviceSP layerContentDevice, KisNodeSP onlyTransparencyMask, const QRect &maskRect, psd_section_type sectionType, const QDomDocument &stylesXmlDoc, bool useLfxsLayerStyleFormat)
template<psd_byte_order = psd_byte_order::psdBigEndian>
void	writePixelDataImpl (QIODevice &io, psd_compression_type compressionType)
template<psd_byte_order = psd_byte_order::psdBigEndian>
void	writeTransparencyMaskPixelData (QIODevice &io)

Private Attributes
const PSDHeader	m_header
KisPaintDeviceSP	m_layerContentDevice
KisNodeSP	m_onlyTransparencyMask
QRect	m_onlyTransparencyMaskRect
qint64	m_transparencyMaskSizeOffset {0}

Detailed Description

Definition at line 68 of file psd_layer_record.h.

Constructor & Destructor Documentation

PSDLayerRecord()

PSDLayerRecord::PSDLayerRecord

(

const PSDHeader &

header

)

Definition at line 162 of file psd_layer_record.cpp.

    : infoBlocks(header)
    , m_header(header)
{
}

~PSDLayerRecord()

PSDLayerRecord::~PSDLayerRecord ( )

inline

Definition at line 73 of file psd_layer_record.h.

    {
        qDeleteAll(channelInfoRecords);
    }

Member Function Documentation

addPathShapeToPSDPath()

void PSDLayerRecord::addPathShapeToPSDPath	(	psd_path &	path,
		KoPathShape *	shape,
		double	shapeWidth,
		double	shapeHeight )

addPathShapeToPSDPath add all KoPathShape subpaths to the given psd_path struct.

Parameters

shapeWidth	the image width in points
shapeHeight	the image height in points

Definition at line 987 of file psd_layer_record.cpp.

{
    QTransform tf = QTransform::fromScale(shapeWidth, shapeHeight).inverted();
    tf = shape->absoluteTransformation()*tf;
 
 
    for (int i = 0; i < shape->subpathCount(); i++) {
        psd_path_sub_path subPath;
        subPath.isClosed = shape->isClosedSubpath(i);
        while(subPath.nodes.size() < shape->subpathPointCount(i)) {
            const KoPathPoint *point = shape->pointByIndex(KoPathPointIndex(i, subPath.nodes.size()));
            psd_path_node node;
            node.node = tf.map(point->point());
            node.control1 = point->activeControlPoint1()? tf.map(point->controlPoint1()): node.node;
            node.control2 = point->activeControlPoint2()? tf.map(point->controlPoint2()): node.node;
 
            node.isSmooth = (point->properties().testFlag(KoPathPoint::IsSmooth)
                    || point->properties().testFlag(KoPathPoint::IsSymmetric));
            subPath.nodes.append(node);
        }
 
        path.subPaths.append(subPath);
    }
}

References KoShape::absoluteTransformation(), KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, psd_path_node::control1, psd_path_node::control2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, psd_path_sub_path::isClosed, KoPathShape::isClosedSubpath(), KoPathPoint::IsSmooth, psd_path_node::isSmooth, KoPathPoint::IsSymmetric, psd_path_node::node, psd_path_sub_path::nodes, KoPathPoint::point, KoPathShape::pointByIndex(), KoPathPoint::properties, KoPathShape::subpathCount(), and KoPathShape::subpathPointCount().

channelRect()

QRect PSDLayerRecord::channelRect

(

ChannelInfo *

channel

)

const

Definition at line 896 of file psd_layer_record.cpp.

{
    QRect result;
 
    if (channel->channelId < -1) {
        result = QRect(layerMask.left, layerMask.top, layerMask.right - layerMask.left, layerMask.bottom - layerMask.top);
    } else {
        result = QRect(left, top, right - left, bottom - top);
    }
 
    return result;
}

References bottom, PSDLayerRecord::LayerMaskData::bottom, ChannelInfo::channelId, layerMask, left, PSDLayerRecord::LayerMaskData::left, right, PSDLayerRecord::LayerMaskData::right, top, and PSDLayerRecord::LayerMaskData::top.

constructPathShape()

KoPathShape * PSDLayerRecord::constructPathShape	(	psd_path	path,
		double	shapeWidth,
		double	shapeHeight )

constructPathShape create a KoPathshape based on a psd_path struct, used in vector masks and path resources.

Parameters

path	a psd path struct.
shapeWidth	the image width in points
shapeHeight	the image height in points
vogk	extra vector data from the vogk layer info block.

Returns

a KoPathShape.

Definition at line 941 of file psd_layer_record.cpp.

{
    KoPathShape *shape = new KoPathShape();
 
    // psd paths are stored normalized.
    QTransform tf = QTransform::fromScale(shapeWidth, shapeHeight);
 
    QString nodeTypes;
    Q_FOREACH(psd_path_sub_path subPath, path.subPaths) {
        for (int i = 0; i < subPath.nodes.size(); i++) {
            psd_path_node node = subPath.nodes.at(i);
            if (i == 0) {
                shape->moveTo(tf.map(node.node));
            } else {
                psd_path_node previousNode = subPath.nodes.at(i-1);
                if (previousNode.node == previousNode.control2 && node.node == node.control1) {
                    shape->lineTo(tf.map(node.node));
                } else {
                    shape->curveTo(tf.map(previousNode.control2), tf.map(node.control1), tf.map(node.node));
                }
            }
            if (node.isSmooth) {
                nodeTypes.append("s");
            } else {
                nodeTypes.append("c");
            }
        }
        if (subPath.isClosed) {
            psd_path_node lastNode = subPath.nodes.last();
            psd_path_node firstNode = subPath.nodes.first();
            if (lastNode.node == lastNode.control2 && firstNode.node == firstNode.control1) {
                shape->lineTo(tf.map(firstNode.node));
            } else {
                shape->curveTo(tf.map(lastNode.control2), tf.map(firstNode.control1), tf.map(firstNode.node));
            }
            shape->closeMerge();
        }
 
    }
    if (shape->pointCount() > 0) {
        shape->loadNodeTypes(nodeTypes);
    }
 
    return shape;
}

References KoPathShape::closeMerge(), psd_path_node::control1, psd_path_node::control2, KoPathShape::curveTo(), psd_path_sub_path::isClosed, psd_path_node::isSmooth, KoPathShape::lineTo(), KoPathShape::loadNodeTypes(), KoPathShape::moveTo(), psd_path_node::node, psd_path_sub_path::nodes, and KoPathShape::pointCount().

convertMaskDeviceIfNeeded()

KisPaintDeviceSP PSDLayerRecord::convertMaskDeviceIfNeeded ( KisPaintDeviceSP dev )

private

Definition at line 713 of file psd_layer_record.cpp.

{
    KisPaintDeviceSP result = dev;
 
    if (m_header.channelDepth == 16) {
        result = new KisPaintDevice(*dev);
        result->convertTo(KoColorSpaceRegistry::instance()->alpha16());
    } else if (m_header.channelDepth == 32) {
        result = new KisPaintDevice(*dev);
        result->convertTo(KoColorSpaceRegistry::instance()->alpha32f());
    }
    return result;
}

References PSDHeader::channelDepth, KisPaintDevice::convertTo(), KoColorSpaceRegistry::instance(), and m_header.

kritaColorLabelIndex()

int PSDLayerRecord::kritaColorLabelIndex ( quint16 labelColor )

private

Definition at line 764 of file psd_layer_record.cpp.

{
    int color = 0;
    switch (labelColor) {
    case 0:
        color = 0;
        break;
    case 1: // red
        color = 6;
        break;
    case 2: // Orange
        color = 4;
        break;
    case 3: // Yellow
        color = 3;
        break;
    case 4: // Green
        color = 2;
        break;
    case 5: // Blue
        color = 1;
        break;
    case 6: // Purple
        color = 7;
        break;
    case 7: // Grey
        color = 8;
        break;
    default:
        color = 0;
    }
    return color;
}

References labelColor.

psdLabelColor()

quint16 PSDLayerRecord::psdLabelColor ( int colorLabelIndex )

private

Definition at line 727 of file psd_layer_record.cpp.

{
    quint16 color = 0;
    switch (colorLabelIndex) {
    case 0: // none
        color = 0;
        break;
    case 1: // Blue
        color = 5;
        break;
    case 2: // Green
        color = 4;
        break;
    case 3: // Yellow
        color = 3;
        break;
    case 4: // Orange
        color = 2;
        break;
    case 5: // Brown, don't save.
        color = 0;
        break;
    case 6: // Red
        color = 1;
        break;
    case 7: // Purple
        color = 6;
        break;
    case 8: // Grey
        color = 7;
        break;
    default:
        color = 0;
    }
    return color;
}

read()

bool PSDLayerRecord::read

(

QIODevice &

io

)

Definition at line 168 of file psd_layer_record.cpp.

{
    switch (m_header.byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return readImpl<psd_byte_order::psdLittleEndian>(io);
    default:
        return readImpl(io);
    }
}

References PSDHeader::byteOrder, m_header, psdLittleEndian, and readImpl().

readImpl()

template<psd_byte_order byteOrder>

bool PSDLayerRecord::readImpl ( QIODevice & io )

private

Definition at line 179 of file psd_layer_record.cpp.

{
    dbgFile << "Going to read layer record. Pos:" << io.pos();
 
    if (!psdread<byteOrder>(io, top) || !psdread<byteOrder>(io, left) || !psdread<byteOrder>(io, bottom) || !psdread<byteOrder>(io, right)
        || !psdread<byteOrder>(io, nChannels)) {
        error = "could not read layer record";
        return false;
    }
 
    dbgFile << "\ttop" << top << "left" << left << "bottom" << bottom << "right" << right << "number of channels" << nChannels;
 
    Q_ASSERT(top <= bottom);
    Q_ASSERT(left <= right);
    Q_ASSERT(nChannels > 0);
 
    if (nChannels < 1) {
        error = QString("Not enough channels. Got: %1").arg(nChannels);
        return false;
    }
 
    if (nChannels > MAX_CHANNELS) {
        error = QString("Too many channels. Got: %1").arg(nChannels);
        return false;
    }
 
    for (int i = 0; i < nChannels; ++i) {
        if (io.atEnd()) {
            error = "Could not read enough data for channels";
            return false;
        }
 
        ChannelInfo *info = new ChannelInfo;
 
        if (!psdread<byteOrder>(io, info->channelId)) {
            error = "could not read channel id";
            delete info;
            return false;
        }
        bool r;
        if (m_header.version == 1) {
            quint32 channelDataLength;
            r = psdread<byteOrder>(io, channelDataLength);
            info->channelDataLength = (quint64)channelDataLength;
        } else {
            r = psdread<byteOrder>(io, info->channelDataLength);
        }
        if (!r) {
            error = "Could not read length for channel data";
            delete info;
            return false;
        }
 
        dbgFile << "\tchannel" << i << "id" << channelIdToChannelType(info->channelId, m_header.colormode) << "length" << info->channelDataLength << "start"
                << info->channelDataStart << "offset" << info->channelOffset << "channelInfoPosition" << info->channelInfoPosition;
 
        channelInfoRecords << info;
    }
 
    if (!psd_read_blendmode<byteOrder>(io, blendModeKey)) {
        error = QString("Could not read blend mode key. Got: %1").arg(blendModeKey);
        return false;
    }
 
    dbgFile << "\tBlend mode" << blendModeKey << "pos" << io.pos();
 
    if (!psdread<byteOrder>(io, opacity)) {
        error = "Could not read opacity";
        return false;
    }
 
    dbgFile << "\tOpacity" << opacity << io.pos();
 
    if (!psdread<byteOrder>(io, clipping)) {
        error = "Could not read clipping";
        return false;
    }
 
    dbgFile << "\tclipping" << clipping << io.pos();
 
    quint8 flags;
    if (!psdread<byteOrder>(io, flags)) {
        error = "Could not read flags";
        return false;
    }
    dbgFile << "\tflags" << flags << io.pos();
 
    transparencyProtected = flags & 1 ? true : false;
 
    dbgFile << "\ttransparency protected" << transparencyProtected;
 
    visible = flags & 2 ? false : true;
 
    dbgFile << "\tvisible" << visible;
 
    if (flags & 8) {
        irrelevant = flags & 16 ? true : false;
    } else {
        irrelevant = false;
    }
 
    dbgFile << "\tirrelevant" << irrelevant;
 
    dbgFile << "\tfiller at " << io.pos();
 
    quint8 filler;
    if (!psdread<byteOrder>(io, filler) || filler != 0) {
        error = "Could not read padding";
        return false;
    }
 
    dbgFile << "\tGoing to read extra data length" << io.pos();
 
    quint32 extraDataLength;
    if (!psdread<byteOrder>(io, extraDataLength) || io.bytesAvailable() < extraDataLength) {
        error = QString("Could not read extra layer data: %1 at pos %2").arg(extraDataLength).arg(io.pos());
        return false;
    }
 
    dbgFile << "\tExtra data length" << extraDataLength;
 
    if (extraDataLength > 0) {
        dbgFile << "Going to read extra data field. Bytes available: " << io.bytesAvailable() << "pos" << io.pos();
 
        // See https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577409_22582
        quint32 layerMaskLength = 1; // invalid...
        if (!psdread<byteOrder>(io, layerMaskLength) || io.bytesAvailable() < layerMaskLength) {
            error = QString("Could not read layer mask length: %1").arg(layerMaskLength);
            return false;
        }
 
        layerMask = {};
 
        if (layerMaskLength == 0) {
            dbgFile << "\tNo layer mask/adjustment layer data. pos" << io.pos();
        } else {
            dbgFile << "\tReading layer mask/adjustment layer data. Length of block:" << layerMaskLength << "pos"
                    << io.pos();
 
            if (!psdread<byteOrder>(io, layerMask.top) || !psdread<byteOrder>(io, layerMask.left)
                || !psdread<byteOrder>(io, layerMask.bottom) || !psdread<byteOrder>(io, layerMask.right)
                || !psdread<byteOrder>(io, layerMask.defaultColor) || !psdread<byteOrder>(io, flags)) {
                error = "could not read common records of layer mask";
                return false;
            }
 
            layerMask.positionedRelativeToLayer = (flags & 1) != 0;
            layerMask.disabled = (flags & 2) != 0;
            layerMask.invertLayerMaskWhenBlending = (flags & 4) != 0;
            const bool hasMaskParameters = (flags & 8) != 0;
 
            dbgFile << "\tLayer mask info (original): position relative" << layerMask.positionedRelativeToLayer
                    << ", disabled" << layerMask.disabled << ", invert" << layerMask.invertLayerMaskWhenBlending
                    << ", needs to read mask parameters" << hasMaskParameters;
 
            if (layerMaskLength == 20) {
                quint16 padding = 0;
                if (!psdread<byteOrder>(io, padding)) {
                    error = "Could not read layer mask padding";
                    return false;
                }
            } else {
                quint32 remainingBlockLength = layerMaskLength - 18;
 
                dbgFile << "\tReading selective records from layer mask info. Remaining block length"
                        << remainingBlockLength;
 
                if (hasMaskParameters) {
                    if (!psdread<byteOrder>(io, flags)) {
                        error = "could not read mask parameters";
                        return false;
                    }
 
                    remainingBlockLength -= 1;
 
                    dbgFile << "\t\tMask parameters" << QString::number(flags, 2) << ". Remaining block length"
                            << remainingBlockLength;
 
                    if (flags & 1) {
                        quint8 dummy = 0;
                        if (!psdread<byteOrder>(io, dummy)) {
                            error = "could not read user mask density";
                            return false;
                        }
                        remainingBlockLength -= sizeof(dummy);
                    }
 
                    if (flags & 2) {
                        double dummy = 0;
                        if (!psdread<byteOrder>(io, dummy)) {
                            error = "could not read user mask feather";
                            return false;
                        }
                        remainingBlockLength -= sizeof(dummy);
                    }
 
                    if (flags & 4) {
                        quint8 dummy = 0;
                        if (!psdread<byteOrder>(io, dummy)) {
                            error = "could not read vector mask density";
                            return false;
                        }
                        remainingBlockLength -= sizeof(dummy);
                    }
 
                    if (flags & 8) {
                        double dummy = 0;
                        if (!psdread<byteOrder>(io, dummy)) {
                            error = "could not read vector mask feather";
                            return false;
                        }
                        remainingBlockLength -= sizeof(dummy);
                    }
                }
 
                if (remainingBlockLength >= 1) {
                    if (!psdread<byteOrder>(io, flags)) {
                        error = "could not read 'real' mask record";
                        return false;
                    }
 
                    layerMask.positionedRelativeToLayer = (flags & 1) != 0;
                    layerMask.disabled = (flags & 2) != 0;
                    layerMask.invertLayerMaskWhenBlending = (flags & 4) != 0;
                    const bool hasMaskParameters = (flags & 8) != 0;
 
                    dbgFile << "\t\tLayer mask info (real): position relative" << layerMask.positionedRelativeToLayer
                            << ", disabled" << layerMask.disabled << ", invert" << layerMask.invertLayerMaskWhenBlending
                            << ", needs to read mask parameters" << hasMaskParameters;
 
                    remainingBlockLength -= 1;
 
                    dbgFile << "\t\tRemaining block length" << remainingBlockLength;
                }
 
                if (remainingBlockLength >= 1) {
                    if (!psdread<byteOrder>(io, layerMask.defaultColor)) {
                        error = "could not read 'real' default color";
                        return false;
                    }
                    remainingBlockLength -= 1;
                    dbgFile << "\t\tRead 'real' default color. Remaining block length" << remainingBlockLength;
                }
 
                if (remainingBlockLength >= 16) {
                    if (!psdread<byteOrder>(io, layerMask.top) || !psdread<byteOrder>(io, layerMask.left)
                        || !psdread<byteOrder>(io, layerMask.bottom) || !psdread<byteOrder>(io, layerMask.right)) {
                        error = "could not read 'real' mask rectangle";
                        return false;
                    }
                    remainingBlockLength -= 16;
                    dbgFile << "\t\tRead 'real' mask rectangle. Remaining block length" << remainingBlockLength;
                }
            }
        }
 
        // layer blending thingies
        quint32 blendingDataLength = 0;
        if (!psdread<byteOrder>(io, blendingDataLength) || io.bytesAvailable() < blendingDataLength) {
            error = "Could not read extra blending data.";
            return false;
        }
 
        quint32 blendingNchannels = blendingDataLength > 0 ? (blendingDataLength - 8) / 4 / 2 : 0;
 
        dbgFile << "\tNumber of blending channels:" << blendingNchannels;
 
        if (blendingDataLength > 0) {
            if (blendingDataLength > 0) {
                if (!psdread<byteOrder>(io, blendingRanges.compositeGrayRange.first.blackValues[0])
                    || !psdread<byteOrder>(io, blendingRanges.compositeGrayRange.first.blackValues[1])
                    || !psdread<byteOrder>(io, blendingRanges.compositeGrayRange.first.whiteValues[0])
                    || !psdread<byteOrder>(io, blendingRanges.compositeGrayRange.first.whiteValues[1])) {
                    error = "Could not read blending black/white values";
                    return false;
                }
            }
            blendingDataLength -= 4;
 
            if (blendingDataLength > 0) {
                if (!psdread<byteOrder>(io, blendingRanges.compositeGrayRange.second.blackValues[0])
                    || !psdread<byteOrder>(io, blendingRanges.compositeGrayRange.second.blackValues[1])
                    || !psdread<byteOrder>(io, blendingRanges.compositeGrayRange.second.whiteValues[0])
                    || !psdread<byteOrder>(io, blendingRanges.compositeGrayRange.second.whiteValues[1])) {
                    error = "Could not read blending black/white values";
                    return false;
                }
            }
            blendingDataLength -= 4;
 
            dbgFile << "\tBlending ranges:";
            dbgFile << "\t\tcomposite gray (source) :" << blendingRanges.compositeGrayRange.first;
            dbgFile << "\t\tcomposite gray (dest):" << blendingRanges.compositeGrayRange.second;
 
            for (quint32 i = 0; i < blendingNchannels; ++i) {
                LayerBlendingRanges::LayerBlendingRange src{};
                LayerBlendingRanges::LayerBlendingRange dst{};
                if (!psdread<byteOrder>(io, src.blackValues[0]) || !psdread<byteOrder>(io, src.blackValues[1]) || !psdread<byteOrder>(io, src.whiteValues[0])
                    || !psdread<byteOrder>(io, src.whiteValues[1]) || !psdread<byteOrder>(io, dst.blackValues[0]) || !psdread<byteOrder>(io, dst.blackValues[1])
                    || !psdread<byteOrder>(io, dst.whiteValues[0]) || !psdread<byteOrder>(io, dst.whiteValues[1])) {
                    error = QString("could not read src/dst range for channel %1").arg(i);
                    return false;
                }
                dbgFile << "\t\tread range " << src << "to" << dst << "for channel" << i;
                blendingRanges.sourceDestinationRanges << qMakePair(src, dst);
            }
        }
 
        dbgFile << "\tGoing to read layer name at" << io.pos();
        quint8 layerNameLength;
        if (!psdread<byteOrder>(io, layerNameLength)) {
            error = "Could not read layer name length";
            return false;
        }
 
        dbgFile << "\tlayer name length unpadded" << layerNameLength << "pos" << io.pos();
        layerNameLength = ((layerNameLength + 1 + 3) & ~0x03) - 1;
 
        dbgFile << "\tlayer name length padded" << layerNameLength << "pos" << io.pos();
        // XXX: This should use psdread_pascalstring
        layerName = io.read(layerNameLength);
        dbgFile << "\tlayer name" << layerName << io.pos();
 
        dbgFile << "\tAbout to read additional info blocks at" << io.pos();
 
        if (!infoBlocks.read(io)) {
            error = infoBlocks.error;
            return false;
        }
 
        if (infoBlocks.keys.contains("luni") && !infoBlocks.unicodeLayerName.isEmpty()) {
            layerName = infoBlocks.unicodeLayerName;
        }
 
        labelColor = kritaColorLabelIndex(infoBlocks.labelColor);
    }
 
    return valid();
}

References blendingRanges, blendModeKey, bottom, PSDLayerRecord::LayerMaskData::bottom, ChannelInfo::channelDataLength, ChannelInfo::channelDataStart, ChannelInfo::channelId, channelIdToChannelType(), ChannelInfo::channelInfoPosition, channelInfoRecords, ChannelInfo::channelOffset, clipping, PSDHeader::colormode, PSDLayerRecord::LayerBlendingRanges::compositeGrayRange, dbgFile, PSDLayerRecord::LayerMaskData::defaultColor, PSDLayerRecord::LayerMaskData::disabled, PsdAdditionalLayerInfoBlock::error, error, infoBlocks, PSDLayerRecord::LayerMaskData::invertLayerMaskWhenBlending, irrelevant, PsdAdditionalLayerInfoBlock::keys, kritaColorLabelIndex(), PsdAdditionalLayerInfoBlock::labelColor, labelColor, layerMask, layerName, left, PSDLayerRecord::LayerMaskData::left, m_header, MAX_CHANNELS, nChannels, opacity, PSDLayerRecord::LayerMaskData::positionedRelativeToLayer, PsdAdditionalLayerInfoBlock::read(), right, PSDLayerRecord::LayerMaskData::right, PSDLayerRecord::LayerBlendingRanges::sourceDestinationRanges, top, PSDLayerRecord::LayerMaskData::top, transparencyProtected, PsdAdditionalLayerInfoBlock::unicodeLayerName, valid(), PSDHeader::version, and visible.

readMask()

bool PSDLayerRecord::readMask	(	QIODevice &	io,
		KisPaintDeviceSP	dev,
		ChannelInfo *	channel )

Definition at line 909 of file psd_layer_record.cpp.

{
    KIS_ASSERT_RECOVER(channelInfo->channelId < -1)
    {
        return false;
    }
 
    dbgFile << "Going to read" << channelIdToChannelType(channelInfo->channelId, m_header.colormode) << "mask";
 
    QRect maskRect = channelRect(channelInfo);
    if (maskRect.isEmpty()) {
        dbgFile << "Empty Channel";
        return true;
    }
 
    // the device must be a pixel selection
    KIS_ASSERT_RECOVER(dev->pixelSize() == 1)
    {
        return false;
    }
 
    dev->setDefaultPixel(KoColor(&layerMask.defaultColor, dev->colorSpace()));
 
    const int pixelSize = m_header.channelDepth == 16 ? 2 : m_header.channelDepth == 32 ? 4 : 1;
 
    QVector<ChannelInfo *> infoRecords;
    infoRecords << channelInfo;
    PsdPixelUtils::readAlphaMaskChannels(io, dev, pixelSize, maskRect, infoRecords);
 
    return true;
}

References PSDHeader::channelDepth, ChannelInfo::channelId, channelIdToChannelType(), channelRect(), PSDHeader::colormode, KisPaintDevice::colorSpace(), dbgFile, PSDLayerRecord::LayerMaskData::defaultColor, KIS_ASSERT_RECOVER, layerMask, m_header, KisPaintDevice::pixelSize(), PsdPixelUtils::readAlphaMaskChannels(), and KisPaintDevice::setDefaultPixel().

readPixelData()

bool PSDLayerRecord::readPixelData	(	QIODevice &	io,
		KisPaintDeviceSP	device )

Definition at line 877 of file psd_layer_record.cpp.

{
    dbgFile << "Reading pixel data for layer" << layerName << "pos" << io.pos();
 
    const int channelSize = m_header.channelDepth / 8;
    const QRect layerRect = QRect(left, top, right - left, bottom - top);
 
    try {
        // WARNING: Pixel data is ALWAYS in big endian!!!
        PsdPixelUtils::readChannels(io, device, m_header.colormode, channelSize, layerRect, channelInfoRecords, psd_byte_order::psdBigEndian);
    } catch (KisAslReaderUtils::ASLParseException &e) {
        device->clear();
        error = e.what();
        return false;
    }
 
    return true;
}

References bottom, PSDHeader::channelDepth, channelInfoRecords, KisPaintDevice::clear(), PSDHeader::colormode, dbgFile, error, layerName, left, m_header, psdBigEndian, PsdPixelUtils::readChannels(), right, and top.

valid()

bool PSDLayerRecord::valid

(

)

Definition at line 871 of file psd_layer_record.cpp.

{
    // XXX: check validity!
    return true;
}

write()

void PSDLayerRecord::write	(	QIODevice &	io,
		KisPaintDeviceSP	layerContentDevice,
		KisNodeSP	onlyTransparencyMask,
		const QRect &	maskRect,
		psd_section_type	sectionType,
		const QDomDocument &	stylesXmlDoc,
		bool	useLfxsLayerStyleFormat )

Definition at line 519 of file psd_layer_record.cpp.

{
    switch (m_header.byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return writeImpl<psd_byte_order::psdLittleEndian>(io,
                                                          layerContentDevice,
                                                          onlyTransparencyMask,
                                                          maskRect,
                                                          sectionType,
                                                          stylesXmlDoc,
                                                          useLfxsLayerStyleFormat);
    default:
        return writeImpl(io, layerContentDevice, onlyTransparencyMask, maskRect, sectionType, stylesXmlDoc, useLfxsLayerStyleFormat);
    }
}

References PSDHeader::byteOrder, m_header, psdLittleEndian, and writeImpl().

writeImpl()

template<psd_byte_order byteOrder>

void PSDLayerRecord::writeImpl ( QIODevice & io, KisPaintDeviceSP layerContentDevice, KisNodeSP onlyTransparencyMask, const QRect & maskRect, psd_section_type sectionType, const QDomDocument & stylesXmlDoc, bool useLfxsLayerStyleFormat )

private

Definition at line 542 of file psd_layer_record.cpp.

{
    dbgFile << "writing layer info record"
            << "at" << io.pos();
 
    m_layerContentDevice = layerContentDevice;
    m_onlyTransparencyMask = onlyTransparencyMask;
    m_onlyTransparencyMaskRect = maskRect;
 
    dbgFile << "saving layer record for " << layerName << "at pos" << io.pos();
    dbgFile << "\ttop" << top << "left" << left << "bottom" << bottom << "right" << right << "number of channels" << nChannels;
    Q_ASSERT(left <= right);
    Q_ASSERT(top <= bottom);
    Q_ASSERT(nChannels > 0);
 
    try {
        {
            const QRect layerRect(left, top, right - left, bottom - top);
            KisAslWriterUtils::writeRect<byteOrder>(layerRect, io);
        }
 
        {
            quint16 realNumberOfChannels = nChannels + bool(m_onlyTransparencyMask);
            SAFE_WRITE_EX(byteOrder, io, realNumberOfChannels);
        }
 
        Q_FOREACH (ChannelInfo *channel, channelInfoRecords) {
            SAFE_WRITE_EX(byteOrder, io, (quint16)channel->channelId);
 
            channel->channelInfoPosition = static_cast<int>(io.pos());
 
            // to be filled in when we know how big channel block is
            const quint32 fakeChannelSize = 0;
            SAFE_WRITE_EX(byteOrder, io, fakeChannelSize);
        }
 
        if (m_onlyTransparencyMask) {
            const quint16 userSuppliedMaskChannelId = -2;
            SAFE_WRITE_EX(byteOrder, io, userSuppliedMaskChannelId);
 
            m_transparencyMaskSizeOffset = io.pos();
 
            const quint32 fakeTransparencyMaskSize = 0;
            SAFE_WRITE_EX(byteOrder, io, fakeTransparencyMaskSize);
        }
 
        // blend mode
        dbgFile << ppVar(blendModeKey) << ppVar(io.pos());
 
        KisAslWriterUtils::writeFixedString<byteOrder>("8BIM", io);
        KisAslWriterUtils::writeFixedString<byteOrder>(blendModeKey, io);
 
        SAFE_WRITE_EX(byteOrder, io, opacity);
        SAFE_WRITE_EX(byteOrder, io, clipping); // unused
 
        // visibility and protection
        quint8 flags = 0;
        if (transparencyProtected)
            flags |= 1;
        if (!visible)
            flags |= 2;
        flags |= (1 << 3);
        if (irrelevant) {
            flags |= (1 << 4);
        }
 
        SAFE_WRITE_EX(byteOrder, io, flags);
 
        {
            quint8 padding = 0;
            SAFE_WRITE_EX(byteOrder, io, padding);
        }
 
        {
            // extra fields with their own length tag
            KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder> extraDataSizeTag(io);
 
            if (m_onlyTransparencyMask) {
                {
                    const quint32 layerMaskDataSize = 20; // support simple case only
                    SAFE_WRITE_EX(byteOrder, io, layerMaskDataSize);
                }
 
                KisAslWriterUtils::writeRect<byteOrder>(m_onlyTransparencyMaskRect, io);
 
                {
                    // NOTE: in PSD the default color of the mask is stored in 1 byte value!
                    //       Even when the mask is actually 16/32 bit! I have no idea how it is
                    //       actually treated in this case.
                    KIS_ASSERT_RECOVER_NOOP(m_onlyTransparencyMask->paintDevice()->pixelSize() == 1);
                    const quint8 defaultPixel = *m_onlyTransparencyMask->paintDevice()->defaultPixel().data();
                    SAFE_WRITE_EX(byteOrder, io, defaultPixel);
                }
 
                {
                    quint8 maskFlags = 0; // nothing serious
                    if (!vectorMask.path.subPaths.isEmpty()) {
                        maskFlags |= 8; // bit 3 = indicates that the user mask actually came from rendering other data
                    }
                    SAFE_WRITE_EX(byteOrder, io, maskFlags);
 
                    const quint16 padding = 0; // 2-byte padding
                    SAFE_WRITE_EX(byteOrder, io, padding);
                }
            } else {
                const quint32 nullLayerMaskDataSize = 0;
                SAFE_WRITE_EX(byteOrder, io, nullLayerMaskDataSize);
            }
 
            {
                // blending ranges are not implemented yet
                const quint32 nullBlendingRangesSize = 0;
                SAFE_WRITE_EX(byteOrder, io, nullBlendingRangesSize);
            }
 
            // layer name: Pascal string, padded to a multiple of 4 bytes.
            psdwrite_pascalstring<byteOrder>(io, layerName, 4);
 
            PsdAdditionalLayerInfoBlock additionalInfoBlock(m_header);
 
            // write 'luni' data block
            additionalInfoBlock.writeLuniBlockEx(io, layerName);
 
            additionalInfoBlock.writeLclrBlockEx(io, psdLabelColor(labelColor));
 
            // write 'lsct' data block
            if (sectionType != psd_other) {
                additionalInfoBlock.writeLsctBlockEx(io, sectionType, isPassThrough, blendModeKey);
            }
 
            // write 'lfx2' data block
            if (!stylesXmlDoc.isNull()) {
                additionalInfoBlock.writeLfx2BlockEx(io, stylesXmlDoc, useLfxsLayerStyleFormat);
            }
 
            // write SoCo, GdFl, PtFl data blocks.
            if (!fillConfig.isNull()) {
                additionalInfoBlock.writeFillLayerBlockEx(io, fillConfig, fillType);
            }
 
            // write 'vmsk' data block
            if (!vectorMask.path.subPaths.isEmpty()) {
                additionalInfoBlock.writeVmskBlockEx(io, vectorMask);
            }
 
            // write 'tysh' data block
            if (!textShape.engineData.isEmpty()) {
                additionalInfoBlock.writeTypeToolBlockEx(io, textShape);
            }
 
            // write 'vstk' data block
            if (!vectorStroke.isNull()) {
                additionalInfoBlock.writeVectorStrokeDataEx(io, vectorStroke);
            }
 
            if (!vectorOriginationData.isNull()) {
                additionalInfoBlock.writeVectorOriginationDataEx(io, vectorOriginationData);
            }
 
        }
    } catch (KisAslWriterUtils::ASLWriteException &e) {
        throw KisAslWriterUtils::ASLWriteException(PREPEND_METHOD(e.what()));
    }
}

References blendModeKey, bottom, ChannelInfo::channelId, ChannelInfo::channelInfoPosition, channelInfoRecords, clipping, KoColor::data(), dbgFile, KisPaintDevice::defaultPixel(), psd_layer_type_shape::engineData, fillConfig, fillType, irrelevant, isPassThrough, KIS_ASSERT_RECOVER_NOOP, labelColor, layerName, left, m_header, m_layerContentDevice, m_onlyTransparencyMask, m_onlyTransparencyMaskRect, m_transparencyMaskSizeOffset, nChannels, opacity, KisBaseNode::paintDevice(), psd_vector_mask::path, KisPaintDevice::pixelSize(), ppVar, PREPEND_METHOD, psd_other, psdLabelColor(), right, SAFE_WRITE_EX, psd_path::subPaths, textShape, top, transparencyProtected, vectorMask, vectorOriginationData, vectorStroke, visible, PsdAdditionalLayerInfoBlock::writeFillLayerBlockEx(), PsdAdditionalLayerInfoBlock::writeLclrBlockEx(), PsdAdditionalLayerInfoBlock::writeLfx2BlockEx(), PsdAdditionalLayerInfoBlock::writeLsctBlockEx(), PsdAdditionalLayerInfoBlock::writeLuniBlockEx(), PsdAdditionalLayerInfoBlock::writeTypeToolBlockEx(), PsdAdditionalLayerInfoBlock::writeVectorOriginationDataEx(), PsdAdditionalLayerInfoBlock::writeVectorStrokeDataEx(), and PsdAdditionalLayerInfoBlock::writeVmskBlockEx().

writePixelData()

void PSDLayerRecord::writePixelData	(	QIODevice &	io,
		psd_compression_type	compressionType )

Definition at line 818 of file psd_layer_record.cpp.

{
    try {
        switch (m_header.byteOrder) {
        case psd_byte_order::psdLittleEndian:
            writePixelDataImpl<psd_byte_order::psdLittleEndian>(io, compressionType);
            break;
        default:
            writePixelDataImpl(io, compressionType);
            break;
        }
    } catch (KisAslWriterUtils::ASLWriteException &e) {
        throw KisAslWriterUtils::ASLWriteException(PREPEND_METHOD(e.what()));
    }
}

References PSDHeader::byteOrder, m_header, PREPEND_METHOD, psdLittleEndian, and writePixelDataImpl().

writePixelDataImpl()

template<psd_byte_order byteOrder>

void PSDLayerRecord::writePixelDataImpl ( QIODevice & io, psd_compression_type compressionType )

private

Definition at line 835 of file psd_layer_record.cpp.

{
    dbgFile << "writing pixel data for layer" << layerName << "at" << io.pos();
 
    KisPaintDeviceSP dev = m_layerContentDevice;
    const QRect rc(left, top, right - left, bottom - top);
 
    if (rc.isEmpty()) {
        dbgFile << "Layer is empty! Writing placeholder information.";
 
        for (int i = 0; i < nChannels; i++) {
            const ChannelInfo *channelInfo = channelInfoRecords[i];
            KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder> channelBlockSizeExternalTag(io, 0, channelInfo->channelInfoPosition);
            SAFE_WRITE_EX(byteOrder, io, static_cast<quint16>(psd_compression_type::Uncompressed));
        }
 
        writeTransparencyMaskPixelData<byteOrder>(io);
 
        return;
    }
 
    // now write all the channels in display order
    dbgFile << "layer" << layerName;
 
    const int channelSize = m_header.channelDepth / 8;
    const psd_color_mode colorMode = m_header.colormode;
 
    QVector<PsdPixelUtils::ChannelWritingInfo> writingInfoList;
    Q_FOREACH (const ChannelInfo *channelInfo, channelInfoRecords) {
        writingInfoList << PsdPixelUtils::ChannelWritingInfo(channelInfo->channelId, channelInfo->channelInfoPosition);
    }
 
    PsdPixelUtils::writePixelDataCommon(io, dev, rc, colorMode, channelSize, true, true, writingInfoList, compressionType, byteOrder);
    writeTransparencyMaskPixelData<byteOrder>(io);
}

References bottom, PSDHeader::channelDepth, ChannelInfo::channelId, ChannelInfo::channelInfoPosition, channelInfoRecords, PSDHeader::colormode, dbgFile, layerName, left, m_header, m_layerContentDevice, nChannels, right, SAFE_WRITE_EX, top, Uncompressed, and PsdPixelUtils::writePixelDataCommon().

writeTransparencyMaskPixelData()

template<psd_byte_order byteOrder>

void PSDLayerRecord::writeTransparencyMaskPixelData ( QIODevice & io )

private

Definition at line 799 of file psd_layer_record.cpp.

{
    if (m_onlyTransparencyMask) {
        KisPaintDeviceSP device = convertMaskDeviceIfNeeded(m_onlyTransparencyMask->paintDevice());
 
        QByteArray buffer(static_cast<int>(device->pixelSize()) * m_onlyTransparencyMaskRect.width() * m_onlyTransparencyMaskRect.height(), 0);
        device->readBytes((quint8 *)buffer.data(), m_onlyTransparencyMaskRect);
 
        PsdPixelUtils::writeChannelDataRLE(io,
                                           (quint8 *)buffer.data(),
                                           static_cast<int>(device->pixelSize()),
                                           m_onlyTransparencyMaskRect,
                                           m_transparencyMaskSizeOffset,
                                           -1,
                                           true,
                                           byteOrder);
    }
}

References convertMaskDeviceIfNeeded(), m_onlyTransparencyMask, m_onlyTransparencyMaskRect, m_transparencyMaskSizeOffset, KisBaseNode::paintDevice(), KisPaintDevice::pixelSize(), KisPaintDevice::readBytes(), and PsdPixelUtils::writeChannelDataRLE().

Member Data Documentation

blendingRanges

LayerBlendingRanges PSDLayerRecord::blendingRanges

Definition at line 173 of file psd_layer_record.h.

blendModeKey

QString PSDLayerRecord::blendModeKey

Definition at line 125 of file psd_layer_record.h.

bottom

qint32 PSDLayerRecord::bottom {0}

Definition at line 118 of file psd_layer_record.h.

{0};

channelInfoRecords

QVector<ChannelInfo *> PSDLayerRecord::channelInfoRecords

Definition at line 123 of file psd_layer_record.h.

clipping

quint8 PSDLayerRecord::clipping {0}

Definition at line 129 of file psd_layer_record.h.

{0};

error

QString PSDLayerRecord::error

Definition at line 114 of file psd_layer_record.h.

fillConfig

QDomDocument PSDLayerRecord::fillConfig

Definition at line 137 of file psd_layer_record.h.

fillType

psd_fill_type PSDLayerRecord::fillType {psd_fill_solid_color}

Definition at line 136 of file psd_layer_record.h.

{psd_fill_solid_color};

infoBlocks

PsdAdditionalLayerInfoBlock PSDLayerRecord::infoBlocks

Definition at line 177 of file psd_layer_record.h.

irrelevant

bool PSDLayerRecord::irrelevant {false}

Definition at line 132 of file psd_layer_record.h.

{false};

isPassThrough

bool PSDLayerRecord::isPassThrough {false}

Definition at line 126 of file psd_layer_record.h.

{false};

labelColor

int PSDLayerRecord::labelColor {0}

Definition at line 134 of file psd_layer_record.h.

{0};

layerMask

LayerMaskData PSDLayerRecord::layerMask

Definition at line 159 of file psd_layer_record.h.

layerName

QString PSDLayerRecord::layerName {"UNINITIALIZED"}

Definition at line 175 of file psd_layer_record.h.

{"UNINITIALIZED"}; // pascal, not unicode!

left

qint32 PSDLayerRecord::left {0}

Definition at line 117 of file psd_layer_record.h.

{0};

m_header

const PSDHeader PSDLayerRecord::m_header

private

Definition at line 209 of file psd_layer_record.h.

m_layerContentDevice

KisPaintDeviceSP PSDLayerRecord::m_layerContentDevice

private

Definition at line 204 of file psd_layer_record.h.

m_onlyTransparencyMask

KisNodeSP PSDLayerRecord::m_onlyTransparencyMask

private

Definition at line 205 of file psd_layer_record.h.

m_onlyTransparencyMaskRect

QRect PSDLayerRecord::m_onlyTransparencyMaskRect

private

Definition at line 206 of file psd_layer_record.h.

m_transparencyMaskSizeOffset

qint64 PSDLayerRecord::m_transparencyMaskSizeOffset {0}

private

Definition at line 207 of file psd_layer_record.h.

{0};

nChannels

quint16 PSDLayerRecord::nChannels {0}

Definition at line 121 of file psd_layer_record.h.

{0};

opacity

quint8 PSDLayerRecord::opacity {0}

Definition at line 128 of file psd_layer_record.h.

{0};

right

qint32 PSDLayerRecord::right {0}

Definition at line 119 of file psd_layer_record.h.

{0};

textShape

psd_layer_type_shape PSDLayerRecord::textShape

Definition at line 140 of file psd_layer_record.h.

top

qint32 PSDLayerRecord::top {0}

Definition at line 116 of file psd_layer_record.h.

{0};

transparencyProtected

bool PSDLayerRecord::transparencyProtected {false}

Definition at line 130 of file psd_layer_record.h.

{false};

vectorMask

psd_vector_mask PSDLayerRecord::vectorMask

Definition at line 139 of file psd_layer_record.h.

vectorOriginationData

QDomDocument PSDLayerRecord::vectorOriginationData

Definition at line 142 of file psd_layer_record.h.

vectorStroke

QDomDocument PSDLayerRecord::vectorStroke

Definition at line 141 of file psd_layer_record.h.

visible

bool PSDLayerRecord::visible {true}

Definition at line 131 of file psd_layer_record.h.

{true};

---

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

• libs/psd/psd_layer_record.h
• libs/psd/psd_layer_record.cpp