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* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); }
  72 static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); }
  73 static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); }
  74 static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
  75 static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
  76
  77
  78 void
  79 ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
  80 {
  81   assert(Dict);
  82   SetObjectFactory(Dict->ul(MDD_Preface), Preface_Factory);
  83   SetObjectFactory(Dict->ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
  84
  85   SetObjectFactory(Dict->ul(MDD_Identification), Identification_Factory);
  86   SetObjectFactory(Dict->ul(MDD_ContentStorage), ContentStorage_Factory);
  87   SetObjectFactory(Dict->ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
  88   SetObjectFactory(Dict->ul(MDD_MaterialPackage), MaterialPackage_Factory);
  89   SetObjectFactory(Dict->ul(MDD_SourcePackage), SourcePackage_Factory);
  90   SetObjectFactory(Dict->ul(MDD_StaticTrack), StaticTrack_Factory);
  91   SetObjectFactory(Dict->ul(MDD_Track), Track_Factory);
  92   SetObjectFactory(Dict->ul(MDD_Sequence), Sequence_Factory);
  93   SetObjectFactory(Dict->ul(MDD_SourceClip), SourceClip_Factory);
  94   SetObjectFactory(Dict->ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
  95   SetObjectFactory(Dict->ul(MDD_FileDescriptor), FileDescriptor_Factory);
  96   SetObjectFactory(Dict->ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
  97   SetObjectFactory(Dict->ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
  98   SetObjectFactory(Dict->ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
  99   SetObjectFactory(Dict->ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
 100   SetObjectFactory(Dict->ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
 101   SetObjectFactory(Dict->ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
 102   SetObjectFactory(Dict->ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
 103   SetObjectFactory(Dict->ul(MDD_DMSegment), DMSegment_Factory);
 104   SetObjectFactory(Dict->ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
 105   SetObjectFactory(Dict->ul(MDD_CryptographicContext), CryptographicContext_Factory);
 106   SetObjectFactory(Dict->ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
 107   SetObjectFactory(Dict->ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
 108   SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
 109   SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
 110   SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory);
 111   SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory);
 112   SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory);
 113   SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
 114   SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
 115 }
 116
 117 //------------------------------------------------------------------------------------------
 118 // KLV Sets
 119
 120
 121
 122 //------------------------------------------------------------------------------------------
 123 // Identification
 124
 125 //
 126
 127 Identification::Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
 128 {
 129   assert(m_Dict);
 130   m_UL = m_Dict->ul(MDD_Identification);
 131 }
 132
 133 Identification::Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 134 {
 135   assert(m_Dict);
 136   m_UL = m_Dict->ul(MDD_Identification);
 137   Copy(rhs);
 138 }
 139
 140
 141 //
 142 ASDCP::Result_t
 143 Identification::InitFromTLVSet(TLVReader& TLVSet)
 144 {
 145   assert(m_Dict);
 146   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 147   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
 148   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
 149   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
 150   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductVersion));
 151   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
 152   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
 153   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
 154   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, ToolkitVersion));
 155   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Identification, Platform));
 156   return result;
 157 }
 158
 159 //
 160 ASDCP::Result_t
 161 Identification::WriteToTLVSet(TLVWriter& TLVSet)
 162 {
 163   assert(m_Dict);
 164   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 165   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ThisGenerationUID));
 166   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, CompanyName));
 167   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductName));
 168   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductVersion));
 169   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, VersionString));
 170   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ProductUID));
 171   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ModificationDate));
 172   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, ToolkitVersion));
 173   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Identification, Platform));
 174   return result;
 175 }
 176
 177 //
 178 void
 179 Identification::Copy(const Identification& rhs)
 180 {
 181   InterchangeObject::Copy(rhs);
 182   ThisGenerationUID = rhs.ThisGenerationUID;
 183   CompanyName = rhs.CompanyName;
 184   ProductName = rhs.ProductName;
 185   ProductVersion = rhs.ProductVersion;
 186   VersionString = rhs.VersionString;
 187   ProductUID = rhs.ProductUID;
 188   ModificationDate = rhs.ModificationDate;
 189   ToolkitVersion = rhs.ToolkitVersion;
 190   Platform = rhs.Platform;
 191 }
 192
 193 //
 194 void
 195 Identification::Dump(FILE* stream)
 196 {
 197   char identbuf[IdentBufferLen];
 198   *identbuf = 0;
 199
 200   if ( stream == 0 )
 201     stream = stderr;
 202
 203   InterchangeObject::Dump(stream);
 204   fprintf(stream, "  %22s = %s\n",  "ThisGenerationUID", ThisGenerationUID.EncodeString(identbuf, IdentBufferLen));
 205   fprintf(stream, "  %22s = %s\n",  "CompanyName", CompanyName.EncodeString(identbuf, IdentBufferLen));
 206   fprintf(stream, "  %22s = %s\n",  "ProductName", ProductName.EncodeString(identbuf, IdentBufferLen));
 207   fprintf(stream, "  %22s = %s\n",  "ProductVersion", ProductVersion.EncodeString(identbuf, IdentBufferLen));
 208   fprintf(stream, "  %22s = %s\n",  "VersionString", VersionString.EncodeString(identbuf, IdentBufferLen));
 209   fprintf(stream, "  %22s = %s\n",  "ProductUID", ProductUID.EncodeString(identbuf, IdentBufferLen));
 210   fprintf(stream, "  %22s = %s\n",  "ModificationDate", ModificationDate.EncodeString(identbuf, IdentBufferLen));
 211   fprintf(stream, "  %22s = %s\n",  "ToolkitVersion", ToolkitVersion.EncodeString(identbuf, IdentBufferLen));
 212   fprintf(stream, "  %22s = %s\n",  "Platform", Platform.EncodeString(identbuf, IdentBufferLen));
 213 }
 214
 215 //
 216 ASDCP::Result_t
 217 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 218 {
 219   return InterchangeObject::InitFromBuffer(p, l);
 220 }
 221
 222 //
 223 ASDCP::Result_t
 224 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 225 {
 226   return InterchangeObject::WriteToBuffer(Buffer);
 227 }
 228
 229 //------------------------------------------------------------------------------------------
 230 // ContentStorage
 231
 232 //
 233
 234 ContentStorage::ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
 235 {
 236   assert(m_Dict);
 237   m_UL = m_Dict->ul(MDD_ContentStorage);
 238 }
 239
 240 ContentStorage::ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 241 {
 242   assert(m_Dict);
 243   m_UL = m_Dict->ul(MDD_ContentStorage);
 244   Copy(rhs);
 245 }
 246
 247
 248 //
 249 ASDCP::Result_t
 250 ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
 251 {
 252   assert(m_Dict);
 253   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 254   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
 255   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
 256   return result;
 257 }
 258
 259 //
 260 ASDCP::Result_t
 261 ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
 262 {
 263   assert(m_Dict);
 264   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 265   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, Packages));
 266   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(ContentStorage, EssenceContainerData));
 267   return result;
 268 }
 269
 270 //
 271 void
 272 ContentStorage::Copy(const ContentStorage& rhs)
 273 {
 274   InterchangeObject::Copy(rhs);
 275   Packages = rhs.Packages;
 276   EssenceContainerData = rhs.EssenceContainerData;
 277 }
 278
 279 //
 280 void
 281 ContentStorage::Dump(FILE* stream)
 282 {
 283   char identbuf[IdentBufferLen];
 284   *identbuf = 0;
 285
 286   if ( stream == 0 )
 287     stream = stderr;
 288
 289   InterchangeObject::Dump(stream);
 290   fprintf(stream, "  %22s:\n",  "Packages");
 291   Packages.Dump(stream);
 292   fprintf(stream, "  %22s:\n",  "EssenceContainerData");
 293   EssenceContainerData.Dump(stream);
 294 }
 295
 296 //
 297 ASDCP::Result_t
 298 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 299 {
 300   return InterchangeObject::InitFromBuffer(p, l);
 301 }
 302
 303 //
 304 ASDCP::Result_t
 305 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 306 {
 307   return InterchangeObject::WriteToBuffer(Buffer);
 308 }
 309
 310 //------------------------------------------------------------------------------------------
 311 // EssenceContainerData
 312
 313 //
 314
 315 EssenceContainerData::EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0)
 316 {
 317   assert(m_Dict);
 318   m_UL = m_Dict->ul(MDD_EssenceContainerData);
 319 }
 320
 321 EssenceContainerData::EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 322 {
 323   assert(m_Dict);
 324   m_UL = m_Dict->ul(MDD_EssenceContainerData);
 325   Copy(rhs);
 326 }
 327
 328
 329 //
 330 ASDCP::Result_t
 331 EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
 332 {
 333   assert(m_Dict);
 334   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 335   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(EssenceContainerData, LinkedPackageUID));
 336   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, IndexSID));
 337   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(EssenceContainerData, BodySID));
 338   return result;
 339 }
 340
 341 //
 342 ASDCP::Result_t
 343 EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
 344 {
 345   assert(m_Dict);
 346   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 347   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(EssenceContainerData, LinkedPackageUID));
 348   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, IndexSID));
 349   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(EssenceContainerData, BodySID));
 350   return result;
 351 }
 352
 353 //
 354 void
 355 EssenceContainerData::Copy(const EssenceContainerData& rhs)
 356 {
 357   InterchangeObject::Copy(rhs);
 358   LinkedPackageUID = rhs.LinkedPackageUID;
 359   IndexSID = rhs.IndexSID;
 360   BodySID = rhs.BodySID;
 361 }
 362
 363 //
 364 void
 365 EssenceContainerData::Dump(FILE* stream)
 366 {
 367   char identbuf[IdentBufferLen];
 368   *identbuf = 0;
 369
 370   if ( stream == 0 )
 371     stream = stderr;
 372
 373   InterchangeObject::Dump(stream);
 374   fprintf(stream, "  %22s = %s\n",  "LinkedPackageUID", LinkedPackageUID.EncodeString(identbuf, IdentBufferLen));
 375   fprintf(stream, "  %22s = %d\n",  "IndexSID", IndexSID);
 376   fprintf(stream, "  %22s = %d\n",  "BodySID", BodySID);
 377 }
 378
 379 //
 380 ASDCP::Result_t
 381 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 382 {
 383   return InterchangeObject::InitFromBuffer(p, l);
 384 }
 385
 386 //
 387 ASDCP::Result_t
 388 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 389 {
 390   return InterchangeObject::WriteToBuffer(Buffer);
 391 }
 392
 393 //------------------------------------------------------------------------------------------
 394 // GenericPackage
 395
 396 //
 397 GenericPackage::GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 398
 399 GenericPackage::GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 400 {
 401   Copy(rhs);
 402 }
 403
 404
 405 //
 406 ASDCP::Result_t
 407 GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
 408 {
 409   assert(m_Dict);
 410   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 411   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
 412   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Name));
 413   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
 414   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
 415   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
 416   return result;
 417 }
 418
 419 //
 420 ASDCP::Result_t
 421 GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
 422 {
 423   assert(m_Dict);
 424   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 425   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageUID));
 426   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Name));
 427   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageCreationDate));
 428   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, PackageModifiedDate));
 429   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPackage, Tracks));
 430   return result;
 431 }
 432
 433 //
 434 void
 435 GenericPackage::Copy(const GenericPackage& rhs)
 436 {
 437   InterchangeObject::Copy(rhs);
 438   PackageUID = rhs.PackageUID;
 439   Name = rhs.Name;
 440   PackageCreationDate = rhs.PackageCreationDate;
 441   PackageModifiedDate = rhs.PackageModifiedDate;
 442   Tracks = rhs.Tracks;
 443 }
 444
 445 //
 446 void
 447 GenericPackage::Dump(FILE* stream)
 448 {
 449   char identbuf[IdentBufferLen];
 450   *identbuf = 0;
 451
 452   if ( stream == 0 )
 453     stream = stderr;
 454
 455   InterchangeObject::Dump(stream);
 456   fprintf(stream, "  %22s = %s\n",  "PackageUID", PackageUID.EncodeString(identbuf, IdentBufferLen));
 457   fprintf(stream, "  %22s = %s\n",  "Name", Name.EncodeString(identbuf, IdentBufferLen));
 458   fprintf(stream, "  %22s = %s\n",  "PackageCreationDate", PackageCreationDate.EncodeString(identbuf, IdentBufferLen));
 459   fprintf(stream, "  %22s = %s\n",  "PackageModifiedDate", PackageModifiedDate.EncodeString(identbuf, IdentBufferLen));
 460   fprintf(stream, "  %22s:\n",  "Tracks");
 461   Tracks.Dump(stream);
 462 }
 463
 464
 465 //------------------------------------------------------------------------------------------
 466 // MaterialPackage
 467
 468 //
 469
 470 MaterialPackage::MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
 471 {
 472   assert(m_Dict);
 473   m_UL = m_Dict->ul(MDD_MaterialPackage);
 474 }
 475
 476 MaterialPackage::MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
 477 {
 478   assert(m_Dict);
 479   m_UL = m_Dict->ul(MDD_MaterialPackage);
 480   Copy(rhs);
 481 }
 482
 483
 484 //
 485 ASDCP::Result_t
 486 MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
 487 {
 488   assert(m_Dict);
 489   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 490   return result;
 491 }
 492
 493 //
 494 ASDCP::Result_t
 495 MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
 496 {
 497   assert(m_Dict);
 498   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 499   return result;
 500 }
 501
 502 //
 503 void
 504 MaterialPackage::Copy(const MaterialPackage& rhs)
 505 {
 506   GenericPackage::Copy(rhs);
 507 }
 508
 509 //
 510 void
 511 MaterialPackage::Dump(FILE* stream)
 512 {
 513   char identbuf[IdentBufferLen];
 514   *identbuf = 0;
 515
 516   if ( stream == 0 )
 517     stream = stderr;
 518
 519   GenericPackage::Dump(stream);
 520 }
 521
 522 //
 523 ASDCP::Result_t
 524 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 525 {
 526   return InterchangeObject::InitFromBuffer(p, l);
 527 }
 528
 529 //
 530 ASDCP::Result_t
 531 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 532 {
 533   return InterchangeObject::WriteToBuffer(Buffer);
 534 }
 535
 536 //------------------------------------------------------------------------------------------
 537 // SourcePackage
 538
 539 //
 540
 541 SourcePackage::SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
 542 {
 543   assert(m_Dict);
 544   m_UL = m_Dict->ul(MDD_SourcePackage);
 545 }
 546
 547 SourcePackage::SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
 548 {
 549   assert(m_Dict);
 550   m_UL = m_Dict->ul(MDD_SourcePackage);
 551   Copy(rhs);
 552 }
 553
 554
 555 //
 556 ASDCP::Result_t
 557 SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
 558 {
 559   assert(m_Dict);
 560   Result_t result = GenericPackage::InitFromTLVSet(TLVSet);
 561   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourcePackage, Descriptor));
 562   return result;
 563 }
 564
 565 //
 566 ASDCP::Result_t
 567 SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
 568 {
 569   assert(m_Dict);
 570   Result_t result = GenericPackage::WriteToTLVSet(TLVSet);
 571   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourcePackage, Descriptor));
 572   return result;
 573 }
 574
 575 //
 576 void
 577 SourcePackage::Copy(const SourcePackage& rhs)
 578 {
 579   GenericPackage::Copy(rhs);
 580   Descriptor = rhs.Descriptor;
 581 }
 582
 583 //
 584 void
 585 SourcePackage::Dump(FILE* stream)
 586 {
 587   char identbuf[IdentBufferLen];
 588   *identbuf = 0;
 589
 590   if ( stream == 0 )
 591     stream = stderr;
 592
 593   GenericPackage::Dump(stream);
 594   fprintf(stream, "  %22s = %s\n",  "Descriptor", Descriptor.EncodeString(identbuf, IdentBufferLen));
 595 }
 596
 597 //
 598 ASDCP::Result_t
 599 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 600 {
 601   return InterchangeObject::InitFromBuffer(p, l);
 602 }
 603
 604 //
 605 ASDCP::Result_t
 606 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 607 {
 608   return InterchangeObject::WriteToBuffer(Buffer);
 609 }
 610
 611 //------------------------------------------------------------------------------------------
 612 // GenericTrack
 613
 614 //
 615 GenericTrack::GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
 616
 617 GenericTrack::GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 618 {
 619   Copy(rhs);
 620 }
 621
 622
 623 //
 624 ASDCP::Result_t
 625 GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
 626 {
 627   assert(m_Dict);
 628   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 629   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
 630   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
 631   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, TrackName));
 632   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericTrack, Sequence));
 633   return result;
 634 }
 635
 636 //
 637 ASDCP::Result_t
 638 GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
 639 {
 640   assert(m_Dict);
 641   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 642   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackID));
 643   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericTrack, TrackNumber));
 644   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericTrack, TrackName));
 645   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericTrack, Sequence));
 646   return result;
 647 }
 648
 649 //
 650 void
 651 GenericTrack::Copy(const GenericTrack& rhs)
 652 {
 653   InterchangeObject::Copy(rhs);
 654   TrackID = rhs.TrackID;
 655   TrackNumber = rhs.TrackNumber;
 656   TrackName = rhs.TrackName;
 657   Sequence = rhs.Sequence;
 658 }
 659
 660 //
 661 void
 662 GenericTrack::Dump(FILE* stream)
 663 {
 664   char identbuf[IdentBufferLen];
 665   *identbuf = 0;
 666
 667   if ( stream == 0 )
 668     stream = stderr;
 669
 670   InterchangeObject::Dump(stream);
 671   fprintf(stream, "  %22s = %d\n",  "TrackID", TrackID);
 672   fprintf(stream, "  %22s = %d\n",  "TrackNumber", TrackNumber);
 673   fprintf(stream, "  %22s = %s\n",  "TrackName", TrackName.EncodeString(identbuf, IdentBufferLen));
 674   fprintf(stream, "  %22s = %s\n",  "Sequence", Sequence.EncodeString(identbuf, IdentBufferLen));
 675 }
 676
 677
 678 //------------------------------------------------------------------------------------------
 679 // StaticTrack
 680
 681 //
 682
 683 StaticTrack::StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d)
 684 {
 685   assert(m_Dict);
 686   m_UL = m_Dict->ul(MDD_StaticTrack);
 687 }
 688
 689 StaticTrack::StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
 690 {
 691   assert(m_Dict);
 692   m_UL = m_Dict->ul(MDD_StaticTrack);
 693   Copy(rhs);
 694 }
 695
 696
 697 //
 698 ASDCP::Result_t
 699 StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
 700 {
 701   assert(m_Dict);
 702   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 703   return result;
 704 }
 705
 706 //
 707 ASDCP::Result_t
 708 StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
 709 {
 710   assert(m_Dict);
 711   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 712   return result;
 713 }
 714
 715 //
 716 void
 717 StaticTrack::Copy(const StaticTrack& rhs)
 718 {
 719   GenericTrack::Copy(rhs);
 720 }
 721
 722 //
 723 void
 724 StaticTrack::Dump(FILE* stream)
 725 {
 726   char identbuf[IdentBufferLen];
 727   *identbuf = 0;
 728
 729   if ( stream == 0 )
 730     stream = stderr;
 731
 732   GenericTrack::Dump(stream);
 733 }
 734
 735 //
 736 ASDCP::Result_t
 737 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 738 {
 739   return InterchangeObject::InitFromBuffer(p, l);
 740 }
 741
 742 //
 743 ASDCP::Result_t
 744 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 745 {
 746   return InterchangeObject::WriteToBuffer(Buffer);
 747 }
 748
 749 //------------------------------------------------------------------------------------------
 750 // Track
 751
 752 //
 753
 754 Track::Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0)
 755 {
 756   assert(m_Dict);
 757   m_UL = m_Dict->ul(MDD_Track);
 758 }
 759
 760 Track::Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
 761 {
 762   assert(m_Dict);
 763   m_UL = m_Dict->ul(MDD_Track);
 764   Copy(rhs);
 765 }
 766
 767
 768 //
 769 ASDCP::Result_t
 770 Track::InitFromTLVSet(TLVReader& TLVSet)
 771 {
 772   assert(m_Dict);
 773   Result_t result = GenericTrack::InitFromTLVSet(TLVSet);
 774   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Track, EditRate));
 775   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(Track, Origin));
 776   return result;
 777 }
 778
 779 //
 780 ASDCP::Result_t
 781 Track::WriteToTLVSet(TLVWriter& TLVSet)
 782 {
 783   assert(m_Dict);
 784   Result_t result = GenericTrack::WriteToTLVSet(TLVSet);
 785   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Track, EditRate));
 786   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(Track, Origin));
 787   return result;
 788 }
 789
 790 //
 791 void
 792 Track::Copy(const Track& rhs)
 793 {
 794   GenericTrack::Copy(rhs);
 795   EditRate = rhs.EditRate;
 796   Origin = rhs.Origin;
 797 }
 798
 799 //
 800 void
 801 Track::Dump(FILE* stream)
 802 {
 803   char identbuf[IdentBufferLen];
 804   *identbuf = 0;
 805
 806   if ( stream == 0 )
 807     stream = stderr;
 808
 809   GenericTrack::Dump(stream);
 810   fprintf(stream, "  %22s = %s\n",  "EditRate", EditRate.EncodeString(identbuf, IdentBufferLen));
 811   fprintf(stream, "  %22s = %s\n",  "Origin", i64sz(Origin, identbuf));
 812 }
 813
 814 //
 815 ASDCP::Result_t
 816 Track::InitFromBuffer(const byte_t* p, ui32_t l)
 817 {
 818   return InterchangeObject::InitFromBuffer(p, l);
 819 }
 820
 821 //
 822 ASDCP::Result_t
 823 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 824 {
 825   return InterchangeObject::WriteToBuffer(Buffer);
 826 }
 827
 828 //------------------------------------------------------------------------------------------
 829 // StructuralComponent
 830
 831 //
 832 StructuralComponent::StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
 833
 834 StructuralComponent::StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
 835 {
 836   Copy(rhs);
 837 }
 838
 839
 840 //
 841 ASDCP::Result_t
 842 StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
 843 {
 844   assert(m_Dict);
 845   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
 846   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 847   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
 848   return result;
 849 }
 850
 851 //
 852 ASDCP::Result_t
 853 StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
 854 {
 855   assert(m_Dict);
 856   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
 857   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(StructuralComponent, DataDefinition));
 858   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(StructuralComponent, Duration));
 859   return result;
 860 }
 861
 862 //
 863 void
 864 StructuralComponent::Copy(const StructuralComponent& rhs)
 865 {
 866   InterchangeObject::Copy(rhs);
 867   DataDefinition = rhs.DataDefinition;
 868   Duration = rhs.Duration;
 869 }
 870
 871 //
 872 void
 873 StructuralComponent::Dump(FILE* stream)
 874 {
 875   char identbuf[IdentBufferLen];
 876   *identbuf = 0;
 877
 878   if ( stream == 0 )
 879     stream = stderr;
 880
 881   InterchangeObject::Dump(stream);
 882   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
 883   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
 884 }
 885
 886
 887 //------------------------------------------------------------------------------------------
 888 // Sequence
 889
 890 //
 891
 892 Sequence::Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d)
 893 {
 894   assert(m_Dict);
 895   m_UL = m_Dict->ul(MDD_Sequence);
 896 }
 897
 898 Sequence::Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
 899 {
 900   assert(m_Dict);
 901   m_UL = m_Dict->ul(MDD_Sequence);
 902   Copy(rhs);
 903 }
 904
 905
 906 //
 907 ASDCP::Result_t
 908 Sequence::InitFromTLVSet(TLVReader& TLVSet)
 909 {
 910   assert(m_Dict);
 911   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 912   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
 913   return result;
 914 }
 915
 916 //
 917 ASDCP::Result_t
 918 Sequence::WriteToTLVSet(TLVWriter& TLVSet)
 919 {
 920   assert(m_Dict);
 921   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
 922   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(Sequence, StructuralComponents));
 923   return result;
 924 }
 925
 926 //
 927 void
 928 Sequence::Copy(const Sequence& rhs)
 929 {
 930   StructuralComponent::Copy(rhs);
 931   StructuralComponents = rhs.StructuralComponents;
 932 }
 933
 934 //
 935 void
 936 Sequence::Dump(FILE* stream)
 937 {
 938   char identbuf[IdentBufferLen];
 939   *identbuf = 0;
 940
 941   if ( stream == 0 )
 942     stream = stderr;
 943
 944   StructuralComponent::Dump(stream);
 945   fprintf(stream, "  %22s:\n",  "StructuralComponents");
 946   StructuralComponents.Dump(stream);
 947 }
 948
 949 //
 950 ASDCP::Result_t
 951 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 952 {
 953   return InterchangeObject::InitFromBuffer(p, l);
 954 }
 955
 956 //
 957 ASDCP::Result_t
 958 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 959 {
 960   return InterchangeObject::WriteToBuffer(Buffer);
 961 }
 962
 963 //------------------------------------------------------------------------------------------
 964 // SourceClip
 965
 966 //
 967
 968 SourceClip::SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0)
 969 {
 970   assert(m_Dict);
 971   m_UL = m_Dict->ul(MDD_SourceClip);
 972 }
 973
 974 SourceClip::SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
 975 {
 976   assert(m_Dict);
 977   m_UL = m_Dict->ul(MDD_SourceClip);
 978   Copy(rhs);
 979 }
 980
 981
 982 //
 983 ASDCP::Result_t
 984 SourceClip::InitFromTLVSet(TLVReader& TLVSet)
 985 {
 986   assert(m_Dict);
 987   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
 988   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
 989   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
 990   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
 991   return result;
 992 }
 993
 994 //
 995 ASDCP::Result_t
 996 SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
 997 {
 998   assert(m_Dict);
 999   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1000   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(SourceClip, StartPosition));
1001   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SourceClip, SourcePackageID));
1002   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(SourceClip, SourceTrackID));
1003   return result;
1004 }
1005
1006 //
1007 void
1008 SourceClip::Copy(const SourceClip& rhs)
1009 {
1010   StructuralComponent::Copy(rhs);
1011   StartPosition = rhs.StartPosition;
1012   SourcePackageID = rhs.SourcePackageID;
1013   SourceTrackID = rhs.SourceTrackID;
1014 }
1015
1016 //
1017 void
1018 SourceClip::Dump(FILE* stream)
1019 {
1020   char identbuf[IdentBufferLen];
1021   *identbuf = 0;
1022
1023   if ( stream == 0 )
1024     stream = stderr;
1025
1026   StructuralComponent::Dump(stream);
1027   fprintf(stream, "  %22s = %s\n",  "StartPosition", i64sz(StartPosition, identbuf));
1028   fprintf(stream, "  %22s = %s\n",  "SourcePackageID", SourcePackageID.EncodeString(identbuf, IdentBufferLen));
1029   fprintf(stream, "  %22s = %d\n",  "SourceTrackID", SourceTrackID);
1030 }
1031
1032 //
1033 ASDCP::Result_t
1034 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
1035 {
1036   return InterchangeObject::InitFromBuffer(p, l);
1037 }
1038
1039 //
1040 ASDCP::Result_t
1041 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1042 {
1043   return InterchangeObject::WriteToBuffer(Buffer);
1044 }
1045
1046 //------------------------------------------------------------------------------------------
1047 // TimecodeComponent
1048
1049 //
1050
1051 TimecodeComponent::TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0)
1052 {
1053   assert(m_Dict);
1054   m_UL = m_Dict->ul(MDD_TimecodeComponent);
1055 }
1056
1057 TimecodeComponent::TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
1058 {
1059   assert(m_Dict);
1060   m_UL = m_Dict->ul(MDD_TimecodeComponent);
1061   Copy(rhs);
1062 }
1063
1064
1065 //
1066 ASDCP::Result_t
1067 TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
1068 {
1069   assert(m_Dict);
1070   Result_t result = StructuralComponent::InitFromTLVSet(TLVSet);
1071   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
1072   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
1073   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
1074   return result;
1075 }
1076
1077 //
1078 ASDCP::Result_t
1079 TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
1080 {
1081   assert(m_Dict);
1082   Result_t result = StructuralComponent::WriteToTLVSet(TLVSet);
1083   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(TimecodeComponent, RoundedTimecodeBase));
1084   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(TimecodeComponent, StartTimecode));
1085   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(TimecodeComponent, DropFrame));
1086   return result;
1087 }
1088
1089 //
1090 void
1091 TimecodeComponent::Copy(const TimecodeComponent& rhs)
1092 {
1093   StructuralComponent::Copy(rhs);
1094   RoundedTimecodeBase = rhs.RoundedTimecodeBase;
1095   StartTimecode = rhs.StartTimecode;
1096   DropFrame = rhs.DropFrame;
1097 }
1098
1099 //
1100 void
1101 TimecodeComponent::Dump(FILE* stream)
1102 {
1103   char identbuf[IdentBufferLen];
1104   *identbuf = 0;
1105
1106   if ( stream == 0 )
1107     stream = stderr;
1108
1109   StructuralComponent::Dump(stream);
1110   fprintf(stream, "  %22s = %d\n",  "RoundedTimecodeBase", RoundedTimecodeBase);
1111   fprintf(stream, "  %22s = %s\n",  "StartTimecode", i64sz(StartTimecode, identbuf));
1112   fprintf(stream, "  %22s = %d\n",  "DropFrame", DropFrame);
1113 }
1114
1115 //
1116 ASDCP::Result_t
1117 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
1118 {
1119   return InterchangeObject::InitFromBuffer(p, l);
1120 }
1121
1122 //
1123 ASDCP::Result_t
1124 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1125 {
1126   return InterchangeObject::WriteToBuffer(Buffer);
1127 }
1128
1129 //------------------------------------------------------------------------------------------
1130 // GenericDescriptor
1131
1132 //
1133 GenericDescriptor::GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
1134
1135 GenericDescriptor::GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1136 {
1137   Copy(rhs);
1138 }
1139
1140
1141 //
1142 ASDCP::Result_t
1143 GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1144 {
1145   assert(m_Dict);
1146   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1147   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
1148   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
1149   return result;
1150 }
1151
1152 //
1153 ASDCP::Result_t
1154 GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1155 {
1156   assert(m_Dict);
1157   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1158   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, Locators));
1159   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDescriptor, SubDescriptors));
1160   return result;
1161 }
1162
1163 //
1164 void
1165 GenericDescriptor::Copy(const GenericDescriptor& rhs)
1166 {
1167   InterchangeObject::Copy(rhs);
1168   Locators = rhs.Locators;
1169   SubDescriptors = rhs.SubDescriptors;
1170 }
1171
1172 //
1173 void
1174 GenericDescriptor::Dump(FILE* stream)
1175 {
1176   char identbuf[IdentBufferLen];
1177   *identbuf = 0;
1178
1179   if ( stream == 0 )
1180     stream = stderr;
1181
1182   InterchangeObject::Dump(stream);
1183   fprintf(stream, "  %22s:\n",  "Locators");
1184   Locators.Dump(stream);
1185   fprintf(stream, "  %22s:\n",  "SubDescriptors");
1186   SubDescriptors.Dump(stream);
1187 }
1188
1189
1190 //------------------------------------------------------------------------------------------
1191 // FileDescriptor
1192
1193 //
1194
1195 FileDescriptor::FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0)
1196 {
1197   assert(m_Dict);
1198   m_UL = m_Dict->ul(MDD_FileDescriptor);
1199 }
1200
1201 FileDescriptor::FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1202 {
1203   assert(m_Dict);
1204   m_UL = m_Dict->ul(MDD_FileDescriptor);
1205   Copy(rhs);
1206 }
1207
1208
1209 //
1210 ASDCP::Result_t
1211 FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1212 {
1213   assert(m_Dict);
1214   Result_t result = GenericDescriptor::InitFromTLVSet(TLVSet);
1215   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
1216   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
1217   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
1218   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
1219   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(FileDescriptor, Codec));
1220   return result;
1221 }
1222
1223 //
1224 ASDCP::Result_t
1225 FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1226 {
1227   assert(m_Dict);
1228   Result_t result = GenericDescriptor::WriteToTLVSet(TLVSet);
1229   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(FileDescriptor, LinkedTrackID));
1230   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, SampleRate));
1231   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(FileDescriptor, ContainerDuration));
1232   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, EssenceContainer));
1233   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(FileDescriptor, Codec));
1234   return result;
1235 }
1236
1237 //
1238 void
1239 FileDescriptor::Copy(const FileDescriptor& rhs)
1240 {
1241   GenericDescriptor::Copy(rhs);
1242   LinkedTrackID = rhs.LinkedTrackID;
1243   SampleRate = rhs.SampleRate;
1244   ContainerDuration = rhs.ContainerDuration;
1245   EssenceContainer = rhs.EssenceContainer;
1246   Codec = rhs.Codec;
1247 }
1248
1249 //
1250 void
1251 FileDescriptor::Dump(FILE* stream)
1252 {
1253   char identbuf[IdentBufferLen];
1254   *identbuf = 0;
1255
1256   if ( stream == 0 )
1257     stream = stderr;
1258
1259   GenericDescriptor::Dump(stream);
1260   fprintf(stream, "  %22s = %d\n",  "LinkedTrackID", LinkedTrackID);
1261   fprintf(stream, "  %22s = %s\n",  "SampleRate", SampleRate.EncodeString(identbuf, IdentBufferLen));
1262   fprintf(stream, "  %22s = %s\n",  "ContainerDuration", i64sz(ContainerDuration, identbuf));
1263   fprintf(stream, "  %22s = %s\n",  "EssenceContainer", EssenceContainer.EncodeString(identbuf, IdentBufferLen));
1264   fprintf(stream, "  %22s = %s\n",  "Codec", Codec.EncodeString(identbuf, IdentBufferLen));
1265 }
1266
1267 //
1268 ASDCP::Result_t
1269 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1270 {
1271   return InterchangeObject::InitFromBuffer(p, l);
1272 }
1273
1274 //
1275 ASDCP::Result_t
1276 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1277 {
1278   return InterchangeObject::WriteToBuffer(Buffer);
1279 }
1280
1281 //------------------------------------------------------------------------------------------
1282 // GenericSoundEssenceDescriptor
1283
1284 //
1285
1286 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0)
1287 {
1288   assert(m_Dict);
1289   m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1290 }
1291
1292 GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1293 {
1294   assert(m_Dict);
1295   m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
1296   Copy(rhs);
1297 }
1298
1299
1300 //
1301 ASDCP::Result_t
1302 GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1303 {
1304   assert(m_Dict);
1305   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1306   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1307   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
1308   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
1309   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1310   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1311   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, DialNorm));
1312   return result;
1313 }
1314
1315 //
1316 ASDCP::Result_t
1317 GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1318 {
1319   assert(m_Dict);
1320   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1321   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
1322   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, Locked));
1323   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, AudioRefLevel));
1324   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
1325   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
1326   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericSoundEssenceDescriptor, DialNorm));
1327   return result;
1328 }
1329
1330 //
1331 void
1332 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
1333 {
1334   FileDescriptor::Copy(rhs);
1335   AudioSamplingRate = rhs.AudioSamplingRate;
1336   Locked = rhs.Locked;
1337   AudioRefLevel = rhs.AudioRefLevel;
1338   ChannelCount = rhs.ChannelCount;
1339   QuantizationBits = rhs.QuantizationBits;
1340   DialNorm = rhs.DialNorm;
1341 }
1342
1343 //
1344 void
1345 GenericSoundEssenceDescriptor::Dump(FILE* stream)
1346 {
1347   char identbuf[IdentBufferLen];
1348   *identbuf = 0;
1349
1350   if ( stream == 0 )
1351     stream = stderr;
1352
1353   FileDescriptor::Dump(stream);
1354   fprintf(stream, "  %22s = %s\n",  "AudioSamplingRate", AudioSamplingRate.EncodeString(identbuf, IdentBufferLen));
1355   fprintf(stream, "  %22s = %d\n",  "Locked", Locked);
1356   fprintf(stream, "  %22s = %d\n",  "AudioRefLevel", AudioRefLevel);
1357   fprintf(stream, "  %22s = %d\n",  "ChannelCount", ChannelCount);
1358   fprintf(stream, "  %22s = %d\n",  "QuantizationBits", QuantizationBits);
1359   fprintf(stream, "  %22s = %d\n",  "DialNorm", DialNorm);
1360 }
1361
1362 //
1363 ASDCP::Result_t
1364 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1365 {
1366   return InterchangeObject::InitFromBuffer(p, l);
1367 }
1368
1369 //
1370 ASDCP::Result_t
1371 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1372 {
1373   return InterchangeObject::WriteToBuffer(Buffer);
1374 }
1375
1376 //------------------------------------------------------------------------------------------
1377 // WaveAudioDescriptor
1378
1379 //
1380
1381 WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0)
1382 {
1383   assert(m_Dict);
1384   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1385 }
1386
1387 WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1388 {
1389   assert(m_Dict);
1390   m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
1391   Copy(rhs);
1392 }
1393
1394
1395 //
1396 ASDCP::Result_t
1397 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1398 {
1399   assert(m_Dict);
1400   Result_t result = GenericSoundEssenceDescriptor::InitFromTLVSet(TLVSet);
1401   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
1402   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(WaveAudioDescriptor, SequenceOffset));
1403   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
1404   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(WaveAudioDescriptor, ChannelAssignment));
1405   return result;
1406 }
1407
1408 //
1409 ASDCP::Result_t
1410 WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1411 {
1412   assert(m_Dict);
1413   Result_t result = GenericSoundEssenceDescriptor::WriteToTLVSet(TLVSet);
1414   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(WaveAudioDescriptor, BlockAlign));
1415   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(WaveAudioDescriptor, SequenceOffset));
1416   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(WaveAudioDescriptor, AvgBps));
1417   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(WaveAudioDescriptor, ChannelAssignment));
1418   return result;
1419 }
1420
1421 //
1422 void
1423 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
1424 {
1425   GenericSoundEssenceDescriptor::Copy(rhs);
1426   BlockAlign = rhs.BlockAlign;
1427   SequenceOffset = rhs.SequenceOffset;
1428   AvgBps = rhs.AvgBps;
1429   ChannelAssignment = rhs.ChannelAssignment;
1430 }
1431
1432 //
1433 void
1434 WaveAudioDescriptor::Dump(FILE* stream)
1435 {
1436   char identbuf[IdentBufferLen];
1437   *identbuf = 0;
1438
1439   if ( stream == 0 )
1440     stream = stderr;
1441
1442   GenericSoundEssenceDescriptor::Dump(stream);
1443   fprintf(stream, "  %22s = %d\n",  "BlockAlign", BlockAlign);
1444   fprintf(stream, "  %22s = %d\n",  "SequenceOffset", SequenceOffset);
1445   fprintf(stream, "  %22s = %d\n",  "AvgBps", AvgBps);
1446   fprintf(stream, "  %22s = %s\n",  "ChannelAssignment", ChannelAssignment.EncodeString(identbuf, IdentBufferLen));
1447 }
1448
1449 //
1450 ASDCP::Result_t
1451 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1452 {
1453   return InterchangeObject::InitFromBuffer(p, l);
1454 }
1455
1456 //
1457 ASDCP::Result_t
1458 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1459 {
1460   return InterchangeObject::WriteToBuffer(Buffer);
1461 }
1462
1463 //------------------------------------------------------------------------------------------
1464 // GenericPictureEssenceDescriptor
1465
1466 //
1467
1468 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0)
1469 {
1470   assert(m_Dict);
1471   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1472 }
1473
1474 GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1475 {
1476   assert(m_Dict);
1477   m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
1478   Copy(rhs);
1479 }
1480
1481
1482 //
1483 ASDCP::Result_t
1484 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1485 {
1486   assert(m_Dict);
1487   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
1488   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1489   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1490   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1491   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1492   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1493   return result;
1494 }
1495
1496 //
1497 ASDCP::Result_t
1498 GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1499 {
1500   assert(m_Dict);
1501   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
1502   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
1503   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
1504   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
1505   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, AspectRatio));
1506   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericPictureEssenceDescriptor, PictureEssenceCoding));
1507   return result;
1508 }
1509
1510 //
1511 void
1512 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
1513 {
1514   FileDescriptor::Copy(rhs);
1515   FrameLayout = rhs.FrameLayout;
1516   StoredWidth = rhs.StoredWidth;
1517   StoredHeight = rhs.StoredHeight;
1518   AspectRatio = rhs.AspectRatio;
1519   PictureEssenceCoding = rhs.PictureEssenceCoding;
1520 }
1521
1522 //
1523 void
1524 GenericPictureEssenceDescriptor::Dump(FILE* stream)
1525 {
1526   char identbuf[IdentBufferLen];
1527   *identbuf = 0;
1528
1529   if ( stream == 0 )
1530     stream = stderr;
1531
1532   FileDescriptor::Dump(stream);
1533   fprintf(stream, "  %22s = %d\n",  "FrameLayout", FrameLayout);
1534   fprintf(stream, "  %22s = %d\n",  "StoredWidth", StoredWidth);
1535   fprintf(stream, "  %22s = %d\n",  "StoredHeight", StoredHeight);
1536   fprintf(stream, "  %22s = %s\n",  "AspectRatio", AspectRatio.EncodeString(identbuf, IdentBufferLen));
1537   fprintf(stream, "  %22s = %s\n",  "PictureEssenceCoding", PictureEssenceCoding.EncodeString(identbuf, IdentBufferLen));
1538 }
1539
1540 //
1541 ASDCP::Result_t
1542 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1543 {
1544   return InterchangeObject::InitFromBuffer(p, l);
1545 }
1546
1547 //
1548 ASDCP::Result_t
1549 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1550 {
1551   return InterchangeObject::WriteToBuffer(Buffer);
1552 }
1553
1554 //------------------------------------------------------------------------------------------
1555 // RGBAEssenceDescriptor
1556
1557 //
1558
1559 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0)
1560 {
1561   assert(m_Dict);
1562   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1563 }
1564
1565 RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1566 {
1567   assert(m_Dict);
1568   m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
1569   Copy(rhs);
1570 }
1571
1572
1573 //
1574 ASDCP::Result_t
1575 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1576 {
1577   assert(m_Dict);
1578   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1579   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1580   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1581   return result;
1582 }
1583
1584 //
1585 ASDCP::Result_t
1586 RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1587 {
1588   assert(m_Dict);
1589   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1590   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
1591   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
1592   return result;
1593 }
1594
1595 //
1596 void
1597 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
1598 {
1599   GenericPictureEssenceDescriptor::Copy(rhs);
1600   ComponentMaxRef = rhs.ComponentMaxRef;
1601   ComponentMinRef = rhs.ComponentMinRef;
1602 }
1603
1604 //
1605 void
1606 RGBAEssenceDescriptor::Dump(FILE* stream)
1607 {
1608   char identbuf[IdentBufferLen];
1609   *identbuf = 0;
1610
1611   if ( stream == 0 )
1612     stream = stderr;
1613
1614   GenericPictureEssenceDescriptor::Dump(stream);
1615   fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef);
1616   fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef);
1617 }
1618
1619 //
1620 ASDCP::Result_t
1621 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1622 {
1623   return InterchangeObject::InitFromBuffer(p, l);
1624 }
1625
1626 //
1627 ASDCP::Result_t
1628 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1629 {
1630   return InterchangeObject::WriteToBuffer(Buffer);
1631 }
1632
1633 //------------------------------------------------------------------------------------------
1634 // JPEG2000PictureSubDescriptor
1635
1636 //
1637
1638 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)
1639 {
1640   assert(m_Dict);
1641   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
1642 }
1643
1644 JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1645 {
1646   assert(m_Dict);
1647   m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
1648   Copy(rhs);
1649 }
1650
1651
1652 //
1653 ASDCP::Result_t
1654 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1655 {
1656   assert(m_Dict);
1657   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1658   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1659   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1660   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1661   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1662   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1663   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1664   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1665   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1666   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1667   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi16(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, Csize));
1668   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1669   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1670   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1671   return result;
1672 }
1673
1674 //
1675 ASDCP::Result_t
1676 JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1677 {
1678   assert(m_Dict);
1679   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1680   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Rsize));
1681   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Xsize));
1682   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Ysize));
1683   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XOsize));
1684   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YOsize));
1685   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTsize));
1686   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTsize));
1687   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, XTOsize));
1688   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, YTOsize));
1689   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi16(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, Csize));
1690   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, PictureComponentSizing));
1691   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, CodingStyleDefault));
1692   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(JPEG2000PictureSubDescriptor, QuantizationDefault));
1693   return result;
1694 }
1695
1696 //
1697 void
1698 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
1699 {
1700   InterchangeObject::Copy(rhs);
1701   Rsize = rhs.Rsize;
1702   Xsize = rhs.Xsize;
1703   Ysize = rhs.Ysize;
1704   XOsize = rhs.XOsize;
1705   YOsize = rhs.YOsize;
1706   XTsize = rhs.XTsize;
1707   YTsize = rhs.YTsize;
1708   XTOsize = rhs.XTOsize;
1709   YTOsize = rhs.YTOsize;
1710   Csize = rhs.Csize;
1711   PictureComponentSizing = rhs.PictureComponentSizing;
1712   CodingStyleDefault = rhs.CodingStyleDefault;
1713   QuantizationDefault = rhs.QuantizationDefault;
1714 }
1715
1716 //
1717 void
1718 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
1719 {
1720   char identbuf[IdentBufferLen];
1721   *identbuf = 0;
1722
1723   if ( stream == 0 )
1724     stream = stderr;
1725
1726   InterchangeObject::Dump(stream);
1727   fprintf(stream, "  %22s = %d\n",  "Rsize", Rsize);
1728   fprintf(stream, "  %22s = %d\n",  "Xsize", Xsize);
1729   fprintf(stream, "  %22s = %d\n",  "Ysize", Ysize);
1730   fprintf(stream, "  %22s = %d\n",  "XOsize", XOsize);
1731   fprintf(stream, "  %22s = %d\n",  "YOsize", YOsize);
1732   fprintf(stream, "  %22s = %d\n",  "XTsize", XTsize);
1733   fprintf(stream, "  %22s = %d\n",  "YTsize", YTsize);
1734   fprintf(stream, "  %22s = %d\n",  "XTOsize", XTOsize);
1735   fprintf(stream, "  %22s = %d\n",  "YTOsize", YTOsize);
1736   fprintf(stream, "  %22s = %d\n",  "Csize", Csize);
1737   fprintf(stream, "  %22s = %s\n",  "PictureComponentSizing", PictureComponentSizing.EncodeString(identbuf, IdentBufferLen));
1738   fprintf(stream, "  %22s = %s\n",  "CodingStyleDefault", CodingStyleDefault.EncodeString(identbuf, IdentBufferLen));
1739   fprintf(stream, "  %22s = %s\n",  "QuantizationDefault", QuantizationDefault.EncodeString(identbuf, IdentBufferLen));
1740 }
1741
1742 //
1743 ASDCP::Result_t
1744 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1745 {
1746   return InterchangeObject::InitFromBuffer(p, l);
1747 }
1748
1749 //
1750 ASDCP::Result_t
1751 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1752 {
1753   return InterchangeObject::WriteToBuffer(Buffer);
1754 }
1755
1756 //------------------------------------------------------------------------------------------
1757 // CDCIEssenceDescriptor
1758
1759 //
1760
1761 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0)
1762 {
1763   assert(m_Dict);
1764   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
1765 }
1766
1767 CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1768 {
1769   assert(m_Dict);
1770   m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
1771   Copy(rhs);
1772 }
1773
1774
1775 //
1776 ASDCP::Result_t
1777 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1778 {
1779   assert(m_Dict);
1780   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
1781   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1782   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1783   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1784   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
1785   return result;
1786 }
1787
1788 //
1789 ASDCP::Result_t
1790 CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1791 {
1792   assert(m_Dict);
1793   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
1794   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ComponentDepth));
1795   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
1796   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
1797   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(CDCIEssenceDescriptor, ColorSiting));
1798   return result;
1799 }
1800
1801 //
1802 void
1803 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
1804 {
1805   GenericPictureEssenceDescriptor::Copy(rhs);
1806   ComponentDepth = rhs.ComponentDepth;
1807   HorizontalSubsampling = rhs.HorizontalSubsampling;
1808   VerticalSubsampling = rhs.VerticalSubsampling;
1809   ColorSiting = rhs.ColorSiting;
1810 }
1811
1812 //
1813 void
1814 CDCIEssenceDescriptor::Dump(FILE* stream)
1815 {
1816   char identbuf[IdentBufferLen];
1817   *identbuf = 0;
1818
1819   if ( stream == 0 )
1820     stream = stderr;
1821
1822   GenericPictureEssenceDescriptor::Dump(stream);
1823   fprintf(stream, "  %22s = %d\n",  "ComponentDepth", ComponentDepth);
1824   fprintf(stream, "  %22s = %d\n",  "HorizontalSubsampling", HorizontalSubsampling);
1825   fprintf(stream, "  %22s = %d\n",  "VerticalSubsampling", VerticalSubsampling);
1826   fprintf(stream, "  %22s = %d\n",  "ColorSiting", ColorSiting);
1827 }
1828
1829 //
1830 ASDCP::Result_t
1831 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1832 {
1833   return InterchangeObject::InitFromBuffer(p, l);
1834 }
1835
1836 //
1837 ASDCP::Result_t
1838 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1839 {
1840   return InterchangeObject::WriteToBuffer(Buffer);
1841 }
1842
1843 //------------------------------------------------------------------------------------------
1844 // MPEG2VideoDescriptor
1845
1846 //
1847
1848 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0)
1849 {
1850   assert(m_Dict);
1851   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
1852 }
1853
1854 MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
1855 {
1856   assert(m_Dict);
1857   m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
1858   Copy(rhs);
1859 }
1860
1861
1862 //
1863 ASDCP::Result_t
1864 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
1865 {
1866   assert(m_Dict);
1867   Result_t result = CDCIEssenceDescriptor::InitFromTLVSet(TLVSet);
1868   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, CodedContentType));
1869   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, LowDelay));
1870   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor, BitRate));
1871   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1872   return result;
1873 }
1874
1875 //
1876 ASDCP::Result_t
1877 MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
1878 {
1879   assert(m_Dict);
1880   Result_t result = CDCIEssenceDescriptor::WriteToTLVSet(TLVSet);
1881   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, CodedContentType));
1882   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, LowDelay));
1883   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, BitRate));
1884   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi8(OBJ_WRITE_ARGS(MPEG2VideoDescriptor, ProfileAndLevel));
1885   return result;
1886 }
1887
1888 //
1889 void
1890 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
1891 {
1892   CDCIEssenceDescriptor::Copy(rhs);
1893   CodedContentType = rhs.CodedContentType;
1894   LowDelay = rhs.LowDelay;
1895   BitRate = rhs.BitRate;
1896   ProfileAndLevel = rhs.ProfileAndLevel;
1897 }
1898
1899 //
1900 void
1901 MPEG2VideoDescriptor::Dump(FILE* stream)
1902 {
1903   char identbuf[IdentBufferLen];
1904   *identbuf = 0;
1905
1906   if ( stream == 0 )
1907     stream = stderr;
1908
1909   CDCIEssenceDescriptor::Dump(stream);
1910   fprintf(stream, "  %22s = %d\n",  "CodedContentType", CodedContentType);
1911   fprintf(stream, "  %22s = %d\n",  "LowDelay", LowDelay);
1912   fprintf(stream, "  %22s = %d\n",  "BitRate", BitRate);
1913   fprintf(stream, "  %22s = %d\n",  "ProfileAndLevel", ProfileAndLevel);
1914 }
1915
1916 //
1917 ASDCP::Result_t
1918 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
1919 {
1920   return InterchangeObject::InitFromBuffer(p, l);
1921 }
1922
1923 //
1924 ASDCP::Result_t
1925 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
1926 {
1927   return InterchangeObject::WriteToBuffer(Buffer);
1928 }
1929
1930 //------------------------------------------------------------------------------------------
1931 // DMSegment
1932
1933 //
1934
1935 DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
1936 {
1937   assert(m_Dict);
1938   m_UL = m_Dict->ul(MDD_DMSegment);
1939 }
1940
1941 DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
1942 {
1943   assert(m_Dict);
1944   m_UL = m_Dict->ul(MDD_DMSegment);
1945   Copy(rhs);
1946 }
1947
1948
1949 //
1950 ASDCP::Result_t
1951 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
1952 {
1953   assert(m_Dict);
1954   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
1955   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DataDefinition));
1956   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, EventStartPosition));
1957   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi64(OBJ_READ_ARGS(DMSegment, Duration));
1958   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, EventComment));
1959   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(DMSegment, DMFramework));
1960   return result;
1961 }
1962
1963 //
1964 ASDCP::Result_t
1965 DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
1966 {
1967   assert(m_Dict);
1968   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
1969   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DataDefinition));
1970   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, EventStartPosition));
1971   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi64(OBJ_WRITE_ARGS(DMSegment, Duration));
1972   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, EventComment));
1973   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(DMSegment, DMFramework));
1974   return result;
1975 }
1976
1977 //
1978 void
1979 DMSegment::Copy(const DMSegment& rhs)
1980 {
1981   InterchangeObject::Copy(rhs);
1982   DataDefinition = rhs.DataDefinition;
1983   EventStartPosition = rhs.EventStartPosition;
1984   Duration = rhs.Duration;
1985   EventComment = rhs.EventComment;
1986   DMFramework = rhs.DMFramework;
1987 }
1988
1989 //
1990 void
1991 DMSegment::Dump(FILE* stream)
1992 {
1993   char identbuf[IdentBufferLen];
1994   *identbuf = 0;
1995
1996   if ( stream == 0 )
1997     stream = stderr;
1998
1999   InterchangeObject::Dump(stream);
2000   fprintf(stream, "  %22s = %s\n",  "DataDefinition", DataDefinition.EncodeString(identbuf, IdentBufferLen));
2001   fprintf(stream, "  %22s = %s\n",  "EventStartPosition", i64sz(EventStartPosition, identbuf));
2002   fprintf(stream, "  %22s = %s\n",  "Duration", i64sz(Duration, identbuf));
2003   fprintf(stream, "  %22s = %s\n",  "EventComment", EventComment.EncodeString(identbuf, IdentBufferLen));
2004   fprintf(stream, "  %22s = %s\n",  "DMFramework", DMFramework.EncodeString(identbuf, IdentBufferLen));
2005 }
2006
2007 //
2008 ASDCP::Result_t
2009 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
2010 {
2011   return InterchangeObject::InitFromBuffer(p, l);
2012 }
2013
2014 //
2015 ASDCP::Result_t
2016 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2017 {
2018   return InterchangeObject::WriteToBuffer(Buffer);
2019 }
2020
2021 //------------------------------------------------------------------------------------------
2022 // CryptographicFramework
2023
2024 //
2025
2026 CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2027 {
2028   assert(m_Dict);
2029   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2030 }
2031
2032 CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2033 {
2034   assert(m_Dict);
2035   m_UL = m_Dict->ul(MDD_CryptographicFramework);
2036   Copy(rhs);
2037 }
2038
2039
2040 //
2041 ASDCP::Result_t
2042 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
2043 {
2044   assert(m_Dict);
2045   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2046   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
2047   return result;
2048 }
2049
2050 //
2051 ASDCP::Result_t
2052 CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
2053 {
2054   assert(m_Dict);
2055   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2056   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicFramework, ContextSR));
2057   return result;
2058 }
2059
2060 //
2061 void
2062 CryptographicFramework::Copy(const CryptographicFramework& rhs)
2063 {
2064   InterchangeObject::Copy(rhs);
2065   ContextSR = rhs.ContextSR;
2066 }
2067
2068 //
2069 void
2070 CryptographicFramework::Dump(FILE* stream)
2071 {
2072   char identbuf[IdentBufferLen];
2073   *identbuf = 0;
2074
2075   if ( stream == 0 )
2076     stream = stderr;
2077
2078   InterchangeObject::Dump(stream);
2079   fprintf(stream, "  %22s = %s\n",  "ContextSR", ContextSR.EncodeString(identbuf, IdentBufferLen));
2080 }
2081
2082 //
2083 ASDCP::Result_t
2084 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
2085 {
2086   return InterchangeObject::InitFromBuffer(p, l);
2087 }
2088
2089 //
2090 ASDCP::Result_t
2091 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2092 {
2093   return InterchangeObject::WriteToBuffer(Buffer);
2094 }
2095
2096 //------------------------------------------------------------------------------------------
2097 // CryptographicContext
2098
2099 //
2100
2101 CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2102 {
2103   assert(m_Dict);
2104   m_UL = m_Dict->ul(MDD_CryptographicContext);
2105 }
2106
2107 CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2108 {
2109   assert(m_Dict);
2110   m_UL = m_Dict->ul(MDD_CryptographicContext);
2111   Copy(rhs);
2112 }
2113
2114
2115 //
2116 ASDCP::Result_t
2117 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
2118 {
2119   assert(m_Dict);
2120   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2121   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
2122   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
2123   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
2124   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
2125   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
2126   return result;
2127 }
2128
2129 //
2130 ASDCP::Result_t
2131 CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
2132 {
2133   assert(m_Dict);
2134   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2135   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, ContextID));
2136   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, SourceEssenceContainer));
2137   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CipherAlgorithm));
2138   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, MICAlgorithm));
2139   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(CryptographicContext, CryptographicKeyID));
2140   return result;
2141 }
2142
2143 //
2144 void
2145 CryptographicContext::Copy(const CryptographicContext& rhs)
2146 {
2147   InterchangeObject::Copy(rhs);
2148   ContextID = rhs.ContextID;
2149   SourceEssenceContainer = rhs.SourceEssenceContainer;
2150   CipherAlgorithm = rhs.CipherAlgorithm;
2151   MICAlgorithm = rhs.MICAlgorithm;
2152   CryptographicKeyID = rhs.CryptographicKeyID;
2153 }
2154
2155 //
2156 void
2157 CryptographicContext::Dump(FILE* stream)
2158 {
2159   char identbuf[IdentBufferLen];
2160   *identbuf = 0;
2161
2162   if ( stream == 0 )
2163     stream = stderr;
2164
2165   InterchangeObject::Dump(stream);
2166   fprintf(stream, "  %22s = %s\n",  "ContextID", ContextID.EncodeString(identbuf, IdentBufferLen));
2167   fprintf(stream, "  %22s = %s\n",  "SourceEssenceContainer", SourceEssenceContainer.EncodeString(identbuf, IdentBufferLen));
2168   fprintf(stream, "  %22s = %s\n",  "CipherAlgorithm", CipherAlgorithm.EncodeString(identbuf, IdentBufferLen));
2169   fprintf(stream, "  %22s = %s\n",  "MICAlgorithm", MICAlgorithm.EncodeString(identbuf, IdentBufferLen));
2170   fprintf(stream, "  %22s = %s\n",  "CryptographicKeyID", CryptographicKeyID.EncodeString(identbuf, IdentBufferLen));
2171 }
2172
2173 //
2174 ASDCP::Result_t
2175 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
2176 {
2177   return InterchangeObject::InitFromBuffer(p, l);
2178 }
2179
2180 //
2181 ASDCP::Result_t
2182 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2183 {
2184   return InterchangeObject::WriteToBuffer(Buffer);
2185 }
2186
2187 //------------------------------------------------------------------------------------------
2188 // GenericDataEssenceDescriptor
2189
2190 //
2191
2192 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
2193 {
2194   assert(m_Dict);
2195   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2196 }
2197
2198 GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2199 {
2200   assert(m_Dict);
2201   m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
2202   Copy(rhs);
2203 }
2204
2205
2206 //
2207 ASDCP::Result_t
2208 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2209 {
2210   assert(m_Dict);
2211   Result_t result = FileDescriptor::InitFromTLVSet(TLVSet);
2212   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2213   return result;
2214 }
2215
2216 //
2217 ASDCP::Result_t
2218 GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2219 {
2220   assert(m_Dict);
2221   Result_t result = FileDescriptor::WriteToTLVSet(TLVSet);
2222   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(GenericDataEssenceDescriptor, DataEssenceCoding));
2223   return result;
2224 }
2225
2226 //
2227 void
2228 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
2229 {
2230   FileDescriptor::Copy(rhs);
2231   DataEssenceCoding = rhs.DataEssenceCoding;
2232 }
2233
2234 //
2235 void
2236 GenericDataEssenceDescriptor::Dump(FILE* stream)
2237 {
2238   char identbuf[IdentBufferLen];
2239   *identbuf = 0;
2240
2241   if ( stream == 0 )
2242     stream = stderr;
2243
2244   FileDescriptor::Dump(stream);
2245   fprintf(stream, "  %22s = %s\n",  "DataEssenceCoding", DataEssenceCoding.EncodeString(identbuf, IdentBufferLen));
2246 }
2247
2248 //
2249 ASDCP::Result_t
2250 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2251 {
2252   return InterchangeObject::InitFromBuffer(p, l);
2253 }
2254
2255 //
2256 ASDCP::Result_t
2257 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2258 {
2259   return InterchangeObject::WriteToBuffer(Buffer);
2260 }
2261
2262 //------------------------------------------------------------------------------------------
2263 // TimedTextDescriptor
2264
2265 //
2266
2267 TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
2268 {
2269   assert(m_Dict);
2270   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2271 }
2272
2273 TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2274 {
2275   assert(m_Dict);
2276   m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
2277   Copy(rhs);
2278 }
2279
2280
2281 //
2282 ASDCP::Result_t
2283 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2284 {
2285   assert(m_Dict);
2286   Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
2287   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, ResourceID));
2288   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, UCSEncoding));
2289   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextDescriptor, NamespaceURI));
2290   return result;
2291 }
2292
2293 //
2294 ASDCP::Result_t
2295 TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2296 {
2297   assert(m_Dict);
2298   Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
2299   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, ResourceID));
2300   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, UCSEncoding));
2301   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextDescriptor, NamespaceURI));
2302   return result;
2303 }
2304
2305 //
2306 void
2307 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
2308 {
2309   GenericDataEssenceDescriptor::Copy(rhs);
2310   ResourceID = rhs.ResourceID;
2311   UCSEncoding = rhs.UCSEncoding;
2312   NamespaceURI = rhs.NamespaceURI;
2313 }
2314
2315 //
2316 void
2317 TimedTextDescriptor::Dump(FILE* stream)
2318 {
2319   char identbuf[IdentBufferLen];
2320   *identbuf = 0;
2321
2322   if ( stream == 0 )
2323     stream = stderr;
2324
2325   GenericDataEssenceDescriptor::Dump(stream);
2326   fprintf(stream, "  %22s = %s\n",  "ResourceID", ResourceID.EncodeString(identbuf, IdentBufferLen));
2327   fprintf(stream, "  %22s = %s\n",  "UCSEncoding", UCSEncoding.EncodeString(identbuf, IdentBufferLen));
2328   fprintf(stream, "  %22s = %s\n",  "NamespaceURI", NamespaceURI.EncodeString(identbuf, IdentBufferLen));
2329 }
2330
2331 //
2332 ASDCP::Result_t
2333 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2334 {
2335   return InterchangeObject::InitFromBuffer(p, l);
2336 }
2337
2338 //
2339 ASDCP::Result_t
2340 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2341 {
2342   return InterchangeObject::WriteToBuffer(Buffer);
2343 }
2344
2345 //------------------------------------------------------------------------------------------
2346 // TimedTextResourceSubDescriptor
2347
2348 //
2349
2350 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
2351 {
2352   assert(m_Dict);
2353   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2354 }
2355
2356 TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2357 {
2358   assert(m_Dict);
2359   m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
2360   Copy(rhs);
2361 }
2362
2363
2364 //
2365 ASDCP::Result_t
2366 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2367 {
2368   assert(m_Dict);
2369   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2370   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2371   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2372   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2373   return result;
2374 }
2375
2376 //
2377 ASDCP::Result_t
2378 TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2379 {
2380   assert(m_Dict);
2381   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2382   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, AncillaryResourceID));
2383   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, MIMEMediaType));
2384   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(TimedTextResourceSubDescriptor, EssenceStreamID));
2385   return result;
2386 }
2387
2388 //
2389 void
2390 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
2391 {
2392   InterchangeObject::Copy(rhs);
2393   AncillaryResourceID = rhs.AncillaryResourceID;
2394   MIMEMediaType = rhs.MIMEMediaType;
2395   EssenceStreamID = rhs.EssenceStreamID;
2396 }
2397
2398 //
2399 void
2400 TimedTextResourceSubDescriptor::Dump(FILE* stream)
2401 {
2402   char identbuf[IdentBufferLen];
2403   *identbuf = 0;
2404
2405   if ( stream == 0 )
2406     stream = stderr;
2407
2408   InterchangeObject::Dump(stream);
2409   fprintf(stream, "  %22s = %s\n",  "AncillaryResourceID", AncillaryResourceID.EncodeString(identbuf, IdentBufferLen));
2410   fprintf(stream, "  %22s = %s\n",  "MIMEMediaType", MIMEMediaType.EncodeString(identbuf, IdentBufferLen));
2411   fprintf(stream, "  %22s = %d\n",  "EssenceStreamID", EssenceStreamID);
2412 }
2413
2414 //
2415 ASDCP::Result_t
2416 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2417 {
2418   return InterchangeObject::InitFromBuffer(p, l);
2419 }
2420
2421 //
2422 ASDCP::Result_t
2423 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2424 {
2425   return InterchangeObject::WriteToBuffer(Buffer);
2426 }
2427
2428 //------------------------------------------------------------------------------------------
2429 // StereoscopicPictureSubDescriptor
2430
2431 //
2432
2433 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2434 {
2435   assert(m_Dict);
2436   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2437 }
2438
2439 StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2440 {
2441   assert(m_Dict);
2442   m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
2443   Copy(rhs);
2444 }
2445
2446
2447 //
2448 ASDCP::Result_t
2449 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2450 {
2451   assert(m_Dict);
2452   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2453   return result;
2454 }
2455
2456 //
2457 ASDCP::Result_t
2458 StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2459 {
2460   assert(m_Dict);
2461   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2462   return result;
2463 }
2464
2465 //
2466 void
2467 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
2468 {
2469   InterchangeObject::Copy(rhs);
2470 }
2471
2472 //
2473 void
2474 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
2475 {
2476   char identbuf[IdentBufferLen];
2477   *identbuf = 0;
2478
2479   if ( stream == 0 )
2480     stream = stderr;
2481
2482   InterchangeObject::Dump(stream);
2483 }
2484
2485 //
2486 ASDCP::Result_t
2487 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2488 {
2489   return InterchangeObject::InitFromBuffer(p, l);
2490 }
2491
2492 //
2493 ASDCP::Result_t
2494 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2495 {
2496   return InterchangeObject::WriteToBuffer(Buffer);
2497 }
2498
2499 //------------------------------------------------------------------------------------------
2500 // NetworkLocator
2501
2502 //
2503
2504 NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
2505 {
2506   assert(m_Dict);
2507   m_UL = m_Dict->ul(MDD_NetworkLocator);
2508 }
2509
2510 NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2511 {
2512   assert(m_Dict);
2513   m_UL = m_Dict->ul(MDD_NetworkLocator);
2514   Copy(rhs);
2515 }
2516
2517
2518 //
2519 ASDCP::Result_t
2520 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
2521 {
2522   assert(m_Dict);
2523   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2524   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(NetworkLocator, URLString));
2525   return result;
2526 }
2527
2528 //
2529 ASDCP::Result_t
2530 NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
2531 {
2532   assert(m_Dict);
2533   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2534   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(NetworkLocator, URLString));
2535   return result;
2536 }
2537
2538 //
2539 void
2540 NetworkLocator::Copy(const NetworkLocator& rhs)
2541 {
2542   InterchangeObject::Copy(rhs);
2543   URLString = rhs.URLString;
2544 }
2545
2546 //
2547 void
2548 NetworkLocator::Dump(FILE* stream)
2549 {
2550   char identbuf[IdentBufferLen];
2551   *identbuf = 0;
2552
2553   if ( stream == 0 )
2554     stream = stderr;
2555
2556   InterchangeObject::Dump(stream);
2557   fprintf(stream, "  %22s = %s\n",  "URLString", URLString.EncodeString(identbuf, IdentBufferLen));
2558 }
2559
2560 //
2561 ASDCP::Result_t
2562 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
2563 {
2564   return InterchangeObject::InitFromBuffer(p, l);
2565 }
2566
2567 //
2568 ASDCP::Result_t
2569 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2570 {
2571   return InterchangeObject::WriteToBuffer(Buffer);
2572 }
2573
2574 //------------------------------------------------------------------------------------------
2575 // MCALabelSubDescriptor
2576
2577 //
2578
2579 MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), MCAChannelID(0)
2580 {
2581   assert(m_Dict);
2582   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
2583 }
2584
2585 MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
2586 {
2587   assert(m_Dict);
2588   m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
2589   Copy(rhs);
2590 }
2591
2592
2593 //
2594 ASDCP::Result_t
2595 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2596 {
2597   assert(m_Dict);
2598   Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
2599   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
2600   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
2601   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
2602   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagName));
2603   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MCALabelSubDescriptor, MCAChannelID));
2604   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage));
2605   return result;
2606 }
2607
2608 //
2609 ASDCP::Result_t
2610 MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2611 {
2612   assert(m_Dict);
2613   Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
2614   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
2615   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
2616   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
2617   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagName));
2618   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCAChannelID));
2619   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage));
2620   return result;
2621 }
2622
2623 //
2624 void
2625 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
2626 {
2627   InterchangeObject::Copy(rhs);
2628   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
2629   MCALinkID = rhs.MCALinkID;
2630   MCATagSymbol = rhs.MCATagSymbol;
2631   MCATagName = rhs.MCATagName;
2632   MCAChannelID = rhs.MCAChannelID;
2633   RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
2634 }
2635
2636 //
2637 void
2638 MCALabelSubDescriptor::Dump(FILE* stream)
2639 {
2640   char identbuf[IdentBufferLen];
2641   *identbuf = 0;
2642
2643   if ( stream == 0 )
2644     stream = stderr;
2645
2646   InterchangeObject::Dump(stream);
2647   fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
2648   fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
2649   fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
2650   fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.EncodeString(identbuf, IdentBufferLen));
2651   fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID);
2652   fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.EncodeString(identbuf, IdentBufferLen));
2653 }
2654
2655 //
2656 ASDCP::Result_t
2657 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2658 {
2659   return InterchangeObject::InitFromBuffer(p, l);
2660 }
2661
2662 //
2663 ASDCP::Result_t
2664 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2665 {
2666   return InterchangeObject::WriteToBuffer(Buffer);
2667 }
2668
2669 //------------------------------------------------------------------------------------------
2670 // AudioChannelLabelSubDescriptor
2671
2672 //
2673
2674 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
2675 {
2676   assert(m_Dict);
2677   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
2678 }
2679
2680 AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2681 {
2682   assert(m_Dict);
2683   m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
2684   Copy(rhs);
2685 }
2686
2687
2688 //
2689 ASDCP::Result_t
2690 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2691 {
2692   assert(m_Dict);
2693   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
2694   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
2695   return result;
2696 }
2697
2698 //
2699 ASDCP::Result_t
2700 AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2701 {
2702   assert(m_Dict);
2703   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
2704   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
2705   return result;
2706 }
2707
2708 //
2709 void
2710 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
2711 {
2712   MCALabelSubDescriptor::Copy(rhs);
2713   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
2714 }
2715
2716 //
2717 void
2718 AudioChannelLabelSubDescriptor::Dump(FILE* stream)
2719 {
2720   char identbuf[IdentBufferLen];
2721   *identbuf = 0;
2722
2723   if ( stream == 0 )
2724     stream = stderr;
2725
2726   MCALabelSubDescriptor::Dump(stream);
2727   fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.EncodeString(identbuf, IdentBufferLen));
2728 }
2729
2730 //
2731 ASDCP::Result_t
2732 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2733 {
2734   return InterchangeObject::InitFromBuffer(p, l);
2735 }
2736
2737 //
2738 ASDCP::Result_t
2739 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2740 {
2741   return InterchangeObject::WriteToBuffer(Buffer);
2742 }
2743
2744 //------------------------------------------------------------------------------------------
2745 // SoundfieldGroupLabelSubDescriptor
2746
2747 //
2748
2749 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
2750 {
2751   assert(m_Dict);
2752   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
2753 }
2754
2755 SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2756 {
2757   assert(m_Dict);
2758   m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
2759   Copy(rhs);
2760 }
2761
2762
2763 //
2764 ASDCP::Result_t
2765 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2766 {
2767   assert(m_Dict);
2768   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
2769   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
2770   return result;
2771 }
2772
2773 //
2774 ASDCP::Result_t
2775 SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2776 {
2777   assert(m_Dict);
2778   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
2779   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
2780   return result;
2781 }
2782
2783 //
2784 void
2785 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
2786 {
2787   MCALabelSubDescriptor::Copy(rhs);
2788   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
2789 }
2790
2791 //
2792 void
2793 SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
2794 {
2795   char identbuf[IdentBufferLen];
2796   *identbuf = 0;
2797
2798   if ( stream == 0 )
2799     stream = stderr;
2800
2801   MCALabelSubDescriptor::Dump(stream);
2802   fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
2803   GroupOfSoundfieldGroupsLinkID.Dump(stream);
2804 }
2805
2806 //
2807 ASDCP::Result_t
2808 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2809 {
2810   return InterchangeObject::InitFromBuffer(p, l);
2811 }
2812
2813 //
2814 ASDCP::Result_t
2815 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2816 {
2817   return InterchangeObject::WriteToBuffer(Buffer);
2818 }
2819
2820 //------------------------------------------------------------------------------------------
2821 // GroupOfSoundfieldGroupsLabelSubDescriptor
2822
2823 //
2824
2825 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
2826 {
2827   assert(m_Dict);
2828   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
2829 }
2830
2831 GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
2832 {
2833   assert(m_Dict);
2834   m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
2835   Copy(rhs);
2836 }
2837
2838
2839 //
2840 ASDCP::Result_t
2841 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
2842 {
2843   assert(m_Dict);
2844   Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
2845   return result;
2846 }
2847
2848 //
2849 ASDCP::Result_t
2850 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
2851 {
2852   assert(m_Dict);
2853   Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
2854   return result;
2855 }
2856
2857 //
2858 void
2859 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
2860 {
2861   MCALabelSubDescriptor::Copy(rhs);
2862 }
2863
2864 //
2865 void
2866 GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
2867 {
2868   char identbuf[IdentBufferLen];
2869   *identbuf = 0;
2870
2871   if ( stream == 0 )
2872     stream = stderr;
2873
2874   MCALabelSubDescriptor::Dump(stream);
2875 }
2876
2877 //
2878 ASDCP::Result_t
2879 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
2880 {
2881   return InterchangeObject::InitFromBuffer(p, l);
2882 }
2883
2884 //
2885 ASDCP::Result_t
2886 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
2887 {
2888   return InterchangeObject::WriteToBuffer(Buffer);
2889 }
2890
2891 //
2892 // end Metadata.cpp
2893 //