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* ContainerConstraintSubDescriptor_Factory(const Dictionary*& Dict) { return new ContainerConstraintSubDescriptor(Dict); }
  72 static InterchangeObject* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); }
  73 static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); }
  74 static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); }
  75 static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
  76 static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
  77 static InterchangeObject* DCDataDescriptor_Factory(const Dictionary*& Dict) { return new DCDataDescriptor(Dict); }
  78 static InterchangeObject* PrivateDCDataDescriptor_Factory(const Dictionary*& Dict) { return new PrivateDCDataDescriptor(Dict); }
  79 static InterchangeObject* DolbyAtmosSubDescriptor_Factory(const Dictionary*& Dict) { return new DolbyAtmosSubDescriptor(Dict); }
  80 static InterchangeObject* PHDRMetadataTrackSubDescriptor_Factory(const Dictionary*& Dict) { return new PHDRMetadataTrackSubDescriptor(Dict); }
  81
  82
  83 void
  84 ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
  85 {
  86   assert(Dict);
  87   SetObjectFactory(Dict->ul(MDD_Preface), Preface_Factory);
  88   SetObjectFactory(Dict->ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
  89
  90   SetObjectFactory(Dict->ul(MDD_Identification), Identification_Factory);
  91   SetObjectFactory(Dict->ul(MDD_ContentStorage), ContentStorage_Factory);
  92   SetObjectFactory(Dict->ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
  93   SetObjectFactory(Dict->ul(MDD_MaterialPackage), MaterialPackage_Factory);
  94   SetObjectFactory(Dict->ul(MDD_SourcePackage), SourcePackage_Factory);
  95   SetObjectFactory(Dict->ul(MDD_StaticTrack), StaticTrack_Factory);
  96   SetObjectFactory(Dict->ul(MDD_Track), Track_Factory);
  97   SetObjectFactory(Dict->ul(MDD_Sequence), Sequence_Factory);
  98   SetObjectFactory(Dict->ul(MDD_SourceClip), SourceClip_Factory);
  99   SetObjectFactory(Dict->ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
 100   SetObjectFactory(Dict->ul(MDD_FileDescriptor), FileDescriptor_Factory);
 101   SetObjectFactory(Dict->ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
 102   SetObjectFactory(Dict->ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
 103   SetObjectFactory(Dict->ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
 104   SetObjectFactory(Dict->ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
 105   SetObjectFactory(Dict->ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
 106   SetObjectFactory(Dict->ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
 107   SetObjectFactory(Dict->ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
 108   SetObjectFactory(Dict->ul(MDD_DMSegment), DMSegment_Factory);
 109   SetObjectFactory(Dict->ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
 110   SetObjectFactory(Dict->ul(MDD_CryptographicContext), CryptographicContext_Factory);
 111   SetObjectFactory(Dict->ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
 112   SetObjectFactory(Dict->ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
 113   SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
 114   SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
 115   SetObjectFactory(Dict->ul(MDD_ContainerConstraintSubDescriptor), ContainerConstraintSubDescriptor_Factory);
 116   SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory);
 117   SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory);
 118   SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory);
 119   SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
 120   SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
 121   SetObjectFactory(Dict->ul(MDD_DCDataDescriptor), DCDataDescriptor_Factory);
 122   SetObjectFactory(Dict->ul(MDD_PrivateDCDataDescriptor), PrivateDCDataDescriptor_Factory);
 123   SetObjectFactory(Dict->ul(MDD_DolbyAtmosSubDescriptor), DolbyAtmosSubDescriptor_Factory);
 124   SetObjectFactory(Dict->ul(MDD_PHDRMetadataTrackSubDescriptor), PHDRMetadataTrackSubDescriptor_Factory);
 125 }
 126
 127 //------------------------------------------------------------------------------------------
 128 // KLV Sets
 129
 130
 131
 132 //------------------------------------------------------------------------------------------
 133 // Identification
 134
 135 //
 136
 137 Identification::Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
 138 {
 139   assert(m_Dict);
 140   m_UL = m_Dict->ul(MDD_Identification);
 141 }
 142
 143 Identification::Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 144 {
 145   assert(m_Dict);
 146   m_UL = m_Dict->ul(MDD_Identification);
 147   Copy(rhs);
 148 }
 149
 150
 151 //
 152 ASDCP::Result_t
 153 Identification::InitFromTLVSet(TLVReader& TLVSet)
 154 {
 155   assert(m_Dict);
 156   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 157   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
 158   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
 159   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
 160   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductVersion));
 161   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
 162   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
 163   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
 164   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ToolkitVersion));
 165   if ( ASDCP_SUCCESS(result) ) {
 166     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(Identification, Platform));
 167     Platform.set_has_value( result == RESULT_OK );
 168   }
 169   return result;
 170 }
 171
 172 //
 173 ASDCP::Result_t
 174 Identification::WriteToTLVSet(TLVWriter& TLVSet)
 175 {
 176   assert(m_Dict);
 177   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 178   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ThisGenerationUID));
 179   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, CompanyName));
 180   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductName));
 181   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductVersion));
 182   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, VersionString));
 183   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductUID));
 184   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ModificationDate));
 185   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ToolkitVersion));
 186   if ( ASDCP_SUCCESS(result)  && ! Platform.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(Identification, Platform));
 187   return result;
 188 }
 189
 190 //
 191 void
 192 Identification::Copy(const Identification& rhs)
 193 {
 194   InterchangeObject::Copy(rhs);
 195   ThisGenerationUID = rhs.ThisGenerationUID;
 196   CompanyName = rhs.CompanyName;
 197   ProductName = rhs.ProductName;
 198   ProductVersion = rhs.ProductVersion;
 199   VersionString = rhs.VersionString;
 200   ProductUID = rhs.ProductUID;
 201   ModificationDate = rhs.ModificationDate;
 202   ToolkitVersion = rhs.ToolkitVersion;
 203   Platform = rhs.Platform;
 204 }
 205
 206 //
 207 void
 208 Identification::Dump(FILE* stream)
 209 {
 210   char identbuf[IdentBufferLen];
 211   *identbuf = 0;
 212
 213   if ( stream == 0 )
 214     stream = stderr;
 215
 216   InterchangeObject::Dump(stream);
 217   fprintf(stream, "  %22s = %s\n",  "ThisGenerationUID", ThisGenerationUID.EncodeString(identbuf, IdentBufferLen));
 218   fprintf(stream, "  %22s = %s\n",  "CompanyName", CompanyName.EncodeString(identbuf, IdentBufferLen));
 219   fprintf(stream, "  %22s = %s\n",  "ProductName", ProductName.EncodeString(identbuf, IdentBufferLen));
 220   fprintf(stream, "  %22s = %s\n",  "ProductVersion", ProductVersion.EncodeString(identbuf, IdentBufferLen));
 221   fprintf(stream, "  %22s = %s\n",  "VersionString", VersionString.EncodeString(identbuf, IdentBufferLen));
 222   fprintf(stream, "  %22s = %s\n",  "ProductUID", ProductUID.EncodeString(identbuf, IdentBufferLen));
 223   fprintf(stream, "  %22s = %s\n",  "ModificationDate", ModificationDate.EncodeString(identbuf, IdentBufferLen));
 224   fprintf(stream, "  %22s = %s\n",  "ToolkitVersion", ToolkitVersion.EncodeString(identbuf, IdentBufferLen));
 225   if ( ! Platform.empty() ) {
 226     fprintf(stream, "  %22s = %s\n",  "Platform", Platform.get().EncodeString(identbuf, IdentBufferLen));
 227   }
 228 }
 229
 230 //
 231 ASDCP::Result_t
 232 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 233 {
 234   return InterchangeObject::InitFromBuffer(p, l);
 235 }
 236
 237 //
 238 ASDCP::Result_t
 239 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 240 {
 241   return InterchangeObject::WriteToBuffer(Buffer);
 242 }
 243
 244 //------------------------------------------------------------------------------------------
 245 // ContentStorage
 246
 247 //
 248
 249 ContentStorage::ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
 250 {
 251   assert(m_Dict);
 252   m_UL = m_Dict->ul(MDD_ContentStorage);
 253 }
 254
 255 ContentStorage::ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 256 {
 257   assert(m_Dict);
 258   m_UL = m_Dict->ul(MDD_ContentStorage);
 259   Copy(rhs);
 260 }
 261
 262
 263 //
 264 ASDCP::Result_t
 265 ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
 266 {
 267   assert(m_Dict);
 268   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 269   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
 270   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
 271   return result;
 272 }
 273
 274 //
 275 ASDCP::Result_t
 276 ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
 277 {
 278   assert(m_Dict);
 279   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 280   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, Packages));
 281   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, EssenceContainerData));
 282   return result;
 283 }
 284
 285 //
 286 void
 287 ContentStorage::Copy(const ContentStorage& rhs)
 288 {
 289   InterchangeObject::Copy(rhs);
 290   Packages = rhs.Packages;
 291   EssenceContainerData = rhs.EssenceContainerData;
 292 }
 293
 294 //
 295 void
 296 ContentStorage::Dump(FILE* stream)
 297 {
 298   char identbuf[IdentBufferLen];
 299   *identbuf = 0;
 300
 301   if ( stream == 0 )
 302     stream = stderr;
 303
 304   InterchangeObject::Dump(stream);
 305   fprintf(stream, "  %22s:\n",  "Packages");
 306   Packages.Dump(stream);
 307   fprintf(stream, "  %22s:\n",  "EssenceContainerData");
 308   EssenceContainerData.Dump(stream);
 309 }
 310
 311 //
 312 ASDCP::Result_t
 313 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 314 {
 315   return InterchangeObject::InitFromBuffer(p, l);
 316 }
 317
 318 //
 319 ASDCP::Result_t
 320 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 321 {
 322   return InterchangeObject::WriteToBuffer(Buffer);
 323 }
 324
 325 //------------------------------------------------------------------------------------------
 326 // EssenceContainerData
 327
 328 //
 329
 330 EssenceContainerData::EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), BodySID(0)
 331 {
 332   assert(m_Dict);
 333   m_UL = m_Dict->ul(MDD_EssenceContainerData);
 334 }
 335
 336 EssenceContainerData::EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 337 {
 338   assert(m_Dict);
 339   m_UL = m_Dict->ul(MDD_EssenceContainerData);
 340   Copy(rhs);
 341 }
 342
 343
 344 //
 345 ASDCP::Result_t
 346 EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
 347 {
 348   assert(m_Dict);
 349   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 350   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(EssenceContainerData, LinkedPackageUID));
 351   if ( ASDCP_SUCCESS(result) ) {
 352     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(EssenceContainerData, IndexSID));
 353     IndexSID.set_has_value( result == RESULT_OK );
 354   }
 355   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, BodySID));
 356   return result;
 357 }
 358
 359 //
 360 ASDCP::Result_t
 361 EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
 362 {
 363   assert(m_Dict);
 364   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 365   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(EssenceContainerData, LinkedPackageUID));
 366   if ( ASDCP_SUCCESS(result)  && ! IndexSID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(EssenceContainerData, IndexSID));
 367   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, BodySID));
 368   return result;
 369 }
 370
 371 //
 372 void
 373 EssenceContainerData::Copy(const EssenceContainerData& rhs)
 374 {
 375   InterchangeObject::Copy(rhs);
 376   LinkedPackageUID = rhs.LinkedPackageUID;
 377   IndexSID = rhs.IndexSID;
 378   BodySID = rhs.BodySID;
 379 }
 380
 381 //
 382 void
 383 EssenceContainerData::Dump(FILE* stream)
 384 {
 385   char identbuf[IdentBufferLen];
 386   *identbuf = 0;
 387
 388   if ( stream == 0 )
 389     stream = stderr;
 390
 391   InterchangeObject::Dump(stream);
 392   fprintf(stream, "  %22s = %s\n",  "LinkedPackageUID", LinkedPackageUID.EncodeString(identbuf, IdentBufferLen));
 393   if ( ! IndexSID.empty() ) {
 394     fprintf(stream, "  %22s = %d\n",  "IndexSID", IndexSID.get());
 395   }
 396   fprintf(stream, "  %22s = %d\n",  "BodySID", BodySID);
 397 }
 398
 399 //
 400 ASDCP::Result_t
 401 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 402 {
 403   return InterchangeObject::InitFromBuffer(p, l);
 404 }
 405
 406 //
 407 ASDCP::Result_t
 408 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 409 {
 410   return InterchangeObject::WriteToBuffer(Buffer);
 411 }
 412
 413 //------------------------------------------------------------------------------------------
 414 // GenericPackage
 415
 416 //
 417 GenericPackage::GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 418
 419 GenericPackage::GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 420 {
 421   Copy(rhs);
 422 }
 423
 424
 425 //
 426 ASDCP::Result_t
 427 GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
 428 {
 429   assert(m_Dict);
 430   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 431   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
 432   if ( ASDCP_SUCCESS(result) ) {
 433     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPackage, Name));
 434     Name.set_has_value( result == RESULT_OK );
 435   }
 436   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
 437   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
 438   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
 439   return result;
 440 }
 441
 442 //
 443 ASDCP::Result_t
 444 GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
 445 {
 446   assert(m_Dict);
 447   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 448   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageUID));
 449   if ( ASDCP_SUCCESS(result)  && ! Name.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPackage, Name));
 450   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageCreationDate));
 451   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageModifiedDate));
 452   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Tracks));
 453   return result;
 454 }
 455
 456 //
 457 void
 458 GenericPackage::Copy(const GenericPackage& rhs)
 459 {
 460   InterchangeObject::Copy(rhs);
 461   PackageUID = rhs.PackageUID;
 462   Name = rhs.Name;
 463   PackageCreationDate = rhs.PackageCreationDate;
 464   PackageModifiedDate = rhs.PackageModifiedDate;
 465   Tracks = rhs.Tracks;
 466 }
 467
 468 //
 469 void
 470 GenericPackage::Dump(FILE* stream)
 471 {
 472   char identbuf[IdentBufferLen];
 473   *identbuf = 0;
 474
 475   if ( stream == 0 )
 476     stream = stderr;
 477
 478   InterchangeObject::Dump(stream);
 479   fprintf(stream, "  %22s = %s\n",  "PackageUID", PackageUID.EncodeString(identbuf, IdentBufferLen));
 480   if ( ! Name.empty() ) {
 481     fprintf(stream, "  %22s = %s\n",  "Name", Name.get().EncodeString(identbuf, IdentBufferLen));
 482   }
 483   fprintf(stream, "  %22s = %s\n",  "PackageCreationDate", PackageCreationDate.EncodeString(identbuf, IdentBufferLen));
 484   fprintf(stream, "  %22s = %s\n",  "PackageModifiedDate", PackageModifiedDate.EncodeString(identbuf, IdentBufferLen));
 485   fprintf(stream, "  %22s:\n",  "Tracks");
 486   Tracks.Dump(stream);
 487 }
 488
 489
 490 //------------------------------------------------------------------------------------------
 491 // MaterialPackage
 492
 493 //
 494
 495 MaterialPackage::MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
 496 {
 497   assert(m_Dict);
 498   m_UL = m_Dict->ul(MDD_MaterialPackage);
 499 }
 500
 501 MaterialPackage::MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
 502 {
 503   assert(m_Dict);
 504   m_UL = m_Dict->ul(MDD_MaterialPackage);
 505   Copy(rhs);
 506 }
 507
 508
 509 //
 510 ASDCP::Result_t
 511 MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
 512 {
 513   assert(m_Dict);
 514   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 515   if ( ASDCP_SUCCESS(result) ) {
 516     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MaterialPackage, PackageMarker));
 517     PackageMarker.set_has_value( result == RESULT_OK );
 518   }
 519   return result;
 520 }
 521
 522 //
 523 ASDCP::Result_t
 524 MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
 525 {
 526   assert(m_Dict);
 527   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 528   if ( ASDCP_SUCCESS(result)  && ! PackageMarker.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MaterialPackage, PackageMarker));
 529   return result;
 530 }
 531
 532 //
 533 void
 534 MaterialPackage::Copy(const MaterialPackage& rhs)
 535 {
 536   GenericPackage::Copy(rhs);
 537   PackageMarker = rhs.PackageMarker;
 538 }
 539
 540 //
 541 void
 542 MaterialPackage::Dump(FILE* stream)
 543 {
 544   char identbuf[IdentBufferLen];
 545   *identbuf = 0;
 546
 547   if ( stream == 0 )
 548     stream = stderr;
 549
 550   GenericPackage::Dump(stream);
 551   if ( ! PackageMarker.empty() ) {
 552     fprintf(stream, "  %22s = %s\n",  "PackageMarker", PackageMarker.get().EncodeString(identbuf, IdentBufferLen));
 553   }
 554 }
 555
 556 //
 557 ASDCP::Result_t
 558 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 559 {
 560   return InterchangeObject::InitFromBuffer(p, l);
 561 }
 562
 563 //
 564 ASDCP::Result_t
 565 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 566 {
 567   return InterchangeObject::WriteToBuffer(Buffer);
 568 }
 569
 570 //------------------------------------------------------------------------------------------
 571 // SourcePackage
 572
 573 //
 574
 575 SourcePackage::SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
 576 {
 577   assert(m_Dict);
 578   m_UL = m_Dict->ul(MDD_SourcePackage);
 579 }
 580
 581 SourcePackage::SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
 582 {
 583   assert(m_Dict);
 584   m_UL = m_Dict->ul(MDD_SourcePackage);
 585   Copy(rhs);
 586 }
 587
 588
 589 //
 590 ASDCP::Result_t
 591 SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
 592 {
 593   assert(m_Dict);
 594   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 595   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourcePackage, Descriptor));
 596   return result;
 597 }
 598
 599 //
 600 ASDCP::Result_t
 601 SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
 602 {
 603   assert(m_Dict);
 604   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 605   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourcePackage, Descriptor));
 606   return result;
 607 }
 608
 609 //
 610 void
 611 SourcePackage::Copy(const SourcePackage& rhs)
 612 {
 613   GenericPackage::Copy(rhs);
 614   Descriptor = rhs.Descriptor;
 615 }
 616
 617 //
 618 void
 619 SourcePackage::Dump(FILE* stream)
 620 {
 621   char identbuf[IdentBufferLen];
 622   *identbuf = 0;
 623
 624   if ( stream == 0 )
 625     stream = stderr;
 626
 627   GenericPackage::Dump(stream);
 628   fprintf(stream, "  %22s = %s\n",  "Descriptor", Descriptor.EncodeString(identbuf, IdentBufferLen));
 629 }
 630
 631 //
 632 ASDCP::Result_t
 633 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 634 {
 635   return InterchangeObject::InitFromBuffer(p, l);
 636 }
 637
 638 //
 639 ASDCP::Result_t
 640 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 641 {
 642   return InterchangeObject::WriteToBuffer(Buffer);
 643 }
 644
 645 //------------------------------------------------------------------------------------------
 646 // GenericTrack
 647
 648 //
 649 GenericTrack::GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
 650
 651 GenericTrack::GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 652 {
 653   Copy(rhs);
 654 }
 655
 656
 657 //
 658 ASDCP::Result_t
 659 GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
 660 {
 661   assert(m_Dict);
 662   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 663   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
 664   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
 665   if ( ASDCP_SUCCESS(result) ) {
 666     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericTrack, TrackName));
 667     TrackName.set_has_value( result == RESULT_OK );
 668   }
 669   if ( ASDCP_SUCCESS(result) ) {
 670     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericTrack, Sequence));
 671     Sequence.set_has_value( result == RESULT_OK );
 672   }
 673   return result;
 674 }
 675
 676 //
 677 ASDCP::Result_t
 678 GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
 679 {
 680   assert(m_Dict);
 681   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 682   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackID));
 683   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackNumber));
 684   if ( ASDCP_SUCCESS(result)  && ! TrackName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericTrack, TrackName));
 685   if ( ASDCP_SUCCESS(result)  && ! Sequence.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericTrack, Sequence));
 686   return result;
 687 }
 688
 689 //
 690 void
 691 GenericTrack::Copy(const GenericTrack& rhs)
 692 {
 693   InterchangeObject::Copy(rhs);
 694   TrackID = rhs.TrackID;
 695   TrackNumber = rhs.TrackNumber;
 696   TrackName = rhs.TrackName;
 697   Sequence = rhs.Sequence;
 698 }
 699
 700 //
 701 void
 702 GenericTrack::Dump(FILE* stream)
 703 {
 704   char identbuf[IdentBufferLen];
 705   *identbuf = 0;
 706
 707   if ( stream == 0 )
 708     stream = stderr;
 709
 710   InterchangeObject::Dump(stream);
 711   fprintf(stream, "  %22s = %d\n",  "TrackID", TrackID);
 712   fprintf(stream, "  %22s = %d\n",  "TrackNumber", TrackNumber);
 713   if ( ! TrackName.empty() ) {
 714     fprintf(stream, "  %22s = %s\n",  "TrackName", TrackName.get().EncodeString(identbuf, IdentBufferLen));
 715   }
 716   if ( ! Sequence.empty() ) {
 717     fprintf(stream, "  %22s = %s\n",  "Sequence", Sequence.get().EncodeString(identbuf, IdentBufferLen));
 718   }
 719 }
 720
 721
 722 //------------------------------------------------------------------------------------------
 723 // StaticTrack
 724
 725 //
 726
 727 StaticTrack::StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d)
 728 {
 729   assert(m_Dict);
 730   m_UL = m_Dict->ul(MDD_StaticTrack);
 731 }
 732
 733 StaticTrack::StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
 734 {
 735   assert(m_Dict);
 736   m_UL = m_Dict->ul(MDD_StaticTrack);
 737   Copy(rhs);
 738 }
 739
 740
 741 //
 742 ASDCP::Result_t
 743 StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
 744 {
 745   assert(m_Dict);
 746   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 747   return result;
 748 }
 749
 750 //
 751 ASDCP::Result_t
 752 StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
 753 {
 754   assert(m_Dict);
 755   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 756   return result;
 757 }
 758
 759 //
 760 void
 761 StaticTrack::Copy(const StaticTrack& rhs)
 762 {
 763   GenericTrack::Copy(rhs);
 764 }
 765
 766 //
 767 void
 768 StaticTrack::Dump(FILE* stream)
 769 {
 770   char identbuf[IdentBufferLen];
 771   *identbuf = 0;
 772
 773   if ( stream == 0 )
 774     stream = stderr;
 775
 776   GenericTrack::Dump(stream);
 777 }
 778
 779 //
 780 ASDCP::Result_t
 781 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 782 {
 783   return InterchangeObject::InitFromBuffer(p, l);
 784 }
 785
 786 //
 787 ASDCP::Result_t
 788 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 789 {
 790   return InterchangeObject::WriteToBuffer(Buffer);
 791 }
 792
 793 //------------------------------------------------------------------------------------------
 794 // Track
 795
 796 //
 797
 798 Track::Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0)
 799 {
 800   assert(m_Dict);
 801   m_UL = m_Dict->ul(MDD_Track);
 802 }
 803
 804 Track::Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
 805 {
 806   assert(m_Dict);
 807   m_UL = m_Dict->ul(MDD_Track);
 808   Copy(rhs);
 809 }
 810
 811
 812 //
 813 ASDCP::Result_t
 814 Track::InitFromTLVSet(TLVReader& TLVSet)
 815 {
 816   assert(m_Dict);
 817   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 818   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
 819   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
 820   return result;
 821 }
 822
 823 //
 824 ASDCP::Result_t
 825 Track::WriteToTLVSet(TLVWriter& TLVSet)
 826 {
 827   assert(m_Dict);
 828   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 829   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Track, EditRate));
 830   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(Track, Origin));
 831   return result;
 832 }
 833
 834 //
 835 void
 836 Track::Copy(const Track& rhs)
 837 {
 838   GenericTrack::Copy(rhs);
 839   EditRate = rhs.EditRate;
 840   Origin = rhs.Origin;
 841 }
 842
 843 //
 844 void
 845 Track::Dump(FILE* stream)
 846 {
 847   char identbuf[IdentBufferLen];
 848   *identbuf = 0;
 849
 850   if ( stream == 0 )
 851     stream = stderr;
 852
 853   GenericTrack::Dump(stream);
 854   fprintf(stream, "  %22s = %s\n",  "EditRate", EditRate.EncodeString(identbuf, IdentBufferLen));
 855   fprintf(stream, "  %22s = %s\n",  "Origin", i64sz(Origin, identbuf));
 856 }
 857
 858 //
 859 ASDCP::Result_t
 860 Track::InitFromBuffer(const byte_t* p, ui32_t l)
 861 {
 862   return InterchangeObject::InitFromBuffer(p, l);
 863 }
 864
 865 //
 866 ASDCP::Result_t
 867 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 868 {
 869   return InterchangeObject::WriteToBuffer(Buffer);
 870 }
 871
 872 //------------------------------------------------------------------------------------------
 873 // StructuralComponent
 874
 875 //
 876 StructuralComponent::StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 877
 878 StructuralComponent::StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 879 {
 880   Copy(rhs);
 881 }
 882
 883
 884 //
 885 ASDCP::Result_t
 886 StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
 887 {
 888   assert(m_Dict);
 889   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 890   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 891   if ( ASDCP_SUCCESS(result) ) {
 892     result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(StructuralComponent, Duration));
 893     Duration.set_has_value( result == RESULT_OK );
 894   }
 895   return result;
 896 }
 897
 898 //
 899 ASDCP::Result_t
 900 StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
 901 {
 902   assert(m_Dict);
 903   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 904   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(StructuralComponent, DataDefinition));
 905   if ( ASDCP_SUCCESS(result)  && ! Duration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(StructuralComponent, Duration));
 906   return result;
 907 }
 908
 909 //
 910 void
 911 StructuralComponent::Copy(const StructuralComponent& rhs)
 912 {
 913   InterchangeObject::Copy(rhs);
 914   DataDefinition = rhs.DataDefinition;
 915   Duration = rhs.Duration;
 916 }
 917
 918 //
 919 void
 920 StructuralComponent::Dump(FILE* stream)
 921 {
 922   char identbuf[IdentBufferLen];
 923   *identbuf = 0;
 924
 925   if ( stream == 0 )
 926     stream = stderr;
 927
 928   InterchangeObject::Dump(stream);
 929   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
 930   if ( ! Duration.empty() ) {
 931     fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration.get(), identbuf));
 932   }
 933 }
 934
 935
 936 //------------------------------------------------------------------------------------------
 937 // Sequence
 938
 939 //
 940
 941 Sequence::Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d)
 942 {
 943   assert(m_Dict);
 944   m_UL = m_Dict->ul(MDD_Sequence);
 945 }
 946
 947 Sequence::Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
 948 {
 949   assert(m_Dict);
 950   m_UL = m_Dict->ul(MDD_Sequence);
 951   Copy(rhs);
 952 }
 953
 954
 955 //
 956 ASDCP::Result_t
 957 Sequence::InitFromTLVSet(TLVReader& TLVSet)
 958 {
 959   assert(m_Dict);
 960   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 961   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
 962   return result;
 963 }
 964
 965 //
 966 ASDCP::Result_t
 967 Sequence::WriteToTLVSet(TLVWriter& TLVSet)
 968 {
 969   assert(m_Dict);
 970   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
 971   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Sequence, StructuralComponents));
 972   return result;
 973 }
 974
 975 //
 976 void
 977 Sequence::Copy(const Sequence& rhs)
 978 {
 979   StructuralComponent::Copy(rhs);
 980   StructuralComponents = rhs.StructuralComponents;
 981 }
 982
 983 //
 984 void
 985 Sequence::Dump(FILE* stream)
 986 {
 987   char identbuf[IdentBufferLen];
 988   *identbuf = 0;
 989
 990   if ( stream == 0 )
 991     stream = stderr;
 992
 993   StructuralComponent::Dump(stream);
 994   fprintf(stream, "  %22s:\n",  "StructuralComponents");
 995   StructuralComponents.Dump(stream);
 996 }
 997
 998 //
 999 ASDCP::Result_t
1000 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
1001 {
1002   return InterchangeObject::InitFromBuffer(p, l);
1003 }
1004
1005 //
1006 ASDCP::Result_t
1007 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1008 {
1009   return InterchangeObject::WriteToBuffer(Buffer);
1010 }
1011
1012 //------------------------------------------------------------------------------------------
1013 // SourceClip
1014
1015 //
1016
1017 SourceClip::SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0)
1018 {
1019   assert(m_Dict);
1020   m_UL = m_Dict->ul(MDD_SourceClip);
1021 }
1022
1023 SourceClip::SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1024 {
1025   assert(m_Dict);
1026   m_UL = m_Dict->ul(MDD_SourceClip);
1027   Copy(rhs);
1028 }
1029
1030
1031 //
1032 ASDCP::Result_t
1033 SourceClip::InitFromTLVSet(TLVReader& TLVSet)
1034 {
1035   assert(m_Dict);
1036   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1037   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
1038   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
1039   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
1040   return result;
1041 }
1042
1043 //
1044 ASDCP::Result_t
1045 SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
1046 {
1047   assert(m_Dict);
1048   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1049   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(SourceClip, StartPosition));
1050   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourceClip, SourcePackageID));
1051   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(SourceClip, SourceTrackID));
1052   return result;
1053 }
1054
1055 //
1056 void
1057 SourceClip::Copy(const SourceClip& rhs)
1058 {
1059   StructuralComponent::Copy(rhs);
1060   StartPosition = rhs.StartPosition;
1061   SourcePackageID = rhs.SourcePackageID;
1062   SourceTrackID = rhs.SourceTrackID;
1063 }
1064
1065 //
1066 void
1067 SourceClip::Dump(FILE* stream)
1068 {
1069   char identbuf[IdentBufferLen];
1070   *identbuf = 0;
1071
1072   if ( stream == 0 )
1073     stream = stderr;
1074
1075   StructuralComponent::Dump(stream);
1076   fprintf(stream, "  %22s = %s\n",  "StartPosition", i64sz(StartPosition, identbuf));
1077   fprintf(stream, "  %22s = %s\n",  "SourcePackageID", SourcePackageID.EncodeString(identbuf, IdentBufferLen));
1078   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
1079 }
1080
1081 //
1082 ASDCP::Result_t
1083 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
1084 {
1085   return InterchangeObject::InitFromBuffer(p, l);
1086 }
1087
1088 //
1089 ASDCP::Result_t
1090 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1091 {
1092   return InterchangeObject::WriteToBuffer(Buffer);
1093 }
1094
1095 //------------------------------------------------------------------------------------------
1096 // TimecodeComponent
1097
1098 //
1099
1100 TimecodeComponent::TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0)
1101 {
1102   assert(m_Dict);
1103   m_UL = m_Dict->ul(MDD_TimecodeComponent);
1104 }
1105
1106 TimecodeComponent::TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1107 {
1108   assert(m_Dict);
1109   m_UL = m_Dict->ul(MDD_TimecodeComponent);
1110   Copy(rhs);
1111 }
1112
1113
1114 //
1115 ASDCP::Result_t
1116 TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
1117 {
1118   assert(m_Dict);
1119   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1120   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
1121   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
1122   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
1123   return result;
1124 }
1125
1126 //
1127 ASDCP::Result_t
1128 TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
1129 {
1130   assert(m_Dict);
1131   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1132   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(TimecodeComponent, RoundedTimecodeBase));
1133   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TimecodeComponent, StartTimecode));
1134   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(TimecodeComponent, DropFrame));
1135   return result;
1136 }
1137
1138 //
1139 void
1140 TimecodeComponent::Copy(const TimecodeComponent& rhs)
1141 {
1142   StructuralComponent::Copy(rhs);
1143   RoundedTimecodeBase = rhs.RoundedTimecodeBase;
1144   StartTimecode = rhs.StartTimecode;
1145   DropFrame = rhs.DropFrame;
1146 }
1147
1148 //
1149 void
1150 TimecodeComponent::Dump(FILE* stream)
1151 {
1152   char identbuf[IdentBufferLen];
1153   *identbuf = 0;
1154
1155   if ( stream == 0 )
1156     stream = stderr;
1157
1158   StructuralComponent::Dump(stream);
1159   fprintf(stream, "  %22s = %d\n",  "RoundedTimecodeBase", RoundedTimecodeBase);
1160   fprintf(stream, "  %22s = %s\n",  "StartTimecode", i64sz(StartTimecode, identbuf));
1161   fprintf(stream, "  %22s = %d\n",  "DropFrame", DropFrame);
1162 }
1163
1164 //
1165 ASDCP::Result_t
1166 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
1167 {
1168   return InterchangeObject::InitFromBuffer(p, l);
1169 }
1170
1171 //
1172 ASDCP::Result_t
1173 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1174 {
1175   return InterchangeObject::WriteToBuffer(Buffer);
1176 }
1177
1178 //------------------------------------------------------------------------------------------
1179 // GenericDescriptor
1180
1181 //
1182 GenericDescriptor::GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
1183
1184 GenericDescriptor::GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1185 {
1186   Copy(rhs);
1187 }
1188
1189
1190 //
1191 ASDCP::Result_t
1192 GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1193 {
1194   assert(m_Dict);
1195   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1196   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
1197   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
1198   return result;
1199 }
1200
1201 //
1202 ASDCP::Result_t
1203 GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1204 {
1205   assert(m_Dict);
1206   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1207   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, Locators));
1208   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, SubDescriptors));
1209   return result;
1210 }
1211
1212 //
1213 void
1214 GenericDescriptor::Copy(const GenericDescriptor& rhs)
1215 {
1216   InterchangeObject::Copy(rhs);
1217   Locators = rhs.Locators;
1218   SubDescriptors = rhs.SubDescriptors;
1219 }
1220
1221 //
1222 void
1223 GenericDescriptor::Dump(FILE* stream)
1224 {
1225   char identbuf[IdentBufferLen];
1226   *identbuf = 0;
1227
1228   if ( stream == 0 )
1229     stream = stderr;
1230
1231   InterchangeObject::Dump(stream);
1232   fprintf(stream, "  %22s:\n",  "Locators");
1233   Locators.Dump(stream);
1234   fprintf(stream, "  %22s:\n",  "SubDescriptors");
1235   SubDescriptors.Dump(stream);
1236 }
1237
1238
1239 //------------------------------------------------------------------------------------------
1240 // FileDescriptor
1241
1242 //
1243
1244 FileDescriptor::FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d)
1245 {
1246   assert(m_Dict);
1247   m_UL = m_Dict->ul(MDD_FileDescriptor);
1248 }
1249
1250 FileDescriptor::FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1251 {
1252   assert(m_Dict);
1253   m_UL = m_Dict->ul(MDD_FileDescriptor);
1254   Copy(rhs);
1255 }
1256
1257
1258 //
1259 ASDCP::Result_t
1260 FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1261 {
1262   assert(m_Dict);
1263   Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
1264   if ( ASDCP_SUCCESS(result) ) {
1265     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(FileDescriptor, LinkedTrackID));
1266     LinkedTrackID.set_has_value( result == RESULT_OK );
1267   }
1268   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
1269   if ( ASDCP_SUCCESS(result) ) {
1270     result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(FileDescriptor, ContainerDuration));
1271     ContainerDuration.set_has_value( result == RESULT_OK );
1272   }
1273   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
1274   if ( ASDCP_SUCCESS(result) ) {
1275     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(FileDescriptor, Codec));
1276     Codec.set_has_value( result == RESULT_OK );
1277   }
1278   return result;
1279 }
1280
1281 //
1282 ASDCP::Result_t
1283 FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1284 {
1285   assert(m_Dict);
1286   Result_t result = GenericDescriptor::WriteToTLVSet(TLVSet);
1287   if ( ASDCP_SUCCESS(result)  && ! LinkedTrackID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(FileDescriptor, LinkedTrackID));
1288   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, SampleRate));
1289   if ( ASDCP_SUCCESS(result)  && ! ContainerDuration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(FileDescriptor, ContainerDuration));
1290   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, EssenceContainer));
1291   if ( ASDCP_SUCCESS(result)  && ! Codec.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(FileDescriptor, Codec));
1292   return result;
1293 }
1294
1295 //
1296 void
1297 FileDescriptor::Copy(const FileDescriptor& rhs)
1298 {
1299   GenericDescriptor::Copy(rhs);
1300   LinkedTrackID = rhs.LinkedTrackID;
1301   SampleRate = rhs.SampleRate;
1302   ContainerDuration = rhs.ContainerDuration;
1303   EssenceContainer = rhs.EssenceContainer;
1304   Codec = rhs.Codec;
1305 }
1306
1307 //
1308 void
1309 FileDescriptor::Dump(FILE* stream)
1310 {
1311   char identbuf[IdentBufferLen];
1312   *identbuf = 0;
1313
1314   if ( stream == 0 )
1315     stream = stderr;
1316
1317   GenericDescriptor::Dump(stream);
1318   if ( ! LinkedTrackID.empty() ) {
1319     fprintf(stream, "  %22s = %d\n",  "LinkedTrackID", LinkedTrackID.get());
1320   }
1321   fprintf(stream, "  %22s = %s\n",  "SampleRate", SampleRate.EncodeString(identbuf, IdentBufferLen));
1322   if ( ! ContainerDuration.empty() ) {
1323     fprintf(stream, "  %22s = %s\n",  "ContainerDuration", i64sz(ContainerDuration.get(), identbuf));
1324   }
1325   fprintf(stream, "  %22s = %s\n",  "EssenceContainer", EssenceContainer.EncodeString(identbuf, IdentBufferLen));
1326   if ( ! Codec.empty() ) {
1327     fprintf(stream, "  %22s = %s\n",  "Codec", Codec.get().EncodeString(identbuf, IdentBufferLen));
1328   }
1329 }
1330
1331 //
1332 ASDCP::Result_t
1333 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1334 {
1335   return InterchangeObject::InitFromBuffer(p, l);
1336 }
1337
1338 //
1339 ASDCP::Result_t
1340 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1341 {
1342   return InterchangeObject::WriteToBuffer(Buffer);
1343 }
1344
1345 //------------------------------------------------------------------------------------------
1346 // GenericSoundEssenceDescriptor
1347
1348 //
1349
1350 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), ChannelCount(0), QuantizationBits(0)
1351 {
1352   assert(m_Dict);
1353   m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1354 }
1355
1356 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1357 {
1358   assert(m_Dict);
1359   m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1360   Copy(rhs);
1361 }
1362
1363
1364 //
1365 ASDCP::Result_t
1366 GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1367 {
1368   assert(m_Dict);
1369   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1370   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1371   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
1372   if ( ASDCP_SUCCESS(result) ) {
1373     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1374     AudioRefLevel.set_has_value( result == RESULT_OK );
1375   }
1376   if ( ASDCP_SUCCESS(result) ) {
1377     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1378     ElectroSpatialFormulation.set_has_value( result == RESULT_OK );
1379   }
1380   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1381   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1382   if ( ASDCP_SUCCESS(result) ) {
1383     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1384     DialNorm.set_has_value( result == RESULT_OK );
1385   }
1386   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1387   return result;
1388 }
1389
1390 //
1391 ASDCP::Result_t
1392 GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1393 {
1394   assert(m_Dict);
1395   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1396   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1397   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
1398   if ( ASDCP_SUCCESS(result)  && ! AudioRefLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1399   if ( ASDCP_SUCCESS(result)  && ! ElectroSpatialFormulation.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1400   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1401   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1402   if ( ASDCP_SUCCESS(result)  && ! DialNorm.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1403   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1404   return result;
1405 }
1406
1407 //
1408 void
1409 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
1410 {
1411   FileDescriptor::Copy(rhs);
1412   AudioSamplingRate = rhs.AudioSamplingRate;
1413   Locked = rhs.Locked;
1414   AudioRefLevel = rhs.AudioRefLevel;
1415   ElectroSpatialFormulation = rhs.ElectroSpatialFormulation;
1416   ChannelCount = rhs.ChannelCount;
1417   QuantizationBits = rhs.QuantizationBits;
1418   DialNorm = rhs.DialNorm;
1419   SoundEssenceCoding = rhs.SoundEssenceCoding;
1420 }
1421
1422 //
1423 void
1424 GenericSoundEssenceDescriptor::Dump(FILE* stream)
1425 {
1426   char identbuf[IdentBufferLen];
1427   *identbuf = 0;
1428
1429   if ( stream == 0 )
1430     stream = stderr;
1431
1432   FileDescriptor::Dump(stream);
1433   fprintf(stream, "  %22s = %s\n",  "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1434   fprintf(stream, "  %22s = %d\n",  "Locked", Locked);
1435   if ( ! AudioRefLevel.empty() ) {
1436     fprintf(stream, "  %22s = %d\n",  "AudioRefLevel", AudioRefLevel.get());
1437   }
1438   if ( ! ElectroSpatialFormulation.empty() ) {
1439     fprintf(stream, "  %22s = %d\n",  "ElectroSpatialFormulation", ElectroSpatialFormulation.get());
1440   }
1441   fprintf(stream, "  %22s = %d\n",  "ChannelCount", ChannelCount);
1442   fprintf(stream, "  %22s = %d\n",  "QuantizationBits", QuantizationBits);
1443   if ( ! DialNorm.empty() ) {
1444     fprintf(stream, "  %22s = %d\n",  "DialNorm", DialNorm.get());
1445   }
1446   fprintf(stream, "  %22s = %s\n",  "SoundEssenceCoding", SoundEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1447 }
1448
1449 //
1450 ASDCP::Result_t
1451 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1452 {
1453   return InterchangeObject::InitFromBuffer(p, l);
1454 }
1455
1456 //
1457 ASDCP::Result_t
1458 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1459 {
1460   return InterchangeObject::WriteToBuffer(Buffer);
1461 }
1462
1463 //------------------------------------------------------------------------------------------
1464 // WaveAudioDescriptor
1465
1466 //
1467
1468 WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), AvgBps(0)
1469 {
1470   assert(m_Dict);
1471   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1472 }
1473
1474 WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1475 {
1476   assert(m_Dict);
1477   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1478   Copy(rhs);
1479 }
1480
1481
1482 //
1483 ASDCP::Result_t
1484 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1485 {
1486   assert(m_Dict);
1487   Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1488   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1489   if ( ASDCP_SUCCESS(result) ) {
1490     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1491     SequenceOffset.set_has_value( result == RESULT_OK );
1492   }
1493   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1494   if ( ASDCP_SUCCESS(result) ) {
1495     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1496     ChannelAssignment.set_has_value( result == RESULT_OK );
1497   }
1498   if ( ASDCP_SUCCESS(result) ) {
1499     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ReferenceImageEditRate));
1500     ReferenceImageEditRate.set_has_value( result == RESULT_OK );
1501   }
1502   if ( ASDCP_SUCCESS(result) ) {
1503     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ReferenceAudioAlignmentLevel));
1504     ReferenceAudioAlignmentLevel.set_has_value( result == RESULT_OK );
1505   }
1506   return result;
1507 }
1508
1509 //
1510 ASDCP::Result_t
1511 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1512 {
1513   assert(m_Dict);
1514   Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1515   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1516   if ( ASDCP_SUCCESS(result)  && ! SequenceOffset.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1517   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1518   if ( ASDCP_SUCCESS(result)  && ! ChannelAssignment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1519   if ( ASDCP_SUCCESS(result)  && ! ReferenceImageEditRate.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ReferenceImageEditRate));
1520   if ( ASDCP_SUCCESS(result)  && ! ReferenceAudioAlignmentLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ReferenceAudioAlignmentLevel));
1521   return result;
1522 }
1523
1524 //
1525 void
1526 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
1527 {
1528   GenericSoundEssenceDescriptor::Copy(rhs);
1529   BlockAlign = rhs.BlockAlign;
1530   SequenceOffset = rhs.SequenceOffset;
1531   AvgBps = rhs.AvgBps;
1532   ChannelAssignment = rhs.ChannelAssignment;
1533   ReferenceImageEditRate = rhs.ReferenceImageEditRate;
1534   ReferenceAudioAlignmentLevel = rhs.ReferenceAudioAlignmentLevel;
1535 }
1536
1537 //
1538 void
1539 WaveAudioDescriptor::Dump(FILE* stream)
1540 {
1541   char identbuf[IdentBufferLen];
1542   *identbuf = 0;
1543
1544   if ( stream == 0 )
1545     stream = stderr;
1546
1547   GenericSoundEssenceDescriptor::Dump(stream);
1548   fprintf(stream, "  %22s = %d\n",  "BlockAlign", BlockAlign);
1549   if ( ! SequenceOffset.empty() ) {
1550     fprintf(stream, "  %22s = %d\n",  "SequenceOffset", SequenceOffset.get());
1551   }
1552   fprintf(stream, "  %22s = %d\n",  "AvgBps", AvgBps);
1553   if ( ! ChannelAssignment.empty() ) {
1554     fprintf(stream, "  %22s = %s\n",  "ChannelAssignment", ChannelAssignment.get().EncodeString(identbuf, IdentBufferLen));
1555   }
1556   if ( ! ReferenceImageEditRate.empty() ) {
1557     fprintf(stream, "  %22s = %s\n",  "ReferenceImageEditRate", ReferenceImageEditRate.get().EncodeString(identbuf, IdentBufferLen));
1558   }
1559   if ( ! ReferenceAudioAlignmentLevel.empty() ) {
1560     fprintf(stream, "  %22s = %d\n",  "ReferenceAudioAlignmentLevel", ReferenceAudioAlignmentLevel.get());
1561   }
1562 }
1563
1564 //
1565 ASDCP::Result_t
1566 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1567 {
1568   return InterchangeObject::InitFromBuffer(p, l);
1569 }
1570
1571 //
1572 ASDCP::Result_t
1573 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1574 {
1575   return InterchangeObject::WriteToBuffer(Buffer);
1576 }
1577
1578 //------------------------------------------------------------------------------------------
1579 // GenericPictureEssenceDescriptor
1580
1581 //
1582
1583 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0)
1584 {
1585   assert(m_Dict);
1586   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1587 }
1588
1589 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1590 {
1591   assert(m_Dict);
1592   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1593   Copy(rhs);
1594 }
1595
1596
1597 //
1598 ASDCP::Result_t
1599 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1600 {
1601   assert(m_Dict);
1602   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1603   if ( ASDCP_SUCCESS(result) ) {
1604     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1605     SignalStandard.set_has_value( result == RESULT_OK );
1606   }
1607   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1608   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1609   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1610   if ( ASDCP_SUCCESS(result) ) {
1611     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1612     StoredF2Offset.set_has_value( result == RESULT_OK );
1613   }
1614   if ( ASDCP_SUCCESS(result) ) {
1615     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1616     SampledWidth.set_has_value( result == RESULT_OK );
1617   }
1618   if ( ASDCP_SUCCESS(result) ) {
1619     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1620     SampledHeight.set_has_value( result == RESULT_OK );
1621   }
1622   if ( ASDCP_SUCCESS(result) ) {
1623     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1624     SampledXOffset.set_has_value( result == RESULT_OK );
1625   }
1626   if ( ASDCP_SUCCESS(result) ) {
1627     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1628     SampledYOffset.set_has_value( result == RESULT_OK );
1629   }
1630   if ( ASDCP_SUCCESS(result) ) {
1631     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1632     DisplayHeight.set_has_value( result == RESULT_OK );
1633   }
1634   if ( ASDCP_SUCCESS(result) ) {
1635     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1636     DisplayWidth.set_has_value( result == RESULT_OK );
1637   }
1638   if ( ASDCP_SUCCESS(result) ) {
1639     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1640     DisplayXOffset.set_has_value( result == RESULT_OK );
1641   }
1642   if ( ASDCP_SUCCESS(result) ) {
1643     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1644     DisplayYOffset.set_has_value( result == RESULT_OK );
1645   }
1646   if ( ASDCP_SUCCESS(result) ) {
1647     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1648     DisplayF2Offset.set_has_value( result == RESULT_OK );
1649   }
1650   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1651   if ( ASDCP_SUCCESS(result) ) {
1652     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1653     ActiveFormatDescriptor.set_has_value( result == RESULT_OK );
1654   }
1655   if ( ASDCP_SUCCESS(result) ) {
1656     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1657     AlphaTransparency.set_has_value( result == RESULT_OK );
1658   }
1659   if ( ASDCP_SUCCESS(result) ) {
1660     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1661     TransferCharacteristic.set_has_value( result == RESULT_OK );
1662   }
1663   if ( ASDCP_SUCCESS(result) ) {
1664     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1665     ImageAlignmentOffset.set_has_value( result == RESULT_OK );
1666   }
1667   if ( ASDCP_SUCCESS(result) ) {
1668     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1669     ImageStartOffset.set_has_value( result == RESULT_OK );
1670   }
1671   if ( ASDCP_SUCCESS(result) ) {
1672     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1673     ImageEndOffset.set_has_value( result == RESULT_OK );
1674   }
1675   if ( ASDCP_SUCCESS(result) ) {
1676     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1677     FieldDominance.set_has_value( result == RESULT_OK );
1678   }
1679   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1680   if ( ASDCP_SUCCESS(result) ) {
1681     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1682     CodingEquations.set_has_value( result == RESULT_OK );
1683   }
1684   if ( ASDCP_SUCCESS(result) ) {
1685     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1686     ColorPrimaries.set_has_value( result == RESULT_OK );
1687   }
1688   if ( ASDCP_SUCCESS(result) ) {
1689     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1690   }
1691   if ( ASDCP_SUCCESS(result) ) {
1692     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1693     ActiveWidth.set_has_value( result == RESULT_OK );
1694   }
1695   if ( ASDCP_SUCCESS(result) ) {
1696     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1697     ActiveHeight.set_has_value( result == RESULT_OK );
1698   }
1699   if ( ASDCP_SUCCESS(result) ) {
1700     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1701     ActiveXOffset.set_has_value( result == RESULT_OK );
1702   }
1703   if ( ASDCP_SUCCESS(result) ) {
1704     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1705     ActiveYOffset.set_has_value( result == RESULT_OK );
1706   }
1707   return result;
1708 }
1709
1710 //
1711 ASDCP::Result_t
1712 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1713 {
1714   assert(m_Dict);
1715   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1716   if ( ASDCP_SUCCESS(result)  && ! SignalStandard.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1717   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1718   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1719   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1720   if ( ASDCP_SUCCESS(result)  && ! StoredF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1721   if ( ASDCP_SUCCESS(result)  && ! SampledWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1722   if ( ASDCP_SUCCESS(result)  && ! SampledHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1723   if ( ASDCP_SUCCESS(result)  && ! SampledXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1724   if ( ASDCP_SUCCESS(result)  && ! SampledYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1725   if ( ASDCP_SUCCESS(result)  && ! DisplayHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1726   if ( ASDCP_SUCCESS(result)  && ! DisplayWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1727   if ( ASDCP_SUCCESS(result)  && ! DisplayXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1728   if ( ASDCP_SUCCESS(result)  && ! DisplayYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1729   if ( ASDCP_SUCCESS(result)  && ! DisplayF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1730   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1731   if ( ASDCP_SUCCESS(result)  && ! ActiveFormatDescriptor.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1732   if ( ASDCP_SUCCESS(result)  && ! AlphaTransparency.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1733   if ( ASDCP_SUCCESS(result)  && ! TransferCharacteristic.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1734   if ( ASDCP_SUCCESS(result)  && ! ImageAlignmentOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1735   if ( ASDCP_SUCCESS(result)  && ! ImageStartOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1736   if ( ASDCP_SUCCESS(result)  && ! ImageEndOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1737   if ( ASDCP_SUCCESS(result)  && ! FieldDominance.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1738   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1739   if ( ASDCP_SUCCESS(result)  && ! CodingEquations.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1740   if ( ASDCP_SUCCESS(result)  && ! ColorPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1741   if ( ASDCP_SUCCESS(result)  && ! AlternativeCenterCuts.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1742   if ( ASDCP_SUCCESS(result)  && ! ActiveWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1743   if ( ASDCP_SUCCESS(result)  && ! ActiveHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1744   if ( ASDCP_SUCCESS(result)  && ! ActiveXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1745   if ( ASDCP_SUCCESS(result)  && ! ActiveYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1746   return result;
1747 }
1748
1749 //
1750 void
1751 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1752 {
1753   FileDescriptor::Copy(rhs);
1754   SignalStandard = rhs.SignalStandard;
1755   FrameLayout = rhs.FrameLayout;
1756   StoredWidth = rhs.StoredWidth;
1757   StoredHeight = rhs.StoredHeight;
1758   StoredF2Offset = rhs.StoredF2Offset;
1759   SampledWidth = rhs.SampledWidth;
1760   SampledHeight = rhs.SampledHeight;
1761   SampledXOffset = rhs.SampledXOffset;
1762   SampledYOffset = rhs.SampledYOffset;
1763   DisplayHeight = rhs.DisplayHeight;
1764   DisplayWidth = rhs.DisplayWidth;
1765   DisplayXOffset = rhs.DisplayXOffset;
1766   DisplayYOffset = rhs.DisplayYOffset;
1767   DisplayF2Offset = rhs.DisplayF2Offset;
1768   AspectRatio = rhs.AspectRatio;
1769   ActiveFormatDescriptor = rhs.ActiveFormatDescriptor;
1770   AlphaTransparency = rhs.AlphaTransparency;
1771   TransferCharacteristic = rhs.TransferCharacteristic;
1772   ImageAlignmentOffset = rhs.ImageAlignmentOffset;
1773   ImageStartOffset = rhs.ImageStartOffset;
1774   ImageEndOffset = rhs.ImageEndOffset;
1775   FieldDominance = rhs.FieldDominance;
1776   PictureEssenceCoding = rhs.PictureEssenceCoding;
1777   CodingEquations = rhs.CodingEquations;
1778   ColorPrimaries = rhs.ColorPrimaries;
1779   AlternativeCenterCuts = rhs.AlternativeCenterCuts;
1780   ActiveWidth = rhs.ActiveWidth;
1781   ActiveHeight = rhs.ActiveHeight;
1782   ActiveXOffset = rhs.ActiveXOffset;
1783   ActiveYOffset = rhs.ActiveYOffset;
1784 }
1785
1786 //
1787 void
1788 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1789 {
1790   char identbuf[IdentBufferLen];
1791   *identbuf = 0;
1792
1793   if ( stream == 0 )
1794     stream = stderr;
1795
1796   FileDescriptor::Dump(stream);
1797   if ( ! SignalStandard.empty() ) {
1798     fprintf(stream, "  %22s = %d\n",  "SignalStandard", SignalStandard.get());
1799   }
1800   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1801   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1802   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1803   if ( ! StoredF2Offset.empty() ) {
1804     fprintf(stream, "  %22s = %d\n",  "StoredF2Offset", StoredF2Offset.get());
1805   }
1806   if ( ! SampledWidth.empty() ) {
1807     fprintf(stream, "  %22s = %d\n",  "SampledWidth", SampledWidth.get());
1808   }
1809   if ( ! SampledHeight.empty() ) {
1810     fprintf(stream, "  %22s = %d\n",  "SampledHeight", SampledHeight.get());
1811   }
1812   if ( ! SampledXOffset.empty() ) {
1813     fprintf(stream, "  %22s = %d\n",  "SampledXOffset", SampledXOffset.get());
1814   }
1815   if ( ! SampledYOffset.empty() ) {
1816     fprintf(stream, "  %22s = %d\n",  "SampledYOffset", SampledYOffset.get());
1817   }
1818   if ( ! DisplayHeight.empty() ) {
1819     fprintf(stream, "  %22s = %d\n",  "DisplayHeight", DisplayHeight.get());
1820   }
1821   if ( ! DisplayWidth.empty() ) {
1822     fprintf(stream, "  %22s = %d\n",  "DisplayWidth", DisplayWidth.get());
1823   }
1824   if ( ! DisplayXOffset.empty() ) {
1825     fprintf(stream, "  %22s = %d\n",  "DisplayXOffset", DisplayXOffset.get());
1826   }
1827   if ( ! DisplayYOffset.empty() ) {
1828     fprintf(stream, "  %22s = %d\n",  "DisplayYOffset", DisplayYOffset.get());
1829   }
1830   if ( ! DisplayF2Offset.empty() ) {
1831     fprintf(stream, "  %22s = %d\n",  "DisplayF2Offset", DisplayF2Offset.get());
1832   }
1833   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1834   if ( ! ActiveFormatDescriptor.empty() ) {
1835     fprintf(stream, "  %22s = %d\n",  "ActiveFormatDescriptor", ActiveFormatDescriptor.get());
1836   }
1837   if ( ! AlphaTransparency.empty() ) {
1838     fprintf(stream, "  %22s = %d\n",  "AlphaTransparency", AlphaTransparency.get());
1839   }
1840   if ( ! TransferCharacteristic.empty() ) {
1841     fprintf(stream, "  %22s = %s\n",  "TransferCharacteristic", TransferCharacteristic.get().EncodeString(identbuf, IdentBufferLen));
1842   }
1843   if ( ! ImageAlignmentOffset.empty() ) {
1844     fprintf(stream, "  %22s = %d\n",  "ImageAlignmentOffset", ImageAlignmentOffset.get());
1845   }
1846   if ( ! ImageStartOffset.empty() ) {
1847     fprintf(stream, "  %22s = %d\n",  "ImageStartOffset", ImageStartOffset.get());
1848   }
1849   if ( ! ImageEndOffset.empty() ) {
1850     fprintf(stream, "  %22s = %d\n",  "ImageEndOffset", ImageEndOffset.get());
1851   }
1852   if ( ! FieldDominance.empty() ) {
1853     fprintf(stream, "  %22s = %d\n",  "FieldDominance", FieldDominance.get());
1854   }
1855   fprintf(stream, "  %22s = %s\n",  "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1856   if ( ! CodingEquations.empty() ) {
1857     fprintf(stream, "  %22s = %s\n",  "CodingEquations", CodingEquations.get().EncodeString(identbuf, IdentBufferLen));
1858   }
1859   if ( ! ColorPrimaries.empty() ) {
1860     fprintf(stream, "  %22s = %s\n",  "ColorPrimaries", ColorPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1861   }
1862   if ( ! AlternativeCenterCuts.empty() ) {
1863     fprintf(stream, "  %22s:\n",  "AlternativeCenterCuts");
1864   AlternativeCenterCuts.get().Dump(stream);
1865   }
1866   if ( ! ActiveWidth.empty() ) {
1867     fprintf(stream, "  %22s = %d\n",  "ActiveWidth", ActiveWidth.get());
1868   }
1869   if ( ! ActiveHeight.empty() ) {
1870     fprintf(stream, "  %22s = %d\n",  "ActiveHeight", ActiveHeight.get());
1871   }
1872   if ( ! ActiveXOffset.empty() ) {
1873     fprintf(stream, "  %22s = %d\n",  "ActiveXOffset", ActiveXOffset.get());
1874   }
1875   if ( ! ActiveYOffset.empty() ) {
1876     fprintf(stream, "  %22s = %d\n",  "ActiveYOffset", ActiveYOffset.get());
1877   }
1878 }
1879
1880 //
1881 ASDCP::Result_t
1882 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1883 {
1884   return InterchangeObject::InitFromBuffer(p, l);
1885 }
1886
1887 //
1888 ASDCP::Result_t
1889 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1890 {
1891   return InterchangeObject::WriteToBuffer(Buffer);
1892 }
1893
1894 //------------------------------------------------------------------------------------------
1895 // RGBAEssenceDescriptor
1896
1897 //
1898
1899 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d)
1900 {
1901   assert(m_Dict);
1902   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1903 }
1904
1905 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1906 {
1907   assert(m_Dict);
1908   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1909   Copy(rhs);
1910 }
1911
1912
1913 //
1914 ASDCP::Result_t
1915 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1916 {
1917   assert(m_Dict);
1918   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1919   if ( ASDCP_SUCCESS(result) ) {
1920     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1921     ComponentMaxRef.set_has_value( result == RESULT_OK );
1922   }
1923   if ( ASDCP_SUCCESS(result) ) {
1924     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1925     ComponentMinRef.set_has_value( result == RESULT_OK );
1926   }
1927   if ( ASDCP_SUCCESS(result) ) {
1928     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1929     AlphaMinRef.set_has_value( result == RESULT_OK );
1930   }
1931   if ( ASDCP_SUCCESS(result) ) {
1932     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
1933     AlphaMaxRef.set_has_value( result == RESULT_OK );
1934   }
1935   if ( ASDCP_SUCCESS(result) ) {
1936     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
1937     ScanningDirection.set_has_value( result == RESULT_OK );
1938   }
1939   return result;
1940 }
1941
1942 //
1943 ASDCP::Result_t
1944 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1945 {
1946   assert(m_Dict);
1947   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1948   if ( ASDCP_SUCCESS(result)  && ! ComponentMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1949   if ( ASDCP_SUCCESS(result)  && ! ComponentMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1950   if ( ASDCP_SUCCESS(result)  && ! AlphaMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1951   if ( ASDCP_SUCCESS(result)  && ! AlphaMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
1952   if ( ASDCP_SUCCESS(result)  && ! ScanningDirection.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
1953   return result;
1954 }
1955
1956 //
1957 void
1958 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
1959 {
1960   GenericPictureEssenceDescriptor::Copy(rhs);
1961   ComponentMaxRef = rhs.ComponentMaxRef;
1962   ComponentMinRef = rhs.ComponentMinRef;
1963   AlphaMinRef = rhs.AlphaMinRef;
1964   AlphaMaxRef = rhs.AlphaMaxRef;
1965   ScanningDirection = rhs.ScanningDirection;
1966 }
1967
1968 //
1969 void
1970 RGBAEssenceDescriptor::Dump(FILE* stream)
1971 {
1972   char identbuf[IdentBufferLen];
1973   *identbuf = 0;
1974
1975   if ( stream == 0 )
1976     stream = stderr;
1977
1978   GenericPictureEssenceDescriptor::Dump(stream);
1979   if ( ! ComponentMaxRef.empty() ) {
1980     fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef.get());
1981   }
1982   if ( ! ComponentMinRef.empty() ) {
1983     fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef.get());
1984   }
1985   if ( ! AlphaMinRef.empty() ) {
1986     fprintf(stream, "  %22s = %d\n",  "AlphaMinRef", AlphaMinRef.get());
1987   }
1988   if ( ! AlphaMaxRef.empty() ) {
1989     fprintf(stream, "  %22s = %d\n",  "AlphaMaxRef", AlphaMaxRef.get());
1990   }
1991   if ( ! ScanningDirection.empty() ) {
1992     fprintf(stream, "  %22s = %d\n",  "ScanningDirection", ScanningDirection.get());
1993   }
1994 }
1995
1996 //
1997 ASDCP::Result_t
1998 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1999 {
2000   return InterchangeObject::InitFromBuffer(p, l);
2001 }
2002
2003 //
2004 ASDCP::Result_t
2005 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2006 {
2007   return InterchangeObject::WriteToBuffer(Buffer);
2008 }
2009
2010 //------------------------------------------------------------------------------------------
2011 // JPEG2000PictureSubDescriptor
2012
2013 //
2014
2015 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)
2016 {
2017   assert(m_Dict);
2018   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2019 }
2020
2021 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2022 {
2023   assert(m_Dict);
2024   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2025   Copy(rhs);
2026 }
2027
2028
2029 //
2030 ASDCP::Result_t
2031 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2032 {
2033   assert(m_Dict);
2034   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2035   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2036   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2037   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2038   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2039   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2040   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2041   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2042   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2043   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2044   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
2045   if ( ASDCP_SUCCESS(result) ) {
2046     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2047     PictureComponentSizing.set_has_value( result == RESULT_OK );
2048   }
2049   if ( ASDCP_SUCCESS(result) ) {
2050     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2051     CodingStyleDefault.set_has_value( result == RESULT_OK );
2052   }
2053   if ( ASDCP_SUCCESS(result) ) {
2054     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2055     QuantizationDefault.set_has_value( result == RESULT_OK );
2056   }
2057   if ( ASDCP_SUCCESS(result) ) {
2058     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2059     J2CLayout.set_has_value( result == RESULT_OK );
2060   }
2061   return result;
2062 }
2063
2064 //
2065 ASDCP::Result_t
2066 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2067 {
2068   assert(m_Dict);
2069   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2070   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2071   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2072   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2073   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2074   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2075   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2076   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2077   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2078   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2079   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
2080   if ( ASDCP_SUCCESS(result)  && ! PictureComponentSizing.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2081   if ( ASDCP_SUCCESS(result)  && ! CodingStyleDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2082   if ( ASDCP_SUCCESS(result)  && ! QuantizationDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2083   if ( ASDCP_SUCCESS(result)  && ! J2CLayout.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2084   return result;
2085 }
2086
2087 //
2088 void
2089 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
2090 {
2091   InterchangeObject::Copy(rhs);
2092   Rsize = rhs.Rsize;
2093   Xsize = rhs.Xsize;
2094   Ysize = rhs.Ysize;
2095   XOsize = rhs.XOsize;
2096   YOsize = rhs.YOsize;
2097   XTsize = rhs.XTsize;
2098   YTsize = rhs.YTsize;
2099   XTOsize = rhs.XTOsize;
2100   YTOsize = rhs.YTOsize;
2101   Csize = rhs.Csize;
2102   PictureComponentSizing = rhs.PictureComponentSizing;
2103   CodingStyleDefault = rhs.CodingStyleDefault;
2104   QuantizationDefault = rhs.QuantizationDefault;
2105   J2CLayout = rhs.J2CLayout;
2106 }
2107
2108 //
2109 void
2110 JPEG2000PictureSubDescriptor::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 = %d\n",  "Rsize", Rsize);
2120   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
2121   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
2122   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
2123   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
2124   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
2125   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
2126   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
2127   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
2128   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
2129   if ( ! PictureComponentSizing.empty() ) {
2130     fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.get().EncodeString(identbuf, IdentBufferLen));
2131   }
2132   if ( ! CodingStyleDefault.empty() ) {
2133     fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.get().EncodeString(identbuf, IdentBufferLen));
2134   }
2135   if ( ! QuantizationDefault.empty() ) {
2136     fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.get().EncodeString(identbuf, IdentBufferLen));
2137   }
2138   if ( ! J2CLayout.empty() ) {
2139     fprintf(stream, "  %22s = %s\n",  "J2CLayout", J2CLayout.get().EncodeString(identbuf, IdentBufferLen));
2140   }
2141 }
2142
2143 //
2144 ASDCP::Result_t
2145 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2146 {
2147   return InterchangeObject::InitFromBuffer(p, l);
2148 }
2149
2150 //
2151 ASDCP::Result_t
2152 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2153 {
2154   return InterchangeObject::WriteToBuffer(Buffer);
2155 }
2156
2157 //------------------------------------------------------------------------------------------
2158 // CDCIEssenceDescriptor
2159
2160 //
2161
2162 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0)
2163 {
2164   assert(m_Dict);
2165   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2166 }
2167
2168 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2169 {
2170   assert(m_Dict);
2171   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2172   Copy(rhs);
2173 }
2174
2175
2176 //
2177 ASDCP::Result_t
2178 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2179 {
2180   assert(m_Dict);
2181   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
2182   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2183   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2184   if ( ASDCP_SUCCESS(result) ) {
2185     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2186     VerticalSubsampling.set_has_value( result == RESULT_OK );
2187   }
2188   if ( ASDCP_SUCCESS(result) ) {
2189     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2190     ColorSiting.set_has_value( result == RESULT_OK );
2191   }
2192   if ( ASDCP_SUCCESS(result) ) {
2193     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2194     ReversedByteOrder.set_has_value( result == RESULT_OK );
2195   }
2196   if ( ASDCP_SUCCESS(result) ) {
2197     result = TLVSet.ReadUi16(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2198     PaddingBits.set_has_value( result == RESULT_OK );
2199   }
2200   if ( ASDCP_SUCCESS(result) ) {
2201     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2202     AlphaSampleDepth.set_has_value( result == RESULT_OK );
2203   }
2204   if ( ASDCP_SUCCESS(result) ) {
2205     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2206     BlackRefLevel.set_has_value( result == RESULT_OK );
2207   }
2208   if ( ASDCP_SUCCESS(result) ) {
2209     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2210     WhiteReflevel.set_has_value( result == RESULT_OK );
2211   }
2212   if ( ASDCP_SUCCESS(result) ) {
2213     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2214     ColorRange.set_has_value( result == RESULT_OK );
2215   }
2216   return result;
2217 }
2218
2219 //
2220 ASDCP::Result_t
2221 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2222 {
2223   assert(m_Dict);
2224   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2225   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2226   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2227   if ( ASDCP_SUCCESS(result)  && ! VerticalSubsampling.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2228   if ( ASDCP_SUCCESS(result)  && ! ColorSiting.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2229   if ( ASDCP_SUCCESS(result)  && ! ReversedByteOrder.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2230   if ( ASDCP_SUCCESS(result)  && ! PaddingBits.empty() ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2231   if ( ASDCP_SUCCESS(result)  && ! AlphaSampleDepth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2232   if ( ASDCP_SUCCESS(result)  && ! BlackRefLevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2233   if ( ASDCP_SUCCESS(result)  && ! WhiteReflevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2234   if ( ASDCP_SUCCESS(result)  && ! ColorRange.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2235   return result;
2236 }
2237
2238 //
2239 void
2240 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
2241 {
2242   GenericPictureEssenceDescriptor::Copy(rhs);
2243   ComponentDepth = rhs.ComponentDepth;
2244   HorizontalSubsampling = rhs.HorizontalSubsampling;
2245   VerticalSubsampling = rhs.VerticalSubsampling;
2246   ColorSiting = rhs.ColorSiting;
2247   ReversedByteOrder = rhs.ReversedByteOrder;
2248   PaddingBits = rhs.PaddingBits;
2249   AlphaSampleDepth = rhs.AlphaSampleDepth;
2250   BlackRefLevel = rhs.BlackRefLevel;
2251   WhiteReflevel = rhs.WhiteReflevel;
2252   ColorRange = rhs.ColorRange;
2253 }
2254
2255 //
2256 void
2257 CDCIEssenceDescriptor::Dump(FILE* stream)
2258 {
2259   char identbuf[IdentBufferLen];
2260   *identbuf = 0;
2261
2262   if ( stream == 0 )
2263     stream = stderr;
2264
2265   GenericPictureEssenceDescriptor::Dump(stream);
2266   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
2267   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
2268   if ( ! VerticalSubsampling.empty() ) {
2269     fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling.get());
2270   }
2271   if ( ! ColorSiting.empty() ) {
2272     fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting.get());
2273   }
2274   if ( ! ReversedByteOrder.empty() ) {
2275     fprintf(stream, "  %22s = %d\n",  "ReversedByteOrder", ReversedByteOrder.get());
2276   }
2277   if ( ! PaddingBits.empty() ) {
2278     fprintf(stream, "  %22s = %d\n",  "PaddingBits", PaddingBits.get());
2279   }
2280   if ( ! AlphaSampleDepth.empty() ) {
2281     fprintf(stream, "  %22s = %d\n",  "AlphaSampleDepth", AlphaSampleDepth.get());
2282   }
2283   if ( ! BlackRefLevel.empty() ) {
2284     fprintf(stream, "  %22s = %d\n",  "BlackRefLevel", BlackRefLevel.get());
2285   }
2286   if ( ! WhiteReflevel.empty() ) {
2287     fprintf(stream, "  %22s = %d\n",  "WhiteReflevel", WhiteReflevel.get());
2288   }
2289   if ( ! ColorRange.empty() ) {
2290     fprintf(stream, "  %22s = %d\n",  "ColorRange", ColorRange.get());
2291   }
2292 }
2293
2294 //
2295 ASDCP::Result_t
2296 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2297 {
2298   return InterchangeObject::InitFromBuffer(p, l);
2299 }
2300
2301 //
2302 ASDCP::Result_t
2303 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2304 {
2305   return InterchangeObject::WriteToBuffer(Buffer);
2306 }
2307
2308 //------------------------------------------------------------------------------------------
2309 // MPEG2VideoDescriptor
2310
2311 //
2312
2313 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d)
2314 {
2315   assert(m_Dict);
2316   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2317 }
2318
2319 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2320 {
2321   assert(m_Dict);
2322   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2323   Copy(rhs);
2324 }
2325
2326
2327 //
2328 ASDCP::Result_t
2329 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2330 {
2331   assert(m_Dict);
2332   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
2333   if ( ASDCP_SUCCESS(result) ) {
2334     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2335     SingleSequence.set_has_value( result == RESULT_OK );
2336   }
2337   if ( ASDCP_SUCCESS(result) ) {
2338     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2339     ConstantBFrames.set_has_value( result == RESULT_OK );
2340   }
2341   if ( ASDCP_SUCCESS(result) ) {
2342     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2343     CodedContentType.set_has_value( result == RESULT_OK );
2344   }
2345   if ( ASDCP_SUCCESS(result) ) {
2346     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2347     LowDelay.set_has_value( result == RESULT_OK );
2348   }
2349   if ( ASDCP_SUCCESS(result) ) {
2350     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2351     ClosedGOP.set_has_value( result == RESULT_OK );
2352   }
2353   if ( ASDCP_SUCCESS(result) ) {
2354     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2355     IdenticalGOP.set_has_value( result == RESULT_OK );
2356   }
2357   if ( ASDCP_SUCCESS(result) ) {
2358     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2359     MaxGOP.set_has_value( result == RESULT_OK );
2360   }
2361   if ( ASDCP_SUCCESS(result) ) {
2362     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2363     BPictureCount.set_has_value( result == RESULT_OK );
2364   }
2365   if ( ASDCP_SUCCESS(result) ) {
2366     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2367     BitRate.set_has_value( result == RESULT_OK );
2368   }
2369   if ( ASDCP_SUCCESS(result) ) {
2370     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2371     ProfileAndLevel.set_has_value( result == RESULT_OK );
2372   }
2373   return result;
2374 }
2375
2376 //
2377 ASDCP::Result_t
2378 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2379 {
2380   assert(m_Dict);
2381   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
2382   if ( ASDCP_SUCCESS(result)  && ! SingleSequence.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2383   if ( ASDCP_SUCCESS(result)  && ! ConstantBFrames.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2384   if ( ASDCP_SUCCESS(result)  && ! CodedContentType.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2385   if ( ASDCP_SUCCESS(result)  && ! LowDelay.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2386   if ( ASDCP_SUCCESS(result)  && ! ClosedGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2387   if ( ASDCP_SUCCESS(result)  && ! IdenticalGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2388   if ( ASDCP_SUCCESS(result)  && ! MaxGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2389   if ( ASDCP_SUCCESS(result)  && ! BPictureCount.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2390   if ( ASDCP_SUCCESS(result)  && ! BitRate.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2391   if ( ASDCP_SUCCESS(result)  && ! ProfileAndLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2392   return result;
2393 }
2394
2395 //
2396 void
2397 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
2398 {
2399   CDCIEssenceDescriptor::Copy(rhs);
2400   SingleSequence = rhs.SingleSequence;
2401   ConstantBFrames = rhs.ConstantBFrames;
2402   CodedContentType = rhs.CodedContentType;
2403   LowDelay = rhs.LowDelay;
2404   ClosedGOP = rhs.ClosedGOP;
2405   IdenticalGOP = rhs.IdenticalGOP;
2406   MaxGOP = rhs.MaxGOP;
2407   BPictureCount = rhs.BPictureCount;
2408   BitRate = rhs.BitRate;
2409   ProfileAndLevel = rhs.ProfileAndLevel;
2410 }
2411
2412 //
2413 void
2414 MPEG2VideoDescriptor::Dump(FILE* stream)
2415 {
2416   char identbuf[IdentBufferLen];
2417   *identbuf = 0;
2418
2419   if ( stream == 0 )
2420     stream = stderr;
2421
2422   CDCIEssenceDescriptor::Dump(stream);
2423   if ( ! SingleSequence.empty() ) {
2424     fprintf(stream, "  %22s = %d\n",  "SingleSequence", SingleSequence.get());
2425   }
2426   if ( ! ConstantBFrames.empty() ) {
2427     fprintf(stream, "  %22s = %d\n",  "ConstantBFrames", ConstantBFrames.get());
2428   }
2429   if ( ! CodedContentType.empty() ) {
2430     fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType.get());
2431   }
2432   if ( ! LowDelay.empty() ) {
2433     fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay.get());
2434   }
2435   if ( ! ClosedGOP.empty() ) {
2436     fprintf(stream, "  %22s = %d\n",  "ClosedGOP", ClosedGOP.get());
2437   }
2438   if ( ! IdenticalGOP.empty() ) {
2439     fprintf(stream, "  %22s = %d\n",  "IdenticalGOP", IdenticalGOP.get());
2440   }
2441   if ( ! MaxGOP.empty() ) {
2442     fprintf(stream, "  %22s = %d\n",  "MaxGOP", MaxGOP.get());
2443   }
2444   if ( ! BPictureCount.empty() ) {
2445     fprintf(stream, "  %22s = %d\n",  "BPictureCount", BPictureCount.get());
2446   }
2447   if ( ! BitRate.empty() ) {
2448     fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate.get());
2449   }
2450   if ( ! ProfileAndLevel.empty() ) {
2451     fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel.get());
2452   }
2453 }
2454
2455 //
2456 ASDCP::Result_t
2457 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2458 {
2459   return InterchangeObject::InitFromBuffer(p, l);
2460 }
2461
2462 //
2463 ASDCP::Result_t
2464 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2465 {
2466   return InterchangeObject::WriteToBuffer(Buffer);
2467 }
2468
2469 //------------------------------------------------------------------------------------------
2470 // DMSegment
2471
2472 //
2473
2474 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
2475 {
2476   assert(m_Dict);
2477   m_UL = m_Dict->ul(MDD_DMSegment);
2478 }
2479
2480 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2481 {
2482   assert(m_Dict);
2483   m_UL = m_Dict->ul(MDD_DMSegment);
2484   Copy(rhs);
2485 }
2486
2487
2488 //
2489 ASDCP::Result_t
2490 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
2491 {
2492   assert(m_Dict);
2493   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2494   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
2495   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
2496   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
2497   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
2498   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2499   return result;
2500 }
2501
2502 //
2503 ASDCP::Result_t
2504 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2505 {
2506   assert(m_Dict);
2507   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2508   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2509   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
2510   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
2511   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
2512   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2513   return result;
2514 }
2515
2516 //
2517 void
2518 DMSegment::Copy(const DMSegment& rhs)
2519 {
2520   InterchangeObject::Copy(rhs);
2521   DataDefinition = rhs.DataDefinition;
2522   EventStartPosition = rhs.EventStartPosition;
2523   Duration = rhs.Duration;
2524   EventComment = rhs.EventComment;
2525   DMFramework = rhs.DMFramework;
2526 }
2527
2528 //
2529 void
2530 DMSegment::Dump(FILE* stream)
2531 {
2532   char identbuf[IdentBufferLen];
2533   *identbuf = 0;
2534
2535   if ( stream == 0 )
2536     stream = stderr;
2537
2538   InterchangeObject::Dump(stream);
2539   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2540   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
2541   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
2542   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
2543   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2544 }
2545
2546 //
2547 ASDCP::Result_t
2548 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2549 {
2550   return InterchangeObject::InitFromBuffer(p, l);
2551 }
2552
2553 //
2554 ASDCP::Result_t
2555 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2556 {
2557   return InterchangeObject::WriteToBuffer(Buffer);
2558 }
2559
2560 //------------------------------------------------------------------------------------------
2561 // CryptographicFramework
2562
2563 //
2564
2565 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2566 {
2567   assert(m_Dict);
2568   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2569 }
2570
2571 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2572 {
2573   assert(m_Dict);
2574   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2575   Copy(rhs);
2576 }
2577
2578
2579 //
2580 ASDCP::Result_t
2581 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2582 {
2583   assert(m_Dict);
2584   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2585   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2586   return result;
2587 }
2588
2589 //
2590 ASDCP::Result_t
2591 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2592 {
2593   assert(m_Dict);
2594   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2595   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2596   return result;
2597 }
2598
2599 //
2600 void
2601 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2602 {
2603   InterchangeObject::Copy(rhs);
2604   ContextSR = rhs.ContextSR;
2605 }
2606
2607 //
2608 void
2609 CryptographicFramework::Dump(FILE* stream)
2610 {
2611   char identbuf[IdentBufferLen];
2612   *identbuf = 0;
2613
2614   if ( stream == 0 )
2615     stream = stderr;
2616
2617   InterchangeObject::Dump(stream);
2618   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2619 }
2620
2621 //
2622 ASDCP::Result_t
2623 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2624 {
2625   return InterchangeObject::InitFromBuffer(p, l);
2626 }
2627
2628 //
2629 ASDCP::Result_t
2630 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2631 {
2632   return InterchangeObject::WriteToBuffer(Buffer);
2633 }
2634
2635 //------------------------------------------------------------------------------------------
2636 // CryptographicContext
2637
2638 //
2639
2640 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2641 {
2642   assert(m_Dict);
2643   m_UL = m_Dict->ul(MDD_CryptographicContext);
2644 }
2645
2646 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2647 {
2648   assert(m_Dict);
2649   m_UL = m_Dict->ul(MDD_CryptographicContext);
2650   Copy(rhs);
2651 }
2652
2653
2654 //
2655 ASDCP::Result_t
2656 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2657 {
2658   assert(m_Dict);
2659   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2660   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2661   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2662   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2663   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2664   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2665   return result;
2666 }
2667
2668 //
2669 ASDCP::Result_t
2670 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2671 {
2672   assert(m_Dict);
2673   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2674   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2675   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2676   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2677   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2678   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2679   return result;
2680 }
2681
2682 //
2683 void
2684 CryptographicContext::Copy(const CryptographicContext& rhs)
2685 {
2686   InterchangeObject::Copy(rhs);
2687   ContextID = rhs.ContextID;
2688   SourceEssenceContainer = rhs.SourceEssenceContainer;
2689   CipherAlgorithm = rhs.CipherAlgorithm;
2690   MICAlgorithm = rhs.MICAlgorithm;
2691   CryptographicKeyID = rhs.CryptographicKeyID;
2692 }
2693
2694 //
2695 void
2696 CryptographicContext::Dump(FILE* stream)
2697 {
2698   char identbuf[IdentBufferLen];
2699   *identbuf = 0;
2700
2701   if ( stream == 0 )
2702     stream = stderr;
2703
2704   InterchangeObject::Dump(stream);
2705   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2706   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2707   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2708   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2709   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2710 }
2711
2712 //
2713 ASDCP::Result_t
2714 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2715 {
2716   return InterchangeObject::InitFromBuffer(p, l);
2717 }
2718
2719 //
2720 ASDCP::Result_t
2721 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2722 {
2723   return InterchangeObject::WriteToBuffer(Buffer);
2724 }
2725
2726 //------------------------------------------------------------------------------------------
2727 // GenericDataEssenceDescriptor
2728
2729 //
2730
2731 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
2732 {
2733   assert(m_Dict);
2734   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2735 }
2736
2737 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2738 {
2739   assert(m_Dict);
2740   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2741   Copy(rhs);
2742 }
2743
2744
2745 //
2746 ASDCP::Result_t
2747 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2748 {
2749   assert(m_Dict);
2750   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
2751   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2752   return result;
2753 }
2754
2755 //
2756 ASDCP::Result_t
2757 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2758 {
2759   assert(m_Dict);
2760   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
2761   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2762   return result;
2763 }
2764
2765 //
2766 void
2767 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
2768 {
2769   FileDescriptor::Copy(rhs);
2770   DataEssenceCoding = rhs.DataEssenceCoding;
2771 }
2772
2773 //
2774 void
2775 GenericDataEssenceDescriptor::Dump(FILE* stream)
2776 {
2777   char identbuf[IdentBufferLen];
2778   *identbuf = 0;
2779
2780   if ( stream == 0 )
2781     stream = stderr;
2782
2783   FileDescriptor::Dump(stream);
2784   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
2785 }
2786
2787 //
2788 ASDCP::Result_t
2789 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2790 {
2791   return InterchangeObject::InitFromBuffer(p, l);
2792 }
2793
2794 //
2795 ASDCP::Result_t
2796 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2797 {
2798   return InterchangeObject::WriteToBuffer(Buffer);
2799 }
2800
2801 //------------------------------------------------------------------------------------------
2802 // TimedTextDescriptor
2803
2804 //
2805
2806 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
2807 {
2808   assert(m_Dict);
2809   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2810 }
2811
2812 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2813 {
2814   assert(m_Dict);
2815   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2816   Copy(rhs);
2817 }
2818
2819
2820 //
2821 ASDCP::Result_t
2822 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2823 {
2824   assert(m_Dict);
2825   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
2826   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
2827   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
2828   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
2829   if ( ASDCP_SUCCESS(result) ) {
2830     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
2831     RFC5646LanguageTagList.set_has_value( result == RESULT_OK );
2832   }
2833   return result;
2834 }
2835
2836 //
2837 ASDCP::Result_t
2838 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2839 {
2840   assert(m_Dict);
2841   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
2842   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
2843   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
2844   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
2845   if ( ASDCP_SUCCESS(result)  && ! RFC5646LanguageTagList.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
2846   return result;
2847 }
2848
2849 //
2850 void
2851 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
2852 {
2853   GenericDataEssenceDescriptor::Copy(rhs);
2854   ResourceID = rhs.ResourceID;
2855   UCSEncoding = rhs.UCSEncoding;
2856   NamespaceURI = rhs.NamespaceURI;
2857   RFC5646LanguageTagList = rhs.RFC5646LanguageTagList;
2858 }
2859
2860 //
2861 void
2862 TimedTextDescriptor::Dump(FILE* stream)
2863 {
2864   char identbuf[IdentBufferLen];
2865   *identbuf = 0;
2866
2867   if ( stream == 0 )
2868     stream = stderr;
2869
2870   GenericDataEssenceDescriptor::Dump(stream);
2871   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
2872   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
2873   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
2874   if ( ! RFC5646LanguageTagList.empty() ) {
2875     fprintf(stream, "  %22s = %s\n",  "RFC5646LanguageTagList", RFC5646LanguageTagList.get().EncodeString(identbuf, IdentBufferLen));
2876   }
2877 }
2878
2879 //
2880 ASDCP::Result_t
2881 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2882 {
2883   return InterchangeObject::InitFromBuffer(p, l);
2884 }
2885
2886 //
2887 ASDCP::Result_t
2888 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2889 {
2890   return InterchangeObject::WriteToBuffer(Buffer);
2891 }
2892
2893 //------------------------------------------------------------------------------------------
2894 // TimedTextResourceSubDescriptor
2895
2896 //
2897
2898 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
2899 {
2900   assert(m_Dict);
2901   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2902 }
2903
2904 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2905 {
2906   assert(m_Dict);
2907   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2908   Copy(rhs);
2909 }
2910
2911
2912 //
2913 ASDCP::Result_t
2914 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2915 {
2916   assert(m_Dict);
2917   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2918   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2919   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2920   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2921   return result;
2922 }
2923
2924 //
2925 ASDCP::Result_t
2926 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2927 {
2928   assert(m_Dict);
2929   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2930   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2931   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2932   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2933   return result;
2934 }
2935
2936 //
2937 void
2938 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
2939 {
2940   InterchangeObject::Copy(rhs);
2941   AncillaryResourceID = rhs.AncillaryResourceID;
2942   MIMEMediaType = rhs.MIMEMediaType;
2943   EssenceStreamID = rhs.EssenceStreamID;
2944 }
2945
2946 //
2947 void
2948 TimedTextResourceSubDescriptor::Dump(FILE* stream)
2949 {
2950   char identbuf[IdentBufferLen];
2951   *identbuf = 0;
2952
2953   if ( stream == 0 )
2954     stream = stderr;
2955
2956   InterchangeObject::Dump(stream);
2957   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
2958   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
2959   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
2960 }
2961
2962 //
2963 ASDCP::Result_t
2964 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2965 {
2966   return InterchangeObject::InitFromBuffer(p, l);
2967 }
2968
2969 //
2970 ASDCP::Result_t
2971 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2972 {
2973   return InterchangeObject::WriteToBuffer(Buffer);
2974 }
2975
2976 //------------------------------------------------------------------------------------------
2977 // StereoscopicPictureSubDescriptor
2978
2979 //
2980
2981 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2982 {
2983   assert(m_Dict);
2984   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2985 }
2986
2987 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2988 {
2989   assert(m_Dict);
2990   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2991   Copy(rhs);
2992 }
2993
2994
2995 //
2996 ASDCP::Result_t
2997 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2998 {
2999   assert(m_Dict);
3000   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3001   return result;
3002 }
3003
3004 //
3005 ASDCP::Result_t
3006 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3007 {
3008   assert(m_Dict);
3009   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3010   return result;
3011 }
3012
3013 //
3014 void
3015 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
3016 {
3017   InterchangeObject::Copy(rhs);
3018 }
3019
3020 //
3021 void
3022 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
3023 {
3024   char identbuf[IdentBufferLen];
3025   *identbuf = 0;
3026
3027   if ( stream == 0 )
3028     stream = stderr;
3029
3030   InterchangeObject::Dump(stream);
3031 }
3032
3033 //
3034 ASDCP::Result_t
3035 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3036 {
3037   return InterchangeObject::InitFromBuffer(p, l);
3038 }
3039
3040 //
3041 ASDCP::Result_t
3042 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3043 {
3044   return InterchangeObject::WriteToBuffer(Buffer);
3045 }
3046
3047 //------------------------------------------------------------------------------------------
3048 // ContainerConstraintSubDescriptor
3049
3050 //
3051
3052 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3053 {
3054   assert(m_Dict);
3055   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3056 }
3057
3058 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3059 {
3060   assert(m_Dict);
3061   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3062   Copy(rhs);
3063 }
3064
3065
3066 //
3067 ASDCP::Result_t
3068 ContainerConstraintSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3069 {
3070   assert(m_Dict);
3071   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3072   return result;
3073 }
3074
3075 //
3076 ASDCP::Result_t
3077 ContainerConstraintSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3078 {
3079   assert(m_Dict);
3080   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3081   return result;
3082 }
3083
3084 //
3085 void
3086 ContainerConstraintSubDescriptor::Copy(const ContainerConstraintSubDescriptor& rhs)
3087 {
3088   InterchangeObject::Copy(rhs);
3089 }
3090
3091 //
3092 void
3093 ContainerConstraintSubDescriptor::Dump(FILE* stream)
3094 {
3095   char identbuf[IdentBufferLen];
3096   *identbuf = 0;
3097
3098   if ( stream == 0 )
3099     stream = stderr;
3100
3101   InterchangeObject::Dump(stream);
3102 }
3103
3104 //
3105 ASDCP::Result_t
3106 ContainerConstraintSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3107 {
3108   return InterchangeObject::InitFromBuffer(p, l);
3109 }
3110
3111 //
3112 ASDCP::Result_t
3113 ContainerConstraintSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3114 {
3115   return InterchangeObject::WriteToBuffer(Buffer);
3116 }
3117
3118 //------------------------------------------------------------------------------------------
3119 // NetworkLocator
3120
3121 //
3122
3123 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3124 {
3125   assert(m_Dict);
3126   m_UL = m_Dict->ul(MDD_NetworkLocator);
3127 }
3128
3129 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3130 {
3131   assert(m_Dict);
3132   m_UL = m_Dict->ul(MDD_NetworkLocator);
3133   Copy(rhs);
3134 }
3135
3136
3137 //
3138 ASDCP::Result_t
3139 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
3140 {
3141   assert(m_Dict);
3142   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3143   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
3144   return result;
3145 }
3146
3147 //
3148 ASDCP::Result_t
3149 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
3150 {
3151   assert(m_Dict);
3152   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3153   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
3154   return result;
3155 }
3156
3157 //
3158 void
3159 NetworkLocator::Copy(const NetworkLocator& rhs)
3160 {
3161   InterchangeObject::Copy(rhs);
3162   URLString = rhs.URLString;
3163 }
3164
3165 //
3166 void
3167 NetworkLocator::Dump(FILE* stream)
3168 {
3169   char identbuf[IdentBufferLen];
3170   *identbuf = 0;
3171
3172   if ( stream == 0 )
3173     stream = stderr;
3174
3175   InterchangeObject::Dump(stream);
3176   fprintf(stream, "  %22s = %s\n",  "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
3177 }
3178
3179 //
3180 ASDCP::Result_t
3181 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
3182 {
3183   return InterchangeObject::InitFromBuffer(p, l);
3184 }
3185
3186 //
3187 ASDCP::Result_t
3188 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3189 {
3190   return InterchangeObject::WriteToBuffer(Buffer);
3191 }
3192
3193 //------------------------------------------------------------------------------------------
3194 // MCALabelSubDescriptor
3195
3196 //
3197
3198 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3199 {
3200   assert(m_Dict);
3201   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3202 }
3203
3204 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3205 {
3206   assert(m_Dict);
3207   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3208   Copy(rhs);
3209 }
3210
3211
3212 //
3213 ASDCP::Result_t
3214 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3215 {
3216   assert(m_Dict);
3217   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3218   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3219   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
3220   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3221   if ( ASDCP_SUCCESS(result) ) {
3222     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3223     MCATagName.set_has_value( result == RESULT_OK );
3224   }
3225   if ( ASDCP_SUCCESS(result) ) {
3226     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3227     MCAChannelID.set_has_value( result == RESULT_OK );
3228   }
3229   if ( ASDCP_SUCCESS(result) ) {
3230     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3231     RFC5646SpokenLanguage.set_has_value( result == RESULT_OK );
3232   }
3233   return result;
3234 }
3235
3236 //
3237 ASDCP::Result_t
3238 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3239 {
3240   assert(m_Dict);
3241   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3242   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3243   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
3244   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3245   if ( ASDCP_SUCCESS(result)  && ! MCATagName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3246   if ( ASDCP_SUCCESS(result)  && ! MCAChannelID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3247   if ( ASDCP_SUCCESS(result)  && ! RFC5646SpokenLanguage.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3248   return result;
3249 }
3250
3251 //
3252 void
3253 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
3254 {
3255   InterchangeObject::Copy(rhs);
3256   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
3257   MCALinkID = rhs.MCALinkID;
3258   MCATagSymbol = rhs.MCATagSymbol;
3259   MCATagName = rhs.MCATagName;
3260   MCAChannelID = rhs.MCAChannelID;
3261   RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
3262 }
3263
3264 //
3265 void
3266 MCALabelSubDescriptor::Dump(FILE* stream)
3267 {
3268   char identbuf[IdentBufferLen];
3269   *identbuf = 0;
3270
3271   if ( stream == 0 )
3272     stream = stderr;
3273
3274   InterchangeObject::Dump(stream);
3275   fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
3276   fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
3277   fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
3278   if ( ! MCATagName.empty() ) {
3279     fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.get().EncodeString(identbuf, IdentBufferLen));
3280   }
3281   if ( ! MCAChannelID.empty() ) {
3282     fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID.get());
3283   }
3284   if ( ! RFC5646SpokenLanguage.empty() ) {
3285     fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.get().EncodeString(identbuf, IdentBufferLen));
3286   }
3287 }
3288
3289 //
3290 ASDCP::Result_t
3291 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3292 {
3293   return InterchangeObject::InitFromBuffer(p, l);
3294 }
3295
3296 //
3297 ASDCP::Result_t
3298 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3299 {
3300   return InterchangeObject::WriteToBuffer(Buffer);
3301 }
3302
3303 //------------------------------------------------------------------------------------------
3304 // AudioChannelLabelSubDescriptor
3305
3306 //
3307
3308 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3309 {
3310   assert(m_Dict);
3311   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3312 }
3313
3314 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3315 {
3316   assert(m_Dict);
3317   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3318   Copy(rhs);
3319 }
3320
3321
3322 //
3323 ASDCP::Result_t
3324 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3325 {
3326   assert(m_Dict);
3327   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3328   if ( ASDCP_SUCCESS(result) ) {
3329     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3330     SoundfieldGroupLinkID.set_has_value( result == RESULT_OK );
3331   }
3332   return result;
3333 }
3334
3335 //
3336 ASDCP::Result_t
3337 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3338 {
3339   assert(m_Dict);
3340   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3341   if ( ASDCP_SUCCESS(result)  && ! SoundfieldGroupLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3342   return result;
3343 }
3344
3345 //
3346 void
3347 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
3348 {
3349   MCALabelSubDescriptor::Copy(rhs);
3350   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
3351 }
3352
3353 //
3354 void
3355 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
3356 {
3357   char identbuf[IdentBufferLen];
3358   *identbuf = 0;
3359
3360   if ( stream == 0 )
3361     stream = stderr;
3362
3363   MCALabelSubDescriptor::Dump(stream);
3364   if ( ! SoundfieldGroupLinkID.empty() ) {
3365     fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.get().EncodeString(identbuf, IdentBufferLen));
3366   }
3367 }
3368
3369 //
3370 ASDCP::Result_t
3371 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3372 {
3373   return InterchangeObject::InitFromBuffer(p, l);
3374 }
3375
3376 //
3377 ASDCP::Result_t
3378 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3379 {
3380   return InterchangeObject::WriteToBuffer(Buffer);
3381 }
3382
3383 //------------------------------------------------------------------------------------------
3384 // SoundfieldGroupLabelSubDescriptor
3385
3386 //
3387
3388 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3389 {
3390   assert(m_Dict);
3391   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3392 }
3393
3394 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3395 {
3396   assert(m_Dict);
3397   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3398   Copy(rhs);
3399 }
3400
3401
3402 //
3403 ASDCP::Result_t
3404 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3405 {
3406   assert(m_Dict);
3407   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3408   if ( ASDCP_SUCCESS(result) ) {
3409     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3410   }
3411   return result;
3412 }
3413
3414 //
3415 ASDCP::Result_t
3416 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3417 {
3418   assert(m_Dict);
3419   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3420   if ( ASDCP_SUCCESS(result)  && ! GroupOfSoundfieldGroupsLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3421   return result;
3422 }
3423
3424 //
3425 void
3426 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
3427 {
3428   MCALabelSubDescriptor::Copy(rhs);
3429   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
3430 }
3431
3432 //
3433 void
3434 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
3435 {
3436   char identbuf[IdentBufferLen];
3437   *identbuf = 0;
3438
3439   if ( stream == 0 )
3440     stream = stderr;
3441
3442   MCALabelSubDescriptor::Dump(stream);
3443   if ( ! GroupOfSoundfieldGroupsLinkID.empty() ) {
3444     fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
3445   GroupOfSoundfieldGroupsLinkID.get().Dump(stream);
3446   }
3447 }
3448
3449 //
3450 ASDCP::Result_t
3451 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3452 {
3453   return InterchangeObject::InitFromBuffer(p, l);
3454 }
3455
3456 //
3457 ASDCP::Result_t
3458 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3459 {
3460   return InterchangeObject::WriteToBuffer(Buffer);
3461 }
3462
3463 //------------------------------------------------------------------------------------------
3464 // GroupOfSoundfieldGroupsLabelSubDescriptor
3465
3466 //
3467
3468 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3469 {
3470   assert(m_Dict);
3471   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3472 }
3473
3474 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3475 {
3476   assert(m_Dict);
3477   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3478   Copy(rhs);
3479 }
3480
3481
3482 //
3483 ASDCP::Result_t
3484 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3485 {
3486   assert(m_Dict);
3487   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3488   return result;
3489 }
3490
3491 //
3492 ASDCP::Result_t
3493 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3494 {
3495   assert(m_Dict);
3496   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3497   return result;
3498 }
3499
3500 //
3501 void
3502 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
3503 {
3504   MCALabelSubDescriptor::Copy(rhs);
3505 }
3506
3507 //
3508 void
3509 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
3510 {
3511   char identbuf[IdentBufferLen];
3512   *identbuf = 0;
3513
3514   if ( stream == 0 )
3515     stream = stderr;
3516
3517   MCALabelSubDescriptor::Dump(stream);
3518 }
3519
3520 //
3521 ASDCP::Result_t
3522 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3523 {
3524   return InterchangeObject::InitFromBuffer(p, l);
3525 }
3526
3527 //
3528 ASDCP::Result_t
3529 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3530 {
3531   return InterchangeObject::WriteToBuffer(Buffer);
3532 }
3533
3534 //------------------------------------------------------------------------------------------
3535 // DCDataDescriptor
3536
3537 //
3538
3539 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3540 {
3541   assert(m_Dict);
3542   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3543 }
3544
3545 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3546 {
3547   assert(m_Dict);
3548   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3549   Copy(rhs);
3550 }
3551
3552
3553 //
3554 ASDCP::Result_t
3555 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3556 {
3557   assert(m_Dict);
3558   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3559   return result;
3560 }
3561
3562 //
3563 ASDCP::Result_t
3564 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3565 {
3566   assert(m_Dict);
3567   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3568   return result;
3569 }
3570
3571 //
3572 void
3573 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
3574 {
3575   GenericDataEssenceDescriptor::Copy(rhs);
3576 }
3577
3578 //
3579 void
3580 DCDataDescriptor::Dump(FILE* stream)
3581 {
3582   char identbuf[IdentBufferLen];
3583   *identbuf = 0;
3584
3585   if ( stream == 0 )
3586     stream = stderr;
3587
3588   GenericDataEssenceDescriptor::Dump(stream);
3589 }
3590
3591 //
3592 ASDCP::Result_t
3593 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3594 {
3595   return InterchangeObject::InitFromBuffer(p, l);
3596 }
3597
3598 //
3599 ASDCP::Result_t
3600 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3601 {
3602   return InterchangeObject::WriteToBuffer(Buffer);
3603 }
3604
3605 //------------------------------------------------------------------------------------------
3606 // PrivateDCDataDescriptor
3607
3608 //
3609
3610 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3611 {
3612   assert(m_Dict);
3613   m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3614 }
3615
3616 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3617 {
3618   assert(m_Dict);
3619   m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3620   Copy(rhs);
3621 }
3622
3623
3624 //
3625 ASDCP::Result_t
3626 PrivateDCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3627 {
3628   assert(m_Dict);
3629   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3630   return result;
3631 }
3632
3633 //
3634 ASDCP::Result_t
3635 PrivateDCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3636 {
3637   assert(m_Dict);
3638   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3639   return result;
3640 }
3641
3642 //
3643 void
3644 PrivateDCDataDescriptor::Copy(const PrivateDCDataDescriptor& rhs)
3645 {
3646   GenericDataEssenceDescriptor::Copy(rhs);
3647 }
3648
3649 //
3650 void
3651 PrivateDCDataDescriptor::Dump(FILE* stream)
3652 {
3653   char identbuf[IdentBufferLen];
3654   *identbuf = 0;
3655
3656   if ( stream == 0 )
3657     stream = stderr;
3658
3659   GenericDataEssenceDescriptor::Dump(stream);
3660 }
3661
3662 //
3663 ASDCP::Result_t
3664 PrivateDCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3665 {
3666   return InterchangeObject::InitFromBuffer(p, l);
3667 }
3668
3669 //
3670 ASDCP::Result_t
3671 PrivateDCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3672 {
3673   return InterchangeObject::WriteToBuffer(Buffer);
3674 }
3675
3676 //------------------------------------------------------------------------------------------
3677 // DolbyAtmosSubDescriptor
3678
3679 //
3680
3681 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
3682 {
3683   assert(m_Dict);
3684   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3685 }
3686
3687 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3688 {
3689   assert(m_Dict);
3690   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3691   Copy(rhs);
3692 }
3693
3694
3695 //
3696 ASDCP::Result_t
3697 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3698 {
3699   assert(m_Dict);
3700   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3701   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3702   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3703   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3704   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3705   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3706   return result;
3707 }
3708
3709 //
3710 ASDCP::Result_t
3711 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3712 {
3713   assert(m_Dict);
3714   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3715   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3716   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3717   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3718   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3719   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3720   return result;
3721 }
3722
3723 //
3724 void
3725 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
3726 {
3727   InterchangeObject::Copy(rhs);
3728   AtmosID = rhs.AtmosID;
3729   FirstFrame = rhs.FirstFrame;
3730   MaxChannelCount = rhs.MaxChannelCount;
3731   MaxObjectCount = rhs.MaxObjectCount;
3732   AtmosVersion = rhs.AtmosVersion;
3733 }
3734
3735 //
3736 void
3737 DolbyAtmosSubDescriptor::Dump(FILE* stream)
3738 {
3739   char identbuf[IdentBufferLen];
3740   *identbuf = 0;
3741
3742   if ( stream == 0 )
3743     stream = stderr;
3744
3745   InterchangeObject::Dump(stream);
3746   fprintf(stream, "  %22s = %s\n",  "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
3747   fprintf(stream, "  %22s = %d\n",  "FirstFrame", FirstFrame);
3748   fprintf(stream, "  %22s = %d\n",  "MaxChannelCount", MaxChannelCount);
3749   fprintf(stream, "  %22s = %d\n",  "MaxObjectCount", MaxObjectCount);
3750   fprintf(stream, "  %22s = %d\n",  "AtmosVersion", AtmosVersion);
3751 }
3752
3753 //
3754 ASDCP::Result_t
3755 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3756 {
3757   return InterchangeObject::InitFromBuffer(p, l);
3758 }
3759
3760 //
3761 ASDCP::Result_t
3762 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3763 {
3764   return InterchangeObject::WriteToBuffer(Buffer);
3765 }
3766
3767 //------------------------------------------------------------------------------------------
3768 // PHDRMetadataTrackSubDescriptor
3769
3770 //
3771
3772 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), SourceTrackID(0), SimplePayloadSID(0)
3773 {
3774   assert(m_Dict);
3775   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
3776 }
3777
3778 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3779 {
3780   assert(m_Dict);
3781   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
3782   Copy(rhs);
3783 }
3784
3785
3786 //
3787 ASDCP::Result_t
3788 PHDRMetadataTrackSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3789 {
3790   assert(m_Dict);
3791   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3792   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
3793   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
3794   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
3795   return result;
3796 }
3797
3798 //
3799 ASDCP::Result_t
3800 PHDRMetadataTrackSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3801 {
3802   assert(m_Dict);
3803   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3804   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
3805   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
3806   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
3807   return result;
3808 }
3809
3810 //
3811 void
3812 PHDRMetadataTrackSubDescriptor::Copy(const PHDRMetadataTrackSubDescriptor& rhs)
3813 {
3814   InterchangeObject::Copy(rhs);
3815   DataDefinition = rhs.DataDefinition;
3816   SourceTrackID = rhs.SourceTrackID;
3817   SimplePayloadSID = rhs.SimplePayloadSID;
3818 }
3819
3820 //
3821 void
3822 PHDRMetadataTrackSubDescriptor::Dump(FILE* stream)
3823 {
3824   char identbuf[IdentBufferLen];
3825   *identbuf = 0;
3826
3827   if ( stream == 0 )
3828     stream = stderr;
3829
3830   InterchangeObject::Dump(stream);
3831   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
3832   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
3833   fprintf(stream, "  %22s = %d\n",  "SimplePayloadSID", SimplePayloadSID);
3834 }
3835
3836 //
3837 ASDCP::Result_t
3838 PHDRMetadataTrackSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3839 {
3840   return InterchangeObject::InitFromBuffer(p, l);
3841 }
3842
3843 //
3844 ASDCP::Result_t
3845 PHDRMetadataTrackSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3846 {
3847   return InterchangeObject::WriteToBuffer(Buffer);
3848 }
3849
3850 //
3851 // end Metadata.cpp
3852 //