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