src/Metadata.cpp

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