src/Metadata.cpp

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