src/Metadata.h

   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.h
  28     \version $Id$
  29     \brief   MXF metadata objects
  30 */
  31
  32 #ifndef _Metadata_H_
  33 #define _Metadata_H_
  34
  35 #include "MXF.h"
  36
  37 namespace ASDCP
  38 {
  39   namespace MXF
  40     {
  41       void Metadata_InitTypes(const Dictionary*& Dict);
  42
  43       //
  44
  45       //
  46       class Identification : public InterchangeObject
  47         {
  48           Identification();
  49
  50         public:
  51           const Dictionary*& m_Dict;
  52           UUID ThisGenerationUID;
  53           UTF16String CompanyName;
  54           UTF16String ProductName;
  55           VersionType ProductVersion;
  56           UTF16String VersionString;
  57           UUID ProductUID;
  58           Kumu::Timestamp ModificationDate;
  59           VersionType ToolkitVersion;
  60           UTF16String Platform;
  61
  62       Identification(const Dictionary*& d);
  63       Identification(const Identification& rhs);
  64       virtual ~Identification() {}
  65
  66       const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
  67       virtual void Copy(const Identification& rhs);
  68       virtual const char* HasName() { return "Identification"; }
  69       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  70       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  71       virtual void     Dump(FILE* = 0);
  72       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  73       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  74         };
  75
  76       //
  77       class ContentStorage : public InterchangeObject
  78         {
  79           ContentStorage();
  80
  81         public:
  82           const Dictionary*& m_Dict;
  83           Batch<UUID> Packages;
  84           Batch<UUID> EssenceContainerData;
  85
  86       ContentStorage(const Dictionary*& d);
  87       ContentStorage(const ContentStorage& rhs);
  88       virtual ~ContentStorage() {}
  89
  90       const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
  91       virtual void Copy(const ContentStorage& rhs);
  92       virtual const char* HasName() { return "ContentStorage"; }
  93       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  94       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  95       virtual void     Dump(FILE* = 0);
  96       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  97       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  98         };
  99
 100       //
 101       class EssenceContainerData : public InterchangeObject
 102         {
 103           EssenceContainerData();
 104
 105         public:
 106           const Dictionary*& m_Dict;
 107           UMID LinkedPackageUID;
 108           ui32_t IndexSID;
 109           ui32_t BodySID;
 110
 111       EssenceContainerData(const Dictionary*& d);
 112       EssenceContainerData(const EssenceContainerData& rhs);
 113       virtual ~EssenceContainerData() {}
 114
 115       const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
 116       virtual void Copy(const EssenceContainerData& rhs);
 117       virtual const char* HasName() { return "EssenceContainerData"; }
 118       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 119       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 120       virtual void     Dump(FILE* = 0);
 121       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 122       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 123         };
 124
 125       //
 126       class GenericPackage : public InterchangeObject
 127         {
 128           GenericPackage();
 129
 130         public:
 131           const Dictionary*& m_Dict;
 132           UMID PackageUID;
 133           UTF16String Name;
 134           Kumu::Timestamp PackageCreationDate;
 135           Kumu::Timestamp PackageModifiedDate;
 136           Batch<UUID> Tracks;
 137
 138       GenericPackage(const Dictionary*& d);
 139       GenericPackage(const GenericPackage& rhs);
 140       virtual ~GenericPackage() {}
 141
 142       const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
 143       virtual void Copy(const GenericPackage& rhs);
 144       virtual const char* HasName() { return "GenericPackage"; }
 145       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 146       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 147       virtual void     Dump(FILE* = 0);
 148         };
 149
 150       //
 151       class MaterialPackage : public GenericPackage
 152         {
 153           MaterialPackage();
 154
 155         public:
 156           const Dictionary*& m_Dict;
 157
 158       MaterialPackage(const Dictionary*& d);
 159       MaterialPackage(const MaterialPackage& rhs);
 160       virtual ~MaterialPackage() {}
 161
 162       const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
 163       virtual void Copy(const MaterialPackage& rhs);
 164       virtual const char* HasName() { return "MaterialPackage"; }
 165       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 166       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 167       virtual void     Dump(FILE* = 0);
 168       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 169       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 170         };
 171
 172       //
 173       class SourcePackage : public GenericPackage
 174         {
 175           SourcePackage();
 176
 177         public:
 178           const Dictionary*& m_Dict;
 179           UUID Descriptor;
 180
 181       SourcePackage(const Dictionary*& d);
 182       SourcePackage(const SourcePackage& rhs);
 183       virtual ~SourcePackage() {}
 184
 185       const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
 186       virtual void Copy(const SourcePackage& rhs);
 187       virtual const char* HasName() { return "SourcePackage"; }
 188       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 189       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 190       virtual void     Dump(FILE* = 0);
 191       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 192       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 193         };
 194
 195       //
 196       class GenericTrack : public InterchangeObject
 197         {
 198           GenericTrack();
 199
 200         public:
 201           const Dictionary*& m_Dict;
 202           ui32_t TrackID;
 203           ui32_t TrackNumber;
 204           UTF16String TrackName;
 205           UUID Sequence;
 206
 207       GenericTrack(const Dictionary*& d);
 208       GenericTrack(const GenericTrack& rhs);
 209       virtual ~GenericTrack() {}
 210
 211       const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
 212       virtual void Copy(const GenericTrack& rhs);
 213       virtual const char* HasName() { return "GenericTrack"; }
 214       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 215       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 216       virtual void     Dump(FILE* = 0);
 217         };
 218
 219       //
 220       class StaticTrack : public GenericTrack
 221         {
 222           StaticTrack();
 223
 224         public:
 225           const Dictionary*& m_Dict;
 226
 227       StaticTrack(const Dictionary*& d);
 228       StaticTrack(const StaticTrack& rhs);
 229       virtual ~StaticTrack() {}
 230
 231       const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
 232       virtual void Copy(const StaticTrack& rhs);
 233       virtual const char* HasName() { return "StaticTrack"; }
 234       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 235       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 236       virtual void     Dump(FILE* = 0);
 237       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 238       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 239         };
 240
 241       //
 242       class Track : public GenericTrack
 243         {
 244           Track();
 245
 246         public:
 247           const Dictionary*& m_Dict;
 248           Rational EditRate;
 249           ui64_t Origin;
 250
 251       Track(const Dictionary*& d);
 252       Track(const Track& rhs);
 253       virtual ~Track() {}
 254
 255       const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
 256       virtual void Copy(const Track& rhs);
 257       virtual const char* HasName() { return "Track"; }
 258       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 259       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 260       virtual void     Dump(FILE* = 0);
 261       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 262       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 263         };
 264
 265       //
 266       class StructuralComponent : public InterchangeObject
 267         {
 268           StructuralComponent();
 269
 270         public:
 271           const Dictionary*& m_Dict;
 272           UL DataDefinition;
 273           ui64_t Duration;
 274
 275       StructuralComponent(const Dictionary*& d);
 276       StructuralComponent(const StructuralComponent& rhs);
 277       virtual ~StructuralComponent() {}
 278
 279       const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
 280       virtual void Copy(const StructuralComponent& rhs);
 281       virtual const char* HasName() { return "StructuralComponent"; }
 282       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 283       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 284       virtual void     Dump(FILE* = 0);
 285         };
 286
 287       //
 288       class Sequence : public StructuralComponent
 289         {
 290           Sequence();
 291
 292         public:
 293           const Dictionary*& m_Dict;
 294           Batch<UUID> StructuralComponents;
 295
 296       Sequence(const Dictionary*& d);
 297       Sequence(const Sequence& rhs);
 298       virtual ~Sequence() {}
 299
 300       const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
 301       virtual void Copy(const Sequence& rhs);
 302       virtual const char* HasName() { return "Sequence"; }
 303       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 304       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 305       virtual void     Dump(FILE* = 0);
 306       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 307       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 308         };
 309
 310       //
 311       class SourceClip : public StructuralComponent
 312         {
 313           SourceClip();
 314
 315         public:
 316           const Dictionary*& m_Dict;
 317           ui64_t StartPosition;
 318           UMID SourcePackageID;
 319           ui32_t SourceTrackID;
 320
 321       SourceClip(const Dictionary*& d);
 322       SourceClip(const SourceClip& rhs);
 323       virtual ~SourceClip() {}
 324
 325       const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
 326       virtual void Copy(const SourceClip& rhs);
 327       virtual const char* HasName() { return "SourceClip"; }
 328       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 329       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 330       virtual void     Dump(FILE* = 0);
 331       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 332       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 333         };
 334
 335       //
 336       class TimecodeComponent : public StructuralComponent
 337         {
 338           TimecodeComponent();
 339
 340         public:
 341           const Dictionary*& m_Dict;
 342           ui16_t RoundedTimecodeBase;
 343           ui64_t StartTimecode;
 344           ui8_t DropFrame;
 345
 346       TimecodeComponent(const Dictionary*& d);
 347       TimecodeComponent(const TimecodeComponent& rhs);
 348       virtual ~TimecodeComponent() {}
 349
 350       const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
 351       virtual void Copy(const TimecodeComponent& rhs);
 352       virtual const char* HasName() { return "TimecodeComponent"; }
 353       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 354       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 355       virtual void     Dump(FILE* = 0);
 356       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 357       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 358         };
 359
 360       //
 361       class GenericDescriptor : public InterchangeObject
 362         {
 363           GenericDescriptor();
 364
 365         public:
 366           const Dictionary*& m_Dict;
 367           Batch<UUID> Locators;
 368           Batch<UUID> SubDescriptors;
 369
 370       GenericDescriptor(const Dictionary*& d);
 371       GenericDescriptor(const GenericDescriptor& rhs);
 372       virtual ~GenericDescriptor() {}
 373
 374       const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
 375       virtual void Copy(const GenericDescriptor& rhs);
 376       virtual const char* HasName() { return "GenericDescriptor"; }
 377       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 378       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 379       virtual void     Dump(FILE* = 0);
 380         };
 381
 382       //
 383       class FileDescriptor : public GenericDescriptor
 384         {
 385           FileDescriptor();
 386
 387         public:
 388           const Dictionary*& m_Dict;
 389           ui32_t LinkedTrackID;
 390           Rational SampleRate;
 391           ui64_t ContainerDuration;
 392           UL EssenceContainer;
 393           UL Codec;
 394
 395       FileDescriptor(const Dictionary*& d);
 396       FileDescriptor(const FileDescriptor& rhs);
 397       virtual ~FileDescriptor() {}
 398
 399       const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
 400       virtual void Copy(const FileDescriptor& rhs);
 401       virtual const char* HasName() { return "FileDescriptor"; }
 402       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 403       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 404       virtual void     Dump(FILE* = 0);
 405       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 406       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 407         };
 408
 409       //
 410       class GenericSoundEssenceDescriptor : public FileDescriptor
 411         {
 412           GenericSoundEssenceDescriptor();
 413
 414         public:
 415           const Dictionary*& m_Dict;
 416           Rational AudioSamplingRate;
 417           ui8_t Locked;
 418           ui8_t AudioRefLevel;
 419           ui32_t ChannelCount;
 420           ui32_t QuantizationBits;
 421           ui8_t DialNorm;
 422
 423       GenericSoundEssenceDescriptor(const Dictionary*& d);
 424       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
 425       virtual ~GenericSoundEssenceDescriptor() {}
 426
 427       const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 428       virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
 429       virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 430       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 431       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 432       virtual void     Dump(FILE* = 0);
 433       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 434       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 435         };
 436
 437       //
 438       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 439         {
 440           WaveAudioDescriptor();
 441
 442         public:
 443           const Dictionary*& m_Dict;
 444           ui16_t BlockAlign;
 445           ui8_t SequenceOffset;
 446           ui32_t AvgBps;
 447           UL ChannelAssignment;
 448
 449       WaveAudioDescriptor(const Dictionary*& d);
 450       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
 451       virtual ~WaveAudioDescriptor() {}
 452
 453       const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
 454       virtual void Copy(const WaveAudioDescriptor& rhs);
 455       virtual const char* HasName() { return "WaveAudioDescriptor"; }
 456       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 457       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 458       virtual void     Dump(FILE* = 0);
 459       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 460       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 461         };
 462
 463       //
 464       class GenericPictureEssenceDescriptor : public FileDescriptor
 465         {
 466           GenericPictureEssenceDescriptor();
 467
 468         public:
 469           const Dictionary*& m_Dict;
 470           ui8_t FrameLayout;
 471           ui32_t StoredWidth;
 472           ui32_t StoredHeight;
 473           Rational AspectRatio;
 474           UL PictureEssenceCoding;
 475           optional_property<ui32_t> DisplayWidth;
 476           optional_property<ui32_t> DisplayHeight;
 477           optional_property<UL> Gamma;
 478           optional_property<ui8_t> FieldDominance;
 479
 480       GenericPictureEssenceDescriptor(const Dictionary*& d);
 481       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
 482       virtual ~GenericPictureEssenceDescriptor() {}
 483
 484       const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 485       virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
 486       virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 487       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 488       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 489       virtual void     Dump(FILE* = 0);
 490       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 491       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 492         };
 493
 494       //
 495       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 496         {
 497           RGBAEssenceDescriptor();
 498
 499         public:
 500           const Dictionary*& m_Dict;
 501           ui32_t ComponentMaxRef;
 502           ui32_t ComponentMinRef;
 503
 504       RGBAEssenceDescriptor(const Dictionary*& d);
 505       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
 506       virtual ~RGBAEssenceDescriptor() {}
 507
 508       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 509       virtual void Copy(const RGBAEssenceDescriptor& rhs);
 510       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 511       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 512       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 513       virtual void     Dump(FILE* = 0);
 514       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 515       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 516         };
 517
 518       //
 519       class JPEG2000PictureSubDescriptor : public InterchangeObject
 520         {
 521           JPEG2000PictureSubDescriptor();
 522
 523         public:
 524           const Dictionary*& m_Dict;
 525           ui16_t Rsize;
 526           ui32_t Xsize;
 527           ui32_t Ysize;
 528           ui32_t XOsize;
 529           ui32_t YOsize;
 530           ui32_t XTsize;
 531           ui32_t YTsize;
 532           ui32_t XTOsize;
 533           ui32_t YTOsize;
 534           ui16_t Csize;
 535           Raw PictureComponentSizing;
 536           Raw CodingStyleDefault;
 537           Raw QuantizationDefault;
 538
 539       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 540       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 541       virtual ~JPEG2000PictureSubDescriptor() {}
 542
 543       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 544       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 545       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 546       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 547       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 548       virtual void     Dump(FILE* = 0);
 549       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 550       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 551         };
 552
 553       //
 554       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 555         {
 556           CDCIEssenceDescriptor();
 557
 558         public:
 559           const Dictionary*& m_Dict;
 560           ui32_t ComponentDepth;
 561           ui32_t HorizontalSubsampling;
 562           ui32_t VerticalSubsampling;
 563           ui8_t ColorSiting;
 564
 565       CDCIEssenceDescriptor(const Dictionary*& d);
 566       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 567       virtual ~CDCIEssenceDescriptor() {}
 568
 569       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 570       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 571       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 572       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 573       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 574       virtual void     Dump(FILE* = 0);
 575       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 576       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 577         };
 578
 579       //
 580       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 581         {
 582           MPEG2VideoDescriptor();
 583
 584         public:
 585           const Dictionary*& m_Dict;
 586           ui8_t CodedContentType;
 587           ui8_t LowDelay;
 588           ui32_t BitRate;
 589           ui8_t ProfileAndLevel;
 590
 591       MPEG2VideoDescriptor(const Dictionary*& d);
 592       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 593       virtual ~MPEG2VideoDescriptor() {}
 594
 595       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 596       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 597       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 598       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 599       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 600       virtual void     Dump(FILE* = 0);
 601       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 602       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 603         };
 604
 605       //
 606       class DMSegment : public InterchangeObject
 607         {
 608           DMSegment();
 609
 610         public:
 611           const Dictionary*& m_Dict;
 612           UL DataDefinition;
 613           ui64_t EventStartPosition;
 614           ui64_t Duration;
 615           UTF16String EventComment;
 616           UUID DMFramework;
 617
 618       DMSegment(const Dictionary*& d);
 619       DMSegment(const DMSegment& rhs);
 620       virtual ~DMSegment() {}
 621
 622       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 623       virtual void Copy(const DMSegment& rhs);
 624       virtual const char* HasName() { return "DMSegment"; }
 625       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 626       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 627       virtual void     Dump(FILE* = 0);
 628       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 629       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 630         };
 631
 632       //
 633       class CryptographicFramework : public InterchangeObject
 634         {
 635           CryptographicFramework();
 636
 637         public:
 638           const Dictionary*& m_Dict;
 639           UUID ContextSR;
 640
 641       CryptographicFramework(const Dictionary*& d);
 642       CryptographicFramework(const CryptographicFramework& rhs);
 643       virtual ~CryptographicFramework() {}
 644
 645       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 646       virtual void Copy(const CryptographicFramework& rhs);
 647       virtual const char* HasName() { return "CryptographicFramework"; }
 648       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 649       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 650       virtual void     Dump(FILE* = 0);
 651       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 652       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 653         };
 654
 655       //
 656       class CryptographicContext : public InterchangeObject
 657         {
 658           CryptographicContext();
 659
 660         public:
 661           const Dictionary*& m_Dict;
 662           UUID ContextID;
 663           UL SourceEssenceContainer;
 664           UL CipherAlgorithm;
 665           UL MICAlgorithm;
 666           UUID CryptographicKeyID;
 667
 668       CryptographicContext(const Dictionary*& d);
 669       CryptographicContext(const CryptographicContext& rhs);
 670       virtual ~CryptographicContext() {}
 671
 672       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 673       virtual void Copy(const CryptographicContext& rhs);
 674       virtual const char* HasName() { return "CryptographicContext"; }
 675       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 676       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 677       virtual void     Dump(FILE* = 0);
 678       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 679       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 680         };
 681
 682       //
 683       class GenericDataEssenceDescriptor : public FileDescriptor
 684         {
 685           GenericDataEssenceDescriptor();
 686
 687         public:
 688           const Dictionary*& m_Dict;
 689           UL DataEssenceCoding;
 690
 691       GenericDataEssenceDescriptor(const Dictionary*& d);
 692       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 693       virtual ~GenericDataEssenceDescriptor() {}
 694
 695       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 696       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 697       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 698       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 699       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 700       virtual void     Dump(FILE* = 0);
 701       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 702       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 703         };
 704
 705       //
 706       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 707         {
 708           TimedTextDescriptor();
 709
 710         public:
 711           const Dictionary*& m_Dict;
 712           UUID ResourceID;
 713           UTF16String UCSEncoding;
 714           UTF16String NamespaceURI;
 715
 716       TimedTextDescriptor(const Dictionary*& d);
 717       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 718       virtual ~TimedTextDescriptor() {}
 719
 720       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 721       virtual void Copy(const TimedTextDescriptor& rhs);
 722       virtual const char* HasName() { return "TimedTextDescriptor"; }
 723       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 724       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 725       virtual void     Dump(FILE* = 0);
 726       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 727       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 728         };
 729
 730       //
 731       class TimedTextResourceSubDescriptor : public InterchangeObject
 732         {
 733           TimedTextResourceSubDescriptor();
 734
 735         public:
 736           const Dictionary*& m_Dict;
 737           UUID AncillaryResourceID;
 738           UTF16String MIMEMediaType;
 739           ui32_t EssenceStreamID;
 740
 741       TimedTextResourceSubDescriptor(const Dictionary*& d);
 742       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 743       virtual ~TimedTextResourceSubDescriptor() {}
 744
 745       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 746       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 747       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 748       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 749       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 750       virtual void     Dump(FILE* = 0);
 751       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 752       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 753         };
 754
 755       //
 756       class StereoscopicPictureSubDescriptor : public InterchangeObject
 757         {
 758           StereoscopicPictureSubDescriptor();
 759
 760         public:
 761           const Dictionary*& m_Dict;
 762
 763       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 764       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 765       virtual ~StereoscopicPictureSubDescriptor() {}
 766
 767       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 768       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 769       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 770       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 771       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 772       virtual void     Dump(FILE* = 0);
 773       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 774       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 775         };
 776
 777       //
 778       class NetworkLocator : public InterchangeObject
 779         {
 780           NetworkLocator();
 781
 782         public:
 783           const Dictionary*& m_Dict;
 784           UTF16String URLString;
 785
 786       NetworkLocator(const Dictionary*& d);
 787       NetworkLocator(const NetworkLocator& rhs);
 788       virtual ~NetworkLocator() {}
 789
 790       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 791       virtual void Copy(const NetworkLocator& rhs);
 792       virtual const char* HasName() { return "NetworkLocator"; }
 793       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 794       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 795       virtual void     Dump(FILE* = 0);
 796       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 797       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 798         };
 799
 800       //
 801       class MCALabelSubDescriptor : public InterchangeObject
 802         {
 803           MCALabelSubDescriptor();
 804
 805         public:
 806           const Dictionary*& m_Dict;
 807           UL MCALabelDictionaryID;
 808           UUID MCALinkID;
 809           UTF16String MCATagSymbol;
 810           UTF16String MCATagName;
 811           ui32_t MCAChannelID;
 812           ISO8String RFC5646SpokenLanguage;
 813
 814       MCALabelSubDescriptor(const Dictionary*& d);
 815       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 816       virtual ~MCALabelSubDescriptor() {}
 817
 818       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 819       virtual void Copy(const MCALabelSubDescriptor& rhs);
 820       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 821       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 822       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 823       virtual void     Dump(FILE* = 0);
 824       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 825       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 826         };
 827
 828       //
 829       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 830         {
 831           AudioChannelLabelSubDescriptor();
 832
 833         public:
 834           const Dictionary*& m_Dict;
 835           UUID SoundfieldGroupLinkID;
 836
 837       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 838       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 839       virtual ~AudioChannelLabelSubDescriptor() {}
 840
 841       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 842       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 843       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 844       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 845       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 846       virtual void     Dump(FILE* = 0);
 847       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 848       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 849         };
 850
 851       //
 852       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 853         {
 854           SoundfieldGroupLabelSubDescriptor();
 855
 856         public:
 857           const Dictionary*& m_Dict;
 858           Array<UUID> GroupOfSoundfieldGroupsLinkID;
 859
 860       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 861       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 862       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 863
 864       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 865       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 866       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 867       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 868       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 869       virtual void     Dump(FILE* = 0);
 870       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 871       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 872         };
 873
 874       //
 875       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 876         {
 877           GroupOfSoundfieldGroupsLabelSubDescriptor();
 878
 879         public:
 880           const Dictionary*& m_Dict;
 881
 882       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 883       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 884       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 885
 886       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 887       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 888       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 889       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 890       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 891       virtual void     Dump(FILE* = 0);
 892       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 893       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 894         };
 895
 896       //
 897       class DCDataDescriptor : public GenericDataEssenceDescriptor
 898         {
 899           DCDataDescriptor();
 900
 901         public:
 902           const Dictionary*& m_Dict;
 903
 904       DCDataDescriptor(const Dictionary*& d);
 905       DCDataDescriptor(const DCDataDescriptor& rhs);
 906       virtual ~DCDataDescriptor() {}
 907
 908       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
 909       virtual void Copy(const DCDataDescriptor& rhs);
 910       virtual const char* HasName() { return "DCDataDescriptor"; }
 911       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 912       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 913       virtual void     Dump(FILE* = 0);
 914       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 915       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 916         };
 917
 918       //
 919       class DolbyAtmosSubDescriptor : public InterchangeObject
 920         {
 921           DolbyAtmosSubDescriptor();
 922
 923         public:
 924           const Dictionary*& m_Dict;
 925           UUID AtmosID;
 926           ui32_t FirstFrame;
 927           ui16_t MaxChannelCount;
 928           ui16_t MaxObjectCount;
 929           ui8_t AtmosVersion;
 930
 931       DolbyAtmosSubDescriptor(const Dictionary*& d);
 932       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
 933       virtual ~DolbyAtmosSubDescriptor() {}
 934
 935       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
 936       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
 937       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
 938       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 939       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 940       virtual void     Dump(FILE* = 0);
 941       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 942       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 943         };
 944
 945     } // namespace MXF
 946 } // namespace ASDCP
 947
 948
 949 #endif // _Metadata_H_
 950
 951 //
 952 // end Metadata.h
 953 //