src/Metadata.cpp

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