X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FMetadata.h;h=ebdb2884d699a483ff9cd0db58c3cfd31a914a9d;hb=1c26f274039b5ccb93ba138482e5328de0c7df2e;hp=4c83034c1a68275407ce2c95d4c998407c8df90f;hpb=fd73a272189d3d121989b8437b7fbe5402160aaa;p=asdcplib.git

diff --git a/src/Metadata.h b/src/Metadata.h
index 4c83034..ebdb288 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2009, John Hurst
+Copyright (c) 2005-2017, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -45,7 +45,6 @@ namespace ASDCP
       //
       class Identification : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Identification);
 	  Identification();
 
 	public:
@@ -56,24 +55,27 @@ namespace ASDCP
           VersionType ProductVersion;
           UTF16String VersionString;
           UUID ProductUID;
-          Timestamp ModificationDate;
+          Kumu::Timestamp ModificationDate;
           VersionType ToolkitVersion;
-          UTF16String Platform;
-
-  Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~Identification() {}
-          virtual const char* HasName() { return "Identification"; }
-          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&);
+          optional_property<UTF16String > Platform;
+
+      Identification(const Dictionary*& d);
+      Identification(const Identification& rhs);
+      virtual ~Identification() {}
+
+      const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const Identification& rhs);
+      virtual const char* HasName() { return "Identification"; }
+      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 ContentStorage : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(ContentStorage);
 	  ContentStorage();
 
 	public:
@@ -81,143 +83,165 @@ namespace ASDCP
           Batch<UUID> Packages;
           Batch<UUID> EssenceContainerData;
 
-  ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~ContentStorage() {}
-          virtual const char* HasName() { return "ContentStorage"; }
-          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&);
+      ContentStorage(const Dictionary*& d);
+      ContentStorage(const ContentStorage& rhs);
+      virtual ~ContentStorage() {}
+
+      const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const ContentStorage& rhs);
+      virtual const char* HasName() { return "ContentStorage"; }
+      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 EssenceContainerData : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(EssenceContainerData);
 	  EssenceContainerData();
 
 	public:
 	  const Dictionary*& m_Dict;
           UMID LinkedPackageUID;
-          ui32_t IndexSID;
+          optional_property<ui32_t > IndexSID;
           ui32_t BodySID;
 
-  EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {}
-	  virtual ~EssenceContainerData() {}
-          virtual const char* HasName() { return "EssenceContainerData"; }
-          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&);
+      EssenceContainerData(const Dictionary*& d);
+      EssenceContainerData(const EssenceContainerData& rhs);
+      virtual ~EssenceContainerData() {}
+
+      const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const EssenceContainerData& rhs);
+      virtual const char* HasName() { return "EssenceContainerData"; }
+      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 GenericPackage : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericPackage);
 	  GenericPackage();
 
 	public:
 	  const Dictionary*& m_Dict;
           UMID PackageUID;
-          UTF16String Name;
-          Timestamp PackageCreationDate;
-          Timestamp PackageModifiedDate;
-          Batch<UUID> Tracks;
-
-  GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~GenericPackage() {}
-          virtual const char* HasName() { return "GenericPackage"; }
-          virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
-          virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
-	  virtual void     Dump(FILE* = 0);
+          optional_property<UTF16String > Name;
+          Kumu::Timestamp PackageCreationDate;
+          Kumu::Timestamp PackageModifiedDate;
+          Array<UUID> Tracks;
+
+      GenericPackage(const Dictionary*& d);
+      GenericPackage(const GenericPackage& rhs);
+      virtual ~GenericPackage() {}
+
+      const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericPackage& rhs);
+      virtual const char* HasName() { return "GenericPackage"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
 	};
 
       //
       class MaterialPackage : public GenericPackage
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(MaterialPackage);
 	  MaterialPackage();
 
 	public:
 	  const Dictionary*& m_Dict;
-
-  MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
-	  virtual ~MaterialPackage() {}
-          virtual const char* HasName() { return "MaterialPackage"; }
-          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&);
+          optional_property<UUID > PackageMarker;
+
+      MaterialPackage(const Dictionary*& d);
+      MaterialPackage(const MaterialPackage& rhs);
+      virtual ~MaterialPackage() {}
+
+      const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const MaterialPackage& rhs);
+      virtual const char* HasName() { return "MaterialPackage"; }
+      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 SourcePackage : public GenericPackage
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(SourcePackage);
 	  SourcePackage();
 
 	public:
 	  const Dictionary*& m_Dict;
           UUID Descriptor;
 
-  SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
-	  virtual ~SourcePackage() {}
-          virtual const char* HasName() { return "SourcePackage"; }
-          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&);
+      SourcePackage(const Dictionary*& d);
+      SourcePackage(const SourcePackage& rhs);
+      virtual ~SourcePackage() {}
+
+      const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const SourcePackage& rhs);
+      virtual const char* HasName() { return "SourcePackage"; }
+      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 GenericTrack : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericTrack);
 	  GenericTrack();
 
 	public:
 	  const Dictionary*& m_Dict;
           ui32_t TrackID;
           ui32_t TrackNumber;
-          UTF16String TrackName;
-          UUID Sequence;
-
-  GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
-	  virtual ~GenericTrack() {}
-          virtual const char* HasName() { return "GenericTrack"; }
-          virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
-          virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
-	  virtual void     Dump(FILE* = 0);
+          optional_property<UTF16String > TrackName;
+          optional_property<UUID > Sequence;
+
+      GenericTrack(const Dictionary*& d);
+      GenericTrack(const GenericTrack& rhs);
+      virtual ~GenericTrack() {}
+
+      const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericTrack& rhs);
+      virtual const char* HasName() { return "GenericTrack"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
 	};
 
       //
       class StaticTrack : public GenericTrack
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(StaticTrack);
 	  StaticTrack();
 
 	public:
 	  const Dictionary*& m_Dict;
 
-  StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d) {}
-	  virtual ~StaticTrack() {}
-          virtual const char* HasName() { return "StaticTrack"; }
-          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&);
+      StaticTrack(const Dictionary*& d);
+      StaticTrack(const StaticTrack& rhs);
+      virtual ~StaticTrack() {}
+
+      const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const StaticTrack& rhs);
+      virtual const char* HasName() { return "StaticTrack"; }
+      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 Track : public GenericTrack
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Track);
 	  Track();
 
 	public:
@@ -225,59 +249,68 @@ namespace ASDCP
           Rational EditRate;
           ui64_t Origin;
 
-  Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0) {}
-	  virtual ~Track() {}
-          virtual const char* HasName() { return "Track"; }
-          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&);
+      Track(const Dictionary*& d);
+      Track(const Track& rhs);
+      virtual ~Track() {}
+
+      const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const Track& rhs);
+      virtual const char* HasName() { return "Track"; }
+      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 StructuralComponent : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(StructuralComponent);
 	  StructuralComponent();
 
 	public:
 	  const Dictionary*& m_Dict;
           UL DataDefinition;
-          ui64_t Duration;
-
-  StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
-	  virtual ~StructuralComponent() {}
-          virtual const char* HasName() { return "StructuralComponent"; }
-          virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
-          virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
-	  virtual void     Dump(FILE* = 0);
+          optional_property<ui64_t > Duration;
+
+      StructuralComponent(const Dictionary*& d);
+      StructuralComponent(const StructuralComponent& rhs);
+      virtual ~StructuralComponent() {}
+
+      const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const StructuralComponent& rhs);
+      virtual const char* HasName() { return "StructuralComponent"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
 	};
 
       //
       class Sequence : public StructuralComponent
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Sequence);
 	  Sequence();
 
 	public:
 	  const Dictionary*& m_Dict;
-          Batch<UUID> StructuralComponents;
-
-  Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d) {}
-	  virtual ~Sequence() {}
-          virtual const char* HasName() { return "Sequence"; }
-          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&);
+          Array<UUID> StructuralComponents;
+
+      Sequence(const Dictionary*& d);
+      Sequence(const Sequence& rhs);
+      virtual ~Sequence() {}
+
+      const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const Sequence& rhs);
+      virtual const char* HasName() { return "Sequence"; }
+      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 SourceClip : public StructuralComponent
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(SourceClip);
 	  SourceClip();
 
 	public:
@@ -286,20 +319,23 @@ namespace ASDCP
           UMID SourcePackageID;
           ui32_t SourceTrackID;
 
-  SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {}
-	  virtual ~SourceClip() {}
-          virtual const char* HasName() { return "SourceClip"; }
-          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&);
+      SourceClip(const Dictionary*& d);
+      SourceClip(const SourceClip& rhs);
+      virtual ~SourceClip() {}
+
+      const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const SourceClip& rhs);
+      virtual const char* HasName() { return "SourceClip"; }
+      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 TimecodeComponent : public StructuralComponent
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent);
 	  TimecodeComponent();
 
 	public:
@@ -308,156 +344,215 @@ namespace ASDCP
           ui64_t StartTimecode;
           ui8_t DropFrame;
 
-  TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
-	  virtual ~TimecodeComponent() {}
-          virtual const char* HasName() { return "TimecodeComponent"; }
-          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&);
+      TimecodeComponent(const Dictionary*& d);
+      TimecodeComponent(const TimecodeComponent& rhs);
+      virtual ~TimecodeComponent() {}
+
+      const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TimecodeComponent& rhs);
+      virtual const char* HasName() { return "TimecodeComponent"; }
+      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 GenericDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericDescriptor);
 	  GenericDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
-          Batch<UUID> Locators;
-          Batch<UUID> SubDescriptors;
-
-  GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~GenericDescriptor() {}
-          virtual const char* HasName() { return "GenericDescriptor"; }
-          virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
-          virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
-	  virtual void     Dump(FILE* = 0);
+          Array<UUID> Locators;
+          Array<UUID> SubDescriptors;
+
+      GenericDescriptor(const Dictionary*& d);
+      GenericDescriptor(const GenericDescriptor& rhs);
+      virtual ~GenericDescriptor() {}
+
+      const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericDescriptor& rhs);
+      virtual const char* HasName() { return "GenericDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
 	};
 
       //
       class FileDescriptor : public GenericDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(FileDescriptor);
 	  FileDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
-          ui32_t LinkedTrackID;
+          optional_property<ui32_t > LinkedTrackID;
           Rational SampleRate;
-          ui64_t ContainerDuration;
+          optional_property<ui64_t > ContainerDuration;
           UL EssenceContainer;
-          UL Codec;
-
-  FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {}
-	  virtual ~FileDescriptor() {}
-          virtual const char* HasName() { return "FileDescriptor"; }
-          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&);
+          optional_property<UL > Codec;
+
+      FileDescriptor(const Dictionary*& d);
+      FileDescriptor(const FileDescriptor& rhs);
+      virtual ~FileDescriptor() {}
+
+      const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const FileDescriptor& rhs);
+      virtual const char* HasName() { return "FileDescriptor"; }
+      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 GenericSoundEssenceDescriptor : public FileDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericSoundEssenceDescriptor);
 	  GenericSoundEssenceDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
           Rational AudioSamplingRate;
           ui8_t Locked;
-          ui8_t AudioRefLevel;
+          optional_property<ui8_t > AudioRefLevel;
+          optional_property<ui8_t > ElectroSpatialFormulation;
           ui32_t ChannelCount;
           ui32_t QuantizationBits;
-          ui8_t DialNorm;
-
-  GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {}
-	  virtual ~GenericSoundEssenceDescriptor() {}
-          virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
-          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&);
+          optional_property<ui8_t > DialNorm;
+          UL SoundEssenceCoding;
+          optional_property<ui8_t > ReferenceAudioAlignmentLevel;
+          optional_property<Rational > ReferenceImageEditRate;
+
+      GenericSoundEssenceDescriptor(const Dictionary*& d);
+      GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
+      virtual ~GenericSoundEssenceDescriptor() {}
+
+      const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
+      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 WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor);
 	  WaveAudioDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
           ui16_t BlockAlign;
-          ui8_t SequenceOffset;
+          optional_property<ui8_t > SequenceOffset;
           ui32_t AvgBps;
-          UL ChannelAssignment;
-
-  WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
-	  virtual ~WaveAudioDescriptor() {}
-          virtual const char* HasName() { return "WaveAudioDescriptor"; }
-          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&);
+          optional_property<UL > ChannelAssignment;
+
+      WaveAudioDescriptor(const Dictionary*& d);
+      WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
+      virtual ~WaveAudioDescriptor() {}
+
+      const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const WaveAudioDescriptor& rhs);
+      virtual const char* HasName() { return "WaveAudioDescriptor"; }
+      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 GenericPictureEssenceDescriptor : public FileDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
 	  GenericPictureEssenceDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
+          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;
           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;
           UL PictureEssenceCoding;
-
-  GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
-	  virtual ~GenericPictureEssenceDescriptor() {}
-          virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
-          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&);
+          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);
+      virtual ~GenericPictureEssenceDescriptor() {}
+
+      const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
+      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 RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 	  RGBAEssenceDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
-          ui32_t ComponentMaxRef;
-          ui32_t ComponentMinRef;
-
-  RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {}
-	  virtual ~RGBAEssenceDescriptor() {}
-          virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
-          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&);
+          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);
+      virtual ~RGBAEssenceDescriptor() {}
+
+      const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const RGBAEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
+      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 JPEG2000PictureSubDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 	  JPEG2000PictureSubDescriptor();
 
 	public:
@@ -472,70 +567,92 @@ namespace ASDCP
           ui32_t XTOsize;
           ui32_t YTOsize;
           ui16_t Csize;
-          Raw PictureComponentSizing;
-          Raw CodingStyleDefault;
-          Raw QuantizationDefault;
-
-  JPEG2000PictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {}
-	  virtual ~JPEG2000PictureSubDescriptor() {}
-          virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
-          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&);
+          optional_property<Raw > PictureComponentSizing;
+          optional_property<Raw > CodingStyleDefault;
+          optional_property<Raw > QuantizationDefault;
+          optional_property<RGBALayout > J2CLayout;
+
+      JPEG2000PictureSubDescriptor(const Dictionary*& d);
+      JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
+      virtual ~JPEG2000PictureSubDescriptor() {}
+
+      const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
+      virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
+      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 CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
 	  CDCIEssenceDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
           ui32_t ComponentDepth;
           ui32_t HorizontalSubsampling;
-          ui32_t VerticalSubsampling;
-          ui8_t ColorSiting;
-
-  CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
-	  virtual ~CDCIEssenceDescriptor() {}
-          virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
-          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&);
+          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);
+      virtual ~CDCIEssenceDescriptor() {}
+
+      const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const CDCIEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
+      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 MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 	  MPEG2VideoDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
-          ui8_t CodedContentType;
-          ui8_t LowDelay;
-          ui32_t BitRate;
-          ui8_t ProfileAndLevel;
-
-  MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
-	  virtual ~MPEG2VideoDescriptor() {}
-          virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
-          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&);
+          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);
+      virtual ~MPEG2VideoDescriptor() {}
+
+      const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const MPEG2VideoDescriptor& rhs);
+      virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
+      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 DMSegment : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(DMSegment);
 	  DMSegment();
 
 	public:
@@ -546,40 +663,46 @@ namespace ASDCP
           UTF16String EventComment;
           UUID DMFramework;
 
-  DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {}
-	  virtual ~DMSegment() {}
-          virtual const char* HasName() { return "DMSegment"; }
-          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&);
+      DMSegment(const Dictionary*& d);
+      DMSegment(const DMSegment& rhs);
+      virtual ~DMSegment() {}
+
+      const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DMSegment& rhs);
+      virtual const char* HasName() { return "DMSegment"; }
+      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 CryptographicFramework : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 	  CryptographicFramework();
 
 	public:
 	  const Dictionary*& m_Dict;
           UUID ContextSR;
 
-  CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~CryptographicFramework() {}
-          virtual const char* HasName() { return "CryptographicFramework"; }
-          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&);
+      CryptographicFramework(const Dictionary*& d);
+      CryptographicFramework(const CryptographicFramework& rhs);
+      virtual ~CryptographicFramework() {}
+
+      const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const CryptographicFramework& rhs);
+      virtual const char* HasName() { return "CryptographicFramework"; }
+      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 CryptographicContext : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 	  CryptographicContext();
 
 	public:
@@ -590,40 +713,92 @@ namespace ASDCP
           UL MICAlgorithm;
           UUID CryptographicKeyID;
 
-  CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~CryptographicContext() {}
-          virtual const char* HasName() { return "CryptographicContext"; }
-          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&);
+      CryptographicContext(const Dictionary*& d);
+      CryptographicContext(const CryptographicContext& rhs);
+      virtual ~CryptographicContext() {}
+
+      const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const CryptographicContext& rhs);
+      virtual const char* HasName() { return "CryptographicContext"; }
+      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 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
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericDataEssenceDescriptor);
 	  GenericDataEssenceDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
           UL DataEssenceCoding;
 
-  GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d) {}
-	  virtual ~GenericDataEssenceDescriptor() {}
-          virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
-          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&);
+      GenericDataEssenceDescriptor(const Dictionary*& d);
+      GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
+      virtual ~GenericDataEssenceDescriptor() {}
+
+      const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GenericDataEssenceDescriptor& rhs);
+      virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
+      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 TimedTextDescriptor : public GenericDataEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(TimedTextDescriptor);
 	  TimedTextDescriptor();
 
 	public:
@@ -631,21 +806,25 @@ namespace ASDCP
           UUID ResourceID;
           UTF16String UCSEncoding;
           UTF16String NamespaceURI;
-
-  TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {}
-	  virtual ~TimedTextDescriptor() {}
-          virtual const char* HasName() { return "TimedTextDescriptor"; }
-          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&);
+          optional_property<UTF16String > RFC5646LanguageTagList;
+
+      TimedTextDescriptor(const Dictionary*& d);
+      TimedTextDescriptor(const TimedTextDescriptor& rhs);
+      virtual ~TimedTextDescriptor() {}
+
+      const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TimedTextDescriptor& rhs);
+      virtual const char* HasName() { return "TimedTextDescriptor"; }
+      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 TimedTextResourceSubDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(TimedTextResourceSubDescriptor);
 	  TimedTextResourceSubDescriptor();
 
 	public:
@@ -654,33 +833,462 @@ namespace ASDCP
           UTF16String MIMEMediaType;
           ui32_t EssenceStreamID;
 
-  TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {}
-	  virtual ~TimedTextResourceSubDescriptor() {}
-          virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
-          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&);
+      TimedTextResourceSubDescriptor(const Dictionary*& d);
+      TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
+      virtual ~TimedTextResourceSubDescriptor() {}
+
+      const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
+      virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
+      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 StereoscopicPictureSubDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(StereoscopicPictureSubDescriptor);
 	  StereoscopicPictureSubDescriptor();
 
 	public:
 	  const Dictionary*& m_Dict;
 
-  StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-	  virtual ~StereoscopicPictureSubDescriptor() {}
-          virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
-          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&);
+      StereoscopicPictureSubDescriptor(const Dictionary*& d);
+      StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
+      virtual ~StereoscopicPictureSubDescriptor() {}
+
+      const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
+      virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
+      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 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
+	{
+	  NetworkLocator();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UTF16String URLString;
+
+      NetworkLocator(const Dictionary*& d);
+      NetworkLocator(const NetworkLocator& rhs);
+      virtual ~NetworkLocator() {}
+
+      const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const NetworkLocator& rhs);
+      virtual const char* HasName() { return "NetworkLocator"; }
+      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 MCALabelSubDescriptor : public InterchangeObject
+	{
+	  MCALabelSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UL MCALabelDictionaryID;
+          UUID MCALinkID;
+          UTF16String MCATagSymbol;
+          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);
+      virtual ~MCALabelSubDescriptor() {}
+
+      const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const MCALabelSubDescriptor& rhs);
+      virtual const char* HasName() { return "MCALabelSubDescriptor"; }
+      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 AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
+	{
+	  AudioChannelLabelSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<UUID > SoundfieldGroupLinkID;
+
+      AudioChannelLabelSubDescriptor(const Dictionary*& d);
+      AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
+      virtual ~AudioChannelLabelSubDescriptor() {}
+
+      const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
+      virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
+      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 SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
+	{
+	  SoundfieldGroupLabelSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
+
+      SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
+      SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
+      virtual ~SoundfieldGroupLabelSubDescriptor() {}
+
+      const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
+      virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
+      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 GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
+	{
+	  GroupOfSoundfieldGroupsLabelSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+
+      GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
+      GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
+      virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
+
+      const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
+      virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
+      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 DCDataDescriptor : public GenericDataEssenceDescriptor
+	{
+	  DCDataDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+
+      DCDataDescriptor(const Dictionary*& d);
+      DCDataDescriptor(const DCDataDescriptor& rhs);
+      virtual ~DCDataDescriptor() {}
+
+      const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DCDataDescriptor& rhs);
+      virtual const char* HasName() { return "DCDataDescriptor"; }
+      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 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
+	{
+	  DolbyAtmosSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UUID AtmosID;
+          ui32_t FirstFrame;
+          ui16_t MaxChannelCount;
+          ui16_t MaxObjectCount;
+          ui8_t AtmosVersion;
+
+      DolbyAtmosSubDescriptor(const Dictionary*& d);
+      DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
+      virtual ~DolbyAtmosSubDescriptor() {}
+
+      const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
+      virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
+      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 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