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