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