src/Metadata.cpp

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