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           RGBALayout PixelLayout;
 534
 535       RGBAEssenceDescriptor(const Dictionary*& d);
 536       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
 537       virtual ~RGBAEssenceDescriptor() {}
 538
 539       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 540       virtual void Copy(const RGBAEssenceDescriptor& rhs);
 541       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 542       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 543       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 544       virtual void     Dump(FILE* = 0);
 545       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 546       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 547         };
 548
 549       //
 550       class JPEG2000PictureSubDescriptor : public InterchangeObject
 551         {
 552           JPEG2000PictureSubDescriptor();
 553
 554         public:
 555           const Dictionary*& m_Dict;
 556           ui16_t Rsize;
 557           ui32_t Xsize;
 558           ui32_t Ysize;
 559           ui32_t XOsize;
 560           ui32_t YOsize;
 561           ui32_t XTsize;
 562           ui32_t YTsize;
 563           ui32_t XTOsize;
 564           ui32_t YTOsize;
 565           ui16_t Csize;
 566           optional_property<Raw > PictureComponentSizing;
 567           optional_property<Raw > CodingStyleDefault;
 568           optional_property<Raw > QuantizationDefault;
 569           optional_property<RGBALayout > J2CLayout;
 570
 571       JPEG2000PictureSubDescriptor(const Dictionary*& d);
 572       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
 573       virtual ~JPEG2000PictureSubDescriptor() {}
 574
 575       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 576       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
 577       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 578       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 579       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 580       virtual void     Dump(FILE* = 0);
 581       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 582       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 583         };
 584
 585       //
 586       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 587         {
 588           CDCIEssenceDescriptor();
 589
 590         public:
 591           const Dictionary*& m_Dict;
 592           ui32_t ComponentDepth;
 593           ui32_t HorizontalSubsampling;
 594           optional_property<ui32_t > VerticalSubsampling;
 595           optional_property<ui8_t > ColorSiting;
 596           optional_property<ui8_t > ReversedByteOrder;
 597           optional_property<ui16_t > PaddingBits;
 598           optional_property<ui32_t > AlphaSampleDepth;
 599           optional_property<ui32_t > BlackRefLevel;
 600           optional_property<ui32_t > WhiteReflevel;
 601           optional_property<ui32_t > ColorRange;
 602
 603       CDCIEssenceDescriptor(const Dictionary*& d);
 604       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
 605       virtual ~CDCIEssenceDescriptor() {}
 606
 607       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 608       virtual void Copy(const CDCIEssenceDescriptor& rhs);
 609       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 610       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 611       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 612       virtual void     Dump(FILE* = 0);
 613       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 614       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 615         };
 616
 617       //
 618       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 619         {
 620           MPEG2VideoDescriptor();
 621
 622         public:
 623           const Dictionary*& m_Dict;
 624           optional_property<ui8_t > SingleSequence;
 625           optional_property<ui8_t > ConstantBFrames;
 626           optional_property<ui8_t > CodedContentType;
 627           optional_property<ui8_t > LowDelay;
 628           optional_property<ui8_t > ClosedGOP;
 629           optional_property<ui8_t > IdenticalGOP;
 630           optional_property<ui8_t > MaxGOP;
 631           optional_property<ui8_t > BPictureCount;
 632           optional_property<ui32_t > BitRate;
 633           optional_property<ui8_t > ProfileAndLevel;
 634
 635       MPEG2VideoDescriptor(const Dictionary*& d);
 636       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
 637       virtual ~MPEG2VideoDescriptor() {}
 638
 639       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
 640       virtual void Copy(const MPEG2VideoDescriptor& rhs);
 641       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 642       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 643       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 644       virtual void     Dump(FILE* = 0);
 645       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 646       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 647         };
 648
 649       //
 650       class DMSegment : public InterchangeObject
 651         {
 652           DMSegment();
 653
 654         public:
 655           const Dictionary*& m_Dict;
 656           UL DataDefinition;
 657           ui64_t EventStartPosition;
 658           ui64_t Duration;
 659           UTF16String EventComment;
 660           UUID DMFramework;
 661
 662       DMSegment(const Dictionary*& d);
 663       DMSegment(const DMSegment& rhs);
 664       virtual ~DMSegment() {}
 665
 666       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
 667       virtual void Copy(const DMSegment& rhs);
 668       virtual const char* HasName() { return "DMSegment"; }
 669       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 670       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 671       virtual void     Dump(FILE* = 0);
 672       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 673       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 674         };
 675
 676       //
 677       class CryptographicFramework : public InterchangeObject
 678         {
 679           CryptographicFramework();
 680
 681         public:
 682           const Dictionary*& m_Dict;
 683           UUID ContextSR;
 684
 685       CryptographicFramework(const Dictionary*& d);
 686       CryptographicFramework(const CryptographicFramework& rhs);
 687       virtual ~CryptographicFramework() {}
 688
 689       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
 690       virtual void Copy(const CryptographicFramework& rhs);
 691       virtual const char* HasName() { return "CryptographicFramework"; }
 692       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 693       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 694       virtual void     Dump(FILE* = 0);
 695       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 696       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 697         };
 698
 699       //
 700       class CryptographicContext : public InterchangeObject
 701         {
 702           CryptographicContext();
 703
 704         public:
 705           const Dictionary*& m_Dict;
 706           UUID ContextID;
 707           UL SourceEssenceContainer;
 708           UL CipherAlgorithm;
 709           UL MICAlgorithm;
 710           UUID CryptographicKeyID;
 711
 712       CryptographicContext(const Dictionary*& d);
 713       CryptographicContext(const CryptographicContext& rhs);
 714       virtual ~CryptographicContext() {}
 715
 716       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
 717       virtual void Copy(const CryptographicContext& rhs);
 718       virtual const char* HasName() { return "CryptographicContext"; }
 719       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 720       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 721       virtual void     Dump(FILE* = 0);
 722       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 723       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 724         };
 725
 726       //
 727       class GenericDataEssenceDescriptor : public FileDescriptor
 728         {
 729           GenericDataEssenceDescriptor();
 730
 731         public:
 732           const Dictionary*& m_Dict;
 733           UL DataEssenceCoding;
 734
 735       GenericDataEssenceDescriptor(const Dictionary*& d);
 736       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
 737       virtual ~GenericDataEssenceDescriptor() {}
 738
 739       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
 740       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
 741       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
 742       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 743       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 744       virtual void     Dump(FILE* = 0);
 745       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 746       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 747         };
 748
 749       //
 750       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 751         {
 752           TimedTextDescriptor();
 753
 754         public:
 755           const Dictionary*& m_Dict;
 756           UUID ResourceID;
 757           UTF16String UCSEncoding;
 758           UTF16String NamespaceURI;
 759           optional_property<UTF16String > RFC5646LanguageTagList;
 760
 761       TimedTextDescriptor(const Dictionary*& d);
 762       TimedTextDescriptor(const TimedTextDescriptor& rhs);
 763       virtual ~TimedTextDescriptor() {}
 764
 765       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
 766       virtual void Copy(const TimedTextDescriptor& rhs);
 767       virtual const char* HasName() { return "TimedTextDescriptor"; }
 768       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 769       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 770       virtual void     Dump(FILE* = 0);
 771       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 772       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 773         };
 774
 775       //
 776       class TimedTextResourceSubDescriptor : public InterchangeObject
 777         {
 778           TimedTextResourceSubDescriptor();
 779
 780         public:
 781           const Dictionary*& m_Dict;
 782           UUID AncillaryResourceID;
 783           UTF16String MIMEMediaType;
 784           ui32_t EssenceStreamID;
 785
 786       TimedTextResourceSubDescriptor(const Dictionary*& d);
 787       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
 788       virtual ~TimedTextResourceSubDescriptor() {}
 789
 790       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
 791       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
 792       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
 793       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 794       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 795       virtual void     Dump(FILE* = 0);
 796       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 797       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 798         };
 799
 800       //
 801       class StereoscopicPictureSubDescriptor : public InterchangeObject
 802         {
 803           StereoscopicPictureSubDescriptor();
 804
 805         public:
 806           const Dictionary*& m_Dict;
 807
 808       StereoscopicPictureSubDescriptor(const Dictionary*& d);
 809       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
 810       virtual ~StereoscopicPictureSubDescriptor() {}
 811
 812       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
 813       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
 814       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
 815       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 816       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 817       virtual void     Dump(FILE* = 0);
 818       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 819       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 820         };
 821
 822       //
 823       class ContainerConstraintSubDescriptor : public InterchangeObject
 824         {
 825           ContainerConstraintSubDescriptor();
 826
 827         public:
 828           const Dictionary*& m_Dict;
 829
 830       ContainerConstraintSubDescriptor(const Dictionary*& d);
 831       ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs);
 832       virtual ~ContainerConstraintSubDescriptor() {}
 833
 834       const ContainerConstraintSubDescriptor& operator=(const ContainerConstraintSubDescriptor& rhs) { Copy(rhs); return *this; }
 835       virtual void Copy(const ContainerConstraintSubDescriptor& rhs);
 836       virtual const char* HasName() { return "ContainerConstraintSubDescriptor"; }
 837       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 838       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 839       virtual void     Dump(FILE* = 0);
 840       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 841       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 842         };
 843
 844       //
 845       class NetworkLocator : public InterchangeObject
 846         {
 847           NetworkLocator();
 848
 849         public:
 850           const Dictionary*& m_Dict;
 851           UTF16String URLString;
 852
 853       NetworkLocator(const Dictionary*& d);
 854       NetworkLocator(const NetworkLocator& rhs);
 855       virtual ~NetworkLocator() {}
 856
 857       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
 858       virtual void Copy(const NetworkLocator& rhs);
 859       virtual const char* HasName() { return "NetworkLocator"; }
 860       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 861       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 862       virtual void     Dump(FILE* = 0);
 863       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 864       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 865         };
 866
 867       //
 868       class MCALabelSubDescriptor : public InterchangeObject
 869         {
 870           MCALabelSubDescriptor();
 871
 872         public:
 873           const Dictionary*& m_Dict;
 874           UL MCALabelDictionaryID;
 875           UUID MCALinkID;
 876           UTF16String MCATagSymbol;
 877           optional_property<UTF16String > MCATagName;
 878           optional_property<ui32_t > MCAChannelID;
 879           optional_property<ISO8String > RFC5646SpokenLanguage;
 880           optional_property<UTF16String > MCATitle;
 881           optional_property<UTF16String > MCATitleVersion;
 882           optional_property<UTF16String > MCATitleSubVersion;
 883           optional_property<UTF16String > MCAEpisode;
 884           optional_property<UTF16String > MCAPartitionKind;
 885           optional_property<UTF16String > MCAPartitionNumber;
 886           optional_property<UTF16String > MCAAudioContentKind;
 887           optional_property<UTF16String > MCAAudioElementKind;
 888
 889       MCALabelSubDescriptor(const Dictionary*& d);
 890       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
 891       virtual ~MCALabelSubDescriptor() {}
 892
 893       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 894       virtual void Copy(const MCALabelSubDescriptor& rhs);
 895       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
 896       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 897       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 898       virtual void     Dump(FILE* = 0);
 899       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 900       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 901         };
 902
 903       //
 904       class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
 905         {
 906           AudioChannelLabelSubDescriptor();
 907
 908         public:
 909           const Dictionary*& m_Dict;
 910           optional_property<UUID > SoundfieldGroupLinkID;
 911
 912       AudioChannelLabelSubDescriptor(const Dictionary*& d);
 913       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
 914       virtual ~AudioChannelLabelSubDescriptor() {}
 915
 916       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 917       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
 918       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
 919       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 920       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 921       virtual void     Dump(FILE* = 0);
 922       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 923       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 924         };
 925
 926       //
 927       class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
 928         {
 929           SoundfieldGroupLabelSubDescriptor();
 930
 931         public:
 932           const Dictionary*& m_Dict;
 933           optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 934
 935       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
 936       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
 937       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 938
 939       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 940       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
 941       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
 942       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 943       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 944       virtual void     Dump(FILE* = 0);
 945       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 946       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 947         };
 948
 949       //
 950       class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
 951         {
 952           GroupOfSoundfieldGroupsLabelSubDescriptor();
 953
 954         public:
 955           const Dictionary*& m_Dict;
 956
 957       GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
 958       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 959       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 960
 961       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
 962       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
 963       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
 964       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 965       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 966       virtual void     Dump(FILE* = 0);
 967       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 968       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 969         };
 970
 971       //
 972       class DCDataDescriptor : public GenericDataEssenceDescriptor
 973         {
 974           DCDataDescriptor();
 975
 976         public:
 977           const Dictionary*& m_Dict;
 978
 979       DCDataDescriptor(const Dictionary*& d);
 980       DCDataDescriptor(const DCDataDescriptor& rhs);
 981       virtual ~DCDataDescriptor() {}
 982
 983       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
 984       virtual void Copy(const DCDataDescriptor& rhs);
 985       virtual const char* HasName() { return "DCDataDescriptor"; }
 986       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 987       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 988       virtual void     Dump(FILE* = 0);
 989       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 990       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 991         };
 992
 993       //
 994       class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
 995         {
 996           PrivateDCDataDescriptor();
 997
 998         public:
 999           const Dictionary*& m_Dict;
1000
1001       PrivateDCDataDescriptor(const Dictionary*& d);
1002       PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
1003       virtual ~PrivateDCDataDescriptor() {}
1004
1005       const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
1006       virtual void Copy(const PrivateDCDataDescriptor& rhs);
1007       virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
1008       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1009       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1010       virtual void     Dump(FILE* = 0);
1011       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1012       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1013         };
1014
1015       //
1016       class DolbyAtmosSubDescriptor : public InterchangeObject
1017         {
1018           DolbyAtmosSubDescriptor();
1019
1020         public:
1021           const Dictionary*& m_Dict;
1022           UUID AtmosID;
1023           ui32_t FirstFrame;
1024           ui16_t MaxChannelCount;
1025           ui16_t MaxObjectCount;
1026           ui8_t AtmosVersion;
1027
1028       DolbyAtmosSubDescriptor(const Dictionary*& d);
1029       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
1030       virtual ~DolbyAtmosSubDescriptor() {}
1031
1032       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
1033       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
1034       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
1035       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1036       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1037       virtual void     Dump(FILE* = 0);
1038       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1039       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1040         };
1041
1042       //
1043       class PHDRMetadataTrackSubDescriptor : public InterchangeObject
1044         {
1045           PHDRMetadataTrackSubDescriptor();
1046
1047         public:
1048           const Dictionary*& m_Dict;
1049           UL DataDefinition;
1050           ui32_t SourceTrackID;
1051           ui32_t SimplePayloadSID;
1052
1053       PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
1054       PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
1055       virtual ~PHDRMetadataTrackSubDescriptor() {}
1056
1057       const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
1058       virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
1059       virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
1060       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1061       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1062       virtual void     Dump(FILE* = 0);
1063       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1064       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1065         };
1066
1067       //
1068       class PIMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
1069         {
1070           PIMFDynamicMetadataDescriptor();
1071
1072         public:
1073           const Dictionary*& m_Dict;
1074           ui32_t GlobalPayloadSID;
1075
1076       PIMFDynamicMetadataDescriptor(const Dictionary*& d);
1077       PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
1078       virtual ~PIMFDynamicMetadataDescriptor() {}
1079
1080       const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
1081       virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
1082       virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
1083       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
1084       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
1085       virtual void     Dump(FILE* = 0);
1086       virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
1087       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
1088         };
1089
1090     } // namespace MXF
1091 } // namespace ASDCP
1092
1093
1094 #endif // _Metadata_H_
1095
1096 //
1097 // end Metadata.h
1098 //