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