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           optional_property<J2KExtendedCapabilities > J2KExtendedCapabilities;
 575           optional_property<Array<Kumu::ArchivableUi16> > J2KProfile;
 576           optional_property<Array<Kumu::ArchivableUi16> > J2KCorrespondingProfile;
 577
 578       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 579       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 580       virtual ~JPEG2000PictureSubDescriptor() {}
 581
 582       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 583       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 584       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 585       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 586       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 587       virtual void     Dump(FILE* = 0);
 588       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 589       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 590         };
 591
 592       //
 593       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 594         {
 595           CDCIEssenceDescriptor();
 596
 597         public:
 598           const Dictionary*& m_Dict;
 599           ui32_t ComponentDepth;
 600           ui32_t HorizontalSubsampling;
 601           optional_property<ui32_t > VerticalSubsampling;
 602           optional_property<ui8_t > ColorSiting;
 603           optional_property<ui8_t > ReversedByteOrder;
 604           optional_property<ui16_t > PaddingBits;
 605           optional_property<ui32_t > AlphaSampleDepth;
 606           optional_property<ui32_t > BlackRefLevel;
 607           optional_property<ui32_t > WhiteReflevel;
 608           optional_property<ui32_t > ColorRange;
 609
 610       CDCIEssenceDescriptor(const Dictionary*& d);
 611       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 612       virtual ~CDCIEssenceDescriptor() {}
 613
 614       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 615       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 616       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 617       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 618       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 619       virtual void     Dump(FILE* = 0);
 620       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 621       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 622         };
 623
 624       //
 625       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 626         {
 627           MPEG2VideoDescriptor();
 628
 629         public:
 630           const Dictionary*& m_Dict;
 631           optional_property<ui8_t > SingleSequence;
 632           optional_property<ui8_t > ConstantBFrames;
 633           optional_property<ui8_t > CodedContentType;
 634           optional_property<ui8_t > LowDelay;
 635           optional_property<ui8_t > ClosedGOP;
 636           optional_property<ui8_t > IdenticalGOP;
 637           optional_property<ui8_t > MaxGOP;
 638           optional_property<ui8_t > BPictureCount;
 639           optional_property<ui32_t > BitRate;
 640           optional_property<ui8_t > ProfileAndLevel;
 641
 642       MPEG2VideoDescriptor(const Dictionary*& d);
 643       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 644       virtual ~MPEG2VideoDescriptor() {}
 645
 646       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 647       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 648       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 649       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 650       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 651       virtual void     Dump(FILE* = 0);
 652       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 653       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 654         };
 655
 656       //
 657       class DMSegment : public InterchangeObject
 658         {
 659           DMSegment();
 660
 661         public:
 662           const Dictionary*& m_Dict;
 663           UL DataDefinition;
 664           optional_property<ui64_t > Duration;
 665           optional_property<ui64_t > EventStartPosition;
 666           optional_property<UTF16String > EventComment;
 667           UUID DMFramework;
 668
 669       DMSegment(const Dictionary*& d);
 670       DMSegment(const DMSegment& rhs);
 671       virtual ~DMSegment() {}
 672
 673       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 674       virtual void Copy(const DMSegment& rhs);
 675       virtual const char* HasName() { return "DMSegment"; }
 676       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 677       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 678       virtual void     Dump(FILE* = 0);
 679       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 680       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 681         };
 682
 683       //
 684       class CryptographicFramework : public InterchangeObject
 685         {
 686           CryptographicFramework();
 687
 688         public:
 689           const Dictionary*& m_Dict;
 690           UUID ContextSR;
 691
 692       CryptographicFramework(const Dictionary*& d);
 693       CryptographicFramework(const CryptographicFramework& rhs);
 694       virtual ~CryptographicFramework() {}
 695
 696       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 697       virtual void Copy(const CryptographicFramework& rhs);
 698       virtual const char* HasName() { return "CryptographicFramework"; }
 699       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 700       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 701       virtual void     Dump(FILE* = 0);
 702       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 703       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 704         };
 705
 706       //
 707       class CryptographicContext : public InterchangeObject
 708         {
 709           CryptographicContext();
 710
 711         public:
 712           const Dictionary*& m_Dict;
 713           UUID ContextID;
 714           UL SourceEssenceContainer;
 715           UL CipherAlgorithm;
 716           UL MICAlgorithm;
 717           UUID CryptographicKeyID;
 718
 719       CryptographicContext(const Dictionary*& d);
 720       CryptographicContext(const CryptographicContext& rhs);
 721       virtual ~CryptographicContext() {}
 722
 723       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 724       virtual void Copy(const CryptographicContext& rhs);
 725       virtual const char* HasName() { return "CryptographicContext"; }
 726       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 727       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 728       virtual void     Dump(FILE* = 0);
 729       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 730       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 731         };
 732
 733       //
 734       class DescriptiveFramework : public InterchangeObject
 735         {
 736           DescriptiveFramework();
 737
 738         public:
 739           const Dictionary*& m_Dict;
 740           optional_property<UUID > LinkedDescriptiveFrameworkPlugInId;
 741
 742       DescriptiveFramework(const Dictionary*& d);
 743       DescriptiveFramework(const DescriptiveFramework& rhs);
 744       virtual ~DescriptiveFramework() {}
 745
 746       const DescriptiveFramework& operator=(const DescriptiveFramework& rhs) { Copy(rhs); return *this; }
 747       virtual void Copy(const DescriptiveFramework& rhs);
 748       virtual const char* HasName() { return "DescriptiveFramework"; }
 749       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 750       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 751       virtual void     Dump(FILE* = 0);
 752       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 753       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 754         };
 755
 756       //
 757       class DescriptiveObject : public InterchangeObject
 758         {
 759           DescriptiveObject();
 760
 761         public:
 762           const Dictionary*& m_Dict;
 763           optional_property<UUID > LinkedDescriptiveObjectPlugInId;
 764
 765       DescriptiveObject(const Dictionary*& d);
 766       DescriptiveObject(const DescriptiveObject& rhs);
 767       virtual ~DescriptiveObject() {}
 768
 769       const DescriptiveObject& operator=(const DescriptiveObject& rhs) { Copy(rhs); return *this; }
 770       virtual void Copy(const DescriptiveObject& rhs);
 771       virtual const char* HasName() { return "DescriptiveObject"; }
 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 GenericDataEssenceDescriptor : public FileDescriptor
 781         {
 782           GenericDataEssenceDescriptor();
 783
 784         public:
 785           const Dictionary*& m_Dict;
 786           UL DataEssenceCoding;
 787
 788       GenericDataEssenceDescriptor(const Dictionary*& d);
 789       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 790       virtual ~GenericDataEssenceDescriptor() {}
 791
 792       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 793       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 794       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 795       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 796       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 797       virtual void     Dump(FILE* = 0);
 798       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 799       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 800         };
 801
 802       //
 803       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 804         {
 805           TimedTextDescriptor();
 806
 807         public:
 808           const Dictionary*& m_Dict;
 809           UUID ResourceID;
 810           UTF16String UCSEncoding;
 811           UTF16String NamespaceURI;
 812           optional_property<UTF16String > RFC5646LanguageTagList;
 813
 814       TimedTextDescriptor(const Dictionary*& d);
 815       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 816       virtual ~TimedTextDescriptor() {}
 817
 818       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 819       virtual void Copy(const TimedTextDescriptor& rhs);
 820       virtual const char* HasName() { return "TimedTextDescriptor"; }
 821       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 822       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 823       virtual void     Dump(FILE* = 0);
 824       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 825       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 826         };
 827
 828       //
 829       class TimedTextResourceSubDescriptor : public InterchangeObject
 830         {
 831           TimedTextResourceSubDescriptor();
 832
 833         public:
 834           const Dictionary*& m_Dict;
 835           UUID AncillaryResourceID;
 836           UTF16String MIMEMediaType;
 837           ui32_t EssenceStreamID;
 838
 839       TimedTextResourceSubDescriptor(const Dictionary*& d);
 840       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 841       virtual ~TimedTextResourceSubDescriptor() {}
 842
 843       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 844       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 845       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 846       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 847       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 848       virtual void     Dump(FILE* = 0);
 849       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 850       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 851         };
 852
 853       //
 854       class StereoscopicPictureSubDescriptor : public InterchangeObject
 855         {
 856           StereoscopicPictureSubDescriptor();
 857
 858         public:
 859           const Dictionary*& m_Dict;
 860
 861       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 862       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 863       virtual ~StereoscopicPictureSubDescriptor() {}
 864
 865       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 866       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 867       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 868       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 869       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 870       virtual void     Dump(FILE* = 0);
 871       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 872       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 873         };
 874
 875       // A ContainerConstraintsSubDescriptor is required to be present in the top level File Descriptor for the Constrained Generic Container per ST 379-2
 876       class ContainerConstraintsSubDescriptor : public InterchangeObject
 877         {
 878           ContainerConstraintsSubDescriptor();
 879
 880         public:
 881           const Dictionary*& m_Dict;
 882
 883       ContainerConstraintsSubDescriptor(const Dictionary*& d);
 884       ContainerConstraintsSubDescriptor(const ContainerConstraintsSubDescriptor& rhs);
 885       virtual ~ContainerConstraintsSubDescriptor() {}
 886
 887       const ContainerConstraintsSubDescriptor& operator=(const ContainerConstraintsSubDescriptor& rhs) { Copy(rhs); return *this; }
 888       virtual void Copy(const ContainerConstraintsSubDescriptor& rhs);
 889       virtual const char* HasName() { return "ContainerConstraintsSubDescriptor"; }
 890       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 891       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 892       virtual void     Dump(FILE* = 0);
 893       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 894       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 895         };
 896
 897       //
 898       class NetworkLocator : public InterchangeObject
 899         {
 900           NetworkLocator();
 901
 902         public:
 903           const Dictionary*& m_Dict;
 904           UTF16String URLString;
 905
 906       NetworkLocator(const Dictionary*& d);
 907       NetworkLocator(const NetworkLocator& rhs);
 908       virtual ~NetworkLocator() {}
 909
 910       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 911       virtual void Copy(const NetworkLocator& rhs);
 912       virtual const char* HasName() { return "NetworkLocator"; }
 913       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 914       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 915       virtual void     Dump(FILE* = 0);
 916       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 917       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 918         };
 919
 920       //
 921       class MCALabelSubDescriptor : public InterchangeObject
 922         {
 923           MCALabelSubDescriptor();
 924
 925         public:
 926           const Dictionary*& m_Dict;
 927           UL MCALabelDictionaryID;
 928           UUID MCALinkID;
 929           UTF16String MCATagSymbol;
 930           optional_property<UTF16String > MCATagName;
 931           optional_property<ui32_t > MCAChannelID;
 932           optional_property<ISO8String > RFC5646SpokenLanguage;
 933           optional_property<UTF16String > MCATitle;
 934           optional_property<UTF16String > MCATitleVersion;
 935           optional_property<UTF16String > MCATitleSubVersion;
 936           optional_property<UTF16String > MCAEpisode;
 937           optional_property<UTF16String > MCAPartitionKind;
 938           optional_property<UTF16String > MCAPartitionNumber;
 939           optional_property<UTF16String > MCAAudioContentKind;
 940           optional_property<UTF16String > MCAAudioElementKind;
 941
 942       MCALabelSubDescriptor(const Dictionary*& d);
 943       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 944       virtual ~MCALabelSubDescriptor() {}
 945
 946       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 947       virtual void Copy(const MCALabelSubDescriptor& rhs);
 948       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 949       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 950       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 951       virtual void     Dump(FILE* = 0);
 952       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 953       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 954         };
 955
 956       //
 957       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 958         {
 959           AudioChannelLabelSubDescriptor();
 960
 961         public:
 962           const Dictionary*& m_Dict;
 963           optional_property<UUID > SoundfieldGroupLinkID;
 964
 965       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 966       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 967       virtual ~AudioChannelLabelSubDescriptor() {}
 968
 969       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 970       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 971       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 972       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 973       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 974       virtual void     Dump(FILE* = 0);
 975       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 976       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 977         };
 978
 979       //
 980       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 981         {
 982           SoundfieldGroupLabelSubDescriptor();
 983
 984         public:
 985           const Dictionary*& m_Dict;
 986           optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 987
 988       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 989       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 990       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 991
 992       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 993       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 994       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 995       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 996       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 997       virtual void     Dump(FILE* = 0);
 998       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 999       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1000         };
1001
1002       //
1003       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
1004         {
1005           GroupOfSoundfieldGroupsLabelSubDescriptor();
1006
1007         public:
1008           const Dictionary*& m_Dict;
1009
1010       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
1011       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
1012       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
1013
1014       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
1015       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
1016       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
1017       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1018       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1019       virtual void     Dump(FILE* = 0);
1020       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1021       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1022         };
1023
1024       //
1025       class DCDataDescriptor : public GenericDataEssenceDescriptor
1026         {
1027           DCDataDescriptor();
1028
1029         public:
1030           const Dictionary*& m_Dict;
1031
1032       DCDataDescriptor(const Dictionary*& d);
1033       DCDataDescriptor(const DCDataDescriptor& rhs);
1034       virtual ~DCDataDescriptor() {}
1035
1036       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
1037       virtual void Copy(const DCDataDescriptor& rhs);
1038       virtual const char* HasName() { return "DCDataDescriptor"; }
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 PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
1048         {
1049           PrivateDCDataDescriptor();
1050
1051         public:
1052           const Dictionary*& m_Dict;
1053
1054       PrivateDCDataDescriptor(const Dictionary*& d);
1055       PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
1056       virtual ~PrivateDCDataDescriptor() {}
1057
1058       const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
1059       virtual void Copy(const PrivateDCDataDescriptor& rhs);
1060       virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
1061       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1062       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1063       virtual void     Dump(FILE* = 0);
1064       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1065       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1066         };
1067
1068       //
1069       class DolbyAtmosSubDescriptor : public InterchangeObject
1070         {
1071           DolbyAtmosSubDescriptor();
1072
1073         public:
1074           const Dictionary*& m_Dict;
1075           UUID AtmosID;
1076           ui32_t FirstFrame;
1077           ui16_t MaxChannelCount;
1078           ui16_t MaxObjectCount;
1079           ui8_t AtmosVersion;
1080
1081       DolbyAtmosSubDescriptor(const Dictionary*& d);
1082       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
1083       virtual ~DolbyAtmosSubDescriptor() {}
1084
1085       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
1086       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
1087       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
1088       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1089       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1090       virtual void     Dump(FILE* = 0);
1091       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1092       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1093         };
1094
1095       //
1096       class ACESPictureSubDescriptor : public InterchangeObject
1097         {
1098           ACESPictureSubDescriptor();
1099
1100         public:
1101           const Dictionary*& m_Dict;
1102           optional_property<UTF16String > ACESAuthoringInformation;
1103           optional_property<ThreeColorPrimaries > ACESMasteringDisplayPrimaries;
1104           optional_property<ColorPrimary > ACESMasteringDisplayWhitePointChromaticity;
1105           optional_property<ui32_t > ACESMasteringDisplayMaximumLuminance;
1106           optional_property<ui32_t > ACESMasteringDisplayMinimumLuminance;
1107
1108       ACESPictureSubDescriptor(const Dictionary*& d);
1109       ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs);
1110       virtual ~ACESPictureSubDescriptor() {}
1111
1112       const ACESPictureSubDescriptor& operator=(const ACESPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
1113       virtual void Copy(const ACESPictureSubDescriptor& rhs);
1114       virtual const char* HasName() { return "ACESPictureSubDescriptor"; }
1115       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1116       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1117       virtual void     Dump(FILE* = 0);
1118       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1119       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1120         };
1121
1122       //
1123       class TargetFrameSubDescriptor : public InterchangeObject
1124         {
1125           TargetFrameSubDescriptor();
1126
1127         public:
1128           const Dictionary*& m_Dict;
1129           UUID TargetFrameAncillaryResourceID;
1130           UTF16String MediaType;
1131           ui64_t TargetFrameIndex;
1132           UL TargetFrameTransferCharacteristic;
1133           UL TargetFrameColorPrimaries;
1134           ui32_t TargetFrameComponentMaxRef;
1135           ui32_t TargetFrameComponentMinRef;
1136           ui32_t TargetFrameEssenceStreamID;
1137           optional_property<UUID > ACESPictureSubDescriptorInstanceID;
1138           optional_property<UL > TargetFrameViewingEnvironment;
1139
1140       TargetFrameSubDescriptor(const Dictionary*& d);
1141       TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs);
1142       virtual ~TargetFrameSubDescriptor() {}
1143
1144       const TargetFrameSubDescriptor& operator=(const TargetFrameSubDescriptor& rhs) { Copy(rhs); return *this; }
1145       virtual void Copy(const TargetFrameSubDescriptor& rhs);
1146       virtual const char* HasName() { return "TargetFrameSubDescriptor"; }
1147       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1148       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1149       virtual void     Dump(FILE* = 0);
1150       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1151       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1152         };
1153
1154       //
1155       class TextBasedDMFramework : public DescriptiveFramework
1156         {
1157           TextBasedDMFramework();
1158
1159         public:
1160           const Dictionary*& m_Dict;
1161           optional_property<UUID > ObjectRef;
1162
1163       TextBasedDMFramework(const Dictionary*& d);
1164       TextBasedDMFramework(const TextBasedDMFramework& rhs);
1165       virtual ~TextBasedDMFramework() {}
1166
1167       const TextBasedDMFramework& operator=(const TextBasedDMFramework& rhs) { Copy(rhs); return *this; }
1168       virtual void Copy(const TextBasedDMFramework& rhs);
1169       virtual const char* HasName() { return "TextBasedDMFramework"; }
1170       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1171       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1172       virtual void     Dump(FILE* = 0);
1173       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1174       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1175         };
1176
1177       //
1178       class TextBasedObject : public DescriptiveObject
1179         {
1180           TextBasedObject();
1181
1182         public:
1183           const Dictionary*& m_Dict;
1184           UL PayloadSchemeID;
1185           UTF16String TextMIMEMediaType;
1186           UTF16String RFC5646TextLanguageCode;
1187           optional_property<UTF16String > TextDataDescription;
1188
1189       TextBasedObject(const Dictionary*& d);
1190       TextBasedObject(const TextBasedObject& rhs);
1191       virtual ~TextBasedObject() {}
1192
1193       const TextBasedObject& operator=(const TextBasedObject& rhs) { Copy(rhs); return *this; }
1194       virtual void Copy(const TextBasedObject& rhs);
1195       virtual const char* HasName() { return "TextBasedObject"; }
1196       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1197       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1198       virtual void     Dump(FILE* = 0);
1199       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1200       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1201         };
1202
1203       //
1204       class GenericStreamTextBasedSet : public TextBasedObject
1205         {
1206           GenericStreamTextBasedSet();
1207
1208         public:
1209           const Dictionary*& m_Dict;
1210           ui32_t GenericStreamSID;
1211
1212       GenericStreamTextBasedSet(const Dictionary*& d);
1213       GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs);
1214       virtual ~GenericStreamTextBasedSet() {}
1215
1216       const GenericStreamTextBasedSet& operator=(const GenericStreamTextBasedSet& rhs) { Copy(rhs); return *this; }
1217       virtual void Copy(const GenericStreamTextBasedSet& rhs);
1218       virtual const char* HasName() { return "GenericStreamTextBasedSet"; }
1219       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1220       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1221       virtual void     Dump(FILE* = 0);
1222       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1223       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1224         };
1225
1226       //
1227       class ISXDDataEssenceDescriptor : public GenericDataEssenceDescriptor
1228         {
1229           ISXDDataEssenceDescriptor();
1230
1231         public:
1232           const Dictionary*& m_Dict;
1233           ISO8String NamespaceURI;
1234
1235       ISXDDataEssenceDescriptor(const Dictionary*& d);
1236       ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs);
1237       virtual ~ISXDDataEssenceDescriptor() {}
1238
1239       const ISXDDataEssenceDescriptor& operator=(const ISXDDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
1240       virtual void Copy(const ISXDDataEssenceDescriptor& rhs);
1241       virtual const char* HasName() { return "ISXDDataEssenceDescriptor"; }
1242       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1243       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1244       virtual void     Dump(FILE* = 0);
1245       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1246       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1247         };
1248
1249       //
1250       class PHDRMetadataTrackSubDescriptor : public InterchangeObject
1251         {
1252           PHDRMetadataTrackSubDescriptor();
1253
1254         public:
1255           const Dictionary*& m_Dict;
1256           UL DataDefinition;
1257           ui32_t SourceTrackID;
1258           ui32_t SimplePayloadSID;
1259
1260       PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
1261       PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
1262       virtual ~PHDRMetadataTrackSubDescriptor() {}
1263
1264       const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
1265       virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
1266       virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
1267       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1268       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1269       virtual void     Dump(FILE* = 0);
1270       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1271       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1272         };
1273
1274       //
1275       class PIMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
1276         {
1277           PIMFDynamicMetadataDescriptor();
1278
1279         public:
1280           const Dictionary*& m_Dict;
1281           ui32_t GlobalPayloadSID;
1282
1283       PIMFDynamicMetadataDescriptor(const Dictionary*& d);
1284       PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
1285       virtual ~PIMFDynamicMetadataDescriptor() {}
1286
1287       const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
1288       virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
1289       virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
1290       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1291       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1292       virtual void     Dump(FILE* = 0);
1293       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1294       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1295         };
1296
1297     } // namespace MXF
1298 } // namespace ASDCP
1299
1300
1301 #endif // _Metadata_H_
1302
1303 //
1304 // end Metadata.h
1305 //