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           Raw PictureComponentSizing;
 558           Raw CodingStyleDefault;
 559           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           optional_property<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           ui8_t CodedContentType;
 615           optional_property<ui8_t> LowDelay;
 616           optional_property<ui32_t> BitRate;
 617           optional_property<ui8_t> ProfileAndLevel;
 618
 619       MPEG2VideoDescriptor(const Dictionary*& d);
 620       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 621       virtual ~MPEG2VideoDescriptor() {}
 622
 623       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 624       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 625       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 626       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 627       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 628       virtual void     Dump(FILE* = 0);
 629       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 630       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 631         };
 632
 633       //
 634       class DMSegment : public InterchangeObject
 635         {
 636           DMSegment();
 637
 638         public:
 639           const Dictionary*& m_Dict;
 640           UL DataDefinition;
 641           ui64_t EventStartPosition;
 642           ui64_t Duration;
 643           UTF16String EventComment;
 644           UUID DMFramework;
 645
 646       DMSegment(const Dictionary*& d);
 647       DMSegment(const DMSegment& rhs);
 648       virtual ~DMSegment() {}
 649
 650       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 651       virtual void Copy(const DMSegment& rhs);
 652       virtual const char* HasName() { return "DMSegment"; }
 653       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 654       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 655       virtual void     Dump(FILE* = 0);
 656       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 657       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 658         };
 659
 660       //
 661       class CryptographicFramework : public InterchangeObject
 662         {
 663           CryptographicFramework();
 664
 665         public:
 666           const Dictionary*& m_Dict;
 667           UUID ContextSR;
 668
 669       CryptographicFramework(const Dictionary*& d);
 670       CryptographicFramework(const CryptographicFramework& rhs);
 671       virtual ~CryptographicFramework() {}
 672
 673       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 674       virtual void Copy(const CryptographicFramework& rhs);
 675       virtual const char* HasName() { return "CryptographicFramework"; }
 676       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 677       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 678       virtual void     Dump(FILE* = 0);
 679       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 680       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 681         };
 682
 683       //
 684       class CryptographicContext : public InterchangeObject
 685         {
 686           CryptographicContext();
 687
 688         public:
 689           const Dictionary*& m_Dict;
 690           UUID ContextID;
 691           UL SourceEssenceContainer;
 692           UL CipherAlgorithm;
 693           UL MICAlgorithm;
 694           UUID CryptographicKeyID;
 695
 696       CryptographicContext(const Dictionary*& d);
 697       CryptographicContext(const CryptographicContext& rhs);
 698       virtual ~CryptographicContext() {}
 699
 700       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 701       virtual void Copy(const CryptographicContext& rhs);
 702       virtual const char* HasName() { return "CryptographicContext"; }
 703       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 704       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 705       virtual void     Dump(FILE* = 0);
 706       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 707       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 708         };
 709
 710       //
 711       class GenericDataEssenceDescriptor : public FileDescriptor
 712         {
 713           GenericDataEssenceDescriptor();
 714
 715         public:
 716           const Dictionary*& m_Dict;
 717           UL DataEssenceCoding;
 718
 719       GenericDataEssenceDescriptor(const Dictionary*& d);
 720       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 721       virtual ~GenericDataEssenceDescriptor() {}
 722
 723       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 724       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 725       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 726       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 727       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 728       virtual void     Dump(FILE* = 0);
 729       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 730       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 731         };
 732
 733       //
 734       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 735         {
 736           TimedTextDescriptor();
 737
 738         public:
 739           const Dictionary*& m_Dict;
 740           UUID ResourceID;
 741           UTF16String UCSEncoding;
 742           UTF16String NamespaceURI;
 743
 744       TimedTextDescriptor(const Dictionary*& d);
 745       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 746       virtual ~TimedTextDescriptor() {}
 747
 748       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 749       virtual void Copy(const TimedTextDescriptor& rhs);
 750       virtual const char* HasName() { return "TimedTextDescriptor"; }
 751       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 752       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 753       virtual void     Dump(FILE* = 0);
 754       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 755       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 756         };
 757
 758       //
 759       class TimedTextResourceSubDescriptor : public InterchangeObject
 760         {
 761           TimedTextResourceSubDescriptor();
 762
 763         public:
 764           const Dictionary*& m_Dict;
 765           UUID AncillaryResourceID;
 766           UTF16String MIMEMediaType;
 767           ui32_t EssenceStreamID;
 768
 769       TimedTextResourceSubDescriptor(const Dictionary*& d);
 770       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 771       virtual ~TimedTextResourceSubDescriptor() {}
 772
 773       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 774       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 775       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 776       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 777       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 778       virtual void     Dump(FILE* = 0);
 779       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 780       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 781         };
 782
 783       //
 784       class StereoscopicPictureSubDescriptor : public InterchangeObject
 785         {
 786           StereoscopicPictureSubDescriptor();
 787
 788         public:
 789           const Dictionary*& m_Dict;
 790
 791       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 792       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 793       virtual ~StereoscopicPictureSubDescriptor() {}
 794
 795       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 796       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 797       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 798       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 799       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 800       virtual void     Dump(FILE* = 0);
 801       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 802       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 803         };
 804
 805       //
 806       class NetworkLocator : public InterchangeObject
 807         {
 808           NetworkLocator();
 809
 810         public:
 811           const Dictionary*& m_Dict;
 812           UTF16String URLString;
 813
 814       NetworkLocator(const Dictionary*& d);
 815       NetworkLocator(const NetworkLocator& rhs);
 816       virtual ~NetworkLocator() {}
 817
 818       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 819       virtual void Copy(const NetworkLocator& rhs);
 820       virtual const char* HasName() { return "NetworkLocator"; }
 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 MCALabelSubDescriptor : public InterchangeObject
 830         {
 831           MCALabelSubDescriptor();
 832
 833         public:
 834           const Dictionary*& m_Dict;
 835           UL MCALabelDictionaryID;
 836           UUID MCALinkID;
 837           UTF16String MCATagSymbol;
 838           optional_property<UTF16String> MCATagName;
 839           optional_property<ui32_t> MCAChannelID;
 840           optional_property<ISO8String> RFC5646SpokenLanguage;
 841
 842       MCALabelSubDescriptor(const Dictionary*& d);
 843       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 844       virtual ~MCALabelSubDescriptor() {}
 845
 846       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 847       virtual void Copy(const MCALabelSubDescriptor& rhs);
 848       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 849       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 850       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 851       virtual void     Dump(FILE* = 0);
 852       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 853       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 854         };
 855
 856       //
 857       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 858         {
 859           AudioChannelLabelSubDescriptor();
 860
 861         public:
 862           const Dictionary*& m_Dict;
 863           UUID SoundfieldGroupLinkID;
 864
 865       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 866       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 867       virtual ~AudioChannelLabelSubDescriptor() {}
 868
 869       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 870       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 871       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 872       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 873       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 874       virtual void     Dump(FILE* = 0);
 875       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 876       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 877         };
 878
 879       //
 880       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 881         {
 882           SoundfieldGroupLabelSubDescriptor();
 883
 884         public:
 885           const Dictionary*& m_Dict;
 886           Array<UUID> GroupOfSoundfieldGroupsLinkID;
 887
 888       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 889       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 890       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 891
 892       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 893       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 894       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 895       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 896       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 897       virtual void     Dump(FILE* = 0);
 898       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 899       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 900         };
 901
 902       //
 903       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 904         {
 905           GroupOfSoundfieldGroupsLabelSubDescriptor();
 906
 907         public:
 908           const Dictionary*& m_Dict;
 909
 910       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 911       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 912       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 913
 914       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 915       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 916       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 917       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 918       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 919       virtual void     Dump(FILE* = 0);
 920       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 921       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 922         };
 923
 924       //
 925       class DCDataDescriptor : public GenericDataEssenceDescriptor
 926         {
 927           DCDataDescriptor();
 928
 929         public:
 930           const Dictionary*& m_Dict;
 931
 932       DCDataDescriptor(const Dictionary*& d);
 933       DCDataDescriptor(const DCDataDescriptor& rhs);
 934       virtual ~DCDataDescriptor() {}
 935
 936       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
 937       virtual void Copy(const DCDataDescriptor& rhs);
 938       virtual const char* HasName() { return "DCDataDescriptor"; }
 939       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 940       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 941       virtual void     Dump(FILE* = 0);
 942       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 943       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 944         };
 945
 946       //
 947       class DolbyAtmosSubDescriptor : public InterchangeObject
 948         {
 949           DolbyAtmosSubDescriptor();
 950
 951         public:
 952           const Dictionary*& m_Dict;
 953           UUID AtmosID;
 954           ui32_t FirstFrame;
 955           ui16_t MaxChannelCount;
 956           ui16_t MaxObjectCount;
 957           ui8_t AtmosVersion;
 958
 959       DolbyAtmosSubDescriptor(const Dictionary*& d);
 960       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
 961       virtual ~DolbyAtmosSubDescriptor() {}
 962
 963       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
 964       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
 965       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
 966       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 967       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 968       virtual void     Dump(FILE* = 0);
 969       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 970       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 971         };
 972
 973     } // namespace MXF
 974 } // namespace ASDCP
 975
 976
 977 #endif // _Metadata_H_
 978
 979 //
 980 // end Metadata.h
 981 //