src/Metadata.cpp

   1 /*
   2 Copyright (c) 2005-2012, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27 /*! \file    Metadata.cpp
  28     \version $Id$
  29     \brief   AS-DCP library, MXF Metadata Sets implementation
  30 */
  31
  32
  33 #include <KM_mutex.h>
  34 #include "Metadata.h"
  35
  36 using namespace ASDCP;
  37 using namespace ASDCP::MXF;
  38
  39 const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
  40
  41 //------------------------------------------------------------------------------------------
  42
  43 static InterchangeObject* Preface_Factory(const Dictionary*& Dict) { return new Preface(Dict); }
  44 static InterchangeObject* IndexTableSegment_Factory(const Dictionary*& Dict) { return new IndexTableSegment(Dict); }
  45
  46 static InterchangeObject* Identification_Factory(const Dictionary*& Dict) { return new Identification(Dict); }
  47 static InterchangeObject* ContentStorage_Factory(const Dictionary*& Dict) { return new ContentStorage(Dict); }
  48 static InterchangeObject* EssenceContainerData_Factory(const Dictionary*& Dict) { return new EssenceContainerData(Dict); }
  49 static InterchangeObject* MaterialPackage_Factory(const Dictionary*& Dict) { return new MaterialPackage(Dict); }
  50 static InterchangeObject* SourcePackage_Factory(const Dictionary*& Dict) { return new SourcePackage(Dict); }
  51 static InterchangeObject* StaticTrack_Factory(const Dictionary*& Dict) { return new StaticTrack(Dict); }
  52 static InterchangeObject* Track_Factory(const Dictionary*& Dict) { return new Track(Dict); }
  53 static InterchangeObject* Sequence_Factory(const Dictionary*& Dict) { return new Sequence(Dict); }
  54 static InterchangeObject* SourceClip_Factory(const Dictionary*& Dict) { return new SourceClip(Dict); }
  55 static InterchangeObject* TimecodeComponent_Factory(const Dictionary*& Dict) { return new TimecodeComponent(Dict); }
  56 static InterchangeObject* FileDescriptor_Factory(const Dictionary*& Dict) { return new FileDescriptor(Dict); }
  57 static InterchangeObject* GenericSoundEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericSoundEssenceDescriptor(Dict); }
  58 static InterchangeObject* WaveAudioDescriptor_Factory(const Dictionary*& Dict) { return new WaveAudioDescriptor(Dict); }
  59 static InterchangeObject* GenericPictureEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericPictureEssenceDescriptor(Dict); }
  60 static InterchangeObject* RGBAEssenceDescriptor_Factory(const Dictionary*& Dict) { return new RGBAEssenceDescriptor(Dict); }
  61 static InterchangeObject* JPEG2000PictureSubDescriptor_Factory(const Dictionary*& Dict) { return new JPEG2000PictureSubDescriptor(Dict); }
  62 static InterchangeObject* CDCIEssenceDescriptor_Factory(const Dictionary*& Dict) { return new CDCIEssenceDescriptor(Dict); }
  63 static InterchangeObject* MPEG2VideoDescriptor_Factory(const Dictionary*& Dict) { return new MPEG2VideoDescriptor(Dict); }
  64 static InterchangeObject* DMSegment_Factory(const Dictionary*& Dict) { return new DMSegment(Dict); }
  65 static InterchangeObject* CryptographicFramework_Factory(const Dictionary*& Dict) { return new CryptographicFramework(Dict); }
  66 static InterchangeObject* CryptographicContext_Factory(const Dictionary*& Dict) { return new CryptographicContext(Dict); }
  67 static InterchangeObject* GenericDataEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericDataEssenceDescriptor(Dict); }
  68 static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextDescriptor(Dict); }
  69 static InterchangeObject* TimedTextResourceSubDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextResourceSubDescriptor(Dict); }
  70 static InterchangeObject* StereoscopicPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new StereoscopicPictureSubDescriptor(Dict); }
  71 static InterchangeObject* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); }
  72 static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); }
  73 static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); }
  74 static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
  75 static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
  76 static InterchangeObject* DCDataDescriptor_Factory(const Dictionary*& Dict) { return new DCDataDescriptor(Dict); }
  77 static InterchangeObject* DolbyAtmosSubDescriptor_Factory(const Dictionary*& Dict) { return new DolbyAtmosSubDescriptor(Dict); }
  78
  79
  80 void
  81 ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
  82 {
  83   assert(Dict);
  84   SetObjectFactory(Dict->ul(MDD_Preface), Preface_Factory);
  85   SetObjectFactory(Dict->ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
  86
  87   SetObjectFactory(Dict->ul(MDD_Identification), Identification_Factory);
  88   SetObjectFactory(Dict->ul(MDD_ContentStorage), ContentStorage_Factory);
  89   SetObjectFactory(Dict->ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
  90   SetObjectFactory(Dict->ul(MDD_MaterialPackage), MaterialPackage_Factory);
  91   SetObjectFactory(Dict->ul(MDD_SourcePackage), SourcePackage_Factory);
  92   SetObjectFactory(Dict->ul(MDD_StaticTrack), StaticTrack_Factory);
  93   SetObjectFactory(Dict->ul(MDD_Track), Track_Factory);
  94   SetObjectFactory(Dict->ul(MDD_Sequence), Sequence_Factory);
  95   SetObjectFactory(Dict->ul(MDD_SourceClip), SourceClip_Factory);
  96   SetObjectFactory(Dict->ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
  97   SetObjectFactory(Dict->ul(MDD_FileDescriptor), FileDescriptor_Factory);
  98   SetObjectFactory(Dict->ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
  99   SetObjectFactory(Dict->ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
 100   SetObjectFactory(Dict->ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
 101   SetObjectFactory(Dict->ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
 102   SetObjectFactory(Dict->ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
 103   SetObjectFactory(Dict->ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
 104   SetObjectFactory(Dict->ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
 105   SetObjectFactory(Dict->ul(MDD_DMSegment), DMSegment_Factory);
 106   SetObjectFactory(Dict->ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
 107   SetObjectFactory(Dict->ul(MDD_CryptographicContext), CryptographicContext_Factory);
 108   SetObjectFactory(Dict->ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
 109   SetObjectFactory(Dict->ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
 110   SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
 111   SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
 112   SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory);
 113   SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory);
 114   SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory);
 115   SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
 116   SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
 117   SetObjectFactory(Dict->ul(MDD_DCDataDescriptor), DCDataDescriptor_Factory);
 118   SetObjectFactory(Dict->ul(MDD_DolbyAtmosSubDescriptor), DolbyAtmosSubDescriptor_Factory);
 119 }
 120
 121 //------------------------------------------------------------------------------------------
 122 // KLV Sets
 123
 124
 125
 126 //------------------------------------------------------------------------------------------
 127 // Identification
 128
 129 //
 130
 131 Identification::Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
 132 {
 133   assert(m_Dict);
 134   m_UL = m_Dict->ul(MDD_Identification);
 135 }
 136
 137 Identification::Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 138 {
 139   assert(m_Dict);
 140   m_UL = m_Dict->ul(MDD_Identification);
 141   Copy(rhs);
 142 }
 143
 144
 145 //
 146 ASDCP::Result_t
 147 Identification::InitFromTLVSet(TLVReader& TLVSet)
 148 {
 149   assert(m_Dict);
 150   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 151   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
 152   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
 153   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
 154   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductVersion));
 155   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
 156   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
 157   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
 158   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ToolkitVersion));
 159   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, Platform));
 160   return result;
 161 }
 162
 163 //
 164 ASDCP::Result_t
 165 Identification::WriteToTLVSet(TLVWriter& TLVSet)
 166 {
 167   assert(m_Dict);
 168   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 169   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ThisGenerationUID));
 170   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, CompanyName));
 171   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductName));
 172   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductVersion));
 173   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, VersionString));
 174   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductUID));
 175   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ModificationDate));
 176   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ToolkitVersion));
 177   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, Platform));
 178   return result;
 179 }
 180
 181 //
 182 void
 183 Identification::Copy(const Identification& rhs)
 184 {
 185   InterchangeObject::Copy(rhs);
 186   ThisGenerationUID = rhs.ThisGenerationUID;
 187   CompanyName = rhs.CompanyName;
 188   ProductName = rhs.ProductName;
 189   ProductVersion = rhs.ProductVersion;
 190   VersionString = rhs.VersionString;
 191   ProductUID = rhs.ProductUID;
 192   ModificationDate = rhs.ModificationDate;
 193   ToolkitVersion = rhs.ToolkitVersion;
 194   Platform = rhs.Platform;
 195 }
 196
 197 //
 198 void
 199 Identification::Dump(FILE* stream)
 200 {
 201   char identbuf[IdentBufferLen];
 202   *identbuf = 0;
 203
 204   if ( stream == 0 )
 205     stream = stderr;
 206
 207   InterchangeObject::Dump(stream);
 208   fprintf(stream, "  %22s = %s\n",  "ThisGenerationUID", ThisGenerationUID.EncodeString(identbuf, IdentBufferLen));
 209   fprintf(stream, "  %22s = %s\n",  "CompanyName", CompanyName.EncodeString(identbuf, IdentBufferLen));
 210   fprintf(stream, "  %22s = %s\n",  "ProductName", ProductName.EncodeString(identbuf, IdentBufferLen));
 211   fprintf(stream, "  %22s = %s\n",  "ProductVersion", ProductVersion.EncodeString(identbuf, IdentBufferLen));
 212   fprintf(stream, "  %22s = %s\n",  "VersionString", VersionString.EncodeString(identbuf, IdentBufferLen));
 213   fprintf(stream, "  %22s = %s\n",  "ProductUID", ProductUID.EncodeString(identbuf, IdentBufferLen));
 214   fprintf(stream, "  %22s = %s\n",  "ModificationDate", ModificationDate.EncodeString(identbuf, IdentBufferLen));
 215   fprintf(stream, "  %22s = %s\n",  "ToolkitVersion", ToolkitVersion.EncodeString(identbuf, IdentBufferLen));
 216   fprintf(stream, "  %22s = %s\n",  "Platform", Platform.EncodeString(identbuf, IdentBufferLen));
 217 }
 218
 219 //
 220 ASDCP::Result_t
 221 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 222 {
 223   return InterchangeObject::InitFromBuffer(p, l);
 224 }
 225
 226 //
 227 ASDCP::Result_t
 228 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 229 {
 230   return InterchangeObject::WriteToBuffer(Buffer);
 231 }
 232
 233 //------------------------------------------------------------------------------------------
 234 // ContentStorage
 235
 236 //
 237
 238 ContentStorage::ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
 239 {
 240   assert(m_Dict);
 241   m_UL = m_Dict->ul(MDD_ContentStorage);
 242 }
 243
 244 ContentStorage::ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 245 {
 246   assert(m_Dict);
 247   m_UL = m_Dict->ul(MDD_ContentStorage);
 248   Copy(rhs);
 249 }
 250
 251
 252 //
 253 ASDCP::Result_t
 254 ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
 255 {
 256   assert(m_Dict);
 257   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 258   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
 259   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
 260   return result;
 261 }
 262
 263 //
 264 ASDCP::Result_t
 265 ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
 266 {
 267   assert(m_Dict);
 268   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 269   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, Packages));
 270   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, EssenceContainerData));
 271   return result;
 272 }
 273
 274 //
 275 void
 276 ContentStorage::Copy(const ContentStorage& rhs)
 277 {
 278   InterchangeObject::Copy(rhs);
 279   Packages = rhs.Packages;
 280   EssenceContainerData = rhs.EssenceContainerData;
 281 }
 282
 283 //
 284 void
 285 ContentStorage::Dump(FILE* stream)
 286 {
 287   char identbuf[IdentBufferLen];
 288   *identbuf = 0;
 289
 290   if ( stream == 0 )
 291     stream = stderr;
 292
 293   InterchangeObject::Dump(stream);
 294   fprintf(stream, "  %22s:\n",  "Packages");
 295   Packages.Dump(stream);
 296   fprintf(stream, "  %22s:\n",  "EssenceContainerData");
 297   EssenceContainerData.Dump(stream);
 298 }
 299
 300 //
 301 ASDCP::Result_t
 302 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 303 {
 304   return InterchangeObject::InitFromBuffer(p, l);
 305 }
 306
 307 //
 308 ASDCP::Result_t
 309 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 310 {
 311   return InterchangeObject::WriteToBuffer(Buffer);
 312 }
 313
 314 //------------------------------------------------------------------------------------------
 315 // EssenceContainerData
 316
 317 //
 318
 319 EssenceContainerData::EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0)
 320 {
 321   assert(m_Dict);
 322   m_UL = m_Dict->ul(MDD_EssenceContainerData);
 323 }
 324
 325 EssenceContainerData::EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 326 {
 327   assert(m_Dict);
 328   m_UL = m_Dict->ul(MDD_EssenceContainerData);
 329   Copy(rhs);
 330 }
 331
 332
 333 //
 334 ASDCP::Result_t
 335 EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
 336 {
 337   assert(m_Dict);
 338   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 339   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(EssenceContainerData, LinkedPackageUID));
 340   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, IndexSID));
 341   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, BodySID));
 342   return result;
 343 }
 344
 345 //
 346 ASDCP::Result_t
 347 EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
 348 {
 349   assert(m_Dict);
 350   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 351   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(EssenceContainerData, LinkedPackageUID));
 352   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, IndexSID));
 353   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, BodySID));
 354   return result;
 355 }
 356
 357 //
 358 void
 359 EssenceContainerData::Copy(const EssenceContainerData& rhs)
 360 {
 361   InterchangeObject::Copy(rhs);
 362   LinkedPackageUID = rhs.LinkedPackageUID;
 363   IndexSID = rhs.IndexSID;
 364   BodySID = rhs.BodySID;
 365 }
 366
 367 //
 368 void
 369 EssenceContainerData::Dump(FILE* stream)
 370 {
 371   char identbuf[IdentBufferLen];
 372   *identbuf = 0;
 373
 374   if ( stream == 0 )
 375     stream = stderr;
 376
 377   InterchangeObject::Dump(stream);
 378   fprintf(stream, "  %22s = %s\n",  "LinkedPackageUID", LinkedPackageUID.EncodeString(identbuf, IdentBufferLen));
 379   fprintf(stream, "  %22s = %d\n",  "IndexSID", IndexSID);
 380   fprintf(stream, "  %22s = %d\n",  "BodySID", BodySID);
 381 }
 382
 383 //
 384 ASDCP::Result_t
 385 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 386 {
 387   return InterchangeObject::InitFromBuffer(p, l);
 388 }
 389
 390 //
 391 ASDCP::Result_t
 392 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 393 {
 394   return InterchangeObject::WriteToBuffer(Buffer);
 395 }
 396
 397 //------------------------------------------------------------------------------------------
 398 // GenericPackage
 399
 400 //
 401 GenericPackage::GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 402
 403 GenericPackage::GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 404 {
 405   Copy(rhs);
 406 }
 407
 408
 409 //
 410 ASDCP::Result_t
 411 GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
 412 {
 413   assert(m_Dict);
 414   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 415   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
 416   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Name));
 417   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
 418   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
 419   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
 420   return result;
 421 }
 422
 423 //
 424 ASDCP::Result_t
 425 GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
 426 {
 427   assert(m_Dict);
 428   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 429   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageUID));
 430   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Name));
 431   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageCreationDate));
 432   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageModifiedDate));
 433   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Tracks));
 434   return result;
 435 }
 436
 437 //
 438 void
 439 GenericPackage::Copy(const GenericPackage& rhs)
 440 {
 441   InterchangeObject::Copy(rhs);
 442   PackageUID = rhs.PackageUID;
 443   Name = rhs.Name;
 444   PackageCreationDate = rhs.PackageCreationDate;
 445   PackageModifiedDate = rhs.PackageModifiedDate;
 446   Tracks = rhs.Tracks;
 447 }
 448
 449 //
 450 void
 451 GenericPackage::Dump(FILE* stream)
 452 {
 453   char identbuf[IdentBufferLen];
 454   *identbuf = 0;
 455
 456   if ( stream == 0 )
 457     stream = stderr;
 458
 459   InterchangeObject::Dump(stream);
 460   fprintf(stream, "  %22s = %s\n",  "PackageUID", PackageUID.EncodeString(identbuf, IdentBufferLen));
 461   fprintf(stream, "  %22s = %s\n",  "Name", Name.EncodeString(identbuf, IdentBufferLen));
 462   fprintf(stream, "  %22s = %s\n",  "PackageCreationDate", PackageCreationDate.EncodeString(identbuf, IdentBufferLen));
 463   fprintf(stream, "  %22s = %s\n",  "PackageModifiedDate", PackageModifiedDate.EncodeString(identbuf, IdentBufferLen));
 464   fprintf(stream, "  %22s:\n",  "Tracks");
 465   Tracks.Dump(stream);
 466 }
 467
 468
 469 //------------------------------------------------------------------------------------------
 470 // MaterialPackage
 471
 472 //
 473
 474 MaterialPackage::MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
 475 {
 476   assert(m_Dict);
 477   m_UL = m_Dict->ul(MDD_MaterialPackage);
 478 }
 479
 480 MaterialPackage::MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
 481 {
 482   assert(m_Dict);
 483   m_UL = m_Dict->ul(MDD_MaterialPackage);
 484   Copy(rhs);
 485 }
 486
 487
 488 //
 489 ASDCP::Result_t
 490 MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
 491 {
 492   assert(m_Dict);
 493   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 494   return result;
 495 }
 496
 497 //
 498 ASDCP::Result_t
 499 MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
 500 {
 501   assert(m_Dict);
 502   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 503   return result;
 504 }
 505
 506 //
 507 void
 508 MaterialPackage::Copy(const MaterialPackage& rhs)
 509 {
 510   GenericPackage::Copy(rhs);
 511 }
 512
 513 //
 514 void
 515 MaterialPackage::Dump(FILE* stream)
 516 {
 517   char identbuf[IdentBufferLen];
 518   *identbuf = 0;
 519
 520   if ( stream == 0 )
 521     stream = stderr;
 522
 523   GenericPackage::Dump(stream);
 524 }
 525
 526 //
 527 ASDCP::Result_t
 528 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 529 {
 530   return InterchangeObject::InitFromBuffer(p, l);
 531 }
 532
 533 //
 534 ASDCP::Result_t
 535 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 536 {
 537   return InterchangeObject::WriteToBuffer(Buffer);
 538 }
 539
 540 //------------------------------------------------------------------------------------------
 541 // SourcePackage
 542
 543 //
 544
 545 SourcePackage::SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
 546 {
 547   assert(m_Dict);
 548   m_UL = m_Dict->ul(MDD_SourcePackage);
 549 }
 550
 551 SourcePackage::SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
 552 {
 553   assert(m_Dict);
 554   m_UL = m_Dict->ul(MDD_SourcePackage);
 555   Copy(rhs);
 556 }
 557
 558
 559 //
 560 ASDCP::Result_t
 561 SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
 562 {
 563   assert(m_Dict);
 564   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 565   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourcePackage, Descriptor));
 566   return result;
 567 }
 568
 569 //
 570 ASDCP::Result_t
 571 SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
 572 {
 573   assert(m_Dict);
 574   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 575   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourcePackage, Descriptor));
 576   return result;
 577 }
 578
 579 //
 580 void
 581 SourcePackage::Copy(const SourcePackage& rhs)
 582 {
 583   GenericPackage::Copy(rhs);
 584   Descriptor = rhs.Descriptor;
 585 }
 586
 587 //
 588 void
 589 SourcePackage::Dump(FILE* stream)
 590 {
 591   char identbuf[IdentBufferLen];
 592   *identbuf = 0;
 593
 594   if ( stream == 0 )
 595     stream = stderr;
 596
 597   GenericPackage::Dump(stream);
 598   fprintf(stream, "  %22s = %s\n",  "Descriptor", Descriptor.EncodeString(identbuf, IdentBufferLen));
 599 }
 600
 601 //
 602 ASDCP::Result_t
 603 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 604 {
 605   return InterchangeObject::InitFromBuffer(p, l);
 606 }
 607
 608 //
 609 ASDCP::Result_t
 610 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 611 {
 612   return InterchangeObject::WriteToBuffer(Buffer);
 613 }
 614
 615 //------------------------------------------------------------------------------------------
 616 // GenericTrack
 617
 618 //
 619 GenericTrack::GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
 620
 621 GenericTrack::GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 622 {
 623   Copy(rhs);
 624 }
 625
 626
 627 //
 628 ASDCP::Result_t
 629 GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
 630 {
 631   assert(m_Dict);
 632   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 633   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
 634   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
 635   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, TrackName));
 636   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, Sequence));
 637   return result;
 638 }
 639
 640 //
 641 ASDCP::Result_t
 642 GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
 643 {
 644   assert(m_Dict);
 645   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 646   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackID));
 647   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackNumber));
 648   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericTrack, TrackName));
 649   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericTrack, Sequence));
 650   return result;
 651 }
 652
 653 //
 654 void
 655 GenericTrack::Copy(const GenericTrack& rhs)
 656 {
 657   InterchangeObject::Copy(rhs);
 658   TrackID = rhs.TrackID;
 659   TrackNumber = rhs.TrackNumber;
 660   TrackName = rhs.TrackName;
 661   Sequence = rhs.Sequence;
 662 }
 663
 664 //
 665 void
 666 GenericTrack::Dump(FILE* stream)
 667 {
 668   char identbuf[IdentBufferLen];
 669   *identbuf = 0;
 670
 671   if ( stream == 0 )
 672     stream = stderr;
 673
 674   InterchangeObject::Dump(stream);
 675   fprintf(stream, "  %22s = %d\n",  "TrackID", TrackID);
 676   fprintf(stream, "  %22s = %d\n",  "TrackNumber", TrackNumber);
 677   fprintf(stream, "  %22s = %s\n",  "TrackName", TrackName.EncodeString(identbuf, IdentBufferLen));
 678   fprintf(stream, "  %22s = %s\n",  "Sequence", Sequence.EncodeString(identbuf, IdentBufferLen));
 679 }
 680
 681
 682 //------------------------------------------------------------------------------------------
 683 // StaticTrack
 684
 685 //
 686
 687 StaticTrack::StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d)
 688 {
 689   assert(m_Dict);
 690   m_UL = m_Dict->ul(MDD_StaticTrack);
 691 }
 692
 693 StaticTrack::StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
 694 {
 695   assert(m_Dict);
 696   m_UL = m_Dict->ul(MDD_StaticTrack);
 697   Copy(rhs);
 698 }
 699
 700
 701 //
 702 ASDCP::Result_t
 703 StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
 704 {
 705   assert(m_Dict);
 706   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 707   return result;
 708 }
 709
 710 //
 711 ASDCP::Result_t
 712 StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
 713 {
 714   assert(m_Dict);
 715   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 716   return result;
 717 }
 718
 719 //
 720 void
 721 StaticTrack::Copy(const StaticTrack& rhs)
 722 {
 723   GenericTrack::Copy(rhs);
 724 }
 725
 726 //
 727 void
 728 StaticTrack::Dump(FILE* stream)
 729 {
 730   char identbuf[IdentBufferLen];
 731   *identbuf = 0;
 732
 733   if ( stream == 0 )
 734     stream = stderr;
 735
 736   GenericTrack::Dump(stream);
 737 }
 738
 739 //
 740 ASDCP::Result_t
 741 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 742 {
 743   return InterchangeObject::InitFromBuffer(p, l);
 744 }
 745
 746 //
 747 ASDCP::Result_t
 748 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 749 {
 750   return InterchangeObject::WriteToBuffer(Buffer);
 751 }
 752
 753 //------------------------------------------------------------------------------------------
 754 // Track
 755
 756 //
 757
 758 Track::Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0)
 759 {
 760   assert(m_Dict);
 761   m_UL = m_Dict->ul(MDD_Track);
 762 }
 763
 764 Track::Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
 765 {
 766   assert(m_Dict);
 767   m_UL = m_Dict->ul(MDD_Track);
 768   Copy(rhs);
 769 }
 770
 771
 772 //
 773 ASDCP::Result_t
 774 Track::InitFromTLVSet(TLVReader& TLVSet)
 775 {
 776   assert(m_Dict);
 777   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 778   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
 779   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
 780   return result;
 781 }
 782
 783 //
 784 ASDCP::Result_t
 785 Track::WriteToTLVSet(TLVWriter& TLVSet)
 786 {
 787   assert(m_Dict);
 788   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 789   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Track, EditRate));
 790   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(Track, Origin));
 791   return result;
 792 }
 793
 794 //
 795 void
 796 Track::Copy(const Track& rhs)
 797 {
 798   GenericTrack::Copy(rhs);
 799   EditRate = rhs.EditRate;
 800   Origin = rhs.Origin;
 801 }
 802
 803 //
 804 void
 805 Track::Dump(FILE* stream)
 806 {
 807   char identbuf[IdentBufferLen];
 808   *identbuf = 0;
 809
 810   if ( stream == 0 )
 811     stream = stderr;
 812
 813   GenericTrack::Dump(stream);
 814   fprintf(stream, "  %22s = %s\n",  "EditRate", EditRate.EncodeString(identbuf, IdentBufferLen));
 815   fprintf(stream, "  %22s = %s\n",  "Origin", i64sz(Origin, identbuf));
 816 }
 817
 818 //
 819 ASDCP::Result_t
 820 Track::InitFromBuffer(const byte_t* p, ui32_t l)
 821 {
 822   return InterchangeObject::InitFromBuffer(p, l);
 823 }
 824
 825 //
 826 ASDCP::Result_t
 827 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 828 {
 829   return InterchangeObject::WriteToBuffer(Buffer);
 830 }
 831
 832 //------------------------------------------------------------------------------------------
 833 // StructuralComponent
 834
 835 //
 836 StructuralComponent::StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
 837
 838 StructuralComponent::StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 839 {
 840   Copy(rhs);
 841 }
 842
 843
 844 //
 845 ASDCP::Result_t
 846 StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
 847 {
 848   assert(m_Dict);
 849   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 850   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 851   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
 852   return result;
 853 }
 854
 855 //
 856 ASDCP::Result_t
 857 StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
 858 {
 859   assert(m_Dict);
 860   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 861   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(StructuralComponent, DataDefinition));
 862   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(StructuralComponent, Duration));
 863   return result;
 864 }
 865
 866 //
 867 void
 868 StructuralComponent::Copy(const StructuralComponent& rhs)
 869 {
 870   InterchangeObject::Copy(rhs);
 871   DataDefinition = rhs.DataDefinition;
 872   Duration = rhs.Duration;
 873 }
 874
 875 //
 876 void
 877 StructuralComponent::Dump(FILE* stream)
 878 {
 879   char identbuf[IdentBufferLen];
 880   *identbuf = 0;
 881
 882   if ( stream == 0 )
 883     stream = stderr;
 884
 885   InterchangeObject::Dump(stream);
 886   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
 887   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
 888 }
 889
 890
 891 //------------------------------------------------------------------------------------------
 892 // Sequence
 893
 894 //
 895
 896 Sequence::Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d)
 897 {
 898   assert(m_Dict);
 899   m_UL = m_Dict->ul(MDD_Sequence);
 900 }
 901
 902 Sequence::Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
 903 {
 904   assert(m_Dict);
 905   m_UL = m_Dict->ul(MDD_Sequence);
 906   Copy(rhs);
 907 }
 908
 909
 910 //
 911 ASDCP::Result_t
 912 Sequence::InitFromTLVSet(TLVReader& TLVSet)
 913 {
 914   assert(m_Dict);
 915   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 916   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
 917   return result;
 918 }
 919
 920 //
 921 ASDCP::Result_t
 922 Sequence::WriteToTLVSet(TLVWriter& TLVSet)
 923 {
 924   assert(m_Dict);
 925   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
 926   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Sequence, StructuralComponents));
 927   return result;
 928 }
 929
 930 //
 931 void
 932 Sequence::Copy(const Sequence& rhs)
 933 {
 934   StructuralComponent::Copy(rhs);
 935   StructuralComponents = rhs.StructuralComponents;
 936 }
 937
 938 //
 939 void
 940 Sequence::Dump(FILE* stream)
 941 {
 942   char identbuf[IdentBufferLen];
 943   *identbuf = 0;
 944
 945   if ( stream == 0 )
 946     stream = stderr;
 947
 948   StructuralComponent::Dump(stream);
 949   fprintf(stream, "  %22s:\n",  "StructuralComponents");
 950   StructuralComponents.Dump(stream);
 951 }
 952
 953 //
 954 ASDCP::Result_t
 955 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 956 {
 957   return InterchangeObject::InitFromBuffer(p, l);
 958 }
 959
 960 //
 961 ASDCP::Result_t
 962 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 963 {
 964   return InterchangeObject::WriteToBuffer(Buffer);
 965 }
 966
 967 //------------------------------------------------------------------------------------------
 968 // SourceClip
 969
 970 //
 971
 972 SourceClip::SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0)
 973 {
 974   assert(m_Dict);
 975   m_UL = m_Dict->ul(MDD_SourceClip);
 976 }
 977
 978 SourceClip::SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
 979 {
 980   assert(m_Dict);
 981   m_UL = m_Dict->ul(MDD_SourceClip);
 982   Copy(rhs);
 983 }
 984
 985
 986 //
 987 ASDCP::Result_t
 988 SourceClip::InitFromTLVSet(TLVReader& TLVSet)
 989 {
 990   assert(m_Dict);
 991   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 992   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
 993   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
 994   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
 995   return result;
 996 }
 997
 998 //
 999 ASDCP::Result_t
1000 SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
1001 {
1002   assert(m_Dict);
1003   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1004   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(SourceClip, StartPosition));
1005   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourceClip, SourcePackageID));
1006   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(SourceClip, SourceTrackID));
1007   return result;
1008 }
1009
1010 //
1011 void
1012 SourceClip::Copy(const SourceClip& rhs)
1013 {
1014   StructuralComponent::Copy(rhs);
1015   StartPosition = rhs.StartPosition;
1016   SourcePackageID = rhs.SourcePackageID;
1017   SourceTrackID = rhs.SourceTrackID;
1018 }
1019
1020 //
1021 void
1022 SourceClip::Dump(FILE* stream)
1023 {
1024   char identbuf[IdentBufferLen];
1025   *identbuf = 0;
1026
1027   if ( stream == 0 )
1028     stream = stderr;
1029
1030   StructuralComponent::Dump(stream);
1031   fprintf(stream, "  %22s = %s\n",  "StartPosition", i64sz(StartPosition, identbuf));
1032   fprintf(stream, "  %22s = %s\n",  "SourcePackageID", SourcePackageID.EncodeString(identbuf, IdentBufferLen));
1033   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
1034 }
1035
1036 //
1037 ASDCP::Result_t
1038 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
1039 {
1040   return InterchangeObject::InitFromBuffer(p, l);
1041 }
1042
1043 //
1044 ASDCP::Result_t
1045 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1046 {
1047   return InterchangeObject::WriteToBuffer(Buffer);
1048 }
1049
1050 //------------------------------------------------------------------------------------------
1051 // TimecodeComponent
1052
1053 //
1054
1055 TimecodeComponent::TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0)
1056 {
1057   assert(m_Dict);
1058   m_UL = m_Dict->ul(MDD_TimecodeComponent);
1059 }
1060
1061 TimecodeComponent::TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1062 {
1063   assert(m_Dict);
1064   m_UL = m_Dict->ul(MDD_TimecodeComponent);
1065   Copy(rhs);
1066 }
1067
1068
1069 //
1070 ASDCP::Result_t
1071 TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
1072 {
1073   assert(m_Dict);
1074   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1075   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
1076   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
1077   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
1078   return result;
1079 }
1080
1081 //
1082 ASDCP::Result_t
1083 TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
1084 {
1085   assert(m_Dict);
1086   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1087   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(TimecodeComponent, RoundedTimecodeBase));
1088   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TimecodeComponent, StartTimecode));
1089   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(TimecodeComponent, DropFrame));
1090   return result;
1091 }
1092
1093 //
1094 void
1095 TimecodeComponent::Copy(const TimecodeComponent& rhs)
1096 {
1097   StructuralComponent::Copy(rhs);
1098   RoundedTimecodeBase = rhs.RoundedTimecodeBase;
1099   StartTimecode = rhs.StartTimecode;
1100   DropFrame = rhs.DropFrame;
1101 }
1102
1103 //
1104 void
1105 TimecodeComponent::Dump(FILE* stream)
1106 {
1107   char identbuf[IdentBufferLen];
1108   *identbuf = 0;
1109
1110   if ( stream == 0 )
1111     stream = stderr;
1112
1113   StructuralComponent::Dump(stream);
1114   fprintf(stream, "  %22s = %d\n",  "RoundedTimecodeBase", RoundedTimecodeBase);
1115   fprintf(stream, "  %22s = %s\n",  "StartTimecode", i64sz(StartTimecode, identbuf));
1116   fprintf(stream, "  %22s = %d\n",  "DropFrame", DropFrame);
1117 }
1118
1119 //
1120 ASDCP::Result_t
1121 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
1122 {
1123   return InterchangeObject::InitFromBuffer(p, l);
1124 }
1125
1126 //
1127 ASDCP::Result_t
1128 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1129 {
1130   return InterchangeObject::WriteToBuffer(Buffer);
1131 }
1132
1133 //------------------------------------------------------------------------------------------
1134 // GenericDescriptor
1135
1136 //
1137 GenericDescriptor::GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
1138
1139 GenericDescriptor::GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1140 {
1141   Copy(rhs);
1142 }
1143
1144
1145 //
1146 ASDCP::Result_t
1147 GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1148 {
1149   assert(m_Dict);
1150   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1151   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
1152   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
1153   return result;
1154 }
1155
1156 //
1157 ASDCP::Result_t
1158 GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1159 {
1160   assert(m_Dict);
1161   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1162   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, Locators));
1163   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, SubDescriptors));
1164   return result;
1165 }
1166
1167 //
1168 void
1169 GenericDescriptor::Copy(const GenericDescriptor& rhs)
1170 {
1171   InterchangeObject::Copy(rhs);
1172   Locators = rhs.Locators;
1173   SubDescriptors = rhs.SubDescriptors;
1174 }
1175
1176 //
1177 void
1178 GenericDescriptor::Dump(FILE* stream)
1179 {
1180   char identbuf[IdentBufferLen];
1181   *identbuf = 0;
1182
1183   if ( stream == 0 )
1184     stream = stderr;
1185
1186   InterchangeObject::Dump(stream);
1187   fprintf(stream, "  %22s:\n",  "Locators");
1188   Locators.Dump(stream);
1189   fprintf(stream, "  %22s:\n",  "SubDescriptors");
1190   SubDescriptors.Dump(stream);
1191 }
1192
1193
1194 //------------------------------------------------------------------------------------------
1195 // FileDescriptor
1196
1197 //
1198
1199 FileDescriptor::FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0)
1200 {
1201   assert(m_Dict);
1202   m_UL = m_Dict->ul(MDD_FileDescriptor);
1203 }
1204
1205 FileDescriptor::FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1206 {
1207   assert(m_Dict);
1208   m_UL = m_Dict->ul(MDD_FileDescriptor);
1209   Copy(rhs);
1210 }
1211
1212
1213 //
1214 ASDCP::Result_t
1215 FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1216 {
1217   assert(m_Dict);
1218   Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
1219   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
1220   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
1221   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
1222   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
1223   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, Codec));
1224   return result;
1225 }
1226
1227 //
1228 ASDCP::Result_t
1229 FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1230 {
1231   assert(m_Dict);
1232   Result_t result = GenericDescriptor::WriteToTLVSet(TLVSet);
1233   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(FileDescriptor, LinkedTrackID));
1234   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, SampleRate));
1235   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(FileDescriptor, ContainerDuration));
1236   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, EssenceContainer));
1237   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, Codec));
1238   return result;
1239 }
1240
1241 //
1242 void
1243 FileDescriptor::Copy(const FileDescriptor& rhs)
1244 {
1245   GenericDescriptor::Copy(rhs);
1246   LinkedTrackID = rhs.LinkedTrackID;
1247   SampleRate = rhs.SampleRate;
1248   ContainerDuration = rhs.ContainerDuration;
1249   EssenceContainer = rhs.EssenceContainer;
1250   Codec = rhs.Codec;
1251 }
1252
1253 //
1254 void
1255 FileDescriptor::Dump(FILE* stream)
1256 {
1257   char identbuf[IdentBufferLen];
1258   *identbuf = 0;
1259
1260   if ( stream == 0 )
1261     stream = stderr;
1262
1263   GenericDescriptor::Dump(stream);
1264   fprintf(stream, "  %22s = %d\n",  "LinkedTrackID", LinkedTrackID);
1265   fprintf(stream, "  %22s = %s\n",  "SampleRate", SampleRate.EncodeString(identbuf, IdentBufferLen));
1266   fprintf(stream, "  %22s = %s\n",  "ContainerDuration", i64sz(ContainerDuration, identbuf));
1267   fprintf(stream, "  %22s = %s\n",  "EssenceContainer", EssenceContainer.EncodeString(identbuf, IdentBufferLen));
1268   fprintf(stream, "  %22s = %s\n",  "Codec", Codec.EncodeString(identbuf, IdentBufferLen));
1269 }
1270
1271 //
1272 ASDCP::Result_t
1273 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1274 {
1275   return InterchangeObject::InitFromBuffer(p, l);
1276 }
1277
1278 //
1279 ASDCP::Result_t
1280 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1281 {
1282   return InterchangeObject::WriteToBuffer(Buffer);
1283 }
1284
1285 //------------------------------------------------------------------------------------------
1286 // GenericSoundEssenceDescriptor
1287
1288 //
1289
1290 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0)
1291 {
1292   assert(m_Dict);
1293   m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1294 }
1295
1296 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1297 {
1298   assert(m_Dict);
1299   m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1300   Copy(rhs);
1301 }
1302
1303
1304 //
1305 ASDCP::Result_t
1306 GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1307 {
1308   assert(m_Dict);
1309   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1310   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1311   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
1312   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
1313   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1314   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1315   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, DialNorm));
1316   return result;
1317 }
1318
1319 //
1320 ASDCP::Result_t
1321 GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1322 {
1323   assert(m_Dict);
1324   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1325   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1326   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
1327   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
1328   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1329   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1330   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, DialNorm));
1331   return result;
1332 }
1333
1334 //
1335 void
1336 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
1337 {
1338   FileDescriptor::Copy(rhs);
1339   AudioSamplingRate = rhs.AudioSamplingRate;
1340   Locked = rhs.Locked;
1341   AudioRefLevel = rhs.AudioRefLevel;
1342   ChannelCount = rhs.ChannelCount;
1343   QuantizationBits = rhs.QuantizationBits;
1344   DialNorm = rhs.DialNorm;
1345 }
1346
1347 //
1348 void
1349 GenericSoundEssenceDescriptor::Dump(FILE* stream)
1350 {
1351   char identbuf[IdentBufferLen];
1352   *identbuf = 0;
1353
1354   if ( stream == 0 )
1355     stream = stderr;
1356
1357   FileDescriptor::Dump(stream);
1358   fprintf(stream, "  %22s = %s\n",  "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1359   fprintf(stream, "  %22s = %d\n",  "Locked", Locked);
1360   fprintf(stream, "  %22s = %d\n",  "AudioRefLevel", AudioRefLevel);
1361   fprintf(stream, "  %22s = %d\n",  "ChannelCount", ChannelCount);
1362   fprintf(stream, "  %22s = %d\n",  "QuantizationBits", QuantizationBits);
1363   fprintf(stream, "  %22s = %d\n",  "DialNorm", DialNorm);
1364 }
1365
1366 //
1367 ASDCP::Result_t
1368 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1369 {
1370   return InterchangeObject::InitFromBuffer(p, l);
1371 }
1372
1373 //
1374 ASDCP::Result_t
1375 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1376 {
1377   return InterchangeObject::WriteToBuffer(Buffer);
1378 }
1379
1380 //------------------------------------------------------------------------------------------
1381 // WaveAudioDescriptor
1382
1383 //
1384
1385 WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0)
1386 {
1387   assert(m_Dict);
1388   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1389 }
1390
1391 WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1392 {
1393   assert(m_Dict);
1394   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1395   Copy(rhs);
1396 }
1397
1398
1399 //
1400 ASDCP::Result_t
1401 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1402 {
1403   assert(m_Dict);
1404   Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1405   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1406   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(WaveAudioDescriptor, SequenceOffset));
1407   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1408   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(WaveAudioDescriptor, ChannelAssignment));
1409   return result;
1410 }
1411
1412 //
1413 ASDCP::Result_t
1414 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1415 {
1416   assert(m_Dict);
1417   Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1418   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1419   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(WaveAudioDescriptor, SequenceOffset));
1420   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1421   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(WaveAudioDescriptor, ChannelAssignment));
1422   return result;
1423 }
1424
1425 //
1426 void
1427 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
1428 {
1429   GenericSoundEssenceDescriptor::Copy(rhs);
1430   BlockAlign = rhs.BlockAlign;
1431   SequenceOffset = rhs.SequenceOffset;
1432   AvgBps = rhs.AvgBps;
1433   ChannelAssignment = rhs.ChannelAssignment;
1434 }
1435
1436 //
1437 void
1438 WaveAudioDescriptor::Dump(FILE* stream)
1439 {
1440   char identbuf[IdentBufferLen];
1441   *identbuf = 0;
1442
1443   if ( stream == 0 )
1444     stream = stderr;
1445
1446   GenericSoundEssenceDescriptor::Dump(stream);
1447   fprintf(stream, "  %22s = %d\n",  "BlockAlign", BlockAlign);
1448   fprintf(stream, "  %22s = %d\n",  "SequenceOffset", SequenceOffset);
1449   fprintf(stream, "  %22s = %d\n",  "AvgBps", AvgBps);
1450   fprintf(stream, "  %22s = %s\n",  "ChannelAssignment", ChannelAssignment.EncodeString(identbuf, IdentBufferLen));
1451 }
1452
1453 //
1454 ASDCP::Result_t
1455 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1456 {
1457   return InterchangeObject::InitFromBuffer(p, l);
1458 }
1459
1460 //
1461 ASDCP::Result_t
1462 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1463 {
1464   return InterchangeObject::WriteToBuffer(Buffer);
1465 }
1466
1467 //------------------------------------------------------------------------------------------
1468 // GenericPictureEssenceDescriptor
1469
1470 //
1471
1472 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0), DisplayWidth(0)
1473 {
1474   assert(m_Dict);
1475   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1476 }
1477
1478 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1479 {
1480   assert(m_Dict);
1481   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1482   Copy(rhs);
1483 }
1484
1485
1486 //
1487 ASDCP::Result_t
1488 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1489 {
1490   assert(m_Dict);
1491   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1492   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1493   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1494   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1495   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1496   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1497   if ( ASDCP_SUCCESS(result) ) {
1498     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1499     DisplayWidth.set_has_value( result == RESULT_OK );
1500   }
1501   if ( ASDCP_SUCCESS(result) ) {
1502     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1503     DisplayHeight.set_has_value( result == RESULT_OK );
1504   }
1505   if ( ASDCP_SUCCESS(result) ) {
1506     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, Gamma));
1507     Gamma.set_has_value( result == RESULT_OK );
1508   }
1509   if ( ASDCP_SUCCESS(result) ) {
1510     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1511     FieldDominance.set_has_value( result == RESULT_OK );
1512   }
1513   return result;
1514 }
1515
1516 //
1517 ASDCP::Result_t
1518 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1519 {
1520   assert(m_Dict);
1521   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1522   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1523   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1524   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1525   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1526   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1527   if ( ASDCP_SUCCESS(result)  && ! DisplayWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1528   if ( ASDCP_SUCCESS(result)  && ! DisplayHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1529   if ( ASDCP_SUCCESS(result)  && ! Gamma.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, Gamma));
1530   if ( ASDCP_SUCCESS(result)  && ! FieldDominance.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1531   return result;
1532 }
1533
1534 //
1535 void
1536 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1537 {
1538   FileDescriptor::Copy(rhs);
1539   FrameLayout = rhs.FrameLayout;
1540   StoredWidth = rhs.StoredWidth;
1541   StoredHeight = rhs.StoredHeight;
1542   AspectRatio = rhs.AspectRatio;
1543   PictureEssenceCoding = rhs.PictureEssenceCoding;
1544   DisplayWidth = rhs.DisplayWidth;
1545   DisplayHeight = rhs.DisplayHeight;
1546   Gamma = rhs.Gamma;
1547   FieldDominance = rhs.FieldDominance;
1548 }
1549
1550 //
1551 void
1552 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1553 {
1554   char identbuf[IdentBufferLen];
1555   *identbuf = 0;
1556
1557   if ( stream == 0 )
1558     stream = stderr;
1559
1560   FileDescriptor::Dump(stream);
1561   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1562   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1563   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1564   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1565   fprintf(stream, "  %22s = %s\n",  "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1566   if ( ! DisplayWidth.empty() ) {
1567     fprintf(stream, "  %22s = %d\n",  "DisplayWidth", DisplayWidth.get());
1568   }
1569   if ( ! DisplayHeight.empty() ) {
1570     fprintf(stream, "  %22s = %d\n",  "DisplayHeight", DisplayHeight.get());
1571   }
1572   if ( ! Gamma.empty() ) {
1573     fprintf(stream, "  %22s = %s\n",  "Gamma", Gamma.get().EncodeString(identbuf, IdentBufferLen));
1574   }
1575   if ( ! FieldDominance.empty() ) {
1576     fprintf(stream, "  %22s = %d\n",  "FieldDominance", FieldDominance.get());
1577   }
1578 }
1579
1580 //
1581 ASDCP::Result_t
1582 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1583 {
1584   return InterchangeObject::InitFromBuffer(p, l);
1585 }
1586
1587 //
1588 ASDCP::Result_t
1589 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1590 {
1591   return InterchangeObject::WriteToBuffer(Buffer);
1592 }
1593
1594 //------------------------------------------------------------------------------------------
1595 // RGBAEssenceDescriptor
1596
1597 //
1598
1599 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0)
1600 {
1601   assert(m_Dict);
1602   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1603 }
1604
1605 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1606 {
1607   assert(m_Dict);
1608   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1609   Copy(rhs);
1610 }
1611
1612
1613 //
1614 ASDCP::Result_t
1615 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1616 {
1617   assert(m_Dict);
1618   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1619   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1620   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1621   return result;
1622 }
1623
1624 //
1625 ASDCP::Result_t
1626 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1627 {
1628   assert(m_Dict);
1629   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1630   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1631   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1632   return result;
1633 }
1634
1635 //
1636 void
1637 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
1638 {
1639   GenericPictureEssenceDescriptor::Copy(rhs);
1640   ComponentMaxRef = rhs.ComponentMaxRef;
1641   ComponentMinRef = rhs.ComponentMinRef;
1642 }
1643
1644 //
1645 void
1646 RGBAEssenceDescriptor::Dump(FILE* stream)
1647 {
1648   char identbuf[IdentBufferLen];
1649   *identbuf = 0;
1650
1651   if ( stream == 0 )
1652     stream = stderr;
1653
1654   GenericPictureEssenceDescriptor::Dump(stream);
1655   fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef);
1656   fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef);
1657 }
1658
1659 //
1660 ASDCP::Result_t
1661 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1662 {
1663   return InterchangeObject::InitFromBuffer(p, l);
1664 }
1665
1666 //
1667 ASDCP::Result_t
1668 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1669 {
1670   return InterchangeObject::WriteToBuffer(Buffer);
1671 }
1672
1673 //------------------------------------------------------------------------------------------
1674 // JPEG2000PictureSubDescriptor
1675
1676 //
1677
1678 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0)
1679 {
1680   assert(m_Dict);
1681   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
1682 }
1683
1684 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1685 {
1686   assert(m_Dict);
1687   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
1688   Copy(rhs);
1689 }
1690
1691
1692 //
1693 ASDCP::Result_t
1694 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1695 {
1696   assert(m_Dict);
1697   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1698   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1699   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1700   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1701   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1702   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1703   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1704   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1705   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1706   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1707   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
1708   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1709   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1710   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1711   return result;
1712 }
1713
1714 //
1715 ASDCP::Result_t
1716 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1717 {
1718   assert(m_Dict);
1719   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1720   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1721   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1722   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1723   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1724   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1725   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1726   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1727   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1728   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1729   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
1730   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1731   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1732   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1733   return result;
1734 }
1735
1736 //
1737 void
1738 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
1739 {
1740   InterchangeObject::Copy(rhs);
1741   Rsize = rhs.Rsize;
1742   Xsize = rhs.Xsize;
1743   Ysize = rhs.Ysize;
1744   XOsize = rhs.XOsize;
1745   YOsize = rhs.YOsize;
1746   XTsize = rhs.XTsize;
1747   YTsize = rhs.YTsize;
1748   XTOsize = rhs.XTOsize;
1749   YTOsize = rhs.YTOsize;
1750   Csize = rhs.Csize;
1751   PictureComponentSizing = rhs.PictureComponentSizing;
1752   CodingStyleDefault = rhs.CodingStyleDefault;
1753   QuantizationDefault = rhs.QuantizationDefault;
1754 }
1755
1756 //
1757 void
1758 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
1759 {
1760   char identbuf[IdentBufferLen];
1761   *identbuf = 0;
1762
1763   if ( stream == 0 )
1764     stream = stderr;
1765
1766   InterchangeObject::Dump(stream);
1767   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
1768   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
1769   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
1770   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
1771   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
1772   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
1773   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
1774   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
1775   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
1776   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
1777   fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.EncodeString(identbuf, IdentBufferLen));
1778   fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.EncodeString(identbuf, IdentBufferLen));
1779   fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.EncodeString(identbuf, IdentBufferLen));
1780 }
1781
1782 //
1783 ASDCP::Result_t
1784 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1785 {
1786   return InterchangeObject::InitFromBuffer(p, l);
1787 }
1788
1789 //
1790 ASDCP::Result_t
1791 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1792 {
1793   return InterchangeObject::WriteToBuffer(Buffer);
1794 }
1795
1796 //------------------------------------------------------------------------------------------
1797 // CDCIEssenceDescriptor
1798
1799 //
1800
1801 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0)
1802 {
1803   assert(m_Dict);
1804   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
1805 }
1806
1807 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1808 {
1809   assert(m_Dict);
1810   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
1811   Copy(rhs);
1812 }
1813
1814
1815 //
1816 ASDCP::Result_t
1817 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1818 {
1819   assert(m_Dict);
1820   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1821   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1822   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1823   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1824   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
1825   return result;
1826 }
1827
1828 //
1829 ASDCP::Result_t
1830 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1831 {
1832   assert(m_Dict);
1833   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1834   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1835   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1836   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1837   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ColorSiting));
1838   return result;
1839 }
1840
1841 //
1842 void
1843 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
1844 {
1845   GenericPictureEssenceDescriptor::Copy(rhs);
1846   ComponentDepth = rhs.ComponentDepth;
1847   HorizontalSubsampling = rhs.HorizontalSubsampling;
1848   VerticalSubsampling = rhs.VerticalSubsampling;
1849   ColorSiting = rhs.ColorSiting;
1850 }
1851
1852 //
1853 void
1854 CDCIEssenceDescriptor::Dump(FILE* stream)
1855 {
1856   char identbuf[IdentBufferLen];
1857   *identbuf = 0;
1858
1859   if ( stream == 0 )
1860     stream = stderr;
1861
1862   GenericPictureEssenceDescriptor::Dump(stream);
1863   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
1864   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
1865   fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling);
1866   fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting);
1867 }
1868
1869 //
1870 ASDCP::Result_t
1871 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1872 {
1873   return InterchangeObject::InitFromBuffer(p, l);
1874 }
1875
1876 //
1877 ASDCP::Result_t
1878 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1879 {
1880   return InterchangeObject::WriteToBuffer(Buffer);
1881 }
1882
1883 //------------------------------------------------------------------------------------------
1884 // MPEG2VideoDescriptor
1885
1886 //
1887
1888 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0)
1889 {
1890   assert(m_Dict);
1891   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
1892 }
1893
1894 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1895 {
1896   assert(m_Dict);
1897   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
1898   Copy(rhs);
1899 }
1900
1901
1902 //
1903 ASDCP::Result_t
1904 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1905 {
1906   assert(m_Dict);
1907   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
1908   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, CodedContentType));
1909   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, LowDelay));
1910   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor, BitRate));
1911   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1912   return result;
1913 }
1914
1915 //
1916 ASDCP::Result_t
1917 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1918 {
1919   assert(m_Dict);
1920   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
1921   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, CodedContentType));
1922   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, LowDelay));
1923   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, BitRate));
1924   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1925   return result;
1926 }
1927
1928 //
1929 void
1930 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
1931 {
1932   CDCIEssenceDescriptor::Copy(rhs);
1933   CodedContentType = rhs.CodedContentType;
1934   LowDelay = rhs.LowDelay;
1935   BitRate = rhs.BitRate;
1936   ProfileAndLevel = rhs.ProfileAndLevel;
1937 }
1938
1939 //
1940 void
1941 MPEG2VideoDescriptor::Dump(FILE* stream)
1942 {
1943   char identbuf[IdentBufferLen];
1944   *identbuf = 0;
1945
1946   if ( stream == 0 )
1947     stream = stderr;
1948
1949   CDCIEssenceDescriptor::Dump(stream);
1950   fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType);
1951   fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay);
1952   fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate);
1953   fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel);
1954 }
1955
1956 //
1957 ASDCP::Result_t
1958 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1959 {
1960   return InterchangeObject::InitFromBuffer(p, l);
1961 }
1962
1963 //
1964 ASDCP::Result_t
1965 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1966 {
1967   return InterchangeObject::WriteToBuffer(Buffer);
1968 }
1969
1970 //------------------------------------------------------------------------------------------
1971 // DMSegment
1972
1973 //
1974
1975 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
1976 {
1977   assert(m_Dict);
1978   m_UL = m_Dict->ul(MDD_DMSegment);
1979 }
1980
1981 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1982 {
1983   assert(m_Dict);
1984   m_UL = m_Dict->ul(MDD_DMSegment);
1985   Copy(rhs);
1986 }
1987
1988
1989 //
1990 ASDCP::Result_t
1991 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
1992 {
1993   assert(m_Dict);
1994   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1995   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
1996   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
1997   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
1998   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
1999   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2000   return result;
2001 }
2002
2003 //
2004 ASDCP::Result_t
2005 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2006 {
2007   assert(m_Dict);
2008   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2009   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2010   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
2011   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
2012   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
2013   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2014   return result;
2015 }
2016
2017 //
2018 void
2019 DMSegment::Copy(const DMSegment& rhs)
2020 {
2021   InterchangeObject::Copy(rhs);
2022   DataDefinition = rhs.DataDefinition;
2023   EventStartPosition = rhs.EventStartPosition;
2024   Duration = rhs.Duration;
2025   EventComment = rhs.EventComment;
2026   DMFramework = rhs.DMFramework;
2027 }
2028
2029 //
2030 void
2031 DMSegment::Dump(FILE* stream)
2032 {
2033   char identbuf[IdentBufferLen];
2034   *identbuf = 0;
2035
2036   if ( stream == 0 )
2037     stream = stderr;
2038
2039   InterchangeObject::Dump(stream);
2040   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2041   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
2042   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
2043   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
2044   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2045 }
2046
2047 //
2048 ASDCP::Result_t
2049 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2050 {
2051   return InterchangeObject::InitFromBuffer(p, l);
2052 }
2053
2054 //
2055 ASDCP::Result_t
2056 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2057 {
2058   return InterchangeObject::WriteToBuffer(Buffer);
2059 }
2060
2061 //------------------------------------------------------------------------------------------
2062 // CryptographicFramework
2063
2064 //
2065
2066 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2067 {
2068   assert(m_Dict);
2069   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2070 }
2071
2072 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2073 {
2074   assert(m_Dict);
2075   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2076   Copy(rhs);
2077 }
2078
2079
2080 //
2081 ASDCP::Result_t
2082 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2083 {
2084   assert(m_Dict);
2085   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2086   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2087   return result;
2088 }
2089
2090 //
2091 ASDCP::Result_t
2092 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2093 {
2094   assert(m_Dict);
2095   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2096   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2097   return result;
2098 }
2099
2100 //
2101 void
2102 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2103 {
2104   InterchangeObject::Copy(rhs);
2105   ContextSR = rhs.ContextSR;
2106 }
2107
2108 //
2109 void
2110 CryptographicFramework::Dump(FILE* stream)
2111 {
2112   char identbuf[IdentBufferLen];
2113   *identbuf = 0;
2114
2115   if ( stream == 0 )
2116     stream = stderr;
2117
2118   InterchangeObject::Dump(stream);
2119   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2120 }
2121
2122 //
2123 ASDCP::Result_t
2124 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2125 {
2126   return InterchangeObject::InitFromBuffer(p, l);
2127 }
2128
2129 //
2130 ASDCP::Result_t
2131 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2132 {
2133   return InterchangeObject::WriteToBuffer(Buffer);
2134 }
2135
2136 //------------------------------------------------------------------------------------------
2137 // CryptographicContext
2138
2139 //
2140
2141 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2142 {
2143   assert(m_Dict);
2144   m_UL = m_Dict->ul(MDD_CryptographicContext);
2145 }
2146
2147 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2148 {
2149   assert(m_Dict);
2150   m_UL = m_Dict->ul(MDD_CryptographicContext);
2151   Copy(rhs);
2152 }
2153
2154
2155 //
2156 ASDCP::Result_t
2157 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2158 {
2159   assert(m_Dict);
2160   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2161   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2162   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2163   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2164   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2165   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2166   return result;
2167 }
2168
2169 //
2170 ASDCP::Result_t
2171 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2172 {
2173   assert(m_Dict);
2174   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2175   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2176   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2177   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2178   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2179   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2180   return result;
2181 }
2182
2183 //
2184 void
2185 CryptographicContext::Copy(const CryptographicContext& rhs)
2186 {
2187   InterchangeObject::Copy(rhs);
2188   ContextID = rhs.ContextID;
2189   SourceEssenceContainer = rhs.SourceEssenceContainer;
2190   CipherAlgorithm = rhs.CipherAlgorithm;
2191   MICAlgorithm = rhs.MICAlgorithm;
2192   CryptographicKeyID = rhs.CryptographicKeyID;
2193 }
2194
2195 //
2196 void
2197 CryptographicContext::Dump(FILE* stream)
2198 {
2199   char identbuf[IdentBufferLen];
2200   *identbuf = 0;
2201
2202   if ( stream == 0 )
2203     stream = stderr;
2204
2205   InterchangeObject::Dump(stream);
2206   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2207   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2208   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2209   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2210   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2211 }
2212
2213 //
2214 ASDCP::Result_t
2215 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2216 {
2217   return InterchangeObject::InitFromBuffer(p, l);
2218 }
2219
2220 //
2221 ASDCP::Result_t
2222 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2223 {
2224   return InterchangeObject::WriteToBuffer(Buffer);
2225 }
2226
2227 //------------------------------------------------------------------------------------------
2228 // GenericDataEssenceDescriptor
2229
2230 //
2231
2232 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
2233 {
2234   assert(m_Dict);
2235   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2236 }
2237
2238 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2239 {
2240   assert(m_Dict);
2241   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2242   Copy(rhs);
2243 }
2244
2245
2246 //
2247 ASDCP::Result_t
2248 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2249 {
2250   assert(m_Dict);
2251   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
2252   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2253   return result;
2254 }
2255
2256 //
2257 ASDCP::Result_t
2258 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2259 {
2260   assert(m_Dict);
2261   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
2262   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2263   return result;
2264 }
2265
2266 //
2267 void
2268 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
2269 {
2270   FileDescriptor::Copy(rhs);
2271   DataEssenceCoding = rhs.DataEssenceCoding;
2272 }
2273
2274 //
2275 void
2276 GenericDataEssenceDescriptor::Dump(FILE* stream)
2277 {
2278   char identbuf[IdentBufferLen];
2279   *identbuf = 0;
2280
2281   if ( stream == 0 )
2282     stream = stderr;
2283
2284   FileDescriptor::Dump(stream);
2285   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
2286 }
2287
2288 //
2289 ASDCP::Result_t
2290 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2291 {
2292   return InterchangeObject::InitFromBuffer(p, l);
2293 }
2294
2295 //
2296 ASDCP::Result_t
2297 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2298 {
2299   return InterchangeObject::WriteToBuffer(Buffer);
2300 }
2301
2302 //------------------------------------------------------------------------------------------
2303 // TimedTextDescriptor
2304
2305 //
2306
2307 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
2308 {
2309   assert(m_Dict);
2310   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2311 }
2312
2313 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2314 {
2315   assert(m_Dict);
2316   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2317   Copy(rhs);
2318 }
2319
2320
2321 //
2322 ASDCP::Result_t
2323 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2324 {
2325   assert(m_Dict);
2326   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
2327   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
2328   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
2329   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
2330   return result;
2331 }
2332
2333 //
2334 ASDCP::Result_t
2335 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2336 {
2337   assert(m_Dict);
2338   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
2339   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
2340   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
2341   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
2342   return result;
2343 }
2344
2345 //
2346 void
2347 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
2348 {
2349   GenericDataEssenceDescriptor::Copy(rhs);
2350   ResourceID = rhs.ResourceID;
2351   UCSEncoding = rhs.UCSEncoding;
2352   NamespaceURI = rhs.NamespaceURI;
2353 }
2354
2355 //
2356 void
2357 TimedTextDescriptor::Dump(FILE* stream)
2358 {
2359   char identbuf[IdentBufferLen];
2360   *identbuf = 0;
2361
2362   if ( stream == 0 )
2363     stream = stderr;
2364
2365   GenericDataEssenceDescriptor::Dump(stream);
2366   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
2367   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
2368   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
2369 }
2370
2371 //
2372 ASDCP::Result_t
2373 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2374 {
2375   return InterchangeObject::InitFromBuffer(p, l);
2376 }
2377
2378 //
2379 ASDCP::Result_t
2380 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2381 {
2382   return InterchangeObject::WriteToBuffer(Buffer);
2383 }
2384
2385 //------------------------------------------------------------------------------------------
2386 // TimedTextResourceSubDescriptor
2387
2388 //
2389
2390 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
2391 {
2392   assert(m_Dict);
2393   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2394 }
2395
2396 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2397 {
2398   assert(m_Dict);
2399   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2400   Copy(rhs);
2401 }
2402
2403
2404 //
2405 ASDCP::Result_t
2406 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2407 {
2408   assert(m_Dict);
2409   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2410   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2411   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2412   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2413   return result;
2414 }
2415
2416 //
2417 ASDCP::Result_t
2418 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2419 {
2420   assert(m_Dict);
2421   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2422   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2423   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2424   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2425   return result;
2426 }
2427
2428 //
2429 void
2430 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
2431 {
2432   InterchangeObject::Copy(rhs);
2433   AncillaryResourceID = rhs.AncillaryResourceID;
2434   MIMEMediaType = rhs.MIMEMediaType;
2435   EssenceStreamID = rhs.EssenceStreamID;
2436 }
2437
2438 //
2439 void
2440 TimedTextResourceSubDescriptor::Dump(FILE* stream)
2441 {
2442   char identbuf[IdentBufferLen];
2443   *identbuf = 0;
2444
2445   if ( stream == 0 )
2446     stream = stderr;
2447
2448   InterchangeObject::Dump(stream);
2449   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
2450   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
2451   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
2452 }
2453
2454 //
2455 ASDCP::Result_t
2456 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2457 {
2458   return InterchangeObject::InitFromBuffer(p, l);
2459 }
2460
2461 //
2462 ASDCP::Result_t
2463 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2464 {
2465   return InterchangeObject::WriteToBuffer(Buffer);
2466 }
2467
2468 //------------------------------------------------------------------------------------------
2469 // StereoscopicPictureSubDescriptor
2470
2471 //
2472
2473 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2474 {
2475   assert(m_Dict);
2476   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2477 }
2478
2479 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2480 {
2481   assert(m_Dict);
2482   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2483   Copy(rhs);
2484 }
2485
2486
2487 //
2488 ASDCP::Result_t
2489 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2490 {
2491   assert(m_Dict);
2492   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2493   return result;
2494 }
2495
2496 //
2497 ASDCP::Result_t
2498 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2499 {
2500   assert(m_Dict);
2501   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2502   return result;
2503 }
2504
2505 //
2506 void
2507 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
2508 {
2509   InterchangeObject::Copy(rhs);
2510 }
2511
2512 //
2513 void
2514 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
2515 {
2516   char identbuf[IdentBufferLen];
2517   *identbuf = 0;
2518
2519   if ( stream == 0 )
2520     stream = stderr;
2521
2522   InterchangeObject::Dump(stream);
2523 }
2524
2525 //
2526 ASDCP::Result_t
2527 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2528 {
2529   return InterchangeObject::InitFromBuffer(p, l);
2530 }
2531
2532 //
2533 ASDCP::Result_t
2534 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2535 {
2536   return InterchangeObject::WriteToBuffer(Buffer);
2537 }
2538
2539 //------------------------------------------------------------------------------------------
2540 // NetworkLocator
2541
2542 //
2543
2544 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2545 {
2546   assert(m_Dict);
2547   m_UL = m_Dict->ul(MDD_NetworkLocator);
2548 }
2549
2550 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2551 {
2552   assert(m_Dict);
2553   m_UL = m_Dict->ul(MDD_NetworkLocator);
2554   Copy(rhs);
2555 }
2556
2557
2558 //
2559 ASDCP::Result_t
2560 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
2561 {
2562   assert(m_Dict);
2563   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2564   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
2565   return result;
2566 }
2567
2568 //
2569 ASDCP::Result_t
2570 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
2571 {
2572   assert(m_Dict);
2573   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2574   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
2575   return result;
2576 }
2577
2578 //
2579 void
2580 NetworkLocator::Copy(const NetworkLocator& rhs)
2581 {
2582   InterchangeObject::Copy(rhs);
2583   URLString = rhs.URLString;
2584 }
2585
2586 //
2587 void
2588 NetworkLocator::Dump(FILE* stream)
2589 {
2590   char identbuf[IdentBufferLen];
2591   *identbuf = 0;
2592
2593   if ( stream == 0 )
2594     stream = stderr;
2595
2596   InterchangeObject::Dump(stream);
2597   fprintf(stream, "  %22s = %s\n",  "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
2598 }
2599
2600 //
2601 ASDCP::Result_t
2602 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
2603 {
2604   return InterchangeObject::InitFromBuffer(p, l);
2605 }
2606
2607 //
2608 ASDCP::Result_t
2609 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2610 {
2611   return InterchangeObject::WriteToBuffer(Buffer);
2612 }
2613
2614 //------------------------------------------------------------------------------------------
2615 // MCALabelSubDescriptor
2616
2617 //
2618
2619 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), MCAChannelID(0)
2620 {
2621   assert(m_Dict);
2622   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
2623 }
2624
2625 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2626 {
2627   assert(m_Dict);
2628   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
2629   Copy(rhs);
2630 }
2631
2632
2633 //
2634 ASDCP::Result_t
2635 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2636 {
2637   assert(m_Dict);
2638   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2639   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
2640   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
2641   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
2642   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagName));
2643   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MCALabelSubDescriptor, MCAChannelID));
2644   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage));
2645   return result;
2646 }
2647
2648 //
2649 ASDCP::Result_t
2650 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2651 {
2652   assert(m_Dict);
2653   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2654   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
2655   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
2656   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
2657   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagName));
2658   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCAChannelID));
2659   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage));
2660   return result;
2661 }
2662
2663 //
2664 void
2665 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
2666 {
2667   InterchangeObject::Copy(rhs);
2668   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
2669   MCALinkID = rhs.MCALinkID;
2670   MCATagSymbol = rhs.MCATagSymbol;
2671   MCATagName = rhs.MCATagName;
2672   MCAChannelID = rhs.MCAChannelID;
2673   RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
2674 }
2675
2676 //
2677 void
2678 MCALabelSubDescriptor::Dump(FILE* stream)
2679 {
2680   char identbuf[IdentBufferLen];
2681   *identbuf = 0;
2682
2683   if ( stream == 0 )
2684     stream = stderr;
2685
2686   InterchangeObject::Dump(stream);
2687   fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
2688   fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
2689   fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
2690   fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.EncodeString(identbuf, IdentBufferLen));
2691   fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID);
2692   fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.EncodeString(identbuf, IdentBufferLen));
2693 }
2694
2695 //
2696 ASDCP::Result_t
2697 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2698 {
2699   return InterchangeObject::InitFromBuffer(p, l);
2700 }
2701
2702 //
2703 ASDCP::Result_t
2704 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2705 {
2706   return InterchangeObject::WriteToBuffer(Buffer);
2707 }
2708
2709 //------------------------------------------------------------------------------------------
2710 // AudioChannelLabelSubDescriptor
2711
2712 //
2713
2714 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
2715 {
2716   assert(m_Dict);
2717   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
2718 }
2719
2720 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2721 {
2722   assert(m_Dict);
2723   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
2724   Copy(rhs);
2725 }
2726
2727
2728 //
2729 ASDCP::Result_t
2730 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2731 {
2732   assert(m_Dict);
2733   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
2734   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
2735   return result;
2736 }
2737
2738 //
2739 ASDCP::Result_t
2740 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2741 {
2742   assert(m_Dict);
2743   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
2744   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
2745   return result;
2746 }
2747
2748 //
2749 void
2750 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
2751 {
2752   MCALabelSubDescriptor::Copy(rhs);
2753   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
2754 }
2755
2756 //
2757 void
2758 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
2759 {
2760   char identbuf[IdentBufferLen];
2761   *identbuf = 0;
2762
2763   if ( stream == 0 )
2764     stream = stderr;
2765
2766   MCALabelSubDescriptor::Dump(stream);
2767   fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.EncodeString(identbuf, IdentBufferLen));
2768 }
2769
2770 //
2771 ASDCP::Result_t
2772 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2773 {
2774   return InterchangeObject::InitFromBuffer(p, l);
2775 }
2776
2777 //
2778 ASDCP::Result_t
2779 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2780 {
2781   return InterchangeObject::WriteToBuffer(Buffer);
2782 }
2783
2784 //------------------------------------------------------------------------------------------
2785 // SoundfieldGroupLabelSubDescriptor
2786
2787 //
2788
2789 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
2790 {
2791   assert(m_Dict);
2792   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
2793 }
2794
2795 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2796 {
2797   assert(m_Dict);
2798   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
2799   Copy(rhs);
2800 }
2801
2802
2803 //
2804 ASDCP::Result_t
2805 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2806 {
2807   assert(m_Dict);
2808   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
2809   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
2810   return result;
2811 }
2812
2813 //
2814 ASDCP::Result_t
2815 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2816 {
2817   assert(m_Dict);
2818   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
2819   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
2820   return result;
2821 }
2822
2823 //
2824 void
2825 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
2826 {
2827   MCALabelSubDescriptor::Copy(rhs);
2828   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
2829 }
2830
2831 //
2832 void
2833 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
2834 {
2835   char identbuf[IdentBufferLen];
2836   *identbuf = 0;
2837
2838   if ( stream == 0 )
2839     stream = stderr;
2840
2841   MCALabelSubDescriptor::Dump(stream);
2842   fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
2843   GroupOfSoundfieldGroupsLinkID.Dump(stream);
2844 }
2845
2846 //
2847 ASDCP::Result_t
2848 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2849 {
2850   return InterchangeObject::InitFromBuffer(p, l);
2851 }
2852
2853 //
2854 ASDCP::Result_t
2855 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2856 {
2857   return InterchangeObject::WriteToBuffer(Buffer);
2858 }
2859
2860 //------------------------------------------------------------------------------------------
2861 // GroupOfSoundfieldGroupsLabelSubDescriptor
2862
2863 //
2864
2865 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
2866 {
2867   assert(m_Dict);
2868   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
2869 }
2870
2871 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2872 {
2873   assert(m_Dict);
2874   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
2875   Copy(rhs);
2876 }
2877
2878
2879 //
2880 ASDCP::Result_t
2881 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2882 {
2883   assert(m_Dict);
2884   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
2885   return result;
2886 }
2887
2888 //
2889 ASDCP::Result_t
2890 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2891 {
2892   assert(m_Dict);
2893   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
2894   return result;
2895 }
2896
2897 //
2898 void
2899 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
2900 {
2901   MCALabelSubDescriptor::Copy(rhs);
2902 }
2903
2904 //
2905 void
2906 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
2907 {
2908   char identbuf[IdentBufferLen];
2909   *identbuf = 0;
2910
2911   if ( stream == 0 )
2912     stream = stderr;
2913
2914   MCALabelSubDescriptor::Dump(stream);
2915 }
2916
2917 //
2918 ASDCP::Result_t
2919 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2920 {
2921   return InterchangeObject::InitFromBuffer(p, l);
2922 }
2923
2924 //
2925 ASDCP::Result_t
2926 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2927 {
2928   return InterchangeObject::WriteToBuffer(Buffer);
2929 }
2930
2931 //------------------------------------------------------------------------------------------
2932 // DCDataDescriptor
2933
2934 //
2935
2936 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
2937 {
2938   assert(m_Dict);
2939   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
2940 }
2941
2942 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2943 {
2944   assert(m_Dict);
2945   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
2946   Copy(rhs);
2947 }
2948
2949
2950 //
2951 ASDCP::Result_t
2952 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2953 {
2954   assert(m_Dict);
2955   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
2956   return result;
2957 }
2958
2959 //
2960 ASDCP::Result_t
2961 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2962 {
2963   assert(m_Dict);
2964   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
2965   return result;
2966 }
2967
2968 //
2969 void
2970 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
2971 {
2972   GenericDataEssenceDescriptor::Copy(rhs);
2973 }
2974
2975 //
2976 void
2977 DCDataDescriptor::Dump(FILE* stream)
2978 {
2979   char identbuf[IdentBufferLen];
2980   *identbuf = 0;
2981
2982   if ( stream == 0 )
2983     stream = stderr;
2984
2985   GenericDataEssenceDescriptor::Dump(stream);
2986 }
2987
2988 //
2989 ASDCP::Result_t
2990 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2991 {
2992   return InterchangeObject::InitFromBuffer(p, l);
2993 }
2994
2995 //
2996 ASDCP::Result_t
2997 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2998 {
2999   return InterchangeObject::WriteToBuffer(Buffer);
3000 }
3001
3002 //------------------------------------------------------------------------------------------
3003 // DolbyAtmosSubDescriptor
3004
3005 //
3006
3007 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
3008 {
3009   assert(m_Dict);
3010   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3011 }
3012
3013 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3014 {
3015   assert(m_Dict);
3016   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3017   Copy(rhs);
3018 }
3019
3020
3021 //
3022 ASDCP::Result_t
3023 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3024 {
3025   assert(m_Dict);
3026   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3027   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3028   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3029   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3030   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3031   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3032   return result;
3033 }
3034
3035 //
3036 ASDCP::Result_t
3037 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3038 {
3039   assert(m_Dict);
3040   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3041   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3042   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3043   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3044   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3045   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3046   return result;
3047 }
3048
3049 //
3050 void
3051 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
3052 {
3053   InterchangeObject::Copy(rhs);
3054   AtmosID = rhs.AtmosID;
3055   FirstFrame = rhs.FirstFrame;
3056   MaxChannelCount = rhs.MaxChannelCount;
3057   MaxObjectCount = rhs.MaxObjectCount;
3058   AtmosVersion = rhs.AtmosVersion;
3059 }
3060
3061 //
3062 void
3063 DolbyAtmosSubDescriptor::Dump(FILE* stream)
3064 {
3065   char identbuf[IdentBufferLen];
3066   *identbuf = 0;
3067
3068   if ( stream == 0 )
3069     stream = stderr;
3070
3071   InterchangeObject::Dump(stream);
3072   fprintf(stream, "  %22s = %s\n",  "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
3073   fprintf(stream, "  %22s = %d\n",  "FirstFrame", FirstFrame);
3074   fprintf(stream, "  %22s = %d\n",  "MaxChannelCount", MaxChannelCount);
3075   fprintf(stream, "  %22s = %d\n",  "MaxObjectCount", MaxObjectCount);
3076   fprintf(stream, "  %22s = %d\n",  "AtmosVersion", AtmosVersion);
3077 }
3078
3079 //
3080 ASDCP::Result_t
3081 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3082 {
3083   return InterchangeObject::InitFromBuffer(p, l);
3084 }
3085
3086 //
3087 ASDCP::Result_t
3088 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3089 {
3090   return InterchangeObject::WriteToBuffer(Buffer);
3091 }
3092
3093 //
3094 // end Metadata.cpp
3095 //