KisExifIO Class Reference

#include <kis_exif_io.h>

Inheritance diagram for KisExifIO:

Public Member Functions
bool	canSaveAllEntries (KisMetaData::Store *store) const override
QString	id () const override
	KisExifIO ()
bool	loadFrom (KisMetaData::Store *store, QIODevice *ioDevice) const override
QString	name () const override
bool	saveTo (const KisMetaData::Store *store, QIODevice *ioDevice, HeaderType headerType=NoHeader) const override
bool	supportLoading () const override
bool	supportSaving () const override
BackendType	type () const override
	~KisExifIO () override
Public Member Functions inherited from KisMetaData::IOBackend
virtual	~IOBackend ()

Additional Inherited Members
Public Types inherited from KisMetaData::IOBackend
enum	BackendType { Binary , Text }
enum	HeaderType { NoHeader , JpegHeader }

Detailed Description

Definition at line 17 of file kis_exif_io.h.

Constructor & Destructor Documentation

KisExifIO()

KisExifIO::KisExifIO

(

)

Definition at line 409 of file kis_exif_io.cpp.

    : KisMetaData::IOBackend()
{
}

~KisExifIO()

KisExifIO::~KisExifIO ( )

override

Definition at line 414 of file kis_exif_io.cpp.

{
}

Member Function Documentation

canSaveAllEntries()

bool KisExifIO::canSaveAllEntries ( KisMetaData::Store * store ) const

overridevirtual

Parameters

store

the list of metadata

Returns

true if this backend is capable of saving all the metadata of the store

Implements KisMetaData::IOBackend.

Definition at line 554 of file kis_exif_io.cpp.

{
    return false; // It's a known fact that exif can't save all information, but TODO: write the check
}

id()

QString KisExifIO::id ( ) const

inlineoverridevirtual

Implements KisMetaData::IOBackend.

Definition at line 22 of file kis_exif_io.h.

    {
        return "exif";
    }

loadFrom()

bool KisExifIO::loadFrom ( KisMetaData::Store * store, QIODevice * ioDevice ) const

overridevirtual

Parameters

store	the list of metadata to load
ioDevice	the device from where the metadata will be loaded

Returns

true if the load was successful

Implements KisMetaData::IOBackend.

Definition at line 559 of file kis_exif_io.cpp.

{
    if (!ioDevice->open(QIODevice::ReadOnly)) {
        return false;
    }
    QByteArray arr(ioDevice->readAll());
    Exiv2::ExifData exifData;
    Exiv2::ByteOrder byteOrder;
#if !EXIV2_TEST_VERSION(0, 18, 0)
    exifData.load((const Exiv2::byte *)arr.data(), arr.size());
    byteOrder = exifData.byteOrder();
#else
    try {
        byteOrder =
            Exiv2::ExifParser::decode(exifData, (const Exiv2::byte *)arr.data(), static_cast<uint32_t>(arr.size()));
    } catch (const std::exception &ex) {
        warnKrita << "Received exception trying to parse exiv data" << ex.what();
        return false;
    } catch (...) {
        dbgKrita << "Received unknown exception trying to parse exiv data";
        return false;
    }
#endif
    dbgMetaData << "Byte order = " << byteOrder << ppVar(Exiv2::bigEndian) << ppVar(Exiv2::littleEndian);
    dbgMetaData << "There are" << exifData.count() << " entries in the exif section";
    const KisMetaData::Schema *tiffSchema =
        KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::TIFFSchemaUri);
    Q_ASSERT(tiffSchema);
    const KisMetaData::Schema *exifSchema =
        KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::EXIFSchemaUri);
    Q_ASSERT(exifSchema);
    const KisMetaData::Schema *dcSchema =
        KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::DublinCoreSchemaUri);
    Q_ASSERT(dcSchema);
    const KisMetaData::Schema *xmpSchema =
        KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::XMPSchemaUri);
    Q_ASSERT(xmpSchema);
    const KisMetaData::Schema *makerNoteSchema =
        KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::MakerNoteSchemaUri);
    Q_ASSERT(makerNoteSchema);
 
    for (const Exiv2::Exifdatum &it : exifData) {
        const uint16_t tag = it.tag();
 
        if (tag == Exif::Image::StripOffsets || tag == Exif::Image::RowsPerStrip || tag == Exif::Image::StripByteCounts
            || tag == Exif::Image::JPEGInterchangeFormat || tag == Exif::Image::JPEGInterchangeFormatLength
            || it.tagName() == "0x0000") {
            dbgMetaData << it.key().c_str() << " is ignored";
        } else if (tag == Exif::Photo::MakerNote) {
            store->addEntry({makerNoteSchema, "RawData", exivValueToKMDValue(it.getValue(), false)});
        } else if (tag == Exif::Image::DateTime) { // load as xmp:ModifyDate
            store->addEntry({xmpSchema, "ModifyDate", exivValueToKMDValue(it.getValue(), false)});
        } else if (tag == Exif::Image::ImageDescription) { // load as "dc:description"
            store->addEntry({dcSchema, "description", exivValueToKMDValue(it.getValue(), false)});
        } else if (tag == Exif::Image::Software) { // load as "xmp:CreatorTool"
            store->addEntry({xmpSchema, "CreatorTool", exivValueToKMDValue(it.getValue(), false)});
        } else if (tag == Exif::Image::Artist) { // load as dc:creator
            QList<KisMetaData::Value> creators = {exivValueToKMDValue(it.getValue(), false)};
            store->addEntry({dcSchema, "creator", {creators, KisMetaData::Value::OrderedArray}});
        } else if (tag == Exif::Image::Copyright) { // load as dc:rights
            store->addEntry({dcSchema, "rights", exivValueToKMDValue(it.getValue(), false)});
        } else if (it.groupName() == "Image") {
            // Tiff tags
            const QString fixedTN(it.tagName().c_str());
            if (tag == Exif::Image::ExifTag || tag == Exif::Image::GPSTag) {
                dbgMetaData << "Ignoring " << it.key().c_str();
            } else if (KisMetaData::Entry::isValidName(fixedTN)) {
                store->addEntry({tiffSchema, fixedTN, exivValueToKMDValue(it.getValue(), false)});
            } else {
                dbgMetaData << "Invalid tag name: " << fixedTN;
            }
        } else if (it.groupName() == "Photo") {
            // Exif tags
            KisMetaData::Value metaDataValue;
            if (tag == Exif::Photo::ExifVersion || tag == Exif::Photo::FlashpixVersion) {
                metaDataValue = exifVersionToKMDValue(it.getValue());
            } else if (tag == Exif::Photo::FileSource) {
                metaDataValue = KisMetaData::Value(3);
            } else if (tag == Exif::Photo::SceneType) {
                metaDataValue = KisMetaData::Value(1);
            } else if (tag == Exif::Photo::ComponentsConfiguration) {
                metaDataValue = exifArrayToKMDIntOrderedArray(it.getValue());
            } else if (tag == Exif::Photo::OECF) {
                metaDataValue = exifOECFToKMDOECFStructure(it.getValue(), byteOrder);
            } else if (tag == Exif::Photo::DateTimeDigitized || tag == Exif::Photo::DateTimeOriginal) {
                metaDataValue = exivValueToKMDValue(it.getValue(), false);
            } else if (tag == Exif::Photo::DeviceSettingDescription) {
                metaDataValue = deviceSettingDescriptionExifToKMD(it.getValue());
            } else if (tag == Exif::Photo::CFAPattern) {
                metaDataValue = cfaPatternExifToKMD(it.getValue(), byteOrder);
            } else if (tag == Exif::Photo::Flash) {
                metaDataValue = flashExifToKMD(it.getValue());
            } else if (tag == Exif::Photo::UserComment) {
                if (it.getValue()->typeId() != Exiv2::undefined) {
                    KisMetaData::Value vUC = exivValueToKMDValue(it.getValue(), false);
                    Q_ASSERT(vUC.type() == KisMetaData::Value::Variant);
                    QVariant commentVar = vUC.asVariant();
                    QString comment;
                    if (commentVar.type() == QVariant::String) {
                        comment = commentVar.toString();
                    } else if (commentVar.type() == QVariant::ByteArray) {
                        const QByteArray commentString = commentVar.toByteArray();
                        comment = QString::fromLatin1(commentString.constData(), commentString.size());
                    } else {
                        warnKrita << "KisExifIO: Unhandled UserComment value type.";
                    }
                    KisMetaData::Value vcomment(comment);
                    vcomment.addPropertyQualifier("xml:lang", KisMetaData::Value("x-default"));
                    QList<KisMetaData::Value> alt;
                    alt.append(vcomment);
                    metaDataValue = KisMetaData::Value(alt, KisMetaData::Value::LangArray);
                }
            } else {
                bool forceSeq = false;
                KisMetaData::Value::ValueType arrayType = KisMetaData::Value::UnorderedArray;
                if (tag == Exif::Photo::ISOSpeedRatings) {
                    forceSeq = true;
                    arrayType = KisMetaData::Value::OrderedArray;
                }
                metaDataValue = exivValueToKMDValue(it.getValue(), forceSeq, arrayType);
            }
            if (tag == Exif::Photo::InteroperabilityTag || tag == 0xea1d
                || metaDataValue.type() == KisMetaData::Value::Invalid) { // InteroperabilityTag isn't useful for XMP,
                // 0xea1d isn't a valid Exif tag
                warnMetaData << "Ignoring " << it.key().c_str();
 
            } else {
                store->addEntry({exifSchema, it.tagName().c_str(), metaDataValue});
            }
        } else if (it.groupName() == "Thumbnail") {
            dbgMetaData << "Ignoring thumbnail tag :" << it.key().c_str();
        } else if (it.groupName() == "GPSInfo") {
            store->addEntry({exifSchema, it.tagName().c_str(), exivValueToKMDValue(it.getValue(), false)});
        } else {
            dbgMetaData << "Unknown exif tag, cannot load:" << it.key().c_str();
        }
    }
    ioDevice->close();
    return true;
}

References KisMetaData::Store::addEntry(), KisMetaData::Value::addPropertyQualifier(), Exif::Image::Artist, KisMetaData::Value::asVariant(), Exif::Photo::CFAPattern, cfaPatternExifToKMD(), Exif::Photo::ComponentsConfiguration, Exif::Image::Copyright, Exif::Image::DateTime, Exif::Photo::DateTimeDigitized, Exif::Photo::DateTimeOriginal, dbgKrita, dbgMetaData, Exif::Photo::DeviceSettingDescription, deviceSettingDescriptionExifToKMD(), KisMetaData::Schema::DublinCoreSchemaUri, exifArrayToKMDIntOrderedArray(), exifOECFToKMDOECFStructure(), KisMetaData::Schema::EXIFSchemaUri, Exif::Image::ExifTag, Exif::Photo::ExifVersion, exifVersionToKMDValue(), exivValueToKMDValue(), Exif::Photo::FileSource, Exif::Photo::Flash, flashExifToKMD(), Exif::Photo::FlashpixVersion, Exif::Image::GPSTag, Exif::Image::ImageDescription, KisMetaData::SchemaRegistry::instance(), Exif::Photo::InteroperabilityTag, KisMetaData::Value::Invalid, Exif::Photo::ISOSpeedRatings, KisMetaData::Entry::isValidName(), Exif::Image::JPEGInterchangeFormat, Exif::Image::JPEGInterchangeFormatLength, KisMetaData::Value::LangArray, Exif::Photo::MakerNote, KisMetaData::Schema::MakerNoteSchemaUri, Exif::Photo::OECF, KisMetaData::Value::OrderedArray, ppVar, Exif::Image::RowsPerStrip, Exif::Photo::SceneType, KisMetaData::SchemaRegistry::schemaFromUri(), Exif::Image::Software, Exif::Image::StripByteCounts, Exif::Image::StripOffsets, KisMetaData::Schema::TIFFSchemaUri, KisMetaData::Value::type(), KisMetaData::Value::UnorderedArray, Exif::Photo::UserComment, KisMetaData::Value::Variant, warnKrita, warnMetaData, and KisMetaData::Schema::XMPSchemaUri.

name()

QString KisExifIO::name ( ) const

inlineoverridevirtual

Implements KisMetaData::IOBackend.

Definition at line 26 of file kis_exif_io.h.

    {
        return i18n("Exif");
    }

saveTo()

bool KisExifIO::saveTo ( const KisMetaData::Store * store, QIODevice * ioDevice, HeaderType headerType = NoHeader ) const

overridevirtual

Parameters

store	the list of metadata to save
ioDevice	the device to where the metadata will be saved
headerType	determine if an header must be prepend to the binary header, and if it does, which type of header

Returns

true if the save was successful (XXX: actually, all backends always return true...)

Implements KisMetaData::IOBackend.

Definition at line 418 of file kis_exif_io.cpp.

{
    ioDevice->open(QIODevice::WriteOnly);
    Exiv2::ExifData exifData;
    if (headerType == KisMetaData::IOBackend::JpegHeader) {
        QByteArray header(6, 0);
        header[0] = 0x45;
        header[1] = 0x78;
        header[2] = 0x69;
        header[3] = 0x66;
        header[4] = 0x00;
        header[5] = 0x00;
        ioDevice->write(header);
    }
 
    for (const KisMetaData::Entry &entry : *store) {
        try {
            dbgMetaData << "Trying to save: " << entry.name() << " of " << entry.schema()->prefix() << ":"
                        << entry.schema()->uri();
            QString exivKey;
            if (entry.schema()->uri() == KisMetaData::Schema::TIFFSchemaUri) {
                exivKey = "Exif.Image." + entry.name();
            } else if (entry.schema()->uri()
                       == KisMetaData::Schema::EXIFSchemaUri) { // Distinguish between exif and gps
                if (entry.name().left(3) == "GPS") {
                    exivKey = "Exif.GPSInfo." + entry.name();
                } else {
                    exivKey = "Exif.Photo." + entry.name();
                }
            } else if (entry.schema()->uri() == KisMetaData::Schema::DublinCoreSchemaUri) {
                if (entry.name() == "description") {
                    exivKey = "Exif.Image.ImageDescription";
                } else if (entry.name() == "creator") {
                    exivKey = "Exif.Image.Artist";
                } else if (entry.name() == "rights") {
                    exivKey = "Exif.Image.Copyright";
                }
            } else if (entry.schema()->uri() == KisMetaData::Schema::XMPSchemaUri) {
                if (entry.name() == "ModifyDate") {
                    exivKey = "Exif.Image.DateTime";
                } else if (entry.name() == "CreatorTool") {
                    exivKey = "Exif.Image.Software";
                }
            } else if (entry.schema()->uri() == KisMetaData::Schema::MakerNoteSchemaUri) {
                if (entry.name() == "RawData") {
                    exivKey = "Exif.Photo.MakerNote";
                }
            }
            dbgMetaData << "Saving " << entry.name() << " to " << exivKey;
            if (exivKey.isEmpty()) {
                dbgMetaData << entry.qualifiedName() << " is unsavable to EXIF";
            } else {
                Exiv2::ExifKey exifKey(qPrintable(exivKey));
                Exiv2::Value *v = 0;
                if (exivKey == "Exif.Photo.ExifVersion" || exivKey == "Exif.Photo.FlashpixVersion") {
                    v = kmdValueToExifVersion(entry.value());
                } else if (exivKey == "Exif.Photo.FileSource") {
                    char s[] = {0x03};
                    v = new Exiv2::DataValue((const Exiv2::byte *)s, 1);
                } else if (exivKey == "Exif.Photo.SceneType") {
                    char s[] = {0x01};
                    v = new Exiv2::DataValue((const Exiv2::byte *)s, 1);
                } else if (exivKey == "Exif.Photo.ComponentsConfiguration") {
                    v = kmdIntOrderedArrayToExifArray(entry.value());
                } else if (exivKey == "Exif.Image.Artist") { // load as dc:creator
                    KisMetaData::Value creator = entry.value();
                    if (entry.value().asArray().size() > 0) {
                        creator = entry.value().asArray()[0];
                    }
#if !EXIV2_TEST_VERSION(0, 21, 0)
                    v = kmdValueToExivValue(creator, Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
#else
                    v = kmdValueToExivValue(creator, exifKey.defaultTypeId());
#endif
                } else if (exivKey == "Exif.Photo.OECF") {
                    v = kmdOECFStructureToExifOECF(entry.value());
                } else if (exivKey == "Exif.Photo.DeviceSettingDescription") {
                    v = deviceSettingDescriptionKMDToExif(entry.value());
                } else if (exivKey == "Exif.Photo.CFAPattern") {
                    v = cfaPatternKMDToExif(entry.value());
                } else if (exivKey == "Exif.Photo.Flash") {
                    v = flashKMDToExif(entry.value());
                } else if (exivKey == "Exif.Photo.UserComment") {
                    Q_ASSERT(entry.value().type() == KisMetaData::Value::LangArray);
                    QMap<QString, KisMetaData::Value> langArr = entry.value().asLangArray();
                    if (langArr.contains("x-default")) {
#if !EXIV2_TEST_VERSION(0, 21, 0)
                        v = kmdValueToExivValue(langArr.value("x-default"),
                                                Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
#else
                        v = kmdValueToExivValue(langArr.value("x-default"), exifKey.defaultTypeId());
#endif
                    } else if (langArr.size() > 0) {
#if !EXIV2_TEST_VERSION(0, 21, 0)
                        v = kmdValueToExivValue(langArr.begin().value(),
                                                Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
#else
                        v = kmdValueToExivValue(langArr.begin().value(), exifKey.defaultTypeId());
#endif
                    }
                } else {
                    dbgMetaData << exifKey.tag();
#if !EXIV2_TEST_VERSION(0, 21, 0)
                    v = kmdValueToExivValue(entry.value(), Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
#else
                    v = kmdValueToExivValue(entry.value(), exifKey.defaultTypeId());
#endif
                }
                if (v && v->typeId() != Exiv2::invalidTypeId) {
                    dbgMetaData << "Saving key" << exivKey << " of KMD value" << entry.value();
                    exifData.add(exifKey, v);
                } else {
                    dbgMetaData << "No exif value was created for" << entry.qualifiedName() << " as"
                                << exivKey; // << " of KMD value" << entry.value();
                }
            }
#if EXIV2_TEST_VERSION(0,28,0)
        } catch (Exiv2::Error &e) {
#else
        } catch (Exiv2::AnyError &e) {
#endif
            dbgMetaData << "exiv error " << e.what();
        }
    }
#if !EXIV2_TEST_VERSION(0, 18, 0)
    Exiv2::DataBuf rawData = exifData.copy();
    ioDevice->write((const char *)rawData.pData_, rawData.size_);
#else
    Exiv2::Blob rawData;
    Exiv2::ExifParser::encode(rawData, Exiv2::littleEndian, exifData);
    ioDevice->write((const char *)&*rawData.begin(), static_cast<int>(rawData.size()));
#endif
    ioDevice->close();
    return true;
}

References KisMetaData::Value::asArray(), cfaPatternKMDToExif(), dbgMetaData, deviceSettingDescriptionKMDToExif(), KisMetaData::Schema::DublinCoreSchemaUri, KisMetaData::Schema::EXIFSchemaUri, flashKMDToExif(), KisMetaData::IOBackend::JpegHeader, kmdIntOrderedArrayToExifArray(), kmdOECFStructureToExifOECF(), kmdValueToExifVersion(), kmdValueToExivValue(), KisMetaData::Value::LangArray, KisMetaData::Schema::MakerNoteSchemaUri, KisMetaData::Schema::TIFFSchemaUri, v, and KisMetaData::Schema::XMPSchemaUri.

supportLoading()

bool KisExifIO::supportLoading ( ) const

inlineoverridevirtual

Returns

true if this backend support loading

Implements KisMetaData::IOBackend.

Definition at line 40 of file kis_exif_io.h.

    {
        return true;
    }

supportSaving()

bool KisExifIO::supportSaving ( ) const

inlineoverridevirtual

Returns

tell if this backend support saving

Implements KisMetaData::IOBackend.

Definition at line 34 of file kis_exif_io.h.

    {
        return true;
    }

type()

BackendType KisExifIO::type ( ) const

inlineoverridevirtual

Returns

the type of the backend

Implements KisMetaData::IOBackend.

Definition at line 30 of file kis_exif_io.h.

    {
        return Binary;
    }

References KisMetaData::IOBackend::Binary.

---

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

• plugins/metadata/exif/kis_exif_io.h
• plugins/metadata/exif/kis_exif_io.cpp