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) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ReferenceImageEditRate));
1406   return result;
1407 }
1408
1409 //
1410 ASDCP::Result_t
1411 GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1412 {
1413   assert(m_Dict);
1414   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1415   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1416   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
1417   if ( ASDCP_SUCCESS(result)  && ! AudioRefLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, AudioRefLevel));
1418   if ( ASDCP_SUCCESS(result)  && ! ElectroSpatialFormulation.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, ElectroSpatialFormulation));
1419   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1420   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1421   if ( ASDCP_SUCCESS(result)  && ! DialNorm.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericSoundEssenceDescriptor, DialNorm));
1422   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, SoundEssenceCoding));
1423   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ReferenceImageEditRate));
1424   return result;
1425 }
1426
1427 //
1428 void
1429 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
1430 {
1431   FileDescriptor::Copy(rhs);
1432   AudioSamplingRate = rhs.AudioSamplingRate;
1433   Locked = rhs.Locked;
1434   AudioRefLevel = rhs.AudioRefLevel;
1435   ElectroSpatialFormulation = rhs.ElectroSpatialFormulation;
1436   ChannelCount = rhs.ChannelCount;
1437   QuantizationBits = rhs.QuantizationBits;
1438   DialNorm = rhs.DialNorm;
1439   SoundEssenceCoding = rhs.SoundEssenceCoding;
1440   ReferenceImageEditRate = rhs.ReferenceImageEditRate;
1441 }
1442
1443 //
1444 void
1445 GenericSoundEssenceDescriptor::Dump(FILE* stream)
1446 {
1447   char identbuf[IdentBufferLen];
1448   *identbuf = 0;
1449
1450   if ( stream == 0 )
1451     stream = stderr;
1452
1453   FileDescriptor::Dump(stream);
1454   fprintf(stream, "  %22s = %s\n",  "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1455   fprintf(stream, "  %22s = %d\n",  "Locked", Locked);
1456   if ( ! AudioRefLevel.empty() ) {
1457     fprintf(stream, "  %22s = %d\n",  "AudioRefLevel", AudioRefLevel.get());
1458   }
1459   if ( ! ElectroSpatialFormulation.empty() ) {
1460     fprintf(stream, "  %22s = %d\n",  "ElectroSpatialFormulation", ElectroSpatialFormulation.get());
1461   }
1462   fprintf(stream, "  %22s = %d\n",  "ChannelCount", ChannelCount);
1463   fprintf(stream, "  %22s = %d\n",  "QuantizationBits", QuantizationBits);
1464   if ( ! DialNorm.empty() ) {
1465     fprintf(stream, "  %22s = %d\n",  "DialNorm", DialNorm.get());
1466   }
1467   fprintf(stream, "  %22s = %s\n",  "SoundEssenceCoding", SoundEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1468   fprintf(stream, "  %22s = %s\n",  "ReferenceImageEditRate", ReferenceImageEditRate.EncodeString(identbuf, IdentBufferLen));
1469 }
1470
1471 //
1472 ASDCP::Result_t
1473 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1474 {
1475   return InterchangeObject::InitFromBuffer(p, l);
1476 }
1477
1478 //
1479 ASDCP::Result_t
1480 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1481 {
1482   return InterchangeObject::WriteToBuffer(Buffer);
1483 }
1484
1485 //------------------------------------------------------------------------------------------
1486 // WaveAudioDescriptor
1487
1488 //
1489
1490 WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), AvgBps(0)
1491 {
1492   assert(m_Dict);
1493   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1494 }
1495
1496 WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1497 {
1498   assert(m_Dict);
1499   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1500   Copy(rhs);
1501 }
1502
1503
1504 //
1505 ASDCP::Result_t
1506 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1507 {
1508   assert(m_Dict);
1509   Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1510   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1511   if ( ASDCP_SUCCESS(result) ) {
1512     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1513     SequenceOffset.set_has_value( result == RESULT_OK );
1514   }
1515   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1516   if ( ASDCP_SUCCESS(result) ) {
1517     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1518     ChannelAssignment.set_has_value( result == RESULT_OK );
1519   }
1520   if ( ASDCP_SUCCESS(result) ) {
1521     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ReferenceImageEditRate));
1522     ReferenceImageEditRate.set_has_value( result == RESULT_OK );
1523   }
1524   if ( ASDCP_SUCCESS(result) ) {
1525     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(WaveAudioDescriptor, ReferenceAudioAlignmentLevel));
1526     ReferenceAudioAlignmentLevel.set_has_value( result == RESULT_OK );
1527   }
1528   return result;
1529 }
1530
1531 //
1532 ASDCP::Result_t
1533 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1534 {
1535   assert(m_Dict);
1536   Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1537   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1538   if ( ASDCP_SUCCESS(result)  && ! SequenceOffset.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, SequenceOffset));
1539   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1540   if ( ASDCP_SUCCESS(result)  && ! ChannelAssignment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ChannelAssignment));
1541   if ( ASDCP_SUCCESS(result)  && ! ReferenceImageEditRate.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ReferenceImageEditRate));
1542   if ( ASDCP_SUCCESS(result)  && ! ReferenceAudioAlignmentLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(WaveAudioDescriptor, ReferenceAudioAlignmentLevel));
1543   return result;
1544 }
1545
1546 //
1547 void
1548 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
1549 {
1550   GenericSoundEssenceDescriptor::Copy(rhs);
1551   BlockAlign = rhs.BlockAlign;
1552   SequenceOffset = rhs.SequenceOffset;
1553   AvgBps = rhs.AvgBps;
1554   ChannelAssignment = rhs.ChannelAssignment;
1555   ReferenceImageEditRate = rhs.ReferenceImageEditRate;
1556   ReferenceAudioAlignmentLevel = rhs.ReferenceAudioAlignmentLevel;
1557 }
1558
1559 //
1560 void
1561 WaveAudioDescriptor::Dump(FILE* stream)
1562 {
1563   char identbuf[IdentBufferLen];
1564   *identbuf = 0;
1565
1566   if ( stream == 0 )
1567     stream = stderr;
1568
1569   GenericSoundEssenceDescriptor::Dump(stream);
1570   fprintf(stream, "  %22s = %d\n",  "BlockAlign", BlockAlign);
1571   if ( ! SequenceOffset.empty() ) {
1572     fprintf(stream, "  %22s = %d\n",  "SequenceOffset", SequenceOffset.get());
1573   }
1574   fprintf(stream, "  %22s = %d\n",  "AvgBps", AvgBps);
1575   if ( ! ChannelAssignment.empty() ) {
1576     fprintf(stream, "  %22s = %s\n",  "ChannelAssignment", ChannelAssignment.get().EncodeString(identbuf, IdentBufferLen));
1577   }
1578   if ( ! ReferenceImageEditRate.empty() ) {
1579     fprintf(stream, "  %22s = %s\n",  "ReferenceImageEditRate", ReferenceImageEditRate.get().EncodeString(identbuf, IdentBufferLen));
1580   }
1581   if ( ! ReferenceAudioAlignmentLevel.empty() ) {
1582     fprintf(stream, "  %22s = %d\n",  "ReferenceAudioAlignmentLevel", ReferenceAudioAlignmentLevel.get());
1583   }
1584 }
1585
1586 //
1587 ASDCP::Result_t
1588 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1589 {
1590   return InterchangeObject::InitFromBuffer(p, l);
1591 }
1592
1593 //
1594 ASDCP::Result_t
1595 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1596 {
1597   return InterchangeObject::WriteToBuffer(Buffer);
1598 }
1599
1600 //------------------------------------------------------------------------------------------
1601 // GenericPictureEssenceDescriptor
1602
1603 //
1604
1605 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0)
1606 {
1607   assert(m_Dict);
1608   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1609 }
1610
1611 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1612 {
1613   assert(m_Dict);
1614   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1615   Copy(rhs);
1616 }
1617
1618
1619 //
1620 ASDCP::Result_t
1621 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1622 {
1623   assert(m_Dict);
1624   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1625   if ( ASDCP_SUCCESS(result) ) {
1626     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1627     SignalStandard.set_has_value( result == RESULT_OK );
1628   }
1629   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1630   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1631   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1632   if ( ASDCP_SUCCESS(result) ) {
1633     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1634     StoredF2Offset.set_has_value( result == RESULT_OK );
1635   }
1636   if ( ASDCP_SUCCESS(result) ) {
1637     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1638     SampledWidth.set_has_value( result == RESULT_OK );
1639   }
1640   if ( ASDCP_SUCCESS(result) ) {
1641     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1642     SampledHeight.set_has_value( result == RESULT_OK );
1643   }
1644   if ( ASDCP_SUCCESS(result) ) {
1645     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1646     SampledXOffset.set_has_value( result == RESULT_OK );
1647   }
1648   if ( ASDCP_SUCCESS(result) ) {
1649     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1650     SampledYOffset.set_has_value( result == RESULT_OK );
1651   }
1652   if ( ASDCP_SUCCESS(result) ) {
1653     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1654     DisplayHeight.set_has_value( result == RESULT_OK );
1655   }
1656   if ( ASDCP_SUCCESS(result) ) {
1657     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1658     DisplayWidth.set_has_value( result == RESULT_OK );
1659   }
1660   if ( ASDCP_SUCCESS(result) ) {
1661     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1662     DisplayXOffset.set_has_value( result == RESULT_OK );
1663   }
1664   if ( ASDCP_SUCCESS(result) ) {
1665     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1666     DisplayYOffset.set_has_value( result == RESULT_OK );
1667   }
1668   if ( ASDCP_SUCCESS(result) ) {
1669     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1670     DisplayF2Offset.set_has_value( result == RESULT_OK );
1671   }
1672   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1673   if ( ASDCP_SUCCESS(result) ) {
1674     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1675     ActiveFormatDescriptor.set_has_value( result == RESULT_OK );
1676   }
1677   if ( ASDCP_SUCCESS(result) ) {
1678     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1679     AlphaTransparency.set_has_value( result == RESULT_OK );
1680   }
1681   if ( ASDCP_SUCCESS(result) ) {
1682     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1683     TransferCharacteristic.set_has_value( result == RESULT_OK );
1684   }
1685   if ( ASDCP_SUCCESS(result) ) {
1686     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1687     ImageAlignmentOffset.set_has_value( result == RESULT_OK );
1688   }
1689   if ( ASDCP_SUCCESS(result) ) {
1690     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1691     ImageStartOffset.set_has_value( result == RESULT_OK );
1692   }
1693   if ( ASDCP_SUCCESS(result) ) {
1694     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1695     ImageEndOffset.set_has_value( result == RESULT_OK );
1696   }
1697   if ( ASDCP_SUCCESS(result) ) {
1698     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1699     FieldDominance.set_has_value( result == RESULT_OK );
1700   }
1701   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1702   if ( ASDCP_SUCCESS(result) ) {
1703     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1704     CodingEquations.set_has_value( result == RESULT_OK );
1705   }
1706   if ( ASDCP_SUCCESS(result) ) {
1707     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1708     ColorPrimaries.set_has_value( result == RESULT_OK );
1709   }
1710   if ( ASDCP_SUCCESS(result) ) {
1711     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1712   }
1713   if ( ASDCP_SUCCESS(result) ) {
1714     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1715     ActiveWidth.set_has_value( result == RESULT_OK );
1716   }
1717   if ( ASDCP_SUCCESS(result) ) {
1718     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1719     ActiveHeight.set_has_value( result == RESULT_OK );
1720   }
1721   if ( ASDCP_SUCCESS(result) ) {
1722     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1723     ActiveXOffset.set_has_value( result == RESULT_OK );
1724   }
1725   if ( ASDCP_SUCCESS(result) ) {
1726     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1727     ActiveYOffset.set_has_value( result == RESULT_OK );
1728   }
1729   if ( ASDCP_SUCCESS(result) ) {
1730     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, VideoLineMap));
1731     VideoLineMap.set_has_value( result == RESULT_OK );
1732   }
1733   if ( ASDCP_SUCCESS(result) ) {
1734     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayPrimaries));
1735     MasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
1736   }
1737   if ( ASDCP_SUCCESS(result) ) {
1738     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayWhitePointChromaticity));
1739     MasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
1740   }
1741   if ( ASDCP_SUCCESS(result) ) {
1742     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMaximumLuminance));
1743     MasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
1744   }
1745   if ( ASDCP_SUCCESS(result) ) {
1746     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMinimumLuminance));
1747     MasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
1748   }
1749   return result;
1750 }
1751
1752 //
1753 ASDCP::Result_t
1754 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1755 {
1756   assert(m_Dict);
1757   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1758   if ( ASDCP_SUCCESS(result)  && ! SignalStandard.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SignalStandard));
1759   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1760   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1761   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1762   if ( ASDCP_SUCCESS(result)  && ! StoredF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, StoredF2Offset));
1763   if ( ASDCP_SUCCESS(result)  && ! SampledWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledWidth));
1764   if ( ASDCP_SUCCESS(result)  && ! SampledHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledHeight));
1765   if ( ASDCP_SUCCESS(result)  && ! SampledXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledXOffset));
1766   if ( ASDCP_SUCCESS(result)  && ! SampledYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, SampledYOffset));
1767   if ( ASDCP_SUCCESS(result)  && ! DisplayHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayHeight));
1768   if ( ASDCP_SUCCESS(result)  && ! DisplayWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayWidth));
1769   if ( ASDCP_SUCCESS(result)  && ! DisplayXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayXOffset));
1770   if ( ASDCP_SUCCESS(result)  && ! DisplayYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayYOffset));
1771   if ( ASDCP_SUCCESS(result)  && ! DisplayF2Offset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, DisplayF2Offset));
1772   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1773   if ( ASDCP_SUCCESS(result)  && ! ActiveFormatDescriptor.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveFormatDescriptor));
1774   if ( ASDCP_SUCCESS(result)  && ! AlphaTransparency.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlphaTransparency));
1775   if ( ASDCP_SUCCESS(result)  && ! TransferCharacteristic.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, TransferCharacteristic));
1776   if ( ASDCP_SUCCESS(result)  && ! ImageAlignmentOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageAlignmentOffset));
1777   if ( ASDCP_SUCCESS(result)  && ! ImageStartOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageStartOffset));
1778   if ( ASDCP_SUCCESS(result)  && ! ImageEndOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ImageEndOffset));
1779   if ( ASDCP_SUCCESS(result)  && ! FieldDominance.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, FieldDominance));
1780   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1781   if ( ASDCP_SUCCESS(result)  && ! CodingEquations.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, CodingEquations));
1782   if ( ASDCP_SUCCESS(result)  && ! ColorPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ColorPrimaries));
1783   if ( ASDCP_SUCCESS(result)  && ! AlternativeCenterCuts.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, AlternativeCenterCuts));
1784   if ( ASDCP_SUCCESS(result)  && ! ActiveWidth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveWidth));
1785   if ( ASDCP_SUCCESS(result)  && ! ActiveHeight.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveHeight));
1786   if ( ASDCP_SUCCESS(result)  && ! ActiveXOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveXOffset));
1787   if ( ASDCP_SUCCESS(result)  && ! ActiveYOffset.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, ActiveYOffset));
1788   if ( ASDCP_SUCCESS(result)  && ! VideoLineMap.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, VideoLineMap));
1789   if ( ASDCP_SUCCESS(result)  && ! MasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayPrimaries));
1790   if ( ASDCP_SUCCESS(result)  && ! MasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayWhitePointChromaticity));
1791   if ( ASDCP_SUCCESS(result)  && ! MasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMaximumLuminance));
1792   if ( ASDCP_SUCCESS(result)  && ! MasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(GenericPictureEssenceDescriptor, MasteringDisplayMinimumLuminance));
1793   return result;
1794 }
1795
1796 //
1797 void
1798 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1799 {
1800   FileDescriptor::Copy(rhs);
1801   SignalStandard = rhs.SignalStandard;
1802   FrameLayout = rhs.FrameLayout;
1803   StoredWidth = rhs.StoredWidth;
1804   StoredHeight = rhs.StoredHeight;
1805   StoredF2Offset = rhs.StoredF2Offset;
1806   SampledWidth = rhs.SampledWidth;
1807   SampledHeight = rhs.SampledHeight;
1808   SampledXOffset = rhs.SampledXOffset;
1809   SampledYOffset = rhs.SampledYOffset;
1810   DisplayHeight = rhs.DisplayHeight;
1811   DisplayWidth = rhs.DisplayWidth;
1812   DisplayXOffset = rhs.DisplayXOffset;
1813   DisplayYOffset = rhs.DisplayYOffset;
1814   DisplayF2Offset = rhs.DisplayF2Offset;
1815   AspectRatio = rhs.AspectRatio;
1816   ActiveFormatDescriptor = rhs.ActiveFormatDescriptor;
1817   AlphaTransparency = rhs.AlphaTransparency;
1818   TransferCharacteristic = rhs.TransferCharacteristic;
1819   ImageAlignmentOffset = rhs.ImageAlignmentOffset;
1820   ImageStartOffset = rhs.ImageStartOffset;
1821   ImageEndOffset = rhs.ImageEndOffset;
1822   FieldDominance = rhs.FieldDominance;
1823   PictureEssenceCoding = rhs.PictureEssenceCoding;
1824   CodingEquations = rhs.CodingEquations;
1825   ColorPrimaries = rhs.ColorPrimaries;
1826   AlternativeCenterCuts = rhs.AlternativeCenterCuts;
1827   ActiveWidth = rhs.ActiveWidth;
1828   ActiveHeight = rhs.ActiveHeight;
1829   ActiveXOffset = rhs.ActiveXOffset;
1830   ActiveYOffset = rhs.ActiveYOffset;
1831   VideoLineMap = rhs.VideoLineMap;
1832   MasteringDisplayPrimaries = rhs.MasteringDisplayPrimaries;
1833   MasteringDisplayWhitePointChromaticity = rhs.MasteringDisplayWhitePointChromaticity;
1834   MasteringDisplayMaximumLuminance = rhs.MasteringDisplayMaximumLuminance;
1835   MasteringDisplayMinimumLuminance = rhs.MasteringDisplayMinimumLuminance;
1836 }
1837
1838 //
1839 void
1840 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1841 {
1842   char identbuf[IdentBufferLen];
1843   *identbuf = 0;
1844
1845   if ( stream == 0 )
1846     stream = stderr;
1847
1848   FileDescriptor::Dump(stream);
1849   if ( ! SignalStandard.empty() ) {
1850     fprintf(stream, "  %22s = %d\n",  "SignalStandard", SignalStandard.get());
1851   }
1852   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1853   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1854   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1855   if ( ! StoredF2Offset.empty() ) {
1856     fprintf(stream, "  %22s = %d\n",  "StoredF2Offset", StoredF2Offset.get());
1857   }
1858   if ( ! SampledWidth.empty() ) {
1859     fprintf(stream, "  %22s = %d\n",  "SampledWidth", SampledWidth.get());
1860   }
1861   if ( ! SampledHeight.empty() ) {
1862     fprintf(stream, "  %22s = %d\n",  "SampledHeight", SampledHeight.get());
1863   }
1864   if ( ! SampledXOffset.empty() ) {
1865     fprintf(stream, "  %22s = %d\n",  "SampledXOffset", SampledXOffset.get());
1866   }
1867   if ( ! SampledYOffset.empty() ) {
1868     fprintf(stream, "  %22s = %d\n",  "SampledYOffset", SampledYOffset.get());
1869   }
1870   if ( ! DisplayHeight.empty() ) {
1871     fprintf(stream, "  %22s = %d\n",  "DisplayHeight", DisplayHeight.get());
1872   }
1873   if ( ! DisplayWidth.empty() ) {
1874     fprintf(stream, "  %22s = %d\n",  "DisplayWidth", DisplayWidth.get());
1875   }
1876   if ( ! DisplayXOffset.empty() ) {
1877     fprintf(stream, "  %22s = %d\n",  "DisplayXOffset", DisplayXOffset.get());
1878   }
1879   if ( ! DisplayYOffset.empty() ) {
1880     fprintf(stream, "  %22s = %d\n",  "DisplayYOffset", DisplayYOffset.get());
1881   }
1882   if ( ! DisplayF2Offset.empty() ) {
1883     fprintf(stream, "  %22s = %d\n",  "DisplayF2Offset", DisplayF2Offset.get());
1884   }
1885   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1886   if ( ! ActiveFormatDescriptor.empty() ) {
1887     fprintf(stream, "  %22s = %d\n",  "ActiveFormatDescriptor", ActiveFormatDescriptor.get());
1888   }
1889   if ( ! AlphaTransparency.empty() ) {
1890     fprintf(stream, "  %22s = %d\n",  "AlphaTransparency", AlphaTransparency.get());
1891   }
1892   if ( ! TransferCharacteristic.empty() ) {
1893     fprintf(stream, "  %22s = %s\n",  "TransferCharacteristic", TransferCharacteristic.get().EncodeString(identbuf, IdentBufferLen));
1894   }
1895   if ( ! ImageAlignmentOffset.empty() ) {
1896     fprintf(stream, "  %22s = %d\n",  "ImageAlignmentOffset", ImageAlignmentOffset.get());
1897   }
1898   if ( ! ImageStartOffset.empty() ) {
1899     fprintf(stream, "  %22s = %d\n",  "ImageStartOffset", ImageStartOffset.get());
1900   }
1901   if ( ! ImageEndOffset.empty() ) {
1902     fprintf(stream, "  %22s = %d\n",  "ImageEndOffset", ImageEndOffset.get());
1903   }
1904   if ( ! FieldDominance.empty() ) {
1905     fprintf(stream, "  %22s = %d\n",  "FieldDominance", FieldDominance.get());
1906   }
1907   fprintf(stream, "  %22s = %s\n",  "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1908   if ( ! CodingEquations.empty() ) {
1909     fprintf(stream, "  %22s = %s\n",  "CodingEquations", CodingEquations.get().EncodeString(identbuf, IdentBufferLen));
1910   }
1911   if ( ! ColorPrimaries.empty() ) {
1912     fprintf(stream, "  %22s = %s\n",  "ColorPrimaries", ColorPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1913   }
1914   if ( ! AlternativeCenterCuts.empty() ) {
1915     fprintf(stream, "  %22s:\n",  "AlternativeCenterCuts");
1916   AlternativeCenterCuts.get().Dump(stream);
1917   }
1918   if ( ! ActiveWidth.empty() ) {
1919     fprintf(stream, "  %22s = %d\n",  "ActiveWidth", ActiveWidth.get());
1920   }
1921   if ( ! ActiveHeight.empty() ) {
1922     fprintf(stream, "  %22s = %d\n",  "ActiveHeight", ActiveHeight.get());
1923   }
1924   if ( ! ActiveXOffset.empty() ) {
1925     fprintf(stream, "  %22s = %d\n",  "ActiveXOffset", ActiveXOffset.get());
1926   }
1927   if ( ! ActiveYOffset.empty() ) {
1928     fprintf(stream, "  %22s = %d\n",  "ActiveYOffset", ActiveYOffset.get());
1929   }
1930   if ( ! VideoLineMap.empty() ) {
1931     fprintf(stream, "  %22s = %s\n",  "VideoLineMap", VideoLineMap.get().EncodeString(identbuf, IdentBufferLen));
1932   }
1933   if ( ! MasteringDisplayPrimaries.empty() ) {
1934     fprintf(stream, "  %22s = %s\n",  "MasteringDisplayPrimaries", MasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
1935   }
1936   if ( ! MasteringDisplayWhitePointChromaticity.empty() ) {
1937     fprintf(stream, "  %22s = %s\n",  "MasteringDisplayWhitePointChromaticity", MasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
1938   }
1939   if ( ! MasteringDisplayMaximumLuminance.empty() ) {
1940     fprintf(stream, "  %22s = %d\n",  "MasteringDisplayMaximumLuminance", MasteringDisplayMaximumLuminance.get());
1941   }
1942   if ( ! MasteringDisplayMinimumLuminance.empty() ) {
1943     fprintf(stream, "  %22s = %d\n",  "MasteringDisplayMinimumLuminance", MasteringDisplayMinimumLuminance.get());
1944   }
1945 }
1946
1947 //
1948 ASDCP::Result_t
1949 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1950 {
1951   return InterchangeObject::InitFromBuffer(p, l);
1952 }
1953
1954 //
1955 ASDCP::Result_t
1956 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1957 {
1958   return InterchangeObject::WriteToBuffer(Buffer);
1959 }
1960
1961 //------------------------------------------------------------------------------------------
1962 // RGBAEssenceDescriptor
1963
1964 //
1965
1966 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d)
1967 {
1968   assert(m_Dict);
1969   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1970 }
1971
1972 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1973 {
1974   assert(m_Dict);
1975   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1976   Copy(rhs);
1977 }
1978
1979
1980 //
1981 ASDCP::Result_t
1982 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1983 {
1984   assert(m_Dict);
1985   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1986   if ( ASDCP_SUCCESS(result) ) {
1987     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
1988     ComponentMaxRef.set_has_value( result == RESULT_OK );
1989   }
1990   if ( ASDCP_SUCCESS(result) ) {
1991     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
1992     ComponentMinRef.set_has_value( result == RESULT_OK );
1993   }
1994   if ( ASDCP_SUCCESS(result) ) {
1995     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
1996     AlphaMinRef.set_has_value( result == RESULT_OK );
1997   }
1998   if ( ASDCP_SUCCESS(result) ) {
1999     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
2000     AlphaMaxRef.set_has_value( result == RESULT_OK );
2001   }
2002   if ( ASDCP_SUCCESS(result) ) {
2003     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
2004     ScanningDirection.set_has_value( result == RESULT_OK );
2005   }
2006   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(RGBAEssenceDescriptor, PixelLayout));
2007   return result;
2008 }
2009
2010 //
2011 ASDCP::Result_t
2012 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2013 {
2014   assert(m_Dict);
2015   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2016   if ( ASDCP_SUCCESS(result)  && ! ComponentMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMaxRef));
2017   if ( ASDCP_SUCCESS(result)  && ! ComponentMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ComponentMinRef));
2018   if ( ASDCP_SUCCESS(result)  && ! AlphaMinRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMinRef));
2019   if ( ASDCP_SUCCESS(result)  && ! AlphaMaxRef.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, AlphaMaxRef));
2020   if ( ASDCP_SUCCESS(result)  && ! ScanningDirection.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(RGBAEssenceDescriptor, ScanningDirection));
2021   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, PixelLayout));
2022   return result;
2023 }
2024
2025 //
2026 void
2027 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
2028 {
2029   GenericPictureEssenceDescriptor::Copy(rhs);
2030   ComponentMaxRef = rhs.ComponentMaxRef;
2031   ComponentMinRef = rhs.ComponentMinRef;
2032   AlphaMinRef = rhs.AlphaMinRef;
2033   AlphaMaxRef = rhs.AlphaMaxRef;
2034   ScanningDirection = rhs.ScanningDirection;
2035   PixelLayout = rhs.PixelLayout;
2036 }
2037
2038 //
2039 void
2040 RGBAEssenceDescriptor::Dump(FILE* stream)
2041 {
2042   char identbuf[IdentBufferLen];
2043   *identbuf = 0;
2044
2045   if ( stream == 0 )
2046     stream = stderr;
2047
2048   GenericPictureEssenceDescriptor::Dump(stream);
2049   if ( ! ComponentMaxRef.empty() ) {
2050     fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef.get());
2051   }
2052   if ( ! ComponentMinRef.empty() ) {
2053     fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef.get());
2054   }
2055   if ( ! AlphaMinRef.empty() ) {
2056     fprintf(stream, "  %22s = %d\n",  "AlphaMinRef", AlphaMinRef.get());
2057   }
2058   if ( ! AlphaMaxRef.empty() ) {
2059     fprintf(stream, "  %22s = %d\n",  "AlphaMaxRef", AlphaMaxRef.get());
2060   }
2061   if ( ! ScanningDirection.empty() ) {
2062     fprintf(stream, "  %22s = %d\n",  "ScanningDirection", ScanningDirection.get());
2063   }
2064   fprintf(stream, "  %22s = %s\n",  "PixelLayout", PixelLayout.EncodeString(identbuf, IdentBufferLen));
2065 }
2066
2067 //
2068 ASDCP::Result_t
2069 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2070 {
2071   return InterchangeObject::InitFromBuffer(p, l);
2072 }
2073
2074 //
2075 ASDCP::Result_t
2076 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2077 {
2078   return InterchangeObject::WriteToBuffer(Buffer);
2079 }
2080
2081 //------------------------------------------------------------------------------------------
2082 // JPEG2000PictureSubDescriptor
2083
2084 //
2085
2086 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)
2087 {
2088   assert(m_Dict);
2089   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2090 }
2091
2092 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2093 {
2094   assert(m_Dict);
2095   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
2096   Copy(rhs);
2097 }
2098
2099
2100 //
2101 ASDCP::Result_t
2102 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2103 {
2104   assert(m_Dict);
2105   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2106   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2107   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2108   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2109   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2110   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2111   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2112   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2113   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2114   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2115   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
2116   if ( ASDCP_SUCCESS(result) ) {
2117     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2118     PictureComponentSizing.set_has_value( result == RESULT_OK );
2119   }
2120   if ( ASDCP_SUCCESS(result) ) {
2121     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2122     CodingStyleDefault.set_has_value( result == RESULT_OK );
2123   }
2124   if ( ASDCP_SUCCESS(result) ) {
2125     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2126     QuantizationDefault.set_has_value( result == RESULT_OK );
2127   }
2128   if ( ASDCP_SUCCESS(result) ) {
2129     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2130     J2CLayout.set_has_value( result == RESULT_OK );
2131   }
2132   return result;
2133 }
2134
2135 //
2136 ASDCP::Result_t
2137 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2138 {
2139   assert(m_Dict);
2140   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2141   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
2142   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
2143   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
2144   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
2145   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
2146   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
2147   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
2148   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
2149   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
2150   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
2151   if ( ASDCP_SUCCESS(result)  && ! PictureComponentSizing.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, PictureComponentSizing));
2152   if ( ASDCP_SUCCESS(result)  && ! CodingStyleDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, CodingStyleDefault));
2153   if ( ASDCP_SUCCESS(result)  && ! QuantizationDefault.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, QuantizationDefault));
2154   if ( ASDCP_SUCCESS(result)  && ! J2CLayout.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(JPEG2000PictureSubDescriptor, J2CLayout));
2155   return result;
2156 }
2157
2158 //
2159 void
2160 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
2161 {
2162   InterchangeObject::Copy(rhs);
2163   Rsize = rhs.Rsize;
2164   Xsize = rhs.Xsize;
2165   Ysize = rhs.Ysize;
2166   XOsize = rhs.XOsize;
2167   YOsize = rhs.YOsize;
2168   XTsize = rhs.XTsize;
2169   YTsize = rhs.YTsize;
2170   XTOsize = rhs.XTOsize;
2171   YTOsize = rhs.YTOsize;
2172   Csize = rhs.Csize;
2173   PictureComponentSizing = rhs.PictureComponentSizing;
2174   CodingStyleDefault = rhs.CodingStyleDefault;
2175   QuantizationDefault = rhs.QuantizationDefault;
2176   J2CLayout = rhs.J2CLayout;
2177 }
2178
2179 //
2180 void
2181 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
2182 {
2183   char identbuf[IdentBufferLen];
2184   *identbuf = 0;
2185
2186   if ( stream == 0 )
2187     stream = stderr;
2188
2189   InterchangeObject::Dump(stream);
2190   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
2191   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
2192   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
2193   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
2194   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
2195   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
2196   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
2197   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
2198   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
2199   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
2200   if ( ! PictureComponentSizing.empty() ) {
2201     fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.get().EncodeString(identbuf, IdentBufferLen));
2202   }
2203   if ( ! CodingStyleDefault.empty() ) {
2204     fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.get().EncodeString(identbuf, IdentBufferLen));
2205   }
2206   if ( ! QuantizationDefault.empty() ) {
2207     fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.get().EncodeString(identbuf, IdentBufferLen));
2208   }
2209   if ( ! J2CLayout.empty() ) {
2210     fprintf(stream, "  %22s = %s\n",  "J2CLayout", J2CLayout.get().EncodeString(identbuf, IdentBufferLen));
2211   }
2212 }
2213
2214 //
2215 ASDCP::Result_t
2216 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2217 {
2218   return InterchangeObject::InitFromBuffer(p, l);
2219 }
2220
2221 //
2222 ASDCP::Result_t
2223 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2224 {
2225   return InterchangeObject::WriteToBuffer(Buffer);
2226 }
2227
2228 //------------------------------------------------------------------------------------------
2229 // CDCIEssenceDescriptor
2230
2231 //
2232
2233 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0)
2234 {
2235   assert(m_Dict);
2236   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2237 }
2238
2239 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2240 {
2241   assert(m_Dict);
2242   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
2243   Copy(rhs);
2244 }
2245
2246
2247 //
2248 ASDCP::Result_t
2249 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2250 {
2251   assert(m_Dict);
2252   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
2253   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2254   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2255   if ( ASDCP_SUCCESS(result) ) {
2256     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2257     VerticalSubsampling.set_has_value( result == RESULT_OK );
2258   }
2259   if ( ASDCP_SUCCESS(result) ) {
2260     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2261     ColorSiting.set_has_value( result == RESULT_OK );
2262   }
2263   if ( ASDCP_SUCCESS(result) ) {
2264     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2265     ReversedByteOrder.set_has_value( result == RESULT_OK );
2266   }
2267   if ( ASDCP_SUCCESS(result) ) {
2268     result = TLVSet.ReadUi16(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2269     PaddingBits.set_has_value( result == RESULT_OK );
2270   }
2271   if ( ASDCP_SUCCESS(result) ) {
2272     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2273     AlphaSampleDepth.set_has_value( result == RESULT_OK );
2274   }
2275   if ( ASDCP_SUCCESS(result) ) {
2276     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2277     BlackRefLevel.set_has_value( result == RESULT_OK );
2278   }
2279   if ( ASDCP_SUCCESS(result) ) {
2280     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2281     WhiteReflevel.set_has_value( result == RESULT_OK );
2282   }
2283   if ( ASDCP_SUCCESS(result) ) {
2284     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2285     ColorRange.set_has_value( result == RESULT_OK );
2286   }
2287   return result;
2288 }
2289
2290 //
2291 ASDCP::Result_t
2292 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2293 {
2294   assert(m_Dict);
2295   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
2296   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
2297   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
2298   if ( ASDCP_SUCCESS(result)  && ! VerticalSubsampling.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, VerticalSubsampling));
2299   if ( ASDCP_SUCCESS(result)  && ! ColorSiting.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorSiting));
2300   if ( ASDCP_SUCCESS(result)  && ! ReversedByteOrder.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ReversedByteOrder));
2301   if ( ASDCP_SUCCESS(result)  && ! PaddingBits.empty() ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, PaddingBits));
2302   if ( ASDCP_SUCCESS(result)  && ! AlphaSampleDepth.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, AlphaSampleDepth));
2303   if ( ASDCP_SUCCESS(result)  && ! BlackRefLevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, BlackRefLevel));
2304   if ( ASDCP_SUCCESS(result)  && ! WhiteReflevel.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, WhiteReflevel));
2305   if ( ASDCP_SUCCESS(result)  && ! ColorRange.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(CDCIEssenceDescriptor, ColorRange));
2306   return result;
2307 }
2308
2309 //
2310 void
2311 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
2312 {
2313   GenericPictureEssenceDescriptor::Copy(rhs);
2314   ComponentDepth = rhs.ComponentDepth;
2315   HorizontalSubsampling = rhs.HorizontalSubsampling;
2316   VerticalSubsampling = rhs.VerticalSubsampling;
2317   ColorSiting = rhs.ColorSiting;
2318   ReversedByteOrder = rhs.ReversedByteOrder;
2319   PaddingBits = rhs.PaddingBits;
2320   AlphaSampleDepth = rhs.AlphaSampleDepth;
2321   BlackRefLevel = rhs.BlackRefLevel;
2322   WhiteReflevel = rhs.WhiteReflevel;
2323   ColorRange = rhs.ColorRange;
2324 }
2325
2326 //
2327 void
2328 CDCIEssenceDescriptor::Dump(FILE* stream)
2329 {
2330   char identbuf[IdentBufferLen];
2331   *identbuf = 0;
2332
2333   if ( stream == 0 )
2334     stream = stderr;
2335
2336   GenericPictureEssenceDescriptor::Dump(stream);
2337   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
2338   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
2339   if ( ! VerticalSubsampling.empty() ) {
2340     fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling.get());
2341   }
2342   if ( ! ColorSiting.empty() ) {
2343     fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting.get());
2344   }
2345   if ( ! ReversedByteOrder.empty() ) {
2346     fprintf(stream, "  %22s = %d\n",  "ReversedByteOrder", ReversedByteOrder.get());
2347   }
2348   if ( ! PaddingBits.empty() ) {
2349     fprintf(stream, "  %22s = %d\n",  "PaddingBits", PaddingBits.get());
2350   }
2351   if ( ! AlphaSampleDepth.empty() ) {
2352     fprintf(stream, "  %22s = %d\n",  "AlphaSampleDepth", AlphaSampleDepth.get());
2353   }
2354   if ( ! BlackRefLevel.empty() ) {
2355     fprintf(stream, "  %22s = %d\n",  "BlackRefLevel", BlackRefLevel.get());
2356   }
2357   if ( ! WhiteReflevel.empty() ) {
2358     fprintf(stream, "  %22s = %d\n",  "WhiteReflevel", WhiteReflevel.get());
2359   }
2360   if ( ! ColorRange.empty() ) {
2361     fprintf(stream, "  %22s = %d\n",  "ColorRange", ColorRange.get());
2362   }
2363 }
2364
2365 //
2366 ASDCP::Result_t
2367 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2368 {
2369   return InterchangeObject::InitFromBuffer(p, l);
2370 }
2371
2372 //
2373 ASDCP::Result_t
2374 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2375 {
2376   return InterchangeObject::WriteToBuffer(Buffer);
2377 }
2378
2379 //------------------------------------------------------------------------------------------
2380 // MPEG2VideoDescriptor
2381
2382 //
2383
2384 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d)
2385 {
2386   assert(m_Dict);
2387   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2388 }
2389
2390 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2391 {
2392   assert(m_Dict);
2393   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
2394   Copy(rhs);
2395 }
2396
2397
2398 //
2399 ASDCP::Result_t
2400 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2401 {
2402   assert(m_Dict);
2403   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
2404   if ( ASDCP_SUCCESS(result) ) {
2405     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2406     SingleSequence.set_has_value( result == RESULT_OK );
2407   }
2408   if ( ASDCP_SUCCESS(result) ) {
2409     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2410     ConstantBFrames.set_has_value( result == RESULT_OK );
2411   }
2412   if ( ASDCP_SUCCESS(result) ) {
2413     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2414     CodedContentType.set_has_value( result == RESULT_OK );
2415   }
2416   if ( ASDCP_SUCCESS(result) ) {
2417     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2418     LowDelay.set_has_value( result == RESULT_OK );
2419   }
2420   if ( ASDCP_SUCCESS(result) ) {
2421     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2422     ClosedGOP.set_has_value( result == RESULT_OK );
2423   }
2424   if ( ASDCP_SUCCESS(result) ) {
2425     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2426     IdenticalGOP.set_has_value( result == RESULT_OK );
2427   }
2428   if ( ASDCP_SUCCESS(result) ) {
2429     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2430     MaxGOP.set_has_value( result == RESULT_OK );
2431   }
2432   if ( ASDCP_SUCCESS(result) ) {
2433     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2434     BPictureCount.set_has_value( result == RESULT_OK );
2435   }
2436   if ( ASDCP_SUCCESS(result) ) {
2437     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2438     BitRate.set_has_value( result == RESULT_OK );
2439   }
2440   if ( ASDCP_SUCCESS(result) ) {
2441     result = TLVSet.ReadUi8(OBJ_READ_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2442     ProfileAndLevel.set_has_value( result == RESULT_OK );
2443   }
2444   return result;
2445 }
2446
2447 //
2448 ASDCP::Result_t
2449 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2450 {
2451   assert(m_Dict);
2452   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
2453   if ( ASDCP_SUCCESS(result)  && ! SingleSequence.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, SingleSequence));
2454   if ( ASDCP_SUCCESS(result)  && ! ConstantBFrames.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ConstantBFrames));
2455   if ( ASDCP_SUCCESS(result)  && ! CodedContentType.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, CodedContentType));
2456   if ( ASDCP_SUCCESS(result)  && ! LowDelay.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, LowDelay));
2457   if ( ASDCP_SUCCESS(result)  && ! ClosedGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ClosedGOP));
2458   if ( ASDCP_SUCCESS(result)  && ! IdenticalGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, IdenticalGOP));
2459   if ( ASDCP_SUCCESS(result)  && ! MaxGOP.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, MaxGOP));
2460   if ( ASDCP_SUCCESS(result)  && ! BPictureCount.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BPictureCount));
2461   if ( ASDCP_SUCCESS(result)  && ! BitRate.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, BitRate));
2462   if ( ASDCP_SUCCESS(result)  && ! ProfileAndLevel.empty() ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS_OPT(MPEG2VideoDescriptor, ProfileAndLevel));
2463   return result;
2464 }
2465
2466 //
2467 void
2468 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
2469 {
2470   CDCIEssenceDescriptor::Copy(rhs);
2471   SingleSequence = rhs.SingleSequence;
2472   ConstantBFrames = rhs.ConstantBFrames;
2473   CodedContentType = rhs.CodedContentType;
2474   LowDelay = rhs.LowDelay;
2475   ClosedGOP = rhs.ClosedGOP;
2476   IdenticalGOP = rhs.IdenticalGOP;
2477   MaxGOP = rhs.MaxGOP;
2478   BPictureCount = rhs.BPictureCount;
2479   BitRate = rhs.BitRate;
2480   ProfileAndLevel = rhs.ProfileAndLevel;
2481 }
2482
2483 //
2484 void
2485 MPEG2VideoDescriptor::Dump(FILE* stream)
2486 {
2487   char identbuf[IdentBufferLen];
2488   *identbuf = 0;
2489
2490   if ( stream == 0 )
2491     stream = stderr;
2492
2493   CDCIEssenceDescriptor::Dump(stream);
2494   if ( ! SingleSequence.empty() ) {
2495     fprintf(stream, "  %22s = %d\n",  "SingleSequence", SingleSequence.get());
2496   }
2497   if ( ! ConstantBFrames.empty() ) {
2498     fprintf(stream, "  %22s = %d\n",  "ConstantBFrames", ConstantBFrames.get());
2499   }
2500   if ( ! CodedContentType.empty() ) {
2501     fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType.get());
2502   }
2503   if ( ! LowDelay.empty() ) {
2504     fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay.get());
2505   }
2506   if ( ! ClosedGOP.empty() ) {
2507     fprintf(stream, "  %22s = %d\n",  "ClosedGOP", ClosedGOP.get());
2508   }
2509   if ( ! IdenticalGOP.empty() ) {
2510     fprintf(stream, "  %22s = %d\n",  "IdenticalGOP", IdenticalGOP.get());
2511   }
2512   if ( ! MaxGOP.empty() ) {
2513     fprintf(stream, "  %22s = %d\n",  "MaxGOP", MaxGOP.get());
2514   }
2515   if ( ! BPictureCount.empty() ) {
2516     fprintf(stream, "  %22s = %d\n",  "BPictureCount", BPictureCount.get());
2517   }
2518   if ( ! BitRate.empty() ) {
2519     fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate.get());
2520   }
2521   if ( ! ProfileAndLevel.empty() ) {
2522     fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel.get());
2523   }
2524 }
2525
2526 //
2527 ASDCP::Result_t
2528 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2529 {
2530   return InterchangeObject::InitFromBuffer(p, l);
2531 }
2532
2533 //
2534 ASDCP::Result_t
2535 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2536 {
2537   return InterchangeObject::WriteToBuffer(Buffer);
2538 }
2539
2540 //------------------------------------------------------------------------------------------
2541 // DMSegment
2542
2543 //
2544
2545 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
2546 {
2547   assert(m_Dict);
2548   m_UL = m_Dict->ul(MDD_DMSegment);
2549 }
2550
2551 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2552 {
2553   assert(m_Dict);
2554   m_UL = m_Dict->ul(MDD_DMSegment);
2555   Copy(rhs);
2556 }
2557
2558
2559 //
2560 ASDCP::Result_t
2561 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
2562 {
2563   assert(m_Dict);
2564   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2565   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
2566   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
2567   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
2568   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
2569   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
2570   return result;
2571 }
2572
2573 //
2574 ASDCP::Result_t
2575 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
2576 {
2577   assert(m_Dict);
2578   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2579   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
2580   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
2581   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
2582   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
2583   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
2584   return result;
2585 }
2586
2587 //
2588 void
2589 DMSegment::Copy(const DMSegment& rhs)
2590 {
2591   InterchangeObject::Copy(rhs);
2592   DataDefinition = rhs.DataDefinition;
2593   EventStartPosition = rhs.EventStartPosition;
2594   Duration = rhs.Duration;
2595   EventComment = rhs.EventComment;
2596   DMFramework = rhs.DMFramework;
2597 }
2598
2599 //
2600 void
2601 DMSegment::Dump(FILE* stream)
2602 {
2603   char identbuf[IdentBufferLen];
2604   *identbuf = 0;
2605
2606   if ( stream == 0 )
2607     stream = stderr;
2608
2609   InterchangeObject::Dump(stream);
2610   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2611   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
2612   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
2613   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
2614   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2615 }
2616
2617 //
2618 ASDCP::Result_t
2619 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2620 {
2621   return InterchangeObject::InitFromBuffer(p, l);
2622 }
2623
2624 //
2625 ASDCP::Result_t
2626 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2627 {
2628   return InterchangeObject::WriteToBuffer(Buffer);
2629 }
2630
2631 //------------------------------------------------------------------------------------------
2632 // CryptographicFramework
2633
2634 //
2635
2636 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2637 {
2638   assert(m_Dict);
2639   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2640 }
2641
2642 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2643 {
2644   assert(m_Dict);
2645   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2646   Copy(rhs);
2647 }
2648
2649
2650 //
2651 ASDCP::Result_t
2652 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2653 {
2654   assert(m_Dict);
2655   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2656   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2657   return result;
2658 }
2659
2660 //
2661 ASDCP::Result_t
2662 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2663 {
2664   assert(m_Dict);
2665   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2666   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2667   return result;
2668 }
2669
2670 //
2671 void
2672 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2673 {
2674   InterchangeObject::Copy(rhs);
2675   ContextSR = rhs.ContextSR;
2676 }
2677
2678 //
2679 void
2680 CryptographicFramework::Dump(FILE* stream)
2681 {
2682   char identbuf[IdentBufferLen];
2683   *identbuf = 0;
2684
2685   if ( stream == 0 )
2686     stream = stderr;
2687
2688   InterchangeObject::Dump(stream);
2689   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2690 }
2691
2692 //
2693 ASDCP::Result_t
2694 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2695 {
2696   return InterchangeObject::InitFromBuffer(p, l);
2697 }
2698
2699 //
2700 ASDCP::Result_t
2701 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2702 {
2703   return InterchangeObject::WriteToBuffer(Buffer);
2704 }
2705
2706 //------------------------------------------------------------------------------------------
2707 // CryptographicContext
2708
2709 //
2710
2711 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2712 {
2713   assert(m_Dict);
2714   m_UL = m_Dict->ul(MDD_CryptographicContext);
2715 }
2716
2717 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2718 {
2719   assert(m_Dict);
2720   m_UL = m_Dict->ul(MDD_CryptographicContext);
2721   Copy(rhs);
2722 }
2723
2724
2725 //
2726 ASDCP::Result_t
2727 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2728 {
2729   assert(m_Dict);
2730   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2731   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2732   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2733   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2734   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2735   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2736   return result;
2737 }
2738
2739 //
2740 ASDCP::Result_t
2741 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2742 {
2743   assert(m_Dict);
2744   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2745   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2746   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2747   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2748   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2749   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2750   return result;
2751 }
2752
2753 //
2754 void
2755 CryptographicContext::Copy(const CryptographicContext& rhs)
2756 {
2757   InterchangeObject::Copy(rhs);
2758   ContextID = rhs.ContextID;
2759   SourceEssenceContainer = rhs.SourceEssenceContainer;
2760   CipherAlgorithm = rhs.CipherAlgorithm;
2761   MICAlgorithm = rhs.MICAlgorithm;
2762   CryptographicKeyID = rhs.CryptographicKeyID;
2763 }
2764
2765 //
2766 void
2767 CryptographicContext::Dump(FILE* stream)
2768 {
2769   char identbuf[IdentBufferLen];
2770   *identbuf = 0;
2771
2772   if ( stream == 0 )
2773     stream = stderr;
2774
2775   InterchangeObject::Dump(stream);
2776   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2777   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2778   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2779   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2780   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2781 }
2782
2783 //
2784 ASDCP::Result_t
2785 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2786 {
2787   return InterchangeObject::InitFromBuffer(p, l);
2788 }
2789
2790 //
2791 ASDCP::Result_t
2792 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2793 {
2794   return InterchangeObject::WriteToBuffer(Buffer);
2795 }
2796
2797 //------------------------------------------------------------------------------------------
2798 // DescriptiveFramework
2799
2800 //
2801
2802 DescriptiveFramework::DescriptiveFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2803 {
2804   assert(m_Dict);
2805   m_UL = m_Dict->ul(MDD_DescriptiveFramework);
2806 }
2807
2808 DescriptiveFramework::DescriptiveFramework(const DescriptiveFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2809 {
2810   assert(m_Dict);
2811   m_UL = m_Dict->ul(MDD_DescriptiveFramework);
2812   Copy(rhs);
2813 }
2814
2815
2816 //
2817 ASDCP::Result_t
2818 DescriptiveFramework::InitFromTLVSet(TLVReader& TLVSet)
2819 {
2820   assert(m_Dict);
2821   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2822   if ( ASDCP_SUCCESS(result) ) {
2823     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DescriptiveFramework, LinkedDescriptiveFrameworkPlugInId));
2824     LinkedDescriptiveFrameworkPlugInId.set_has_value( result == RESULT_OK );
2825   }
2826   return result;
2827 }
2828
2829 //
2830 ASDCP::Result_t
2831 DescriptiveFramework::WriteToTLVSet(TLVWriter& TLVSet)
2832 {
2833   assert(m_Dict);
2834   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2835   if ( ASDCP_SUCCESS(result)  && ! LinkedDescriptiveFrameworkPlugInId.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DescriptiveFramework, LinkedDescriptiveFrameworkPlugInId));
2836   return result;
2837 }
2838
2839 //
2840 void
2841 DescriptiveFramework::Copy(const DescriptiveFramework& rhs)
2842 {
2843   InterchangeObject::Copy(rhs);
2844   LinkedDescriptiveFrameworkPlugInId = rhs.LinkedDescriptiveFrameworkPlugInId;
2845 }
2846
2847 //
2848 void
2849 DescriptiveFramework::Dump(FILE* stream)
2850 {
2851   char identbuf[IdentBufferLen];
2852   *identbuf = 0;
2853
2854   if ( stream == 0 )
2855     stream = stderr;
2856
2857   InterchangeObject::Dump(stream);
2858   if ( ! LinkedDescriptiveFrameworkPlugInId.empty() ) {
2859     fprintf(stream, "  %22s = %s\n",  "LinkedDescriptiveFrameworkPlugInId", LinkedDescriptiveFrameworkPlugInId.get().EncodeString(identbuf, IdentBufferLen));
2860   }
2861 }
2862
2863 //
2864 ASDCP::Result_t
2865 DescriptiveFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2866 {
2867   return InterchangeObject::InitFromBuffer(p, l);
2868 }
2869
2870 //
2871 ASDCP::Result_t
2872 DescriptiveFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2873 {
2874   return InterchangeObject::WriteToBuffer(Buffer);
2875 }
2876
2877 //------------------------------------------------------------------------------------------
2878 // DescriptiveObject
2879
2880 //
2881
2882 DescriptiveObject::DescriptiveObject(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2883 {
2884   assert(m_Dict);
2885   m_UL = m_Dict->ul(MDD_DescriptiveObject);
2886 }
2887
2888 DescriptiveObject::DescriptiveObject(const DescriptiveObject& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2889 {
2890   assert(m_Dict);
2891   m_UL = m_Dict->ul(MDD_DescriptiveObject);
2892   Copy(rhs);
2893 }
2894
2895
2896 //
2897 ASDCP::Result_t
2898 DescriptiveObject::InitFromTLVSet(TLVReader& TLVSet)
2899 {
2900   assert(m_Dict);
2901   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2902   if ( ASDCP_SUCCESS(result) ) {
2903     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(DescriptiveObject, LinkedDescriptiveObjectPlugInId));
2904     LinkedDescriptiveObjectPlugInId.set_has_value( result == RESULT_OK );
2905   }
2906   return result;
2907 }
2908
2909 //
2910 ASDCP::Result_t
2911 DescriptiveObject::WriteToTLVSet(TLVWriter& TLVSet)
2912 {
2913   assert(m_Dict);
2914   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2915   if ( ASDCP_SUCCESS(result)  && ! LinkedDescriptiveObjectPlugInId.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(DescriptiveObject, LinkedDescriptiveObjectPlugInId));
2916   return result;
2917 }
2918
2919 //
2920 void
2921 DescriptiveObject::Copy(const DescriptiveObject& rhs)
2922 {
2923   InterchangeObject::Copy(rhs);
2924   LinkedDescriptiveObjectPlugInId = rhs.LinkedDescriptiveObjectPlugInId;
2925 }
2926
2927 //
2928 void
2929 DescriptiveObject::Dump(FILE* stream)
2930 {
2931   char identbuf[IdentBufferLen];
2932   *identbuf = 0;
2933
2934   if ( stream == 0 )
2935     stream = stderr;
2936
2937   InterchangeObject::Dump(stream);
2938   if ( ! LinkedDescriptiveObjectPlugInId.empty() ) {
2939     fprintf(stream, "  %22s = %s\n",  "LinkedDescriptiveObjectPlugInId", LinkedDescriptiveObjectPlugInId.get().EncodeString(identbuf, IdentBufferLen));
2940   }
2941 }
2942
2943 //
2944 ASDCP::Result_t
2945 DescriptiveObject::InitFromBuffer(const byte_t* p, ui32_t l)
2946 {
2947   return InterchangeObject::InitFromBuffer(p, l);
2948 }
2949
2950 //
2951 ASDCP::Result_t
2952 DescriptiveObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2953 {
2954   return InterchangeObject::WriteToBuffer(Buffer);
2955 }
2956
2957 //------------------------------------------------------------------------------------------
2958 // GenericDataEssenceDescriptor
2959
2960 //
2961
2962 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
2963 {
2964   assert(m_Dict);
2965   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2966 }
2967
2968 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2969 {
2970   assert(m_Dict);
2971   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2972   Copy(rhs);
2973 }
2974
2975
2976 //
2977 ASDCP::Result_t
2978 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2979 {
2980   assert(m_Dict);
2981   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
2982   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2983   return result;
2984 }
2985
2986 //
2987 ASDCP::Result_t
2988 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2989 {
2990   assert(m_Dict);
2991   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
2992   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2993   return result;
2994 }
2995
2996 //
2997 void
2998 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
2999 {
3000   FileDescriptor::Copy(rhs);
3001   DataEssenceCoding = rhs.DataEssenceCoding;
3002 }
3003
3004 //
3005 void
3006 GenericDataEssenceDescriptor::Dump(FILE* stream)
3007 {
3008   char identbuf[IdentBufferLen];
3009   *identbuf = 0;
3010
3011   if ( stream == 0 )
3012     stream = stderr;
3013
3014   FileDescriptor::Dump(stream);
3015   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
3016 }
3017
3018 //
3019 ASDCP::Result_t
3020 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3021 {
3022   return InterchangeObject::InitFromBuffer(p, l);
3023 }
3024
3025 //
3026 ASDCP::Result_t
3027 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3028 {
3029   return InterchangeObject::WriteToBuffer(Buffer);
3030 }
3031
3032 //------------------------------------------------------------------------------------------
3033 // TimedTextDescriptor
3034
3035 //
3036
3037 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3038 {
3039   assert(m_Dict);
3040   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
3041 }
3042
3043 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3044 {
3045   assert(m_Dict);
3046   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
3047   Copy(rhs);
3048 }
3049
3050
3051 //
3052 ASDCP::Result_t
3053 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3054 {
3055   assert(m_Dict);
3056   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3057   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
3058   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
3059   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
3060   if ( ASDCP_SUCCESS(result) ) {
3061     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
3062     RFC5646LanguageTagList.set_has_value( result == RESULT_OK );
3063   }
3064   return result;
3065 }
3066
3067 //
3068 ASDCP::Result_t
3069 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3070 {
3071   assert(m_Dict);
3072   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3073   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
3074   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
3075   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
3076   if ( ASDCP_SUCCESS(result)  && ! RFC5646LanguageTagList.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TimedTextDescriptor, RFC5646LanguageTagList));
3077   return result;
3078 }
3079
3080 //
3081 void
3082 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
3083 {
3084   GenericDataEssenceDescriptor::Copy(rhs);
3085   ResourceID = rhs.ResourceID;
3086   UCSEncoding = rhs.UCSEncoding;
3087   NamespaceURI = rhs.NamespaceURI;
3088   RFC5646LanguageTagList = rhs.RFC5646LanguageTagList;
3089 }
3090
3091 //
3092 void
3093 TimedTextDescriptor::Dump(FILE* stream)
3094 {
3095   char identbuf[IdentBufferLen];
3096   *identbuf = 0;
3097
3098   if ( stream == 0 )
3099     stream = stderr;
3100
3101   GenericDataEssenceDescriptor::Dump(stream);
3102   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
3103   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
3104   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
3105   if ( ! RFC5646LanguageTagList.empty() ) {
3106     fprintf(stream, "  %22s = %s\n",  "RFC5646LanguageTagList", RFC5646LanguageTagList.get().EncodeString(identbuf, IdentBufferLen));
3107   }
3108 }
3109
3110 //
3111 ASDCP::Result_t
3112 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3113 {
3114   return InterchangeObject::InitFromBuffer(p, l);
3115 }
3116
3117 //
3118 ASDCP::Result_t
3119 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3120 {
3121   return InterchangeObject::WriteToBuffer(Buffer);
3122 }
3123
3124 //------------------------------------------------------------------------------------------
3125 // TimedTextResourceSubDescriptor
3126
3127 //
3128
3129 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
3130 {
3131   assert(m_Dict);
3132   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
3133 }
3134
3135 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3136 {
3137   assert(m_Dict);
3138   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
3139   Copy(rhs);
3140 }
3141
3142
3143 //
3144 ASDCP::Result_t
3145 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3146 {
3147   assert(m_Dict);
3148   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3149   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
3150   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
3151   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
3152   return result;
3153 }
3154
3155 //
3156 ASDCP::Result_t
3157 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3158 {
3159   assert(m_Dict);
3160   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3161   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
3162   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
3163   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
3164   return result;
3165 }
3166
3167 //
3168 void
3169 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
3170 {
3171   InterchangeObject::Copy(rhs);
3172   AncillaryResourceID = rhs.AncillaryResourceID;
3173   MIMEMediaType = rhs.MIMEMediaType;
3174   EssenceStreamID = rhs.EssenceStreamID;
3175 }
3176
3177 //
3178 void
3179 TimedTextResourceSubDescriptor::Dump(FILE* stream)
3180 {
3181   char identbuf[IdentBufferLen];
3182   *identbuf = 0;
3183
3184   if ( stream == 0 )
3185     stream = stderr;
3186
3187   InterchangeObject::Dump(stream);
3188   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
3189   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
3190   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
3191 }
3192
3193 //
3194 ASDCP::Result_t
3195 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3196 {
3197   return InterchangeObject::InitFromBuffer(p, l);
3198 }
3199
3200 //
3201 ASDCP::Result_t
3202 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3203 {
3204   return InterchangeObject::WriteToBuffer(Buffer);
3205 }
3206
3207 //------------------------------------------------------------------------------------------
3208 // StereoscopicPictureSubDescriptor
3209
3210 //
3211
3212 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3213 {
3214   assert(m_Dict);
3215   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3216 }
3217
3218 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3219 {
3220   assert(m_Dict);
3221   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
3222   Copy(rhs);
3223 }
3224
3225
3226 //
3227 ASDCP::Result_t
3228 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3229 {
3230   assert(m_Dict);
3231   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3232   return result;
3233 }
3234
3235 //
3236 ASDCP::Result_t
3237 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3238 {
3239   assert(m_Dict);
3240   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3241   return result;
3242 }
3243
3244 //
3245 void
3246 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
3247 {
3248   InterchangeObject::Copy(rhs);
3249 }
3250
3251 //
3252 void
3253 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
3254 {
3255   char identbuf[IdentBufferLen];
3256   *identbuf = 0;
3257
3258   if ( stream == 0 )
3259     stream = stderr;
3260
3261   InterchangeObject::Dump(stream);
3262 }
3263
3264 //
3265 ASDCP::Result_t
3266 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3267 {
3268   return InterchangeObject::InitFromBuffer(p, l);
3269 }
3270
3271 //
3272 ASDCP::Result_t
3273 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3274 {
3275   return InterchangeObject::WriteToBuffer(Buffer);
3276 }
3277
3278 //------------------------------------------------------------------------------------------
3279 // ContainerConstraintSubDescriptor
3280
3281 //
3282
3283 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3284 {
3285   assert(m_Dict);
3286   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3287 }
3288
3289 ContainerConstraintSubDescriptor::ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3290 {
3291   assert(m_Dict);
3292   m_UL = m_Dict->ul(MDD_ContainerConstraintSubDescriptor);
3293   Copy(rhs);
3294 }
3295
3296
3297 //
3298 ASDCP::Result_t
3299 ContainerConstraintSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3300 {
3301   assert(m_Dict);
3302   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3303   return result;
3304 }
3305
3306 //
3307 ASDCP::Result_t
3308 ContainerConstraintSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3309 {
3310   assert(m_Dict);
3311   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3312   return result;
3313 }
3314
3315 //
3316 void
3317 ContainerConstraintSubDescriptor::Copy(const ContainerConstraintSubDescriptor& rhs)
3318 {
3319   InterchangeObject::Copy(rhs);
3320 }
3321
3322 //
3323 void
3324 ContainerConstraintSubDescriptor::Dump(FILE* stream)
3325 {
3326   char identbuf[IdentBufferLen];
3327   *identbuf = 0;
3328
3329   if ( stream == 0 )
3330     stream = stderr;
3331
3332   InterchangeObject::Dump(stream);
3333 }
3334
3335 //
3336 ASDCP::Result_t
3337 ContainerConstraintSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3338 {
3339   return InterchangeObject::InitFromBuffer(p, l);
3340 }
3341
3342 //
3343 ASDCP::Result_t
3344 ContainerConstraintSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3345 {
3346   return InterchangeObject::WriteToBuffer(Buffer);
3347 }
3348
3349 //------------------------------------------------------------------------------------------
3350 // NetworkLocator
3351
3352 //
3353
3354 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3355 {
3356   assert(m_Dict);
3357   m_UL = m_Dict->ul(MDD_NetworkLocator);
3358 }
3359
3360 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3361 {
3362   assert(m_Dict);
3363   m_UL = m_Dict->ul(MDD_NetworkLocator);
3364   Copy(rhs);
3365 }
3366
3367
3368 //
3369 ASDCP::Result_t
3370 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
3371 {
3372   assert(m_Dict);
3373   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3374   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
3375   return result;
3376 }
3377
3378 //
3379 ASDCP::Result_t
3380 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
3381 {
3382   assert(m_Dict);
3383   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3384   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
3385   return result;
3386 }
3387
3388 //
3389 void
3390 NetworkLocator::Copy(const NetworkLocator& rhs)
3391 {
3392   InterchangeObject::Copy(rhs);
3393   URLString = rhs.URLString;
3394 }
3395
3396 //
3397 void
3398 NetworkLocator::Dump(FILE* stream)
3399 {
3400   char identbuf[IdentBufferLen];
3401   *identbuf = 0;
3402
3403   if ( stream == 0 )
3404     stream = stderr;
3405
3406   InterchangeObject::Dump(stream);
3407   fprintf(stream, "  %22s = %s\n",  "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
3408 }
3409
3410 //
3411 ASDCP::Result_t
3412 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
3413 {
3414   return InterchangeObject::InitFromBuffer(p, l);
3415 }
3416
3417 //
3418 ASDCP::Result_t
3419 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3420 {
3421   return InterchangeObject::WriteToBuffer(Buffer);
3422 }
3423
3424 //------------------------------------------------------------------------------------------
3425 // MCALabelSubDescriptor
3426
3427 //
3428
3429 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
3430 {
3431   assert(m_Dict);
3432   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3433 }
3434
3435 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3436 {
3437   assert(m_Dict);
3438   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
3439   Copy(rhs);
3440 }
3441
3442
3443 //
3444 ASDCP::Result_t
3445 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3446 {
3447   assert(m_Dict);
3448   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
3449   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3450   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
3451   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3452   if ( ASDCP_SUCCESS(result) ) {
3453     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3454     MCATagName.set_has_value( result == RESULT_OK );
3455   }
3456   if ( ASDCP_SUCCESS(result) ) {
3457     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3458     MCAChannelID.set_has_value( result == RESULT_OK );
3459   }
3460   if ( ASDCP_SUCCESS(result) ) {
3461     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3462     RFC5646SpokenLanguage.set_has_value( result == RESULT_OK );
3463   }
3464   if ( ASDCP_SUCCESS(result) ) {
3465     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3466     MCATitle.set_has_value( result == RESULT_OK );
3467   }
3468   if ( ASDCP_SUCCESS(result) ) {
3469     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3470     MCATitleVersion.set_has_value( result == RESULT_OK );
3471   }
3472   if ( ASDCP_SUCCESS(result) ) {
3473     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3474     MCATitleSubVersion.set_has_value( result == RESULT_OK );
3475   }
3476   if ( ASDCP_SUCCESS(result) ) {
3477     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3478     MCAEpisode.set_has_value( result == RESULT_OK );
3479   }
3480   if ( ASDCP_SUCCESS(result) ) {
3481     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3482     MCAPartitionKind.set_has_value( result == RESULT_OK );
3483   }
3484   if ( ASDCP_SUCCESS(result) ) {
3485     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3486     MCAPartitionNumber.set_has_value( result == RESULT_OK );
3487   }
3488   if ( ASDCP_SUCCESS(result) ) {
3489     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3490     MCAAudioContentKind.set_has_value( result == RESULT_OK );
3491   }
3492   if ( ASDCP_SUCCESS(result) ) {
3493     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3494     MCAAudioElementKind.set_has_value( result == RESULT_OK );
3495   }
3496   return result;
3497 }
3498
3499 //
3500 ASDCP::Result_t
3501 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3502 {
3503   assert(m_Dict);
3504   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
3505   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
3506   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
3507   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
3508   if ( ASDCP_SUCCESS(result)  && ! MCATagName.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATagName));
3509   if ( ASDCP_SUCCESS(result)  && ! MCAChannelID.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAChannelID));
3510   if ( ASDCP_SUCCESS(result)  && ! RFC5646SpokenLanguage.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, RFC5646SpokenLanguage));
3511   if ( ASDCP_SUCCESS(result)  && ! MCATitle.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitle));
3512   if ( ASDCP_SUCCESS(result)  && ! MCATitleVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleVersion));
3513   if ( ASDCP_SUCCESS(result)  && ! MCATitleSubVersion.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCATitleSubVersion));
3514   if ( ASDCP_SUCCESS(result)  && ! MCAEpisode.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAEpisode));
3515   if ( ASDCP_SUCCESS(result)  && ! MCAPartitionKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionKind));
3516   if ( ASDCP_SUCCESS(result)  && ! MCAPartitionNumber.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAPartitionNumber));
3517   if ( ASDCP_SUCCESS(result)  && ! MCAAudioContentKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioContentKind));
3518   if ( ASDCP_SUCCESS(result)  && ! MCAAudioElementKind.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(MCALabelSubDescriptor, MCAAudioElementKind));
3519   return result;
3520 }
3521
3522 //
3523 void
3524 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
3525 {
3526   InterchangeObject::Copy(rhs);
3527   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
3528   MCALinkID = rhs.MCALinkID;
3529   MCATagSymbol = rhs.MCATagSymbol;
3530   MCATagName = rhs.MCATagName;
3531   MCAChannelID = rhs.MCAChannelID;
3532   RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
3533   MCATitle = rhs.MCATitle;
3534   MCATitleVersion = rhs.MCATitleVersion;
3535   MCATitleSubVersion = rhs.MCATitleSubVersion;
3536   MCAEpisode = rhs.MCAEpisode;
3537   MCAPartitionKind = rhs.MCAPartitionKind;
3538   MCAPartitionNumber = rhs.MCAPartitionNumber;
3539   MCAAudioContentKind = rhs.MCAAudioContentKind;
3540   MCAAudioElementKind = rhs.MCAAudioElementKind;
3541 }
3542
3543 //
3544 void
3545 MCALabelSubDescriptor::Dump(FILE* stream)
3546 {
3547   char identbuf[IdentBufferLen];
3548   *identbuf = 0;
3549
3550   if ( stream == 0 )
3551     stream = stderr;
3552
3553   InterchangeObject::Dump(stream);
3554   fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
3555   fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
3556   fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
3557   if ( ! MCATagName.empty() ) {
3558     fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.get().EncodeString(identbuf, IdentBufferLen));
3559   }
3560   if ( ! MCAChannelID.empty() ) {
3561     fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID.get());
3562   }
3563   if ( ! RFC5646SpokenLanguage.empty() ) {
3564     fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.get().EncodeString(identbuf, IdentBufferLen));
3565   }
3566   if ( ! MCATitle.empty() ) {
3567     fprintf(stream, "  %22s = %s\n",  "MCATitle", MCATitle.get().EncodeString(identbuf, IdentBufferLen));
3568   }
3569   if ( ! MCATitleVersion.empty() ) {
3570     fprintf(stream, "  %22s = %s\n",  "MCATitleVersion", MCATitleVersion.get().EncodeString(identbuf, IdentBufferLen));
3571   }
3572   if ( ! MCATitleSubVersion.empty() ) {
3573     fprintf(stream, "  %22s = %s\n",  "MCATitleSubVersion", MCATitleSubVersion.get().EncodeString(identbuf, IdentBufferLen));
3574   }
3575   if ( ! MCAEpisode.empty() ) {
3576     fprintf(stream, "  %22s = %s\n",  "MCAEpisode", MCAEpisode.get().EncodeString(identbuf, IdentBufferLen));
3577   }
3578   if ( ! MCAPartitionKind.empty() ) {
3579     fprintf(stream, "  %22s = %s\n",  "MCAPartitionKind", MCAPartitionKind.get().EncodeString(identbuf, IdentBufferLen));
3580   }
3581   if ( ! MCAPartitionNumber.empty() ) {
3582     fprintf(stream, "  %22s = %s\n",  "MCAPartitionNumber", MCAPartitionNumber.get().EncodeString(identbuf, IdentBufferLen));
3583   }
3584   if ( ! MCAAudioContentKind.empty() ) {
3585     fprintf(stream, "  %22s = %s\n",  "MCAAudioContentKind", MCAAudioContentKind.get().EncodeString(identbuf, IdentBufferLen));
3586   }
3587   if ( ! MCAAudioElementKind.empty() ) {
3588     fprintf(stream, "  %22s = %s\n",  "MCAAudioElementKind", MCAAudioElementKind.get().EncodeString(identbuf, IdentBufferLen));
3589   }
3590 }
3591
3592 //
3593 ASDCP::Result_t
3594 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3595 {
3596   return InterchangeObject::InitFromBuffer(p, l);
3597 }
3598
3599 //
3600 ASDCP::Result_t
3601 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3602 {
3603   return InterchangeObject::WriteToBuffer(Buffer);
3604 }
3605
3606 //------------------------------------------------------------------------------------------
3607 // AudioChannelLabelSubDescriptor
3608
3609 //
3610
3611 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3612 {
3613   assert(m_Dict);
3614   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3615 }
3616
3617 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3618 {
3619   assert(m_Dict);
3620   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
3621   Copy(rhs);
3622 }
3623
3624
3625 //
3626 ASDCP::Result_t
3627 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3628 {
3629   assert(m_Dict);
3630   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3631   if ( ASDCP_SUCCESS(result) ) {
3632     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3633     SoundfieldGroupLinkID.set_has_value( result == RESULT_OK );
3634   }
3635   return result;
3636 }
3637
3638 //
3639 ASDCP::Result_t
3640 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3641 {
3642   assert(m_Dict);
3643   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3644   if ( ASDCP_SUCCESS(result)  && ! SoundfieldGroupLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
3645   return result;
3646 }
3647
3648 //
3649 void
3650 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
3651 {
3652   MCALabelSubDescriptor::Copy(rhs);
3653   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
3654 }
3655
3656 //
3657 void
3658 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
3659 {
3660   char identbuf[IdentBufferLen];
3661   *identbuf = 0;
3662
3663   if ( stream == 0 )
3664     stream = stderr;
3665
3666   MCALabelSubDescriptor::Dump(stream);
3667   if ( ! SoundfieldGroupLinkID.empty() ) {
3668     fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.get().EncodeString(identbuf, IdentBufferLen));
3669   }
3670 }
3671
3672 //
3673 ASDCP::Result_t
3674 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3675 {
3676   return InterchangeObject::InitFromBuffer(p, l);
3677 }
3678
3679 //
3680 ASDCP::Result_t
3681 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3682 {
3683   return InterchangeObject::WriteToBuffer(Buffer);
3684 }
3685
3686 //------------------------------------------------------------------------------------------
3687 // SoundfieldGroupLabelSubDescriptor
3688
3689 //
3690
3691 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3692 {
3693   assert(m_Dict);
3694   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3695 }
3696
3697 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3698 {
3699   assert(m_Dict);
3700   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
3701   Copy(rhs);
3702 }
3703
3704
3705 //
3706 ASDCP::Result_t
3707 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3708 {
3709   assert(m_Dict);
3710   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3711   if ( ASDCP_SUCCESS(result) ) {
3712     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3713   }
3714   return result;
3715 }
3716
3717 //
3718 ASDCP::Result_t
3719 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3720 {
3721   assert(m_Dict);
3722   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3723   if ( ASDCP_SUCCESS(result)  && ! GroupOfSoundfieldGroupsLinkID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
3724   return result;
3725 }
3726
3727 //
3728 void
3729 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
3730 {
3731   MCALabelSubDescriptor::Copy(rhs);
3732   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
3733 }
3734
3735 //
3736 void
3737 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
3738 {
3739   char identbuf[IdentBufferLen];
3740   *identbuf = 0;
3741
3742   if ( stream == 0 )
3743     stream = stderr;
3744
3745   MCALabelSubDescriptor::Dump(stream);
3746   if ( ! GroupOfSoundfieldGroupsLinkID.empty() ) {
3747     fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
3748   GroupOfSoundfieldGroupsLinkID.get().Dump(stream);
3749   }
3750 }
3751
3752 //
3753 ASDCP::Result_t
3754 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3755 {
3756   return InterchangeObject::InitFromBuffer(p, l);
3757 }
3758
3759 //
3760 ASDCP::Result_t
3761 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3762 {
3763   return InterchangeObject::WriteToBuffer(Buffer);
3764 }
3765
3766 //------------------------------------------------------------------------------------------
3767 // GroupOfSoundfieldGroupsLabelSubDescriptor
3768
3769 //
3770
3771 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
3772 {
3773   assert(m_Dict);
3774   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3775 }
3776
3777 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3778 {
3779   assert(m_Dict);
3780   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
3781   Copy(rhs);
3782 }
3783
3784
3785 //
3786 ASDCP::Result_t
3787 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3788 {
3789   assert(m_Dict);
3790   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
3791   return result;
3792 }
3793
3794 //
3795 ASDCP::Result_t
3796 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3797 {
3798   assert(m_Dict);
3799   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
3800   return result;
3801 }
3802
3803 //
3804 void
3805 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
3806 {
3807   MCALabelSubDescriptor::Copy(rhs);
3808 }
3809
3810 //
3811 void
3812 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
3813 {
3814   char identbuf[IdentBufferLen];
3815   *identbuf = 0;
3816
3817   if ( stream == 0 )
3818     stream = stderr;
3819
3820   MCALabelSubDescriptor::Dump(stream);
3821 }
3822
3823 //
3824 ASDCP::Result_t
3825 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3826 {
3827   return InterchangeObject::InitFromBuffer(p, l);
3828 }
3829
3830 //
3831 ASDCP::Result_t
3832 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3833 {
3834   return InterchangeObject::WriteToBuffer(Buffer);
3835 }
3836
3837 //------------------------------------------------------------------------------------------
3838 // DCDataDescriptor
3839
3840 //
3841
3842 DCDataDescriptor::DCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3843 {
3844   assert(m_Dict);
3845   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3846 }
3847
3848 DCDataDescriptor::DCDataDescriptor(const DCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3849 {
3850   assert(m_Dict);
3851   m_UL = m_Dict->ul(MDD_DCDataDescriptor);
3852   Copy(rhs);
3853 }
3854
3855
3856 //
3857 ASDCP::Result_t
3858 DCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3859 {
3860   assert(m_Dict);
3861   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3862   return result;
3863 }
3864
3865 //
3866 ASDCP::Result_t
3867 DCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3868 {
3869   assert(m_Dict);
3870   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3871   return result;
3872 }
3873
3874 //
3875 void
3876 DCDataDescriptor::Copy(const DCDataDescriptor& rhs)
3877 {
3878   GenericDataEssenceDescriptor::Copy(rhs);
3879 }
3880
3881 //
3882 void
3883 DCDataDescriptor::Dump(FILE* stream)
3884 {
3885   char identbuf[IdentBufferLen];
3886   *identbuf = 0;
3887
3888   if ( stream == 0 )
3889     stream = stderr;
3890
3891   GenericDataEssenceDescriptor::Dump(stream);
3892 }
3893
3894 //
3895 ASDCP::Result_t
3896 DCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3897 {
3898   return InterchangeObject::InitFromBuffer(p, l);
3899 }
3900
3901 //
3902 ASDCP::Result_t
3903 DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3904 {
3905   return InterchangeObject::WriteToBuffer(Buffer);
3906 }
3907
3908 //------------------------------------------------------------------------------------------
3909 // PrivateDCDataDescriptor
3910
3911 //
3912
3913 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
3914 {
3915   assert(m_Dict);
3916   m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3917 }
3918
3919 PrivateDCDataDescriptor::PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
3920 {
3921   assert(m_Dict);
3922   m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
3923   Copy(rhs);
3924 }
3925
3926
3927 //
3928 ASDCP::Result_t
3929 PrivateDCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
3930 {
3931   assert(m_Dict);
3932   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
3933   return result;
3934 }
3935
3936 //
3937 ASDCP::Result_t
3938 PrivateDCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
3939 {
3940   assert(m_Dict);
3941   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
3942   return result;
3943 }
3944
3945 //
3946 void
3947 PrivateDCDataDescriptor::Copy(const PrivateDCDataDescriptor& rhs)
3948 {
3949   GenericDataEssenceDescriptor::Copy(rhs);
3950 }
3951
3952 //
3953 void
3954 PrivateDCDataDescriptor::Dump(FILE* stream)
3955 {
3956   char identbuf[IdentBufferLen];
3957   *identbuf = 0;
3958
3959   if ( stream == 0 )
3960     stream = stderr;
3961
3962   GenericDataEssenceDescriptor::Dump(stream);
3963 }
3964
3965 //
3966 ASDCP::Result_t
3967 PrivateDCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
3968 {
3969   return InterchangeObject::InitFromBuffer(p, l);
3970 }
3971
3972 //
3973 ASDCP::Result_t
3974 PrivateDCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
3975 {
3976   return InterchangeObject::WriteToBuffer(Buffer);
3977 }
3978
3979 //------------------------------------------------------------------------------------------
3980 // DolbyAtmosSubDescriptor
3981
3982 //
3983
3984 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), FirstFrame(0), MaxChannelCount(0), MaxObjectCount(0), AtmosVersion(0)
3985 {
3986   assert(m_Dict);
3987   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3988 }
3989
3990 DolbyAtmosSubDescriptor::DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
3991 {
3992   assert(m_Dict);
3993   m_UL = m_Dict->ul(MDD_DolbyAtmosSubDescriptor);
3994   Copy(rhs);
3995 }
3996
3997
3998 //
3999 ASDCP::Result_t
4000 DolbyAtmosSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4001 {
4002   assert(m_Dict);
4003   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4004   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosID));
4005   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
4006   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
4007   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
4008   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
4009   return result;
4010 }
4011
4012 //
4013 ASDCP::Result_t
4014 DolbyAtmosSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4015 {
4016   assert(m_Dict);
4017   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4018   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosID));
4019   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, FirstFrame));
4020   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxChannelCount));
4021   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, MaxObjectCount));
4022   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(DolbyAtmosSubDescriptor, AtmosVersion));
4023   return result;
4024 }
4025
4026 //
4027 void
4028 DolbyAtmosSubDescriptor::Copy(const DolbyAtmosSubDescriptor& rhs)
4029 {
4030   InterchangeObject::Copy(rhs);
4031   AtmosID = rhs.AtmosID;
4032   FirstFrame = rhs.FirstFrame;
4033   MaxChannelCount = rhs.MaxChannelCount;
4034   MaxObjectCount = rhs.MaxObjectCount;
4035   AtmosVersion = rhs.AtmosVersion;
4036 }
4037
4038 //
4039 void
4040 DolbyAtmosSubDescriptor::Dump(FILE* stream)
4041 {
4042   char identbuf[IdentBufferLen];
4043   *identbuf = 0;
4044
4045   if ( stream == 0 )
4046     stream = stderr;
4047
4048   InterchangeObject::Dump(stream);
4049   fprintf(stream, "  %22s = %s\n",  "AtmosID", AtmosID.EncodeString(identbuf, IdentBufferLen));
4050   fprintf(stream, "  %22s = %d\n",  "FirstFrame", FirstFrame);
4051   fprintf(stream, "  %22s = %d\n",  "MaxChannelCount", MaxChannelCount);
4052   fprintf(stream, "  %22s = %d\n",  "MaxObjectCount", MaxObjectCount);
4053   fprintf(stream, "  %22s = %d\n",  "AtmosVersion", AtmosVersion);
4054 }
4055
4056 //
4057 ASDCP::Result_t
4058 DolbyAtmosSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4059 {
4060   return InterchangeObject::InitFromBuffer(p, l);
4061 }
4062
4063 //
4064 ASDCP::Result_t
4065 DolbyAtmosSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4066 {
4067   return InterchangeObject::WriteToBuffer(Buffer);
4068 }
4069
4070 //------------------------------------------------------------------------------------------
4071 // ACESPictureSubDescriptor
4072
4073 //
4074
4075 ACESPictureSubDescriptor::ACESPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
4076 {
4077   assert(m_Dict);
4078   m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
4079 }
4080
4081 ACESPictureSubDescriptor::ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4082 {
4083   assert(m_Dict);
4084   m_UL = m_Dict->ul(MDD_ACESPictureSubDescriptor);
4085   Copy(rhs);
4086 }
4087
4088
4089 //
4090 ASDCP::Result_t
4091 ACESPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4092 {
4093   assert(m_Dict);
4094   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4095   if ( ASDCP_SUCCESS(result) ) {
4096     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
4097     ACESAuthoringInformation.set_has_value( result == RESULT_OK );
4098   }
4099   if ( ASDCP_SUCCESS(result) ) {
4100     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
4101     ACESMasteringDisplayPrimaries.set_has_value( result == RESULT_OK );
4102   }
4103   if ( ASDCP_SUCCESS(result) ) {
4104     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
4105     ACESMasteringDisplayWhitePointChromaticity.set_has_value( result == RESULT_OK );
4106   }
4107   if ( ASDCP_SUCCESS(result) ) {
4108     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
4109     ACESMasteringDisplayMaximumLuminance.set_has_value( result == RESULT_OK );
4110   }
4111   if ( ASDCP_SUCCESS(result) ) {
4112     result = TLVSet.ReadUi32(OBJ_READ_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
4113     ACESMasteringDisplayMinimumLuminance.set_has_value( result == RESULT_OK );
4114   }
4115   return result;
4116 }
4117
4118 //
4119 ASDCP::Result_t
4120 ACESPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4121 {
4122   assert(m_Dict);
4123   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4124   if ( ASDCP_SUCCESS(result)  && ! ACESAuthoringInformation.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESAuthoringInformation));
4125   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayPrimaries.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayPrimaries));
4126   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayWhitePointChromaticity.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayWhitePointChromaticity));
4127   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayMaximumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMaximumLuminance));
4128   if ( ASDCP_SUCCESS(result)  && ! ACESMasteringDisplayMinimumLuminance.empty() ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS_OPT(ACESPictureSubDescriptor, ACESMasteringDisplayMinimumLuminance));
4129   return result;
4130 }
4131
4132 //
4133 void
4134 ACESPictureSubDescriptor::Copy(const ACESPictureSubDescriptor& rhs)
4135 {
4136   InterchangeObject::Copy(rhs);
4137   ACESAuthoringInformation = rhs.ACESAuthoringInformation;
4138   ACESMasteringDisplayPrimaries = rhs.ACESMasteringDisplayPrimaries;
4139   ACESMasteringDisplayWhitePointChromaticity = rhs.ACESMasteringDisplayWhitePointChromaticity;
4140   ACESMasteringDisplayMaximumLuminance = rhs.ACESMasteringDisplayMaximumLuminance;
4141   ACESMasteringDisplayMinimumLuminance = rhs.ACESMasteringDisplayMinimumLuminance;
4142 }
4143
4144 //
4145 void
4146 ACESPictureSubDescriptor::Dump(FILE* stream)
4147 {
4148   char identbuf[IdentBufferLen];
4149   *identbuf = 0;
4150
4151   if ( stream == 0 )
4152     stream = stderr;
4153
4154   InterchangeObject::Dump(stream);
4155   if ( ! ACESAuthoringInformation.empty() ) {
4156     fprintf(stream, "  %22s = %s\n",  "ACESAuthoringInformation", ACESAuthoringInformation.get().EncodeString(identbuf, IdentBufferLen));
4157   }
4158   if ( ! ACESMasteringDisplayPrimaries.empty() ) {
4159     fprintf(stream, "  %22s = %s\n",  "ACESMasteringDisplayPrimaries", ACESMasteringDisplayPrimaries.get().EncodeString(identbuf, IdentBufferLen));
4160   }
4161   if ( ! ACESMasteringDisplayWhitePointChromaticity.empty() ) {
4162     fprintf(stream, "  %22s = %s\n",  "ACESMasteringDisplayWhitePointChromaticity", ACESMasteringDisplayWhitePointChromaticity.get().EncodeString(identbuf, IdentBufferLen));
4163   }
4164   if ( ! ACESMasteringDisplayMaximumLuminance.empty() ) {
4165     fprintf(stream, "  %22s = %d\n",  "ACESMasteringDisplayMaximumLuminance", ACESMasteringDisplayMaximumLuminance.get());
4166   }
4167   if ( ! ACESMasteringDisplayMinimumLuminance.empty() ) {
4168     fprintf(stream, "  %22s = %d\n",  "ACESMasteringDisplayMinimumLuminance", ACESMasteringDisplayMinimumLuminance.get());
4169   }
4170 }
4171
4172 //
4173 ASDCP::Result_t
4174 ACESPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4175 {
4176   return InterchangeObject::InitFromBuffer(p, l);
4177 }
4178
4179 //
4180 ASDCP::Result_t
4181 ACESPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4182 {
4183   return InterchangeObject::WriteToBuffer(Buffer);
4184 }
4185
4186 //------------------------------------------------------------------------------------------
4187 // TargetFrameSubDescriptor
4188
4189 //
4190
4191 TargetFrameSubDescriptor::TargetFrameSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TargetFrameIndex(0), TargetFrameComponentMaxRef(0), TargetFrameComponentMinRef(0), TargetFrameEssenceStreamID(0)
4192 {
4193   assert(m_Dict);
4194   m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
4195 }
4196
4197 TargetFrameSubDescriptor::TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4198 {
4199   assert(m_Dict);
4200   m_UL = m_Dict->ul(MDD_TargetFrameSubDescriptor);
4201   Copy(rhs);
4202 }
4203
4204
4205 //
4206 ASDCP::Result_t
4207 TargetFrameSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4208 {
4209   assert(m_Dict);
4210   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4211   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
4212   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, MediaType));
4213   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
4214   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
4215   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
4216   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
4217   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
4218   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
4219   if ( ASDCP_SUCCESS(result) ) {
4220     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
4221     ACESPictureSubDescriptorInstanceID.set_has_value( result == RESULT_OK );
4222   }
4223   if ( ASDCP_SUCCESS(result) ) {
4224     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
4225     TargetFrameViewingEnvironment.set_has_value( result == RESULT_OK );
4226   }
4227   return result;
4228 }
4229
4230 //
4231 ASDCP::Result_t
4232 TargetFrameSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4233 {
4234   assert(m_Dict);
4235   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4236   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameAncillaryResourceID));
4237   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, MediaType));
4238   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameIndex));
4239   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameTransferCharacteristic));
4240   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameColorPrimaries));
4241   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMaxRef));
4242   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameComponentMinRef));
4243   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TargetFrameSubDescriptor, TargetFrameEssenceStreamID));
4244   if ( ASDCP_SUCCESS(result)  && ! ACESPictureSubDescriptorInstanceID.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, ACESPictureSubDescriptorInstanceID));
4245   if ( ASDCP_SUCCESS(result)  && ! TargetFrameViewingEnvironment.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TargetFrameSubDescriptor, TargetFrameViewingEnvironment));
4246   return result;
4247 }
4248
4249 //
4250 void
4251 TargetFrameSubDescriptor::Copy(const TargetFrameSubDescriptor& rhs)
4252 {
4253   InterchangeObject::Copy(rhs);
4254   TargetFrameAncillaryResourceID = rhs.TargetFrameAncillaryResourceID;
4255   MediaType = rhs.MediaType;
4256   TargetFrameIndex = rhs.TargetFrameIndex;
4257   TargetFrameTransferCharacteristic = rhs.TargetFrameTransferCharacteristic;
4258   TargetFrameColorPrimaries = rhs.TargetFrameColorPrimaries;
4259   TargetFrameComponentMaxRef = rhs.TargetFrameComponentMaxRef;
4260   TargetFrameComponentMinRef = rhs.TargetFrameComponentMinRef;
4261   TargetFrameEssenceStreamID = rhs.TargetFrameEssenceStreamID;
4262   ACESPictureSubDescriptorInstanceID = rhs.ACESPictureSubDescriptorInstanceID;
4263   TargetFrameViewingEnvironment = rhs.TargetFrameViewingEnvironment;
4264 }
4265
4266 //
4267 void
4268 TargetFrameSubDescriptor::Dump(FILE* stream)
4269 {
4270   char identbuf[IdentBufferLen];
4271   *identbuf = 0;
4272
4273   if ( stream == 0 )
4274     stream = stderr;
4275
4276   InterchangeObject::Dump(stream);
4277   fprintf(stream, "  %22s = %s\n",  "TargetFrameAncillaryResourceID", TargetFrameAncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
4278   fprintf(stream, "  %22s = %s\n",  "MediaType", MediaType.EncodeString(identbuf, IdentBufferLen));
4279   fprintf(stream, "  %22s = %s\n",  "TargetFrameIndex", i64sz(TargetFrameIndex, identbuf));
4280   fprintf(stream, "  %22s = %s\n",  "TargetFrameTransferCharacteristic", TargetFrameTransferCharacteristic.EncodeString(identbuf, IdentBufferLen));
4281   fprintf(stream, "  %22s = %s\n",  "TargetFrameColorPrimaries", TargetFrameColorPrimaries.EncodeString(identbuf, IdentBufferLen));
4282   fprintf(stream, "  %22s = %d\n",  "TargetFrameComponentMaxRef", TargetFrameComponentMaxRef);
4283   fprintf(stream, "  %22s = %d\n",  "TargetFrameComponentMinRef", TargetFrameComponentMinRef);
4284   fprintf(stream, "  %22s = %d\n",  "TargetFrameEssenceStreamID", TargetFrameEssenceStreamID);
4285   if ( ! ACESPictureSubDescriptorInstanceID.empty() ) {
4286     fprintf(stream, "  %22s = %s\n",  "ACESPictureSubDescriptorInstanceID", ACESPictureSubDescriptorInstanceID.get().EncodeString(identbuf, IdentBufferLen));
4287   }
4288   if ( ! TargetFrameViewingEnvironment.empty() ) {
4289     fprintf(stream, "  %22s = %s\n",  "TargetFrameViewingEnvironment", TargetFrameViewingEnvironment.get().EncodeString(identbuf, IdentBufferLen));
4290   }
4291 }
4292
4293 //
4294 ASDCP::Result_t
4295 TargetFrameSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4296 {
4297   return InterchangeObject::InitFromBuffer(p, l);
4298 }
4299
4300 //
4301 ASDCP::Result_t
4302 TargetFrameSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4303 {
4304   return InterchangeObject::WriteToBuffer(Buffer);
4305 }
4306
4307 //------------------------------------------------------------------------------------------
4308 // TextBasedDMFramework
4309
4310 //
4311
4312 TextBasedDMFramework::TextBasedDMFramework(const Dictionary*& d) : DescriptiveFramework(d), m_Dict(d)
4313 {
4314   assert(m_Dict);
4315   m_UL = m_Dict->ul(MDD_TextBasedDMFramework);
4316 }
4317
4318 TextBasedDMFramework::TextBasedDMFramework(const TextBasedDMFramework& rhs) : DescriptiveFramework(rhs.m_Dict), m_Dict(rhs.m_Dict)
4319 {
4320   assert(m_Dict);
4321   m_UL = m_Dict->ul(MDD_TextBasedDMFramework);
4322   Copy(rhs);
4323 }
4324
4325
4326 //
4327 ASDCP::Result_t
4328 TextBasedDMFramework::InitFromTLVSet(TLVReader& TLVSet)
4329 {
4330   assert(m_Dict);
4331   Result_t result = DescriptiveFramework::InitFromTLVSet(TLVSet);
4332   if ( ASDCP_SUCCESS(result) ) {
4333     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TextBasedDMFramework, ObjectRef));
4334     ObjectRef.set_has_value( result == RESULT_OK );
4335   }
4336   return result;
4337 }
4338
4339 //
4340 ASDCP::Result_t
4341 TextBasedDMFramework::WriteToTLVSet(TLVWriter& TLVSet)
4342 {
4343   assert(m_Dict);
4344   Result_t result = DescriptiveFramework::WriteToTLVSet(TLVSet);
4345   if ( ASDCP_SUCCESS(result)  && ! ObjectRef.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TextBasedDMFramework, ObjectRef));
4346   return result;
4347 }
4348
4349 //
4350 void
4351 TextBasedDMFramework::Copy(const TextBasedDMFramework& rhs)
4352 {
4353   DescriptiveFramework::Copy(rhs);
4354   ObjectRef = rhs.ObjectRef;
4355 }
4356
4357 //
4358 void
4359 TextBasedDMFramework::Dump(FILE* stream)
4360 {
4361   char identbuf[IdentBufferLen];
4362   *identbuf = 0;
4363
4364   if ( stream == 0 )
4365     stream = stderr;
4366
4367   DescriptiveFramework::Dump(stream);
4368   if ( ! ObjectRef.empty() ) {
4369     fprintf(stream, "  %22s = %s\n",  "ObjectRef", ObjectRef.get().EncodeString(identbuf, IdentBufferLen));
4370   }
4371 }
4372
4373 //
4374 ASDCP::Result_t
4375 TextBasedDMFramework::InitFromBuffer(const byte_t* p, ui32_t l)
4376 {
4377   return InterchangeObject::InitFromBuffer(p, l);
4378 }
4379
4380 //
4381 ASDCP::Result_t
4382 TextBasedDMFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4383 {
4384   return InterchangeObject::WriteToBuffer(Buffer);
4385 }
4386
4387 //------------------------------------------------------------------------------------------
4388 // TextBasedObject
4389
4390 //
4391
4392 TextBasedObject::TextBasedObject(const Dictionary*& d) : DescriptiveObject(d), m_Dict(d)
4393 {
4394   assert(m_Dict);
4395   m_UL = m_Dict->ul(MDD_TextBasedObject);
4396 }
4397
4398 TextBasedObject::TextBasedObject(const TextBasedObject& rhs) : DescriptiveObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4399 {
4400   assert(m_Dict);
4401   m_UL = m_Dict->ul(MDD_TextBasedObject);
4402   Copy(rhs);
4403 }
4404
4405
4406 //
4407 ASDCP::Result_t
4408 TextBasedObject::InitFromTLVSet(TLVReader& TLVSet)
4409 {
4410   assert(m_Dict);
4411   Result_t result = DescriptiveObject::InitFromTLVSet(TLVSet);
4412   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, PayloadSchemeID));
4413   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, TextMIMEMediaType));
4414   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TextBasedObject, RFC5646TextLanguageCode));
4415   if ( ASDCP_SUCCESS(result) ) {
4416     result = TLVSet.ReadObject(OBJ_READ_ARGS_OPT(TextBasedObject, TextDataDescription));
4417     TextDataDescription.set_has_value( result == RESULT_OK );
4418   }
4419   return result;
4420 }
4421
4422 //
4423 ASDCP::Result_t
4424 TextBasedObject::WriteToTLVSet(TLVWriter& TLVSet)
4425 {
4426   assert(m_Dict);
4427   Result_t result = DescriptiveObject::WriteToTLVSet(TLVSet);
4428   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, PayloadSchemeID));
4429   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, TextMIMEMediaType));
4430   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TextBasedObject, RFC5646TextLanguageCode));
4431   if ( ASDCP_SUCCESS(result)  && ! TextDataDescription.empty() ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS_OPT(TextBasedObject, TextDataDescription));
4432   return result;
4433 }
4434
4435 //
4436 void
4437 TextBasedObject::Copy(const TextBasedObject& rhs)
4438 {
4439   DescriptiveObject::Copy(rhs);
4440   PayloadSchemeID = rhs.PayloadSchemeID;
4441   TextMIMEMediaType = rhs.TextMIMEMediaType;
4442   RFC5646TextLanguageCode = rhs.RFC5646TextLanguageCode;
4443   TextDataDescription = rhs.TextDataDescription;
4444 }
4445
4446 //
4447 void
4448 TextBasedObject::Dump(FILE* stream)
4449 {
4450   char identbuf[IdentBufferLen];
4451   *identbuf = 0;
4452
4453   if ( stream == 0 )
4454     stream = stderr;
4455
4456   DescriptiveObject::Dump(stream);
4457   fprintf(stream, "  %22s = %s\n",  "PayloadSchemeID", PayloadSchemeID.EncodeString(identbuf, IdentBufferLen));
4458   fprintf(stream, "  %22s = %s\n",  "TextMIMEMediaType", TextMIMEMediaType.EncodeString(identbuf, IdentBufferLen));
4459   fprintf(stream, "  %22s = %s\n",  "RFC5646TextLanguageCode", RFC5646TextLanguageCode.EncodeString(identbuf, IdentBufferLen));
4460   if ( ! TextDataDescription.empty() ) {
4461     fprintf(stream, "  %22s = %s\n",  "TextDataDescription", TextDataDescription.get().EncodeString(identbuf, IdentBufferLen));
4462   }
4463 }
4464
4465 //
4466 ASDCP::Result_t
4467 TextBasedObject::InitFromBuffer(const byte_t* p, ui32_t l)
4468 {
4469   return InterchangeObject::InitFromBuffer(p, l);
4470 }
4471
4472 //
4473 ASDCP::Result_t
4474 TextBasedObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4475 {
4476   return InterchangeObject::WriteToBuffer(Buffer);
4477 }
4478
4479 //------------------------------------------------------------------------------------------
4480 // GenericStreamTextBasedSet
4481
4482 //
4483
4484 GenericStreamTextBasedSet::GenericStreamTextBasedSet(const Dictionary*& d) : TextBasedObject(d), m_Dict(d), GenericStreamSID(0)
4485 {
4486   assert(m_Dict);
4487   m_UL = m_Dict->ul(MDD_GenericStreamTextBasedSet);
4488 }
4489
4490 GenericStreamTextBasedSet::GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs) : TextBasedObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4491 {
4492   assert(m_Dict);
4493   m_UL = m_Dict->ul(MDD_GenericStreamTextBasedSet);
4494   Copy(rhs);
4495 }
4496
4497
4498 //
4499 ASDCP::Result_t
4500 GenericStreamTextBasedSet::InitFromTLVSet(TLVReader& TLVSet)
4501 {
4502   assert(m_Dict);
4503   Result_t result = TextBasedObject::InitFromTLVSet(TLVSet);
4504   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericStreamTextBasedSet, GenericStreamSID));
4505   return result;
4506 }
4507
4508 //
4509 ASDCP::Result_t
4510 GenericStreamTextBasedSet::WriteToTLVSet(TLVWriter& TLVSet)
4511 {
4512   assert(m_Dict);
4513   Result_t result = TextBasedObject::WriteToTLVSet(TLVSet);
4514   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericStreamTextBasedSet, GenericStreamSID));
4515   return result;
4516 }
4517
4518 //
4519 void
4520 GenericStreamTextBasedSet::Copy(const GenericStreamTextBasedSet& rhs)
4521 {
4522   TextBasedObject::Copy(rhs);
4523   GenericStreamSID = rhs.GenericStreamSID;
4524 }
4525
4526 //
4527 void
4528 GenericStreamTextBasedSet::Dump(FILE* stream)
4529 {
4530   char identbuf[IdentBufferLen];
4531   *identbuf = 0;
4532
4533   if ( stream == 0 )
4534     stream = stderr;
4535
4536   TextBasedObject::Dump(stream);
4537   fprintf(stream, "  %22s = %d\n",  "GenericStreamSID", GenericStreamSID);
4538 }
4539
4540 //
4541 ASDCP::Result_t
4542 GenericStreamTextBasedSet::InitFromBuffer(const byte_t* p, ui32_t l)
4543 {
4544   return InterchangeObject::InitFromBuffer(p, l);
4545 }
4546
4547 //
4548 ASDCP::Result_t
4549 GenericStreamTextBasedSet::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4550 {
4551   return InterchangeObject::WriteToBuffer(Buffer);
4552 }
4553
4554 //------------------------------------------------------------------------------------------
4555 // ISXDDataEssenceDescriptor
4556
4557 //
4558
4559 ISXDDataEssenceDescriptor::ISXDDataEssenceDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
4560 {
4561   assert(m_Dict);
4562   m_UL = m_Dict->ul(MDD_ISXDDataEssenceDescriptor);
4563 }
4564
4565 ISXDDataEssenceDescriptor::ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
4566 {
4567   assert(m_Dict);
4568   m_UL = m_Dict->ul(MDD_ISXDDataEssenceDescriptor);
4569   Copy(rhs);
4570 }
4571
4572
4573 //
4574 ASDCP::Result_t
4575 ISXDDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4576 {
4577   assert(m_Dict);
4578   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
4579   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ISXDDataEssenceDescriptor, NamespaceURI));
4580   return result;
4581 }
4582
4583 //
4584 ASDCP::Result_t
4585 ISXDDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4586 {
4587   assert(m_Dict);
4588   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4589   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ISXDDataEssenceDescriptor, NamespaceURI));
4590   return result;
4591 }
4592
4593 //
4594 void
4595 ISXDDataEssenceDescriptor::Copy(const ISXDDataEssenceDescriptor& rhs)
4596 {
4597   GenericDataEssenceDescriptor::Copy(rhs);
4598   NamespaceURI = rhs.NamespaceURI;
4599 }
4600
4601 //
4602 void
4603 ISXDDataEssenceDescriptor::Dump(FILE* stream)
4604 {
4605   char identbuf[IdentBufferLen];
4606   *identbuf = 0;
4607
4608   if ( stream == 0 )
4609     stream = stderr;
4610
4611   GenericDataEssenceDescriptor::Dump(stream);
4612   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
4613 }
4614
4615 //
4616 ASDCP::Result_t
4617 ISXDDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4618 {
4619   return InterchangeObject::InitFromBuffer(p, l);
4620 }
4621
4622 //
4623 ASDCP::Result_t
4624 ISXDDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4625 {
4626   return InterchangeObject::WriteToBuffer(Buffer);
4627 }
4628
4629 //------------------------------------------------------------------------------------------
4630 // PHDRMetadataTrackSubDescriptor
4631
4632 //
4633
4634 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), SourceTrackID(0), SimplePayloadSID(0)
4635 {
4636   assert(m_Dict);
4637   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
4638 }
4639
4640 PHDRMetadataTrackSubDescriptor::PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
4641 {
4642   assert(m_Dict);
4643   m_UL = m_Dict->ul(MDD_PHDRMetadataTrackSubDescriptor);
4644   Copy(rhs);
4645 }
4646
4647
4648 //
4649 ASDCP::Result_t
4650 PHDRMetadataTrackSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4651 {
4652   assert(m_Dict);
4653   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
4654   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
4655   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
4656   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
4657   return result;
4658 }
4659
4660 //
4661 ASDCP::Result_t
4662 PHDRMetadataTrackSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4663 {
4664   assert(m_Dict);
4665   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
4666   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, DataDefinition));
4667   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SourceTrackID));
4668   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PHDRMetadataTrackSubDescriptor, SimplePayloadSID));
4669   return result;
4670 }
4671
4672 //
4673 void
4674 PHDRMetadataTrackSubDescriptor::Copy(const PHDRMetadataTrackSubDescriptor& rhs)
4675 {
4676   InterchangeObject::Copy(rhs);
4677   DataDefinition = rhs.DataDefinition;
4678   SourceTrackID = rhs.SourceTrackID;
4679   SimplePayloadSID = rhs.SimplePayloadSID;
4680 }
4681
4682 //
4683 void
4684 PHDRMetadataTrackSubDescriptor::Dump(FILE* stream)
4685 {
4686   char identbuf[IdentBufferLen];
4687   *identbuf = 0;
4688
4689   if ( stream == 0 )
4690     stream = stderr;
4691
4692   InterchangeObject::Dump(stream);
4693   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
4694   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
4695   fprintf(stream, "  %22s = %d\n",  "SimplePayloadSID", SimplePayloadSID);
4696 }
4697
4698 //
4699 ASDCP::Result_t
4700 PHDRMetadataTrackSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4701 {
4702   return InterchangeObject::InitFromBuffer(p, l);
4703 }
4704
4705 //
4706 ASDCP::Result_t
4707 PHDRMetadataTrackSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4708 {
4709   return InterchangeObject::WriteToBuffer(Buffer);
4710 }
4711
4712 //------------------------------------------------------------------------------------------
4713 // PIMFDynamicMetadataDescriptor
4714
4715 //
4716
4717 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d), GlobalPayloadSID(0)
4718 {
4719   assert(m_Dict);
4720   m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
4721 }
4722
4723 PIMFDynamicMetadataDescriptor::PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
4724 {
4725   assert(m_Dict);
4726   m_UL = m_Dict->ul(MDD_PIMFDynamicMetadataDescriptor);
4727   Copy(rhs);
4728 }
4729
4730
4731 //
4732 ASDCP::Result_t
4733 PIMFDynamicMetadataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
4734 {
4735   assert(m_Dict);
4736   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
4737   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4738   return result;
4739 }
4740
4741 //
4742 ASDCP::Result_t
4743 PIMFDynamicMetadataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
4744 {
4745   assert(m_Dict);
4746   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
4747   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(PIMFDynamicMetadataDescriptor, GlobalPayloadSID));
4748   return result;
4749 }
4750
4751 //
4752 void
4753 PIMFDynamicMetadataDescriptor::Copy(const PIMFDynamicMetadataDescriptor& rhs)
4754 {
4755   GenericDataEssenceDescriptor::Copy(rhs);
4756   GlobalPayloadSID = rhs.GlobalPayloadSID;
4757 }
4758
4759 //
4760 void
4761 PIMFDynamicMetadataDescriptor::Dump(FILE* stream)
4762 {
4763   char identbuf[IdentBufferLen];
4764   *identbuf = 0;
4765
4766   if ( stream == 0 )
4767     stream = stderr;
4768
4769   GenericDataEssenceDescriptor::Dump(stream);
4770   fprintf(stream, "  %22s = %d\n",  "GlobalPayloadSID", GlobalPayloadSID);
4771 }
4772
4773 //
4774 ASDCP::Result_t
4775 PIMFDynamicMetadataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
4776 {
4777   return InterchangeObject::InitFromBuffer(p, l);
4778 }
4779
4780 //
4781 ASDCP::Result_t
4782 PIMFDynamicMetadataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
4783 {
4784   return InterchangeObject::WriteToBuffer(Buffer);
4785 }
4786
4787 //
4788 // end Metadata.cpp
4789 //