SkXmp.cpp File Reference

#include "include/private/SkXmp.h"
#include "include/core/SkColor.h"
#include "include/core/SkData.h"
#include "include/core/SkScalar.h"
#include "include/core/SkStream.h"
#include "include/private/SkGainmapInfo.h"
#include "include/utils/SkParse.h"
#include "src/codec/SkCodecPriv.h"
#include "src/xml/SkDOM.h"
#include <cmath>
#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
#include <utility>

Go to the source code of this file.

Classes
class	SkXmpImpl

Functions
static const char *	get_namespace_prefix (const char *name)
static const char *	get_unique_child_text (const SkDOM &dom, const SkDOM::Node *node, const std::string &childName)
static const SkDOM::Node *	get_typed_child (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &type)
static const char *	get_attr (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &key)
static bool	get_attr_bool (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &key, bool *outValue)
static bool	get_attr_int32 (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &key, int32_t *value)
static bool	get_attr_float (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &key, float *outValue)
static bool	get_attr_float3_as_list (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &key, SkColor4f *outValue)
static bool	get_attr_float3 (const SkDOM *dom, const SkDOM::Node *node, const std::string &prefix, const std::string &key, SkColor4f *outValue)
static void	find_uri_namespaces (const SkDOM &dom, const SkDOM::Node *node, size_t count, const char *uris[], const char *outNamespaces[])
static const SkDOM::Node *	find_uri_namespaces (const SkDOM &dom, size_t count, const char *uris[], const char *outNamespaces[])

Variables
const char *	kXmlnsPrefix = "xmlns:"
const size_t	kXmlnsPrefixLength = 6

Function Documentation

find_uri_namespaces() [1/2]

static void find_uri_namespaces ( const SkDOM &  dom, const SkDOM::Node *  node, size_t  count, const char *  uris[], const char *  outNamespaces[]  )

static

Definition at line 271 of file SkXmp.cpp.

                                                             {
    // Search all attributes for xmlns:NAMESPACEi="URIi".
    for (const auto* attr = dom.getFirstAttr(node); attr; attr = dom.getNextAttr(node, attr)) {
        const char* attrName = dom.getAttrName(node, attr);
        const char* attrValue = dom.getAttrValue(node, attr);
        if (!attrName || !attrValue) {
            continue;
        }
        // Make sure the name starts with "xmlns:".
        if (strlen(attrName) <= kXmlnsPrefixLength) {
            continue;
        }
        if (memcmp(attrName, kXmlnsPrefix, kXmlnsPrefixLength) != 0) {
            continue;
        }
        // Search for a requested URI that matches.
        for (size_t i = 0; i < count; ++i) {
            if (strcmp(attrValue, uris[i]) != 0) {
                continue;
            }
            outNamespaces[i] = attrName;
        }
    }
}

find_uri_namespaces() [2/2]

static const SkDOM::Node * find_uri_namespaces ( const SkDOM &  dom, size_t  count, const char *  uris[], const char *  outNamespaces[]  )

static

Definition at line 302 of file SkXmp.cpp.

                                                                           {
    const SkDOM::Node* root = dom.getRootNode();
    if (!root) {
        return nullptr;
    }
 
    // Ensure that the root node identifies itself as XMP metadata.
    const char* rootName = dom.getName(root);
    if (!rootName || strcmp(rootName, "x:xmpmeta") != 0) {
        return nullptr;
    }
 
    //  Iterate the children with name rdf:RDF.
    const char* kRdf = "rdf:RDF";
    for (const auto* rdf = dom.getFirstChild(root, kRdf); rdf;
         rdf = dom.getNextSibling(rdf, kRdf)) {
        std::vector<const char*> rdfNamespaces(count, nullptr);
        find_uri_namespaces(dom, rdf, count, uris, rdfNamespaces.data());
 
        // Iterate the children with name rdf::Description.
        const char* kDesc = "rdf:Description";
        for (const auto* desc = dom.getFirstChild(rdf, kDesc); desc;
             desc = dom.getNextSibling(desc, kDesc)) {
            std::vector<const char*> descNamespaces = rdfNamespaces;
            find_uri_namespaces(dom, desc, count, uris, descNamespaces.data());
 
            // If we have a match for all the requested URIs, return.
            bool foundAllUris = true;
            for (size_t i = 0; i < count; ++i) {
                if (!descNamespaces[i]) {
                    foundAllUris = false;
                    break;
                }
            }
            if (foundAllUris) {
                for (size_t i = 0; i < count; ++i) {
                    outNamespaces[i] = descNamespaces[i];
                }
                return desc;
            }
        }
    }
    return nullptr;
}

get_attr()

static const char * get_attr ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  key  )

static

Definition at line 125 of file SkXmp.cpp.

                                                  {
    const auto name = prefix + ":" + key;
    const char* attr = dom->findAttr(node, name.c_str());
    if (attr) {
        return attr;
    }
    return get_unique_child_text(*dom, node, name);
}

get_attr_bool()

static bool get_attr_bool ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  key, bool *  outValue  )

static

Definition at line 138 of file SkXmp.cpp.

                                          {
    const char* attr = get_attr(dom, node, prefix, key);
    if (!attr) {
        return false;
    }
    switch (SkParse::FindList(attr, "False,True")) {
        case 0:
            *outValue = false;
            return true;
        case 1:
            *outValue = true;
            return true;
        default:
            break;
    }
    return false;
}

get_attr_float()

static bool get_attr_float ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  key, float *  outValue  )

static

Definition at line 177 of file SkXmp.cpp.

                                            {
    const char* attr = get_attr(dom, node, prefix, key);
    if (!attr) {
        return false;
    }
    SkScalar value = 0.f;
    if (SkParse::FindScalar(attr, &value)) {
        *outValue = value;
        return true;
    }
    return false;
}

get_attr_float3()

static bool get_attr_float3 ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  key, SkColor4f *  outValue  )

static

Definition at line 255 of file SkXmp.cpp.

                                                 {
    if (get_attr_float3_as_list(dom, node, prefix, key, outValue)) {
        return true;
    }
    SkScalar value = -1.0;
    if (get_attr_float(dom, node, prefix, key, &value)) {
        *outValue = {value, value, value, 1.f};
        return true;
    }
    return false;
}

get_attr_float3_as_list()

static bool get_attr_float3_as_list ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  key, SkColor4f *  outValue  )

static

Definition at line 196 of file SkXmp.cpp.

                                                         {
    const auto name = prefix + ":" + key;
 
    // Fail if there are multiple children with childName.
    if (dom->countChildren(node, name.c_str()) != 1) {
        return false;
    }
    // Find the child.
    const auto* child = dom->getFirstChild(node, name.c_str());
    if (!child) {
        return false;
    }
 
    // Search for the rdf:Seq child.
    const auto* seq = dom->getFirstChild(child, "rdf:Seq");
    if (!seq) {
        return false;
    }
 
    size_t count = 0;
    SkScalar values[3] = {0.f, 0.f, 0.f};
    for (const auto* liNode = dom->getFirstChild(seq, "rdf:li"); liNode;
         liNode = dom->getNextSibling(liNode, "rdf:li")) {
        if (count > 2) {
            SkCodecPrintf("Too many items in list.\n");
            return false;
        }
        if (dom->countChildren(liNode) != 1) {
            SkCodecPrintf("Item can only have one child.\n");
            return false;
        }
        const auto* liTextNode = dom->getFirstChild(liNode);
        if (dom->getType(liTextNode) != SkDOM::kText_Type) {
            SkCodecPrintf("Item's only child must be text.\n");
            return false;
        }
        const char* liText = dom->getName(liTextNode);
        if (!liText) {
            SkCodecPrintf("Failed to get item's text.\n");
            return false;
        }
        if (!SkParse::FindScalar(liText, values + count)) {
            SkCodecPrintf("Failed to parse item's text to float.\n");
            return false;
        }
        count += 1;
    }
    if (count < 3) {
        SkCodecPrintf("List didn't have enough items.\n");
        return false;
    }
    *outValue = {values[0], values[1], values[2], 1.f};
    return true;
}

get_attr_int32()

static bool get_attr_int32 ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  key, int32_t *  value  )

static

Definition at line 161 of file SkXmp.cpp.

                                           {
    const char* attr = get_attr(dom, node, prefix, key);
    if (!attr) {
        return false;
    }
    if (!SkParse::FindS32(attr, value)) {
        return false;
    }
    return true;
}

get_namespace_prefix()

static const char * get_namespace_prefix ( const char *  name )

static

Definition at line 32 of file SkXmp.cpp.

                                                          {
    if (strlen(name) <= kXmlnsPrefixLength) {
        return nullptr;
    }
    return name + kXmlnsPrefixLength;
}

get_typed_child()

static const SkDOM::Node * get_typed_child ( const SkDOM *  dom, const SkDOM::Node *  node, const std::string &  prefix, const std::string &  type  )

static

Definition at line 86 of file SkXmp.cpp.

                                                                 {
    const auto name = prefix + std::string(":") + type;
    const SkDOM::Node* child = dom->getFirstChild(node, name.c_str());
    if (child) {
        return child;
    }
 
    const SkDOM::Node* typeChild = dom->getFirstChild(node, "rdf:type");
    if (!typeChild) {
        return nullptr;
    }
    const char* typeChildResource = dom->findAttr(typeChild, "rdf:resource");
    if (!typeChildResource || typeChildResource != type) {
        return nullptr;
    }
 
    const SkDOM::Node* valueChild = dom->getFirstChild(node, "rdf:value");
    if (!valueChild) {
        return nullptr;
    }
    const char* valueChildParseType = dom->findAttr(valueChild, "rdf:parseType");
    if (!valueChildParseType || strcmp(valueChildParseType, "Resource") != 0) {
        return nullptr;
    }
    return valueChild;
}

get_unique_child_text()

static const char * get_unique_child_text ( const SkDOM &  dom, const SkDOM::Node *  node, const std::string &  childName  )

static

Definition at line 52 of file SkXmp.cpp.

                                                                     {
    // Fail if there are multiple children with childName.
    if (dom.countChildren(node, childName.c_str()) != 1) {
        return nullptr;
    }
    const auto* child = dom.getFirstChild(node, childName.c_str());
    if (!child) {
        return nullptr;
    }
    // Fail if the child has any children besides text.
    if (dom.countChildren(child) != 1) {
        return nullptr;
    }
    const auto* grandChild = dom.getFirstChild(child);
    if (dom.getType(grandChild) != SkDOM::kText_Type) {
        return nullptr;
    }
    // Return the text.
    return dom.getName(grandChild);
}

Variable Documentation

kXmlnsPrefix

const char* kXmlnsPrefix = "xmlns:"

Definition at line 29 of file SkXmp.cpp.

kXmlnsPrefixLength

const size_t kXmlnsPrefixLength = 6

Definition at line 30 of file SkXmp.cpp.