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: Metadata.cpp,v 1.40 2015/10/10 20:26:29 jhurst Exp $
  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), ActiveHeight(0), ActiveYOffset(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) ) {
1687     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1688   }
1689   if ( ASDCP_SUCCESS(result) ) {
1690     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1691     ActiveWidth.set_has_value( result == RESULT_OK );
1692   }
1693   if ( ASDCP_SUCCESS(result) ) {
1694     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1695     ActiveHeight.set_has_value( result == RESULT_OK );
1696   }
1697   if ( ASDCP_SUCCESS(result) ) {
1698     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1699     ActiveXOffset.set_has_value( result == RESULT_OK );
1700   }
1701   if ( ASDCP_SUCCESS(result) ) {
1702     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1703     ActiveYOffset.set_has_value( result == RESULT_OK );
1704   }
1705   return result;
1706 }
1707
1708 //
1709 ASDCP::Result_t
1710 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1711 {
1712   assert(m_Dict);
1713   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1714   if ( ASDCP_SUCCESS(result)  && ! SignalStandard.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1715   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1716   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1717   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1718   if ( ASDCP_SUCCESS(result)  && ! StoredF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1719   if ( ASDCP_SUCCESS(result)  && ! SampledWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1720   if ( ASDCP_SUCCESS(result)  && ! SampledHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1721   if ( ASDCP_SUCCESS(result)  && ! SampledXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1722   if ( ASDCP_SUCCESS(result)  && ! SampledYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1723   if ( ASDCP_SUCCESS(result)  && ! DisplayHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1724   if ( ASDCP_SUCCESS(result)  && ! DisplayWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1725   if ( ASDCP_SUCCESS(result)  && ! DisplayXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1726   if ( ASDCP_SUCCESS(result)  && ! DisplayYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1727   if ( ASDCP_SUCCESS(result)  && ! DisplayF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1728   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1729   if ( ASDCP_SUCCESS(result)  && ! ActiveFormatDescriptor.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1730   if ( ASDCP_SUCCESS(result)  && ! AlphaTransparency.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1731   if ( ASDCP_SUCCESS(result)  && ! TransferCharacteristic.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1732   if ( ASDCP_SUCCESS(result)  && ! ImageAlignmentOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1733   if ( ASDCP_SUCCESS(result)  && ! ImageStartOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1734   if ( ASDCP_SUCCESS(result)  && ! ImageEndOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1735   if ( ASDCP_SUCCESS(result)  && ! FieldDominance.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1736   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1737   if ( ASDCP_SUCCESS(result)  && ! CodingEquations.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1738   if ( ASDCP_SUCCESS(result)  && ! ColorPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1739   if ( ASDCP_SUCCESS(result)  && ! AlternativeCenterCuts.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1740   if ( ASDCP_SUCCESS(result)  && ! ActiveWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1741   if ( ASDCP_SUCCESS(result)  && ! ActiveHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1742   if ( ASDCP_SUCCESS(result)  && ! ActiveXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1743   if ( ASDCP_SUCCESS(result)  && ! ActiveYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1744   return result;
1745 }
1746
1747 //
1748 void
1749 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1750 {
1751   FileDescriptor::Copy(rhs);
1752   SignalStandard = rhs.SignalStandard;
1753   FrameLayout = rhs.FrameLayout;
1754   StoredWidth = rhs.StoredWidth;
1755   StoredHeight = rhs.StoredHeight;
1756   StoredF2Offset = rhs.StoredF2Offset;
1757   SampledWidth = rhs.SampledWidth;
1758   SampledHeight = rhs.SampledHeight;
1759   SampledXOffset = rhs.SampledXOffset;
1760   SampledYOffset = rhs.SampledYOffset;
1761   DisplayHeight = rhs.DisplayHeight;
1762   DisplayWidth = rhs.DisplayWidth;
1763   DisplayXOffset = rhs.DisplayXOffset;
1764   DisplayYOffset = rhs.DisplayYOffset;
1765   DisplayF2Offset = rhs.DisplayF2Offset;
1766   AspectRatio = rhs.AspectRatio;
1767   ActiveFormatDescriptor = rhs.ActiveFormatDescriptor;
1768   AlphaTransparency = rhs.AlphaTransparency;
1769   TransferCharacteristic = rhs.TransferCharacteristic;
1770   ImageAlignmentOffset = rhs.ImageAlignmentOffset;
1771   ImageStartOffset = rhs.ImageStartOffset;
1772   ImageEndOffset = rhs.ImageEndOffset;
1773   FieldDominance = rhs.FieldDominance;
1774   PictureEssenceCoding = rhs.PictureEssenceCoding;
1775   CodingEquations = rhs.CodingEquations;
1776   ColorPrimaries = rhs.ColorPrimaries;
1777   AlternativeCenterCuts = rhs.AlternativeCenterCuts;
1778   ActiveWidth = rhs.ActiveWidth;
1779   ActiveHeight = rhs.ActiveHeight;
1780   ActiveXOffset = rhs.ActiveXOffset;
1781   ActiveYOffset = rhs.ActiveYOffset;
1782 }
1783
1784 //
1785 void
1786 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1787 {
1788   char identbuf[IdentBufferLen];
1789   *identbuf = 0;
1790
1791   if ( stream == 0 )
1792     stream = stderr;
1793
1794   FileDescriptor::Dump(stream);
1795   if ( ! SignalStandard.empty() ) {
1796     fprintf(stream, "  %22s = %d\n",  "SignalStandard", SignalStandard.get());
1797   }
1798   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1799   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1800   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1801   if ( ! StoredF2Offset.empty() ) {
1802     fprintf(stream, "  %22s = %d\n",  "StoredF2Offset", StoredF2Offset.get());
1803   }
1804   if ( ! SampledWidth.empty() ) {
1805     fprintf(stream, "  %22s = %d\n",  "SampledWidth", SampledWidth.get());
1806   }
1807   if ( ! SampledHeight.empty() ) {
1808     fprintf(stream, "  %22s = %d\n",  "SampledHeight", SampledHeight.get());
1809   }
1810   if ( ! SampledXOffset.empty() ) {
1811     fprintf(stream, "  %22s = %d\n",  "SampledXOffset", SampledXOffset.get());
1812   }
1813   if ( ! SampledYOffset.empty() ) {
1814     fprintf(stream, "  %22s = %d\n",  "SampledYOffset", SampledYOffset.get());
1815   }
1816   if ( ! DisplayHeight.empty() ) {
1817     fprintf(stream, "  %22s = %d\n",  "DisplayHeight", DisplayHeight.get());
1818   }
1819   if ( ! DisplayWidth.empty() ) {
1820     fprintf(stream, "  %22s = %d\n",  "DisplayWidth", DisplayWidth.get());
1821   }
1822   if ( ! DisplayXOffset.empty() ) {
1823     fprintf(stream, "  %22s = %d\n",  "DisplayXOffset", DisplayXOffset.get());
1824   }
1825   if ( ! DisplayYOffset.empty() ) {
1826     fprintf(stream, "  %22s = %d\n",  "DisplayYOffset", DisplayYOffset.get());
1827   }
1828   if ( ! DisplayF2Offset.empty() ) {
1829     fprintf(stream, "  %22s = %d\n",  "DisplayF2Offset", DisplayF2Offset.get());
1830   }
1831   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1832   if ( ! ActiveFormatDescriptor.empty() ) {
1833     fprintf(stream, "  %22s = %d\n",  "ActiveFormatDescriptor", ActiveFormatDescriptor.get());
1834   }
1835   if ( ! AlphaTransparency.empty() ) {
1836     fprintf(stream, "  %22s = %d\n",  "AlphaTransparency", AlphaTransparency.get());
1837   }
1838   if ( ! TransferCharacteristic.empty() ) {
1839     fprintf(stream, "  %22s = %s\n",  "TransferCharacteristic", TransferCharacteristic.get().EncodeString(identbuf, IdentBufferLen));
1840   }
1841   if ( ! ImageAlignmentOffset.empty() ) {
1842     fprintf(stream, "  %22s = %d\n",  "ImageAlignmentOffset", ImageAlignmentOffset.get());
1843   }
1844   if ( ! ImageStartOffset.empty() ) {
1845     fprintf(stream, "  %22s = %d\n",  "ImageStartOffset", ImageStartOffset.get());
1846   }
1847   if ( ! ImageEndOffset.empty() ) {
1848     fprintf(stream, "  %22s = %d\n",  "ImageEndOffset", ImageEndOffset.get());
1849   }
1850   if ( ! FieldDominance.empty() ) {
1851     fprintf(stream, "  %22s = %d\n",  "FieldDominance", FieldDominance.get());
1852   }
1853   fprintf(stream, "  %22s = %s\n",  "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1854   if ( ! CodingEquations.empty() ) {
1855     fprintf(stream, "  %22s = %s\n",  "CodingEquations", CodingEquations.get().EncodeString(identbuf, IdentBufferLen));
1856   }
1857   if ( ! ColorPrimaries.empty() ) {
1858     fprintf(stream, "  %22s = %s\n",  "ColorPrimaries", ColorPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1859   }
1860   if ( ! AlternativeCenterCuts.empty() ) {
1861     fprintf(stream, "  %22s:\n",  "AlternativeCenterCuts");
1862   AlternativeCenterCuts.get().Dump(stream);
1863   }
1864   if ( ! ActiveWidth.empty() ) {
1865     fprintf(stream, "  %22s = %d\n",  "ActiveWidth", ActiveWidth.get());
1866   }
1867   if ( ! ActiveHeight.empty() ) {
1868     fprintf(stream, "  %22s = %d\n",  "ActiveHeight", ActiveHeight.get());
1869   }
1870   if ( ! ActiveXOffset.empty() ) {
1871     fprintf(stream, "  %22s = %d\n",  "ActiveXOffset", ActiveXOffset.get());
1872   }
1873   if ( ! ActiveYOffset.empty() ) {
1874     fprintf(stream, "  %22s = %d\n",  "ActiveYOffset", ActiveYOffset.get());
1875   }
1876 }
1877
1878 //
1879 ASDCP::Result_t
1880 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1881 {
1882   return InterchangeObject::InitFromBuffer(p, l);
1883 }
1884
1885 //
1886 ASDCP::Result_t
1887 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1888 {
1889   return InterchangeObject::WriteToBuffer(Buffer);
1890 }
1891
1892 //------------------------------------------------------------------------------------------
1893 // RGBAEssenceDescriptor
1894
1895 //
1896
1897 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), AlphaMinRef(0), ScanningDirection(0)
1898 {
1899   assert(m_Dict);
1900   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1901 }
1902
1903 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1904 {
1905   assert(m_Dict);
1906   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1907   Copy(rhs);
1908 }
1909
1910
1911 //
1912 ASDCP::Result_t
1913 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1914 {
1915   assert(m_Dict);
1916   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1917   if ( ASDCP_SUCCESS(result) ) {
1918     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1919     ComponentMaxRef.set_has_value( result == RESULT_OK );
1920   }
1921   if ( ASDCP_SUCCESS(result) ) {
1922     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1923     ComponentMinRef.set_has_value( result == RESULT_OK );
1924   }
1925   if ( ASDCP_SUCCESS(result) ) {
1926     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1927     AlphaMinRef.set_has_value( result == RESULT_OK );
1928   }
1929   if ( ASDCP_SUCCESS(result) ) {
1930     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
1931     AlphaMaxRef.set_has_value( result == RESULT_OK );
1932   }
1933   if ( ASDCP_SUCCESS(result) ) {
1934     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
1935     ScanningDirection.set_has_value( result == RESULT_OK );
1936   }
1937   return result;
1938 }
1939
1940 //
1941 ASDCP::Result_t
1942 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1943 {
1944   assert(m_Dict);
1945   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1946   if ( ASDCP_SUCCESS(result)  && ! ComponentMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1947   if ( ASDCP_SUCCESS(result)  && ! ComponentMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1948   if ( ASDCP_SUCCESS(result)  && ! AlphaMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1949   if ( ASDCP_SUCCESS(result)  && ! AlphaMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
1950   if ( ASDCP_SUCCESS(result)  && ! ScanningDirection.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
1951   return result;
1952 }
1953
1954 //
1955 void
1956 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
1957 {
1958   GenericPictureEssenceDescriptor::Copy(rhs);
1959   ComponentMaxRef = rhs.ComponentMaxRef;
1960   ComponentMinRef = rhs.ComponentMinRef;
1961   AlphaMinRef = rhs.AlphaMinRef;
1962   AlphaMaxRef = rhs.AlphaMaxRef;
1963   ScanningDirection = rhs.ScanningDirection;
1964 }
1965
1966 //
1967 void
1968 RGBAEssenceDescriptor::Dump(FILE* stream)
1969 {
1970   char identbuf[IdentBufferLen];
1971   *identbuf = 0;
1972
1973   if ( stream == 0 )
1974     stream = stderr;
1975
1976   GenericPictureEssenceDescriptor::Dump(stream);
1977   if ( ! ComponentMaxRef.empty() ) {
1978     fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef.get());
1979   }
1980   if ( ! ComponentMinRef.empty() ) {
1981     fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef.get());
1982   }
1983   if ( ! AlphaMinRef.empty() ) {
1984     fprintf(stream, "  %22s = %d\n",  "AlphaMinRef", AlphaMinRef.get());
1985   }
1986   if ( ! AlphaMaxRef.empty() ) {
1987     fprintf(stream, "  %22s = %d\n",  "AlphaMaxRef", AlphaMaxRef.get());
1988   }
1989   if ( ! ScanningDirection.empty() ) {
1990     fprintf(stream, "  %22s = %d\n",  "ScanningDirection", ScanningDirection.get());
1991   }
1992 }
1993
1994 //
1995 ASDCP::Result_t
1996 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1997 {
1998   return InterchangeObject::InitFromBuffer(p, l);
1999 }
2000
2001 //
2002 ASDCP::Result_t
2003 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2004 {
2005   return InterchangeObject::WriteToBuffer(Buffer);
2006 }
2007
2008 //------------------------------------------------------------------------------------------
2009 // JPEG2000PictureSubDescriptor
2010
2011 //
2012
2013 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)
2014 {
2015   assert(m_Dict);
2016   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2017 }
2018
2019 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2020 {
2021   assert(m_Dict);
2022   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2023   Copy(rhs);
2024 }
2025
2026
2027 //
2028 ASDCP::Result_t
2029 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2030 {
2031   assert(m_Dict);
2032   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2033   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2034   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2035   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2036   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2037   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2038   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2039   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2040   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2041   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2042   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
2043   if ( ASDCP_SUCCESS(result) ) {
2044     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2045     PictureComponentSizing.set_has_value( result == RESULT_OK );
2046   }
2047   if ( ASDCP_SUCCESS(result) ) {
2048     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2049     CodingStyleDefault.set_has_value( result == RESULT_OK );
2050   }
2051   if ( ASDCP_SUCCESS(result) ) {
2052     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2053     QuantizationDefault.set_has_value( result == RESULT_OK );
2054   }
2055   if ( ASDCP_SUCCESS(result) ) {
2056     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2057     J2CLayout.set_has_value( result == RESULT_OK );
2058   }
2059   return result;
2060 }
2061
2062 //
2063 ASDCP::Result_t
2064 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2065 {
2066   assert(m_Dict);
2067   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2068   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2069   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2070   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2071   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2072   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2073   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2074   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2075   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2076   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2077   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
2078   if ( ASDCP_SUCCESS(result)  && ! PictureComponentSizing.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2079   if ( ASDCP_SUCCESS(result)  && ! CodingStyleDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2080   if ( ASDCP_SUCCESS(result)  && ! QuantizationDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2081   if ( ASDCP_SUCCESS(result)  && ! J2CLayout.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2082   return result;
2083 }
2084
2085 //
2086 void
2087 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
2088 {
2089   InterchangeObject::Copy(rhs);
2090   Rsize = rhs.Rsize;
2091   Xsize = rhs.Xsize;
2092   Ysize = rhs.Ysize;
2093   XOsize = rhs.XOsize;
2094   YOsize = rhs.YOsize;
2095   XTsize = rhs.XTsize;
2096   YTsize = rhs.YTsize;
2097   XTOsize = rhs.XTOsize;
2098   YTOsize = rhs.YTOsize;
2099   Csize = rhs.Csize;
2100   PictureComponentSizing = rhs.PictureComponentSizing;
2101   CodingStyleDefault = rhs.CodingStyleDefault;
2102   QuantizationDefault = rhs.QuantizationDefault;
2103   J2CLayout = rhs.J2CLayout;
2104 }
2105
2106 //
2107 void
2108 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
2109 {
2110   char identbuf[IdentBufferLen];
2111   *identbuf = 0;
2112
2113   if ( stream == 0 )
2114     stream = stderr;
2115
2116   InterchangeObject::Dump(stream);
2117   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
2118   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
2119   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
2120   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
2121   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
2122   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
2123   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
2124   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
2125   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
2126   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
2127   if ( ! PictureComponentSizing.empty() ) {
2128     fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.get().EncodeString(identbuf, IdentBufferLen));
2129   }
2130   if ( ! CodingStyleDefault.empty() ) {
2131     fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.get().EncodeString(identbuf, IdentBufferLen));
2132   }
2133   if ( ! QuantizationDefault.empty() ) {
2134     fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.get().EncodeString(identbuf, IdentBufferLen));
2135   }
2136   if ( ! J2CLayout.empty() ) {
2137     fprintf(stream, "  %22s = %s\n",  "J2CLayout", J2CLayout.get().EncodeString(identbuf, IdentBufferLen));
2138   }
2139 }
2140
2141 //
2142 ASDCP::Result_t
2143 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2144 {
2145   return InterchangeObject::InitFromBuffer(p, l);
2146 }
2147
2148 //
2149 ASDCP::Result_t
2150 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2151 {
2152   return InterchangeObject::WriteToBuffer(Buffer);
2153 }
2154
2155 //------------------------------------------------------------------------------------------
2156 // CDCIEssenceDescriptor
2157
2158 //
2159
2160 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ReversedByteOrder(0), AlphaSampleDepth(0), WhiteReflevel(0)
2161 {
2162   assert(m_Dict);
2163   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2164 }
2165
2166 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2167 {
2168   assert(m_Dict);
2169   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2170   Copy(rhs);
2171 }
2172
2173
2174 //
2175 ASDCP::Result_t
2176 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2177 {
2178   assert(m_Dict);
2179   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
2180   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2181   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2182   if ( ASDCP_SUCCESS(result) ) {
2183     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2184     VerticalSubsampling.set_has_value( result == RESULT_OK );
2185   }
2186   if ( ASDCP_SUCCESS(result) ) {
2187     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2188     ColorSiting.set_has_value( result == RESULT_OK );
2189   }
2190   if ( ASDCP_SUCCESS(result) ) {
2191     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2192     ReversedByteOrder.set_has_value( result == RESULT_OK );
2193   }
2194   if ( ASDCP_SUCCESS(result) ) {
2195     result = TLVSet.ReadUi16(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2196     PaddingBits.set_has_value( result == RESULT_OK );
2197   }
2198   if ( ASDCP_SUCCESS(result) ) {
2199     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2200     AlphaSampleDepth.set_has_value( result == RESULT_OK );
2201   }
2202   if ( ASDCP_SUCCESS(result) ) {
2203     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2204     BlackRefLevel.set_has_value( result == RESULT_OK );
2205   }
2206   if ( ASDCP_SUCCESS(result) ) {
2207     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2208     WhiteReflevel.set_has_value( result == RESULT_OK );
2209   }
2210   if ( ASDCP_SUCCESS(result) ) {
2211     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2212     ColorRange.set_has_value( result == RESULT_OK );
2213   }
2214   return result;
2215 }
2216
2217 //
2218 ASDCP::Result_t
2219 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2220 {
2221   assert(m_Dict);
2222   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2223   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2224   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2225   if ( ASDCP_SUCCESS(result)  && ! VerticalSubsampling.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2226   if ( ASDCP_SUCCESS(result)  && ! ColorSiting.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2227   if ( ASDCP_SUCCESS(result)  && ! ReversedByteOrder.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2228   if ( ASDCP_SUCCESS(result)  && ! PaddingBits.empty() ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2229   if ( ASDCP_SUCCESS(result)  && ! AlphaSampleDepth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2230   if ( ASDCP_SUCCESS(result)  && ! BlackRefLevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2231   if ( ASDCP_SUCCESS(result)  && ! WhiteReflevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2232   if ( ASDCP_SUCCESS(result)  && ! ColorRange.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2233   return result;
2234 }
2235
2236 //
2237 void
2238 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
2239 {
2240   GenericPictureEssenceDescriptor::Copy(rhs);
2241   ComponentDepth = rhs.ComponentDepth;
2242   HorizontalSubsampling = rhs.HorizontalSubsampling;
2243   VerticalSubsampling = rhs.VerticalSubsampling;
2244   ColorSiting = rhs.ColorSiting;
2245   ReversedByteOrder = rhs.ReversedByteOrder;
2246   PaddingBits = rhs.PaddingBits;
2247   AlphaSampleDepth = rhs.AlphaSampleDepth;
2248   BlackRefLevel = rhs.BlackRefLevel;
2249   WhiteReflevel = rhs.WhiteReflevel;
2250   ColorRange = rhs.ColorRange;
2251 }
2252
2253 //
2254 void
2255 CDCIEssenceDescriptor::Dump(FILE* stream)
2256 {
2257   char identbuf[IdentBufferLen];
2258   *identbuf = 0;
2259
2260   if ( stream == 0 )
2261     stream = stderr;
2262
2263   GenericPictureEssenceDescriptor::Dump(stream);
2264   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
2265   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
2266   if ( ! VerticalSubsampling.empty() ) {
2267     fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling.get());
2268   }
2269   if ( ! ColorSiting.empty() ) {
2270     fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting.get());
2271   }
2272   if ( ! ReversedByteOrder.empty() ) {
2273     fprintf(stream, "  %22s = %d\n",  "ReversedByteOrder", ReversedByteOrder.get());
2274   }
2275   if ( ! PaddingBits.empty() ) {
2276     fprintf(stream, "  %22s = %d\n",  "PaddingBits", PaddingBits.get());
2277   }
2278   if ( ! AlphaSampleDepth.empty() ) {
2279     fprintf(stream, "  %22s = %d\n",  "AlphaSampleDepth", AlphaSampleDepth.get());
2280   }
2281   if ( ! BlackRefLevel.empty() ) {
2282     fprintf(stream, "  %22s = %d\n",  "BlackRefLevel", BlackRefLevel.get());
2283   }
2284   if ( ! WhiteReflevel.empty() ) {
2285     fprintf(stream, "  %22s = %d\n",  "WhiteReflevel", WhiteReflevel.get());
2286   }
2287   if ( ! ColorRange.empty() ) {
2288     fprintf(stream, "  %22s = %d\n",  "ColorRange", ColorRange.get());
2289   }
2290 }
2291
2292 //
2293 ASDCP::Result_t
2294 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2295 {
2296   return InterchangeObject::InitFromBuffer(p, l);
2297 }
2298
2299 //
2300 ASDCP::Result_t
2301 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2302 {
2303   return InterchangeObject::WriteToBuffer(Buffer);
2304 }
2305
2306 //------------------------------------------------------------------------------------------
2307 // MPEG2VideoDescriptor
2308
2309 //
2310
2311 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), SingleSequence(0), CodedContentType(0), ClosedGOP(0), MaxGOP(0), BitRate(0)
2312 {
2313   assert(m_Dict);
2314   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2315 }
2316
2317 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2318 {
2319   assert(m_Dict);
2320   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2321   Copy(rhs);
2322 }
2323
2324
2325 //
2326 ASDCP::Result_t
2327 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2328 {
2329   assert(m_Dict);
2330   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
2331   if ( ASDCP_SUCCESS(result) ) {
2332     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2333     SingleSequence.set_has_value( result == RESULT_OK );
2334   }
2335   if ( ASDCP_SUCCESS(result) ) {
2336     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2337     ConstantBFrames.set_has_value( result == RESULT_OK );
2338   }
2339   if ( ASDCP_SUCCESS(result) ) {
2340     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2341     CodedContentType.set_has_value( result == RESULT_OK );
2342   }
2343   if ( ASDCP_SUCCESS(result) ) {
2344     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2345     LowDelay.set_has_value( result == RESULT_OK );
2346   }
2347   if ( ASDCP_SUCCESS(result) ) {
2348     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2349     ClosedGOP.set_has_value( result == RESULT_OK );
2350   }
2351   if ( ASDCP_SUCCESS(result) ) {
2352     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2353     IdenticalGOP.set_has_value( result == RESULT_OK );
2354   }
2355   if ( ASDCP_SUCCESS(result) ) {
2356     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2357     MaxGOP.set_has_value( result == RESULT_OK );
2358   }
2359   if ( ASDCP_SUCCESS(result) ) {
2360     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2361     BPictureCount.set_has_value( result == RESULT_OK );
2362   }
2363   if ( ASDCP_SUCCESS(result) ) {
2364     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2365     BitRate.set_has_value( result == RESULT_OK );
2366   }
2367   if ( ASDCP_SUCCESS(result) ) {
2368     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2369     ProfileAndLevel.set_has_value( result == RESULT_OK );
2370   }
2371   return result;
2372 }
2373
2374 //
2375 ASDCP::Result_t
2376 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2377 {
2378   assert(m_Dict);
2379   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
2380   if ( ASDCP_SUCCESS(result)  && ! SingleSequence.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2381   if ( ASDCP_SUCCESS(result)  && ! ConstantBFrames.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2382   if ( ASDCP_SUCCESS(result)  && ! CodedContentType.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2383   if ( ASDCP_SUCCESS(result)  && ! LowDelay.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2384   if ( ASDCP_SUCCESS(result)  && ! ClosedGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2385   if ( ASDCP_SUCCESS(result)  && ! IdenticalGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2386   if ( ASDCP_SUCCESS(result)  && ! MaxGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2387   if ( ASDCP_SUCCESS(result)  && ! BPictureCount.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2388   if ( ASDCP_SUCCESS(result)  && ! BitRate.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2389   if ( ASDCP_SUCCESS(result)  && ! ProfileAndLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2390   return result;
2391 }
2392
2393 //
2394 void
2395 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
2396 {
2397   CDCIEssenceDescriptor::Copy(rhs);
2398   SingleSequence = rhs.SingleSequence;
2399   ConstantBFrames = rhs.ConstantBFrames;
2400   CodedContentType = rhs.CodedContentType;
2401   LowDelay = rhs.LowDelay;
2402   ClosedGOP = rhs.ClosedGOP;
2403   IdenticalGOP = rhs.IdenticalGOP;
2404   MaxGOP = rhs.MaxGOP;
2405   BPictureCount = rhs.BPictureCount;
2406   BitRate = rhs.BitRate;
2407   ProfileAndLevel = rhs.ProfileAndLevel;
2408 }
2409
2410 //
2411 void
2412 MPEG2VideoDescriptor::Dump(FILE* stream)
2413 {
2414   char identbuf[IdentBufferLen];
2415   *identbuf = 0;
2416
2417   if ( stream == 0 )
2418     stream = stderr;
2419
2420   CDCIEssenceDescriptor::Dump(stream);
2421   if ( ! SingleSequence.empty() ) {
2422     fprintf(stream, "  %22s = %d\n",  "SingleSequence", SingleSequence.get());
2423   }
2424   if ( ! ConstantBFrames.empty() ) {
2425     fprintf(stream, "  %22s = %d\n",  "ConstantBFrames", ConstantBFrames.get());
2426   }
2427   if ( ! CodedContentType.empty() ) {
2428     fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType.get());
2429   }
2430   if ( ! LowDelay.empty() ) {
2431     fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay.get());
2432   }
2433   if ( ! ClosedGOP.empty() ) {
2434     fprintf(stream, "  %22s = %d\n",  "ClosedGOP", ClosedGOP.get());
2435   }
2436   if ( ! IdenticalGOP.empty() ) {
2437     fprintf(stream, "  %22s = %d\n",  "IdenticalGOP", IdenticalGOP.get());
2438   }
2439   if ( ! MaxGOP.empty() ) {
2440     fprintf(stream, "  %22s = %d\n",  "MaxGOP", MaxGOP.get());
2441   }
2442   if ( ! BPictureCount.empty() ) {
2443     fprintf(stream, "  %22s = %d\n",  "BPictureCount", BPictureCount.get());
2444   }
2445   if ( ! BitRate.empty() ) {
2446     fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate.get());
2447   }
2448   if ( ! ProfileAndLevel.empty() ) {
2449     fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel.get());
2450   }
2451 }
2452
2453 //
2454 ASDCP::Result_t
2455 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2456 {
2457   return InterchangeObject::InitFromBuffer(p, l);
2458 }
2459
2460 //
2461 ASDCP::Result_t
2462 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2463 {
2464   return InterchangeObject::WriteToBuffer(Buffer);
2465 }
2466
2467 //------------------------------------------------------------------------------------------
2468 // DMSegment
2469
2470 //
2471
2472 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
2473 {
2474   assert(m_Dict);
2475   m_UL = m_Dict->ul(MDD_DMSegment);
2476 }
2477
2478 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2479 {
2480   assert(m_Dict);
2481   m_UL = m_Dict->ul(MDD_DMSegment);
2482   Copy(rhs);
2483 }
2484
2485
2486 //
2487 ASDCP::Result_t
2488 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
2489 {
2490   assert(m_Dict);
2491   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2492   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
2493   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
2494   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
2495   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
2496   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2497   return result;
2498 }
2499
2500 //
2501 ASDCP::Result_t
2502 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2503 {
2504   assert(m_Dict);
2505   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2506   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2507   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
2508   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
2509   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
2510   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2511   return result;
2512 }
2513
2514 //
2515 void
2516 DMSegment::Copy(const DMSegment& rhs)
2517 {
2518   InterchangeObject::Copy(rhs);
2519   DataDefinition = rhs.DataDefinition;
2520   EventStartPosition = rhs.EventStartPosition;
2521   Duration = rhs.Duration;
2522   EventComment = rhs.EventComment;
2523   DMFramework = rhs.DMFramework;
2524 }
2525
2526 //
2527 void
2528 DMSegment::Dump(FILE* stream)
2529 {
2530   char identbuf[IdentBufferLen];
2531   *identbuf = 0;
2532
2533   if ( stream == 0 )
2534     stream = stderr;
2535
2536   InterchangeObject::Dump(stream);
2537   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2538   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
2539   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
2540   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
2541   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2542 }
2543
2544 //
2545 ASDCP::Result_t
2546 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2547 {
2548   return InterchangeObject::InitFromBuffer(p, l);
2549 }
2550
2551 //
2552 ASDCP::Result_t
2553 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2554 {
2555   return InterchangeObject::WriteToBuffer(Buffer);
2556 }
2557
2558 //------------------------------------------------------------------------------------------
2559 // CryptographicFramework
2560
2561 //
2562
2563 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2564 {
2565   assert(m_Dict);
2566   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2567 }
2568
2569 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2570 {
2571   assert(m_Dict);
2572   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2573   Copy(rhs);
2574 }
2575
2576
2577 //
2578 ASDCP::Result_t
2579 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2580 {
2581   assert(m_Dict);
2582   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2583   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2584   return result;
2585 }
2586
2587 //
2588 ASDCP::Result_t
2589 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2590 {
2591   assert(m_Dict);
2592   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2593   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2594   return result;
2595 }
2596
2597 //
2598 void
2599 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2600 {
2601   InterchangeObject::Copy(rhs);
2602   ContextSR = rhs.ContextSR;
2603 }
2604
2605 //
2606 void
2607 CryptographicFramework::Dump(FILE* stream)
2608 {
2609   char identbuf[IdentBufferLen];
2610   *identbuf = 0;
2611
2612   if ( stream == 0 )
2613     stream = stderr;
2614
2615   InterchangeObject::Dump(stream);
2616   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2617 }
2618
2619 //
2620 ASDCP::Result_t
2621 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2622 {
2623   return InterchangeObject::InitFromBuffer(p, l);
2624 }
2625
2626 //
2627 ASDCP::Result_t
2628 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2629 {
2630   return InterchangeObject::WriteToBuffer(Buffer);
2631 }
2632
2633 //------------------------------------------------------------------------------------------
2634 // CryptographicContext
2635
2636 //
2637
2638 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2639 {
2640   assert(m_Dict);
2641   m_UL = m_Dict->ul(MDD_CryptographicContext);
2642 }
2643
2644 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2645 {
2646   assert(m_Dict);
2647   m_UL = m_Dict->ul(MDD_CryptographicContext);
2648   Copy(rhs);
2649 }
2650
2651
2652 //
2653 ASDCP::Result_t
2654 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2655 {
2656   assert(m_Dict);
2657   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2658   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2659   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2660   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2661   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2662   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2663   return result;
2664 }
2665
2666 //
2667 ASDCP::Result_t
2668 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2669 {
2670   assert(m_Dict);
2671   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2672   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2673   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2674   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2675   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2676   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2677   return result;
2678 }
2679
2680 //
2681 void
2682 CryptographicContext::Copy(const CryptographicContext& rhs)
2683 {
2684   InterchangeObject::Copy(rhs);
2685   ContextID = rhs.ContextID;
2686   SourceEssenceContainer = rhs.SourceEssenceContainer;
2687   CipherAlgorithm = rhs.CipherAlgorithm;
2688   MICAlgorithm = rhs.MICAlgorithm;
2689   CryptographicKeyID = rhs.CryptographicKeyID;
2690 }
2691
2692 //
2693 void
2694 CryptographicContext::Dump(FILE* stream)
2695 {
2696   char identbuf[IdentBufferLen];
2697   *identbuf = 0;
2698
2699   if ( stream == 0 )
2700     stream = stderr;
2701
2702   InterchangeObject::Dump(stream);
2703   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2704   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2705   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2706   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2707   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2708 }
2709
2710 //
2711 ASDCP::Result_t
2712 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2713 {
2714   return InterchangeObject::InitFromBuffer(p, l);
2715 }
2716
2717 //
2718 ASDCP::Result_t
2719 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2720 {
2721   return InterchangeObject::WriteToBuffer(Buffer);
2722 }
2723
2724 //------------------------------------------------------------------------------------------
2725 // GenericDataEssenceDescriptor
2726
2727 //
2728
2729 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
2730 {
2731   assert(m_Dict);
2732   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2733 }
2734
2735 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2736 {
2737   assert(m_Dict);
2738   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2739   Copy(rhs);
2740 }
2741
2742
2743 //
2744 ASDCP::Result_t
2745 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2746 {
2747   assert(m_Dict);
2748   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
2749   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2750   return result;
2751 }
2752
2753 //
2754 ASDCP::Result_t
2755 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2756 {
2757   assert(m_Dict);
2758   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
2759   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2760   return result;
2761 }
2762
2763 //
2764 void
2765 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
2766 {
2767   FileDescriptor::Copy(rhs);
2768   DataEssenceCoding = rhs.DataEssenceCoding;
2769 }
2770
2771 //
2772 void
2773 GenericDataEssenceDescriptor::Dump(FILE* stream)
2774 {
2775   char identbuf[IdentBufferLen];
2776   *identbuf = 0;
2777
2778   if ( stream == 0 )
2779     stream = stderr;
2780
2781   FileDescriptor::Dump(stream);
2782   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
2783 }
2784
2785 //
2786 ASDCP::Result_t
2787 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2788 {
2789   return InterchangeObject::InitFromBuffer(p, l);
2790 }
2791
2792 //
2793 ASDCP::Result_t
2794 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2795 {
2796   return InterchangeObject::WriteToBuffer(Buffer);
2797 }
2798
2799 //------------------------------------------------------------------------------------------
2800 // TimedTextDescriptor
2801
2802 //
2803
2804 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
2805 {
2806   assert(m_Dict);
2807   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2808 }
2809
2810 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2811 {
2812   assert(m_Dict);
2813   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2814   Copy(rhs);
2815 }
2816
2817
2818 //
2819 ASDCP::Result_t
2820 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2821 {
2822   assert(m_Dict);
2823   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
2824   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
2825   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
2826   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
2827   if ( ASDCP_SUCCESS(result) ) {
2828     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
2829     RFC5646LanguageTagList.set_has_value( result == RESULT_OK );
2830   }
2831   return result;
2832 }
2833
2834 //
2835 ASDCP::Result_t
2836 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2837 {
2838   assert(m_Dict);
2839   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
2840   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
2841   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
2842   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
2843   if ( ASDCP_SUCCESS(result)  && ! RFC5646LanguageTagList.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
2844   return result;
2845 }
2846
2847 //
2848 void
2849 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
2850 {
2851   GenericDataEssenceDescriptor::Copy(rhs);
2852   ResourceID = rhs.ResourceID;
2853   UCSEncoding = rhs.UCSEncoding;
2854   NamespaceURI = rhs.NamespaceURI;
2855   RFC5646LanguageTagList = rhs.RFC5646LanguageTagList;
2856 }
2857
2858 //
2859 void
2860 TimedTextDescriptor::Dump(FILE* stream)
2861 {
2862   char identbuf[IdentBufferLen];
2863   *identbuf = 0;
2864
2865   if ( stream == 0 )
2866     stream = stderr;
2867
2868   GenericDataEssenceDescriptor::Dump(stream);
2869   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
2870   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
2871   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
2872   if ( ! RFC5646LanguageTagList.empty() ) {
2873     fprintf(stream, "  %22s = %s\n",  "RFC5646LanguageTagList", RFC5646LanguageTagList.get().EncodeString(identbuf, IdentBufferLen));
2874   }
2875 }
2876
2877 //
2878 ASDCP::Result_t
2879 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2880 {
2881   return InterchangeObject::InitFromBuffer(p, l);
2882 }
2883
2884 //
2885 ASDCP::Result_t
2886 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2887 {
2888   return InterchangeObject::WriteToBuffer(Buffer);
2889 }
2890
2891 //------------------------------------------------------------------------------------------
2892 // TimedTextResourceSubDescriptor
2893
2894 //
2895
2896 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
2897 {
2898   assert(m_Dict);
2899   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2900 }
2901
2902 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2903 {
2904   assert(m_Dict);
2905   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2906   Copy(rhs);
2907 }
2908
2909
2910 //
2911 ASDCP::Result_t
2912 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2913 {
2914   assert(m_Dict);
2915   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2916   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2917   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2918   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2919   return result;
2920 }
2921
2922 //
2923 ASDCP::Result_t
2924 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2925 {
2926   assert(m_Dict);
2927   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2928   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2929   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2930   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2931   return result;
2932 }
2933
2934 //
2935 void
2936 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
2937 {
2938   InterchangeObject::Copy(rhs);
2939   AncillaryResourceID = rhs.AncillaryResourceID;
2940   MIMEMediaType = rhs.MIMEMediaType;
2941   EssenceStreamID = rhs.EssenceStreamID;
2942 }
2943
2944 //
2945 void
2946 TimedTextResourceSubDescriptor::Dump(FILE* stream)
2947 {
2948   char identbuf[IdentBufferLen];
2949   *identbuf = 0;
2950
2951   if ( stream == 0 )
2952     stream = stderr;
2953
2954   InterchangeObject::Dump(stream);
2955   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
2956   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
2957   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
2958 }
2959
2960 //
2961 ASDCP::Result_t
2962 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2963 {
2964   return InterchangeObject::InitFromBuffer(p, l);
2965 }
2966
2967 //
2968 ASDCP::Result_t
2969 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2970 {
2971   return InterchangeObject::WriteToBuffer(Buffer);
2972 }
2973
2974 //------------------------------------------------------------------------------------------
2975 // StereoscopicPictureSubDescriptor
2976
2977 //
2978
2979 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2980 {
2981   assert(m_Dict);
2982   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2983 }
2984
2985 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2986 {
2987   assert(m_Dict);
2988   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2989   Copy(rhs);
2990 }
2991
2992
2993 //
2994 ASDCP::Result_t
2995 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2996 {
2997   assert(m_Dict);
2998   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2999   return result;
3000 }
3001
3002 //
3003 ASDCP::Result_t
3004 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3005 {
3006   assert(m_Dict);
3007   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3008   return result;
3009 }
3010
3011 //
3012 void
3013 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
3014 {
3015   InterchangeObject::Copy(rhs);
3016 }
3017
3018 //
3019 void
3020 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
3021 {
3022   char identbuf[IdentBufferLen];
3023   *identbuf = 0;
3024
3025   if ( stream == 0 )
3026     stream = stderr;
3027
3028   InterchangeObject::Dump(stream);
3029 }
3030
3031 //
3032 ASDCP::Result_t
3033 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3034 {
3035   return InterchangeObject::InitFromBuffer(p, l);
3036 }
3037
3038 //
3039 ASDCP::Result_t
3040 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3041 {
3042   return InterchangeObject::WriteToBuffer(Buffer);
3043 }
3044
3045 //------------------------------------------------------------------------------------------
3046 // ContainerConstraintSubDescriptor
3047
3048 //
3049
3050 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3051 {
3052   assert(m_Dict);
3053   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3054 }
3055
3056 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3057 {
3058   assert(m_Dict);
3059   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3060   Copy(rhs);
3061 }
3062
3063
3064 //
3065 ASDCP::Result_t
3066 ContainerConstraintSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3067 {
3068   assert(m_Dict);
3069   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3070   return result;
3071 }
3072
3073 //
3074 ASDCP::Result_t
3075 ContainerConstraintSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3076 {
3077   assert(m_Dict);
3078   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3079   return result;
3080 }
3081
3082 //
3083 void
3084 ContainerConstraintSubDescriptor::Copy(const ContainerConstraintSubDescriptor& rhs)
3085 {
3086   InterchangeObject::Copy(rhs);
3087 }
3088
3089 //
3090 void
3091 ContainerConstraintSubDescriptor::Dump(FILE* stream)
3092 {
3093   char identbuf[IdentBufferLen];
3094   *identbuf = 0;
3095
3096   if ( stream == 0 )
3097     stream = stderr;
3098
3099   InterchangeObject::Dump(stream);
3100 }
3101
3102 //
3103 ASDCP::Result_t
3104 ContainerConstraintSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3105 {
3106   return InterchangeObject::InitFromBuffer(p, l);
3107 }
3108
3109 //
3110 ASDCP::Result_t
3111 ContainerConstraintSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3112 {
3113   return InterchangeObject::WriteToBuffer(Buffer);
3114 }
3115
3116 //------------------------------------------------------------------------------------------
3117 // NetworkLocator
3118
3119 //
3120
3121 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3122 {
3123   assert(m_Dict);
3124   m_UL = m_Dict->ul(MDD_NetworkLocator);
3125 }
3126
3127 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3128 {
3129   assert(m_Dict);
3130   m_UL = m_Dict->ul(MDD_NetworkLocator);
3131   Copy(rhs);
3132 }
3133
3134
3135 //
3136 ASDCP::Result_t
3137 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
3138 {
3139   assert(m_Dict);
3140   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3141   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
3142   return result;
3143 }
3144
3145 //
3146 ASDCP::Result_t
3147 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
3148 {
3149   assert(m_Dict);
3150   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3151   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
3152   return result;
3153 }
3154
3155 //
3156 void
3157 NetworkLocator::Copy(const NetworkLocator& rhs)
3158 {
3159   InterchangeObject::Copy(rhs);
3160   URLString = rhs.URLString;
3161 }
3162
3163 //
3164 void
3165 NetworkLocator::Dump(FILE* stream)
3166 {
3167   char identbuf[IdentBufferLen];
3168   *identbuf = 0;
3169
3170   if ( stream == 0 )
3171     stream = stderr;
3172
3173   InterchangeObject::Dump(stream);
3174   fprintf(stream, "  %22s = %s\n",  "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
3175 }
3176
3177 //
3178 ASDCP::Result_t
3179 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
3180 {
3181   return InterchangeObject::InitFromBuffer(p, l);
3182 }
3183
3184 //
3185 ASDCP::Result_t
3186 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3187 {
3188   return InterchangeObject::WriteToBuffer(Buffer);
3189 }
3190
3191 //------------------------------------------------------------------------------------------
3192 // MCALabelSubDescriptor
3193
3194 //
3195
3196 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3197 {
3198   assert(m_Dict);
3199   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3200 }
3201
3202 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3203 {
3204   assert(m_Dict);
3205   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3206   Copy(rhs);
3207 }
3208
3209
3210 //
3211 ASDCP::Result_t
3212 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3213 {
3214   assert(m_Dict);
3215   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3216   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3217   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
3218   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3219   if ( ASDCP_SUCCESS(result) ) {
3220     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3221     MCATagName.set_has_value( result == RESULT_OK );
3222   }
3223   if ( ASDCP_SUCCESS(result) ) {
3224     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3225     MCAChannelID.set_has_value( result == RESULT_OK );
3226   }
3227   if ( ASDCP_SUCCESS(result) ) {
3228     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3229     RFC5646SpokenLanguage.set_has_value( result == RESULT_OK );
3230   }
3231   return result;
3232 }
3233
3234 //
3235 ASDCP::Result_t
3236 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3237 {
3238   assert(m_Dict);
3239   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3240   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3241   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
3242   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3243   if ( ASDCP_SUCCESS(result)  && ! MCATagName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3244   if ( ASDCP_SUCCESS(result)  && ! MCAChannelID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3245   if ( ASDCP_SUCCESS(result)  && ! RFC5646SpokenLanguage.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3246   return result;
3247 }
3248
3249 //
3250 void
3251 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
3252 {
3253   InterchangeObject::Copy(rhs);
3254   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
3255   MCALinkID = rhs.MCALinkID;
3256   MCATagSymbol = rhs.MCATagSymbol;
3257   MCATagName = rhs.MCATagName;
3258   MCAChannelID = rhs.MCAChannelID;
3259   RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
3260 }
3261
3262 //
3263 void
3264 MCALabelSubDescriptor::Dump(FILE* stream)
3265 {
3266   char identbuf[IdentBufferLen];
3267   *identbuf = 0;
3268
3269   if ( stream == 0 )
3270     stream = stderr;
3271
3272   InterchangeObject::Dump(stream);
3273   fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
3274   fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
3275   fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
3276   if ( ! MCATagName.empty() ) {
3277     fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.get().EncodeString(identbuf, IdentBufferLen));
3278   }
3279   if ( ! MCAChannelID.empty() ) {
3280     fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID.get());
3281   }
3282   if ( ! RFC5646SpokenLanguage.empty() ) {
3283     fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.get().EncodeString(identbuf, IdentBufferLen));
3284   }
3285 }
3286
3287 //
3288 ASDCP::Result_t
3289 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3290 {
3291   return InterchangeObject::InitFromBuffer(p, l);
3292 }
3293
3294 //
3295 ASDCP::Result_t
3296 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3297 {
3298   return InterchangeObject::WriteToBuffer(Buffer);
3299 }
3300
3301 //------------------------------------------------------------------------------------------
3302 // AudioChannelLabelSubDescriptor
3303
3304 //
3305
3306 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3307 {
3308   assert(m_Dict);
3309   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3310 }
3311
3312 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3313 {
3314   assert(m_Dict);
3315   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3316   Copy(rhs);
3317 }
3318
3319
3320 //
3321 ASDCP::Result_t
3322 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3323 {
3324   assert(m_Dict);
3325   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3326   if ( ASDCP_SUCCESS(result) ) {
3327     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3328     SoundfieldGroupLinkID.set_has_value( result == RESULT_OK );
3329   }
3330   return result;
3331 }
3332
3333 //
3334 ASDCP::Result_t
3335 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3336 {
3337   assert(m_Dict);
3338   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3339   if ( ASDCP_SUCCESS(result)  && ! SoundfieldGroupLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3340   return result;
3341 }
3342
3343 //
3344 void
3345 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
3346 {
3347   MCALabelSubDescriptor::Copy(rhs);
3348   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
3349 }
3350
3351 //
3352 void
3353 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
3354 {
3355   char identbuf[IdentBufferLen];
3356   *identbuf = 0;
3357
3358   if ( stream == 0 )
3359     stream = stderr;
3360
3361   MCALabelSubDescriptor::Dump(stream);
3362   if ( ! SoundfieldGroupLinkID.empty() ) {
3363     fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.get().EncodeString(identbuf, IdentBufferLen));
3364   }
3365 }
3366
3367 //
3368 ASDCP::Result_t
3369 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3370 {
3371   return InterchangeObject::InitFromBuffer(p, l);
3372 }
3373
3374 //
3375 ASDCP::Result_t
3376 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3377 {
3378   return InterchangeObject::WriteToBuffer(Buffer);
3379 }
3380
3381 //------------------------------------------------------------------------------------------
3382 // SoundfieldGroupLabelSubDescriptor
3383
3384 //
3385
3386 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3387 {
3388   assert(m_Dict);
3389   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3390 }
3391
3392 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3393 {
3394   assert(m_Dict);
3395   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3396   Copy(rhs);
3397 }
3398
3399
3400 //
3401 ASDCP::Result_t
3402 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3403 {
3404   assert(m_Dict);
3405   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3406   if ( ASDCP_SUCCESS(result) ) {
3407     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3408   }
3409   return result;
3410 }
3411
3412 //
3413 ASDCP::Result_t
3414 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3415 {
3416   assert(m_Dict);
3417   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3418   if ( ASDCP_SUCCESS(result)  && ! GroupOfSoundfieldGroupsLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3419   return result;
3420 }
3421
3422 //
3423 void
3424 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
3425 {
3426   MCALabelSubDescriptor::Copy(rhs);
3427   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
3428 }
3429
3430 //
3431 void
3432 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
3433 {
3434   char identbuf[IdentBufferLen];
3435   *identbuf = 0;
3436
3437   if ( stream == 0 )
3438     stream = stderr;
3439
3440   MCALabelSubDescriptor::Dump(stream);
3441   if ( ! GroupOfSoundfieldGroupsLinkID.empty() ) {
3442     fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
3443   GroupOfSoundfieldGroupsLinkID.get().Dump(stream);
3444   }
3445 }
3446
3447 //
3448 ASDCP::Result_t
3449 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3450 {
3451   return InterchangeObject::InitFromBuffer(p, l);
3452 }
3453
3454 //
3455 ASDCP::Result_t
3456 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3457 {
3458   return InterchangeObject::WriteToBuffer(Buffer);
3459 }
3460
3461 //------------------------------------------------------------------------------------------
3462 // GroupOfSoundfieldGroupsLabelSubDescriptor
3463
3464 //
3465
3466 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3467 {
3468   assert(m_Dict);
3469   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3470 }
3471
3472 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3473 {
3474   assert(m_Dict);
3475   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3476   Copy(rhs);
3477 }
3478
3479
3480 //
3481 ASDCP::Result_t
3482 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3483 {
3484   assert(m_Dict);
3485   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3486   return result;
3487 }
3488
3489 //
3490 ASDCP::Result_t
3491 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3492 {
3493   assert(m_Dict);
3494   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3495   return result;
3496 }
3497
3498 //
3499 void
3500 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
3501 {
3502   MCALabelSubDescriptor::Copy(rhs);
3503 }
3504
3505 //
3506 void
3507 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
3508 {
3509   char identbuf[IdentBufferLen];
3510   *identbuf = 0;
3511
3512   if ( stream == 0 )
3513     stream = stderr;
3514
3515   MCALabelSubDescriptor::Dump(stream);
3516 }
3517
3518 //
3519 ASDCP::Result_t
3520 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3521 {
3522   return InterchangeObject::InitFromBuffer(p, l);
3523 }
3524
3525 //
3526 ASDCP::Result_t
3527 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3528 {
3529   return InterchangeObject::WriteToBuffer(Buffer);
3530 }
3531
3532 //------------------------------------------------------------------------------------------
3533 // DCDataDescriptor
3534
3535 //
3536
3537 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3538 {
3539   assert(m_Dict);
3540   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3541 }
3542
3543 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3544 {
3545   assert(m_Dict);
3546   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3547   Copy(rhs);
3548 }
3549
3550
3551 //
3552 ASDCP::Result_t
3553 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3554 {
3555   assert(m_Dict);
3556   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3557   return result;
3558 }
3559
3560 //
3561 ASDCP::Result_t
3562 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3563 {
3564   assert(m_Dict);
3565   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3566   return result;
3567 }
3568
3569 //
3570 void
3571 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
3572 {
3573   GenericDataEssenceDescriptor::Copy(rhs);
3574 }
3575
3576 //
3577 void
3578 DCDataDescriptor::Dump(FILE* stream)
3579 {
3580   char identbuf[IdentBufferLen];
3581   *identbuf = 0;
3582
3583   if ( stream == 0 )
3584     stream = stderr;
3585
3586   GenericDataEssenceDescriptor::Dump(stream);
3587 }
3588
3589 //
3590 ASDCP::Result_t
3591 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3592 {
3593   return InterchangeObject::InitFromBuffer(p, l);
3594 }
3595
3596 //
3597 ASDCP::Result_t
3598 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3599 {
3600   return InterchangeObject::WriteToBuffer(Buffer);
3601 }
3602
3603 //------------------------------------------------------------------------------------------
3604 // DolbyAtmosSubDescriptor
3605
3606 //
3607
3608 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
3609 {
3610   assert(m_Dict);
3611   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3612 }
3613
3614 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3615 {
3616   assert(m_Dict);
3617   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3618   Copy(rhs);
3619 }
3620
3621
3622 //
3623 ASDCP::Result_t
3624 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3625 {
3626   assert(m_Dict);
3627   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3628   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3629   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3630   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3631   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3632   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3633   return result;
3634 }
3635
3636 //
3637 ASDCP::Result_t
3638 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3639 {
3640   assert(m_Dict);
3641   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3642   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
3643   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
3644   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
3645   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
3646   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
3647   return result;
3648 }
3649
3650 //
3651 void
3652 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
3653 {
3654   InterchangeObject::Copy(rhs);
3655   AtmosID = rhs.AtmosID;
3656   FirstFrame = rhs.FirstFrame;
3657   MaxChannelCount = rhs.MaxChannelCount;
3658   MaxObjectCount = rhs.MaxObjectCount;
3659   AtmosVersion = rhs.AtmosVersion;
3660 }
3661
3662 //
3663 void
3664 DolbyAtmosSubDescriptor::Dump(FILE* stream)
3665 {
3666   char identbuf[IdentBufferLen];
3667   *identbuf = 0;
3668
3669   if ( stream == 0 )
3670     stream = stderr;
3671
3672   InterchangeObject::Dump(stream);
3673   fprintf(stream, "  %22s = %s\n",  "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
3674   fprintf(stream, "  %22s = %d\n",  "FirstFrame", FirstFrame);
3675   fprintf(stream, "  %22s = %d\n",  "MaxChannelCount", MaxChannelCount);
3676   fprintf(stream, "  %22s = %d\n",  "MaxObjectCount", MaxObjectCount);
3677   fprintf(stream, "  %22s = %d\n",  "AtmosVersion", AtmosVersion);
3678 }
3679
3680 //
3681 ASDCP::Result_t
3682 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3683 {
3684   return InterchangeObject::InitFromBuffer(p, l);
3685 }
3686
3687 //
3688 ASDCP::Result_t
3689 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3690 {
3691   return InterchangeObject::WriteToBuffer(Buffer);
3692 }
3693
3694 //------------------------------------------------------------------------------------------
3695 // PHDRMetadataTrackSubDescriptor
3696
3697 //
3698
3699 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), SourceTrackID(0), SimplePayloadSID(0)
3700 {
3701   assert(m_Dict);
3702   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
3703 }
3704
3705 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3706 {
3707   assert(m_Dict);
3708   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
3709   Copy(rhs);
3710 }
3711
3712
3713 //
3714 ASDCP::Result_t
3715 PHDRMetadataTrackSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3716 {
3717   assert(m_Dict);
3718   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3719   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
3720   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
3721   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
3722   return result;
3723 }
3724
3725 //
3726 ASDCP::Result_t
3727 PHDRMetadataTrackSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3728 {
3729   assert(m_Dict);
3730   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3731   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
3732   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
3733   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
3734   return result;
3735 }
3736
3737 //
3738 void
3739 PHDRMetadataTrackSubDescriptor::Copy(const PHDRMetadataTrackSubDescriptor& rhs)
3740 {
3741   InterchangeObject::Copy(rhs);
3742   DataDefinition = rhs.DataDefinition;
3743   SourceTrackID = rhs.SourceTrackID;
3744   SimplePayloadSID = rhs.SimplePayloadSID;
3745 }
3746
3747 //
3748 void
3749 PHDRMetadataTrackSubDescriptor::Dump(FILE* stream)
3750 {
3751   char identbuf[IdentBufferLen];
3752   *identbuf = 0;
3753
3754   if ( stream == 0 )
3755     stream = stderr;
3756
3757   InterchangeObject::Dump(stream);
3758   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
3759   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
3760   fprintf(stream, "  %22s = %d\n",  "SimplePayloadSID", SimplePayloadSID);
3761 }
3762
3763 //
3764 ASDCP::Result_t
3765 PHDRMetadataTrackSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3766 {
3767   return InterchangeObject::InitFromBuffer(p, l);
3768 }
3769
3770 //
3771 ASDCP::Result_t
3772 PHDRMetadataTrackSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3773 {
3774   return InterchangeObject::WriteToBuffer(Buffer);
3775 }
3776
3777 //
3778 // end Metadata.cpp
3779 //