megachanges

15 files changed, 3936 insertions, 559 deletions

diff --git a/src/Index.cpp b/src/Index.cpp
index 307e851..449d5bf 100755
--- a/src/Index.cpp
+++ b/src/Index.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2009, John Hurst
+Copyright (c) 2005-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -39,6 +39,8 @@ ASDCP::MXF::IndexTableSegment::IndexTableSegment(const Dictionary*& d) :
   IndexStartPosition(0), IndexDuration(0), EditUnitByteCount(0),
   IndexSID(129), BodySID(1), SliceCount(0), PosTableCount(0)
 {
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_IndexTableSegment);
 }
 
 //
@@ -47,6 +49,23 @@ ASDCP::MXF::IndexTableSegment::~IndexTableSegment()
 }
 
 //
+void
+ASDCP::MXF::IndexTableSegment::Copy(const IndexTableSegment& rhs)
+{
+  InterchangeObject::Copy(rhs);
+  IndexEditRate = rhs.IndexEditRate;
+  IndexStartPosition = rhs.IndexStartPosition;
+  IndexDuration = rhs.IndexDuration;
+  EditUnitByteCount = rhs.EditUnitByteCount;
+  IndexSID = rhs.IndexSID;
+  BodySID = rhs.BodySID;
+  SliceCount = rhs.SliceCount;
+  PosTableCount = rhs.PosTableCount;
+  DeltaEntryArray = rhs.DeltaEntryArray;
+  IndexEntryArray = rhs.IndexEntryArray;
+}
+
+//
 ASDCP::Result_t
 ASDCP::MXF::IndexTableSegment::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -86,8 +105,6 @@ ASDCP::MXF::IndexTableSegment::WriteToTLVSet(TLVWriter& TLVSet)
 ASDCP::Result_t
 ASDCP::MXF::IndexTableSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_IndexTableSegment));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -95,8 +112,6 @@ ASDCP::MXF::IndexTableSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::IndexTableSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_IndexTableSegment));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
diff --git a/src/KLV.cpp b/src/KLV.cpp
index 40fb442..34c9524 100755
--- a/src/KLV.cpp
+++ b/src/KLV.cpp
@@ -57,8 +57,23 @@ ASDCP::KLVPacket::InitFromBuffer(const byte_t* buf, ui32_t buf_len, const UL& la
 
 //
 ASDCP::UL
-ASDCP::KLVPacket::GetUL() {
-  return UL(m_KeyStart);
+ASDCP::KLVPacket::GetUL()
+{
+  if ( m_KeyStart != 0 )
+    return UL(m_KeyStart);
+
+  return m_UL;
+}
+
+//
+bool
+ASDCP::KLVPacket::SetUL(const UL& new_ul)
+{
+  if ( m_KeyStart != 0 )
+    return false;
+
+  m_UL = new_ul;
+  return true;
 }
 
 //
@@ -105,16 +120,25 @@ ASDCP::KLVPacket::InitFromBuffer(const byte_t* buf, ui32_t buf_len)
 bool
 ASDCP::KLVPacket::HasUL(const byte_t* ul)
 {
-  if ( m_KeyStart == 0 )
-    return false;
+  if ( m_KeyStart != 0 )
+    {
+      return ( memcmp(ul, m_KeyStart, SMPTE_UL_LENGTH) == 0 ) ? true : false;
+    }
 
-  return ( memcmp(ul, m_KeyStart, SMPTE_UL_LENGTH) == 0 ) ? true : false;
+  if ( m_UL.HasValue() )
+    {
+      return UL(ul) == m_UL;
+    }
+
+  return false;
 }
 
 //
 ASDCP::Result_t
 ASDCP::KLVPacket::WriteKLToBuffer(ASDCP::FrameBuffer& Buffer, const UL& label, ui32_t length)
 {
+  assert(label.HasValue());
+
   if ( Buffer.Size() + kl_length > Buffer.Capacity() )
     {
       DefaultLogSink().Error("Small write buffer\n");
@@ -134,6 +158,8 @@ ASDCP::KLVPacket::WriteKLToBuffer(ASDCP::FrameBuffer& Buffer, const UL& label, u
 void
 ASDCP::KLVPacket::Dump(FILE* stream, const Dictionary& Dict, bool show_value)
 {
+  char buf[64];
+
   if ( stream == 0 )
     stream = stderr;
 
@@ -141,7 +167,6 @@ ASDCP::KLVPacket::Dump(FILE* stream, const Dictionary& Dict, bool show_value)
     {
       assert(m_ValueStart);
       UL TmpUL(m_KeyStart);
-      char buf[64];
       fprintf(stream, "%s", TmpUL.EncodeString(buf, 64));
 
       const MDDEntry* Entry = Dict.FindUL(m_KeyStart);
@@ -150,6 +175,10 @@ ASDCP::KLVPacket::Dump(FILE* stream, const Dictionary& Dict, bool show_value)
       if ( show_value && m_ValueLength < 1000 )
 	Kumu::hexdump(m_ValueStart, Kumu::xmin(m_ValueLength, (ui32_t)128), stream);
     }
+  else if ( m_UL.HasValue() )
+    {
+      fprintf(stream, "%s\n", m_UL.EncodeString(buf, 64));
+    }
   else
     {
       fprintf(stream, "*** Malformed KLV packet ***\n");
diff --git a/src/KLV.h b/src/KLV.h
index 37fdd2c..b8e2149 100755
--- a/src/KLV.h
+++ b/src/KLV.h
@@ -195,6 +195,7 @@ inline const char* ui64sz(ui64_t i, char* buf)
       ui32_t        m_KLLength;
       const byte_t* m_ValueStart;
       ui32_t        m_ValueLength;
+      UL m_UL;
 
     public:
       KLVPacket() : m_KeyStart(0), m_KLLength(0), m_ValueStart(0), m_ValueLength(0) {}
@@ -213,10 +214,16 @@ inline const char* ui64sz(ui64_t i, char* buf)
       }
 
       virtual UL       GetUL();
+      virtual bool     SetUL(const UL&);
       virtual bool     HasUL(const byte_t*);
       virtual Result_t InitFromBuffer(const byte_t*, ui32_t);
       virtual Result_t InitFromBuffer(const byte_t*, ui32_t, const UL& label);
       virtual Result_t WriteKLToBuffer(ASDCP::FrameBuffer&, const UL& label, ui32_t length);
+      virtual Result_t WriteKLToBuffer(ASDCP::FrameBuffer& fb, ui32_t length) {
+	if ( ! m_UL.HasValue() )
+	  return RESULT_STATE;
+	return WriteKLToBuffer(fb, m_UL, length); }
+
       virtual void     Dump(FILE*, const Dictionary& Dict, bool show_value);
     };
 
diff --git a/src/MXF.cpp b/src/MXF.cpp
index d1dd6d0..529344f 100755
--- a/src/MXF.cpp
+++ b/src/MXF.cpp
@@ -420,7 +420,9 @@ public:
 
 
 //
-ASDCP::MXF::Primer::Primer(const Dictionary*& d) : m_LocalTag(0xff), m_Dict(d) {}
+ASDCP::MXF::Primer::Primer(const Dictionary*& d) : m_LocalTag(0xff), m_Dict(d) {
+  m_UL = m_Dict->ul(MDD_Primer);
+}
 
 //
 ASDCP::MXF::Primer::~Primer() {}
@@ -486,7 +488,7 @@ ASDCP::MXF::Primer::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   if ( ASDCP_SUCCESS(result) )
     {
       ui32_t packet_length = MemWRT.Length();
-      result = WriteKLToBuffer(Buffer, m_Dict->ul(MDD_Primer), packet_length);
+      result = WriteKLToBuffer(Buffer, packet_length);
 
       if ( ASDCP_SUCCESS(result) )
 	Buffer.Size(Buffer.Size() + packet_length);
@@ -579,6 +581,31 @@ ASDCP::MXF::Primer::Dump(FILE* stream)
 //
 
 //
+ASDCP::MXF::Preface::Preface(const Dictionary*& d) :
+  InterchangeObject(d), m_Dict(d), Version(258), ObjectModelVersion(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->Type(MDD_Preface).ul;
+}
+
+//
+void
+ASDCP::MXF::Preface::Copy(const Preface& rhs)
+{
+  InterchangeObject::Copy(rhs);
+
+  LastModifiedDate = rhs.LastModifiedDate;
+  Version = rhs.Version;
+  ObjectModelVersion = rhs.ObjectModelVersion;
+  PrimaryPackage = rhs.PrimaryPackage;
+  Identifications = rhs.Identifications;
+  ContentStorage = rhs.ContentStorage;
+  OperationalPattern = rhs.OperationalPattern;
+  EssenceContainers = rhs.EssenceContainers;
+  DMSchemes = rhs.DMSchemes;
+}
+
+//
 ASDCP::Result_t
 ASDCP::MXF::Preface::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -616,8 +643,6 @@ ASDCP::MXF::Preface::WriteToTLVSet(TLVWriter& TLVSet)
 ASDCP::Result_t
 ASDCP::MXF::Preface::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Preface));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -625,8 +650,6 @@ ASDCP::MXF::Preface::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::Preface::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Preface));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1262,6 +1285,15 @@ ASDCP::MXF::OPAtomIndexFooter::PushIndexEntry(const IndexTableSegment::IndexEntr
 //
 
 //
+void
+ASDCP::MXF::InterchangeObject::Copy(const InterchangeObject& rhs)
+{
+  m_UL = rhs.m_UL;
+  InstanceUID = rhs.InstanceUID;
+  GenerationUID = rhs.GenerationUID;
+}
+
+//
 ASDCP::Result_t
 ASDCP::MXF::InterchangeObject::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1288,13 +1320,9 @@ ASDCP::MXF::InterchangeObject::InitFromBuffer(const byte_t* p, ui32_t l)
   ASDCP_TEST_NULL(p);
   Result_t result = RESULT_FALSE;
 
-  if ( m_Typeinfo == 0 )
+  if ( m_UL.HasValue() )
     {
-      result = KLVPacket::InitFromBuffer(p, l);
-    }
-  else
-    {
-      result = KLVPacket::InitFromBuffer(p, l, m_Typeinfo->ul);
+      result = KLVPacket::InitFromBuffer(p, l, m_UL);
 
       if ( ASDCP_SUCCESS(result) )
 	{
@@ -1302,6 +1330,10 @@ ASDCP::MXF::InterchangeObject::InitFromBuffer(const byte_t* p, ui32_t l)
 	  result = InitFromTLVSet(MemRDR);
 	}
     }
+  else
+    {
+      result = KLVPacket::InitFromBuffer(p, l);
+    }
   
   return result;
 }
@@ -1310,7 +1342,7 @@ ASDCP::MXF::InterchangeObject::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::InterchangeObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  if ( m_Typeinfo == 0 )
+  if ( ! m_UL.HasValue() )
     return RESULT_STATE;
 
   TLVWriter MemWRT(Buffer.Data() + kl_length, Buffer.Capacity() - kl_length, m_Lookup);
@@ -1319,7 +1351,7 @@ ASDCP::MXF::InterchangeObject::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   if ( ASDCP_SUCCESS(result) )
     {
       ui32_t packet_length = MemWRT.Length();
-      result = WriteKLToBuffer(Buffer, m_Typeinfo->ul, packet_length);
+      result = WriteKLToBuffer(Buffer, packet_length);
 
       if ( ASDCP_SUCCESS(result) )
 	Buffer.Size(Buffer.Size() + packet_length);
diff --git a/src/MXF.h b/src/MXF.h
index fbae834..d62732e 100755
--- a/src/MXF.h
+++ b/src/MXF.h
@@ -206,17 +206,16 @@ namespace ASDCP
 	{
 	  InterchangeObject();
 
-	protected:
-	  const MDDEntry* m_Typeinfo;
-
 	public:
 	  const Dictionary*& m_Dict;
 	  IPrimerLookup* m_Lookup;
 	  UUID           InstanceUID;
 	  UUID           GenerationUID;
 
-	InterchangeObject(const Dictionary*& d) : m_Typeinfo(0), m_Dict(d), m_Lookup(0) {}
+	InterchangeObject(const Dictionary*& d) : m_Dict(d), m_Lookup(0) {}
 	  virtual ~InterchangeObject() {}
+
+	  virtual void Copy(const InterchangeObject& rhs);
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -234,7 +233,7 @@ namespace ASDCP
 
 	public:
 	  const Dictionary*& m_Dict;
-	  UUID         GenerationUID;
+	  ////	  UUID         GenerationUID;
 	  Timestamp    LastModifiedDate;
 	  ui16_t       Version;
 	  ui32_t       ObjectModelVersion;
@@ -245,8 +244,10 @@ namespace ASDCP
 	  Batch<UL>    EssenceContainers;
 	  Batch<UL>    DMSchemes;
 
-	Preface(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Version(258), ObjectModelVersion(0) {}
+	  Preface(const Dictionary*& d);
 	  virtual ~Preface() {}
+
+	  virtual void Copy(const Preface& rhs);
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -315,6 +316,8 @@ namespace ASDCP
 
 	  IndexTableSegment(const Dictionary*&);
 	  virtual ~IndexTableSegment();
+
+	  virtual void Copy(const IndexTableSegment& rhs);
 	  virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
diff --git a/src/Makefile.am b/src/Makefile.am
index 9e4c11e..58cfe89 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -125,31 +125,50 @@ napali_la_LIBADD = libnapali.la libpyasdcp.la
 endif
 
 # list of programs to be built and installed
-bin_PROGRAMS = asdcp-test j2c-test blackwave klvwalk kmfilegen kmrandgen \
-		kmuuidgen wavesplit
+bin_PROGRAMS = \
+	asdcp-wrap asdcp-unwrap asdcp-util asdcp-info asdcp-test \
+	j2c-test blackwave klvwalk wavesplit \
+	kmfilegen kmrandgen kmuuidgen
 
-# sources for a program
+# sources and linkage for CLI utilities
 asdcp_test_SOURCES = asdcp-test.cpp
-
-# list of libraries to link against for a program
 asdcp_test_LDADD = libasdcp.la
+
+asdcp_wrap_SOURCES = asdcp-wrap.cpp
+asdcp_wrap_LDADD = libasdcp.la
+
+asdcp_unwrap_SOURCES = asdcp-unwrap.cpp
+asdcp_unwrap_LDADD = libasdcp.la
+
+asdcp_util_SOURCES = asdcp-util.cpp
+asdcp_util_LDADD = libasdcp.la
+
+asdcp_info_SOURCES = asdcp-info.cpp
+asdcp_info_LDADD = libasdcp.la
+
 kmfilegen_SOURCES = kmfilegen.cpp
 kmfilegen_LDADD = libkumu.la
+
 kmrandgen_SOURCES = kmrandgen.cpp
 kmrandgen_LDADD = libkumu.la
+
 kmuuidgen_SOURCES = kmuuidgen.cpp
 kmuuidgen_LDADD = libkumu.la
+
 blackwave_SOURCES = blackwave.cpp
 blackwave_LDADD = libasdcp.la
+
 klvwalk_SOURCES = klvwalk.cpp
 klvwalk_LDADD = libasdcp.la
+
 wavesplit_SOURCES = wavesplit.cpp
 wavesplit_LDADD = libasdcp.la
+
 j2c_test_SOURCES = j2c-test.cpp
 j2c_test_LDADD = libasdcp.la
 
 # list of programs that need to be compiled for use in test suite
-check_PROGRAMS = asdcp-mem-test path-test S429-5-cgi \
+check_PROGRAMS = asdcp-mem-test path-test \
 	fips-186-rng-test asdcp-version
 if DEV_HEADERS
 check_PROGRAMS += tt-xform
@@ -159,14 +178,16 @@ endif
 # list of libraries to link against for a test program
 asdcp_mem_test_SOURCES = asdcp-mem-test.cpp
 asdcp_mem_test_LDADD = libasdcp.la
+
 path_test_SOURCES = path-test.cpp
 path_test_LDADD = libkumu.la
-S429_5_cgi_SOURCES = S429-5-cgi.cpp
-S429_5_cgi_LDADD = libasdcp.la
+
 fips_186_rng_test_SOURCES = fips-186-rng-test.cpp
 fips_186_rng_test_LDADD = libasdcp.la
+
 asdcp_version_SOURCES = asdcp-version.cpp
 asdcp_version_LDADD = libkumu.la
+
 if DEV_HEADERS
 nodist_tt_xform_SOURCES = tt-xform.cpp
 tt_xform_LDADD = libasdcp.la
diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index f62f273..ac1db76 100755
--- a/src/Metadata.cpp
+++ b/src/Metadata.cpp
@@ -123,6 +123,22 @@ ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
 // Identification
 
 //
+
+Identification::Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_Identification);
+}
+
+Identification::Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_Identification);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 Identification::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -162,6 +178,7 @@ Identification::WriteToTLVSet(TLVWriter& TLVSet)
 void
 Identification::Copy(const Identification& rhs)
 {
+  InterchangeObject::Copy(rhs);
   ThisGenerationUID = rhs.ThisGenerationUID;
   CompanyName = rhs.CompanyName;
   ProductName = rhs.ProductName;
@@ -199,8 +216,6 @@ Identification::Dump(FILE* stream)
 ASDCP::Result_t
 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Identification));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -208,8 +223,6 @@ Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Identification));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -217,6 +230,22 @@ Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // ContentStorage
 
 //
+
+ContentStorage::ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_ContentStorage);
+}
+
+ContentStorage::ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_ContentStorage);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 ContentStorage::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -242,6 +271,7 @@ ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
 void
 ContentStorage::Copy(const ContentStorage& rhs)
 {
+  InterchangeObject::Copy(rhs);
   Packages = rhs.Packages;
   EssenceContainerData = rhs.EssenceContainerData;
 }
@@ -267,8 +297,6 @@ ContentStorage::Dump(FILE* stream)
 ASDCP::Result_t
 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_ContentStorage));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -276,8 +304,6 @@ ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_ContentStorage));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -285,6 +311,22 @@ ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // EssenceContainerData
 
 //
+
+EssenceContainerData::EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_EssenceContainerData);
+}
+
+EssenceContainerData::EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_EssenceContainerData);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 EssenceContainerData::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -312,6 +354,7 @@ EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
 void
 EssenceContainerData::Copy(const EssenceContainerData& rhs)
 {
+  InterchangeObject::Copy(rhs);
   LinkedPackageUID = rhs.LinkedPackageUID;
   IndexSID = rhs.IndexSID;
   BodySID = rhs.BodySID;
@@ -337,8 +380,6 @@ EssenceContainerData::Dump(FILE* stream)
 ASDCP::Result_t
 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_EssenceContainerData));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -346,8 +387,6 @@ EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_EssenceContainerData));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -355,6 +394,15 @@ EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GenericPackage
 
 //
+GenericPackage::GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
+
+GenericPackage::GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GenericPackage::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -386,6 +434,7 @@ GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GenericPackage::Copy(const GenericPackage& rhs)
 {
+  InterchangeObject::Copy(rhs);
   PackageUID = rhs.PackageUID;
   Name = rhs.Name;
   PackageCreationDate = rhs.PackageCreationDate;
@@ -417,6 +466,22 @@ GenericPackage::Dump(FILE* stream)
 // MaterialPackage
 
 //
+
+MaterialPackage::MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_MaterialPackage);
+}
+
+MaterialPackage::MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_MaterialPackage);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 MaterialPackage::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -438,6 +503,7 @@ MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
 void
 MaterialPackage::Copy(const MaterialPackage& rhs)
 {
+  GenericPackage::Copy(rhs);
 }
 
 //
@@ -457,8 +523,6 @@ MaterialPackage::Dump(FILE* stream)
 ASDCP::Result_t
 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_MaterialPackage));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -466,8 +530,6 @@ MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_MaterialPackage));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -475,6 +537,22 @@ MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // SourcePackage
 
 //
+
+SourcePackage::SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_SourcePackage);
+}
+
+SourcePackage::SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_SourcePackage);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 SourcePackage::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -498,6 +576,7 @@ SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
 void
 SourcePackage::Copy(const SourcePackage& rhs)
 {
+  GenericPackage::Copy(rhs);
   Descriptor = rhs.Descriptor;
 }
 
@@ -519,8 +598,6 @@ SourcePackage::Dump(FILE* stream)
 ASDCP::Result_t
 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_SourcePackage));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -528,8 +605,6 @@ SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_SourcePackage));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -537,6 +612,15 @@ SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GenericTrack
 
 //
+GenericTrack::GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
+
+GenericTrack::GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GenericTrack::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -566,6 +650,7 @@ GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GenericTrack::Copy(const GenericTrack& rhs)
 {
+  InterchangeObject::Copy(rhs);
   TrackID = rhs.TrackID;
   TrackNumber = rhs.TrackNumber;
   TrackName = rhs.TrackName;
@@ -594,6 +679,22 @@ GenericTrack::Dump(FILE* stream)
 // StaticTrack
 
 //
+
+StaticTrack::StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_StaticTrack);
+}
+
+StaticTrack::StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_StaticTrack);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 StaticTrack::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -615,6 +716,7 @@ StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
 void
 StaticTrack::Copy(const StaticTrack& rhs)
 {
+  GenericTrack::Copy(rhs);
 }
 
 //
@@ -634,8 +736,6 @@ StaticTrack::Dump(FILE* stream)
 ASDCP::Result_t
 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_StaticTrack));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -643,8 +743,6 @@ StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_StaticTrack));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -652,6 +750,22 @@ StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // Track
 
 //
+
+Track::Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_Track);
+}
+
+Track::Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_Track);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 Track::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -677,6 +791,7 @@ Track::WriteToTLVSet(TLVWriter& TLVSet)
 void
 Track::Copy(const Track& rhs)
 {
+  GenericTrack::Copy(rhs);
   EditRate = rhs.EditRate;
   Origin = rhs.Origin;
 }
@@ -700,8 +815,6 @@ Track::Dump(FILE* stream)
 ASDCP::Result_t
 Track::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Track));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -709,8 +822,6 @@ Track::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Track));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -718,6 +829,15 @@ Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // StructuralComponent
 
 //
+StructuralComponent::StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
+
+StructuralComponent::StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 StructuralComponent::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -743,6 +863,7 @@ StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
 void
 StructuralComponent::Copy(const StructuralComponent& rhs)
 {
+  InterchangeObject::Copy(rhs);
   DataDefinition = rhs.DataDefinition;
   Duration = rhs.Duration;
 }
@@ -767,6 +888,22 @@ StructuralComponent::Dump(FILE* stream)
 // Sequence
 
 //
+
+Sequence::Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_Sequence);
+}
+
+Sequence::Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_Sequence);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 Sequence::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -790,6 +927,7 @@ Sequence::WriteToTLVSet(TLVWriter& TLVSet)
 void
 Sequence::Copy(const Sequence& rhs)
 {
+  StructuralComponent::Copy(rhs);
   StructuralComponents = rhs.StructuralComponents;
 }
 
@@ -812,8 +950,6 @@ Sequence::Dump(FILE* stream)
 ASDCP::Result_t
 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Sequence));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -821,8 +957,6 @@ Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_Sequence));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -830,6 +964,22 @@ Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // SourceClip
 
 //
+
+SourceClip::SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_SourceClip);
+}
+
+SourceClip::SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_SourceClip);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 SourceClip::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -857,6 +1007,7 @@ SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
 void
 SourceClip::Copy(const SourceClip& rhs)
 {
+  StructuralComponent::Copy(rhs);
   StartPosition = rhs.StartPosition;
   SourcePackageID = rhs.SourcePackageID;
   SourceTrackID = rhs.SourceTrackID;
@@ -882,8 +1033,6 @@ SourceClip::Dump(FILE* stream)
 ASDCP::Result_t
 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_SourceClip));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -891,8 +1040,6 @@ SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_SourceClip));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -900,6 +1047,22 @@ SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // TimecodeComponent
 
 //
+
+TimecodeComponent::TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TimecodeComponent);
+}
+
+TimecodeComponent::TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TimecodeComponent);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 TimecodeComponent::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -927,6 +1090,7 @@ TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
 void
 TimecodeComponent::Copy(const TimecodeComponent& rhs)
 {
+  StructuralComponent::Copy(rhs);
   RoundedTimecodeBase = rhs.RoundedTimecodeBase;
   StartTimecode = rhs.StartTimecode;
   DropFrame = rhs.DropFrame;
@@ -952,8 +1116,6 @@ TimecodeComponent::Dump(FILE* stream)
 ASDCP::Result_t
 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_TimecodeComponent));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -961,8 +1123,6 @@ TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_TimecodeComponent));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -970,6 +1130,15 @@ TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GenericDescriptor
 
 //
+GenericDescriptor::GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
+
+GenericDescriptor::GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GenericDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -995,6 +1164,7 @@ GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GenericDescriptor::Copy(const GenericDescriptor& rhs)
 {
+  InterchangeObject::Copy(rhs);
   Locators = rhs.Locators;
   SubDescriptors = rhs.SubDescriptors;
 }
@@ -1021,6 +1191,22 @@ GenericDescriptor::Dump(FILE* stream)
 // FileDescriptor
 
 //
+
+FileDescriptor::FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_FileDescriptor);
+}
+
+FileDescriptor::FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_FileDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 FileDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1052,6 +1238,7 @@ FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 FileDescriptor::Copy(const FileDescriptor& rhs)
 {
+  GenericDescriptor::Copy(rhs);
   LinkedTrackID = rhs.LinkedTrackID;
   SampleRate = rhs.SampleRate;
   ContainerDuration = rhs.ContainerDuration;
@@ -1081,8 +1268,6 @@ FileDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_FileDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1090,8 +1275,6 @@ FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_FileDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1099,6 +1282,22 @@ FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GenericSoundEssenceDescriptor
 
 //
+
+GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
+}
+
+GenericSoundEssenceDescriptor::GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GenericSoundEssenceDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GenericSoundEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1132,6 +1331,7 @@ GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
 {
+  FileDescriptor::Copy(rhs);
   AudioSamplingRate = rhs.AudioSamplingRate;
   Locked = rhs.Locked;
   AudioRefLevel = rhs.AudioRefLevel;
@@ -1163,8 +1363,6 @@ GenericSoundEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GenericSoundEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1172,8 +1370,6 @@ GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GenericSoundEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1181,6 +1377,22 @@ GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // WaveAudioDescriptor
 
 //
+
+WaveAudioDescriptor::WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
+}
+
+WaveAudioDescriptor::WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_WaveAudioDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 WaveAudioDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1210,6 +1422,7 @@ WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
 {
+  GenericSoundEssenceDescriptor::Copy(rhs);
   BlockAlign = rhs.BlockAlign;
   SequenceOffset = rhs.SequenceOffset;
   AvgBps = rhs.AvgBps;
@@ -1237,8 +1450,6 @@ WaveAudioDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_WaveAudioDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1246,8 +1457,6 @@ WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_WaveAudioDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1255,6 +1464,22 @@ WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GenericPictureEssenceDescriptor
 
 //
+
+GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
+}
+
+GenericPictureEssenceDescriptor::GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GenericPictureEssenceDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GenericPictureEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1286,6 +1511,7 @@ GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
 {
+  FileDescriptor::Copy(rhs);
   FrameLayout = rhs.FrameLayout;
   StoredWidth = rhs.StoredWidth;
   StoredHeight = rhs.StoredHeight;
@@ -1315,8 +1541,6 @@ GenericPictureEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GenericPictureEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1324,8 +1548,6 @@ GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GenericPictureEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1333,6 +1555,22 @@ GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // RGBAEssenceDescriptor
 
 //
+
+RGBAEssenceDescriptor::RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
+}
+
+RGBAEssenceDescriptor::RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_RGBAEssenceDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1358,6 +1596,7 @@ RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
 {
+  GenericPictureEssenceDescriptor::Copy(rhs);
   ComponentMaxRef = rhs.ComponentMaxRef;
   ComponentMinRef = rhs.ComponentMinRef;
 }
@@ -1381,8 +1620,6 @@ RGBAEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_RGBAEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1390,8 +1627,6 @@ RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_RGBAEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1399,6 +1634,22 @@ RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // JPEG2000PictureSubDescriptor
 
 //
+
+JPEG2000PictureSubDescriptor::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)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
+}
+
+JPEG2000PictureSubDescriptor::JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_JPEG2000PictureSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 JPEG2000PictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1446,6 +1697,7 @@ JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
 {
+  InterchangeObject::Copy(rhs);
   Rsize = rhs.Rsize;
   Xsize = rhs.Xsize;
   Ysize = rhs.Ysize;
@@ -1491,8 +1743,6 @@ JPEG2000PictureSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_JPEG2000PictureSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1500,8 +1750,6 @@ JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_JPEG2000PictureSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1509,6 +1757,22 @@ JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // CDCIEssenceDescriptor
 
 //
+
+CDCIEssenceDescriptor::CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
+}
+
+CDCIEssenceDescriptor::CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_CDCIEssenceDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 CDCIEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1538,6 +1802,7 @@ CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
 {
+  GenericPictureEssenceDescriptor::Copy(rhs);
   ComponentDepth = rhs.ComponentDepth;
   HorizontalSubsampling = rhs.HorizontalSubsampling;
   VerticalSubsampling = rhs.VerticalSubsampling;
@@ -1565,8 +1830,6 @@ CDCIEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_CDCIEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1574,8 +1837,6 @@ CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_CDCIEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1583,6 +1844,22 @@ CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // MPEG2VideoDescriptor
 
 //
+
+MPEG2VideoDescriptor::MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
+}
+
+MPEG2VideoDescriptor::MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_MPEG2VideoDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 MPEG2VideoDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1612,6 +1889,7 @@ MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
 {
+  CDCIEssenceDescriptor::Copy(rhs);
   CodedContentType = rhs.CodedContentType;
   LowDelay = rhs.LowDelay;
   BitRate = rhs.BitRate;
@@ -1639,8 +1917,6 @@ MPEG2VideoDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_MPEG2VideoDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1648,8 +1924,6 @@ MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_MPEG2VideoDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1657,6 +1931,22 @@ MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // DMSegment
 
 //
+
+DMSegment::DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_DMSegment);
+}
+
+DMSegment::DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_DMSegment);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 DMSegment::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1688,6 +1978,7 @@ DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
 void
 DMSegment::Copy(const DMSegment& rhs)
 {
+  InterchangeObject::Copy(rhs);
   DataDefinition = rhs.DataDefinition;
   EventStartPosition = rhs.EventStartPosition;
   Duration = rhs.Duration;
@@ -1717,8 +2008,6 @@ DMSegment::Dump(FILE* stream)
 ASDCP::Result_t
 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_DMSegment));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1726,8 +2015,6 @@ DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_DMSegment));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1735,6 +2022,22 @@ DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // CryptographicFramework
 
 //
+
+CryptographicFramework::CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_CryptographicFramework);
+}
+
+CryptographicFramework::CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_CryptographicFramework);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 CryptographicFramework::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1758,6 +2061,7 @@ CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
 void
 CryptographicFramework::Copy(const CryptographicFramework& rhs)
 {
+  InterchangeObject::Copy(rhs);
   ContextSR = rhs.ContextSR;
 }
 
@@ -1779,8 +2083,6 @@ CryptographicFramework::Dump(FILE* stream)
 ASDCP::Result_t
 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicFramework));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1788,8 +2090,6 @@ CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicFramework));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1797,6 +2097,22 @@ CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // CryptographicContext
 
 //
+
+CryptographicContext::CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_CryptographicContext);
+}
+
+CryptographicContext::CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_CryptographicContext);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 CryptographicContext::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1828,6 +2144,7 @@ CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
 void
 CryptographicContext::Copy(const CryptographicContext& rhs)
 {
+  InterchangeObject::Copy(rhs);
   ContextID = rhs.ContextID;
   SourceEssenceContainer = rhs.SourceEssenceContainer;
   CipherAlgorithm = rhs.CipherAlgorithm;
@@ -1857,8 +2174,6 @@ CryptographicContext::Dump(FILE* stream)
 ASDCP::Result_t
 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicContext));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1866,8 +2181,6 @@ CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicContext));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1875,6 +2188,22 @@ CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GenericDataEssenceDescriptor
 
 //
+
+GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
+}
+
+GenericDataEssenceDescriptor::GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GenericDataEssenceDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GenericDataEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1898,6 +2227,7 @@ GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
 {
+  FileDescriptor::Copy(rhs);
   DataEssenceCoding = rhs.DataEssenceCoding;
 }
 
@@ -1919,8 +2249,6 @@ GenericDataEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GenericDataEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1928,8 +2256,6 @@ GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GenericDataEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1937,6 +2263,22 @@ GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // TimedTextDescriptor
 
 //
+
+TimedTextDescriptor::TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
+}
+
+TimedTextDescriptor::TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TimedTextDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 TimedTextDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -1964,6 +2306,7 @@ TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
 {
+  GenericDataEssenceDescriptor::Copy(rhs);
   ResourceID = rhs.ResourceID;
   UCSEncoding = rhs.UCSEncoding;
   NamespaceURI = rhs.NamespaceURI;
@@ -1989,8 +2332,6 @@ TimedTextDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1998,8 +2339,6 @@ TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2007,6 +2346,22 @@ TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // TimedTextResourceSubDescriptor
 
 //
+
+TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
+}
+
+TimedTextResourceSubDescriptor::TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_TimedTextResourceSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 TimedTextResourceSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2034,6 +2389,7 @@ TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
 {
+  InterchangeObject::Copy(rhs);
   AncillaryResourceID = rhs.AncillaryResourceID;
   MIMEMediaType = rhs.MIMEMediaType;
   EssenceStreamID = rhs.EssenceStreamID;
@@ -2059,8 +2415,6 @@ TimedTextResourceSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextResourceSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2068,8 +2422,6 @@ TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextResourceSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2077,6 +2429,22 @@ TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // StereoscopicPictureSubDescriptor
 
 //
+
+StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
+}
+
+StereoscopicPictureSubDescriptor::StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_StereoscopicPictureSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 StereoscopicPictureSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2098,6 +2466,7 @@ StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
 {
+  InterchangeObject::Copy(rhs);
 }
 
 //
@@ -2117,8 +2486,6 @@ StereoscopicPictureSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_StereoscopicPictureSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2126,8 +2493,6 @@ StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_StereoscopicPictureSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2135,6 +2500,22 @@ StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // NetworkLocator
 
 //
+
+NetworkLocator::NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_NetworkLocator);
+}
+
+NetworkLocator::NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_NetworkLocator);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 NetworkLocator::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2158,6 +2539,7 @@ NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
 void
 NetworkLocator::Copy(const NetworkLocator& rhs)
 {
+  InterchangeObject::Copy(rhs);
   URLString = rhs.URLString;
 }
 
@@ -2179,8 +2561,6 @@ NetworkLocator::Dump(FILE* stream)
 ASDCP::Result_t
 NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_NetworkLocator));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2188,8 +2568,6 @@ NetworkLocator::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_NetworkLocator));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2197,6 +2575,22 @@ NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // MCALabelSubDescriptor
 
 //
+
+MCALabelSubDescriptor::MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), MCAChannelID(0)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
+}
+
+MCALabelSubDescriptor::MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_MCALabelSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2230,6 +2624,7 @@ MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
 {
+  InterchangeObject::Copy(rhs);
   MCALabelDictionaryID = rhs.MCALabelDictionaryID;
   MCALinkID = rhs.MCALinkID;
   MCATagSymbol = rhs.MCATagSymbol;
@@ -2261,8 +2656,6 @@ MCALabelSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_MCALabelSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2270,8 +2663,6 @@ MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_MCALabelSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2279,6 +2670,22 @@ MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // AudioChannelLabelSubDescriptor
 
 //
+
+AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
+}
+
+AudioChannelLabelSubDescriptor::AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_AudioChannelLabelSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2302,6 +2709,7 @@ AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
 {
+  MCALabelSubDescriptor::Copy(rhs);
   SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
 }
 
@@ -2323,8 +2731,6 @@ AudioChannelLabelSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_AudioChannelLabelSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2332,8 +2738,6 @@ AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_AudioChannelLabelSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2341,6 +2745,22 @@ AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // SoundfieldGroupLabelSubDescriptor
 
 //
+
+SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
+}
+
+SoundfieldGroupLabelSubDescriptor::SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2364,6 +2784,7 @@ SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
 {
+  MCALabelSubDescriptor::Copy(rhs);
   GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
 }
 
@@ -2386,8 +2807,6 @@ SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_SoundfieldGroupLabelSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2395,8 +2814,6 @@ SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_SoundfieldGroupLabelSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -2404,6 +2821,22 @@ SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 // GroupOfSoundfieldGroupsLabelSubDescriptor
 
 //
+
+GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
+}
+
+GroupOfSoundfieldGroupsLabelSubDescriptor::GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor);
+  Copy(rhs);
+}
+
+
+//
 ASDCP::Result_t
 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
 {
@@ -2425,6 +2858,7 @@ GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 void
 GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
 {
+  MCALabelSubDescriptor::Copy(rhs);
 }
 
 //
@@ -2444,8 +2878,6 @@ GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -2453,8 +2885,6 @@ GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_
 ASDCP::Result_t
 GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  assert(m_Dict);
-  m_Typeinfo = &(m_Dict->Type(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
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
diff --git a/src/PCMParserList.cpp b/src/PCMParserList.cpp
index 5a6a9c9..f97b66e 100755
--- a/src/PCMParserList.cpp
+++ b/src/PCMParserList.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2009, John Hurst
+Copyright (c) 2004-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -48,7 +48,7 @@ ASDCP::ParserInstance::~ParserInstance()
 
 // PCM::CalcSampleSize(ADesc);
 Result_t
-ASDCP::ParserInstance::OpenRead(const char* filename, Rational& PictureRate)
+ASDCP::ParserInstance::OpenRead(const char* filename, const Rational& PictureRate)
 {
   ASDCP_TEST_NULL_STR(filename);
 
@@ -108,21 +108,32 @@ ASDCP::PCMParserList::~PCMParserList()
     }
 }
 
-
 //
 Result_t
-ASDCP::PCMParserList::OpenRead(ui32_t argc, const char** argv, Rational& PictureRate)
+ASDCP::PCMParserList::OpenRead(ui32_t argc, const char** argv, const Rational& PictureRate)
 {
   ASDCP_TEST_NULL_STR(argv);
+  PathList_t TmpFileList;
+
+  for ( ui32_t i = 0; i < argc; ++i )
+    TmpFileList.push_back(argv[i]);
+
+  return OpenRead(TmpFileList, PictureRate);
+}
+
+//
+Result_t
+ASDCP::PCMParserList::OpenRead(const Kumu::PathList_t& argv, const Rational& PictureRate)
+{
   Result_t result = RESULT_OK;
   PathList_t::iterator fi;
-  PathList_t TmpFileList;
+  Kumu::PathList_t file_list;
 
-  if ( argc == 1 && PathIsDirectory(argv[0]) )
+  if ( argv.size() == 1 && PathIsDirectory(argv.front()) )
     {
       DirScanner Dir;
       char name_buf[MaxFilePath];
-      result = Dir.Open(argv[0]);
+      result = Dir.Open(argv.front().c_str());
 
       if ( KM_SUCCESS(result) )
 	result = Dir.GetNext(name_buf);
@@ -131,8 +142,8 @@ ASDCP::PCMParserList::OpenRead(ui32_t argc, const char** argv, Rational& Picture
 	{
 	  if ( name_buf[0] != '.' ) // no hidden files
 	    {
-	      std::string tmp_path = std::string(argv[0]) + "/" + name_buf;
-	      TmpFileList.push_back(tmp_path);
+	      std::string tmp_path = argv.front() + "/" + name_buf;
+	      file_list.push_back(tmp_path);
 	    }
 
 	  result = Dir.GetNext(name_buf);
@@ -141,23 +152,22 @@ ASDCP::PCMParserList::OpenRead(ui32_t argc, const char** argv, Rational& Picture
       if ( result == RESULT_ENDOFFILE )
 	{
 	  result = RESULT_OK;
-	  TmpFileList.sort();
+	  file_list.sort();
 	}
     }
   else
     {
-      for ( ui32_t i = 0; i < argc; ++i )
-	TmpFileList.push_back(argv[i]);
+      file_list = argv;
     }
 
-  for ( fi = TmpFileList.begin(); KM_SUCCESS(result) && fi != TmpFileList.end(); fi++ )
+  for ( fi = file_list.begin(); KM_SUCCESS(result) && fi != file_list.end(); ++fi )
     {
       mem_ptr<ParserInstance> I = new ParserInstance;
       result = I->OpenRead(fi->c_str(), PictureRate);
 
       if ( ASDCP_SUCCESS(result) )
 	{
-	  if ( fi == TmpFileList.begin() )
+	  if ( fi == file_list.begin() )
 	    {
 	      m_ADesc = I->ADesc;
 	    }
diff --git a/src/PCMParserList.h b/src/PCMParserList.h
index 718870c..80c1d52 100755
--- a/src/PCMParserList.h
+++ b/src/PCMParserList.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2009, John Hurst
+Copyright (c) 2004-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef _PCMPARSERLIST_H_
 #define _PCMPARSERLIST_H_
 
+#include <KM_fileio.h>
 #include <AS_DCP.h>
 #include <vector>
 
@@ -53,7 +54,7 @@ namespace ASDCP
       ParserInstance();
       virtual ~ParserInstance();
 
-      Result_t OpenRead(const char* filename, Rational& PictureRate);
+      Result_t OpenRead(const char* filename, const Rational& PictureRate);
       Result_t PutSample(byte_t* p);
       Result_t ReadFrame();
       inline ui32_t SampleSize()  { return m_SampleSize; }
@@ -72,7 +73,8 @@ namespace ASDCP
       PCMParserList();
       virtual ~PCMParserList();
 
-      Result_t OpenRead(ui32_t argc, const char** argv, Rational& PictureRate);
+      Result_t OpenRead(ui32_t argc, const char** argv, const Rational& PictureRate);
+      Result_t OpenRead(const Kumu::PathList_t& argv, const Rational& PictureRate);
       Result_t FillAudioDescriptor(PCM::AudioDescriptor& ADesc) const;
       Result_t Reset();
       Result_t ReadFrame(PCM::FrameBuffer& OutFB);
diff --git a/src/asdcp-info.cpp b/src/asdcp-info.cpp
new file mode 100755
index 0000000..13c5a20
--- /dev/null
+++ b/src/asdcp-info.cpp
@@ -0,0 +1,428 @@
+/*
+Copyright (c) 2003-2012, John Hurst
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*! \file    asdcp-info.cpp
+    \version $Id$       
+    \brief   AS-DCP file metadata utility
+
+  This program provides metadata information about an AS-DCP file.
+
+  For more information about asdcplib, please refer to the header file AS_DCP.h
+*/
+
+#include <KM_fileio.h>
+#include <AS_DCP.h>
+#include <MXF.h>
+#include <Metadata.h>
+#include <openssl/sha.h>
+
+using namespace Kumu;
+using namespace ASDCP;
+
+const ui32_t FRAME_BUFFER_SIZE = 4 * Kumu::Megabyte;
+
+//------------------------------------------------------------------------------------------
+//
+// command line option parser class
+
+static const char* PROGRAM_NAME = "asdcp-info";  // program name for messages
+
+
+// Increment the iterator, test for an additional non-option command line argument.
+// Causes the caller to return if there are no remaining arguments or if the next
+// argument begins with '-'.
+#define TEST_EXTRA_ARG(i,c)						\
+  if ( ++i >= argc || argv[(i)][0] == '-' ) {				\
+    fprintf(stderr, "Argument not found for option -%c.\n", (c));	\
+    return;								\
+  }
+
+//
+void
+banner(FILE* stream = stdout)
+{
+  fprintf(stream, "\n\
+%s (asdcplib %s)\n\n\
+Copyright (c) 2003-2012 John Hurst\n\n\
+asdcplib may be copied only under the terms of the license found at\n\
+the top of every file in the asdcplib distribution kit.\n\n\
+Specify the -h (help) option for further information about %s\n\n",
+	  PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME);
+}
+
+//
+void
+usage(FILE* stream = stdout)
+{
+  fprintf(stream, "\
+USAGE:%s [-h|-help] [-V]\n\
+\n\
+       %s [-3] [-H] [-n] <input-file>+\n\
+\n\
+Options:\n\
+  -3                - Force stereoscopic interpretation of a JP2K file\n\
+  -h | -help        - Show help\n\
+  -H                - Show MXF header metadata\n\
+  -n                - Show index\n\
+  -V                - Show version information\n\
+\n\
+  NOTES: o There is no option grouping, all options must be distinct arguments.\n\
+         o All option arguments must be separated from the option by whitespace.\n\n",
+	  PROGRAM_NAME, PROGRAM_NAME);
+
+}
+
+//
+class CommandOptions
+{
+  CommandOptions();
+
+public:
+  bool   error_flag;     // true if the given options are in error or not complete
+  bool   version_flag;   // true if the version display option was selected
+  bool   help_flag;      // true if the help display option was selected
+  PathList_t filenames;  // list of filenames to be processed
+  bool   showindex_flag; // true if index is to be displayed
+  bool   showheader_flag; // true if MXF file header is to be displayed
+  bool   stereo_image_flag; // if true, expect stereoscopic JP2K input (left eye first)
+
+  //
+  CommandOptions(int argc, const char** argv) :
+    error_flag(true), version_flag(false), help_flag(false),
+    showindex_flag(), showheader_flag(), stereo_image_flag(false)
+  {
+    for ( int i = 1; i < argc; ++i )
+      {
+
+	if ( (strcmp( argv[i], "-help") == 0) )
+	  {
+	    help_flag = true;
+	    continue;
+	  }
+         
+	if ( argv[i][0] == '-'
+	     && ( isalpha(argv[i][1]) || isdigit(argv[i][1]) )
+	     && argv[i][2] == 0 )
+	  {
+	    switch ( argv[i][1] )
+	      {
+	      case '3': stereo_image_flag = true; break;
+	      case 'H': showheader_flag = true; break;
+	      case 'h': help_flag = true; break;
+	      case 'n': showindex_flag = true; break;
+	      case 'V': version_flag = true; break;
+
+	      default:
+		fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
+		return;
+	      }
+	  }
+	else
+	  {
+	    if ( argv[i][0] != '-' )
+	      {
+		filenames.push_back(argv[i]);
+	      }
+	    else
+	      {
+		fprintf(stderr, "Unrecognized argument: %s\n", argv[i]);
+		return;
+	      }
+	  }
+      }
+
+    if ( help_flag || version_flag )
+      return;
+    
+    if ( filenames.empty() )
+      {
+	fputs("Option requires at least one filename argument.\n", stderr);
+	return;
+      }
+
+    error_flag = false;
+  }
+};
+
+//------------------------------------------------------------------------------------------
+//
+
+//
+// These classes wrap the irregular names in the asdcplib API
+// so that I can use a template to simplify the implementation
+// of show_file_info()
+
+class MyVideoDescriptor : public MPEG2::VideoDescriptor
+{
+ public:
+  void FillDescriptor(MPEG2::MXFReader& Reader) {
+    Reader.FillVideoDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    MPEG2::VideoDescriptorDump(*this, stream);
+  }
+};
+
+class MyPictureDescriptor : public JP2K::PictureDescriptor
+{
+ public:
+  void FillDescriptor(JP2K::MXFReader& Reader) {
+    Reader.FillPictureDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    JP2K::PictureDescriptorDump(*this, stream);
+  }
+};
+
+class MyStereoPictureDescriptor : public JP2K::PictureDescriptor
+{
+ public:
+  void FillDescriptor(JP2K::MXFSReader& Reader) {
+    Reader.FillPictureDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    JP2K::PictureDescriptorDump(*this, stream);
+  }
+};
+
+class MyAudioDescriptor : public PCM::AudioDescriptor
+{
+ public:
+  void FillDescriptor(PCM::MXFReader& Reader) {
+    Reader.FillAudioDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    PCM::AudioDescriptorDump(*this, stream);
+  }
+};
+
+class MyTextDescriptor : public TimedText::TimedTextDescriptor
+{
+ public:
+  void FillDescriptor(TimedText::MXFReader& Reader) {
+    Reader.FillTimedTextDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    TimedText::DescriptorDump(*this, stream);
+  }
+};
+
+// MSVC didn't like the function template, so now it's a static class method
+template<class ReaderT, class DescriptorT>
+class FileInfoWrapper
+{
+public:
+  static Result_t
+  file_info(CommandOptions& Options, const char* type_string, FILE* stream = 0)
+  {
+    assert(type_string);
+    if ( stream == 0 )
+      stream = stdout;
+
+    Result_t result = RESULT_OK;
+    ReaderT     Reader;
+    result = Reader.OpenRead(Options.filenames.front().c_str());
+
+    if ( ASDCP_SUCCESS(result) )
+      {
+	fprintf(stdout, "File essence type is %s.\n", type_string);
+
+	if ( Options.showheader_flag )
+	  Reader.DumpHeaderMetadata(stream);
+
+	WriterInfo WI;
+	Reader.FillWriterInfo(WI);
+	WriterInfoDump(WI, stream);
+
+	DescriptorT Desc;
+	Desc.FillDescriptor(Reader);
+	Desc.Dump(stream);
+
+	if ( Options.showindex_flag )
+	  Reader.DumpIndex(stream);
+      }
+    else if ( result == RESULT_FORMAT && Options.showheader_flag )
+      {
+	Reader.DumpHeaderMetadata(stream);
+      }
+
+    return result;
+  }
+};
+
+// Read header metadata from an ASDCP file
+//
+Result_t
+show_file_info(CommandOptions& Options)
+{
+  EssenceType_t EssenceType;
+  Result_t result = ASDCP::EssenceType(Options.filenames.front().c_str(), EssenceType);
+
+  if ( ASDCP_FAILURE(result) )
+    return result;
+
+  if ( EssenceType == ESS_MPEG2_VES )
+    {
+      result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
+    }
+  else if ( EssenceType == ESS_PCM_24b_48k || EssenceType == ESS_PCM_24b_96k )
+    {
+      result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  const Dictionary* Dict = &DefaultCompositeDict();
+	  PCM::MXFReader Reader;
+	  MXF::OPAtomHeader OPAtomHeader(Dict);
+	  MXF::WaveAudioDescriptor *descriptor = 0;
+
+	  result = Reader.OpenRead(Options.filenames.front().c_str());
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Reader.OPAtomHeader().GetMDObjectByType(Dict->ul(MDD_WaveAudioDescriptor), reinterpret_cast<MXF::InterchangeObject**>(&descriptor));
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      char buf[64];
+	      fprintf(stdout, " ChannelAssignment: %s\n", descriptor->ChannelAssignment.EncodeString(buf, 64));
+	    }
+	}
+    }
+  else if ( EssenceType == ESS_JPEG_2000 )
+    {
+      if ( Options.stereo_image_flag )
+	{
+	  result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+				   MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+	}
+      else
+	{
+	  result = FileInfoWrapper<ASDCP::JP2K::MXFReader,
+				   MyPictureDescriptor>::file_info(Options, "JPEG 2000 pictures");
+	}
+    }
+  else if ( EssenceType == ESS_JPEG_2000_S )
+    {
+      result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+			       MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+    }
+  else if ( EssenceType == ESS_TIMED_TEXT )
+    {
+      result = FileInfoWrapper<ASDCP::TimedText::MXFReader, MyTextDescriptor>::file_info(Options, "Timed Text");
+    }
+  else
+    {
+      fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames.front().c_str());
+      Kumu::FileReader   Reader;
+      const Dictionary* Dict = &DefaultCompositeDict();
+      MXF::OPAtomHeader TestHeader(Dict);
+
+      result = Reader.OpenRead(Options.filenames.front().c_str());
+
+      if ( ASDCP_SUCCESS(result) )
+	result = TestHeader.InitFromFile(Reader); // test UL and OP
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  TestHeader.Partition::Dump(stdout);
+
+	  if ( MXF::Identification* ID = TestHeader.GetIdentification() )
+	    ID->Dump(stdout);
+	  else
+	    fputs("File contains no Identification object.\n", stdout);
+
+	  if ( MXF::SourcePackage* SP = TestHeader.GetSourcePackage() )
+	    SP->Dump(stdout);
+	  else
+	    fputs("File contains no SourcePackage object.\n", stdout);
+	}
+      else
+	{
+	  fputs("File is not MXF.\n", stdout);
+	}
+    }
+
+  return result;
+}
+
+//
+int
+main(int argc, const char** argv)
+{
+  Result_t result = RESULT_OK;
+  char     str_buf[64];
+  CommandOptions Options(argc, argv);
+
+  if ( Options.version_flag )
+    banner();
+
+  if ( Options.help_flag )
+    usage();
+
+  if ( Options.version_flag || Options.help_flag )
+    return 0;
+
+  if ( Options.error_flag )
+    {
+      fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
+      return 3;
+    }
+
+  while ( ! Options.filenames.empty() && ASDCP_SUCCESS(result) )
+    {
+      result = show_file_info(Options);
+      Options.filenames.pop_front();
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    {
+      fputs("Program stopped on error.\n", stderr);
+
+      if ( result == RESULT_SFORMAT )
+	{
+	  fputs("Use option '-3' to force stereoscopic mode.\n", stderr);
+	}
+      else if ( result != RESULT_FAIL )
+	{
+	  fputs(result, stderr);
+	  fputc('\n', stderr);
+	}
+
+      return 1;
+    }
+
+  return 0;
+}
+
+
+//
+// end asdcp-info.cpp
+//
diff --git a/src/asdcp-test.cpp b/src/asdcp-test.cpp
index 624c18b..384324d 100755
--- a/src/asdcp-test.cpp
+++ b/src/asdcp-test.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2003-2011, John Hurst
+Copyright (c) 2003-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -103,7 +103,7 @@ banner(FILE* stream = stdout)
 {
   fprintf(stream, "\n\
 %s (asdcplib %s)\n\n\
-Copyright (c) 2003-2011 John Hurst\n\n\
+Copyright (c) 2003-2012 John Hurst\n\n\
 asdcplib may be copied only under the terms of the license found at\n\
 the top of every file in the asdcplib distribution kit.\n\n\
 Specify the -h (help) option for further information about %s\n\n",
@@ -132,8 +132,9 @@ USAGE: %s -c <output-file> [-3] [-a <uuid>] [-b <buffer-size>]\n\
 \n\
        %s -x <file-prefix> [-3] [-b <buffer-size>] [-d <duration>]\n\
        [-f <starting-frame>] [-m] [-p <frame-rate>] [-R] [-s <num>] [-S|-1]\n\
-       [-v] [-W] [-w] <input-file>\n\
-\n", PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
+       [-v] [-W] [-w] <input-file>\n\n",
+	  PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME,
+	  PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
 
   fprintf(stream, "\
 Major modes:\n\
@@ -1782,28 +1783,54 @@ show_file_info(CommandOptions& Options)
     return result;
 
   if ( EssenceType == ESS_MPEG2_VES )
-    result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
-
+    {
+      result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
+    }
   else if ( EssenceType == ESS_PCM_24b_48k || EssenceType == ESS_PCM_24b_96k )
-    result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
+    {
+      result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  const Dictionary* Dict = &DefaultCompositeDict();
+	  PCM::MXFReader Reader;
+	  MXF::OPAtomHeader OPAtomHeader(Dict);
+	  MXF::WaveAudioDescriptor *descriptor = 0;
 
+	  result = Reader.OpenRead(Options.filenames[0]);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Reader.OPAtomHeader().GetMDObjectByType(Dict->ul(MDD_WaveAudioDescriptor), reinterpret_cast<MXF::InterchangeObject**>(&descriptor));
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      char buf[64];
+	      fprintf(stdout, " ChannelAssignment: %s\n", descriptor->ChannelAssignment.EncodeString(buf, 64));
+	    }
+	}
+    }
   else if ( EssenceType == ESS_JPEG_2000 )
     {
       if ( Options.stereo_image_flag )
-	result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
-	MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
-
+	{
+	  result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+				   MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+	}
       else
-	result = FileInfoWrapper<ASDCP::JP2K::MXFReader,
-	MyPictureDescriptor>::file_info(Options, "JPEG 2000 pictures");
+	{
+	  result = FileInfoWrapper<ASDCP::JP2K::MXFReader,
+				   MyPictureDescriptor>::file_info(Options, "JPEG 2000 pictures");
+	}
     }
   else if ( EssenceType == ESS_JPEG_2000_S )
-    result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
-    MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
-
+    {
+      result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+			       MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+    }
   else if ( EssenceType == ESS_TIMED_TEXT )
-    result = FileInfoWrapper<ASDCP::TimedText::MXFReader, MyTextDescriptor>::file_info(Options, "Timed Text");
-
+    {
+      result = FileInfoWrapper<ASDCP::TimedText::MXFReader, MyTextDescriptor>::file_info(Options, "Timed Text");
+    }
   else
     {
       fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames[0]);
diff --git a/src/asdcp-unwrap.cpp b/src/asdcp-unwrap.cpp
new file mode 100755
index 0000000..55d291b
--- /dev/null
+++ b/src/asdcp-unwrap.cpp
@@ -0,0 +1,896 @@
+/*
+Copyright (c) 2003-2012, John Hurst
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*! \file    asdcp-unwrap.cpp
+    \version $Id$       
+    \brief   AS-DCP file manipulation utility
+
+  This program extracts picture, sound and text essence from AS-DCP files.
+
+  For more information about asdcplib, please refer to the header file AS_DCP.h
+*/
+
+#include <KM_fileio.h>
+#include <WavFileWriter.h>
+
+using namespace ASDCP;
+
+const ui32_t FRAME_BUFFER_SIZE = 4 * Kumu::Megabyte;
+
+//------------------------------------------------------------------------------------------
+//
+// command line option parser class
+
+static const char* PROGRAM_NAME = "asdcp-unwrap";  // program name for messages
+
+// Increment the iterator, test for an additional non-option command line argument.
+// Causes the caller to return if there are no remaining arguments or if the next
+// argument begins with '-'.
+#define TEST_EXTRA_ARG(i,c)						\
+  if ( ++i >= argc || argv[(i)][0] == '-' ) {				\
+    fprintf(stderr, "Argument not found for option -%c.\n", (c));	\
+    return;								\
+  }
+
+//
+void
+banner(FILE* stream = stdout)
+{
+  fprintf(stream, "\n\
+%s (asdcplib %s)\n\n\
+Copyright (c) 2003-2012 John Hurst\n\n\
+asdcplib may be copied only under the terms of the license found at\n\
+the top of every file in the asdcplib distribution kit.\n\n\
+Specify the -h (help) option for further information about %s\n\n",
+	  PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME);
+}
+
+//
+void
+usage(FILE* stream = stdout)
+{
+  fprintf(stream, "\
+USAGE: %s [-h|-help] [-V]\n\
+\n\
+       %s -G [-v] <input-file>\n\
+\n\
+       %s [-1|-2] [-3] [-b <buffer-size>] [-d <duration>]\n\
+       [-f <starting-frame>] [-m] [-p <frame-rate>] [-R] [-s <size>] [-v] [-W]\n\
+       [-w] <input-file> [<file-prefix>]\n\n",
+	  PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
+
+  fprintf(stream, "\
+Options:\n\
+  -1                - Split Wave essence to mono WAV files during extract.\n\
+                      Default is multichannel WAV\n\
+  -2                - Split Wave essence to stereo WAV files during extract.\n\
+                      Default is multichannel WAV\n\
+  -3                - Force stereoscopic interpretation of a JP2K file.\n\
+  -b <buffer-size>  - Specify size in bytes of picture frame buffer.\n\
+                      Defaults to 4,194,304 (4MB)\n\
+  -d <duration>     - Number of frames to process, default all\n\
+  -f <start-frame>  - Starting frame number, default 0\n\
+  -G                - Perform GOP start lookup test on MXF+Interop MPEG file\n\
+  -h | -help        - Show help\n\
+  -k <key-string>   - Use key for ciphertext operations\n\
+  -m                - verify HMAC values when reading\n\
+  -p <rate>         - fps of picture when wrapping PCM or JP2K:\n\
+                      Use one of [23|24|25|30|48|50|60], 24 is default\n\
+  -s <size>         - Number of bytes to dump to output when -v is given\n\
+  -V                - Show version information\n\
+  -v                - Verbose, prints informative messages to stderr\n\
+  -W                - Read input file only, do not write destination file\n\
+  -w <width>        - Width of numeric element in a series of frame file names\n\
+                      (default 6).\n\
+  -z                - Fail if j2c inputs have unequal parameters (default)\n\
+  -Z                - Ignore unequal parameters in j2c inputs\n\
+\n\
+  NOTES: o There is no option grouping, all options must be distinct arguments.\n\
+         o All option arguments must be separated from the option by whitespace.\n\
+         o An argument of \"23\" to the -p option will be interpreted\n\
+           as 24000/1001 fps.\n\n");
+}
+
+//
+enum MajorMode_t
+{
+  MMT_NONE,
+  MMT_EXTRACT,
+  MMT_GOP_START,
+};
+
+//
+class CommandOptions
+{
+  CommandOptions();
+
+public:
+  MajorMode_t mode;
+  bool   error_flag;     // true if the given options are in error or not complete
+  bool   key_flag;       // true if an encryption key was given
+  bool   read_hmac;      // true if HMAC values are to be validated
+  bool   split_wav;      // true if PCM is to be extracted to stereo WAV files
+  bool   mono_wav;       // true if PCM is to be extracted to mono WAV files
+  bool   verbose_flag;   // true if the verbose option was selected
+  ui32_t fb_dump_size;   // number of bytes of frame buffer to dump
+  bool   no_write_flag;  // true if no output files are to be written
+  bool   version_flag;   // true if the version display option was selected
+  bool   help_flag;      // true if the help display option was selected
+  bool   stereo_image_flag; // if true, expect stereoscopic JP2K input (left eye first)
+  ui32_t number_width;   // number of digits in a serialized filename (for JPEG extract)
+  ui32_t start_frame;    // frame number to begin processing
+  ui32_t duration;       // number of frames to be processed
+  bool   duration_flag;  // true if duration argument given
+  bool   j2c_pedantic;   // passed to JP2K::SequenceParser::OpenRead
+  ui32_t picture_rate;   // fps of picture when wrapping PCM
+  ui32_t fb_size;        // size of picture frame buffer
+  const char* file_prefix; // filename pre for files written by the extract mode
+  byte_t key_value[KeyLen];  // value of given encryption key (when key_flag is true)
+  byte_t key_id_value[UUIDlen];// value of given key ID (when key_id_flag is true)
+  PCM::ChannelFormat_t channel_fmt; // audio channel arrangement
+  const char* input_filename;
+  std::string prefix_buffer;
+
+  //
+  Rational PictureRate()
+  {
+    if ( picture_rate == 23 ) return EditRate_23_98;
+    if ( picture_rate == 24 ) return EditRate_24;
+    if ( picture_rate == 25 ) return EditRate_25;
+    if ( picture_rate == 30 ) return EditRate_30;
+    if ( picture_rate == 48 ) return EditRate_48;
+    if ( picture_rate == 50 ) return EditRate_50;
+    if ( picture_rate == 60 ) return EditRate_60;
+    if ( picture_rate == 96 ) return EditRate_96;
+    if ( picture_rate == 100 ) return EditRate_100;
+    if ( picture_rate == 120 ) return EditRate_120;
+    return EditRate_24;
+  }
+
+  //
+  CommandOptions(int argc, const char** argv) :
+    mode(MMT_EXTRACT), error_flag(true), key_flag(false), read_hmac(false), split_wav(false),
+    mono_wav(false), verbose_flag(false), fb_dump_size(0), no_write_flag(false),
+    version_flag(false), help_flag(false), stereo_image_flag(false), number_width(6),
+    start_frame(0), duration(0xffffffff), duration_flag(false), j2c_pedantic(true),
+    picture_rate(24), fb_size(FRAME_BUFFER_SIZE), file_prefix(0),
+    channel_fmt(PCM::CF_NONE), input_filename(0)
+  {
+    memset(key_value, 0, KeyLen);
+    memset(key_id_value, 0, UUIDlen);
+
+    for ( int i = 1; i < argc; ++i )
+      {
+
+	if ( (strcmp( argv[i], "-help") == 0) )
+	  {
+	    help_flag = true;
+	    continue;
+	  }
+         
+	if ( argv[i][0] == '-'
+	     && ( isalpha(argv[i][1]) || isdigit(argv[i][1]) )
+	     && argv[i][2] == 0 )
+	  {
+	    switch ( argv[i][1] )
+	      {
+	      case '1': mono_wav = true; break;
+	      case '2': split_wav = true; break;
+	      case '3': stereo_image_flag = true; break;
+
+	      case 'b':
+		TEST_EXTRA_ARG(i, 'b');
+		fb_size = abs(atoi(argv[i]));
+
+		if ( verbose_flag )
+		  fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+
+		break;
+
+	      case 'd':
+		TEST_EXTRA_ARG(i, 'd');
+		duration_flag = true;
+		duration = abs(atoi(argv[i]));
+		break;
+
+	      case 'f':
+		TEST_EXTRA_ARG(i, 'f');
+		start_frame = abs(atoi(argv[i]));
+		break;
+
+	      case 'G': mode = MMT_GOP_START; break;
+	      case 'h': help_flag = true; break;
+
+	      case 'm': read_hmac = true; break;
+
+	      case 'p':
+		TEST_EXTRA_ARG(i, 'p');
+		picture_rate = abs(atoi(argv[i]));
+		break;
+
+	      case 's':
+		TEST_EXTRA_ARG(i, 's');
+		fb_dump_size = abs(atoi(argv[i]));
+		break;
+
+	      case 'V': version_flag = true; break;
+	      case 'v': verbose_flag = true; break;
+	      case 'W': no_write_flag = true; break;
+
+	      case 'w':
+		TEST_EXTRA_ARG(i, 'w');
+		number_width = abs(atoi(argv[i]));
+		break;
+
+	      case 'Z': j2c_pedantic = false; break;
+	      case 'z': j2c_pedantic = true; break;
+
+	      default:
+		fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
+		return;
+	      }
+	  }
+	else
+	  {
+	    if ( argv[i][0] != '-' )
+	      {
+		if ( input_filename == 0 )
+		  {
+		    input_filename = argv[i];
+		  }
+		else if ( file_prefix == 0 )
+		  {
+		    file_prefix = argv[i];
+		  }
+	      }
+	    else
+	      {
+		fprintf(stderr, "Unrecognized argument: %s\n", argv[i]);
+		return;
+	      }
+	  }
+      }
+
+    if ( help_flag || version_flag )
+      return;
+    
+    if ( (  mode == MMT_EXTRACT || mode == MMT_GOP_START ) && input_filename == 0 )
+      {
+	fputs("Option requires at least one filename argument.\n", stderr);
+	return;
+      }
+
+    if ( mode == MMT_EXTRACT  && file_prefix == 0 )
+      {
+	prefix_buffer = Kumu::PathSetExtension(input_filename, "") + "_";
+	file_prefix = prefix_buffer.c_str();
+      }
+
+    error_flag = false;
+  }
+};
+
+//------------------------------------------------------------------------------------------
+// MPEG2 essence
+
+// Read a plaintext MPEG2 Video Elementary Stream from a plaintext ASDCP file
+// Read a plaintext MPEG2 Video Elementary Stream from a ciphertext ASDCP file
+// Read a ciphertext MPEG2 Video Elementary Stream from a ciphertext ASDCP file
+//
+Result_t
+read_MPEG2_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  MPEG2::MXFReader   Reader;
+  MPEG2::FrameBuffer FrameBuffer(Options.fb_size);
+  Kumu::FileWriter   OutFile;
+  ui32_t             frame_count = 0;
+
+  Result_t result = Reader.OpenRead(Options.input_filename);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      MPEG2::VideoDescriptor VDesc;
+      Reader.FillVideoDescriptor(VDesc);
+      frame_count = VDesc.ContainerDuration;
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  MPEG2::VideoDescriptorDump(VDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      char filename[256];
+      snprintf(filename, 256, "%s.ves", Options.file_prefix);
+      result = OutFile.OpenWrite(filename);
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
+  if ( last_frame > frame_count )
+    last_frame = frame_count;
+
+  for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+    {
+      result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	  ui32_t write_count = 0;
+	  result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+	}
+    }
+
+  return result;
+}
+
+
+//
+Result_t
+gop_start_test(CommandOptions& Options)
+{
+  using namespace ASDCP::MPEG2;
+
+  MXFReader   Reader;
+  MPEG2::FrameBuffer FrameBuffer(Options.fb_size);
+  ui32_t      frame_count = 0;
+
+  Result_t result = Reader.OpenRead(Options.input_filename);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      MPEG2::VideoDescriptor VDesc;
+      Reader.FillVideoDescriptor(VDesc);
+      frame_count = VDesc.ContainerDuration;
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  MPEG2::VideoDescriptorDump(VDesc);
+	}
+    }
+
+  ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
+  if ( last_frame > frame_count )
+    last_frame = frame_count;
+
+  for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+    {
+      result = Reader.ReadFrameGOPStart(i, FrameBuffer);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	  if ( FrameBuffer.FrameType() != FRAME_I )
+	    fprintf(stderr, "Expecting an I frame, got %c\n", FrameTypeChar(FrameBuffer.FrameType()));
+
+	  fprintf(stderr, "Requested frame %u, got %u\n", i, FrameBuffer.FrameNumber());
+	}
+    }
+
+  return result;
+}
+
+//------------------------------------------------------------------------------------------
+// JPEG 2000 essence
+
+
+// Read one or more plaintext JPEG 2000 stereoscopic codestream pairs from a plaintext ASDCP file
+// Read one or more plaintext JPEG 2000 stereoscopic codestream pairs from a ciphertext ASDCP file
+// Read one or more ciphertext JPEG 2000 stereoscopic codestream pairs from a ciphertext ASDCP file
+Result_t
+read_JP2K_S_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  JP2K::MXFSReader    Reader;
+  JP2K::FrameBuffer  FrameBuffer(Options.fb_size);
+  ui32_t             frame_count = 0;
+
+  Result_t result = Reader.OpenRead(Options.input_filename);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      JP2K::PictureDescriptor PDesc;
+      Reader.FillPictureDescriptor(PDesc);
+
+      frame_count = PDesc.ContainerDuration;
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  JP2K::PictureDescriptorDump(PDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  const int filename_max = 1024;
+  char filename[filename_max];
+  ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
+  if ( last_frame > frame_count )
+    last_frame = frame_count;
+
+  char left_format[64];  char right_format[64];
+  snprintf(left_format,  64, "%%s%%0%duL.j2c", Options.number_width);
+  snprintf(right_format, 64, "%%s%%0%duR.j2c", Options.number_width);
+
+  for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+    {
+      result = Reader.ReadFrame(i, JP2K::SP_LEFT, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter OutFile;
+	  ui32_t write_count;
+	  snprintf(filename, filename_max, left_format, Options.file_prefix, i);
+	  result = OutFile.OpenWrite(filename);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Reader.ReadFrame(i, JP2K::SP_RIGHT, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter OutFile;
+	  ui32_t write_count;
+	  snprintf(filename, filename_max, right_format, Options.file_prefix, i);
+	  result = OutFile.OpenWrite(filename);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+	}
+    }
+
+  return result;
+}
+
+// Read one or more plaintext JPEG 2000 codestreams from a plaintext ASDCP file
+// Read one or more plaintext JPEG 2000 codestreams from a ciphertext ASDCP file
+// Read one or more ciphertext JPEG 2000 codestreams from a ciphertext ASDCP file
+//
+Result_t
+read_JP2K_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  JP2K::MXFReader    Reader;
+  JP2K::FrameBuffer  FrameBuffer(Options.fb_size);
+  ui32_t             frame_count = 0;
+
+  Result_t result = Reader.OpenRead(Options.input_filename);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      JP2K::PictureDescriptor PDesc;
+      Reader.FillPictureDescriptor(PDesc);
+
+      frame_count = PDesc.ContainerDuration;
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  JP2K::PictureDescriptorDump(PDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
+  if ( last_frame > frame_count )
+    last_frame = frame_count;
+
+  char name_format[64];
+  snprintf(name_format,  64, "%%s%%0%du.j2c", Options.number_width);
+
+  for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+    {
+      result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter OutFile;
+	  char filename[256];
+	  ui32_t write_count;
+	  snprintf(filename, 256, name_format, Options.file_prefix, i);
+	  result = OutFile.OpenWrite(filename);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+	}
+    }
+
+  return result;
+}
+
+//------------------------------------------------------------------------------------------
+// PCM essence
+
+// Read one or more plaintext PCM audio streams from a plaintext ASDCP file
+// Read one or more plaintext PCM audio streams from a ciphertext ASDCP file
+// Read one or more ciphertext PCM audio streams from a ciphertext ASDCP file
+//
+Result_t
+read_PCM_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  PCM::MXFReader     Reader;
+  PCM::FrameBuffer   FrameBuffer;
+  WavFileWriter      OutWave;
+  PCM::AudioDescriptor ADesc;
+  ui32_t last_frame = 0;
+
+  Result_t result = Reader.OpenRead(Options.input_filename);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Reader.FillAudioDescriptor(ADesc);
+
+      if ( ADesc.EditRate != EditRate_23_98
+	   && ADesc.EditRate != EditRate_24
+	   && ADesc.EditRate != EditRate_25
+	   && ADesc.EditRate != EditRate_30
+	   && ADesc.EditRate != EditRate_48
+	   && ADesc.EditRate != EditRate_50
+	   && ADesc.EditRate != EditRate_60 )
+	ADesc.EditRate = Options.PictureRate();
+
+      FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
+
+      if ( Options.verbose_flag )
+	PCM::AudioDescriptorDump(ADesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      last_frame = ADesc.ContainerDuration;
+
+      if ( Options.duration > 0 && Options.duration < last_frame )
+	last_frame = Options.duration;
+
+      if ( Options.start_frame > 0 )
+	{
+	  if ( Options.start_frame > ADesc.ContainerDuration )
+	    {
+	      fprintf(stderr, "Start value greater than file duration.\n");
+	      return RESULT_FAIL;
+	    }
+
+	  last_frame = Kumu::xmin(Options.start_frame + last_frame, ADesc.ContainerDuration);
+	}
+
+      ADesc.ContainerDuration = last_frame - Options.start_frame;
+      OutWave.OpenWrite(ADesc, Options.file_prefix,
+			( Options.split_wav ? WavFileWriter::ST_STEREO : 
+			  ( Options.mono_wav ? WavFileWriter::ST_MONO : WavFileWriter::ST_NONE ) ));
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+    {
+      result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	  result = OutWave.WriteFrame(FrameBuffer);
+	}
+    }
+
+  return result;
+}
+
+
+//------------------------------------------------------------------------------------------
+// TimedText essence
+
+// Read one or more timed text streams from a plaintext ASDCP file
+// Read one or more timed text streams from a ciphertext ASDCP file
+// Read one or more timed text streams from a ciphertext ASDCP file
+//
+Result_t
+read_timed_text_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  TimedText::MXFReader     Reader;
+  TimedText::FrameBuffer   FrameBuffer;
+  TimedText::TimedTextDescriptor TDesc;
+
+  Result_t result = Reader.OpenRead(Options.input_filename);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Reader.FillTimedTextDescriptor(TDesc);
+      FrameBuffer.Capacity(Options.fb_size);
+
+      if ( Options.verbose_flag )
+	TimedText::DescriptorDump(TDesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    return result;
+
+  std::string XMLDoc;
+  std::string out_path = Kumu::PathDirname(Options.file_prefix);
+  ui32_t write_count;
+  char buf[64];
+  TimedText::ResourceList_t::const_iterator ri;
+
+  result = Reader.ReadTimedTextResource(XMLDoc, Context, HMAC);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Kumu::FileWriter Writer;
+      result = Writer.OpenWrite(Options.file_prefix);
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.Write(reinterpret_cast<const byte_t*>(XMLDoc.c_str()), XMLDoc.size(), &write_count);
+    }
+
+  for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
+    {
+      result = Reader.ReadAncillaryResource(ri->ResourceID, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter Writer;
+	  result = Writer.OpenWrite(Kumu::PathJoin(out_path, Kumu::UUID(ri->ResourceID).EncodeHex(buf, 64)).c_str());
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	      result = Writer.Write(FrameBuffer.RoData(), FrameBuffer.Size(), &write_count);
+	    }
+	}
+    }
+
+  return result;
+}
+
+//
+int
+main(int argc, const char** argv)
+{
+  Result_t result = RESULT_OK;
+  char     str_buf[64];
+  CommandOptions Options(argc, argv);
+
+  if ( Options.version_flag )
+    banner();
+
+  if ( Options.help_flag )
+    usage();
+
+  if ( Options.version_flag || Options.help_flag )
+    return 0;
+
+  if ( Options.error_flag )
+    {
+      fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
+      return 3;
+    }
+
+  if ( Options.mode == MMT_GOP_START )
+    {
+      result = gop_start_test(Options);
+    }
+  else if ( Options.mode == MMT_EXTRACT )
+    {
+      EssenceType_t EssenceType;
+      result = ASDCP::EssenceType(Options.input_filename, EssenceType);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  switch ( EssenceType )
+	    {
+	    case ESS_MPEG2_VES:
+	      result = read_MPEG2_file(Options);
+	      break;
+
+	    case ESS_JPEG_2000:
+	      if ( Options.stereo_image_flag )
+		result = read_JP2K_S_file(Options);
+	      else
+		result = read_JP2K_file(Options);
+	      break;
+
+	    case ESS_JPEG_2000_S:
+	      result = read_JP2K_S_file(Options);
+	      break;
+
+	    case ESS_PCM_24b_48k:
+	    case ESS_PCM_24b_96k:
+	      result = read_PCM_file(Options);
+	      break;
+
+	    case ESS_TIMED_TEXT:
+	      result = read_timed_text_file(Options);
+	      break;
+
+	    default:
+	      fprintf(stderr, "%s: Unknown file type, not ASDCP essence.\n", Options.input_filename);
+	      return 5;
+	    }
+	}
+    }
+  else
+    {
+      fprintf(stderr, "Unhandled mode: %d.\n", Options.mode);
+      return 6;
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    {
+      fputs("Program stopped on error.\n", stderr);
+
+      if ( result == RESULT_SFORMAT )
+	{
+	  fputs("Use option '-3' to force stereoscopic mode.\n", stderr);
+	}
+      else if ( result != RESULT_FAIL )
+	{
+	  fputs(result, stderr);
+	  fputc('\n', stderr);
+	}
+
+      return 1;
+    }
+
+  return 0;
+}
+
+
+//
+// end asdcp-unwrap.cpp
+//
diff --git a/src/asdcp-util.cpp b/src/asdcp-util.cpp
new file mode 100755
index 0000000..be070ff
--- /dev/null
+++ b/src/asdcp-util.cpp
@@ -0,0 +1,294 @@
+/*
+Copyright (c) 2003-2012, John Hurst
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*! \file    asdcp-util.cpp
+    \version $Id$       
+    \brief   Utility functions for working with AS-DCP files
+
+  This program provides utility features commonly useful in DCP workflows.
+
+  For more information about asdcplib, please refer to the header file AS_DCP.h
+*/
+
+#include <KM_fileio.h>
+#include <KM_prng.h>
+#include <AS_DCP.h>
+#include <openssl/sha.h>
+
+using namespace Kumu;
+
+
+//------------------------------------------------------------------------------------------
+//
+// command line option parser class
+
+static const char* PROGRAM_NAME = "asdcp-util";  // program name for messages
+
+// Increment the iterator, test for an additional non-option command line argument.
+// Causes the caller to return if there are no remaining arguments or if the next
+// argument begins with '-'.
+#define TEST_EXTRA_ARG(i,c)						\
+  if ( ++i >= argc || argv[(i)][0] == '-' ) {				\
+    fprintf(stderr, "Argument not found for option -%c.\n", (c));	\
+    return;								\
+  }
+
+//
+void
+banner(FILE* stream = stdout)
+{
+  fprintf(stream, "\n\
+%s (asdcplib %s)\n\n\
+Copyright (c) 2003-2012 John Hurst\n\n\
+asdcplib may be copied only under the terms of the license found at\n\
+the top of every file in the asdcplib distribution kit.\n\n\
+Specify the -h (help) option for further information about %s\n\n",
+	  PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME);
+}
+
+//
+void
+usage(FILE* stream = stdout)
+{
+  fprintf(stream, "\
+USAGE: %s [-h|-help] [-V]\n\
+\n\
+       %s -d <input-file>\n\
+\n\
+       %s -g | -u\n\
+\n\
+       %s -u\n\n",
+	  PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
+
+  fprintf(stream, "\
+Major modes:\n\
+  -d                - Calculate message digest of input file\n\
+  -g                - Generate a random 16 byte value to stdout\n\
+  -h | -help        - Show help\n\
+  -u                - Generate a random UUID value to stdout\n\
+  -V                - Show version information\n\
+\n\
+  NOTES: o There is no option grouping, all options must be distinct arguments.\n\
+         o All option arguments must be separated from the option by whitespace.\n\n");
+}
+
+//
+enum MajorMode_t
+{
+  MMT_NONE,
+  MMT_GEN_ID,
+  MMT_GEN_KEY,
+  MMT_DIGEST,
+};
+
+//
+class CommandOptions
+{
+  CommandOptions();
+
+public:
+  MajorMode_t mode;
+  bool   error_flag;     // true if the given options are in error or not complete
+  bool   version_flag;   // true if the version display option was selected
+  bool   help_flag;      // true if the help display option was selected
+  PathList_t filenames;  // list of filenames to be processed
+
+  //
+  CommandOptions(int argc, const char** argv) :
+    mode(MMT_NONE), error_flag(true), version_flag(false), help_flag(false)
+  {
+    for ( int i = 1; i < argc; ++i )
+      {
+
+	if ( (strcmp( argv[i], "-help") == 0) )
+	  {
+	    help_flag = true;
+	    continue;
+	  }
+         
+	if ( argv[i][0] == '-'
+	     && ( isalpha(argv[i][1]) || isdigit(argv[i][1]) )
+	     && argv[i][2] == 0 )
+	  {
+	    switch ( argv[i][1] )
+	      {
+	      case 'd': mode = MMT_DIGEST; break;
+	      case 'g': mode = MMT_GEN_KEY; break;
+	      case 'h': help_flag = true; break;
+	      case 'u':	mode = MMT_GEN_ID; break;
+	      case 'V': version_flag = true; break;
+
+	      default:
+		fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
+		return;
+	      }
+	  }
+	else
+	  {
+	    if ( argv[i][0] != '-' )
+	      {
+		filenames.push_back(argv[i]);
+	      }
+	    else
+	      {
+		fprintf(stderr, "Unrecognized argument: %s\n", argv[i]);
+		return;
+	      }
+	  }
+      }
+
+    if ( help_flag || version_flag )
+      return;
+    
+    if ( ( mode == MMT_DIGEST ) && filenames.empty() )
+      {
+	fputs("Option requires at least one filename argument.\n", stderr);
+	return;
+      }
+
+    if ( mode == MMT_NONE && ! help_flag && ! version_flag )
+      {
+	fputs("No operation selected (use one of -[dgu] or -h for help).\n", stderr);
+	return;
+      }
+
+    error_flag = false;
+  }
+};
+
+//
+Result_t
+digest_file(const std::string& filename)
+{
+  FileReader Reader;
+  SHA_CTX Ctx;
+  SHA1_Init(&Ctx);
+  ByteString Buf(8192);
+
+  Result_t result = Reader.OpenRead(filename.c_str());
+
+  while ( ASDCP_SUCCESS(result) )
+    {
+      ui32_t read_count = 0;
+      result = Reader.Read(Buf.Data(), Buf.Capacity(), &read_count);
+
+      if ( result == RESULT_ENDOFFILE )
+	{
+	  result = RESULT_OK;
+	  break;
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	SHA1_Update(&Ctx, Buf.Data(), read_count);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      const ui32_t sha_len = 20;
+      byte_t bin_buf[sha_len];
+      char sha_buf[64];
+      SHA1_Final(bin_buf, &Ctx);
+
+      fprintf(stdout, "%s %s\n",
+	      base64encode(bin_buf, sha_len, sha_buf, 64),
+	      filename.c_str());
+    }
+
+  return result;
+}
+
+//
+int
+main(int argc, const char** argv)
+{
+  Result_t result = RESULT_OK;
+  char     str_buf[64];
+  CommandOptions Options(argc, argv);
+
+  if ( Options.version_flag )
+    banner();
+
+  if ( Options.help_flag )
+    usage();
+
+  if ( Options.version_flag || Options.help_flag )
+    return 0;
+
+  if ( Options.error_flag )
+    {
+      fprintf(stderr, "There was a problem. Type %s -h for help.\n",
+	      PROGRAM_NAME);
+      return 3;
+    }
+
+  if ( Options.mode == MMT_GEN_KEY )
+    {
+      Kumu::FortunaRNG RNG;
+      byte_t bin_buf[ASDCP::KeyLen];
+
+      RNG.FillRandom(bin_buf, ASDCP::KeyLen);
+      printf("%s\n", Kumu::bin2hex(bin_buf, ASDCP::KeyLen, str_buf, 64));
+    }
+  else if ( Options.mode == MMT_GEN_ID )
+    {
+      UUID TmpID;
+      Kumu::GenRandomValue(TmpID);
+      printf("%s\n", TmpID.EncodeHex(str_buf, 64));
+    }
+  else if ( Options.mode == MMT_DIGEST )
+    {
+      PathList_t::iterator i;
+
+      for ( i = Options.filenames.begin();
+	    i != Options.filenames.end() && ASDCP_SUCCESS(result); ++i )
+	result = digest_file(*i);
+    }
+  else
+    {
+      fprintf(stderr, "Unhandled mode: %d.\n", Options.mode);
+      return 6;
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    {
+      fputs("Program stopped on error.\n", stderr);
+
+      if ( result != RESULT_FAIL )
+	{
+	  fputs(result, stderr);
+	  fputc('\n', stderr);
+	}
+
+      return 1;
+    }
+
+  return 0;
+}
+
+
+//
+// end asdcp-util.cpp
+//
diff --git a/src/asdcp-wrap.cpp b/src/asdcp-wrap.cpp
new file mode 100755
index 0000000..916f37f
--- /dev/null
+++ b/src/asdcp-wrap.cpp
@@ -0,0 +1,1149 @@
+/*
+Copyright (c) 2003-2012, John Hurst
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*! \file    asdcp-wrap.cpp
+    \version $Id$       
+    \brief   AS-DCP file manipulation utility
+
+  This program wraps d-cinema essence (picture, sound or text) in t an AS-DCP
+  MXF file.
+
+  For more information about asdcplib, please refer to the header file AS_DCP.h
+
+  WARNING: While the asdcplib library attempts to provide a complete and secure
+  implementation of the cryptographic features of the AS-DCP file formats, this
+  unit test program is NOT secure and is therefore NOT SUITABLE FOR USE in a
+  production environment without some modification.
+
+  In particular, this program uses weak IV generation and externally generated
+  plaintext keys. These shortcomings exist because cryptographic-quality
+  random number generation and key management are outside the scope of the
+  asdcplib library. Developers using asdcplib for commercial implementations
+  claiming SMPTE conformance are expected to provide proper implementations of
+  these features.
+*/
+
+#include <KM_fileio.h>
+#include <KM_prng.h>
+#include <AS_DCP.h>
+#include <PCMParserList.h>
+#include <Metadata.h>
+
+using namespace ASDCP;
+
+const ui32_t FRAME_BUFFER_SIZE = 4 * Kumu::Megabyte;
+
+//------------------------------------------------------------------------------------------
+//
+// command line option parser class
+
+static const char* PROGRAM_NAME = "asdcp-wrap";  // program name for messages
+
+// local program identification info written to file headers
+class MyInfo : public WriterInfo
+{
+public:
+  MyInfo()
+  {
+      static byte_t default_ProductUUID_Data[UUIDlen] =
+      { 0x7d, 0x83, 0x6e, 0x16, 0x37, 0xc7, 0x4c, 0x22,
+	0xb2, 0xe0, 0x46, 0xa7, 0x17, 0xe8, 0x4f, 0x42 };
+      
+      memcpy(ProductUUID, default_ProductUUID_Data, UUIDlen);
+      CompanyName = "WidgetCo";
+      ProductName = "asdcp-wrap";
+      ProductVersion = ASDCP::Version();
+  }
+} s_MyInfo;
+
+
+
+// Increment the iterator, test for an additional non-option command line argument.
+// Causes the caller to return if there are no remaining arguments or if the next
+// argument begins with '-'.
+#define TEST_EXTRA_ARG(i,c)						\
+  if ( ++i >= argc || argv[(i)][0] == '-' ) {				\
+    fprintf(stderr, "Argument not found for option -%c.\n", (c));	\
+    return;								\
+  }
+
+//
+void
+banner(FILE* stream = stdout)
+{
+  fprintf(stream, "\n\
+%s (asdcplib %s)\n\n\
+Copyright (c) 2003-2012 John Hurst\n\n\
+asdcplib may be copied only under the terms of the license found at\n\
+the top of every file in the asdcplib distribution kit.\n\n\
+Specify the -h (help) option for further information about %s\n\n",
+	  PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME);
+}
+
+//
+void
+usage(FILE* stream = stdout)
+{
+  fprintf(stream, "\
+USAGE: %s [-h|-help] [-V]\n\
+\n\
+       %s [-3] [-a <uuid>] [-b <buffer-size>] [-C <UL>] [-d <duration>] [-e|-E] [-f <start-frame>] [-j <key-id-string>] [-k <key-string>] [-l <label>] [-L] [-M] [-p <frame-rate>] [-s <num>] [-v] [-W] [-z|-Z] <input-file>+ <output-file>\n\n",
+	  PROGRAM_NAME, PROGRAM_NAME);
+
+  fprintf(stream, "\
+Options:\n\
+  -3                - With -c, create a stereoscopic image file. Expects two\n\
+                      directories of JP2K codestreams (directories must have\n\
+                      an equal number of frames; left eye is first).\n\
+                    - With -x, force stereoscopic interpretation of a JP2K\n\
+                      track file.\n\
+  -C <UL>           - Set ChannelAssignment UL value\n\
+  -h | -help        - Show help\n\
+  -V                - Show version information\n\
+  -e                - Encrypt MPEG or JP2K headers (default)\n\
+  -E                - Do not encrypt MPEG or JP2K headers\n\
+  -j <key-id-str>   - Write key ID instead of creating a random value\n\
+  -k <key-string>   - Use key for ciphertext operations\n\
+  -M                - Do not create HMAC values when writing\n\
+  -a <UUID>         - Specify the Asset ID of a file (with -c)\n\
+  -b <buffer-size>  - Specify size in bytes of picture frame buffer.\n\
+                      Defaults to 4,194,304 (4MB)\n\
+  -d <duration>     - Number of frames to process, default all\n\
+  -f <start-frame>  - Starting frame number, default 0\n\
+  -l <label>        - Use given channel format label when writing MXF sound\n\
+                      files. SMPTE 429-2 labels: '5.1', '6.1', '7.1', '7.1DS', 'WTF'.\n\
+                      Default is no label (valid for Interop only).\n\
+  -L                - Write SMPTE UL values instead of MXF Interop\n\
+  -p <rate>         - fps of picture when wrapping PCM or JP2K:\n\
+                      Use one of [23|24|25|30|48|50|60], 24 is default\n\
+  -v                - Verbose, prints informative messages to stderr\n\
+  -W                - Read input file only, do not write source file\n\
+  -z                - Fail if j2c inputs have unequal parameters (default)\n\
+  -Z                - Ignore unequal parameters in j2c inputs\n\
+\n\
+  NOTES: o There is no option grouping, all options must be distinct arguments.\n\
+         o All option arguments must be separated from the option by whitespace.\n\
+         o An argument of \"23\" to the -p option will be interpreted\n\
+           as 24000/1001 fps.\n\
+\n");
+}
+
+//
+PCM::ChannelFormat_t
+decode_channel_fmt(const std::string& label_name)
+{
+  if ( label_name == "5.1" )
+    return PCM::CF_CFG_1;
+
+  else if ( label_name == "6.1" )
+    return PCM::CF_CFG_2;
+  
+  else if ( label_name == "7.1" )
+    return PCM::CF_CFG_3;
+
+  else if ( label_name == "WTF" )
+    return PCM::CF_CFG_4;
+
+  else if ( label_name == "7.1DS" )
+    return PCM::CF_CFG_5;
+
+  fprintf(stderr, "Error decoding channel format string: %s\n", label_name.c_str());
+  fprintf(stderr, "Expecting '5.1', '6.1', '7.1', '7.1DS' or 'WTF'\n");
+  return PCM::CF_NONE;
+}
+
+//
+//
+class CommandOptions
+{
+  CommandOptions();
+
+public:
+  bool   error_flag;     // true if the given options are in error or not complete
+  bool   key_flag;       // true if an encryption key was given
+  bool   asset_id_flag;  // true if an asset ID was given
+  bool   encrypt_header_flag; // true if mpeg headers are to be encrypted
+  bool   write_hmac;     // true if HMAC values are to be generated and written
+  ///  bool   read_hmac;      // true if HMAC values are to be validated
+  ///  bool   split_wav;      // true if PCM is to be extracted to stereo WAV files
+  ///  bool   mono_wav;       // true if PCM is to be extracted to mono WAV files
+  bool   verbose_flag;   // true if the verbose option was selected
+  ui32_t fb_dump_size;   // number of bytes of frame buffer to dump
+  ///  bool   showindex_flag; // true if index is to be displayed
+  ///  bool   showheader_flag; // true if MXF file header is to be displayed
+  bool   no_write_flag;  // true if no output files are to be written
+  bool   version_flag;   // true if the version display option was selected
+  bool   help_flag;      // true if the help display option was selected
+  bool   stereo_image_flag; // if true, expect stereoscopic JP2K input (left eye first)
+  ///  ui32_t number_width;   // number of digits in a serialized filename (for JPEG extract)
+  ui32_t start_frame;    // frame number to begin processing
+  ui32_t duration;       // number of frames to be processed
+  bool   use_smpte_labels; // if true, SMPTE UL values will be written instead of MXF Interop values
+  bool   j2c_pedantic;   // passed to JP2K::SequenceParser::OpenRead
+  ui32_t picture_rate;   // fps of picture when wrapping PCM
+  ui32_t fb_size;        // size of picture frame buffer
+  byte_t key_value[KeyLen];  // value of given encryption key (when key_flag is true)
+  bool   key_id_flag;    // true if a key ID was given
+  byte_t key_id_value[UUIDlen];// value of given key ID (when key_id_flag is true)
+  byte_t asset_id_value[UUIDlen];// value of asset ID (when asset_id_flag is true)
+  PCM::ChannelFormat_t channel_fmt; // audio channel arrangement
+  std::string out_file; //
+  bool show_ul_values;    /// if true, dump the UL table before going tp work.
+  Kumu::PathList_t filenames;  // list of filenames to be processed
+  UL channel_assignment;
+
+  //
+  Rational PictureRate()
+  {
+    if ( picture_rate == 23 ) return EditRate_23_98;
+    if ( picture_rate == 24 ) return EditRate_24;
+    if ( picture_rate == 25 ) return EditRate_25;
+    if ( picture_rate == 30 ) return EditRate_30;
+    if ( picture_rate == 48 ) return EditRate_48;
+    if ( picture_rate == 50 ) return EditRate_50;
+    if ( picture_rate == 60 ) return EditRate_60;
+    if ( picture_rate == 96 ) return EditRate_96;
+    if ( picture_rate == 100 ) return EditRate_100;
+    if ( picture_rate == 120 ) return EditRate_120;
+    return EditRate_24;
+  }
+
+  //
+  const char* szPictureRate()
+  {
+    if ( picture_rate == 23 ) return "23.976";
+    if ( picture_rate == 24 ) return "24";
+    if ( picture_rate == 25 ) return "25";
+    if ( picture_rate == 30 ) return "30";
+    if ( picture_rate == 48 ) return "48";
+    if ( picture_rate == 50 ) return "50";
+    if ( picture_rate == 60 ) return "60";
+    if ( picture_rate == 96 ) return "96";
+    if ( picture_rate == 100 ) return "100";
+    if ( picture_rate == 120 ) return "120";
+    return "24";
+  }
+
+  //
+  CommandOptions(int argc, const char** argv) :
+    error_flag(true), key_flag(false), key_id_flag(false), asset_id_flag(false),
+    encrypt_header_flag(true), write_hmac(true),
+    verbose_flag(false), fb_dump_size(0),
+    no_write_flag(false), version_flag(false), help_flag(false), stereo_image_flag(false),
+    start_frame(0),
+    duration(0xffffffff), use_smpte_labels(false), j2c_pedantic(true),
+    fb_size(FRAME_BUFFER_SIZE),
+    channel_fmt(PCM::CF_NONE),
+    show_ul_values(false)
+  {
+    memset(key_value, 0, KeyLen);
+    memset(key_id_value, 0, UUIDlen);
+
+    for ( int i = 1; i < argc; i++ )
+      {
+
+	if ( (strcmp( argv[i], "-help") == 0) )
+	  {
+	    help_flag = true;
+	    continue;
+	  }
+         
+	if ( argv[i][0] == '-'
+	     && ( isalpha(argv[i][1]) || isdigit(argv[i][1]) )
+	     && argv[i][2] == 0 )
+	  {
+	    switch ( argv[i][1] )
+	      {
+	      case '3': stereo_image_flag = true; break;
+
+	      case 'a':
+		asset_id_flag = true;
+		TEST_EXTRA_ARG(i, 'a');
+		{
+		  ui32_t length;
+		  Kumu::hex2bin(argv[i], asset_id_value, UUIDlen, &length);
+
+		  if ( length != UUIDlen )
+		    {
+		      fprintf(stderr, "Unexpected asset ID length: %u, expecting %u characters.\n", length, UUIDlen);
+		      return;
+		    }
+		}
+		break;
+
+	      case 'b':
+		TEST_EXTRA_ARG(i, 'b');
+		fb_size = abs(atoi(argv[i]));
+
+		if ( verbose_flag )
+		  fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+
+		break;
+
+	      case 'd':
+		TEST_EXTRA_ARG(i, 'd');
+		duration = abs(atoi(argv[i]));
+		break;
+
+	      case 'E': encrypt_header_flag = false; break;
+	      case 'e': encrypt_header_flag = true; break;
+
+	      case 'f':
+		TEST_EXTRA_ARG(i, 'f');
+		start_frame = abs(atoi(argv[i]));
+		break;
+
+	      case 'h': help_flag = true; break;
+
+	      case 'j': key_id_flag = true;
+		TEST_EXTRA_ARG(i, 'j');
+		{
+		  ui32_t length;
+		  Kumu::hex2bin(argv[i], key_id_value, UUIDlen, &length);
+
+		  if ( length != UUIDlen )
+		    {
+		      fprintf(stderr, "Unexpected key ID length: %u, expecting %u characters.\n", length, UUIDlen);
+		      return;
+		    }
+		}
+		break;
+
+	      case 'k': key_flag = true;
+		TEST_EXTRA_ARG(i, 'k');
+		{
+		  ui32_t length;
+		  Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
+
+		  if ( length != KeyLen )
+		    {
+		      fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
+		      return;
+		    }
+		}
+		break;
+
+	      case 'l':
+		TEST_EXTRA_ARG(i, 'l');
+		channel_fmt = decode_channel_fmt(argv[i]);
+		break;
+
+	      case 'L': use_smpte_labels = true; break;
+	      case 'M': write_hmac = false; break;
+
+	      case 'p':
+		TEST_EXTRA_ARG(i, 'p');
+		picture_rate = abs(atoi(argv[i]));
+		break;
+
+	      case 'U':
+		TEST_EXTRA_ARG(i, 'U');
+		if ( ! channel_assignment.DecodeHex(argv[i]) )
+		  {
+		    fprintf(stderr, "Error decoding UL value: %s\n", argv[i]);
+		    return;
+		  }
+		break;
+
+	      case 'V': version_flag = true; break;
+	      case 'v': verbose_flag = true; break;
+	      case 'W': no_write_flag = true; break;
+	      case 'Z': j2c_pedantic = false; break;
+	      case 'z': j2c_pedantic = true; break;
+
+	      default:
+		fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
+		return;
+	      }
+	  }
+	else
+	  {
+
+	    if ( argv[i][0] != '-' )
+	      {
+		filenames.push_back(argv[i]);
+	      }
+	    else
+	      {
+		fprintf(stderr, "Unrecognized argument: %s\n", argv[i]);
+		return;
+	      }
+	  }
+      }
+
+    if ( help_flag || version_flag )
+      return;
+    
+    if ( filenames.size() < 2 )
+      {
+	fputs("Option requires at least two filename arguments: <input-file> <output-file>\n", stderr);
+	return;
+      }
+
+    out_file = filenames.back();
+    filenames.pop_back();
+    error_flag = false;
+  }
+};
+
+//------------------------------------------------------------------------------------------
+// MPEG2 essence
+
+// Write a plaintext MPEG2 Video Elementary Stream to a plaintext ASDCP file
+// Write a plaintext MPEG2 Video Elementary Stream to a ciphertext ASDCP file
+//
+Result_t
+write_MPEG2_file(CommandOptions& Options)
+{
+  AESEncContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  MPEG2::FrameBuffer FrameBuffer(Options.fb_size);
+  MPEG2::Parser      Parser;
+  MPEG2::MXFWriter   Writer;
+  MPEG2::VideoDescriptor VDesc;
+  byte_t             IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG   RNG;
+
+  // set up essence parser
+  Result_t result = Parser.OpenRead(Options.filenames.front().c_str());
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Parser.FillVideoDescriptor(VDesc);
+
+      if ( Options.verbose_flag )
+	{
+	  fputs("MPEG-2 Pictures\n", stderr);
+	  fputs("VideoDescriptor:\n", stderr);
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  MPEG2::VideoDescriptorDump(VDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file.c_str(), Info, VDesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    // loop through the frames
+    {
+      result = Parser.Reset();
+      ui32_t duration = 0;
+
+      while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
+	{
+	  if ( duration == 1 )
+	    {
+	      result = Parser.ReadFrame(FrameBuffer);
+
+	      if ( ASDCP_SUCCESS(result) )
+		{
+		  if ( Options.verbose_flag )
+		    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+		  
+		  if ( Options.encrypt_header_flag )
+		    FrameBuffer.PlaintextOffset(0);
+		}
+	    }
+
+	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    {
+	      result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
+
+	      // The Writer class will forward the last block of ciphertext
+	      // to the encryption context for use as the IV for the next
+	      // frame. If you want to use non-sequitur IV values, un-comment
+	      // the following  line of code.
+	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+	    }
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+
+//------------------------------------------------------------------------------------------
+// JPEG 2000 essence
+
+// Write one or more plaintext JPEG 2000 stereoscopic codestream pairs to a plaintext ASDCP file
+// Write one or more plaintext JPEG 2000 stereoscopic codestream pairs to a ciphertext ASDCP file
+//
+Result_t
+write_JP2K_S_file(CommandOptions& Options)
+{
+  AESEncContext*          Context = 0;
+  HMACContext*            HMAC = 0;
+  JP2K::MXFSWriter        Writer;
+  JP2K::FrameBuffer       FrameBuffer(Options.fb_size);
+  JP2K::PictureDescriptor PDesc;
+  JP2K::SequenceParser    ParserLeft, ParserRight;
+  byte_t                  IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG        RNG;
+
+  if ( Options.filenames.size() != 2 )
+    {
+      fprintf(stderr, "Two inputs are required for stereoscopic option.\n");
+      return RESULT_FAIL;
+    }
+
+  // set up essence parser
+  Result_t result = ParserLeft.OpenRead(Options.filenames.front().c_str(), Options.j2c_pedantic);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Options.filenames.pop_front();
+      result = ParserRight.OpenRead(Options.filenames.front().c_str(), Options.j2c_pedantic);
+    }
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      ParserLeft.FillPictureDescriptor(PDesc);
+      PDesc.EditRate = Options.PictureRate();
+
+      if ( Options.verbose_flag )
+	{
+	  fputs("JPEG 2000 stereoscopic pictures\nPictureDescriptor:\n", stderr);
+          fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  JP2K::PictureDescriptorDump(PDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file.c_str(), Info, PDesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      ui32_t duration = 0;
+      result = ParserLeft.Reset();
+      if ( ASDCP_SUCCESS(result) ) result = ParserRight.Reset();
+
+      while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
+	{
+	  result = ParserLeft.ReadFrame(FrameBuffer);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+		  
+	      if ( Options.encrypt_header_flag )
+		FrameBuffer.PlaintextOffset(0);
+	    }
+
+	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    result = Writer.WriteFrame(FrameBuffer, JP2K::SP_LEFT, Context, HMAC);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = ParserRight.ReadFrame(FrameBuffer);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+		  
+	      if ( Options.encrypt_header_flag )
+		FrameBuffer.PlaintextOffset(0);
+	    }
+
+	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    result = Writer.WriteFrame(FrameBuffer, JP2K::SP_RIGHT, Context, HMAC);
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+// Write one or more plaintext JPEG 2000 codestreams to a plaintext ASDCP file
+// Write one or more plaintext JPEG 2000 codestreams to a ciphertext ASDCP file
+//
+Result_t
+write_JP2K_file(CommandOptions& Options)
+{
+  AESEncContext*          Context = 0;
+  HMACContext*            HMAC = 0;
+  JP2K::MXFWriter         Writer;
+  JP2K::FrameBuffer       FrameBuffer(Options.fb_size);
+  JP2K::PictureDescriptor PDesc;
+  JP2K::SequenceParser    Parser;
+  byte_t                  IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG        RNG;
+
+  // set up essence parser
+  Result_t result = Parser.OpenRead(Options.filenames.front().c_str(), Options.j2c_pedantic);
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Parser.FillPictureDescriptor(PDesc);
+      PDesc.EditRate = Options.PictureRate();
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "JPEG 2000 pictures\n");
+	  fputs("PictureDescriptor:\n", stderr);
+          fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  JP2K::PictureDescriptorDump(PDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file.c_str(), Info, PDesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      ui32_t duration = 0;
+      result = Parser.Reset();
+
+      while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
+	{
+	  if ( duration == 1 )
+	    {
+	      result = Parser.ReadFrame(FrameBuffer);
+
+	      if ( ASDCP_SUCCESS(result) )
+		{
+		  if ( Options.verbose_flag )
+		    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+		  
+		  if ( Options.encrypt_header_flag )
+		    FrameBuffer.PlaintextOffset(0);
+		}
+	    }
+
+	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    {
+	      result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
+
+	      // The Writer class will forward the last block of ciphertext
+	      // to the encryption context for use as the IV for the next
+	      // frame. If you want to use non-sequitur IV values, un-comment
+	      // the following  line of code.
+	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+	    }
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+//------------------------------------------------------------------------------------------
+// PCM essence
+
+
+// Write one or more plaintext PCM audio streams to a plaintext ASDCP file
+// Write one or more plaintext PCM audio streams to a ciphertext ASDCP file
+//
+Result_t
+write_PCM_file(CommandOptions& Options)
+{
+  AESEncContext*    Context = 0;
+  HMACContext*      HMAC = 0;
+  PCMParserList     Parser;
+  PCM::MXFWriter    Writer;
+  PCM::FrameBuffer  FrameBuffer;
+  PCM::AudioDescriptor ADesc;
+  Rational          PictureRate = Options.PictureRate();
+  byte_t            IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG  RNG;
+
+  // set up essence parser
+  Result_t result = Parser.OpenRead(Options.filenames, PictureRate);
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Parser.FillAudioDescriptor(ADesc);
+
+      ADesc.EditRate = PictureRate;
+      FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
+      ADesc.ChannelFormat = Options.channel_fmt;
+
+      if ( Options.use_smpte_labels && ADesc.ChannelFormat == PCM::CF_NONE)
+	{
+	  fprintf(stderr, "ATTENTION! Writing SMPTE audio without ChannelAssignment property (see option -l)\n");
+	}
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "%.1fkHz PCM Audio, %s fps (%u spf)\n",
+		  ADesc.AudioSamplingRate.Quotient() / 1000.0,
+		  Options.szPictureRate(),
+		  PCM::CalcSamplesPerFrame(ADesc));
+	  fputs("AudioDescriptor:\n", stderr);
+	  PCM::AudioDescriptorDump(ADesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file.c_str(), Info, ADesc);
+
+      if ( ASDCP_SUCCESS(result) && Options.channel_assignment.HasValue() )
+	{
+	  MXF::WaveAudioDescriptor *descriptor = 0;
+	  Writer.OPAtomHeader().GetMDObjectByType(DefaultSMPTEDict().ul(MDD_WaveAudioDescriptor),
+						  reinterpret_cast<MXF::InterchangeObject**>(&descriptor));
+	  descriptor->ChannelAssignment = Options.channel_assignment;
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      result = Parser.Reset();
+      ui32_t duration = 0;
+
+      while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
+	{
+	  result = Parser.ReadFrame(FrameBuffer);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( FrameBuffer.Size() != FrameBuffer.Capacity() )
+		{
+		  fprintf(stderr, "WARNING: Last frame read was short, PCM input is possibly not frame aligned.\n");
+		  fprintf(stderr, "Expecting %u bytes, got %u.\n", FrameBuffer.Capacity(), FrameBuffer.Size());
+		  result = RESULT_ENDOFFILE;
+		  continue;
+		}
+
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	      if ( ! Options.no_write_flag )
+		{
+		  result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
+
+		  // The Writer class will forward the last block of ciphertext
+		  // to the encryption context for use as the IV for the next
+		  // frame. If you want to use non-sequitur IV values, un-comment
+		  // the following  line of code.
+		  // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+		  //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+		}
+	    }
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+
+//------------------------------------------------------------------------------------------
+// TimedText essence
+
+
+// Write one or more plaintext timed text streams to a plaintext ASDCP file
+// Write one or more plaintext timed text streams to a ciphertext ASDCP file
+//
+Result_t
+write_timed_text_file(CommandOptions& Options)
+{
+  AESEncContext*    Context = 0;
+  HMACContext*      HMAC = 0;
+  TimedText::DCSubtitleParser  Parser;
+  TimedText::MXFWriter    Writer;
+  TimedText::FrameBuffer  FrameBuffer;
+  TimedText::TimedTextDescriptor TDesc;
+  byte_t            IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG  RNG;
+
+  // set up essence parser
+  Result_t result = Parser.OpenRead(Options.filenames.front().c_str());
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Parser.FillTimedTextDescriptor(TDesc);
+      FrameBuffer.Capacity(Options.fb_size);
+
+      if ( Options.verbose_flag )
+	{
+	  fputs("D-Cinema Timed-Text Descriptor:\n", stderr);
+	  TimedText::DescriptorDump(TDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file.c_str(), Info, TDesc);
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    return result;
+
+  std::string XMLDoc;
+  TimedText::ResourceList_t::const_iterator ri;
+
+  result = Parser.ReadTimedTextResource(XMLDoc);
+
+  if ( ASDCP_SUCCESS(result) )
+    result = Writer.WriteTimedTextResource(XMLDoc, Context, HMAC);
+
+  for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
+    {
+      result = Parser.ReadAncillaryResource((*ri).ResourceID, FrameBuffer);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	  if ( ! Options.no_write_flag )
+	    {
+	      result = Writer.WriteAncillaryResource(FrameBuffer, Context, HMAC);
+	      
+	      // The Writer class will forward the last block of ciphertext
+	      // to the encryption context for use as the IV for the next
+	      // frame. If you want to use non-sequitur IV values, un-comment
+	      // the following  line of code.
+	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+	    }
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+//
+int
+main(int argc, const char** argv)
+{
+  Result_t result = RESULT_OK;
+  char     str_buf[64];
+  CommandOptions Options(argc, argv);
+
+  if ( Options.version_flag )
+    banner();
+
+  if ( Options.help_flag )
+    usage();
+
+  if ( Options.version_flag || Options.help_flag )
+    return 0;
+
+  if ( Options.error_flag )
+    {
+      fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
+      return 3;
+    }
+
+  if ( Options.show_ul_values )
+    {
+      if ( Options.use_smpte_labels )
+	DefaultSMPTEDict().Dump(stdout);
+      else
+	DefaultInteropDict().Dump(stdout);
+    }
+
+  EssenceType_t EssenceType;
+  result = ASDCP::RawEssenceType(Options.filenames.front().c_str(), EssenceType);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      switch ( EssenceType )
+	{
+	case ESS_MPEG2_VES:
+	  result = write_MPEG2_file(Options);
+	  break;
+
+	case ESS_JPEG_2000:
+	  if ( Options.stereo_image_flag )
+	    {
+	      result = write_JP2K_S_file(Options);
+	    }
+	  else
+	    {
+	      result = write_JP2K_file(Options);
+	    }
+	  break;
+
+	case ESS_PCM_24b_48k:
+	case ESS_PCM_24b_96k:
+	  result = write_PCM_file(Options);
+	  break;
+
+	case ESS_TIMED_TEXT:
+	  result = write_timed_text_file(Options);
+	  break;
+
+	default:
+	  fprintf(stderr, "%s: Unknown file type, not ASDCP-compatible essence.\n",
+		  Options.filenames.front().c_str());
+	  return 5;
+	}
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    {
+      fputs("Program stopped on error.\n", stderr);
+
+      if ( result != RESULT_FAIL )
+	{
+	  fputs(result, stderr);
+	  fputc('\n', stderr);
+	}
+
+      return 1;
+    }
+
+  return 0;
+}
+
+
+//
+// end asdcp-wrap.cpp
+//