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