src/Metadata.h

   1 /*
   2 Copyright (c) 2005-2017, 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           Array<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           Array<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           Array<UUID> Locators;
 369           Array<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           optional_property<Rational > ReferenceImageEditRate;
 452           optional_property<ui8_t > ReferenceAudioAlignmentLevel;
 453
 454       WaveAudioDescriptor(const Dictionary*& d);
 455       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
 456       virtual ~WaveAudioDescriptor() {}
 457
 458       const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
 459       virtual void Copy(const WaveAudioDescriptor& rhs);
 460       virtual const char* HasName() { return "WaveAudioDescriptor"; }
 461       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 462       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 463       virtual void     Dump(FILE* = 0);
 464       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 465       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 466         };
 467
 468       //
 469       class GenericPictureEssenceDescriptor : public FileDescriptor
 470         {
 471           GenericPictureEssenceDescriptor();
 472
 473         public:
 474           const Dictionary*& m_Dict;
 475           optional_property<ui8_t > SignalStandard;
 476           ui8_t FrameLayout;
 477           ui32_t StoredWidth;
 478           ui32_t StoredHeight;
 479           optional_property<ui32_t > StoredF2Offset;
 480           optional_property<ui32_t > SampledWidth;
 481           optional_property<ui32_t > SampledHeight;
 482           optional_property<ui32_t > SampledXOffset;
 483           optional_property<ui32_t > SampledYOffset;
 484           optional_property<ui32_t > DisplayHeight;
 485           optional_property<ui32_t > DisplayWidth;
 486           optional_property<ui32_t > DisplayXOffset;
 487           optional_property<ui32_t > DisplayYOffset;
 488           optional_property<ui32_t > DisplayF2Offset;
 489           Rational AspectRatio;
 490           optional_property<ui8_t > ActiveFormatDescriptor;
 491           optional_property<ui8_t > AlphaTransparency;
 492           optional_property<UL > TransferCharacteristic;
 493           optional_property<ui32_t > ImageAlignmentOffset;
 494           optional_property<ui32_t > ImageStartOffset;
 495           optional_property<ui32_t > ImageEndOffset;
 496           optional_property<ui8_t > FieldDominance;
 497           UL PictureEssenceCoding;
 498           optional_property<UL > CodingEquations;
 499           optional_property<UL > ColorPrimaries;
 500           optional_property<Batch<UL> > AlternativeCenterCuts;
 501           optional_property<ui32_t > ActiveWidth;
 502           optional_property<ui32_t > ActiveHeight;
 503           optional_property<ui32_t > ActiveXOffset;
 504           optional_property<ui32_t > ActiveYOffset;
 505           optional_property<LineMapPair > VideoLineMap;
 506           optional_property<ThreeColorPrimaries > MasteringDisplayPrimaries;
 507           optional_property<ColorPrimary > MasteringDisplayWhitePointChromaticity;
 508           optional_property<ui32_t > MasteringDisplayMaximumLuminance;
 509           optional_property<ui32_t > MasteringDisplayMinimumLuminance;
 510
 511       GenericPictureEssenceDescriptor(const Dictionary*& d);
 512       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
 513       virtual ~GenericPictureEssenceDescriptor() {}
 514
 515       const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 516       virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
 517       virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 518       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 519       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 520       virtual void     Dump(FILE* = 0);
 521       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 522       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 523         };
 524
 525       //
 526       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 527         {
 528           RGBAEssenceDescriptor();
 529
 530         public:
 531           const Dictionary*& m_Dict;
 532           optional_property<ui32_t > ComponentMaxRef;
 533           optional_property<ui32_t > ComponentMinRef;
 534           optional_property<ui32_t > AlphaMinRef;
 535           optional_property<ui32_t > AlphaMaxRef;
 536           optional_property<ui8_t > ScanningDirection;
 537           RGBALayout PixelLayout;
 538
 539       RGBAEssenceDescriptor(const Dictionary*& d);
 540       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
 541       virtual ~RGBAEssenceDescriptor() {}
 542
 543       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 544       virtual void Copy(const RGBAEssenceDescriptor& rhs);
 545       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 546       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 547       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 548       virtual void     Dump(FILE* = 0);
 549       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 550       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 551         };
 552
 553       //
 554       class JPEG2000PictureSubDescriptor : public InterchangeObject
 555         {
 556           JPEG2000PictureSubDescriptor();
 557
 558         public:
 559           const Dictionary*& m_Dict;
 560           ui16_t Rsize;
 561           ui32_t Xsize;
 562           ui32_t Ysize;
 563           ui32_t XOsize;
 564           ui32_t YOsize;
 565           ui32_t XTsize;
 566           ui32_t YTsize;
 567           ui32_t XTOsize;
 568           ui32_t YTOsize;
 569           ui16_t Csize;
 570           optional_property<Raw > PictureComponentSizing;
 571           optional_property<Raw > CodingStyleDefault;
 572           optional_property<Raw > QuantizationDefault;
 573           optional_property<RGBALayout > J2CLayout;
 574
 575       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 576       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 577       virtual ~JPEG2000PictureSubDescriptor() {}
 578
 579       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 580       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 581       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 582       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 583       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 584       virtual void     Dump(FILE* = 0);
 585       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 586       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 587         };
 588
 589       //
 590       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 591         {
 592           CDCIEssenceDescriptor();
 593
 594         public:
 595           const Dictionary*& m_Dict;
 596           ui32_t ComponentDepth;
 597           ui32_t HorizontalSubsampling;
 598           optional_property<ui32_t > VerticalSubsampling;
 599           optional_property<ui8_t > ColorSiting;
 600           optional_property<ui8_t > ReversedByteOrder;
 601           optional_property<ui16_t > PaddingBits;
 602           optional_property<ui32_t > AlphaSampleDepth;
 603           optional_property<ui32_t > BlackRefLevel;
 604           optional_property<ui32_t > WhiteReflevel;
 605           optional_property<ui32_t > ColorRange;
 606
 607       CDCIEssenceDescriptor(const Dictionary*& d);
 608       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 609       virtual ~CDCIEssenceDescriptor() {}
 610
 611       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 612       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 613       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 614       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 615       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 616       virtual void     Dump(FILE* = 0);
 617       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 618       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 619         };
 620
 621       //
 622       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 623         {
 624           MPEG2VideoDescriptor();
 625
 626         public:
 627           const Dictionary*& m_Dict;
 628           optional_property<ui8_t > SingleSequence;
 629           optional_property<ui8_t > ConstantBFrames;
 630           optional_property<ui8_t > CodedContentType;
 631           optional_property<ui8_t > LowDelay;
 632           optional_property<ui8_t > ClosedGOP;
 633           optional_property<ui8_t > IdenticalGOP;
 634           optional_property<ui8_t > MaxGOP;
 635           optional_property<ui8_t > BPictureCount;
 636           optional_property<ui32_t > BitRate;
 637           optional_property<ui8_t > ProfileAndLevel;
 638
 639       MPEG2VideoDescriptor(const Dictionary*& d);
 640       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 641       virtual ~MPEG2VideoDescriptor() {}
 642
 643       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 644       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 645       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 646       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 647       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 648       virtual void     Dump(FILE* = 0);
 649       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 650       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 651         };
 652
 653       //
 654       class DMSegment : public InterchangeObject
 655         {
 656           DMSegment();
 657
 658         public:
 659           const Dictionary*& m_Dict;
 660           UL DataDefinition;
 661           ui64_t EventStartPosition;
 662           ui64_t Duration;
 663           UTF16String EventComment;
 664           UUID DMFramework;
 665
 666       DMSegment(const Dictionary*& d);
 667       DMSegment(const DMSegment& rhs);
 668       virtual ~DMSegment() {}
 669
 670       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 671       virtual void Copy(const DMSegment& rhs);
 672       virtual const char* HasName() { return "DMSegment"; }
 673       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 674       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 675       virtual void     Dump(FILE* = 0);
 676       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 677       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 678         };
 679
 680       //
 681       class CryptographicFramework : public InterchangeObject
 682         {
 683           CryptographicFramework();
 684
 685         public:
 686           const Dictionary*& m_Dict;
 687           UUID ContextSR;
 688
 689       CryptographicFramework(const Dictionary*& d);
 690       CryptographicFramework(const CryptographicFramework& rhs);
 691       virtual ~CryptographicFramework() {}
 692
 693       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 694       virtual void Copy(const CryptographicFramework& rhs);
 695       virtual const char* HasName() { return "CryptographicFramework"; }
 696       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 697       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 698       virtual void     Dump(FILE* = 0);
 699       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 700       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 701         };
 702
 703       //
 704       class CryptographicContext : public InterchangeObject
 705         {
 706           CryptographicContext();
 707
 708         public:
 709           const Dictionary*& m_Dict;
 710           UUID ContextID;
 711           UL SourceEssenceContainer;
 712           UL CipherAlgorithm;
 713           UL MICAlgorithm;
 714           UUID CryptographicKeyID;
 715
 716       CryptographicContext(const Dictionary*& d);
 717       CryptographicContext(const CryptographicContext& rhs);
 718       virtual ~CryptographicContext() {}
 719
 720       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 721       virtual void Copy(const CryptographicContext& rhs);
 722       virtual const char* HasName() { return "CryptographicContext"; }
 723       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 724       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 725       virtual void     Dump(FILE* = 0);
 726       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 727       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 728         };
 729
 730       //
 731       class GenericDataEssenceDescriptor : public FileDescriptor
 732         {
 733           GenericDataEssenceDescriptor();
 734
 735         public:
 736           const Dictionary*& m_Dict;
 737           UL DataEssenceCoding;
 738
 739       GenericDataEssenceDescriptor(const Dictionary*& d);
 740       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 741       virtual ~GenericDataEssenceDescriptor() {}
 742
 743       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 744       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 745       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 746       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 747       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 748       virtual void     Dump(FILE* = 0);
 749       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 750       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 751         };
 752
 753       //
 754       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 755         {
 756           TimedTextDescriptor();
 757
 758         public:
 759           const Dictionary*& m_Dict;
 760           UUID ResourceID;
 761           UTF16String UCSEncoding;
 762           UTF16String NamespaceURI;
 763           optional_property<UTF16String > RFC5646LanguageTagList;
 764
 765       TimedTextDescriptor(const Dictionary*& d);
 766       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 767       virtual ~TimedTextDescriptor() {}
 768
 769       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 770       virtual void Copy(const TimedTextDescriptor& rhs);
 771       virtual const char* HasName() { return "TimedTextDescriptor"; }
 772       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 773       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 774       virtual void     Dump(FILE* = 0);
 775       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 776       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 777         };
 778
 779       //
 780       class TimedTextResourceSubDescriptor : public InterchangeObject
 781         {
 782           TimedTextResourceSubDescriptor();
 783
 784         public:
 785           const Dictionary*& m_Dict;
 786           UUID AncillaryResourceID;
 787           UTF16String MIMEMediaType;
 788           ui32_t EssenceStreamID;
 789
 790       TimedTextResourceSubDescriptor(const Dictionary*& d);
 791       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 792       virtual ~TimedTextResourceSubDescriptor() {}
 793
 794       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 795       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 796       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 797       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 798       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 799       virtual void     Dump(FILE* = 0);
 800       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 801       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 802         };
 803
 804       //
 805       class StereoscopicPictureSubDescriptor : public InterchangeObject
 806         {
 807           StereoscopicPictureSubDescriptor();
 808
 809         public:
 810           const Dictionary*& m_Dict;
 811
 812       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 813       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 814       virtual ~StereoscopicPictureSubDescriptor() {}
 815
 816       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 817       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 818       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 819       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 820       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 821       virtual void     Dump(FILE* = 0);
 822       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 823       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 824         };
 825
 826       //
 827       class ContainerConstraintSubDescriptor : public InterchangeObject
 828         {
 829           ContainerConstraintSubDescriptor();
 830
 831         public:
 832           const Dictionary*& m_Dict;
 833
 834       ContainerConstraintSubDescriptor(const Dictionary*& d);
 835       ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs);
 836       virtual ~ContainerConstraintSubDescriptor() {}
 837
 838       const ContainerConstraintSubDescriptor& operator=(const ContainerConstraintSubDescriptor& rhs) { Copy(rhs); return *this; }
 839       virtual void Copy(const ContainerConstraintSubDescriptor& rhs);
 840       virtual const char* HasName() { return "ContainerConstraintSubDescriptor"; }
 841       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 842       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 843       virtual void     Dump(FILE* = 0);
 844       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 845       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 846         };
 847
 848       //
 849       class NetworkLocator : public InterchangeObject
 850         {
 851           NetworkLocator();
 852
 853         public:
 854           const Dictionary*& m_Dict;
 855           UTF16String URLString;
 856
 857       NetworkLocator(const Dictionary*& d);
 858       NetworkLocator(const NetworkLocator& rhs);
 859       virtual ~NetworkLocator() {}
 860
 861       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 862       virtual void Copy(const NetworkLocator& rhs);
 863       virtual const char* HasName() { return "NetworkLocator"; }
 864       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 865       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 866       virtual void     Dump(FILE* = 0);
 867       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 868       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 869         };
 870
 871       //
 872       class MCALabelSubDescriptor : public InterchangeObject
 873         {
 874           MCALabelSubDescriptor();
 875
 876         public:
 877           const Dictionary*& m_Dict;
 878           UL MCALabelDictionaryID;
 879           UUID MCALinkID;
 880           UTF16String MCATagSymbol;
 881           optional_property<UTF16String > MCATagName;
 882           optional_property<ui32_t > MCAChannelID;
 883           optional_property<ISO8String > RFC5646SpokenLanguage;
 884           optional_property<UTF16String > MCATitle;
 885           optional_property<UTF16String > MCATitleVersion;
 886           optional_property<UTF16String > MCATitleSubVersion;
 887           optional_property<UTF16String > MCAEpisode;
 888           optional_property<UTF16String > MCAPartitionKind;
 889           optional_property<UTF16String > MCAPartitionNumber;
 890           optional_property<UTF16String > MCAAudioContentKind;
 891           optional_property<UTF16String > MCAAudioElementKind;
 892
 893       MCALabelSubDescriptor(const Dictionary*& d);
 894       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 895       virtual ~MCALabelSubDescriptor() {}
 896
 897       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 898       virtual void Copy(const MCALabelSubDescriptor& rhs);
 899       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 900       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 901       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 902       virtual void     Dump(FILE* = 0);
 903       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 904       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 905         };
 906
 907       //
 908       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 909         {
 910           AudioChannelLabelSubDescriptor();
 911
 912         public:
 913           const Dictionary*& m_Dict;
 914           optional_property<UUID > SoundfieldGroupLinkID;
 915
 916       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 917       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 918       virtual ~AudioChannelLabelSubDescriptor() {}
 919
 920       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 921       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 922       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 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 SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 932         {
 933           SoundfieldGroupLabelSubDescriptor();
 934
 935         public:
 936           const Dictionary*& m_Dict;
 937           optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 938
 939       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 940       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 941       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 942
 943       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 944       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 945       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 946       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 947       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 948       virtual void     Dump(FILE* = 0);
 949       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 950       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 951         };
 952
 953       //
 954       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 955         {
 956           GroupOfSoundfieldGroupsLabelSubDescriptor();
 957
 958         public:
 959           const Dictionary*& m_Dict;
 960
 961       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 962       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 963       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 964
 965       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 966       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 967       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 968       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 969       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 970       virtual void     Dump(FILE* = 0);
 971       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 972       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 973         };
 974
 975       //
 976       class DCDataDescriptor : public GenericDataEssenceDescriptor
 977         {
 978           DCDataDescriptor();
 979
 980         public:
 981           const Dictionary*& m_Dict;
 982
 983       DCDataDescriptor(const Dictionary*& d);
 984       DCDataDescriptor(const DCDataDescriptor& rhs);
 985       virtual ~DCDataDescriptor() {}
 986
 987       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
 988       virtual void Copy(const DCDataDescriptor& rhs);
 989       virtual const char* HasName() { return "DCDataDescriptor"; }
 990       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 991       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 992       virtual void     Dump(FILE* = 0);
 993       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 994       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 995         };
 996
 997       //
 998       class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
 999         {
1000           PrivateDCDataDescriptor();
1001
1002         public:
1003           const Dictionary*& m_Dict;
1004
1005       PrivateDCDataDescriptor(const Dictionary*& d);
1006       PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
1007       virtual ~PrivateDCDataDescriptor() {}
1008
1009       const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
1010       virtual void Copy(const PrivateDCDataDescriptor& rhs);
1011       virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
1012       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1013       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1014       virtual void     Dump(FILE* = 0);
1015       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1016       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1017         };
1018
1019       //
1020       class DolbyAtmosSubDescriptor : public InterchangeObject
1021         {
1022           DolbyAtmosSubDescriptor();
1023
1024         public:
1025           const Dictionary*& m_Dict;
1026           UUID AtmosID;
1027           ui32_t FirstFrame;
1028           ui16_t MaxChannelCount;
1029           ui16_t MaxObjectCount;
1030           ui8_t AtmosVersion;
1031
1032       DolbyAtmosSubDescriptor(const Dictionary*& d);
1033       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
1034       virtual ~DolbyAtmosSubDescriptor() {}
1035
1036       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
1037       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
1038       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
1039       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1040       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1041       virtual void     Dump(FILE* = 0);
1042       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1043       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1044         };
1045
1046       //
1047       class ACESPictureSubDescriptor : public InterchangeObject
1048         {
1049           ACESPictureSubDescriptor();
1050
1051         public:
1052           const Dictionary*& m_Dict;
1053           optional_property<UTF16String > ACESAuthoringInformation;
1054           optional_property<ThreeColorPrimaries > ACESMasteringDisplayPrimaries;
1055           optional_property<ColorPrimary > ACESMasteringDisplayWhitePointChromaticity;
1056           optional_property<ui32_t > ACESMasteringDisplayMaximumLuminance;
1057           optional_property<ui32_t > ACESMasteringDisplayMinimumLuminance;
1058
1059       ACESPictureSubDescriptor(const Dictionary*& d);
1060       ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs);
1061       virtual ~ACESPictureSubDescriptor() {}
1062
1063       const ACESPictureSubDescriptor& operator=(const ACESPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
1064       virtual void Copy(const ACESPictureSubDescriptor& rhs);
1065       virtual const char* HasName() { return "ACESPictureSubDescriptor"; }
1066       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1067       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1068       virtual void     Dump(FILE* = 0);
1069       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1070       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1071         };
1072
1073       //
1074       class TargetFrameSubDescriptor : public InterchangeObject
1075         {
1076           TargetFrameSubDescriptor();
1077
1078         public:
1079           const Dictionary*& m_Dict;
1080           UUID TargetFrameAncillaryResourceID;
1081           UTF16String MediaType;
1082           ui64_t TargetFrameIndex;
1083           UL TargetFrameTransferCharacteristic;
1084           UL TargetFrameColorPrimaries;
1085           ui32_t TargetFrameComponentMaxRef;
1086           ui32_t TargetFrameComponentMinRef;
1087           ui32_t TargetFrameEssenceStreamID;
1088           optional_property<UUID > ACESPictureSubDescriptorInstanceID;
1089           optional_property<UL > TargetFrameViewingEnvironment;
1090
1091       TargetFrameSubDescriptor(const Dictionary*& d);
1092       TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs);
1093       virtual ~TargetFrameSubDescriptor() {}
1094
1095       const TargetFrameSubDescriptor& operator=(const TargetFrameSubDescriptor& rhs) { Copy(rhs); return *this; }
1096       virtual void Copy(const TargetFrameSubDescriptor& rhs);
1097       virtual const char* HasName() { return "TargetFrameSubDescriptor"; }
1098       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1099       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1100       virtual void     Dump(FILE* = 0);
1101       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1102       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1103         };
1104
1105       //
1106       class PHDRMetadataTrackSubDescriptor : public InterchangeObject
1107         {
1108           PHDRMetadataTrackSubDescriptor();
1109
1110         public:
1111           const Dictionary*& m_Dict;
1112           UL DataDefinition;
1113           ui32_t SourceTrackID;
1114           ui32_t SimplePayloadSID;
1115
1116       PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
1117       PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
1118       virtual ~PHDRMetadataTrackSubDescriptor() {}
1119
1120       const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
1121       virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
1122       virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
1123       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1124       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1125       virtual void     Dump(FILE* = 0);
1126       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1127       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1128         };
1129
1130       //
1131       class PIMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
1132         {
1133           PIMFDynamicMetadataDescriptor();
1134
1135         public:
1136           const Dictionary*& m_Dict;
1137           ui32_t GlobalPayloadSID;
1138
1139       PIMFDynamicMetadataDescriptor(const Dictionary*& d);
1140       PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
1141       virtual ~PIMFDynamicMetadataDescriptor() {}
1142
1143       const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
1144       virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
1145       virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
1146       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1147       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1148       virtual void     Dump(FILE* = 0);
1149       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1150       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1151         };
1152
1153     } // namespace MXF
1154 } // namespace ASDCP
1155
1156
1157 #endif // _Metadata_H_
1158
1159 //
1160 // end Metadata.h
1161 //