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