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