int encrypt_custom(const string& videoFile, EncryptionScope scope)
{
cout << "Custom encryption usage sample:" << endl;
MetadataStream mdStream;
if (!mdStream.open(videoFile, MetadataStream::Update |
MetadataStream::IgnoreUnknownCompressor |
MetadataStream::IgnoreUnknownEncryptor))
{
cerr << "Can't open file '" + videoFile + "'" << endl;
exit(1);
}
std::shared_ptr<Encryptor> encryptor = std::make_shared<MyEncryptor>("thereisnospoon");
cout << "Generating metadata..." << endl;
generateEncryptedMetadata(mdStream, scope);
mdStream.setEncryptor(encryptor);
cout << "Saving metadata using custom encryptor..." << endl;
cout << "Encryption algorithm info: " << encryptor->getHint() << endl;
mdStream.save();
mdStream.close();
cout << "Loading metadata back..." << endl;
readAndDumpEncryptedMetadata(videoFile, encryptor);
cout << "That's all!" << endl;
return 0;
}
void generateMetadata(MetadataStream& mdStream)
{
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);
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)));
// Fill item fields
gpsMetadata->push_back(FieldValue(GPS_COORD_LAT_FIELD, lat));
gpsMetadata->push_back(FieldValue(GPS_COORD_LNG_FIELD, lng));
gpsMetadata->setTimestamp(time);
// Add to metadata a new item
mdStream.add(gpsMetadata);
}
cout << "\n\t" << nPoints << " items." << endl;
}
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 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();
}
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;
}