make way for MCA

13 files changed, 1221 insertions, 64 deletions

diff --git a/src/AS_DCP.h b/src/AS_DCP.h
index 29f07c0..72d5261 100755
--- a/src/AS_DCP.h
+++ b/src/AS_DCP.h
@@ -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
@@ -34,22 +34,23 @@ D-Cinema Technology Committee 21DC. The file format, labeled AS-DCP,
 is described in series of separate documents which include but may not
 be be limited to:
 
- o SMPTE ST 429-2:2009 DCP Operational Constraints
- o SMPTE ST 429-3:2006 Track File Specification
- o SMPTE ST 429-4:2006 JPEG 2000 for D-Cinema
+ o SMPTE ST 429-2:2011 DCP Operational Constraints
+ o SMPTE ST 429-3:2006 Sound and Picture Track File
+ o SMPTE ST 429-4:2006 MXF JPEG 2000 Application
  o SMPTE ST 429-5:2009 Timed Text Track File
- o SMPTE ST 429-6:2006 Essence Encryption
- o SMPTE ST 429-10:2008 Stereoscopic Image Track File
+ o SMPTE ST 429-6:2006 MXF Track File Essence Encryption
+ o SMPTE ST 429-10:2008 Stereoscopic Picture Track File
  o SMPTE ST 330:2004 - UMID
  o SMPTE ST 336:2001 - KLV
- o SMPTE ST 377:2000 - MXF
- o SMPTE ST 390:2004 - MXF OP-Atom
- o SMPTE ST 379:2004 - MXF Generic Container (GC)
- o SMPTE ST 381:2005 - MPEG2 picture in GC
+ o SMPTE ST 377-1:2011 - MXF
+ o SMPTE ST 377-4:2012 - MXF Multichannel Audio Labeling Framework
+ o SMPTE ST 390:2011 - MXF OP-Atom
+ o SMPTE ST 379-1:2009 - MXF Generic Container (GC)
+ o SMPTE ST 381-1:2005 - MPEG2 picture in GC
  o SMPTE ST 422:2006 - JPEG 2000 picture in GC
  o SMPTE ST 382:2007 - WAV/PCM sound in GC
  o IETF RFC 2104 - HMAC/SHA1
- o NIST FIPS 197 - AES (Rijndael)
+ o NIST FIPS 197 - AES (Rijndael) (via OpenSSL)
 
  o MXF Interop Track File Specification
  o MXF Interop Track File Essence Encryption Specification
@@ -551,6 +552,15 @@ namespace ASDCP {
       inline ui32_t  PlaintextOffset() const { return m_PlaintextOffset; }
     };
 
+  //---------------------------------------------------------------------------------
+  // Accessors in the MXFReader and MXFWriter classes below return these types to
+  // provide direct access to MXF metadata structures declared in MXF.h and Metadata.h
+
+  namespace MXF {
+    // #include<Metadata.h> to use these
+    class OPAtomHeader;
+    class OPAtomIndexFooter;
+  };
 
   //---------------------------------------------------------------------------------
   // MPEG2 video elementary stream support
@@ -707,6 +717,11 @@ namespace ASDCP {
 	  MXFWriter();
 	  virtual ~MXFWriter();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for writing. The file must not exist. Returns error if
 	  // the operation cannot be completed or if nonsensical data is discovered
 	  // in the essence descriptor.
@@ -734,6 +749,11 @@ namespace ASDCP {
 	  MXFReader();
 	  virtual ~MXFReader();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for reading. The file must exist. Returns error if the
 	  // operation cannot be completed.
 	  Result_t OpenRead(const char* filename) const;
@@ -780,6 +800,9 @@ namespace ASDCP {
 
   //---------------------------------------------------------------------------------
   //
+
+
+
   namespace PCM
     {
       // The default value of the ChannelFormat element of the AudioDescriptor struct
@@ -893,6 +916,11 @@ namespace ASDCP {
 	  MXFWriter();
 	  virtual ~MXFWriter();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for writing. The file must not exist. Returns error if
 	  // the operation cannot be completed or if nonsensical data is discovered
 	  // in the essence descriptor.
@@ -920,6 +948,11 @@ namespace ASDCP {
 	  MXFReader();
 	  virtual ~MXFReader();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for reading. The file must exist. Returns error if the
 	  // operation cannot be completed.
 	  Result_t OpenRead(const char* filename) const;
@@ -1124,6 +1157,11 @@ namespace ASDCP {
 	  MXFWriter();
 	  virtual ~MXFWriter();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for writing. The file must not exist. Returns error if
 	  // the operation cannot be completed or if nonsensical data is discovered
 	  // in the essence descriptor.
@@ -1151,6 +1189,11 @@ namespace ASDCP {
 	  MXFReader();
 	  virtual ~MXFReader();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for reading. The file must exist. Returns error if the
 	  // operation cannot be completed.
 	  Result_t OpenRead(const char* filename) const;
@@ -1211,6 +1254,11 @@ namespace ASDCP {
 	  MXFSWriter();
 	  virtual ~MXFSWriter();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for writing. The file must not exist. Returns error if
 	  // the operation cannot be completed or if nonsensical data is discovered
 	  // in the essence descriptor.
@@ -1248,6 +1296,11 @@ namespace ASDCP {
 	  MXFSReader();
 	  virtual ~MXFSReader();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for reading. The file must exist. Returns error if the
 	  // operation cannot be completed.
 	  Result_t OpenRead(const char* filename) const;
@@ -1401,6 +1454,11 @@ namespace ASDCP {
 	  MXFWriter();
 	  virtual ~MXFWriter();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for writing. The file must not exist. Returns error if
 	  // the operation cannot be completed or if nonsensical data is discovered
 	  // in the essence descriptor.
@@ -1438,6 +1496,11 @@ namespace ASDCP {
 	  MXFReader();
 	  virtual ~MXFReader();
 
+	  // Warning: direct manipulation of MXF structures can interfere
+	  // with the normal operation of the wrapper.  Caveat emptor!
+	  virtual MXF::OPAtomHeader& OPAtomHeader();
+	  virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter();
+
 	  // Open the file for reading. The file must exist. Returns error if the
 	  // operation cannot be completed.
 	  Result_t OpenRead(const char* filename) const;
diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index 72b975d..9e676ae 100755
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2010, John Hurst
+Copyright (c) 2004-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -38,6 +38,10 @@ using Kumu::GenRandomValue;
 
 //------------------------------------------------------------------------------------------
 
+static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict();
+static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict);
+static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict);
+
 static std::string JP2K_PACKAGE_LABEL = "File Package: SMPTE 429-4 frame wrapping of JPEG 2000 codestreams";
 static std::string JP2K_S_PACKAGE_LABEL = "File Package: SMPTE 429-10 frame wrapping of stereoscopic JPEG 2000 codestreams";
 static std::string PICT_DEF_LABEL = "Picture Track";
@@ -461,6 +465,30 @@ ASDCP::JP2K::MXFReader::~MXFReader()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::JP2K::MXFReader::OPAtomHeader()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Reader->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::JP2K::MXFReader::OPAtomIndexFooter()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Reader->m_FooterPart;
+}
+
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
@@ -635,6 +663,30 @@ ASDCP::JP2K::MXFSReader::~MXFSReader()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::JP2K::MXFSReader::OPAtomHeader()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Reader->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::JP2K::MXFSReader::OPAtomIndexFooter()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Reader->m_FooterPart;
+}
+
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
@@ -977,6 +1029,29 @@ ASDCP::JP2K::MXFWriter::~MXFWriter()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::JP2K::MXFWriter::OPAtomHeader()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Writer->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::JP2K::MXFWriter::OPAtomIndexFooter()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Writer->m_FooterPart;
+}
 
 // Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
@@ -1079,6 +1154,29 @@ ASDCP::JP2K::MXFSWriter::~MXFSWriter()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::JP2K::MXFSWriter::OPAtomHeader()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Writer->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::JP2K::MXFSWriter::OPAtomIndexFooter()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Writer->m_FooterPart;
+}
 
 // Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
diff --git a/src/AS_DCP_MPEG2.cpp b/src/AS_DCP_MPEG2.cpp
index 252c1fa..ea7ed74 100755
--- a/src/AS_DCP_MPEG2.cpp
+++ b/src/AS_DCP_MPEG2.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2011, John Hurst
+Copyright (c) 2004-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -36,6 +36,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 //------------------------------------------------------------------------------------------
 
+static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict();
+static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict);
+static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict);
+
 static std::string MPEG_PACKAGE_LABEL = "File Package: SMPTE 381M frame wrapping of MPEG2 video elementary stream";
 static std::string PICT_DEF_LABEL = "Picture Track";
 
@@ -335,6 +339,30 @@ ASDCP::MPEG2::MXFReader::~MXFReader()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::MPEG2::MXFReader::OPAtomHeader()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Reader->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::MPEG2::MXFReader::OPAtomIndexFooter()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Reader->m_FooterPart;
+}
+
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
@@ -611,6 +639,29 @@ ASDCP::MPEG2::MXFWriter::~MXFWriter()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::MPEG2::MXFWriter::OPAtomHeader()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Writer->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::MPEG2::MXFWriter::OPAtomIndexFooter()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Writer->m_FooterPart;
+}
 
 // Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
diff --git a/src/AS_DCP_PCM.cpp b/src/AS_DCP_PCM.cpp
index eb0c3b7..3956c71 100755
--- a/src/AS_DCP_PCM.cpp
+++ b/src/AS_DCP_PCM.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2011, John Hurst
+Copyright (c) 2004-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -36,6 +36,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 //------------------------------------------------------------------------------------------
 
+static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict();
+static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict);
+static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict);
+
 static std::string PCM_PACKAGE_LABEL = "File Package: SMPTE 382M frame wrapping of wave audio";
 static std::string SOUND_DEF_LABEL = "Sound Track";
 
@@ -313,6 +317,30 @@ ASDCP::PCM::MXFReader::~MXFReader()
     m_Reader->Close();
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::PCM::MXFReader::OPAtomHeader()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Reader->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::PCM::MXFReader::OPAtomIndexFooter()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Reader->m_FooterPart;
+}
+
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
@@ -544,6 +572,29 @@ ASDCP::PCM::MXFWriter::~MXFWriter()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::PCM::MXFWriter::OPAtomHeader()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Writer->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::PCM::MXFWriter::OPAtomIndexFooter()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Writer->m_FooterPart;
+}
 
 // Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
diff --git a/src/AS_DCP_TimedText.cpp b/src/AS_DCP_TimedText.cpp
index f7d64bd..5d31a8d 100644
--- a/src/AS_DCP_TimedText.cpp
+++ b/src/AS_DCP_TimedText.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2011, John Hurst
+Copyright (c) 2008-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -37,6 +37,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using Kumu::GenRandomValue;
 
+static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict();
+static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict);
+static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict);
+
 static std::string TIMED_TEXT_PACKAGE_LABEL = "File Package: SMPTE 429-5 clip wrapping of D-Cinema Timed Text data";
 static std::string TIMED_TEXT_DEF_LABEL = "Timed Text Track";
 
@@ -341,6 +345,30 @@ ASDCP::TimedText::MXFReader::~MXFReader()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::TimedText::MXFReader::OPAtomHeader()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Reader->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::TimedText::MXFReader::OPAtomIndexFooter()
+{
+  if ( m_Reader.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Reader->m_FooterPart;
+}
+
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
@@ -647,6 +675,29 @@ ASDCP::TimedText::MXFWriter::~MXFWriter()
 {
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomHeader&
+ASDCP::TimedText::MXFWriter::OPAtomHeader()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomHeader;
+
+  return m_Writer->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::TimedText::MXFWriter::OPAtomIndexFooter()
+{
+  if ( m_Writer.empty() )
+    return sg_OPAtomIndexFooter;
+
+  return m_Writer->m_FooterPart;
+}
 
 // Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
diff --git a/src/MDD.cpp b/src/MDD.cpp
index 98666a8..5627624 100644
--- a/src/MDD.cpp
+++ b/src/MDD.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2006-2011, John Hurst
+Copyright (c) 2006-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -881,6 +881,42 @@ static const ASDCP::MDDEntry s_MDD_Table[] = {
   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0b, // 281
       0x04, 0x02, 0x02, 0x10, 0x03, 0x01, 0x05, 0x00 },
     {0}, false, "DCAudioChannelCfg_5_7p1_DS" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 282
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6a, 0x00 },
+    {0}, false, "MCALabelSubDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 283
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6b, 0x00 },
+    {0}, false, "AudioChannelLabelSubDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 284
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6c, 0x00 },
+    {0}, false, "SoundfieldGroupLabelSubDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 285
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6d, 0x00 },
+    {0}, false, "GroupOfSoundfieldGroupsLabelSubDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 286
+      0x01, 0x03, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00 },
+    {0}, false, "MCALabelSubDescriptor_MCALabelDictionaryID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 287
+      0x01, 0x03, 0x07, 0x01, 0x05, 0x00, 0x00, 0x00 },
+    {0}, false, "MCALabelSubDescriptor_MCALinkID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 288
+      0x01, 0x03, 0x07, 0x01, 0x02, 0x00, 0x00, 0x00 },
+    {0}, false, "MCALabelSubDescriptor_MCATagSymbol" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 289
+      0x01, 0x03, 0x07, 0x01, 0x03, 0x00, 0x00, 0x00 },
+    {0}, false, "MCALabelSubDescriptor_MCATagName" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 290
+      0x01, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00 },
+    {0}, false, "MCALabelSubDescriptor_MCAChannelID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0d, // 291
+      0x03, 0x01, 0x01, 0x02, 0x03, 0x15, 0x00, 0x00 },
+    {0}, false, "MCALabelSubDescriptor_RFC5646SpokenLanguage" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0d, // 292
+      0x01, 0x03, 0x07, 0x01, 0x03, 0x00, 0x00, 0x00 },
+    {0}, false, "AudioChannelLabelSubDescriptor_SoundfieldGroupLinkID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0d, // 293
+      0x01, 0x03, 0x07, 0x01, 0x04, 0x00, 0x00, 0x00 },
+    {0}, false, "SoundfieldGroupLabelSubDescriptor_GroupOfSoundfieldGroupsLinkID" },
   { {0}, {0}, false, 0 }
 };
 
diff --git a/src/MDD.h b/src/MDD.h
index 3682e5e..358b874 100755
--- a/src/MDD.h
+++ b/src/MDD.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2006-2009, John Hurst
+Copyright (c) 2006-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -317,6 +317,18 @@ namespace ASDCP {
 	MDD_DCAudioChannelCfg_3_7p1, // 279
 	MDD_DCAudioChannelCfg_4_WTF, // 280
 	MDD_DCAudioChannelCfg_5_7p1_DS, // 281
+	MDD_MCALabelSubDescriptor, // 282
+	MDD_AudioChannelLabelSubDescriptor, // 283
+	MDD_SoundfieldGroupLabelSubDescriptor, // 284
+	MDD_GroupOfSoundfieldGroupsLabelSubDescriptor, // 285
+	MDD_MCALabelSubDescriptor_MCALabelDictionaryID, // 286
+	MDD_MCALabelSubDescriptor_MCALinkID, // 287
+	MDD_MCALabelSubDescriptor_MCATagSymbol, // 288
+	MDD_MCALabelSubDescriptor_MCATagName, // 289
+	MDD_MCALabelSubDescriptor_MCAChannelID, // 290
+	MDD_MCALabelSubDescriptor_RFC5646SpokenLanguage, // 291
+	MDD_AudioChannelLabelSubDescriptor_SoundfieldGroupLinkID, // 292
+	MDD_SoundfieldGroupLabelSubDescriptor_GroupOfSoundfieldGroupsLinkID, // 293
 	MDD_Max
 
     }; // enum MDD_t
diff --git a/src/MXF.cpp b/src/MXF.cpp
index 4ba82cd..d1dd6d0 100755
--- a/src/MXF.cpp
+++ b/src/MXF.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
@@ -189,7 +189,7 @@ public:
   }
 
   //
-  void AddPacket(InterchangeObject* ThePacket)
+  void AddPacket(InterchangeObject* ThePacket) // takes ownership
   {
     assert(ThePacket);
     m_Map.insert(std::map<UUID, InterchangeObject*>::value_type(ThePacket->InstanceUID, ThePacket));
@@ -267,7 +267,7 @@ ASDCP::MXF::Partition::~Partition()
 {
 }
 
-//
+// takes ownership
 void
 ASDCP::MXF::Partition::AddChildObject(InterchangeObject* Object)
 {
@@ -814,7 +814,7 @@ ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l)
 	    }
 	  else
 	    {
-	      m_PacketList->AddPacket(object);
+	      m_PacketList->AddPacket(object); // takes ownership
 
 	      if ( object->IsA(m_Dict->ul(MDD_Preface)) && m_Preface == 0 )
 		m_Preface = (Preface*)object;
@@ -1070,7 +1070,7 @@ ASDCP::MXF::OPAtomIndexFooter::InitFromBuffer(const byte_t* p, ui32_t l)
 
       if ( ASDCP_SUCCESS(result) )
 	{
-	  m_PacketList->AddPacket(object);
+	  m_PacketList->AddPacket(object); // takes ownership
 	}
       else
 	{
diff --git a/src/MXF.h b/src/MXF.h
index 3ae2c85..fbae834 100755
--- a/src/MXF.h
+++ b/src/MXF.h
@@ -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
@@ -136,7 +136,7 @@ namespace ASDCP
 
 	  Partition(const Dictionary*&);
 	  virtual ~Partition();
-	  virtual void     AddChildObject(InterchangeObject*);
+	  virtual void     AddChildObject(InterchangeObject*); // takes ownership
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 	  virtual Result_t WriteToFile(Kumu::FileWriter& Writer, UL& PartitionLabel);
@@ -363,7 +363,9 @@ namespace ASDCP
 	  ui32_t              m_BytesPerEditUnit;
 	  Rational            m_EditRate;
 	  ui32_t              m_BodySID;
+
 	  ASDCP_NO_COPY_CONSTRUCT(OPAtomIndexFooter);
+	  OPAtomIndexFooter();
 
 	public:
 	  const Dictionary*&   m_Dict;
diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp
index 1418541..7b054c7 100755
--- a/src/MXFTypes.cpp
+++ b/src/MXFTypes.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2011, John Hurst
+Copyright (c) 2005-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -325,6 +325,61 @@ ASDCP::MXF::UTF16String::Archive(Kumu::MemIOWriter* Writer) const
   return true;
 }
 
+//------------------------------------------------------------------------------------------
+//
+
+//
+const ASDCP::MXF::ISO8String&
+ASDCP::MXF::ISO8String::operator=(const char* sz)
+{
+  if ( sz == 0 || *sz == 0 )
+    erase();
+
+  else
+    this->assign(sz);
+  
+  return *this;
+}
+
+//
+const ASDCP::MXF::ISO8String&
+ASDCP::MXF::ISO8String::operator=(const std::string& str)
+{
+  this->assign(str);
+  return *this;
+}
+
+//
+const char*
+ASDCP::MXF::ISO8String::EncodeString(char* str_buf, ui32_t buf_len) const
+{
+  ui32_t write_len = Kumu::xmin(buf_len - 1, (ui32_t)size());
+  strncpy(str_buf, c_str(), write_len);
+  str_buf[write_len] = 0;
+  return str_buf;
+}
+
+//
+bool
+ASDCP::MXF::ISO8String::Unarchive(Kumu::MemIOReader* Reader)
+{
+  assign((char*)Reader->CurrentData(), Reader->Remainder());
+  return true;
+}
+
+//
+bool
+ASDCP::MXF::ISO8String::Archive(Kumu::MemIOWriter* Writer) const
+{
+  if ( size() > IdentBufferLen )
+    {
+      DefaultLogSink().Error("String length exceeds maximum %u bytes\n", IdentBufferLen);
+      return false;
+    }
+
+  return Writer->WriteString(*this);
+}
+
 
 //------------------------------------------------------------------------------------------
 //
diff --git a/src/MXFTypes.h b/src/MXFTypes.h
index fe03495..410fa8b 100755
--- a/src/MXFTypes.h
+++ b/src/MXFTypes.h
@@ -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
@@ -289,6 +289,23 @@ namespace ASDCP
 	};
 
       //
+    class ISO8String : public std::string, public Kumu::IArchive
+	{
+	public:
+	  ISO8String() {}
+	  ~ISO8String() {}
+
+	  const ISO8String& operator=(const char*);
+	  const ISO8String& operator=(const std::string&);
+
+	  const char* EncodeString(char* str_buf, ui32_t buf_len) const;
+	  inline virtual bool HasValue() const { return ! empty(); }
+	  inline virtual ui32_t ArchiveLength() const { return sizeof(ui32_t) + size(); }
+	  virtual bool Unarchive(Kumu::MemIOReader* Reader);
+	  virtual bool Archive(Kumu::MemIOWriter* Writer) const;
+	};
+
+      //
     class UTF16String : public std::string, public Kumu::IArchive
 	{
 	public:
@@ -359,8 +376,6 @@ namespace ASDCP
       //
       class VersionType : public Kumu::IArchive
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(VersionType);
-
 	public:
 	  enum Release_t { RL_UNKNOWN, RL_RELEASE, RL_DEVELOPMENT, RL_PATCHED, RL_BETA, RL_PRIVATE };
 	  ui16_t Major;
@@ -370,7 +385,19 @@ namespace ASDCP
 	  Release_t Release;
 
 	  VersionType() : Major(0), Minor(0), Patch(0), Build(0), Release(RL_UNKNOWN) {}
-	  ~VersionType() {}
+	  VersionType(const VersionType& rhs) { Copy(rhs); }
+	  virtual ~VersionType() {}
+
+	  const VersionType& operator=(const VersionType& rhs) { Copy(rhs); return *this; }
+
+	  void Copy(const VersionType& rhs) {
+	    Major = rhs.Major;
+	    Minor = rhs.Minor;
+	    Patch = rhs.Patch;
+	    Build = rhs.Build;
+	    Release = rhs.Release;
+	  }
+
 	  void Dump(FILE* = 0);
 
 	  const char* EncodeString(char* str_buf, ui32_t buf_len) const {
@@ -405,11 +432,18 @@ namespace ASDCP
       //
       class Raw : public Kumu::ByteString
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Raw);
-
 	public:
 	  Raw();
-	  ~Raw();
+	  Raw(const Raw& rhs) { Copy(rhs); }
+	  virtual ~Raw();
+
+	  const Raw& operator=(const Raw& rhs) { Copy(rhs); return *this; }
+	  void Copy(const Raw& rhs) {
+	    if ( KM_SUCCESS(Capacity(rhs.Length())) )
+	      {
+		Set(rhs);
+	      }
+	  }
 
 	  //
           virtual bool Unarchive(Kumu::MemIOReader* Reader);
diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index aeedbde..f62f273 100755
--- a/src/Metadata.cpp
+++ b/src/Metadata.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
@@ -69,6 +69,10 @@ static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary*& Dict) {
 static InterchangeObject* TimedTextResourceSubDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextResourceSubDescriptor(Dict); }
 static InterchangeObject* StereoscopicPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new StereoscopicPictureSubDescriptor(Dict); }
 static InterchangeObject* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); }
+static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); }
+static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); }
+static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
+static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
 
 
 void
@@ -104,6 +108,10 @@ ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
   SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory);
+  SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
 }
 
 //------------------------------------------------------------------------------------------
@@ -152,6 +160,21 @@ Identification::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+Identification::Copy(const Identification& rhs)
+{
+  ThisGenerationUID = rhs.ThisGenerationUID;
+  CompanyName = rhs.CompanyName;
+  ProductName = rhs.ProductName;
+  ProductVersion = rhs.ProductVersion;
+  VersionString = rhs.VersionString;
+  ProductUID = rhs.ProductUID;
+  ModificationDate = rhs.ModificationDate;
+  ToolkitVersion = rhs.ToolkitVersion;
+  Platform = rhs.Platform;
+}
+
+//
+void
 Identification::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -217,6 +240,14 @@ ContentStorage::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+ContentStorage::Copy(const ContentStorage& rhs)
+{
+  Packages = rhs.Packages;
+  EssenceContainerData = rhs.EssenceContainerData;
+}
+
+//
+void
 ContentStorage::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -279,6 +310,15 @@ EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+EssenceContainerData::Copy(const EssenceContainerData& rhs)
+{
+  LinkedPackageUID = rhs.LinkedPackageUID;
+  IndexSID = rhs.IndexSID;
+  BodySID = rhs.BodySID;
+}
+
+//
+void
 EssenceContainerData::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -344,6 +384,17 @@ GenericPackage::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+GenericPackage::Copy(const GenericPackage& rhs)
+{
+  PackageUID = rhs.PackageUID;
+  Name = rhs.Name;
+  PackageCreationDate = rhs.PackageCreationDate;
+  PackageModifiedDate = rhs.PackageModifiedDate;
+  Tracks = rhs.Tracks;
+}
+
+//
+void
 GenericPackage::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -385,6 +436,12 @@ MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+MaterialPackage::Copy(const MaterialPackage& rhs)
+{
+}
+
+//
+void
 MaterialPackage::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -439,6 +496,13 @@ SourcePackage::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+SourcePackage::Copy(const SourcePackage& rhs)
+{
+  Descriptor = rhs.Descriptor;
+}
+
+//
+void
 SourcePackage::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -500,6 +564,16 @@ GenericTrack::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+GenericTrack::Copy(const GenericTrack& rhs)
+{
+  TrackID = rhs.TrackID;
+  TrackNumber = rhs.TrackNumber;
+  TrackName = rhs.TrackName;
+  Sequence = rhs.Sequence;
+}
+
+//
+void
 GenericTrack::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -539,6 +613,12 @@ StaticTrack::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+StaticTrack::Copy(const StaticTrack& rhs)
+{
+}
+
+//
+void
 StaticTrack::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -595,6 +675,14 @@ Track::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+Track::Copy(const Track& rhs)
+{
+  EditRate = rhs.EditRate;
+  Origin = rhs.Origin;
+}
+
+//
+void
 Track::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -653,6 +741,14 @@ StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+StructuralComponent::Copy(const StructuralComponent& rhs)
+{
+  DataDefinition = rhs.DataDefinition;
+  Duration = rhs.Duration;
+}
+
+//
+void
 StructuralComponent::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -692,6 +788,13 @@ Sequence::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+Sequence::Copy(const Sequence& rhs)
+{
+  StructuralComponents = rhs.StructuralComponents;
+}
+
+//
+void
 Sequence::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -752,6 +855,15 @@ SourceClip::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+SourceClip::Copy(const SourceClip& rhs)
+{
+  StartPosition = rhs.StartPosition;
+  SourcePackageID = rhs.SourcePackageID;
+  SourceTrackID = rhs.SourceTrackID;
+}
+
+//
+void
 SourceClip::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -813,6 +925,15 @@ TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+TimecodeComponent::Copy(const TimecodeComponent& rhs)
+{
+  RoundedTimecodeBase = rhs.RoundedTimecodeBase;
+  StartTimecode = rhs.StartTimecode;
+  DropFrame = rhs.DropFrame;
+}
+
+//
+void
 TimecodeComponent::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -872,6 +993,14 @@ GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+GenericDescriptor::Copy(const GenericDescriptor& rhs)
+{
+  Locators = rhs.Locators;
+  SubDescriptors = rhs.SubDescriptors;
+}
+
+//
+void
 GenericDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -921,6 +1050,17 @@ FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+FileDescriptor::Copy(const FileDescriptor& rhs)
+{
+  LinkedTrackID = rhs.LinkedTrackID;
+  SampleRate = rhs.SampleRate;
+  ContainerDuration = rhs.ContainerDuration;
+  EssenceContainer = rhs.EssenceContainer;
+  Codec = rhs.Codec;
+}
+
+//
+void
 FileDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -990,6 +1130,18 @@ GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs)
+{
+  AudioSamplingRate = rhs.AudioSamplingRate;
+  Locked = rhs.Locked;
+  AudioRefLevel = rhs.AudioRefLevel;
+  ChannelCount = rhs.ChannelCount;
+  QuantizationBits = rhs.QuantizationBits;
+  DialNorm = rhs.DialNorm;
+}
+
+//
+void
 GenericSoundEssenceDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1056,6 +1208,16 @@ WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs)
+{
+  BlockAlign = rhs.BlockAlign;
+  SequenceOffset = rhs.SequenceOffset;
+  AvgBps = rhs.AvgBps;
+  ChannelAssignment = rhs.ChannelAssignment;
+}
+
+//
+void
 WaveAudioDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1122,6 +1284,17 @@ GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs)
+{
+  FrameLayout = rhs.FrameLayout;
+  StoredWidth = rhs.StoredWidth;
+  StoredHeight = rhs.StoredHeight;
+  AspectRatio = rhs.AspectRatio;
+  PictureEssenceCoding = rhs.PictureEssenceCoding;
+}
+
+//
+void
 GenericPictureEssenceDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1183,6 +1356,14 @@ RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs)
+{
+  ComponentMaxRef = rhs.ComponentMaxRef;
+  ComponentMinRef = rhs.ComponentMinRef;
+}
+
+//
+void
 RGBAEssenceDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1263,6 +1444,25 @@ JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs)
+{
+  Rsize = rhs.Rsize;
+  Xsize = rhs.Xsize;
+  Ysize = rhs.Ysize;
+  XOsize = rhs.XOsize;
+  YOsize = rhs.YOsize;
+  XTsize = rhs.XTsize;
+  YTsize = rhs.YTsize;
+  XTOsize = rhs.XTOsize;
+  YTOsize = rhs.YTOsize;
+  Csize = rhs.Csize;
+  PictureComponentSizing = rhs.PictureComponentSizing;
+  CodingStyleDefault = rhs.CodingStyleDefault;
+  QuantizationDefault = rhs.QuantizationDefault;
+}
+
+//
+void
 JPEG2000PictureSubDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1336,6 +1536,16 @@ CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs)
+{
+  ComponentDepth = rhs.ComponentDepth;
+  HorizontalSubsampling = rhs.HorizontalSubsampling;
+  VerticalSubsampling = rhs.VerticalSubsampling;
+  ColorSiting = rhs.ColorSiting;
+}
+
+//
+void
 CDCIEssenceDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1400,6 +1610,16 @@ MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs)
+{
+  CodedContentType = rhs.CodedContentType;
+  LowDelay = rhs.LowDelay;
+  BitRate = rhs.BitRate;
+  ProfileAndLevel = rhs.ProfileAndLevel;
+}
+
+//
+void
 MPEG2VideoDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1466,6 +1686,17 @@ DMSegment::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+DMSegment::Copy(const DMSegment& rhs)
+{
+  DataDefinition = rhs.DataDefinition;
+  EventStartPosition = rhs.EventStartPosition;
+  Duration = rhs.Duration;
+  EventComment = rhs.EventComment;
+  DMFramework = rhs.DMFramework;
+}
+
+//
+void
 DMSegment::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1525,6 +1756,13 @@ CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+CryptographicFramework::Copy(const CryptographicFramework& rhs)
+{
+  ContextSR = rhs.ContextSR;
+}
+
+//
+void
 CryptographicFramework::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1588,6 +1826,17 @@ CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+CryptographicContext::Copy(const CryptographicContext& rhs)
+{
+  ContextID = rhs.ContextID;
+  SourceEssenceContainer = rhs.SourceEssenceContainer;
+  CipherAlgorithm = rhs.CipherAlgorithm;
+  MICAlgorithm = rhs.MICAlgorithm;
+  CryptographicKeyID = rhs.CryptographicKeyID;
+}
+
+//
+void
 CryptographicContext::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1647,6 +1896,13 @@ GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs)
+{
+  DataEssenceCoding = rhs.DataEssenceCoding;
+}
+
+//
+void
 GenericDataEssenceDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1706,6 +1962,15 @@ TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs)
+{
+  ResourceID = rhs.ResourceID;
+  UCSEncoding = rhs.UCSEncoding;
+  NamespaceURI = rhs.NamespaceURI;
+}
+
+//
+void
 TimedTextDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1767,6 +2032,15 @@ TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs)
+{
+  AncillaryResourceID = rhs.AncillaryResourceID;
+  MIMEMediaType = rhs.MIMEMediaType;
+  EssenceStreamID = rhs.EssenceStreamID;
+}
+
+//
+void
 TimedTextResourceSubDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1822,6 +2096,12 @@ StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs)
+{
+}
+
+//
+void
 StereoscopicPictureSubDescriptor::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1876,6 +2156,13 @@ NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet)
 
 //
 void
+NetworkLocator::Copy(const NetworkLocator& rhs)
+{
+  URLString = rhs.URLString;
+}
+
+//
+void
 NetworkLocator::Dump(FILE* stream)
 {
   char identbuf[IdentBufferLen];
@@ -1906,6 +2193,271 @@ NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
+//------------------------------------------------------------------------------------------
+// MCALabelSubDescriptor
+
+//
+ASDCP::Result_t
+MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = InterchangeObject::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagName));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MCALabelSubDescriptor, MCAChannelID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage));
+  return result;
+}
+
+//
+ASDCP::Result_t
+MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = InterchangeObject::WriteToTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagName));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCAChannelID));
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage));
+  return result;
+}
+
+//
+void
+MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs)
+{
+  MCALabelDictionaryID = rhs.MCALabelDictionaryID;
+  MCALinkID = rhs.MCALinkID;
+  MCATagSymbol = rhs.MCATagSymbol;
+  MCATagName = rhs.MCATagName;
+  MCAChannelID = rhs.MCAChannelID;
+  RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage;
+}
+
+//
+void
+MCALabelSubDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  InterchangeObject::Dump(stream);
+  fprintf(stream, "  %22s = %s\n",  "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %s\n",  "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %s\n",  "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %s\n",  "MCATagName", MCATagName.EncodeString(identbuf, IdentBufferLen));
+  fprintf(stream, "  %22s = %d\n",  "MCAChannelID", MCAChannelID);
+  fprintf(stream, "  %22s = %s\n",  "RFC5646SpokenLanguage", RFC5646SpokenLanguage.EncodeString(identbuf, IdentBufferLen));
+}
+
+//
+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);
+}
+
+//
+ASDCP::Result_t
+MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  assert(m_Dict);
+  m_Typeinfo = &(m_Dict->Type(MDD_MCALabelSubDescriptor));
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
+//------------------------------------------------------------------------------------------
+// AudioChannelLabelSubDescriptor
+
+//
+ASDCP::Result_t
+AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
+  return result;
+}
+
+//
+ASDCP::Result_t
+AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID));
+  return result;
+}
+
+//
+void
+AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs)
+{
+  SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID;
+}
+
+//
+void
+AudioChannelLabelSubDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  MCALabelSubDescriptor::Dump(stream);
+  fprintf(stream, "  %22s = %s\n",  "SoundfieldGroupLinkID", SoundfieldGroupLinkID.EncodeString(identbuf, IdentBufferLen));
+}
+
+//
+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);
+}
+
+//
+ASDCP::Result_t
+AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  assert(m_Dict);
+  m_Typeinfo = &(m_Dict->Type(MDD_AudioChannelLabelSubDescriptor));
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
+//------------------------------------------------------------------------------------------
+// SoundfieldGroupLabelSubDescriptor
+
+//
+ASDCP::Result_t
+SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
+  return result;
+}
+
+//
+ASDCP::Result_t
+SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
+  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID));
+  return result;
+}
+
+//
+void
+SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs)
+{
+  GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID;
+}
+
+//
+void
+SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  MCALabelSubDescriptor::Dump(stream);
+  fprintf(stream, "  %22s:\n",  "GroupOfSoundfieldGroupsLinkID");
+  GroupOfSoundfieldGroupsLinkID.Dump(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);
+}
+
+//
+ASDCP::Result_t
+SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  assert(m_Dict);
+  m_Typeinfo = &(m_Dict->Type(MDD_SoundfieldGroupLabelSubDescriptor));
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
+//------------------------------------------------------------------------------------------
+// GroupOfSoundfieldGroupsLabelSubDescriptor
+
+//
+ASDCP::Result_t
+GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet);
+  return result;
+}
+
+//
+ASDCP::Result_t
+GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet);
+  return result;
+}
+
+//
+void
+GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs)
+{
+}
+
+//
+void
+GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  MCALabelSubDescriptor::Dump(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);
+}
+
+//
+ASDCP::Result_t
+GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  assert(m_Dict);
+  m_Typeinfo = &(m_Dict->Type(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor));
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
 //
 // end Metadata.cpp
 //
diff --git a/src/Metadata.h b/src/Metadata.h
index 891d155..bee893a 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -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
@@ -45,7 +45,6 @@ namespace ASDCP
       //
       class Identification : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Identification);
 	  Identification();
 
 	public:
@@ -61,7 +60,10 @@ namespace ASDCP
           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);
@@ -73,7 +75,6 @@ namespace ASDCP
       //
       class ContentStorage : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(ContentStorage);
 	  ContentStorage();
 
 	public:
@@ -82,7 +83,10 @@ namespace ASDCP
           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);
@@ -94,7 +98,6 @@ namespace ASDCP
       //
       class EssenceContainerData : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(EssenceContainerData);
 	  EssenceContainerData();
 
 	public:
@@ -104,7 +107,10 @@ namespace ASDCP
           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);
@@ -116,7 +122,6 @@ namespace ASDCP
       //
       class GenericPackage : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericPackage);
 	  GenericPackage();
 
 	public:
@@ -128,7 +133,10 @@ namespace ASDCP
           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);
@@ -138,14 +146,16 @@ namespace ASDCP
       //
       class MaterialPackage : public GenericPackage
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(MaterialPackage);
 	  MaterialPackage();
 
 	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);
@@ -157,7 +167,6 @@ namespace ASDCP
       //
       class SourcePackage : public GenericPackage
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(SourcePackage);
 	  SourcePackage();
 
 	public:
@@ -165,7 +174,10 @@ namespace ASDCP
           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);
@@ -177,7 +189,6 @@ namespace ASDCP
       //
       class GenericTrack : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericTrack);
 	  GenericTrack();
 
 	public:
@@ -188,7 +199,10 @@ namespace ASDCP
           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);
@@ -198,14 +212,16 @@ namespace ASDCP
       //
       class StaticTrack : public GenericTrack
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(StaticTrack);
 	  StaticTrack();
 
 	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);
@@ -217,7 +233,6 @@ namespace ASDCP
       //
       class Track : public GenericTrack
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Track);
 	  Track();
 
 	public:
@@ -226,7 +241,10 @@ namespace ASDCP
           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);
@@ -238,7 +256,6 @@ namespace ASDCP
       //
       class StructuralComponent : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(StructuralComponent);
 	  StructuralComponent();
 
 	public:
@@ -247,7 +264,10 @@ namespace ASDCP
           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);
@@ -257,7 +277,6 @@ namespace ASDCP
       //
       class Sequence : public StructuralComponent
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(Sequence);
 	  Sequence();
 
 	public:
@@ -265,7 +284,10 @@ namespace ASDCP
           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);
@@ -277,7 +299,6 @@ namespace ASDCP
       //
       class SourceClip : public StructuralComponent
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(SourceClip);
 	  SourceClip();
 
 	public:
@@ -287,7 +308,10 @@ namespace ASDCP
           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);
@@ -299,7 +323,6 @@ namespace ASDCP
       //
       class TimecodeComponent : public StructuralComponent
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent);
 	  TimecodeComponent();
 
 	public:
@@ -309,7 +332,10 @@ namespace ASDCP
           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);
@@ -321,7 +347,6 @@ namespace ASDCP
       //
       class GenericDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericDescriptor);
 	  GenericDescriptor();
 
 	public:
@@ -330,7 +355,10 @@ namespace ASDCP
           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);
@@ -340,7 +368,6 @@ namespace ASDCP
       //
       class FileDescriptor : public GenericDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(FileDescriptor);
 	  FileDescriptor();
 
 	public:
@@ -352,7 +379,10 @@ namespace ASDCP
           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);
@@ -364,7 +394,6 @@ namespace ASDCP
       //
       class GenericSoundEssenceDescriptor : public FileDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericSoundEssenceDescriptor);
 	  GenericSoundEssenceDescriptor();
 
 	public:
@@ -377,7 +406,10 @@ namespace ASDCP
           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);
@@ -389,7 +421,6 @@ namespace ASDCP
       //
       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor);
 	  WaveAudioDescriptor();
 
 	public:
@@ -400,7 +431,10 @@ namespace ASDCP
           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);
@@ -412,7 +446,6 @@ namespace ASDCP
       //
       class GenericPictureEssenceDescriptor : public FileDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
 	  GenericPictureEssenceDescriptor();
 
 	public:
@@ -424,7 +457,10 @@ namespace ASDCP
           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);
@@ -436,7 +472,6 @@ namespace ASDCP
       //
       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 	  RGBAEssenceDescriptor();
 
 	public:
@@ -445,7 +480,10 @@ namespace ASDCP
           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);
@@ -457,7 +495,6 @@ namespace ASDCP
       //
       class JPEG2000PictureSubDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 	  JPEG2000PictureSubDescriptor();
 
 	public:
@@ -477,7 +514,10 @@ namespace ASDCP
           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);
@@ -489,7 +529,6 @@ namespace ASDCP
       //
       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
 	  CDCIEssenceDescriptor();
 
 	public:
@@ -500,7 +539,10 @@ namespace ASDCP
           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);
@@ -512,7 +554,6 @@ namespace ASDCP
       //
       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 	  MPEG2VideoDescriptor();
 
 	public:
@@ -523,7 +564,10 @@ namespace ASDCP
           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);
@@ -535,7 +579,6 @@ namespace ASDCP
       //
       class DMSegment : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(DMSegment);
 	  DMSegment();
 
 	public:
@@ -547,7 +590,10 @@ namespace ASDCP
           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);
@@ -559,7 +605,6 @@ namespace ASDCP
       //
       class CryptographicFramework : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 	  CryptographicFramework();
 
 	public:
@@ -567,7 +612,10 @@ namespace ASDCP
           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);
@@ -579,7 +627,6 @@ namespace ASDCP
       //
       class CryptographicContext : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 	  CryptographicContext();
 
 	public:
@@ -591,7 +638,10 @@ namespace ASDCP
           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);
@@ -603,7 +653,6 @@ namespace ASDCP
       //
       class GenericDataEssenceDescriptor : public FileDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(GenericDataEssenceDescriptor);
 	  GenericDataEssenceDescriptor();
 
 	public:
@@ -611,7 +660,10 @@ namespace ASDCP
           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);
@@ -623,7 +675,6 @@ namespace ASDCP
       //
       class TimedTextDescriptor : public GenericDataEssenceDescriptor
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(TimedTextDescriptor);
 	  TimedTextDescriptor();
 
 	public:
@@ -633,7 +684,10 @@ namespace ASDCP
           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);
@@ -645,7 +699,6 @@ namespace ASDCP
       //
       class TimedTextResourceSubDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(TimedTextResourceSubDescriptor);
 	  TimedTextResourceSubDescriptor();
 
 	public:
@@ -655,7 +708,10 @@ namespace ASDCP
           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);
@@ -667,14 +723,16 @@ namespace ASDCP
       //
       class StereoscopicPictureSubDescriptor : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(StereoscopicPictureSubDescriptor);
 	  StereoscopicPictureSubDescriptor();
 
 	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);
@@ -686,7 +744,6 @@ namespace ASDCP
       //
       class NetworkLocator : public InterchangeObject
 	{
-	  ASDCP_NO_COPY_CONSTRUCT(NetworkLocator);
 	  NetworkLocator();
 
 	public:
@@ -694,7 +751,10 @@ namespace ASDCP
           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);
@@ -703,6 +763,98 @@ namespace ASDCP
 	  virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 	};
 
+      //
+      class MCALabelSubDescriptor : public InterchangeObject
+	{
+	  MCALabelSubDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+          UL MCALabelDictionaryID;
+          UUID MCALinkID;
+          UTF16String MCATagSymbol;
+          UTF16String MCATagName;
+          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&);
+	};
+
+      //
+      class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor
+	{
+	  AudioChannelLabelSubDescriptor();
+
+	public:
+	  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&);
+	};
+
+      //
+      class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor
+	{
+	  SoundfieldGroupLabelSubDescriptor();
+
+	public:
+	  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&);
+	};
+
+      //
+      class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor
+	{
+	  GroupOfSoundfieldGroupsLabelSubDescriptor();
+
+	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&);
+	};
+
     } // namespace MXF
 } // namespace ASDCP