summaryrefslogtreecommitdiff
path: root/source/XMPFiles/FormatSupport/ASF_Support.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/XMPFiles/FormatSupport/ASF_Support.cpp')
-rw-r--r--source/XMPFiles/FormatSupport/ASF_Support.cpp1434
1 files changed, 1434 insertions, 0 deletions
diff --git a/source/XMPFiles/FormatSupport/ASF_Support.cpp b/source/XMPFiles/FormatSupport/ASF_Support.cpp
new file mode 100644
index 0000000..3baa7d0
--- /dev/null
+++ b/source/XMPFiles/FormatSupport/ASF_Support.cpp
@@ -0,0 +1,1434 @@
+// =================================================================================================
+// ADOBE SYSTEMS INCORPORATED
+// Copyright 2002-2008 Adobe Systems Incorporated
+// All Rights Reserved
+//
+// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms
+// of the Adobe license agreement accompanying it.
+// =================================================================================================
+
+#include "ASF_Support.hpp"
+#include "UnicodeConversions.hpp"
+
+#if XMP_WinBuild
+ #define snprintf _snprintf
+ #pragma warning ( disable : 4996 ) // '...' was declared deprecated
+ #pragma warning ( disable : 4267 ) // *** conversion (from size_t), possible loss of date (many 64 bit related)
+#endif
+
+// =============================================================================================
+
+// Platforms other than Win
+#if ! XMP_WinBuild
+int IsEqualGUID ( const GUID& guid1, const GUID& guid2 )
+{
+ return (memcmp ( &guid1, &guid2, sizeof(GUID) ) == 0);
+}
+#endif
+
+ASF_Support::ASF_Support() : legacyManager(0), posFileSizeInfo(0) {}
+
+ASF_Support::ASF_Support ( ASF_LegacyManager* _legacyManager ) : posFileSizeInfo(0)
+{
+ legacyManager = _legacyManager;
+}
+
+ASF_Support::~ASF_Support()
+{
+ legacyManager = 0;
+}
+
+// =============================================================================================
+
+long ASF_Support::OpenASF ( LFA_FileRef fileRef, ObjectState & inOutObjectState )
+{
+ XMP_Uns64 pos = 0;
+ XMP_Uns64 len;
+
+ try {
+ pos = LFA_Seek ( fileRef, 0, SEEK_SET );
+ } catch ( ... ) {}
+
+ if ( pos != 0 ) return 0;
+
+ // read first and following chunks
+ while ( ReadObject ( fileRef, inOutObjectState, &len, pos) ) {}
+
+ return inOutObjectState.objects.size();
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::ReadObject ( LFA_FileRef fileRef, ObjectState & inOutObjectState, XMP_Uns64 * objectLength, XMP_Uns64 & inOutPosition )
+{
+
+ try {
+
+ XMP_Uns64 startPosition = inOutPosition;
+ long bytesRead;
+ ASF_ObjectBase objectBase;
+
+ bytesRead = LFA_Read ( fileRef, &objectBase, kASF_ObjectBaseLen, true );
+ if ( bytesRead != kASF_ObjectBaseLen ) return false;
+
+ *objectLength = GetUns64LE ( &objectBase.size );
+ inOutPosition += *objectLength;
+
+ ObjectData newObject;
+
+ newObject.pos = startPosition;
+ newObject.len = *objectLength;
+ newObject.guid = objectBase.guid;
+
+ // xmpIsLastObject indicates, that the XMP-object is the last top-level object
+ // reset here, if any another object is read
+ inOutObjectState.xmpIsLastObject = false;
+
+ if ( IsEqualGUID ( ASF_Header_Object, newObject.guid ) ) {
+
+ // header object ?
+ this->ReadHeaderObject ( fileRef, inOutObjectState, newObject );
+
+ } else if ( IsEqualGUID ( ASF_XMP_Metadata, newObject.guid ) ) {
+
+ // check object for XMP GUID
+ inOutObjectState.xmpPos = newObject.pos + kASF_ObjectBaseLen;
+ inOutObjectState.xmpLen = newObject.len - kASF_ObjectBaseLen;
+ inOutObjectState.xmpIsLastObject = true;
+ inOutObjectState.xmpObject = newObject;
+ newObject.xmp = true;
+
+ }
+
+ inOutObjectState.objects.push_back ( newObject );
+
+ LFA_Seek ( fileRef, inOutPosition, SEEK_SET );
+
+ } catch ( ... ) {
+
+ return false;
+
+ }
+
+ return true;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::ReadHeaderObject ( LFA_FileRef fileRef, ObjectState& inOutObjectState, const ObjectData& newObject )
+{
+ if ( ! IsEqualGUID ( ASF_Header_Object, newObject.guid) || (! legacyManager ) ) return false;
+
+ std::string buffer;
+
+ legacyManager->SetPadding(0);
+
+ try {
+
+ // read header-object structure
+ XMP_Uns64 pos = newObject.pos;
+ XMP_Uns32 bufferSize = kASF_ObjectBaseLen + 6;
+
+ buffer.clear();
+ buffer.reserve ( bufferSize );
+ buffer.assign ( bufferSize, ' ' );
+ LFA_Seek ( fileRef, pos, SEEK_SET );
+ LFA_Read ( fileRef, const_cast<char*>(buffer.data()), bufferSize, true );
+
+ XMP_Uns64 read = bufferSize;
+ pos += bufferSize;
+
+ // read contained header objects
+ XMP_Uns32 numberOfHeaders = GetUns32LE ( &buffer[24] );
+ ASF_ObjectBase objectBase;
+
+ while ( read < newObject.len ) {
+
+ LFA_Seek ( fileRef, pos, SEEK_SET );
+ if ( kASF_ObjectBaseLen != LFA_Read ( fileRef, &objectBase, kASF_ObjectBaseLen, true ) ) break;
+
+ LFA_Seek ( fileRef, pos, SEEK_SET );
+ objectBase.size = GetUns64LE ( &objectBase.size );
+
+ if ( IsEqualGUID ( ASF_File_Properties_Object, objectBase.guid) && (objectBase.size >= 104 ) ) {
+
+ buffer.clear();
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( fileRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ // save position of filesize-information
+ posFileSizeInfo = (pos + 40);
+
+ // creation date
+ std::string sub ( buffer.substr ( 48, 8 ) );
+ legacyManager->SetField ( ASF_LegacyManager::fieldCreationDate, sub );
+
+ // broadcast flag set ?
+ XMP_Uns32 flags = GetUns32LE ( &buffer[88] );
+ inOutObjectState.broadcast = (flags & 1);
+ legacyManager->SetBroadcast ( inOutObjectState.broadcast );
+
+ legacyManager->SetObjectExists ( ASF_LegacyManager::objectFileProperties );
+
+ } else if ( IsEqualGUID ( ASF_Content_Description_Object, objectBase.guid) && (objectBase.size >= 34 ) ) {
+
+ buffer.clear();
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( fileRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ XMP_Uns16 titleLen = GetUns16LE ( &buffer[24] );
+ XMP_Uns16 authorLen = GetUns16LE ( &buffer[26] );
+ XMP_Uns16 copyrightLen = GetUns16LE ( &buffer[28] );
+ XMP_Uns16 descriptionLen = GetUns16LE ( &buffer[30] );
+ XMP_Uns16 ratingLen = GetUns16LE ( &buffer[32] );
+
+ XMP_Uns16 fieldPos = 34;
+
+ std::string titleStr = buffer.substr ( fieldPos, titleLen );
+ fieldPos += titleLen;
+ legacyManager->SetField ( ASF_LegacyManager::fieldTitle, titleStr );
+
+ std::string authorStr = buffer.substr ( fieldPos, authorLen );
+ fieldPos += authorLen;
+ legacyManager->SetField ( ASF_LegacyManager::fieldAuthor, authorStr );
+
+ std::string copyrightStr = buffer.substr ( fieldPos, copyrightLen );
+ fieldPos += copyrightLen;
+ legacyManager->SetField ( ASF_LegacyManager::fieldCopyright, copyrightStr );
+
+ std::string descriptionStr = buffer.substr ( fieldPos, descriptionLen );
+ fieldPos += descriptionLen;
+ legacyManager->SetField ( ASF_LegacyManager::fieldDescription, descriptionStr );
+
+ /* rating is currently not part of reconciliation
+ std::string ratingStr = buffer.substr ( fieldPos, ratingLen );
+ fieldPos += ratingLen;
+ legacyData.append ( titleStr );
+ */
+
+ legacyManager->SetObjectExists ( ASF_LegacyManager::objectContentDescription );
+
+ } else if ( IsEqualGUID ( ASF_Content_Branding_Object, objectBase.guid ) ) {
+
+ buffer.clear();
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( fileRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ XMP_Uns32 fieldPos = 28;
+
+ // copyright URL is 3. element with variable size
+ for ( int i = 1; i <= 3 ; ++i ) {
+ XMP_Uns32 len = GetUns32LE ( &buffer[fieldPos] );
+ if ( i == 3 ) {
+ std::string copyrightURLStr = buffer.substr ( fieldPos + 4, len );
+ legacyManager->SetField ( ASF_LegacyManager::fieldCopyrightURL, copyrightURLStr );
+ }
+ fieldPos += (len + 4);
+ }
+
+ legacyManager->SetObjectExists ( ASF_LegacyManager::objectContentBranding );
+
+#if ! Exclude_LicenseURL_Recon
+
+ } else if ( IsEqualGUID ( ASF_Content_Encryption_Object, objectBase.guid ) ) {
+
+ buffer.clear();
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( fileRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ XMP_Uns32 fieldPos = 24;
+
+ // license URL is 4. element with variable size
+ for ( int i = 1; i <= 4 ; ++i ) {
+ XMP_Uns32 len = GetUns32LE ( &buffer[fieldPos] );
+ if ( i == 4 ) {
+ std::string licenseURLStr = buffer.substr ( fieldPos + 4, len );
+ legacyManager->SetField ( ASF_LegacyManager::fieldLicenseURL, licenseURLStr );
+ }
+ fieldPos += (len + 4);
+ }
+
+ legacyManager->SetObjectExists ( objectContentEncryption );
+
+#endif
+
+ } else if ( IsEqualGUID ( ASF_Padding_Object, objectBase.guid ) ) {
+
+ legacyManager->SetPadding ( legacyManager->GetPadding() + (objectBase.size - 24) );
+
+ } else if ( IsEqualGUID ( ASF_Header_Extension_Object, objectBase.guid ) ) {
+
+ this->ReadHeaderExtensionObject ( fileRef, inOutObjectState, pos, objectBase );
+
+ }
+
+ pos += objectBase.size;
+ read += objectBase.size;
+ }
+
+ } catch ( ... ) {
+
+ return false;
+
+ }
+
+ legacyManager->ComputeDigest();
+
+ return true;
+}
+
+// =============================================================================================
+
+bool ASF_Support::WriteHeaderObject ( LFA_FileRef sourceRef, LFA_FileRef destRef, const ObjectData& object, ASF_LegacyManager& _legacyManager, bool usePadding )
+{
+ if ( ! IsEqualGUID ( ASF_Header_Object, object.guid ) ) return false;
+
+ bool ret = false;
+
+ std::string buffer;
+ XMP_Uns16 valueUns16LE;
+ XMP_Uns32 valueUns32LE;
+ XMP_Uns64 valueUns64LE;
+
+ try {
+
+ // read header-object structure
+ XMP_Uns64 pos = object.pos;
+ XMP_Uns32 bufferSize = kASF_ObjectBaseLen + 6;
+
+ buffer.clear();
+ buffer.reserve ( bufferSize );
+ buffer.assign ( bufferSize, ' ' );
+ LFA_Seek ( sourceRef, pos, SEEK_SET );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), bufferSize, true );
+
+ XMP_Uns64 read = bufferSize;
+ pos += bufferSize;
+
+ // read contained header objects
+ XMP_Uns32 numberOfHeaders = GetUns32LE ( &buffer[24] );
+ ASF_ObjectBase objectBase;
+
+ // prepare new header in memory
+ std::string header;
+
+ int changedObjects = _legacyManager.changedObjects();
+ int exportedObjects = 0;
+ int writtenObjects = 0;
+
+ header.append ( buffer.c_str(), bufferSize );
+
+ while ( read < object.len ) {
+
+ LFA_Seek ( sourceRef, pos, SEEK_SET );
+ if ( kASF_ObjectBaseLen != LFA_Read ( sourceRef, &objectBase, kASF_ObjectBaseLen, true ) ) break;
+
+ LFA_Seek ( sourceRef, pos, SEEK_SET );
+ objectBase.size = GetUns64LE ( &objectBase.size );
+
+ int headerStartPos = header.size();
+
+ // save position of filesize-information
+ if ( IsEqualGUID ( ASF_File_Properties_Object, objectBase.guid ) ) {
+ posFileSizeInfo = (headerStartPos + 40);
+ }
+
+ // write objects
+ if ( IsEqualGUID ( ASF_File_Properties_Object, objectBase.guid ) &&
+ (objectBase.size >= 104) && (changedObjects & ASF_LegacyManager::objectFileProperties) ) {
+
+ // copy object and replace creation-date
+ buffer.reserve ( XMP_Uns32 ( objectBase.size ) );
+ buffer.assign ( XMP_Uns32 ( objectBase.size ), ' ' );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+ header.append ( buffer, 0, XMP_Uns32( objectBase.size ) );
+
+ if ( ! _legacyManager.GetBroadcast() ) {
+ buffer = _legacyManager.GetField ( ASF_LegacyManager::fieldCreationDate );
+ ReplaceString ( header, buffer, (headerStartPos + 48), 8 );
+ }
+
+ exportedObjects |= ASF_LegacyManager::objectFileProperties;
+
+ } else if ( IsEqualGUID ( ASF_Content_Description_Object, objectBase.guid ) &&
+ (objectBase.size >= 34) && (changedObjects & ASF_LegacyManager::objectContentDescription) ) {
+
+ // re-create object with xmp-data
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+ // write header only
+ header.append ( buffer, 0, XMP_Uns32( kASF_ObjectBaseLen ) );
+
+ // write length fields
+
+ XMP_Uns16 titleLen = _legacyManager.GetField ( ASF_LegacyManager::fieldTitle).size( );
+ valueUns16LE = MakeUns16LE ( titleLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 authorLen = _legacyManager.GetField ( ASF_LegacyManager::fieldAuthor).size( );
+ valueUns16LE = MakeUns16LE ( authorLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 copyrightLen = _legacyManager.GetField ( ASF_LegacyManager::fieldCopyright).size( );
+ valueUns16LE = MakeUns16LE ( copyrightLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 descriptionLen = _legacyManager.GetField ( ASF_LegacyManager::fieldDescription).size( );
+ valueUns16LE = MakeUns16LE ( descriptionLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ // retrieve existing overall length of preceding fields
+ XMP_Uns16 precedingLen = 0;
+ precedingLen += GetUns16LE ( &buffer[24] ); // Title
+ precedingLen += GetUns16LE ( &buffer[26] ); // Author
+ precedingLen += GetUns16LE ( &buffer[28] ); // Copyright
+ precedingLen += GetUns16LE ( &buffer[30] ); // Description
+ // retrieve existing 'Rating' length
+ XMP_Uns16 ratingLen = GetUns16LE ( &buffer[32] ); // Rating
+ valueUns16LE = MakeUns16LE ( ratingLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ // write field contents
+
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldTitle ) );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldAuthor ) );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldCopyright ) );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldDescription ) );
+ header.append ( buffer, (34 + precedingLen), ratingLen );
+
+ // update new object size
+ valueUns64LE = MakeUns64LE ( header.size() - headerStartPos );
+ std::string newSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newSize, (headerStartPos + 16), 8 );
+
+ exportedObjects |= ASF_LegacyManager::objectContentDescription;
+
+ } else if ( IsEqualGUID ( ASF_Content_Branding_Object, objectBase.guid ) &&
+ (changedObjects & ASF_LegacyManager::objectContentBranding) ) {
+
+ // re-create object with xmp-data
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ // calculate size of fields coming before 'Copyright URL'
+ XMP_Uns32 length = 28;
+ length += (GetUns32LE ( &buffer[length] ) + 4); // Banner Image Data
+ length += (GetUns32LE ( &buffer[length] ) + 4); // Banner Image URL
+
+ // write first part of header
+ header.append ( buffer, 0, length );
+
+ // copyright URL
+ length = _legacyManager.GetField ( ASF_LegacyManager::fieldCopyrightURL).size( );
+ valueUns32LE = MakeUns32LE ( length );
+ header.append ( (const char*)&valueUns32LE, 4 );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldCopyrightURL ) );
+
+ // update new object size
+ valueUns64LE = MakeUns64LE ( header.size() - headerStartPos );
+ std::string newSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newSize, (headerStartPos + 16), 8 );
+
+ exportedObjects |= ASF_LegacyManager::objectContentBranding;
+
+#if ! Exclude_LicenseURL_Recon
+
+ } else if ( IsEqualGUID ( ASF_Content_Encryption_Object, objectBase.guid ) &&
+ (changedObjects & ASF_LegacyManager::objectContentEncryption) ) {
+
+ // re-create object with xmp-data
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ // calculate size of fields coming before 'License URL'
+ XMP_Uns32 length = 24;
+ length += (GetUns32LE ( &buffer[length] ) + 4); // Secret Data
+ length += (GetUns32LE ( &buffer[length] ) + 4); // Protection Type
+ length += (GetUns32LE ( &buffer[length] ) + 4); // Key ID
+
+ // write first part of header
+ header.append ( buffer, 0, length );
+
+ // License URL
+ length = _legacyManager.GetField ( ASF_LegacyManager::fieldLicenseURL).size( );
+ valueUns32LE = MakeUns32LE ( length );
+ header.append ( (const char*)&valueUns32LE, 4 );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldLicenseURL ) );
+
+ // update new object size
+ valueUns64LE = MakeUns64LE ( header.size() - headerStartPos );
+ std::string newSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newSize, (headerStartPos + 16), 8 );
+
+ exportedObjects |= ASF_LegacyManager::objectContentEncryption;
+
+#endif
+
+ } else if ( IsEqualGUID ( ASF_Header_Extension_Object, objectBase.guid ) && usePadding ) {
+
+ // re-create object if padding needs to be used
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ ASF_Support::WriteHeaderExtensionObject ( buffer, &header, objectBase, 0 );
+
+ } else if ( IsEqualGUID ( ASF_Padding_Object, objectBase.guid ) && usePadding ) {
+
+ // eliminate padding (will be created as last object)
+
+ } else {
+
+ // simply copy all other objects
+ buffer.reserve ( XMP_Uns32( objectBase.size ) );
+ buffer.assign ( XMP_Uns32( objectBase.size ), ' ' );
+ LFA_Read ( sourceRef, const_cast<char*>(buffer.data()), XMP_Int32(objectBase.size), true );
+
+ header.append ( buffer, 0, XMP_Uns32( objectBase.size ) );
+
+ }
+
+ pos += objectBase.size;
+ read += objectBase.size;
+
+ writtenObjects ++;
+
+ }
+
+ // any objects to create ?
+ int newObjects = (changedObjects ^ exportedObjects);
+
+ if ( newObjects ) {
+
+ // create new objects with xmp-data
+ int headerStartPos;
+ ASF_ObjectBase newObjectBase;
+ XMP_Uns32 length;
+
+ if ( newObjects & ASF_LegacyManager::objectContentDescription ) {
+
+ headerStartPos = header.size();
+ newObjectBase.guid = ASF_Content_Description_Object;
+ newObjectBase.size = 0;
+
+ // write object header
+ header.append ( (const char*)&newObjectBase, kASF_ObjectBaseLen );
+
+ XMP_Uns16 titleLen = _legacyManager.GetField ( ASF_LegacyManager::fieldTitle).size( );
+ valueUns16LE = MakeUns16LE ( titleLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 authorLen = _legacyManager.GetField ( ASF_LegacyManager::fieldAuthor).size( );
+ valueUns16LE = MakeUns16LE ( authorLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 copyrightLen = _legacyManager.GetField ( ASF_LegacyManager::fieldCopyright).size( );
+ valueUns16LE = MakeUns16LE ( copyrightLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 descriptionLen = _legacyManager.GetField ( ASF_LegacyManager::fieldDescription).size( );
+ valueUns16LE = MakeUns16LE ( descriptionLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ XMP_Uns16 ratingLen = 0;
+ valueUns16LE = MakeUns16LE ( ratingLen );
+ header.append ( (const char*)&valueUns16LE, 2 );
+
+ // write field contents
+
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldTitle ) );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldAuthor ) );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldCopyright ) );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldDescription ) );
+
+ // update new object size
+ valueUns64LE = MakeUns64LE ( header.size() - headerStartPos );
+ std::string newSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newSize, (headerStartPos + 16), 8 );
+
+ newObjects &= ~ASF_LegacyManager::objectContentDescription;
+
+ writtenObjects ++;
+
+ }
+
+ if ( newObjects & ASF_LegacyManager::objectContentBranding ) {
+
+ headerStartPos = header.size();
+ newObjectBase.guid = ASF_Content_Branding_Object;
+ newObjectBase.size = 0;
+
+ // write object header
+ header.append ( (const char*)&newObjectBase, kASF_ObjectBaseLen );
+
+ // write 'empty' fields
+ header.append ( 12, '\0' );
+
+ // copyright URL
+ length = _legacyManager.GetField ( ASF_LegacyManager::fieldCopyrightURL).size( );
+ valueUns32LE = MakeUns32LE ( length );
+ header.append ( (const char*)&valueUns32LE, 4 );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldCopyrightURL ) );
+
+ // update new object size
+ valueUns64LE = MakeUns64LE ( header.size() - headerStartPos );
+ std::string newSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newSize, (headerStartPos + 16), 8 );
+
+ newObjects &= ~ASF_LegacyManager::objectContentBranding;
+
+ writtenObjects ++;
+
+ }
+
+#if ! Exclude_LicenseURL_Recon
+
+ if ( newObjects & ASF_LegacyManager::objectContentEncryption ) {
+
+ headerStartPos = header.size();
+ newObjectBase.guid = ASF_Content_Encryption_Object;
+ newObjectBase.size = 0;
+
+ // write object header
+ header.append ( (const char*)&newObjectBase, kASF_ObjectBaseLen );
+
+ // write 'empty' fields
+ header.append ( 12, '\0' );
+
+ // License URL
+ length = _legacyManager.GetField ( ASF_LegacyManager::fieldLicenseURL).size( );
+ valueUns32LE = MakeUns32LE ( length );
+ header.append ( (const char*)&valueUns32LE, 4 );
+ header.append ( _legacyManager.GetField ( ASF_LegacyManager::fieldLicenseURL ) );
+
+ // update new object size
+ valueUns64LE = MakeUns64LE ( header.size() - headerStartPos );
+ std::string newSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newSize, (headerStartPos + 16), 8 );
+
+ newObjects &= ~ASF_LegacyManager::objectContentEncryption;
+
+ writtenObjects ++;
+
+ }
+
+#endif
+
+ }
+
+ // create padding object ?
+ if ( usePadding && (header.size ( ) < object.len ) ) {
+ ASF_Support::CreatePaddingObject ( &header, (object.len - header.size()) );
+ writtenObjects ++;
+ }
+
+ // update new header-object size
+ valueUns64LE = MakeUns64LE ( header.size() );
+ std::string newValue ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( header, newValue, 16, 8 );
+
+ // update new number of Header objects
+ valueUns32LE = MakeUns32LE ( writtenObjects );
+ newValue = std::string ( (const char*)&valueUns32LE, 4 );
+ ReplaceString ( header, newValue, 24, 4 );
+
+ // if we are operating on the same file (in-place update), place pointer before writing
+ if ( sourceRef == destRef ) LFA_Seek ( destRef, object.pos, SEEK_SET );
+
+ // write header
+ LFA_Write ( destRef, header.c_str(), header.size() );
+
+ } catch ( ... ) {
+
+ ret = false;
+
+ }
+
+ return ret;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::UpdateHeaderObject ( LFA_FileRef fileRef, const ObjectData& object, ASF_LegacyManager& _legacyManager )
+{
+ return ASF_Support::WriteHeaderObject ( fileRef, fileRef, object, _legacyManager, true );
+}
+
+// =============================================================================================
+
+bool ASF_Support::UpdateFileSize ( LFA_FileRef fileRef )
+{
+ if ( fileRef == 0 ) return false;
+
+ XMP_Uns64 posCurrent = LFA_Seek ( fileRef, 0, SEEK_CUR );
+ XMP_Uns64 newSizeLE = MakeUns64LE ( LFA_Measure ( fileRef ) );
+
+ if ( this->posFileSizeInfo != 0 ) {
+
+ LFA_Seek ( fileRef, this->posFileSizeInfo, SEEK_SET );
+
+ } else {
+
+ // The position of the file size field is not known, find it.
+
+ ASF_ObjectBase objHeader;
+
+ // Read the Header object at the start of the file.
+
+ LFA_Seek ( fileRef, 0, SEEK_SET );
+ LFA_Read ( fileRef, &objHeader, kASF_ObjectBaseLen, kLFA_RequireAll );
+ if ( ! IsEqualGUID ( ASF_Header_Object, objHeader.guid ) ) return false;
+
+ XMP_Uns32 childCount;
+ LFA_Read ( fileRef, &childCount, 4, kLFA_RequireAll );
+ childCount = GetUns32LE ( &childCount );
+
+ LFA_Seek ( fileRef, 2, SEEK_CUR ); // Skip the 2 reserved bytes.
+
+ // Look for the File Properties object in the Header's children.
+
+ for ( ; childCount > 0; --childCount ) {
+ LFA_Read ( fileRef, &objHeader, kASF_ObjectBaseLen, kLFA_RequireAll );
+ if ( IsEqualGUID ( ASF_File_Properties_Object, objHeader.guid ) ) break;
+ XMP_Uns64 dataLen = GetUns64LE ( &objHeader.size ) - 24;
+ LFA_Seek ( fileRef, dataLen, SEEK_CUR ); // Skip this object's data.
+ }
+ if ( childCount == 0 ) return false;
+
+ // Seek to the file size field.
+
+ XMP_Uns64 fpoSize = GetUns64LE ( &objHeader.size );
+ if ( fpoSize < (16+8+16+8) ) return false;
+ LFA_Seek ( fileRef, 16, SEEK_CUR ); // Skip to the file size field.
+
+ }
+
+ LFA_Write ( fileRef, &newSizeLE, 8 ); // Write the new file size.
+
+ LFA_Seek ( fileRef, posCurrent, SEEK_SET );
+ return true;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::ReadHeaderExtensionObject ( LFA_FileRef fileRef, ObjectState& inOutObjectState, const XMP_Uns64& _pos, const ASF_ObjectBase& _objectBase )
+{
+ if ( ! IsEqualGUID ( ASF_Header_Extension_Object, _objectBase.guid) || (! legacyManager ) ) return false;
+
+ try {
+
+ // read extended header-object structure beginning at the data part (offset = 46)
+ const XMP_Uns64 offset = 46;
+ XMP_Uns64 read = 0;
+ XMP_Uns64 data = (_objectBase.size - offset);
+ XMP_Uns64 pos = (_pos + offset);
+
+ ASF_ObjectBase objectBase;
+
+ while ( read < data ) {
+
+ LFA_Seek ( fileRef, pos, SEEK_SET );
+ if ( kASF_ObjectBaseLen != LFA_Read ( fileRef, &objectBase, kASF_ObjectBaseLen, true ) ) break;
+
+ objectBase.size = GetUns64LE ( &objectBase.size );
+
+ if ( IsEqualGUID ( ASF_Padding_Object, objectBase.guid ) ) {
+ legacyManager->SetPadding ( legacyManager->GetPadding() + (objectBase.size - 24) );
+ }
+
+ pos += objectBase.size;
+ read += objectBase.size;
+
+ }
+
+ } catch ( ... ) {
+
+ return false;
+
+ }
+
+ return true;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::WriteHeaderExtensionObject ( const std::string& buffer, std::string* header, const ASF_ObjectBase& _objectBase, const int /*reservePadding*/ )
+{
+ if ( ! IsEqualGUID ( ASF_Header_Extension_Object, _objectBase.guid ) || (! header) || (buffer.size() < 46) ) return false;
+
+ const XMP_Uns64 offset = 46;
+ int startPos = header->size();
+
+ // copy header base
+ header->append ( buffer, 0, offset );
+
+ // read extended header-object structure beginning at the data part (offset = 46)
+ XMP_Uns64 read = 0;
+ XMP_Uns64 data = (_objectBase.size - offset);
+ XMP_Uns64 pos = offset;
+
+ ASF_ObjectBase objectBase;
+
+ while ( read < data ) {
+
+ memcpy ( &objectBase, &buffer[int(pos)], kASF_ObjectBaseLen );
+ objectBase.size = GetUns64LE ( &objectBase.size );
+
+ if ( IsEqualGUID ( ASF_Padding_Object, objectBase.guid ) ) {
+ // eliminate
+ } else {
+ // copy other objects
+ header->append ( buffer, XMP_Uns32(pos), XMP_Uns32(objectBase.size) );
+ }
+
+ pos += objectBase.size;
+ read += objectBase.size;
+
+ }
+
+ // update header extension data size
+ XMP_Uns32 valueUns32LE = MakeUns32LE ( header->size() - startPos - offset );
+ std::string newDataSize ( (const char*)&valueUns32LE, 4 );
+ ReplaceString ( *header, newDataSize, (startPos + 42), 4 );
+
+ // update new object size
+ XMP_Uns64 valueUns64LE = MakeUns64LE ( header->size() - startPos );
+ std::string newObjectSize ( (const char*)&valueUns64LE, 8 );
+ ReplaceString ( *header, newObjectSize, (startPos + 16), 8 );
+
+ return true;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::CreatePaddingObject ( std::string* header, const XMP_Uns64 size )
+{
+ if ( ( ! header) || (size < 24) ) return false;
+
+ ASF_ObjectBase newObjectBase;
+
+ newObjectBase.guid = ASF_Padding_Object;
+ newObjectBase.size = MakeUns64LE ( size );
+
+ // write object header
+ header->append ( (const char*)&newObjectBase, kASF_ObjectBaseLen );
+
+ // write 'empty' padding
+ header->append ( XMP_Uns32 ( size - 24 ), '\0' );
+
+ return true;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::WriteXMPObject ( LFA_FileRef fileRef, XMP_Uns32 len, const char* inBuffer )
+{
+ bool ret = false;
+
+ ASF_ObjectBase objectBase = { ASF_XMP_Metadata, 0 };
+ objectBase.size = MakeUns64LE ( len + kASF_ObjectBaseLen );
+
+ try {
+ LFA_Write ( fileRef, &objectBase, kASF_ObjectBaseLen );
+ LFA_Write ( fileRef, inBuffer, len );
+ ret = true;
+ } catch ( ... ) {}
+
+ return ret;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::UpdateXMPObject ( LFA_FileRef fileRef, const ObjectData& object, XMP_Uns32 len, const char * inBuffer )
+{
+ bool ret = false;
+
+ ASF_ObjectBase objectBase = { ASF_XMP_Metadata, 0 };
+ objectBase.size = MakeUns64LE ( len + kASF_ObjectBaseLen );
+
+ try {
+ LFA_Seek ( fileRef, object.pos, SEEK_SET );
+ LFA_Write ( fileRef, &objectBase, kASF_ObjectBaseLen );
+ LFA_Write ( fileRef, inBuffer, len );
+ ret = true;
+ } catch ( ... ) {}
+
+ return ret;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::CopyObject ( LFA_FileRef sourceRef, LFA_FileRef destRef, const ObjectData& object )
+{
+ try {
+ LFA_Seek ( sourceRef, object.pos, SEEK_SET );
+ LFA_Copy ( sourceRef, destRef, object.len );
+ } catch ( ... ) {
+ return false;
+ }
+
+ return true;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::ReadBuffer ( LFA_FileRef fileRef, XMP_Uns64 & pos, XMP_Uns64 len, char * outBuffer )
+{
+ try {
+
+ if ( (fileRef == 0) || (outBuffer == 0) ) return false;
+
+ LFA_Seek (fileRef, pos, SEEK_SET );
+ long bytesRead = LFA_Read ( fileRef, outBuffer, XMP_Int32(len), true );
+ if ( XMP_Uns32 ( bytesRead ) != len ) return false;
+
+ return true;
+
+ } catch ( ... ) {}
+
+ return false;
+
+}
+
+// =============================================================================================
+
+bool ASF_Support::WriteBuffer ( LFA_FileRef fileRef, XMP_Uns64 & pos, XMP_Uns32 len, const char * inBuffer )
+{
+ try {
+
+ if ( (fileRef == 0) || (inBuffer == 0) ) return false;
+
+ LFA_Seek (fileRef, pos, SEEK_SET );
+ LFA_Write( fileRef, inBuffer, len );
+
+ return true;
+
+ } catch ( ... ) {}
+
+ return false;
+
+}
+
+// =================================================================================================
+
+std::string ASF_Support::ReplaceString ( std::string& operand, std::string& str, int offset, int count )
+{
+ std::basic_string<char>::iterator iterF1, iterL1, iterF2, iterL2;
+
+ iterF1 = operand.begin() + offset;
+ iterL1 = operand.begin() + offset + count;
+ iterF2 = str.begin();
+ iterL2 = str.begin() + count;
+
+ return operand.replace ( iterF1, iterL1, iterF2, iterL2 );
+
+}
+
+// =================================================================================================
+
+ASF_LegacyManager::ASF_LegacyManager() : fields(fieldLast), broadcastSet(false), digestComputed(false),
+ imported(false), objectsExisting(0), objectsToExport(0), legacyDiff(0), padding(0)
+{
+ // Nothing more to do.
+}
+
+// =================================================================================================
+
+ASF_LegacyManager::~ASF_LegacyManager()
+{
+ // Nothing to do.
+}
+
+// =================================================================================================
+
+bool ASF_LegacyManager::SetField ( fieldType field, const std::string& value )
+{
+ if ( field >= fieldLast ) return false;
+
+ unsigned int maxSize = this->GetFieldMaxSize ( field );
+
+ if (value.size ( ) <= maxSize ) {
+ fields[field] = value;
+ } else {
+ fields[field] = value.substr ( 0, maxSize );
+ }
+
+ if ( field == fieldCopyrightURL ) NormalizeStringDisplayASCII ( fields[field] );
+
+ #if ! Exclude_LicenseURL_Recon
+ if ( field == fieldLicenseURL ) NormalizeStringDisplayASCII ( fields[field] );
+ #endif
+
+ return true;
+
+}
+
+// =================================================================================================
+
+std::string ASF_LegacyManager::GetField ( fieldType field )
+{
+ if ( field >= fieldLast ) return std::string();
+ return fields[field];
+}
+
+// =================================================================================================
+
+unsigned int ASF_LegacyManager::GetFieldMaxSize ( fieldType field )
+{
+ unsigned int maxSize = 0;
+
+ switch ( field ) {
+
+ case fieldCreationDate :
+ maxSize = 8;
+ break;
+
+ case fieldTitle :
+ case fieldAuthor :
+ case fieldCopyright :
+ case fieldDescription :
+ maxSize = 0xFFFF;
+ break;
+
+ case fieldCopyrightURL :
+#if ! Exclude_LicenseURL_Recon
+ case fieldLicenseURL :
+#endif
+ maxSize = 0xFFFFFFFF;
+ break;
+
+ default:
+ break;
+
+ }
+
+ return maxSize;
+
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::SetObjectExists ( objectType object )
+{
+ objectsExisting |= object;
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::SetBroadcast ( const bool broadcast )
+{
+ broadcastSet = broadcast;
+}
+
+// =================================================================================================
+
+bool ASF_LegacyManager::GetBroadcast()
+{
+ return broadcastSet;
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::ComputeDigest()
+{
+ MD5_CTX context;
+ MD5_Digest digest;
+ char buffer[40];
+
+ MD5Init ( &context );
+ digestStr.clear();
+ digestStr.reserve ( 160 );
+
+ for ( int type=0; type < fieldLast; ++type ) {
+
+ if (fields[type].size ( ) > 0 ) {
+ snprintf ( buffer, sizeof(buffer), "%d,", type );
+ digestStr.append ( buffer );
+ MD5Update ( &context, (XMP_Uns8*)fields[type].data(), fields[type].size() );
+ }
+
+ }
+
+ digestStr[digestStr.size()-1] = ';';
+
+ MD5Final ( digest, &context );
+
+ size_t in, out;
+ for ( in = 0, out = 0; in < 16; in += 1, out += 2 ) {
+ XMP_Uns8 byte = digest[in];
+ buffer[out] = ReconcileUtils::kHexDigits [ byte >> 4 ];
+ buffer[out+1] = ReconcileUtils::kHexDigits [ byte & 0xF ];
+ }
+ buffer[32] = 0;
+
+ digestStr.append ( buffer );
+
+ digestComputed = true;
+
+}
+
+// =================================================================================================
+
+bool ASF_LegacyManager::CheckDigest ( const SXMPMeta& xmp )
+{
+ bool ret = false;
+
+ if ( ! digestComputed ) this->ComputeDigest();
+
+ std::string oldDigest;
+
+ if ( xmp.GetProperty ( kXMP_NS_ASF, "NativeDigest", &oldDigest, 0 ) ) {
+ ret = (digestStr == oldDigest);
+ }
+
+ return ret;
+
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::SetDigest ( SXMPMeta* xmp )
+{
+ if ( ! digestComputed ) this->ComputeDigest();
+
+ xmp->SetProperty ( kXMP_NS_ASF, "NativeDigest", digestStr.c_str() );
+
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::ImportLegacy ( SXMPMeta* xmp )
+{
+ std::string utf8;
+
+ if ( ! broadcastSet ) {
+ ConvertMSDateToISODate ( fields[fieldCreationDate], &utf8 );
+ xmp->SetProperty ( kXMP_NS_XMP, "CreateDate", utf8.c_str(), kXMP_DeleteExisting );
+ }
+
+ FromUTF16 ( (UTF16Unit*)fields[fieldTitle].c_str(), (fields[fieldTitle].size() / 2), &utf8, false );
+ xmp->SetLocalizedText ( kXMP_NS_DC, "title", "", "x-default", utf8.c_str(), kXMP_DeleteExisting );
+
+ xmp->DeleteProperty ( kXMP_NS_DC, "creator" );
+ FromUTF16 ( (UTF16Unit*)fields[fieldAuthor].c_str(), (fields[fieldAuthor].size() / 2), &utf8, false );
+ SXMPUtils::SeparateArrayItems ( xmp, kXMP_NS_DC, "creator", kXMPUtil_AllowCommas, utf8.c_str() );
+
+ FromUTF16 ( (UTF16Unit*)fields[fieldCopyright].c_str(), (fields[fieldCopyright].size() / 2), &utf8, false );
+ xmp->SetLocalizedText ( kXMP_NS_DC, "rights", "", "x-default", utf8.c_str(), kXMP_DeleteExisting );
+
+ FromUTF16 ( (UTF16Unit*)fields[fieldDescription].c_str(), (fields[fieldDescription].size() / 2), &utf8, false );
+ xmp->SetLocalizedText ( kXMP_NS_DC, "description", "", "x-default", utf8.c_str(), kXMP_DeleteExisting );
+
+ xmp->SetProperty ( kXMP_NS_XMP_Rights, "WebStatement", fields[fieldCopyrightURL].c_str(), kXMP_DeleteExisting );
+
+#if ! Exclude_LicenseURL_Recon
+ xmp->SetProperty ( kXMP_NS_XMP_Rights, "Certificate", fields[fieldLicenseURL].c_str(), kXMP_DeleteExisting );
+#endif
+
+ imported = true;
+
+}
+
+// =================================================================================================
+
+int ASF_LegacyManager::ExportLegacy ( const SXMPMeta& xmp )
+{
+ int changed = 0;
+ objectsToExport = 0;
+ legacyDiff = 0;
+
+ std::string utf8;
+ std::string utf16;
+ XMP_OptionBits flags;
+
+ if ( ! broadcastSet ) {
+ if ( xmp.GetProperty ( kXMP_NS_XMP, "CreateDate", &utf8, &flags ) ) {
+ std::string date;
+ ConvertISODateToMSDate ( utf8, &date );
+ if ( fields[fieldCreationDate] != date ) {
+ legacyDiff += date.size();
+ legacyDiff -= fields[fieldCreationDate].size();
+ this->SetField ( fieldCreationDate, date );
+ objectsToExport |= objectFileProperties;
+ changed ++;
+ }
+ }
+ }
+
+ if ( xmp.GetLocalizedText ( kXMP_NS_DC, "title", "", "x-default", 0, &utf8, &flags ) ) {
+ NormalizeStringTrailingNull ( utf8 );
+ ToUTF16 ( (const UTF8Unit*)utf8.data(), utf8.size(), &utf16, false );
+ if ( fields[fieldTitle] != utf16 ) {
+ legacyDiff += utf16.size();
+ legacyDiff -= fields[fieldTitle].size();
+ this->SetField ( fieldTitle, utf16 );
+ objectsToExport |= objectContentDescription;
+ changed ++;
+ }
+ }
+
+ utf8.clear();
+ SXMPUtils::CatenateArrayItems ( xmp, kXMP_NS_DC, "creator", 0, 0, kXMPUtil_AllowCommas, &utf8 );
+ if ( ! utf8.empty() ) {
+ NormalizeStringTrailingNull ( utf8 );
+ ToUTF16 ( (const UTF8Unit*)utf8.data(), utf8.size(), &utf16, false );
+ if ( fields[fieldAuthor] != utf16 ) {
+ legacyDiff += utf16.size();
+ legacyDiff -= fields[fieldAuthor].size();
+ this->SetField ( fieldAuthor, utf16 );
+ objectsToExport |= objectContentDescription;
+ changed ++;
+ }
+ }
+
+ if ( xmp.GetLocalizedText ( kXMP_NS_DC, "rights", "", "x-default", 0, &utf8, &flags ) ) {
+ NormalizeStringTrailingNull ( utf8 );
+ ToUTF16 ( (const UTF8Unit*)utf8.data(), utf8.size(), &utf16, false );
+ if ( fields[fieldCopyright] != utf16 ) {
+ legacyDiff += utf16.size();
+ legacyDiff -= fields[fieldCopyright].size();
+ this->SetField ( fieldCopyright, utf16 );
+ objectsToExport |= objectContentDescription;
+ changed ++;
+ }
+ }
+
+ if ( xmp.GetLocalizedText ( kXMP_NS_DC, "description", "", "x-default", 0, &utf8, &flags ) ) {
+ NormalizeStringTrailingNull ( utf8 );
+ ToUTF16 ( (const UTF8Unit*)utf8.data(), utf8.size(), &utf16, false );
+ if ( fields[fieldDescription] != utf16 ) {
+ legacyDiff += utf16.size();
+ legacyDiff -= fields[fieldDescription].size();
+ this->SetField ( fieldDescription, utf16 );
+ objectsToExport |= objectContentDescription;
+ changed ++;
+ }
+ }
+
+ if ( xmp.GetProperty ( kXMP_NS_XMP_Rights, "WebStatement", &utf8, &flags ) ) {
+ NormalizeStringTrailingNull ( utf8 );
+ if ( fields[fieldCopyrightURL] != utf8 ) {
+ legacyDiff += utf8.size();
+ legacyDiff -= fields[fieldCopyrightURL].size();
+ this->SetField ( fieldCopyrightURL, utf8 );
+ objectsToExport |= objectContentBranding;
+ changed ++;
+ }
+ }
+
+#if ! Exclude_LicenseURL_Recon
+ if ( xmp.GetProperty ( kXMP_NS_XMP_Rights, "Certificate", &utf8, &flags ) ) {
+ NormalizeStringTrailingNull ( utf8 );
+ if ( fields[fieldLicenseURL] != utf8 ) {
+ legacyDiff += utf8.size();
+ legacyDiff -= fields[fieldLicenseURL].size();
+ this->SetField ( fieldLicenseURL, utf8 );
+ objectsToExport |= objectContentEncryption;
+ changed ++;
+ }
+ }
+#endif
+
+ // find objects, that would need to be created on legacy export
+ int newObjects = (objectsToExport & !objectsExisting);
+
+ // calculate minimum storage for new objects, that might be created on export
+ if ( newObjects & objectContentDescription )
+ legacyDiff += sizeContentDescription;
+ if ( newObjects & objectContentBranding )
+ legacyDiff += sizeContentBranding;
+ if ( newObjects & objectContentEncryption )
+ legacyDiff += sizeContentEncryption;
+
+ ComputeDigest();
+
+ return changed;
+
+}
+
+// =================================================================================================
+
+bool ASF_LegacyManager::hasLegacyChanged()
+{
+ return (objectsToExport != 0);
+}
+
+// =================================================================================================
+
+XMP_Int64 ASF_LegacyManager::getLegacyDiff()
+{
+ return (this->hasLegacyChanged() ? legacyDiff : 0);
+}
+
+// =================================================================================================
+
+int ASF_LegacyManager::changedObjects()
+{
+ return objectsToExport;
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::SetPadding ( XMP_Int64 _padding )
+{
+ padding = _padding;
+}
+
+// =================================================================================================
+
+XMP_Int64 ASF_LegacyManager::GetPadding()
+{
+ return padding;
+}
+
+// =================================================================================================
+
+std::string ASF_LegacyManager::NormalizeStringDisplayASCII ( std::string& operand )
+{
+ std::basic_string<char>::iterator current = operand.begin();
+ std::basic_string<char>::iterator end = operand.end();;
+
+ for ( ; (current != end); ++current ) {
+ char element = *current;
+ if ( ( (element < 0x21) && (element != 0x00)) || (element > 0x7e) ) {
+ *current = '?';
+ }
+ }
+
+ return operand;
+
+}
+
+// =================================================================================================
+
+std::string ASF_LegacyManager::NormalizeStringTrailingNull ( std::string& operand )
+{
+ if ( ( operand.size() > 0) && (operand[operand.size() - 1] != '\0') ) {
+ operand.append ( 1, '\0' );
+ }
+
+ return operand;
+
+}
+
+// =================================================================================================
+
+int ASF_LegacyManager::DaysInMonth ( XMP_Int32 year, XMP_Int32 month )
+{
+
+ static short daysInMonth[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+ // Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
+
+ int days = daysInMonth [ month ];
+ if ( (month == 2) && IsLeapYear ( year ) ) days += 1;
+
+ return days;
+
+}
+
+// =================================================================================================
+
+bool ASF_LegacyManager::IsLeapYear ( long year )
+{
+
+ if ( year < 0 ) year = -year + 1; // Fold the negative years, assuming there is a year 0.
+
+ if ( (year % 4) != 0 ) return false; // Not a multiple of 4.
+ if ( (year % 100) != 0 ) return true; // A multiple of 4 but not a multiple of 100.
+ if ( (year % 400) == 0 ) return true; // A multiple of 400.
+
+ return false; // A multiple of 100 but not a multiple of 400.
+
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::ConvertMSDateToISODate ( std::string& source, std::string* dest )
+{
+
+ XMP_Int64 creationDate = GetUns64LE ( source.c_str() );
+ XMP_Int64 totalSecs = creationDate / (10*1000*1000);
+ XMP_Int32 nanoSec = ( ( XMP_Int32) (creationDate - (totalSecs * 10*1000*1000)) ) * 100;
+
+ XMP_Int32 days = (XMP_Int32) (totalSecs / 86400);
+ totalSecs -= ( ( XMP_Int64)days * 86400 );
+
+ XMP_Int32 hour = (XMP_Int32) (totalSecs / 3600);
+ totalSecs -= ( ( XMP_Int64)hour * 3600 );
+
+ XMP_Int32 minute = (XMP_Int32) (totalSecs / 60);
+ totalSecs -= ( ( XMP_Int64)minute * 60 );
+
+ XMP_Int32 second = (XMP_Int32)totalSecs;
+
+ // A little more simple code converts this to an XMP date string:
+
+ XMP_DateTime date;
+ memset ( &date, 0, sizeof ( date ) );
+
+ date.year = 1601; // The MS date origin.
+ date.month = 1;
+ date.day = 1;
+
+ date.day += days; // Add in the delta.
+ date.hour = hour;
+ date.minute = minute;
+ date.second = second;
+ date.nanoSecond = nanoSec;
+
+ SXMPUtils::ConvertToUTCTime ( &date ); // Normalize the date/time.
+ SXMPUtils::ConvertFromDate ( date, dest ); // Convert to an ISO 8601 string.
+
+}
+
+// =================================================================================================
+
+void ASF_LegacyManager::ConvertISODateToMSDate ( std::string& source, std::string* dest )
+{
+ XMP_DateTime date;
+ SXMPUtils::ConvertToDate ( source, &date );
+ SXMPUtils::ConvertToUTCTime ( &date );
+
+ XMP_Int64 creationDate;
+ creationDate = date.nanoSecond / 100;
+ creationDate += (XMP_Int64 ( date.second) * (10*1000*1000) );
+ creationDate += (XMP_Int64 ( date.minute) * 60 * (10*1000*1000) );
+ creationDate += (XMP_Int64 ( date.hour) * 3600 * (10*1000*1000) );
+
+ XMP_Int32 days = (date.day - 1);
+
+ --date.month;
+ while ( date.month >= 1 ) {
+ days += DaysInMonth ( date.year, date.month );
+ --date.month;
+ }
+
+ --date.year;
+ while ( date.year >= 1601 ) {
+ days += (IsLeapYear ( date.year) ? 366 : 365 );
+ --date.year;
+ }
+
+ creationDate += (XMP_Int64 ( days) * 86400 * (10*1000*1000) );
+
+ creationDate = GetUns64LE ( &creationDate );
+ dest->assign ( (const char*)&creationDate, 8 );
+
+}