src/Metadata.cpp

   1 /*
   2 Copyright (c) 2005-2006, 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 "Metadata.h"
  34 #include "MDD.h"
  35 #include <hex_utils.h>
  36
  37
  38 //------------------------------------------------------------------------------------------
  39 //
  40
  41 //
  42 ASDCP::Result_t
  43 ASDCP::MXF::Identification::InitFromBuffer(const byte_t* p, ui32_t l)
  44 {
  45   ASDCP_TEST_NULL(p);
  46
  47   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_Identification].ul);
  48
  49   if ( ASDCP_SUCCESS(result) )
  50     {
  51       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
  52
  53       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
  54       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ThisGenerationUID));
  55       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, CompanyName));
  56       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ProductName));
  57       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(Identification, ProductVersion));
  58       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, VersionString));
  59       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ProductUID));
  60       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, ModificationDate));
  61       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(Identification, ToolkitVersion));
  62       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Identification, Platform));
  63     }
  64
  65   return result;
  66 }
  67
  68 //
  69 ASDCP::Result_t
  70 ASDCP::MXF::Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
  71 {
  72   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_Identification].ul, 0);
  73 }
  74
  75
  76 //
  77 void
  78 ASDCP::MXF::Identification::Dump(FILE* stream)
  79 {
  80   char identbuf[IdentBufferLen];
  81
  82   if ( stream == 0 )
  83     stream = stderr;
  84
  85   KLVPacket::Dump(stream, false);
  86   fprintf(stream, "  InstanceUID        = %s\n",  InstanceUID.ToString(identbuf));
  87   fprintf(stream, "  ThisGenerationUID  = %s\n",  ThisGenerationUID.ToString(identbuf));
  88   fprintf(stream, "  CompanyName        = %s\n",  CompanyName.ToString(identbuf));
  89   fprintf(stream, "  ProductName        = %s\n",  ProductName.ToString(identbuf));
  90   fprintf(stream, "  ProductVersion     = %hu\n", ProductVersion);
  91   fprintf(stream, "  VersionString      = %s\n",  VersionString.ToString(identbuf));
  92   fprintf(stream, "  ProductUID         = %s\n",  ProductUID.ToString(identbuf));
  93   fprintf(stream, "  ModificationDate   = %s\n",  ModificationDate.ToString(identbuf));
  94   fprintf(stream, "  ToolkitVersion     = %hu\n", ToolkitVersion);
  95   fprintf(stream, "  Platform           = %s\n",  Platform.ToString(identbuf));
  96
  97   fputs("==========================================================================\n", stream);
  98 }
  99
 100 //------------------------------------------------------------------------------------------
 101 //
 102
 103 //
 104 ASDCP::Result_t
 105 ASDCP::MXF::ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 106 {
 107   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_ContentStorage].ul);
 108
 109   if ( ASDCP_SUCCESS(result) )
 110     {
 111       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 112
 113       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 114       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 115       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(ContentStorage, Packages));
 116       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(ContentStorage, EssenceContainerData));
 117     }
 118
 119   return result;
 120 }
 121
 122 //
 123 ASDCP::Result_t
 124 ASDCP::MXF::ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 125 {
 126   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_ContentStorage].ul, 0);
 127 }
 128
 129 //
 130 void
 131 ASDCP::MXF::ContentStorage::Dump(FILE* stream)
 132 {
 133   char identbuf[IdentBufferLen];
 134
 135   if ( stream == 0 )
 136     stream = stderr;
 137
 138   KLVPacket::Dump(stream, false);
 139   fprintf(stream, "  InstanceUID        = %s\n",  InstanceUID.ToString(identbuf));
 140   fprintf(stream, "  GenerationUID      = %s\n",  GenerationUID.ToString(identbuf));
 141   fprintf(stream, "  Packages:\n");  Packages.Dump(stream);
 142   fprintf(stream, "  EssenceContainerData:\n");  EssenceContainerData.Dump(stream);
 143
 144   fputs("==========================================================================\n", stream);
 145 }
 146
 147 //------------------------------------------------------------------------------------------
 148 //
 149
 150 //
 151 ASDCP::Result_t
 152 ASDCP::MXF::GenericPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 153 {
 154   TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 155
 156   Result_t result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 157   //      result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 158   if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 159   if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageUID));
 160   if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, Name));
 161   if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageCreationDate));
 162   if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, PackageModifiedDate));
 163   if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericPackage, Tracks));
 164
 165   return result;
 166 }
 167
 168 //
 169 ASDCP::Result_t
 170 ASDCP::MXF::GenericPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 171 {
 172   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_DefaultObject].ul, 0);
 173 }
 174
 175 //
 176 void
 177 ASDCP::MXF::GenericPackage::Dump(FILE* stream)
 178 {
 179   char identbuf[IdentBufferLen];
 180
 181   if ( stream == 0 )
 182     stream = stderr;
 183
 184   KLVPacket::Dump(stream, false);
 185   fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
 186   fprintf(stream, "  GenerationUID      = %s\n", GenerationUID.ToString(identbuf));
 187   fprintf(stream, "  PackageUID         = %s\n", PackageUID.ToString(identbuf));
 188   fprintf(stream, "  Name               = %s\n", Name.ToString(identbuf));
 189   fprintf(stream, "  PackageCreationDate= %s\n", PackageCreationDate.ToString(identbuf));
 190   fprintf(stream, "  PackageModifiedDate= %s\n", PackageModifiedDate.ToString(identbuf));
 191   fprintf(stream, "  Tracks:\n");  Tracks.Dump(stream);
 192
 193   fputs("==========================================================================\n", stream);
 194 }
 195
 196
 197 //------------------------------------------------------------------------------------------
 198 //
 199
 200 //
 201 ASDCP::Result_t
 202 ASDCP::MXF::MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 203 {
 204   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_MaterialPackage].ul);
 205
 206   if ( ASDCP_SUCCESS(result) )
 207     {
 208       return GenericPackage::InitFromBuffer(p, l);
 209     }
 210
 211   return result;
 212 }
 213
 214 //
 215 ASDCP::Result_t
 216 ASDCP::MXF::MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 217 {
 218   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_MaterialPackage].ul, 0);
 219 }
 220
 221 //
 222 void
 223 ASDCP::MXF::MaterialPackage::Dump(FILE* stream)
 224 {
 225   GenericPackage::Dump(stream);
 226 }
 227
 228
 229 //------------------------------------------------------------------------------------------
 230 //
 231
 232 //
 233 ASDCP::Result_t
 234 ASDCP::MXF::SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 235 {
 236   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_SourcePackage].ul);
 237
 238   if ( ASDCP_SUCCESS(result) )
 239     {
 240       return GenericPackage::InitFromBuffer(p, l);
 241     }
 242
 243   return result;
 244 }
 245
 246 //
 247 ASDCP::Result_t
 248 ASDCP::MXF::SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 249 {
 250   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_SourcePackage].ul, 0);
 251 }
 252
 253 //
 254 void
 255 ASDCP::MXF::SourcePackage::Dump(FILE* stream)
 256 {
 257   GenericPackage::Dump(stream);
 258 }
 259
 260 //------------------------------------------------------------------------------------------
 261 //
 262
 263 //
 264 ASDCP::Result_t
 265 ASDCP::MXF::Track::InitFromBuffer(const byte_t* p, ui32_t l)
 266 {
 267   ASDCP_TEST_NULL(p);
 268
 269   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_Track].ul);
 270
 271   if ( ASDCP_SUCCESS(result) )
 272     {
 273       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 274
 275       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 276       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 277       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackID));
 278       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericTrack, TrackNumber));
 279       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericTrack, TrackName));
 280       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericTrack, Sequence));
 281       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Track, EditRate));
 282       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(Track, Origin));
 283     }
 284
 285   return result;
 286 }
 287
 288 //
 289 ASDCP::Result_t
 290 ASDCP::MXF::Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 291 {
 292   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_Track].ul, 0);
 293 }
 294
 295 //
 296 void
 297 ASDCP::MXF::Track::Dump(FILE* stream)
 298 {
 299   char identbuf[IdentBufferLen];
 300
 301   if ( stream == 0 )
 302     stream = stderr;
 303
 304   KLVPacket::Dump(stream, false);
 305   fprintf(stream, "  InstanceUID        = %s\n",  InstanceUID.ToString(identbuf));
 306   fprintf(stream, "  GenerationUID      = %s\n",  GenerationUID.ToString(identbuf));
 307   fprintf(stream, "  TrackID            = %lu\n", TrackID);
 308   fprintf(stream, "  TrackNumber        = %lu\n", TrackNumber);
 309   fprintf(stream, "  TrackName          = %s\n",  TrackName.ToString(identbuf));
 310   fprintf(stream, "  Sequence           = %s\n",  Sequence.ToString(identbuf));
 311   fprintf(stream, "  EditRate           = %s\n",  EditRate.ToString(identbuf));
 312   fprintf(stream, "  Origin             = %s\n",  i64sz(Origin, identbuf));
 313
 314   fputs("==========================================================================\n", stream);
 315 }
 316
 317 //------------------------------------------------------------------------------------------
 318 //
 319
 320 //
 321 ASDCP::Result_t
 322 ASDCP::MXF::Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 323 {
 324   ASDCP_TEST_NULL(p);
 325
 326   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_Sequence].ul);
 327
 328   if ( ASDCP_SUCCESS(result) )
 329     {
 330       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 331
 332       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 333       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 334       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 335       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
 336       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(Sequence, StructuralComponents));
 337     }
 338
 339   return result;
 340 }
 341
 342 //
 343 ASDCP::Result_t
 344 ASDCP::MXF::Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 345 {
 346   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_Sequence].ul, 0);
 347 }
 348
 349 //
 350 void
 351 ASDCP::MXF::Sequence::Dump(FILE* stream)
 352 {
 353   char identbuf[IdentBufferLen];
 354
 355   if ( stream == 0 )
 356     stream = stderr;
 357
 358   const MDDEntry* Entry = GetMDDEntry(DataDefinition.Data());
 359
 360   KLVPacket::Dump(stream, false);
 361   fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
 362   fprintf(stream, "  DataDefinition     = %s (%s)\n", DataDefinition.ToString(identbuf), (Entry ? Entry->name : "Unknown"));
 363   fprintf(stream, "  Duration           = %s\n", ui64sz(Duration, identbuf));
 364   fprintf(stream, "  StructuralComponents:\n");  StructuralComponents.Dump(stream);
 365
 366   fputs("==========================================================================\n", stream);
 367 }
 368
 369
 370
 371 //------------------------------------------------------------------------------------------
 372 //
 373
 374 //
 375 ASDCP::Result_t
 376 ASDCP::MXF::SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 377 {
 378   ASDCP_TEST_NULL(p);
 379
 380   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_SourceClip].ul);
 381
 382   if ( ASDCP_SUCCESS(result) )
 383     {
 384       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 385
 386       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 387       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 388       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 389       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(SourceClip, StartPosition));
 390       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
 391       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(SourceClip, SourcePackageID));
 392       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(SourceClip, SourceTrackID));
 393     }
 394
 395   return result;
 396 }
 397
 398 //
 399 ASDCP::Result_t
 400 ASDCP::MXF::SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 401 {
 402   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_SourceClip].ul, 0);
 403 }
 404
 405 //
 406 void
 407 ASDCP::MXF::SourceClip::Dump(FILE* stream)
 408 {
 409   char identbuf[IdentBufferLen];
 410
 411   if ( stream == 0 )
 412     stream = stderr;
 413
 414   KLVPacket::Dump(stream, false);
 415   fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
 416   fprintf(stream, "  DataDefinition     = %s\n", DataDefinition.ToString(identbuf));
 417   fprintf(stream, "  StartPosition      = %s\n", ui64sz(StartPosition, identbuf));
 418   fprintf(stream, "  SourcePackageID    = %s\n", SourcePackageID.ToString(identbuf));
 419   fprintf(stream, "  SourcePackageID    = %u\n", SourceTrackID);
 420
 421   fputs("==========================================================================\n", stream);
 422 }
 423
 424
 425 //------------------------------------------------------------------------------------------
 426 //
 427
 428 //
 429 ASDCP::Result_t
 430 ASDCP::MXF::TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 431 {
 432   ASDCP_TEST_NULL(p);
 433
 434   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_TimecodeComponent].ul);
 435
 436   if ( ASDCP_SUCCESS(result) )
 437     {
 438       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 439
 440       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 441       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 442       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(StructuralComponent, DataDefinition));
 443       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(StructuralComponent, Duration));
 444       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(TimecodeComponent, RoundedTimecodeBase));
 445       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(TimecodeComponent, StartTimecode));
 446       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(TimecodeComponent, DropFrame));
 447     }
 448
 449   return result;
 450 }
 451
 452 //
 453 ASDCP::Result_t
 454 ASDCP::MXF::TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 455 {
 456   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_TimecodeComponent].ul, 0);
 457 }
 458
 459 //
 460 void
 461 ASDCP::MXF::TimecodeComponent::Dump(FILE* stream)
 462 {
 463   char identbuf[IdentBufferLen];
 464
 465   if ( stream == 0 )
 466     stream = stderr;
 467
 468   KLVPacket::Dump(stream, false);
 469   fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
 470   fprintf(stream, "  DataDefinition     = %s\n", DataDefinition.ToString(identbuf));
 471   fprintf(stream, "  Duration           = %s\n", ui64sz(Duration, identbuf));
 472   fprintf(stream, "  RoundedTimecodeBase= %u\n", RoundedTimecodeBase);
 473   fprintf(stream, "  StartTimecode      = %s\n", ui64sz(StartTimecode, identbuf));
 474   fprintf(stream, "  DropFrame          = %d\n", DropFrame);
 475
 476   fputs("==========================================================================\n", stream);
 477 }
 478
 479 //------------------------------------------------------------------------------------------
 480 //
 481
 482 //
 483 ASDCP::Result_t
 484 ASDCP::MXF::WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 485 {
 486   ASDCP_TEST_NULL(p);
 487
 488   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_WaveAudioDescriptor].ul);
 489
 490   if ( ASDCP_SUCCESS(result) )
 491     {
 492       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 493       MXF::Rational TmpRat;
 494
 495       //InterchangeObject_InstanceUID
 496       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 497       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 498       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
 499       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
 500       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
 501       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
 502       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, AudioSamplingRate));
 503       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, Locked));
 504       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, ChannelCount));
 505       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericSoundEssenceDescriptor, QuantizationBits));
 506       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16(OBJ_READ_ARGS(WaveAudioDescriptor, BlockAlign));
 507       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(WaveAudioDescriptor, AvgBps));
 508     }
 509
 510   return result;
 511 }
 512
 513 //
 514 ASDCP::Result_t
 515 ASDCP::MXF::WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 516 {
 517   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_WaveAudioDescriptor].ul, 0);
 518 }
 519
 520 //
 521 void
 522 ASDCP::MXF::WaveAudioDescriptor::Dump(FILE* stream)
 523 {
 524   char identbuf[IdentBufferLen];
 525
 526   if ( stream == 0 )
 527     stream = stderr;
 528
 529   KLVPacket::Dump(stream, false);
 530   fprintf(stream, "          InstanceUID: %s\n",  InstanceUID.ToString(identbuf));
 531   fprintf(stream, "        LinkedTrackID: %lu\n", LinkedTrackID);
 532   fprintf(stream, "     EssenceContainer: %s\n",  EssenceContainer.ToString(identbuf));
 533   fprintf(stream, "...\n");
 534
 535   fputs("==========================================================================\n", stream);
 536 }
 537
 538
 539 //------------------------------------------------------------------------------------------
 540 //
 541
 542 //
 543 ASDCP::Result_t
 544 ASDCP::MXF::MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 545 {
 546   ASDCP_TEST_NULL(p);
 547
 548   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_MPEG2VideoDescriptor].ul);
 549
 550   if ( ASDCP_SUCCESS(result) )
 551     {
 552       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 553       MXF::Rational TmpRat;
 554       ui8_t tmp_delay;
 555
 556       //InterchangeObject_InstanceUID
 557       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 558       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS_R(FileDescriptor, SampleRate, TmpRat));
 559       SampleRate = TmpRat;
 560       ui64_t tmpDuration = 0;
 561       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS_R(FileDescriptor, ContainerDuration, tmpDuration));
 562       ContainerDuration = tmpDuration;
 563       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
 564       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
 565       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS_R(GenericPictureEssenceDescriptor, AspectRatio, TmpRat));
 566       AspectRatio = TmpRat;
 567       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, FrameLayout));
 568       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredWidth));
 569       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(GenericPictureEssenceDescriptor, StoredHeight));
 570       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, ComponentDepth));
 571       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, HorizontalSubsampling));
 572       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(CDCIEssenceDescriptor, VerticalSubsampling));
 573       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(CDCIEssenceDescriptor, ColorSiting));
 574       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor,  CodedContentType));
 575       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(MPEG2VideoDescriptor,  BitRate));
 576       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS(MPEG2VideoDescriptor,  ProfileAndLevel));
 577       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi8(OBJ_READ_ARGS_R(MPEG2VideoDescriptor,  LowDelay, tmp_delay));
 578       LowDelay = (tmp_delay > 0);
 579     }
 580
 581   return result;
 582 }
 583
 584 //
 585 ASDCP::Result_t
 586 ASDCP::MXF::MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 587 {
 588   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_MPEG2VideoDescriptor].ul, 0);
 589 }
 590
 591 //
 592 void
 593 ASDCP::MXF::MPEG2VideoDescriptor::Dump(FILE* stream)
 594 {
 595   char identbuf[IdentBufferLen];
 596
 597   if ( stream == 0 )
 598     stream = stderr;
 599
 600   KLVPacket::Dump(stream, false);
 601   fprintf(stream, "          InstanceUID: %s\n",  InstanceUID.ToString(identbuf));
 602   fprintf(stream, "        LinkedTrackID: %lu\n", LinkedTrackID);
 603   fprintf(stream, "     EssenceContainer: %s\n",  EssenceContainer.ToString(identbuf));
 604   ASDCP::MPEG2::VideoDescriptorDump(*this, stream);
 605
 606   fputs("==========================================================================\n", stream);
 607 }
 608
 609 //------------------------------------------------------------------------------------------
 610 //
 611
 612 //
 613 ASDCP::Result_t
 614 ASDCP::MXF::FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 615 {
 616   ASDCP_TEST_NULL(p);
 617
 618   Result_t result = KLVPacket::InitFromBuffer(p, l); // any of a variety of ULs, really
 619
 620   if ( ASDCP_SUCCESS(result) )
 621     {
 622       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 623
 624       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 625       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenerationInterchangeObject, GenerationUID));
 626       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericDescriptor, Locators));
 627       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(GenericDescriptor, SubDescriptors));
 628       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32(OBJ_READ_ARGS(FileDescriptor, LinkedTrackID));
 629       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, SampleRate));
 630       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64(OBJ_READ_ARGS(FileDescriptor, ContainerDuration));
 631       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, EssenceContainer));
 632       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(FileDescriptor, Codec));
 633     }
 634
 635   return result;
 636 }
 637
 638 //
 639 ASDCP::Result_t
 640 ASDCP::MXF::FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 641 {
 642   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_FileDescriptor].ul, 0);
 643 }
 644
 645 //
 646 void
 647 ASDCP::MXF::FileDescriptor::Dump(FILE* stream)
 648 {
 649   char identbuf[IdentBufferLen];
 650
 651   if ( stream == 0 )
 652     stream = stderr;
 653
 654   KLVPacket::Dump(stream, false);
 655   fprintf(stream, "          InstanceUID: %s\n",  InstanceUID.ToString(identbuf));
 656   fprintf(stream, "        GenerationUID: %lu\n", GenerationUID.ToString(identbuf));
 657   fprintf(stream, "        LinkedTrackID: %lu\n", LinkedTrackID);
 658   fprintf(stream, "     EssenceContainer: %s\n",  EssenceContainer.ToString(identbuf));
 659   fprintf(stream, "...\n");
 660
 661   fputs("==========================================================================\n", stream);
 662 }
 663
 664 //------------------------------------------------------------------------------------------
 665 //
 666
 667 //
 668 ASDCP::Result_t
 669 ASDCP::MXF::GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 670 {
 671   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_GenericPictureEssenceDescriptor].ul, 0);
 672 }
 673
 674 //------------------------------------------------------------------------------------------
 675 //
 676
 677 //
 678 ASDCP::Result_t
 679 ASDCP::MXF::RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 680 {
 681   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_RGBAEssenceDescriptor].ul, 0);
 682 }
 683
 684 //------------------------------------------------------------------------------------------
 685 //
 686
 687 //
 688 ASDCP::Result_t
 689 ASDCP::MXF::JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 690 {
 691   return WriteKLToBuffer(Buffer, s_MDD_Table[MDDindex_JPEG2000PictureSubDescriptor].ul, 0);
 692 }
 693
 694 //------------------------------------------------------------------------------------------
 695 //
 696
 697 //
 698 ASDCP::Result_t
 699 ASDCP::MXF::CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
 700 {
 701   ASDCP_TEST_NULL(p);
 702
 703   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_CryptographicFramework].ul);
 704
 705   if ( ASDCP_SUCCESS(result) )
 706     {
 707       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 708
 709       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 710       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicFramework, ContextSR));
 711     }
 712
 713   return result;
 714 }
 715
 716 //
 717 void
 718 ASDCP::MXF::CryptographicFramework::Dump(FILE* stream)
 719 {
 720   char identbuf[IdentBufferLen];
 721
 722   if ( stream == 0 )
 723     stream = stderr;
 724
 725   KLVPacket::Dump(stream, false);
 726   fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
 727   fprintf(stream, "  ContextSR          = %s\n", ContextSR.ToString(identbuf));
 728
 729   fputs("==========================================================================\n", stream);
 730 }
 731
 732
 733 //------------------------------------------------------------------------------------------
 734 //
 735
 736 //
 737 ASDCP::Result_t
 738 ASDCP::MXF::CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
 739 {
 740   ASDCP_TEST_NULL(p);
 741
 742   Result_t result = KLVPacket::InitFromBuffer(p, l, s_MDD_Table[MDDindex_CryptographicContext].ul);
 743
 744   if ( ASDCP_SUCCESS(result) )
 745     {
 746       TLVReader MemRDR(m_ValueStart, m_ValueLength, m_Lookup);
 747
 748       result = MemRDR.ReadObject(OBJ_READ_ARGS(InterchangeObject, InstanceUID));
 749       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, ContextID));
 750       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, SourceEssenceContainer));
 751       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, CipherAlgorithm));
 752       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, MICAlgorithm));
 753       if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadObject(OBJ_READ_ARGS(CryptographicContext, CryptographicKeyID));
 754     }
 755
 756   return result;
 757 }
 758
 759 //
 760 void
 761 ASDCP::MXF::CryptographicContext::Dump(FILE* stream)
 762 {
 763   char identbuf[IdentBufferLen];
 764
 765   if ( stream == 0 )
 766     stream = stderr;
 767
 768   KLVPacket::Dump(stream, false);
 769   fprintf(stream, "  InstanceUID        = %s\n", InstanceUID.ToString(identbuf));
 770   fprintf(stream, "  ContextID          = %s\n", ContextID.ToString(identbuf));
 771   fprintf(stream, "  SourceEssenceCnt   = %s\n", SourceEssenceContainer.ToString(identbuf));
 772   fprintf(stream, "  CipherAlgorithm    = %s\n", CipherAlgorithm.ToString(identbuf));
 773   fprintf(stream, "  MICAlgorithm       = %s\n", MICAlgorithm.ToString(identbuf));
 774   fprintf(stream, "  CryptographicKeyID = %s\n", CryptographicKeyID.ToString(identbuf));
 775
 776   fputs("==========================================================================\n", stream);
 777 }
 778
 779 //
 780 // end MXF.cpp
 781 //