src/Metadata.cpp

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