src/Metadata.h

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