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.ReadObject(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.WriteObject(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:\n",  "J2KCorrespondingProfile");
2235   J2KCorrespondingProfile.get().Dump(stream);
2236   }
2237 }
2238
2239 //
2240 ASDCP::Result_t
2241 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2242 {
2243   return InterchangeObject::InitFromBuffer(p, l);
2244 }
2245
2246 //
2247 ASDCP::Result_t
2248 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2249 {
2250   return InterchangeObject::WriteToBuffer(Buffer);
2251 }
2252
2253 //------------------------------------------------------------------------------------------
2254 // CDCIEssenceDescriptor
2255
2256 //
2257
2258 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0)
2259 {
2260   assert(m_Dict);
2261   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2262 }
2263
2264 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2265 {
2266   assert(m_Dict);
2267   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2268   Copy(rhs);
2269 }
2270
2271
2272 //
2273 ASDCP::Result_t
2274 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2275 {
2276   assert(m_Dict);
2277   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
2278   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2279   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2280   if ( ASDCP_SUCCESS(result) ) {
2281     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2282     VerticalSubsampling.set_has_value( result == RESULT_OK );
2283   }
2284   if ( ASDCP_SUCCESS(result) ) {
2285     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2286     ColorSiting.set_has_value( result == RESULT_OK );
2287   }
2288   if ( ASDCP_SUCCESS(result) ) {
2289     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2290     ReversedByteOrder.set_has_value( result == RESULT_OK );
2291   }
2292   if ( ASDCP_SUCCESS(result) ) {
2293     result = TLVSet.ReadUi16(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2294     PaddingBits.set_has_value( result == RESULT_OK );
2295   }
2296   if ( ASDCP_SUCCESS(result) ) {
2297     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2298     AlphaSampleDepth.set_has_value( result == RESULT_OK );
2299   }
2300   if ( ASDCP_SUCCESS(result) ) {
2301     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2302     BlackRefLevel.set_has_value( result == RESULT_OK );
2303   }
2304   if ( ASDCP_SUCCESS(result) ) {
2305     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2306     WhiteReflevel.set_has_value( result == RESULT_OK );
2307   }
2308   if ( ASDCP_SUCCESS(result) ) {
2309     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2310     ColorRange.set_has_value( result == RESULT_OK );
2311   }
2312   return result;
2313 }
2314
2315 //
2316 ASDCP::Result_t
2317 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2318 {
2319   assert(m_Dict);
2320   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2321   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2322   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2323   if ( ASDCP_SUCCESS(result)  && ! VerticalSubsampling.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2324   if ( ASDCP_SUCCESS(result)  && ! ColorSiting.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2325   if ( ASDCP_SUCCESS(result)  && ! ReversedByteOrder.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2326   if ( ASDCP_SUCCESS(result)  && ! PaddingBits.empty() ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2327   if ( ASDCP_SUCCESS(result)  && ! AlphaSampleDepth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2328   if ( ASDCP_SUCCESS(result)  && ! BlackRefLevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2329   if ( ASDCP_SUCCESS(result)  && ! WhiteReflevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2330   if ( ASDCP_SUCCESS(result)  && ! ColorRange.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2331   return result;
2332 }
2333
2334 //
2335 void
2336 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
2337 {
2338   GenericPictureEssenceDescriptor::Copy(rhs);
2339   ComponentDepth = rhs.ComponentDepth;
2340   HorizontalSubsampling = rhs.HorizontalSubsampling;
2341   VerticalSubsampling = rhs.VerticalSubsampling;
2342   ColorSiting = rhs.ColorSiting;
2343   ReversedByteOrder = rhs.ReversedByteOrder;
2344   PaddingBits = rhs.PaddingBits;
2345   AlphaSampleDepth = rhs.AlphaSampleDepth;
2346   BlackRefLevel = rhs.BlackRefLevel;
2347   WhiteReflevel = rhs.WhiteReflevel;
2348   ColorRange = rhs.ColorRange;
2349 }
2350
2351 //
2352 void
2353 CDCIEssenceDescriptor::Dump(FILE* stream)
2354 {
2355   char identbuf[IdentBufferLen];
2356   *identbuf = 0;
2357
2358   if ( stream == 0 )
2359     stream = stderr;
2360
2361   GenericPictureEssenceDescriptor::Dump(stream);
2362   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
2363   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
2364   if ( ! VerticalSubsampling.empty() ) {
2365     fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling.get());
2366   }
2367   if ( ! ColorSiting.empty() ) {
2368     fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting.get());
2369   }
2370   if ( ! ReversedByteOrder.empty() ) {
2371     fprintf(stream, "  %22s = %d\n",  "ReversedByteOrder", ReversedByteOrder.get());
2372   }
2373   if ( ! PaddingBits.empty() ) {
2374     fprintf(stream, "  %22s = %d\n",  "PaddingBits", PaddingBits.get());
2375   }
2376   if ( ! AlphaSampleDepth.empty() ) {
2377     fprintf(stream, "  %22s = %d\n",  "AlphaSampleDepth", AlphaSampleDepth.get());
2378   }
2379   if ( ! BlackRefLevel.empty() ) {
2380     fprintf(stream, "  %22s = %d\n",  "BlackRefLevel", BlackRefLevel.get());
2381   }
2382   if ( ! WhiteReflevel.empty() ) {
2383     fprintf(stream, "  %22s = %d\n",  "WhiteReflevel", WhiteReflevel.get());
2384   }
2385   if ( ! ColorRange.empty() ) {
2386     fprintf(stream, "  %22s = %d\n",  "ColorRange", ColorRange.get());
2387   }
2388 }
2389
2390 //
2391 ASDCP::Result_t
2392 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2393 {
2394   return InterchangeObject::InitFromBuffer(p, l);
2395 }
2396
2397 //
2398 ASDCP::Result_t
2399 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2400 {
2401   return InterchangeObject::WriteToBuffer(Buffer);
2402 }
2403
2404 //------------------------------------------------------------------------------------------
2405 // MPEG2VideoDescriptor
2406
2407 //
2408
2409 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d)
2410 {
2411   assert(m_Dict);
2412   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2413 }
2414
2415 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2416 {
2417   assert(m_Dict);
2418   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2419   Copy(rhs);
2420 }
2421
2422
2423 //
2424 ASDCP::Result_t
2425 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2426 {
2427   assert(m_Dict);
2428   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
2429   if ( ASDCP_SUCCESS(result) ) {
2430     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2431     SingleSequence.set_has_value( result == RESULT_OK );
2432   }
2433   if ( ASDCP_SUCCESS(result) ) {
2434     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2435     ConstantBFrames.set_has_value( result == RESULT_OK );
2436   }
2437   if ( ASDCP_SUCCESS(result) ) {
2438     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2439     CodedContentType.set_has_value( result == RESULT_OK );
2440   }
2441   if ( ASDCP_SUCCESS(result) ) {
2442     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2443     LowDelay.set_has_value( result == RESULT_OK );
2444   }
2445   if ( ASDCP_SUCCESS(result) ) {
2446     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2447     ClosedGOP.set_has_value( result == RESULT_OK );
2448   }
2449   if ( ASDCP_SUCCESS(result) ) {
2450     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2451     IdenticalGOP.set_has_value( result == RESULT_OK );
2452   }
2453   if ( ASDCP_SUCCESS(result) ) {
2454     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2455     MaxGOP.set_has_value( result == RESULT_OK );
2456   }
2457   if ( ASDCP_SUCCESS(result) ) {
2458     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2459     BPictureCount.set_has_value( result == RESULT_OK );
2460   }
2461   if ( ASDCP_SUCCESS(result) ) {
2462     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2463     BitRate.set_has_value( result == RESULT_OK );
2464   }
2465   if ( ASDCP_SUCCESS(result) ) {
2466     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2467     ProfileAndLevel.set_has_value( result == RESULT_OK );
2468   }
2469   return result;
2470 }
2471
2472 //
2473 ASDCP::Result_t
2474 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2475 {
2476   assert(m_Dict);
2477   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
2478   if ( ASDCP_SUCCESS(result)  && ! SingleSequence.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2479   if ( ASDCP_SUCCESS(result)  && ! ConstantBFrames.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2480   if ( ASDCP_SUCCESS(result)  && ! CodedContentType.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2481   if ( ASDCP_SUCCESS(result)  && ! LowDelay.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2482   if ( ASDCP_SUCCESS(result)  && ! ClosedGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2483   if ( ASDCP_SUCCESS(result)  && ! IdenticalGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2484   if ( ASDCP_SUCCESS(result)  && ! MaxGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2485   if ( ASDCP_SUCCESS(result)  && ! BPictureCount.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2486   if ( ASDCP_SUCCESS(result)  && ! BitRate.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2487   if ( ASDCP_SUCCESS(result)  && ! ProfileAndLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2488   return result;
2489 }
2490
2491 //
2492 void
2493 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
2494 {
2495   CDCIEssenceDescriptor::Copy(rhs);
2496   SingleSequence = rhs.SingleSequence;
2497   ConstantBFrames = rhs.ConstantBFrames;
2498   CodedContentType = rhs.CodedContentType;
2499   LowDelay = rhs.LowDelay;
2500   ClosedGOP = rhs.ClosedGOP;
2501   IdenticalGOP = rhs.IdenticalGOP;
2502   MaxGOP = rhs.MaxGOP;
2503   BPictureCount = rhs.BPictureCount;
2504   BitRate = rhs.BitRate;
2505   ProfileAndLevel = rhs.ProfileAndLevel;
2506 }
2507
2508 //
2509 void
2510 MPEG2VideoDescriptor::Dump(FILE* stream)
2511 {
2512   char identbuf[IdentBufferLen];
2513   *identbuf = 0;
2514
2515   if ( stream == 0 )
2516     stream = stderr;
2517
2518   CDCIEssenceDescriptor::Dump(stream);
2519   if ( ! SingleSequence.empty() ) {
2520     fprintf(stream, "  %22s = %d\n",  "SingleSequence", SingleSequence.get());
2521   }
2522   if ( ! ConstantBFrames.empty() ) {
2523     fprintf(stream, "  %22s = %d\n",  "ConstantBFrames", ConstantBFrames.get());
2524   }
2525   if ( ! CodedContentType.empty() ) {
2526     fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType.get());
2527   }
2528   if ( ! LowDelay.empty() ) {
2529     fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay.get());
2530   }
2531   if ( ! ClosedGOP.empty() ) {
2532     fprintf(stream, "  %22s = %d\n",  "ClosedGOP", ClosedGOP.get());
2533   }
2534   if ( ! IdenticalGOP.empty() ) {
2535     fprintf(stream, "  %22s = %d\n",  "IdenticalGOP", IdenticalGOP.get());
2536   }
2537   if ( ! MaxGOP.empty() ) {
2538     fprintf(stream, "  %22s = %d\n",  "MaxGOP", MaxGOP.get());
2539   }
2540   if ( ! BPictureCount.empty() ) {
2541     fprintf(stream, "  %22s = %d\n",  "BPictureCount", BPictureCount.get());
2542   }
2543   if ( ! BitRate.empty() ) {
2544     fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate.get());
2545   }
2546   if ( ! ProfileAndLevel.empty() ) {
2547     fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel.get());
2548   }
2549 }
2550
2551 //
2552 ASDCP::Result_t
2553 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2554 {
2555   return InterchangeObject::InitFromBuffer(p, l);
2556 }
2557
2558 //
2559 ASDCP::Result_t
2560 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2561 {
2562   return InterchangeObject::WriteToBuffer(Buffer);
2563 }
2564
2565 //------------------------------------------------------------------------------------------
2566 // DMSegment
2567
2568 //
2569
2570 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2571 {
2572   assert(m_Dict);
2573   m_UL = m_Dict->ul(MDD_DMSegment);
2574 }
2575
2576 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2577 {
2578   assert(m_Dict);
2579   m_UL = m_Dict->ul(MDD_DMSegment);
2580   Copy(rhs);
2581 }
2582
2583
2584 //
2585 ASDCP::Result_t
2586 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
2587 {
2588   assert(m_Dict);
2589   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2590   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
2591   if ( ASDCP_SUCCESS(result) ) {
2592     result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(DMSegment, Duration));
2593     Duration.set_has_value( result == RESULT_OK );
2594   }
2595   if ( ASDCP_SUCCESS(result) ) {
2596     result = TLVSet.ReadUi64(OBJ_READ_ARGS_OPT(DMSegment, EventStartPosition));
2597     EventStartPosition.set_has_value( result == RESULT_OK );
2598   }
2599   if ( ASDCP_SUCCESS(result) ) {
2600     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DMSegment, EventComment));
2601     EventComment.set_has_value( result == RESULT_OK );
2602   }
2603   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2604   return result;
2605 }
2606
2607 //
2608 ASDCP::Result_t
2609 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2610 {
2611   assert(m_Dict);
2612   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2613   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2614   if ( ASDCP_SUCCESS(result)  && ! Duration.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(DMSegment, Duration));
2615   if ( ASDCP_SUCCESS(result)  && ! EventStartPosition.empty() ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS_OPT(DMSegment, EventStartPosition));
2616   if ( ASDCP_SUCCESS(result)  && ! EventComment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DMSegment, EventComment));
2617   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2618   return result;
2619 }
2620
2621 //
2622 void
2623 DMSegment::Copy(const DMSegment& rhs)
2624 {
2625   InterchangeObject::Copy(rhs);
2626   DataDefinition = rhs.DataDefinition;
2627   Duration = rhs.Duration;
2628   EventStartPosition = rhs.EventStartPosition;
2629   EventComment = rhs.EventComment;
2630   DMFramework = rhs.DMFramework;
2631 }
2632
2633 //
2634 void
2635 DMSegment::Dump(FILE* stream)
2636 {
2637   char identbuf[IdentBufferLen];
2638   *identbuf = 0;
2639
2640   if ( stream == 0 )
2641     stream = stderr;
2642
2643   InterchangeObject::Dump(stream);
2644   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2645   if ( ! Duration.empty() ) {
2646     fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration.get(), identbuf));
2647   }
2648   if ( ! EventStartPosition.empty() ) {
2649     fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition.get(), identbuf));
2650   }
2651   if ( ! EventComment.empty() ) {
2652     fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.get().EncodeString(identbuf, IdentBufferLen));
2653   }
2654   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2655 }
2656
2657 //
2658 ASDCP::Result_t
2659 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2660 {
2661   return InterchangeObject::InitFromBuffer(p, l);
2662 }
2663
2664 //
2665 ASDCP::Result_t
2666 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2667 {
2668   return InterchangeObject::WriteToBuffer(Buffer);
2669 }
2670
2671 //------------------------------------------------------------------------------------------
2672 // CryptographicFramework
2673
2674 //
2675
2676 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2677 {
2678   assert(m_Dict);
2679   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2680 }
2681
2682 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2683 {
2684   assert(m_Dict);
2685   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2686   Copy(rhs);
2687 }
2688
2689
2690 //
2691 ASDCP::Result_t
2692 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2693 {
2694   assert(m_Dict);
2695   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2696   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2697   return result;
2698 }
2699
2700 //
2701 ASDCP::Result_t
2702 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2703 {
2704   assert(m_Dict);
2705   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2706   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2707   return result;
2708 }
2709
2710 //
2711 void
2712 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2713 {
2714   InterchangeObject::Copy(rhs);
2715   ContextSR = rhs.ContextSR;
2716 }
2717
2718 //
2719 void
2720 CryptographicFramework::Dump(FILE* stream)
2721 {
2722   char identbuf[IdentBufferLen];
2723   *identbuf = 0;
2724
2725   if ( stream == 0 )
2726     stream = stderr;
2727
2728   InterchangeObject::Dump(stream);
2729   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2730 }
2731
2732 //
2733 ASDCP::Result_t
2734 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2735 {
2736   return InterchangeObject::InitFromBuffer(p, l);
2737 }
2738
2739 //
2740 ASDCP::Result_t
2741 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2742 {
2743   return InterchangeObject::WriteToBuffer(Buffer);
2744 }
2745
2746 //------------------------------------------------------------------------------------------
2747 // CryptographicContext
2748
2749 //
2750
2751 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2752 {
2753   assert(m_Dict);
2754   m_UL = m_Dict->ul(MDD_CryptographicContext);
2755 }
2756
2757 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2758 {
2759   assert(m_Dict);
2760   m_UL = m_Dict->ul(MDD_CryptographicContext);
2761   Copy(rhs);
2762 }
2763
2764
2765 //
2766 ASDCP::Result_t
2767 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2768 {
2769   assert(m_Dict);
2770   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2771   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2772   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2773   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2774   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2775   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2776   return result;
2777 }
2778
2779 //
2780 ASDCP::Result_t
2781 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2782 {
2783   assert(m_Dict);
2784   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2785   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2786   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2787   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2788   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2789   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2790   return result;
2791 }
2792
2793 //
2794 void
2795 CryptographicContext::Copy(const CryptographicContext& rhs)
2796 {
2797   InterchangeObject::Copy(rhs);
2798   ContextID = rhs.ContextID;
2799   SourceEssenceContainer = rhs.SourceEssenceContainer;
2800   CipherAlgorithm = rhs.CipherAlgorithm;
2801   MICAlgorithm = rhs.MICAlgorithm;
2802   CryptographicKeyID = rhs.CryptographicKeyID;
2803 }
2804
2805 //
2806 void
2807 CryptographicContext::Dump(FILE* stream)
2808 {
2809   char identbuf[IdentBufferLen];
2810   *identbuf = 0;
2811
2812   if ( stream == 0 )
2813     stream = stderr;
2814
2815   InterchangeObject::Dump(stream);
2816   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2817   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2818   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2819   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2820   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2821 }
2822
2823 //
2824 ASDCP::Result_t
2825 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2826 {
2827   return InterchangeObject::InitFromBuffer(p, l);
2828 }
2829
2830 //
2831 ASDCP::Result_t
2832 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2833 {
2834   return InterchangeObject::WriteToBuffer(Buffer);
2835 }
2836
2837 //------------------------------------------------------------------------------------------
2838 // DescriptiveFramework
2839
2840 //
2841
2842 DescriptiveFramework::DescriptiveFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2843 {
2844   assert(m_Dict);
2845   m_UL = m_Dict->ul(MDD_DescriptiveFramework);
2846 }
2847
2848 DescriptiveFramework::DescriptiveFramework(const DescriptiveFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2849 {
2850   assert(m_Dict);
2851   m_UL = m_Dict->ul(MDD_DescriptiveFramework);
2852   Copy(rhs);
2853 }
2854
2855
2856 //
2857 ASDCP::Result_t
2858 DescriptiveFramework::InitFromTLVSet(TLVReader& TLVSet)
2859 {
2860   assert(m_Dict);
2861   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2862   if ( ASDCP_SUCCESS(result) ) {
2863     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DescriptiveFramework, LinkedDescriptiveFrameworkPlugInId));
2864     LinkedDescriptiveFrameworkPlugInId.set_has_value( result == RESULT_OK );
2865   }
2866   return result;
2867 }
2868
2869 //
2870 ASDCP::Result_t
2871 DescriptiveFramework::WriteToTLVSet(TLVWriter& TLVSet)
2872 {
2873   assert(m_Dict);
2874   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2875   if ( ASDCP_SUCCESS(result)  && ! LinkedDescriptiveFrameworkPlugInId.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DescriptiveFramework, LinkedDescriptiveFrameworkPlugInId));
2876   return result;
2877 }
2878
2879 //
2880 void
2881 DescriptiveFramework::Copy(const DescriptiveFramework& rhs)
2882 {
2883   InterchangeObject::Copy(rhs);
2884   LinkedDescriptiveFrameworkPlugInId = rhs.LinkedDescriptiveFrameworkPlugInId;
2885 }
2886
2887 //
2888 void
2889 DescriptiveFramework::Dump(FILE* stream)
2890 {
2891   char identbuf[IdentBufferLen];
2892   *identbuf = 0;
2893
2894   if ( stream == 0 )
2895     stream = stderr;
2896
2897   InterchangeObject::Dump(stream);
2898   if ( ! LinkedDescriptiveFrameworkPlugInId.empty() ) {
2899     fprintf(stream, "  %22s = %s\n",  "LinkedDescriptiveFrameworkPlugInId", LinkedDescriptiveFrameworkPlugInId.get().EncodeString(identbuf, IdentBufferLen));
2900   }
2901 }
2902
2903 //
2904 ASDCP::Result_t
2905 DescriptiveFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2906 {
2907   return InterchangeObject::InitFromBuffer(p, l);
2908 }
2909
2910 //
2911 ASDCP::Result_t
2912 DescriptiveFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2913 {
2914   return InterchangeObject::WriteToBuffer(Buffer);
2915 }
2916
2917 //------------------------------------------------------------------------------------------
2918 // DescriptiveObject
2919
2920 //
2921
2922 DescriptiveObject::DescriptiveObject(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2923 {
2924   assert(m_Dict);
2925   m_UL = m_Dict->ul(MDD_DescriptiveObject);
2926 }
2927
2928 DescriptiveObject::DescriptiveObject(const DescriptiveObject& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2929 {
2930   assert(m_Dict);
2931   m_UL = m_Dict->ul(MDD_DescriptiveObject);
2932   Copy(rhs);
2933 }
2934
2935
2936 //
2937 ASDCP::Result_t
2938 DescriptiveObject::InitFromTLVSet(TLVReader& TLVSet)
2939 {
2940   assert(m_Dict);
2941   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2942   if ( ASDCP_SUCCESS(result) ) {
2943     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DescriptiveObject, LinkedDescriptiveObjectPlugInId));
2944     LinkedDescriptiveObjectPlugInId.set_has_value( result == RESULT_OK );
2945   }
2946   return result;
2947 }
2948
2949 //
2950 ASDCP::Result_t
2951 DescriptiveObject::WriteToTLVSet(TLVWriter& TLVSet)
2952 {
2953   assert(m_Dict);
2954   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2955   if ( ASDCP_SUCCESS(result)  && ! LinkedDescriptiveObjectPlugInId.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DescriptiveObject, LinkedDescriptiveObjectPlugInId));
2956   return result;
2957 }
2958
2959 //
2960 void
2961 DescriptiveObject::Copy(const DescriptiveObject& rhs)
2962 {
2963   InterchangeObject::Copy(rhs);
2964   LinkedDescriptiveObjectPlugInId = rhs.LinkedDescriptiveObjectPlugInId;
2965 }
2966
2967 //
2968 void
2969 DescriptiveObject::Dump(FILE* stream)
2970 {
2971   char identbuf[IdentBufferLen];
2972   *identbuf = 0;
2973
2974   if ( stream == 0 )
2975     stream = stderr;
2976
2977   InterchangeObject::Dump(stream);
2978   if ( ! LinkedDescriptiveObjectPlugInId.empty() ) {
2979     fprintf(stream, "  %22s = %s\n",  "LinkedDescriptiveObjectPlugInId", LinkedDescriptiveObjectPlugInId.get().EncodeString(identbuf, IdentBufferLen));
2980   }
2981 }
2982
2983 //
2984 ASDCP::Result_t
2985 DescriptiveObject::InitFromBuffer(const byte_t* p, ui32_t l)
2986 {
2987   return InterchangeObject::InitFromBuffer(p, l);
2988 }
2989
2990 //
2991 ASDCP::Result_t
2992 DescriptiveObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2993 {
2994   return InterchangeObject::WriteToBuffer(Buffer);
2995 }
2996
2997 //------------------------------------------------------------------------------------------
2998 // GenericDataEssenceDescriptor
2999
3000 //
3001
3002 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
3003 {
3004   assert(m_Dict);
3005   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
3006 }
3007
3008 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3009 {
3010   assert(m_Dict);
3011   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
3012   Copy(rhs);
3013 }
3014
3015
3016 //
3017 ASDCP::Result_t
3018 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3019 {
3020   assert(m_Dict);
3021   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
3022   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
3023   return result;
3024 }
3025
3026 //
3027 ASDCP::Result_t
3028 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3029 {
3030   assert(m_Dict);
3031   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
3032   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
3033   return result;
3034 }
3035
3036 //
3037 void
3038 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
3039 {
3040   FileDescriptor::Copy(rhs);
3041   DataEssenceCoding = rhs.DataEssenceCoding;
3042 }
3043
3044 //
3045 void
3046 GenericDataEssenceDescriptor::Dump(FILE* stream)
3047 {
3048   char identbuf[IdentBufferLen];
3049   *identbuf = 0;
3050
3051   if ( stream == 0 )
3052     stream = stderr;
3053
3054   FileDescriptor::Dump(stream);
3055   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
3056 }
3057
3058 //
3059 ASDCP::Result_t
3060 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3061 {
3062   return InterchangeObject::InitFromBuffer(p, l);
3063 }
3064
3065 //
3066 ASDCP::Result_t
3067 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3068 {
3069   return InterchangeObject::WriteToBuffer(Buffer);
3070 }
3071
3072 //------------------------------------------------------------------------------------------
3073 // TimedTextDescriptor
3074
3075 //
3076
3077 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3078 {
3079   assert(m_Dict);
3080   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
3081 }
3082
3083 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3084 {
3085   assert(m_Dict);
3086   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
3087   Copy(rhs);
3088 }
3089
3090
3091 //
3092 ASDCP::Result_t
3093 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3094 {
3095   assert(m_Dict);
3096   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3097   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
3098   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
3099   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
3100   if ( ASDCP_SUCCESS(result) ) {
3101     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
3102     RFC5646LanguageTagList.set_has_value( result == RESULT_OK );
3103   }
3104   return result;
3105 }
3106
3107 //
3108 ASDCP::Result_t
3109 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3110 {
3111   assert(m_Dict);
3112   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3113   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
3114   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
3115   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
3116   if ( ASDCP_SUCCESS(result)  && ! RFC5646LanguageTagList.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
3117   return result;
3118 }
3119
3120 //
3121 void
3122 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
3123 {
3124   GenericDataEssenceDescriptor::Copy(rhs);
3125   ResourceID = rhs.ResourceID;
3126   UCSEncoding = rhs.UCSEncoding;
3127   NamespaceURI = rhs.NamespaceURI;
3128   RFC5646LanguageTagList = rhs.RFC5646LanguageTagList;
3129 }
3130
3131 //
3132 void
3133 TimedTextDescriptor::Dump(FILE* stream)
3134 {
3135   char identbuf[IdentBufferLen];
3136   *identbuf = 0;
3137
3138   if ( stream == 0 )
3139     stream = stderr;
3140
3141   GenericDataEssenceDescriptor::Dump(stream);
3142   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
3143   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
3144   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
3145   if ( ! RFC5646LanguageTagList.empty() ) {
3146     fprintf(stream, "  %22s = %s\n",  "RFC5646LanguageTagList", RFC5646LanguageTagList.get().EncodeString(identbuf, IdentBufferLen));
3147   }
3148 }
3149
3150 //
3151 ASDCP::Result_t
3152 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3153 {
3154   return InterchangeObject::InitFromBuffer(p, l);
3155 }
3156
3157 //
3158 ASDCP::Result_t
3159 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3160 {
3161   return InterchangeObject::WriteToBuffer(Buffer);
3162 }
3163
3164 //------------------------------------------------------------------------------------------
3165 // TimedTextResourceSubDescriptor
3166
3167 //
3168
3169 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
3170 {
3171   assert(m_Dict);
3172   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
3173 }
3174
3175 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3176 {
3177   assert(m_Dict);
3178   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
3179   Copy(rhs);
3180 }
3181
3182
3183 //
3184 ASDCP::Result_t
3185 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3186 {
3187   assert(m_Dict);
3188   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3189   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
3190   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
3191   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
3192   return result;
3193 }
3194
3195 //
3196 ASDCP::Result_t
3197 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3198 {
3199   assert(m_Dict);
3200   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3201   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
3202   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
3203   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
3204   return result;
3205 }
3206
3207 //
3208 void
3209 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
3210 {
3211   InterchangeObject::Copy(rhs);
3212   AncillaryResourceID = rhs.AncillaryResourceID;
3213   MIMEMediaType = rhs.MIMEMediaType;
3214   EssenceStreamID = rhs.EssenceStreamID;
3215 }
3216
3217 //
3218 void
3219 TimedTextResourceSubDescriptor::Dump(FILE* stream)
3220 {
3221   char identbuf[IdentBufferLen];
3222   *identbuf = 0;
3223
3224   if ( stream == 0 )
3225     stream = stderr;
3226
3227   InterchangeObject::Dump(stream);
3228   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
3229   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
3230   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
3231 }
3232
3233 //
3234 ASDCP::Result_t
3235 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3236 {
3237   return InterchangeObject::InitFromBuffer(p, l);
3238 }
3239
3240 //
3241 ASDCP::Result_t
3242 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3243 {
3244   return InterchangeObject::WriteToBuffer(Buffer);
3245 }
3246
3247 //------------------------------------------------------------------------------------------
3248 // StereoscopicPictureSubDescriptor
3249
3250 //
3251
3252 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3253 {
3254   assert(m_Dict);
3255   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3256 }
3257
3258 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3259 {
3260   assert(m_Dict);
3261   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3262   Copy(rhs);
3263 }
3264
3265
3266 //
3267 ASDCP::Result_t
3268 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3269 {
3270   assert(m_Dict);
3271   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3272   return result;
3273 }
3274
3275 //
3276 ASDCP::Result_t
3277 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3278 {
3279   assert(m_Dict);
3280   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3281   return result;
3282 }
3283
3284 //
3285 void
3286 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
3287 {
3288   InterchangeObject::Copy(rhs);
3289 }
3290
3291 //
3292 void
3293 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
3294 {
3295   char identbuf[IdentBufferLen];
3296   *identbuf = 0;
3297
3298   if ( stream == 0 )
3299     stream = stderr;
3300
3301   InterchangeObject::Dump(stream);
3302 }
3303
3304 //
3305 ASDCP::Result_t
3306 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3307 {
3308   return InterchangeObject::InitFromBuffer(p, l);
3309 }
3310
3311 //
3312 ASDCP::Result_t
3313 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3314 {
3315   return InterchangeObject::WriteToBuffer(Buffer);
3316 }
3317
3318 //------------------------------------------------------------------------------------------
3319 // ContainerConstraintSubDescriptor
3320
3321 //
3322
3323 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3324 {
3325   assert(m_Dict);
3326   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3327 }
3328
3329 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3330 {
3331   assert(m_Dict);
3332   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3333   Copy(rhs);
3334 }
3335
3336
3337 //
3338 ASDCP::Result_t
3339 ContainerConstraintSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3340 {
3341   assert(m_Dict);
3342   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3343   return result;
3344 }
3345
3346 //
3347 ASDCP::Result_t
3348 ContainerConstraintSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3349 {
3350   assert(m_Dict);
3351   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3352   return result;
3353 }
3354
3355 //
3356 void
3357 ContainerConstraintSubDescriptor::Copy(const ContainerConstraintSubDescriptor& rhs)
3358 {
3359   InterchangeObject::Copy(rhs);
3360 }
3361
3362 //
3363 void
3364 ContainerConstraintSubDescriptor::Dump(FILE* stream)
3365 {
3366   char identbuf[IdentBufferLen];
3367   *identbuf = 0;
3368
3369   if ( stream == 0 )
3370     stream = stderr;
3371
3372   InterchangeObject::Dump(stream);
3373 }
3374
3375 //
3376 ASDCP::Result_t
3377 ContainerConstraintSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3378 {
3379   return InterchangeObject::InitFromBuffer(p, l);
3380 }
3381
3382 //
3383 ASDCP::Result_t
3384 ContainerConstraintSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3385 {
3386   return InterchangeObject::WriteToBuffer(Buffer);
3387 }
3388
3389 //------------------------------------------------------------------------------------------
3390 // NetworkLocator
3391
3392 //
3393
3394 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3395 {
3396   assert(m_Dict);
3397   m_UL = m_Dict->ul(MDD_NetworkLocator);
3398 }
3399
3400 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3401 {
3402   assert(m_Dict);
3403   m_UL = m_Dict->ul(MDD_NetworkLocator);
3404   Copy(rhs);
3405 }
3406
3407
3408 //
3409 ASDCP::Result_t
3410 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
3411 {
3412   assert(m_Dict);
3413   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3414   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
3415   return result;
3416 }
3417
3418 //
3419 ASDCP::Result_t
3420 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
3421 {
3422   assert(m_Dict);
3423   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3424   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
3425   return result;
3426 }
3427
3428 //
3429 void
3430 NetworkLocator::Copy(const NetworkLocator& rhs)
3431 {
3432   InterchangeObject::Copy(rhs);
3433   URLString = rhs.URLString;
3434 }
3435
3436 //
3437 void
3438 NetworkLocator::Dump(FILE* stream)
3439 {
3440   char identbuf[IdentBufferLen];
3441   *identbuf = 0;
3442
3443   if ( stream == 0 )
3444     stream = stderr;
3445
3446   InterchangeObject::Dump(stream);
3447   fprintf(stream, "  %22s = %s\n",  "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
3448 }
3449
3450 //
3451 ASDCP::Result_t
3452 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
3453 {
3454   return InterchangeObject::InitFromBuffer(p, l);
3455 }
3456
3457 //
3458 ASDCP::Result_t
3459 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3460 {
3461   return InterchangeObject::WriteToBuffer(Buffer);
3462 }
3463
3464 //------------------------------------------------------------------------------------------
3465 // MCALabelSubDescriptor
3466
3467 //
3468
3469 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3470 {
3471   assert(m_Dict);
3472   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3473 }
3474
3475 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3476 {
3477   assert(m_Dict);
3478   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3479   Copy(rhs);
3480 }
3481
3482
3483 //
3484 ASDCP::Result_t
3485 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3486 {
3487   assert(m_Dict);
3488   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3489   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3490   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
3491   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3492   if ( ASDCP_SUCCESS(result) ) {
3493     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3494     MCATagName.set_has_value( result == RESULT_OK );
3495   }
3496   if ( ASDCP_SUCCESS(result) ) {
3497     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3498     MCAChannelID.set_has_value( result == RESULT_OK );
3499   }
3500   if ( ASDCP_SUCCESS(result) ) {
3501     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3502     RFC5646SpokenLanguage.set_has_value( result == RESULT_OK );
3503   }
3504   if ( ASDCP_SUCCESS(result) ) {
3505     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3506     MCATitle.set_has_value( result == RESULT_OK );
3507   }
3508   if ( ASDCP_SUCCESS(result) ) {
3509     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3510     MCATitleVersion.set_has_value( result == RESULT_OK );
3511   }
3512   if ( ASDCP_SUCCESS(result) ) {
3513     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3514     MCATitleSubVersion.set_has_value( result == RESULT_OK );
3515   }
3516   if ( ASDCP_SUCCESS(result) ) {
3517     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3518     MCAEpisode.set_has_value( result == RESULT_OK );
3519   }
3520   if ( ASDCP_SUCCESS(result) ) {
3521     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3522     MCAPartitionKind.set_has_value( result == RESULT_OK );
3523   }
3524   if ( ASDCP_SUCCESS(result) ) {
3525     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3526     MCAPartitionNumber.set_has_value( result == RESULT_OK );
3527   }
3528   if ( ASDCP_SUCCESS(result) ) {
3529     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3530     MCAAudioContentKind.set_has_value( result == RESULT_OK );
3531   }
3532   if ( ASDCP_SUCCESS(result) ) {
3533     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3534     MCAAudioElementKind.set_has_value( result == RESULT_OK );
3535   }
3536   return result;
3537 }
3538
3539 //
3540 ASDCP::Result_t
3541 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3542 {
3543   assert(m_Dict);
3544   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3545   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3546   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
3547   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3548   if ( ASDCP_SUCCESS(result)  && ! MCATagName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3549   if ( ASDCP_SUCCESS(result)  && ! MCAChannelID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3550   if ( ASDCP_SUCCESS(result)  && ! RFC5646SpokenLanguage.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3551   if ( ASDCP_SUCCESS(result)  && ! MCATitle.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3552   if ( ASDCP_SUCCESS(result)  && ! MCATitleVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3553   if ( ASDCP_SUCCESS(result)  && ! MCATitleSubVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3554   if ( ASDCP_SUCCESS(result)  && ! MCAEpisode.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3555   if ( ASDCP_SUCCESS(result)  && ! MCAPartitionKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3556   if ( ASDCP_SUCCESS(result)  && ! MCAPartitionNumber.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3557   if ( ASDCP_SUCCESS(result)  && ! MCAAudioContentKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3558   if ( ASDCP_SUCCESS(result)  && ! MCAAudioElementKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3559   return result;
3560 }
3561
3562 //
3563 void
3564 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
3565 {
3566   InterchangeObject::Copy(rhs);
3567   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
3568   MCALinkID = rhs.MCALinkID;
3569   MCATagSymbol = rhs.MCATagSymbol;
3570   MCATagName = rhs.MCATagName;
3571   MCAChannelID = rhs.MCAChannelID;
3572   RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
3573   MCATitle = rhs.MCATitle;
3574   MCATitleVersion = rhs.MCATitleVersion;
3575   MCATitleSubVersion = rhs.MCATitleSubVersion;
3576   MCAEpisode = rhs.MCAEpisode;
3577   MCAPartitionKind = rhs.MCAPartitionKind;
3578   MCAPartitionNumber = rhs.MCAPartitionNumber;
3579   MCAAudioContentKind = rhs.MCAAudioContentKind;
3580   MCAAudioElementKind = rhs.MCAAudioElementKind;
3581 }
3582
3583 //
3584 void
3585 MCALabelSubDescriptor::Dump(FILE* stream)
3586 {
3587   char identbuf[IdentBufferLen];
3588   *identbuf = 0;
3589
3590   if ( stream == 0 )
3591     stream = stderr;
3592
3593   InterchangeObject::Dump(stream);
3594   fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
3595   fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
3596   fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
3597   if ( ! MCATagName.empty() ) {
3598     fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.get().EncodeString(identbuf, IdentBufferLen));
3599   }
3600   if ( ! MCAChannelID.empty() ) {
3601     fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID.get());
3602   }
3603   if ( ! RFC5646SpokenLanguage.empty() ) {
3604     fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.get().EncodeString(identbuf, IdentBufferLen));
3605   }
3606   if ( ! MCATitle.empty() ) {
3607     fprintf(stream, "  %22s = %s\n",  "MCATitle", MCATitle.get().EncodeString(identbuf, IdentBufferLen));
3608   }
3609   if ( ! MCATitleVersion.empty() ) {
3610     fprintf(stream, "  %22s = %s\n",  "MCATitleVersion", MCATitleVersion.get().EncodeString(identbuf, IdentBufferLen));
3611   }
3612   if ( ! MCATitleSubVersion.empty() ) {
3613     fprintf(stream, "  %22s = %s\n",  "MCATitleSubVersion", MCATitleSubVersion.get().EncodeString(identbuf, IdentBufferLen));
3614   }
3615   if ( ! MCAEpisode.empty() ) {
3616     fprintf(stream, "  %22s = %s\n",  "MCAEpisode", MCAEpisode.get().EncodeString(identbuf, IdentBufferLen));
3617   }
3618   if ( ! MCAPartitionKind.empty() ) {
3619     fprintf(stream, "  %22s = %s\n",  "MCAPartitionKind", MCAPartitionKind.get().EncodeString(identbuf, IdentBufferLen));
3620   }
3621   if ( ! MCAPartitionNumber.empty() ) {
3622     fprintf(stream, "  %22s = %s\n",  "MCAPartitionNumber", MCAPartitionNumber.get().EncodeString(identbuf, IdentBufferLen));
3623   }
3624   if ( ! MCAAudioContentKind.empty() ) {
3625     fprintf(stream, "  %22s = %s\n",  "MCAAudioContentKind", MCAAudioContentKind.get().EncodeString(identbuf, IdentBufferLen));
3626   }
3627   if ( ! MCAAudioElementKind.empty() ) {
3628     fprintf(stream, "  %22s = %s\n",  "MCAAudioElementKind", MCAAudioElementKind.get().EncodeString(identbuf, IdentBufferLen));
3629   }
3630 }
3631
3632 //
3633 ASDCP::Result_t
3634 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3635 {
3636   return InterchangeObject::InitFromBuffer(p, l);
3637 }
3638
3639 //
3640 ASDCP::Result_t
3641 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3642 {
3643   return InterchangeObject::WriteToBuffer(Buffer);
3644 }
3645
3646 //------------------------------------------------------------------------------------------
3647 // AudioChannelLabelSubDescriptor
3648
3649 //
3650
3651 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3652 {
3653   assert(m_Dict);
3654   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3655 }
3656
3657 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3658 {
3659   assert(m_Dict);
3660   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3661   Copy(rhs);
3662 }
3663
3664
3665 //
3666 ASDCP::Result_t
3667 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3668 {
3669   assert(m_Dict);
3670   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3671   if ( ASDCP_SUCCESS(result) ) {
3672     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3673     SoundfieldGroupLinkID.set_has_value( result == RESULT_OK );
3674   }
3675   return result;
3676 }
3677
3678 //
3679 ASDCP::Result_t
3680 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3681 {
3682   assert(m_Dict);
3683   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3684   if ( ASDCP_SUCCESS(result)  && ! SoundfieldGroupLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3685   return result;
3686 }
3687
3688 //
3689 void
3690 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
3691 {
3692   MCALabelSubDescriptor::Copy(rhs);
3693   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
3694 }
3695
3696 //
3697 void
3698 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
3699 {
3700   char identbuf[IdentBufferLen];
3701   *identbuf = 0;
3702
3703   if ( stream == 0 )
3704     stream = stderr;
3705
3706   MCALabelSubDescriptor::Dump(stream);
3707   if ( ! SoundfieldGroupLinkID.empty() ) {
3708     fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.get().EncodeString(identbuf, IdentBufferLen));
3709   }
3710 }
3711
3712 //
3713 ASDCP::Result_t
3714 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3715 {
3716   return InterchangeObject::InitFromBuffer(p, l);
3717 }
3718
3719 //
3720 ASDCP::Result_t
3721 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3722 {
3723   return InterchangeObject::WriteToBuffer(Buffer);
3724 }
3725
3726 //------------------------------------------------------------------------------------------
3727 // SoundfieldGroupLabelSubDescriptor
3728
3729 //
3730
3731 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3732 {
3733   assert(m_Dict);
3734   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3735 }
3736
3737 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3738 {
3739   assert(m_Dict);
3740   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3741   Copy(rhs);
3742 }
3743
3744
3745 //
3746 ASDCP::Result_t
3747 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3748 {
3749   assert(m_Dict);
3750   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3751   if ( ASDCP_SUCCESS(result) ) {
3752     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3753   }
3754   return result;
3755 }
3756
3757 //
3758 ASDCP::Result_t
3759 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3760 {
3761   assert(m_Dict);
3762   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3763   if ( ASDCP_SUCCESS(result)  && ! GroupOfSoundfieldGroupsLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3764   return result;
3765 }
3766
3767 //
3768 void
3769 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
3770 {
3771   MCALabelSubDescriptor::Copy(rhs);
3772   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
3773 }
3774
3775 //
3776 void
3777 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
3778 {
3779   char identbuf[IdentBufferLen];
3780   *identbuf = 0;
3781
3782   if ( stream == 0 )
3783     stream = stderr;
3784
3785   MCALabelSubDescriptor::Dump(stream);
3786   if ( ! GroupOfSoundfieldGroupsLinkID.empty() ) {
3787     fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
3788   GroupOfSoundfieldGroupsLinkID.get().Dump(stream);
3789   }
3790 }
3791
3792 //
3793 ASDCP::Result_t
3794 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3795 {
3796   return InterchangeObject::InitFromBuffer(p, l);
3797 }
3798
3799 //
3800 ASDCP::Result_t
3801 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3802 {
3803   return InterchangeObject::WriteToBuffer(Buffer);
3804 }
3805
3806 //------------------------------------------------------------------------------------------
3807 // GroupOfSoundfieldGroupsLabelSubDescriptor
3808
3809 //
3810
3811 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3812 {
3813   assert(m_Dict);
3814   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3815 }
3816
3817 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3818 {
3819   assert(m_Dict);
3820   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3821   Copy(rhs);
3822 }
3823
3824
3825 //
3826 ASDCP::Result_t
3827 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3828 {
3829   assert(m_Dict);
3830   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3831   return result;
3832 }
3833
3834 //
3835 ASDCP::Result_t
3836 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3837 {
3838   assert(m_Dict);
3839   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3840   return result;
3841 }
3842
3843 //
3844 void
3845 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
3846 {
3847   MCALabelSubDescriptor::Copy(rhs);
3848 }
3849
3850 //
3851 void
3852 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
3853 {
3854   char identbuf[IdentBufferLen];
3855   *identbuf = 0;
3856
3857   if ( stream == 0 )
3858     stream = stderr;
3859
3860   MCALabelSubDescriptor::Dump(stream);
3861 }
3862
3863 //
3864 ASDCP::Result_t
3865 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3866 {
3867   return InterchangeObject::InitFromBuffer(p, l);
3868 }
3869
3870 //
3871 ASDCP::Result_t
3872 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3873 {
3874   return InterchangeObject::WriteToBuffer(Buffer);
3875 }
3876
3877 //------------------------------------------------------------------------------------------
3878 // DCDataDescriptor
3879
3880 //
3881
3882 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3883 {
3884   assert(m_Dict);
3885   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3886 }
3887
3888 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3889 {
3890   assert(m_Dict);
3891   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3892   Copy(rhs);
3893 }
3894
3895
3896 //
3897 ASDCP::Result_t
3898 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3899 {
3900   assert(m_Dict);
3901   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3902   return result;
3903 }
3904
3905 //
3906 ASDCP::Result_t
3907 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3908 {
3909   assert(m_Dict);
3910   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3911   return result;
3912 }
3913
3914 //
3915 void
3916 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
3917 {
3918   GenericDataEssenceDescriptor::Copy(rhs);
3919 }
3920
3921 //
3922 void
3923 DCDataDescriptor::Dump(FILE* stream)
3924 {
3925   char identbuf[IdentBufferLen];
3926   *identbuf = 0;
3927
3928   if ( stream == 0 )
3929     stream = stderr;
3930
3931   GenericDataEssenceDescriptor::Dump(stream);
3932 }
3933
3934 //
3935 ASDCP::Result_t
3936 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3937 {
3938   return InterchangeObject::InitFromBuffer(p, l);
3939 }
3940
3941 //
3942 ASDCP::Result_t
3943 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3944 {
3945   return InterchangeObject::WriteToBuffer(Buffer);
3946 }
3947
3948 //------------------------------------------------------------------------------------------
3949 // PrivateDCDataDescriptor
3950
3951 //
3952
3953 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3954 {
3955   assert(m_Dict);
3956   m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3957 }
3958
3959 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3960 {
3961   assert(m_Dict);
3962   m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3963   Copy(rhs);
3964 }
3965
3966
3967 //
3968 ASDCP::Result_t
3969 PrivateDCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3970 {
3971   assert(m_Dict);
3972   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3973   return result;
3974 }
3975
3976 //
3977 ASDCP::Result_t
3978 PrivateDCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3979 {
3980   assert(m_Dict);
3981   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3982   return result;
3983 }
3984
3985 //
3986 void
3987 PrivateDCDataDescriptor::Copy(const PrivateDCDataDescriptor& rhs)
3988 {
3989   GenericDataEssenceDescriptor::Copy(rhs);
3990 }
3991
3992 //
3993 void
3994 PrivateDCDataDescriptor::Dump(FILE* stream)
3995 {
3996   char identbuf[IdentBufferLen];
3997   *identbuf = 0;
3998
3999   if ( stream == 0 )
4000     stream = stderr;
4001
4002   GenericDataEssenceDescriptor::Dump(stream);
4003 }
4004
4005 //
4006 ASDCP::Result_t
4007 PrivateDCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4008 {
4009   return InterchangeObject::InitFromBuffer(p, l);
4010 }
4011
4012 //
4013 ASDCP::Result_t
4014 PrivateDCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4015 {
4016   return InterchangeObject::WriteToBuffer(Buffer);
4017 }
4018
4019 //------------------------------------------------------------------------------------------
4020 // DolbyAtmosSubDescriptor
4021
4022 //
4023
4024 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
4025 {
4026   assert(m_Dict);
4027   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
4028 }
4029
4030 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4031 {
4032   assert(m_Dict);
4033   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
4034   Copy(rhs);
4035 }
4036
4037
4038 //
4039 ASDCP::Result_t
4040 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4041 {
4042   assert(m_Dict);
4043   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4044   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
4045   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
4046   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
4047   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
4048   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
4049   return result;
4050 }
4051
4052 //
4053 ASDCP::Result_t
4054 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4055 {
4056   assert(m_Dict);
4057   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4058   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
4059   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
4060   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
4061   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
4062   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
4063   return result;
4064 }
4065
4066 //
4067 void
4068 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
4069 {
4070   InterchangeObject::Copy(rhs);
4071   AtmosID = rhs.AtmosID;
4072   FirstFrame = rhs.FirstFrame;
4073   MaxChannelCount = rhs.MaxChannelCount;
4074   MaxObjectCount = rhs.MaxObjectCount;
4075   AtmosVersion = rhs.AtmosVersion;
4076 }
4077
4078 //
4079 void
4080 DolbyAtmosSubDescriptor::Dump(FILE* stream)
4081 {
4082   char identbuf[IdentBufferLen];
4083   *identbuf = 0;
4084
4085   if ( stream == 0 )
4086     stream = stderr;
4087
4088   InterchangeObject::Dump(stream);
4089   fprintf(stream, "  %22s = %s\n",  "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
4090   fprintf(stream, "  %22s = %d\n",  "FirstFrame", FirstFrame);
4091   fprintf(stream, "  %22s = %d\n",  "MaxChannelCount", MaxChannelCount);
4092   fprintf(stream, "  %22s = %d\n",  "MaxObjectCount", MaxObjectCount);
4093   fprintf(stream, "  %22s = %d\n",  "AtmosVersion", AtmosVersion);
4094 }
4095
4096 //
4097 ASDCP::Result_t
4098 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4099 {
4100   return InterchangeObject::InitFromBuffer(p, l);
4101 }
4102
4103 //
4104 ASDCP::Result_t
4105 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4106 {
4107   return InterchangeObject::WriteToBuffer(Buffer);
4108 }
4109
4110 //------------------------------------------------------------------------------------------
4111 // ACESPictureSubDescriptor
4112
4113 //
4114
4115 ACESPictureSubDescriptor::ACESPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
4116 {
4117   assert(m_Dict);
4118   m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
4119 }
4120
4121 ACESPictureSubDescriptor::ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4122 {
4123   assert(m_Dict);
4124   m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
4125   Copy(rhs);
4126 }
4127
4128
4129 //
4130 ASDCP::Result_t
4131 ACESPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4132 {
4133   assert(m_Dict);
4134   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4135   if ( ASDCP_SUCCESS(result) ) {
4136     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
4137     ACESAuthoringInformation.set_has_value( result == RESULT_OK );
4138   }
4139   if ( ASDCP_SUCCESS(result) ) {
4140     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
4141     ACESMasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
4142   }
4143   if ( ASDCP_SUCCESS(result) ) {
4144     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
4145     ACESMasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
4146   }
4147   if ( ASDCP_SUCCESS(result) ) {
4148     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
4149     ACESMasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
4150   }
4151   if ( ASDCP_SUCCESS(result) ) {
4152     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
4153     ACESMasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
4154   }
4155   return result;
4156 }
4157
4158 //
4159 ASDCP::Result_t
4160 ACESPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4161 {
4162   assert(m_Dict);
4163   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4164   if ( ASDCP_SUCCESS(result)  && ! ACESAuthoringInformation.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
4165   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
4166   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
4167   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
4168   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
4169   return result;
4170 }
4171
4172 //
4173 void
4174 ACESPictureSubDescriptor::Copy(const ACESPictureSubDescriptor& rhs)
4175 {
4176   InterchangeObject::Copy(rhs);
4177   ACESAuthoringInformation = rhs.ACESAuthoringInformation;
4178   ACESMasteringDisplayPrimaries = rhs.ACESMasteringDisplayPrimaries;
4179   ACESMasteringDisplayWhitePointChromaticity = rhs.ACESMasteringDisplayWhitePointChromaticity;
4180   ACESMasteringDisplayMaximumLuminance = rhs.ACESMasteringDisplayMaximumLuminance;
4181   ACESMasteringDisplayMinimumLuminance = rhs.ACESMasteringDisplayMinimumLuminance;
4182 }
4183
4184 //
4185 void
4186 ACESPictureSubDescriptor::Dump(FILE* stream)
4187 {
4188   char identbuf[IdentBufferLen];
4189   *identbuf = 0;
4190
4191   if ( stream == 0 )
4192     stream = stderr;
4193
4194   InterchangeObject::Dump(stream);
4195   if ( ! ACESAuthoringInformation.empty() ) {
4196     fprintf(stream, "  %22s = %s\n",  "ACESAuthoringInformation", ACESAuthoringInformation.get().EncodeString(identbuf, IdentBufferLen));
4197   }
4198   if ( ! ACESMasteringDisplayPrimaries.empty() ) {
4199     fprintf(stream, "  %22s = %s\n",  "ACESMasteringDisplayPrimaries", ACESMasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
4200   }
4201   if ( ! ACESMasteringDisplayWhitePointChromaticity.empty() ) {
4202     fprintf(stream, "  %22s = %s\n",  "ACESMasteringDisplayWhitePointChromaticity", ACESMasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
4203   }
4204   if ( ! ACESMasteringDisplayMaximumLuminance.empty() ) {
4205     fprintf(stream, "  %22s = %d\n",  "ACESMasteringDisplayMaximumLuminance", ACESMasteringDisplayMaximumLuminance.get());
4206   }
4207   if ( ! ACESMasteringDisplayMinimumLuminance.empty() ) {
4208     fprintf(stream, "  %22s = %d\n",  "ACESMasteringDisplayMinimumLuminance", ACESMasteringDisplayMinimumLuminance.get());
4209   }
4210 }
4211
4212 //
4213 ASDCP::Result_t
4214 ACESPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4215 {
4216   return InterchangeObject::InitFromBuffer(p, l);
4217 }
4218
4219 //
4220 ASDCP::Result_t
4221 ACESPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4222 {
4223   return InterchangeObject::WriteToBuffer(Buffer);
4224 }
4225
4226 //------------------------------------------------------------------------------------------
4227 // TargetFrameSubDescriptor
4228
4229 //
4230
4231 TargetFrameSubDescriptor::TargetFrameSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TargetFrameIndex(0), TargetFrameComponentMaxRef(0), TargetFrameComponentMinRef(0), TargetFrameEssenceStreamID(0)
4232 {
4233   assert(m_Dict);
4234   m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
4235 }
4236
4237 TargetFrameSubDescriptor::TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4238 {
4239   assert(m_Dict);
4240   m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
4241   Copy(rhs);
4242 }
4243
4244
4245 //
4246 ASDCP::Result_t
4247 TargetFrameSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4248 {
4249   assert(m_Dict);
4250   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4251   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
4252   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, MediaType));
4253   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
4254   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
4255   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
4256   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
4257   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
4258   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
4259   if ( ASDCP_SUCCESS(result) ) {
4260     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
4261     ACESPictureSubDescriptorInstanceID.set_has_value( result == RESULT_OK );
4262   }
4263   if ( ASDCP_SUCCESS(result) ) {
4264     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
4265     TargetFrameViewingEnvironment.set_has_value( result == RESULT_OK );
4266   }
4267   return result;
4268 }
4269
4270 //
4271 ASDCP::Result_t
4272 TargetFrameSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4273 {
4274   assert(m_Dict);
4275   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4276   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
4277   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, MediaType));
4278   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
4279   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
4280   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
4281   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
4282   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
4283   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
4284   if ( ASDCP_SUCCESS(result)  && ! ACESPictureSubDescriptorInstanceID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
4285   if ( ASDCP_SUCCESS(result)  && ! TargetFrameViewingEnvironment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
4286   return result;
4287 }
4288
4289 //
4290 void
4291 TargetFrameSubDescriptor::Copy(const TargetFrameSubDescriptor& rhs)
4292 {
4293   InterchangeObject::Copy(rhs);
4294   TargetFrameAncillaryResourceID = rhs.TargetFrameAncillaryResourceID;
4295   MediaType = rhs.MediaType;
4296   TargetFrameIndex = rhs.TargetFrameIndex;
4297   TargetFrameTransferCharacteristic = rhs.TargetFrameTransferCharacteristic;
4298   TargetFrameColorPrimaries = rhs.TargetFrameColorPrimaries;
4299   TargetFrameComponentMaxRef = rhs.TargetFrameComponentMaxRef;
4300   TargetFrameComponentMinRef = rhs.TargetFrameComponentMinRef;
4301   TargetFrameEssenceStreamID = rhs.TargetFrameEssenceStreamID;
4302   ACESPictureSubDescriptorInstanceID = rhs.ACESPictureSubDescriptorInstanceID;
4303   TargetFrameViewingEnvironment = rhs.TargetFrameViewingEnvironment;
4304 }
4305
4306 //
4307 void
4308 TargetFrameSubDescriptor::Dump(FILE* stream)
4309 {
4310   char identbuf[IdentBufferLen];
4311   *identbuf = 0;
4312
4313   if ( stream == 0 )
4314     stream = stderr;
4315
4316   InterchangeObject::Dump(stream);
4317   fprintf(stream, "  %22s = %s\n",  "TargetFrameAncillaryResourceID", TargetFrameAncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
4318   fprintf(stream, "  %22s = %s\n",  "MediaType", MediaType.EncodeString(identbuf, IdentBufferLen));
4319   fprintf(stream, "  %22s = %s\n",  "TargetFrameIndex", i64sz(TargetFrameIndex, identbuf));
4320   fprintf(stream, "  %22s = %s\n",  "TargetFrameTransferCharacteristic", TargetFrameTransferCharacteristic.EncodeString(identbuf, IdentBufferLen));
4321   fprintf(stream, "  %22s = %s\n",  "TargetFrameColorPrimaries", TargetFrameColorPrimaries.EncodeString(identbuf, IdentBufferLen));
4322   fprintf(stream, "  %22s = %d\n",  "TargetFrameComponentMaxRef", TargetFrameComponentMaxRef);
4323   fprintf(stream, "  %22s = %d\n",  "TargetFrameComponentMinRef", TargetFrameComponentMinRef);
4324   fprintf(stream, "  %22s = %d\n",  "TargetFrameEssenceStreamID", TargetFrameEssenceStreamID);
4325   if ( ! ACESPictureSubDescriptorInstanceID.empty() ) {
4326     fprintf(stream, "  %22s = %s\n",  "ACESPictureSubDescriptorInstanceID", ACESPictureSubDescriptorInstanceID.get().EncodeString(identbuf, IdentBufferLen));
4327   }
4328   if ( ! TargetFrameViewingEnvironment.empty() ) {
4329     fprintf(stream, "  %22s = %s\n",  "TargetFrameViewingEnvironment", TargetFrameViewingEnvironment.get().EncodeString(identbuf, IdentBufferLen));
4330   }
4331 }
4332
4333 //
4334 ASDCP::Result_t
4335 TargetFrameSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4336 {
4337   return InterchangeObject::InitFromBuffer(p, l);
4338 }
4339
4340 //
4341 ASDCP::Result_t
4342 TargetFrameSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4343 {
4344   return InterchangeObject::WriteToBuffer(Buffer);
4345 }
4346
4347 //------------------------------------------------------------------------------------------
4348 // TextBasedDMFramework
4349
4350 //
4351
4352 TextBasedDMFramework::TextBasedDMFramework(const Dictionary*& d) : DescriptiveFramework(d), m_Dict(d)
4353 {
4354   assert(m_Dict);
4355   m_UL = m_Dict->ul(MDD_TextBasedDMFramework);
4356 }
4357
4358 TextBasedDMFramework::TextBasedDMFramework(const TextBasedDMFramework& rhs) : DescriptiveFramework(rhs.m_Dict), m_Dict(rhs.m_Dict)
4359 {
4360   assert(m_Dict);
4361   m_UL = m_Dict->ul(MDD_TextBasedDMFramework);
4362   Copy(rhs);
4363 }
4364
4365
4366 //
4367 ASDCP::Result_t
4368 TextBasedDMFramework::InitFromTLVSet(TLVReader& TLVSet)
4369 {
4370   assert(m_Dict);
4371   Result_t result = DescriptiveFramework::InitFromTLVSet(TLVSet);
4372   if ( ASDCP_SUCCESS(result) ) {
4373     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TextBasedDMFramework, ObjectRef));
4374     ObjectRef.set_has_value( result == RESULT_OK );
4375   }
4376   return result;
4377 }
4378
4379 //
4380 ASDCP::Result_t
4381 TextBasedDMFramework::WriteToTLVSet(TLVWriter& TLVSet)
4382 {
4383   assert(m_Dict);
4384   Result_t result = DescriptiveFramework::WriteToTLVSet(TLVSet);
4385   if ( ASDCP_SUCCESS(result)  && ! ObjectRef.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TextBasedDMFramework, ObjectRef));
4386   return result;
4387 }
4388
4389 //
4390 void
4391 TextBasedDMFramework::Copy(const TextBasedDMFramework& rhs)
4392 {
4393   DescriptiveFramework::Copy(rhs);
4394   ObjectRef = rhs.ObjectRef;
4395 }
4396
4397 //
4398 void
4399 TextBasedDMFramework::Dump(FILE* stream)
4400 {
4401   char identbuf[IdentBufferLen];
4402   *identbuf = 0;
4403
4404   if ( stream == 0 )
4405     stream = stderr;
4406
4407   DescriptiveFramework::Dump(stream);
4408   if ( ! ObjectRef.empty() ) {
4409     fprintf(stream, "  %22s = %s\n",  "ObjectRef", ObjectRef.get().EncodeString(identbuf, IdentBufferLen));
4410   }
4411 }
4412
4413 //
4414 ASDCP::Result_t
4415 TextBasedDMFramework::InitFromBuffer(const byte_t* p, ui32_t l)
4416 {
4417   return InterchangeObject::InitFromBuffer(p, l);
4418 }
4419
4420 //
4421 ASDCP::Result_t
4422 TextBasedDMFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4423 {
4424   return InterchangeObject::WriteToBuffer(Buffer);
4425 }
4426
4427 //------------------------------------------------------------------------------------------
4428 // TextBasedObject
4429
4430 //
4431
4432 TextBasedObject::TextBasedObject(const Dictionary*& d) : DescriptiveObject(d), m_Dict(d)
4433 {
4434   assert(m_Dict);
4435   m_UL = m_Dict->ul(MDD_TextBasedObject);
4436 }
4437
4438 TextBasedObject::TextBasedObject(const TextBasedObject& rhs) : DescriptiveObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4439 {
4440   assert(m_Dict);
4441   m_UL = m_Dict->ul(MDD_TextBasedObject);
4442   Copy(rhs);
4443 }
4444
4445
4446 //
4447 ASDCP::Result_t
4448 TextBasedObject::InitFromTLVSet(TLVReader& TLVSet)
4449 {
4450   assert(m_Dict);
4451   Result_t result = DescriptiveObject::InitFromTLVSet(TLVSet);
4452   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, PayloadSchemeID));
4453   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, TextMIMEMediaType));
4454   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, RFC5646TextLanguageCode));
4455   if ( ASDCP_SUCCESS(result) ) {
4456     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TextBasedObject, TextDataDescription));
4457     TextDataDescription.set_has_value( result == RESULT_OK );
4458   }
4459   return result;
4460 }
4461
4462 //
4463 ASDCP::Result_t
4464 TextBasedObject::WriteToTLVSet(TLVWriter& TLVSet)
4465 {
4466   assert(m_Dict);
4467   Result_t result = DescriptiveObject::WriteToTLVSet(TLVSet);
4468   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, PayloadSchemeID));
4469   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, TextMIMEMediaType));
4470   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, RFC5646TextLanguageCode));
4471   if ( ASDCP_SUCCESS(result)  && ! TextDataDescription.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TextBasedObject, TextDataDescription));
4472   return result;
4473 }
4474
4475 //
4476 void
4477 TextBasedObject::Copy(const TextBasedObject& rhs)
4478 {
4479   DescriptiveObject::Copy(rhs);
4480   PayloadSchemeID = rhs.PayloadSchemeID;
4481   TextMIMEMediaType = rhs.TextMIMEMediaType;
4482   RFC5646TextLanguageCode = rhs.RFC5646TextLanguageCode;
4483   TextDataDescription = rhs.TextDataDescription;
4484 }
4485
4486 //
4487 void
4488 TextBasedObject::Dump(FILE* stream)
4489 {
4490   char identbuf[IdentBufferLen];
4491   *identbuf = 0;
4492
4493   if ( stream == 0 )
4494     stream = stderr;
4495
4496   DescriptiveObject::Dump(stream);
4497   fprintf(stream, "  %22s = %s\n",  "PayloadSchemeID", PayloadSchemeID.EncodeString(identbuf, IdentBufferLen));
4498   fprintf(stream, "  %22s = %s\n",  "TextMIMEMediaType", TextMIMEMediaType.EncodeString(identbuf, IdentBufferLen));
4499   fprintf(stream, "  %22s = %s\n",  "RFC5646TextLanguageCode", RFC5646TextLanguageCode.EncodeString(identbuf, IdentBufferLen));
4500   if ( ! TextDataDescription.empty() ) {
4501     fprintf(stream, "  %22s = %s\n",  "TextDataDescription", TextDataDescription.get().EncodeString(identbuf, IdentBufferLen));
4502   }
4503 }
4504
4505 //
4506 ASDCP::Result_t
4507 TextBasedObject::InitFromBuffer(const byte_t* p, ui32_t l)
4508 {
4509   return InterchangeObject::InitFromBuffer(p, l);
4510 }
4511
4512 //
4513 ASDCP::Result_t
4514 TextBasedObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4515 {
4516   return InterchangeObject::WriteToBuffer(Buffer);
4517 }
4518
4519 //------------------------------------------------------------------------------------------
4520 // GenericStreamTextBasedSet
4521
4522 //
4523
4524 GenericStreamTextBasedSet::GenericStreamTextBasedSet(const Dictionary*& d) : TextBasedObject(d), m_Dict(d), GenericStreamSID(0)
4525 {
4526   assert(m_Dict);
4527   m_UL = m_Dict->ul(MDD_GenericStreamTextBasedSet);
4528 }
4529
4530 GenericStreamTextBasedSet::GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs) : TextBasedObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4531 {
4532   assert(m_Dict);
4533   m_UL = m_Dict->ul(MDD_GenericStreamTextBasedSet);
4534   Copy(rhs);
4535 }
4536
4537
4538 //
4539 ASDCP::Result_t
4540 GenericStreamTextBasedSet::InitFromTLVSet(TLVReader& TLVSet)
4541 {
4542   assert(m_Dict);
4543   Result_t result = TextBasedObject::InitFromTLVSet(TLVSet);
4544   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericStreamTextBasedSet, GenericStreamSID));
4545   return result;
4546 }
4547
4548 //
4549 ASDCP::Result_t
4550 GenericStreamTextBasedSet::WriteToTLVSet(TLVWriter& TLVSet)
4551 {
4552   assert(m_Dict);
4553   Result_t result = TextBasedObject::WriteToTLVSet(TLVSet);
4554   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericStreamTextBasedSet, GenericStreamSID));
4555   return result;
4556 }
4557
4558 //
4559 void
4560 GenericStreamTextBasedSet::Copy(const GenericStreamTextBasedSet& rhs)
4561 {
4562   TextBasedObject::Copy(rhs);
4563   GenericStreamSID = rhs.GenericStreamSID;
4564 }
4565
4566 //
4567 void
4568 GenericStreamTextBasedSet::Dump(FILE* stream)
4569 {
4570   char identbuf[IdentBufferLen];
4571   *identbuf = 0;
4572
4573   if ( stream == 0 )
4574     stream = stderr;
4575
4576   TextBasedObject::Dump(stream);
4577   fprintf(stream, "  %22s = %d\n",  "GenericStreamSID", GenericStreamSID);
4578 }
4579
4580 //
4581 ASDCP::Result_t
4582 GenericStreamTextBasedSet::InitFromBuffer(const byte_t* p, ui32_t l)
4583 {
4584   return InterchangeObject::InitFromBuffer(p, l);
4585 }
4586
4587 //
4588 ASDCP::Result_t
4589 GenericStreamTextBasedSet::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4590 {
4591   return InterchangeObject::WriteToBuffer(Buffer);
4592 }
4593
4594 //------------------------------------------------------------------------------------------
4595 // ISXDDataEssenceDescriptor
4596
4597 //
4598
4599 ISXDDataEssenceDescriptor::ISXDDataEssenceDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
4600 {
4601   assert(m_Dict);
4602   m_UL = m_Dict->ul(MDD_ISXDDataEssenceDescriptor);
4603 }
4604
4605 ISXDDataEssenceDescriptor::ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
4606 {
4607   assert(m_Dict);
4608   m_UL = m_Dict->ul(MDD_ISXDDataEssenceDescriptor);
4609   Copy(rhs);
4610 }
4611
4612
4613 //
4614 ASDCP::Result_t
4615 ISXDDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4616 {
4617   assert(m_Dict);
4618   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
4619   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ISXDDataEssenceDescriptor, NamespaceURI));
4620   return result;
4621 }
4622
4623 //
4624 ASDCP::Result_t
4625 ISXDDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4626 {
4627   assert(m_Dict);
4628   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4629   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ISXDDataEssenceDescriptor, NamespaceURI));
4630   return result;
4631 }
4632
4633 //
4634 void
4635 ISXDDataEssenceDescriptor::Copy(const ISXDDataEssenceDescriptor& rhs)
4636 {
4637   GenericDataEssenceDescriptor::Copy(rhs);
4638   NamespaceURI = rhs.NamespaceURI;
4639 }
4640
4641 //
4642 void
4643 ISXDDataEssenceDescriptor::Dump(FILE* stream)
4644 {
4645   char identbuf[IdentBufferLen];
4646   *identbuf = 0;
4647
4648   if ( stream == 0 )
4649     stream = stderr;
4650
4651   GenericDataEssenceDescriptor::Dump(stream);
4652   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
4653 }
4654
4655 //
4656 ASDCP::Result_t
4657 ISXDDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4658 {
4659   return InterchangeObject::InitFromBuffer(p, l);
4660 }
4661
4662 //
4663 ASDCP::Result_t
4664 ISXDDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4665 {
4666   return InterchangeObject::WriteToBuffer(Buffer);
4667 }
4668
4669 //------------------------------------------------------------------------------------------
4670 // PHDRMetadataTrackSubDescriptor
4671
4672 //
4673
4674 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), SourceTrackID(0), SimplePayloadSID(0)
4675 {
4676   assert(m_Dict);
4677   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
4678 }
4679
4680 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4681 {
4682   assert(m_Dict);
4683   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
4684   Copy(rhs);
4685 }
4686
4687
4688 //
4689 ASDCP::Result_t
4690 PHDRMetadataTrackSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4691 {
4692   assert(m_Dict);
4693   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4694   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
4695   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
4696   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
4697   return result;
4698 }
4699
4700 //
4701 ASDCP::Result_t
4702 PHDRMetadataTrackSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4703 {
4704   assert(m_Dict);
4705   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4706   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
4707   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
4708   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
4709   return result;
4710 }
4711
4712 //
4713 void
4714 PHDRMetadataTrackSubDescriptor::Copy(const PHDRMetadataTrackSubDescriptor& rhs)
4715 {
4716   InterchangeObject::Copy(rhs);
4717   DataDefinition = rhs.DataDefinition;
4718   SourceTrackID = rhs.SourceTrackID;
4719   SimplePayloadSID = rhs.SimplePayloadSID;
4720 }
4721
4722 //
4723 void
4724 PHDRMetadataTrackSubDescriptor::Dump(FILE* stream)
4725 {
4726   char identbuf[IdentBufferLen];
4727   *identbuf = 0;
4728
4729   if ( stream == 0 )
4730     stream = stderr;
4731
4732   InterchangeObject::Dump(stream);
4733   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
4734   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
4735   fprintf(stream, "  %22s = %d\n",  "SimplePayloadSID", SimplePayloadSID);
4736 }
4737
4738 //
4739 ASDCP::Result_t
4740 PHDRMetadataTrackSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4741 {
4742   return InterchangeObject::InitFromBuffer(p, l);
4743 }
4744
4745 //
4746 ASDCP::Result_t
4747 PHDRMetadataTrackSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4748 {
4749   return InterchangeObject::WriteToBuffer(Buffer);
4750 }
4751
4752 //------------------------------------------------------------------------------------------
4753 // PIMFDynamicMetadataDescriptor
4754
4755 //
4756
4757 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d), GlobalPayloadSID(0)
4758 {
4759   assert(m_Dict);
4760   m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
4761 }
4762
4763 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
4764 {
4765   assert(m_Dict);
4766   m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
4767   Copy(rhs);
4768 }
4769
4770
4771 //
4772 ASDCP::Result_t
4773 PIMFDynamicMetadataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4774 {
4775   assert(m_Dict);
4776   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
4777   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4778   return result;
4779 }
4780
4781 //
4782 ASDCP::Result_t
4783 PIMFDynamicMetadataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4784 {
4785   assert(m_Dict);
4786   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4787   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4788   return result;
4789 }
4790
4791 //
4792 void
4793 PIMFDynamicMetadataDescriptor::Copy(const PIMFDynamicMetadataDescriptor& rhs)
4794 {
4795   GenericDataEssenceDescriptor::Copy(rhs);
4796   GlobalPayloadSID = rhs.GlobalPayloadSID;
4797 }
4798
4799 //
4800 void
4801 PIMFDynamicMetadataDescriptor::Dump(FILE* stream)
4802 {
4803   char identbuf[IdentBufferLen];
4804   *identbuf = 0;
4805
4806   if ( stream == 0 )
4807     stream = stderr;
4808
4809   GenericDataEssenceDescriptor::Dump(stream);
4810   fprintf(stream, "  %22s = %d\n",  "GlobalPayloadSID", GlobalPayloadSID);
4811 }
4812
4813 //
4814 ASDCP::Result_t
4815 PIMFDynamicMetadataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4816 {
4817   return InterchangeObject::InitFromBuffer(p, l);
4818 }
4819
4820 //
4821 ASDCP::Result_t
4822 PIMFDynamicMetadataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4823 {
4824   return InterchangeObject::WriteToBuffer(Buffer);
4825 }
4826
4827 //
4828 // end Metadata.cpp
4829 //