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