src/Metadata.cpp

   1 /*
   2 Copyright (c) 2005-2007, 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   return result;
 981 }
 982
 983 //
 984 ASDCP::Result_t
 985 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 986 {
 987   Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
 988   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
 989   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(WaveAudioDescriptor, SequenceOffset));
 990   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
 991   return result;
 992 }
 993
 994 //
 995 void
 996 WaveAudioDescriptor::Dump(FILE* stream)
 997 {
 998   char identbuf[IdentBufferLen];
 999   *identbuf = 0;
1000
1001   if ( stream == 0 )
1002     stream = stderr;
1003
1004   GenericSoundEssenceDescriptor::Dump(stream);
1005   fprintf(stream, "  %22s = %d\n",  "BlockAlign", BlockAlign);
1006   fprintf(stream, "  %22s = %d\n",  "SequenceOffset", SequenceOffset);
1007   fprintf(stream, "  %22s = %d\n",  "AvgBps", AvgBps);
1008 }
1009
1010 //
1011 ASDCP::Result_t
1012 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1013 {
1014   m_Typeinfo = &Dict::Type(MDD_WaveAudioDescriptor);
1015   return InterchangeObject::InitFromBuffer(p, l);
1016 }
1017
1018 //
1019 ASDCP::Result_t
1020 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1021 {
1022   m_Typeinfo = &Dict::Type(MDD_WaveAudioDescriptor);
1023   return InterchangeObject::WriteToBuffer(Buffer);
1024 }
1025
1026 //------------------------------------------------------------------------------------------
1027 // GenericPictureEssenceDescriptor
1028
1029 //
1030 ASDCP::Result_t
1031 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1032 {
1033   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1034   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1035   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1036   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1037   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1038   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1039   return result;
1040 }
1041
1042 //
1043 ASDCP::Result_t
1044 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1045 {
1046   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1047   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1048   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1049   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1050   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1051   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1052   return result;
1053 }
1054
1055 //
1056 void
1057 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1058 {
1059   char identbuf[IdentBufferLen];
1060   *identbuf = 0;
1061
1062   if ( stream == 0 )
1063     stream = stderr;
1064
1065   FileDescriptor::Dump(stream);
1066   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1067   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1068   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1069   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1070   fprintf(stream, "  %22s = %s\n",  "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1071 }
1072
1073 //
1074 ASDCP::Result_t
1075 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1076 {
1077   m_Typeinfo = &Dict::Type(MDD_GenericPictureEssenceDescriptor);
1078   return InterchangeObject::InitFromBuffer(p, l);
1079 }
1080
1081 //
1082 ASDCP::Result_t
1083 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1084 {
1085   m_Typeinfo = &Dict::Type(MDD_GenericPictureEssenceDescriptor);
1086   return InterchangeObject::WriteToBuffer(Buffer);
1087 }
1088
1089 //------------------------------------------------------------------------------------------
1090 // RGBAEssenceDescriptor
1091
1092 //
1093 ASDCP::Result_t
1094 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1095 {
1096   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1097   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1098   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1099   return result;
1100 }
1101
1102 //
1103 ASDCP::Result_t
1104 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1105 {
1106   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1107   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1108   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1109   return result;
1110 }
1111
1112 //
1113 void
1114 RGBAEssenceDescriptor::Dump(FILE* stream)
1115 {
1116   char identbuf[IdentBufferLen];
1117   *identbuf = 0;
1118
1119   if ( stream == 0 )
1120     stream = stderr;
1121
1122   GenericPictureEssenceDescriptor::Dump(stream);
1123   fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef);
1124   fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef);
1125 }
1126
1127 //
1128 ASDCP::Result_t
1129 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1130 {
1131   m_Typeinfo = &Dict::Type(MDD_RGBAEssenceDescriptor);
1132   return InterchangeObject::InitFromBuffer(p, l);
1133 }
1134
1135 //
1136 ASDCP::Result_t
1137 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1138 {
1139   m_Typeinfo = &Dict::Type(MDD_RGBAEssenceDescriptor);
1140   return InterchangeObject::WriteToBuffer(Buffer);
1141 }
1142
1143 //------------------------------------------------------------------------------------------
1144 // JPEG2000PictureSubDescriptor
1145
1146 //
1147 ASDCP::Result_t
1148 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1149 {
1150   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1151   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1152   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1153   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1154   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1155   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1156   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1157   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1158   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1159   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1160   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
1161   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1162   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1163   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1164   return result;
1165 }
1166
1167 //
1168 ASDCP::Result_t
1169 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1170 {
1171   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1172   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1173   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1174   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1175   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1176   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1177   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1178   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1179   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1180   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1181   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
1182   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1183   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1184   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1185   return result;
1186 }
1187
1188 //
1189 void
1190 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
1191 {
1192   char identbuf[IdentBufferLen];
1193   *identbuf = 0;
1194
1195   if ( stream == 0 )
1196     stream = stderr;
1197
1198   InterchangeObject::Dump(stream);
1199   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
1200   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
1201   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
1202   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
1203   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
1204   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
1205   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
1206   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
1207   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
1208   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
1209   fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.EncodeString(identbuf, IdentBufferLen));
1210   fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.EncodeString(identbuf, IdentBufferLen));
1211   fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.EncodeString(identbuf, IdentBufferLen));
1212 }
1213
1214 //
1215 ASDCP::Result_t
1216 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1217 {
1218   m_Typeinfo = &Dict::Type(MDD_JPEG2000PictureSubDescriptor);
1219   return InterchangeObject::InitFromBuffer(p, l);
1220 }
1221
1222 //
1223 ASDCP::Result_t
1224 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1225 {
1226   m_Typeinfo = &Dict::Type(MDD_JPEG2000PictureSubDescriptor);
1227   return InterchangeObject::WriteToBuffer(Buffer);
1228 }
1229
1230 //------------------------------------------------------------------------------------------
1231 // CDCIEssenceDescriptor
1232
1233 //
1234 ASDCP::Result_t
1235 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1236 {
1237   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1238   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1239   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1240   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1241   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
1242   return result;
1243 }
1244
1245 //
1246 ASDCP::Result_t
1247 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1248 {
1249   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1250   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1251   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1252   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1253   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ColorSiting));
1254   return result;
1255 }
1256
1257 //
1258 void
1259 CDCIEssenceDescriptor::Dump(FILE* stream)
1260 {
1261   char identbuf[IdentBufferLen];
1262   *identbuf = 0;
1263
1264   if ( stream == 0 )
1265     stream = stderr;
1266
1267   GenericPictureEssenceDescriptor::Dump(stream);
1268   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
1269   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
1270   fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling);
1271   fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting);
1272 }
1273
1274 //
1275 ASDCP::Result_t
1276 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1277 {
1278   m_Typeinfo = &Dict::Type(MDD_CDCIEssenceDescriptor);
1279   return InterchangeObject::InitFromBuffer(p, l);
1280 }
1281
1282 //
1283 ASDCP::Result_t
1284 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1285 {
1286   m_Typeinfo = &Dict::Type(MDD_CDCIEssenceDescriptor);
1287   return InterchangeObject::WriteToBuffer(Buffer);
1288 }
1289
1290 //------------------------------------------------------------------------------------------
1291 // MPEG2VideoDescriptor
1292
1293 //
1294 ASDCP::Result_t
1295 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1296 {
1297   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
1298   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, CodedContentType));
1299   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, LowDelay));
1300   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor, BitRate));
1301   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1302   return result;
1303 }
1304
1305 //
1306 ASDCP::Result_t
1307 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1308 {
1309   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
1310   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, CodedContentType));
1311   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, LowDelay));
1312   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, BitRate));
1313   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1314   return result;
1315 }
1316
1317 //
1318 void
1319 MPEG2VideoDescriptor::Dump(FILE* stream)
1320 {
1321   char identbuf[IdentBufferLen];
1322   *identbuf = 0;
1323
1324   if ( stream == 0 )
1325     stream = stderr;
1326
1327   CDCIEssenceDescriptor::Dump(stream);
1328   fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType);
1329   fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay);
1330   fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate);
1331   fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel);
1332 }
1333
1334 //
1335 ASDCP::Result_t
1336 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1337 {
1338   m_Typeinfo = &Dict::Type(MDD_MPEG2VideoDescriptor);
1339   return InterchangeObject::InitFromBuffer(p, l);
1340 }
1341
1342 //
1343 ASDCP::Result_t
1344 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1345 {
1346   m_Typeinfo = &Dict::Type(MDD_MPEG2VideoDescriptor);
1347   return InterchangeObject::WriteToBuffer(Buffer);
1348 }
1349
1350 //------------------------------------------------------------------------------------------
1351 // DMSegment
1352
1353 //
1354 ASDCP::Result_t
1355 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
1356 {
1357   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1358   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
1359   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
1360   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
1361   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
1362   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
1363   return result;
1364 }
1365
1366 //
1367 ASDCP::Result_t
1368 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
1369 {
1370   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1371   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
1372   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
1373   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
1374   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
1375   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
1376   return result;
1377 }
1378
1379 //
1380 void
1381 DMSegment::Dump(FILE* stream)
1382 {
1383   char identbuf[IdentBufferLen];
1384   *identbuf = 0;
1385
1386   if ( stream == 0 )
1387     stream = stderr;
1388
1389   InterchangeObject::Dump(stream);
1390   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
1391   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
1392   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
1393   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
1394   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
1395 }
1396
1397 //
1398 ASDCP::Result_t
1399 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
1400 {
1401   m_Typeinfo = &Dict::Type(MDD_DMSegment);
1402   return InterchangeObject::InitFromBuffer(p, l);
1403 }
1404
1405 //
1406 ASDCP::Result_t
1407 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1408 {
1409   m_Typeinfo = &Dict::Type(MDD_DMSegment);
1410   return InterchangeObject::WriteToBuffer(Buffer);
1411 }
1412
1413 //------------------------------------------------------------------------------------------
1414 // CryptographicFramework
1415
1416 //
1417 ASDCP::Result_t
1418 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
1419 {
1420   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1421   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
1422   return result;
1423 }
1424
1425 //
1426 ASDCP::Result_t
1427 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
1428 {
1429   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1430   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
1431   return result;
1432 }
1433
1434 //
1435 void
1436 CryptographicFramework::Dump(FILE* stream)
1437 {
1438   char identbuf[IdentBufferLen];
1439   *identbuf = 0;
1440
1441   if ( stream == 0 )
1442     stream = stderr;
1443
1444   InterchangeObject::Dump(stream);
1445   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
1446 }
1447
1448 //
1449 ASDCP::Result_t
1450 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
1451 {
1452   m_Typeinfo = &Dict::Type(MDD_CryptographicFramework);
1453   return InterchangeObject::InitFromBuffer(p, l);
1454 }
1455
1456 //
1457 ASDCP::Result_t
1458 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1459 {
1460   m_Typeinfo = &Dict::Type(MDD_CryptographicFramework);
1461   return InterchangeObject::WriteToBuffer(Buffer);
1462 }
1463
1464 //------------------------------------------------------------------------------------------
1465 // CryptographicContext
1466
1467 //
1468 ASDCP::Result_t
1469 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
1470 {
1471   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1472   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
1473   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
1474   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
1475   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
1476   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
1477   return result;
1478 }
1479
1480 //
1481 ASDCP::Result_t
1482 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
1483 {
1484   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1485   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
1486   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
1487   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
1488   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
1489   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
1490   return result;
1491 }
1492
1493 //
1494 void
1495 CryptographicContext::Dump(FILE* stream)
1496 {
1497   char identbuf[IdentBufferLen];
1498   *identbuf = 0;
1499
1500   if ( stream == 0 )
1501     stream = stderr;
1502
1503   InterchangeObject::Dump(stream);
1504   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
1505   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
1506   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
1507   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
1508   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
1509 }
1510
1511 //
1512 ASDCP::Result_t
1513 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
1514 {
1515   m_Typeinfo = &Dict::Type(MDD_CryptographicContext);
1516   return InterchangeObject::InitFromBuffer(p, l);
1517 }
1518
1519 //
1520 ASDCP::Result_t
1521 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1522 {
1523   m_Typeinfo = &Dict::Type(MDD_CryptographicContext);
1524   return InterchangeObject::WriteToBuffer(Buffer);
1525 }
1526
1527 //------------------------------------------------------------------------------------------
1528 // GenericDataEssenceDescriptor
1529
1530 //
1531 ASDCP::Result_t
1532 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1533 {
1534   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1535   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
1536   return result;
1537 }
1538
1539 //
1540 ASDCP::Result_t
1541 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1542 {
1543   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1544   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
1545   return result;
1546 }
1547
1548 //
1549 void
1550 GenericDataEssenceDescriptor::Dump(FILE* stream)
1551 {
1552   char identbuf[IdentBufferLen];
1553   *identbuf = 0;
1554
1555   if ( stream == 0 )
1556     stream = stderr;
1557
1558   FileDescriptor::Dump(stream);
1559   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1560 }
1561
1562 //
1563 ASDCP::Result_t
1564 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1565 {
1566   m_Typeinfo = &Dict::Type(MDD_GenericDataEssenceDescriptor);
1567   return InterchangeObject::InitFromBuffer(p, l);
1568 }
1569
1570 //
1571 ASDCP::Result_t
1572 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1573 {
1574   m_Typeinfo = &Dict::Type(MDD_GenericDataEssenceDescriptor);
1575   return InterchangeObject::WriteToBuffer(Buffer);
1576 }
1577
1578 //------------------------------------------------------------------------------------------
1579 // TimedTextDescriptor
1580
1581 //
1582 ASDCP::Result_t
1583 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1584 {
1585   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
1586   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
1587   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
1588   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
1589   return result;
1590 }
1591
1592 //
1593 ASDCP::Result_t
1594 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1595 {
1596   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
1597   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
1598   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
1599   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
1600   return result;
1601 }
1602
1603 //
1604 void
1605 TimedTextDescriptor::Dump(FILE* stream)
1606 {
1607   char identbuf[IdentBufferLen];
1608   *identbuf = 0;
1609
1610   if ( stream == 0 )
1611     stream = stderr;
1612
1613   GenericDataEssenceDescriptor::Dump(stream);
1614   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
1615   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
1616   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
1617 }
1618
1619 //
1620 ASDCP::Result_t
1621 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1622 {
1623   m_Typeinfo = &Dict::Type(MDD_TimedTextDescriptor);
1624   return InterchangeObject::InitFromBuffer(p, l);
1625 }
1626
1627 //
1628 ASDCP::Result_t
1629 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1630 {
1631   m_Typeinfo = &Dict::Type(MDD_TimedTextDescriptor);
1632   return InterchangeObject::WriteToBuffer(Buffer);
1633 }
1634
1635 //------------------------------------------------------------------------------------------
1636 // TimedTextResourceSubDescriptor
1637
1638 //
1639 ASDCP::Result_t
1640 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1641 {
1642   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1643   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
1644   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
1645   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
1646   return result;
1647 }
1648
1649 //
1650 ASDCP::Result_t
1651 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1652 {
1653   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1654   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
1655   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
1656   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
1657   return result;
1658 }
1659
1660 //
1661 void
1662 TimedTextResourceSubDescriptor::Dump(FILE* stream)
1663 {
1664   char identbuf[IdentBufferLen];
1665   *identbuf = 0;
1666
1667   if ( stream == 0 )
1668     stream = stderr;
1669
1670   InterchangeObject::Dump(stream);
1671   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
1672   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
1673   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
1674 }
1675
1676 //
1677 ASDCP::Result_t
1678 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1679 {
1680   m_Typeinfo = &Dict::Type(MDD_TimedTextResourceSubDescriptor);
1681   return InterchangeObject::InitFromBuffer(p, l);
1682 }
1683
1684 //
1685 ASDCP::Result_t
1686 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1687 {
1688   m_Typeinfo = &Dict::Type(MDD_TimedTextResourceSubDescriptor);
1689   return InterchangeObject::WriteToBuffer(Buffer);
1690 }
1691
1692 //------------------------------------------------------------------------------------------
1693 // StereoscopicPictureSubDescriptor
1694
1695 //
1696 ASDCP::Result_t
1697 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1698 {
1699   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1700   return result;
1701 }
1702
1703 //
1704 ASDCP::Result_t
1705 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1706 {
1707   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1708   return result;
1709 }
1710
1711 //
1712 void
1713 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
1714 {
1715   char identbuf[IdentBufferLen];
1716   *identbuf = 0;
1717
1718   if ( stream == 0 )
1719     stream = stderr;
1720
1721   InterchangeObject::Dump(stream);
1722 }
1723
1724 //
1725 ASDCP::Result_t
1726 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1727 {
1728   m_Typeinfo = &Dict::Type(MDD_StereoscopicPictureSubDescriptor);
1729   return InterchangeObject::InitFromBuffer(p, l);
1730 }
1731
1732 //
1733 ASDCP::Result_t
1734 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1735 {
1736   m_Typeinfo = &Dict::Type(MDD_StereoscopicPictureSubDescriptor);
1737   return InterchangeObject::WriteToBuffer(Buffer);
1738 }
1739
1740 //
1741 // end Metadata.cpp
1742 //