working multi-dict

20 files changed, 414 insertions, 309 deletions

diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index 20e3e8c..ed8a923 100755
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -359,7 +359,7 @@ lh__Reader::ReadFrame(ui32_t FrameNum, JP2K::FrameBuffer& FrameBuf,
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict.ul(MDD_JPEG2000Essence), Ctx, HMAC);
+  return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_JPEG2000Essence), Ctx, HMAC);
 }
 
 
@@ -547,7 +547,7 @@ public:
       {
 	ui32_t SequenceNum = FrameNum * 2;
 	SequenceNum += ( phase == SP_RIGHT ) ? 2 : 1;
-	result = ReadEKLVPacket(FrameNum, SequenceNum, FrameBuf, m_Dict.ul(MDD_JPEG2000Essence), Ctx, HMAC);
+	result = ReadEKLVPacket(FrameNum, SequenceNum, FrameBuf, m_Dict->ul(MDD_JPEG2000Essence), Ctx, HMAC);
       }
 
     return result;
@@ -708,12 +708,12 @@ lh__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc)
 
   if ( PDesc.StoredWidth < 2049 )
     {
-      PDescObj->PictureEssenceCoding.Set(m_Dict.ul(MDD_JP2KEssenceCompression_2K));
+      PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_2K));
       m_EssenceSubDescriptor->Rsize = 3;
     }
   else
     {
-      PDescObj->PictureEssenceCoding.Set(m_Dict.ul(MDD_JP2KEssenceCompression_4K));
+      PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_4K));
       m_EssenceSubDescriptor->Rsize = 4;
     }
 
@@ -806,13 +806,13 @@ lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& l
   Result_t result = JP2K_PDesc_to_MD(m_PDesc);
 
   if ( ASDCP_SUCCESS(result) )
-      result = WriteMXFHeader(label, UL(m_Dict.ul(MDD_JPEG_2000Wrapping)),
-			      PICT_DEF_LABEL,     UL(m_Dict.ul(MDD_PictureDataDef)),
+      result = WriteMXFHeader(label, UL(m_Dict->ul(MDD_JPEG_2000Wrapping)),
+			      PICT_DEF_LABEL,     UL(m_Dict->ul(MDD_PictureDataDef)),
 			      LocalEditRate, 24 /* TCFrameRate */);
 
   if ( ASDCP_SUCCESS(result) )
     {
-      memcpy(m_EssenceUL, m_Dict.ul(MDD_JPEG2000Essence), SMPTE_UL_LENGTH);
+      memcpy(m_EssenceUL, m_Dict->ul(MDD_JPEG2000Essence), SMPTE_UL_LENGTH);
       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
       result = m_State.Goto_READY();
     }
diff --git a/src/AS_DCP_MPEG2.cpp b/src/AS_DCP_MPEG2.cpp
index 580c08f..2370319 100755
--- a/src/AS_DCP_MPEG2.cpp
+++ b/src/AS_DCP_MPEG2.cpp
@@ -255,7 +255,7 @@ ASDCP::MPEG2::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& Fram
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  Result_t result = ReadEKLVFrame(FrameNum, FrameBuf, m_Dict.ul(MDD_MPEG2Essence), Ctx, HMAC);
+  Result_t result = ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_MPEG2Essence), Ctx, HMAC);
 
   if ( ASDCP_FAILURE(result) )
     return result;
@@ -460,13 +460,13 @@ ASDCP::MPEG2::MXFWriter::h__Writer::SetSourceStream(const VideoDescriptor& VDesc
   Result_t result = MPEG2_VDesc_to_MD(m_VDesc, (MPEG2VideoDescriptor*)m_EssenceDescriptor);
 
   if ( ASDCP_SUCCESS(result) )
-      result = WriteMXFHeader(MPEG_PACKAGE_LABEL, UL(m_Dict.ul(MDD_MPEG2_VESWrapping)), 
-			      PICT_DEF_LABEL,     UL(m_Dict.ul(MDD_PictureDataDef)),
+      result = WriteMXFHeader(MPEG_PACKAGE_LABEL, UL(m_Dict->ul(MDD_MPEG2_VESWrapping)), 
+			      PICT_DEF_LABEL,     UL(m_Dict->ul(MDD_PictureDataDef)),
 			      m_VDesc.EditRate, 24 /* TCFrameRate */);
 
   if ( ASDCP_SUCCESS(result) )
     {
-      memcpy(m_EssenceUL, m_Dict.ul(MDD_MPEG2Essence), SMPTE_UL_LENGTH);
+      memcpy(m_EssenceUL, m_Dict->ul(MDD_MPEG2Essence), SMPTE_UL_LENGTH);
       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
       result = m_State.Goto_READY();
     }
diff --git a/src/AS_DCP_MXF.cpp b/src/AS_DCP_MXF.cpp
index f8a415b..8ce4c55 100755
--- a/src/AS_DCP_MXF.cpp
+++ b/src/AS_DCP_MXF.cpp
@@ -163,7 +163,7 @@ ASDCP::MD_to_CryptoInfo(CryptographicContext* InfoObj, WriterInfo& Info, const D
 ASDCP::Result_t
 ASDCP::EssenceType(const char* filename, EssenceType_t& type)
 {
-  const Dictionary& m_Dict = DefaultCompositeDict();
+  const Dictionary* m_Dict = &DefaultCompositeDict();
 
   ASDCP_TEST_NULL_STR(filename);
   Kumu::FileReader   Reader;
diff --git a/src/AS_DCP_PCM.cpp b/src/AS_DCP_PCM.cpp
index 6ca3a77..b709e8d 100755
--- a/src/AS_DCP_PCM.cpp
+++ b/src/AS_DCP_PCM.cpp
@@ -267,7 +267,7 @@ ASDCP::PCM::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& FrameB
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict.ul(MDD_WAVEssence), Ctx, HMAC);
+  return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_WAVEssence), Ctx, HMAC);
 }
 
 //------------------------------------------------------------------------------------------
@@ -444,13 +444,13 @@ ASDCP::PCM::MXFWriter::h__Writer::SetSourceStream(const AudioDescriptor& ADesc)
   Result_t result = PCM_ADesc_to_MD(m_ADesc, (WaveAudioDescriptor*)m_EssenceDescriptor);
   
   if ( ASDCP_SUCCESS(result) )
-      result = WriteMXFHeader(PCM_PACKAGE_LABEL, UL(m_Dict.ul(MDD_WAVWrapping)),
-			      SOUND_DEF_LABEL,   UL(m_Dict.ul(MDD_SoundDataDef)),
+      result = WriteMXFHeader(PCM_PACKAGE_LABEL, UL(m_Dict->ul(MDD_WAVWrapping)),
+			      SOUND_DEF_LABEL,   UL(m_Dict->ul(MDD_SoundDataDef)),
 			      m_ADesc.SampleRate, 24 /* TCFrameRate */, calc_CBR_frame_size(m_Info, m_ADesc));
 
   if ( ASDCP_SUCCESS(result) )
     {
-      memcpy(m_EssenceUL, m_Dict.ul(MDD_WAVEssence), SMPTE_UL_LENGTH);
+      memcpy(m_EssenceUL, m_Dict->ul(MDD_WAVEssence), SMPTE_UL_LENGTH);
       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
       result = m_State.Goto_READY();
     }
diff --git a/src/AS_DCP_TimedText.cpp b/src/AS_DCP_TimedText.cpp
index c319850..39a5c1a 100644
--- a/src/AS_DCP_TimedText.cpp
+++ b/src/AS_DCP_TimedText.cpp
@@ -233,7 +233,7 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadTimedTextResource(FrameBuffer& Frame
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  Result_t result = ReadEKLVFrame(0, FrameBuf, m_Dict.ul(MDD_TimedTextEssence), Ctx, HMAC);
+  Result_t result = ReadEKLVFrame(0, FrameBuf, m_Dict->ul(MDD_TimedTextEssence), Ctx, HMAC);
 
  if( ASDCP_SUCCESS(result) )
    {
@@ -318,7 +318,7 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
 
 	      // read the essence packet
 	      if( ASDCP_SUCCESS(result) )
-		result = ReadEKLVPacket(0, 1, FrameBuf, m_Dict.ul(MDD_GenericStream_DataElement), Ctx, HMAC);
+		result = ReadEKLVPacket(0, 1, FrameBuf, m_Dict->ul(MDD_GenericStream_DataElement), Ctx, HMAC);
 	    }
 	}
     }
@@ -520,9 +520,9 @@ ASDCP::TimedText::MXFWriter::h__Writer::SetSourceStream(ASDCP::TimedText::TimedT
     {
       InitHeader();
       AddDMSegment(m_TDesc.EditRate, 24, TIMED_TEXT_DEF_LABEL,
-		   UL(m_Dict.ul(MDD_PictureDataDef)), TIMED_TEXT_PACKAGE_LABEL);
+		   UL(m_Dict->ul(MDD_PictureDataDef)), TIMED_TEXT_PACKAGE_LABEL);
 
-      AddEssenceDescriptor(UL(m_Dict.ul(MDD_TimedTextWrapping)));
+      AddEssenceDescriptor(UL(m_Dict->ul(MDD_TimedTextWrapping)));
 
       result = m_HeaderPart.WriteToFile(m_File, m_HeaderSize);
       
@@ -532,7 +532,7 @@ ASDCP::TimedText::MXFWriter::h__Writer::SetSourceStream(ASDCP::TimedText::TimedT
 
   if ( ASDCP_SUCCESS(result) )
     {
-      memcpy(m_EssenceUL, m_Dict.ul(MDD_TimedTextEssence), SMPTE_UL_LENGTH);
+      memcpy(m_EssenceUL, m_Dict->ul(MDD_TimedTextEssence), SMPTE_UL_LENGTH);
       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
       result = m_State.Goto_READY();
     }
@@ -585,7 +585,7 @@ ASDCP::TimedText::MXFWriter::h__Writer::WriteAncillaryResource(const ASDCP::Time
   Kumu::fpos_t here = m_File.Tell();
 
   // create generic stream partition header
-  static UL GenericStream_DataElement(m_Dict.ul(MDD_GenericStream_DataElement));
+  static UL GenericStream_DataElement(m_Dict->ul(MDD_GenericStream_DataElement));
   MXF::Partition GSPart(m_Dict);
 
   GSPart.ThisPartition = here;
@@ -594,8 +594,8 @@ ASDCP::TimedText::MXFWriter::h__Writer::WriteAncillaryResource(const ASDCP::Time
   GSPart.OperationalPattern = m_HeaderPart.OperationalPattern;
 
   m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(m_EssenceStreamID++, here));
-  GSPart.EssenceContainers.push_back(UL(m_Dict.ul(MDD_TimedTextEssence)));
-  UL TmpUL(m_Dict.ul(MDD_GenericStreamPartition));
+  GSPart.EssenceContainers.push_back(UL(m_Dict->ul(MDD_TimedTextEssence)));
+  UL TmpUL(m_Dict->ul(MDD_GenericStreamPartition));
   Result_t result = GSPart.WriteToFile(m_File, TmpUL);
 
   if ( ASDCP_SUCCESS(result) )
diff --git a/src/AS_DCP_internal.h b/src/AS_DCP_internal.h
index af2c0c1..d55d337 100755
--- a/src/AS_DCP_internal.h
+++ b/src/AS_DCP_internal.h
@@ -114,7 +114,7 @@ namespace ASDCP
       h__Reader();
 
     public:
-      const Dictionary&  m_Dict;
+      const Dictionary*  m_Dict;
       Kumu::FileReader   m_File;
       OPAtomHeader       m_HeaderPart;
       Partition          m_BodyPart;
@@ -186,7 +186,7 @@ namespace ASDCP
       h__Writer();
 
     public:
-      const Dictionary&  m_Dict;
+      const Dictionary*  m_Dict;
       Kumu::FileWriter   m_File;
       ui32_t             m_HeaderSize;
       OPAtomHeader       m_HeaderPart;
diff --git a/src/Dict.cpp b/src/Dict.cpp
index deb05d8..aaef990 100755
--- a/src/Dict.cpp
+++ b/src/Dict.cpp
@@ -31,67 +31,165 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "KM_mutex.h"
+#include "KM_log.h"
 #include "KLV.h"
 #include "MDD.cpp"
 
 //------------------------------------------------------------------------------------------
 
-//static ASDCP::Dictionary s_SMPTEDict;
-//static ASDCP::Dictionary s_InteropDict;
+// The composite dict is the union of the SMPTE and Interop dicts
+//
+static ASDCP::Dictionary s_CompositeDict;
+static Kumu::Mutex s_CompositeDictLock;
+static bool s_CompositeDictInit = false;
 
+//
 const ASDCP::Dictionary&
-ASDCP::DefaultSMPTEDict() {
-  // return s_SMPTEDict;
-  return DefaultCompositeDict();
+ASDCP::DefaultCompositeDict()
+{
+  if ( ! s_CompositeDictInit )
+    {
+      Kumu::AutoMutex AL(s_CompositeDictLock);
+
+      if ( ! s_CompositeDictInit )
+	{
+	  s_CompositeDict.Init();
+	  s_CompositeDictInit = true;
+	}
+    }
+
+  return s_CompositeDict;
 }
 
+//
+//
+static ASDCP::Dictionary s_InteropDict;
+static Kumu::Mutex s_InteropDictLock;
+static bool s_InteropDictInit = false;
+
+//
 const ASDCP::Dictionary&
-ASDCP::DefaultInteropDict() {
-  // return s_InteropDict;
-  return DefaultCompositeDict();
+ASDCP::DefaultInteropDict()
+{
+  if ( ! s_InteropDictInit )
+    {
+      Kumu::AutoMutex AL(s_InteropDictLock);
+
+      if ( ! s_InteropDictInit )
+	{
+	  s_InteropDict.Init();
+
+	  s_InteropDict.AddEntry(s_InteropDict.Type(MDD_MXFInterop_OPAtom), MDD_OPAtom);
+	  s_InteropDict.AddEntry(s_InteropDict.Type(MDD_MXFInterop_CryptEssence), MDD_CryptEssence);
+	  s_InteropDict.AddEntry(s_InteropDict.Type(MDD_MXFInterop_GenericDescriptor_SubDescriptors),
+				     MDD_GenericDescriptor_SubDescriptors);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextWrapping);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextEssence);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextDescriptor);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextDescriptor_ResourceID);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextDescriptor_UCSEncoding);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextDescriptor_NamespaceURI);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextResourceSubDescriptor);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextResourceSubDescriptor_AncillaryResourceID);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextResourceSubDescriptor_MIMEMediaType);
+	  s_InteropDict.DeleteEntry(MDD_TimedTextResourceSubDescriptor_EssenceStreamID);
+	  s_InteropDict.DeleteEntry(MDD_GenericStreamPartition);
+	  s_InteropDict.DeleteEntry(MDD_StereoscopicPictureSubDescriptor);
+	  s_InteropDict.DeleteEntry(MDD_GenericStream_DataElement);
+
+	  s_InteropDictInit = true;
+	}
+    }
+
+  return s_InteropDict;
 }
 
 //
 //
-static ASDCP::Dictionary s_CompositeDict;
-static Kumu::Mutex s_Lock;
-static bool s_md_init = false;
+static ASDCP::Dictionary s_SMPTEDict;
+static Kumu::Mutex s_SMPTEDictLock;
+static bool s_SMPTEDictInit = false;
 
 //
 const ASDCP::Dictionary&
-ASDCP::DefaultCompositeDict()
+ASDCP::DefaultSMPTEDict()
 {
-  if ( ! s_md_init )
+  if ( ! s_SMPTEDictInit )
     {
-      Kumu::AutoMutex AL(s_Lock);
+      Kumu::AutoMutex AL(s_SMPTEDictLock);
 
-      if ( ! s_md_init )
+      if ( ! s_SMPTEDictInit )
 	{
-	  for ( ui32_t x = 0; x < ASDCP::MDD_Table_size; x++ )
-	    s_CompositeDict.AddEntry(s_MDD_Table[x], x);
-	  //	    s_md_lookup.insert(std::map<UL, ui32_t>::value_type(UL(s_MDD_Table[x].ul), x));
+	  s_SMPTEDict.Init();
 
-	  s_md_init = true;
+	  s_SMPTEDict.DeleteEntry(MDD_MXFInterop_OPAtom);
+	  s_SMPTEDict.DeleteEntry(MDD_MXFInterop_CryptEssence);
+	  s_SMPTEDict.DeleteEntry(MDD_MXFInterop_GenericDescriptor_SubDescriptors);
+
+	  s_SMPTEDictInit = true;
 	}
     }
 
-  return s_CompositeDict;
+  return s_SMPTEDict;
 }
 
+
 //------------------------------------------------------------------------------------------
 //
 
 ASDCP::Dictionary::Dictionary() {}
 ASDCP::Dictionary::~Dictionary() {}
 
+//
+void
+ASDCP::Dictionary::Init()
+{
+  m_md_lookup.clear();
+  memset(m_MDD_Table, 0, sizeof(m_MDD_Table));
+
+  for ( ui32_t x = 0; x < ASDCP::MDD_Table_size; x++ )
+    AddEntry(s_MDD_Table[x], x);
+}
 
 //
 bool
 ASDCP::Dictionary::AddEntry(const MDDEntry& Entry, ui32_t index)
 {
-  m_MDD_Table[index] = Entry;
+  bool result = true;
+  // is this index already there?
+  std::map<ui32_t, ASDCP::UL>::iterator rii = m_md_rev_lookup.find(index);
+
+  if ( rii != m_md_rev_lookup.end() )
+    {
+      DeleteEntry(index);
+      result = false;
+    }
+
   m_md_lookup.insert(std::map<UL, ui32_t>::value_type(UL(Entry.ul), index));
-  return true;
+  m_md_rev_lookup.insert(std::map<ui32_t, UL>::value_type(index, UL(Entry.ul)));
+  m_MDD_Table[index] = Entry;
+
+  return result;
+}
+
+//
+bool
+ASDCP::Dictionary::DeleteEntry(ui32_t index)
+{
+  // is this index already there?
+  std::map<ui32_t, ASDCP::UL>::iterator rii = m_md_rev_lookup.find(index);
+
+  if ( rii != m_md_rev_lookup.end() )
+    {
+      std::map<ASDCP::UL, ui32_t>::iterator ii = m_md_lookup.find(rii->second);
+      assert(ii != m_md_lookup.end());
+
+      char buf[64];
+      Kumu::DefaultLogSink().Warn("Deleting %s: %s\n", ii->first.EncodeString(buf, 64), m_MDD_Table[index].name);
+      return true;
+    }
+
+  return false;
 }
 
 //
diff --git a/src/Index.cpp b/src/Index.cpp
index e231f8e..2449937 100755
--- a/src/Index.cpp
+++ b/src/Index.cpp
@@ -34,7 +34,7 @@ const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
 
 
 //
-ASDCP::MXF::IndexTableSegment::IndexTableSegment(const Dictionary& d) :
+ASDCP::MXF::IndexTableSegment::IndexTableSegment(const Dictionary*& d) :
   InterchangeObject(d), m_Dict(d),
   IndexStartPosition(0), IndexDuration(0), EditUnitByteCount(0),
   IndexSID(129), BodySID(1), SliceCount(0), PosTableCount(0)
@@ -86,7 +86,7 @@ ASDCP::MXF::IndexTableSegment::WriteToTLVSet(TLVWriter& TLVSet)
 ASDCP::Result_t
 ASDCP::MXF::IndexTableSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_IndexTableSegment);
+  m_Typeinfo = &(m_Dict->Type(MDD_IndexTableSegment));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -94,7 +94,7 @@ ASDCP::MXF::IndexTableSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::IndexTableSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_IndexTableSegment);
+  m_Typeinfo = &(m_Dict->Type(MDD_IndexTableSegment));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
diff --git a/src/KLV.h b/src/KLV.h
index 1a5c298..ca455fc 100755
--- a/src/KLV.h
+++ b/src/KLV.h
@@ -137,27 +137,21 @@ inline const char* ui64sz(ui64_t i, char* buf)
   //
   class Dictionary
     {
-    public:
-#if 0
-      static const MDDEntry* FindName(const char*);
-      static const MDDEntry& Type(MDD_t type_id);
-      static bool            Replace(const MDDEntry& Entry);
-      static void            Restore(const byte_t* ul);
-      static void            RestoreAll();
-#endif
-
-    private:
       std::map<ASDCP::UL, ui32_t> m_md_lookup;
+      std::map<ui32_t, ASDCP::UL> m_md_rev_lookup;
       MDDEntry m_MDD_Table[ASDCP::MDD_Table_size];
 
       ASDCP_NO_COPY_CONSTRUCT(Dictionary);
 
-
     public:
       Dictionary();
       ~Dictionary();
 
+      bool operator==(const Dictionary& rhs) const { return this == &rhs; }
+
+      void Init();
       bool AddEntry(const MDDEntry& Entry, ui32_t index);
+      bool DeleteEntry(ui32_t index);
 
       const MDDEntry* FindUL(const byte_t*) const;
       const MDDEntry& Type(MDD_t type_id) const;
diff --git a/src/MDD.cpp b/src/MDD.cpp
index 9ddca06..27c4cf1 100644
--- a/src/MDD.cpp
+++ b/src/MDD.cpp
@@ -853,7 +853,7 @@ static const ASDCP::MDDEntry s_MDD_Table[] = {
     {0x00, 0x00}, false, "GenericStream_DataElement" },
   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 272
       0x06, 0x01, 0x01, 0x04, 0x06, 0x10, 0x00, 0x00 },
-      {0}, true, "GenericDescriptor_MXFInterop_SubDescriptors" },
+      {0}, true, "MXFInterop_GenericDescriptor_SubDescriptors" },
 
   { {0}, {0}, false, 0 }
 };
diff --git a/src/MDD.h b/src/MDD.h
index 758096f..7633471 100755
--- a/src/MDD.h
+++ b/src/MDD.h
@@ -307,7 +307,7 @@ namespace ASDCP {
 	MDD_StereoscopicPictureSubDescriptor, // 269
         MDD_WaveAudioDescriptor_ChannelAssignment,  // 270
 	MDD_GenericStream_DataElement, // 271
-        MDD_GenericDescriptor_MXFInterop_SubDescriptors,  // 272
+        MDD_MXFInterop_GenericDescriptor_SubDescriptors,  // 272
 	MDD_Max
     }; // enum MDD_t
 
diff --git a/src/MXF.cpp b/src/MXF.cpp
index 9d20dcd..97d834e 100755
--- a/src/MXF.cpp
+++ b/src/MXF.cpp
@@ -113,7 +113,7 @@ ASDCP::MXF::RIP::GetPairBySID(ui32_t SID, Pair& outPair) const
 ASDCP::Result_t
 ASDCP::MXF::RIP::InitFromFile(const Kumu::FileReader& Reader)
 {
-  Result_t result = KLVFilePacket::InitFromFile(Reader, m_Dict.ul(MDD_RandomIndexMetadata));
+  Result_t result = KLVFilePacket::InitFromFile(Reader, m_Dict->ul(MDD_RandomIndexMetadata));
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -136,7 +136,7 @@ ASDCP::MXF::RIP::WriteToFile(Kumu::FileWriter& Writer)
   Result_t result = Buffer.Capacity(RIPSize);
 
   if ( ASDCP_SUCCESS(result) )
-    result = WriteKLToFile(Writer, m_Dict.ul(MDD_RandomIndexMetadata), RIPSize);
+    result = WriteKLToFile(Writer, m_Dict->ul(MDD_RandomIndexMetadata), RIPSize);
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -164,7 +164,7 @@ ASDCP::MXF::RIP::Dump(FILE* stream)
   if ( stream == 0 )
     stream = stderr;
 
-  KLVFilePacket::Dump(stream, m_Dict, false);
+  KLVFilePacket::Dump(stream, *m_Dict, false);
   PairArray.Dump(stream, false);
 }
 
@@ -251,7 +251,7 @@ public:
 //
 
 
-ASDCP::MXF::Partition::Partition(const Dictionary& d) :
+ASDCP::MXF::Partition::Partition(const Dictionary*& d) :
   m_Dict(d),
   MajorVersion(1), MinorVersion(2),
   KAGSize(1), ThisPartition(0), PreviousPartition(0),
@@ -384,7 +384,7 @@ ASDCP::MXF::Partition::Dump(FILE* stream)
   if ( stream == 0 )
     stream = stderr;
 
-  KLVFilePacket::Dump(stream, m_Dict, false);
+  KLVFilePacket::Dump(stream, *m_Dict, false);
   fprintf(stream, "  MajorVersion       = %hu\n", MajorVersion);
   fprintf(stream, "  MinorVersion       = %hu\n", MinorVersion);
   fprintf(stream, "  KAGSize            = %u\n",  KAGSize);
@@ -418,7 +418,7 @@ 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) {}
 
 //
 ASDCP::MXF::Primer::~Primer() {}
@@ -435,7 +435,7 @@ ASDCP::MXF::Primer::ClearTagList()
 ASDCP::Result_t
 ASDCP::MXF::Primer::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  Result_t result = KLVPacket::InitFromBuffer(p, l, m_Dict.ul(MDD_Primer));
+  Result_t result = KLVPacket::InitFromBuffer(p, l, m_Dict->ul(MDD_Primer));
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -482,7 +482,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, m_Dict->ul(MDD_Primer), packet_length);
 
       if ( ASDCP_SUCCESS(result) )
 	Buffer.Size(Buffer.Size() + packet_length);
@@ -556,7 +556,7 @@ ASDCP::MXF::Primer::Dump(FILE* stream)
   if ( stream == 0 )
     stream = stderr;
 
-  KLVPacket::Dump(stream, m_Dict, false);
+  KLVPacket::Dump(stream, *m_Dict, false);
   fprintf(stream, "Primer: %u %s\n",
 	  (ui32_t)LocalTagEntryBatch.size(),
 	  ( LocalTagEntryBatch.size() == 1 ? "entry" : "entries" ));
@@ -564,7 +564,7 @@ ASDCP::MXF::Primer::Dump(FILE* stream)
   Batch<LocalTagEntry>::iterator i = LocalTagEntryBatch.begin();
   for ( ; i != LocalTagEntryBatch.end(); i++ )
     {
-      const MDDEntry* Entry = m_Dict.FindUL((*i).UL.Value());
+      const MDDEntry* Entry = m_Dict->FindUL((*i).UL.Value());
       fprintf(stream, "  %s %s\n", (*i).EncodeString(identbuf, IdentBufferLen), (Entry ? Entry->name : "Unknown"));
     }
 }
@@ -611,7 +611,7 @@ ASDCP::MXF::Preface::WriteToTLVSet(TLVWriter& TLVSet)
 ASDCP::Result_t
 ASDCP::MXF::Preface::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Preface);
+  m_Typeinfo = &(m_Dict->Type(MDD_Preface));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -619,7 +619,7 @@ ASDCP::MXF::Preface::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ASDCP::MXF::Preface::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Preface);
+  m_Typeinfo = &(m_Dict->Type(MDD_Preface));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -647,7 +647,7 @@ ASDCP::MXF::Preface::Dump(FILE* stream)
 //------------------------------------------------------------------------------------------
 //
 
-ASDCP::MXF::OPAtomHeader::OPAtomHeader(const Dictionary& d) : Partition(d), m_Dict(d), m_RIP(d), m_Primer(d), m_Preface(0), m_HasRIP(false) {}
+ASDCP::MXF::OPAtomHeader::OPAtomHeader(const Dictionary*& d) : Partition(d), m_Dict(d), m_RIP(d), m_Primer(d), m_Preface(0), m_HasRIP(false) {}
 ASDCP::MXF::OPAtomHeader::~OPAtomHeader() {}
 
 //
@@ -702,15 +702,26 @@ ASDCP::MXF::OPAtomHeader::InitFromFile(const Kumu::FileReader& Reader)
     return result;
 
   // is it really OP-Atom?
-  UL OPAtomUL(m_Dict.ul(MDD_OPAtom));
-  UL InteropOPAtomUL(m_Dict.ul(MDD_MXFInterop_OPAtom));
+  UL OPAtomUL(m_Dict->ul(MDD_OPAtom));
+  UL InteropOPAtomUL(m_Dict->ul(MDD_MXFInterop_OPAtom));
 
-  if ( ! ( OperationalPattern == OPAtomUL  || OperationalPattern == InteropOPAtomUL ) )
+  if ( OperationalPattern == OPAtomUL ) // SMPTE
+    {
+      if ( m_Dict == &DefaultCompositeDict() )
+	m_Dict = &DefaultSMPTEDict();
+    }
+  else if ( OperationalPattern == InteropOPAtomUL ) // Interop
+    {
+      if ( m_Dict == &DefaultCompositeDict() )
+	m_Dict = &DefaultInteropDict();
+    }
+  else
     {
       char strbuf[IdentBufferLen];
-      const MDDEntry* Entry = m_Dict.FindUL(OperationalPattern.Value());
+      const MDDEntry* Entry = m_Dict->FindUL(OperationalPattern.Value());
       if ( Entry == 0 )
-	DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", OperationalPattern.EncodeString(strbuf, IdentBufferLen));
+	DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n",
+			      OperationalPattern.EncodeString(strbuf, IdentBufferLen));
       else
 	DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", Entry->name);
     }
@@ -783,11 +794,11 @@ ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l)
 
       if ( ASDCP_SUCCESS(result) )
 	{
-	  if ( object->IsA(m_Dict.ul(MDD_KLVFill)) )
+	  if ( object->IsA(m_Dict->ul(MDD_KLVFill)) )
 	    {
 	      delete object;
 	    }
-	  else if ( object->IsA(m_Dict.ul(MDD_Primer)) )
+	  else if ( object->IsA(m_Dict->ul(MDD_Primer)) )
 	    {
 	      delete object;
 	      result = m_Primer.InitFromBuffer(redo_p, end_p - redo_p);
@@ -796,7 +807,7 @@ ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l)
 	    {
 	      m_PacketList->AddPacket(object);
 
-	      if ( object->IsA(m_Dict.ul(MDD_Preface)) && m_Preface == 0 )
+	      if ( object->IsA(m_Dict->ul(MDD_Preface)) && m_Preface == 0 )
 		m_Preface = (Preface*)object;
 	    }
 	}
@@ -894,7 +905,7 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSiz
 
   if ( ASDCP_SUCCESS(result) )
     {
-      UL TmpUL(m_Dict.ul(MDD_ClosedCompleteHeader));
+      UL TmpUL(m_Dict->ul(MDD_ClosedCompleteHeader));
       result = Partition::WriteToFile(Writer, TmpUL);
     }
 
@@ -932,7 +943,7 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSiz
 	}
 
       klv_fill_length -= kl_length;
-      result = WriteKLToFile(Writer, m_Dict.ul(MDD_KLVFill), klv_fill_length);
+      result = WriteKLToFile(Writer, m_Dict->ul(MDD_KLVFill), klv_fill_length);
 
       if ( ASDCP_SUCCESS(result) )
 	result = NilBuf.Capacity(klv_fill_length);
@@ -970,7 +981,7 @@ ASDCP::MXF::OPAtomHeader::Dump(FILE* stream)
 //------------------------------------------------------------------------------------------
 //
 
-ASDCP::MXF::OPAtomIndexFooter::OPAtomIndexFooter(const Dictionary& d) :
+ASDCP::MXF::OPAtomIndexFooter::OPAtomIndexFooter(const Dictionary*& d) :
   Partition(d), m_Dict(d),
   m_CurrentSegment(0), m_BytesPerEditUnit(0), m_BodySID(0),
   m_ECOffset(0), m_Lookup(0)
@@ -1109,7 +1120,7 @@ ASDCP::MXF::OPAtomIndexFooter::WriteToFile(Kumu::FileWriter& Writer, ui64_t dura
   if ( ASDCP_SUCCESS(result) )
     {
       IndexByteCount = FooterBuffer.Size();
-      UL FooterUL(m_Dict.ul(MDD_CompleteFooter));
+      UL FooterUL(m_Dict->ul(MDD_CompleteFooter));
       result = Partition::WriteToFile(Writer, FooterUL);
     }
 
@@ -1313,7 +1324,7 @@ ASDCP::MXF::InterchangeObject::Dump(FILE* stream)
   char identbuf[IdentBufferLen];
 
   fputc('\n', stream);
-  KLVPacket::Dump(stream, m_Dict, false);
+  KLVPacket::Dump(stream, *m_Dict, false);
   fprintf(stream, "             InstanceUID = %s\n",  InstanceUID.EncodeHex(identbuf, IdentBufferLen));
   fprintf(stream, "           GenerationUID = %s\n",  GenerationUID.EncodeHex(identbuf, IdentBufferLen));
 }
@@ -1380,7 +1391,7 @@ ASDCP::MXF::SetObjectFactory(ASDCP::UL label, ASDCP::MXF::MXFObjectFactory_t fac
 
 //
 ASDCP::MXF::InterchangeObject*
-ASDCP::MXF::CreateObject(const Dictionary& Dict, const UL& label)
+ASDCP::MXF::CreateObject(const Dictionary*& Dict, const UL& label)
 {
   if ( ! s_TypesInit )
     {
diff --git a/src/MXF.h b/src/MXF.h
index 989a53b..3ae2c85 100755
--- a/src/MXF.h
+++ b/src/MXF.h
@@ -41,13 +41,13 @@ namespace ASDCP
       class InterchangeObject;
 
       //
-      typedef ASDCP::MXF::InterchangeObject* (*MXFObjectFactory_t)(const Dictionary&);
+      typedef ASDCP::MXF::InterchangeObject* (*MXFObjectFactory_t)(const Dictionary*&);
 
       //
       void SetObjectFactory(UL label, MXFObjectFactory_t factory);
 
       //
-      InterchangeObject* CreateObject(const Dictionary& Dict, const UL& label);
+      InterchangeObject* CreateObject(const Dictionary*& Dict, const UL& label);
 
 
       // seek an open file handle to the start of the RIP KLV packet
@@ -95,10 +95,10 @@ namespace ASDCP
 	      }
 	    };
 
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 	  Array<Pair> PairArray;
 
-	RIP(const Dictionary& d) : m_Dict(d) {}
+	RIP(const Dictionary*& d) : m_Dict(d) {}
 	  virtual ~RIP() {}
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
 	  virtual Result_t WriteToFile(Kumu::FileWriter& Writer);
@@ -118,7 +118,7 @@ namespace ASDCP
 	  mem_ptr<h__PacketList> m_PacketList;
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 
 	  ui16_t    MajorVersion;
 	  ui16_t    MinorVersion;
@@ -134,7 +134,7 @@ namespace ASDCP
 	  UL        OperationalPattern;
 	  Batch<UL> EssenceContainers;
 
-	  Partition(const Dictionary&);
+	  Partition(const Dictionary*&);
 	  virtual ~Partition();
 	  virtual void     AddChildObject(InterchangeObject*);
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
@@ -185,9 +185,9 @@ namespace ASDCP
 	    };
 
 	  Batch<LocalTagEntry> LocalTagEntryBatch;
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 
-	  Primer(const Dictionary&);
+	  Primer(const Dictionary*&);
 	  virtual ~Primer();
 
 	  virtual void     ClearTagList();
@@ -210,12 +210,12 @@ namespace ASDCP
 	  const MDDEntry* m_Typeinfo;
 
 	public:
-	  const Dictionary& m_Dict;
+	  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_Typeinfo(0), m_Dict(d), m_Lookup(0) {}
 	  virtual ~InterchangeObject() {}
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
@@ -233,7 +233,7 @@ namespace ASDCP
 	  Preface();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 	  UUID         GenerationUID;
 	  Timestamp    LastModifiedDate;
 	  ui16_t       Version;
@@ -245,7 +245,7 @@ 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) : InterchangeObject(d), m_Dict(d), Version(258), ObjectModelVersion(0) {}
 	  virtual ~Preface() {}
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
@@ -300,7 +300,7 @@ namespace ASDCP
 	      const char* EncodeString(char* str_buf, ui32_t buf_len) const;
 	    };
 
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 
 	  Rational    IndexEditRate;
 	  ui64_t      IndexStartPosition;
@@ -313,7 +313,7 @@ namespace ASDCP
 	  Batch<DeltaEntry> DeltaEntryArray;
 	  Batch<IndexEntry> IndexEntryArray;
 
-	  IndexTableSegment(const Dictionary&);
+	  IndexTableSegment(const Dictionary*&);
 	  virtual ~IndexTableSegment();
 	  virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 	  virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
@@ -334,14 +334,14 @@ namespace ASDCP
 	  OPAtomHeader();
 
 	public:
-	  const Dictionary&   m_Dict;
+	  const Dictionary*&   m_Dict;
 	  ASDCP::MXF::RIP     m_RIP;
 	  ASDCP::MXF::Primer  m_Primer;
 	  Preface*            m_Preface;
 	  ASDCP::FrameBuffer  m_Buffer;
 	  bool                m_HasRIP;
 
-	  OPAtomHeader(const Dictionary&);
+	  OPAtomHeader(const Dictionary*&);
 	  virtual ~OPAtomHeader();
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
 	  virtual Result_t InitFromPartitionBuffer(const byte_t* p, ui32_t l);
@@ -366,11 +366,11 @@ namespace ASDCP
 	  ASDCP_NO_COPY_CONSTRUCT(OPAtomIndexFooter);
 
 	public:
-	  const Dictionary&   m_Dict;
+	  const Dictionary*&   m_Dict;
 	  Kumu::fpos_t        m_ECOffset;
 	  IPrimerLookup*      m_Lookup;
 	 
-	  OPAtomIndexFooter(const Dictionary&);
+	  OPAtomIndexFooter(const Dictionary*&);
 	  virtual ~OPAtomIndexFooter();
 	  virtual Result_t InitFromFile(const Kumu::FileReader& Reader);
 	  virtual Result_t InitFromPartitionBuffer(const byte_t* p, ui32_t l);
diff --git a/src/MXFTypes.h b/src/MXFTypes.h
index d42fe69..fe03495 100755
--- a/src/MXFTypes.h
+++ b/src/MXFTypes.h
@@ -41,9 +41,9 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // used with TLVReader::Read*
 //
 // these are used below to manufacture arguments
-#define OBJ_READ_ARGS(s,l) m_Dict.Type(MDD_##s##_##l), &l
-#define OBJ_WRITE_ARGS(s,l) m_Dict.Type(MDD_##s##_##l), &l
-#define OBJ_TYPE_ARGS(t) m_Dict.Type(MDD_##t).ul
+#define OBJ_READ_ARGS(s,l) m_Dict->Type(MDD_##s##_##l), &l
+#define OBJ_WRITE_ARGS(s,l) m_Dict->Type(MDD_##s##_##l), &l
+#define OBJ_TYPE_ARGS(t) m_Dict->Type(MDD_##t).ul
 
 
 namespace ASDCP
diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index 7ad1832..76ae51f 100755
--- a/src/Metadata.cpp
+++ b/src/Metadata.cpp
@@ -40,67 +40,67 @@ const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
 
 //------------------------------------------------------------------------------------------
 
-static InterchangeObject* Preface_Factory(const Dictionary& Dict) { return new Preface(Dict); }
-static InterchangeObject* IndexTableSegment_Factory(const Dictionary& Dict) { return new IndexTableSegment(Dict); }
-
-static InterchangeObject* Identification_Factory(const Dictionary& Dict) { return new Identification(Dict); }
-static InterchangeObject* ContentStorage_Factory(const Dictionary& Dict) { return new ContentStorage(Dict); }
-static InterchangeObject* EssenceContainerData_Factory(const Dictionary& Dict) { return new EssenceContainerData(Dict); }
-static InterchangeObject* MaterialPackage_Factory(const Dictionary& Dict) { return new MaterialPackage(Dict); }
-static InterchangeObject* SourcePackage_Factory(const Dictionary& Dict) { return new SourcePackage(Dict); }
-static InterchangeObject* StaticTrack_Factory(const Dictionary& Dict) { return new StaticTrack(Dict); }
-static InterchangeObject* Track_Factory(const Dictionary& Dict) { return new Track(Dict); }
-static InterchangeObject* Sequence_Factory(const Dictionary& Dict) { return new Sequence(Dict); }
-static InterchangeObject* SourceClip_Factory(const Dictionary& Dict) { return new SourceClip(Dict); }
-static InterchangeObject* TimecodeComponent_Factory(const Dictionary& Dict) { return new TimecodeComponent(Dict); }
-static InterchangeObject* FileDescriptor_Factory(const Dictionary& Dict) { return new FileDescriptor(Dict); }
-static InterchangeObject* GenericSoundEssenceDescriptor_Factory(const Dictionary& Dict) { return new GenericSoundEssenceDescriptor(Dict); }
-static InterchangeObject* WaveAudioDescriptor_Factory(const Dictionary& Dict) { return new WaveAudioDescriptor(Dict); }
-static InterchangeObject* GenericPictureEssenceDescriptor_Factory(const Dictionary& Dict) { return new GenericPictureEssenceDescriptor(Dict); }
-static InterchangeObject* RGBAEssenceDescriptor_Factory(const Dictionary& Dict) { return new RGBAEssenceDescriptor(Dict); }
-static InterchangeObject* JPEG2000PictureSubDescriptor_Factory(const Dictionary& Dict) { return new JPEG2000PictureSubDescriptor(Dict); }
-static InterchangeObject* CDCIEssenceDescriptor_Factory(const Dictionary& Dict) { return new CDCIEssenceDescriptor(Dict); }
-static InterchangeObject* MPEG2VideoDescriptor_Factory(const Dictionary& Dict) { return new MPEG2VideoDescriptor(Dict); }
-static InterchangeObject* DMSegment_Factory(const Dictionary& Dict) { return new DMSegment(Dict); }
-static InterchangeObject* CryptographicFramework_Factory(const Dictionary& Dict) { return new CryptographicFramework(Dict); }
-static InterchangeObject* CryptographicContext_Factory(const Dictionary& Dict) { return new CryptographicContext(Dict); }
-static InterchangeObject* GenericDataEssenceDescriptor_Factory(const Dictionary& Dict) { return new GenericDataEssenceDescriptor(Dict); }
-static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary& Dict) { return new TimedTextDescriptor(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* Preface_Factory(const Dictionary*& Dict) { return new Preface(Dict); }
+static InterchangeObject* IndexTableSegment_Factory(const Dictionary*& Dict) { return new IndexTableSegment(Dict); }
+
+static InterchangeObject* Identification_Factory(const Dictionary*& Dict) { return new Identification(Dict); }
+static InterchangeObject* ContentStorage_Factory(const Dictionary*& Dict) { return new ContentStorage(Dict); }
+static InterchangeObject* EssenceContainerData_Factory(const Dictionary*& Dict) { return new EssenceContainerData(Dict); }
+static InterchangeObject* MaterialPackage_Factory(const Dictionary*& Dict) { return new MaterialPackage(Dict); }
+static InterchangeObject* SourcePackage_Factory(const Dictionary*& Dict) { return new SourcePackage(Dict); }
+static InterchangeObject* StaticTrack_Factory(const Dictionary*& Dict) { return new StaticTrack(Dict); }
+static InterchangeObject* Track_Factory(const Dictionary*& Dict) { return new Track(Dict); }
+static InterchangeObject* Sequence_Factory(const Dictionary*& Dict) { return new Sequence(Dict); }
+static InterchangeObject* SourceClip_Factory(const Dictionary*& Dict) { return new SourceClip(Dict); }
+static InterchangeObject* TimecodeComponent_Factory(const Dictionary*& Dict) { return new TimecodeComponent(Dict); }
+static InterchangeObject* FileDescriptor_Factory(const Dictionary*& Dict) { return new FileDescriptor(Dict); }
+static InterchangeObject* GenericSoundEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericSoundEssenceDescriptor(Dict); }
+static InterchangeObject* WaveAudioDescriptor_Factory(const Dictionary*& Dict) { return new WaveAudioDescriptor(Dict); }
+static InterchangeObject* GenericPictureEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericPictureEssenceDescriptor(Dict); }
+static InterchangeObject* RGBAEssenceDescriptor_Factory(const Dictionary*& Dict) { return new RGBAEssenceDescriptor(Dict); }
+static InterchangeObject* JPEG2000PictureSubDescriptor_Factory(const Dictionary*& Dict) { return new JPEG2000PictureSubDescriptor(Dict); }
+static InterchangeObject* CDCIEssenceDescriptor_Factory(const Dictionary*& Dict) { return new CDCIEssenceDescriptor(Dict); }
+static InterchangeObject* MPEG2VideoDescriptor_Factory(const Dictionary*& Dict) { return new MPEG2VideoDescriptor(Dict); }
+static InterchangeObject* DMSegment_Factory(const Dictionary*& Dict) { return new DMSegment(Dict); }
+static InterchangeObject* CryptographicFramework_Factory(const Dictionary*& Dict) { return new CryptographicFramework(Dict); }
+static InterchangeObject* CryptographicContext_Factory(const Dictionary*& Dict) { return new CryptographicContext(Dict); }
+static InterchangeObject* GenericDataEssenceDescriptor_Factory(const Dictionary*& Dict) { return new GenericDataEssenceDescriptor(Dict); }
+static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextDescriptor(Dict); }
+static InterchangeObject* TimedTextResourceSubDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextResourceSubDescriptor(Dict); }
+static InterchangeObject* StereoscopicPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new StereoscopicPictureSubDescriptor(Dict); }
 
 
 void
-ASDCP::MXF::Metadata_InitTypes(const Dictionary& Dict)
-{
-  SetObjectFactory(Dict.ul(MDD_Preface), Preface_Factory);
-  SetObjectFactory(Dict.ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
-
-  SetObjectFactory(Dict.ul(MDD_Identification), Identification_Factory);
-  SetObjectFactory(Dict.ul(MDD_ContentStorage), ContentStorage_Factory);
-  SetObjectFactory(Dict.ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
-  SetObjectFactory(Dict.ul(MDD_MaterialPackage), MaterialPackage_Factory);
-  SetObjectFactory(Dict.ul(MDD_SourcePackage), SourcePackage_Factory);
-  SetObjectFactory(Dict.ul(MDD_StaticTrack), StaticTrack_Factory);
-  SetObjectFactory(Dict.ul(MDD_Track), Track_Factory);
-  SetObjectFactory(Dict.ul(MDD_Sequence), Sequence_Factory);
-  SetObjectFactory(Dict.ul(MDD_SourceClip), SourceClip_Factory);
-  SetObjectFactory(Dict.ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
-  SetObjectFactory(Dict.ul(MDD_FileDescriptor), FileDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_DMSegment), DMSegment_Factory);
-  SetObjectFactory(Dict.ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
-  SetObjectFactory(Dict.ul(MDD_CryptographicContext), CryptographicContext_Factory);
-  SetObjectFactory(Dict.ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
-  SetObjectFactory(Dict.ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
+ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
+{
+  SetObjectFactory(Dict->ul(MDD_Preface), Preface_Factory);
+  SetObjectFactory(Dict->ul(MDD_IndexTableSegment), IndexTableSegment_Factory);
+
+  SetObjectFactory(Dict->ul(MDD_Identification), Identification_Factory);
+  SetObjectFactory(Dict->ul(MDD_ContentStorage), ContentStorage_Factory);
+  SetObjectFactory(Dict->ul(MDD_EssenceContainerData), EssenceContainerData_Factory);
+  SetObjectFactory(Dict->ul(MDD_MaterialPackage), MaterialPackage_Factory);
+  SetObjectFactory(Dict->ul(MDD_SourcePackage), SourcePackage_Factory);
+  SetObjectFactory(Dict->ul(MDD_StaticTrack), StaticTrack_Factory);
+  SetObjectFactory(Dict->ul(MDD_Track), Track_Factory);
+  SetObjectFactory(Dict->ul(MDD_Sequence), Sequence_Factory);
+  SetObjectFactory(Dict->ul(MDD_SourceClip), SourceClip_Factory);
+  SetObjectFactory(Dict->ul(MDD_TimecodeComponent), TimecodeComponent_Factory);
+  SetObjectFactory(Dict->ul(MDD_FileDescriptor), FileDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_GenericSoundEssenceDescriptor), GenericSoundEssenceDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_WaveAudioDescriptor), WaveAudioDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_GenericPictureEssenceDescriptor), GenericPictureEssenceDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_RGBAEssenceDescriptor), RGBAEssenceDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_JPEG2000PictureSubDescriptor), JPEG2000PictureSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_CDCIEssenceDescriptor), CDCIEssenceDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_MPEG2VideoDescriptor), MPEG2VideoDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_DMSegment), DMSegment_Factory);
+  SetObjectFactory(Dict->ul(MDD_CryptographicFramework), CryptographicFramework_Factory);
+  SetObjectFactory(Dict->ul(MDD_CryptographicContext), CryptographicContext_Factory);
+  SetObjectFactory(Dict->ul(MDD_GenericDataEssenceDescriptor), GenericDataEssenceDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_TimedTextDescriptor), TimedTextDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory);
 }
 
 //------------------------------------------------------------------------------------------
@@ -171,7 +171,7 @@ Identification::Dump(FILE* stream)
 ASDCP::Result_t
 Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Identification);
+  m_Typeinfo = &(m_Dict->Type(MDD_Identification));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -179,7 +179,7 @@ Identification::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 Identification::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Identification);
+  m_Typeinfo = &(m_Dict->Type(MDD_Identification));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -227,7 +227,7 @@ ContentStorage::Dump(FILE* stream)
 ASDCP::Result_t
 ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_ContentStorage);
+  m_Typeinfo = &(m_Dict->Type(MDD_ContentStorage));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -235,7 +235,7 @@ ContentStorage::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 ContentStorage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_ContentStorage);
+  m_Typeinfo = &(m_Dict->Type(MDD_ContentStorage));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -284,7 +284,7 @@ EssenceContainerData::Dump(FILE* stream)
 ASDCP::Result_t
 EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_EssenceContainerData);
+  m_Typeinfo = &(m_Dict->Type(MDD_EssenceContainerData));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -292,7 +292,7 @@ EssenceContainerData::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 EssenceContainerData::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_EssenceContainerData);
+  m_Typeinfo = &(m_Dict->Type(MDD_EssenceContainerData));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -381,7 +381,7 @@ MaterialPackage::Dump(FILE* stream)
 ASDCP::Result_t
 MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_MaterialPackage);
+  m_Typeinfo = &(m_Dict->Type(MDD_MaterialPackage));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -389,7 +389,7 @@ MaterialPackage::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 MaterialPackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_MaterialPackage);
+  m_Typeinfo = &(m_Dict->Type(MDD_MaterialPackage));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -432,7 +432,7 @@ SourcePackage::Dump(FILE* stream)
 ASDCP::Result_t
 SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_SourcePackage);
+  m_Typeinfo = &(m_Dict->Type(MDD_SourcePackage));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -440,7 +440,7 @@ SourcePackage::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 SourcePackage::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_SourcePackage);
+  m_Typeinfo = &(m_Dict->Type(MDD_SourcePackage));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -525,7 +525,7 @@ StaticTrack::Dump(FILE* stream)
 ASDCP::Result_t
 StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_StaticTrack);
+  m_Typeinfo = &(m_Dict->Type(MDD_StaticTrack));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -533,7 +533,7 @@ StaticTrack::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 StaticTrack::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_StaticTrack);
+  m_Typeinfo = &(m_Dict->Type(MDD_StaticTrack));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -579,7 +579,7 @@ Track::Dump(FILE* stream)
 ASDCP::Result_t
 Track::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Track);
+  m_Typeinfo = &(m_Dict->Type(MDD_Track));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -587,7 +587,7 @@ Track::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 Track::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Track);
+  m_Typeinfo = &(m_Dict->Type(MDD_Track));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -670,7 +670,7 @@ Sequence::Dump(FILE* stream)
 ASDCP::Result_t
 Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Sequence);
+  m_Typeinfo = &(m_Dict->Type(MDD_Sequence));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -678,7 +678,7 @@ Sequence::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 Sequence::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_Sequence);
+  m_Typeinfo = &(m_Dict->Type(MDD_Sequence));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -727,7 +727,7 @@ SourceClip::Dump(FILE* stream)
 ASDCP::Result_t
 SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_SourceClip);
+  m_Typeinfo = &(m_Dict->Type(MDD_SourceClip));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -735,7 +735,7 @@ SourceClip::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 SourceClip::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_SourceClip);
+  m_Typeinfo = &(m_Dict->Type(MDD_SourceClip));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -784,7 +784,7 @@ TimecodeComponent::Dump(FILE* stream)
 ASDCP::Result_t
 TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_TimecodeComponent);
+  m_Typeinfo = &(m_Dict->Type(MDD_TimecodeComponent));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -792,7 +792,7 @@ TimecodeComponent::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 TimecodeComponent::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_TimecodeComponent);
+  m_Typeinfo = &(m_Dict->Type(MDD_TimecodeComponent));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -888,7 +888,7 @@ FileDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_FileDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_FileDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -896,7 +896,7 @@ FileDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 FileDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_FileDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_FileDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -954,7 +954,7 @@ GenericSoundEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_GenericSoundEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_GenericSoundEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -962,7 +962,7 @@ GenericSoundEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 GenericSoundEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_GenericSoundEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_GenericSoundEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1014,7 +1014,7 @@ WaveAudioDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_WaveAudioDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_WaveAudioDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1022,7 +1022,7 @@ WaveAudioDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 WaveAudioDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_WaveAudioDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_WaveAudioDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1077,7 +1077,7 @@ GenericPictureEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_GenericPictureEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_GenericPictureEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1085,7 +1085,7 @@ GenericPictureEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 GenericPictureEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_GenericPictureEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_GenericPictureEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1131,7 +1131,7 @@ RGBAEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_RGBAEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_RGBAEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1139,7 +1139,7 @@ RGBAEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 RGBAEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_RGBAEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_RGBAEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1218,7 +1218,7 @@ JPEG2000PictureSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_JPEG2000PictureSubDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_JPEG2000PictureSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1226,7 +1226,7 @@ JPEG2000PictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 JPEG2000PictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_JPEG2000PictureSubDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_JPEG2000PictureSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1278,7 +1278,7 @@ CDCIEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_CDCIEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_CDCIEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1286,7 +1286,7 @@ CDCIEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 CDCIEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_CDCIEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_CDCIEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1338,7 +1338,7 @@ MPEG2VideoDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_MPEG2VideoDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_MPEG2VideoDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1346,7 +1346,7 @@ MPEG2VideoDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 MPEG2VideoDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_MPEG2VideoDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_MPEG2VideoDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1401,7 +1401,7 @@ DMSegment::Dump(FILE* stream)
 ASDCP::Result_t
 DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_DMSegment);
+  m_Typeinfo = &(m_Dict->Type(MDD_DMSegment));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1409,7 +1409,7 @@ DMSegment::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 DMSegment::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_DMSegment);
+  m_Typeinfo = &(m_Dict->Type(MDD_DMSegment));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1452,7 +1452,7 @@ CryptographicFramework::Dump(FILE* stream)
 ASDCP::Result_t
 CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_CryptographicFramework);
+  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicFramework));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1460,7 +1460,7 @@ CryptographicFramework::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 CryptographicFramework::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_CryptographicFramework);
+  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicFramework));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1515,7 +1515,7 @@ CryptographicContext::Dump(FILE* stream)
 ASDCP::Result_t
 CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_CryptographicContext);
+  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicContext));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1523,7 +1523,7 @@ CryptographicContext::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 CryptographicContext::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_CryptographicContext);
+  m_Typeinfo = &(m_Dict->Type(MDD_CryptographicContext));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1566,7 +1566,7 @@ GenericDataEssenceDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_GenericDataEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_GenericDataEssenceDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1574,7 +1574,7 @@ GenericDataEssenceDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 GenericDataEssenceDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_GenericDataEssenceDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_GenericDataEssenceDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1623,7 +1623,7 @@ TimedTextDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_TimedTextDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1631,7 +1631,7 @@ TimedTextDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 TimedTextDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_TimedTextDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1680,7 +1680,7 @@ TimedTextResourceSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_TimedTextResourceSubDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextResourceSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1688,7 +1688,7 @@ TimedTextResourceSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 TimedTextResourceSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_TimedTextResourceSubDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_TimedTextResourceSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
@@ -1728,7 +1728,7 @@ StereoscopicPictureSubDescriptor::Dump(FILE* stream)
 ASDCP::Result_t
 StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_StereoscopicPictureSubDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_StereoscopicPictureSubDescriptor));
   return InterchangeObject::InitFromBuffer(p, l);
 }
 
@@ -1736,7 +1736,7 @@ StereoscopicPictureSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
 ASDCP::Result_t
 StereoscopicPictureSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 {
-  m_Typeinfo = &m_Dict.Type(MDD_StereoscopicPictureSubDescriptor);
+  m_Typeinfo = &(m_Dict->Type(MDD_StereoscopicPictureSubDescriptor));
   return InterchangeObject::WriteToBuffer(Buffer);
 }
 
diff --git a/src/Metadata.h b/src/Metadata.h
index b5a255e..4c83034 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -38,7 +38,7 @@ namespace ASDCP
 {
   namespace MXF
     {
-      void Metadata_InitTypes(const Dictionary& Dict);
+      void Metadata_InitTypes(const Dictionary*& Dict);
 
       //
 
@@ -49,7 +49,7 @@ namespace ASDCP
 	  Identification();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UUID ThisGenerationUID;
           UTF16String CompanyName;
           UTF16String ProductName;
@@ -60,7 +60,7 @@ namespace ASDCP
           VersionType ToolkitVersion;
           UTF16String Platform;
 
-  Identification(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~Identification() {}
           virtual const char* HasName() { return "Identification"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -77,11 +77,11 @@ namespace ASDCP
 	  ContentStorage();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           Batch<UUID> Packages;
           Batch<UUID> EssenceContainerData;
 
-  ContentStorage(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~ContentStorage() {}
           virtual const char* HasName() { return "ContentStorage"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -98,12 +98,12 @@ namespace ASDCP
 	  EssenceContainerData();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UMID LinkedPackageUID;
           ui32_t IndexSID;
           ui32_t BodySID;
 
-  EssenceContainerData(const Dictionary& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {}
+  EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {}
 	  virtual ~EssenceContainerData() {}
           virtual const char* HasName() { return "EssenceContainerData"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -120,14 +120,14 @@ namespace ASDCP
 	  GenericPackage();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UMID PackageUID;
           UTF16String Name;
           Timestamp PackageCreationDate;
           Timestamp PackageModifiedDate;
           Batch<UUID> Tracks;
 
-  GenericPackage(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~GenericPackage() {}
           virtual const char* HasName() { return "GenericPackage"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -142,9 +142,9 @@ namespace ASDCP
 	  MaterialPackage();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 
-  MaterialPackage(const Dictionary& d) : GenericPackage(d), m_Dict(d) {}
+  MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
 	  virtual ~MaterialPackage() {}
           virtual const char* HasName() { return "MaterialPackage"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -161,10 +161,10 @@ namespace ASDCP
 	  SourcePackage();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UUID Descriptor;
 
-  SourcePackage(const Dictionary& d) : GenericPackage(d), m_Dict(d) {}
+  SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {}
 	  virtual ~SourcePackage() {}
           virtual const char* HasName() { return "SourcePackage"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -181,13 +181,13 @@ namespace ASDCP
 	  GenericTrack();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui32_t TrackID;
           ui32_t TrackNumber;
           UTF16String TrackName;
           UUID Sequence;
 
-  GenericTrack(const Dictionary& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
+  GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {}
 	  virtual ~GenericTrack() {}
           virtual const char* HasName() { return "GenericTrack"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -202,9 +202,9 @@ namespace ASDCP
 	  StaticTrack();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 
-  StaticTrack(const Dictionary& d) : GenericTrack(d), m_Dict(d) {}
+  StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d) {}
 	  virtual ~StaticTrack() {}
           virtual const char* HasName() { return "StaticTrack"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -221,11 +221,11 @@ namespace ASDCP
 	  Track();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           Rational EditRate;
           ui64_t Origin;
 
-  Track(const Dictionary& d) : GenericTrack(d), m_Dict(d), Origin(0) {}
+  Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0) {}
 	  virtual ~Track() {}
           virtual const char* HasName() { return "Track"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -242,11 +242,11 @@ namespace ASDCP
 	  StructuralComponent();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UL DataDefinition;
           ui64_t Duration;
 
-  StructuralComponent(const Dictionary& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
+  StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {}
 	  virtual ~StructuralComponent() {}
           virtual const char* HasName() { return "StructuralComponent"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -261,10 +261,10 @@ namespace ASDCP
 	  Sequence();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           Batch<UUID> StructuralComponents;
 
-  Sequence(const Dictionary& d) : StructuralComponent(d), m_Dict(d) {}
+  Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d) {}
 	  virtual ~Sequence() {}
           virtual const char* HasName() { return "Sequence"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -281,12 +281,12 @@ namespace ASDCP
 	  SourceClip();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui64_t StartPosition;
           UMID SourcePackageID;
           ui32_t SourceTrackID;
 
-  SourceClip(const Dictionary& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {}
+  SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {}
 	  virtual ~SourceClip() {}
           virtual const char* HasName() { return "SourceClip"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -303,12 +303,12 @@ namespace ASDCP
 	  TimecodeComponent();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui16_t RoundedTimecodeBase;
           ui64_t StartTimecode;
           ui8_t DropFrame;
 
-  TimecodeComponent(const Dictionary& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
+  TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
 	  virtual ~TimecodeComponent() {}
           virtual const char* HasName() { return "TimecodeComponent"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -325,11 +325,11 @@ namespace ASDCP
 	  GenericDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           Batch<UUID> Locators;
           Batch<UUID> SubDescriptors;
 
-  GenericDescriptor(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~GenericDescriptor() {}
           virtual const char* HasName() { return "GenericDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -344,14 +344,14 @@ namespace ASDCP
 	  FileDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui32_t LinkedTrackID;
           Rational SampleRate;
           ui64_t ContainerDuration;
           UL EssenceContainer;
           UL Codec;
 
-  FileDescriptor(const Dictionary& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {}
+  FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {}
 	  virtual ~FileDescriptor() {}
           virtual const char* HasName() { return "FileDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -368,7 +368,7 @@ namespace ASDCP
 	  GenericSoundEssenceDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           Rational AudioSamplingRate;
           ui8_t Locked;
           ui8_t AudioRefLevel;
@@ -376,7 +376,7 @@ 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 Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {}
 	  virtual ~GenericSoundEssenceDescriptor() {}
           virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -393,13 +393,13 @@ namespace ASDCP
 	  WaveAudioDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui16_t BlockAlign;
           ui8_t SequenceOffset;
           ui32_t AvgBps;
           UL ChannelAssignment;
 
-  WaveAudioDescriptor(const Dictionary& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
+  WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
 	  virtual ~WaveAudioDescriptor() {}
           virtual const char* HasName() { return "WaveAudioDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -416,14 +416,14 @@ namespace ASDCP
 	  GenericPictureEssenceDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui8_t FrameLayout;
           ui32_t StoredWidth;
           ui32_t StoredHeight;
           Rational AspectRatio;
           UL PictureEssenceCoding;
 
-  GenericPictureEssenceDescriptor(const Dictionary& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
+  GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
 	  virtual ~GenericPictureEssenceDescriptor() {}
           virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -440,11 +440,11 @@ namespace ASDCP
 	  RGBAEssenceDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui32_t ComponentMaxRef;
           ui32_t ComponentMinRef;
 
-  RGBAEssenceDescriptor(const Dictionary& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {}
+  RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {}
 	  virtual ~RGBAEssenceDescriptor() {}
           virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -461,7 +461,7 @@ namespace ASDCP
 	  JPEG2000PictureSubDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui16_t Rsize;
           ui32_t Xsize;
           ui32_t Ysize;
@@ -476,7 +476,7 @@ 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 Dictionary*& d) : InterchangeObject(d), m_Dict(d), Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {}
 	  virtual ~JPEG2000PictureSubDescriptor() {}
           virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -493,13 +493,13 @@ namespace ASDCP
 	  CDCIEssenceDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui32_t ComponentDepth;
           ui32_t HorizontalSubsampling;
           ui32_t VerticalSubsampling;
           ui8_t ColorSiting;
 
-  CDCIEssenceDescriptor(const Dictionary& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
+  CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
 	  virtual ~CDCIEssenceDescriptor() {}
           virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -516,13 +516,13 @@ namespace ASDCP
 	  MPEG2VideoDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           ui8_t CodedContentType;
           ui8_t LowDelay;
           ui32_t BitRate;
           ui8_t ProfileAndLevel;
 
-  MPEG2VideoDescriptor(const Dictionary& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
+  MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
 	  virtual ~MPEG2VideoDescriptor() {}
           virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -539,14 +539,14 @@ namespace ASDCP
 	  DMSegment();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UL DataDefinition;
           ui64_t EventStartPosition;
           ui64_t Duration;
           UTF16String EventComment;
           UUID DMFramework;
 
-  DMSegment(const Dictionary& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {}
+  DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {}
 	  virtual ~DMSegment() {}
           virtual const char* HasName() { return "DMSegment"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -563,10 +563,10 @@ namespace ASDCP
 	  CryptographicFramework();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UUID ContextSR;
 
-  CryptographicFramework(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~CryptographicFramework() {}
           virtual const char* HasName() { return "CryptographicFramework"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -583,14 +583,14 @@ namespace ASDCP
 	  CryptographicContext();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UUID ContextID;
           UL SourceEssenceContainer;
           UL CipherAlgorithm;
           UL MICAlgorithm;
           UUID CryptographicKeyID;
 
-  CryptographicContext(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~CryptographicContext() {}
           virtual const char* HasName() { return "CryptographicContext"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -607,10 +607,10 @@ namespace ASDCP
 	  GenericDataEssenceDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UL DataEssenceCoding;
 
-  GenericDataEssenceDescriptor(const Dictionary& d) : FileDescriptor(d), m_Dict(d) {}
+  GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d) {}
 	  virtual ~GenericDataEssenceDescriptor() {}
           virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -627,12 +627,12 @@ namespace ASDCP
 	  TimedTextDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UUID ResourceID;
           UTF16String UCSEncoding;
           UTF16String NamespaceURI;
 
-  TimedTextDescriptor(const Dictionary& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {}
+  TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {}
 	  virtual ~TimedTextDescriptor() {}
           virtual const char* HasName() { return "TimedTextDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -649,12 +649,12 @@ namespace ASDCP
 	  TimedTextResourceSubDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
           UUID AncillaryResourceID;
           UTF16String MIMEMediaType;
           ui32_t EssenceStreamID;
 
-  TimedTextResourceSubDescriptor(const Dictionary& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {}
+  TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {}
 	  virtual ~TimedTextResourceSubDescriptor() {}
           virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
@@ -671,9 +671,9 @@ namespace ASDCP
 	  StereoscopicPictureSubDescriptor();
 
 	public:
-	  const Dictionary& m_Dict;
+	  const Dictionary*& m_Dict;
 
-  StereoscopicPictureSubDescriptor(const Dictionary& d) : InterchangeObject(d), m_Dict(d) {}
+  StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {}
 	  virtual ~StereoscopicPictureSubDescriptor() {}
           virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
diff --git a/src/asdcp-test.cpp b/src/asdcp-test.cpp
index 9397c50..43e927a 100755
--- a/src/asdcp-test.cpp
+++ b/src/asdcp-test.cpp
@@ -1728,7 +1728,8 @@ show_file_info(CommandOptions& Options)
     {
       fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames[0]);
       Kumu::FileReader   Reader;
-      MXF::OPAtomHeader TestHeader(DefaultCompositeDict());
+      const Dictionary* Dict = &DefaultCompositeDict();
+      MXF::OPAtomHeader TestHeader(Dict);
 
       result = Reader.OpenRead(Options.filenames[0]);
 
diff --git a/src/h__Reader.cpp b/src/h__Reader.cpp
index 1f41d95..7a1dd12 100755
--- a/src/h__Reader.cpp
+++ b/src/h__Reader.cpp
@@ -37,7 +37,7 @@ using namespace ASDCP::MXF;
 
 //
 ASDCP::h__Reader::h__Reader(const Dictionary& d) :
-  m_HeaderPart(d), m_BodyPart(d), m_FooterPart(d), m_Dict(d), m_EssenceStart(0)
+  m_HeaderPart(m_Dict), m_BodyPart(m_Dict), m_FooterPart(m_Dict), m_Dict(&d), m_EssenceStart(0)
 {
 }
 
@@ -62,8 +62,8 @@ ASDCP::h__Reader::InitInfo()
   InterchangeObject* Object;
 
   m_Info.LabelSetType = LS_MXF_UNKNOWN;
-  UL OPAtomUL(m_Dict.ul(MDD_OPAtom));
-  UL Interop_OPAtomUL(m_Dict.ul(MDD_MXFInterop_OPAtom));
+  UL OPAtomUL(m_Dict->ul(MDD_OPAtom));
+  UL Interop_OPAtomUL(m_Dict->ul(MDD_MXFInterop_OPAtom));
 
   if ( m_HeaderPart.OperationalPattern == Interop_OPAtomUL )
     m_Info.LabelSetType = LS_MXF_INTEROP;
@@ -92,7 +92,7 @@ ASDCP::h__Reader::InitInfo()
       Result_t cr_result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(CryptographicContext), &Object);
 
       if( ASDCP_SUCCESS(cr_result) )
-	MD_to_CryptoInfo((CryptographicContext*)Object, m_Info, m_Dict);
+	MD_to_CryptoInfo((CryptographicContext*)Object, m_Info, *m_Dict);
     }
 
   return result;
@@ -215,8 +215,8 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::Fra
   ui64_t PacketLength = Reader.Length();
   m_LastPosition = m_LastPosition + Reader.KLLength() + PacketLength;
 
-  if ( memcmp(Key.Value(), m_Dict.ul(MDD_CryptEssence), Key.Size() - 1) == 0  // ignore the stream numbers
-       || memcmp(Key.Value(), m_Dict.ul(MDD_MXFInterop_CryptEssence), Key.Size() - 1) == 0 )
+  if ( memcmp(Key.Value(), m_Dict->ul(MDD_CryptEssence), Key.Size() - 1) == 0  // ignore the stream numbers
+       || memcmp(Key.Value(), m_Dict->ul(MDD_MXFInterop_CryptEssence), Key.Size() - 1) == 0 )
     {
       if ( ! m_Info.EncryptedEssence )
 	{
@@ -272,7 +272,7 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::Fra
       if ( memcmp(ess_p, EssenceUL, SMPTE_UL_LENGTH - 1) != 0 ) // ignore the stream number
 	{
 	  char strbuf[IntBufferLen];
-	  const MDDEntry* Entry = m_Dict.FindUL(Key.Value());
+	  const MDDEntry* Entry = m_Dict->FindUL(Key.Value());
 	  if ( Entry == 0 )
 	    DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Key.EncodeString(strbuf, IntBufferLen));
 	  else
@@ -383,7 +383,7 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::Fra
   else
     {
       char strbuf[IntBufferLen];
-      const MDDEntry* Entry = m_Dict.FindUL(Key.Value());
+      const MDDEntry* Entry = m_Dict->FindUL(Key.Value());
       if ( Entry == 0 )
         DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Key.EncodeString(strbuf, IntBufferLen));
       else
diff --git a/src/h__Writer.cpp b/src/h__Writer.cpp
index da17983..cb4e461 100755
--- a/src/h__Writer.cpp
+++ b/src/h__Writer.cpp
@@ -69,7 +69,7 @@ version_split(const char* str)
 
 //
 ASDCP::h__Writer::h__Writer(const Dictionary& d) :
-  m_HeaderPart(d), m_BodyPart(d), m_FooterPart(d), m_Dict(d),
+  m_HeaderPart(m_Dict), m_BodyPart(m_Dict), m_FooterPart(m_Dict), m_Dict(&d),
   m_HeaderSize(0), m_EssenceStart(0),
   m_EssenceDescriptor(0), m_FramesWritten(0), m_StreamOffset(0)
 {
@@ -83,7 +83,7 @@ ASDCP::h__Writer::~h__Writer()
 // add DMS CryptographicFramework entry to source package
 void
 AddDMScrypt(Partition& HeaderPart, SourcePackage& Package,
-	    WriterInfo& Descr, const UL& WrappingUL, const Dictionary& Dict)
+	    WriterInfo& Descr, const UL& WrappingUL, const Dictionary*& Dict)
 {
   // Essence Track
   StaticTrack* NewTrack = new StaticTrack(Dict);
@@ -95,7 +95,7 @@ AddDMScrypt(Partition& HeaderPart, SourcePackage& Package,
   Sequence* Seq = new Sequence(Dict);
   HeaderPart.AddChildObject(Seq);
   NewTrack->Sequence = Seq->InstanceUID;
-  Seq->DataDefinition = UL(Dict.ul(MDD_DescriptiveMetaDataDef));
+  Seq->DataDefinition = UL(Dict->ul(MDD_DescriptiveMetaDataDef));
 
   DMSegment* Segment = new DMSegment(Dict);
   HeaderPart.AddChildObject(Segment);
@@ -112,8 +112,8 @@ AddDMScrypt(Partition& HeaderPart, SourcePackage& Package,
 
   Context->ContextID.Set(Descr.ContextID);
   Context->SourceEssenceContainer = WrappingUL; // ??????
-  Context->CipherAlgorithm.Set(Dict.ul(MDD_CipherAlgorithm_AES));
-  Context->MICAlgorithm.Set( Descr.UsesHMAC ? Dict.ul(MDD_MICAlgorithm_HMAC_SHA1) : Dict.ul(MDD_MICAlgorithm_NONE) );
+  Context->CipherAlgorithm.Set(Dict->ul(MDD_CipherAlgorithm_AES));
+  Context->MICAlgorithm.Set( Descr.UsesHMAC ? Dict->ul(MDD_MICAlgorithm_HMAC_SHA1) : Dict->ul(MDD_MICAlgorithm_NONE) );
   Context->CryptographicKeyID.Set(Descr.CryptographicKeyID);
 }
 
@@ -129,7 +129,7 @@ ASDCP::h__Writer::InitHeader()
 
   // Set the Operational Pattern label -- we're just starting and have no RIP or index,
   // so we tell the world by using OP1a
-  m_HeaderPart.m_Preface->OperationalPattern = UL(m_Dict.ul(MDD_OP1a));
+  m_HeaderPart.m_Preface->OperationalPattern = UL(m_Dict->ul(MDD_OP1a));
   m_HeaderPart.OperationalPattern = m_HeaderPart.m_Preface->OperationalPattern;
 
   // First RIP Entry
@@ -176,7 +176,7 @@ struct TrackSet
 template <class PackageT, class ClipT>
 TrackSet<ClipT>
 CreateTrackAndSequence(OPAtomHeader& Header, PackageT& Package, const std::string TrackName,
-		       const MXF::Rational& EditRate, const UL& Definition, ui32_t TrackID, const Dictionary& Dict)
+		       const MXF::Rational& EditRate, const UL& Definition, ui32_t TrackID, const Dictionary*& Dict)
 {
   TrackSet<ClipT> NewTrack;
 
@@ -199,9 +199,9 @@ CreateTrackAndSequence(OPAtomHeader& Header, PackageT& Package, const std::strin
 template <class PackageT>
 TrackSet<TimecodeComponent>
 CreateTimecodeTrack(OPAtomHeader& Header, PackageT& Package,
-		    const MXF::Rational& EditRate, ui32_t TCFrameRate, ui64_t TCStart, const Dictionary& Dict)
+		    const MXF::Rational& EditRate, ui32_t TCFrameRate, ui64_t TCStart, const Dictionary*& Dict)
 {
-  UL TCUL(Dict.ul(MDD_TimecodeDataDef));
+  UL TCUL(Dict->ul(MDD_TimecodeDataDef));
 
   TrackSet<TimecodeComponent> NewTrack = CreateTrackAndSequence<PackageT, TimecodeComponent>(Header, Package, "Timecode Track", EditRate, TCUL, 1, Dict);
 
@@ -396,14 +396,14 @@ ASDCP::h__Writer::AddEssenceDescriptor(const UL& WrappingUL)
   //
   // Essence Descriptors
   //
-  UL GenericContainerUL(m_Dict.ul(MDD_GCMulti));
+  UL GenericContainerUL(m_Dict->ul(MDD_GCMulti));
   m_HeaderPart.EssenceContainers.push_back(GenericContainerUL);
 
   if ( m_Info.EncryptedEssence )
     {
-      UL CryptEssenceUL(m_Dict.ul(MDD_EncryptedContainerLabel));
+      UL CryptEssenceUL(m_Dict->ul(MDD_EncryptedContainerLabel));
       m_HeaderPart.EssenceContainers.push_back(CryptEssenceUL);
-      m_HeaderPart.m_Preface->DMSchemes.push_back(UL(m_Dict.ul(MDD_CryptographicFrameworkLabel)));
+      m_HeaderPart.m_Preface->DMSchemes.push_back(UL(m_Dict->ul(MDD_CryptographicFrameworkLabel)));
       AddDMScrypt(m_HeaderPart, *m_FilePackage, m_Info, WrappingUL, m_Dict);
     }
   else
@@ -434,11 +434,11 @@ ASDCP::h__Writer::CreateBodyPart(const MXF::Rational& EditRate, ui32_t BytesPerE
       m_BodyPart.EssenceContainers = m_HeaderPart.EssenceContainers;
       m_BodyPart.ThisPartition = m_File.Tell();
       m_BodyPart.BodySID = 1;
-      UL OPAtomUL(m_Dict.ul(MDD_OPAtom));
+      UL OPAtomUL(m_Dict->ul(MDD_OPAtom));
       m_BodyPart.OperationalPattern = OPAtomUL;
       m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(1, m_BodyPart.ThisPartition)); // Second RIP Entry
       
-      UL BodyUL(m_Dict.ul(MDD_ClosedCompleteBodyPartition));
+      UL BodyUL(m_Dict->ul(MDD_ClosedCompleteBodyPartition));
       result = m_BodyPart.WriteToFile(m_File, BodyUL);
     }
   else
@@ -518,9 +518,9 @@ ASDCP::h__Writer::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf, const byte
       if ( ASDCP_SUCCESS(result) )
 	{ // write UL
 	  if ( m_Info.LabelSetType == LS_MXF_INTEROP )
-	    Overhead.WriteRaw(m_Dict.ul(MDD_MXFInterop_CryptEssence), SMPTE_UL_LENGTH);
+	    Overhead.WriteRaw(m_Dict->ul(MDD_MXFInterop_CryptEssence), SMPTE_UL_LENGTH);
 	  else
-	    Overhead.WriteRaw(m_Dict.ul(MDD_CryptEssence), SMPTE_UL_LENGTH);
+	    Overhead.WriteRaw(m_Dict->ul(MDD_CryptEssence), SMPTE_UL_LENGTH);
 
 	  // construct encrypted triplet header
 	  ui32_t ETLength = klv_cryptinfo_size + m_CtFrameBuf.Size();
@@ -617,10 +617,10 @@ ASDCP::h__Writer::WriteMXFFooter()
   m_HeaderPart.FooterPartition = here;
 
   // re-label the partition
-  UL OPAtomUL(m_Dict.ul(MDD_OPAtom));
+  UL OPAtomUL(m_Dict->ul(MDD_OPAtom));
 
   if ( m_Info.LabelSetType == LS_MXF_INTEROP )
-    OPAtomUL.Set(m_Dict.ul(MDD_MXFInterop_OPAtom));
+    OPAtomUL.Set(m_Dict->ul(MDD_MXFInterop_OPAtom));
   
   m_HeaderPart.OperationalPattern = OPAtomUL;
   m_HeaderPart.m_Preface->OperationalPattern = m_HeaderPart.OperationalPattern;
diff --git a/src/klvwalk.cpp b/src/klvwalk.cpp
index 276ff20..6715060 100755
--- a/src/klvwalk.cpp
+++ b/src/klvwalk.cpp
@@ -193,7 +193,8 @@ main(int argc, const char** argv)
       if ( Options.read_mxf_flag ) // dump MXF
 	{
 	  Kumu::FileReader        Reader;
-	  ASDCP::MXF::OPAtomHeader Header(DefaultCompositeDict());
+	  const Dictionary* Dict = &DefaultCompositeDict();
+	  ASDCP::MXF::OPAtomHeader Header(Dict);
 	  
 	  result = Reader.OpenRead((*fi).c_str());
 	  
@@ -213,7 +214,7 @@ main(int argc, const char** argv)
 
 		  if ( ASDCP_SUCCESS(result) )
 		    {
-		      MXF::Partition TmpPart(DefaultCompositeDict());
+		      MXF::Partition TmpPart(Dict);
 		      result = TmpPart.InitFromFile(Reader);
 
 		      if ( ASDCP_SUCCESS(result) && TmpPart.BodySID > 0 )
@@ -224,7 +225,7 @@ main(int argc, const char** argv)
 
 	  if ( ASDCP_SUCCESS(result) )
 	    {
-	      ASDCP::MXF::OPAtomIndexFooter Index(DefaultCompositeDict());
+	      ASDCP::MXF::OPAtomIndexFooter Index(Dict);
 	      result = Reader.Seek(Header.FooterPartition);
 	      
 	      if ( ASDCP_SUCCESS(result) )