KisTiffPsdWriter Class Reference

#include <kis_tiff_psd_writer_visitor.h>

Inheritance diagram for KisTiffPsdWriter:

Public Member Functions
	KisTiffPsdWriter (TIFF *image, KisTIFFOptions *options)
KisImportExportErrorCode	writeImage (KisGroupLayerSP rootLayer)
	~KisTiffPsdWriter () override

Additional Inherited Members
Protected Member Functions inherited from KisTIFFBaseWriter
bool	copyDataToStrips (KisHLineConstIteratorSP it, tdata_t buff, uint32_t depth, uint16_t sample_format, uint8_t nbcolorssamples, const std::array< quint8, 5 > &poses)
TIFF *	image ()
	KisTIFFBaseWriter (TIFF *image, KisTIFFOptions *options)
	~KisTIFFBaseWriter ()=default
Static Protected Member Functions inherited from KisTIFFBaseWriter
static bool	isBitDepthFloat (const KoID depth)
static bool	writeColorSpaceInformation (TIFF *image, const KoColorSpace *cs, uint16_t &color_type, uint16_t &sample_format, const KoColorSpace *&destColorSpace)
Protected Attributes inherited from KisTIFFBaseWriter
TIFF *	m_image
KisTIFFOptions *	m_options

Detailed Description

Definition at line 22 of file kis_tiff_psd_writer_visitor.h.

Constructor & Destructor Documentation

KisTiffPsdWriter()

KisTiffPsdWriter::KisTiffPsdWriter	(	TIFF *	image,
		KisTIFFOptions *	options )

Definition at line 36 of file kis_tiff_psd_writer_visitor.cpp.

    : KisTIFFBaseWriter(image, options)
{
}

~KisTiffPsdWriter()

KisTiffPsdWriter::~KisTiffPsdWriter ( )

overridedefault

Member Function Documentation

writeImage()

KisImportExportErrorCode KisTiffPsdWriter::writeImage

(

KisGroupLayerSP

rootLayer

)

For Photoshop tiff files, first thing is to write the projection of the image file.

• BEGIN PHOTOSHOP SPECIFIC HANDLING CODE *‍///

Synthesize the PSD file into the TIFFTAG_IMAGESOURCEDATA field.

Write all the annotations into the TIFFTAG_PHOTOSHOP field.

Freshly baked Photoshoppy TIFF file!

• END PHOTOSHOP SPECIFIC HANDLING CODE *‍///

Definition at line 43 of file kis_tiff_psd_writer_visitor.cpp.

{
    dbgFile << "Starting write of Photoshop layer data";
 
    if (layer->image()->width() > MAX_PSD_SIZE || layer->image()->height() > MAX_PSD_SIZE) {
        dbgFile << "This TIFF file is too big to be represented as a PSD blob!";
        return ImportExportCodes::Failure;
    }
 
    dbgFile << "Writing root layer projection";
    KisPaintDeviceSP pd = layer->projection();
 
    uint16_t color_type = 0;
    uint16_t sample_format = SAMPLEFORMAT_UINT;
    const KoColorSpace *destColorSpace = nullptr;
    // Check colorspace
    if (!writeColorSpaceInformation(image(), pd->colorSpace(), color_type, sample_format, destColorSpace)) { // unsupported colorspace
        if (!destColorSpace) {
            dbgFile << "Unsupported colorspace" << pd->colorSpace()->name();
            return ImportExportCodes::FormatColorSpaceUnsupported;
        }
        pd.attach(new KisPaintDevice(*pd));
        pd->convertTo(destColorSpace);
    }
 
    {
        // WORKAROUND: block any attempts to use YCbCr with alpha channels.
        // This should not happen because alpha is disabled by default
        // and the checkbox is blocked for YCbCr and CMYK.
        KIS_SAFE_ASSERT_RECOVER(color_type != PHOTOMETRIC_YCBCR
                                || !m_options->alpha)
        {
            warnFile << "TIFF does not support exporting alpha channels with "
                        "YCbCr. Skipping...";
            m_options->alpha = false;
        }
    }
 
    // Save depth
    uint32_t depth = 8 * pd->pixelSize() / pd->channelCount();
    TIFFSetField(image(), TIFFTAG_BITSPERSAMPLE, depth);
 
    {
        // WORKAROUND: block any attempts to use JPEG with >= 8 bits
 
        if (m_options->compressionType == COMPRESSION_JPEG && depth != 8) {
            warnFile << "Attempt to export JPEG with multi-byte depth, "
                        "disabling compression";
            m_options->compressionType = COMPRESSION_NONE;
        }
    }
 
    // Save number of samples
    if (m_options->alpha) {
        TIFFSetField(image(), TIFFTAG_SAMPLESPERPIXEL, pd->channelCount());
        const std::array<uint16_t, 1> sampleinfo = {EXTRASAMPLE_UNASSALPHA};
        TIFFSetField(image(), TIFFTAG_EXTRASAMPLES, 1, sampleinfo.data());
    } else {
        TIFFSetField(image(), TIFFTAG_SAMPLESPERPIXEL, pd->channelCount() - 1);
        TIFFSetField(image(), TIFFTAG_EXTRASAMPLES, 0);
    }
 
    // Save colorspace information
    TIFFSetField(image(), TIFFTAG_PHOTOMETRIC, color_type);
    TIFFSetField(image(), TIFFTAG_SAMPLEFORMAT, sample_format);
    TIFFSetField(image(), TIFFTAG_IMAGEWIDTH, layer->image()->width());
    TIFFSetField(image(), TIFFTAG_IMAGELENGTH, layer->image()->height());
 
    // Set the compression options
    TIFFSetField(image(), TIFFTAG_COMPRESSION, m_options->compressionType);
    if (m_options->compressionType == COMPRESSION_JPEG) {
        TIFFSetField(image(), TIFFTAG_JPEGQUALITY, m_options->jpegQuality);
    } else if (m_options->compressionType == COMPRESSION_ADOBE_DEFLATE) {
        TIFFSetField(image(), TIFFTAG_ZIPQUALITY, m_options->deflateCompress);
    } else if (m_options->compressionType == COMPRESSION_PIXARLOG) {
        TIFFSetField(image(),
                     TIFFTAG_PIXARLOGQUALITY,
                     m_options->pixarLogCompress);
    }
 
    // Set the predictor
    if (m_options->compressionType == COMPRESSION_LZW
        || m_options->compressionType == COMPRESSION_ADOBE_DEFLATE)
        TIFFSetField(image(), TIFFTAG_PREDICTOR, m_options->predictor);
 
    // Use contiguous configuration
    TIFFSetField(image(), TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 
    // Do not set the rowsperstrip, as it's incompatible with JPEG
 
    // But do set YCbCr 4:4:4 if applicable
    if (color_type == PHOTOMETRIC_YCBCR) {
        TIFFSetField(image(), TIFFTAG_YCBCRSUBSAMPLING, 1, 1);
        TIFFSetField(image(), TIFFTAG_YCBCRPOSITIONING, YCBCRPOSITION_CENTERED);
        if (m_options->compressionType == COMPRESSION_JPEG) {
            TIFFSetField(image(), TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
        }
    }
 
    // Save profile
    if (m_options->saveProfile) {
        const KoColorProfile *profile = pd->colorSpace()->profile();
        if (profile && profile->type() == "icc" && !profile->rawData().isEmpty()) {
            QByteArray ba = profile->rawData();
            TIFFSetField(image(), TIFFTAG_ICCPROFILE, ba.size(), ba.constData());
        }
    }
    tsize_t stripsize = TIFFStripSize(image());
    std::unique_ptr<std::remove_pointer_t<tdata_t>, decltype(&_TIFFfree)> buff(
        _TIFFmalloc(stripsize),
        &_TIFFfree);
    KIS_ASSERT_RECOVER_RETURN_VALUE(
        buff && "Unable to allocate buffer for TIFF!",
        ImportExportCodes::InsufficientMemory);
    qint32 height = layer->image()->height();
    qint32 width = layer->image()->width();
    bool r = true;
    for (qint32 y = 0; y < height; y++) {
        KisHLineConstIteratorSP it = pd->createHLineConstIteratorNG(0, y, width);
        switch (color_type) {
        case PHOTOMETRIC_MINISBLACK: {
            const std::array<quint8, 5> poses = {0, 1};
            r = copyDataToStrips(it,
                                 buff.get(),
                                 depth,
                                 sample_format,
                                 1,
                                 poses);
        } break;
        case PHOTOMETRIC_RGB: {
            const auto poses = [&]() -> std::array<quint8, 5> {
                if (sample_format == SAMPLEFORMAT_IEEEFP) {
                    return {0, 1, 2, 3};
                } else {
                    return {2, 1, 0, 3};
                }
            }();
            r = copyDataToStrips(it,
                                 buff.get(),
                                 depth,
                                 sample_format,
                                 3,
                                 poses);
        } break;
        case PHOTOMETRIC_SEPARATED: {
            const std::array<quint8, 5> poses = {0, 1, 2, 3, 4};
            r = copyDataToStrips(it,
                                 buff.get(),
                                 depth,
                                 sample_format,
                                 4,
                                 poses);
        } break;
        case PHOTOMETRIC_ICCLAB:
        case PHOTOMETRIC_YCBCR: {
            const std::array<quint8, 5> poses = {0, 1, 2, 3};
            r = copyDataToStrips(it,
                                 buff.get(),
                                 depth,
                                 sample_format,
                                 3,
                                 poses);
        } break;
        }
        if (!r)
            return ImportExportCodes::InternalError;
        TIFFWriteScanline(image(),
                          buff.get(),
                          static_cast<quint32>(y),
                          (tsample_t)-1);
    }
    buff.reset();
 
 
    {
        const bool haveLayers = layer->childCount() > 1 || KisPainter::checkDeviceHasTransparency(layer->firstChild()->projection());
 
        QBuffer buf;
        buf.open(QIODevice::WriteOnly);
 
        dbgFile << "m_image->rootLayer->childCount" << layer->childCount() << buf.pos();
 
        if (haveLayers) {
            KisTiffPsdLayerRecord layerSection(
                TIFFIsBigEndian(image()),
                static_cast<uint32_t>(width),
                static_cast<uint32_t>(height),
                static_cast<uint16_t>(depth),
                static_cast<uint16_t>(pd->channelCount()),
                color_type,
                true);
 
            if (!layerSection.write(buf, layer, static_cast<psd_compression_type>(m_options->psdCompressionType))) {
                dbgFile << "failed to write layer section. Error:" << layerSection.record()->error << buf.pos();
                return ImportExportCodes::ErrorWhileWriting;
            }
        } else {
            // else write a zero length block
            dbgFile << "No layers, saving empty layers/mask block" << buf.pos();
            psdwrite(buf, (quint32)0);
        }
 
        buf.close();
        buf.open(QIODevice::ReadOnly);
 
        if (!TIFFSetField(image(), TIFFTAG_IMAGESOURCEDATA, static_cast<uint32_t>(buf.size()), buf.data().constData())) {
            dbgFile << "Failed to write the PSD image block to the TIFF field";
            return ImportExportCodes::ErrorWhileWriting;
        }
    }
 
    {
        // IMAGE RESOURCES SECTION
        KisTiffPsdResourceRecord resourceSection;
 
        for (vKisAnnotationSP_it it = layer->image()->beginAnnotations(); it != layer->image()->endAnnotations(); ++it) {
            KisAnnotationSP annotation = (*it);
            if (!annotation || annotation->type().isEmpty()) {
                dbgFile << "Warning: empty annotation";
                continue;
            }
 
            dbgFile << "Annotation:" << annotation->type() << annotation->description();
 
            if (annotation->type().startsWith(QString("PSD Resource Block:"))) { //
                PSDResourceBlock *resourceBlock =
                    dynamic_cast<PSDResourceBlock *>(annotation.data());
                if (resourceBlock) {
                    dbgFile << "Adding PSD Resource Block" << resourceBlock->identifier;
                    resourceSection.resources[(KisTiffPsdResourceRecord::PSDResourceID)resourceBlock->identifier] = resourceBlock;
                }
            }
        }
 
        // Add resolution block
        {
            auto *resInfo = new RESN_INFO_1005();
            resInfo->hRes = static_cast<int>(INCH_TO_POINT(layer->image()->xRes()));
            resInfo->vRes = static_cast<int>(INCH_TO_POINT(layer->image()->yRes()));
            auto *block = new PSDResourceBlock();
            block->identifier = KisTiffPsdResourceRecord::RESN_INFO;
            block->resource = resInfo;
            resourceSection.resources[KisTiffPsdResourceRecord::RESN_INFO] = block;
        }
 
        // Add icc block
        {
            auto *profileInfo = new ICC_PROFILE_1039();
            profileInfo->icc = layer->image()->profile()->rawData();
            auto *block = new PSDResourceBlock();
            block->identifier = KisTiffPsdResourceRecord::ICC_PROFILE;
            block->resource = profileInfo;
            resourceSection.resources[KisTiffPsdResourceRecord::ICC_PROFILE] = block;
        }
 
        dbgFile << "Resource section ready to write";
 
        QBuffer buf;
        buf.open(QIODevice::WriteOnly);
 
        if (!resourceSection.write(buf)) {
            dbgFile << "Failed to write resource section. Error:" << resourceSection.error << buf.pos();
            return ImportExportCodes::ErrorWhileWriting;
        }
 
        buf.close();
        buf.open(QIODevice::WriteOnly);
 
        if (!TIFFSetField(image(), TIFFTAG_PHOTOSHOP, static_cast<uint32_t>(buf.size()), buf.data().data())) {
            dbgFile << "Failed to write the PSD resource block to the TIFF field";
            return ImportExportCodes::ErrorWhileWriting;
        }
    }
 
 
    TIFFWriteDirectory(image());
    return ImportExportCodes::OK;
}

References KisTIFFOptions::alpha, KisSharedPtr< T >::attach(), KisImage::beginAnnotations(), KisPaintDevice::channelCount(), KisPainter::checkDeviceHasTransparency(), KisNode::childCount(), KisPaintDevice::colorSpace(), KisTIFFOptions::compressionType, KisPaintDevice::convertTo(), KisTIFFBaseWriter::copyDataToStrips(), KisPaintDevice::createHLineConstIteratorNG(), KisSharedPtr< T >::data(), dbgFile, KisTIFFOptions::deflateCompress, KisImage::endAnnotations(), KisTiffPsdResourceRecord::error, ImportExportCodes::ErrorWhileWriting, ImportExportCodes::Failure, KisNode::firstChild(), ImportExportCodes::FormatColorSpaceUnsupported, KisImage::height(), KisTiffPsdResourceRecord::ICC_PROFILE, PSDResourceBlock::identifier, KisBaseNode::image, KisTIFFBaseWriter::image(), INCH_TO_POINT(), ImportExportCodes::InsufficientMemory, ImportExportCodes::InternalError, KisTIFFOptions::jpegQuality, KIS_ASSERT_RECOVER_RETURN_VALUE, KIS_SAFE_ASSERT_RECOVER, KisTIFFBaseWriter::m_options, MAX_PSD_SIZE, KoColorSpace::name, ImportExportCodes::OK, KisTIFFOptions::pixarLogCompress, KisPaintDevice::pixelSize(), KisTIFFOptions::predictor, KisImage::profile(), KoColorSpace::profile(), KisBaseNode::projection(), KisLayer::projection(), KisTIFFOptions::psdCompressionType, psdwrite(), KoColorProfile::rawData(), KisTiffPsdLayerRecord::record(), KisTiffPsdResourceRecord::RESN_INFO, KisTiffPsdResourceRecord::resources, KisTIFFOptions::saveProfile, KoColorProfile::type(), warnFile, KisImage::width(), KisTiffPsdResourceRecord::write(), KisTiffPsdLayerRecord::write(), KisTIFFBaseWriter::writeColorSpaceInformation(), KisImage::xRes(), and KisImage::yRes().

---

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

• plugins/impex/tiff/kis_tiff_psd_writer_visitor.h
• plugins/impex/tiff/kis_tiff_psd_writer_visitor.cpp