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           optional_property<ui8_t > ReferenceAudioAlignmentLevel;
 426           optional_property<Rational > ReferenceImageEditRate;
 427
 428       GenericSoundEssenceDescriptor(const Dictionary*& d);
 429       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
 430       virtual ~GenericSoundEssenceDescriptor() {}
 431
 432       const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 433       virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
 434       virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 435       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 436       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 437       virtual void     Dump(FILE* = 0);
 438       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 439       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 440         };
 441
 442       //
 443       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 444         {
 445           WaveAudioDescriptor();
 446
 447         public:
 448           const Dictionary*& m_Dict;
 449           ui16_t BlockAlign;
 450           optional_property<ui8_t > SequenceOffset;
 451           ui32_t AvgBps;
 452           optional_property<UL > ChannelAssignment;
 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 DescriptiveFramework : public InterchangeObject
 732         {
 733           DescriptiveFramework();
 734
 735         public:
 736           const Dictionary*& m_Dict;
 737           optional_property<UUID > LinkedDescriptiveFrameworkPlugInId;
 738
 739       DescriptiveFramework(const Dictionary*& d);
 740       DescriptiveFramework(const DescriptiveFramework& rhs);
 741       virtual ~DescriptiveFramework() {}
 742
 743       const DescriptiveFramework& operator=(const DescriptiveFramework& rhs) { Copy(rhs); return *this; }
 744       virtual void Copy(const DescriptiveFramework& rhs);
 745       virtual const char* HasName() { return "DescriptiveFramework"; }
 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 DescriptiveObject : public InterchangeObject
 755         {
 756           DescriptiveObject();
 757
 758         public:
 759           const Dictionary*& m_Dict;
 760           optional_property<UUID > LinkedDescriptiveObjectPlugInId;
 761
 762       DescriptiveObject(const Dictionary*& d);
 763       DescriptiveObject(const DescriptiveObject& rhs);
 764       virtual ~DescriptiveObject() {}
 765
 766       const DescriptiveObject& operator=(const DescriptiveObject& rhs) { Copy(rhs); return *this; }
 767       virtual void Copy(const DescriptiveObject& rhs);
 768       virtual const char* HasName() { return "DescriptiveObject"; }
 769       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 770       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 771       virtual void     Dump(FILE* = 0);
 772       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 773       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 774         };
 775
 776       //
 777       class GenericDataEssenceDescriptor : public FileDescriptor
 778         {
 779           GenericDataEssenceDescriptor();
 780
 781         public:
 782           const Dictionary*& m_Dict;
 783           UL DataEssenceCoding;
 784
 785       GenericDataEssenceDescriptor(const Dictionary*& d);
 786       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 787       virtual ~GenericDataEssenceDescriptor() {}
 788
 789       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 790       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 791       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 792       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 793       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 794       virtual void     Dump(FILE* = 0);
 795       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 796       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 797         };
 798
 799       //
 800       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 801         {
 802           TimedTextDescriptor();
 803
 804         public:
 805           const Dictionary*& m_Dict;
 806           UUID ResourceID;
 807           UTF16String UCSEncoding;
 808           UTF16String NamespaceURI;
 809           optional_property<UTF16String > RFC5646LanguageTagList;
 810
 811       TimedTextDescriptor(const Dictionary*& d);
 812       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 813       virtual ~TimedTextDescriptor() {}
 814
 815       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 816       virtual void Copy(const TimedTextDescriptor& rhs);
 817       virtual const char* HasName() { return "TimedTextDescriptor"; }
 818       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 819       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 820       virtual void     Dump(FILE* = 0);
 821       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 822       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 823         };
 824
 825       //
 826       class TimedTextResourceSubDescriptor : public InterchangeObject
 827         {
 828           TimedTextResourceSubDescriptor();
 829
 830         public:
 831           const Dictionary*& m_Dict;
 832           UUID AncillaryResourceID;
 833           UTF16String MIMEMediaType;
 834           ui32_t EssenceStreamID;
 835
 836       TimedTextResourceSubDescriptor(const Dictionary*& d);
 837       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 838       virtual ~TimedTextResourceSubDescriptor() {}
 839
 840       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 841       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 842       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 843       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 844       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 845       virtual void     Dump(FILE* = 0);
 846       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 847       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 848         };
 849
 850       //
 851       class StereoscopicPictureSubDescriptor : public InterchangeObject
 852         {
 853           StereoscopicPictureSubDescriptor();
 854
 855         public:
 856           const Dictionary*& m_Dict;
 857
 858       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 859       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 860       virtual ~StereoscopicPictureSubDescriptor() {}
 861
 862       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 863       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 864       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 865       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 866       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 867       virtual void     Dump(FILE* = 0);
 868       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 869       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 870         };
 871
 872       //
 873       class ContainerConstraintSubDescriptor : public InterchangeObject
 874         {
 875           ContainerConstraintSubDescriptor();
 876
 877         public:
 878           const Dictionary*& m_Dict;
 879
 880       ContainerConstraintSubDescriptor(const Dictionary*& d);
 881       ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs);
 882       virtual ~ContainerConstraintSubDescriptor() {}
 883
 884       const ContainerConstraintSubDescriptor& operator=(const ContainerConstraintSubDescriptor& rhs) { Copy(rhs); return *this; }
 885       virtual void Copy(const ContainerConstraintSubDescriptor& rhs);
 886       virtual const char* HasName() { return "ContainerConstraintSubDescriptor"; }
 887       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 888       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 889       virtual void     Dump(FILE* = 0);
 890       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 891       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 892         };
 893
 894       //
 895       class NetworkLocator : public InterchangeObject
 896         {
 897           NetworkLocator();
 898
 899         public:
 900           const Dictionary*& m_Dict;
 901           UTF16String URLString;
 902
 903       NetworkLocator(const Dictionary*& d);
 904       NetworkLocator(const NetworkLocator& rhs);
 905       virtual ~NetworkLocator() {}
 906
 907       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 908       virtual void Copy(const NetworkLocator& rhs);
 909       virtual const char* HasName() { return "NetworkLocator"; }
 910       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 911       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 912       virtual void     Dump(FILE* = 0);
 913       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 914       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 915         };
 916
 917       //
 918       class MCALabelSubDescriptor : public InterchangeObject
 919         {
 920           MCALabelSubDescriptor();
 921
 922         public:
 923           const Dictionary*& m_Dict;
 924           UL MCALabelDictionaryID;
 925           UUID MCALinkID;
 926           UTF16String MCATagSymbol;
 927           optional_property<UTF16String > MCATagName;
 928           optional_property<ui32_t > MCAChannelID;
 929           optional_property<ISO8String > RFC5646SpokenLanguage;
 930           optional_property<UTF16String > MCATitle;
 931           optional_property<UTF16String > MCATitleVersion;
 932           optional_property<UTF16String > MCATitleSubVersion;
 933           optional_property<UTF16String > MCAEpisode;
 934           optional_property<UTF16String > MCAPartitionKind;
 935           optional_property<UTF16String > MCAPartitionNumber;
 936           optional_property<UTF16String > MCAAudioContentKind;
 937           optional_property<UTF16String > MCAAudioElementKind;
 938
 939       MCALabelSubDescriptor(const Dictionary*& d);
 940       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 941       virtual ~MCALabelSubDescriptor() {}
 942
 943       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 944       virtual void Copy(const MCALabelSubDescriptor& rhs);
 945       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 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 AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 955         {
 956           AudioChannelLabelSubDescriptor();
 957
 958         public:
 959           const Dictionary*& m_Dict;
 960           optional_property<UUID > SoundfieldGroupLinkID;
 961
 962       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 963       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 964       virtual ~AudioChannelLabelSubDescriptor() {}
 965
 966       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 967       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 968       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 969       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 970       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 971       virtual void     Dump(FILE* = 0);
 972       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 973       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 974         };
 975
 976       //
 977       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 978         {
 979           SoundfieldGroupLabelSubDescriptor();
 980
 981         public:
 982           const Dictionary*& m_Dict;
 983           optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 984
 985       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 986       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 987       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 988
 989       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 990       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 991       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 992       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 993       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 994       virtual void     Dump(FILE* = 0);
 995       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 996       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 997         };
 998
 999       //
1000       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
1001         {
1002           GroupOfSoundfieldGroupsLabelSubDescriptor();
1003
1004         public:
1005           const Dictionary*& m_Dict;
1006
1007       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
1008       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
1009       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
1010
1011       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
1012       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
1013       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
1014       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1015       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1016       virtual void     Dump(FILE* = 0);
1017       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1018       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1019         };
1020
1021       //
1022       class DCDataDescriptor : public GenericDataEssenceDescriptor
1023         {
1024           DCDataDescriptor();
1025
1026         public:
1027           const Dictionary*& m_Dict;
1028
1029       DCDataDescriptor(const Dictionary*& d);
1030       DCDataDescriptor(const DCDataDescriptor& rhs);
1031       virtual ~DCDataDescriptor() {}
1032
1033       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
1034       virtual void Copy(const DCDataDescriptor& rhs);
1035       virtual const char* HasName() { return "DCDataDescriptor"; }
1036       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1037       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1038       virtual void     Dump(FILE* = 0);
1039       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1040       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1041         };
1042
1043       //
1044       class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
1045         {
1046           PrivateDCDataDescriptor();
1047
1048         public:
1049           const Dictionary*& m_Dict;
1050
1051       PrivateDCDataDescriptor(const Dictionary*& d);
1052       PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
1053       virtual ~PrivateDCDataDescriptor() {}
1054
1055       const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
1056       virtual void Copy(const PrivateDCDataDescriptor& rhs);
1057       virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
1058       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1059       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1060       virtual void     Dump(FILE* = 0);
1061       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1062       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1063         };
1064
1065       //
1066       class DolbyAtmosSubDescriptor : public InterchangeObject
1067         {
1068           DolbyAtmosSubDescriptor();
1069
1070         public:
1071           const Dictionary*& m_Dict;
1072           UUID AtmosID;
1073           ui32_t FirstFrame;
1074           ui16_t MaxChannelCount;
1075           ui16_t MaxObjectCount;
1076           ui8_t AtmosVersion;
1077
1078       DolbyAtmosSubDescriptor(const Dictionary*& d);
1079       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
1080       virtual ~DolbyAtmosSubDescriptor() {}
1081
1082       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
1083       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
1084       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
1085       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1086       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1087       virtual void     Dump(FILE* = 0);
1088       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1089       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1090         };
1091
1092       //
1093       class ACESPictureSubDescriptor : public InterchangeObject
1094         {
1095           ACESPictureSubDescriptor();
1096
1097         public:
1098           const Dictionary*& m_Dict;
1099           optional_property<UTF16String > ACESAuthoringInformation;
1100           optional_property<ThreeColorPrimaries > ACESMasteringDisplayPrimaries;
1101           optional_property<ColorPrimary > ACESMasteringDisplayWhitePointChromaticity;
1102           optional_property<ui32_t > ACESMasteringDisplayMaximumLuminance;
1103           optional_property<ui32_t > ACESMasteringDisplayMinimumLuminance;
1104
1105       ACESPictureSubDescriptor(const Dictionary*& d);
1106       ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs);
1107       virtual ~ACESPictureSubDescriptor() {}
1108
1109       const ACESPictureSubDescriptor& operator=(const ACESPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
1110       virtual void Copy(const ACESPictureSubDescriptor& rhs);
1111       virtual const char* HasName() { return "ACESPictureSubDescriptor"; }
1112       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1113       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1114       virtual void     Dump(FILE* = 0);
1115       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1116       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1117         };
1118
1119       //
1120       class TargetFrameSubDescriptor : public InterchangeObject
1121         {
1122           TargetFrameSubDescriptor();
1123
1124         public:
1125           const Dictionary*& m_Dict;
1126           UUID TargetFrameAncillaryResourceID;
1127           UTF16String MediaType;
1128           ui64_t TargetFrameIndex;
1129           UL TargetFrameTransferCharacteristic;
1130           UL TargetFrameColorPrimaries;
1131           ui32_t TargetFrameComponentMaxRef;
1132           ui32_t TargetFrameComponentMinRef;
1133           ui32_t TargetFrameEssenceStreamID;
1134           optional_property<UUID > ACESPictureSubDescriptorInstanceID;
1135           optional_property<UL > TargetFrameViewingEnvironment;
1136
1137       TargetFrameSubDescriptor(const Dictionary*& d);
1138       TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs);
1139       virtual ~TargetFrameSubDescriptor() {}
1140
1141       const TargetFrameSubDescriptor& operator=(const TargetFrameSubDescriptor& rhs) { Copy(rhs); return *this; }
1142       virtual void Copy(const TargetFrameSubDescriptor& rhs);
1143       virtual const char* HasName() { return "TargetFrameSubDescriptor"; }
1144       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1145       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1146       virtual void     Dump(FILE* = 0);
1147       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1148       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1149         };
1150
1151       //
1152       class TextBasedDMFramework : public DescriptiveFramework
1153         {
1154           TextBasedDMFramework();
1155
1156         public:
1157           const Dictionary*& m_Dict;
1158           optional_property<UUID > ObjectRef;
1159
1160       TextBasedDMFramework(const Dictionary*& d);
1161       TextBasedDMFramework(const TextBasedDMFramework& rhs);
1162       virtual ~TextBasedDMFramework() {}
1163
1164       const TextBasedDMFramework& operator=(const TextBasedDMFramework& rhs) { Copy(rhs); return *this; }
1165       virtual void Copy(const TextBasedDMFramework& rhs);
1166       virtual const char* HasName() { return "TextBasedDMFramework"; }
1167       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1168       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1169       virtual void     Dump(FILE* = 0);
1170       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1171       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1172         };
1173
1174       //
1175       class TextBasedObject : public DescriptiveObject
1176         {
1177           TextBasedObject();
1178
1179         public:
1180           const Dictionary*& m_Dict;
1181           UL PayloadSchemeID;
1182           UTF16String TextMIMEMediaType;
1183           UTF16String RFC5646TextLanguageCode;
1184           optional_property<UTF16String > TextDataDescription;
1185
1186       TextBasedObject(const Dictionary*& d);
1187       TextBasedObject(const TextBasedObject& rhs);
1188       virtual ~TextBasedObject() {}
1189
1190       const TextBasedObject& operator=(const TextBasedObject& rhs) { Copy(rhs); return *this; }
1191       virtual void Copy(const TextBasedObject& rhs);
1192       virtual const char* HasName() { return "TextBasedObject"; }
1193       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1194       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1195       virtual void     Dump(FILE* = 0);
1196       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1197       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1198         };
1199
1200       //
1201       class GenericStreamTextBasedSet : public TextBasedObject
1202         {
1203           GenericStreamTextBasedSet();
1204
1205         public:
1206           const Dictionary*& m_Dict;
1207           ui32_t GenericStreamSID;
1208
1209       GenericStreamTextBasedSet(const Dictionary*& d);
1210       GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs);
1211       virtual ~GenericStreamTextBasedSet() {}
1212
1213       const GenericStreamTextBasedSet& operator=(const GenericStreamTextBasedSet& rhs) { Copy(rhs); return *this; }
1214       virtual void Copy(const GenericStreamTextBasedSet& rhs);
1215       virtual const char* HasName() { return "GenericStreamTextBasedSet"; }
1216       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1217       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1218       virtual void     Dump(FILE* = 0);
1219       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1220       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1221         };
1222
1223       //
1224       class ISXDDataEssenceDescriptor : public GenericDataEssenceDescriptor
1225         {
1226           ISXDDataEssenceDescriptor();
1227
1228         public:
1229           const Dictionary*& m_Dict;
1230           ISO8String NamespaceURI;
1231
1232       ISXDDataEssenceDescriptor(const Dictionary*& d);
1233       ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs);
1234       virtual ~ISXDDataEssenceDescriptor() {}
1235
1236       const ISXDDataEssenceDescriptor& operator=(const ISXDDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
1237       virtual void Copy(const ISXDDataEssenceDescriptor& rhs);
1238       virtual const char* HasName() { return "ISXDDataEssenceDescriptor"; }
1239       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1240       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1241       virtual void     Dump(FILE* = 0);
1242       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1243       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1244         };
1245
1246       //
1247       class PHDRMetadataTrackSubDescriptor : public InterchangeObject
1248         {
1249           PHDRMetadataTrackSubDescriptor();
1250
1251         public:
1252           const Dictionary*& m_Dict;
1253           UL DataDefinition;
1254           ui32_t SourceTrackID;
1255           ui32_t SimplePayloadSID;
1256
1257       PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
1258       PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
1259       virtual ~PHDRMetadataTrackSubDescriptor() {}
1260
1261       const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
1262       virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
1263       virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
1264       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1265       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1266       virtual void     Dump(FILE* = 0);
1267       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1268       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1269         };
1270
1271       //
1272       class PIMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
1273         {
1274           PIMFDynamicMetadataDescriptor();
1275
1276         public:
1277           const Dictionary*& m_Dict;
1278           ui32_t GlobalPayloadSID;
1279
1280       PIMFDynamicMetadataDescriptor(const Dictionary*& d);
1281       PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
1282       virtual ~PIMFDynamicMetadataDescriptor() {}
1283
1284       const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
1285       virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
1286       virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
1287       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1288       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1289       virtual void     Dump(FILE* = 0);
1290       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1291       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1292         };
1293
1294     } // namespace MXF
1295 } // namespace ASDCP
1296
1297
1298 #endif // _Metadata_H_
1299
1300 //
1301 // end Metadata.h
1302 //