added aiff reader

23 files changed, 1792 insertions, 1878 deletions

diff --git a/src/AS_DCP.h b/src/AS_DCP.h
index b7dc94a..b64c3a5 100755
--- a/src/AS_DCP.h
+++ b/src/AS_DCP.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2003-2005, John Hurst
+Copyright (c) 2003-2006, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index 6558a06..3bb5484 100755
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -34,12 +34,8 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 //------------------------------------------------------------------------------------------
 
-//
-const byte_t JP2KEssenceCompressionLabel[klv_key_size] =
-{
-  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x09,
-  0x04, 0x01, 0x02, 0x02, 0x03, 0x01, 0x01, 0x01 };
-
+static std::string JP2K_PACKAGE_LABEL = "File Package: SMPTE XXXM frame wrapping of JPEG 2000 codestreams";
+static std::string PICT_DEF_LABEL = "Picture Track";
 
 //
 void
@@ -101,7 +97,7 @@ ContainerDuration: %lu\n",
 	    );
 
   if ( PDesc.QuantDefaultLength )
-    fprintf(stream, "Default Coding (%lu): %s\n",
+    fprintf(stream, "Quantization Default (%lu): %s\n",
 	    PDesc.QuantDefaultLength,
 	    bin2hex(PDesc.QuantDefault, PDesc.QuantDefaultLength,
 		    tmp_buf, tmp_buf_len)
@@ -114,24 +110,27 @@ ContainerDuration: %lu\n",
 
 class ASDCP::JP2K::MXFReader::h__Reader : public ASDCP::h__Reader
 {
+  RGBAEssenceDescriptor*        m_EssenceDescriptor;
+  JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor;
+
   ASDCP_NO_COPY_CONSTRUCT(h__Reader);
 
 public:
   PictureDescriptor m_PDesc;        // codestream parameter list
 
-  h__Reader() {}
+  h__Reader() : m_EssenceDescriptor(0), m_EssenceSubDescriptor(0) {}
   Result_t    OpenRead(const char*);
   Result_t    ReadFrame(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*);
   Result_t    ReadFrameGOPStart(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*);
-  Result_t    MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor* PDescObj, JP2K::PictureDescriptor& PDesc);
+  Result_t    MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc);
 };
 
 //
 ASDCP::Result_t
-ASDCP::JP2K::MXFReader::h__Reader::MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor* PDescObj, JP2K::PictureDescriptor& PDesc)
+ASDCP::JP2K::MXFReader::h__Reader::MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc)
 {
-  ASDCP_TEST_NULL(PDescObj);
   memset(&PDesc, 0, sizeof(PDesc));
+  MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor;
 
   PDesc.EditRate           = PDescObj->SampleRate;
   PDesc.ContainerDuration  = PDescObj->ContainerDuration;
@@ -139,49 +138,36 @@ ASDCP::JP2K::MXFReader::h__Reader::MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor*
   PDesc.StoredHeight       = PDescObj->StoredHeight;
   PDesc.AspectRatio        = PDescObj->AspectRatio;
 
-  InterchangeObject* MDObject;
-  if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &MDObject)) )
+  if ( m_EssenceSubDescriptor != 0 )
     {
-      if ( MDObject == 0 )
-	{
-	  DefaultLogSink().Error("Unable to locate JPEG2000PictureSubDescriptor");
-	  return RESULT_FALSE;
-	}
+      PDesc.Rsize   = m_EssenceSubDescriptor->Rsize;
+      PDesc.Xsize   = m_EssenceSubDescriptor->Xsize;
+      PDesc.Ysize   = m_EssenceSubDescriptor->Ysize;
+      PDesc.XOsize  = m_EssenceSubDescriptor->XOsize;
+      PDesc.YOsize  = m_EssenceSubDescriptor->YOsize;
+      PDesc.XTsize  = m_EssenceSubDescriptor->XTsize;
+      PDesc.YTsize  = m_EssenceSubDescriptor->YTsize;
+      PDesc.XTOsize = m_EssenceSubDescriptor->XTOsize;
+      PDesc.YTOsize = m_EssenceSubDescriptor->YTOsize;
+      PDesc.Csize   = m_EssenceSubDescriptor->Csize;
 
-      JPEG2000PictureSubDescriptor* PSubDescObj = (JPEG2000PictureSubDescriptor*)MDObject;
-
-      PDesc.Rsize   = PSubDescObj->Rsize;
-      PDesc.Xsize   = PSubDescObj->Xsize;
-      PDesc.Ysize   = PSubDescObj->Ysize;
-      PDesc.XOsize  = PSubDescObj->XOsize;
-      PDesc.YOsize  = PSubDescObj->YOsize;
-      PDesc.XTsize  = PSubDescObj->XTsize;
-      PDesc.YTsize  = PSubDescObj->YTsize;
-      PDesc.XTOsize = PSubDescObj->XTOsize;
-      PDesc.YTOsize = PSubDescObj->YTOsize;
-      PDesc.Csize   = PSubDescObj->Csize;
-    }
-
-#if 0
       // PictureComponentSizing
+      ui32_t tmp_size = m_EssenceSubDescriptor->PictureComponentSizing.Size();
+
+      if ( tmp_size == 17 ) // ( 2 * sizeof(ui32_t) ) + 3 components * 3 byte each
+	memcpy(&PDesc.ImageComponents, m_EssenceSubDescriptor->PictureComponentSizing.RoData() + 8, tmp_size - 8);
 
-      if ( DC3.Size == 17 ) // ( 2* sizeof(ui32_t) ) + 3 components * 3 byte each
-	{
-	  memcpy(&PDesc.ImageComponents, DC3.Data + 8, DC3.Size - 8);
-	}
       else
-	{
-	  DefaultLogSink().Error("Unexpected PictureComponentSizing size: %lu, should be 17\n", DC3.Size);
-	}
-#endif
+	DefaultLogSink().Error("Unexpected PictureComponentSizing size: %lu, should be 17\n", tmp_size);
 
-  // CodingStyleDefault
-      //      PDesc.CodingStyleLength = DC1.Size;
-      //      memcpy(PDesc.CodingStyle, DC1.Data, DC1.Size);
+      // CodingStyleDefault
+      if ( ( PDesc.CodingStyleLength = m_EssenceSubDescriptor->CodingStyleDefault.Size() ) != 0 )
+	memcpy(PDesc.CodingStyle, m_EssenceSubDescriptor->CodingStyleDefault.RoData(), PDesc.CodingStyleLength);
 
-  // QuantizationDefault
-      //      PDesc.QuantDefaultLength = DC2.Size;
-      //      memcpy(PDesc.QuantDefault, DC2.Data, DC2.Size);
+      // QuantizationDefault
+      if ( ( PDesc.QuantDefaultLength = m_EssenceSubDescriptor->QuantizationDefault.Size() ) != 0 )
+	memcpy(PDesc.QuantDefault, m_EssenceSubDescriptor->QuantizationDefault.RoData(), PDesc.QuantDefaultLength);
+    }
 
   return RESULT_OK;
 }
@@ -195,12 +181,13 @@ ASDCP::JP2K::MXFReader::h__Reader::OpenRead(const char* filename)
 
   if( ASDCP_SUCCESS(result) )
     {
-      InterchangeObject* Object;
-      if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), &Object)) )
+      if ( m_EssenceDescriptor == 0 )
 	{
-	  assert(Object);
-	  result = MD_to_JP2K_PDesc((MXF::RGBAEssenceDescriptor*)Object, m_PDesc);
+	  m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), (InterchangeObject**)&m_EssenceDescriptor);
+	  m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), (InterchangeObject**)&m_EssenceSubDescriptor);
 	}
+
+      result = MD_to_JP2K_PDesc(m_PDesc);
     }
 
   if( ASDCP_SUCCESS(result) )
@@ -221,7 +208,7 @@ ASDCP::JP2K::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& Frame
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  return ReadEKLVPacket(FrameNum, FrameBuf, JP2KEssenceUL_Data, Ctx, HMAC);
+  return ReadEKLVPacket(FrameNum, FrameBuf, Dict::ul(MDD_JPEG2000Essence), Ctx, HMAC);
 }
 
 //------------------------------------------------------------------------------------------
@@ -329,28 +316,33 @@ ASDCP::JP2K::MXFReader::DumpIndex(FILE* stream) const
 //
 class ASDCP::JP2K::MXFWriter::h__Writer : public ASDCP::h__Writer
 {
+  JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor;
+
 public:
   PictureDescriptor m_PDesc;
-  ui32_t            m_GOPOffset;
 
   ASDCP_NO_COPY_CONSTRUCT(h__Writer);
 
-  h__Writer() : m_GOPOffset(0) {}
+  h__Writer() : m_EssenceSubDescriptor(0) {}
   ~h__Writer(){}
 
   Result_t OpenWrite(const char*, ui32_t HeaderSize);
   Result_t SetSourceStream(const PictureDescriptor&);
   Result_t WriteFrame(const FrameBuffer&, AESEncContext* = 0, HMACContext* = 0);
   Result_t Finalize();
-  Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc, MXF::RGBAEssenceDescriptor* PDescObj);
+  Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc);
 };
 
 
 //
 ASDCP::Result_t
-ASDCP::JP2K::MXFWriter::h__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc, MXF::RGBAEssenceDescriptor* PDescObj)
+ASDCP::JP2K::MXFWriter::h__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc)
 {
-  // Codec
+  assert(m_EssenceDescriptor);
+  assert(m_EssenceSubDescriptor);
+  MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor;
+
+  PDescObj->Codec.Set(Dict::ul(MDD_JP2KEssenceCompression));
   PDescObj->SampleRate = PDesc.EditRate;
   PDescObj->ContainerDuration = PDesc.ContainerDuration;
   PDescObj->StoredWidth = PDesc.StoredWidth;
@@ -358,24 +350,17 @@ ASDCP::JP2K::MXFWriter::h__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDe
   PDescObj->AspectRatio = PDesc.AspectRatio;
   PDescObj->FrameLayout = 0;
 
-  InterchangeObject* MDObject;
-  if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &MDObject)) )
-    {
-      assert(MDObject);
-      JPEG2000PictureSubDescriptor* PSubDescObj = (JPEG2000PictureSubDescriptor*)MDObject;
-
-      PSubDescObj->Rsize = PDesc.Rsize;
-      PSubDescObj->Xsize = PDesc.Xsize;
-      PSubDescObj->Ysize = PDesc.Ysize;
-      PSubDescObj->XOsize = PDesc.XOsize;
-      PSubDescObj->YOsize = PDesc.YOsize;
-      PSubDescObj->XTsize = PDesc.XTsize;
-      PSubDescObj->YTsize = PDesc.YTsize;
-      PSubDescObj->XTOsize = PDesc.XTOsize;
-      PSubDescObj->YTOsize = PDesc.YTOsize;
-      PSubDescObj->Csize = PDesc.Csize;
-    }
-#if 0
+  m_EssenceSubDescriptor->Rsize = PDesc.Rsize;
+  m_EssenceSubDescriptor->Xsize = PDesc.Xsize;
+  m_EssenceSubDescriptor->Ysize = PDesc.Ysize;
+  m_EssenceSubDescriptor->XOsize = PDesc.XOsize;
+  m_EssenceSubDescriptor->YOsize = PDesc.YOsize;
+  m_EssenceSubDescriptor->XTsize = PDesc.XTsize;
+  m_EssenceSubDescriptor->YTsize = PDesc.YTsize;
+  m_EssenceSubDescriptor->XTOsize = PDesc.XTOsize;
+  m_EssenceSubDescriptor->YTOsize = PDesc.YTOsize;
+  m_EssenceSubDescriptor->Csize = PDesc.Csize;
+
   const ui32_t tmp_buffer_len = 64;
   byte_t tmp_buffer[tmp_buffer_len];
 
@@ -383,10 +368,14 @@ ASDCP::JP2K::MXFWriter::h__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDe
   *(ui32_t*)(tmp_buffer+4) = ASDCP_i32_BE(3L);
   memcpy(tmp_buffer + 8, &PDesc.ImageComponents, sizeof(ASDCP::JP2K::ImageComponent) * 3L);
 
-  PSubDescObj->SetValue("PictureComponentSizing", DataChunk(17, tmp_buffer));
-  PSubDescObj->SetValue("CodingStyleDefault", DataChunk(PDesc.CodingStyleLength, PDesc.CodingStyle));
-  PSubDescObj->SetValue("QuantizationDefault", DataChunk(PDesc.QuantDefaultLength, PDesc.QuantDefault));
-#endif
+  memcpy(m_EssenceSubDescriptor->PictureComponentSizing.Data(), tmp_buffer, 17);
+  m_EssenceSubDescriptor->PictureComponentSizing.Size(17);
+
+  memcpy(m_EssenceSubDescriptor->CodingStyleDefault.Data(), PDesc.CodingStyle, PDesc.CodingStyleLength);
+  m_EssenceSubDescriptor->CodingStyleDefault.Size(PDesc.CodingStyleLength);
+
+  memcpy(m_EssenceSubDescriptor->QuantizationDefault.Data(), PDesc.QuantDefault, PDesc.QuantDefaultLength);
+  m_EssenceSubDescriptor->QuantizationDefault.Size(PDesc.QuantDefaultLength);
 
   return RESULT_OK;
 }
@@ -404,13 +393,11 @@ ASDCP::JP2K::MXFWriter::h__Writer::OpenWrite(const char* filename, ui32_t Header
 
   if ( ASDCP_SUCCESS(result) )
     {
-      RGBAEssenceDescriptor* rgbDesc = new RGBAEssenceDescriptor;
-
-      JPEG2000PictureSubDescriptor* jp2kSubDesc = new JPEG2000PictureSubDescriptor;
-      m_HeaderPart.AddChildObject(jp2kSubDesc);
-      rgbDesc->SubDescriptors.push_back(jp2kSubDesc->InstanceUID);
-
-      m_EssenceDescriptor = rgbDesc;
+      m_HeaderSize = HeaderSize;
+      m_EssenceDescriptor = new RGBAEssenceDescriptor;
+      m_EssenceSubDescriptor = new JPEG2000PictureSubDescriptor;
+      m_HeaderPart.AddChildObject(m_EssenceSubDescriptor);
+      m_EssenceDescriptor->SubDescriptors.push_back(m_EssenceSubDescriptor->InstanceUID);
       result = m_State.Goto_INIT();
     }
 
@@ -425,11 +412,11 @@ ASDCP::JP2K::MXFWriter::h__Writer::SetSourceStream(const PictureDescriptor& PDes
     return RESULT_STATE;
 
   m_PDesc = PDesc;
-  Result_t result = JP2K_PDesc_to_MD(m_PDesc, (RGBAEssenceDescriptor*)m_EssenceDescriptor);
+  Result_t result = JP2K_PDesc_to_MD(m_PDesc);
 
   if ( ASDCP_SUCCESS(result) )
-      result = WriteMXFHeader(JP2K_PACKAGE_LABEL,
-			      UL(WrappingUL_Data_JPEG_2000),
+      result = WriteMXFHeader(JP2K_PACKAGE_LABEL, UL(Dict::ul(MDD_JPEG_2000Wrapping)),
+			      PICT_DEF_LABEL,     UL(Dict::ul(MDD_PictureDataDef)),
 			      m_PDesc.EditRate, 24 /* TCFrameRate */);
 
   if ( ASDCP_SUCCESS(result) )
@@ -451,16 +438,15 @@ ASDCP::JP2K::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESEn
 
   if ( m_State.Test_READY() )
     result = m_State.Goto_RUNNING(); // first time through
-
-  fpos_t ThisOffset = m_StreamOffset;
  
+  IndexTableSegment::IndexEntry Entry;
+  Entry.StreamOffset = m_StreamOffset;
+
   if ( ASDCP_SUCCESS(result) )
-    result = WriteEKLVPacket(FrameBuf, JP2KEssenceUL_Data, Ctx, HMAC);
+    result = WriteEKLVPacket(FrameBuf, Dict::ul(MDD_JPEG2000Essence), Ctx, HMAC);
 
   if ( ASDCP_SUCCESS(result) )
     {  
-      IndexTableSegment::IndexEntry Entry;
-      Entry.StreamOffset = ThisOffset - m_FooterPart.m_ECOffset;
       m_FooterPart.PushIndexEntry(Entry);
       m_FramesWritten++;
     }
diff --git a/src/AS_DCP_MPEG2.cpp b/src/AS_DCP_MPEG2.cpp
index db00c45..badc221 100755
--- a/src/AS_DCP_MPEG2.cpp
+++ b/src/AS_DCP_MPEG2.cpp
@@ -34,9 +34,12 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 //------------------------------------------------------------------------------------------
 
+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";
+
 //
 ASDCP::Result_t
-ASDCP::MD_to_MPEG2_VDesc(MXF::MPEG2VideoDescriptor* VDescObj, MPEG2::VideoDescriptor& VDesc)
+MD_to_MPEG2_VDesc(MXF::MPEG2VideoDescriptor* VDescObj, MPEG2::VideoDescriptor& VDesc)
 {
   ASDCP_TEST_NULL(VDescObj);
 
@@ -65,7 +68,7 @@ ASDCP::MD_to_MPEG2_VDesc(MXF::MPEG2VideoDescriptor* VDescObj, MPEG2::VideoDescri
 
 //
 ASDCP::Result_t
-ASDCP::MPEG2_VDesc_to_MD(MPEG2::VideoDescriptor& VDesc, MXF::MPEG2VideoDescriptor* VDescObj)
+MPEG2_VDesc_to_MD(MPEG2::VideoDescriptor& VDesc, MXF::MPEG2VideoDescriptor* VDescObj)
 {
   ASDCP_TEST_NULL(VDescObj);
 
@@ -228,7 +231,7 @@ ASDCP::MPEG2::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& Fram
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  Result_t result = ReadEKLVPacket(FrameNum, FrameBuf, MPEGEssenceUL_Data, Ctx, HMAC);
+  Result_t result = ReadEKLVPacket(FrameNum, FrameBuf, Dict::ul(MDD_MPEG2Essence), Ctx, HMAC);
 
   if ( ASDCP_FAILURE(result) )
     return result;
@@ -409,6 +412,7 @@ ASDCP::MPEG2::MXFWriter::h__Writer::OpenWrite(const char* filename, ui32_t Heade
 
   if ( ASDCP_SUCCESS(result) )
     {
+      m_HeaderSize = HeaderSize;
       m_EssenceDescriptor = new MPEG2VideoDescriptor;
       result = m_State.Goto_INIT();
     }
@@ -427,8 +431,8 @@ 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(WrappingUL_Data_MPEG2_VES),
+      result = WriteMXFHeader(MPEG_PACKAGE_LABEL, UL(Dict::ul(MDD_MPEG2_VESWrapping)), 
+			      PICT_DEF_LABEL,     UL(Dict::ul(MDD_PictureDataDef)),
 			      m_VDesc.EditRate, 24 /* TCFrameRate */);
 
   if ( ASDCP_SUCCESS(result) )
@@ -451,10 +455,11 @@ ASDCP::MPEG2::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESE
   if ( m_State.Test_READY() )
     result = m_State.Goto_RUNNING(); // first time through, get the body location
 
-  ui64_t ThisOffset = m_File.Tell();
+  IndexTableSegment::IndexEntry Entry;
+  Entry.StreamOffset = m_StreamOffset;
 
   if ( ASDCP_SUCCESS(result) )
-    result = WriteEKLVPacket(FrameBuf, MPEGEssenceUL_Data, Ctx, HMAC);
+    result = WriteEKLVPacket(FrameBuf, Dict::ul(MDD_MPEG2Essence), Ctx, HMAC);
 
   if ( ASDCP_FAILURE(result) )
     return result;
@@ -479,11 +484,9 @@ ASDCP::MPEG2::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESE
     }
 
   // update the index manager
-  IndexTableSegment::IndexEntry Entry;
   Entry.TemporalOffset = - FrameBuf.TemporalOffset();
   Entry.KeyFrameOffset = m_GOPOffset;
   Entry.Flags = Flags;
-  Entry.StreamOffset = ThisOffset - m_FooterPart.m_ECOffset;
   m_FooterPart.PushIndexEntry(Entry);
   m_FramesWritten++;
   m_GOPOffset++;
diff --git a/src/AS_DCP_MXF.cpp b/src/AS_DCP_MXF.cpp
index 5bba537..9436273 100755
--- a/src/AS_DCP_MXF.cpp
+++ b/src/AS_DCP_MXF.cpp
@@ -108,8 +108,8 @@ ASDCP::MD_to_CryptoInfo(CryptographicContext* InfoObj, WriterInfo& Info)
   memcpy(Info.ContextID, InfoObj->ContextID.Value(), UUIDlen);
   memcpy(Info.CryptographicKeyID, InfoObj->CryptographicKeyID.Value(), UUIDlen);
 
-  UL MIC_SHA1(MICAlgorithm_HMAC_SHA1);
-  UL MIC_NONE(MICAlgorithm_NONE);
+  UL MIC_SHA1(Dict::ul(MDD_MICAlgorithm_HMAC_SHA1));
+  UL MIC_NONE(Dict::ul(MDD_MICAlgorithm_NONE));
 
   if ( InfoObj->MICAlgorithm == MIC_SHA1 )
     Info.UsesHMAC = true;
@@ -185,6 +185,7 @@ ASDCP::RawEssenceType(const char* filename, EssenceType_t& type)
       if ( ASDCP_SUCCESS(result) )
 	{
 	  ASDCP::Wav::SimpleWaveHeader WavHeader;
+	  ASDCP::AIFF::SimpleAIFFHeader AIFFHeader;
 	  ui32_t data_offset;
 	  const byte_t* p = FB.RoData();
 
@@ -193,6 +194,9 @@ ASDCP::RawEssenceType(const char* filename, EssenceType_t& type)
 
 	  else if ( ASDCP_SUCCESS(WavHeader.ReadFromBuffer(p, read_count, &data_offset)) )
 	    type = ESS_PCM_24b_48k;
+
+	  else if ( ASDCP_SUCCESS(AIFFHeader.ReadFromBuffer(p, read_count, &data_offset)) )
+	    type = ESS_PCM_24b_48k;
 	}
     }
   else if ( ASDCP::PathIsDirectory(filename) )
@@ -370,33 +374,33 @@ ASDCP::IntegrityPack::CalcValues(const ASDCP::FrameBuffer& FB, byte_t* AssetID,
   byte_t* p = Data;
   HMAC->Reset();
 
-  static byte_t ber_4[klv_length_size] = {0x83, 0};
+  static byte_t ber_4[MXF_BER_LENGTH] = {0x83, 0};
 
   // update HMAC with essence data
   HMAC->Update(FB.RoData(), FB.Size());
 
   // track file ID length
-  memcpy(p, ber_4, klv_length_size);
+  memcpy(p, ber_4, MXF_BER_LENGTH);
   *(p+3) = UUIDlen;;
-  p += klv_length_size;
+  p += MXF_BER_LENGTH;
 
   // track file ID
   memcpy(p, AssetID, UUIDlen);
   p += UUIDlen;
 
   // sequence length
-  memcpy(p, ber_4, klv_length_size);
+  memcpy(p, ber_4, MXF_BER_LENGTH);
   *(p+3) = sizeof(ui64_t);
-  p += klv_length_size;
+  p += MXF_BER_LENGTH;
 
   // sequence number
   i2p<ui64_t>(ASDCP_i64_BE(sequence), p);
   p += sizeof(ui64_t);
 
   // HMAC length
-  memcpy(p, ber_4, klv_length_size);
+  memcpy(p, ber_4, MXF_BER_LENGTH);
   *(p+3) = HMAC_SIZE;
-  p += klv_length_size;
+  p += MXF_BER_LENGTH;
 
   // update HMAC with intpack values
   HMAC->Update(Data, klv_intpack_size - HMAC_SIZE);
@@ -469,23 +473,23 @@ ASDCP::Result_t
 ASDCP::KLVReader::ReadKLFromFile(ASDCP::FileReader& Reader)
 {
   ui32_t read_count;
-  m_HeaderLength = klv_key_size + klv_length_size;
+  m_HeaderLength = SMPTE_UL_LENGTH + MXF_BER_LENGTH;
   Result_t result = Reader.Read(m_Key, m_HeaderLength, &read_count);
   assert(read_count == m_HeaderLength);
 
   if ( ASDCP_SUCCESS(result) )
     {
-      m_BERLength = BER_length(m_Key + klv_key_size);
+      m_BERLength = BER_length(m_Key + SMPTE_UL_LENGTH);
       
       if ( m_BERLength == 0 )
 	{
 	  char intbuf[IntBufferLen];
 	  ASDCP::DefaultLogSink().Error("KLV format error, zero BER length not allowed at file position %s\n",
-					i64szx((Reader.Tell() - (fpos_t)klv_key_size), 8, intbuf));
+					i64szx((Reader.Tell() - (fpos_t)SMPTE_UL_LENGTH), 8, intbuf));
 	  return RESULT_FAIL;
 	}
 
-      if ( m_BERLength != klv_length_size )
+      if ( m_BERLength != MXF_BER_LENGTH )
 	{
 
 	  ASDCP::DefaultLogSink().Error("Found packet with BER length %lu; being less efficient...\n",
@@ -496,7 +500,7 @@ ASDCP::KLVReader::ReadKLFromFile(ASDCP::FileReader& Reader)
 	  assert(0);
 	}
 
-      if ( ! read_BER(m_Key + klv_key_size, &m_Length) )
+      if ( ! read_BER(m_Key + SMPTE_UL_LENGTH, &m_Length) )
 	return RESULT_FAIL;
     }
   
diff --git a/src/AS_DCP_PCM.cpp b/src/AS_DCP_PCM.cpp
index 0aa396f..ef16f2b 100755
--- a/src/AS_DCP_PCM.cpp
+++ b/src/AS_DCP_PCM.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2005, John Hurst
+Copyright (c) 2004-2006, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -34,8 +34,12 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 //------------------------------------------------------------------------------------------
 
+static std::string PCM_PACKAGE_LABEL = "File Package: SMPTE 382M frame wrapping of wave audio";
+static std::string SOUND_DEF_LABEL = "Sound Track";
+
+//
 Result_t
-ASDCP::PCM_ADesc_to_MD(PCM::AudioDescriptor& ADesc, MXF::WaveAudioDescriptor* ADescObj)
+PCM_ADesc_to_MD(PCM::AudioDescriptor& ADesc, MXF::WaveAudioDescriptor* ADescObj)
 {
   ASDCP_TEST_NULL(ADescObj);
   ADescObj->SampleRate = ADesc.SampleRate;
@@ -52,7 +56,7 @@ ASDCP::PCM_ADesc_to_MD(PCM::AudioDescriptor& ADesc, MXF::WaveAudioDescriptor* AD
 
 //
 ASDCP::Result_t
-ASDCP::MD_to_PCM_ADesc(MXF::WaveAudioDescriptor* ADescObj, PCM::AudioDescriptor& ADesc)
+MD_to_PCM_ADesc(MXF::WaveAudioDescriptor* ADescObj, PCM::AudioDescriptor& ADesc)
 {
   ASDCP_TEST_NULL(ADescObj);
   ADesc.SampleRate = ADescObj->SampleRate;
@@ -106,15 +110,15 @@ calc_CBR_frame_size(ASDCP::WriterInfo& Info, const ASDCP::PCM::AudioDescriptor&
   if ( Info.EncryptedEssence )
     {
       CBR_frame_size =
-	klv_key_size
-	+ klv_length_size
+	SMPTE_UL_LENGTH
+	+ MXF_BER_LENGTH
 	+ klv_cryptinfo_size
 	+ calc_esv_length(ASDCP::PCM::CalcFrameBufferSize(ADesc), 0)
-	+ ( Info.UsesHMAC ? klv_intpack_size : (klv_length_size * 3) );
+	+ ( Info.UsesHMAC ? klv_intpack_size : (MXF_BER_LENGTH * 3) );
     }
   else
     {
-      CBR_frame_size = ASDCP::PCM::CalcFrameBufferSize(ADesc) + klv_key_size + klv_length_size;
+      CBR_frame_size = ASDCP::PCM::CalcFrameBufferSize(ADesc) + SMPTE_UL_LENGTH + MXF_BER_LENGTH;
     }
 
   return CBR_frame_size;
@@ -198,7 +202,7 @@ ASDCP::PCM::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& FrameB
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  return ReadEKLVPacket(FrameNum, FrameBuf, WAVEssenceUL_Data, Ctx, HMAC);
+  return ReadEKLVPacket(FrameNum, FrameBuf, Dict::ul(MDD_WAVEssence), Ctx, HMAC);
 }
 
 //------------------------------------------------------------------------------------------
@@ -334,6 +338,7 @@ ASDCP::PCM::MXFWriter::h__Writer::OpenWrite(const char* filename, ui32_t HeaderS
 
   if ( ASDCP_SUCCESS(result) )
     {
+      m_HeaderSize = HeaderSize;
       m_EssenceDescriptor = new WaveAudioDescriptor;
       result = m_State.Goto_INIT();
     }
@@ -369,8 +374,8 @@ 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(WrappingUL_Data_PCM_24b_48k),
+      result = WriteMXFHeader(PCM_PACKAGE_LABEL, UL(Dict::ul(MDD_WAVWrapping)),
+			      SOUND_DEF_LABEL,   UL(Dict::ul(MDD_SoundDataDef)),
 			      m_ADesc.SampleRate, 24 /* TCFrameRate */, calc_CBR_frame_size(m_Info, m_ADesc));
 
   if ( ASDCP_SUCCESS(result) )
@@ -392,7 +397,7 @@ ASDCP::PCM::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESEnc
     result = m_State.Goto_RUNNING(); // first time through
 
   if ( ASDCP_SUCCESS(result) )
-    result = WriteEKLVPacket(FrameBuf, WAVEssenceUL_Data, Ctx, HMAC);
+    result = WriteEKLVPacket(FrameBuf, Dict::ul(MDD_WAVEssence), Ctx, HMAC);
 
   if ( ASDCP_SUCCESS(result) )
     m_FramesWritten++;
diff --git a/src/AS_DCP_internal.h b/src/AS_DCP_internal.h
index ca3d9bb..15890a7 100755
--- a/src/AS_DCP_internal.h
+++ b/src/AS_DCP_internal.h
@@ -45,106 +45,46 @@ using namespace ASDCP::MXF;
 namespace ASDCP
 {
   // constant values used to calculate KLV and EKLV packet sizes
-  static const ui32_t klv_key_size = 16;
-  static const ui32_t klv_length_size = 4;
 
   static const ui32_t klv_cryptinfo_size =
-    klv_length_size
+    MXF_BER_LENGTH
     + UUIDlen /* ContextID */
-    + klv_length_size
+    + MXF_BER_LENGTH
     + sizeof(ui64_t) /* PlaintextOffset */
-    + klv_length_size
-    + klv_key_size /* SourceKey */
-    + klv_length_size
+    + MXF_BER_LENGTH
+    + SMPTE_UL_LENGTH /* SourceKey */
+    + MXF_BER_LENGTH
     + sizeof(ui64_t) /* SourceLength */
-    + klv_length_size /* ESV length */ ;
+    + MXF_BER_LENGTH /* ESV length */ ;
 
   static const ui32_t klv_intpack_size =
-    klv_length_size
+    MXF_BER_LENGTH
     + UUIDlen /* TrackFileID */
-    + klv_length_size
+    + MXF_BER_LENGTH
     + sizeof(ui64_t) /* SequenceNumber */
-    + klv_length_size
+    + MXF_BER_LENGTH
     + 20; /* HMAC length*/
 
-  // why this value? i dunno. it was peeled from mxflib.
-  static const ui32_t HeaderPadding = 16384;
-  
-  const byte_t GCMulti_Data[16] =
-  { 0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x03,
-    0x0d, 0x01, 0x03, 0x01, 0x02, 0x7F, 0x01, 0x00 };
-
-  static const byte_t CipherAlgorithm_AES[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07,
-    0x02, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 };
-
-  static const byte_t MICAlgorithm_NONE[klv_key_size] = {0};
-  static const byte_t MICAlgorithm_HMAC_SHA1[klv_key_size] = 
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07,
-    0x02, 0x09, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 };
-
-#ifdef SMPTE_LABELS
-  static byte_t OPAtom_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02,
-    0x0d, 0x01, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 };
-  static UL OPAtomUL(OPAtom_Data);
-#else
-  static byte_t OPAtom_Data[klv_key_size] =
+  // calculate size of encrypted essence with IV, CheckValue, and padding
+  inline ui32_t
+    calc_esv_length(ui32_t source_length, ui32_t plaintext_offset)
+    {
+      ui32_t ct_size = source_length - plaintext_offset;
+      ui32_t diff = ct_size % CBC_BLOCK_SIZE;
+      ui32_t block_size = ct_size - diff;
+      return plaintext_offset + block_size + (CBC_BLOCK_SIZE * 3);
+    }
+
+  // Interop labels
+
+  static byte_t OPAtom_Data[SMPTE_UL_LENGTH] =
   { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
     0x0d, 0x01, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 };
   static UL OPAtomUL(OPAtom_Data);
-#endif
 
-  static const byte_t OP1a_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
-    0x0d, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00 };
-  static UL OP1aUL(OP1a_Data);
-  
-  // Essence element labels
-  static const byte_t WAVEssenceUL_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01,
-    0x0d, 0x01, 0x03, 0x01, 0x16, 0x01, 0x01, 0x00 };
-
-  static const byte_t MPEGEssenceUL_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01,
-    0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x05, 0x00 };
-
-  static const byte_t JP2KEssenceUL_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01,
-    0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x08, 0x01 };
-
-#ifdef SMPTE_LABELS
-  static const byte_t CryptEssenceUL_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x01,
-    0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 };
-#else
-  static const byte_t CryptEssenceUL_Data[klv_key_size] =
+  static const byte_t CryptEssenceUL_Data[SMPTE_UL_LENGTH] =
   { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x07,
     0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 };
-#endif
-
-  // Essence Container Labels
-  static const byte_t WrappingUL_Data_PCM_24b_48k[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
-    0x0d, 0x01, 0x03, 0x01, 0x02, 0x06, 0x01, 0x00 };
-
-  static const byte_t WrappingUL_Data_MPEG2_VES[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02,
-    0x0d, 0x01, 0x03, 0x01, 0x02, 0x04, 0x60, 0x01 };
-
-  static const byte_t WrappingUL_Data_JPEG_2000[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07,
-    0x0d, 0x01, 0x03, 0x01, 0x02, 0x0c, 0x01, 0x00 };
-
-  static const byte_t WrappingUL_Data_Crypt[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07,
-    0x0d, 0x01, 0x03, 0x01, 0x02, 0x0b, 0x01, 0x00 };
-
-
-  // the label for the Cryptographic Framework DM scheme
-  static const byte_t CryptoFrameworkUL_Data[klv_key_size] =
-  { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07,
-    0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x01, 0x00 };
 
   // the check value for EKLV packets
   // CHUKCHUKCHUKCHUK
@@ -152,39 +92,14 @@ namespace ASDCP
   { 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b,
     0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b };
 
-  // labels used for FilePackages
-  static std::string MPEG_PACKAGE_LABEL = "File Package: SMPTE 381M frame wrapping of MPEG2 video elementary stream";
-  static std::string JP2K_PACKAGE_LABEL = "File Package: SMPTE XXXM frame wrapping of JPEG 2000 codestreams";
-  static std::string PCM_PACKAGE_LABEL = "File Package: SMPTE 382M frame wrapping of wave audio";
-
-  // GetMDObjectByPath() allows searching for metadata object by pathname
-  // This character separates the path elements.
-  static const char OBJECT_PATH_SEPARATOR = '.';
-
   //------------------------------------------------------------------------------------------
   //
 
-  Result_t MD_to_MPEG2_VDesc(MXF::MPEG2VideoDescriptor*, MPEG2::VideoDescriptor&);
-  Result_t MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor*, JP2K::PictureDescriptor&);
-  Result_t MD_to_PCM_ADesc(MXF::WaveAudioDescriptor*, PCM::AudioDescriptor&);
   Result_t MD_to_WriterInfo(MXF::Identification*, WriterInfo&);
   Result_t MD_to_CryptoInfo(MXF::CryptographicContext*, WriterInfo&);
-  Result_t MPEG2_VDesc_to_MD(MPEG2::VideoDescriptor&, MXF::MPEG2VideoDescriptor*);
-  Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor&, MXF::RGBAEssenceDescriptor*);
-  Result_t PCM_ADesc_to_MD(PCM::AudioDescriptor&, MXF::WaveAudioDescriptor*);
   Result_t EncryptFrameBuffer(const ASDCP::FrameBuffer&, ASDCP::FrameBuffer&, AESEncContext*);
   Result_t DecryptFrameBuffer(const ASDCP::FrameBuffer&, ASDCP::FrameBuffer&, AESDecContext*);
 
-  // calculate size of encrypted essence with IV, CheckValue, and padding
-  inline ui32_t
-    calc_esv_length(ui32_t source_length, ui32_t plaintext_offset)
-    {
-      ui32_t ct_size = source_length - plaintext_offset;
-      ui32_t diff = ct_size % CBC_BLOCK_SIZE;
-      ui32_t block_size = ct_size - diff;
-      return plaintext_offset + block_size + (CBC_BLOCK_SIZE * 3);
-    }
-
   //
   class h__Reader
     {
@@ -254,17 +169,22 @@ namespace ASDCP
 
     public:
       FileWriter         m_File;
+      ui32_t             m_HeaderSize;
       OPAtomHeader       m_HeaderPart;
       Partition          m_BodyPart;
       OPAtomIndexFooter  m_FooterPart;
       ui64_t             m_EssenceStart;
 
       MaterialPackage*   m_MaterialPackage;
+      Sequence*          m_MPTCSequence;
       TimecodeComponent* m_MPTimecode;
+      Sequence*          m_MPClSequence;
       SourceClip*        m_MPClip;			//! Material Package SourceClip for each essence stream 
 
       SourcePackage*     m_FilePackage;
+      Sequence*          m_FPTCSequence;
       TimecodeComponent* m_FPTimecode;
+      Sequence*          m_FPClSequence;
       SourceClip*        m_FPClip;			//! File Package SourceClip for each essence stream 
 
       FileDescriptor*    m_EssenceDescriptor;
@@ -279,6 +199,7 @@ namespace ASDCP
       virtual ~h__Writer();
 
       Result_t WriteMXFHeader(const std::string& PackageLabel, const UL& WrappingUL,
+			      const std::string& TrackName, const UL& DataDefinition,
 			      const MXF::Rational& EditRate,
 			      ui32_t TCFrameRate, ui32_t BytesPerEditUnit = 0);
 
@@ -323,7 +244,7 @@ namespace ASDCP
 
       inline const byte_t* Key() { return m_Key; }
       inline const ui64_t  Length() { return m_Length; }
-      inline const ui64_t  KLLength() { return m_BERLength + klv_key_size; }
+      inline const ui64_t  KLLength() { return m_BERLength + SMPTE_UL_LENGTH; }
       Result_t ReadKLFromFile(ASDCP::FileReader& Reader);
     };
 
diff --git a/src/Dict.cpp b/src/Dict.cpp
index 384843e..0b71a8c 100755
--- a/src/Dict.cpp
+++ b/src/Dict.cpp
@@ -36,8 +36,6 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //------------------------------------------------------------------------------------------
 // singleton wrapper
 
-const byte_t mdd_key[] = { 0x06, 0x0e, 0x2b, 0x34 };
-
 //
 const ASDCP::MDDEntry&
 ASDCP::Dict::Type(MDD_t type_id)
@@ -53,7 +51,7 @@ ASDCP::Dict::FindUL(const byte_t* ul_buf)
   ui32_t k_idx = 8;
 
   // must be a pointer to a SMPTE UL
-  if ( ul_buf == 0 || memcmp(mdd_key, ul_buf, 4) != 0 )
+  if ( ul_buf == 0 || memcmp(SMPTE_UL_START, ul_buf, 4) != 0 )
     return 0;
 
   // advance to first matching element
diff --git a/src/Index.cpp b/src/Index.cpp
index 20db4da..0f243f8 100755
--- a/src/Index.cpp
+++ b/src/Index.cpp
@@ -168,7 +168,7 @@ ASDCP::MXF::IndexTableSegment::DeltaEntry::Unarchive(ASDCP::MemIOReader& Reader)
 
 //
 ASDCP::Result_t
-ASDCP::MXF::IndexTableSegment::DeltaEntry::Archive(ASDCP::MemIOWriter& Writer)
+ASDCP::MXF::IndexTableSegment::DeltaEntry::Archive(ASDCP::MemIOWriter& Writer) const
 {
   Result_t result = Writer.WriteUi8((ui8_t)PosTableIndex);
   if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi8(Slice);
@@ -225,7 +225,7 @@ ASDCP::MXF::IndexTableSegment::IndexEntry::Unarchive(ASDCP::MemIOReader& Reader)
 
 //
 ASDCP::Result_t
-ASDCP::MXF::IndexTableSegment::IndexEntry::Archive(ASDCP::MemIOWriter& Writer)
+ASDCP::MXF::IndexTableSegment::IndexEntry::Archive(ASDCP::MemIOWriter& Writer) const
 {
   Result_t result = Writer.WriteUi8((ui8_t)TemporalOffset);
   if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi8((ui8_t)KeyFrameOffset);
diff --git a/src/KLV.cpp b/src/KLV.cpp
index a0d2089..b31969e 100755
--- a/src/KLV.cpp
+++ b/src/KLV.cpp
@@ -131,7 +131,7 @@ ASDCP::KLVPacket::Dump(FILE* stream, bool show_hex)
     }
   else
     {
-      fprintf(stream, "*** Malformed packet ***\n");
+      fprintf(stream, "*** Malformed KLV packet ***\n");
     }
 }
 
diff --git a/src/KLV.h b/src/KLV.h
index 5fb0b3a..9eb230b 100755
--- a/src/KLV.h
+++ b/src/KLV.h
@@ -72,7 +72,8 @@ namespace ASDCP
     public:
       virtual ~IArchive() {}
       virtual Result_t Unarchive(ASDCP::MemIOReader& Reader) = 0;
-      virtual Result_t Archive(ASDCP::MemIOWriter& Writer) = 0;
+      virtual bool     HasValue() const = 0;
+      virtual Result_t Archive(ASDCP::MemIOWriter& Writer) const = 0;
     };
 } // namespace ASDCP
 
@@ -87,7 +88,6 @@ namespace ASDCP
     TagValue      tag;
     bool          optional;
     const char*   name;
-    const char*   detail;
   };
 
   //
@@ -95,6 +95,7 @@ namespace ASDCP
     {
     public:
       static const MDDEntry* FindUL(const byte_t*);
+      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);
@@ -105,6 +106,7 @@ namespace ASDCP
       }
 
     private:
+      Dict* m_Dict;
       ASDCP_NO_COPY_CONSTRUCT(Dict);
 
     protected:
diff --git a/src/MDD.cpp b/src/MDD.cpp
index a365c1e..59e5f0b 100644
--- a/src/MDD.cpp
+++ b/src/MDD.cpp
@@ -33,1049 +33,800 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 
 static const ASDCP::MDDEntry s_MDD_Table[] = {
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01,
-      0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x08, 0x01 }, {0}, true, "JPEG2000Essence", // 0
-    "JPEG 2000 Compressed Picture Essence Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01,
-      0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x05, 0x00 }, {0}, true, "MPEG2Essence", // 1
-    "MPEG-2 Compressed Picture Essence Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01,
-      0x0d, 0x01, 0x03, 0x01, 0x16, 0x01, 0x01, 0x00 }, {0}, true, "WAVEssence", // 2
-    "PCM Audio Essence Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x07,
-      0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 }, {0}, true, "EKLVPacket", // 3
-    "Encrypted Essence Container Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x03, 0x01, 0x02, 0x10, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "KLVFill", // 4
-    "KLV Filler packet" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x03, 0x01, 0x02, 0x01, 0x06, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_MajorVersion", // 5
-    "Major Version number of MXF byte-level format (non-backwards compatible version number)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x03, 0x01, 0x02, 0x01, 0x07, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_MinorVersion", // 6
-    "Minor Version number of MXF byte-level format (backwards compatible version number)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x03, 0x01, 0x02, 0x01, 0x09, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_KAGSize", // 7
-    "Size of the KLV Alignment Grid (KAG) for this partition, in bytes" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x10, 0x10, 0x03, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_ThisPartition", // 8
-    "Byte offset of the start of This Partition, relative to the start of the Header Partition" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x10, 0x10, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_PreviousPartition", // 9
-    "Byte offset of the start of the Previous Partition, relative to the start of the Header Partition" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x10, 0x10, 0x05, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_FooterPartition", // 10
-    "Byte offset of the start of the Footer Partition, relative to the start of the Header Partition" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x06, 0x09, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_HeaderByteCount", // 11
-    "Count of Bytes used for Header Metadata. This starts at the byte following the Partition pack and includes any trailing filler which is part of the Header Metadata." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x06, 0x09, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_IndexByteCount", // 12
-    "Count of Bytes used for Index Table Segments. This starts at the byte following the Header Metadata and includes any trailing filler which is part of the Index Table." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_IndexSID", // 13
-    "Index Table Segment Identifier in this partition. The value 0 defines that there are no Index Table segments in this partition." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x08, 0x01, 0x02, 0x01, 0x03, 0x00, 0x00 }, {0}, false, "PartitionMetadata_BodyOffset", // 14
-    "Byte offset of the first byte in the following Essence Container data relative to the start of the Essence Container identified by this BodySID" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_BodySID", // 15
-    "Identifier of the Essence Container data found in this partition. The value 0 indicates there is no Essence Container data in this partition." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "PartitionMetadata_OperationalPattern", // 16
-    "Universal Label of the Operational Pattern to which this file complies" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00 }, {0}, false, "PartitionMetadata_EssenceContainers", // 17
-    "The unordered batch of Universal Labels of Essence Containers used in or referenced by this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x01, 0x00 }, {0}, false, "OpenHeader", // 18
-    "Open Header Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x03, 0x00 }, {0}, false, "OpenCompleteHeader", // 19
-    "Open Complete Header Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x00 }, {0}, false, "ClosedHeader", // 20
-    "Closed Header Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, 0x00 }, {0}, false, "ClosedCompleteHeader", // 21
-    "Closed Complete Header Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x01, 0x00 }, {0}, false, "OpenBodyPartition", // 22
-    "Open Body Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x03, 0x00 }, {0}, false, "OpenCompleteBodyPartition", // 23
-    "Open Complete Body Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x00 }, {0}, false, "ClosedBodyPartition", // 24
-    "Closed Body Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x04, 0x00 }, {0}, false, "ClosedCompleteBodyPartition", // 25
-    "Closed Complete Body Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x04, 0x02, 0x00 }, {0}, false, "Footer", // 26
-    "Footer Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x04, 0x04, 0x00 }, {0}, false, "CompleteFooter", // 27
-    "Complete Footer Partition Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x05, 0x01, 0x00 }, {0}, false, "Primer", // 28
-    "Primer Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x06, 0x01, 0x01, 0x07, 0x15, 0x00, 0x00, 0x00 }, {0}, false, "Primer_LocalTagEntryBatch", // 29
-    "Local Tag Entry Batch" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "LocalTagEntryBatch_Primer_LocalTag", // 30
-    "The value of the Local Tag" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x03, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "LocalTagEntryBatch_Primer_UID", // 31
-    "The UID of which the local tag is an alias" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x01, 0x01, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x3c, 0x0a}, false, "InterchangeObject_InstanceUID", // 32
-    "Unique ID of this instance" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x08, 0x00, 0x00, 0x00 }, {0x01, 0x02}, true, "GenerationInterchangeObject_GenerationUID", // 33
-    "Generation Instance" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "DefaultObject", // 34
-    "" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x05, 0x30, 0x04, 0x06, 0x00, 0x00, 0x00, 0x00 }, {0x3f, 0x0b}, false, "IndexTableSegmentBase_IndexEditRate", // 35
-    "Edit Rate copied from the tracks of the Essence Container" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x07, 0x02, 0x01, 0x03, 0x01, 0x0a, 0x00, 0x00 }, {0x3f, 0x0c}, false, "IndexTableSegmentBase_IndexStartPosition", // 36
-    "The first editable unit indexed by this Index Table segment measured in File Package Edit Units" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x07, 0x02, 0x02, 0x01, 0x01, 0x02, 0x00, 0x00 }, {0x3f, 0x0d}, false, "IndexTableSegmentBase_IndexDuration", // 37
-    "Time duration of this table segment measured in Edit Unitsof the referenceg package" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x06, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0x3f, 0x05}, false, "IndexTableSegmentBase_EditUnitByteCount", // 38
-    "Byte count of each and every Edit Unit. A value of 0 defines the byte count of Edit Units is only given in the Index Entry Array" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 }, {0x3f, 0x06}, false, "IndexTableSegmentBase_IndexSID", // 39
-    "Stream Identifier (SID) of Index Stream" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 }, {0x3f, 0x07}, false, "IndexTableSegmentBase_BodySID", // 40
-    "Stream Identifier (SID) of Essence Container Stream" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0x3f, 0x08}, false, "IndexTableSegmentBase_SliceCount", // 41
-    "Number of slices minus 1 (NSL)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x04, 0x04, 0x01, 0x07, 0x00, 0x00, 0x00 }, {0x3f, 0x0e}, true, "IndexTableSegmentBase_PosTableCount", // 42
-    "Number of PosTable Entries minus 1 (NPE)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x10, 0x00, 0x00 }, {0}, false, "V10IndexTableSegment", // 43
-    "A segment of an Index Table (v10)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x04, 0x04, 0x01, 0x06, 0x00, 0x00, 0x00 }, {0x3f, 0x09}, true, "V10IndexTableSegment_V10DeltaEntryArray", // 44
-    "Map Elements onto Slices" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0}, false, "V10DeltaEntryArray_V10IndexTableSegment_Reorder", // 45
-    "TRUE=Apply Temporal Reordering" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "V10DeltaEntryArray_V10IndexTableSegment_Slice", // 46
-    "Slice number in IndexEntry" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "V10DeltaEntryArray_V10IndexTableSegment_ElementDelta", // 47
-    "Delta from start of slice to this Element" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x04, 0x04, 0x02, 0x05, 0x00, 0x00, 0x00 }, {0x3f, 0x0a}, false, "V10IndexTableSegment_V10IndexEntryArray", // 48
-    "Index from Edit Unit number to stream offset" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "V10IndexEntryArray_V10IndexTableSegment_TemporalOffset", // 49
-    "Offset in edit units from Display Order to Coded Order" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x04, 0x00, 0x00, 0x00 }, {0}, false, "V10IndexEntryArray_V10IndexTableSegment_AnchorOffset", // 50
-    "Offset in edit units to previous Anchor Frame. The value is zero if this is an anchor frame." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "V10IndexEntryArray_V10IndexTableSegment_Flags", // 51
-    "Flags for this Edit Unit" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "V10IndexEntryArray_V10IndexTableSegment_StreamOffset", // 52
-    "Offset in bytes from the first KLV element in this Edit Unit within the Essence Container" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x05, 0x00, 0x00, 0x00 }, {0}, false, "V10IndexEntryArray_V10IndexTableSegment_SliceOffsetArray", // 53
-    "Array of offsets in bytes from the Stream Offset to the start of each slice." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x10, 0x01, 0x00 }, {0}, false, "IndexTableSegment", // 54
-    "A segment of an Index Table" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x04, 0x04, 0x01, 0x06, 0x00, 0x00, 0x00 }, {0x3f, 0x09}, true, "IndexTableSegment_DeltaEntryArray", // 55
-    "Map Elements onto Slices" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0}, false, "DeltaEntryArray_IndexTableSegment_PosTableIndex", // 56
-    "Index into PosTable (or Apply Temporta Reordering if -1)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "DeltaEntryArray_IndexTableSegment_Slice", // 57
-    "Slice number in IndexEntry" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "DeltaEntryArray_IndexTableSegment_ElementDelta", // 58
-    "Delta from start of slice to this Element" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x04, 0x04, 0x02, 0x05, 0x00, 0x00, 0x00 }, {0x3f, 0x0a}, false, "IndexTableSegment_IndexEntryArray", // 59
-    "Index from Edit Unit number to stream offset" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "IndexEntryArray_IndexTableSegment_TemporalOffset", // 60
-    "Offset in edit units from Display Order to Coded Order" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x04, 0x00, 0x00, 0x00 }, {0}, false, "IndexEntryArray_IndexTableSegment_AnchorOffset", // 61
-    "Offset in edit units to previous Anchor Frame. The value is zero if this is an anchor frame." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "IndexEntryArray_IndexTableSegment_Flags", // 62
-    "Flags for this Edit Unit" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "IndexEntryArray_IndexTableSegment_StreamOffset", // 63
-    "Offset in bytes from the first KLV element in this Edit Unit within the Essence Container" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x05, 0x00, 0x00, 0x00 }, {0}, false, "IndexEntryArray_IndexTableSegment_SliceOffsetArray", // 64
-    "Array of offsets in bytes from the Stream Offset to the start of each slice." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x04, 0x04, 0x01, 0x08, 0x00, 0x00, 0x00 }, {0}, false, "IndexEntryArray_IndexTableSegment_PosTableArray", // 65
-    "Array of fractional position offsets from the start of the content package to the synchronized sample in the Content Package" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x11, 0x01, 0x00 }, {0}, false, "RandomIndexMetadata", // 66
-    "Random Index Pack" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "PartitionArray_RandomIndexMetadata_BodySID", // 67
-    "Stream ID of the Body in this partition" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "PartitionArray_RandomIndexMetadata_ByteOffset", // 68
-    "Byte offset from file start (1st byte of the file which is numbered 0) to the 1st byte of the Partition Pack Key" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x06, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "RandomIndexMetadata_Length", // 69
-    "Overall Length of this Pack including the Set Key and BER Length fields" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 
-      0x0d, 0x01, 0x02, 0x01, 0x01, 0x11, 0x00, 0x00 }, {0}, false, "RandomIndexMetadataV10", // 70
-    "Random Index Pack (v10)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2f, 0x00 }, {0}, false, "Preface", // 71
-    "Preface Set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x10, 0x02, 0x04, 0x00, 0x00 }, {0x3b, 0x02}, false, "Preface_LastModifiedDate", // 72
-    "Date &amp; time of the last modification of the file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x03, 0x01, 0x02, 0x01, 0x05, 0x00, 0x00, 0x00 }, {0x3b, 0x05}, false, "Preface_Version", // 73
-    "The value shall be 258 (i.e. v1.2)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x03, 0x01, 0x02, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0x3b, 0x07}, true, "Preface_ObjectModelVersion", // 74
-    "Simple integer version number of Object Model" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x01, 0x01, 0x04, 0x01, 0x08, 0x00, 0x00 }, {0x3b, 0x08}, true, "Preface_PrimaryPackage", // 75
-    "The primary Package in this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x06, 0x04, 0x00, 0x00 }, {0x3b, 0x06}, false, "Preface_Identifications", // 76
-    "Ordered array of strong references to Identification sets recording all modifications to the file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x02, 0x01, 0x00, 0x00 }, {0x3b, 0x03}, false, "Preface_ContentStorage", // 77
-    "Strong reference to Content Storage object" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 }, {0x3b, 0x09}, false, "Preface_OperationalPattern", // 78
-    "Universal Label of the Operational Pattern which this file complies to (repeat of Partition Pack value)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00 }, {0x3b, 0x0a}, false, "Preface_EssenceContainers", // 79
-    "Unordered batch of ULs of Essence Containers used in or referenced by this file (repeat of Partition Pack value)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x02, 0x02, 0x10, 0x02, 0x02, 0x00, 0x00 }, {0x3b, 0x0b}, false, "Preface_DMSchemes", // 80
-    "An unordered batch of Universal Labels of all the Descriptive Metadata schemes used in this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x30, 0x00 }, {0}, false, "Identification", // 81
-    "Identification set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0x3c, 0x09}, false, "Identification_ThisGenerationUID", // 82
-    "This Generation Identifier" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00 }, {0x3c, 0x01}, false, "Identification_CompanyName", // 83
-    "Manufacturer of the equipment or application that created or modified the file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x03, 0x01, 0x00, 0x00 }, {0x3c, 0x02}, false, "Identification_ProductName", // 84
-    "Name of the application which created or modified this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0x3c, 0x03}, true, "Identification_ProductVersion", // 85
-    "Maj.min.tweak.build.rel  version number of this application" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x05, 0x01, 0x00, 0x00 }, {0x3c, 0x04}, false, "Identification_VersionString", // 86
-    "Human readable name of the application version" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x07, 0x00, 0x00, 0x00 }, {0x3c, 0x05}, false, "Identification_ProductUID", // 87
-    "A unique identification for the product which created this file (defined by the manufacturer)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x10, 0x02, 0x03, 0x00, 0x00 }, {0x3c, 0x06}, false, "Identification_ModificationDate", // 88
-    "Time &amp; date an application created or modified this file and created this Identification set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x0a, 0x00, 0x00, 0x00 }, {0x3c, 0x07}, true, "Identification_ToolkitVersion", // 89
-    "Maj.min.tweak.build.rel version of software or hardware codec used" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x07, 0x01, 0x06, 0x01, 0x00, 0x00 }, {0x3c, 0x08}, true, "Identification_Platform", // 90
-    "Human readable name of the operating system used." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18, 0x00 }, {0}, false, "ContentStorage", // 91
-    "Content Storage set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x05, 0x01, 0x00, 0x00 }, {0x19, 0x01}, false, "ContentStorage_Packages", // 92
-    "Unordered batch of all packages used in this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x05, 0x02, 0x00, 0x00 }, {0x19, 0x02}, true, "ContentStorage_EssenceContainerData", // 93
-    "Unordered batch of strong references to Essence Container Data sets used in this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x05, 0x00, 0x00, 0x00 }, {0x19, 0x01}, false, "ContentStorageKludge_V10Packages", // 94
-    "Unordered batch of all packages used in this file" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23, 0x00 }, {0}, false, "EssenceContainerData", // 95
-    "Essence Container Data set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00 }, {0x27, 0x01}, false, "EssenceContainerData_LinkedPackageUID", // 96
-    "Identifier of the Package to which this set is linked as a UMID" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 }, {0x3f, 0x06}, true, "EssenceContainerData_IndexSID", // 97
-    "ID of the Index Table for the Essence Container to which this set is linked" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 }, {0x3f, 0x07}, false, "EssenceContainerData_BodySID", // 98
-    "ID of the Essence Container to which this set is linked" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x01, 0x01, 0x15, 0x10, 0x00, 0x00, 0x00, 0x00 }, {0x44, 0x01}, false, "GenericPackage_PackageUID", // 99
-    "Unique Package Identifier as a UMID" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x01, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0x44, 0x02}, true, "GenericPackage_Name", // 100
-    "Human readable package name" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x10, 0x01, 0x03, 0x00, 0x00 }, {0x44, 0x05}, false, "GenericPackage_PackageCreationDate", // 101
-    "The date &amp; time of creation of this package" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x10, 0x02, 0x05, 0x00, 0x00 }, {0x44, 0x04}, false, "GenericPackage_PackageModifiedDate", // 102
-    "The date &amp; time of last modification of this package" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x06, 0x05, 0x00, 0x00 }, {0x44, 0x03}, false, "GenericPackage_Tracks", // 103
-    "Array of Unique IDs of Tracks" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x32, 0x00 }, {0}, false, "NetworkLocator", // 104
-    "Network Locator set for location with a URL" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0x40, 0x01}, false, "NetworkLocator_URLString", // 105
-    "A URL indicating where the essence may be found." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x33, 0x00 }, {0}, false, "TextLocator", // 106
-    "Text Locator set for location with a human-readable text string" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0x41, 0x01}, false, "TextLocator_LocatorName", // 107
-    "Value of a human-readable locator text string for manual location of essence" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x01, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0x48, 0x01}, false, "GenericTrack_TrackID", // 108
-    "ID of the track in this package (for linking to a SourceTrackID in a segment)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x01, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 }, {0x48, 0x04}, false, "GenericTrack_TrackNumber", // 109
-    "Number used to link to the track in the Essence Container if it exists" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x01, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0x48, 0x02}, true, "GenericTrack_TrackName", // 110
-    "Human readable name of the track type" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x02, 0x04, 0x00, 0x00 }, {0x48, 0x03}, false, "GenericTrack_Sequence", // 111
-    "Strong Reference to Sequence Set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3a, 0x00 }, {0}, false, "StaticTrack", // 112
-    "" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3b, 0x00 }, {0}, false, "Track", // 113
-    "Track" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x30, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 }, {0x4b, 0x01}, false, "Track_EditRate", // 114
-    "Edit Rate of Track" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x03, 0x01, 0x03, 0x00, 0x00 }, {0x4b, 0x02}, false, "Track_Origin", // 115
-    "An Offset used to resolved timeline references to this track. The start of the track has this timeline value measured in Edit Units." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x39, 0x00 }, {0}, false, "EventTrack", // 116
-    "Event Track" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x30, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x49, 0x01}, false, "EventTrack_EventEditRate", // 117
-    "Edit Rate of Event Track" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x07, 0x02, 0x01, 0x03, 0x01, 0x0b, 0x00, 0x00 }, {0x49, 0x02}, true, "EventTrack_EventOrigin", // 118
-    "An Offset used to resolved timeline references to this event track. The start of the event track has this timeline value measured in Edit Units." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, {0x02, 0x01}, false, "StructuralComponent_DataDefinition", // 119
-    "Data Definition - kind of data or metadata this structure refers to" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00 }, {0x02, 0x02}, false, "StructuralComponent_Duration", // 120
-    "Duration (in units of edit rate)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x00 }, {0}, false, "Sequence", // 121
-    "Sequence" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x06, 0x09, 0x00, 0x00 }, {0x10, 0x01}, false, "Sequence_StructuralComponents", // 122
-    "Ordered array of strong references to Structural Components" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x14, 0x00 }, {0}, false, "TimecodeComponent", // 123
-    "Timecode Component" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x04, 0x01, 0x01, 0x02, 0x06, 0x00, 0x00 }, {0x15, 0x02}, false, "TimecodeComponent_RoundedTimecodeBase", // 124
-    "Integer frames per second" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x03, 0x01, 0x05, 0x00, 0x00 }, {0x15, 0x01}, false, "TimecodeComponent_StartTimecode", // 125
-    "Starting timecode" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x04, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00 }, {0x15, 0x03}, false, "TimecodeComponent_DropFrame", // 126
-    "Drop frame flag" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x11, 0x00 }, {0}, false, "SourceClip", // 127
-    "Source Clip" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00 }, {0x12, 0x01}, false, "SourceClip_StartPosition", // 128
-    "Offset into Essence measured in edit units of the track containing this segment" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00 }, {0x11, 0x01}, false, "SourceClip_SourcePackageID", // 129
-    "ID of referenced Package as a UMID" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x03, 0x02, 0x00, 0x00, 0x00 }, {0x11, 0x02}, false, "SourceClip_SourceTrackID", // 130
-    "Track ID of the referenced Track within the referenced Package" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x41, 0x00 }, {0}, false, "DMSegment", // 131
-    "Descriptive Metadata Segment" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x07, 0x02, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00 }, {0x06, 0x01}, false, "DMSegment_EventStartPosition", // 132
-    "Offset into the descriptive metadata track in edit units" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x30, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00 }, {0x06, 0x02}, true, "DMSegment_EventComment", // 133
-    "Description of the Descriptive Metadata Framework" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x01, 0x07, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00 }, {0x61, 0x02}, false, "DMSegment_TrackIDs", // 134
-    "An unordered list of track ID values that identify the tracks in this Package to which this DM Framework refers (if omitted, refers to all essence tracks)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x06, 0x01, 0x01, 0x04, 0x02, 0x0c, 0x00, 0x00 }, {0x61, 0x01}, false, "DMSegment_DMFramework", // 135
-    "Strong Reference to the Descriptive Metadata Framework" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x45, 0x00 }, {0}, false, "DMSourceClip", // 136
-    "Descriptive Metadata SourceClip" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x01, 0x07, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00 }, {0x61, 0x03}, true, "DMSourceClip_DMSourceClipTrackIDs", // 137
-    "An unordered list of track ID values that identify the tracks in this Package to which the referenced Descriptive Metadata refers (if omitted, refers to all essence tracks)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x36, 0x00 }, {0}, false, "MaterialPackage", // 138
-    "Material Package set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x37, 0x00 }, {0}, false, "SourcePackage", // 139
-    "File Package set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x02, 0x03, 0x00, 0x00 }, {0x47, 0x01}, false, "SourcePackage_Descriptor", // 140
-    "Strong Reference to the Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x06, 0x03, 0x00, 0x00 }, {0x2f, 0x01}, true, "GenericDescriptor_Locators", // 141
-    "Ordered array of strong references to Locator sets" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x06, 0x10, 0x00, 0x00 }, {0}, true, "GenericDescriptor_SubDescriptors", // 142
-    "Ordered array of strong references to sub descriptor sets" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x25, 0x00 }, {0}, false, "FileDescriptor", // 143
-    "File Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x06, 0x01, 0x01, 0x03, 0x05, 0x00, 0x00, 0x00 }, {0x30, 0x06}, true, "FileDescriptor_LinkedTrackID", // 144
-    "Link to (i.e. value of) the Track ID of the Track in this Package to which the Descriptor applies" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0x30, 0x01}, false, "FileDescriptor_SampleRate", // 145
-    "The field or frame rate of the Essence Container (not the essence sampling clock rate)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x06, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x30, 0x02}, true, "FileDescriptor_ContainerDuration", // 146
-    "Duration of Essence Container (measured in Edit Units)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x01, 0x02, 0x00, 0x00 }, {0x30, 0x04}, false, "FileDescriptor_EssenceContainer", // 147
-    "The UL identifying the Essence Container described by this Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x06, 0x01, 0x01, 0x04, 0x01, 0x03, 0x00, 0x00 }, {0x30, 0x05}, true, "FileDescriptor_Codec", // 148
-    "UL to identify a codec compatible with this Essence Container" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x27, 0x00 }, {0}, false, "GenericPictureEssenceDescriptor", // 149
-    "Defines the Picture Essence Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x05, 0x01, 0x13, 0x00, 0x00, 0x00, 0x00 }, {0x32, 0x15}, true, "GenericPictureEssenceDescriptor_SignalStandard", // 150
-    "Underlying signal standard" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0x32, 0x0c}, false, "GenericPictureEssenceDescriptor_FrameLayout", // 151
-    "Interlace or Progressive layout" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x02, 0x02, 0x00, 0x00, 0x00 }, {0x32, 0x03}, false, "GenericPictureEssenceDescriptor_StoredWidth", // 152
-    "Horizontal Size of active picture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0x32, 0x02}, false, "GenericPictureEssenceDescriptor_StoredHeight", // 153
-    "Vertical Field Size of active picture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x03, 0x02, 0x08, 0x00, 0x00, 0x00 }, {0x32, 0x16}, true, "GenericPictureEssenceDescriptor_StoredF2Offset", // 154
-    "Topness Adjustment for stored picture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x08, 0x00, 0x00, 0x00 }, {0x32, 0x05}, true, "GenericPictureEssenceDescriptor_SampledWidth", // 155
-    "Sampled width supplied to codec" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x07, 0x00, 0x00, 0x00 }, {0x32, 0x04}, true, "GenericPictureEssenceDescriptor_SampledHeight", // 156
-    "Sampled height supplied to codec" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x09, 0x00, 0x00, 0x00 }, {0x32, 0x06}, true, "GenericPictureEssenceDescriptor_SampledXOffset", // 157
-    "Offset from sampled to stored width" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x0a, 0x00, 0x00, 0x00 }, {0x32, 0x07}, true, "GenericPictureEssenceDescriptor_SampledYOffset", // 158
-    "Offset from sampled to stored" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x0b, 0x00, 0x00, 0x00 }, {0x32, 0x08}, true, "GenericPictureEssenceDescriptor_DisplayHeight", // 159
-    "Displayed Height placed in Production Aperture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x0c, 0x00, 0x00, 0x00 }, {0x32, 0x09}, true, "GenericPictureEssenceDescriptor_DisplayWidth", // 160
-    "Displayed Width placed in Production Aperture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x0d, 0x00, 0x00, 0x00 }, {0x32, 0x0a}, true, "GenericPictureEssenceDescriptor_DisplayXOffset", // 161
-    "The horizontal offset from the (in pixels) of the picture as displayed" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x0e, 0x00, 0x00, 0x00 }, {0x32, 0x0b}, true, "GenericPictureEssenceDescriptor_DisplayYOffset", // 162
-    "The vertical offset (in pixels) of the picture as displayed" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x03, 0x02, 0x07, 0x00, 0x00, 0x00 }, {0x32, 0x17}, true, "GenericPictureEssenceDescriptor_DisplayF2Offset", // 163
-    "Topness Adjustment for Displayed Picture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0x32, 0x0e}, false, "GenericPictureEssenceDescriptor_AspectRatio", // 164
-    "Specifies the horizontal to vertical aspect ratio of the whole image as it is to be presented to avoid geometric distortion (and hence including any black edges)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x03, 0x02, 0x09, 0x00, 0x00, 0x00 }, {0x32, 0x18}, true, "GenericPictureEssenceDescriptor_ActiveFormatDescriptor", // 165
-    "Specifies the intended framing of the content within the displayed image" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x03, 0x02, 0x05, 0x00, 0x00, 0x00 }, {0x32, 0x0d}, false, "GenericPictureEssenceDescriptor_VideoLineMap", // 166
-    "First active line in each field" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x05, 0x20, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x32, 0x0f}, true, "GenericPictureEssenceDescriptor_AlphaTransparency", // 167
-    "Is Alpha Inverted" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x00 }, {0x32, 0x10}, true, "GenericPictureEssenceDescriptor_Gamma", // 168
-    "Registered UL of known Gamma" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x18, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0x32, 0x11}, true, "GenericPictureEssenceDescriptor_ImageAlignmentOffset", // 169
-    "Byte Boundary alignment required for Low Level Essence Storage" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x18, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x32, 0x13}, true, "GenericPictureEssenceDescriptor_ImageStartOffset", // 170
-    "Unused bytes before start of stored data" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x18, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 }, {0x32, 0x14}, true, "GenericPictureEssenceDescriptor_ImageEndOffset", // 171
-    "Unused bytes before start of stored data" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x03, 0x01, 0x06, 0x00, 0x00, 0x00 }, {0x32, 0x12}, true, "GenericPictureEssenceDescriptor_FieldDominance", // 172
-    "The number of the field which is considered temporally to come first" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0x32, 0x01}, false, "GenericPictureEssenceDescriptor_PictureEssenceCoding", // 173
-    "UL identifying the Picture Compression Scheme" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x28, 0x00 }, {0}, false, "CDCIEssenceDescriptor", // 174
-    "Defines the CDCI Picture Essence Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x03, 0x0a, 0x00, 0x00, 0x00 }, {0x33, 0x01}, false, "CDCIEssenceDescriptor_ComponentDepth", // 175
-    "Number of active bits per sample (e.g. 8, 10, 16)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x05, 0x00, 0x00, 0x00 }, {0x33, 0x02}, false, "CDCIEssenceDescriptor_HorizontalSubsampling", // 176
-    "Specifies the H colour subsampling" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x01, 0x10, 0x00, 0x00, 0x00 }, {0x33, 0x08}, true, "CDCIEssenceDescriptor_VerticalSubsampling", // 177
-    "Specifies the V colour subsampling" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x01, 0x06, 0x00, 0x00, 0x00 }, {0x33, 0x03}, true, "CDCIEssenceDescriptor_ColorSiting", // 178
-    "Enumerated value describing the color siting" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x03, 0x01, 0x02, 0x01, 0x0a, 0x00, 0x00, 0x00 }, {0x33, 0x0b}, true, "CDCIEssenceDescriptor_ReversedByteOrder", // 179
-    "a FALSE value denotes Chroma followed by Luma pexels according to ITU Rec. 601" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x18, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00 }, {0x33, 0x07}, true, "CDCIEssenceDescriptor_PaddingBits", // 180
-    "Bits to round up each pixel to stored size" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x03, 0x07, 0x00, 0x00, 0x00 }, {0x33, 0x09}, true, "CDCIEssenceDescriptor_AlphaSampleDepth", // 181
-    "Number of bits per alpha sample" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x03, 0x03, 0x00, 0x00, 0x00 }, {0x33, 0x04}, true, "CDCIEssenceDescriptor_BlackRefLevel", // 182
-    "Black refernece level e.g. 16 or 64 (8 or 10-bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x01, 0x05, 0x03, 0x04, 0x00, 0x00, 0x00 }, {0x33, 0x05}, true, "CDCIEssenceDescriptor_WhiteReflevel", // 183
-    "White reference level e.g. 235 or 943 (8 or 10 bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x03, 0x05, 0x00, 0x00, 0x00 }, {0x33, 0x06}, true, "CDCIEssenceDescriptor_ColorRange", // 184
-    "Color range e.g. 225 or 897 (8 or 10 bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x29, 0x00 }, {0}, false, "RGBAEssenceDescriptor", // 185
-    "Defines the RGBA Picture Essence Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x05, 0x03, 0x0b, 0x00, 0x00, 0x00 }, {0x34, 0x06}, true, "RGBAEssenceDescriptor_ComponentMaxRef", // 186
-    "Maximum value for RGB components, e.g. 235 or 940 (8 or 10 bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x05, 0x03, 0x0c, 0x00, 0x00, 0x00 }, {0x34, 0x07}, true, "RGBAEssenceDescriptor_ComponentMinRef", // 187
-    "Minimum value for RGB components, e.g. 16 or 64 (8 or 10 bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x05, 0x03, 0x0d, 0x00, 0x00, 0x00 }, {0x34, 0x08}, true, "RGBAEssenceDescriptor_AlphaMaxRef", // 188
-    "Maximum value for alpha component, e.g. 235 or 940 (8 or 10 bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x05, 0x03, 0x0e, 0x00, 0x00, 0x00 }, {0x34, 0x09}, true, "RGBAEssenceDescriptor_AlphaMinRef", // 189
-    "Minimum value for alpha component, e.g. 16 or 64 (8 or 10 bits)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00 }, {0x34, 0x05}, true, "RGBAEssenceDescriptor_ScanningDirection", // 190
-    "Enumerated Scanning Direction" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x03, 0x06, 0x00, 0x00, 0x00 }, {0x34, 0x01}, false, "RGBAEssenceDescriptor_PixelLayout", // 191
-    "Pixel Layout" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x03, 0x08, 0x00, 0x00, 0x00 }, {0x34, 0x03}, true, "RGBAEssenceDescriptor_Palette", // 192
-    "Palette" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x01, 0x05, 0x03, 0x09, 0x00, 0x00, 0x00 }, {0x34, 0x04}, true, "RGBAEssenceDescriptor_PaletteLayout", // 193
-    "Palette Layout" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x42, 0x00 }, {0}, false, "GenericSoundEssenceDescriptor", // 194
-    "Defines the Sound Essence Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00 }, {0x3d, 0x03}, false, "GenericSoundEssenceDescriptor_AudioSamplingRate", // 195
-    "Sampling rate of the audio essence" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x02, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0x3d, 0x02}, false, "GenericSoundEssenceDescriptor_Locked", // 196
-    "Boolean indicating that the Number of samples per frame is locked or unlocked (non-0 = locked)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00 }, {0x3d, 0x04}, true, "GenericSoundEssenceDescriptor_AudioRefLevel", // 197
-    "Audio reference level which gives the number of dBm for 0VU" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 
-      0x04, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0x3d, 0x05}, true, "GenericSoundEssenceDescriptor_ElectroSpatialFormulation", // 198
-    "E.g. mono, dual mono, stereo, A,B etc (enum)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x01, 0x01, 0x04, 0x00, 0x00, 0x00 }, {0x3d, 0x07}, false, "GenericSoundEssenceDescriptor_ChannelCount", // 199
-    "Number of Sound Channels" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x04, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00 }, {0x3d, 0x01}, false, "GenericSoundEssenceDescriptor_QuantizationBits", // 200
-    "Number of quantization bits" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0x3d, 0x0c}, true, "GenericSoundEssenceDescriptor_DialNorm", // 201
-    "Gain to be applied to normalise perceived loudness of the clip, defined by ATSC A/53 (1dB per step)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 
-      0x04, 0x02, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x3d, 0x06}, false, "GenericSoundEssenceDescriptor_SoundEssenceCompression", // 202
-    "UL identifying the Sound Compression Scheme" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x43, 0x00 }, {0}, false, "GenericDataEssenceDescriptor", // 203
-    "Defines the Data Essence Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0x3e, 0x01}, false, "GenericDataEssenceDescriptor_DataEssenceCoding", // 204
-    "Specifies the data essence coding type" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x44, 0x00 }, {0}, false, "MultipleDescriptor", // 205
-    "Defines the Multiple Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 
-      0x06, 0x01, 0x01, 0x04, 0x06, 0x0b, 0x00, 0x00 }, {0x3f, 0x01}, false, "MultipleDescriptor_SubDescriptorUIDs", // 206
-    "Unordered array of strong references to File Descriptor sets (1 per interleaved item within the Essence Container)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x51, 0x00 }, {0}, false, "MPEG2VideoDescriptor", // 207
-    "Defines the MPEG2 Picture Essence Descriptor set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x02, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_SingleSequence", // 208
-    "TRUE if the essence consists of a single MPEG sequence. False if there are a number of sequences. This flag implies that the sequence header information is not varying in the essence stream." },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x03, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_ConstantBFrames", // 209
-    "TRUE if the number of B frames is always constant" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x04, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_CodedContentType", // 210
-    "0= &quot;Unknown&quot;,1= &quot;Progressive&quot;, 2= &quot;Interlaced&quot;, 3= &quot;Mixed&quot;: an enumerated value which tells if the underlying content which was MPEG coded was of a known type" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x05, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_LowDelay", // 211
-    "TRUE if low delay mode was used in the sequence" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x06, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_ClosedGOP", // 212
-    "TRUE if closed_gop is set in all GOP Headers, per 13818-1 IBP descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x07, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_IdenticalGOP", // 213
-    "TRUE if every GOP in the sequence is constructed the same, per 13818-1 IBP descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x08, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_MaxGOP", // 214
-    "Specifies the maximum occurring spacing between I frames, per 13818-1 IBP descriptor. A value of 0 or the absence of this property implies no limit to the maximum GOP" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x09, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_BPictureCount", // 215
-    "Specifies the maximum number of B pictures between P or I frames, equivalent to 13818-2 annex D (M-1)" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x0b, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_BitRate", // 216
-    "Maximum bit rate of MPEG video elementary stream in bit/s as defined in ISO-13818-2 bit_rate property" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x01, 0x06, 0x02, 0x01, 0x0a, 0x00, 0x00 }, {0}, true, "MPEG2VideoDescriptor_ProfileAndLevel", // 217
-    "Specifies the MPEG-2 video profile and level. The value is taken directly from the profile_and_level_indication in the MPEG-2 sequence header extension. For main profile @ main level, the value is 0x48. For 4:2:2 profile @ main level, the value is 0x85" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x48, 0x00 }, {0}, false, "WaveAudioDescriptor", // 218
-    "Defines the Wave Audio Essence Descriptor Set" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0x3d, 0x0a}, false, "WaveAudioDescriptor_BlockAlign", // 219
-    "Sample Block alignment" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x03, 0x02, 0x02, 0x00, 0x00, 0x00 }, {0x3d, 0x0b}, true, "WaveAudioDescriptor_SequenceOffset", // 220
-    "Zero-based ordinal frame number of first essence data within five-frame sequence" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x03, 0x03, 0x05, 0x00, 0x00, 0x00 }, {0x3d, 0x09}, false, "WaveAudioDescriptor_AvgBps", // 221
-    "Average Bytes per second" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 
-      0x04, 0x02, 0x03, 0x01, 0x0e, 0x00, 0x00, 0x00 }, {0x3d, 0x0e}, true, "WaveAudioDescriptor_PeakEnvelope", // 222
-    "Peak Envelope from &lt;LEVL> Chunk" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x5a, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor", // 223
-    "JPEG 2000 Picture Sub Descriptor" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_Rsize", // 224
-    "An enumerated value that defines the decoder capabilities" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_Xsize", // 225
-    "Width of the reference grid" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_Ysize", // 226
-    "Height of the reference grid" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x04, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_XOsize", // 227
-    "Horizontal offset from the origin of the reference grid to the left side of the image area" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x05, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_YOsize", // 228
-    "Vertical offset from the origin of the reference grid to the top side of the image area" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x06, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_XTsize", // 229
-    "Width of one reference tile with respect to the reference grid" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x07, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_YTsize", // 230
-    "Height of one reference tile with respect to the reference grid" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x08, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_XTOsize", // 231
-    "Horizontal offset from the origin of the reference grid to the left side of the first tile" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x09, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_YTOsize", // 232
-    "Vertical offset from the origin of the reference grid to the top side of the first tile" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x0a, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_Csize", // 233
-    "The number of components in the picture" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x0b, 0x00, 0x00, 0x00 }, {0}, false, "JPEG2000PictureSubDescriptor_PictureComponentSizing", // 234
-    "Array of picture components" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x0c, 0x00, 0x00, 0x00 }, {0}, true, "JPEG2000PictureSubDescriptor_CodingStyleDefault", // 235
-    "Default coding style for all components. Use this value only if static for all pictures in the Essence Container" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, 
-      0x04, 0x01, 0x06, 0x03, 0x0d, 0x00, 0x00, 0x00 }, {0}, true, "JPEG2000PictureSubDescriptor_QuantizationDefault", // 236
-    "Default quantization style for all components. Use this value only if static for all pictures in the Essence Container" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "DM_Framework", // 237
-    "Superclass for all concrete DM Frameworks" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "DM_Set", // 238
-    "Superclass for all concrete DM Frameworks" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, 
-      0x0d, 0x01, 0x03, 0x01, 0x02, 0x0b, 0x01, 0x00 }, {0}, false, "EncryptedContainerLabel", // 239
-    "DCP-Crypto Encrypted Essence Container, frame-wrapped" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, 
-      0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x01, 0x00 }, {0}, false, "CryptographicFrameworkLabel", // 240
-    "DCP-Crypto Framework" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00 }, {0}, false, "CryptographicFramework", // 241
-    "DCP-Encryption Cryptographic Framework" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x01, 0x01, 0x04, 0x02, 0x0d, 0x00, 0x00 }, {0}, false, "CryptographicFramework_ContextSR", // 242
-    "Strong Reference to the associated Cryptographic Context" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 
-      0x0d, 0x01, 0x04, 0x01, 0x02, 0x02, 0x00, 0x00 }, {0}, false, "CryptographicContext", // 243
-    "cryptographic information that applies to encrypted essence tracks as a whole" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x01, 0x01, 0x15, 0x11, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "CryptographicContext_ContextID", // 244
-    "Persistent Unique identifier for the context" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x01, 0x01, 0x02, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "CryptographicContext_SourceEssenceContainer", // 245
-    "Essence Container Label for the source essence, prior to encryption" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x02, 0x09, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "CryptographicContext_CipherAlgorithm", // 246
-    "Algorithm used for Triplet encryption, if any" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x02, 0x09, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "CryptographicContext_MICAlgorithm", // 247
-    "Algorithm used for Triplet integrity, if any" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x02, 0x09, 0x03, 0x01, 0x02, 0x00, 0x00, 0x00 }, {0}, false, "CryptographicContext_CryptographicKeyID", // 248
-    "Unique identifier for the cryptographic key" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x07, 
-      0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 }, {0}, false, "EncryptedTriplet", // 249
-    "encrypted data and cryptographic information specific to the Triplet" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x01, 0x01, 0x06, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "EncryptedTriplet_ContextIDLink", // 250
-    "Persistent Unique identifier for the context.associated with this Triplet" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x09, 0x02, 0x01, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "EncryptedTriplet_PlaintextOffset", // 251
-    "Offset within the source at which encryption starts" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x01, 0x01, 0x02, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "EncryptedTriplet_SourceKey", // 252
-    "Key of the source Triplet" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x04, 0x06, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00 }, {0}, false, "EncryptedTriplet_SourceLength", // 253
-    "Length of the value of the source Triplet" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x02, 0x09, 0x03, 0x01, 0x03, 0x00, 0x00, 0x00 }, {0}, false, "EncryptedTriplet_EncryptedSourceValue", // 254
-    "Encrypted Source value starting at Plaintext Offset" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x01, 0x01, 0x06, 0x02, 0x00, 0x00, 0x00 }, {0}, true, "EncryptedTriplet_TrackFileID", // 255
-    "The identifier of the AS-DCP Track File containing this Triplet" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x06, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 }, {0}, true, "EncryptedTriplet_SequenceNumber", // 256
-    "Sequence number of this Triplet within the Track File" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, 
-      0x02, 0x09, 0x03, 0x02, 0x02, 0x00, 0x00, 0x00 }, {0}, true, "EncryptedTriplet_MIC", // 257
-    "Keyed HMAC" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, 
-      0x02, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "CipherAlgorithmAES128CBC", // 258
-    "Identifes the use of AES128 CBC mode cipher algorithm" },
-
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, 
-      0x02, 0x09, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 }, {0}, false, "HMACAlgorithmSHA1128", // 259
-    "Identifes the use of SHA1 128 bit HMAC algorithm" },
-
+  { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "MICAlgorithm_NONE" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02, // 1
+      0x0d, 0x01, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 },
+      {0}, false, "OPAtom" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 2
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00 },
+      {0}, false, "OP1a" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x03, // 3
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x7f, 0x01, 0x00 },
+      {0}, false, "GCMulti" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 4
+      0x01, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "PictureDataDef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 5
+      0x01, 0x03, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00 },
+      {0}, false, "SoundDataDef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 6
+      0x01, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "TimecodeDataDef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 7
+      0x01, 0x03, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 },
+      {0}, false, "DescriptiveMetaDataDef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 8
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x06, 0x01, 0x00 },
+      {0}, false, "WAVWrapping" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02, // 9
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x04, 0x60, 0x01 },
+      {0}, false, "MPEG2_VESWrapping" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 10
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x0c, 0x01, 0x00 },
+      {0}, false, "JPEG_2000Wrapping" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 11
+      0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x08, 0x01 },
+      {0}, false, "JPEG2000Essence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 12
+      0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x05, 0x00 },
+      {0}, false, "MPEG2Essence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x01, // 13
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 },
+      {0}, false, "CryptEssence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 14
+      0x0d, 0x01, 0x03, 0x01, 0x16, 0x01, 0x01, 0x00 },
+      {0}, false, "WAVEssence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x09, // 15
+      0x04, 0x01, 0x02, 0x02, 0x03, 0x01, 0x01, 0x01 },
+      {0}, false, "JP2KEssenceCompression" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 16
+      0x02, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "CipherAlgorithm_AES" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 17
+      0x02, 0x09, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "MICAlgorithm_HMAC_SHA1" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 18
+      0x03, 0x01, 0x02, 0x10, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "KLVFill" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 19
+      0x03, 0x01, 0x02, 0x01, 0x06, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_MajorVersion" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 20
+      0x03, 0x01, 0x02, 0x01, 0x07, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_MinorVersion" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 21
+      0x03, 0x01, 0x02, 0x01, 0x09, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_KAGSize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 22
+      0x06, 0x10, 0x10, 0x03, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_ThisPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 23
+      0x06, 0x10, 0x10, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_PreviousPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 24
+      0x06, 0x10, 0x10, 0x05, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_FooterPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 25
+      0x04, 0x06, 0x09, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_HeaderByteCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 26
+      0x04, 0x06, 0x09, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_IndexByteCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 27
+      0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_IndexSID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 28
+      0x06, 0x08, 0x01, 0x02, 0x01, 0x03, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_BodyOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 29
+      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_BodySID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 30
+      0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_OperationalPattern" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 31
+      0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00 },
+      {0}, false, "PartitionMetadata_EssenceContainers" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 32
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x01, 0x00 },
+      {0}, false, "OpenHeader" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 33
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x03, 0x00 },
+      {0}, false, "OpenCompleteHeader" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 34
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x00 },
+      {0}, false, "ClosedHeader" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 35
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, 0x00 },
+      {0}, false, "ClosedCompleteHeader" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 36
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x01, 0x00 },
+      {0}, false, "OpenBodyPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 37
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x03, 0x00 },
+      {0}, false, "OpenCompleteBodyPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 38
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x00 },
+      {0}, false, "ClosedBodyPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 39
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x04, 0x00 },
+      {0}, false, "ClosedCompleteBodyPartition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 40
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x04, 0x02, 0x00 },
+      {0}, false, "Footer" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 41
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x04, 0x04, 0x00 },
+      {0}, false, "CompleteFooter" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 42
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x05, 0x01, 0x00 },
+      {0}, false, "Primer" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 43
+      0x06, 0x01, 0x01, 0x07, 0x15, 0x00, 0x00, 0x00 },
+      {0}, false, "Primer_LocalTagEntryBatch" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 44
+      0x01, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "LocalTagEntryBatch_Primer_LocalTag" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 45
+      0x01, 0x03, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "LocalTagEntryBatch_Primer_UID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 46
+      0x01, 0x01, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x3c, 0x0a}, false, "InterchangeObject_InstanceUID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 47
+      0x05, 0x20, 0x07, 0x01, 0x08, 0x00, 0x00, 0x00 },
+      {0x01, 0x02}, true, "GenerationInterchangeObject_GenerationUID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 48
+      0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "DefaultObject" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 49
+      0x05, 0x30, 0x04, 0x06, 0x00, 0x00, 0x00, 0x00 },
+      {0x3f, 0x0b}, false, "IndexTableSegmentBase_IndexEditRate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 50
+      0x07, 0x02, 0x01, 0x03, 0x01, 0x0a, 0x00, 0x00 },
+      {0x3f, 0x0c}, false, "IndexTableSegmentBase_IndexStartPosition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 51
+      0x07, 0x02, 0x02, 0x01, 0x01, 0x02, 0x00, 0x00 },
+      {0x3f, 0x0d}, false, "IndexTableSegmentBase_IndexDuration" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 52
+      0x04, 0x06, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0x3f, 0x05}, false, "IndexTableSegmentBase_EditUnitByteCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 53
+      0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
+      {0x3f, 0x06}, false, "IndexTableSegmentBase_IndexSID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 54
+      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
+      {0x3f, 0x07}, false, "IndexTableSegmentBase_BodySID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 55
+      0x04, 0x04, 0x04, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0x3f, 0x08}, false, "IndexTableSegmentBase_SliceCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 56
+      0x04, 0x04, 0x04, 0x01, 0x07, 0x00, 0x00, 0x00 },
+      {0x3f, 0x0e}, true, "IndexTableSegmentBase_PosTableCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 57
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x10, 0x01, 0x00 },
+      {0}, false, "IndexTableSegment" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 58
+      0x04, 0x04, 0x04, 0x01, 0x06, 0x00, 0x00, 0x00 },
+      {0x3f, 0x09}, true, "IndexTableSegment_DeltaEntryArray" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 59
+      0x04, 0x04, 0x04, 0x01, 0x04, 0x00, 0x00, 0x00 },
+      {0}, false, "DeltaEntryArray_IndexTableSegment_PosTableIndex" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 60
+      0x04, 0x04, 0x04, 0x01, 0x02, 0x00, 0x00, 0x00 },
+      {0}, false, "DeltaEntryArray_IndexTableSegment_Slice" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 61
+      0x04, 0x04, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "DeltaEntryArray_IndexTableSegment_ElementDelta" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 62
+      0x04, 0x04, 0x04, 0x02, 0x05, 0x00, 0x00, 0x00 },
+      {0x3f, 0x0a}, false, "IndexTableSegment_IndexEntryArray" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 63
+      0x04, 0x04, 0x04, 0x02, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "IndexEntryArray_IndexTableSegment_TemporalOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 64
+      0x04, 0x04, 0x04, 0x02, 0x04, 0x00, 0x00, 0x00 },
+      {0}, false, "IndexEntryArray_IndexTableSegment_AnchorOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 65
+      0x04, 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00 },
+      {0}, false, "IndexEntryArray_IndexTableSegment_Flags" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 66
+      0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "IndexEntryArray_IndexTableSegment_StreamOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 67
+      0x04, 0x04, 0x04, 0x01, 0x05, 0x00, 0x00, 0x00 },
+      {0}, false, "IndexEntryArray_IndexTableSegment_SliceOffsetArray" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 68
+      0x04, 0x04, 0x04, 0x01, 0x08, 0x00, 0x00, 0x00 },
+      {0}, false, "IndexEntryArray_IndexTableSegment_PosTableArray" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 69
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x11, 0x01, 0x00 },
+      {0}, false, "RandomIndexMetadata" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 70
+      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionArray_RandomIndexMetadata_BodySID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 71
+      0x06, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "PartitionArray_RandomIndexMetadata_ByteOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 72
+      0x04, 0x06, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "RandomIndexMetadata_Length" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 73
+      0x0d, 0x01, 0x02, 0x01, 0x01, 0x11, 0x00, 0x00 },
+      {0}, false, "RandomIndexMetadataV10" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 74
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2f, 0x00 },
+      {0}, false, "Preface" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 75
+      0x07, 0x02, 0x01, 0x10, 0x02, 0x04, 0x00, 0x00 },
+      {0x3b, 0x02}, false, "Preface_LastModifiedDate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 76
+      0x03, 0x01, 0x02, 0x01, 0x05, 0x00, 0x00, 0x00 },
+      {0x3b, 0x05}, false, "Preface_Version" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 77
+      0x03, 0x01, 0x02, 0x01, 0x04, 0x00, 0x00, 0x00 },
+      {0x3b, 0x07}, true, "Preface_ObjectModelVersion" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 78
+      0x06, 0x01, 0x01, 0x04, 0x01, 0x08, 0x00, 0x00 },
+      {0x3b, 0x08}, true, "Preface_PrimaryPackage" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 79
+      0x06, 0x01, 0x01, 0x04, 0x06, 0x04, 0x00, 0x00 },
+      {0x3b, 0x06}, false, "Preface_Identifications" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 80
+      0x06, 0x01, 0x01, 0x04, 0x02, 0x01, 0x00, 0x00 },
+      {0x3b, 0x03}, false, "Preface_ContentStorage" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 81
+      0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 },
+      {0x3b, 0x09}, false, "Preface_OperationalPattern" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 82
+      0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00 },
+      {0x3b, 0x0a}, false, "Preface_EssenceContainers" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 83
+      0x01, 0x02, 0x02, 0x10, 0x02, 0x02, 0x00, 0x00 },
+      {0x3b, 0x0b}, false, "Preface_DMSchemes" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 84
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x30, 0x00 },
+      {0}, false, "Identification" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 85
+      0x05, 0x20, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0x3c, 0x09}, false, "Identification_ThisGenerationUID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 86
+      0x05, 0x20, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00 },
+      {0x3c, 0x01}, false, "Identification_CompanyName" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 87
+      0x05, 0x20, 0x07, 0x01, 0x03, 0x01, 0x00, 0x00 },
+      {0x3c, 0x02}, false, "Identification_ProductName" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 88
+      0x05, 0x20, 0x07, 0x01, 0x04, 0x00, 0x00, 0x00 },
+      {0x3c, 0x03}, true, "Identification_ProductVersion" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 89
+      0x05, 0x20, 0x07, 0x01, 0x05, 0x01, 0x00, 0x00 },
+      {0x3c, 0x04}, false, "Identification_VersionString" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 90
+      0x05, 0x20, 0x07, 0x01, 0x07, 0x00, 0x00, 0x00 },
+      {0x3c, 0x05}, false, "Identification_ProductUID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 91
+      0x07, 0x02, 0x01, 0x10, 0x02, 0x03, 0x00, 0x00 },
+      {0x3c, 0x06}, false, "Identification_ModificationDate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 92
+      0x05, 0x20, 0x07, 0x01, 0x0a, 0x00, 0x00, 0x00 },
+      {0x3c, 0x07}, true, "Identification_ToolkitVersion" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 93
+      0x05, 0x20, 0x07, 0x01, 0x06, 0x01, 0x00, 0x00 },
+      {0x3c, 0x08}, true, "Identification_Platform" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 94
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18, 0x00 },
+      {0}, false, "ContentStorage" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 95
+      0x06, 0x01, 0x01, 0x04, 0x05, 0x01, 0x00, 0x00 },
+      {0x19, 0x01}, false, "ContentStorage_Packages" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 96
+      0x06, 0x01, 0x01, 0x04, 0x05, 0x02, 0x00, 0x00 },
+      {0x19, 0x02}, true, "ContentStorage_EssenceContainerData" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 97
+      0x06, 0x01, 0x01, 0x04, 0x05, 0x00, 0x00, 0x00 },
+      {0x19, 0x01}, false, "ContentStorageKludge_V10Packages" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 98
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23, 0x00 },
+      {0}, false, "EssenceContainerData" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 99
+      0x06, 0x01, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00 },
+      {0x27, 0x01}, false, "EssenceContainerData_LinkedPackageUID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 100
+      0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
+      {0x3f, 0x06}, true, "EssenceContainerData_IndexSID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 101
+      0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
+      {0x3f, 0x07}, false, "EssenceContainerData_BodySID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 102
+      0x01, 0x01, 0x15, 0x10, 0x00, 0x00, 0x00, 0x00 },
+      {0x44, 0x01}, false, "GenericPackage_PackageUID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 103
+      0x01, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0x44, 0x02}, true, "GenericPackage_Name" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 104
+      0x07, 0x02, 0x01, 0x10, 0x01, 0x03, 0x00, 0x00 },
+      {0x44, 0x05}, false, "GenericPackage_PackageCreationDate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 105
+      0x07, 0x02, 0x01, 0x10, 0x02, 0x05, 0x00, 0x00 },
+      {0x44, 0x04}, false, "GenericPackage_PackageModifiedDate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 106
+      0x06, 0x01, 0x01, 0x04, 0x06, 0x05, 0x00, 0x00 },
+      {0x44, 0x03}, false, "GenericPackage_Tracks" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 107
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x32, 0x00 },
+      {0}, false, "NetworkLocator" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 108
+      0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0x40, 0x01}, false, "NetworkLocator_URLString" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 109
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x33, 0x00 },
+      {0}, false, "TextLocator" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 110
+      0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0x41, 0x01}, false, "TextLocator_LocatorName" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 111
+      0x01, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0x48, 0x01}, false, "GenericTrack_TrackID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 112
+      0x01, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 },
+      {0x48, 0x04}, false, "GenericTrack_TrackNumber" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 113
+      0x01, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0x48, 0x02}, true, "GenericTrack_TrackName" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 114
+      0x06, 0x01, 0x01, 0x04, 0x02, 0x04, 0x00, 0x00 },
+      {0x48, 0x03}, false, "GenericTrack_Sequence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 115
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3a, 0x00 },
+      {0}, false, "StaticTrack" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 116
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3b, 0x00 },
+      {0}, false, "Track" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 117
+      0x05, 0x30, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
+      {0x4b, 0x01}, false, "Track_EditRate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 118
+      0x07, 0x02, 0x01, 0x03, 0x01, 0x03, 0x00, 0x00 },
+      {0x4b, 0x02}, false, "Track_Origin" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 119
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x39, 0x00 },
+      {0}, false, "EventTrack" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 120
+      0x05, 0x30, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x49, 0x01}, false, "EventTrack_EventEditRate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 121
+      0x07, 0x02, 0x01, 0x03, 0x01, 0x0b, 0x00, 0x00 },
+      {0x49, 0x02}, true, "EventTrack_EventOrigin" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 122
+      0x04, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 },
+      {0x02, 0x01}, false, "StructuralComponent_DataDefinition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 123
+      0x07, 0x02, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00 },
+      {0x02, 0x02}, false, "StructuralComponent_Duration" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 124
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x00 },
+      {0}, false, "Sequence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 125
+      0x06, 0x01, 0x01, 0x04, 0x06, 0x09, 0x00, 0x00 },
+      {0x10, 0x01}, false, "Sequence_StructuralComponents" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 126
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x14, 0x00 },
+      {0}, false, "TimecodeComponent" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 127
+      0x04, 0x04, 0x01, 0x01, 0x02, 0x06, 0x00, 0x00 },
+      {0x15, 0x02}, false, "TimecodeComponent_RoundedTimecodeBase" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 128
+      0x07, 0x02, 0x01, 0x03, 0x01, 0x05, 0x00, 0x00 },
+      {0x15, 0x01}, false, "TimecodeComponent_StartTimecode" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 129
+      0x04, 0x04, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00 },
+      {0x15, 0x03}, false, "TimecodeComponent_DropFrame" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 130
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x11, 0x00 },
+      {0}, false, "SourceClip" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 131
+      0x07, 0x02, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00 },
+      {0x12, 0x01}, false, "SourceClip_StartPosition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 132
+      0x06, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00 },
+      {0x11, 0x01}, false, "SourceClip_SourcePackageID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 133
+      0x06, 0x01, 0x01, 0x03, 0x02, 0x00, 0x00, 0x00 },
+      {0x11, 0x02}, false, "SourceClip_SourceTrackID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 134
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x41, 0x00 },
+      {0}, false, "DMSegment" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 135
+      0x07, 0x02, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00 },
+      {0x06, 0x01}, false, "DMSegment_EventStartPosition" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 136
+      0x05, 0x30, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00 },
+      {0x06, 0x02}, true, "DMSegment_EventComment" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 137
+      0x01, 0x07, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00 },
+      {0x61, 0x02}, false, "DMSegment_TrackIDs" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 138
+      0x06, 0x01, 0x01, 0x04, 0x02, 0x0c, 0x00, 0x00 },
+      {0x61, 0x01}, false, "DMSegment_DMFramework" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 139
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x45, 0x00 },
+      {0}, false, "DMSourceClip" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 140
+      0x01, 0x07, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00 },
+      {0x61, 0x03}, true, "DMSourceClip_DMSourceClipTrackIDs" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 141
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x36, 0x00 },
+      {0}, false, "MaterialPackage" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 142
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x37, 0x00 },
+      {0}, false, "SourcePackage" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 143
+      0x06, 0x01, 0x01, 0x04, 0x02, 0x03, 0x00, 0x00 },
+      {0x47, 0x01}, false, "SourcePackage_Descriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 144
+      0x06, 0x01, 0x01, 0x04, 0x06, 0x03, 0x00, 0x00 },
+      {0x2f, 0x01}, true, "GenericDescriptor_Locators" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 145
+      0x06, 0x01, 0x01, 0x04, 0x06, 0x10, 0x00, 0x00 },
+      {0}, true, "GenericDescriptor_SubDescriptors" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 146
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x25, 0x00 },
+      {0}, false, "FileDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 147
+      0x06, 0x01, 0x01, 0x03, 0x05, 0x00, 0x00, 0x00 },
+      {0x30, 0x06}, true, "FileDescriptor_LinkedTrackID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 148
+      0x04, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0x30, 0x01}, false, "FileDescriptor_SampleRate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 149
+      0x04, 0x06, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x30, 0x02}, true, "FileDescriptor_ContainerDuration" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 150
+      0x06, 0x01, 0x01, 0x04, 0x01, 0x02, 0x00, 0x00 },
+      {0x30, 0x04}, false, "FileDescriptor_EssenceContainer" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 151
+      0x06, 0x01, 0x01, 0x04, 0x01, 0x03, 0x00, 0x00 },
+      {0x30, 0x05}, true, "FileDescriptor_Codec" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 152
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x27, 0x00 },
+      {0}, false, "GenericPictureEssenceDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 153
+      0x04, 0x05, 0x01, 0x13, 0x00, 0x00, 0x00, 0x00 },
+      {0x32, 0x15}, true, "GenericPictureEssenceDescriptor_SignalStandard" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 154
+      0x04, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00 },
+      {0x32, 0x0c}, false, "GenericPictureEssenceDescriptor_FrameLayout" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 155
+      0x04, 0x01, 0x05, 0x02, 0x02, 0x00, 0x00, 0x00 },
+      {0x32, 0x03}, false, "GenericPictureEssenceDescriptor_StoredWidth" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 156
+      0x04, 0x01, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0x32, 0x02}, false, "GenericPictureEssenceDescriptor_StoredHeight" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 157
+      0x04, 0x01, 0x03, 0x02, 0x08, 0x00, 0x00, 0x00 },
+      {0x32, 0x16}, true, "GenericPictureEssenceDescriptor_StoredF2Offset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 158
+      0x04, 0x01, 0x05, 0x01, 0x08, 0x00, 0x00, 0x00 },
+      {0x32, 0x05}, true, "GenericPictureEssenceDescriptor_SampledWidth" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 159
+      0x04, 0x01, 0x05, 0x01, 0x07, 0x00, 0x00, 0x00 },
+      {0x32, 0x04}, true, "GenericPictureEssenceDescriptor_SampledHeight" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 160
+      0x04, 0x01, 0x05, 0x01, 0x09, 0x00, 0x00, 0x00 },
+      {0x32, 0x06}, true, "GenericPictureEssenceDescriptor_SampledXOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 161
+      0x04, 0x01, 0x05, 0x01, 0x0a, 0x00, 0x00, 0x00 },
+      {0x32, 0x07}, true, "GenericPictureEssenceDescriptor_SampledYOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 162
+      0x04, 0x01, 0x05, 0x01, 0x0b, 0x00, 0x00, 0x00 },
+      {0x32, 0x08}, true, "GenericPictureEssenceDescriptor_DisplayHeight" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 163
+      0x04, 0x01, 0x05, 0x01, 0x0c, 0x00, 0x00, 0x00 },
+      {0x32, 0x09}, true, "GenericPictureEssenceDescriptor_DisplayWidth" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 164
+      0x04, 0x01, 0x05, 0x01, 0x0d, 0x00, 0x00, 0x00 },
+      {0x32, 0x0a}, true, "GenericPictureEssenceDescriptor_DisplayXOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 165
+      0x04, 0x01, 0x05, 0x01, 0x0e, 0x00, 0x00, 0x00 },
+      {0x32, 0x0b}, true, "GenericPictureEssenceDescriptor_DisplayYOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 166
+      0x04, 0x01, 0x03, 0x02, 0x07, 0x00, 0x00, 0x00 },
+      {0x32, 0x17}, true, "GenericPictureEssenceDescriptor_DisplayF2Offset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 167
+      0x04, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0x32, 0x0e}, false, "GenericPictureEssenceDescriptor_AspectRatio" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 168
+      0x04, 0x01, 0x03, 0x02, 0x09, 0x00, 0x00, 0x00 },
+      {0x32, 0x18}, true, "GenericPictureEssenceDescriptor_ActiveFormatDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 169
+      0x04, 0x01, 0x03, 0x02, 0x05, 0x00, 0x00, 0x00 },
+      {0x32, 0x0d}, false, "GenericPictureEssenceDescriptor_VideoLineMap" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 170
+      0x05, 0x20, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x32, 0x0f}, true, "GenericPictureEssenceDescriptor_AlphaTransparency" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 171
+      0x04, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x00 },
+      {0x32, 0x10}, true, "GenericPictureEssenceDescriptor_Gamma" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 172
+      0x04, 0x18, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0x32, 0x11}, true, "GenericPictureEssenceDescriptor_ImageAlignmentOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 173
+      0x04, 0x18, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x32, 0x13}, true, "GenericPictureEssenceDescriptor_ImageStartOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 174
+      0x04, 0x18, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 },
+      {0x32, 0x14}, true, "GenericPictureEssenceDescriptor_ImageEndOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 175
+      0x04, 0x01, 0x03, 0x01, 0x06, 0x00, 0x00, 0x00 },
+      {0x32, 0x12}, true, "GenericPictureEssenceDescriptor_FieldDominance" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 176
+      0x04, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0x32, 0x01}, false, "GenericPictureEssenceDescriptor_PictureEssenceCoding" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 177
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x28, 0x00 },
+      {0}, false, "CDCIEssenceDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 178
+      0x04, 0x01, 0x05, 0x03, 0x0a, 0x00, 0x00, 0x00 },
+      {0x33, 0x01}, false, "CDCIEssenceDescriptor_ComponentDepth" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 179
+      0x04, 0x01, 0x05, 0x01, 0x05, 0x00, 0x00, 0x00 },
+      {0x33, 0x02}, false, "CDCIEssenceDescriptor_HorizontalSubsampling" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 180
+      0x04, 0x01, 0x05, 0x01, 0x10, 0x00, 0x00, 0x00 },
+      {0x33, 0x08}, true, "CDCIEssenceDescriptor_VerticalSubsampling" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 181
+      0x04, 0x01, 0x05, 0x01, 0x06, 0x00, 0x00, 0x00 },
+      {0x33, 0x03}, true, "CDCIEssenceDescriptor_ColorSiting" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 182
+      0x03, 0x01, 0x02, 0x01, 0x0a, 0x00, 0x00, 0x00 },
+      {0x33, 0x0b}, true, "CDCIEssenceDescriptor_ReversedByteOrder" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 183
+      0x04, 0x18, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00 },
+      {0x33, 0x07}, true, "CDCIEssenceDescriptor_PaddingBits" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 184
+      0x04, 0x01, 0x05, 0x03, 0x07, 0x00, 0x00, 0x00 },
+      {0x33, 0x09}, true, "CDCIEssenceDescriptor_AlphaSampleDepth" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 185
+      0x04, 0x01, 0x05, 0x03, 0x03, 0x00, 0x00, 0x00 },
+      {0x33, 0x04}, true, "CDCIEssenceDescriptor_BlackRefLevel" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 186
+      0x04, 0x01, 0x05, 0x03, 0x04, 0x00, 0x00, 0x00 },
+      {0x33, 0x05}, true, "CDCIEssenceDescriptor_WhiteReflevel" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 187
+      0x04, 0x01, 0x05, 0x03, 0x05, 0x00, 0x00, 0x00 },
+      {0x33, 0x06}, true, "CDCIEssenceDescriptor_ColorRange" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 188
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x29, 0x00 },
+      {0}, false, "RGBAEssenceDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 189
+      0x04, 0x01, 0x05, 0x03, 0x0b, 0x00, 0x00, 0x00 },
+      {0x34, 0x06}, true, "RGBAEssenceDescriptor_ComponentMaxRef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 190
+      0x04, 0x01, 0x05, 0x03, 0x0c, 0x00, 0x00, 0x00 },
+      {0x34, 0x07}, true, "RGBAEssenceDescriptor_ComponentMinRef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 191
+      0x04, 0x01, 0x05, 0x03, 0x0d, 0x00, 0x00, 0x00 },
+      {0x34, 0x08}, true, "RGBAEssenceDescriptor_AlphaMaxRef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 192
+      0x04, 0x01, 0x05, 0x03, 0x0e, 0x00, 0x00, 0x00 },
+      {0x34, 0x09}, true, "RGBAEssenceDescriptor_AlphaMinRef" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 193
+      0x04, 0x01, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00 },
+      {0x34, 0x05}, true, "RGBAEssenceDescriptor_ScanningDirection" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 194
+      0x04, 0x01, 0x05, 0x03, 0x06, 0x00, 0x00, 0x00 },
+      {0x34, 0x01}, false, "RGBAEssenceDescriptor_PixelLayout" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 195
+      0x04, 0x01, 0x05, 0x03, 0x08, 0x00, 0x00, 0x00 },
+      {0x34, 0x03}, true, "RGBAEssenceDescriptor_Palette" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 196
+      0x04, 0x01, 0x05, 0x03, 0x09, 0x00, 0x00, 0x00 },
+      {0x34, 0x04}, true, "RGBAEssenceDescriptor_PaletteLayout" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 197
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x42, 0x00 },
+      {0}, false, "GenericSoundEssenceDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 198
+      0x04, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00 },
+      {0x3d, 0x03}, false, "GenericSoundEssenceDescriptor_AudioSamplingRate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 199
+      0x04, 0x02, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00 },
+      {0x3d, 0x02}, false, "GenericSoundEssenceDescriptor_Locked" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 200
+      0x04, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00 },
+      {0x3d, 0x04}, true, "GenericSoundEssenceDescriptor_AudioRefLevel" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 201
+      0x04, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0x3d, 0x05}, true, "GenericSoundEssenceDescriptor_ElectroSpatialFormulation" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 202
+      0x04, 0x02, 0x01, 0x01, 0x04, 0x00, 0x00, 0x00 },
+      {0x3d, 0x07}, false, "GenericSoundEssenceDescriptor_ChannelCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 203
+      0x04, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00 },
+      {0x3d, 0x01}, false, "GenericSoundEssenceDescriptor_QuantizationBits" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 204
+      0x04, 0x02, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0x3d, 0x0c}, true, "GenericSoundEssenceDescriptor_DialNorm" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 205
+      0x04, 0x02, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x3d, 0x06}, false, "GenericSoundEssenceDescriptor_SoundEssenceCompression" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 206
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x43, 0x00 },
+      {0}, false, "GenericDataEssenceDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 207
+      0x04, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0x3e, 0x01}, false, "GenericDataEssenceDescriptor_DataEssenceCoding" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 208
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x44, 0x00 },
+      {0}, false, "MultipleDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 209
+      0x06, 0x01, 0x01, 0x04, 0x06, 0x0b, 0x00, 0x00 },
+      {0x3f, 0x01}, false, "MultipleDescriptor_SubDescriptorUIDs" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 210
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x51, 0x00 },
+      {0}, false, "MPEG2VideoDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 211
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x02, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_SingleSequence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 212
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x03, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_ConstantBFrames" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 213
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x04, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_CodedContentType" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 214
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x05, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_LowDelay" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 215
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x06, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_ClosedGOP" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 216
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x07, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_IdenticalGOP" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 217
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x08, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_MaxGOP" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 218
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x09, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_BPictureCount" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 219
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x0b, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_BitRate" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 220
+      0x04, 0x01, 0x06, 0x02, 0x01, 0x0a, 0x00, 0x00 },
+      {0}, true, "MPEG2VideoDescriptor_ProfileAndLevel" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 221
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x48, 0x00 },
+      {0}, false, "WaveAudioDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 222
+      0x04, 0x02, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0x3d, 0x0a}, false, "WaveAudioDescriptor_BlockAlign" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 223
+      0x04, 0x02, 0x03, 0x02, 0x02, 0x00, 0x00, 0x00 },
+      {0x3d, 0x0b}, true, "WaveAudioDescriptor_SequenceOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 224
+      0x04, 0x02, 0x03, 0x03, 0x05, 0x00, 0x00, 0x00 },
+      {0x3d, 0x09}, false, "WaveAudioDescriptor_AvgBps" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 225
+      0x04, 0x02, 0x03, 0x01, 0x0e, 0x00, 0x00, 0x00 },
+      {0x3d, 0x0e}, true, "WaveAudioDescriptor_PeakEnvelope" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 226
+      0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x5a, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 227
+      0x04, 0x01, 0x06, 0x03, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_Rsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 228
+      0x04, 0x01, 0x06, 0x03, 0x02, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_Xsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 229
+      0x04, 0x01, 0x06, 0x03, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_Ysize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 230
+      0x04, 0x01, 0x06, 0x03, 0x04, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_XOsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 231
+      0x04, 0x01, 0x06, 0x03, 0x05, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_YOsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 232
+      0x04, 0x01, 0x06, 0x03, 0x06, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_XTsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 233
+      0x04, 0x01, 0x06, 0x03, 0x07, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_YTsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 234
+      0x04, 0x01, 0x06, 0x03, 0x08, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_XTOsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 235
+      0x04, 0x01, 0x06, 0x03, 0x09, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_YTOsize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 236
+      0x04, 0x01, 0x06, 0x03, 0x0a, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_Csize" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 237
+      0x04, 0x01, 0x06, 0x03, 0x0b, 0x00, 0x00, 0x00 },
+      {0}, false, "JPEG2000PictureSubDescriptor_PictureComponentSizing" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 238
+      0x04, 0x01, 0x06, 0x03, 0x0c, 0x00, 0x00, 0x00 },
+      {0}, true, "JPEG2000PictureSubDescriptor_CodingStyleDefault" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 239
+      0x04, 0x01, 0x06, 0x03, 0x0d, 0x00, 0x00, 0x00 },
+      {0}, true, "JPEG2000PictureSubDescriptor_QuantizationDefault" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 240
+      0x0d, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "DM_Framework" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 241
+      0x0d, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "DM_Set" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 242
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x0b, 0x01, 0x00 },
+      {0}, false, "EncryptedContainerLabel" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 243
+      0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x01, 0x00 },
+      {0}, false, "CryptographicFrameworkLabel" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 244
+      0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00 },
+      {0}, false, "CryptographicFramework" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 245
+      0x06, 0x01, 0x01, 0x04, 0x02, 0x0d, 0x00, 0x00 },
+      {0}, false, "CryptographicFramework_ContextSR" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 246
+      0x0d, 0x01, 0x04, 0x01, 0x02, 0x02, 0x00, 0x00 },
+      {0}, false, "CryptographicContext" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 247
+      0x01, 0x01, 0x15, 0x11, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "CryptographicContext_ContextID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 248
+      0x06, 0x01, 0x01, 0x02, 0x02, 0x00, 0x00, 0x00 },
+      {0}, false, "CryptographicContext_SourceEssenceContainer" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 249
+      0x02, 0x09, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "CryptographicContext_CipherAlgorithm" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 250
+      0x02, 0x09, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "CryptographicContext_MICAlgorithm" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 251
+      0x02, 0x09, 0x03, 0x01, 0x02, 0x00, 0x00, 0x00 },
+      {0}, false, "CryptographicContext_CryptographicKeyID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x07, // 252
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 },
+      {0}, false, "EncryptedTriplet" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 253
+      0x06, 0x01, 0x01, 0x06, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "EncryptedTriplet_ContextIDLink" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 254
+      0x06, 0x09, 0x02, 0x01, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "EncryptedTriplet_PlaintextOffset" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 255
+      0x06, 0x01, 0x01, 0x02, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "EncryptedTriplet_SourceKey" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 256
+      0x04, 0x06, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00 },
+      {0}, false, "EncryptedTriplet_SourceLength" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 257
+      0x02, 0x09, 0x03, 0x01, 0x03, 0x00, 0x00, 0x00 },
+      {0}, false, "EncryptedTriplet_EncryptedSourceValue" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 258
+      0x06, 0x01, 0x01, 0x06, 0x02, 0x00, 0x00, 0x00 },
+      {0}, true, "EncryptedTriplet_TrackFileID" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 259
+      0x06, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 },
+      {0}, true, "EncryptedTriplet_SequenceNumber" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 260
+      0x02, 0x09, 0x03, 0x02, 0x02, 0x00, 0x00, 0x00 },
+      {0}, true, "EncryptedTriplet_MIC" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 261
+      0x02, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "CipherAlgorithmAES128CBC" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 262
+      0x02, 0x09, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 },
+      {0}, false, "HMACAlgorithmSHA1128" },
   { 0, 0, 0 }
 };
 
+const ui32_t s_MDD_Table_size = 263;
+
 //
 // end MDD.cpp
 //
diff --git a/src/MDD.h b/src/MDD.h
index 413955c..ac65bf5 100755
--- a/src/MDD.h
+++ b/src/MDD.h
@@ -35,266 +35,269 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 namespace ASDCP {
     enum MDD_t {
-        MDD_JPEG2000Essence,
-        MDD_MPEG2Essence,
-        MDD_WAVEssence,
-        MDD_EKLVPacket,
-        MDD_KLVFill,
-        MDD_PartitionMetadata_MajorVersion,
-        MDD_PartitionMetadata_MinorVersion,
-        MDD_PartitionMetadata_KAGSize,
-        MDD_PartitionMetadata_ThisPartition,
-        MDD_PartitionMetadata_PreviousPartition,
-        MDD_PartitionMetadata_FooterPartition,
-        MDD_PartitionMetadata_HeaderByteCount,
-        MDD_PartitionMetadata_IndexByteCount,
-        MDD_PartitionMetadata_IndexSID,
-        MDD_PartitionMetadata_BodyOffset,
-        MDD_PartitionMetadata_BodySID,
-        MDD_PartitionMetadata_OperationalPattern,
-        MDD_PartitionMetadata_EssenceContainers,
-        MDD_OpenHeader,
-        MDD_OpenCompleteHeader,
-        MDD_ClosedHeader,
-        MDD_ClosedCompleteHeader,
-        MDD_OpenBodyPartition,
-        MDD_OpenCompleteBodyPartition,
-        MDD_ClosedBodyPartition,
-        MDD_ClosedCompleteBodyPartition,
-        MDD_Footer,
-        MDD_CompleteFooter,
-        MDD_Primer,
-        MDD_Primer_LocalTagEntryBatch,
-        MDD_LocalTagEntryBatch_Primer_LocalTag,
-        MDD_LocalTagEntryBatch_Primer_UID,
-        MDD_InterchangeObject_InstanceUID,
-        MDD_GenerationInterchangeObject_GenerationUID,
-        MDD_DefaultObject,
-        MDD_IndexTableSegmentBase_IndexEditRate,
-        MDD_IndexTableSegmentBase_IndexStartPosition,
-        MDD_IndexTableSegmentBase_IndexDuration,
-        MDD_IndexTableSegmentBase_EditUnitByteCount,
-        MDD_IndexTableSegmentBase_IndexSID,
-        MDD_IndexTableSegmentBase_BodySID,
-        MDD_IndexTableSegmentBase_SliceCount,
-        MDD_IndexTableSegmentBase_PosTableCount,
-        MDD_V10IndexTableSegment,
-        MDD_V10IndexTableSegment_V10DeltaEntryArray,
-        MDD_V10DeltaEntryArray_V10IndexTableSegment_Reorder,
-        MDD_V10DeltaEntryArray_V10IndexTableSegment_Slice,
-        MDD_V10DeltaEntryArray_V10IndexTableSegment_ElementDelta,
-        MDD_V10IndexTableSegment_V10IndexEntryArray,
-        MDD_V10IndexEntryArray_V10IndexTableSegment_TemporalOffset,
-        MDD_V10IndexEntryArray_V10IndexTableSegment_AnchorOffset,
-        MDD_V10IndexEntryArray_V10IndexTableSegment_Flags,
-        MDD_V10IndexEntryArray_V10IndexTableSegment_StreamOffset,
-        MDD_V10IndexEntryArray_V10IndexTableSegment_SliceOffsetArray,
-        MDD_IndexTableSegment,
-        MDD_IndexTableSegment_DeltaEntryArray,
-        MDD_DeltaEntryArray_IndexTableSegment_PosTableIndex,
-        MDD_DeltaEntryArray_IndexTableSegment_Slice,
-        MDD_DeltaEntryArray_IndexTableSegment_ElementDelta,
-        MDD_IndexTableSegment_IndexEntryArray,
-        MDD_IndexEntryArray_IndexTableSegment_TemporalOffset,
-        MDD_IndexEntryArray_IndexTableSegment_AnchorOffset,
-        MDD_IndexEntryArray_IndexTableSegment_Flags,
-        MDD_IndexEntryArray_IndexTableSegment_StreamOffset,
-        MDD_IndexEntryArray_IndexTableSegment_SliceOffsetArray,
-        MDD_IndexEntryArray_IndexTableSegment_PosTableArray,
-        MDD_RandomIndexMetadata,
-        MDD_PartitionArray_RandomIndexMetadata_BodySID,
-        MDD_PartitionArray_RandomIndexMetadata_ByteOffset,
-        MDD_RandomIndexMetadata_Length,
-        MDD_RandomIndexMetadataV10,
-        MDD_Preface,
-        MDD_Preface_LastModifiedDate,
-        MDD_Preface_Version,
-        MDD_Preface_ObjectModelVersion,
-        MDD_Preface_PrimaryPackage,
-        MDD_Preface_Identifications,
-        MDD_Preface_ContentStorage,
-        MDD_Preface_OperationalPattern,
-        MDD_Preface_EssenceContainers,
-        MDD_Preface_DMSchemes,
-        MDD_Identification,
-        MDD_Identification_ThisGenerationUID,
-        MDD_Identification_CompanyName,
-        MDD_Identification_ProductName,
-        MDD_Identification_ProductVersion,
-        MDD_Identification_VersionString,
-        MDD_Identification_ProductUID,
-        MDD_Identification_ModificationDate,
-        MDD_Identification_ToolkitVersion,
-        MDD_Identification_Platform,
-        MDD_ContentStorage,
-        MDD_ContentStorage_Packages,
-        MDD_ContentStorage_EssenceContainerData,
-        MDD_ContentStorageKludge_V10Packages,
-        MDD_EssenceContainerData,
-        MDD_EssenceContainerData_LinkedPackageUID,
-        MDD_EssenceContainerData_IndexSID,
-        MDD_EssenceContainerData_BodySID,
-        MDD_GenericPackage_PackageUID,
-        MDD_GenericPackage_Name,
-        MDD_GenericPackage_PackageCreationDate,
-        MDD_GenericPackage_PackageModifiedDate,
-        MDD_GenericPackage_Tracks,
-        MDD_NetworkLocator,
-        MDD_NetworkLocator_URLString,
-        MDD_TextLocator,
-        MDD_TextLocator_LocatorName,
-        MDD_GenericTrack_TrackID,
-        MDD_GenericTrack_TrackNumber,
-        MDD_GenericTrack_TrackName,
-        MDD_GenericTrack_Sequence,
-        MDD_StaticTrack,
-        MDD_Track,
-        MDD_Track_EditRate,
-        MDD_Track_Origin,
-        MDD_EventTrack,
-        MDD_EventTrack_EventEditRate,
-        MDD_EventTrack_EventOrigin,
-        MDD_StructuralComponent_DataDefinition,
-        MDD_StructuralComponent_Duration,
-        MDD_Sequence,
-        MDD_Sequence_StructuralComponents,
-        MDD_TimecodeComponent,
-        MDD_TimecodeComponent_RoundedTimecodeBase,
-        MDD_TimecodeComponent_StartTimecode,
-        MDD_TimecodeComponent_DropFrame,
-        MDD_SourceClip,
-        MDD_SourceClip_StartPosition,
-        MDD_SourceClip_SourcePackageID,
-        MDD_SourceClip_SourceTrackID,
-        MDD_DMSegment,
-        MDD_DMSegment_EventStartPosition,
-        MDD_DMSegment_EventComment,
-        MDD_DMSegment_TrackIDs,
-        MDD_DMSegment_DMFramework,
-        MDD_DMSourceClip,
-        MDD_DMSourceClip_DMSourceClipTrackIDs,
-        MDD_MaterialPackage,
-        MDD_SourcePackage,
-        MDD_SourcePackage_Descriptor,
-        MDD_GenericDescriptor_Locators,
-        MDD_GenericDescriptor_SubDescriptors,
-        MDD_FileDescriptor,
-        MDD_FileDescriptor_LinkedTrackID,
-        MDD_FileDescriptor_SampleRate,
-        MDD_FileDescriptor_ContainerDuration,
-        MDD_FileDescriptor_EssenceContainer,
-        MDD_FileDescriptor_Codec,
-        MDD_GenericPictureEssenceDescriptor,
-        MDD_GenericPictureEssenceDescriptor_SignalStandard,
-        MDD_GenericPictureEssenceDescriptor_FrameLayout,
-        MDD_GenericPictureEssenceDescriptor_StoredWidth,
-        MDD_GenericPictureEssenceDescriptor_StoredHeight,
-        MDD_GenericPictureEssenceDescriptor_StoredF2Offset,
-        MDD_GenericPictureEssenceDescriptor_SampledWidth,
-        MDD_GenericPictureEssenceDescriptor_SampledHeight,
-        MDD_GenericPictureEssenceDescriptor_SampledXOffset,
-        MDD_GenericPictureEssenceDescriptor_SampledYOffset,
-        MDD_GenericPictureEssenceDescriptor_DisplayHeight,
-        MDD_GenericPictureEssenceDescriptor_DisplayWidth,
-        MDD_GenericPictureEssenceDescriptor_DisplayXOffset,
-        MDD_GenericPictureEssenceDescriptor_DisplayYOffset,
-        MDD_GenericPictureEssenceDescriptor_DisplayF2Offset,
-        MDD_GenericPictureEssenceDescriptor_AspectRatio,
-        MDD_GenericPictureEssenceDescriptor_ActiveFormatDescriptor,
-        MDD_GenericPictureEssenceDescriptor_VideoLineMap,
-        MDD_GenericPictureEssenceDescriptor_AlphaTransparency,
-        MDD_GenericPictureEssenceDescriptor_Gamma,
-        MDD_GenericPictureEssenceDescriptor_ImageAlignmentOffset,
-        MDD_GenericPictureEssenceDescriptor_ImageStartOffset,
-        MDD_GenericPictureEssenceDescriptor_ImageEndOffset,
-        MDD_GenericPictureEssenceDescriptor_FieldDominance,
-        MDD_GenericPictureEssenceDescriptor_PictureEssenceCoding,
-        MDD_CDCIEssenceDescriptor,
-        MDD_CDCIEssenceDescriptor_ComponentDepth,
-        MDD_CDCIEssenceDescriptor_HorizontalSubsampling,
-        MDD_CDCIEssenceDescriptor_VerticalSubsampling,
-        MDD_CDCIEssenceDescriptor_ColorSiting,
-        MDD_CDCIEssenceDescriptor_ReversedByteOrder,
-        MDD_CDCIEssenceDescriptor_PaddingBits,
-        MDD_CDCIEssenceDescriptor_AlphaSampleDepth,
-        MDD_CDCIEssenceDescriptor_BlackRefLevel,
-        MDD_CDCIEssenceDescriptor_WhiteReflevel,
-        MDD_CDCIEssenceDescriptor_ColorRange,
-        MDD_RGBAEssenceDescriptor,
-        MDD_RGBAEssenceDescriptor_ComponentMaxRef,
-        MDD_RGBAEssenceDescriptor_ComponentMinRef,
-        MDD_RGBAEssenceDescriptor_AlphaMaxRef,
-        MDD_RGBAEssenceDescriptor_AlphaMinRef,
-        MDD_RGBAEssenceDescriptor_ScanningDirection,
-        MDD_RGBAEssenceDescriptor_PixelLayout,
-        MDD_RGBAEssenceDescriptor_Palette,
-        MDD_RGBAEssenceDescriptor_PaletteLayout,
-        MDD_GenericSoundEssenceDescriptor,
-        MDD_GenericSoundEssenceDescriptor_AudioSamplingRate,
-        MDD_GenericSoundEssenceDescriptor_Locked,
-        MDD_GenericSoundEssenceDescriptor_AudioRefLevel,
-        MDD_GenericSoundEssenceDescriptor_ElectroSpatialFormulation,
-        MDD_GenericSoundEssenceDescriptor_ChannelCount,
-        MDD_GenericSoundEssenceDescriptor_QuantizationBits,
-        MDD_GenericSoundEssenceDescriptor_DialNorm,
-        MDD_GenericSoundEssenceDescriptor_SoundEssenceCompression,
-        MDD_GenericDataEssenceDescriptor,
-        MDD_GenericDataEssenceDescriptor_DataEssenceCoding,
-        MDD_MultipleDescriptor,
-        MDD_MultipleDescriptor_SubDescriptorUIDs,
-        MDD_MPEG2VideoDescriptor,
-        MDD_MPEG2VideoDescriptor_SingleSequence,
-        MDD_MPEG2VideoDescriptor_ConstantBFrames,
-        MDD_MPEG2VideoDescriptor_CodedContentType,
-        MDD_MPEG2VideoDescriptor_LowDelay,
-        MDD_MPEG2VideoDescriptor_ClosedGOP,
-        MDD_MPEG2VideoDescriptor_IdenticalGOP,
-        MDD_MPEG2VideoDescriptor_MaxGOP,
-        MDD_MPEG2VideoDescriptor_BPictureCount,
-        MDD_MPEG2VideoDescriptor_BitRate,
-        MDD_MPEG2VideoDescriptor_ProfileAndLevel,
-        MDD_WaveAudioDescriptor,
-        MDD_WaveAudioDescriptor_BlockAlign,
-        MDD_WaveAudioDescriptor_SequenceOffset,
-        MDD_WaveAudioDescriptor_AvgBps,
-        MDD_WaveAudioDescriptor_PeakEnvelope,
-        MDD_JPEG2000PictureSubDescriptor,
-        MDD_JPEG2000PictureSubDescriptor_Rsize,
-        MDD_JPEG2000PictureSubDescriptor_Xsize,
-        MDD_JPEG2000PictureSubDescriptor_Ysize,
-        MDD_JPEG2000PictureSubDescriptor_XOsize,
-        MDD_JPEG2000PictureSubDescriptor_YOsize,
-        MDD_JPEG2000PictureSubDescriptor_XTsize,
-        MDD_JPEG2000PictureSubDescriptor_YTsize,
-        MDD_JPEG2000PictureSubDescriptor_XTOsize,
-        MDD_JPEG2000PictureSubDescriptor_YTOsize,
-        MDD_JPEG2000PictureSubDescriptor_Csize,
-        MDD_JPEG2000PictureSubDescriptor_PictureComponentSizing,
-        MDD_JPEG2000PictureSubDescriptor_CodingStyleDefault,
-        MDD_JPEG2000PictureSubDescriptor_QuantizationDefault,
-        MDD_DM_Framework,
-        MDD_DM_Set,
-        MDD_EncryptedContainerLabel,
-        MDD_CryptographicFrameworkLabel,
-        MDD_CryptographicFramework,
-        MDD_CryptographicFramework_ContextSR,
-        MDD_CryptographicContext,
-        MDD_CryptographicContext_ContextID,
-        MDD_CryptographicContext_SourceEssenceContainer,
-        MDD_CryptographicContext_CipherAlgorithm,
-        MDD_CryptographicContext_MICAlgorithm,
-        MDD_CryptographicContext_CryptographicKeyID,
-        MDD_EncryptedTriplet,
-        MDD_EncryptedTriplet_ContextIDLink,
-        MDD_EncryptedTriplet_PlaintextOffset,
-        MDD_EncryptedTriplet_SourceKey,
-        MDD_EncryptedTriplet_SourceLength,
-        MDD_EncryptedTriplet_EncryptedSourceValue,
-        MDD_EncryptedTriplet_TrackFileID,
-        MDD_EncryptedTriplet_SequenceNumber,
-        MDD_EncryptedTriplet_MIC,
-        MDD_CipherAlgorithmAES128CBC,
-        MDD_HMACAlgorithmSHA1128,
+        MDD_MICAlgorithm_NONE,  // 0
+        MDD_OPAtom,  // 1
+        MDD_OP1a,  // 2
+        MDD_GCMulti,  // 3
+        MDD_PictureDataDef,  // 4
+        MDD_SoundDataDef,  // 5
+        MDD_TimecodeDataDef,  // 6
+        MDD_DescriptiveMetaDataDef,  // 7
+        MDD_WAVWrapping,  // 8
+        MDD_MPEG2_VESWrapping,  // 9
+        MDD_JPEG_2000Wrapping,  // 10
+        MDD_JPEG2000Essence,  // 11
+        MDD_MPEG2Essence,  // 12
+        MDD_CryptEssence,  // 13
+        MDD_WAVEssence,  // 14
+        MDD_JP2KEssenceCompression,  // 15
+        MDD_CipherAlgorithm_AES,  // 16
+        MDD_MICAlgorithm_HMAC_SHA1,  // 17
+        MDD_KLVFill,  // 18
+        MDD_PartitionMetadata_MajorVersion,  // 19
+        MDD_PartitionMetadata_MinorVersion,  // 20
+        MDD_PartitionMetadata_KAGSize,  // 21
+        MDD_PartitionMetadata_ThisPartition,  // 22
+        MDD_PartitionMetadata_PreviousPartition,  // 23
+        MDD_PartitionMetadata_FooterPartition,  // 24
+        MDD_PartitionMetadata_HeaderByteCount,  // 25
+        MDD_PartitionMetadata_IndexByteCount,  // 26
+        MDD_PartitionMetadata_IndexSID,  // 27
+        MDD_PartitionMetadata_BodyOffset,  // 28
+        MDD_PartitionMetadata_BodySID,  // 29
+        MDD_PartitionMetadata_OperationalPattern,  // 30
+        MDD_PartitionMetadata_EssenceContainers,  // 31
+        MDD_OpenHeader,  // 32
+        MDD_OpenCompleteHeader,  // 33
+        MDD_ClosedHeader,  // 34
+        MDD_ClosedCompleteHeader,  // 35
+        MDD_OpenBodyPartition,  // 36
+        MDD_OpenCompleteBodyPartition,  // 37
+        MDD_ClosedBodyPartition,  // 38
+        MDD_ClosedCompleteBodyPartition,  // 39
+        MDD_Footer,  // 40
+        MDD_CompleteFooter,  // 41
+        MDD_Primer,  // 42
+        MDD_Primer_LocalTagEntryBatch,  // 43
+        MDD_LocalTagEntryBatch_Primer_LocalTag,  // 44
+        MDD_LocalTagEntryBatch_Primer_UID,  // 45
+        MDD_InterchangeObject_InstanceUID,  // 46
+        MDD_GenerationInterchangeObject_GenerationUID,  // 47
+        MDD_DefaultObject,  // 48
+        MDD_IndexTableSegmentBase_IndexEditRate,  // 49
+        MDD_IndexTableSegmentBase_IndexStartPosition,  // 50
+        MDD_IndexTableSegmentBase_IndexDuration,  // 51
+        MDD_IndexTableSegmentBase_EditUnitByteCount,  // 52
+        MDD_IndexTableSegmentBase_IndexSID,  // 53
+        MDD_IndexTableSegmentBase_BodySID,  // 54
+        MDD_IndexTableSegmentBase_SliceCount,  // 55
+        MDD_IndexTableSegmentBase_PosTableCount,  // 56
+        MDD_IndexTableSegment,  // 57
+        MDD_IndexTableSegment_DeltaEntryArray,  // 58
+        MDD_DeltaEntryArray_IndexTableSegment_PosTableIndex,  // 59
+        MDD_DeltaEntryArray_IndexTableSegment_Slice,  // 60
+        MDD_DeltaEntryArray_IndexTableSegment_ElementDelta,  // 61
+        MDD_IndexTableSegment_IndexEntryArray,  // 62
+        MDD_IndexEntryArray_IndexTableSegment_TemporalOffset,  // 63
+        MDD_IndexEntryArray_IndexTableSegment_AnchorOffset,  // 64
+        MDD_IndexEntryArray_IndexTableSegment_Flags,  // 65
+        MDD_IndexEntryArray_IndexTableSegment_StreamOffset,  // 66
+        MDD_IndexEntryArray_IndexTableSegment_SliceOffsetArray,  // 67
+        MDD_IndexEntryArray_IndexTableSegment_PosTableArray,  // 68
+        MDD_RandomIndexMetadata,  // 69
+        MDD_PartitionArray_RandomIndexMetadata_BodySID,  // 70
+        MDD_PartitionArray_RandomIndexMetadata_ByteOffset,  // 71
+        MDD_RandomIndexMetadata_Length,  // 72
+        MDD_RandomIndexMetadataV10,  // 73
+        MDD_Preface,  // 74
+        MDD_Preface_LastModifiedDate,  // 75
+        MDD_Preface_Version,  // 76
+        MDD_Preface_ObjectModelVersion,  // 77
+        MDD_Preface_PrimaryPackage,  // 78
+        MDD_Preface_Identifications,  // 79
+        MDD_Preface_ContentStorage,  // 80
+        MDD_Preface_OperationalPattern,  // 81
+        MDD_Preface_EssenceContainers,  // 82
+        MDD_Preface_DMSchemes,  // 83
+        MDD_Identification,  // 84
+        MDD_Identification_ThisGenerationUID,  // 85
+        MDD_Identification_CompanyName,  // 86
+        MDD_Identification_ProductName,  // 87
+        MDD_Identification_ProductVersion,  // 88
+        MDD_Identification_VersionString,  // 89
+        MDD_Identification_ProductUID,  // 90
+        MDD_Identification_ModificationDate,  // 91
+        MDD_Identification_ToolkitVersion,  // 92
+        MDD_Identification_Platform,  // 93
+        MDD_ContentStorage,  // 94
+        MDD_ContentStorage_Packages,  // 95
+        MDD_ContentStorage_EssenceContainerData,  // 96
+        MDD_ContentStorageKludge_V10Packages,  // 97
+        MDD_EssenceContainerData,  // 98
+        MDD_EssenceContainerData_LinkedPackageUID,  // 99
+        MDD_EssenceContainerData_IndexSID,  // 100
+        MDD_EssenceContainerData_BodySID,  // 101
+        MDD_GenericPackage_PackageUID,  // 102
+        MDD_GenericPackage_Name,  // 103
+        MDD_GenericPackage_PackageCreationDate,  // 104
+        MDD_GenericPackage_PackageModifiedDate,  // 105
+        MDD_GenericPackage_Tracks,  // 106
+        MDD_NetworkLocator,  // 107
+        MDD_NetworkLocator_URLString,  // 108
+        MDD_TextLocator,  // 109
+        MDD_TextLocator_LocatorName,  // 110
+        MDD_GenericTrack_TrackID,  // 111
+        MDD_GenericTrack_TrackNumber,  // 112
+        MDD_GenericTrack_TrackName,  // 113
+        MDD_GenericTrack_Sequence,  // 114
+        MDD_StaticTrack,  // 115
+        MDD_Track,  // 116
+        MDD_Track_EditRate,  // 117
+        MDD_Track_Origin,  // 118
+        MDD_EventTrack,  // 119
+        MDD_EventTrack_EventEditRate,  // 120
+        MDD_EventTrack_EventOrigin,  // 121
+        MDD_StructuralComponent_DataDefinition,  // 122
+        MDD_StructuralComponent_Duration,  // 123
+        MDD_Sequence,  // 124
+        MDD_Sequence_StructuralComponents,  // 125
+        MDD_TimecodeComponent,  // 126
+        MDD_TimecodeComponent_RoundedTimecodeBase,  // 127
+        MDD_TimecodeComponent_StartTimecode,  // 128
+        MDD_TimecodeComponent_DropFrame,  // 129
+        MDD_SourceClip,  // 130
+        MDD_SourceClip_StartPosition,  // 131
+        MDD_SourceClip_SourcePackageID,  // 132
+        MDD_SourceClip_SourceTrackID,  // 133
+        MDD_DMSegment,  // 134
+        MDD_DMSegment_EventStartPosition,  // 135
+        MDD_DMSegment_EventComment,  // 136
+        MDD_DMSegment_TrackIDs,  // 137
+        MDD_DMSegment_DMFramework,  // 138
+        MDD_DMSourceClip,  // 139
+        MDD_DMSourceClip_DMSourceClipTrackIDs,  // 140
+        MDD_MaterialPackage,  // 141
+        MDD_SourcePackage,  // 142
+        MDD_SourcePackage_Descriptor,  // 143
+        MDD_GenericDescriptor_Locators,  // 144
+        MDD_GenericDescriptor_SubDescriptors,  // 145
+        MDD_FileDescriptor,  // 146
+        MDD_FileDescriptor_LinkedTrackID,  // 147
+        MDD_FileDescriptor_SampleRate,  // 148
+        MDD_FileDescriptor_ContainerDuration,  // 149
+        MDD_FileDescriptor_EssenceContainer,  // 150
+        MDD_FileDescriptor_Codec,  // 151
+        MDD_GenericPictureEssenceDescriptor,  // 152
+        MDD_GenericPictureEssenceDescriptor_SignalStandard,  // 153
+        MDD_GenericPictureEssenceDescriptor_FrameLayout,  // 154
+        MDD_GenericPictureEssenceDescriptor_StoredWidth,  // 155
+        MDD_GenericPictureEssenceDescriptor_StoredHeight,  // 156
+        MDD_GenericPictureEssenceDescriptor_StoredF2Offset,  // 157
+        MDD_GenericPictureEssenceDescriptor_SampledWidth,  // 158
+        MDD_GenericPictureEssenceDescriptor_SampledHeight,  // 159
+        MDD_GenericPictureEssenceDescriptor_SampledXOffset,  // 160
+        MDD_GenericPictureEssenceDescriptor_SampledYOffset,  // 161
+        MDD_GenericPictureEssenceDescriptor_DisplayHeight,  // 162
+        MDD_GenericPictureEssenceDescriptor_DisplayWidth,  // 163
+        MDD_GenericPictureEssenceDescriptor_DisplayXOffset,  // 164
+        MDD_GenericPictureEssenceDescriptor_DisplayYOffset,  // 165
+        MDD_GenericPictureEssenceDescriptor_DisplayF2Offset,  // 166
+        MDD_GenericPictureEssenceDescriptor_AspectRatio,  // 167
+        MDD_GenericPictureEssenceDescriptor_ActiveFormatDescriptor,  // 168
+        MDD_GenericPictureEssenceDescriptor_VideoLineMap,  // 169
+        MDD_GenericPictureEssenceDescriptor_AlphaTransparency,  // 170
+        MDD_GenericPictureEssenceDescriptor_Gamma,  // 171
+        MDD_GenericPictureEssenceDescriptor_ImageAlignmentOffset,  // 172
+        MDD_GenericPictureEssenceDescriptor_ImageStartOffset,  // 173
+        MDD_GenericPictureEssenceDescriptor_ImageEndOffset,  // 174
+        MDD_GenericPictureEssenceDescriptor_FieldDominance,  // 175
+        MDD_GenericPictureEssenceDescriptor_PictureEssenceCoding,  // 176
+        MDD_CDCIEssenceDescriptor,  // 177
+        MDD_CDCIEssenceDescriptor_ComponentDepth,  // 178
+        MDD_CDCIEssenceDescriptor_HorizontalSubsampling,  // 179
+        MDD_CDCIEssenceDescriptor_VerticalSubsampling,  // 180
+        MDD_CDCIEssenceDescriptor_ColorSiting,  // 181
+        MDD_CDCIEssenceDescriptor_ReversedByteOrder,  // 182
+        MDD_CDCIEssenceDescriptor_PaddingBits,  // 183
+        MDD_CDCIEssenceDescriptor_AlphaSampleDepth,  // 184
+        MDD_CDCIEssenceDescriptor_BlackRefLevel,  // 185
+        MDD_CDCIEssenceDescriptor_WhiteReflevel,  // 186
+        MDD_CDCIEssenceDescriptor_ColorRange,  // 187
+        MDD_RGBAEssenceDescriptor,  // 188
+        MDD_RGBAEssenceDescriptor_ComponentMaxRef,  // 189
+        MDD_RGBAEssenceDescriptor_ComponentMinRef,  // 190
+        MDD_RGBAEssenceDescriptor_AlphaMaxRef,  // 191
+        MDD_RGBAEssenceDescriptor_AlphaMinRef,  // 192
+        MDD_RGBAEssenceDescriptor_ScanningDirection,  // 193
+        MDD_RGBAEssenceDescriptor_PixelLayout,  // 194
+        MDD_RGBAEssenceDescriptor_Palette,  // 195
+        MDD_RGBAEssenceDescriptor_PaletteLayout,  // 196
+        MDD_GenericSoundEssenceDescriptor,  // 197
+        MDD_GenericSoundEssenceDescriptor_AudioSamplingRate,  // 198
+        MDD_GenericSoundEssenceDescriptor_Locked,  // 199
+        MDD_GenericSoundEssenceDescriptor_AudioRefLevel,  // 200
+        MDD_GenericSoundEssenceDescriptor_ElectroSpatialFormulation,  // 201
+        MDD_GenericSoundEssenceDescriptor_ChannelCount,  // 202
+        MDD_GenericSoundEssenceDescriptor_QuantizationBits,  // 203
+        MDD_GenericSoundEssenceDescriptor_DialNorm,  // 204
+        MDD_GenericSoundEssenceDescriptor_SoundEssenceCompression,  // 205
+        MDD_GenericDataEssenceDescriptor,  // 206
+        MDD_GenericDataEssenceDescriptor_DataEssenceCoding,  // 207
+        MDD_MultipleDescriptor,  // 208
+        MDD_MultipleDescriptor_SubDescriptorUIDs,  // 209
+        MDD_MPEG2VideoDescriptor,  // 210
+        MDD_MPEG2VideoDescriptor_SingleSequence,  // 211
+        MDD_MPEG2VideoDescriptor_ConstantBFrames,  // 212
+        MDD_MPEG2VideoDescriptor_CodedContentType,  // 213
+        MDD_MPEG2VideoDescriptor_LowDelay,  // 214
+        MDD_MPEG2VideoDescriptor_ClosedGOP,  // 215
+        MDD_MPEG2VideoDescriptor_IdenticalGOP,  // 216
+        MDD_MPEG2VideoDescriptor_MaxGOP,  // 217
+        MDD_MPEG2VideoDescriptor_BPictureCount,  // 218
+        MDD_MPEG2VideoDescriptor_BitRate,  // 219
+        MDD_MPEG2VideoDescriptor_ProfileAndLevel,  // 220
+        MDD_WaveAudioDescriptor,  // 221
+        MDD_WaveAudioDescriptor_BlockAlign,  // 222
+        MDD_WaveAudioDescriptor_SequenceOffset,  // 223
+        MDD_WaveAudioDescriptor_AvgBps,  // 224
+        MDD_WaveAudioDescriptor_PeakEnvelope,  // 225
+        MDD_JPEG2000PictureSubDescriptor,  // 226
+        MDD_JPEG2000PictureSubDescriptor_Rsize,  // 227
+        MDD_JPEG2000PictureSubDescriptor_Xsize,  // 228
+        MDD_JPEG2000PictureSubDescriptor_Ysize,  // 229
+        MDD_JPEG2000PictureSubDescriptor_XOsize,  // 230
+        MDD_JPEG2000PictureSubDescriptor_YOsize,  // 231
+        MDD_JPEG2000PictureSubDescriptor_XTsize,  // 232
+        MDD_JPEG2000PictureSubDescriptor_YTsize,  // 233
+        MDD_JPEG2000PictureSubDescriptor_XTOsize,  // 234
+        MDD_JPEG2000PictureSubDescriptor_YTOsize,  // 235
+        MDD_JPEG2000PictureSubDescriptor_Csize,  // 236
+        MDD_JPEG2000PictureSubDescriptor_PictureComponentSizing,  // 237
+        MDD_JPEG2000PictureSubDescriptor_CodingStyleDefault,  // 238
+        MDD_JPEG2000PictureSubDescriptor_QuantizationDefault,  // 239
+        MDD_DM_Framework,  // 240
+        MDD_DM_Set,  // 241
+        MDD_EncryptedContainerLabel,  // 242
+        MDD_CryptographicFrameworkLabel,  // 243
+        MDD_CryptographicFramework,  // 244
+        MDD_CryptographicFramework_ContextSR,  // 245
+        MDD_CryptographicContext,  // 246
+        MDD_CryptographicContext_ContextID,  // 247
+        MDD_CryptographicContext_SourceEssenceContainer,  // 248
+        MDD_CryptographicContext_CipherAlgorithm,  // 249
+        MDD_CryptographicContext_MICAlgorithm,  // 250
+        MDD_CryptographicContext_CryptographicKeyID,  // 251
+        MDD_EncryptedTriplet,  // 252
+        MDD_EncryptedTriplet_ContextIDLink,  // 253
+        MDD_EncryptedTriplet_PlaintextOffset,  // 254
+        MDD_EncryptedTriplet_SourceKey,  // 255
+        MDD_EncryptedTriplet_SourceLength,  // 256
+        MDD_EncryptedTriplet_EncryptedSourceValue,  // 257
+        MDD_EncryptedTriplet_TrackFileID,  // 258
+        MDD_EncryptedTriplet_SequenceNumber,  // 259
+        MDD_EncryptedTriplet_MIC,  // 260
+        MDD_CipherAlgorithmAES128CBC,  // 261
+        MDD_HMACAlgorithmSHA1128,  // 262
     }; // enum MDD_t
 } // namespaceASDCP
 
diff --git a/src/MXF.cpp b/src/MXF.cpp
index 2c41afc..d5585d3 100755
--- a/src/MXF.cpp
+++ b/src/MXF.cpp
@@ -32,59 +32,11 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "MXF.h"
 #include "hex_utils.h"
 
+
 //------------------------------------------------------------------------------------------
 //
 
 const ui32_t kl_length = ASDCP::SMPTE_UL_LENGTH + ASDCP::MXF_BER_LENGTH;
-#if 0
-const byte_t mdd_key[] = { 0x06, 0x0e, 0x2b, 0x34 };
-
-//
-const ASDCP::MDDEntry*
-ASDCP::GetMDDEntry(const byte_t* ul_buf)
-{
-  ui32_t t_idx = 0;
-  ui32_t k_idx = 8;
-
-  // must be a pointer to a SMPTE UL
-  if ( ul_buf == 0 || memcmp(mdd_key, ul_buf, 4) != 0 )
-    return 0;
-
-  // advance to first matching element
-  // TODO: optimize using binary search
-  while ( s_MDD_Table[t_idx].ul != 0
-  	  && s_MDD_Table[t_idx].ul[k_idx] != ul_buf[k_idx] )
-    t_idx++;
-
-  if ( s_MDD_Table[t_idx].ul == 0 )
-    return 0;
-
-  // match successive elements
-  while ( s_MDD_Table[t_idx].ul != 0
-	  && k_idx < SMPTE_UL_LENGTH - 1
-	  && s_MDD_Table[t_idx].ul[k_idx] == ul_buf[k_idx] )
-    {
-      if ( s_MDD_Table[t_idx].ul[k_idx+1] == ul_buf[k_idx+1] )
-	{
-	  k_idx++;
-	}
-      else
-	{
-	  while ( s_MDD_Table[t_idx].ul != 0
-		  && s_MDD_Table[t_idx].ul[k_idx] == ul_buf[k_idx]
-		  && s_MDD_Table[t_idx].ul[k_idx+1] != ul_buf[k_idx+1] )
-	    t_idx++;
-	      
-	  while ( s_MDD_Table[t_idx].ul[k_idx] != ul_buf[k_idx] )
-	    k_idx--;
-	}
-    }
-
-  return (s_MDD_Table[t_idx].ul == 0 ? 0 : &s_MDD_Table[t_idx]);
-}
-#endif
-//------------------------------------------------------------------------------------------
-//
 
 //
 ASDCP::Result_t
@@ -328,7 +280,7 @@ ASDCP::MXF::Partition::WriteToFile(ASDCP::FileWriter& Writer, UL& PartitionLabel
 
   if ( ASDCP_SUCCESS(result) )
     {
-      ui32_t write_count; // this is subclassed, so the UL is only right some of the time
+      ui32_t write_count;
       result = WriteKLToFile(Writer, PartitionLabel.Value(), Buffer.Size());
 
       if ( ASDCP_SUCCESS(result) )
@@ -339,6 +291,21 @@ ASDCP::MXF::Partition::WriteToFile(ASDCP::FileWriter& Writer, UL& PartitionLabel
 }
 
 //
+ui32_t
+ASDCP::MXF::Partition::ArchiveSize()
+{
+  return ( kl_length
+	   + sizeof(ui16_t) + sizeof(ui16_t)
+	   + sizeof(ui32_t)
+	   + sizeof(ui64_t) + sizeof(ui64_t) + sizeof(ui64_t) + sizeof(ui64_t) + sizeof(ui64_t)
+	   + sizeof(ui32_t)
+	   + sizeof(ui64_t)
+	   + sizeof(ui32_t)
+	   + SMPTE_UL_LENGTH
+	   + sizeof(ui32_t) + sizeof(ui32_t) + ( UUIDlen * EssenceContainers.size() ) );
+}
+
+//
 void
 ASDCP::MXF::Partition::Dump(FILE* stream)
 {
@@ -524,8 +491,8 @@ ASDCP::MXF::Primer::Dump(FILE* stream)
 
   KLVPacket::Dump(stream, false);
   fprintf(stream, "Primer: %lu %s\n",
-	  LocalTagEntryBatch.ItemCount,
-	  ( LocalTagEntryBatch.ItemCount == 1 ? "entry" : "entries" ));
+	  LocalTagEntryBatch.size(),
+	  ( LocalTagEntryBatch.size() == 1 ? "entry" : "entries" ));
   
   Batch<LocalTagEntry>::iterator i = LocalTagEntryBatch.begin();
   for ( ; i != LocalTagEntryBatch.end(); i++ )
@@ -628,12 +595,25 @@ ASDCP::MXF::OPAtomHeader::InitFromFile(const ASDCP::FileReader& Reader)
   if ( ASDCP_SUCCESS(result) )
     {
       result = m_RIP.InitFromFile(Reader);
+      ui32_t test_s = m_RIP.PairArray.size();
 
       if ( ASDCP_FAILURE(result) )
 	{
 	  DefaultLogSink().Error("File contains no RIP\n");
 	  result = RESULT_OK;
 	}
+      else if ( test_s == 0 )
+	{
+	  DefaultLogSink().Error("RIP contains no Pairs.\n");
+	  result = RESULT_FORMAT;
+	}
+      else if ( test_s < 2 || test_s > 3 )
+	{
+	  // OP-Atom states that there will be either two or three partitions,
+	  // one closed header and one closed footer with an optional body
+	  DefaultLogSink().Error("RIP count is not 2 or 3: %lu\n", test_s);
+	  return RESULT_FORMAT;
+	}
       else
 	{
 	  m_HasRIP = true;
@@ -641,35 +621,55 @@ ASDCP::MXF::OPAtomHeader::InitFromFile(const ASDCP::FileReader& Reader)
     }
 
   if ( ASDCP_SUCCESS(result) )
+    {
+      Array<RIP::Pair>::iterator r_i = m_RIP.PairArray.begin();
+      
+      if ( (*r_i).ByteOffset !=  0 )
+	{
+	  DefaultLogSink().Error("First Partition in RIP is not at offset 0.\n");
+	  result = RESULT_FORMAT;
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) )
     result = Reader.Seek(0);
 
   if ( ASDCP_SUCCESS(result) )
     result = Partition::InitFromFile(Reader); // test UL and OP
 
-  // slurp up the remainder of the header
-  ui32_t read_count;
+  // is it really OP-Atom?
+  UL OPAtomUL(Dict::ul(MDD_OPAtom));
 
-  if ( ASDCP_SUCCESS(result) )
+  if ( ! ( OperationalPattern == OPAtomUL ) )
     {
-      ui32_t here = (ui32_t)Reader.Tell();
+      char strbuf[IntBufferLen];
+      const MDDEntry* Entry = Dict::FindUL(m_KeyStart);
+      if ( Entry == 0 )
+	DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s.\n", OperationalPattern.ToString(strbuf));
+      else
+	DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s.\n", Entry->name);
+    }
 
-      if ( HeaderByteCount < here )
-	{
-	  DefaultLogSink().Error("HeaderByteCount less than Partition size\n");
-	  return RESULT_FAIL;
-	}
+  // slurp up the remainder of the header
+  if ( ASDCP_SUCCESS(result) )
+    {
+      if ( HeaderByteCount < 1024 )
+	DefaultLogSink().Warn("Improbably small HeaderByteCount value: %lu\n", HeaderByteCount);
 
-      result = m_Buffer.Capacity(HeaderByteCount - here);
+      result = m_Buffer.Capacity(HeaderByteCount);
     }
 
   if ( ASDCP_SUCCESS(result) )
-    result = Reader.Read(m_Buffer.Data(), m_Buffer.Capacity(), &read_count);
-
-  if ( ASDCP_SUCCESS(result) && read_count != m_Buffer.Capacity() )
     {
-      DefaultLogSink().Error("Short read of OP-Atom header metadata; wanted %lu, got %lu\n",
-			     m_Buffer.Capacity(), read_count);
-      return RESULT_FAIL;
+      ui32_t read_count;
+      result = Reader.Read(m_Buffer.Data(), m_Buffer.Capacity(), &read_count);
+
+      if ( ASDCP_SUCCESS(result) && read_count != m_Buffer.Capacity() )
+	{
+	  DefaultLogSink().Error("Short read of OP-Atom header metadata; wanted %lu, got %lu\n",
+				 m_Buffer.Capacity(), read_count);
+	  return RESULT_FAIL;
+	}
     }
 
   const byte_t* p = m_Buffer.RoData();
@@ -754,6 +754,7 @@ ASDCP::MXF::OPAtomHeader::GetSourcePackage()
   return 0;
 }
 
+
 //
 ASDCP::Result_t
 ASDCP::MXF::OPAtomHeader::WriteToFile(ASDCP::FileWriter& Writer, ui32_t HeaderSize)
@@ -768,8 +769,8 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(ASDCP::FileWriter& Writer, ui32_t HeaderSi
     }
 
   ASDCP::FrameBuffer HeaderBuffer;
-  HeaderByteCount = HeaderSize;
-  Result_t result = HeaderBuffer.Capacity(HeaderSize); 
+  HeaderByteCount = HeaderSize - ArchiveSize();
+  Result_t result = HeaderBuffer.Capacity(HeaderByteCount); 
   m_Preface->m_Lookup = &m_Primer;
 
   std::list<InterchangeObject*>::iterator pl_i = m_PacketList->m_List.begin();
@@ -806,7 +807,7 @@ ASDCP::MXF::OPAtomHeader::WriteToFile(ASDCP::FileWriter& Writer, ui32_t HeaderSi
     {
       ASDCP::fpos_t pos = Writer.Tell();
 
-      if ( pos > HeaderSize )
+      if ( pos > (ASDCP::fpos_t)HeaderByteCount )
 	{
 	  char intbuf[IntBufferLen];
 	  DefaultLogSink().Error("Header size %s exceeds specified value %lu\n",
@@ -1076,7 +1077,7 @@ ASDCP::MXF::OPAtomIndexFooter::PushIndexEntry(const IndexTableSegment::IndexEntr
 
   // do we have an available segment?
   if ( m_CurrentSegment == 0 )
-    {
+    { // no, set up a new segment
       m_CurrentSegment = new IndexTableSegment;
       assert(m_CurrentSegment);
       AddChildObject(m_CurrentSegment);
@@ -1085,7 +1086,7 @@ ASDCP::MXF::OPAtomIndexFooter::PushIndexEntry(const IndexTableSegment::IndexEntr
       m_CurrentSegment->IndexStartPosition = 0;
     }
   else if ( m_CurrentSegment->IndexEntryArray.size() >= 1486 ) // 1486 gets us 16K packets
-    {
+    { // no, this one is full, start another
       m_CurrentSegment->IndexDuration = m_CurrentSegment->IndexEntryArray.size();
       ui64_t StartPosition = m_CurrentSegment->IndexStartPosition + m_CurrentSegment->IndexDuration;
 
diff --git a/src/MXF.h b/src/MXF.h
index 649d4d9..27f3b3e 100755
--- a/src/MXF.h
+++ b/src/MXF.h
@@ -50,40 +50,43 @@ namespace ASDCP
 
 	public:
 	  //
-	  class Pair {
-	  public:
-	    ui32_t BodySID;
-	    ui64_t ByteOffset;
-
-	    Pair() : BodySID(0), ByteOffset(0) {}
-	    Pair(ui32_t sid, ui64_t offset) : BodySID(sid), ByteOffset(offset) {}
+	  class Pair : public IArchive
+	    {
+	    public:
+	      ui32_t BodySID;
+	      ui64_t ByteOffset;
 
-	    ui32_t Size() { return sizeof(ui32_t) + sizeof(ui64_t); }
+	      Pair() : BodySID(0), ByteOffset(0) {}
+	      Pair(ui32_t sid, ui64_t offset) : BodySID(sid), ByteOffset(offset) {}
 
-	    inline const char* ToString(char* str_buf) const {
-	      char intbuf[IntBufferLen];
-	      snprintf(str_buf, IdentBufferLen, "%-6lu: %s", BodySID, ui64sz(ByteOffset, intbuf));
-	      return str_buf;
-	    }
+	      ui32_t Size() { return sizeof(ui32_t) + sizeof(ui64_t); }
 
-	    inline Result_t Unarchive(ASDCP::MemIOReader& Reader) {
-	      Result_t result = Reader.ReadUi32BE(&BodySID);
+	      inline const char* ToString(char* str_buf) const {
+		char intbuf[IntBufferLen];
+		snprintf(str_buf, IdentBufferLen, "%-6lu: %s", BodySID, ui64sz(ByteOffset, intbuf));
+		return str_buf;
+	      }
 
-	      if ( ASDCP_SUCCESS(result) )
-		result = Reader.ReadUi64BE(&ByteOffset);
+	      inline Result_t Unarchive(ASDCP::MemIOReader& Reader) {
+		Result_t result = Reader.ReadUi32BE(&BodySID);
 
-	      return result;
-	    }
+		if ( ASDCP_SUCCESS(result) )
+		  result = Reader.ReadUi64BE(&ByteOffset);
 
-	    inline Result_t Archive(ASDCP::MemIOWriter& Writer) {
-	      Result_t result = Writer.WriteUi32BE(BodySID);
+		return result;
+	      }
+	      
+	      inline bool HasValue() const { return true; }
+	  
+	      inline Result_t Archive(ASDCP::MemIOWriter& Writer) const {
+		Result_t result = Writer.WriteUi32BE(BodySID);
 
-	      if ( ASDCP_SUCCESS(result) )
-		result = Writer.WriteUi64BE(ByteOffset);
+		if ( ASDCP_SUCCESS(result) )
+		  result = Writer.WriteUi64BE(ByteOffset);
 
-	      return result;
-	    }
-	  };
+		return result;
+	      }
+	    };
 
 	  Array<Pair> PairArray;
 
@@ -124,6 +127,7 @@ namespace ASDCP
 	  virtual void     AddChildObject(InterchangeObject*);
 	  virtual Result_t InitFromFile(const ASDCP::FileReader& Reader);
 	  virtual Result_t WriteToFile(ASDCP::FileWriter& Writer, UL& PartitionLabel);
+	  virtual ui32_t   ArchiveSize(); // returns the size of the archived structure
 	  virtual void     Dump(FILE* = 0);
 	};
 
@@ -157,7 +161,7 @@ namespace ASDCP
 		return result;
 	      }
 
-	      inline Result_t Archive(ASDCP::MemIOWriter& Writer) {
+	      inline Result_t Archive(ASDCP::MemIOWriter& Writer) const {
 		Result_t result = Writer.WriteUi8(Tag.a);
 		if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi8(Tag.b);
 		if ( ASDCP_SUCCESS(result) ) result = UL.Archive(Writer);
@@ -250,7 +254,7 @@ namespace ASDCP
 
 	      DeltaEntry() : PosTableIndex(-1), Slice(0), ElementData(0) {}
 	      Result_t    Unarchive(ASDCP::MemIOReader& Reader);
-	      Result_t    Archive(ASDCP::MemIOWriter& Writer);
+	      Result_t    Archive(ASDCP::MemIOWriter& Writer) const;
 	      const char* ToString(char* str_buf) const;
 	    };
 
@@ -265,8 +269,9 @@ namespace ASDCP
 	      //	      std::list<ui32_t>  SliceOffset;
 	      //	      Array<Rational>    PosTable;
 
+	      IndexEntry() : TemporalOffset(0), KeyFrameOffset(0), Flags(0), StreamOffset() {}
 	      Result_t    Unarchive(ASDCP::MemIOReader& Reader);
-	      Result_t    Archive(ASDCP::MemIOWriter& Writer);
+	      Result_t    Archive(ASDCP::MemIOWriter& Writer) const;
 	      const char* ToString(char* str_buf) const;
 	    };
 
diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp
index 6001cf3..ec4f2d7 100755
--- a/src/MXFTypes.cpp
+++ b/src/MXFTypes.cpp
@@ -35,12 +35,6 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //------------------------------------------------------------------------------------------
 //
 
-const ASDCP::UID&
-ASDCP::UID::operator=(const UMID& rhs)
-{
-  // TODO
-  return *this;
-}
 
 //
 void
@@ -58,21 +52,14 @@ ASDCP::UMID::MakeUMID(int Type, const UUID& AssetID)
   // Set the non-varying base of the UMID
   static const byte_t UMIDBase[10] = { 0x06, 0x0a, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
   memcpy(m_Value, UMIDBase, 10);
+  m_Value[10] = Type;  // Material Type
+  m_Value[12] = 0x13;  // length
 
-  // Correct to v5 dictionary for new (330M-2003) types
-  if( Type > 4 )
-    m_Value[7] = 5;
-
-  // Set the type
-  m_Value[10] = Type;
-
-  // We are using a GUID for material number, and no defined instance method
-  m_Value[11] = 0x20;
-
-  // Length of UMID "Value" is 19 bytes
-  m_Value[12] = 0x13;
+  // preserved for compatibility with mfxlib
+  if( Type > 4 ) m_Value[7] = 5;
+  m_Value[11] = 0x20; // UUID/UL method, number gen undefined
 
-  // Set instance number to zero as this is the first instance of this material
+  // Instance Number
   m_Value[13] = m_Value[14] = m_Value[15] = 0;
   
   memcpy(&m_Value[16], AssetID.Value(), AssetID.Size());
@@ -87,8 +74,10 @@ ASDCP::UMID::ToString(char* str_buf) const
   assert(str_buf);
 
   snprintf(str_buf, IdentBufferLen, "[%02x%02x%02x%02x.%02x%02x.%02x%02x.%02x%02x%02x%02x],%02x,%02x,%02x,%02x,",
-	   m_Value[0],  m_Value[1],  m_Value[2],  m_Value[3],  m_Value[4],  m_Value[5],  m_Value[6],  m_Value[7],
-	   m_Value[8],  m_Value[9],  m_Value[10], m_Value[11], m_Value[12], m_Value[13], m_Value[14], m_Value[15]
+	   m_Value[0],  m_Value[1],  m_Value[2],  m_Value[3],
+	   m_Value[4],  m_Value[5],  m_Value[6],  m_Value[7],
+	   m_Value[8],  m_Value[9],  m_Value[10], m_Value[11],
+	   m_Value[12], m_Value[13], m_Value[14], m_Value[15]
 	   );
 
   ui32_t offset = strlen(str_buf);
@@ -98,8 +87,10 @@ ASDCP::UMID::ToString(char* str_buf) const
       // half-swapped UL, use [bbaa9988.ddcc.ffee.00010203.04050607]
       snprintf(str_buf + offset, IdentBufferLen - offset,
 	       "[%02x%02x%02x%02x.%02x%02x.%02x%02x.%02x%02x%02x%02x.%02x%02x%02x%02x]",
-               m_Value[24], m_Value[25], m_Value[26], m_Value[27], m_Value[28], m_Value[29], m_Value[30], m_Value[31],
-               m_Value[16], m_Value[17], m_Value[18], m_Value[19], m_Value[20], m_Value[21], m_Value[22], m_Value[23]
+               m_Value[24], m_Value[25], m_Value[26], m_Value[27],
+	       m_Value[28], m_Value[29], m_Value[30], m_Value[31],
+               m_Value[16], m_Value[17], m_Value[18], m_Value[19],
+	       m_Value[20], m_Value[21], m_Value[22], m_Value[23]
                );
     }
   else
@@ -107,8 +98,10 @@ ASDCP::UMID::ToString(char* str_buf) const
       // UUID, use {00112233-4455-6677-8899-aabbccddeeff}
       snprintf(str_buf + offset, IdentBufferLen - offset,
 	       "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
-               m_Value[16], m_Value[17], m_Value[18], m_Value[19], m_Value[20], m_Value[21], m_Value[22], m_Value[23],
-               m_Value[24], m_Value[25], m_Value[26], m_Value[27], m_Value[28], m_Value[29], m_Value[30], m_Value[31]
+               m_Value[16], m_Value[17], m_Value[18], m_Value[19],
+	       m_Value[20], m_Value[21], m_Value[22], m_Value[23],
+               m_Value[24], m_Value[25], m_Value[26], m_Value[27],
+	       m_Value[28], m_Value[29], m_Value[30], m_Value[31]
                );
     }
 
@@ -125,6 +118,7 @@ ASDCP::UUID::GenRandomValue()
   m_Value[6] |= 0x40; // set UUID version
   m_Value[8] &= 0x3f; // clear bits 6&7
   m_Value[8] |= 0x80; // set bit 7
+  //  m_HasValue = true;
 }
 
 
@@ -155,9 +149,8 @@ ASDCP::MXF::UTF16String::operator=(const char* sz)
 ASDCP::Result_t
 ASDCP::MXF::UTF16String::Unarchive(ASDCP::MemIOReader& Reader)
 {
-  const byte_t* p = Reader.Data() + Reader.Offset();
-  /// cheating - for all use cases, we know the previous two bytes are the length
-  m_length = ASDCP_i16_BE(cp2i<ui16_t>(p-2));
+  const byte_t* p = Reader.CurrentData();
+  m_length = Reader.Remainder();
   assert(m_length % 2 == 0);
   m_length /= 2;
   assert(IdentBufferLen >= m_length);
@@ -174,17 +167,16 @@ ASDCP::MXF::UTF16String::Unarchive(ASDCP::MemIOReader& Reader)
 
 //
 ASDCP::Result_t
-ASDCP::MXF::UTF16String::Archive(ASDCP::MemIOWriter& Writer)
+ASDCP::MXF::UTF16String::Archive(ASDCP::MemIOWriter& Writer) const
 {
   byte_t* p = Writer.Data() + Writer.Size();
   ui32_t i = 0;
-  m_length = strlen(m_buffer);
-  memset(p, 0, m_length*2);
+  memset(p, 0, (m_length*2)+2);
 
   for ( i = 0; i < m_length; i++ )
     p[(i*2)+1] = m_buffer[i];
 
-  Writer.AddOffset(m_length * 2 );
+  Writer.AddOffset(m_length * 2);
   return RESULT_OK;
 }
 
@@ -505,7 +497,10 @@ ASDCP::MXF::TLVReader::ReadObject(const MDDEntry& Entry, IArchive* Object)
   ASDCP_TEST_NULL(Object);
 
   if ( FindTL(Entry) )
-    return Object->Unarchive(*this);
+    {
+      if ( m_size < m_capacity ) // don't try to unarchive an empty item
+	return Object->Unarchive(*this);
+    }
 
   return RESULT_FALSE;
 }
@@ -596,6 +591,10 @@ ASDCP::Result_t
 ASDCP::MXF::TLVWriter::WriteObject(const MDDEntry& Entry, IArchive* Object)
 {
   ASDCP_TEST_NULL(Object);
+
+  if ( Entry.optional && ! Object->HasValue() )
+    return RESULT_OK;
+
   Result_t result = WriteTag(Entry);
 
   // write a temp length
@@ -660,6 +659,56 @@ ASDCP::MXF::TLVWriter::WriteUi64(const MDDEntry& Entry, ui64_t* value)
   return result;
 }
 
+
+//----------------------------------------------------------------------------------------------------
+//
+
+ASDCP::MXF::Raw::Raw()
+{
+  Capacity(256);
+}
+
+ASDCP::MXF::Raw::~Raw()
+{
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::Raw::Unarchive(ASDCP::MemIOReader& Reader)
+{
+  ui32_t payload_size = Reader.Remainder();
+
+  if ( payload_size == 0 )
+    return RESULT_OK;
+
+  Result_t result = Capacity(payload_size);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      memcpy(Data(), Reader.CurrentData(), payload_size);
+      Size(payload_size);
+    }
+
+  return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::MXF::Raw::Archive(ASDCP::MemIOWriter& Writer) const
+{
+  return Writer.WriteRaw(RoData(), Size());
+}
+
+//
+const char*
+ASDCP::MXF::Raw::ToString(char* str_buf) const
+{
+  *str_buf = 0;
+  bin2hex(RoData(), Size(), str_buf, IdentBufferLen);
+  snprintf(str_buf, IdentBufferLen, "%s\n", str_buf);
+  return str_buf;
+}
+
 //
 // end MXFTypes.cpp
 //
diff --git a/src/MXFTypes.h b/src/MXFTypes.h
index d0638b1..0a6ea72 100755
--- a/src/MXFTypes.h
+++ b/src/MXFTypes.h
@@ -98,14 +98,12 @@ namespace ASDCP
 	class Batch : public std::vector<T>, public IArchive
 	{
 	public:
-	  ui32_t ItemCount;
-	  ui32_t ItemSize;
-
-	  Batch() : ItemCount(0), ItemSize(0) { ItemSize = sizeof(T); }
+	  Batch() {}
 	  ~Batch() {}
 
 	  //
 	  Result_t Unarchive(ASDCP::MemIOReader& Reader) {
+	    ui32_t ItemCount, ItemSize;
 	    Result_t result = Reader.ReadUi32BE(&ItemCount);
 
 	    if ( ASDCP_SUCCESS(result) )
@@ -126,14 +124,28 @@ namespace ASDCP
 	    return result;
 	  }
 
+	  inline bool HasValue() const { return ! empty(); }
+
 	  //
-	  Result_t Archive(ASDCP::MemIOWriter& Writer) {
+	  Result_t Archive(ASDCP::MemIOWriter& Writer) const {
 	    Result_t result = Writer.WriteUi32BE(size());
+	    byte_t* p = Writer.CurrentData();
 
 	    if ( ASDCP_SUCCESS(result) )
-	      result = Writer.WriteUi32BE(ItemSize);
+	      result = Writer.WriteUi32BE(0);
+
+	    if ( ASDCP_FAILURE(result) || empty() )
+	      return result;
+	    
+	    typename std::vector<T>::const_iterator l_i = begin();
+	    assert(l_i != end());
+
+	    ui32_t ItemSize = Writer.Remainder();
+	    result = (*l_i).Archive(Writer);
+	    ItemSize -= Writer.Remainder();
+	    i2p<ui32_t>(ASDCP_i32_BE(ItemSize), p);
+	    l_i++;
 
-	    typename std::vector<T>::iterator l_i = begin();
 	    for ( ; l_i != end() && ASDCP_SUCCESS(result); l_i++ )
 	      result = (*l_i).Archive(Writer);
 
@@ -175,10 +187,12 @@ namespace ASDCP
 	      return RESULT_OK;
 	    }
 
+	  inline bool HasValue() const { return ! empty(); }
+
 	  //
-	  Result_t Archive(ASDCP::MemIOWriter& Writer) {
+	  Result_t Archive(ASDCP::MemIOWriter& Writer) const {
 	    Result_t result = RESULT_OK;
-	    typename std::list<T>::iterator l_i = begin();
+	    typename std::list<T>::const_iterator l_i = begin();
 
 	    for ( ; l_i != end() && ASDCP_SUCCESS(result); l_i++ )
 	      result = (*l_i).Archive(Writer);
@@ -244,8 +258,10 @@ namespace ASDCP
 	    return result;
 	  }
 
+	  inline bool HasValue() const { return true; }
+
 	  //
-	  inline Result_t Archive(ASDCP::MemIOWriter& Writer) {
+	  inline Result_t Archive(ASDCP::MemIOWriter& Writer) const {
 	    Result_t result = Writer.WriteUi16BE(Year);
 
 	    if ( ASDCP_SUCCESS(result) )
@@ -260,6 +276,7 @@ namespace ASDCP
 	{
 	  ui16_t m_length;
 	  char   m_buffer[IdentBufferLen];
+	  ASDCP_NO_COPY_CONSTRUCT(UTF16String);
 	  
 	public:
 	  UTF16String() : m_length(0) { *m_buffer = 0; }
@@ -274,7 +291,8 @@ namespace ASDCP
 	  }
 
 	  Result_t Unarchive(ASDCP::MemIOReader& Reader);
-	  Result_t Archive(ASDCP::MemIOWriter& Writer);
+	  inline bool HasValue() const { return true; }
+	  Result_t Archive(ASDCP::MemIOWriter& Writer) const;
 	};
 
       //
@@ -321,7 +339,9 @@ namespace ASDCP
 	    return result;
 	  }
 
-	  Result_t Archive(ASDCP::MemIOWriter& Writer) {
+	  inline bool HasValue() const { return true; }
+
+	  Result_t Archive(ASDCP::MemIOWriter& Writer) const {
 	    Result_t result = Writer.WriteUi32BE((ui32_t)Numerator);
 
 	    if ( ASDCP_SUCCESS(result) )
@@ -349,7 +369,7 @@ namespace ASDCP
 	  void Dump(FILE* = 0);
 
 	  const char* ToString(char* str_buf) const {
-	    snprintf(str_buf, IdentBufferLen, "%hu.%hu.%hu.%hu.%hu", Major, Minor, Patch, Build, Release);
+	    snprintf(str_buf, IdentBufferLen, "%hu.%hu.%hu.%hur%hu", Major, Minor, Patch, Build, Release);
 	    return str_buf;
 	  }
 
@@ -368,52 +388,32 @@ namespace ASDCP
 	    return result;
 	  }
 
-	  Result_t Archive(ASDCP::MemIOWriter& Writer) {
-	    Result_t result = Writer.WriteUi32BE(Major);
-	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi32BE(Minor);
-	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi32BE(Patch);
-	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi32BE(Build);
-	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi32BE((ui16_t)(Release & 0x0000ffffL));
+	  inline bool HasValue() const { return true; }
+
+	  Result_t Archive(ASDCP::MemIOWriter& Writer) const {
+	    Result_t result = Writer.WriteUi16BE(Major);
+	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi16BE(Minor);
+	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi16BE(Patch);
+	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi16BE(Build);
+	    if ( ASDCP_SUCCESS(result) ) result = Writer.WriteUi16BE((ui16_t)(Release & 0x0000ffffL));
 	    return result;
 	  }
 	};
 
       //
-      class RGBLayout : public IArchive
-        {
-        public:
-          struct element {
-            ui8_t Code;
-            ui8_t Depth;
-          } PictureElement[8];
-          RGBLayout() { memset(PictureElement, 0, sizeof(PictureElement)); }
-
-	  //
-          Result_t Unarchive(ASDCP::MemIOReader& Reader) { return RESULT_OK; }
-	  Result_t Archive(ASDCP::MemIOWriter& Writer) { return RESULT_OK; }
-          inline const char* ToString(char* str_buf) const {
-            snprintf(str_buf, IdentBufferLen, "RGBLayout: <PictureElement[8]>\n");
-            return str_buf;
-          }
-        };
-
-      //
-      class Raw : public IArchive
+      class Raw : public ASDCP::FrameBuffer, public IArchive
 	{
 	  ASDCP_NO_COPY_CONSTRUCT(Raw);
 
 	public:
-	  byte_t* data;
-	  Raw() {}
-	  ~Raw() {}
+	  Raw();
+	  ~Raw();
 
 	  //
-          Result_t Unarchive(ASDCP::MemIOReader& Reader) { return RESULT_OK; }
-	  Result_t Archive(ASDCP::MemIOWriter& Writer) { return RESULT_OK; }
-          inline const char* ToString(char* str_buf) const {
-            snprintf(str_buf, IdentBufferLen, "RAW\n");
-            return str_buf;
-          }
+          Result_t    Unarchive(ASDCP::MemIOReader& Reader);
+	  inline bool HasValue() const { return true; }
+	  Result_t    Archive(ASDCP::MemIOWriter& Writer) const;
+	  const char* ToString(char* str_buf) const;
 	};
 
     } // namespace MXF
diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index 00bf99e..d4cc819 100755
--- a/src/Metadata.cpp
+++ b/src/Metadata.cpp
@@ -1157,7 +1157,6 @@ ASDCP::MXF::RGBAEssenceDescriptor::InitFromTLVSet(TLVReader& TLVSet)
   Result_t result = GenericPictureEssenceDescriptor::InitFromTLVSet(TLVSet);
   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
   if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
-  if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(RGBAEssenceDescriptor, PixelLayout));
   return result;
 }
 
@@ -1168,7 +1167,6 @@ ASDCP::MXF::RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
   Result_t result = GenericPictureEssenceDescriptor::WriteToTLVSet(TLVSet);
   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMaxRef));
   if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, ComponentMinRef));
-  if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(RGBAEssenceDescriptor, PixelLayout));
   return result;
 }
 
@@ -1185,7 +1183,6 @@ ASDCP::MXF::RGBAEssenceDescriptor::Dump(FILE* stream)
   GenericPictureEssenceDescriptor::Dump(stream);
   fprintf(stream, "  %22s = %d\n",  "ComponentMaxRef", ComponentMaxRef);
   fprintf(stream, "  %22s = %d\n",  "ComponentMinRef", ComponentMinRef);
-  fprintf(stream, "  %22s = %s\n",  "PixelLayout", PixelLayout.ToString(identbuf));
 }
 
 //
diff --git a/src/Metadata.h b/src/Metadata.h
index eb89061..f158194 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -401,7 +401,6 @@ namespace ASDCP
 	public:
           ui32_t ComponentMaxRef;
           ui32_t ComponentMinRef;
-          RGBLayout PixelLayout;
 
 	  RGBAEssenceDescriptor() : ComponentMaxRef(0), ComponentMinRef(0) {}
 	  virtual ~RGBAEssenceDescriptor() {}
diff --git a/src/PCM_Parser.cpp b/src/PCM_Parser.cpp
index 70cc277..9262de7 100755
--- a/src/PCM_Parser.cpp
+++ b/src/PCM_Parser.cpp
@@ -94,22 +94,42 @@ ASDCP::Result_t
 ASDCP::PCM::WAVParser::h__WAVParser::OpenRead(const char* filename, const Rational& PictureRate)
 {
   ASDCP_TEST_NULL_STR(filename);
-  SimpleWaveHeader WavHeader;
 
   Result_t result = m_FileReader.OpenRead(filename);
 
   if ( ASDCP_SUCCESS(result) )
-    result = WavHeader.ReadFromFile(m_FileReader, &m_DataStart);
-  
-  if ( ASDCP_SUCCESS(result) )
     {
-      WavHeader.FillADesc(m_ADesc, PictureRate);
-      m_FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(m_ADesc);
-      m_DataLength = WavHeader.data_len;
-      m_ADesc.ContainerDuration = m_DataLength / m_FrameBufferSize;
-      Reset();
+      SimpleWaveHeader WavHeader;
+      result = WavHeader.ReadFromFile(m_FileReader, &m_DataStart);
+  
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  WavHeader.FillADesc(m_ADesc, PictureRate);
+	  m_FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(m_ADesc);
+	  m_DataLength = WavHeader.data_len;
+	  m_ADesc.ContainerDuration = m_DataLength / m_FrameBufferSize;
+	  Reset();
+	}
+      else
+	{
+	  ASDCP::AIFF::SimpleAIFFHeader AIFFHeader;
+	  m_FileReader.Seek(0);
+
+	  result = AIFFHeader.ReadFromFile(m_FileReader, &m_DataStart);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      AIFFHeader.FillADesc(m_ADesc, PictureRate);
+	      m_FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(m_ADesc);
+	      m_DataLength = AIFFHeader.data_len;
+	      m_ADesc.ContainerDuration = m_DataLength / m_FrameBufferSize;
+	      Reset();
+	    }
+	}
     }
 
+  AudioDescriptorDump(m_ADesc);
+
   return result;
 }
 
diff --git a/src/Wav.cpp b/src/Wav.cpp
index 42e0d21..ce64a78 100755
--- a/src/Wav.cpp
+++ b/src/Wav.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005, John Hurst
+Copyright (c) 2005-2006, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -29,11 +29,12 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     \brief   Wave file common elements
 */
 
-#include <Wav.h>
+#include "Wav.h"
+#include "hex_utils.h"
 #include <assert.h>
 
 
-const ui32_t SimpleHeaderLength = 46;
+const ui32_t SimpleWavHeaderLength = 46;
 
 //
 ASDCP::Wav::SimpleWaveHeader::SimpleWaveHeader(ASDCP::PCM::AudioDescriptor& ADesc)
@@ -71,7 +72,7 @@ ASDCP::Result_t
 ASDCP::Wav::SimpleWaveHeader::WriteToFile(ASDCP::FileWriter& OutFile) const
 {
   ui32_t write_count;
-  byte_t tmp_header[SimpleHeaderLength];
+  byte_t tmp_header[SimpleWavHeaderLength];
   byte_t* p = tmp_header;
 
   static ui32_t fmt_len =
@@ -83,7 +84,7 @@ ASDCP::Wav::SimpleWaveHeader::WriteToFile(ASDCP::FileWriter& OutFile) const
     + sizeof(bitspersample)
     + sizeof(cbsize);
 
-  ui32_t RIFF_len = data_len + SimpleHeaderLength - 8;
+  ui32_t RIFF_len = data_len + SimpleWavHeaderLength - 8;
 
   memcpy(p, &FCC_RIFF, sizeof(fourcc)); p += 4;
   *((ui32_t*)p) = ASDCP_i32_LE(RIFF_len); p += 4;
@@ -100,7 +101,7 @@ ASDCP::Wav::SimpleWaveHeader::WriteToFile(ASDCP::FileWriter& OutFile) const
   memcpy(p, &FCC_data, sizeof(fourcc)); p += 4;
   *((ui32_t*)p) = ASDCP_i32_LE(data_len); p += 4;
 
-  return OutFile.Write(tmp_header, SimpleHeaderLength, &write_count);
+  return OutFile.Write(tmp_header, SimpleWavHeaderLength, &write_count);
 }
 
 //
@@ -125,7 +126,7 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromFile(const ASDCP::FileReader& InFile, ui32
 ASDCP::Result_t
 ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len, ui32_t* data_start)
 {
-  if ( buf_len < SimpleHeaderLength )
+  if ( buf_len < SimpleWavHeaderLength )
     return RESULT_SMALLBUF;
 
   *data_start = 0;
@@ -135,7 +136,7 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   fourcc test_RIFF(p); p += 4;
   if ( test_RIFF != FCC_RIFF )
     {
-      DefaultLogSink().Error("Files does not begin with RIFF header\n");      
+      DefaultLogSink().Error("File does not begin with RIFF header\n");      
       return RESULT_RAW_FORMAT;
     }
 
@@ -144,7 +145,7 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   fourcc test_WAVE(p); p += 4;
   if ( test_WAVE != FCC_WAVE )
     {
-      DefaultLogSink().Error("Files does not begin with WAVE header\n");
+      DefaultLogSink().Error("File does not contain a WAVE header\n");
       return RESULT_RAW_FORMAT;
     }
 
@@ -200,6 +201,166 @@ ASDCP::Wav::SimpleWaveHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len,
   return RESULT_OK;
 }
 
+//------------------------------------------------------------------------------------------
+// conversion algorithms from http://www.borg.com/~jglatt/tech/aiff.htm
+
+//
+void
+Rat_to_extended(ASDCP::Rational rate, byte_t* buf)
+{
+  memset(buf, 0, 10);
+  ui32_t value = (ui32_t)ceil(rate.Quotient()); 
+  ui32_t exp = value;
+  exp >>= 1;
+  ui8_t i = 0;
+
+  for ( ; i < 32; i++ )
+    {
+      exp >>= 1;
+      if ( ! exp )
+	break;
+    }
+
+  *(buf+1) = i;
+
+   for ( i = 32; i != 0 ; i-- )
+     {
+       if ( value & 0x80000000 )
+	 break;
+       value <<= 1;
+     }
+
+   *(ui32_t*)(buf+2) = ASDCP_i32_BE(value);
+}
+
+//
+ASDCP::Rational
+extended_to_Rat(const byte_t* buf)
+{
+  ui32_t last = 0;
+  ui32_t mantissa = ASDCP_i32_BE(*(ui32_t*)(buf+2));
+
+  byte_t exp = 30 - *(buf+1);
+
+  while ( exp-- )
+    {
+      last = mantissa;
+      mantissa >>= 1;
+    }
+
+  if ( last & 0x00000001 )
+    mantissa++;
+
+  return ASDCP::Rational(mantissa, 1);
+}
+
+//
+void
+ASDCP::AIFF::SimpleAIFFHeader::FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, ASDCP::Rational PictureRate) const
+{
+  ADesc.SampleRate = PictureRate;
+
+  ADesc.ChannelCount = numChannels;
+  ADesc.AudioSamplingRate = extended_to_Rat(sampleRate);
+  ADesc.QuantizationBits = sampleSize;
+  ADesc.BlockAlign = sampleSize / 8;
+  ADesc.AvgBps = ADesc.BlockAlign * (ui32_t)ceil(ADesc.AudioSamplingRate.Quotient());
+  ui32_t FrameBufferSize = ASDCP::PCM::CalcFrameBufferSize(ADesc);
+  ADesc.ContainerDuration = data_len / FrameBufferSize;
+}
+
+//
+ASDCP::Result_t
+ASDCP::AIFF::SimpleAIFFHeader::ReadFromFile(const ASDCP::FileReader& InFile, ui32_t* data_start)
+{
+  ui32_t read_count = 0;
+  ui32_t local_data_start = 0;
+  ASDCP::PCM::FrameBuffer TmpBuffer(Wav::MaxWavHeader);
+
+  if ( data_start == 0 )
+    data_start = &local_data_start;
+
+  Result_t result = InFile.Read(TmpBuffer.Data(), TmpBuffer.Capacity(), &read_count);
+
+  if ( ASDCP_SUCCESS(result) )
+    result = ReadFromBuffer(TmpBuffer.RoData(), read_count, data_start);
+
+    return result;
+}
+
+//
+ASDCP::Result_t
+ASDCP::AIFF::SimpleAIFFHeader::ReadFromBuffer(const byte_t* buf, ui32_t buf_len, ui32_t* data_start)
+{
+  if ( buf_len < 32 )
+    return RESULT_SMALLBUF;
+
+  *data_start = 0;
+  const byte_t* p = buf;
+  const byte_t* end_p = p + buf_len;
+
+  fourcc test_FORM(p); p += 4;
+  if ( test_FORM != FCC_FORM )
+    {
+      DefaultLogSink().Error("File does not begin with FORM header\n");
+      return RESULT_RAW_FORMAT;
+    }
+
+  ui32_t RIFF_len = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+
+  fourcc test_AIFF(p); p += 4;
+  if ( test_AIFF != FCC_AIFF )
+    {
+      DefaultLogSink().Error("File does not contain an AIFF header\n");
+      return RESULT_RAW_FORMAT;
+    }
+
+  fourcc test_fcc;
+
+  while ( p < end_p )
+    {
+      test_fcc = fourcc(p); p += 4;
+      ui32_t chunk_size = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+
+      if ( test_fcc == FCC_COMM )
+	{
+	  numChannels = ASDCP_i16_BE(*(ui16_t*)p); p += 2;
+	  numSampleFrames = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+	  sampleSize = ASDCP_i16_BE(*(ui16_t*)p); p += 2;
+	  memcpy(sampleRate, p, 10);
+	  p += 10;
+	}
+      else if ( test_fcc == FCC_SSND )
+	{
+	  if ( chunk_size > RIFF_len )
+            {
+              DefaultLogSink().Error("Chunk size %lu larger than file: %lu\n", chunk_size, RIFF_len);
+              return RESULT_RAW_FORMAT;
+            }
+
+	  ui32_t offset = ASDCP_i32_BE(*(ui32_t*)p); p += 4;
+	  p += 4; // blockSize;
+
+	  data_len = chunk_size - 8;
+	  *data_start = (p - buf) + offset;
+	  fprintf(stderr, "*data_start: %p\n", *data_start);
+	  break;
+	}
+      else
+	{
+	  p += chunk_size;
+	}
+    }
+
+  if ( *data_start == 0 ) // can't have no data!
+    {
+      DefaultLogSink().Error("No data chunk found, file contains no essence\n");
+      return RESULT_RAW_FORMAT;
+    }
+
+  return RESULT_OK;
+}
+
 
 
 //
diff --git a/src/Wav.h b/src/Wav.h
index a04c92f..efd99c0 100755
--- a/src/Wav.h
+++ b/src/Wav.h
@@ -36,10 +36,6 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace ASDCP
 {
-namespace Wav
-{
-  const ui32_t MaxWavHeader = 1024*32; // must find "data" within this space or no happy
-
   //
   class fourcc
     {
@@ -55,37 +51,69 @@ namespace Wav
       inline bool operator!=(const fourcc &rhs)  { return memcmp(data, rhs.data, 4) != 0 ? true : false; }
     };
 
-  const fourcc FCC_RIFF("RIFF");
-  const fourcc FCC_WAVE("WAVE");
-  const fourcc FCC_fmt_("fmt ");
-  const fourcc FCC_data("data");
+  namespace AIFF
+    {
+      const fourcc FCC_FORM("FORM");
+      const fourcc FCC_AIFF("AIFF");
+      const fourcc FCC_COMM("COMM");
+      const fourcc FCC_SSND("SSND");
+
+      class SimpleAIFFHeader
+	{
+	public:
+	  ui16_t  numChannels;
+	  ui32_t  numSampleFrames;
+	  ui16_t  sampleSize;
+	  byte_t  sampleRate[10]; // 80-bit IEEE 754 float
+	  ui32_t  data_len;
 
-  //
-  class SimpleWaveHeader
+	  SimpleAIFFHeader() :
+	    numChannels(0), numSampleFrames(0), sampleSize(0), data_len(0) {
+	    memset(sampleRate, 0, 10);
+	  }
+      	  
+	  Result_t  ReadFromBuffer(const byte_t* buf, ui32_t buf_len, ui32_t* data_start);
+	  Result_t  ReadFromFile(const ASDCP::FileReader& InFile, ui32_t* data_start);
+	  void      FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, Rational PictureRate) const;
+	};
+
+    } // namespace AIFF
+
+  namespace Wav
     {
-    public:
-      ui16_t	format;
-      ui16_t	nchannels;
-      ui32_t	samplespersec;
-      ui32_t	avgbps;
-      ui16_t	blockalign;
-      ui16_t	bitspersample;
-      ui16_t	cbsize;
-      ui32_t	data_len;
-
-      SimpleWaveHeader() :
-	format(0), nchannels(0), samplespersec(0), avgbps(0),
-	blockalign(0), bitspersample(0), cbsize(0), data_len(0) {}
-      
-      SimpleWaveHeader(ASDCP::PCM::AudioDescriptor& ADesc);
+      const ui32_t MaxWavHeader = 1024*32; // must find "data" within this space or no happy
 
-      Result_t  ReadFromBuffer(const byte_t* buf, ui32_t buf_len, ui32_t* data_start);
-      Result_t  ReadFromFile(const ASDCP::FileReader& InFile, ui32_t* data_start);
-      Result_t  WriteToFile(ASDCP::FileWriter& OutFile) const;
-      void      FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, Rational PictureRate) const;
-   };
+      const fourcc FCC_RIFF("RIFF");
+      const fourcc FCC_WAVE("WAVE");
+      const fourcc FCC_fmt_("fmt ");
+      const fourcc FCC_data("data");
+
+      //
+      class SimpleWaveHeader
+	{
+	public:
+	  ui16_t	format;
+	  ui16_t	nchannels;
+	  ui32_t	samplespersec;
+	  ui32_t	avgbps;
+	  ui16_t	blockalign;
+	  ui16_t	bitspersample;
+	  ui16_t	cbsize;
+	  ui32_t	data_len;
+
+	  SimpleWaveHeader() :
+	    format(0), nchannels(0), samplespersec(0), avgbps(0),
+	    blockalign(0), bitspersample(0), cbsize(0), data_len(0) {}
+      
+	  SimpleWaveHeader(ASDCP::PCM::AudioDescriptor& ADesc);
+	  
+	  Result_t  ReadFromBuffer(const byte_t* buf, ui32_t buf_len, ui32_t* data_start);
+	  Result_t  ReadFromFile(const ASDCP::FileReader& InFile, ui32_t* data_start);
+	  Result_t  WriteToFile(ASDCP::FileWriter& OutFile) const;
+	  void      FillADesc(ASDCP::PCM::AudioDescriptor& ADesc, Rational PictureRate) const;
+	};
 
-} // namespace Wav
+    } // namespace Wav
 } // namespace ASDCP
 
 #endif // _WAV_H_
diff --git a/src/h__Reader.cpp b/src/h__Reader.cpp
index 95c510c..4e20a98 100755
--- a/src/h__Reader.cpp
+++ b/src/h__Reader.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2005, John Hurst
+Copyright (c) 2004-2006, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -99,23 +99,9 @@ ASDCP::h__Reader::OpenMXFRead(const char* filename)
   if ( ASDCP_SUCCESS(result) )
     result = m_HeaderPart.InitFromFile(m_File);
 
-  // OP-Atom states that there will be either two or three partitions,
-  // one closed header and one closed footer with an optional body
-  ui32_t test_s = m_HeaderPart.m_RIP.PairArray.size();
-
-  if ( test_s < 2 || test_s > 3 )
-    {
-      DefaultLogSink().Error("RIP count is not 2 or 3: %lu\n", test_s);
-      return RESULT_FORMAT;
-    }
-
-  // it really OP-Atom?
-  //  MDObject* OpPattern = GetMDObjectByType("OperationalPattern");
-  // TODO: check the label
-
   // if this is a three partition file, go to the body
   // partition and read off the partition pack
-  if ( test_s == 3 )
+  if ( m_HeaderPart.m_RIP.PairArray.size() == 3 )
     {
       DefaultLogSink().Error("RIP count is 3: must write code...\n");
       return RESULT_FORMAT;
@@ -183,12 +169,11 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
     return result;
 
   UL Key(Reader.Key());
-  UL InteropRef(CryptEssenceUL_Data);
-  UL SMPTERef(CryptEssenceUL_Data);
+  UL CryptEssenceUL(Dict::ul(MDD_CryptEssence));
   ui64_t PacketLength = Reader.Length();
   m_LastPosition = m_LastPosition + Reader.KLLength() + PacketLength;
 
-  if ( Key == InteropRef || Key == SMPTERef )
+  if ( Key == CryptEssenceUL )
     {
       if ( ! m_Info.EncryptedEssence )
 	{
@@ -235,11 +220,11 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
       ess_p += sizeof(ui64_t);
 
       // read essence UL length
-      if ( ! read_test_BER(&ess_p, klv_key_size) )
+      if ( ! read_test_BER(&ess_p, SMPTE_UL_LENGTH) )
 	return RESULT_FORMAT;
 
       // TODO: test essence UL
-      ess_p += klv_key_size;
+      ess_p += SMPTE_UL_LENGTH;
 
       // read SourceLength length
       if ( ! read_test_BER(&ess_p, sizeof(ui64_t)) )
@@ -336,7 +321,12 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
     }
   else
     {
-      DefaultLogSink().Error("Unexpected UL found.\n");
+      char strbuf[IntBufferLen];
+      const MDDEntry* Entry = Dict::FindUL(Key.Value());
+      if ( Entry == 0 )
+        DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Key.ToString(strbuf));
+      else
+        DefaultLogSink().Warn("Unexpected Essence UL found: %s.\n", Entry->name);
       return RESULT_FORMAT;
     }
 
diff --git a/src/h__Writer.cpp b/src/h__Writer.cpp
index cd51391..3c2b97b 100755
--- a/src/h__Writer.cpp
+++ b/src/h__Writer.cpp
@@ -31,21 +31,24 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "AS_DCP_internal.h"
 #include "MemIO.h"
-#include "Timecode.h"
 #include "KLV.h"
 
 using namespace ASDCP;
 using namespace ASDCP::MXF;
 
 // a magic number identifying asdcplib
-#ifndef WM_BUILD_NUMBER
-#define WM_BUILD_NUMBER 0x4A48
+#ifndef ASDCP_BUILD_NUMBER
+#define ASDCP_BUILD_NUMBER 0x4A48
 #endif
 
 
 
 //
-ASDCP::h__Writer::h__Writer() : m_EssenceDescriptor(0), m_FramesWritten(0), m_StreamOffset(0)
+ASDCP::h__Writer::h__Writer() :
+  m_HeaderSize(0), m_EssenceStart(0),
+  m_MaterialPackage(0), m_MPTCSequence(0), m_MPTimecode(0), m_MPClSequence(0), m_MPClip(0),
+  m_FilePackage(0), m_FPTCSequence(0), m_FPTimecode(0), m_FPClSequence(0), m_FPClip(0),
+  m_EssenceDescriptor(0), m_FramesWritten(0), m_StreamOffset(0)
 {
 }
 
@@ -54,23 +57,6 @@ ASDCP::h__Writer::~h__Writer()
 }
 
 
-const byte_t PictDD_Data[SMPTE_UL_LENGTH] = {
-  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
-  0x01, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 };
-
-const byte_t SoundDD_Data[SMPTE_UL_LENGTH] = {
-  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
-  0x01, 0x03, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00 };
-
-const byte_t TCDD_Data[SMPTE_UL_LENGTH] = {
-  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
-  0x01, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 };
-
-const byte_t DMDD_Data[SMPTE_UL_LENGTH] = {
-  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
-  0x01, 0x03, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 };
-
-
 //
 // add DMS CryptographicFramework entry to source package
 void
@@ -86,7 +72,7 @@ AddDMScrypt(Partition& HeaderPart, SourcePackage& Package, WriterInfo& Descr, co
   Sequence* Seq = new Sequence;
   HeaderPart.AddChildObject(Seq);
   NewTrack->Sequence = Seq->InstanceUID;
-  Seq->DataDefinition = UL(DMDD_Data);
+  Seq->DataDefinition = UL(Dict::ul(MDD_DescriptiveMetaDataDef));
 
   DMSegment* Segment = new DMSegment;
   HeaderPart.AddChildObject(Segment);
@@ -103,14 +89,15 @@ AddDMScrypt(Partition& HeaderPart, SourcePackage& Package, WriterInfo& Descr, co
 
   Context->ContextID.Set(Descr.ContextID);
   Context->SourceEssenceContainer = WrappingUL; // ??????
-  Context->CipherAlgorithm.Set(CipherAlgorithm_AES);
-  Context->MICAlgorithm.Set( Descr.UsesHMAC ? MICAlgorithm_HMAC_SHA1 : 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);
 }
 
 //
 Result_t
 ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& WrappingUL,
+				 const std::string& TrackName, const UL& DataDefinition,
 				 const MXF::Rational& EditRate,
 				 ui32_t TCFrameRate, ui32_t BytesPerEditUnit)
 {
@@ -122,7 +109,7 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
 
   // 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(OP1aUL);
+  m_HeaderPart.m_Preface->OperationalPattern = UL(Dict::ul(MDD_OP1a));
   m_HeaderPart.OperationalPattern = m_HeaderPart.m_Preface->OperationalPattern;
   m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(1, 0)); // First RIP Entry
 
@@ -138,12 +125,12 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   Ident->ProductName = m_Info.ProductName.c_str();
   Ident->VersionString = m_Info.ProductVersion.c_str();
   Ident->ProductUID.Set(m_Info.ProductUUID);
-  // Ident->Platform = WM_PLATFORM;
-  Ident->ToolkitVersion.Release = VersionType::RL_DEVELOPMENT;
+  //  Ident->Platform = "Foonix"; // ASDCP_PLATFORM;
   Ident->ToolkitVersion.Major = VERSION_MAJOR;
   Ident->ToolkitVersion.Minor = VERSION_APIMINOR;
   Ident->ToolkitVersion.Patch = VERSION_IMPMINOR;
-  Ident->ToolkitVersion.Build = WM_BUILD_NUMBER;
+  Ident->ToolkitVersion.Build = ASDCP_BUILD_NUMBER;
+  Ident->ToolkitVersion.Release = VersionType::RL_DEVELOPMENT;
 
   //
   ContentStorage* Storage = new ContentStorage;
@@ -160,7 +147,7 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   // Material Package
   //
   UMID PackageUMID;
-  PackageUMID.MakeUMID(0x0d); // Using mixed type. What is the actual type?
+  PackageUMID.MakeUMID(0x0f); // unidentified essence
 
   m_MaterialPackage = new MaterialPackage;
   m_MaterialPackage->Name = "AS-DCP Material Package";
@@ -177,17 +164,17 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   NewTrack->TrackID = 1;
   NewTrack->TrackName = "Timecode Track";
 
-  Sequence* Seq = new Sequence;
-  m_HeaderPart.AddChildObject(Seq);
-  NewTrack->Sequence = Seq->InstanceUID;
-  Seq->DataDefinition = UL(TCDD_Data);
+  m_MPTCSequence = new Sequence;
+  m_HeaderPart.AddChildObject(m_MPTCSequence);
+  NewTrack->Sequence = m_MPTCSequence->InstanceUID;
+  m_MPTCSequence->DataDefinition = UL(Dict::ul(MDD_TimecodeDataDef));
 
   m_MPTimecode = new TimecodeComponent;
   m_HeaderPart.AddChildObject(m_MPTimecode);
-  Seq->StructuralComponents.push_back(m_MPTimecode->InstanceUID);
+  m_MPTCSequence->StructuralComponents.push_back(m_MPTimecode->InstanceUID);
   m_MPTimecode->RoundedTimecodeBase = TCFrameRate;
   m_MPTimecode->StartTimecode = ui64_C(0);
-  m_MPTimecode->DataDefinition = UL(TCDD_Data);
+  m_MPTimecode->DataDefinition = UL(Dict::ul(MDD_TimecodeDataDef));
 
   // Essence Track
   NewTrack = new Track;
@@ -195,15 +182,17 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   NewTrack->EditRate = EditRate;
   m_MaterialPackage->Tracks.push_back(NewTrack->InstanceUID);
   NewTrack->TrackID = 2;
-  NewTrack->TrackName = "Essence Track";
+  NewTrack->TrackName = TrackName.c_str();
 
-  Seq = new Sequence;
-  m_HeaderPart.AddChildObject(Seq);
-  NewTrack->Sequence = Seq->InstanceUID;
+  m_MPClSequence = new Sequence;
+  m_HeaderPart.AddChildObject(m_MPClSequence);
+  NewTrack->Sequence = m_MPClSequence->InstanceUID;
+  m_MPClSequence->DataDefinition = DataDefinition;
 
   m_MPClip = new SourceClip;
   m_HeaderPart.AddChildObject(m_MPClip);
-  Seq->StructuralComponents.push_back(m_MPClip->InstanceUID);
+  m_MPClSequence->StructuralComponents.push_back(m_MPClip->InstanceUID);
+  m_MPClip->DataDefinition = DataDefinition;
 
   //
   // File (Source) Package
@@ -229,17 +218,17 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   NewTrack->TrackID = 1;
   NewTrack->TrackName = "Timecode Track";
 
-  Seq = new Sequence;
-  m_HeaderPart.AddChildObject(Seq);
-  NewTrack->Sequence = Seq->InstanceUID;
-  Seq->DataDefinition = UL(TCDD_Data);
+  m_FPTCSequence = new Sequence;
+  m_HeaderPart.AddChildObject(m_FPTCSequence);
+  NewTrack->Sequence = m_FPTCSequence->InstanceUID;
+  m_FPTCSequence->DataDefinition = UL(Dict::ul(MDD_TimecodeDataDef));
 
   m_FPTimecode = new TimecodeComponent;
   m_HeaderPart.AddChildObject(m_FPTimecode);
-  Seq->StructuralComponents.push_back(m_FPTimecode->InstanceUID);
+  m_FPTCSequence->StructuralComponents.push_back(m_FPTimecode->InstanceUID);
   m_FPTimecode->RoundedTimecodeBase = TCFrameRate;
   m_FPTimecode->StartTimecode = ui64_C(86400); // 01:00:00:00
-  m_FPTimecode->DataDefinition = UL(TCDD_Data);
+  m_FPTimecode->DataDefinition = UL(Dict::ul(MDD_TimecodeDataDef));
 
   // Essence Track
   NewTrack = new Track;
@@ -247,24 +236,23 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   NewTrack->EditRate = EditRate;
   m_FilePackage->Tracks.push_back(NewTrack->InstanceUID);
   NewTrack->TrackID = 2;
-  NewTrack->TrackName = "Essence Track";
+  NewTrack->TrackName = TrackName.c_str();
 
-  Seq = new Sequence;
-  m_HeaderPart.AddChildObject(Seq);
-  NewTrack->Sequence = Seq->InstanceUID;
+  m_FPClSequence = new Sequence;
+  m_HeaderPart.AddChildObject(m_FPClSequence);
+  NewTrack->Sequence = m_FPClSequence->InstanceUID;
+  m_FPClSequence->DataDefinition = DataDefinition;
 
   m_FPClip = new SourceClip;
   m_HeaderPart.AddChildObject(m_FPClip);
-  Seq->StructuralComponents.push_back(m_FPClip->InstanceUID);
+  m_FPClSequence->StructuralComponents.push_back(m_FPClip->InstanceUID);
+  m_FPClip->DataDefinition = DataDefinition;
 
   //
   // Essence Descriptor
   //
   m_EssenceDescriptor->EssenceContainer = WrappingUL;
   m_EssenceDescriptor->LinkedTrackID = NewTrack->TrackID;
-
-  // link the Material Package to the File Package ?????????????????????????????????
-  Seq->StructuralComponents.push_back(NewTrack->InstanceUID);
   m_HeaderPart.m_Preface->PrimaryPackage = m_FilePackage->InstanceUID;
 
   //
@@ -272,16 +260,15 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   //
   if ( m_Info.EncryptedEssence )
     {
-      UL CryptEssenceUL(WrappingUL_Data_Crypt);
+      UL CryptEssenceUL(Dict::ul(MDD_EncryptedContainerLabel));
       m_HeaderPart.EssenceContainers.push_back(CryptEssenceUL);
       m_HeaderPart.m_Preface->EssenceContainers.push_back(CryptEssenceUL);
-      m_HeaderPart.m_Preface->DMSchemes.push_back(UL(CryptoFrameworkUL_Data));
+      m_HeaderPart.m_Preface->DMSchemes.push_back(UL(Dict::ul(MDD_CryptographicFrameworkLabel)));
       AddDMScrypt(m_HeaderPart, *m_FilePackage, m_Info, WrappingUL);
     }
   else
     {
-      UL GCUL(GCMulti_Data);
-      m_HeaderPart.EssenceContainers.push_back(GCUL);
+      m_HeaderPart.EssenceContainers.push_back(UL(Dict::ul(MDD_GCMulti)));
       m_HeaderPart.EssenceContainers.push_back(WrappingUL);
       m_HeaderPart.m_Preface->EssenceContainers = m_HeaderPart.EssenceContainers;
     }
@@ -290,7 +277,7 @@ ASDCP::h__Writer::WriteMXFHeader(const std::string& PackageLabel, const UL& Wrap
   m_FilePackage->Descriptor = m_EssenceDescriptor->InstanceUID;
 
   // Write the header partition
-  Result_t result = m_HeaderPart.WriteToFile(m_File, HeaderPadding);
+  Result_t result = m_HeaderPart.WriteToFile(m_File, m_HeaderSize);
 
   //
   // Body Partition
@@ -349,7 +336,7 @@ ASDCP::h__Writer::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf, const byte
 
       if ( ASDCP_SUCCESS(result) )
 	{ // write UL
-	  Overhead.WriteRaw((byte_t*)CryptEssenceUL_Data, klv_key_size);
+	  Overhead.WriteRaw(Dict::ul(MDD_CryptEssence), SMPTE_UL_LENGTH);
 
 	  // construct encrypted triplet header
 	  ui32_t ETLength = klv_cryptinfo_size + m_CtFrameBuf.Size();
@@ -357,18 +344,18 @@ ASDCP::h__Writer::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf, const byte
 	  if ( m_Info.UsesHMAC )
 	    ETLength += klv_intpack_size;
 	  else
-	    ETLength += (klv_length_size * 3); // for empty intpack
+	    ETLength += (MXF_BER_LENGTH * 3); // for empty intpack
 
-	  Overhead.WriteBER(ETLength, klv_length_size);                  // write encrypted triplet length
-	  Overhead.WriteBER(UUIDlen, klv_length_size);                   // write ContextID length
+	  Overhead.WriteBER(ETLength, MXF_BER_LENGTH);                  // write encrypted triplet length
+	  Overhead.WriteBER(UUIDlen, MXF_BER_LENGTH);                   // write ContextID length
 	  Overhead.WriteRaw(m_Info.ContextID, UUIDlen);                  // write ContextID
-	  Overhead.WriteBER(sizeof(ui64_t), klv_length_size);            // write PlaintextOffset length
+	  Overhead.WriteBER(sizeof(ui64_t), MXF_BER_LENGTH);            // write PlaintextOffset length
 	  Overhead.WriteUi64BE(FrameBuf.PlaintextOffset());              // write PlaintextOffset
-	  Overhead.WriteBER(klv_key_size, klv_length_size);              // write essence UL length
-	  Overhead.WriteRaw((byte_t*)EssenceUL, klv_key_size);           // write the essence UL
-	  Overhead.WriteBER(sizeof(ui64_t), klv_length_size);            // write SourceLength length
+	  Overhead.WriteBER(SMPTE_UL_LENGTH, MXF_BER_LENGTH);              // write essence UL length
+	  Overhead.WriteRaw((byte_t*)EssenceUL, SMPTE_UL_LENGTH);           // write the essence UL
+	  Overhead.WriteBER(sizeof(ui64_t), MXF_BER_LENGTH);            // write SourceLength length
 	  Overhead.WriteUi64BE(FrameBuf.Size());                         // write SourceLength
-	  Overhead.WriteBER(m_CtFrameBuf.Size(), klv_length_size);       // write ESV length
+	  Overhead.WriteBER(m_CtFrameBuf.Size(), MXF_BER_LENGTH);       // write ESV length
 
 	  result = m_File.Writev(Overhead.Data(), Overhead.Size());
 	}
@@ -395,7 +382,7 @@ ASDCP::h__Writer::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf, const byte
 	  else
 	    { // we still need the var-pack length values if the intpack is empty
 	      for ( ui32_t i = 0; i < 3 ; i++ )
-		HMACOverhead.WriteBER(0, klv_length_size);
+		HMACOverhead.WriteBER(0, MXF_BER_LENGTH);
 	    }
 
 	  // write HMAC
@@ -405,8 +392,8 @@ ASDCP::h__Writer::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf, const byte
     }
   else
     {
-      Overhead.WriteRaw((byte_t*)EssenceUL, klv_key_size);
-      Overhead.WriteBER(FrameBuf.Size(), klv_length_size);
+      Overhead.WriteRaw((byte_t*)EssenceUL, SMPTE_UL_LENGTH);
+      Overhead.WriteBER(FrameBuf.Size(), MXF_BER_LENGTH);
       result = m_File.Writev(Overhead.Data(), Overhead.Size());
  
       if ( ASDCP_SUCCESS(result) )
@@ -429,9 +416,13 @@ Result_t
 ASDCP::h__Writer::WriteMXFFooter()
 {
   // Set top-level file package correctly for OP-Atom
+  m_MPTCSequence->Duration = m_FramesWritten;
   m_MPTimecode->Duration = m_FramesWritten;
+  m_MPClSequence->Duration = m_FramesWritten;
   m_MPClip->Duration = m_FramesWritten;
+  m_FPTCSequence->Duration = m_FramesWritten;
   m_FPTimecode->Duration = m_FramesWritten;
+  m_FPClSequence->Duration = m_FramesWritten;
   m_FPClip->Duration = m_FramesWritten;
   m_EssenceDescriptor->ContainerDuration = m_FramesWritten;
 
@@ -439,8 +430,8 @@ ASDCP::h__Writer::WriteMXFFooter()
   m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(1, here)); // Third RIP Entry
   m_HeaderPart.FooterPartition = here;
   m_HeaderPart.BodySID = 1;
-  m_HeaderPart.IndexSID = m_FooterPart.IndexSID;
-  m_HeaderPart.OperationalPattern = UL(OPAtomUL);
+  //  m_HeaderPart.IndexSID = m_FooterPart.IndexSID;
+  m_HeaderPart.OperationalPattern = UL(Dict::ul(MDD_OPAtom));
   m_HeaderPart.m_Preface->OperationalPattern = m_HeaderPart.OperationalPattern;
 
   m_FooterPart.OperationalPattern = m_HeaderPart.OperationalPattern;
@@ -457,7 +448,7 @@ ASDCP::h__Writer::WriteMXFFooter()
     result = m_File.Seek(0);
 
   if ( ASDCP_SUCCESS(result) )
-    result = m_HeaderPart.WriteToFile(m_File, HeaderPadding);
+    result = m_HeaderPart.WriteToFile(m_File, m_HeaderSize);
 
   m_File.Close();
   return result;