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
 476       GenericPictureEssenceDescriptor(const Dictionary*& d);
 477       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
 478       virtual ~GenericPictureEssenceDescriptor() {}
 479
 480       const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 481       virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
 482       virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 483       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 484       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 485       virtual void     Dump(FILE* = 0);
 486       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 487       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 488         };
 489
 490       //
 491       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 492         {
 493           RGBAEssenceDescriptor();
 494
 495         public:
 496           const Dictionary*& m_Dict;
 497           ui32_t ComponentMaxRef;
 498           ui32_t ComponentMinRef;
 499
 500       RGBAEssenceDescriptor(const Dictionary*& d);
 501       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
 502       virtual ~RGBAEssenceDescriptor() {}
 503
 504       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 505       virtual void Copy(const RGBAEssenceDescriptor& rhs);
 506       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 507       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 508       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 509       virtual void     Dump(FILE* = 0);
 510       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 511       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 512         };
 513
 514       //
 515       class JPEG2000PictureSubDescriptor : public InterchangeObject
 516         {
 517           JPEG2000PictureSubDescriptor();
 518
 519         public:
 520           const Dictionary*& m_Dict;
 521           ui16_t Rsize;
 522           ui32_t Xsize;
 523           ui32_t Ysize;
 524           ui32_t XOsize;
 525           ui32_t YOsize;
 526           ui32_t XTsize;
 527           ui32_t YTsize;
 528           ui32_t XTOsize;
 529           ui32_t YTOsize;
 530           ui16_t Csize;
 531           Raw PictureComponentSizing;
 532           Raw CodingStyleDefault;
 533           Raw QuantizationDefault;
 534
 535       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 536       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 537       virtual ~JPEG2000PictureSubDescriptor() {}
 538
 539       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 540       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 541       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 542       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 543       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 544       virtual void     Dump(FILE* = 0);
 545       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 546       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 547         };
 548
 549       //
 550       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 551         {
 552           CDCIEssenceDescriptor();
 553
 554         public:
 555           const Dictionary*& m_Dict;
 556           ui32_t ComponentDepth;
 557           ui32_t HorizontalSubsampling;
 558           ui32_t VerticalSubsampling;
 559           ui8_t ColorSiting;
 560
 561       CDCIEssenceDescriptor(const Dictionary*& d);
 562       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 563       virtual ~CDCIEssenceDescriptor() {}
 564
 565       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 566       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 567       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 568       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 569       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 570       virtual void     Dump(FILE* = 0);
 571       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 572       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 573         };
 574
 575       //
 576       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 577         {
 578           MPEG2VideoDescriptor();
 579
 580         public:
 581           const Dictionary*& m_Dict;
 582           ui8_t CodedContentType;
 583           ui8_t LowDelay;
 584           ui32_t BitRate;
 585           ui8_t ProfileAndLevel;
 586
 587       MPEG2VideoDescriptor(const Dictionary*& d);
 588       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 589       virtual ~MPEG2VideoDescriptor() {}
 590
 591       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 592       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 593       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 594       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 595       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 596       virtual void     Dump(FILE* = 0);
 597       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 598       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 599         };
 600
 601       //
 602       class DMSegment : public InterchangeObject
 603         {
 604           DMSegment();
 605
 606         public:
 607           const Dictionary*& m_Dict;
 608           UL DataDefinition;
 609           ui64_t EventStartPosition;
 610           ui64_t Duration;
 611           UTF16String EventComment;
 612           UUID DMFramework;
 613
 614       DMSegment(const Dictionary*& d);
 615       DMSegment(const DMSegment& rhs);
 616       virtual ~DMSegment() {}
 617
 618       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 619       virtual void Copy(const DMSegment& rhs);
 620       virtual const char* HasName() { return "DMSegment"; }
 621       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 622       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 623       virtual void     Dump(FILE* = 0);
 624       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 625       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 626         };
 627
 628       //
 629       class CryptographicFramework : public InterchangeObject
 630         {
 631           CryptographicFramework();
 632
 633         public:
 634           const Dictionary*& m_Dict;
 635           UUID ContextSR;
 636
 637       CryptographicFramework(const Dictionary*& d);
 638       CryptographicFramework(const CryptographicFramework& rhs);
 639       virtual ~CryptographicFramework() {}
 640
 641       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 642       virtual void Copy(const CryptographicFramework& rhs);
 643       virtual const char* HasName() { return "CryptographicFramework"; }
 644       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 645       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 646       virtual void     Dump(FILE* = 0);
 647       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 648       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 649         };
 650
 651       //
 652       class CryptographicContext : public InterchangeObject
 653         {
 654           CryptographicContext();
 655
 656         public:
 657           const Dictionary*& m_Dict;
 658           UUID ContextID;
 659           UL SourceEssenceContainer;
 660           UL CipherAlgorithm;
 661           UL MICAlgorithm;
 662           UUID CryptographicKeyID;
 663
 664       CryptographicContext(const Dictionary*& d);
 665       CryptographicContext(const CryptographicContext& rhs);
 666       virtual ~CryptographicContext() {}
 667
 668       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 669       virtual void Copy(const CryptographicContext& rhs);
 670       virtual const char* HasName() { return "CryptographicContext"; }
 671       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 672       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 673       virtual void     Dump(FILE* = 0);
 674       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 675       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 676         };
 677
 678       //
 679       class GenericDataEssenceDescriptor : public FileDescriptor
 680         {
 681           GenericDataEssenceDescriptor();
 682
 683         public:
 684           const Dictionary*& m_Dict;
 685           UL DataEssenceCoding;
 686
 687       GenericDataEssenceDescriptor(const Dictionary*& d);
 688       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 689       virtual ~GenericDataEssenceDescriptor() {}
 690
 691       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 692       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 693       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 694       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 695       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 696       virtual void     Dump(FILE* = 0);
 697       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 698       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 699         };
 700
 701       //
 702       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 703         {
 704           TimedTextDescriptor();
 705
 706         public:
 707           const Dictionary*& m_Dict;
 708           UUID ResourceID;
 709           UTF16String UCSEncoding;
 710           UTF16String NamespaceURI;
 711
 712       TimedTextDescriptor(const Dictionary*& d);
 713       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 714       virtual ~TimedTextDescriptor() {}
 715
 716       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 717       virtual void Copy(const TimedTextDescriptor& rhs);
 718       virtual const char* HasName() { return "TimedTextDescriptor"; }
 719       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 720       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 721       virtual void     Dump(FILE* = 0);
 722       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 723       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 724         };
 725
 726       //
 727       class TimedTextResourceSubDescriptor : public InterchangeObject
 728         {
 729           TimedTextResourceSubDescriptor();
 730
 731         public:
 732           const Dictionary*& m_Dict;
 733           UUID AncillaryResourceID;
 734           UTF16String MIMEMediaType;
 735           ui32_t EssenceStreamID;
 736
 737       TimedTextResourceSubDescriptor(const Dictionary*& d);
 738       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 739       virtual ~TimedTextResourceSubDescriptor() {}
 740
 741       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 742       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 743       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 744       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 745       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 746       virtual void     Dump(FILE* = 0);
 747       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 748       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 749         };
 750
 751       //
 752       class StereoscopicPictureSubDescriptor : public InterchangeObject
 753         {
 754           StereoscopicPictureSubDescriptor();
 755
 756         public:
 757           const Dictionary*& m_Dict;
 758
 759       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 760       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 761       virtual ~StereoscopicPictureSubDescriptor() {}
 762
 763       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 764       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 765       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 766       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 767       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 768       virtual void     Dump(FILE* = 0);
 769       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 770       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 771         };
 772
 773       //
 774       class NetworkLocator : public InterchangeObject
 775         {
 776           NetworkLocator();
 777
 778         public:
 779           const Dictionary*& m_Dict;
 780           UTF16String URLString;
 781
 782       NetworkLocator(const Dictionary*& d);
 783       NetworkLocator(const NetworkLocator& rhs);
 784       virtual ~NetworkLocator() {}
 785
 786       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 787       virtual void Copy(const NetworkLocator& rhs);
 788       virtual const char* HasName() { return "NetworkLocator"; }
 789       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 790       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 791       virtual void     Dump(FILE* = 0);
 792       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 793       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 794         };
 795
 796       //
 797       class MCALabelSubDescriptor : public InterchangeObject
 798         {
 799           MCALabelSubDescriptor();
 800
 801         public:
 802           const Dictionary*& m_Dict;
 803           UL MCALabelDictionaryID;
 804           UUID MCALinkID;
 805           UTF16String MCATagSymbol;
 806           UTF16String MCATagName;
 807           ui32_t MCAChannelID;
 808           ISO8String RFC5646SpokenLanguage;
 809
 810       MCALabelSubDescriptor(const Dictionary*& d);
 811       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 812       virtual ~MCALabelSubDescriptor() {}
 813
 814       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 815       virtual void Copy(const MCALabelSubDescriptor& rhs);
 816       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 817       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 818       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 819       virtual void     Dump(FILE* = 0);
 820       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 821       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 822         };
 823
 824       //
 825       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 826         {
 827           AudioChannelLabelSubDescriptor();
 828
 829         public:
 830           const Dictionary*& m_Dict;
 831           UUID SoundfieldGroupLinkID;
 832
 833       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 834       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 835       virtual ~AudioChannelLabelSubDescriptor() {}
 836
 837       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 838       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 839       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 840       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 841       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 842       virtual void     Dump(FILE* = 0);
 843       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 844       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 845         };
 846
 847       //
 848       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 849         {
 850           SoundfieldGroupLabelSubDescriptor();
 851
 852         public:
 853           const Dictionary*& m_Dict;
 854           Array<UUID> GroupOfSoundfieldGroupsLinkID;
 855
 856       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 857       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 858       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 859
 860       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 861       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 862       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 863       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 864       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 865       virtual void     Dump(FILE* = 0);
 866       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 867       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 868         };
 869
 870       //
 871       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 872         {
 873           GroupOfSoundfieldGroupsLabelSubDescriptor();
 874
 875         public:
 876           const Dictionary*& m_Dict;
 877
 878       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 879       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 880       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 881
 882       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 883       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 884       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 885       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 886       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 887       virtual void     Dump(FILE* = 0);
 888       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 889       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 890         };
 891
 892     } // namespace MXF
 893 } // namespace ASDCP
 894
 895
 896 #endif // _Metadata_H_
 897
 898 //
 899 // end Metadata.h
 900 //