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   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(RGBAEssenceDescriptor, PixelLayout));
1161   return result;
1162 }
1163
1164 //
1165 ASDCP::Result_t
1166 ASDCP::MXF::RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1167 {
1168   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1169   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1170   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1171   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, PixelLayout));
1172   return result;
1173 }
1174
1175 //
1176 void
1177 ASDCP::MXF::RGBAEssenceDescriptor::Dump(FILE* stream)
1178 {
1179   char identbuf[IdentBufferLen];
1180   *identbuf = 0;
1181
1182   if ( stream == 0 )
1183     stream = stderr;
1184
1185   GenericPictureEssenceDescriptor::Dump(stream);
1186   fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef);
1187   fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef);
1188   fprintf(stream, "  %22s = %s\n",  "PixelLayout", PixelLayout.ToString(identbuf));
1189 }
1190
1191 //
1192 ASDCP::Result_t
1193 ASDCP::MXF::RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1194 {
1195   m_Typeinfo = &Dict::Type(MDD_RGBAEssenceDescriptor);
1196   return InterchangeObject::InitFromBuffer(p, l);
1197 }
1198
1199 //
1200 ASDCP::Result_t
1201 ASDCP::MXF::RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1202 {
1203   m_Typeinfo = &Dict::Type(MDD_RGBAEssenceDescriptor);
1204   return InterchangeObject::WriteToBuffer(Buffer);
1205 }
1206
1207 //------------------------------------------------------------------------------------------
1208 // JPEG2000PictureSubDescriptor
1209
1210 //
1211 ASDCP::Result_t
1212 ASDCP::MXF::JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1213 {
1214   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1215   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1216   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1217   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1218   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1219   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1220   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1221   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1222   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1223   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1224   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
1225   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1226   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1227   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1228   return result;
1229 }
1230
1231 //
1232 ASDCP::Result_t
1233 ASDCP::MXF::JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1234 {
1235   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1236   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1237   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1238   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1239   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1240   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1241   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1242   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1243   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1244   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1245   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
1246   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1247   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1248   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1249   return result;
1250 }
1251
1252 //
1253 void
1254 ASDCP::MXF::JPEG2000PictureSubDescriptor::Dump(FILE* stream)
1255 {
1256   char identbuf[IdentBufferLen];
1257   *identbuf = 0;
1258
1259   if ( stream == 0 )
1260     stream = stderr;
1261
1262   InterchangeObject::Dump(stream);
1263   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
1264   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
1265   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
1266   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
1267   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
1268   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
1269   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
1270   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
1271   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
1272   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
1273   fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.ToString(identbuf));
1274   fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.ToString(identbuf));
1275   fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.ToString(identbuf));
1276 }
1277
1278 //
1279 ASDCP::Result_t
1280 ASDCP::MXF::JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1281 {
1282   m_Typeinfo = &Dict::Type(MDD_JPEG2000PictureSubDescriptor);
1283   return InterchangeObject::InitFromBuffer(p, l);
1284 }
1285
1286 //
1287 ASDCP::Result_t
1288 ASDCP::MXF::JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1289 {
1290   m_Typeinfo = &Dict::Type(MDD_JPEG2000PictureSubDescriptor);
1291   return InterchangeObject::WriteToBuffer(Buffer);
1292 }
1293
1294 //------------------------------------------------------------------------------------------
1295 // CDCIEssenceDescriptor
1296
1297 //
1298 ASDCP::Result_t
1299 ASDCP::MXF::CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1300 {
1301   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1302   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1303   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1304   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1305   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
1306   return result;
1307 }
1308
1309 //
1310 ASDCP::Result_t
1311 ASDCP::MXF::CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1312 {
1313   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1314   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1315   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1316   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1317   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ColorSiting));
1318   return result;
1319 }
1320
1321 //
1322 void
1323 ASDCP::MXF::CDCIEssenceDescriptor::Dump(FILE* stream)
1324 {
1325   char identbuf[IdentBufferLen];
1326   *identbuf = 0;
1327
1328   if ( stream == 0 )
1329     stream = stderr;
1330
1331   GenericPictureEssenceDescriptor::Dump(stream);
1332   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
1333   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
1334   fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling);
1335   fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting);
1336 }
1337
1338 //
1339 ASDCP::Result_t
1340 ASDCP::MXF::CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1341 {
1342   m_Typeinfo = &Dict::Type(MDD_CDCIEssenceDescriptor);
1343   return InterchangeObject::InitFromBuffer(p, l);
1344 }
1345
1346 //
1347 ASDCP::Result_t
1348 ASDCP::MXF::CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1349 {
1350   m_Typeinfo = &Dict::Type(MDD_CDCIEssenceDescriptor);
1351   return InterchangeObject::WriteToBuffer(Buffer);
1352 }
1353
1354 //------------------------------------------------------------------------------------------
1355 // MPEG2VideoDescriptor
1356
1357 //
1358 ASDCP::Result_t
1359 ASDCP::MXF::MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1360 {
1361   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
1362   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, CodedContentType));
1363   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, LowDelay));
1364   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor, BitRate));
1365   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1366   return result;
1367 }
1368
1369 //
1370 ASDCP::Result_t
1371 ASDCP::MXF::MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1372 {
1373   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
1374   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, CodedContentType));
1375   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, LowDelay));
1376   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, BitRate));
1377   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1378   return result;
1379 }
1380
1381 //
1382 void
1383 ASDCP::MXF::MPEG2VideoDescriptor::Dump(FILE* stream)
1384 {
1385   char identbuf[IdentBufferLen];
1386   *identbuf = 0;
1387
1388   if ( stream == 0 )
1389     stream = stderr;
1390
1391   CDCIEssenceDescriptor::Dump(stream);
1392   fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType);
1393   fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay);
1394   fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate);
1395   fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel);
1396 }
1397
1398 //
1399 ASDCP::Result_t
1400 ASDCP::MXF::MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1401 {
1402   m_Typeinfo = &Dict::Type(MDD_MPEG2VideoDescriptor);
1403   return InterchangeObject::InitFromBuffer(p, l);
1404 }
1405
1406 //
1407 ASDCP::Result_t
1408 ASDCP::MXF::MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1409 {
1410   m_Typeinfo = &Dict::Type(MDD_MPEG2VideoDescriptor);
1411   return InterchangeObject::WriteToBuffer(Buffer);
1412 }
1413
1414 //------------------------------------------------------------------------------------------
1415 // DMSegment
1416
1417 //
1418 ASDCP::Result_t
1419 ASDCP::MXF::DMSegment::InitFromTLVSet(TLVReader& TLVSet)
1420 {
1421   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1422   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
1423   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
1424   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
1425   return result;
1426 }
1427
1428 //
1429 ASDCP::Result_t
1430 ASDCP::MXF::DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
1431 {
1432   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1433   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
1434   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
1435   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
1436   return result;
1437 }
1438
1439 //
1440 void
1441 ASDCP::MXF::DMSegment::Dump(FILE* stream)
1442 {
1443   char identbuf[IdentBufferLen];
1444   *identbuf = 0;
1445
1446   if ( stream == 0 )
1447     stream = stderr;
1448
1449   InterchangeObject::Dump(stream);
1450   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
1451   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.ToString(identbuf));
1452   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.ToString(identbuf));
1453 }
1454
1455 //
1456 ASDCP::Result_t
1457 ASDCP::MXF::DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
1458 {
1459   m_Typeinfo = &Dict::Type(MDD_DMSegment);
1460   return InterchangeObject::InitFromBuffer(p, l);
1461 }
1462
1463 //
1464 ASDCP::Result_t
1465 ASDCP::MXF::DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1466 {
1467   m_Typeinfo = &Dict::Type(MDD_DMSegment);
1468   return InterchangeObject::WriteToBuffer(Buffer);
1469 }
1470
1471 //------------------------------------------------------------------------------------------
1472 // CryptographicFramework
1473
1474 //
1475 ASDCP::Result_t
1476 ASDCP::MXF::CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
1477 {
1478   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1479   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
1480   return result;
1481 }
1482
1483 //
1484 ASDCP::Result_t
1485 ASDCP::MXF::CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
1486 {
1487   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1488   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
1489   return result;
1490 }
1491
1492 //
1493 void
1494 ASDCP::MXF::CryptographicFramework::Dump(FILE* stream)
1495 {
1496   char identbuf[IdentBufferLen];
1497   *identbuf = 0;
1498
1499   if ( stream == 0 )
1500     stream = stderr;
1501
1502   InterchangeObject::Dump(stream);
1503   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.ToString(identbuf));
1504 }
1505
1506 //
1507 ASDCP::Result_t
1508 ASDCP::MXF::CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
1509 {
1510   m_Typeinfo = &Dict::Type(MDD_CryptographicFramework);
1511   return InterchangeObject::InitFromBuffer(p, l);
1512 }
1513
1514 //
1515 ASDCP::Result_t
1516 ASDCP::MXF::CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1517 {
1518   m_Typeinfo = &Dict::Type(MDD_CryptographicFramework);
1519   return InterchangeObject::WriteToBuffer(Buffer);
1520 }
1521
1522 //------------------------------------------------------------------------------------------
1523 // CryptographicContext
1524
1525 //
1526 ASDCP::Result_t
1527 ASDCP::MXF::CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
1528 {
1529   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1530   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
1531   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
1532   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
1533   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
1534   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
1535   return result;
1536 }
1537
1538 //
1539 ASDCP::Result_t
1540 ASDCP::MXF::CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
1541 {
1542   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1543   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
1544   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
1545   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
1546   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
1547   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
1548   return result;
1549 }
1550
1551 //
1552 void
1553 ASDCP::MXF::CryptographicContext::Dump(FILE* stream)
1554 {
1555   char identbuf[IdentBufferLen];
1556   *identbuf = 0;
1557
1558   if ( stream == 0 )
1559     stream = stderr;
1560
1561   InterchangeObject::Dump(stream);
1562   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.ToString(identbuf));
1563   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.ToString(identbuf));
1564   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.ToString(identbuf));
1565   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.ToString(identbuf));
1566   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.ToString(identbuf));
1567 }
1568
1569 //
1570 ASDCP::Result_t
1571 ASDCP::MXF::CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
1572 {
1573   m_Typeinfo = &Dict::Type(MDD_CryptographicContext);
1574   return InterchangeObject::InitFromBuffer(p, l);
1575 }
1576
1577 //
1578 ASDCP::Result_t
1579 ASDCP::MXF::CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1580 {
1581   m_Typeinfo = &Dict::Type(MDD_CryptographicContext);
1582   return InterchangeObject::WriteToBuffer(Buffer);
1583 }
1584
1585 //
1586 // end MXF.cpp
1587 //