KisXMPIO Class Reference

#include <kis_xmp_io.h>

Inheritance diagram for KisXMPIO:

Public Member Functions
bool	canSaveAllEntries (KisMetaData::Store *) const override
QString	id () const override
	KisXMPIO ()
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
	~KisXMPIO () 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 15 of file kis_xmp_io.h.

Constructor & Destructor Documentation

KisXMPIO()

KisXMPIO::KisXMPIO

(

)

Definition at line 26 of file kis_xmp_io.cpp.

    : KisMetaData::IOBackend()
{
}

~KisXMPIO()

KisXMPIO::~KisXMPIO ( )

override

Definition at line 31 of file kis_xmp_io.cpp.

{
}

Member Function Documentation

canSaveAllEntries()

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

inlineoverridevirtual

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 37 of file kis_xmp_io.h.

    {
        return true;
    }

id()

QString KisXMPIO::id ( ) const

inlineoverridevirtual

Implements KisMetaData::IOBackend.

Definition at line 20 of file kis_xmp_io.h.

    {
        return "xmp";
    }

loadFrom()

bool KisXMPIO::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 230 of file kis_xmp_io.cpp.

{
    ioDevice->open(QIODevice::ReadOnly);
    dbgMetaData << "Load XMP Data";
    std::string xmpPacket_;
    QByteArray arr = ioDevice->readAll();
    xmpPacket_.assign(arr.data(), arr.length());
    dbgMetaData << xmpPacket_.length();
    //     dbgMetaData << xmpPacket_.c_str();
    Exiv2::XmpData xmpData_;
    if (Exiv2::XmpParser::decode(xmpData_, xmpPacket_) != 0) {
        warnMetaData << "Failed to decode as XMP";
        return false;
    }
    QMap<const KisMetaData::Schema *, QMap<QString, QMap<QString, KisMetaData::Value>>> structures;
    QMap<const KisMetaData::Schema *, QMap<QString, QVector<QMap<QString, KisMetaData::Value>>>> arraysOfStructures;
    for (Exiv2::XmpData::iterator it = xmpData_.begin(); it != xmpData_.end(); ++it) {
        dbgMetaData << "Start iteration" << it->key().c_str();
 
        Exiv2::XmpKey key(it->key());
        dbgMetaData << key.groupName().c_str() << " " << key.tagName().c_str() << " " << key.ns().c_str();
        if ((key.groupName() == "exif" || key.groupName() == "tiff")
            && key.tagName() == "NativeDigest") { // TODO: someone who has time to lose can look in adding support for
                                                  // NativeDigest, it's undocumented use by the XMP SDK to check if exif
                                                  // data has been changed while XMP hasn't been updated
            dbgMetaData << "dropped";
        } else {
            const KisMetaData::Schema *schema =
                KisMetaData::SchemaRegistry::instance()->schemaFromPrefix(key.groupName().c_str());
            if (!schema) {
                schema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(key.ns().c_str());
                if (!schema) {
                    schema = KisMetaData::SchemaRegistry::instance()->create(key.ns().c_str(), key.groupName().c_str());
                    Q_ASSERT(schema);
                }
            }
#if EXIV2_TEST_VERSION(0,28,0)
            const Exiv2::Value::UniquePtr value = it->getValue();
#else
            const Exiv2::Value::AutoPtr value = it->getValue();
#endif
            QString structName;
            int arrayIndex = -1;
            QString tagName;
            const KisMetaData::TypeInfo *typeInfo = 0;
 
            if (!parseTagName(key.tagName().c_str(), structName, arrayIndex, tagName, &typeInfo, schema))
                continue;
 
            bool isStructureEntry = !structName.isEmpty() && arrayIndex == -1;
            bool isStructureInArrayEntry = !structName.isEmpty() && arrayIndex != -1;
            Q_ASSERT(isStructureEntry != isStructureInArrayEntry || !isStructureEntry);
 
            KisMetaData::Value v;
            bool ignoreValue = false;
            // Compute the value
            if (value->typeId() == Exiv2::xmpBag || value->typeId() == Exiv2::xmpSeq
                || value->typeId() == Exiv2::xmpAlt) {
                const KisMetaData::TypeInfo *embeddedTypeInfo = 0;
                if (typeInfo) {
                    embeddedTypeInfo = typeInfo->embeddedPropertyType();
                }
                const KisMetaData::Parser *parser = 0;
                if (embeddedTypeInfo) {
                    parser = embeddedTypeInfo->parser();
                }
                const Exiv2::XmpArrayValue *xav = dynamic_cast<const Exiv2::XmpArrayValue *>(value.get());
                Q_ASSERT(xav);
                QList<KisMetaData::Value> array;
#if EXIV2_TEST_VERSION(0,28,0)
                for (size_t i = 0; i < xav->count(); ++i) {
#else
                for (int i = 0; i < xav->count(); ++i) {
#endif
                    QString value = QString::fromStdString(xav->toString(i));
                    if (parser) {
                        array.push_back(parser->parse(value));
                    } else {
                        dbgImage << "No parser " << tagName;
                        array.push_back(KisMetaData::Value(value));
                    }
                }
                KisMetaData::Value::ValueType vt = KisMetaData::Value::Invalid;
                switch (xav->xmpArrayType()) {
                case Exiv2::XmpValue::xaNone:
                    warnKrita << "KisXMPIO: Unsupported array";
                    break;
                case Exiv2::XmpValue::xaAlt:
                    vt = KisMetaData::Value::AlternativeArray;
                    break;
                case Exiv2::XmpValue::xaBag:
                    vt = KisMetaData::Value::UnorderedArray;
                    break;
                case Exiv2::XmpValue::xaSeq:
                    vt = KisMetaData::Value::OrderedArray;
                    break;
                }
                v = KisMetaData::Value(array, vt);
            } else if (value->typeId() == Exiv2::langAlt) {
                const Exiv2::LangAltValue *xav = dynamic_cast<const Exiv2::LangAltValue *>(value.get());
                KIS_ASSERT(xav);
 
                QList<KisMetaData::Value> alt;
                for (std::map<std::string, std::string>::const_iterator it = xav->value_.begin();
                     it != xav->value_.end();
                     ++it) {
                    KisMetaData::Value valt(it->second.c_str());
                    valt.addPropertyQualifier("xml:lang", KisMetaData::Value(it->first.c_str()));
                    alt.push_back(valt);
                }
                v = KisMetaData::Value(alt, KisMetaData::Value::LangArray);
            } else {
                QString valTxt = value->toString().c_str();
                if (typeInfo && typeInfo->parser()) {
                    v = typeInfo->parser()->parse(valTxt);
                } else {
                    dbgMetaData << "No parser " << tagName;
                    v = KisMetaData::Value(valTxt);
                }
                if (valTxt == "type=\"Struct\"") {
                    if (!typeInfo || typeInfo->propertyType() == KisMetaData::TypeInfo::StructureType) {
                        ignoreValue = true;
                    }
                }
            }
 
            // set the value
            if (isStructureEntry) {
                structures[schema][structName][tagName] = v;
            } else if (isStructureInArrayEntry) {
                if (arraysOfStructures[schema][structName].size() <= arrayIndex) {
                    arraysOfStructures[schema][structName].resize(arrayIndex + 1);
                }
 
                if (!arraysOfStructures[schema][structName][arrayIndex].contains(tagName)) {
                    arraysOfStructures[schema][structName][arrayIndex][tagName] = v;
                } else {
                    warnKrita << "WARNING: trying to overwrite tag" << tagName << "in" << structName << arrayIndex;
                }
            } else {
                if (!ignoreValue) {
                    store->addEntry(KisMetaData::Entry(schema, tagName, v));
                } else {
                    dbgMetaData << "Ignoring value for " << tagName << " " << v;
                }
            }
        }
    }
 
    for (QMap<const KisMetaData::Schema *, QMap<QString, QMap<QString, KisMetaData::Value>>>::iterator it =
             structures.begin();
         it != structures.end();
         ++it) {
        const KisMetaData::Schema *schema = it.key();
        for (QMap<QString, QMap<QString, KisMetaData::Value>>::iterator it2 = it.value().begin();
             it2 != it.value().end();
             ++it2) {
            store->addEntry(KisMetaData::Entry(schema, it2.key(), KisMetaData::Value(it2.value())));
        }
    }
    for (QMap<const KisMetaData::Schema *, QMap<QString, QVector<QMap<QString, KisMetaData::Value>>>>::iterator it =
             arraysOfStructures.begin();
         it != arraysOfStructures.end();
         ++it) {
        const KisMetaData::Schema *schema = it.key();
        for (QMap<QString, QVector<QMap<QString, KisMetaData::Value>>>::iterator it2 = it.value().begin();
             it2 != it.value().end();
             ++it2) {
            KisMetaData::Value::ValueType type = KisMetaData::Value::OrderedArray;
            QString entryName = it2.key();
            if (schema->propertyType(entryName)) {
                switch (schema->propertyType(entryName)->propertyType()) {
                case KisMetaData::TypeInfo::OrderedArrayType:
                    type = KisMetaData::Value::OrderedArray;
                    break;
                case KisMetaData::TypeInfo::UnorderedArrayType:
                    type = KisMetaData::Value::OrderedArray;
                    break;
                case KisMetaData::TypeInfo::AlternativeArrayType:
                    type = KisMetaData::Value::AlternativeArray;
                    break;
                default:
                    type = KisMetaData::Value::Invalid;
                    break;
                }
            } else if (store->containsEntry(schema, entryName)) {
                KisMetaData::Value value = store->getEntry(schema, entryName).value();
                if (value.isArray()) {
                    type = value.type();
                }
            }
            store->removeEntry(schema, entryName);
            if (type != KisMetaData::Value::Invalid) {
                QList<KisMetaData::Value> valueList;
                for (int i = 0; i < it2.value().size(); ++i) {
                    valueList.append(it2.value()[i]);
                }
                store->addEntry(KisMetaData::Entry(schema, entryName, KisMetaData::Value(valueList, type)));
            }
        }
    }
 
    return true;
}

References KisMetaData::Store::addEntry(), KisMetaData::Value::addPropertyQualifier(), KisMetaData::Value::AlternativeArray, KisMetaData::TypeInfo::AlternativeArrayType, KisMetaData::Store::containsEntry(), KisMetaData::SchemaRegistry::create(), dbgImage, dbgMetaData, KisMetaData::TypeInfo::embeddedPropertyType(), KisMetaData::Store::getEntry(), KisMetaData::SchemaRegistry::instance(), KisMetaData::Value::Invalid, KIS_ASSERT, KisMetaData::Value::LangArray, KisMetaData::Value::OrderedArray, KisMetaData::TypeInfo::OrderedArrayType, KisMetaData::Parser::parse(), KisMetaData::TypeInfo::parser(), parseTagName(), KisMetaData::TypeInfo::propertyType(), KisMetaData::Schema::propertyType(), KisMetaData::Store::removeEntry(), KisMetaData::SchemaRegistry::schemaFromPrefix(), KisMetaData::SchemaRegistry::schemaFromUri(), KisMetaData::TypeInfo::StructureType, KisMetaData::Value::type(), type(), KisMetaData::Value::UnorderedArray, KisMetaData::TypeInfo::UnorderedArrayType, v, KisMetaData::Entry::value(), value(), warnKrita, and warnMetaData.

name()

QString KisXMPIO::name ( ) const

inlineoverridevirtual

Implements KisMetaData::IOBackend.

Definition at line 24 of file kis_xmp_io.h.

    {
        return i18n("XMP");
    }

saveTo()

bool KisXMPIO::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 69 of file kis_xmp_io.cpp.

{
    dbgMetaData << "Save XMP Data";
    Exiv2::XmpData xmpData_;
 
    for (const KisMetaData::Entry &entry : *store) {
        // Check whether the prefix and namespace are know to exiv2
        std::string prefix = exiv2Prefix(entry.schema());
        dbgMetaData << "Saving " << entry.name();
 
        const KisMetaData::Value &value = entry.value();
 
        const KisMetaData::TypeInfo *typeInfo = entry.schema()->propertyType(entry.name());
        if (value.type() == KisMetaData::Value::Structure) {
            QMap<QString, KisMetaData::Value> structure = value.asStructure();
            const KisMetaData::Schema *structureSchema = 0;
            if (typeInfo) {
                structureSchema = typeInfo->structureSchema();
            }
            if (!structureSchema) {
                dbgMetaData << "Unknown schema for " << entry.name();
                structureSchema = entry.schema();
            }
            Q_ASSERT(structureSchema);
            saveStructure(xmpData_, entry.name(), prefix, structure, structureSchema);
        } else {
            Exiv2::XmpKey key(prefix, entry.name().toLatin1().constData());
            if (typeInfo
                && (typeInfo->propertyType() == KisMetaData::TypeInfo::OrderedArrayType
                    || typeInfo->propertyType() == KisMetaData::TypeInfo::UnorderedArrayType
                    || typeInfo->propertyType() == KisMetaData::TypeInfo::AlternativeArrayType)
                && typeInfo->embeddedPropertyType()->propertyType() == KisMetaData::TypeInfo::StructureType) {
                // Here is the bad part, again we need to do it by hand
                Exiv2::XmpTextValue tv;
                switch (typeInfo->propertyType()) {
                case KisMetaData::TypeInfo::OrderedArrayType:
                    tv.setXmpArrayType(Exiv2::XmpValue::xaSeq);
                    break;
                case KisMetaData::TypeInfo::UnorderedArrayType:
                    tv.setXmpArrayType(Exiv2::XmpValue::xaBag);
                    break;
                case KisMetaData::TypeInfo::AlternativeArrayType:
                    tv.setXmpArrayType(Exiv2::XmpValue::xaAlt);
                    break;
                default:
                    // Cannot happen
                    ;
                }
                xmpData_.add(key, &tv); // set the array type
                const KisMetaData::TypeInfo *structureTypeInfo = typeInfo->embeddedPropertyType();
                const KisMetaData::Schema *structureSchema = 0;
                if (structureTypeInfo) {
                    structureSchema = structureTypeInfo->structureSchema();
                }
                if (!structureSchema) {
                    dbgMetaData << "Unknown schema for " << entry.name();
                    structureSchema = entry.schema();
                }
                Q_ASSERT(structureSchema);
                QList<KisMetaData::Value> array = value.asArray();
                for (int idx = 0; idx < array.size(); ++idx) {
                    saveStructure(xmpData_,
                                  QString("%1[%2]").arg(entry.name()).arg(idx + 1),
                                  prefix,
                                  array[idx].asStructure(),
                                  structureSchema);
                }
            } else {
                dbgMetaData << ppVar(key.key().c_str());
                Exiv2::Value *v = kmdValueToExivXmpValue(value);
                if (v) {
                    xmpData_.add(key, v);
                }
            }
        }
        // TODO property qualifier
    }
    // Serialize data
    std::string xmpPacket_;
    try {
        Exiv2::XmpParser::encode(xmpPacket_, xmpData_);
    } catch (std::exception &e) {
        warnMetaData << "Couldn't encode the data, error =" << e.what();
        return false;
    }
    // Save data into the IO device
    ioDevice->open(QIODevice::WriteOnly);
    if (headerType == KisMetaData::IOBackend::JpegHeader) {
        xmpPacket_ = "http://ns.adobe.com/xap/1.0/\0" + xmpPacket_;
    }
    ioDevice->write(xmpPacket_.c_str(), xmpPacket_.length());
    return true;
}

References KisMetaData::TypeInfo::AlternativeArrayType, dbgMetaData, KisMetaData::TypeInfo::embeddedPropertyType(), exiv2Prefix(), KisMetaData::IOBackend::JpegHeader, kmdValueToExivXmpValue(), KisMetaData::TypeInfo::OrderedArrayType, ppVar, KisMetaData::TypeInfo::propertyType(), KisMetaData::Value::Structure, KisMetaData::TypeInfo::structureSchema(), KisMetaData::TypeInfo::StructureType, KisMetaData::TypeInfo::UnorderedArrayType, v, value(), and warnMetaData.

supportLoading()

bool KisXMPIO::supportLoading ( ) const

inlineoverridevirtual

Returns

true if this backend support loading

Implements KisMetaData::IOBackend.

Definition at line 41 of file kis_xmp_io.h.

    {
        return true;
    }

supportSaving()

bool KisXMPIO::supportSaving ( ) const

inlineoverridevirtual

Returns

tell if this backend support saving

Implements KisMetaData::IOBackend.

Definition at line 32 of file kis_xmp_io.h.

    {
        return true;
    }

type()

BackendType KisXMPIO::type ( ) const

inlineoverridevirtual

Returns

the type of the backend

Implements KisMetaData::IOBackend.

Definition at line 28 of file kis_xmp_io.h.

    {
        return Text;
    }

References KisMetaData::IOBackend::Text.

---

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

• plugins/metadata/xmp/kis_xmp_io.h
• plugins/metadata/xmp/kis_xmp_io.cpp