src/Metadata.cpp

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