Example #1
0
void XMPMetadataSource::saveProperty(const MetadataSet& property, const MetaString& pathToSchema, const MetaString& propertyName)
{
    if (property.empty())
    {
        // not loaded or empty. In any case nothing to do.
        return;
    }

    MetaString pathToPropertiesArray;
    SXMPUtils::ComposeStructFieldPath(VMF_NS, pathToSchema.c_str(), VMF_NS, SCHEMA_SET, &pathToPropertiesArray);

    MetaString thisPropertyPath = findProperty(pathToSchema, propertyName);
    if (thisPropertyPath.empty())
    {
        xmp->AppendArrayItem(VMF_NS, pathToPropertiesArray.c_str(), kXMP_PropValueIsArray, nullptr, kXMP_PropValueIsStruct);
        SXMPUtils::ComposeArrayItemPath(VMF_NS, pathToPropertiesArray.c_str(), kXMP_ArrayLastItem, &thisPropertyPath);
    }

    savePropertyName(thisPropertyPath, propertyName);
    xmp->SetStructField(VMF_NS, thisPropertyPath.c_str(), VMF_NS, PROPERTY_SET, nullptr, kXMP_PropValueIsArray);
    MetaString thisPropertySetPath;
    SXMPUtils::ComposeStructFieldPath(VMF_NS, thisPropertyPath.c_str(), VMF_NS, PROPERTY_SET, &thisPropertySetPath);

    for(auto metadata = property.begin(); metadata != property.end(); ++metadata)
    {
        saveMetadata(*metadata, thisPropertySetPath);
    }
}
Example #2
0
File: main.cpp Project: SSE4/vmf-1
// setName == "" means all sets in the specified schema
// schemaName == "" means all schemas (i.e. all metadata)
void dumpMetadata(const string& path, const string& schemaName = "", const string& setName = "")
{
    cout << "\nDumping metadata: " 
         << (schemaName.empty() ? string("*") : schemaName + '/' + 
                                               (setName.empty() ? string("*") : setName) ) 
         << endl;
    MetadataStream ms;
    if (!ms.open(path, MetadataStream::ReadOnly))
        throw std::runtime_error("Can't open MetadataStream");
    vector<string> schemas;
    if(schemaName.empty()) ms.getAllSchemaNames().swap(schemas);
    else schemas.push_back(schemaName);
    for (unsigned int sNum = 0; sNum < schemas.size(); sNum++)
    {
        auto sName = schemas[sNum];
        cout << "* (" << sNum << ") [schema]: " << sName << endl;
        if(!ms.load(sName))
            throw std::runtime_error(string("Error loading schema: " + sName).c_str());
        vector<shared_ptr<MetadataDesc>>mDescs;
        if(setName.empty()) ms.getSchema(sName)->getAll().swap(mDescs);
        else mDescs.push_back(ms.getSchema(sName)->findMetadataDesc(setName));
        for (unsigned int setNum = 0; setNum < mDescs.size(); setNum++)
        {
            auto mDesc = mDescs[setNum];
            string setName = mDesc->getMetadataName();
            MetadataSet set = ms.queryByName(setName);
            cout << "\t* (" << sNum << "." << setNum << ") [set]: " << setName << "(" << set.size() << " items)" << endl;
            if(set.empty()) continue;
            vector<string> fields(set[0]->getFieldNames());
            int itemNum = 0;
            for (auto item = set.begin(); item != set.end(); item++)
            {
                cout << "\t\t* (" << sNum << "." << setNum << "." << ++itemNum << ") { ";
                const char * separator = "";
                for (auto f = fields.begin(); f != fields.end(); f++)
                {
                    cout << separator << *f << "=";
                    try { cout << (*item)->getFieldValue(*f).toString(); }
                    catch(vmf::Exception& e) { cout << '<' << e.what() << '>'; }
                    separator = ", ";
                }
                cout << " }" << endl;
            }
        }
    }
}
Example #3
0
void readAndDumpEncryptedMetadata(const umf_string& videoFile, std::shared_ptr<Encryptor> encryptor)
{
    cout << "Opening file name '" << videoFile << "'" << endl;

    // Open new metadata stream to load and print saved metadata
    MetadataStream loadStream;
    loadStream.setEncryptor(encryptor);
    if (!loadStream.open(videoFile, MetadataStream::ReadOnly))
    {
        cerr << "Can't open file " << videoFile << endl;
        exit(1);
    }

    if(loadStream.getUseEncryption())
    {
        cout << "The whole stream is encrypted" << endl;
    }

    // Get all schemas
    vector<string> schemas = loadStream.getAllSchemaNames();
    // and dump all the related data to console
    for(size_t sNum = 0; sNum < schemas.size(); sNum++)
    {
        string sName = schemas[sNum];
        std::shared_ptr<MetadataSchema> schemaPtr = loadStream.getSchema(sName);
        bool schemaEncrypted = schemaPtr->getUseEncryption();
        cout << "* (" << sNum << ") [schema]: " << sName;
        if(schemaEncrypted)
        {
            cout << ", encrypted";
        }
        cout << endl;

        if(!loadStream.load(sName))
        {
            cerr << "Error loading schema " << sName << endl;
            exit(1);
        }

        vector< shared_ptr<MetadataDesc> > mDescs = schemaPtr->getAll();
        for(size_t setNum = 0; setNum < mDescs.size(); setNum++)
        {
            shared_ptr<MetadataDesc> mDesc = mDescs[setNum];
            string setName = mDesc->getMetadataName();
            bool metadescEncrypted = mDesc->getUseEncryption();
            MetadataSet mdSet = loadStream.queryByName(setName);
            cout << "\t* (" << sNum << "." << setNum << ") [set]: ";
            cout << setName << "(" << mdSet.size() << " items)";


            if(mdSet.empty()) continue;
            vector<string> fields(mdSet[0]->getFieldNames());
            cout << " {";
            const char * separator = "";
            for(FieldDesc fDesc : mDesc->getFields())
            {
                cout << separator << fDesc.name;
                if(fDesc.useEncryption)
                {
                    cout << " encrypted";
                }
                separator = ", ";
            }
            cout << "}";
            if(metadescEncrypted)
            {
                cout << ", encrypted";
            }
            cout << endl;
            int itemNum = 0;
            for(const std::shared_ptr<Metadata>& item : mdSet)
            {
                if (itemNum++ <= 3)
                {
                    cout << "\t\t* (" << sNum << "." << setNum << "." << itemNum << ") { ";
                    separator = "";
                    for (const string& f : fields)
                    {
                        cout << separator << f << "=";
                        try { cout << item->getFieldValue(f).toString(); }
                        catch (umf::Exception& e) { cout << '<' << e.what() << '>'; }
                        if(item->findField(f)->getUseEncryption())
                        {
                            cout << " encrypted";
                        }
                        separator = ", ";
                    }
                    cout << " }";
                    long long t = item->getTime();
                    if (t >= 0) cout << ", time " << t;
                    if(item->getUseEncryption()) cout << ", encrypted";
                    cout << endl;
                }
                else
                    cout << '.';
            }
            cout << "\n\t\t" << itemNum << " items." << endl;
        }
    }

    // Close metadata stream
    loadStream.close();
}