megachanges

1 files changed, 400 insertions, 366 deletions

diff --git a/src/Metadata.h b/src/Metadata.h
index bee893a..250f379 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -59,17 +59,18 @@ namespace ASDCP
           VersionType ToolkitVersion;
           UTF16String Platform;
 
-  Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -82,17 +83,18 @@ namespace ASDCP
           Batch<UUID> Packages;
           Batch<UUID> EssenceContainerData;
 
-  ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -106,17 +108,18 @@ namespace ASDCP
           ui32_t IndexSID;
           ui32_t BodySID;
 
-  EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {}
-  EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -132,15 +135,16 @@ namespace ASDCP
           Timestamp PackageModifiedDate;
           Batch<UUID> Tracks;
 
-  GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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);
+      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);
 	};
 
       //
@@ -151,17 +155,18 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
 
-  MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
-  MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -173,17 +178,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           UUID Descriptor;
 
-  SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
-  SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -198,15 +204,16 @@ namespace ASDCP
           UTF16String TrackName;
           UUID Sequence;
 
-  GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
-  GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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);
+      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);
 	};
 
       //
@@ -217,17 +224,18 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
 
-  StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d) {}
-  StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -240,17 +248,18 @@ namespace ASDCP
           Rational EditRate;
           ui64_t Origin;
 
-  Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0) {}
-  Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -263,15 +272,16 @@ namespace ASDCP
           UL DataDefinition;
           ui64_t Duration;
 
-  StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
-  StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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);
+      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);
 	};
 
       //
@@ -283,17 +293,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           Batch<UUID> StructuralComponents;
 
-  Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d) {}
-  Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -307,17 +318,18 @@ namespace ASDCP
           UMID SourcePackageID;
           ui32_t SourceTrackID;
 
-  SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {}
-  SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -331,17 +343,18 @@ namespace ASDCP
           ui64_t StartTimecode;
           ui8_t DropFrame;
 
-  TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
-  TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -354,15 +367,16 @@ namespace ASDCP
           Batch<UUID> Locators;
           Batch<UUID> SubDescriptors;
 
-  GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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);
+      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);
 	};
 
       //
@@ -378,17 +392,18 @@ namespace ASDCP
           UL EssenceContainer;
           UL Codec;
 
-  FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {}
-  FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -405,17 +420,18 @@ namespace ASDCP
           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) {}
-  GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -430,17 +446,18 @@ namespace ASDCP
           ui32_t AvgBps;
           UL ChannelAssignment;
 
-  WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
-  WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -456,17 +473,18 @@ namespace ASDCP
           Rational AspectRatio;
           UL PictureEssenceCoding;
 
-  GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
-  GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -479,17 +497,18 @@ namespace ASDCP
           ui32_t ComponentMaxRef;
           ui32_t ComponentMinRef;
 
-  RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {}
-  RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -513,17 +532,18 @@ namespace ASDCP
           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) {}
-  JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -538,17 +558,18 @@ namespace ASDCP
           ui32_t VerticalSubsampling;
           ui8_t ColorSiting;
 
-  CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
-  CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -563,17 +584,18 @@ namespace ASDCP
           ui32_t BitRate;
           ui8_t ProfileAndLevel;
 
-  MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
-  MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -589,17 +611,18 @@ namespace ASDCP
           UTF16String EventComment;
           UUID DMFramework;
 
-  DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {}
-  DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -611,17 +634,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           UUID ContextSR;
 
-  CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -637,17 +661,18 @@ namespace ASDCP
           UL MICAlgorithm;
           UUID CryptographicKeyID;
 
-  CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -659,17 +684,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           UL DataEssenceCoding;
 
-  GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d) {}
-  GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -683,17 +709,18 @@ namespace ASDCP
           UTF16String UCSEncoding;
           UTF16String NamespaceURI;
 
-  TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {}
-  TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -707,17 +734,18 @@ namespace ASDCP
           UTF16String MIMEMediaType;
           ui32_t EssenceStreamID;
 
-  TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {}
-  TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -728,17 +756,18 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
 
-  StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -750,17 +779,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           UTF16String URLString;
 
-  NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
-  NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -777,17 +807,18 @@ namespace ASDCP
           ui32_t MCAChannelID;
           ISO8String RFC5646SpokenLanguage;
 
-  MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), MCAChannelID(0) {}
-  MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -799,17 +830,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           UUID SoundfieldGroupLinkID;
 
-  AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {}
-  AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -821,17 +853,18 @@ namespace ASDCP
 	  const Dictionary*& m_Dict;
           Array<UUID> GroupOfSoundfieldGroupsLinkID;
 
-  SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {}
-  SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
       //
@@ -842,17 +875,18 @@ namespace ASDCP
 	public:
 	  const Dictionary*& m_Dict;
 
-  GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {}
-  GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(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&);
+      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&);
 	};
 
     } // namespace MXF