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