release

diff --git a/FileIO.cpp b/FileIO.cpp
index b3d434ef1029941cdbf31c50c2f7e306a29522ab..3665c458bc73d408cf69420545f9dc8e036095ca 100755 (executable)
--- a/FileIO.cpp
+++ b/FileIO.cpp
@@ -362,13 +362,12 @@ ASDCP::FileWriter::Writev(ui32_t* bytes_written)
                                   (DWORD*)&tmp_count,
                                   NULL);
 
-      if ( wr_result == 0 )
+      if ( wr_result == 0 || iov->m_iovec[i].iov_len != tmp_count)
        {
          result = ASDCP::RESULT_WRITEFAIL;
          break;
        }
 
-      assert(iov->m_iovec[i].iov_len == tmp_count);
       *bytes_written += tmp_count;
     }
 

diff --git a/README b/README
index 89d3d856c0ee5a08ab97eee811f68b0f1dc64e9d..dbd73fd3236fc239a8b45a7a7cb580e3f6a15710 100755 (executable)
--- a/README
+++ b/README
@@ -83,26 +83,6 @@ I have tested this build on win32, Linux and Darwin platforms.
 Others may work as well.
 
 
-Build Versions
-
-There are two flavors of build: the default build and the
-"SMPTE_LABELS" build. Unless you are specifically  working on
-emerging SMPTE standards for D-Cinema content, you will certainly
-want the default build. If you are developing support for the MXF
-Interop Initiative standards, the default build is for you!
-
-If you are not aiming for MXF Interop and if you are working
-on developing support for the very latest versions of the SMPTE
-draft standards, then you want the SMPTE_LABELS build:
-
-  make SMPTE_LABELS=1
-
-NOTE: If you choose the SMPTE_LABELS build, you will be creating
-files that may not work on MXF Interop systems. In the case of
-encryption, incompatibility with MXF Interop is guaranteed! You
-have been warned!
-
-
 Documentation
 
 Currently, the documentation is mostly in AS_DCP.h. Read
@@ -112,10 +92,20 @@ examples. More detailed documentation will be written RSN.
 
 
 Change History
+2006.03.16 - bug fixes plus
+ o Removed SMPTE_LABELS compile-time option. The reader will now
+   silently accept either SMPTE or MXF Interop labels, the writer
+   can be instructed which to use at runtime. Default is Interop.
+ o Added an AIFF reader. Support is preliminary, it works with the
+   AIFF files I have on hand.
+ o More code refactoring. More to come.
+
+
 2006.03.09 - full read-write
  o Removed ASDCP_WITHOUT_OPENSSL compile-time option.
  o Full read/write now working on new MXF library
 
+
 2005.00.00 - A New Hope
  o The temporary mxf-lite has been removed. MXF files are now 
    managed via the objects in KLV.h, MXFTypes.h MXF.h and

diff --git a/src/AS_DCP.h b/src/AS_DCP.h
index b64c3a5c469f35da284c378220c1dce8b95089e2..e65b029ff8690563a748208bfa85e84f4e06da57 100755 (executable)
--- a/src/AS_DCP.h
+++ b/src/AS_DCP.h
@@ -143,7 +143,7 @@ namespace ASDCP {
   // 1.0.1. If changes were also required in AS_DCP.h, the new version would be 1.1.1.
   const ui32_t VERSION_MAJOR = 1;
   const ui32_t VERSION_APIMINOR = 0;
-  const ui32_t VERSION_IMPMINOR = 4;
+  const ui32_t VERSION_IMPMINOR = 5;
   const char* Version();
 
   // UUIDs are passed around as strings of UUIDlen bytes
@@ -152,11 +152,6 @@ namespace ASDCP {
   // Encryption keys are passed around as strings of KeyLen bytes
   const ui32_t KeyLen = 16;
 
-  // Key IDs are really UUIDs, so it makes no sense to have this value
-  //  // Encryption key IDs are passed around as strings of KeyIDlen bytes
-  //  const ui32_t KeyIDlen = 16;
-
-
   //---------------------------------------------------------------------------------
   // message logging
 
@@ -240,7 +235,6 @@ namespace ASDCP {
     ESS_PCM_24b_48k  // the file contains one or more PCM audio pairs
   };
 
-
   // Determine the type of essence contained in the given MXF file. RESULT_OK
   // is returned if the file is successfully opened and contains a valid MXF
   // stream. If there is an error, the result code will indicate the reason.
@@ -251,10 +245,9 @@ namespace ASDCP {
   // stream type. If there is an error, the result code will indicate the reason.
   Result_t RawEssenceType(const char* filename, EssenceType_t& type);
 
-  // Locate the named object in the file header and dump it to the given stream.
-  // The default dump stream is stderr.
-  Result_t FindObject(const char* filename, const char* objname, FILE* = 0);
 
+  //---------------------------------------------------------------------------------
+  // base types
 
   // A simple container for rational numbers.
   class Rational
@@ -409,6 +402,30 @@ namespace ASDCP {
   //---------------------------------------------------------------------------------
   // WriterInfo class - encapsulates writer identification details used for
   // OpenWrite() calls.  Replace these values at runtime to identify your product.
+  //
+  // MXF files use SMPTE Universal Labels to identify data items. The set of Labels
+  // in a file is determined by the MXF Operational Pattern and any constraining
+  // documentation. There are currently two flavors of AS-DCP file in use: MXF Interop
+  // and SMPTE. The two differ only in the values of two labels:
+  //
+  //   OP Atom     / Interop : 06 0e 2b 34 04 01 01 01  0d 01 02 01 10 00 00 00
+  //   OP Atom     / SMPTE   : 06 0e 2b 34 04 01 01 02  0d 01 02 01 10 00 00 00
+  // and 
+  //   EKLV Packet / Interop : 06 0e 2b 34 02 04 01 07  0d 01 03 01 02 7e 01 00
+  //   EKLV Packet / SMPTE   : 06 0e 2b 34 02 04 01 01  0d 01 03 01 02 7e 01 00
+  //
+  // asdcplib will read any (otherwise valid) file which has any combination of the
+  // above values. When writing files, MXF Interop labels are used by default. To
+  // write a file containing SMPTE labels, replace the default label set value in
+  // the WriterInfo before calling OpenWrite()
+  //
+  enum LabelSet_t
+  {
+    LS_MXF_UNKNOWN,
+    LS_MXF_INTEROP,
+    LS_MXF_SMPTE
+  };
+
   //
   struct WriterInfo
   {
@@ -416,15 +433,18 @@ namespace ASDCP {
     byte_t      AssetUUID[UUIDlen];
     byte_t      ContextID[UUIDlen];
     byte_t      CryptographicKeyID[UUIDlen];
-    bool        EncryptedEssence; // true if essence data is (or is to be) encrypted
+    bool        EncryptedEssence; // true if essence data is (or is going to be) encrypted
     bool        UsesHMAC;         // true if HMAC exists or is to be calculated
     std::string ProductVersion;
     std::string CompanyName;
     std::string ProductName;
-    
-    WriterInfo() : EncryptedEssence(false), UsesHMAC(false) {
-      static byte_t default_ProductUUID_Data[UUIDlen] = { 0x43, 0x05, 0x9a, 0x1d, 0x04, 0x32, 0x41, 0x01,
-                                                         0xb8, 0x3f, 0x73, 0x68, 0x15, 0xac, 0xf3, 0x1d };
+    LabelSet_t  LabelSetType;
+
+    WriterInfo() : EncryptedEssence(false), UsesHMAC(false), LabelSetType(LS_MXF_INTEROP)
+    {
+      static byte_t default_ProductUUID_Data[UUIDlen] = {
+       0x43, 0x05, 0x9a, 0x1d, 0x04, 0x32, 0x41, 0x01,
+       0xb8, 0x3f, 0x73, 0x68, 0x15, 0xac, 0xf3, 0x1d };
       
       memcpy(ProductUUID, default_ProductUUID_Data, UUIDlen);
       memset(AssetUUID, 0, UUIDlen);

diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index 3bb5484c87a356cfc736d978698e181e5f5e5686..bf276e75a9c31d43b0f16d4f4d1fb9852733af52 100755 (executable)
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -45,20 +45,20 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream)
     stream = stderr;
 
   fprintf(stream, "\
-      AspectRatio: %lu/%lu\n\
-         EditRate: %lu/%lu\n\
-      StoredWidth: %lu\n\
-     StoredHeight: %lu\n\
-            Rsize: %lu\n\
-            Xsize: %lu\n\
-            Ysize: %lu\n\
-           XOsize: %lu\n\
-           YOsize: %lu\n\
-           XTsize: %lu\n\
-           YTsize: %lu\n\
-          XTOsize: %lu\n\
-          YTOsize: %lu\n\
-ContainerDuration: %lu\n",
+       AspectRatio: %lu/%lu\n\
+          EditRate: %lu/%lu\n\
+       StoredWidth: %lu\n\
+      StoredHeight: %lu\n\
+             Rsize: %lu\n\
+             Xsize: %lu\n\
+             Ysize: %lu\n\
+            XOsize: %lu\n\
+            YOsize: %lu\n\
+            XTsize: %lu\n\
+            YTsize: %lu\n\
+           XTOsize: %lu\n\
+           YTOsize: %lu\n\
+ ContainerDuration: %lu\n",
          PDesc.AspectRatio.Numerator ,PDesc.AspectRatio.Denominator,
          PDesc.EditRate.Numerator ,PDesc.EditRate.Denominator,
          PDesc.StoredWidth,
@@ -194,7 +194,7 @@ ASDCP::JP2K::MXFReader::h__Reader::OpenRead(const char* filename)
     result = InitMXFIndex();
 
   if( ASDCP_SUCCESS(result) )
-    result = InitInfo(m_Info);
+    result = InitInfo();
 
   return result;
 }

diff --git a/src/AS_DCP_MPEG2.cpp b/src/AS_DCP_MPEG2.cpp
index badc221acb807142947346cf62ea3589bb471e1a..26988e45c4121341236f16f8241eb2b9d5ee7464 100755 (executable)
--- a/src/AS_DCP_MPEG2.cpp
+++ b/src/AS_DCP_MPEG2.cpp
@@ -102,20 +102,20 @@ ASDCP::MPEG2::VideoDescriptorDump(const VideoDescriptor& VDesc, FILE* stream)
     stream = stderr;
 
   fprintf(stream, "\
-           SampleRate: %lu/%lu\n\
-          FrameLayout: %lu\n\
-          StoredWidth: %lu\n\
-         StoredHeight: %lu\n\
-          AspectRatio: %lu/%lu\n\
-       ComponentDepth: %lu\n\
-HorizontalSubsampling: %lu\n\
-  VerticalSubsampling: %lu\n\
-          ColorSiting: %lu\n\
-     CodedContentType: %lu\n\
-             LowDelay: %lu\n\
-              BitRate: %lu\n\
-      ProfileAndLevel: %lu\n\
-    ContainerDuration: %lu\n",
+        SampleRate: %lu/%lu\n\
+       FrameLayout: %lu\n\
+       StoredWidth: %lu\n\
+      StoredHeight: %lu\n\
+       AspectRatio: %lu/%lu\n\
+    ComponentDepth: %lu\n\
+ HorizontalSubsmpl: %lu\n\
+   VerticalSubsmpl: %lu\n\
+       ColorSiting: %lu\n\
+  CodedContentType: %lu\n\
+          LowDelay: %lu\n\
+           BitRate: %lu\n\
+   ProfileAndLevel: %lu\n\
+ ContainerDuration: %lu\n",
          VDesc.SampleRate.Numerator ,VDesc.SampleRate.Denominator,
          VDesc.FrameLayout,
          VDesc.StoredWidth,
@@ -174,7 +174,7 @@ ASDCP::MPEG2::MXFReader::h__Reader::OpenRead(const char* filename)
     result = InitMXFIndex();
 
   if( ASDCP_SUCCESS(result) )
-    result = InitInfo(m_Info);
+    result = InitInfo();
 
   return result;
 }

diff --git a/src/AS_DCP_MXF.cpp b/src/AS_DCP_MXF.cpp
index 9436273e7be18d4f95e4fd4e950ffb3bf4dec2f8..92f76bb2c23927ccfb13efac7d0cabc6ed663d4c 100755 (executable)
--- a/src/AS_DCP_MXF.cpp
+++ b/src/AS_DCP_MXF.cpp
@@ -69,6 +69,9 @@ ASDCP::WriterInfoDump(const WriterInfo& Info, FILE* stream)
     }
 
   fprintf(stream,"         AssetUUID: %s\n", bin2hex(Info.AssetUUID, 16, str_buf, 40));
+  fprintf(stream,"    Label Set Type: %s\n", ( Info.LabelSetType == LS_MXF_SMPTE ? "SMPTE" :
+                                              ( Info.LabelSetType == LS_MXF_INTEROP ? "MXF Interop" :
+                                                "Unknown" ) ));
 }
 
 //
@@ -464,49 +467,6 @@ ASDCP::IntegrityPack::TestValues(const ASDCP::FrameBuffer& FB, byte_t* AssetID,
   return HMAC->TestHMACValue(p);
 }
 
-//------------------------------------------------------------------------------------------
-//
-
-
-//
-ASDCP::Result_t
-ASDCP::KLVReader::ReadKLFromFile(ASDCP::FileReader& Reader)
-{
-  ui32_t read_count;
-  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 + 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)SMPTE_UL_LENGTH), 8, intbuf));
-         return RESULT_FAIL;
-       }
-
-      if ( m_BERLength != MXF_BER_LENGTH )
-       {
-
-         ASDCP::DefaultLogSink().Error("Found packet with BER length %lu; being less efficient...\n",
-                                       m_BERLength);
-         // TODO: recover the correct BER value
-         // and reposition the file pointer
-         ASDCP::DefaultLogSink().Error("please finish me\n");
-         assert(0);
-       }
-
-      if ( ! read_BER(m_Key + SMPTE_UL_LENGTH, &m_Length) )
-       return RESULT_FAIL;
-    }
-  
-  return result;
-}
-
 //
 // end AS_DCP_MXF.cpp
 //

diff --git a/src/AS_DCP_PCM.cpp b/src/AS_DCP_PCM.cpp
index ef16f2b64618e354f5e8296c35536e5e5b311fde..90632101736179d956ee1763a898a23f695a4779 100755 (executable)
--- a/src/AS_DCP_PCM.cpp
+++ b/src/AS_DCP_PCM.cpp
@@ -185,7 +185,7 @@ ASDCP::PCM::MXFReader::h__Reader::OpenRead(const char* filename)
     result = InitMXFIndex();
 
   if( ASDCP_SUCCESS(result) )
-    result = InitInfo(m_Info);
+    result = InitInfo();
 
   // TODO: test file for sane CBR index BytesPerEditUnit
 

diff --git a/src/AS_DCP_internal.h b/src/AS_DCP_internal.h
index 15890a77917f6f82adb79a906976d7a8d2727e99..173540d5472f408c19c15362f9319085c8be0a66 100755 (executable)
--- a/src/AS_DCP_internal.h
+++ b/src/AS_DCP_internal.h
@@ -75,17 +75,6 @@ namespace ASDCP
       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);
-
-  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 };
-
   // the check value for EKLV packets
   // CHUKCHUKCHUKCHUK
   static const byte_t ESV_CheckValue[CBC_BLOCK_SIZE] =
@@ -118,7 +107,7 @@ namespace ASDCP
       h__Reader();
       virtual ~h__Reader();
 
-      Result_t InitInfo(WriterInfo& Info);
+      Result_t InitInfo();
       Result_t OpenMXFRead(const char* filename);
       Result_t InitMXFIndex();
       Result_t ReadEKLVPacket(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
@@ -228,25 +217,6 @@ namespace ASDCP
       Result_t TestValues(const ASDCP::FrameBuffer&, byte_t* AssetID, ui32_t sequence, HMACContext* HMAC);
     };
 
-  //
-  class KLVReader
-    {
-      byte_t m_Key[32];
-      ui64_t m_Length;
-      ui32_t m_BERLength;
-      ui32_t m_HeaderLength;
-
-      ASDCP_NO_COPY_CONSTRUCT(KLVReader);
-
-    public:
-      KLVReader() : m_Length(0), m_BERLength(0), m_HeaderLength(0) {}
-      ~KLVReader() {}
-
-      inline const byte_t* Key() { return m_Key; }
-      inline const ui64_t  Length() { return m_Length; }
-      inline const ui64_t  KLLength() { return m_BERLength + SMPTE_UL_LENGTH; }
-      Result_t ReadKLFromFile(ASDCP::FileReader& Reader);
-    };
 
 } // namespace ASDCP
 

diff --git a/src/Dict.cpp b/src/Dict.cpp
index 0b71a8cb2fd41d5b1f5e7a569038e6bc8b219305..fe2988015befd3612d44dbd833f09c819bf02157 100755 (executable)
--- a/src/Dict.cpp
+++ b/src/Dict.cpp
@@ -32,6 +32,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "KLV.h"
 #include "MDD.cpp"
+#include <map>
+ 
+static bool    s_md_init = false;
+static std::map<ASDCP::UL, ui32_t> s_md_lookup;
 
 //------------------------------------------------------------------------------------------
 // singleton wrapper
@@ -43,57 +47,24 @@ ASDCP::Dict::Type(MDD_t type_id)
   return s_MDD_Table[type_id];
 }
 
+
 //
 const ASDCP::MDDEntry*
 ASDCP::Dict::FindUL(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(SMPTE_UL_START, 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_md_init )
     {
-      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--;
-       }
+      for ( ui32_t x = 0; x < s_MDD_Table_size; x++ )
+       s_md_lookup.insert(std::map<UL, ui32_t>::value_type(UL(s_MDD_Table[x].ul), x));
     }
 
-  return (s_MDD_Table[t_idx].ul == 0 ? 0 : &s_MDD_Table[t_idx]);
-}
-
-
-//
-// implementation
-
-ASDCP::Dict::Dict() { DefaultLogSink().Warn("new Dict\n"); }
-ASDCP::Dict::~Dict() {}
+  std::map<UL, ui32_t>::iterator i = s_md_lookup.find(UL(ul_buf));
+  
+  if ( i == s_md_lookup.end() )
+    return 0;
 
+  return &s_MDD_Table[(*i).second];
+}
 
 
 //

diff --git a/src/KLV.cpp b/src/KLV.cpp
index b31969e3467a92b7ce707219a30d4f502d7034b4..63c1e549aff758dbcfbc232e3a3920874819af5b 100755 (executable)
--- a/src/KLV.cpp
+++ b/src/KLV.cpp
@@ -69,6 +69,20 @@ ASDCP::KLVPacket::InitFromBuffer(const byte_t* buf, ui32_t buf_len)
       return RESULT_FAIL;
     }
 
+  ui32_t ber_len = BER_length(buf + SMPTE_UL_LENGTH);
+
+  if ( ber_len > ( buf_len - SMPTE_UL_LENGTH ) )
+    {
+      DefaultLogSink().Error("BER encoding length exceeds buffer size\n");
+      return RESULT_FAIL;
+    }
+
+  if ( ber_len == 0 )
+    {
+      ASDCP::DefaultLogSink().Error("KLV format error, zero BER length not allowed\n");
+      return RESULT_FAIL;
+    }
+
   ui64_t tmp_size;
   if ( ! read_BER(buf + SMPTE_UL_LENGTH, &tmp_size) )
        return RESULT_FAIL;
@@ -148,7 +162,7 @@ ASDCP::KLVFilePacket::InitFromFile(const FileReader& Reader, const byte_t* label
   return result;
 }
 
-//
+// TODO: refactor to use InitFromBuffer
 ASDCP::Result_t
 ASDCP::KLVFilePacket::InitFromFile(const FileReader& Reader)
 {

diff --git a/src/MDD.cpp b/src/MDD.cpp
index 59e5f0b1226b8f33e65bd828247ecfdf77e589a9..ba7007cd625fb2876b03e0e8c16bfa40b7bdf87c 100644 (file)
--- a/src/MDD.cpp
+++ b/src/MDD.cpp
@@ -36,796 +36,769 @@ static const ASDCP::MDDEntry s_MDD_Table[] = {
   { { 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
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 1
+      0x0d, 0x01, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 },
+      {0}, false, "MXFInterop_OPAtom" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02, // 2
       0x0d, 0x01, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 },
       {0}, false, "OPAtom" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 2
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 3
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00 },
       {0}, false, "OP1a" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x03, // 3
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x03, // 4
       0x0d, 0x01, 0x03, 0x01, 0x02, 0x7f, 0x01, 0x00 },
       {0}, false, "GCMulti" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 4
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 5
       0x01, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "PictureDataDef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 5
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 6
       0x01, 0x03, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00 },
       {0}, false, "SoundDataDef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 6
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 7
       0x01, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "TimecodeDataDef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 7
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 8
       0x01, 0x03, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00 },
       {0}, false, "DescriptiveMetaDataDef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 8
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, // 9
       0x0d, 0x01, 0x03, 0x01, 0x02, 0x06, 0x01, 0x00 },
       {0}, false, "WAVWrapping" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02, // 9
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x02, // 10
       0x0d, 0x01, 0x03, 0x01, 0x02, 0x04, 0x60, 0x01 },
       {0}, false, "MPEG2_VESWrapping" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 10
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 11
       0x0d, 0x01, 0x03, 0x01, 0x02, 0x0c, 0x01, 0x00 },
       {0}, false, "JPEG_2000Wrapping" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 11
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 12
       0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x08, 0x01 },
       {0}, false, "JPEG2000Essence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 12
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 13
       0x0d, 0x01, 0x03, 0x01, 0x15, 0x01, 0x05, 0x00 },
       {0}, false, "MPEG2Essence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x01, // 13
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x07, // 14
+      0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 },
+      {0}, false, "MXFInterop_CryptEssence" },
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x04, 0x01, 0x01, // 15
       0x0d, 0x01, 0x03, 0x01, 0x02, 0x7e, 0x01, 0x00 },
       {0}, false, "CryptEssence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 14
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x01, // 16
       0x0d, 0x01, 0x03, 0x01, 0x16, 0x01, 0x01, 0x00 },
       {0}, false, "WAVEssence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x09, // 15
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x09, // 17
       0x04, 0x01, 0x02, 0x02, 0x03, 0x01, 0x01, 0x01 },
       {0}, false, "JP2KEssenceCompression" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 16
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 18
       0x02, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "CipherAlgorithm_AES" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 17
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 19
       0x02, 0x09, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "MICAlgorithm_HMAC_SHA1" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 18
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 20
       0x03, 0x01, 0x02, 0x10, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "KLVFill" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 19
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 21
       0x03, 0x01, 0x02, 0x01, 0x06, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_MajorVersion" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 20
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 22
       0x03, 0x01, 0x02, 0x01, 0x07, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_MinorVersion" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 21
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 23
       0x03, 0x01, 0x02, 0x01, 0x09, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_KAGSize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 22
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 24
       0x06, 0x10, 0x10, 0x03, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_ThisPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 23
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 25
       0x06, 0x10, 0x10, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_PreviousPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 24
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 26
       0x06, 0x10, 0x10, 0x05, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_FooterPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 25
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 27
       0x04, 0x06, 0x09, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_HeaderByteCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 26
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 28
       0x04, 0x06, 0x09, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_IndexByteCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 27
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 29
       0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_IndexSID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 28
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 30
       0x06, 0x08, 0x01, 0x02, 0x01, 0x03, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_BodyOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 29
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 31
       0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_BodySID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 30
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 32
       0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_OperationalPattern" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 31
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 33
       0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00 },
       {0}, false, "PartitionMetadata_EssenceContainers" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 32
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 34
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x01, 0x00 },
       {0}, false, "OpenHeader" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 33
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 35
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x03, 0x00 },
       {0}, false, "OpenCompleteHeader" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 34
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 36
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x00 },
       {0}, false, "ClosedHeader" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 35
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 37
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, 0x00 },
       {0}, false, "ClosedCompleteHeader" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 36
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 38
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x01, 0x00 },
       {0}, false, "OpenBodyPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 37
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 39
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x03, 0x00 },
       {0}, false, "OpenCompleteBodyPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 38
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 40
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x00 },
       {0}, false, "ClosedBodyPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 39
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 41
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x03, 0x04, 0x00 },
       {0}, false, "ClosedCompleteBodyPartition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 40
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 42
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x04, 0x02, 0x00 },
       {0}, false, "Footer" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 41
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 43
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x04, 0x04, 0x00 },
       {0}, false, "CompleteFooter" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 42
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 44
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x05, 0x01, 0x00 },
       {0}, false, "Primer" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 43
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 45
       0x06, 0x01, 0x01, 0x07, 0x15, 0x00, 0x00, 0x00 },
       {0}, false, "Primer_LocalTagEntryBatch" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 44
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 46
       0x01, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "LocalTagEntryBatch_Primer_LocalTag" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 45
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 47
       0x01, 0x03, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "LocalTagEntryBatch_Primer_UID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 46
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 48
       0x01, 0x01, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x3c, 0x0a}, false, "InterchangeObject_InstanceUID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 47
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 49
       0x05, 0x20, 0x07, 0x01, 0x08, 0x00, 0x00, 0x00 },
       {0x01, 0x02}, true, "GenerationInterchangeObject_GenerationUID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 48
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 50
       0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "DefaultObject" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 49
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 51
       0x05, 0x30, 0x04, 0x06, 0x00, 0x00, 0x00, 0x00 },
       {0x3f, 0x0b}, false, "IndexTableSegmentBase_IndexEditRate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 50
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 52
       0x07, 0x02, 0x01, 0x03, 0x01, 0x0a, 0x00, 0x00 },
       {0x3f, 0x0c}, false, "IndexTableSegmentBase_IndexStartPosition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 51
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 53
       0x07, 0x02, 0x02, 0x01, 0x01, 0x02, 0x00, 0x00 },
       {0x3f, 0x0d}, false, "IndexTableSegmentBase_IndexDuration" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 52
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 54
       0x04, 0x06, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0x3f, 0x05}, false, "IndexTableSegmentBase_EditUnitByteCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 53
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 55
       0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
       {0x3f, 0x06}, false, "IndexTableSegmentBase_IndexSID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 54
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 56
       0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
       {0x3f, 0x07}, false, "IndexTableSegmentBase_BodySID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 55
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 57
       0x04, 0x04, 0x04, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0x3f, 0x08}, false, "IndexTableSegmentBase_SliceCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 56
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 58
       0x04, 0x04, 0x04, 0x01, 0x07, 0x00, 0x00, 0x00 },
       {0x3f, 0x0e}, true, "IndexTableSegmentBase_PosTableCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 57
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 59
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x10, 0x01, 0x00 },
       {0}, false, "IndexTableSegment" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 58
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 60
       0x04, 0x04, 0x04, 0x01, 0x06, 0x00, 0x00, 0x00 },
       {0x3f, 0x09}, true, "IndexTableSegment_DeltaEntryArray" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 59
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 61
       0x04, 0x04, 0x04, 0x01, 0x04, 0x00, 0x00, 0x00 },
       {0}, false, "DeltaEntryArray_IndexTableSegment_PosTableIndex" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 60
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 62
       0x04, 0x04, 0x04, 0x01, 0x02, 0x00, 0x00, 0x00 },
       {0}, false, "DeltaEntryArray_IndexTableSegment_Slice" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 61
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 63
       0x04, 0x04, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00 },
       {0}, false, "DeltaEntryArray_IndexTableSegment_ElementDelta" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 62
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 64
       0x04, 0x04, 0x04, 0x02, 0x05, 0x00, 0x00, 0x00 },
       {0x3f, 0x0a}, false, "IndexTableSegment_IndexEntryArray" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 63
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 65
       0x04, 0x04, 0x04, 0x02, 0x03, 0x00, 0x00, 0x00 },
       {0}, false, "IndexEntryArray_IndexTableSegment_TemporalOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 64
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 66
       0x04, 0x04, 0x04, 0x02, 0x04, 0x00, 0x00, 0x00 },
       {0}, false, "IndexEntryArray_IndexTableSegment_AnchorOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 65
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 67
       0x04, 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00 },
       {0}, false, "IndexEntryArray_IndexTableSegment_Flags" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 66
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 68
       0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "IndexEntryArray_IndexTableSegment_StreamOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 67
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 69
       0x04, 0x04, 0x04, 0x01, 0x05, 0x00, 0x00, 0x00 },
       {0}, false, "IndexEntryArray_IndexTableSegment_SliceOffsetArray" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 68
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 70
       0x04, 0x04, 0x04, 0x01, 0x08, 0x00, 0x00, 0x00 },
       {0}, false, "IndexEntryArray_IndexTableSegment_PosTableArray" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 69
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 71
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x11, 0x01, 0x00 },
       {0}, false, "RandomIndexMetadata" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 70
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 72
       0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionArray_RandomIndexMetadata_BodySID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 71
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 73
       0x06, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "PartitionArray_RandomIndexMetadata_ByteOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 72
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 74
       0x04, 0x06, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "RandomIndexMetadata_Length" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 73
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, // 75
       0x0d, 0x01, 0x02, 0x01, 0x01, 0x11, 0x00, 0x00 },
       {0}, false, "RandomIndexMetadataV10" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 74
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 76
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2f, 0x00 },
       {0}, false, "Preface" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 75
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 77
       0x07, 0x02, 0x01, 0x10, 0x02, 0x04, 0x00, 0x00 },
       {0x3b, 0x02}, false, "Preface_LastModifiedDate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 76
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 78
       0x03, 0x01, 0x02, 0x01, 0x05, 0x00, 0x00, 0x00 },
       {0x3b, 0x05}, false, "Preface_Version" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 77
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 79
       0x03, 0x01, 0x02, 0x01, 0x04, 0x00, 0x00, 0x00 },
       {0x3b, 0x07}, true, "Preface_ObjectModelVersion" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 78
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 80
       0x06, 0x01, 0x01, 0x04, 0x01, 0x08, 0x00, 0x00 },
       {0x3b, 0x08}, true, "Preface_PrimaryPackage" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 79
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 81
       0x06, 0x01, 0x01, 0x04, 0x06, 0x04, 0x00, 0x00 },
       {0x3b, 0x06}, false, "Preface_Identifications" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 80
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 82
       0x06, 0x01, 0x01, 0x04, 0x02, 0x01, 0x00, 0x00 },
       {0x3b, 0x03}, false, "Preface_ContentStorage" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 81
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 83
       0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 },
       {0x3b, 0x09}, false, "Preface_OperationalPattern" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 82
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 84
       0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00 },
       {0x3b, 0x0a}, false, "Preface_EssenceContainers" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 83
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 85
       0x01, 0x02, 0x02, 0x10, 0x02, 0x02, 0x00, 0x00 },
       {0x3b, 0x0b}, false, "Preface_DMSchemes" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 84
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 86
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x30, 0x00 },
       {0}, false, "Identification" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 85
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 87
       0x05, 0x20, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0x3c, 0x09}, false, "Identification_ThisGenerationUID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 86
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 88
       0x05, 0x20, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00 },
       {0x3c, 0x01}, false, "Identification_CompanyName" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 87
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 89
       0x05, 0x20, 0x07, 0x01, 0x03, 0x01, 0x00, 0x00 },
       {0x3c, 0x02}, false, "Identification_ProductName" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 88
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 90
       0x05, 0x20, 0x07, 0x01, 0x04, 0x00, 0x00, 0x00 },
       {0x3c, 0x03}, true, "Identification_ProductVersion" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 89
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 91
       0x05, 0x20, 0x07, 0x01, 0x05, 0x01, 0x00, 0x00 },
       {0x3c, 0x04}, false, "Identification_VersionString" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 90
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 92
       0x05, 0x20, 0x07, 0x01, 0x07, 0x00, 0x00, 0x00 },
       {0x3c, 0x05}, false, "Identification_ProductUID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 91
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 93
       0x07, 0x02, 0x01, 0x10, 0x02, 0x03, 0x00, 0x00 },
       {0x3c, 0x06}, false, "Identification_ModificationDate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 92
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 94
       0x05, 0x20, 0x07, 0x01, 0x0a, 0x00, 0x00, 0x00 },
       {0x3c, 0x07}, true, "Identification_ToolkitVersion" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 93
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 95
       0x05, 0x20, 0x07, 0x01, 0x06, 0x01, 0x00, 0x00 },
       {0x3c, 0x08}, true, "Identification_Platform" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 94
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 96
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18, 0x00 },
       {0}, false, "ContentStorage" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 95
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 97
       0x06, 0x01, 0x01, 0x04, 0x05, 0x01, 0x00, 0x00 },
       {0x19, 0x01}, false, "ContentStorage_Packages" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 96
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 98
       0x06, 0x01, 0x01, 0x04, 0x05, 0x02, 0x00, 0x00 },
       {0x19, 0x02}, true, "ContentStorage_EssenceContainerData" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 97
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 99
       0x06, 0x01, 0x01, 0x04, 0x05, 0x00, 0x00, 0x00 },
       {0x19, 0x01}, false, "ContentStorageKludge_V10Packages" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 98
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 100
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x23, 0x00 },
       {0}, false, "EssenceContainerData" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 99
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 101
       0x06, 0x01, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00 },
       {0x27, 0x01}, false, "EssenceContainerData_LinkedPackageUID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 100
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 102
       0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
       {0x3f, 0x06}, true, "EssenceContainerData_IndexSID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 101
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 103
       0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00 },
       {0x3f, 0x07}, false, "EssenceContainerData_BodySID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 102
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 104
       0x01, 0x01, 0x15, 0x10, 0x00, 0x00, 0x00, 0x00 },
       {0x44, 0x01}, false, "GenericPackage_PackageUID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 103
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 105
       0x01, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0x44, 0x02}, true, "GenericPackage_Name" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 104
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 106
       0x07, 0x02, 0x01, 0x10, 0x01, 0x03, 0x00, 0x00 },
       {0x44, 0x05}, false, "GenericPackage_PackageCreationDate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 105
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 107
       0x07, 0x02, 0x01, 0x10, 0x02, 0x05, 0x00, 0x00 },
       {0x44, 0x04}, false, "GenericPackage_PackageModifiedDate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 106
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 108
       0x06, 0x01, 0x01, 0x04, 0x06, 0x05, 0x00, 0x00 },
       {0x44, 0x03}, false, "GenericPackage_Tracks" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 107
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 109
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x32, 0x00 },
       {0}, false, "NetworkLocator" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 108
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 110
       0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0x40, 0x01}, false, "NetworkLocator_URLString" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 109
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 111
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x33, 0x00 },
       {0}, false, "TextLocator" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 110
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 112
       0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0x41, 0x01}, false, "TextLocator_LocatorName" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 111
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 113
       0x01, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0x48, 0x01}, false, "GenericTrack_TrackID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 112
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 114
       0x01, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 },
       {0x48, 0x04}, false, "GenericTrack_TrackNumber" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 113
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 115
       0x01, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0x48, 0x02}, true, "GenericTrack_TrackName" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 114
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 116
       0x06, 0x01, 0x01, 0x04, 0x02, 0x04, 0x00, 0x00 },
       {0x48, 0x03}, false, "GenericTrack_Sequence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 115
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 117
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3a, 0x00 },
       {0}, false, "StaticTrack" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 116
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 118
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3b, 0x00 },
       {0}, false, "Track" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 117
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 119
       0x05, 0x30, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00 },
       {0x4b, 0x01}, false, "Track_EditRate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 118
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 120
       0x07, 0x02, 0x01, 0x03, 0x01, 0x03, 0x00, 0x00 },
       {0x4b, 0x02}, false, "Track_Origin" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 119
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 121
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x39, 0x00 },
       {0}, false, "EventTrack" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 120
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 122
       0x05, 0x30, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x49, 0x01}, false, "EventTrack_EventEditRate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 121
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 123
       0x07, 0x02, 0x01, 0x03, 0x01, 0x0b, 0x00, 0x00 },
       {0x49, 0x02}, true, "EventTrack_EventOrigin" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 122
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 124
       0x04, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 },
       {0x02, 0x01}, false, "StructuralComponent_DataDefinition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 123
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 125
       0x07, 0x02, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00 },
       {0x02, 0x02}, false, "StructuralComponent_Duration" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 124
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 126
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x00 },
       {0}, false, "Sequence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 125
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 127
       0x06, 0x01, 0x01, 0x04, 0x06, 0x09, 0x00, 0x00 },
       {0x10, 0x01}, false, "Sequence_StructuralComponents" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 126
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 128
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x14, 0x00 },
       {0}, false, "TimecodeComponent" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 127
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 129
       0x04, 0x04, 0x01, 0x01, 0x02, 0x06, 0x00, 0x00 },
       {0x15, 0x02}, false, "TimecodeComponent_RoundedTimecodeBase" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 128
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 130
       0x07, 0x02, 0x01, 0x03, 0x01, 0x05, 0x00, 0x00 },
       {0x15, 0x01}, false, "TimecodeComponent_StartTimecode" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 129
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 131
       0x04, 0x04, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00 },
       {0x15, 0x03}, false, "TimecodeComponent_DropFrame" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 130
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 132
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x11, 0x00 },
       {0}, false, "SourceClip" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 131
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 133
       0x07, 0x02, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00 },
       {0x12, 0x01}, false, "SourceClip_StartPosition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 132
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 134
       0x06, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00 },
       {0x11, 0x01}, false, "SourceClip_SourcePackageID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 133
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 135
       0x06, 0x01, 0x01, 0x03, 0x02, 0x00, 0x00, 0x00 },
       {0x11, 0x02}, false, "SourceClip_SourceTrackID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 134
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 136
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x41, 0x00 },
       {0}, false, "DMSegment" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 135
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 137
       0x07, 0x02, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00 },
       {0x06, 0x01}, false, "DMSegment_EventStartPosition" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 136
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 138
       0x05, 0x30, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00 },
       {0x06, 0x02}, true, "DMSegment_EventComment" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 137
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 139
       0x01, 0x07, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00 },
       {0x61, 0x02}, false, "DMSegment_TrackIDs" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 138
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 140
       0x06, 0x01, 0x01, 0x04, 0x02, 0x0c, 0x00, 0x00 },
       {0x61, 0x01}, false, "DMSegment_DMFramework" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 139
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 141
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x45, 0x00 },
       {0}, false, "DMSourceClip" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 140
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 142
       0x01, 0x07, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00 },
       {0x61, 0x03}, true, "DMSourceClip_DMSourceClipTrackIDs" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 141
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 143
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x36, 0x00 },
       {0}, false, "MaterialPackage" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 142
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 144
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x37, 0x00 },
       {0}, false, "SourcePackage" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 143
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 145
       0x06, 0x01, 0x01, 0x04, 0x02, 0x03, 0x00, 0x00 },
       {0x47, 0x01}, false, "SourcePackage_Descriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 144
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 146
       0x06, 0x01, 0x01, 0x04, 0x06, 0x03, 0x00, 0x00 },
       {0x2f, 0x01}, true, "GenericDescriptor_Locators" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 145
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 147
       0x06, 0x01, 0x01, 0x04, 0x06, 0x10, 0x00, 0x00 },
       {0}, true, "GenericDescriptor_SubDescriptors" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 146
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 148
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x25, 0x00 },
       {0}, false, "FileDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 147
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 149
       0x06, 0x01, 0x01, 0x03, 0x05, 0x00, 0x00, 0x00 },
       {0x30, 0x06}, true, "FileDescriptor_LinkedTrackID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 148
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 150
       0x04, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0x30, 0x01}, false, "FileDescriptor_SampleRate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 149
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 151
       0x04, 0x06, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x30, 0x02}, true, "FileDescriptor_ContainerDuration" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 150
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 152
       0x06, 0x01, 0x01, 0x04, 0x01, 0x02, 0x00, 0x00 },
       {0x30, 0x04}, false, "FileDescriptor_EssenceContainer" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 151
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 153
       0x06, 0x01, 0x01, 0x04, 0x01, 0x03, 0x00, 0x00 },
       {0x30, 0x05}, true, "FileDescriptor_Codec" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 152
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 154
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x27, 0x00 },
       {0}, false, "GenericPictureEssenceDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 153
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 155
       0x04, 0x05, 0x01, 0x13, 0x00, 0x00, 0x00, 0x00 },
       {0x32, 0x15}, true, "GenericPictureEssenceDescriptor_SignalStandard" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 154
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 156
       0x04, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00 },
       {0x32, 0x0c}, false, "GenericPictureEssenceDescriptor_FrameLayout" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 155
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 157
       0x04, 0x01, 0x05, 0x02, 0x02, 0x00, 0x00, 0x00 },
       {0x32, 0x03}, false, "GenericPictureEssenceDescriptor_StoredWidth" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 156
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 158
       0x04, 0x01, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0x32, 0x02}, false, "GenericPictureEssenceDescriptor_StoredHeight" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 157
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 159
       0x04, 0x01, 0x03, 0x02, 0x08, 0x00, 0x00, 0x00 },
       {0x32, 0x16}, true, "GenericPictureEssenceDescriptor_StoredF2Offset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 158
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 160
       0x04, 0x01, 0x05, 0x01, 0x08, 0x00, 0x00, 0x00 },
       {0x32, 0x05}, true, "GenericPictureEssenceDescriptor_SampledWidth" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 159
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 161
       0x04, 0x01, 0x05, 0x01, 0x07, 0x00, 0x00, 0x00 },
       {0x32, 0x04}, true, "GenericPictureEssenceDescriptor_SampledHeight" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 160
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 162
       0x04, 0x01, 0x05, 0x01, 0x09, 0x00, 0x00, 0x00 },
       {0x32, 0x06}, true, "GenericPictureEssenceDescriptor_SampledXOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 161
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 163
       0x04, 0x01, 0x05, 0x01, 0x0a, 0x00, 0x00, 0x00 },
       {0x32, 0x07}, true, "GenericPictureEssenceDescriptor_SampledYOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 162
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 164
       0x04, 0x01, 0x05, 0x01, 0x0b, 0x00, 0x00, 0x00 },
       {0x32, 0x08}, true, "GenericPictureEssenceDescriptor_DisplayHeight" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 163
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 165
       0x04, 0x01, 0x05, 0x01, 0x0c, 0x00, 0x00, 0x00 },
       {0x32, 0x09}, true, "GenericPictureEssenceDescriptor_DisplayWidth" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 164
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 166
       0x04, 0x01, 0x05, 0x01, 0x0d, 0x00, 0x00, 0x00 },
       {0x32, 0x0a}, true, "GenericPictureEssenceDescriptor_DisplayXOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 165
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 167
       0x04, 0x01, 0x05, 0x01, 0x0e, 0x00, 0x00, 0x00 },
       {0x32, 0x0b}, true, "GenericPictureEssenceDescriptor_DisplayYOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 166
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 168
       0x04, 0x01, 0x03, 0x02, 0x07, 0x00, 0x00, 0x00 },
       {0x32, 0x17}, true, "GenericPictureEssenceDescriptor_DisplayF2Offset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 167
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 169
       0x04, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0x32, 0x0e}, false, "GenericPictureEssenceDescriptor_AspectRatio" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 168
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 170
       0x04, 0x01, 0x03, 0x02, 0x09, 0x00, 0x00, 0x00 },
       {0x32, 0x18}, true, "GenericPictureEssenceDescriptor_ActiveFormatDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 169
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 171
       0x04, 0x01, 0x03, 0x02, 0x05, 0x00, 0x00, 0x00 },
       {0x32, 0x0d}, false, "GenericPictureEssenceDescriptor_VideoLineMap" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 170
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 172
       0x05, 0x20, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x32, 0x0f}, true, "GenericPictureEssenceDescriptor_AlphaTransparency" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 171
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 173
       0x04, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x00 },
       {0x32, 0x10}, true, "GenericPictureEssenceDescriptor_Gamma" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 172
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 174
       0x04, 0x18, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0x32, 0x11}, true, "GenericPictureEssenceDescriptor_ImageAlignmentOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 173
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 175
       0x04, 0x18, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x32, 0x13}, true, "GenericPictureEssenceDescriptor_ImageStartOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 174
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 176
       0x04, 0x18, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 },
       {0x32, 0x14}, true, "GenericPictureEssenceDescriptor_ImageEndOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 175
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 177
       0x04, 0x01, 0x03, 0x01, 0x06, 0x00, 0x00, 0x00 },
       {0x32, 0x12}, true, "GenericPictureEssenceDescriptor_FieldDominance" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 176
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 178
       0x04, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0x32, 0x01}, false, "GenericPictureEssenceDescriptor_PictureEssenceCoding" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 177
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 179
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x28, 0x00 },
       {0}, false, "CDCIEssenceDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 178
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 180
       0x04, 0x01, 0x05, 0x03, 0x0a, 0x00, 0x00, 0x00 },
       {0x33, 0x01}, false, "CDCIEssenceDescriptor_ComponentDepth" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 179
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 181
       0x04, 0x01, 0x05, 0x01, 0x05, 0x00, 0x00, 0x00 },
       {0x33, 0x02}, false, "CDCIEssenceDescriptor_HorizontalSubsampling" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 180
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 182
       0x04, 0x01, 0x05, 0x01, 0x10, 0x00, 0x00, 0x00 },
       {0x33, 0x08}, true, "CDCIEssenceDescriptor_VerticalSubsampling" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 181
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 183
       0x04, 0x01, 0x05, 0x01, 0x06, 0x00, 0x00, 0x00 },
       {0x33, 0x03}, true, "CDCIEssenceDescriptor_ColorSiting" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 182
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 184
       0x03, 0x01, 0x02, 0x01, 0x0a, 0x00, 0x00, 0x00 },
       {0x33, 0x0b}, true, "CDCIEssenceDescriptor_ReversedByteOrder" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 183
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 185
       0x04, 0x18, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00 },
       {0x33, 0x07}, true, "CDCIEssenceDescriptor_PaddingBits" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 184
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 186
       0x04, 0x01, 0x05, 0x03, 0x07, 0x00, 0x00, 0x00 },
       {0x33, 0x09}, true, "CDCIEssenceDescriptor_AlphaSampleDepth" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 185
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 187
       0x04, 0x01, 0x05, 0x03, 0x03, 0x00, 0x00, 0x00 },
       {0x33, 0x04}, true, "CDCIEssenceDescriptor_BlackRefLevel" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 186
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 188
       0x04, 0x01, 0x05, 0x03, 0x04, 0x00, 0x00, 0x00 },
       {0x33, 0x05}, true, "CDCIEssenceDescriptor_WhiteReflevel" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 187
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 189
       0x04, 0x01, 0x05, 0x03, 0x05, 0x00, 0x00, 0x00 },
       {0x33, 0x06}, true, "CDCIEssenceDescriptor_ColorRange" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 188
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 190
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x29, 0x00 },
       {0}, false, "RGBAEssenceDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 189
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 191
       0x04, 0x01, 0x05, 0x03, 0x0b, 0x00, 0x00, 0x00 },
       {0x34, 0x06}, true, "RGBAEssenceDescriptor_ComponentMaxRef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 190
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 192
       0x04, 0x01, 0x05, 0x03, 0x0c, 0x00, 0x00, 0x00 },
       {0x34, 0x07}, true, "RGBAEssenceDescriptor_ComponentMinRef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 191
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 193
       0x04, 0x01, 0x05, 0x03, 0x0d, 0x00, 0x00, 0x00 },
       {0x34, 0x08}, true, "RGBAEssenceDescriptor_AlphaMaxRef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 192
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 194
       0x04, 0x01, 0x05, 0x03, 0x0e, 0x00, 0x00, 0x00 },
       {0x34, 0x09}, true, "RGBAEssenceDescriptor_AlphaMinRef" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 193
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 195
       0x04, 0x01, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00 },
       {0x34, 0x05}, true, "RGBAEssenceDescriptor_ScanningDirection" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 194
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 196
       0x04, 0x01, 0x05, 0x03, 0x06, 0x00, 0x00, 0x00 },
       {0x34, 0x01}, false, "RGBAEssenceDescriptor_PixelLayout" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 195
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 197
       0x04, 0x01, 0x05, 0x03, 0x08, 0x00, 0x00, 0x00 },
       {0x34, 0x03}, true, "RGBAEssenceDescriptor_Palette" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 196
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 198
       0x04, 0x01, 0x05, 0x03, 0x09, 0x00, 0x00, 0x00 },
       {0x34, 0x04}, true, "RGBAEssenceDescriptor_PaletteLayout" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 197
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 199
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x42, 0x00 },
       {0}, false, "GenericSoundEssenceDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 198
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 200
       0x04, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00 },
       {0x3d, 0x03}, false, "GenericSoundEssenceDescriptor_AudioSamplingRate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 199
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 201
       0x04, 0x02, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00 },
       {0x3d, 0x02}, false, "GenericSoundEssenceDescriptor_Locked" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 200
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 202
       0x04, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00 },
       {0x3d, 0x04}, true, "GenericSoundEssenceDescriptor_AudioRefLevel" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 201
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, // 203
       0x04, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0x3d, 0x05}, true, "GenericSoundEssenceDescriptor_ElectroSpatialFormulation" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 202
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 204
       0x04, 0x02, 0x01, 0x01, 0x04, 0x00, 0x00, 0x00 },
       {0x3d, 0x07}, false, "GenericSoundEssenceDescriptor_ChannelCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 203
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 205
       0x04, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00 },
       {0x3d, 0x01}, false, "GenericSoundEssenceDescriptor_QuantizationBits" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 204
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 206
       0x04, 0x02, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0x3d, 0x0c}, true, "GenericSoundEssenceDescriptor_DialNorm" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 205
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, // 207
       0x04, 0x02, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x3d, 0x06}, false, "GenericSoundEssenceDescriptor_SoundEssenceCompression" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 206
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 208
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x43, 0x00 },
       {0}, false, "GenericDataEssenceDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 207
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 209
       0x04, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00 },
       {0x3e, 0x01}, false, "GenericDataEssenceDescriptor_DataEssenceCoding" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 208
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 210
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x44, 0x00 },
       {0}, false, "MultipleDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 209
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, // 211
       0x06, 0x01, 0x01, 0x04, 0x06, 0x0b, 0x00, 0x00 },
       {0x3f, 0x01}, false, "MultipleDescriptor_SubDescriptorUIDs" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 210
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 212
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x51, 0x00 },
       {0}, false, "MPEG2VideoDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 211
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 213
       0x04, 0x01, 0x06, 0x02, 0x01, 0x02, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_SingleSequence" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 212
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 214
       0x04, 0x01, 0x06, 0x02, 0x01, 0x03, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_ConstantBFrames" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 213
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 215
       0x04, 0x01, 0x06, 0x02, 0x01, 0x04, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_CodedContentType" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 214
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 216
       0x04, 0x01, 0x06, 0x02, 0x01, 0x05, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_LowDelay" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 215
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 217
       0x04, 0x01, 0x06, 0x02, 0x01, 0x06, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_ClosedGOP" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 216
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 218
       0x04, 0x01, 0x06, 0x02, 0x01, 0x07, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_IdenticalGOP" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 217
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 219
       0x04, 0x01, 0x06, 0x02, 0x01, 0x08, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_MaxGOP" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 218
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 220
       0x04, 0x01, 0x06, 0x02, 0x01, 0x09, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_BPictureCount" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 219
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 221
       0x04, 0x01, 0x06, 0x02, 0x01, 0x0b, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_BitRate" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 220
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 222
       0x04, 0x01, 0x06, 0x02, 0x01, 0x0a, 0x00, 0x00 },
       {0}, true, "MPEG2VideoDescriptor_ProfileAndLevel" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 221
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 223
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x48, 0x00 },
       {0}, false, "WaveAudioDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 222
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 224
       0x04, 0x02, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0x3d, 0x0a}, false, "WaveAudioDescriptor_BlockAlign" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 223
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 225
       0x04, 0x02, 0x03, 0x02, 0x02, 0x00, 0x00, 0x00 },
       {0x3d, 0x0b}, true, "WaveAudioDescriptor_SequenceOffset" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 224
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 226
       0x04, 0x02, 0x03, 0x03, 0x05, 0x00, 0x00, 0x00 },
       {0x3d, 0x09}, false, "WaveAudioDescriptor_AvgBps" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 225
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, // 227
       0x04, 0x02, 0x03, 0x01, 0x0e, 0x00, 0x00, 0x00 },
       {0x3d, 0x0e}, true, "WaveAudioDescriptor_PeakEnvelope" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 226
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 228
       0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x5a, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 227
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 229
       0x04, 0x01, 0x06, 0x03, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_Rsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 228
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 230
       0x04, 0x01, 0x06, 0x03, 0x02, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_Xsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 229
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 231
       0x04, 0x01, 0x06, 0x03, 0x03, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_Ysize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 230
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 232
       0x04, 0x01, 0x06, 0x03, 0x04, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_XOsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 231
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 233
       0x04, 0x01, 0x06, 0x03, 0x05, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_YOsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 232
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 234
       0x04, 0x01, 0x06, 0x03, 0x06, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_XTsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 233
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 235
       0x04, 0x01, 0x06, 0x03, 0x07, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_YTsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 234
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 236
       0x04, 0x01, 0x06, 0x03, 0x08, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_XTOsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 235
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 237
       0x04, 0x01, 0x06, 0x03, 0x09, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_YTOsize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 236
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 238
       0x04, 0x01, 0x06, 0x03, 0x0a, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_Csize" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 237
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 239
       0x04, 0x01, 0x06, 0x03, 0x0b, 0x00, 0x00, 0x00 },
       {0}, false, "JPEG2000PictureSubDescriptor_PictureComponentSizing" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 238
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 240
       0x04, 0x01, 0x06, 0x03, 0x0c, 0x00, 0x00, 0x00 },
       {0}, true, "JPEG2000PictureSubDescriptor_CodingStyleDefault" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 239
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0a, // 241
       0x04, 0x01, 0x06, 0x03, 0x0d, 0x00, 0x00, 0x00 },
       {0}, true, "JPEG2000PictureSubDescriptor_QuantizationDefault" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 240
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 242
       0x0d, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "DM_Framework" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 241
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 243
       0x0d, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "DM_Set" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 242
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 244
       0x0d, 0x01, 0x03, 0x01, 0x02, 0x0b, 0x01, 0x00 },
       {0}, false, "EncryptedContainerLabel" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 243
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x07, // 245
       0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x01, 0x00 },
       {0}, false, "CryptographicFrameworkLabel" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 244
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 246
       0x0d, 0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00 },
       {0}, false, "CryptographicFramework" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 245
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 247
       0x06, 0x01, 0x01, 0x04, 0x02, 0x0d, 0x00, 0x00 },
       {0}, false, "CryptographicFramework_ContextSR" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 246
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 248
       0x0d, 0x01, 0x04, 0x01, 0x02, 0x02, 0x00, 0x00 },
       {0}, false, "CryptographicContext" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 247
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 249
       0x01, 0x01, 0x15, 0x11, 0x00, 0x00, 0x00, 0x00 },
       {0}, false, "CryptographicContext_ContextID" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 248
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 250
       0x06, 0x01, 0x01, 0x02, 0x02, 0x00, 0x00, 0x00 },
       {0}, false, "CryptographicContext_SourceEssenceContainer" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 249
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 251
       0x02, 0x09, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "CryptographicContext_CipherAlgorithm" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 250
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 252
       0x02, 0x09, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00 },
       {0}, false, "CryptographicContext_MICAlgorithm" },
-  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 251
+  { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x09, // 253
       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;
+const ui32_t s_MDD_Table_size = 254;
 
 //
 // end MDD.cpp

diff --git a/src/MDD.h b/src/MDD.h
index ac65bf5c465d42238680503f251303f6daa90e01..69214a465877133ec82ff2b79e66fd468e78b446 100755 (executable)
--- a/src/MDD.h
+++ b/src/MDD.h
@@ -36,268 +36,259 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace ASDCP {
     enum MDD_t {
         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
+        MDD_MXFInterop_OPAtom,  // 1
+        MDD_OPAtom,  // 2
+        MDD_OP1a,  // 3
+        MDD_GCMulti,  // 4
+        MDD_PictureDataDef,  // 5
+        MDD_SoundDataDef,  // 6
+        MDD_TimecodeDataDef,  // 7
+        MDD_DescriptiveMetaDataDef,  // 8
+        MDD_WAVWrapping,  // 9
+        MDD_MPEG2_VESWrapping,  // 10
+        MDD_JPEG_2000Wrapping,  // 11
+        MDD_JPEG2000Essence,  // 12
+        MDD_MPEG2Essence,  // 13
+        MDD_MXFInterop_CryptEssence,  // 14
+        MDD_CryptEssence,  // 15
+        MDD_WAVEssence,  // 16
+        MDD_JP2KEssenceCompression,  // 17
+        MDD_CipherAlgorithm_AES,  // 18
+        MDD_MICAlgorithm_HMAC_SHA1,  // 19
+        MDD_KLVFill,  // 20
+        MDD_PartitionMetadata_MajorVersion,  // 21
+        MDD_PartitionMetadata_MinorVersion,  // 22
+        MDD_PartitionMetadata_KAGSize,  // 23
+        MDD_PartitionMetadata_ThisPartition,  // 24
+        MDD_PartitionMetadata_PreviousPartition,  // 25
+        MDD_PartitionMetadata_FooterPartition,  // 26
+        MDD_PartitionMetadata_HeaderByteCount,  // 27
+        MDD_PartitionMetadata_IndexByteCount,  // 28
+        MDD_PartitionMetadata_IndexSID,  // 29
+        MDD_PartitionMetadata_BodyOffset,  // 30
+        MDD_PartitionMetadata_BodySID,  // 31
+        MDD_PartitionMetadata_OperationalPattern,  // 32
+        MDD_PartitionMetadata_EssenceContainers,  // 33
+        MDD_OpenHeader,  // 34
+        MDD_OpenCompleteHeader,  // 35
+        MDD_ClosedHeader,  // 36
+        MDD_ClosedCompleteHeader,  // 37
+        MDD_OpenBodyPartition,  // 38
+        MDD_OpenCompleteBodyPartition,  // 39
+        MDD_ClosedBodyPartition,  // 40
+        MDD_ClosedCompleteBodyPartition,  // 41
+        MDD_Footer,  // 42
+        MDD_CompleteFooter,  // 43
+        MDD_Primer,  // 44
+        MDD_Primer_LocalTagEntryBatch,  // 45
+        MDD_LocalTagEntryBatch_Primer_LocalTag,  // 46
+        MDD_LocalTagEntryBatch_Primer_UID,  // 47
+        MDD_InterchangeObject_InstanceUID,  // 48
+        MDD_GenerationInterchangeObject_GenerationUID,  // 49
+        MDD_DefaultObject,  // 50
+        MDD_IndexTableSegmentBase_IndexEditRate,  // 51
+        MDD_IndexTableSegmentBase_IndexStartPosition,  // 52
+        MDD_IndexTableSegmentBase_IndexDuration,  // 53
+        MDD_IndexTableSegmentBase_EditUnitByteCount,  // 54
+        MDD_IndexTableSegmentBase_IndexSID,  // 55
+        MDD_IndexTableSegmentBase_BodySID,  // 56
+        MDD_IndexTableSegmentBase_SliceCount,  // 57
+        MDD_IndexTableSegmentBase_PosTableCount,  // 58
+        MDD_IndexTableSegment,  // 59
+        MDD_IndexTableSegment_DeltaEntryArray,  // 60
+        MDD_DeltaEntryArray_IndexTableSegment_PosTableIndex,  // 61
+        MDD_DeltaEntryArray_IndexTableSegment_Slice,  // 62
+        MDD_DeltaEntryArray_IndexTableSegment_ElementDelta,  // 63
+        MDD_IndexTableSegment_IndexEntryArray,  // 64
+        MDD_IndexEntryArray_IndexTableSegment_TemporalOffset,  // 65
+        MDD_IndexEntryArray_IndexTableSegment_AnchorOffset,  // 66
+        MDD_IndexEntryArray_IndexTableSegment_Flags,  // 67
+        MDD_IndexEntryArray_IndexTableSegment_StreamOffset,  // 68
+        MDD_IndexEntryArray_IndexTableSegment_SliceOffsetArray,  // 69
+        MDD_IndexEntryArray_IndexTableSegment_PosTableArray,  // 70
+        MDD_RandomIndexMetadata,  // 71
+        MDD_PartitionArray_RandomIndexMetadata_BodySID,  // 72
+        MDD_PartitionArray_RandomIndexMetadata_ByteOffset,  // 73
+        MDD_RandomIndexMetadata_Length,  // 74
+        MDD_RandomIndexMetadataV10,  // 75
+        MDD_Preface,  // 76
+        MDD_Preface_LastModifiedDate,  // 77
+        MDD_Preface_Version,  // 78
+        MDD_Preface_ObjectModelVersion,  // 79
+        MDD_Preface_PrimaryPackage,  // 80
+        MDD_Preface_Identifications,  // 81
+        MDD_Preface_ContentStorage,  // 82
+        MDD_Preface_OperationalPattern,  // 83
+        MDD_Preface_EssenceContainers,  // 84
+        MDD_Preface_DMSchemes,  // 85
+        MDD_Identification,  // 86
+        MDD_Identification_ThisGenerationUID,  // 87
+        MDD_Identification_CompanyName,  // 88
+        MDD_Identification_ProductName,  // 89
+        MDD_Identification_ProductVersion,  // 90
+        MDD_Identification_VersionString,  // 91
+        MDD_Identification_ProductUID,  // 92
+        MDD_Identification_ModificationDate,  // 93
+        MDD_Identification_ToolkitVersion,  // 94
+        MDD_Identification_Platform,  // 95
+        MDD_ContentStorage,  // 96
+        MDD_ContentStorage_Packages,  // 97
+        MDD_ContentStorage_EssenceContainerData,  // 98
+        MDD_ContentStorageKludge_V10Packages,  // 99
+        MDD_EssenceContainerData,  // 100
+        MDD_EssenceContainerData_LinkedPackageUID,  // 101
+        MDD_EssenceContainerData_IndexSID,  // 102
+        MDD_EssenceContainerData_BodySID,  // 103
+        MDD_GenericPackage_PackageUID,  // 104
+        MDD_GenericPackage_Name,  // 105
+        MDD_GenericPackage_PackageCreationDate,  // 106
+        MDD_GenericPackage_PackageModifiedDate,  // 107
+        MDD_GenericPackage_Tracks,  // 108
+        MDD_NetworkLocator,  // 109
+        MDD_NetworkLocator_URLString,  // 110
+        MDD_TextLocator,  // 111
+        MDD_TextLocator_LocatorName,  // 112
+        MDD_GenericTrack_TrackID,  // 113
+        MDD_GenericTrack_TrackNumber,  // 114
+        MDD_GenericTrack_TrackName,  // 115
+        MDD_GenericTrack_Sequence,  // 116
+        MDD_StaticTrack,  // 117
+        MDD_Track,  // 118
+        MDD_Track_EditRate,  // 119
+        MDD_Track_Origin,  // 120
+        MDD_EventTrack,  // 121
+        MDD_EventTrack_EventEditRate,  // 122
+        MDD_EventTrack_EventOrigin,  // 123
+        MDD_StructuralComponent_DataDefinition,  // 124
+        MDD_StructuralComponent_Duration,  // 125
+        MDD_Sequence,  // 126
+        MDD_Sequence_StructuralComponents,  // 127
+        MDD_TimecodeComponent,  // 128
+        MDD_TimecodeComponent_RoundedTimecodeBase,  // 129
+        MDD_TimecodeComponent_StartTimecode,  // 130
+        MDD_TimecodeComponent_DropFrame,  // 131
+        MDD_SourceClip,  // 132
+        MDD_SourceClip_StartPosition,  // 133
+        MDD_SourceClip_SourcePackageID,  // 134
+        MDD_SourceClip_SourceTrackID,  // 135
+        MDD_DMSegment,  // 136
+        MDD_DMSegment_EventStartPosition,  // 137
+        MDD_DMSegment_EventComment,  // 138
+        MDD_DMSegment_TrackIDs,  // 139
+        MDD_DMSegment_DMFramework,  // 140
+        MDD_DMSourceClip,  // 141
+        MDD_DMSourceClip_DMSourceClipTrackIDs,  // 142
+        MDD_MaterialPackage,  // 143
+        MDD_SourcePackage,  // 144
+        MDD_SourcePackage_Descriptor,  // 145
+        MDD_GenericDescriptor_Locators,  // 146
+        MDD_GenericDescriptor_SubDescriptors,  // 147
+        MDD_FileDescriptor,  // 148
+        MDD_FileDescriptor_LinkedTrackID,  // 149
+        MDD_FileDescriptor_SampleRate,  // 150
+        MDD_FileDescriptor_ContainerDuration,  // 151
+        MDD_FileDescriptor_EssenceContainer,  // 152
+        MDD_FileDescriptor_Codec,  // 153
+        MDD_GenericPictureEssenceDescriptor,  // 154
+        MDD_GenericPictureEssenceDescriptor_SignalStandard,  // 155
+        MDD_GenericPictureEssenceDescriptor_FrameLayout,  // 156
+        MDD_GenericPictureEssenceDescriptor_StoredWidth,  // 157
+        MDD_GenericPictureEssenceDescriptor_StoredHeight,  // 158
+        MDD_GenericPictureEssenceDescriptor_StoredF2Offset,  // 159
+        MDD_GenericPictureEssenceDescriptor_SampledWidth,  // 160
+        MDD_GenericPictureEssenceDescriptor_SampledHeight,  // 161
+        MDD_GenericPictureEssenceDescriptor_SampledXOffset,  // 162
+        MDD_GenericPictureEssenceDescriptor_SampledYOffset,  // 163
+        MDD_GenericPictureEssenceDescriptor_DisplayHeight,  // 164
+        MDD_GenericPictureEssenceDescriptor_DisplayWidth,  // 165
+        MDD_GenericPictureEssenceDescriptor_DisplayXOffset,  // 166
+        MDD_GenericPictureEssenceDescriptor_DisplayYOffset,  // 167
+        MDD_GenericPictureEssenceDescriptor_DisplayF2Offset,  // 168
+        MDD_GenericPictureEssenceDescriptor_AspectRatio,  // 169
+        MDD_GenericPictureEssenceDescriptor_ActiveFormatDescriptor,  // 170
+        MDD_GenericPictureEssenceDescriptor_VideoLineMap,  // 171
+        MDD_GenericPictureEssenceDescriptor_AlphaTransparency,  // 172
+        MDD_GenericPictureEssenceDescriptor_Gamma,  // 173
+        MDD_GenericPictureEssenceDescriptor_ImageAlignmentOffset,  // 174
+        MDD_GenericPictureEssenceDescriptor_ImageStartOffset,  // 175
+        MDD_GenericPictureEssenceDescriptor_ImageEndOffset,  // 176
+        MDD_GenericPictureEssenceDescriptor_FieldDominance,  // 177
+        MDD_GenericPictureEssenceDescriptor_PictureEssenceCoding,  // 178
+        MDD_CDCIEssenceDescriptor,  // 179
+        MDD_CDCIEssenceDescriptor_ComponentDepth,  // 180
+        MDD_CDCIEssenceDescriptor_HorizontalSubsampling,  // 181
+        MDD_CDCIEssenceDescriptor_VerticalSubsampling,  // 182
+        MDD_CDCIEssenceDescriptor_ColorSiting,  // 183
+        MDD_CDCIEssenceDescriptor_ReversedByteOrder,  // 184
+        MDD_CDCIEssenceDescriptor_PaddingBits,  // 185
+        MDD_CDCIEssenceDescriptor_AlphaSampleDepth,  // 186
+        MDD_CDCIEssenceDescriptor_BlackRefLevel,  // 187
+        MDD_CDCIEssenceDescriptor_WhiteReflevel,  // 188
+        MDD_CDCIEssenceDescriptor_ColorRange,  // 189
+        MDD_RGBAEssenceDescriptor,  // 190
+        MDD_RGBAEssenceDescriptor_ComponentMaxRef,  // 191
+        MDD_RGBAEssenceDescriptor_ComponentMinRef,  // 192
+        MDD_RGBAEssenceDescriptor_AlphaMaxRef,  // 193
+        MDD_RGBAEssenceDescriptor_AlphaMinRef,  // 194
+        MDD_RGBAEssenceDescriptor_ScanningDirection,  // 195
+        MDD_RGBAEssenceDescriptor_PixelLayout,  // 196
+        MDD_RGBAEssenceDescriptor_Palette,  // 197
+        MDD_RGBAEssenceDescriptor_PaletteLayout,  // 198
+        MDD_GenericSoundEssenceDescriptor,  // 199
+        MDD_GenericSoundEssenceDescriptor_AudioSamplingRate,  // 200
+        MDD_GenericSoundEssenceDescriptor_Locked,  // 201
+        MDD_GenericSoundEssenceDescriptor_AudioRefLevel,  // 202
+        MDD_GenericSoundEssenceDescriptor_ElectroSpatialFormulation,  // 203
+        MDD_GenericSoundEssenceDescriptor_ChannelCount,  // 204
+        MDD_GenericSoundEssenceDescriptor_QuantizationBits,  // 205
+        MDD_GenericSoundEssenceDescriptor_DialNorm,  // 206
+        MDD_GenericSoundEssenceDescriptor_SoundEssenceCompression,  // 207
+        MDD_GenericDataEssenceDescriptor,  // 208
+        MDD_GenericDataEssenceDescriptor_DataEssenceCoding,  // 209
+        MDD_MultipleDescriptor,  // 210
+        MDD_MultipleDescriptor_SubDescriptorUIDs,  // 211
+        MDD_MPEG2VideoDescriptor,  // 212
+        MDD_MPEG2VideoDescriptor_SingleSequence,  // 213
+        MDD_MPEG2VideoDescriptor_ConstantBFrames,  // 214
+        MDD_MPEG2VideoDescriptor_CodedContentType,  // 215
+        MDD_MPEG2VideoDescriptor_LowDelay,  // 216
+        MDD_MPEG2VideoDescriptor_ClosedGOP,  // 217
+        MDD_MPEG2VideoDescriptor_IdenticalGOP,  // 218
+        MDD_MPEG2VideoDescriptor_MaxGOP,  // 219
+        MDD_MPEG2VideoDescriptor_BPictureCount,  // 220
+        MDD_MPEG2VideoDescriptor_BitRate,  // 221
+        MDD_MPEG2VideoDescriptor_ProfileAndLevel,  // 222
+        MDD_WaveAudioDescriptor,  // 223
+        MDD_WaveAudioDescriptor_BlockAlign,  // 224
+        MDD_WaveAudioDescriptor_SequenceOffset,  // 225
+        MDD_WaveAudioDescriptor_AvgBps,  // 226
+        MDD_WaveAudioDescriptor_PeakEnvelope,  // 227
+        MDD_JPEG2000PictureSubDescriptor,  // 228
+        MDD_JPEG2000PictureSubDescriptor_Rsize,  // 229
+        MDD_JPEG2000PictureSubDescriptor_Xsize,  // 230
+        MDD_JPEG2000PictureSubDescriptor_Ysize,  // 231
+        MDD_JPEG2000PictureSubDescriptor_XOsize,  // 232
+        MDD_JPEG2000PictureSubDescriptor_YOsize,  // 233
+        MDD_JPEG2000PictureSubDescriptor_XTsize,  // 234
+        MDD_JPEG2000PictureSubDescriptor_YTsize,  // 235
+        MDD_JPEG2000PictureSubDescriptor_XTOsize,  // 236
+        MDD_JPEG2000PictureSubDescriptor_YTOsize,  // 237
+        MDD_JPEG2000PictureSubDescriptor_Csize,  // 238
+        MDD_JPEG2000PictureSubDescriptor_PictureComponentSizing,  // 239
+        MDD_JPEG2000PictureSubDescriptor_CodingStyleDefault,  // 240
+        MDD_JPEG2000PictureSubDescriptor_QuantizationDefault,  // 241
+        MDD_DM_Framework,  // 242
+        MDD_DM_Set,  // 243
+        MDD_EncryptedContainerLabel,  // 244
+        MDD_CryptographicFrameworkLabel,  // 245
+        MDD_CryptographicFramework,  // 246
+        MDD_CryptographicFramework_ContextSR,  // 247
+        MDD_CryptographicContext,  // 248
+        MDD_CryptographicContext_ContextID,  // 249
+        MDD_CryptographicContext_SourceEssenceContainer,  // 250
+        MDD_CryptographicContext_CipherAlgorithm,  // 251
+        MDD_CryptographicContext_MICAlgorithm,  // 252
+        MDD_CryptographicContext_CryptographicKeyID,  // 253
     }; // enum MDD_t
 } // namespaceASDCP
 

diff --git a/src/MXF.cpp b/src/MXF.cpp
index d5585d3a96fa304bdba6c4a23cf1f32505f8f690..413513cd84871f407e38622385b4756f121a67ca 100755 (executable)
--- a/src/MXF.cpp
+++ b/src/MXF.cpp
@@ -639,15 +639,16 @@ ASDCP::MXF::OPAtomHeader::InitFromFile(const ASDCP::FileReader& Reader)
 
   // is it really OP-Atom?
   UL OPAtomUL(Dict::ul(MDD_OPAtom));
+  UL InteropOPAtomUL(Dict::ul(MDD_MXFInterop_OPAtom));
 
-  if ( ! ( OperationalPattern == OPAtomUL ) )
+  if ( ! ( OperationalPattern == OPAtomUL  || OperationalPattern == InteropOPAtomUL ) )
     {
       char strbuf[IntBufferLen];
-      const MDDEntry* Entry = Dict::FindUL(m_KeyStart);
+      const MDDEntry* Entry = Dict::FindUL(OperationalPattern.Value());
       if ( Entry == 0 )
-       DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s.\n", OperationalPattern.ToString(strbuf));
+       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);
+       DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", Entry->name);
     }
 
   // slurp up the remainder of the header

diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp
index ec4f2d75ba24fd755f52f73fda6cb21ed63e25fc..111d493bbed1e64afd5c810bdc93c15c232666e0 100755 (executable)
--- a/src/MXFTypes.cpp
+++ b/src/MXFTypes.cpp
@@ -118,7 +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;
+  m_HasValue = true;
 }
 
 

diff --git a/src/MXFTypes.h b/src/MXFTypes.h
index 0a6ea72b47f430339dcbfa252a89cca4b2f1eb7e..6c524633058ecfbcfaac70ecd23a5e184718c4a9 100755 (executable)
--- a/src/MXFTypes.h
+++ b/src/MXFTypes.h
@@ -291,7 +291,7 @@ namespace ASDCP
          }
 
          Result_t Unarchive(ASDCP::MemIOReader& Reader);
-         inline bool HasValue() const { return true; }
+         inline bool HasValue() const { return m_length > 0; }
          Result_t Archive(ASDCP::MemIOWriter& Writer) const;
        };
 
@@ -411,7 +411,7 @@ namespace ASDCP
 
          //
           Result_t    Unarchive(ASDCP::MemIOReader& Reader);
-         inline bool HasValue() const { return true; }
+         inline bool HasValue() const { return Size() > 0; }
          Result_t    Archive(ASDCP::MemIOWriter& Writer) const;
          const char* ToString(char* str_buf) const;
        };

diff --git a/src/PCM_Parser.cpp b/src/PCM_Parser.cpp
index 9262de7d68de6b881cf921e11029c3aef4e7cfb0..331bebfc86b25bdf539811fce4f5eb1e68302465 100755 (executable)
--- a/src/PCM_Parser.cpp
+++ b/src/PCM_Parser.cpp
@@ -128,8 +128,6 @@ ASDCP::PCM::WAVParser::h__WAVParser::OpenRead(const char* filename, const Ration
        }
     }
 
-  AudioDescriptorDump(m_ADesc);
-
   return result;
 }
 

diff --git a/src/asdcp-test.cpp b/src/asdcp-test.cpp
index 83fbb15649bb16a19d3dd5b45daa1f4c20867f4f..c048a3069347406c6b397bd1a965132617052d65 100755 (executable)
--- a/src/asdcp-test.cpp
+++ b/src/asdcp-test.cpp
@@ -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
@@ -164,6 +164,7 @@ Read/Write Options:\n\
   -f <frame-num>  - starting frame number, default 0\n\
   -d <duration>   - number of frames to process, default all\n\
   -p <rate>       - fps of picture when wrapping PCM or JP2K:, use one of [23|24|48], 24 is default\n\
+  -L              - Write SMPTE UL values instead of MXF Interop\n\
   -R              - Repeat the first frame over the entire file (picture essence only, requires -c, -d)\n\
   -S              - Split Wave essence to stereo WAV files during extract (default = multichannel WAV)\n\
   -W              - read input file only, do not write source file\n\
@@ -215,6 +216,7 @@ public:
   ui32_t duration;       // number of frames to be processed
   bool   duration_flag;  // true if duration argument given
   bool   do_repeat;      // if true and -c -d, repeat first input frame
+  bool   use_smpte_labels; // if true, SMPTE UL values will be written instead of MXF Interop values
   ui32_t picture_rate;   // fps of picture when wrapping PCM
   ui32_t fb_size;        // size of picture frame buffer
   ui32_t file_count;     // number of elements in filenames[]
@@ -248,8 +250,8 @@ public:
     write_hmac(true), read_hmac(false), split_wav(false),
     verbose_flag(false), fb_dump_size(0), showindex_flag(false), showheader_flag(false),
     no_write_flag(false), version_flag(false), help_flag(false), start_frame(0),
-    duration(0xffffffff), duration_flag(false), do_repeat(false), picture_rate(24),
-    fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0)
+    duration(0xffffffff), duration_flag(false), do_repeat(false), use_smpte_labels(false),
+    picture_rate(24), fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0)
   {
     memset(key_value, 0, KeyLen);
     memset(key_id_value, 0, UUIDlen);
@@ -276,6 +278,7 @@ public:
              case 'E': encrypt_header_flag = false; break;
              case 'M': write_hmac = false; break;
              case 'm': read_hmac = true; break;
+             case 'L': use_smpte_labels = true; break;
 
              case 'c':
                TEST_SET_MAJOR_MODE(create_flag);
@@ -423,6 +426,12 @@ write_MPEG2_file(CommandOptions& Options)
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
       GenRandomUUID(RNG, Info.AssetUUID);
 
+      if ( Options.use_smpte_labels )
+       {
+         Info.LabelSetType = LS_MXF_INTEROP;
+         fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+       }
+
       // configure encryption
       if( Options.key_flag )
        {
@@ -666,6 +675,12 @@ write_JP2K_file(CommandOptions& Options)
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
       GenRandomUUID(RNG, Info.AssetUUID);
 
+      if ( Options.use_smpte_labels )
+       {
+         Info.LabelSetType = LS_MXF_INTEROP;
+         fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+       }
+
       // configure encryption
       if( Options.key_flag )
        {
@@ -863,6 +878,12 @@ write_PCM_file(CommandOptions& Options)
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
       GenRandomUUID(RNG, Info.AssetUUID);
 
+      if ( Options.use_smpte_labels )
+       {
+         Info.LabelSetType = LS_MXF_INTEROP;
+         fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+       }
+
       // configure encryption
       if( Options.key_flag )
        {
@@ -1226,9 +1247,7 @@ main(int argc, const char** argv)
     {
       EssenceType_t EssenceType;
       result = ASDCP::EssenceType(Options.filenames[0], EssenceType);
-#ifdef SMPTE_LABELS
-      fprintf(stderr, "ATTENTION! Expecting SMPTE Universal Labels\n");
-#endif
+
       if ( ASDCP_SUCCESS(result) )
        {
          switch ( EssenceType )
@@ -1261,9 +1280,7 @@ main(int argc, const char** argv)
 
       EssenceType_t EssenceType;
       result = ASDCP::RawEssenceType(Options.filenames[0], EssenceType);
-#ifdef SMPTE_LABELS
-      fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
-#endif
+
       if ( ASDCP_SUCCESS(result) )
        {
          switch ( EssenceType )

diff --git a/src/h__Reader.cpp b/src/h__Reader.cpp
index 4e20a98360a53d376d2318924bdec95a80f52c08..e958e345d2249aacc5cf3e3edf456e0382686d1b 100755 (executable)
--- a/src/h__Reader.cpp
+++ b/src/h__Reader.cpp
@@ -56,10 +56,19 @@ ASDCP::h__Reader::Close()
 
 //
 Result_t
-ASDCP::h__Reader::InitInfo(WriterInfo& Info)
+ASDCP::h__Reader::InitInfo()
 {
   InterchangeObject* Object;
 
+  m_Info.LabelSetType = LS_MXF_UNKNOWN;
+  UL OPAtomUL(Dict::ul(MDD_OPAtom));
+  UL Interop_OPAtomUL(Dict::ul(MDD_MXFInterop_OPAtom));
+
+  if ( m_HeaderPart.OperationalPattern == Interop_OPAtomUL )
+    m_Info.LabelSetType = LS_MXF_INTEROP;
+  else if ( m_HeaderPart.OperationalPattern == OPAtomUL )
+    m_Info.LabelSetType = LS_MXF_SMPTE;
+
   // Identification
   Result_t result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(Identification), &Object);
 
@@ -73,7 +82,7 @@ ASDCP::h__Reader::InitInfo(WriterInfo& Info)
   if( ASDCP_SUCCESS(result) )
     {
       SourcePackage* SP = (SourcePackage*)Object;
-      memcpy(Info.AssetUUID, SP->PackageUID.Value() + 16, UUIDlen);
+      memcpy(m_Info.AssetUUID, SP->PackageUID.Value() + 16, UUIDlen);
     }
 
   // optional CryptographicContext
@@ -136,6 +145,36 @@ ASDCP::h__Reader::InitMXFIndex()
   return result;
 }
 
+//
+class KLReader : public ASDCP::KLVPacket
+{
+  ASDCP_NO_COPY_CONSTRUCT(KLReader);
+  byte_t m_KeyBuf[32];
+
+public:
+  KLReader() {}
+  ~KLReader() {}
+
+  inline const byte_t* Key() { return m_KeyBuf; }
+  inline const ui64_t  Length() { return m_ValueLength; }
+  inline const ui64_t  KLLength() { return m_KLLength; }
+
+  Result_t ReadKLFromFile(ASDCP::FileReader& Reader)
+  {
+    ui32_t read_count;
+    ui32_t header_length = SMPTE_UL_LENGTH + MXF_BER_LENGTH;
+    Result_t result = Reader.Read(m_KeyBuf, header_length, &read_count);
+
+    if ( read_count != header_length )
+      return RESULT_READFAIL;
+  
+    if ( ASDCP_SUCCESS(result) )
+      result = InitFromBuffer(m_KeyBuf, header_length);
+
+    return result;
+  }
+};
+
 
 // standard method of reading a plaintext or encrypted frame
 Result_t
@@ -153,7 +192,7 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
 
   // get frame position and go read the frame's key and length
   Result_t result = RESULT_OK;
-  ASDCP::KLVReader Reader;
+  KLReader Reader;
   ASDCP::fpos_t FilePosition = m_EssenceStart + TmpEntry.StreamOffset;
 
   if ( FilePosition != m_LastPosition )
@@ -170,10 +209,11 @@ ASDCP::h__Reader::ReadEKLVPacket(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
 
   UL Key(Reader.Key());
   UL CryptEssenceUL(Dict::ul(MDD_CryptEssence));
+  UL InteropCryptEssenceUL(Dict::ul(MDD_MXFInterop_CryptEssence));
   ui64_t PacketLength = Reader.Length();
   m_LastPosition = m_LastPosition + Reader.KLLength() + PacketLength;
 
-  if ( Key == CryptEssenceUL )
+  if ( Key == InteropCryptEssenceUL || Key == CryptEssenceUL )
     {
       if ( ! m_Info.EncryptedEssence )
        {

diff --git a/src/h__Writer.cpp b/src/h__Writer.cpp
index 3c2b97b88167dff14f1c2b8cfa66bbfea2045b26..8fad4ed0c9c67275b2ec8e81af862df653ba2508 100755 (executable)
--- a/src/h__Writer.cpp
+++ b/src/h__Writer.cpp
@@ -336,7 +336,10 @@ ASDCP::h__Writer::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf, const byte
 
       if ( ASDCP_SUCCESS(result) )
        { // write UL
-         Overhead.WriteRaw(Dict::ul(MDD_CryptEssence), SMPTE_UL_LENGTH);
+         if ( m_Info.LabelSetType == LS_MXF_INTEROP )
+           Overhead.WriteRaw(Dict::ul(MDD_MXFInterop_CryptEssence), SMPTE_UL_LENGTH);
+         else
+           Overhead.WriteRaw(Dict::ul(MDD_CryptEssence), SMPTE_UL_LENGTH);
 
          // construct encrypted triplet header
          ui32_t ETLength = klv_cryptinfo_size + m_CtFrameBuf.Size();
@@ -430,8 +433,14 @@ 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(Dict::ul(MDD_OPAtom));
+
+  // re-label the partition
+  UL OPAtomUL(Dict::ul(MDD_OPAtom));
+
+  if ( m_Info.LabelSetType == LS_MXF_INTEROP )
+    OPAtomUL.Set(Dict::ul(MDD_MXFInterop_OPAtom));
+  
+  m_HeaderPart.OperationalPattern = OPAtomUL;
   m_HeaderPart.m_Preface->OperationalPattern = m_HeaderPart.OperationalPattern;
 
   m_FooterPart.OperationalPattern = m_HeaderPart.OperationalPattern;