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