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