src/Metadata.h

   1 /*
   2 Copyright (c) 2005-2015, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27 /*! \file    Metadata.h
  28     \version $Id$
  29     \brief   MXF metadata objects
  30 */
  31
  32 #ifndef _Metadata_H_
  33 #define _Metadata_H_
  34
  35 #include "MXF.h"
  36
  37 namespace ASDCP
  38 {
  39   namespace MXF
  40     {
  41       void Metadata_InitTypes(const Dictionary*& Dict);
  42
  43       //
  44
  45       //
  46       class Identification : public InterchangeObject
  47         {
  48           Identification();
  49
  50         public:
  51           const Dictionary*& m_Dict;
  52           UUID ThisGenerationUID;
  53           UTF16String CompanyName;
  54           UTF16String ProductName;
  55           VersionType ProductVersion;
  56           UTF16String VersionString;
  57           UUID ProductUID;
  58           Kumu::Timestamp ModificationDate;
  59           VersionType ToolkitVersion;
  60           optional_property<UTF16String > Platform;
  61
  62       Identification(const Dictionary*& d);
  63       Identification(const Identification& rhs);
  64       virtual ~Identification() {}
  65
  66       const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
  67       virtual void Copy(const Identification& rhs);
  68       virtual const char* HasName() { return "Identification"; }
  69       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  70       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  71       virtual void     Dump(FILE* = 0);
  72       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  73       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  74         };
  75
  76       //
  77       class ContentStorage : public InterchangeObject
  78         {
  79           ContentStorage();
  80
  81         public:
  82           const Dictionary*& m_Dict;
  83           Batch<UUID> Packages;
  84           Batch<UUID> EssenceContainerData;
  85
  86       ContentStorage(const Dictionary*& d);
  87       ContentStorage(const ContentStorage& rhs);
  88       virtual ~ContentStorage() {}
  89
  90       const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
  91       virtual void Copy(const ContentStorage& rhs);
  92       virtual const char* HasName() { return "ContentStorage"; }
  93       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  94       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  95       virtual void     Dump(FILE* = 0);
  96       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  97       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  98         };
  99
 100       //
 101       class EssenceContainerData : public InterchangeObject
 102         {
 103           EssenceContainerData();
 104
 105         public:
 106           const Dictionary*& m_Dict;
 107           UMID LinkedPackageUID;
 108           optional_property<ui32_t > IndexSID;
 109           ui32_t BodySID;
 110
 111       EssenceContainerData(const Dictionary*& d);
 112       EssenceContainerData(const EssenceContainerData& rhs);
 113       virtual ~EssenceContainerData() {}
 114
 115       const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
 116       virtual void Copy(const EssenceContainerData& rhs);
 117       virtual const char* HasName() { return "EssenceContainerData"; }
 118       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 119       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 120       virtual void     Dump(FILE* = 0);
 121       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 122       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 123         };
 124
 125       //
 126       class GenericPackage : public InterchangeObject
 127         {
 128           GenericPackage();
 129
 130         public:
 131           const Dictionary*& m_Dict;
 132           UMID PackageUID;
 133           optional_property<UTF16String > Name;
 134           Kumu::Timestamp PackageCreationDate;
 135           Kumu::Timestamp PackageModifiedDate;
 136           Array<UUID> Tracks;
 137
 138       GenericPackage(const Dictionary*& d);
 139       GenericPackage(const GenericPackage& rhs);
 140       virtual ~GenericPackage() {}
 141
 142       const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
 143       virtual void Copy(const GenericPackage& rhs);
 144       virtual const char* HasName() { return "GenericPackage"; }
 145       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 146       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 147       virtual void     Dump(FILE* = 0);
 148         };
 149
 150       //
 151       class MaterialPackage : public GenericPackage
 152         {
 153           MaterialPackage();
 154
 155         public:
 156           const Dictionary*& m_Dict;
 157           optional_property<UUID > PackageMarker;
 158
 159       MaterialPackage(const Dictionary*& d);
 160       MaterialPackage(const MaterialPackage& rhs);
 161       virtual ~MaterialPackage() {}
 162
 163       const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
 164       virtual void Copy(const MaterialPackage& rhs);
 165       virtual const char* HasName() { return "MaterialPackage"; }
 166       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 167       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 168       virtual void     Dump(FILE* = 0);
 169       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 170       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 171         };
 172
 173       //
 174       class SourcePackage : public GenericPackage
 175         {
 176           SourcePackage();
 177
 178         public:
 179           const Dictionary*& m_Dict;
 180           UUID Descriptor;
 181
 182       SourcePackage(const Dictionary*& d);
 183       SourcePackage(const SourcePackage& rhs);
 184       virtual ~SourcePackage() {}
 185
 186       const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
 187       virtual void Copy(const SourcePackage& rhs);
 188       virtual const char* HasName() { return "SourcePackage"; }
 189       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 190       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 191       virtual void     Dump(FILE* = 0);
 192       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 193       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 194         };
 195
 196       //
 197       class GenericTrack : public InterchangeObject
 198         {
 199           GenericTrack();
 200
 201         public:
 202           const Dictionary*& m_Dict;
 203           ui32_t TrackID;
 204           ui32_t TrackNumber;
 205           optional_property<UTF16String > TrackName;
 206           optional_property<UUID > Sequence;
 207
 208       GenericTrack(const Dictionary*& d);
 209       GenericTrack(const GenericTrack& rhs);
 210       virtual ~GenericTrack() {}
 211
 212       const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
 213       virtual void Copy(const GenericTrack& rhs);
 214       virtual const char* HasName() { return "GenericTrack"; }
 215       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 216       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 217       virtual void     Dump(FILE* = 0);
 218         };
 219
 220       //
 221       class StaticTrack : public GenericTrack
 222         {
 223           StaticTrack();
 224
 225         public:
 226           const Dictionary*& m_Dict;
 227
 228       StaticTrack(const Dictionary*& d);
 229       StaticTrack(const StaticTrack& rhs);
 230       virtual ~StaticTrack() {}
 231
 232       const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
 233       virtual void Copy(const StaticTrack& rhs);
 234       virtual const char* HasName() { return "StaticTrack"; }
 235       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 236       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 237       virtual void     Dump(FILE* = 0);
 238       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 239       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 240         };
 241
 242       //
 243       class Track : public GenericTrack
 244         {
 245           Track();
 246
 247         public:
 248           const Dictionary*& m_Dict;
 249           Rational EditRate;
 250           ui64_t Origin;
 251
 252       Track(const Dictionary*& d);
 253       Track(const Track& rhs);
 254       virtual ~Track() {}
 255
 256       const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
 257       virtual void Copy(const Track& rhs);
 258       virtual const char* HasName() { return "Track"; }
 259       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 260       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 261       virtual void     Dump(FILE* = 0);
 262       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 263       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 264         };
 265
 266       //
 267       class StructuralComponent : public InterchangeObject
 268         {
 269           StructuralComponent();
 270
 271         public:
 272           const Dictionary*& m_Dict;
 273           UL DataDefinition;
 274           optional_property<ui64_t > Duration;
 275
 276       StructuralComponent(const Dictionary*& d);
 277       StructuralComponent(const StructuralComponent& rhs);
 278       virtual ~StructuralComponent() {}
 279
 280       const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
 281       virtual void Copy(const StructuralComponent& rhs);
 282       virtual const char* HasName() { return "StructuralComponent"; }
 283       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 284       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 285       virtual void     Dump(FILE* = 0);
 286         };
 287
 288       //
 289       class Sequence : public StructuralComponent
 290         {
 291           Sequence();
 292
 293         public:
 294           const Dictionary*& m_Dict;
 295           Array<UUID> StructuralComponents;
 296
 297       Sequence(const Dictionary*& d);
 298       Sequence(const Sequence& rhs);
 299       virtual ~Sequence() {}
 300
 301       const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
 302       virtual void Copy(const Sequence& rhs);
 303       virtual const char* HasName() { return "Sequence"; }
 304       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 305       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 306       virtual void     Dump(FILE* = 0);
 307       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 308       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 309         };
 310
 311       //
 312       class SourceClip : public StructuralComponent
 313         {
 314           SourceClip();
 315
 316         public:
 317           const Dictionary*& m_Dict;
 318           ui64_t StartPosition;
 319           UMID SourcePackageID;
 320           ui32_t SourceTrackID;
 321
 322       SourceClip(const Dictionary*& d);
 323       SourceClip(const SourceClip& rhs);
 324       virtual ~SourceClip() {}
 325
 326       const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
 327       virtual void Copy(const SourceClip& rhs);
 328       virtual const char* HasName() { return "SourceClip"; }
 329       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 330       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 331       virtual void     Dump(FILE* = 0);
 332       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 333       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 334         };
 335
 336       //
 337       class TimecodeComponent : public StructuralComponent
 338         {
 339           TimecodeComponent();
 340
 341         public:
 342           const Dictionary*& m_Dict;
 343           ui16_t RoundedTimecodeBase;
 344           ui64_t StartTimecode;
 345           ui8_t DropFrame;
 346
 347       TimecodeComponent(const Dictionary*& d);
 348       TimecodeComponent(const TimecodeComponent& rhs);
 349       virtual ~TimecodeComponent() {}
 350
 351       const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
 352       virtual void Copy(const TimecodeComponent& rhs);
 353       virtual const char* HasName() { return "TimecodeComponent"; }
 354       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 355       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 356       virtual void     Dump(FILE* = 0);
 357       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 358       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 359         };
 360
 361       //
 362       class GenericDescriptor : public InterchangeObject
 363         {
 364           GenericDescriptor();
 365
 366         public:
 367           const Dictionary*& m_Dict;
 368           Array<UUID> Locators;
 369           Array<UUID> SubDescriptors;
 370
 371       GenericDescriptor(const Dictionary*& d);
 372       GenericDescriptor(const GenericDescriptor& rhs);
 373       virtual ~GenericDescriptor() {}
 374
 375       const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
 376       virtual void Copy(const GenericDescriptor& rhs);
 377       virtual const char* HasName() { return "GenericDescriptor"; }
 378       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 379       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 380       virtual void     Dump(FILE* = 0);
 381         };
 382
 383       //
 384       class FileDescriptor : public GenericDescriptor
 385         {
 386           FileDescriptor();
 387
 388         public:
 389           const Dictionary*& m_Dict;
 390           optional_property<ui32_t > LinkedTrackID;
 391           Rational SampleRate;
 392           optional_property<ui64_t > ContainerDuration;
 393           UL EssenceContainer;
 394           optional_property<UL > Codec;
 395
 396       FileDescriptor(const Dictionary*& d);
 397       FileDescriptor(const FileDescriptor& rhs);
 398       virtual ~FileDescriptor() {}
 399
 400       const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
 401       virtual void Copy(const FileDescriptor& rhs);
 402       virtual const char* HasName() { return "FileDescriptor"; }
 403       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 404       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 405       virtual void     Dump(FILE* = 0);
 406       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 407       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 408         };
 409
 410       //
 411       class GenericSoundEssenceDescriptor : public FileDescriptor
 412         {
 413           GenericSoundEssenceDescriptor();
 414
 415         public:
 416           const Dictionary*& m_Dict;
 417           Rational AudioSamplingRate;
 418           ui8_t Locked;
 419           optional_property<ui8_t > AudioRefLevel;
 420           optional_property<ui8_t > ElectroSpatialFormulation;
 421           ui32_t ChannelCount;
 422           ui32_t QuantizationBits;
 423           optional_property<ui8_t > DialNorm;
 424           UL SoundEssenceCoding;
 425
 426       GenericSoundEssenceDescriptor(const Dictionary*& d);
 427       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
 428       virtual ~GenericSoundEssenceDescriptor() {}
 429
 430       const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 431       virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
 432       virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 433       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 434       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 435       virtual void     Dump(FILE* = 0);
 436       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 437       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 438         };
 439
 440       //
 441       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 442         {
 443           WaveAudioDescriptor();
 444
 445         public:
 446           const Dictionary*& m_Dict;
 447           ui16_t BlockAlign;
 448           optional_property<ui8_t > SequenceOffset;
 449           ui32_t AvgBps;
 450           optional_property<UL > ChannelAssignment;
 451           optional_property<Rational > ReferenceImageEditRate;
 452           optional_property<ui8_t > ReferenceAudioAlignmentLevel;
 453
 454       WaveAudioDescriptor(const Dictionary*& d);
 455       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
 456       virtual ~WaveAudioDescriptor() {}
 457
 458       const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
 459       virtual void Copy(const WaveAudioDescriptor& rhs);
 460       virtual const char* HasName() { return "WaveAudioDescriptor"; }
 461       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 462       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 463       virtual void     Dump(FILE* = 0);
 464       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 465       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 466         };
 467
 468       //
 469       class GenericPictureEssenceDescriptor : public FileDescriptor
 470         {
 471           GenericPictureEssenceDescriptor();
 472
 473         public:
 474           const Dictionary*& m_Dict;
 475           optional_property<ui8_t > SignalStandard;
 476           ui8_t FrameLayout;
 477           ui32_t StoredWidth;
 478           ui32_t StoredHeight;
 479           optional_property<ui32_t > StoredF2Offset;
 480           optional_property<ui32_t > SampledWidth;
 481           optional_property<ui32_t > SampledHeight;
 482           optional_property<ui32_t > SampledXOffset;
 483           optional_property<ui32_t > SampledYOffset;
 484           optional_property<ui32_t > DisplayHeight;
 485           optional_property<ui32_t > DisplayWidth;
 486           optional_property<ui32_t > DisplayXOffset;
 487           optional_property<ui32_t > DisplayYOffset;
 488           optional_property<ui32_t > DisplayF2Offset;
 489           Rational AspectRatio;
 490           optional_property<ui8_t > ActiveFormatDescriptor;
 491           optional_property<ui8_t > AlphaTransparency;
 492           optional_property<UL > TransferCharacteristic;
 493           optional_property<ui32_t > ImageAlignmentOffset;
 494           optional_property<ui32_t > ImageStartOffset;
 495           optional_property<ui32_t > ImageEndOffset;
 496           optional_property<ui8_t > FieldDominance;
 497           UL PictureEssenceCoding;
 498           optional_property<UL > CodingEquations;
 499           optional_property<UL > ColorPrimaries;
 500           optional_property<Batch<UL> > AlternativeCenterCuts;
 501           optional_property<ui32_t > ActiveWidth;
 502           optional_property<ui32_t > ActiveHeight;
 503           optional_property<ui32_t > ActiveXOffset;
 504           optional_property<ui32_t > ActiveYOffset;
 505           optional_property<LineMapPair > VideoLineMap;
 506
 507       GenericPictureEssenceDescriptor(const Dictionary*& d);
 508       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
 509       virtual ~GenericPictureEssenceDescriptor() {}
 510
 511       const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 512       virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
 513       virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 514       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 515       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 516       virtual void     Dump(FILE* = 0);
 517       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 518       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 519         };
 520
 521       //
 522       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 523         {
 524           RGBAEssenceDescriptor();
 525
 526         public:
 527           const Dictionary*& m_Dict;
 528           optional_property<ui32_t > ComponentMaxRef;
 529           optional_property<ui32_t > ComponentMinRef;
 530           optional_property<ui32_t > AlphaMinRef;
 531           optional_property<ui32_t > AlphaMaxRef;
 532           optional_property<ui8_t > ScanningDirection;
 533
 534       RGBAEssenceDescriptor(const Dictionary*& d);
 535       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
 536       virtual ~RGBAEssenceDescriptor() {}
 537
 538       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 539       virtual void Copy(const RGBAEssenceDescriptor& rhs);
 540       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 541       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 542       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 543       virtual void     Dump(FILE* = 0);
 544       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 545       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 546         };
 547
 548       //
 549       class JPEG2000PictureSubDescriptor : public InterchangeObject
 550         {
 551           JPEG2000PictureSubDescriptor();
 552
 553         public:
 554           const Dictionary*& m_Dict;
 555           ui16_t Rsize;
 556           ui32_t Xsize;
 557           ui32_t Ysize;
 558           ui32_t XOsize;
 559           ui32_t YOsize;
 560           ui32_t XTsize;
 561           ui32_t YTsize;
 562           ui32_t XTOsize;
 563           ui32_t YTOsize;
 564           ui16_t Csize;
 565           optional_property<Raw > PictureComponentSizing;
 566           optional_property<Raw > CodingStyleDefault;
 567           optional_property<Raw > QuantizationDefault;
 568           optional_property<RGBALayout > J2CLayout;
 569
 570       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 571       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 572       virtual ~JPEG2000PictureSubDescriptor() {}
 573
 574       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 575       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 576       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 577       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 578       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 579       virtual void     Dump(FILE* = 0);
 580       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 581       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 582         };
 583
 584       //
 585       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 586         {
 587           CDCIEssenceDescriptor();
 588
 589         public:
 590           const Dictionary*& m_Dict;
 591           ui32_t ComponentDepth;
 592           ui32_t HorizontalSubsampling;
 593           optional_property<ui32_t > VerticalSubsampling;
 594           optional_property<ui8_t > ColorSiting;
 595           optional_property<ui8_t > ReversedByteOrder;
 596           optional_property<ui16_t > PaddingBits;
 597           optional_property<ui32_t > AlphaSampleDepth;
 598           optional_property<ui32_t > BlackRefLevel;
 599           optional_property<ui32_t > WhiteReflevel;
 600           optional_property<ui32_t > ColorRange;
 601
 602       CDCIEssenceDescriptor(const Dictionary*& d);
 603       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 604       virtual ~CDCIEssenceDescriptor() {}
 605
 606       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 607       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 608       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 609       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 610       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 611       virtual void     Dump(FILE* = 0);
 612       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 613       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 614         };
 615
 616       //
 617       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 618         {
 619           MPEG2VideoDescriptor();
 620
 621         public:
 622           const Dictionary*& m_Dict;
 623           optional_property<ui8_t > SingleSequence;
 624           optional_property<ui8_t > ConstantBFrames;
 625           optional_property<ui8_t > CodedContentType;
 626           optional_property<ui8_t > LowDelay;
 627           optional_property<ui8_t > ClosedGOP;
 628           optional_property<ui8_t > IdenticalGOP;
 629           optional_property<ui8_t > MaxGOP;
 630           optional_property<ui8_t > BPictureCount;
 631           optional_property<ui32_t > BitRate;
 632           optional_property<ui8_t > ProfileAndLevel;
 633
 634       MPEG2VideoDescriptor(const Dictionary*& d);
 635       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 636       virtual ~MPEG2VideoDescriptor() {}
 637
 638       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 639       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 640       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 641       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 642       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 643       virtual void     Dump(FILE* = 0);
 644       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 645       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 646         };
 647
 648       //
 649       class DMSegment : public InterchangeObject
 650         {
 651           DMSegment();
 652
 653         public:
 654           const Dictionary*& m_Dict;
 655           UL DataDefinition;
 656           ui64_t EventStartPosition;
 657           ui64_t Duration;
 658           UTF16String EventComment;
 659           UUID DMFramework;
 660
 661       DMSegment(const Dictionary*& d);
 662       DMSegment(const DMSegment& rhs);
 663       virtual ~DMSegment() {}
 664
 665       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 666       virtual void Copy(const DMSegment& rhs);
 667       virtual const char* HasName() { return "DMSegment"; }
 668       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 669       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 670       virtual void     Dump(FILE* = 0);
 671       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 672       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 673         };
 674
 675       //
 676       class CryptographicFramework : public InterchangeObject
 677         {
 678           CryptographicFramework();
 679
 680         public:
 681           const Dictionary*& m_Dict;
 682           UUID ContextSR;
 683
 684       CryptographicFramework(const Dictionary*& d);
 685       CryptographicFramework(const CryptographicFramework& rhs);
 686       virtual ~CryptographicFramework() {}
 687
 688       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 689       virtual void Copy(const CryptographicFramework& rhs);
 690       virtual const char* HasName() { return "CryptographicFramework"; }
 691       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 692       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 693       virtual void     Dump(FILE* = 0);
 694       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 695       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 696         };
 697
 698       //
 699       class CryptographicContext : public InterchangeObject
 700         {
 701           CryptographicContext();
 702
 703         public:
 704           const Dictionary*& m_Dict;
 705           UUID ContextID;
 706           UL SourceEssenceContainer;
 707           UL CipherAlgorithm;
 708           UL MICAlgorithm;
 709           UUID CryptographicKeyID;
 710
 711       CryptographicContext(const Dictionary*& d);
 712       CryptographicContext(const CryptographicContext& rhs);
 713       virtual ~CryptographicContext() {}
 714
 715       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 716       virtual void Copy(const CryptographicContext& rhs);
 717       virtual const char* HasName() { return "CryptographicContext"; }
 718       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 719       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 720       virtual void     Dump(FILE* = 0);
 721       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 722       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 723         };
 724
 725       //
 726       class GenericDataEssenceDescriptor : public FileDescriptor
 727         {
 728           GenericDataEssenceDescriptor();
 729
 730         public:
 731           const Dictionary*& m_Dict;
 732           UL DataEssenceCoding;
 733
 734       GenericDataEssenceDescriptor(const Dictionary*& d);
 735       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 736       virtual ~GenericDataEssenceDescriptor() {}
 737
 738       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 739       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 740       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 741       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 742       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 743       virtual void     Dump(FILE* = 0);
 744       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 745       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 746         };
 747
 748       //
 749       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 750         {
 751           TimedTextDescriptor();
 752
 753         public:
 754           const Dictionary*& m_Dict;
 755           UUID ResourceID;
 756           UTF16String UCSEncoding;
 757           UTF16String NamespaceURI;
 758           optional_property<UTF16String > RFC5646LanguageTagList;
 759
 760       TimedTextDescriptor(const Dictionary*& d);
 761       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 762       virtual ~TimedTextDescriptor() {}
 763
 764       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 765       virtual void Copy(const TimedTextDescriptor& rhs);
 766       virtual const char* HasName() { return "TimedTextDescriptor"; }
 767       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 768       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 769       virtual void     Dump(FILE* = 0);
 770       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 771       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 772         };
 773
 774       //
 775       class TimedTextResourceSubDescriptor : public InterchangeObject
 776         {
 777           TimedTextResourceSubDescriptor();
 778
 779         public:
 780           const Dictionary*& m_Dict;
 781           UUID AncillaryResourceID;
 782           UTF16String MIMEMediaType;
 783           ui32_t EssenceStreamID;
 784
 785       TimedTextResourceSubDescriptor(const Dictionary*& d);
 786       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 787       virtual ~TimedTextResourceSubDescriptor() {}
 788
 789       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 790       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 791       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 792       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 793       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 794       virtual void     Dump(FILE* = 0);
 795       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 796       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 797         };
 798
 799       //
 800       class StereoscopicPictureSubDescriptor : public InterchangeObject
 801         {
 802           StereoscopicPictureSubDescriptor();
 803
 804         public:
 805           const Dictionary*& m_Dict;
 806
 807       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 808       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 809       virtual ~StereoscopicPictureSubDescriptor() {}
 810
 811       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 812       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 813       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 814       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 815       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 816       virtual void     Dump(FILE* = 0);
 817       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 818       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 819         };
 820
 821       //
 822       class ContainerConstraintSubDescriptor : public InterchangeObject
 823         {
 824           ContainerConstraintSubDescriptor();
 825
 826         public:
 827           const Dictionary*& m_Dict;
 828
 829       ContainerConstraintSubDescriptor(const Dictionary*& d);
 830       ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs);
 831       virtual ~ContainerConstraintSubDescriptor() {}
 832
 833       const ContainerConstraintSubDescriptor& operator=(const ContainerConstraintSubDescriptor& rhs) { Copy(rhs); return *this; }
 834       virtual void Copy(const ContainerConstraintSubDescriptor& rhs);
 835       virtual const char* HasName() { return "ContainerConstraintSubDescriptor"; }
 836       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 837       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 838       virtual void     Dump(FILE* = 0);
 839       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 840       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 841         };
 842
 843       //
 844       class NetworkLocator : public InterchangeObject
 845         {
 846           NetworkLocator();
 847
 848         public:
 849           const Dictionary*& m_Dict;
 850           UTF16String URLString;
 851
 852       NetworkLocator(const Dictionary*& d);
 853       NetworkLocator(const NetworkLocator& rhs);
 854       virtual ~NetworkLocator() {}
 855
 856       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 857       virtual void Copy(const NetworkLocator& rhs);
 858       virtual const char* HasName() { return "NetworkLocator"; }
 859       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 860       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 861       virtual void     Dump(FILE* = 0);
 862       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 863       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 864         };
 865
 866       //
 867       class MCALabelSubDescriptor : public InterchangeObject
 868         {
 869           MCALabelSubDescriptor();
 870
 871         public:
 872           const Dictionary*& m_Dict;
 873           UL MCALabelDictionaryID;
 874           UUID MCALinkID;
 875           UTF16String MCATagSymbol;
 876           optional_property<UTF16String > MCATagName;
 877           optional_property<ui32_t > MCAChannelID;
 878           optional_property<ISO8String > RFC5646SpokenLanguage;
 879           optional_property<UTF16String > MCATitle;
 880           optional_property<UTF16String > MCATitleVersion;
 881           optional_property<UTF16String > MCATitleSubVersion;
 882           optional_property<UTF16String > MCAEpisode;
 883           optional_property<UTF16String > MCAPartitionKind;
 884           optional_property<UTF16String > MCAPartitionNumber;
 885           optional_property<UTF16String > MCAAudioContentKind;
 886           optional_property<UTF16String > MCAAudioElementKind;
 887
 888       MCALabelSubDescriptor(const Dictionary*& d);
 889       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 890       virtual ~MCALabelSubDescriptor() {}
 891
 892       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 893       virtual void Copy(const MCALabelSubDescriptor& rhs);
 894       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 895       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 896       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 897       virtual void     Dump(FILE* = 0);
 898       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 899       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 900         };
 901
 902       //
 903       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 904         {
 905           AudioChannelLabelSubDescriptor();
 906
 907         public:
 908           const Dictionary*& m_Dict;
 909           optional_property<UUID > SoundfieldGroupLinkID;
 910
 911       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 912       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 913       virtual ~AudioChannelLabelSubDescriptor() {}
 914
 915       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 916       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 917       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 918       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 919       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 920       virtual void     Dump(FILE* = 0);
 921       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 922       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 923         };
 924
 925       //
 926       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 927         {
 928           SoundfieldGroupLabelSubDescriptor();
 929
 930         public:
 931           const Dictionary*& m_Dict;
 932           optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 933
 934       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 935       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 936       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 937
 938       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 939       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 940       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 941       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 942       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 943       virtual void     Dump(FILE* = 0);
 944       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 945       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 946         };
 947
 948       //
 949       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 950         {
 951           GroupOfSoundfieldGroupsLabelSubDescriptor();
 952
 953         public:
 954           const Dictionary*& m_Dict;
 955
 956       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 957       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 958       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 959
 960       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 961       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 962       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 963       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 964       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 965       virtual void     Dump(FILE* = 0);
 966       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 967       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 968         };
 969
 970       //
 971       class DCDataDescriptor : public GenericDataEssenceDescriptor
 972         {
 973           DCDataDescriptor();
 974
 975         public:
 976           const Dictionary*& m_Dict;
 977
 978       DCDataDescriptor(const Dictionary*& d);
 979       DCDataDescriptor(const DCDataDescriptor& rhs);
 980       virtual ~DCDataDescriptor() {}
 981
 982       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
 983       virtual void Copy(const DCDataDescriptor& rhs);
 984       virtual const char* HasName() { return "DCDataDescriptor"; }
 985       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 986       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 987       virtual void     Dump(FILE* = 0);
 988       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 989       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 990         };
 991
 992       //
 993       class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
 994         {
 995           PrivateDCDataDescriptor();
 996
 997         public:
 998           const Dictionary*& m_Dict;
 999
1000       PrivateDCDataDescriptor(const Dictionary*& d);
1001       PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
1002       virtual ~PrivateDCDataDescriptor() {}
1003
1004       const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
1005       virtual void Copy(const PrivateDCDataDescriptor& rhs);
1006       virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
1007       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1008       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1009       virtual void     Dump(FILE* = 0);
1010       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1011       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1012         };
1013
1014       //
1015       class DolbyAtmosSubDescriptor : public InterchangeObject
1016         {
1017           DolbyAtmosSubDescriptor();
1018
1019         public:
1020           const Dictionary*& m_Dict;
1021           UUID AtmosID;
1022           ui32_t FirstFrame;
1023           ui16_t MaxChannelCount;
1024           ui16_t MaxObjectCount;
1025           ui8_t AtmosVersion;
1026
1027       DolbyAtmosSubDescriptor(const Dictionary*& d);
1028       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
1029       virtual ~DolbyAtmosSubDescriptor() {}
1030
1031       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
1032       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
1033       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
1034       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1035       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1036       virtual void     Dump(FILE* = 0);
1037       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1038       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1039         };
1040
1041       //
1042       class PHDRMetadataTrackSubDescriptor : public InterchangeObject
1043         {
1044           PHDRMetadataTrackSubDescriptor();
1045
1046         public:
1047           const Dictionary*& m_Dict;
1048           UL DataDefinition;
1049           ui32_t SourceTrackID;
1050           ui32_t SimplePayloadSID;
1051
1052       PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
1053       PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
1054       virtual ~PHDRMetadataTrackSubDescriptor() {}
1055
1056       const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
1057       virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
1058       virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
1059       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1060       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1061       virtual void     Dump(FILE* = 0);
1062       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1063       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1064         };
1065
1066       //
1067       class IMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
1068         {
1069           IMFDynamicMetadataDescriptor();
1070
1071         public:
1072           const Dictionary*& m_Dict;
1073           ui32_t GlobalPayloadSID;
1074
1075       IMFDynamicMetadataDescriptor(const Dictionary*& d);
1076       IMFDynamicMetadataDescriptor(const IMFDynamicMetadataDescriptor& rhs);
1077       virtual ~IMFDynamicMetadataDescriptor() {}
1078
1079       const IMFDynamicMetadataDescriptor& operator=(const IMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
1080       virtual void Copy(const IMFDynamicMetadataDescriptor& rhs);
1081       virtual const char* HasName() { return "IMFDynamicMetadataDescriptor"; }
1082       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1083       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1084       virtual void     Dump(FILE* = 0);
1085       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1086       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1087         };
1088
1089     } // namespace MXF
1090 } // namespace ASDCP
1091
1092
1093 #endif // _Metadata_H_
1094
1095 //
1096 // end Metadata.h
1097 //