HeifExport Class Reference

#include <HeifExport.h>

Inheritance diagram for HeifExport:

Public Member Functions
KisImportExportErrorCode	convert (KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration=0) override
KisConfigWidget *	createConfigurationWidget (QWidget *parent, const QByteArray &from="", const QByteArray &to="") const override
	createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter
KisPropertiesConfigurationSP	defaultConfiguration (const QByteArray &from="", const QByteArray &to="") const override
	defaultConfiguration defines the default settings for the given import export filter
	HeifExport (QObject *parent, const QVariantList &)
void	initializeCapabilities () override
bool	supportsIO () const override
	Override and return false for the filters that use a library that cannot handle file handles, only file names.
	~HeifExport () override
Public Member Functions inherited from KisImportExportFilter
virtual QMap< QString, KisExportCheckBase * >	exportChecks ()
	generate and return the list of capabilities of this export filter. The list
virtual bool	exportSupportsGuides () const
	exportSupportsGuides Because guides are in the document and not the image, checking for guides cannot be made an exportCheck.
KisPropertiesConfigurationSP	lastSavedConfiguration (const QByteArray &from="", const QByteArray &to="") const
	lastSavedConfiguration return the last saved configuration for this filter
	Private ()
void	setBatchMode (bool batchmode)
void	setFilename (const QString &filename)
void	setImportUserFeedBackInterface (KisImportUserFeedbackInterface *interface)
void	setMimeType (const QString &mime)
void	setRealFilename (const QString &filename)
void	setUpdater (QPointer< KoUpdater > updater)
QPointer< KoUpdater >	updater ()
virtual QString	verify (const QString &fileName) const
	Verify whether the given file is correct and readable.
	~KisImportExportFilter () override
	~Private ()

Additional Inherited Members
Public Attributes inherited from KisImportExportFilter
bool	batchmode
QMap< QString, KisExportCheckBase * >	capabilities
QString	filename
KisImportUserFeedbackInterface *	importUserFeedBackInterface {nullptr}
QByteArray	mime
QString	realFilename
QPointer< KoUpdater >	updater
Static Public Attributes inherited from KisImportExportFilter
static const QString	CICPPrimariesTag = "CICPCompatiblePrimaries"
static const QString	CICPTransferCharacteristicsTag = "CICPCompatibleTransferFunction"
static const QString	ColorDepthIDTag = "ColorDepthID"
static const QString	ColorModelIDTag = "ColorModelID"
static const QString	HDRTag = "HDRSupported"
static const QString	ImageContainsTransparencyTag = "ImageContainsTransparency"
static const QString	sRGBTag = "sRGB"
Protected Member Functions inherited from KisImportExportFilter
void	addCapability (KisExportCheckBase *capability)
void	addSupportedColorModels (QList< QPair< KoID, KoID > > supportedColorModels, const QString &name, KisExportCheckBase::Level level=KisExportCheckBase::PARTIALLY)
bool	batchMode () const
QString	filename () const
KisImportUserFeedbackInterface *	importUserFeedBackInterface () const
	KisImportExportFilter (QObject *parent=0)
QByteArray	mimeType () const
QString	realFilename () const
void	setProgress (int value)
QString	verifyZiPBasedFiles (const QString &fileName, const QStringList &filesToCheck) const

Detailed Description

Definition at line 53 of file HeifExport.h.

Constructor & Destructor Documentation

HeifExport()

HeifExport::HeifExport	(	QObject *	parent,
		const QVariantList &	)

Definition at line 54 of file HeifExport.cpp.

                                                            : KisImportExportFilter(parent)
{
}

~HeifExport()

HeifExport::~HeifExport ( )

override

Definition at line 58 of file HeifExport.cpp.

{
}

Member Function Documentation

convert()

KisImportExportErrorCode HeifExport::convert ( KisDocument * document, QIODevice * io, KisPropertiesConfigurationSP configuration = 0 )

overridevirtual

The filter chain calls this method to perform the actual conversion. The passed mimetypes should be a pair of those you specified in your .desktop file. You have to implement this method to make the filter work.

Returns

The error status, see the #ConversionStatus enum. KisImportExportFilter::OK means that everything is alright.

Implements KisImportExportFilter.

Definition at line 133 of file HeifExport.cpp.

{
#if LIBHEIF_HAVE_VERSION(1, 13, 0)
    HeifLock lock;
#endif
 
#if LIBHEIF_HAVE_VERSION(1, 20, 2)
    using HeifStrideType = size_t;
    auto heifGetPlaneMethod = std::mem_fn(qNonConstOverload<heif_channel, HeifStrideType*>(&heif::Image::get_plane2));
#elif LIBHEIF_HAVE_VERSION(1, 20, 0)
    using HeifStrideType = size_t;
    auto heifGetPlaneMethod = std::mem_fn(qNonConstOverload<heif_channel, HeifStrideType*>(&heif::Image::get_plane));
#else
    using HeifStrideType = int;
    auto heifGetPlaneMethod = std::mem_fn(qNonConstOverload<heif_channel, HeifStrideType*>(&heif::Image::get_plane));
#endif
 
 
    KisImageSP image = document->savingImage();
    const KoColorSpace *cs = image->colorSpace();
 
 
 
    dbgFile << "Starting" << mimeType() << "encoding.";
 
    bool convertToSRGB = (configuration->getBool("monochromeToSRGB") && cs->colorModelId() == GrayAColorModelID);
 
    // Convert to 8 bits rgba on saving if not rgba or graya.
    if ( (cs->colorModelId() != RGBAColorModelID && cs->colorModelId() != GrayAColorModelID) || convertToSRGB) {
        const KoColorSpace *sRgb = KoColorSpaceRegistry::instance()->rgb8();
        image->convertImageColorSpace(sRgb,
                                      KoColorConversionTransformation::internalRenderingIntent(),
                                      KoColorConversionTransformation::internalConversionFlags());
    }
 
    if (cs->colorModelId() == GrayAColorModelID && cs->hasHighDynamicRange() && !convertToSRGB) {
        const KoColorSpace *gray = KoColorSpaceRegistry::instance()->graya16(cs->profile()->name());
        image->convertImageColorSpace(gray,
                                      KoColorConversionTransformation::internalRenderingIntent(),
                                      KoColorConversionTransformation::internalConversionFlags());
    }
 
    ConversionPolicy conversionPolicy = ConversionPolicy::KeepTheSame;
    bool convertToRec2020 = false;
    
    if (cs->hasHighDynamicRange() && cs->colorModelId() != GrayAColorModelID) {
        QString conversionOption =
            (configuration->getString("floatingPointConversionOption",
                                      "KeepSame"));
        if (conversionOption == "Rec2100PQ") {
            convertToRec2020 = true;
            conversionPolicy = ConversionPolicy::ApplyPQ;
        } else if (conversionOption == "Rec2100HLG") {
            convertToRec2020 = true;
            conversionPolicy = ConversionPolicy::ApplyHLG;
        } else if (conversionOption == "ApplyPQ") {
            conversionPolicy = ConversionPolicy::ApplyPQ;
        } else if (conversionOption == "ApplyHLG") {
            conversionPolicy = ConversionPolicy::ApplyHLG;
        }  else if (conversionOption == "ApplySMPTE428") {
            conversionPolicy = ConversionPolicy::ApplySMPTE428;
        }
    }
 
    if (cs->hasHighDynamicRange() && convertToRec2020) {
        const KoColorProfile *linear = KoColorSpaceRegistry::instance()->profileFor(QVector<double>(),
                                                                                   PRIMARIES_ITU_R_BT_2020_2_AND_2100_0,
                                                                                   TRC_LINEAR);
        const KoColorSpace *linearRec2020 = KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", linear);
        image->convertImageColorSpace(linearRec2020,
                                      KoColorConversionTransformation::internalRenderingIntent(),
                                      KoColorConversionTransformation::internalConversionFlags());
    }
 
    image->waitForDone();
    cs = image->colorSpace();
 
    int quality = configuration->getInt("quality", 50);
    bool lossless = configuration->getBool("lossless", false);
    bool hasAlpha = configuration->getBool(KisImportExportFilter::ImageContainsTransparencyTag, false);
    float hlgGamma = configuration->getFloat("HLGgamma", 1.2f);
    float hlgNominalPeak = configuration->getFloat("HLGnominalPeak", 1000.0f);
    bool removeHGLOOTF = configuration->getBool("removeHGLOOTF", true);
 
    // If we want to add information from the document to the metadata,
    // we should do that here.
 
    try {
        // --- use standard HEVC encoder
 
 
        heif::Encoder encoder(heif_compression_HEVC);
 
 
        if (mimeType() == "image/avif") {
            encoder = heif::Encoder(heif_compression_AV1);
        }
 
 
        encoder.set_lossy_quality(quality);
        if (lossless) {
            //https://invent.kde.org/graphics/krita/-/merge_requests/530#note_169521
            encoder.set_lossy_quality(100);
        }
        encoder.set_lossless(lossless);
        if (cs->colorModelId() != GrayAColorModelID) {
        encoder.set_parameter("chroma", configuration->getString("chroma", "444").toStdString());
        }
 
 
        // --- convert KisImage to HEIF image ---
        int width = image->width();
        int height = image->height();
 
        heif::Context ctx;
 
        heif_chroma chroma = hasAlpha? heif_chroma_interleaved_RRGGBBAA_LE: heif_chroma_interleaved_RRGGBB_LE;
        if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
            chroma = hasAlpha? heif_chroma_interleaved_RRGGBBAA_BE: heif_chroma_interleaved_RRGGBB_BE;
        }
 
        heif::Image img;
 
        if (cs->colorModelId() == RGBAColorModelID) {
            if (cs->colorDepthId() == Integer8BitsColorDepthID) {
                dbgFile << "saving as 8bit rgba";
                img.create(width,height, heif_colorspace_RGB, heif_chroma_444);
                img.add_plane(heif_channel_R, width,height, 8);
                img.add_plane(heif_channel_G, width,height, 8);
                img.add_plane(heif_channel_B, width,height, 8);
 
                HeifStrideType strideR = 0;
                HeifStrideType strideG = 0;
                HeifStrideType strideB = 0;
                HeifStrideType strideA = 0;
 
                uint8_t *ptrR = heifGetPlaneMethod(img, heif_channel_R, &strideR);
                uint8_t *ptrG = heifGetPlaneMethod(img, heif_channel_G, &strideG);
                uint8_t *ptrB = heifGetPlaneMethod(img, heif_channel_B, &strideB);
 
                uint8_t *ptrA = [&]() -> uint8_t * {
                    if (hasAlpha) {
                        img.add_plane(heif_channel_Alpha, width, height, 8);
                        return heifGetPlaneMethod(img, heif_channel_Alpha, &strideA);
                    } else {
                        return nullptr;
                    }
                }();
 
                KisPaintDeviceSP pd = image->projection();
                KisHLineConstIteratorSP it =
                    pd->createHLineConstIteratorNG(0, 0, width);
 
                Planar::writeLayer(hasAlpha,
                                   width,
                                   height,
                                   ptrR,
                                   strideR,
                                   ptrG,
                                   strideG,
                                   ptrB,
                                   strideB,
                                   ptrA,
                                   strideA,
                                   it);
            } else {
                dbgFile << "Saving as 12bit rgba";
                img.create(width, height, heif_colorspace_RGB, chroma);
                img.add_plane(heif_channel_interleaved, width, height, 12);
 
                HeifStrideType stride = 0;
 
                uint8_t *ptr = heifGetPlaneMethod(img, heif_channel_interleaved, &stride);
 
                KisPaintDeviceSP pd = image->projection();
                KisHLineConstIteratorSP it =
                    pd->createHLineConstIteratorNG(0, 0, width);
 
                if (cs->colorDepthId() == Integer16BitsColorDepthID) {
                    HDRInt::writeInterleavedLayer(QSysInfo::ByteOrder,
                                                  hasAlpha,
                                                  width,
                                                  height,
                                                  ptr,
                                                  stride,
                                                  it);
                } else {
                    HDRFloat::writeInterleavedLayer(cs->colorDepthId(),
                                                    QSysInfo::ByteOrder,
                                                    hasAlpha,
                                                    convertToRec2020,
                                                    cs->profile()->isLinear(),
                                                    conversionPolicy,
                                                    removeHGLOOTF,
                                                    width,
                                                    height,
                                                    ptr,
                                                    stride,
                                                    it,
                                                    hlgGamma,
                                                    hlgNominalPeak,
                                                    cs);
                }
            }
        } else {
            if (cs->colorDepthId() == Integer8BitsColorDepthID) {
                dbgFile << "Saving as 8 bit monochrome.";
                img.create(width, height, heif_colorspace_monochrome, heif_chroma_monochrome);
 
                img.add_plane(heif_channel_Y, width, height, 8);
 
                HeifStrideType strideG = 0;
                HeifStrideType strideA = 0;
 
                uint8_t *ptrG = heifGetPlaneMethod(img, heif_channel_Y, &strideG);
                uint8_t *ptrA = [&]() -> uint8_t * {
                    if (hasAlpha) {
                        img.add_plane(heif_channel_Alpha, width, height, 8);
                        return heifGetPlaneMethod(img, heif_channel_Alpha, &strideA);
                    } else {
                        return nullptr;
                    }
                }();
 
                KisPaintDeviceSP pd = image->projection();
                KisHLineConstIteratorSP it =
                    pd->createHLineConstIteratorNG(0, 0, width);
 
                Gray::writePlanarLayer(QSysInfo::ByteOrder,
                                       8,
                                       hasAlpha,
                                       width,
                                       height,
                                       ptrG,
                                       strideG,
                                       ptrA,
                                       strideA,
                                       it);
            } else {
                dbgFile << "Saving as 12 bit monochrome";
                img.create(width, height, heif_colorspace_monochrome, heif_chroma_monochrome);
 
                img.add_plane(heif_channel_Y, width, height, 12);
 
                HeifStrideType strideG = 0;
                HeifStrideType strideA = 0;
 
                uint8_t *ptrG = heifGetPlaneMethod(img, heif_channel_Y, &strideG);
                uint8_t *ptrA = [&]() -> uint8_t * {
                    if (hasAlpha) {
                        img.add_plane(heif_channel_Alpha, width, height, 12);
                        return heifGetPlaneMethod(img, heif_channel_Alpha, &strideA);
                    } else {
                        return nullptr;
                    }
                }();
 
                KisPaintDeviceSP pd = image->projection();
                KisHLineConstIteratorSP it =
                    pd->createHLineConstIteratorNG(0, 0, width);
 
                Gray::writePlanarLayer(QSysInfo::ByteOrder,
                                       12,
                                       hasAlpha,
                                       width,
                                       height,
                                       ptrG,
                                       strideG,
                                       ptrA,
                                       strideA,
                                       it);
            }
        }
 
        // --- save the color profile.
        if (conversionPolicy == ConversionPolicy::KeepTheSame) {
            QByteArray rawProfileBA = image->colorSpace()->profile()->rawData();
            std::vector<uint8_t> rawProfile(rawProfileBA.begin(), rawProfileBA.end());
            img.set_raw_color_profile(heif_color_profile_type_prof, rawProfile);
        } else {
           heif::ColorProfile_nclx nclxDescription;
           nclxDescription.set_full_range_flag(true);
           nclxDescription.set_matrix_coefficients(heif_matrix_coefficients_RGB_GBR);
           if (convertToRec2020) {
#if LIBHEIF_HAVE_VERSION(1, 14, 1)
               nclxDescription.set_color_primaries(heif_color_primaries_ITU_R_BT_2020_2_and_2100_0);
#else
               nclxDescription.set_color_primaties(heif_color_primaries_ITU_R_BT_2020_2_and_2100_0);
#endif
           } else {
                const ColorPrimaries primaries =
                    image->colorSpace()->profile()->getColorPrimaries();
                // PRIMARIES_ADOBE_RGB_1998 and higher are not valid for CICP.
                // But this should have already been caught by the KeepTheSame
                // clause...
                KIS_SAFE_ASSERT_RECOVER(primaries <= PRIMARIES_EBU_Tech_3213_E) {
                    errFile << "Attempt to export a file with unsupported primaries" << primaries;
                    return ImportExportCodes::FormatColorSpaceUnsupported;
                }
#if LIBHEIF_HAVE_VERSION(1, 14, 1)
                nclxDescription.set_color_primaries(heif_color_primaries(primaries));
#else
                nclxDescription.set_color_primaties(heif_color_primaries(primaries));
#endif
           }
 
           if (conversionPolicy == ConversionPolicy::ApplyPQ) {
               nclxDescription.set_transfer_characteristics(heif_transfer_characteristic_ITU_R_BT_2100_0_PQ);
           } else if (conversionPolicy == ConversionPolicy::ApplyHLG) {
               nclxDescription.set_transfer_characteristics(heif_transfer_characteristic_ITU_R_BT_2100_0_HLG);
           } else if (conversionPolicy == ConversionPolicy::ApplySMPTE428) {
               nclxDescription.set_transfer_characteristics(heif_transfer_characteristic_SMPTE_ST_428_1);
           }
 
           img.set_nclx_color_profile(nclxDescription);
        }
 
 
        // --- encode and write image
 
        heif::Context::EncodingOptions options;
 
        // iOS gets confused when a heif file contains an nclx.
        // but we absolutely need it for hdr.
        if (conversionPolicy != ConversionPolicy::KeepTheSame && cs->hasHighDynamicRange()) {
            options.macOS_compatibility_workaround_no_nclx_profile = false;
        }
 
        heif::ImageHandle handle = ctx.encode_image(img, encoder, options);
 
 
        // --- add Exif / XMP metadata
 
        KisExifInfoVisitor exivInfoVisitor;
        exivInfoVisitor.visit(image->rootLayer().data());
 
        QScopedPointer<KisMetaData::Store> metaDataStore;
        if (exivInfoVisitor.metaDataCount() == 1) {
            metaDataStore.reset(new KisMetaData::Store(*exivInfoVisitor.exifInfo()));
        }
        else {
            metaDataStore.reset(new KisMetaData::Store());
        }
 
        if (!metaDataStore->empty()) {
            {
                KisMetaData::IOBackend *exifIO = KisMetadataBackendRegistry::instance()->value("exif");
                QBuffer buffer;
                exifIO->saveTo(metaDataStore.data(), &buffer, KisMetaData::IOBackend::NoHeader); // Or JpegHeader? Or something else?
                QByteArray data = buffer.data();
 
                // Write the data to the file
                if (data.size() > 4) {
                    ctx.add_exif_metadata(handle, data.constData(), data.size());
                }
            }
            {
                KisMetaData::IOBackend *xmpIO = KisMetadataBackendRegistry::instance()->value("xmp");
                QBuffer buffer;
                xmpIO->saveTo(metaDataStore.data(), &buffer, KisMetaData::IOBackend::NoHeader); // Or JpegHeader? Or something else?
                QByteArray data = buffer.data();
 
                // Write the data to the file
                if (data.size() > 0) {
                    ctx.add_XMP_metadata(handle, data.constData(), data.size());
                }
            }
        }
 
 
        // --- write HEIF file
 
        Writer_QIODevice writer(io);
 
        ctx.write(writer);
    } catch (Error &err) {
        return setHeifError(document, err);
    }
 
    return ImportExportCodes::OK;
}

References ApplyHLG, ApplyPQ, ApplySMPTE428, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KoColorSpaceRegistry::colorSpace(), KisImage::convertImageColorSpace(), KisPaintDevice::createHLineConstIteratorNG(), KisSharedPtr< T >::data(), dbgFile, encoder(), errFile, KisExifInfoVisitor::exifInfo(), ImportExportCodes::FormatColorSpaceUnsupported, KoColorProfile::getColorPrimaries(), KoColorSpaceRegistry::graya16(), GrayAColorModelID, KoColorSpace::hasHighDynamicRange(), KisImage::height(), KisImportExportFilter::ImageContainsTransparencyTag, KisMetadataBackendRegistry::instance(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KoColorProfile::isLinear(), KeepTheSame, KIS_SAFE_ASSERT_RECOVER, KisExifInfoVisitor::metaDataCount(), KisImportExportFilter::mimeType(), KoColorProfile::name, KisMetaData::IOBackend::NoHeader, ImportExportCodes::OK, PRIMARIES_EBU_Tech_3213_E, PRIMARIES_ITU_R_BT_2020_2_AND_2100_0, KoColorSpace::profile(), KoColorSpaceRegistry::profileFor(), KisImage::projection(), KoColorProfile::rawData(), KoColorSpaceRegistry::rgb8(), RGBAColorModelID, KisImage::rootLayer(), KisMetaData::IOBackend::saveTo(), setHeifError(), TRC_LINEAR, KoGenericRegistry< T >::value(), KisExifInfoVisitor::visit(), KisImage::waitForDone(), KisImage::width(), HDRFloat::writeInterleavedLayer(), HDRInt::writeInterleavedLayer(), Planar::writeLayer(), and Gray::writePlanarLayer().

createConfigurationWidget()

KisConfigWidget * HeifExport::createConfigurationWidget ( QWidget * parent, const QByteArray & from = "", const QByteArray & to = "" ) const

overridevirtual

createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter

Parameters

parent	the owner of the widget; the caller is responsible for deleting
from	The mimetype of the source file/document
to	The mimetype of the destination file/document

Returns

the widget

Reimplemented from KisImportExportFilter.

Definition at line 76 of file HeifExport.cpp.

{
    return new KisWdgOptionsHeif(parent);
}

defaultConfiguration()

KisPropertiesConfigurationSP HeifExport::defaultConfiguration ( const QByteArray & from = "", const QByteArray & to = "" ) const

overridevirtual

defaultConfiguration defines the default settings for the given import export filter

Parameters

from	The mimetype of the source file/document
to	The mimetype of the destination file/document

Returns

a serializable KisPropertiesConfiguration object

Reimplemented from KisImportExportFilter.

Definition at line 62 of file HeifExport.cpp.

{
    KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
    cfg->setProperty("quality", 100);
    cfg->setProperty("lossless", true);
    cfg->setProperty("chroma", "444");
    cfg->setProperty("floatingPointConversionOption", "KeepSame");
    cfg->setProperty("monochromeToSRGB", false);
    cfg->setProperty("HLGnominalPeak", 1000.0);
    cfg->setProperty("HLGgamma", 1.2);
    cfg->setProperty("removeHGLOOTF", true);
    return cfg;
}

initializeCapabilities()

void HeifExport::initializeCapabilities ( )

overridevirtual

Reimplemented from KisImportExportFilter.

Definition at line 515 of file HeifExport.cpp.

{
    // This checks before saving for what the file format supports: anything that is supported needs to be mentioned here
 
    QList<QPair<KoID, KoID> > supportedColorModels;
    addCapability(KisExportCheckRegistry::instance()->get("sRGBProfileCheck")->create(KisExportCheckBase::SUPPORTED));
    supportedColorModels << QPair<KoID, KoID>()
            << QPair<KoID, KoID>(RGBAColorModelID, Integer8BitsColorDepthID)
            << QPair<KoID, KoID>(GrayAColorModelID, Integer8BitsColorDepthID)
            << QPair<KoID, KoID>(RGBAColorModelID, Integer16BitsColorDepthID)
            << QPair<KoID, KoID>(GrayAColorModelID, Integer16BitsColorDepthID)
            ;
    addSupportedColorModels(supportedColorModels, "HEIF");
}

References KisImportExportFilter::addCapability(), KisImportExportFilter::addSupportedColorModels(), get(), GrayAColorModelID, KisExportCheckRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, RGBAColorModelID, and KisExportCheckBase::SUPPORTED.

supportsIO()

bool HeifExport::supportsIO ( ) const

inlineoverridevirtual

Override and return false for the filters that use a library that cannot handle file handles, only file names.

Reimplemented from KisImportExportFilter.

Definition at line 61 of file HeifExport.h.

{ return true; }

---

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

• plugins/impex/heif/HeifExport.h
• plugins/impex/heif/HeifExport.cpp