summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorjhurst <jhurst@cinecert.com>2006-03-17 00:41:14 +0000
committerjhurst <>2006-03-17 00:41:14 +0000
commitdde89765744dad9a6b9d13126092d9bfc2dbc0d7 (patch)
tree0617ee94752000b5b603145eefb1ccb4e847a13c
parent30d642bd3b8474744dfbdcc2bdc46cdf827102c4 (diff)
release
Diffstat
-rwxr-xr-xFileIO.cpp3
-rwxr-xr-xREADME30
-rwxr-xr-xsrc/AS_DCP.h50
-rwxr-xr-xsrc/AS_DCP_JP2K.cpp30
-rwxr-xr-xsrc/AS_DCP_MPEG2.cpp30
-rwxr-xr-xsrc/AS_DCP_MXF.cpp46
-rwxr-xr-xsrc/AS_DCP_PCM.cpp2
-rwxr-xr-xsrc/AS_DCP_internal.h32
-rwxr-xr-xsrc/Dict.cpp57
-rwxr-xr-xsrc/KLV.cpp16
-rw-r--r--src/MDD.cpp543
-rwxr-xr-xsrc/MDD.h515
-rwxr-xr-xsrc/MXF.cpp9
-rwxr-xr-xsrc/MXFTypes.cpp2
-rwxr-xr-xsrc/MXFTypes.h4
-rwxr-xr-xsrc/PCM_Parser.cpp2
-rwxr-xr-xsrc/asdcp-test.cpp35
-rwxr-xr-xsrc/h__Reader.cpp48
-rwxr-xr-xsrc/h__Writer.cpp15
19 files changed, 711 insertions, 758 deletions
diff --git a/FileIO.cpp b/FileIO.cpp
index b3d434e..3665c45 100755
--- 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 89d3d85..dbd73fd 100755
--- 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 b64c3a5..e65b029 100755
--- 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
@@ -410,21 +403,48 @@ 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
{
byte_t ProductUUID[UUIDlen];
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 3bb5484..bf276e7 100755
--- 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 badc221..26988e4 100755
--- 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 9436273..92f76bb 100755
--- 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 ef16f2b..9063210 100755
--- 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 15890a7..173540d 100755
--- 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 0b71a8c..fe29880 100755
--- 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 b31969e..63c1e54 100755
--- 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 59e5f0b..ba7007c 100644
--- 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 ac65bf5..69214a4 100755
--- 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 d5585d3..413513c 100755
--- 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 ec4f2d7..111d493 100755
--- 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 0a6ea72..6c52463 100755
--- 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 9262de7..331bebf 100755
--- 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 83fbb15..c048a30 100755
--- 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 4e20a98..e958e34 100755
--- 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 3c2b97b..8fad4ed 100755
--- 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;
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-19 15:42:49 +0000