int main(int argc, char **argv)
{
QApplication a(argc, argv);
umf::initialize();
std::string appPath = argv[0];
#ifdef WIN32
char delim = '\\';
#else
char delim = '/';
#endif
size_t pos = appPath.find_last_of(delim);
if (pos != std::string::npos)
{
workingPath = appPath.substr(0, pos);
}
if (QFile::exists(TEST_FILE))
QFile::remove(TEST_FILE);
QFile::copy(VIDEO_FILE.c_str(), "global_test.avi");
const umf_string FILE_NAME = "global_test.avi";
const umf_string SCHEMA_NAME = "demo-unicode-schema";
const umf_string STRING_METADATA = "unicode-string-metadata";
{
auto schema = make_shared<MetadataSchema>(SCHEMA_NAME);
auto desc = make_shared<MetadataDesc>(STRING_METADATA, Variant::type_string);
schema->add(desc);
MetadataStream stream;
if (!stream.open(FILE_NAME, MetadataStream::Update))
{
cerr << "Failed to open file " << FILE_NAME << endl;
return -1;
}
stream.addSchema(schema);
auto metadata = make_shared<Metadata>(desc);
// UTF-8 string with Russian text
std::string str("\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82\x21");
metadata->addValue(str);
stream.add(metadata);
if (!stream.save())
{
cerr << "Failed to save file " << FILE_NAME << endl;
return -1;
}
stream.close();
}
{
MetadataStream stream;
if (!stream.open(FILE_NAME, MetadataStream::ReadOnly))
{
cerr << "Failed to open file " << FILE_NAME << endl;
return -1;
}
if (!stream.load(SCHEMA_NAME))
{
cerr << "Failed to load schema " << SCHEMA_NAME << endl;
return -1;
}
auto stringMetadata = stream.queryByName(STRING_METADATA);
auto savedMetadata = stringMetadata.at(0);
std::string savedString = savedMetadata->at(0);
QMessageBox::information(NULL, "UMF Demo Unicode", QString::fromUtf8(savedString.c_str()));
}
umf::terminate();
return 0;
}
void generateEncryptedMetadata(MetadataStream &mdStream, EncryptionScope scope)
{
mdStream.remove();
mdStream.save();
mdStream.close();
mdStream.reopen(MetadataStream::OpenModeFlags::Update);
// Create a GPS metadata field descriptions
shared_ptr<MetadataSchema> gpsSchema(new MetadataSchema(GPS_SCHEMA_NAME));
UMF_METADATA_BEGIN(GPS_DESC);
UMF_FIELD_REAL(GPS_COORD_LAT_FIELD);
UMF_FIELD_REAL(GPS_COORD_LNG_FIELD);
UMF_METADATA_END(gpsSchema);
//set encryption for all fields/metadata/schema/stream
std::shared_ptr< MetadataDesc > metadesc = gpsSchema->findMetadataDesc(GPS_DESC);
FieldDesc& field = metadesc->getFieldDesc(GPS_COORD_LNG_FIELD);
if(scope == EncryptionScope::Whole)
{
mdStream.setUseEncryption(true);
}
else if(scope == EncryptionScope::AllSchema)
{
gpsSchema->setUseEncryption(true);
}
else if(scope == EncryptionScope::AllMetaDesc)
{
metadesc->setUseEncryption(true);
}
else if(scope == EncryptionScope::AllFieldDesc)
{
field.useEncryption = true;
}
cout << "Adding metadata schema '" << GPS_SCHEMA_NAME << "':" << endl;
// Add schema to metadata stream
mdStream.addSchema(gpsSchema);
shared_ptr<Metadata> gpsMetadata;
// Let there be an UFO moving around some point on Earth
const int nPoints = 1<<10;
for(int i = 0; i < nPoints; i++)
{
float lat = float( 37.235 + cos(i/25.0*2.0*PI) * 0.001);
float lng = float(-115.811 + sin(i/25.0*2.0*PI) * 0.001);
long long time = i;
if (i<3) cout << "\t[" << i << "] 'lat " << lat << " lng " << lng << '\'' << " time " << time << endl;
else cout << '.';
// Create a metadata item
gpsMetadata = shared_ptr<Metadata>(new Metadata(gpsSchema->findMetadataDesc(GPS_DESC)));
//Encrypt specified fields/records or not
bool encryptRecord = false, encryptField = false;
if(i == 0)
{
if(scope == EncryptionScope::OneField)
{
encryptField = true;
}
if(scope == EncryptionScope::OneMetadata)
{
encryptRecord = true;
}
}
// Fill item fields
gpsMetadata->push_back(FieldValue(GPS_COORD_LAT_FIELD, lat, encryptField));
gpsMetadata->push_back(FieldValue(GPS_COORD_LNG_FIELD, lng));
gpsMetadata->setTimestamp(time);
gpsMetadata->setUseEncryption(encryptRecord);
// Add to metadata a new item
mdStream.add(gpsMetadata);
}
cout << "\n\t" << nPoints << " items." << endl;
}
void XMPDataSource::saveXMPstructs()
{
std::shared_ptr<SXMPMeta> tmpXMP = xmp;
//Sometimes compressed&encoded data is bigger than the source data
//but there's no need to compare their sizes and write the smallest one.
//Because due to RDF's verbosity it happens only when the source data is small.
//That's why the economy wouldn't be significant.
if(compressor)
{
string buffer;
XMP_OptionBits options = kXMP_ReadOnlyPacket | kXMP_UseCompactFormat;
tmpXMP->SerializeToBuffer(&buffer, options, 0, NULL);
vmf_rawbuffer compressed;
compressor->compress(buffer, compressed);
string encoded;
XMPUtils::EncodeToBase64 (compressed.data(), compressed.size(), &encoded);
//save compressed data as VMF metadata with corresponding schema
MetadataStream cStream;
cStream.addSchema(schemaCompression);
shared_ptr<Metadata> cMetadata;
cMetadata = make_shared<Metadata>(schemaCompression->findMetadataDesc(COMPRESSED_DATA_DESC_NAME));
cMetadata->push_back(FieldValue(COMPRESSION_ALGO_PROP_NAME, compressor->getId()));
cMetadata->push_back(FieldValue(COMPRESSED_DATA_PROP_NAME, encoded));
cStream.add(cMetadata);
tmpXMP = make_shared<SXMPMeta>();
std::shared_ptr<XMPMetadataSource> cMetaSource;
std::shared_ptr<XMPSchemaSource> cSchemaSource;
cSchemaSource = make_shared<XMPSchemaSource>(tmpXMP);
cMetaSource = make_shared<XMPMetadataSource>(tmpXMP);
if (!cMetaSource || !cSchemaSource)
{
VMF_EXCEPTION(DataStorageException, "Failed to create compressed metadata source or schema source");
}
try
{
cMetaSource->saveSchema(schemaCompression, cStream.getAll());
cSchemaSource->save(schemaCompression);
}
catch(const XMP_Error& e)
{
VMF_EXCEPTION(DataStorageException, e.GetErrMsg());
}
catch(const std::exception& e)
{
VMF_EXCEPTION(DataStorageException, e.what());
}
IdType cNextId = 1;
tmpXMP->SetProperty_Int64(VMF_NS, VMF_GLOBAL_NEXT_ID, cNextId);
}
//existing encryptor should mean that we need an encryption
if(encryptor)
{
string buffer;
XMP_OptionBits options = kXMP_ReadOnlyPacket | kXMP_UseCompactFormat;
tmpXMP->SerializeToBuffer(&buffer, options, 0, NULL);
vmf_rawbuffer encrypted;
encryptor->encrypt(buffer, encrypted);
string encoded;
XMPUtils::EncodeToBase64(encrypted.data(), encrypted.size(), &encoded);
//save encrypted data as VMF metadata with corresponding schema
MetadataStream eStream;
eStream.addSchema(schemaEncryption);
shared_ptr<Metadata> eMetadata;
eMetadata = make_shared<Metadata>(schemaEncryption->findMetadataDesc(ENCRYPTED_DATA_DESC_NAME));
eMetadata->push_back(FieldValue(ENCRYPTION_HINT_PROP_NAME, encryptor->getHint()));
eMetadata->push_back(FieldValue(ENCRYPTED_DATA_PROP_NAME, encoded));
eStream.add(eMetadata);
tmpXMP = make_shared<SXMPMeta>();
std::shared_ptr<XMPMetadataSource> eMetaSource;
std::shared_ptr<XMPSchemaSource> eSchemaSource;
eSchemaSource = make_shared<XMPSchemaSource>(tmpXMP);
eMetaSource = make_shared<XMPMetadataSource>(tmpXMP);
if(!eMetaSource || !eSchemaSource)
{
VMF_EXCEPTION(DataStorageException, "Failed to create compressed metadata source or schema source");
}
try
{
eMetaSource->saveSchema(schemaEncryption, eStream.getAll());
eSchemaSource->save(schemaEncryption);
}
catch(const XMP_Error& e)
{
VMF_EXCEPTION(DataStorageException, e.GetErrMsg());
}
catch(const std::exception& e)
{
VMF_EXCEPTION(DataStorageException, e.what());
}
IdType eNextId = 1;
tmpXMP->SetProperty_Int64(VMF_NS, VMF_GLOBAL_NEXT_ID, eNextId);
}
if(xmpFile.CanPutXMP(*tmpXMP))
{
xmpFile.PutXMP(*tmpXMP);
}
else
{
VMF_EXCEPTION(InternalErrorException, "Can't write XMP data to file");
}
}
int main(int argc, char *argv[])
{
initialize();
string appPath = argv[0];
#ifdef WIN32
char delim = '\\';
#else
char delim = '/';
#endif
size_t pos = appPath.find_last_of(delim);
if (pos != string::npos)
{
workingPath = appPath.substr(0, pos + 1);
}
// Copy test video file to another location.
copyFile(VIDEO_FILE, "global_test.avi");
cout << "VMF sample: read/write GPS location and time" << endl << endl;
const string FILE_NAME = "global_test.avi";
const string META_SOURCE_NAME = "test-id";
const string GPS_DESC = "gps";
const string GPS_COORD_FIELD = "GPS";
const string GPS_TIME_FIELD = "Time";
const string GPS_SCHEMA_NAME = "gps_schema";
const string GPS_METADATA_ITEM1 = "lat=53.78,lng=132.46";
const string GPS_METADATA_ITEM2 = "lat=53.28,lng=131.87";
const string GPS_METADATA_ITEM3 = "lat=52.95,lng=131.41";
const string GPS_METADATA_ITEM4 = "lat=52.49,lng=130.98";
cout << "Adding metadata..." << endl;
cout << "Opening file name '" << FILE_NAME << "'" << endl;
// Open metadata stream
MetadataStream mdStream;
if (!mdStream.open(FILE_NAME, MetadataStream::ReadWrite))
{
cerr << "Can't open file " << FILE_NAME << endl;
exit(1);
}
// Create a GPS metadata field descriptions
vector<FieldDesc> fieldDesc;
fieldDesc.push_back(FieldDesc(GPS_COORD_FIELD)); // GPS coordinate as string
fieldDesc.push_back(FieldDesc(GPS_TIME_FIELD)); // Associated time as string
// Create GPS metadata description
shared_ptr<MetadataDesc> gpsDesc(new MetadataDesc(GPS_DESC, fieldDesc));
// Create GPS metadata schema
shared_ptr<MetadataSchema> gpsSchema(new MetadataSchema(GPS_SCHEMA_NAME));
// Add description to the schema
gpsSchema->add(gpsDesc);
string t = "21.02.2013 18:35";
cout << "Add metadata schema '" << GPS_SCHEMA_NAME << "'" << endl;
// Add schema to metadata stream
mdStream.addSchema(gpsSchema);
shared_ptr<Metadata> gpsMetadata;
t = "21.02.2013 18:45";
cout << "Adding metadata's item '" << GPS_METADATA_ITEM1 << "' with associated time " << t << endl;
// Create a metadata item
gpsMetadata = shared_ptr<Metadata>(new Metadata(gpsDesc));
// Fill item fields
gpsMetadata->push_back(FieldValue(GPS_COORD_FIELD, GPS_METADATA_ITEM1));
gpsMetadata->push_back(FieldValue(GPS_TIME_FIELD, t));
// Add to metadata a new item
mdStream.add(gpsMetadata);
t = "21.02.2013 19:28";
cout << "Adding metadata's item '" << GPS_METADATA_ITEM2 << "' with associated time " << t << endl;
gpsMetadata = shared_ptr<Metadata>(new Metadata(gpsDesc));
gpsMetadata->push_back(FieldValue(GPS_COORD_FIELD, GPS_METADATA_ITEM2));
gpsMetadata->push_back(FieldValue(GPS_TIME_FIELD, t));
mdStream.add(gpsMetadata);
t = "21.02.2013 21:02";
cout << "Adding metadata's item '" << GPS_METADATA_ITEM3 << "' with associated time " << t << endl;
gpsMetadata = shared_ptr<Metadata>(new Metadata(gpsDesc));
gpsMetadata->push_back(FieldValue(GPS_COORD_FIELD, GPS_METADATA_ITEM3));
gpsMetadata->push_back(FieldValue(GPS_TIME_FIELD, t));
mdStream.add(gpsMetadata);
t = "21.02.2013 23:19";
cout << "Adding metadata's item '" << GPS_METADATA_ITEM4 << "' with associated time " << t << endl;
gpsMetadata = shared_ptr<Metadata>(new Metadata(gpsDesc));
gpsMetadata->push_back(FieldValue(GPS_COORD_FIELD, GPS_METADATA_ITEM4));
gpsMetadata->push_back(FieldValue(GPS_TIME_FIELD, t));
mdStream.add(gpsMetadata);
cout << "Save metadata" << endl << endl;
// Save metadata to video file and close metadata stream
mdStream.save();
mdStream.close();
cout << "Loading metadata..." << endl;
cout << "Opening file name '" << FILE_NAME << "'" << endl;
// Open new metadata stream to load and print saved metadata
MetadataStream loadStream;
if (!loadStream.open(FILE_NAME, MetadataStream::ReadOnly))
{
cerr << "Can't open file " << FILE_NAME << endl;
exit(1);
}
cout << "Loading schema '" << GPS_SCHEMA_NAME << "'" << endl;
if (!loadStream.load(GPS_SCHEMA_NAME))
{
cerr << "Can't load schema " << GPS_SCHEMA_NAME << endl;
exit(1);
}
// Select all metadata items from loaded schema
auto dataSet = loadStream.queryBySchema(GPS_SCHEMA_NAME);
// and print them to console
for (size_t i = 0; i < dataSet.size(); i++)
{
cout << "Getting item " << i << endl;
auto metadataItem = dataSet[i];
string coord = metadataItem->getFieldValue(GPS_COORD_FIELD);
cout << "\tGPS coordinates are: " << coord << endl;
string time = metadataItem->getFieldValue(GPS_TIME_FIELD);
cout << "\tAssociated time is: " << time << endl;
}
// Close metadata stream
loadStream.close();
// Uninitialize VMF library to free allocated resources
vmf::terminate();
return 0;
}
void XMPDataSource::loadXMPstructs()
{
std::shared_ptr<SXMPMeta> tmpXMP = make_shared<SXMPMeta>();
xmpFile.GetXMP(tmpXMP.get());
std::shared_ptr<XMPMetadataSource> tmpMetaSource;
std::shared_ptr<XMPSchemaSource> tmpSchemaSource;
std::shared_ptr<XMPStatSource> tmpStatSource;
tmpSchemaSource = make_shared<XMPSchemaSource>(tmpXMP);
tmpMetaSource = make_shared<XMPMetadataSource>(tmpXMP);
tmpStatSource = make_shared<XMPStatSource>(tmpXMP);
if(!tmpMetaSource || !tmpSchemaSource || !tmpStatSource)
{
VMF_EXCEPTION(DataStorageException, "Failed to create metadata source or schema source");
}
//load standard VMF metadata and decompress them if there is a corresponding schema
//or pass them further
try
{
//load standard VMF metadata and decrypt them if there is a corresponding schema
//or pass them further
std::map<vmf_string, std::shared_ptr<MetadataSchema> > eSchemas;
tmpSchemaSource->load(eSchemas);
auto itEncryption = eSchemas.find(ENCRYPTED_DATA_SCHEMA_NAME);
if(itEncryption != eSchemas.end())
{
MetadataStream eStream;
eStream.addSchema(itEncryption->second);
tmpMetaSource->loadSchema(ENCRYPTED_DATA_SCHEMA_NAME, eStream);
MetadataSet eSet = eStream.queryBySchema(ENCRYPTED_DATA_SCHEMA_NAME);
std::shared_ptr<Metadata> eItem = eSet[0];
vmf_string hint = eItem->getFieldValue(ENCRYPTION_HINT_PROP_NAME);
vmf_string encodedB64 = eItem->getFieldValue(ENCRYPTED_DATA_PROP_NAME);
bool ignoreBad = (openMode & MetadataStream::OpenModeFlags::IgnoreUnknownEncryptor) != 0;
if(!encryptor)
{
if(!ignoreBad)
{
VMF_EXCEPTION(IncorrectParamException,
"No decryption algorithm provided for encrypted data");
}
}
else
{
string decodedFromB64;
XMPUtils::DecodeFromBase64(encodedB64.data(), encodedB64.length(), &decodedFromB64);
vmf_rawbuffer encrypted(decodedFromB64.c_str(), decodedFromB64.size());
string theData;
try
{
encryptor->decrypt(encrypted, theData);
}
catch(Exception& ee)
{
//if we've failed with decryption (whatever the reason was)
//and we're allowed to ignore that
if(!ignoreBad)
{
string message = "Decryption failed: " + string(ee.what()) + ", hint: " + hint;
VMF_EXCEPTION(IncorrectParamException, message);
}
}
//replace tmp XMP entities
tmpXMP->ParseFromBuffer(theData.c_str(), theData.size(), 0);
tmpSchemaSource = make_shared<XMPSchemaSource>(tmpXMP);
tmpMetaSource = make_shared<XMPMetadataSource>(tmpXMP);
tmpStatSource = make_shared<XMPStatSource>(tmpXMP);
if(!tmpMetaSource || !tmpSchemaSource || !tmpStatSource)
{
VMF_EXCEPTION(DataStorageException,
"Failed to create metadata source, schema source or stat source");
}
}
}
//load standard VMF metadata and decompress them if there is a corresponding schema
//or pass them further
std::map<vmf_string, std::shared_ptr<MetadataSchema> > cSchemas;
tmpSchemaSource->load(cSchemas);
auto itCompression = cSchemas.find(COMPRESSED_DATA_SCHEMA_NAME);
if(itCompression != cSchemas.end())
{
MetadataStream cStream;
cStream.addSchema(itCompression->second);
tmpMetaSource->loadSchema(COMPRESSED_DATA_SCHEMA_NAME, cStream);
MetadataSet cSet = cStream.queryBySchema(COMPRESSED_DATA_SCHEMA_NAME);
std::shared_ptr<Metadata> cItem = cSet[0];
vmf_string algo = cItem->getFieldValue(COMPRESSION_ALGO_PROP_NAME);
vmf_string encoded = cItem->getFieldValue(COMPRESSED_DATA_PROP_NAME);
bool ignoreBad = (openMode & MetadataStream::OpenModeFlags::IgnoreUnknownCompressor) != 0;
try
{
std::shared_ptr<Compressor> decompressor = Compressor::create(algo);
string decoded;
XMPUtils::DecodeFromBase64(encoded.data(), encoded.length(), &decoded);
vmf_rawbuffer compressed(decoded.c_str(), decoded.size());
string theData;
decompressor->decompress(compressed, theData);
//replace tmp XMP entities
tmpXMP->ParseFromBuffer(theData.c_str(), theData.size(), 0);
tmpSchemaSource = make_shared<XMPSchemaSource>(tmpXMP);
tmpMetaSource = make_shared<XMPMetadataSource>(tmpXMP);
tmpStatSource = make_shared<XMPStatSource>(tmpXMP);
if(!tmpMetaSource || !tmpSchemaSource || !tmpStatSource)
{
VMF_EXCEPTION(DataStorageException,
"Failed to create metadata source, schema source or stat source");
}
}
catch(IncorrectParamException& ce)
{
//if there's no such compressor and we're allowed to ignore that
if(!ignoreBad)
{
VMF_EXCEPTION(IncorrectParamException, ce.what());
}
}
catch(InternalErrorException& ce)
{
//if there was an error during decompression
if(!ignoreBad)
{
VMF_EXCEPTION(IncorrectParamException, ce.what());
}
}
}
}
catch(const XMP_Error& e)
{
VMF_EXCEPTION(DataStorageException, e.GetErrMsg());
}
catch(const std::exception& e)
{
VMF_EXCEPTION(DataStorageException, e.what());
}
xmp = tmpXMP;
schemaSource = tmpSchemaSource;
metadataSource = tmpMetaSource;
statSource = tmpStatSource;
}