src/Metadata.cpp

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