X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FMetadata.h;h=72ca7a55ff1e37291684318ee122a07a4259924c;hb=20c2f749a4593c418259bcf8b5f6f0775b70d910;hp=5121989ccdfb99e03a4173bf634699cad81a148e;hpb=2f6f8dbb08b63351bfa25d3a008a41dec78f7dde;p=asdcplib.git

diff --git a/src/Metadata.h b/src/Metadata.h
index 5121989..72ca7a5 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2012, John Hurst
+Copyright (c) 2005-2017, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -57,7 +57,7 @@ namespace ASDCP
           UUID ProductUID;
           Kumu::Timestamp ModificationDate;
           VersionType ToolkitVersion;
-          optional_property<UTF16String> Platform;
+          optional_property<UTF16String > Platform;
 
       Identification(const Dictionary*& d);
       Identification(const Identification& rhs);
@@ -105,7 +105,7 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
           UMID LinkedPackageUID;
-          optional_property<ui32_t> IndexSID;
+          optional_property<ui32_t > IndexSID;
           ui32_t BodySID;
 
       EssenceContainerData(const Dictionary*& d);
@@ -130,10 +130,10 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
           UMID PackageUID;
-          optional_property<UTF16String> Name;
+          optional_property<UTF16String > Name;
           Kumu::Timestamp PackageCreationDate;
           Kumu::Timestamp PackageModifiedDate;
-          Batch<UUID> Tracks;
+          Array<UUID> Tracks;
 
       GenericPackage(const Dictionary*& d);
       GenericPackage(const GenericPackage& rhs);
@@ -154,7 +154,7 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          optional_property<UUID> PackageMarker;
+          optional_property<UUID > PackageMarker;
 
       MaterialPackage(const Dictionary*& d);
       MaterialPackage(const MaterialPackage& rhs);
@@ -202,8 +202,8 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           ui32_t TrackID;
           ui32_t TrackNumber;
-          optional_property<UTF16String> TrackName;
-          optional_property<UUID> Sequence;
+          optional_property<UTF16String > TrackName;
+          optional_property<UUID > Sequence;
 
       GenericTrack(const Dictionary*& d);
       GenericTrack(const GenericTrack& rhs);
@@ -271,7 +271,7 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
           UL DataDefinition;
-          optional_property<ui64_t> Duration;
+          optional_property<ui64_t > Duration;
 
       StructuralComponent(const Dictionary*& d);
       StructuralComponent(const StructuralComponent& rhs);
@@ -292,7 +292,7 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          Batch<UUID> StructuralComponents;
+          Array<UUID> StructuralComponents;
 
       Sequence(const Dictionary*& d);
       Sequence(const Sequence& rhs);
@@ -365,8 +365,8 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          Batch<UUID> Locators;
-          Batch<UUID> SubDescriptors;
+          Array<UUID> Locators;
+          Array<UUID> SubDescriptors;
 
       GenericDescriptor(const Dictionary*& d);
       GenericDescriptor(const GenericDescriptor& rhs);
@@ -387,11 +387,11 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          optional_property<ui32_t> LinkedTrackID;
+          optional_property<ui32_t > LinkedTrackID;
           Rational SampleRate;
-          optional_property<ui64_t> ContainerDuration;
+          optional_property<ui64_t > ContainerDuration;
           UL EssenceContainer;
-          optional_property<UL> Codec;
+          optional_property<UL > Codec;
 
       FileDescriptor(const Dictionary*& d);
       FileDescriptor(const FileDescriptor& rhs);
@@ -416,12 +416,14 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           Rational AudioSamplingRate;
           ui8_t Locked;
-          optional_property<ui8_t> AudioRefLevel;
-          optional_property<ui8_t> ElectroSpatialFormulation;
+          optional_property<ui8_t > AudioRefLevel;
+          optional_property<ui8_t > ElectroSpatialFormulation;
           ui32_t ChannelCount;
           ui32_t QuantizationBits;
-          optional_property<ui8_t> DialNorm;
+          optional_property<ui8_t > DialNorm;
           UL SoundEssenceCoding;
+          optional_property<ui8_t > ReferenceAudioAlignmentLevel;
+          optional_property<Rational > ReferenceImageEditRate;
 
       GenericSoundEssenceDescriptor(const Dictionary*& d);
       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
@@ -445,9 +447,9 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
           ui16_t BlockAlign;
-          optional_property<ui8_t> SequenceOffset;
+          optional_property<ui8_t > SequenceOffset;
           ui32_t AvgBps;
-          optional_property<UL> ChannelAssignment;
+          optional_property<UL > ChannelAssignment;
 
       WaveAudioDescriptor(const Dictionary*& d);
       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
@@ -470,31 +472,41 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          optional_property<ui8_t> SignalStandard;
+          optional_property<ui8_t > SignalStandard;
           ui8_t FrameLayout;
           ui32_t StoredWidth;
           ui32_t StoredHeight;
-          optional_property<ui32_t> StoredF2Offset;
-          optional_property<ui32_t> SampledWidth;
-          optional_property<ui32_t> SampledHeight;
-          optional_property<ui32_t> SampledXOffset;
-          optional_property<ui32_t> SampledYOffset;
-          optional_property<ui32_t> DisplayHeight;
-          optional_property<ui32_t> DisplayWidth;
-          optional_property<ui32_t> DisplayXOffset;
-          optional_property<ui32_t> DisplayYOffset;
-          optional_property<ui32_t> DisplayF2Offset;
+          optional_property<ui32_t > StoredF2Offset;
+          optional_property<ui32_t > SampledWidth;
+          optional_property<ui32_t > SampledHeight;
+          optional_property<ui32_t > SampledXOffset;
+          optional_property<ui32_t > SampledYOffset;
+          optional_property<ui32_t > DisplayHeight;
+          optional_property<ui32_t > DisplayWidth;
+          optional_property<ui32_t > DisplayXOffset;
+          optional_property<ui32_t > DisplayYOffset;
+          optional_property<ui32_t > DisplayF2Offset;
           Rational AspectRatio;
-          optional_property<ui8_t> ActiveFormatDescriptor;
-          optional_property<ui8_t> AlphaTransparency;
-          optional_property<UL> TransferCharacteristic;
-          optional_property<ui32_t> ImageAlignmentOffset;
-          optional_property<ui32_t> ImageStartOffset;
-          optional_property<ui32_t> ImageEndOffset;
-          optional_property<ui8_t> FieldDominance;
+          optional_property<ui8_t > ActiveFormatDescriptor;
+          optional_property<ui8_t > AlphaTransparency;
+          optional_property<UL > TransferCharacteristic;
+          optional_property<ui32_t > ImageAlignmentOffset;
+          optional_property<ui32_t > ImageStartOffset;
+          optional_property<ui32_t > ImageEndOffset;
+          optional_property<ui8_t > FieldDominance;
           UL PictureEssenceCoding;
-          optional_property<UL> CodingEquations;
-          optional_property<UL> ColorPrimaries;
+          optional_property<UL > CodingEquations;
+          optional_property<UL > ColorPrimaries;
+          optional_property<Batch<UL> > AlternativeCenterCuts;
+          optional_property<ui32_t > ActiveWidth;
+          optional_property<ui32_t > ActiveHeight;
+          optional_property<ui32_t > ActiveXOffset;
+          optional_property<ui32_t > ActiveYOffset;
+          optional_property<LineMapPair > VideoLineMap;
+          optional_property<ThreeColorPrimaries > MasteringDisplayPrimaries;
+          optional_property<ColorPrimary > MasteringDisplayWhitePointChromaticity;
+          optional_property<ui32_t > MasteringDisplayMaximumLuminance;
+          optional_property<ui32_t > MasteringDisplayMinimumLuminance;
 
       GenericPictureEssenceDescriptor(const Dictionary*& d);
       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
@@ -517,11 +529,12 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          optional_property<ui32_t> ComponentMaxRef;
-          optional_property<ui32_t> ComponentMinRef;
-          optional_property<ui32_t> AlphaMinRef;
-          optional_property<ui32_t> AlphaMaxRef;
-          optional_property<ui8_t> ScanningDirection;
+          optional_property<ui32_t > ComponentMaxRef;
+          optional_property<ui32_t > ComponentMinRef;
+          optional_property<ui32_t > AlphaMinRef;
+          optional_property<ui32_t > AlphaMaxRef;
+          optional_property<ui8_t > ScanningDirection;
+          RGBALayout PixelLayout;
 
       RGBAEssenceDescriptor(const Dictionary*& d);
       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
@@ -554,9 +567,13 @@ namespace ASDCP
           ui32_t XTOsize;
           ui32_t YTOsize;
           ui16_t Csize;
-          optional_property<Raw> PictureComponentSizing;
-          optional_property<Raw> CodingStyleDefault;
-          optional_property<Raw> QuantizationDefault;
+          optional_property<Raw > PictureComponentSizing;
+          optional_property<Raw > CodingStyleDefault;
+          optional_property<Raw > QuantizationDefault;
+          optional_property<RGBALayout > J2CLayout;
+          optional_property<J2KExtendedCapabilities > J2KExtendedCapabilities;
+          optional_property<Array<Kumu::ArchivableUi16> > J2KProfile;
+          optional_property<ui16_t > J2KCorrespondingProfile;
 
       JPEG2000PictureSubDescriptor(const Dictionary*& d);
       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
@@ -581,14 +598,14 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           ui32_t ComponentDepth;
           ui32_t HorizontalSubsampling;
-          optional_property<ui32_t> VerticalSubsampling;
-          optional_property<ui8_t> ColorSiting;
-          optional_property<ui8_t> ReversedByteOrder;
-          optional_property<ui16_t> PaddingBits;
-          optional_property<ui32_t> AlphaSampleDepth;
-          optional_property<ui32_t> BlackRefLevel;
-          optional_property<ui32_t> WhiteReflevel;
-          optional_property<ui32_t> ColorRange;
+          optional_property<ui32_t > VerticalSubsampling;
+          optional_property<ui8_t > ColorSiting;
+          optional_property<ui8_t > ReversedByteOrder;
+          optional_property<ui16_t > PaddingBits;
+          optional_property<ui32_t > AlphaSampleDepth;
+          optional_property<ui32_t > BlackRefLevel;
+          optional_property<ui32_t > WhiteReflevel;
+          optional_property<ui32_t > ColorRange;
 
       CDCIEssenceDescriptor(const Dictionary*& d);
       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
@@ -611,16 +628,16 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          optional_property<ui8_t> SingleSequence;
-          optional_property<ui8_t> ConstantBFrames;
-          optional_property<ui8_t> CodedContentType;
-          optional_property<ui8_t> LowDelay;
-          optional_property<ui8_t> ClosedGOP;
-          optional_property<ui8_t> IdenticalGOP;
-          optional_property<ui8_t> MaxGOP;
-          optional_property<ui8_t> BPictureCount;
-          optional_property<ui32_t> BitRate;
-          optional_property<ui8_t> ProfileAndLevel;
+          optional_property<ui8_t > SingleSequence;
+          optional_property<ui8_t > ConstantBFrames;
+          optional_property<ui8_t > CodedContentType;
+          optional_property<ui8_t > LowDelay;
+          optional_property<ui8_t > ClosedGOP;
+          optional_property<ui8_t > IdenticalGOP;
+          optional_property<ui8_t > MaxGOP;
+          optional_property<ui8_t > BPictureCount;
+          optional_property<ui32_t > BitRate;
+          optional_property<ui8_t > ProfileAndLevel;
 
       MPEG2VideoDescriptor(const Dictionary*& d);
       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
@@ -644,9 +661,9 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
           UL DataDefinition;
-          ui64_t EventStartPosition;
-          ui64_t Duration;
-          UTF16String EventComment;
+          optional_property<ui64_t > Duration;
+          optional_property<ui64_t > EventStartPosition;
+          optional_property<UTF16String > EventComment;
           UUID DMFramework;
 
       DMSegment(const Dictionary*& d);
@@ -713,6 +730,52 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class DescriptiveFramework : public InterchangeObject
+	{
+	  DescriptiveFramework();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > LinkedDescriptiveFrameworkPlugInId;
+
+      DescriptiveFramework(const Dictionary*& d);
+      DescriptiveFramework(const DescriptiveFramework& rhs);
+      virtual ~DescriptiveFramework() {}
+
+      const DescriptiveFramework& operator=(const DescriptiveFramework& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DescriptiveFramework& rhs);
+      virtual const char* HasName() { return "DescriptiveFramework"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class DescriptiveObject : public InterchangeObject
+	{
+	  DescriptiveObject();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > LinkedDescriptiveObjectPlugInId;
+
+      DescriptiveObject(const Dictionary*& d);
+      DescriptiveObject(const DescriptiveObject& rhs);
+      virtual ~DescriptiveObject() {}
+
+      const DescriptiveObject& operator=(const DescriptiveObject& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DescriptiveObject& rhs);
+      virtual const char* HasName() { return "DescriptiveObject"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
       //
       class GenericDataEssenceDescriptor : public FileDescriptor
 	{
@@ -746,6 +809,7 @@ namespace ASDCP
           UUID ResourceID;
           UTF16String UCSEncoding;
           UTF16String NamespaceURI;
+          optional_property<UTF16String > RFC5646LanguageTagList;
 
       TimedTextDescriptor(const Dictionary*& d);
       TimedTextDescriptor(const TimedTextDescriptor& rhs);
@@ -808,6 +872,28 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class ContainerConstraintSubDescriptor : public InterchangeObject
+	{
+	  ContainerConstraintSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+
+      ContainerConstraintSubDescriptor(const Dictionary*& d);
+      ContainerConstraintSubDescriptor(const ContainerConstraintSubDescriptor& rhs);
+      virtual ~ContainerConstraintSubDescriptor() {}
+
+      const ContainerConstraintSubDescriptor& operator=(const ContainerConstraintSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const ContainerConstraintSubDescriptor& rhs);
+      virtual const char* HasName() { return "ContainerConstraintSubDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
       //
       class NetworkLocator : public InterchangeObject
 	{
@@ -841,9 +927,17 @@ namespace ASDCP
           UL MCALabelDictionaryID;
           UUID MCALinkID;
           UTF16String MCATagSymbol;
-          optional_property<UTF16String> MCATagName;
-          optional_property<ui32_t> MCAChannelID;
-          optional_property<ISO8String> RFC5646SpokenLanguage;
+          optional_property<UTF16String > MCATagName;
+          optional_property<ui32_t > MCAChannelID;
+          optional_property<ISO8String > RFC5646SpokenLanguage;
+          optional_property<UTF16String > MCATitle;
+          optional_property<UTF16String > MCATitleVersion;
+          optional_property<UTF16String > MCATitleSubVersion;
+          optional_property<UTF16String > MCAEpisode;
+          optional_property<UTF16String > MCAPartitionKind;
+          optional_property<UTF16String > MCAPartitionNumber;
+          optional_property<UTF16String > MCAAudioContentKind;
+          optional_property<UTF16String > MCAAudioElementKind;
 
       MCALabelSubDescriptor(const Dictionary*& d);
       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
@@ -866,7 +960,7 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          UUID SoundfieldGroupLinkID;
+          optional_property<UUID > SoundfieldGroupLinkID;
 
       AudioChannelLabelSubDescriptor(const Dictionary*& d);
       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
@@ -889,7 +983,7 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-          Array<UUID> GroupOfSoundfieldGroupsLinkID;
+          optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 
       SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
@@ -949,6 +1043,28 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
+	{
+	  PrivateDCDataDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+
+      PrivateDCDataDescriptor(const Dictionary*& d);
+      PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
+      virtual ~PrivateDCDataDescriptor() {}
+
+      const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const PrivateDCDataDescriptor& rhs);
+      virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
       //
       class DolbyAtmosSubDescriptor : public InterchangeObject
 	{
@@ -976,6 +1092,208 @@ namespace ASDCP
       virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class ACESPictureSubDescriptor : public InterchangeObject
+	{
+	  ACESPictureSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UTF16String > ACESAuthoringInformation;
+          optional_property<ThreeColorPrimaries > ACESMasteringDisplayPrimaries;
+          optional_property<ColorPrimary > ACESMasteringDisplayWhitePointChromaticity;
+          optional_property<ui32_t > ACESMasteringDisplayMaximumLuminance;
+          optional_property<ui32_t > ACESMasteringDisplayMinimumLuminance;
+
+      ACESPictureSubDescriptor(const Dictionary*& d);
+      ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs);
+      virtual ~ACESPictureSubDescriptor() {}
+
+      const ACESPictureSubDescriptor& operator=(const ACESPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const ACESPictureSubDescriptor& rhs);
+      virtual const char* HasName() { return "ACESPictureSubDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class TargetFrameSubDescriptor : public InterchangeObject
+	{
+	  TargetFrameSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UUID TargetFrameAncillaryResourceID;
+          UTF16String MediaType;
+          ui64_t TargetFrameIndex;
+          UL TargetFrameTransferCharacteristic;
+          UL TargetFrameColorPrimaries;
+          ui32_t TargetFrameComponentMaxRef;
+          ui32_t TargetFrameComponentMinRef;
+          ui32_t TargetFrameEssenceStreamID;
+          optional_property<UUID > ACESPictureSubDescriptorInstanceID;
+          optional_property<UL > TargetFrameViewingEnvironment;
+
+      TargetFrameSubDescriptor(const Dictionary*& d);
+      TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs);
+      virtual ~TargetFrameSubDescriptor() {}
+
+      const TargetFrameSubDescriptor& operator=(const TargetFrameSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TargetFrameSubDescriptor& rhs);
+      virtual const char* HasName() { return "TargetFrameSubDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class TextBasedDMFramework : public DescriptiveFramework
+	{
+	  TextBasedDMFramework();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > ObjectRef;
+
+      TextBasedDMFramework(const Dictionary*& d);
+      TextBasedDMFramework(const TextBasedDMFramework& rhs);
+      virtual ~TextBasedDMFramework() {}
+
+      const TextBasedDMFramework& operator=(const TextBasedDMFramework& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TextBasedDMFramework& rhs);
+      virtual const char* HasName() { return "TextBasedDMFramework"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class TextBasedObject : public DescriptiveObject
+	{
+	  TextBasedObject();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UL PayloadSchemeID;
+          UTF16String TextMIMEMediaType;
+          UTF16String RFC5646TextLanguageCode;
+          optional_property<UTF16String > TextDataDescription;
+
+      TextBasedObject(const Dictionary*& d);
+      TextBasedObject(const TextBasedObject& rhs);
+      virtual ~TextBasedObject() {}
+
+      const TextBasedObject& operator=(const TextBasedObject& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TextBasedObject& rhs);
+      virtual const char* HasName() { return "TextBasedObject"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class GenericStreamTextBasedSet : public TextBasedObject
+	{
+	  GenericStreamTextBasedSet();
+
+	public:
+	  const Dictionary*& m_Dict;
+          ui32_t GenericStreamSID;
+
+      GenericStreamTextBasedSet(const Dictionary*& d);
+      GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs);
+      virtual ~GenericStreamTextBasedSet() {}
+
+      const GenericStreamTextBasedSet& operator=(const GenericStreamTextBasedSet& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericStreamTextBasedSet& rhs);
+      virtual const char* HasName() { return "GenericStreamTextBasedSet"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class ISXDDataEssenceDescriptor : public GenericDataEssenceDescriptor
+	{
+	  ISXDDataEssenceDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          ISO8String NamespaceURI;
+
+      ISXDDataEssenceDescriptor(const Dictionary*& d);
+      ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs);
+      virtual ~ISXDDataEssenceDescriptor() {}
+
+      const ISXDDataEssenceDescriptor& operator=(const ISXDDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const ISXDDataEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "ISXDDataEssenceDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class PHDRMetadataTrackSubDescriptor : public InterchangeObject
+	{
+	  PHDRMetadataTrackSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UL DataDefinition;
+          ui32_t SourceTrackID;
+          ui32_t SimplePayloadSID;
+
+      PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
+      PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
+      virtual ~PHDRMetadataTrackSubDescriptor() {}
+
+      const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
+      virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
+      class PIMFDynamicMetadataDescriptor : public GenericDataEssenceDescriptor
+	{
+	  PIMFDynamicMetadataDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          ui32_t GlobalPayloadSID;
+
+      PIMFDynamicMetadataDescriptor(const Dictionary*& d);
+      PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
+      virtual ~PIMFDynamicMetadataDescriptor() {}
+
+      const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
+      virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
     } // namespace MXF
 } // namespace ASDCP