src/Metadata.cpp

   1 /*
   2 Copyright (c) 2005-2006, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27 /*! \file    Metadata.cpp
  28     \version $Id$
  29     \brief   AS-DCP library, MXF Metadata Sets implementation
  30 */
  31
  32
  33 #include <KM_mutex.h>
  34 #include "Metadata.h"
  35
  36 const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
  37
  38 //------------------------------------------------------------------------------------------
  39
  40 //
  41 enum FLT_t
  42   {
  43     FLT_Preface,
  44     FLT_IndexTableSegment,
  45     FLT_Identification,
  46     FLT_ContentStorage,
  47     FLT_EssenceContainerData,
  48     FLT_MaterialPackage,
  49     FLT_SourcePackage,
  50     FLT_StaticTrack,
  51     FLT_Track,
  52     FLT_Sequence,
  53     FLT_SourceClip,
  54     FLT_TimecodeComponent,
  55     FLT_FileDescriptor,
  56     FLT_GenericSoundEssenceDescriptor,
  57     FLT_WaveAudioDescriptor,
  58     FLT_GenericPictureEssenceDescriptor,
  59     FLT_RGBAEssenceDescriptor,
  60     FLT_JPEG2000PictureSubDescriptor,
  61     FLT_CDCIEssenceDescriptor,
  62     FLT_MPEG2VideoDescriptor,
  63     FLT_DMSegment,
  64     FLT_CryptographicFramework,
  65     FLT_CryptographicContext,
  66   };
  67
  68 //
  69 typedef std::map<ASDCP::UL, FLT_t>::iterator FLi_t;
  70
  71 class FactoryList : public std::map<ASDCP::UL, FLT_t>
  72 {
  73   Kumu::Mutex m_Lock;
  74
  75 public:
  76   FactoryList() {}
  77   ~FactoryList() {}
  78
  79   bool Empty() {
  80     Kumu::AutoMutex BlockLock(m_Lock);
  81     return empty();
  82   }
  83
  84   FLi_t Find(const byte_t* label) {
  85     Kumu::AutoMutex BlockLock(m_Lock);
  86     return find(label);
  87   }
  88
  89   FLi_t End() {
  90     Kumu::AutoMutex BlockLock(m_Lock);
  91     return end();
  92   }
  93
  94 };
  95
  96 //
  97 static FactoryList s_FactoryList;
  98
  99 //
 100 ASDCP::MXF::InterchangeObject*
 101 ASDCP::MXF::CreateObject(const byte_t* label)
 102 {
 103   if ( label == 0 )
 104     return 0;
 105
 106   if ( s_FactoryList.empty() )
 107     {
 108       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_Preface), FLT_Preface));
 109       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_IndexTableSegment), FLT_IndexTableSegment));
 110       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_Identification), FLT_Identification));
 111       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_ContentStorage), FLT_ContentStorage));
 112       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_EssenceContainerData), FLT_EssenceContainerData));
 113       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_MaterialPackage), FLT_MaterialPackage));
 114       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_SourcePackage), FLT_SourcePackage));
 115       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_StaticTrack), FLT_StaticTrack));
 116       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_Track), FLT_Track));
 117       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_Sequence), FLT_Sequence));
 118       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_SourceClip), FLT_SourceClip));
 119       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_TimecodeComponent), FLT_TimecodeComponent));
 120       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_FileDescriptor), FLT_FileDescriptor));
 121       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_GenericSoundEssenceDescriptor), FLT_GenericSoundEssenceDescriptor));
 122       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_WaveAudioDescriptor), FLT_WaveAudioDescriptor));
 123       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_GenericPictureEssenceDescriptor), FLT_GenericPictureEssenceDescriptor));
 124       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_RGBAEssenceDescriptor), FLT_RGBAEssenceDescriptor));
 125       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_JPEG2000PictureSubDescriptor), FLT_JPEG2000PictureSubDescriptor));
 126       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_CDCIEssenceDescriptor), FLT_CDCIEssenceDescriptor));
 127       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_MPEG2VideoDescriptor), FLT_MPEG2VideoDescriptor));
 128       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_DMSegment), FLT_DMSegment));
 129       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_CryptographicFramework), FLT_CryptographicFramework));
 130       s_FactoryList.insert(FactoryList::value_type(Dict::ul(MDD_CryptographicContext), FLT_CryptographicContext));
 131     }
 132
 133   FLi_t i = s_FactoryList.find(label);
 134
 135   if ( i == s_FactoryList.end() )
 136     return new InterchangeObject;
 137
 138   switch ( i->second )
 139     {
 140       case FLT_Preface: return new Preface;
 141       case FLT_IndexTableSegment: return new IndexTableSegment;
 142       case FLT_Identification: return new Identification;
 143       case FLT_ContentStorage: return new ContentStorage;
 144       case FLT_EssenceContainerData: return new EssenceContainerData;
 145       case FLT_MaterialPackage: return new MaterialPackage;
 146       case FLT_SourcePackage: return new SourcePackage;
 147       case FLT_StaticTrack: return new StaticTrack;
 148       case FLT_Track: return new Track;
 149       case FLT_Sequence: return new Sequence;
 150       case FLT_SourceClip: return new SourceClip;
 151       case FLT_TimecodeComponent: return new TimecodeComponent;
 152       case FLT_FileDescriptor: return new FileDescriptor;
 153       case FLT_GenericSoundEssenceDescriptor: return new GenericSoundEssenceDescriptor;
 154       case FLT_WaveAudioDescriptor: return new WaveAudioDescriptor;
 155       case FLT_GenericPictureEssenceDescriptor: return new GenericPictureEssenceDescriptor;
 156       case FLT_RGBAEssenceDescriptor: return new RGBAEssenceDescriptor;
 157       case FLT_JPEG2000PictureSubDescriptor: return new JPEG2000PictureSubDescriptor;
 158       case FLT_CDCIEssenceDescriptor: return new CDCIEssenceDescriptor;
 159       case FLT_MPEG2VideoDescriptor: return new MPEG2VideoDescriptor;
 160       case FLT_DMSegment: return new DMSegment;
 161       case FLT_CryptographicFramework: return new CryptographicFramework;
 162       case FLT_CryptographicContext: return new CryptographicContext;
 163     }
 164
 165   return 0;
 166 }
 167
 168
 169 //------------------------------------------------------------------------------------------
 170 // KLV Sets
 171
 172
 173
 174 //------------------------------------------------------------------------------------------
 175 // Identification
 176
 177 //
 178 ASDCP::Result_t
 179 ASDCP::MXF::Identification::InitFromTLVSet(TLVReader& TLVSet)
 180 {
 181   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 182   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
 183   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
 184   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
 185   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductVersion));
 186   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
 187   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
 188   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
 189   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ToolkitVersion));
 190   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, Platform));
 191   return result;
 192 }
 193
 194 //
 195 ASDCP::Result_t
 196 ASDCP::MXF::Identification::WriteToTLVSet(TLVWriter& TLVSet)
 197 {
 198   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 199   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ThisGenerationUID));
 200   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, CompanyName));
 201   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductName));
 202   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductVersion));
 203   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, VersionString));
 204   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductUID));
 205   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ModificationDate));
 206   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ToolkitVersion));
 207   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, Platform));
 208   return result;
 209 }
 210
 211 //
 212 void
 213 ASDCP::MXF::Identification::Dump(FILE* stream)
 214 {
 215   char identbuf[IdentBufferLen];
 216   *identbuf = 0;
 217
 218   if ( stream == 0 )
 219     stream = stderr;
 220
 221   InterchangeObject::Dump(stream);
 222   fprintf(stream, "  %22s = %s\n",  "ThisGenerationUID", ThisGenerationUID.EncodeString(identbuf, IdentBufferLen));
 223   fprintf(stream, "  %22s = %s\n",  "CompanyName", CompanyName.EncodeString(identbuf, IdentBufferLen));
 224   fprintf(stream, "  %22s = %s\n",  "ProductName", ProductName.EncodeString(identbuf, IdentBufferLen));
 225   fprintf(stream, "  %22s = %s\n",  "ProductVersion", ProductVersion.EncodeString(identbuf, IdentBufferLen));
 226   fprintf(stream, "  %22s = %s\n",  "VersionString", VersionString.EncodeString(identbuf, IdentBufferLen));
 227   fprintf(stream, "  %22s = %s\n",  "ProductUID", ProductUID.EncodeString(identbuf, IdentBufferLen));
 228   fprintf(stream, "  %22s = %s\n",  "ModificationDate", ModificationDate.EncodeString(identbuf, IdentBufferLen));
 229   fprintf(stream, "  %22s = %s\n",  "ToolkitVersion", ToolkitVersion.EncodeString(identbuf, IdentBufferLen));
 230   fprintf(stream, "  %22s = %s\n",  "Platform", Platform.EncodeString(identbuf, IdentBufferLen));
 231 }
 232
 233 //
 234 ASDCP::Result_t
 235 ASDCP::MXF::Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 236 {
 237   m_Typeinfo = &Dict::Type(MDD_Identification);
 238   return InterchangeObject::InitFromBuffer(p, l);
 239 }
 240
 241 //
 242 ASDCP::Result_t
 243 ASDCP::MXF::Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 244 {
 245   m_Typeinfo = &Dict::Type(MDD_Identification);
 246   return InterchangeObject::WriteToBuffer(Buffer);
 247 }
 248
 249 //------------------------------------------------------------------------------------------
 250 // ContentStorage
 251
 252 //
 253 ASDCP::Result_t
 254 ASDCP::MXF::ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
 255 {
 256   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 257   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
 258   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
 259   return result;
 260 }
 261
 262 //
 263 ASDCP::Result_t
 264 ASDCP::MXF::ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
 265 {
 266   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 267   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, Packages));
 268   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, EssenceContainerData));
 269   return result;
 270 }
 271
 272 //
 273 void
 274 ASDCP::MXF::ContentStorage::Dump(FILE* stream)
 275 {
 276   char identbuf[IdentBufferLen];
 277   *identbuf = 0;
 278
 279   if ( stream == 0 )
 280     stream = stderr;
 281
 282   InterchangeObject::Dump(stream);
 283   fprintf(stream, "  %22s:\n",  "Packages");
 284   Packages.Dump(stream);
 285   fprintf(stream, "  %22s:\n",  "EssenceContainerData");
 286   EssenceContainerData.Dump(stream);
 287 }
 288
 289 //
 290 ASDCP::Result_t
 291 ASDCP::MXF::ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 292 {
 293   m_Typeinfo = &Dict::Type(MDD_ContentStorage);
 294   return InterchangeObject::InitFromBuffer(p, l);
 295 }
 296
 297 //
 298 ASDCP::Result_t
 299 ASDCP::MXF::ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 300 {
 301   m_Typeinfo = &Dict::Type(MDD_ContentStorage);
 302   return InterchangeObject::WriteToBuffer(Buffer);
 303 }
 304
 305 //------------------------------------------------------------------------------------------
 306 // EssenceContainerData
 307
 308 //
 309 ASDCP::Result_t
 310 ASDCP::MXF::EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
 311 {
 312   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 313   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(EssenceContainerData, LinkedPackageUID));
 314   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, IndexSID));
 315   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, BodySID));
 316   return result;
 317 }
 318
 319 //
 320 ASDCP::Result_t
 321 ASDCP::MXF::EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
 322 {
 323   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 324   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(EssenceContainerData, LinkedPackageUID));
 325   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, IndexSID));
 326   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, BodySID));
 327   return result;
 328 }
 329
 330 //
 331 void
 332 ASDCP::MXF::EssenceContainerData::Dump(FILE* stream)
 333 {
 334   char identbuf[IdentBufferLen];
 335   *identbuf = 0;
 336
 337   if ( stream == 0 )
 338     stream = stderr;
 339
 340   InterchangeObject::Dump(stream);
 341   fprintf(stream, "  %22s = %s\n",  "LinkedPackageUID", LinkedPackageUID.EncodeString(identbuf, IdentBufferLen));
 342   fprintf(stream, "  %22s = %d\n",  "IndexSID", IndexSID);
 343   fprintf(stream, "  %22s = %d\n",  "BodySID", BodySID);
 344 }
 345
 346 //
 347 ASDCP::Result_t
 348 ASDCP::MXF::EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 349 {
 350   m_Typeinfo = &Dict::Type(MDD_EssenceContainerData);
 351   return InterchangeObject::InitFromBuffer(p, l);
 352 }
 353
 354 //
 355 ASDCP::Result_t
 356 ASDCP::MXF::EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 357 {
 358   m_Typeinfo = &Dict::Type(MDD_EssenceContainerData);
 359   return InterchangeObject::WriteToBuffer(Buffer);
 360 }
 361
 362 //------------------------------------------------------------------------------------------
 363 // GenericPackage
 364
 365 //
 366 ASDCP::Result_t
 367 ASDCP::MXF::GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
 368 {
 369   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 370   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
 371   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Name));
 372   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
 373   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
 374   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
 375   return result;
 376 }
 377
 378 //
 379 ASDCP::Result_t
 380 ASDCP::MXF::GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
 381 {
 382   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 383   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageUID));
 384   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Name));
 385   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageCreationDate));
 386   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageModifiedDate));
 387   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Tracks));
 388   return result;
 389 }
 390
 391 //
 392 void
 393 ASDCP::MXF::GenericPackage::Dump(FILE* stream)
 394 {
 395   char identbuf[IdentBufferLen];
 396   *identbuf = 0;
 397
 398   if ( stream == 0 )
 399     stream = stderr;
 400
 401   InterchangeObject::Dump(stream);
 402   fprintf(stream, "  %22s = %s\n",  "PackageUID", PackageUID.EncodeString(identbuf, IdentBufferLen));
 403   fprintf(stream, "  %22s = %s\n",  "Name", Name.EncodeString(identbuf, IdentBufferLen));
 404   fprintf(stream, "  %22s = %s\n",  "PackageCreationDate", PackageCreationDate.EncodeString(identbuf, IdentBufferLen));
 405   fprintf(stream, "  %22s = %s\n",  "PackageModifiedDate", PackageModifiedDate.EncodeString(identbuf, IdentBufferLen));
 406   fprintf(stream, "  %22s:\n",  "Tracks");
 407   Tracks.Dump(stream);
 408 }
 409
 410
 411 //------------------------------------------------------------------------------------------
 412 // MaterialPackage
 413
 414 //
 415 ASDCP::Result_t
 416 ASDCP::MXF::MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
 417 {
 418   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 419   return result;
 420 }
 421
 422 //
 423 ASDCP::Result_t
 424 ASDCP::MXF::MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
 425 {
 426   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 427   return result;
 428 }
 429
 430 //
 431 void
 432 ASDCP::MXF::MaterialPackage::Dump(FILE* stream)
 433 {
 434   char identbuf[IdentBufferLen];
 435   *identbuf = 0;
 436
 437   if ( stream == 0 )
 438     stream = stderr;
 439
 440   GenericPackage::Dump(stream);
 441 }
 442
 443 //
 444 ASDCP::Result_t
 445 ASDCP::MXF::MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 446 {
 447   m_Typeinfo = &Dict::Type(MDD_MaterialPackage);
 448   return InterchangeObject::InitFromBuffer(p, l);
 449 }
 450
 451 //
 452 ASDCP::Result_t
 453 ASDCP::MXF::MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 454 {
 455   m_Typeinfo = &Dict::Type(MDD_MaterialPackage);
 456   return InterchangeObject::WriteToBuffer(Buffer);
 457 }
 458
 459 //------------------------------------------------------------------------------------------
 460 // SourcePackage
 461
 462 //
 463 ASDCP::Result_t
 464 ASDCP::MXF::SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
 465 {
 466   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 467   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourcePackage, Descriptor));
 468   return result;
 469 }
 470
 471 //
 472 ASDCP::Result_t
 473 ASDCP::MXF::SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
 474 {
 475   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 476   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourcePackage, Descriptor));
 477   return result;
 478 }
 479
 480 //
 481 void
 482 ASDCP::MXF::SourcePackage::Dump(FILE* stream)
 483 {
 484   char identbuf[IdentBufferLen];
 485   *identbuf = 0;
 486
 487   if ( stream == 0 )
 488     stream = stderr;
 489
 490   GenericPackage::Dump(stream);
 491   fprintf(stream, "  %22s = %s\n",  "Descriptor", Descriptor.EncodeString(identbuf, IdentBufferLen));
 492 }
 493
 494 //
 495 ASDCP::Result_t
 496 ASDCP::MXF::SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 497 {
 498   m_Typeinfo = &Dict::Type(MDD_SourcePackage);
 499   return InterchangeObject::InitFromBuffer(p, l);
 500 }
 501
 502 //
 503 ASDCP::Result_t
 504 ASDCP::MXF::SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 505 {
 506   m_Typeinfo = &Dict::Type(MDD_SourcePackage);
 507   return InterchangeObject::WriteToBuffer(Buffer);
 508 }
 509
 510 //------------------------------------------------------------------------------------------
 511 // GenericTrack
 512
 513 //
 514 ASDCP::Result_t
 515 ASDCP::MXF::GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
 516 {
 517   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 518   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
 519   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
 520   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, TrackName));
 521   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, Sequence));
 522   return result;
 523 }
 524
 525 //
 526 ASDCP::Result_t
 527 ASDCP::MXF::GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
 528 {
 529   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 530   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackID));
 531   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackNumber));
 532   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericTrack, TrackName));
 533   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericTrack, Sequence));
 534   return result;
 535 }
 536
 537 //
 538 void
 539 ASDCP::MXF::GenericTrack::Dump(FILE* stream)
 540 {
 541   char identbuf[IdentBufferLen];
 542   *identbuf = 0;
 543
 544   if ( stream == 0 )
 545     stream = stderr;
 546
 547   InterchangeObject::Dump(stream);
 548   fprintf(stream, "  %22s = %d\n",  "TrackID", TrackID);
 549   fprintf(stream, "  %22s = %d\n",  "TrackNumber", TrackNumber);
 550   fprintf(stream, "  %22s = %s\n",  "TrackName", TrackName.EncodeString(identbuf, IdentBufferLen));
 551   fprintf(stream, "  %22s = %s\n",  "Sequence", Sequence.EncodeString(identbuf, IdentBufferLen));
 552 }
 553
 554
 555 //------------------------------------------------------------------------------------------
 556 // StaticTrack
 557
 558 //
 559 ASDCP::Result_t
 560 ASDCP::MXF::StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
 561 {
 562   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 563   return result;
 564 }
 565
 566 //
 567 ASDCP::Result_t
 568 ASDCP::MXF::StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
 569 {
 570   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 571   return result;
 572 }
 573
 574 //
 575 void
 576 ASDCP::MXF::StaticTrack::Dump(FILE* stream)
 577 {
 578   char identbuf[IdentBufferLen];
 579   *identbuf = 0;
 580
 581   if ( stream == 0 )
 582     stream = stderr;
 583
 584   GenericTrack::Dump(stream);
 585 }
 586
 587 //
 588 ASDCP::Result_t
 589 ASDCP::MXF::StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 590 {
 591   m_Typeinfo = &Dict::Type(MDD_StaticTrack);
 592   return InterchangeObject::InitFromBuffer(p, l);
 593 }
 594
 595 //
 596 ASDCP::Result_t
 597 ASDCP::MXF::StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 598 {
 599   m_Typeinfo = &Dict::Type(MDD_StaticTrack);
 600   return InterchangeObject::WriteToBuffer(Buffer);
 601 }
 602
 603 //------------------------------------------------------------------------------------------
 604 // Track
 605
 606 //
 607 ASDCP::Result_t
 608 ASDCP::MXF::Track::InitFromTLVSet(TLVReader& TLVSet)
 609 {
 610   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 611   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
 612   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
 613   return result;
 614 }
 615
 616 //
 617 ASDCP::Result_t
 618 ASDCP::MXF::Track::WriteToTLVSet(TLVWriter& TLVSet)
 619 {
 620   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 621   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Track, EditRate));
 622   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(Track, Origin));
 623   return result;
 624 }
 625
 626 //
 627 void
 628 ASDCP::MXF::Track::Dump(FILE* stream)
 629 {
 630   char identbuf[IdentBufferLen];
 631   *identbuf = 0;
 632
 633   if ( stream == 0 )
 634     stream = stderr;
 635
 636   GenericTrack::Dump(stream);
 637   fprintf(stream, "  %22s = %s\n",  "EditRate", EditRate.EncodeString(identbuf, IdentBufferLen));
 638   fprintf(stream, "  %22s = %s\n",  "Origin", i64sz(Origin, identbuf));
 639 }
 640
 641 //
 642 ASDCP::Result_t
 643 ASDCP::MXF::Track::InitFromBuffer(const byte_t* p, ui32_t l)
 644 {
 645   m_Typeinfo = &Dict::Type(MDD_Track);
 646   return InterchangeObject::InitFromBuffer(p, l);
 647 }
 648
 649 //
 650 ASDCP::Result_t
 651 ASDCP::MXF::Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 652 {
 653   m_Typeinfo = &Dict::Type(MDD_Track);
 654   return InterchangeObject::WriteToBuffer(Buffer);
 655 }
 656
 657 //------------------------------------------------------------------------------------------
 658 // StructuralComponent
 659
 660 //
 661 ASDCP::Result_t
 662 ASDCP::MXF::StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
 663 {
 664   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 665   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 666   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
 667   return result;
 668 }
 669
 670 //
 671 ASDCP::Result_t
 672 ASDCP::MXF::StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
 673 {
 674   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 675   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(StructuralComponent, DataDefinition));
 676   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(StructuralComponent, Duration));
 677   return result;
 678 }
 679
 680 //
 681 void
 682 ASDCP::MXF::StructuralComponent::Dump(FILE* stream)
 683 {
 684   char identbuf[IdentBufferLen];
 685   *identbuf = 0;
 686
 687   if ( stream == 0 )
 688     stream = stderr;
 689
 690   InterchangeObject::Dump(stream);
 691   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
 692   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
 693 }
 694
 695
 696 //------------------------------------------------------------------------------------------
 697 // Sequence
 698
 699 //
 700 ASDCP::Result_t
 701 ASDCP::MXF::Sequence::InitFromTLVSet(TLVReader& TLVSet)
 702 {
 703   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 704   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
 705   return result;
 706 }
 707
 708 //
 709 ASDCP::Result_t
 710 ASDCP::MXF::Sequence::WriteToTLVSet(TLVWriter& TLVSet)
 711 {
 712   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
 713   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Sequence, StructuralComponents));
 714   return result;
 715 }
 716
 717 //
 718 void
 719 ASDCP::MXF::Sequence::Dump(FILE* stream)
 720 {
 721   char identbuf[IdentBufferLen];
 722   *identbuf = 0;
 723
 724   if ( stream == 0 )
 725     stream = stderr;
 726
 727   StructuralComponent::Dump(stream);
 728   fprintf(stream, "  %22s:\n",  "StructuralComponents");
 729   StructuralComponents.Dump(stream);
 730 }
 731
 732 //
 733 ASDCP::Result_t
 734 ASDCP::MXF::Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 735 {
 736   m_Typeinfo = &Dict::Type(MDD_Sequence);
 737   return InterchangeObject::InitFromBuffer(p, l);
 738 }
 739
 740 //
 741 ASDCP::Result_t
 742 ASDCP::MXF::Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 743 {
 744   m_Typeinfo = &Dict::Type(MDD_Sequence);
 745   return InterchangeObject::WriteToBuffer(Buffer);
 746 }
 747
 748 //------------------------------------------------------------------------------------------
 749 // SourceClip
 750
 751 //
 752 ASDCP::Result_t
 753 ASDCP::MXF::SourceClip::InitFromTLVSet(TLVReader& TLVSet)
 754 {
 755   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 756   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
 757   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
 758   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
 759   return result;
 760 }
 761
 762 //
 763 ASDCP::Result_t
 764 ASDCP::MXF::SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
 765 {
 766   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
 767   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(SourceClip, StartPosition));
 768   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourceClip, SourcePackageID));
 769   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(SourceClip, SourceTrackID));
 770   return result;
 771 }
 772
 773 //
 774 void
 775 ASDCP::MXF::SourceClip::Dump(FILE* stream)
 776 {
 777   char identbuf[IdentBufferLen];
 778   *identbuf = 0;
 779
 780   if ( stream == 0 )
 781     stream = stderr;
 782
 783   StructuralComponent::Dump(stream);
 784   fprintf(stream, "  %22s = %s\n",  "StartPosition", i64sz(StartPosition, identbuf));
 785   fprintf(stream, "  %22s = %s\n",  "SourcePackageID", SourcePackageID.EncodeString(identbuf, IdentBufferLen));
 786   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
 787 }
 788
 789 //
 790 ASDCP::Result_t
 791 ASDCP::MXF::SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 792 {
 793   m_Typeinfo = &Dict::Type(MDD_SourceClip);
 794   return InterchangeObject::InitFromBuffer(p, l);
 795 }
 796
 797 //
 798 ASDCP::Result_t
 799 ASDCP::MXF::SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 800 {
 801   m_Typeinfo = &Dict::Type(MDD_SourceClip);
 802   return InterchangeObject::WriteToBuffer(Buffer);
 803 }
 804
 805 //------------------------------------------------------------------------------------------
 806 // TimecodeComponent
 807
 808 //
 809 ASDCP::Result_t
 810 ASDCP::MXF::TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
 811 {
 812   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 813   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
 814   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
 815   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
 816   return result;
 817 }
 818
 819 //
 820 ASDCP::Result_t
 821 ASDCP::MXF::TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
 822 {
 823   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
 824   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(TimecodeComponent, RoundedTimecodeBase));
 825   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TimecodeComponent, StartTimecode));
 826   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(TimecodeComponent, DropFrame));
 827   return result;
 828 }
 829
 830 //
 831 void
 832 ASDCP::MXF::TimecodeComponent::Dump(FILE* stream)
 833 {
 834   char identbuf[IdentBufferLen];
 835   *identbuf = 0;
 836
 837   if ( stream == 0 )
 838     stream = stderr;
 839
 840   StructuralComponent::Dump(stream);
 841   fprintf(stream, "  %22s = %d\n",  "RoundedTimecodeBase", RoundedTimecodeBase);
 842   fprintf(stream, "  %22s = %s\n",  "StartTimecode", i64sz(StartTimecode, identbuf));
 843   fprintf(stream, "  %22s = %d\n",  "DropFrame", DropFrame);
 844 }
 845
 846 //
 847 ASDCP::Result_t
 848 ASDCP::MXF::TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 849 {
 850   m_Typeinfo = &Dict::Type(MDD_TimecodeComponent);
 851   return InterchangeObject::InitFromBuffer(p, l);
 852 }
 853
 854 //
 855 ASDCP::Result_t
 856 ASDCP::MXF::TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 857 {
 858   m_Typeinfo = &Dict::Type(MDD_TimecodeComponent);
 859   return InterchangeObject::WriteToBuffer(Buffer);
 860 }
 861
 862 //------------------------------------------------------------------------------------------
 863 // GenericDescriptor
 864
 865 //
 866 ASDCP::Result_t
 867 ASDCP::MXF::GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 868 {
 869   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 870   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
 871   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
 872   return result;
 873 }
 874
 875 //
 876 ASDCP::Result_t
 877 ASDCP::MXF::GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 878 {
 879   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 880   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, Locators));
 881   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, SubDescriptors));
 882   return result;
 883 }
 884
 885 //
 886 void
 887 ASDCP::MXF::GenericDescriptor::Dump(FILE* stream)
 888 {
 889   char identbuf[IdentBufferLen];
 890   *identbuf = 0;
 891
 892   if ( stream == 0 )
 893     stream = stderr;
 894
 895   InterchangeObject::Dump(stream);
 896   fprintf(stream, "  %22s:\n",  "Locators");
 897   Locators.Dump(stream);
 898   fprintf(stream, "  %22s:\n",  "SubDescriptors");
 899   SubDescriptors.Dump(stream);
 900 }
 901
 902
 903 //------------------------------------------------------------------------------------------
 904 // FileDescriptor
 905
 906 //
 907 ASDCP::Result_t
 908 ASDCP::MXF::FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 909 {
 910   Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
 911   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
 912   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
 913   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
 914   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
 915   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, Codec));
 916   return result;
 917 }
 918
 919 //
 920 ASDCP::Result_t
 921 ASDCP::MXF::FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 922 {
 923   Result_t result = GenericDescriptor::WriteToTLVSet(TLVSet);
 924   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(FileDescriptor, LinkedTrackID));
 925   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, SampleRate));
 926   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(FileDescriptor, ContainerDuration));
 927   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, EssenceContainer));
 928   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, Codec));
 929   return result;
 930 }
 931
 932 //
 933 void
 934 ASDCP::MXF::FileDescriptor::Dump(FILE* stream)
 935 {
 936   char identbuf[IdentBufferLen];
 937   *identbuf = 0;
 938
 939   if ( stream == 0 )
 940     stream = stderr;
 941
 942   GenericDescriptor::Dump(stream);
 943   fprintf(stream, "  %22s = %d\n",  "LinkedTrackID", LinkedTrackID);
 944   fprintf(stream, "  %22s = %s\n",  "SampleRate", SampleRate.EncodeString(identbuf, IdentBufferLen));
 945   fprintf(stream, "  %22s = %s\n",  "ContainerDuration", i64sz(ContainerDuration, identbuf));
 946   fprintf(stream, "  %22s = %s\n",  "EssenceContainer", EssenceContainer.EncodeString(identbuf, IdentBufferLen));
 947   fprintf(stream, "  %22s = %s\n",  "Codec", Codec.EncodeString(identbuf, IdentBufferLen));
 948 }
 949
 950 //
 951 ASDCP::Result_t
 952 ASDCP::MXF::FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 953 {
 954   m_Typeinfo = &Dict::Type(MDD_FileDescriptor);
 955   return InterchangeObject::InitFromBuffer(p, l);
 956 }
 957
 958 //
 959 ASDCP::Result_t
 960 ASDCP::MXF::FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 961 {
 962   m_Typeinfo = &Dict::Type(MDD_FileDescriptor);
 963   return InterchangeObject::WriteToBuffer(Buffer);
 964 }
 965
 966 //------------------------------------------------------------------------------------------
 967 // GenericSoundEssenceDescriptor
 968
 969 //
 970 ASDCP::Result_t
 971 ASDCP::MXF::GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 972 {
 973   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
 974   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
 975   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
 976   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
 977   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
 978   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
 979   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, DialNorm));
 980   return result;
 981 }
 982
 983 //
 984 ASDCP::Result_t
 985 ASDCP::MXF::GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 986 {
 987   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
 988   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
 989   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
 990   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
 991   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
 992   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
 993   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, DialNorm));
 994   return result;
 995 }
 996
 997 //
 998 void
 999 ASDCP::MXF::GenericSoundEssenceDescriptor::Dump(FILE* stream)
1000 {
1001   char identbuf[IdentBufferLen];
1002   *identbuf = 0;
1003
1004   if ( stream == 0 )
1005     stream = stderr;
1006
1007   FileDescriptor::Dump(stream);
1008   fprintf(stream, "  %22s = %s\n",  "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1009   fprintf(stream, "  %22s = %d\n",  "Locked", Locked);
1010   fprintf(stream, "  %22s = %d\n",  "AudioRefLevel", AudioRefLevel);
1011   fprintf(stream, "  %22s = %d\n",  "ChannelCount", ChannelCount);
1012   fprintf(stream, "  %22s = %d\n",  "QuantizationBits", QuantizationBits);
1013   fprintf(stream, "  %22s = %d\n",  "DialNorm", DialNorm);
1014 }
1015
1016 //
1017 ASDCP::Result_t
1018 ASDCP::MXF::GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1019 {
1020   m_Typeinfo = &Dict::Type(MDD_GenericSoundEssenceDescriptor);
1021   return InterchangeObject::InitFromBuffer(p, l);
1022 }
1023
1024 //
1025 ASDCP::Result_t
1026 ASDCP::MXF::GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1027 {
1028   m_Typeinfo = &Dict::Type(MDD_GenericSoundEssenceDescriptor);
1029   return InterchangeObject::WriteToBuffer(Buffer);
1030 }
1031
1032 //------------------------------------------------------------------------------------------
1033 // WaveAudioDescriptor
1034
1035 //
1036 ASDCP::Result_t
1037 ASDCP::MXF::WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1038 {
1039   Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1040   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1041   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(WaveAudioDescriptor, SequenceOffset));
1042   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1043   return result;
1044 }
1045
1046 //
1047 ASDCP::Result_t
1048 ASDCP::MXF::WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1049 {
1050   Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1051   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1052   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(WaveAudioDescriptor, SequenceOffset));
1053   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1054   return result;
1055 }
1056
1057 //
1058 void
1059 ASDCP::MXF::WaveAudioDescriptor::Dump(FILE* stream)
1060 {
1061   char identbuf[IdentBufferLen];
1062   *identbuf = 0;
1063
1064   if ( stream == 0 )
1065     stream = stderr;
1066
1067   GenericSoundEssenceDescriptor::Dump(stream);
1068   fprintf(stream, "  %22s = %d\n",  "BlockAlign", BlockAlign);
1069   fprintf(stream, "  %22s = %d\n",  "SequenceOffset", SequenceOffset);
1070   fprintf(stream, "  %22s = %d\n",  "AvgBps", AvgBps);
1071 }
1072
1073 //
1074 ASDCP::Result_t
1075 ASDCP::MXF::WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1076 {
1077   m_Typeinfo = &Dict::Type(MDD_WaveAudioDescriptor);
1078   return InterchangeObject::InitFromBuffer(p, l);
1079 }
1080
1081 //
1082 ASDCP::Result_t
1083 ASDCP::MXF::WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1084 {
1085   m_Typeinfo = &Dict::Type(MDD_WaveAudioDescriptor);
1086   return InterchangeObject::WriteToBuffer(Buffer);
1087 }
1088
1089 //------------------------------------------------------------------------------------------
1090 // GenericPictureEssenceDescriptor
1091
1092 //
1093 ASDCP::Result_t
1094 ASDCP::MXF::GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1095 {
1096   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1097   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1098   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1099   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1100   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1101   return result;
1102 }
1103
1104 //
1105 ASDCP::Result_t
1106 ASDCP::MXF::GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1107 {
1108   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1109   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1110   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1111   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1112   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1113   return result;
1114 }
1115
1116 //
1117 void
1118 ASDCP::MXF::GenericPictureEssenceDescriptor::Dump(FILE* stream)
1119 {
1120   char identbuf[IdentBufferLen];
1121   *identbuf = 0;
1122
1123   if ( stream == 0 )
1124     stream = stderr;
1125
1126   FileDescriptor::Dump(stream);
1127   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1128   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1129   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1130   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1131 }
1132
1133 //
1134 ASDCP::Result_t
1135 ASDCP::MXF::GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1136 {
1137   m_Typeinfo = &Dict::Type(MDD_GenericPictureEssenceDescriptor);
1138   return InterchangeObject::InitFromBuffer(p, l);
1139 }
1140
1141 //
1142 ASDCP::Result_t
1143 ASDCP::MXF::GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1144 {
1145   m_Typeinfo = &Dict::Type(MDD_GenericPictureEssenceDescriptor);
1146   return InterchangeObject::WriteToBuffer(Buffer);
1147 }
1148
1149 //------------------------------------------------------------------------------------------
1150 // RGBAEssenceDescriptor
1151
1152 //
1153 ASDCP::Result_t
1154 ASDCP::MXF::RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1155 {
1156   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1157   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1158   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1159   return result;
1160 }
1161
1162 //
1163 ASDCP::Result_t
1164 ASDCP::MXF::RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1165 {
1166   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1167   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1168   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1169   return result;
1170 }
1171
1172 //
1173 void
1174 ASDCP::MXF::RGBAEssenceDescriptor::Dump(FILE* stream)
1175 {
1176   char identbuf[IdentBufferLen];
1177   *identbuf = 0;
1178
1179   if ( stream == 0 )
1180     stream = stderr;
1181
1182   GenericPictureEssenceDescriptor::Dump(stream);
1183   fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef);
1184   fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef);
1185 }
1186
1187 //
1188 ASDCP::Result_t
1189 ASDCP::MXF::RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1190 {
1191   m_Typeinfo = &Dict::Type(MDD_RGBAEssenceDescriptor);
1192   return InterchangeObject::InitFromBuffer(p, l);
1193 }
1194
1195 //
1196 ASDCP::Result_t
1197 ASDCP::MXF::RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1198 {
1199   m_Typeinfo = &Dict::Type(MDD_RGBAEssenceDescriptor);
1200   return InterchangeObject::WriteToBuffer(Buffer);
1201 }
1202
1203 //------------------------------------------------------------------------------------------
1204 // JPEG2000PictureSubDescriptor
1205
1206 //
1207 ASDCP::Result_t
1208 ASDCP::MXF::JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1209 {
1210   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1211   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1212   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1213   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1214   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1215   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1216   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1217   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1218   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1219   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1220   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
1221   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1222   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1223   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1224   return result;
1225 }
1226
1227 //
1228 ASDCP::Result_t
1229 ASDCP::MXF::JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1230 {
1231   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1232   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1233   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1234   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1235   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1236   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1237   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1238   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1239   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1240   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1241   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
1242   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1243   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1244   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1245   return result;
1246 }
1247
1248 //
1249 void
1250 ASDCP::MXF::JPEG2000PictureSubDescriptor::Dump(FILE* stream)
1251 {
1252   char identbuf[IdentBufferLen];
1253   *identbuf = 0;
1254
1255   if ( stream == 0 )
1256     stream = stderr;
1257
1258   InterchangeObject::Dump(stream);
1259   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
1260   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
1261   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
1262   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
1263   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
1264   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
1265   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
1266   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
1267   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
1268   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
1269   fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.EncodeString(identbuf, IdentBufferLen));
1270   fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.EncodeString(identbuf, IdentBufferLen));
1271   fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.EncodeString(identbuf, IdentBufferLen));
1272 }
1273
1274 //
1275 ASDCP::Result_t
1276 ASDCP::MXF::JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1277 {
1278   m_Typeinfo = &Dict::Type(MDD_JPEG2000PictureSubDescriptor);
1279   return InterchangeObject::InitFromBuffer(p, l);
1280 }
1281
1282 //
1283 ASDCP::Result_t
1284 ASDCP::MXF::JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1285 {
1286   m_Typeinfo = &Dict::Type(MDD_JPEG2000PictureSubDescriptor);
1287   return InterchangeObject::WriteToBuffer(Buffer);
1288 }
1289
1290 //------------------------------------------------------------------------------------------
1291 // CDCIEssenceDescriptor
1292
1293 //
1294 ASDCP::Result_t
1295 ASDCP::MXF::CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1296 {
1297   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1298   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1299   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1300   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1301   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
1302   return result;
1303 }
1304
1305 //
1306 ASDCP::Result_t
1307 ASDCP::MXF::CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1308 {
1309   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1310   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1311   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1312   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1313   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ColorSiting));
1314   return result;
1315 }
1316
1317 //
1318 void
1319 ASDCP::MXF::CDCIEssenceDescriptor::Dump(FILE* stream)
1320 {
1321   char identbuf[IdentBufferLen];
1322   *identbuf = 0;
1323
1324   if ( stream == 0 )
1325     stream = stderr;
1326
1327   GenericPictureEssenceDescriptor::Dump(stream);
1328   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
1329   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
1330   fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling);
1331   fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting);
1332 }
1333
1334 //
1335 ASDCP::Result_t
1336 ASDCP::MXF::CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1337 {
1338   m_Typeinfo = &Dict::Type(MDD_CDCIEssenceDescriptor);
1339   return InterchangeObject::InitFromBuffer(p, l);
1340 }
1341
1342 //
1343 ASDCP::Result_t
1344 ASDCP::MXF::CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1345 {
1346   m_Typeinfo = &Dict::Type(MDD_CDCIEssenceDescriptor);
1347   return InterchangeObject::WriteToBuffer(Buffer);
1348 }
1349
1350 //------------------------------------------------------------------------------------------
1351 // MPEG2VideoDescriptor
1352
1353 //
1354 ASDCP::Result_t
1355 ASDCP::MXF::MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1356 {
1357   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
1358   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, CodedContentType));
1359   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, LowDelay));
1360   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor, BitRate));
1361   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1362   return result;
1363 }
1364
1365 //
1366 ASDCP::Result_t
1367 ASDCP::MXF::MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1368 {
1369   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
1370   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, CodedContentType));
1371   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, LowDelay));
1372   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, BitRate));
1373   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1374   return result;
1375 }
1376
1377 //
1378 void
1379 ASDCP::MXF::MPEG2VideoDescriptor::Dump(FILE* stream)
1380 {
1381   char identbuf[IdentBufferLen];
1382   *identbuf = 0;
1383
1384   if ( stream == 0 )
1385     stream = stderr;
1386
1387   CDCIEssenceDescriptor::Dump(stream);
1388   fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType);
1389   fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay);
1390   fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate);
1391   fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel);
1392 }
1393
1394 //
1395 ASDCP::Result_t
1396 ASDCP::MXF::MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1397 {
1398   m_Typeinfo = &Dict::Type(MDD_MPEG2VideoDescriptor);
1399   return InterchangeObject::InitFromBuffer(p, l);
1400 }
1401
1402 //
1403 ASDCP::Result_t
1404 ASDCP::MXF::MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1405 {
1406   m_Typeinfo = &Dict::Type(MDD_MPEG2VideoDescriptor);
1407   return InterchangeObject::WriteToBuffer(Buffer);
1408 }
1409
1410 //------------------------------------------------------------------------------------------
1411 // DMSegment
1412
1413 //
1414 ASDCP::Result_t
1415 ASDCP::MXF::DMSegment::InitFromTLVSet(TLVReader& TLVSet)
1416 {
1417   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1418   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
1419   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
1420   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
1421   return result;
1422 }
1423
1424 //
1425 ASDCP::Result_t
1426 ASDCP::MXF::DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
1427 {
1428   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1429   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
1430   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
1431   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
1432   return result;
1433 }
1434
1435 //
1436 void
1437 ASDCP::MXF::DMSegment::Dump(FILE* stream)
1438 {
1439   char identbuf[IdentBufferLen];
1440   *identbuf = 0;
1441
1442   if ( stream == 0 )
1443     stream = stderr;
1444
1445   InterchangeObject::Dump(stream);
1446   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
1447   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
1448   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
1449 }
1450
1451 //
1452 ASDCP::Result_t
1453 ASDCP::MXF::DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
1454 {
1455   m_Typeinfo = &Dict::Type(MDD_DMSegment);
1456   return InterchangeObject::InitFromBuffer(p, l);
1457 }
1458
1459 //
1460 ASDCP::Result_t
1461 ASDCP::MXF::DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1462 {
1463   m_Typeinfo = &Dict::Type(MDD_DMSegment);
1464   return InterchangeObject::WriteToBuffer(Buffer);
1465 }
1466
1467 //------------------------------------------------------------------------------------------
1468 // CryptographicFramework
1469
1470 //
1471 ASDCP::Result_t
1472 ASDCP::MXF::CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
1473 {
1474   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1475   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
1476   return result;
1477 }
1478
1479 //
1480 ASDCP::Result_t
1481 ASDCP::MXF::CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
1482 {
1483   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1484   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
1485   return result;
1486 }
1487
1488 //
1489 void
1490 ASDCP::MXF::CryptographicFramework::Dump(FILE* stream)
1491 {
1492   char identbuf[IdentBufferLen];
1493   *identbuf = 0;
1494
1495   if ( stream == 0 )
1496     stream = stderr;
1497
1498   InterchangeObject::Dump(stream);
1499   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
1500 }
1501
1502 //
1503 ASDCP::Result_t
1504 ASDCP::MXF::CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
1505 {
1506   m_Typeinfo = &Dict::Type(MDD_CryptographicFramework);
1507   return InterchangeObject::InitFromBuffer(p, l);
1508 }
1509
1510 //
1511 ASDCP::Result_t
1512 ASDCP::MXF::CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1513 {
1514   m_Typeinfo = &Dict::Type(MDD_CryptographicFramework);
1515   return InterchangeObject::WriteToBuffer(Buffer);
1516 }
1517
1518 //------------------------------------------------------------------------------------------
1519 // CryptographicContext
1520
1521 //
1522 ASDCP::Result_t
1523 ASDCP::MXF::CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
1524 {
1525   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1526   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
1527   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
1528   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
1529   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
1530   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
1531   return result;
1532 }
1533
1534 //
1535 ASDCP::Result_t
1536 ASDCP::MXF::CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
1537 {
1538   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1539   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
1540   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
1541   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
1542   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
1543   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
1544   return result;
1545 }
1546
1547 //
1548 void
1549 ASDCP::MXF::CryptographicContext::Dump(FILE* stream)
1550 {
1551   char identbuf[IdentBufferLen];
1552   *identbuf = 0;
1553
1554   if ( stream == 0 )
1555     stream = stderr;
1556
1557   InterchangeObject::Dump(stream);
1558   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
1559   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
1560   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
1561   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
1562   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
1563 }
1564
1565 //
1566 ASDCP::Result_t
1567 ASDCP::MXF::CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
1568 {
1569   m_Typeinfo = &Dict::Type(MDD_CryptographicContext);
1570   return InterchangeObject::InitFromBuffer(p, l);
1571 }
1572
1573 //
1574 ASDCP::Result_t
1575 ASDCP::MXF::CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1576 {
1577   m_Typeinfo = &Dict::Type(MDD_CryptographicContext);
1578   return InterchangeObject::WriteToBuffer(Buffer);
1579 }
1580
1581 //
1582 // end Metadata.cpp
1583 //