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