Defined bool ASDCP::UL::operator<(const UL& rhs) const, which is needed to carry out the version-insensitive lookup policy when searching for ULs in a std::map<> of UL entries.

11 files changed, 409 insertions, 115 deletions

diff --git a/src/AS_DCP_ATMOS.cpp b/src/AS_DCP_ATMOS.cpp
index e1eb612..518df74 100644
--- a/src/AS_DCP_ATMOS.cpp
+++ b/src/AS_DCP_ATMOS.cpp
@@ -166,7 +166,7 @@ ASDCP::ATMOS::MXFReader::h__Reader::OpenRead(const std::string& filename)
   if ( KM_SUCCESS(result) )
     {
       InterchangeObject* iObj = 0;
-      result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(DolbyAtmosDCDataDescriptor), &iObj);
+      result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(PrivateDCDataDescriptor), &iObj);
 
       if ( KM_SUCCESS(result) )
 	{
@@ -237,7 +237,7 @@ ASDCP::ATMOS::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& Fram
     return RESULT_INIT;
 
   assert(m_Dict);
-  return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_DolbyAtmosDCDataEssence), Ctx, HMAC);
+  return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_PrivateDCDataEssence), Ctx, HMAC);
 }
 
 
@@ -518,7 +518,7 @@ ASDCP::ATMOS::MXFWriter::h__Writer::SetSourceStream(ASDCP::DCData::DCDataDescrip
 
   if ( ASDCP_SUCCESS(result) )
   {
-    memcpy(m_EssenceUL, m_Dict->ul(MDD_DolbyAtmosDCDataEssence), SMPTE_UL_LENGTH);
+    memcpy(m_EssenceUL, m_Dict->ul(MDD_PrivateDCDataEssence), SMPTE_UL_LENGTH);
     m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
     result = m_State.Goto_READY();
   }
@@ -527,7 +527,7 @@ ASDCP::ATMOS::MXFWriter::h__Writer::SetSourceStream(ASDCP::DCData::DCDataDescrip
   {
     ui32_t TCFrameRate = m_DDesc.EditRate.Numerator;
 
-    result = WriteASDCPHeader(packageLabel, UL(m_Dict->ul(MDD_DolbyAtmosDCDataWrappingFrame)),
+    result = WriteASDCPHeader(packageLabel, UL(m_Dict->ul(MDD_PrivateDCDataWrappingFrame)),
 			      defLabel, UL(m_EssenceUL), UL(m_Dict->ul(MDD_DataDataDef)),
 			      m_DDesc.EditRate, TCFrameRate);
   }
diff --git a/src/AS_DCP_DCData.cpp b/src/AS_DCP_DCData.cpp
index 5db1482..ef4d6d4 100644
--- a/src/AS_DCP_DCData.cpp
+++ b/src/AS_DCP_DCData.cpp
@@ -78,31 +78,42 @@ typedef std::list<MXF::InterchangeObject*> SubDescriptorList_t;
 
 class ASDCP::DCData::MXFReader::h__Reader : public ASDCP::h__ASDCPReader
 {
-  bool m_AtmosLabelCompatibilityMode;
-  MXF::DCDataDescriptor* m_EssenceDescriptor;
+  bool m_PrivateLabelCompatibilityMode;
   ASDCP_NO_COPY_CONSTRUCT(h__Reader);
   h__Reader();
 
  public:
   DCDataDescriptor m_DDesc;
 
-  h__Reader(const Dictionary& d) : ASDCP::h__ASDCPReader(d), m_AtmosLabelCompatibilityMode(false), m_EssenceDescriptor(0), m_DDesc() {}
+  h__Reader(const Dictionary& d) : ASDCP::h__ASDCPReader(d), m_PrivateLabelCompatibilityMode(false), m_DDesc() {}
   ~h__Reader() {}
   Result_t    OpenRead(const std::string&);
   Result_t    ReadFrame(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*);
-  Result_t    MD_to_DCData_DDesc(DCData::DCDataDescriptor& DDesc);
+  Result_t    MD_to_DCData_DDesc(const MXF::DCDataDescriptor& descriptor_object, DCData::DCDataDescriptor& DDesc);
+  Result_t    MD_to_DCData_DDesc(const MXF::PrivateDCDataDescriptor& descriptor_object, DCData::DCDataDescriptor& DDesc);
 };
 
+//
+ASDCP::Result_t
+ASDCP::DCData::MXFReader::h__Reader::MD_to_DCData_DDesc(const MXF::DCDataDescriptor& descriptor_object,
+							DCData::DCDataDescriptor& DDesc)
+{
+  DDesc.EditRate = descriptor_object.SampleRate;
+  assert(descriptor_object.ContainerDuration.const_get() <= 0xFFFFFFFFL);
+  DDesc.ContainerDuration = static_cast<ui32_t>(descriptor_object.ContainerDuration.const_get());
+  memcpy(DDesc.DataEssenceCoding, descriptor_object.DataEssenceCoding.Value(), SMPTE_UL_LENGTH);
+  return RESULT_OK;
+}
 
+//
 ASDCP::Result_t
-ASDCP::DCData::MXFReader::h__Reader::MD_to_DCData_DDesc(DCData::DCDataDescriptor& DDesc)
+ASDCP::DCData::MXFReader::h__Reader::MD_to_DCData_DDesc(const MXF::PrivateDCDataDescriptor& descriptor_object,
+							DCData::DCDataDescriptor& DDesc)
 {
-  ASDCP_TEST_NULL(m_EssenceDescriptor);
-  MXF::DCDataDescriptor* DDescObj = m_EssenceDescriptor;
-  DDesc.EditRate = DDescObj->SampleRate;
-  assert(DDescObj->ContainerDuration <= 0xFFFFFFFFL);
-  DDesc.ContainerDuration = static_cast<ui32_t>(DDescObj->ContainerDuration);
-  memcpy(DDesc.DataEssenceCoding, DDescObj->DataEssenceCoding.Value(), SMPTE_UL_LENGTH);
+  DDesc.EditRate = descriptor_object.SampleRate;
+  assert(descriptor_object.ContainerDuration.const_get() <= 0xFFFFFFFFL);
+  DDesc.ContainerDuration = static_cast<ui32_t>(descriptor_object.ContainerDuration.const_get());
+  memcpy(DDesc.DataEssenceCoding, descriptor_object.DataEssenceCoding.Value(), SMPTE_UL_LENGTH);
   return RESULT_OK;
 }
 
@@ -112,40 +123,38 @@ ASDCP::Result_t
 ASDCP::DCData::MXFReader::h__Reader::OpenRead(const std::string& filename)
 {
   Result_t result = OpenMXFRead(filename);
-  m_EssenceDescriptor = 0;
 
   if( KM_SUCCESS(result) )
     {
       InterchangeObject* iObj = 0;
       result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(DCDataDescriptor), &iObj);
 
-      if ( KM_FAILURE(result) )
+      if ( KM_SUCCESS(result) )
 	{
-	  result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(DolbyAtmosDCDataDescriptor), &iObj);
+	  const MXF::DCDataDescriptor* p = dynamic_cast<const MXF::DCDataDescriptor*>(iObj);
+	  assert(p);
+	  result = MD_to_DCData_DDesc(*p, m_DDesc);
+	}
+      else
+	{
+	  result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(PrivateDCDataDescriptor), &iObj);
 	  
 	  if ( KM_SUCCESS(result) )
 	    {
-	      m_AtmosLabelCompatibilityMode = true;
+	      m_PrivateLabelCompatibilityMode = true;
+	      const MXF::PrivateDCDataDescriptor* p = dynamic_cast<const MXF::PrivateDCDataDescriptor*>(iObj);
+	      assert(p);
+	      result = MD_to_DCData_DDesc(*p, m_DDesc);
 	    }
 	}
 
-      if ( KM_SUCCESS(result) )
+      if ( KM_FAILURE(result) )
 	{
-	  m_EssenceDescriptor = static_cast<MXF::DCDataDescriptor*>(iObj);
+	  DefaultLogSink().Error("DCDataDescriptor object not found.\n");
+	  result = RESULT_FORMAT;
 	}
     }
 
-  if ( m_EssenceDescriptor == 0 )
-    {
-      DefaultLogSink().Error("DCDataDescriptor object not found.\n");
-      result = RESULT_FORMAT;
-    }
-  
-  if ( KM_SUCCESS(result) )
-    {
-      result = MD_to_DCData_DDesc(m_DDesc);
-    }
-
   // check for sample/frame rate sanity
   if ( ASDCP_SUCCESS(result)
                 && m_DDesc.EditRate != EditRate_24
@@ -177,9 +186,9 @@ ASDCP::DCData::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& Fra
     return RESULT_INIT;
 
   assert(m_Dict);
-  if ( m_AtmosLabelCompatibilityMode )
+  if ( m_PrivateLabelCompatibilityMode )
     {
-      return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_DolbyAtmosDCDataEssence), Ctx, HMAC);
+      return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_PrivateDCDataEssence), Ctx, HMAC);
     }
 
   return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_DCDataEssence), Ctx, HMAC);
diff --git a/src/AS_DCP_MXF.cpp b/src/AS_DCP_MXF.cpp
index 32225be..e00d93a 100755
--- a/src/AS_DCP_MXF.cpp
+++ b/src/AS_DCP_MXF.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2004-2013, John Hurst
+Copyright (c) 2004-2016, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -213,7 +213,8 @@ ASDCP::EssenceType(const std::string& filename, EssenceType_t& type)
 	    {
 	      type = ESS_TIMED_TEXT;
 	    }
-	  else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(DCDataDescriptor))) )
+	  else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(DCDataDescriptor)))
+		    || ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(PrivateDCDataDescriptor))) )
 	    {
 	      if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(DolbyAtmosSubDescriptor))) )
 		{
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 8ccc914..259989b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,51 +1,171 @@
-cmake_minimum_required(VERSION 2.8.12)

-

-project(asdcplibmod)

-

-# The version number.

-set(VERSION_MAJOR 2)

-set(VERSION_MINOR 5)

-set(VERSION_PATCH 13)

-set(VERSION_STRING ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})

-set_property(GLOBAL PROPERTY USE_FOLDERS ON)

-set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "Default Targets")

-# use, i.e. don't skip the full RPATH for the build tree

-set(CMAKE_SKIP_BUILD_RPATH  OFF)

-# when building, don't use the install RPATH already

-# (but later on when installing)

-set(CMAKE_BUILD_WITH_INSTALL_RPATH OFF) 

-set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")

-# add the automatically determined parts of the RPATH

-# which point to directories outside the build tree to the install RPATH

-set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)

-# the RPATH to be used when installing, but only if it's not a system directory

-list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)

-if("${isSystemDir}" STREQUAL "-1")

-   set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")

-endif("${isSystemDir}" STREQUAL "-1")

-

-# Configure a header file to pass some of the CMake settings to the source code.

-configure_file("${PROJECT_SOURCE_DIR}/src/info.in" "${PROJECT_BINARY_DIR}/src/info.h")

-

-# Add the binary tree to the search path for include files so that we will find info.h.

-include_directories("${PROJECT_BINARY_DIR}/src")

-add_subdirectory(src)

-

-set(CPACK_GENERATOR ZIP)

-if(UNIX)

-	set(CPACK_GENERATOR ${CPACK_GENERATOR};STGZ;TGZ)

-endif(UNIX)

-if(UNIX AND NOT APPLE)

-	set(CPACK_GENERATOR ${CPACK_GENERATOR};DEB;RPM)

-endif(UNIX AND NOT APPLE)

-set(CPACK_PACKAGE_NAME ${PROJECT_NAME})

-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Modified asdcp lib. Can generate MXF resources.")

-set(CPACK_PACKAGE_VENDOR "HSRM")

-set(CPACK_PACKAGE_CONTACT "bjoern.stresing@gmx.de")

-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYING")

-set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})

-set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})

-set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH})

-set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)

-set(CPACK_PACKAGE_INSTALL_DIRECTORY ${PROJECT_NAME}{VERSION_MAJOR}.${VERSION_MINOR})

-include(CPack)

+find_library(OpenSSLLib_PATH NAMES libeay32 crypto PATHS "${PROJECT_SOURCE_DIR}/../openssl" "${PROJECT_SOURCE_DIR}/../lib/openssl" "$ENV{CMAKE_HINT}/openssl" ENV CMAKE_HINT PATH_SUFFIXES "lib" "openssl" "lib/openssl")
+find_path(OpenSSLLib_include_DIR NAMES openssl/rand.h PATHS "${PROJECT_SOURCE_DIR}/../openssl" "${PROJECT_SOURCE_DIR}/../lib/openssl" "$ENV{CMAKE_HINT}/openssl" ENV CMAKE_HINT PATH_SUFFIXES "include" "inc32")
+find_library(XercescppLib_PATH NAMES xerces-c xerces-c_3 PATHS "${PROJECT_SOURCE_DIR}/../xercescpp" "${PROJECT_SOURCE_DIR}/../lib/xercescpp" "$ENV{CMAKE_HINT}/xercescpp" ENV CMAKE_HINT PATH_SUFFIXES "lib")
+find_library(XercescppLib_Debug_PATH NAMES xerces-c xerces-c_3D PATHS "${PROJECT_SOURCE_DIR}/../xercescpp" "${PROJECT_SOURCE_DIR}/../lib/xercescpp" "$ENV{CMAKE_HINT}/xercescpp" ENV CMAKE_HINT PATH_SUFFIXES "lib")
+find_path(XercescppLib_include_DIR NAMES xercesc/dom/DOM.hpp PATHS "${PROJECT_SOURCE_DIR}/../xercescpp" "${PROJECT_SOURCE_DIR}/../lib/xercescpp" "$ENV{CMAKE_HINT}/xercescpp" ENV CMAKE_HINT PATH_SUFFIXES "include")
+set(UseRandomUUID OFF CACHE BOOL "")
+
+# This lib. doesn't export from dll with __declspec(dllexport). So this lib. must be built statically on Windows.
+if(NOT WIN32)
+	set(BUILD_SHARED_LIBS true CACHE BOOL "Build shared or static libs?" FORCE)
+endif(NOT WIN32)
+
+# ----------libkumu----------
+# source
+set(kumu_src KM_fileio.cpp KM_log.cpp KM_prng.cpp KM_util.cpp KM_xml.cpp KM_tai.cpp)
+
+# header
+set(kumu_src ${kumu_src} KM_fileio.h KM_log.h KM_prng.h KM_util.h KM_xml.h KM_tai.h KM_error.h KM_memio.h KM_mutex.h KM_platform.h)
+
+# ----------libasdcp----------
+# source
+set(asdcp_src MPEG2_Parser.cpp MPEG.cpp JP2K_Codestream_Parser.cpp JP2K_Sequence_Parser.cpp JP2K.cpp PCM_Parser.cpp Wav.cpp 
+	TimedText_Parser.cpp KLV.cpp Dict.cpp MXFTypes.cpp MXF.cpp Index.cpp Metadata.cpp AS_DCP.cpp AS_DCP_MXF.cpp AS_DCP_AES.cpp
+	h__Reader.cpp h__Writer.cpp AS_DCP_MPEG2.cpp AS_DCP_JP2K.cpp AS_DCP_PCM.cpp AS_DCP_TimedText.cpp PCMParserList.cpp MDD.cpp
+	AS_DCP_ATMOS.cpp AS_DCP_DCData.cpp DCData_ByteStream_Parser.cpp DCData_Sequence_Parser.cpp AtmosSyncChannel_Generator.cpp
+	AtmosSyncChannel_Mixer.cpp PCMDataProviders.cpp SyncEncoder.c CRC16.c UUIDInformation.c
+)
+
+# header for deployment (install target)
+set(asdcp_deploy_header AS_DCP.h PCMParserList.h AS_DCP_internal.h KM_error.h KM_fileio.h KM_util.h KM_memio.h KM_tai.h KM_platform.h KM_log.h KM_mutex.h)
+
+# header
+set(asdcp_src ${asdcp_src} Wav.h WavFileWriter.h MXF.h Metadata.h JP2K.h AS_DCP.h AS_DCP_internal.h KLV.h MPEG.h MXFTypes.h MDD.h
+	PCMParserList.h S12MTimecode.h AS_DCP_DCData_internal.h AtmosSyncChannel_Generator.h AtmosSyncChannel_Mixer.h PCMDataProviders.h
+	SyncEncoder.h SyncCommon.h CRC16.h UUIDInformation.h
+)
+
+# ----------as02----------
+# source
+set(as02_src h__02_Reader.cpp h__02_Writer.cpp AS_02_JP2K.cpp AS_02_PCM.cpp ST2052_TextParser.cpp AS_02_TimedText.cpp)
+
+# header for deployment (install target)
+set(as02_deploy_header AS_02.h Metadata.h MXF.h MXFTypes.h KLV.h MDD.h)
+
+# header
+set(as02_src ${as02_src} AS_02.h AS_02_internal.h)
+
+
+include_directories("${PROJECT_SOURCE_DIR}/src" "${OpenSSLLib_include_DIR}" "${XercescppLib_include_DIR}")
+
+add_definitions(/DPACKAGE_VERSION=\"${VERSION_STRING}\" /DHAVE_XERCES_C=1)
+if(WIN32)
+	add_definitions(/DKM_WIN32 /D_CONSOLE /DASDCP_PLATFORM=\"win32\" /D_CRT_SECURE_NO_WARNINGS /D_CRT_NONSTDC_NO_WARNINGS)
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
+elseif(UNIX)
+	add_definitions(/DASDCP_PLATFORM=\"unix\")
+endif(WIN32)
+
+if(UseRandomUUID)
+	add_definitions(/DCONFIG_RANDOM_UUID=1)
+endif(UseRandomUUID)
+
+set(CMAKE_DEBUG_POSTFIX _d) # Append "_d" if debug lib.
+
+add_library(libkumu ${kumu_src})
+target_link_libraries(libkumu general "${OpenSSLLib_PATH}" debug "${XercescppLib_Debug_PATH}" optimized "${XercescppLib_PATH}")
+set_target_properties(libkumu PROPERTIES PREFIX "" VERSION ${VERSION_STRING} SOVERSION ${VERSION_MAJOR})
+
+add_library(libasdcp ${asdcp_src})
+target_link_libraries(libasdcp general libkumu)
+set_target_properties(libasdcp PROPERTIES PREFIX "" VERSION ${VERSION_STRING} SOVERSION ${VERSION_MAJOR})
+
+add_library(libas02 ${as02_src})
+target_link_libraries(libas02 general libasdcp)
+set_target_properties(libas02 PROPERTIES PREFIX "" VERSION ${VERSION_STRING} SOVERSION ${VERSION_MAJOR})
+
+add_executable(blackwave "blackwave.cpp")
+target_link_libraries(blackwave general libasdcp)
+if(WIN32)
+	target_link_libraries(blackwave general Advapi32.lib)
+endif(WIN32)
+
+add_executable(wavesplit "wavesplit.cpp")
+target_link_libraries(wavesplit general libasdcp)
+if(WIN32)
+	target_link_libraries(wavesplit general Advapi32.lib)
+endif(WIN32)
+
+add_executable(kmuuidgen "kmuuidgen.cpp")
+target_link_libraries(kmuuidgen general libkumu)
+if(WIN32)
+	target_link_libraries(kmuuidgen general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(kmrandgen "kmrandgen.cpp")
+target_link_libraries(kmrandgen general libkumu)
+if(WIN32)
+	target_link_libraries(kmrandgen general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(kmfilegen "kmfilegen.cpp")
+target_link_libraries(kmfilegen general libkumu)
+if(WIN32)
+	target_link_libraries(kmfilegen general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(klvwalk "klvwalk.cpp")
+target_link_libraries(klvwalk general libasdcp)
+if(WIN32)
+	target_link_libraries(klvwalk general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(asdcp-test "asdcp-test.cpp")
+target_link_libraries(asdcp-test general libasdcp)
+if(WIN32)
+	target_link_libraries(asdcp-test general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(asdcp-wrap "asdcp-wrap.cpp")
+target_link_libraries(asdcp-wrap general libasdcp)
+if(WIN32)
+	target_link_libraries(asdcp-wrap general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(asdcp-unwrap "asdcp-unwrap.cpp")
+target_link_libraries(asdcp-unwrap general libasdcp)
+if(WIN32)
+	target_link_libraries(asdcp-unwrap general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(asdcp-info "asdcp-info.cpp")
+target_link_libraries(asdcp-info general libasdcp)
+if(WIN32)
+	target_link_libraries(asdcp-info general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(asdcp-util "asdcp-util.cpp")
+target_link_libraries(asdcp-util general libasdcp)
+if(WIN32)
+	target_link_libraries(asdcp-util general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(j2c-test "j2c-test.cpp")
+target_link_libraries(j2c-test general libasdcp)
+if(WIN32)
+	target_link_libraries(j2c-test general Advapi32.lib)
+endif(WIN32)
+
+add_executable(as-02-wrap "as-02-wrap.cpp")
+target_link_libraries(as-02-wrap general libas02)
+if(WIN32)
+	target_link_libraries(as-02-wrap general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(as-02-unwrap "as-02-unwrap.cpp")
+target_link_libraries(as-02-unwrap general libas02)
+if(WIN32)
+	target_link_libraries(as-02-unwrap general Advapi32.lib) 
+endif(WIN32)
+
+add_executable(as-02-info "as-02-info.cpp")
+target_link_libraries(as-02-info general libas02)
+if(WIN32)
+	target_link_libraries(as-02-info general Advapi32.lib)
+endif(WIN32)
+
+# add the install target
+install(TARGETS libkumu libasdcp libas02 EXPORT asdcplibtargets RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib INCLUDES DESTINATION "${OpenSSLLib_include_DIR}" "${XercescppLib_include_DIR}")
+install(TARGETS blackwave wavesplit kmuuidgen kmrandgen kmfilegen klvwalk asdcp-test asdcp-wrap asdcp-unwrap asdcp-info asdcp-util j2c-test as-02-wrap as-02-unwrap as-02-info RUNTIME DESTINATION bin)
+install(FILES ${as02_deploy_header} ${asdcp_deploy_header} DESTINATION include)
+install(EXPORT asdcplibtargets DESTINATION targets)
diff --git a/src/KLV.h b/src/KLV.h
index b49cd07..9bb1cb3 100755
--- a/src/KLV.h
+++ b/src/KLV.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2011, John Hurst
+Copyright (c) 2005-2016, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -107,6 +107,7 @@ inline const char* ui64sz(ui64_t i, char* buf)
 
       const char* EncodeString(char* str_buf, ui32_t buf_len) const;
       bool operator==(const UL& rhs) const;
+      bool operator<(const UL& rhs) const;
       bool MatchIgnoreStream(const UL& rhs) const;
       bool ExactMatch(const UL& rhs) const;
     };
diff --git a/src/MDD.cpp b/src/MDD.cpp
index 116caab..2d6d0d2 100644
--- a/src/MDD.cpp
+++ b/src/MDD.cpp
@@ -1190,13 +1190,13 @@ static const ASDCP::MDDEntry s_MDD_Table[] = {
   //
   { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x05, // 381
       0x0e, 0x09, 0x06, 0x05, 0x00, 0x00, 0x00, 0x00 },
-    {0}, false, "DolbyAtmosDCDataWrappingFrame" },
+    {0}, false, "PrivateDCDataWrappingFrame" },
   { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x02, 0x01, 0x05, // 382
       0x0e, 0x09, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 },
-    {0}, false, "DolbyAtmosDCDataEssence" },
+    {0}, false, "PrivateDCDataEssence" },
   { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x05, // 383
       0x0e, 0x09, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00 },
-    {0}, false, "DolbyAtmosDCDataDescriptor" },
+    {0}, false, "PrivateDCDataDescriptor" },
 
   { {0}, {0}, false, 0 }
 };
diff --git a/src/MDD.h b/src/MDD.h
index 2b274ab..cef2db3 100755
--- a/src/MDD.h
+++ b/src/MDD.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2006-2015, John Hurst
+Copyright (c) 2006-2016, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -416,9 +416,9 @@ namespace ASDCP {
 	MDD_PHDRMetadataTrackSubDescriptor_SourceTrackID, // 378
 	MDD_PHDRMetadataTrackSubDescriptor_SimplePayloadSID, // 379
 	MDD_JPEG2000PictureSubDescriptor_J2CLayout, // 380
-	MDD_DolbyAtmosDCDataWrappingFrame, // 381
-	MDD_DolbyAtmosDCDataEssence,  // 382
-	MDD_DolbyAtmosDCDataDescriptor, // 383
+	MDD_PrivateDCDataWrappingFrame, // 381
+	MDD_PrivateDCDataEssence,  // 382
+	MDD_PrivateDCDataDescriptor, // 383
         MDD_Max
     }; // enum MDD_t
 
diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp
index d4bbf44..9e481e2 100755
--- a/src/MXFTypes.cpp
+++ b/src/MXFTypes.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2015, John Hurst
+Copyright (c) 2005-2016, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -65,6 +65,72 @@ ASDCP::UL::operator==(const UL& rhs) const
   return false;
 }
 
+
+//
+bool
+ASDCP::UL::operator<(const UL& rhs) const
+{
+  if ( m_Value[0] < rhs.m_Value[0] ) return true;
+  if ( m_Value[0] == rhs.m_Value[0] )
+    {
+      if ( m_Value[1] < rhs.m_Value[1] ) return true;
+      if ( m_Value[1] == rhs.m_Value[1] )
+	{
+	  if ( m_Value[2] < rhs.m_Value[2] ) return true;
+	  if ( m_Value[2] == rhs.m_Value[2] )
+	    {
+	      if ( m_Value[3] < rhs.m_Value[3] ) return true;
+	      if ( m_Value[3] == rhs.m_Value[3] )
+		{
+		  if ( m_Value[4] < rhs.m_Value[4] ) return true;
+		  if ( m_Value[4] == rhs.m_Value[4] )
+		    {
+		      if ( m_Value[5] < rhs.m_Value[5] ) return true;
+		      if ( m_Value[5] == rhs.m_Value[5] )
+			{
+			  if ( m_Value[6] < rhs.m_Value[6] ) return true;
+			  if ( m_Value[6] == rhs.m_Value[6] )
+			    {
+			      if ( m_Value[8] < rhs.m_Value[8] ) return true;
+			      if ( m_Value[8] == rhs.m_Value[8] )
+				{
+				  if ( m_Value[9] < rhs.m_Value[9] ) return true;
+				  if ( m_Value[9] == rhs.m_Value[9] )
+				    {
+				      if ( m_Value[10] < rhs.m_Value[10] ) return true;
+				      if ( m_Value[10] == rhs.m_Value[10] )
+					{
+					  if ( m_Value[11] < rhs.m_Value[11] ) return true;
+					  if ( m_Value[11] == rhs.m_Value[11] )
+					    {
+					      if ( m_Value[12] < rhs.m_Value[12] ) return true;
+					      if ( m_Value[12] == rhs.m_Value[12] )
+						{
+						  if ( m_Value[13] < rhs.m_Value[13] ) return true;
+						  if ( m_Value[13] == rhs.m_Value[13] )
+						    {
+						      if ( m_Value[14] < rhs.m_Value[14] ) return true;
+						      if ( m_Value[14] == rhs.m_Value[14] )
+							{
+							  if ( m_Value[15] < rhs.m_Value[15] ) return true;
+							}
+						    }
+						}
+					    }
+					}
+				    }
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+    }
+
+  return false;
+}
+
 //
 bool
 ASDCP::UL::MatchIgnoreStream(const UL& rhs) const
diff --git a/src/Metadata.cpp b/src/Metadata.cpp
index 7839f4f..72136d7 100755
--- a/src/Metadata.cpp
+++ b/src/Metadata.cpp
@@ -75,6 +75,7 @@ static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionar
 static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); }
 static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); }
 static InterchangeObject* DCDataDescriptor_Factory(const Dictionary*& Dict) { return new DCDataDescriptor(Dict); }
+static InterchangeObject* PrivateDCDataDescriptor_Factory(const Dictionary*& Dict) { return new PrivateDCDataDescriptor(Dict); }
 static InterchangeObject* DolbyAtmosSubDescriptor_Factory(const Dictionary*& Dict) { return new DolbyAtmosSubDescriptor(Dict); }
 static InterchangeObject* PHDRMetadataTrackSubDescriptor_Factory(const Dictionary*& Dict) { return new PHDRMetadataTrackSubDescriptor(Dict); }
 
@@ -118,6 +119,7 @@ ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict)
   SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_DCDataDescriptor), DCDataDescriptor_Factory);
+  SetObjectFactory(Dict->ul(MDD_PrivateDCDataDescriptor), PrivateDCDataDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_DolbyAtmosSubDescriptor), DolbyAtmosSubDescriptor_Factory);
   SetObjectFactory(Dict->ul(MDD_PHDRMetadataTrackSubDescriptor), PHDRMetadataTrackSubDescriptor_Factory);
 }
@@ -3601,6 +3603,77 @@ DCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
 }
 
 //------------------------------------------------------------------------------------------
+// PrivateDCDataDescriptor
+
+//
+
+PrivateDCDataDescriptor::PrivateDCDataDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
+}
+
+PrivateDCDataDescriptor::PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict)
+{
+  assert(m_Dict);
+  m_UL = m_Dict->ul(MDD_PrivateDCDataDescriptor);
+  Copy(rhs);
+}
+
+
+//
+ASDCP::Result_t
+PrivateDCDataDescriptor::InitFromTLVSet(TLVReader& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = GenericDataEssenceDescriptor::InitFromTLVSet(TLVSet);
+  return result;
+}
+
+//
+ASDCP::Result_t
+PrivateDCDataDescriptor::WriteToTLVSet(TLVWriter& TLVSet)
+{
+  assert(m_Dict);
+  Result_t result = GenericDataEssenceDescriptor::WriteToTLVSet(TLVSet);
+  return result;
+}
+
+//
+void
+PrivateDCDataDescriptor::Copy(const PrivateDCDataDescriptor& rhs)
+{
+  GenericDataEssenceDescriptor::Copy(rhs);
+}
+
+//
+void
+PrivateDCDataDescriptor::Dump(FILE* stream)
+{
+  char identbuf[IdentBufferLen];
+  *identbuf = 0;
+
+  if ( stream == 0 )
+    stream = stderr;
+
+  GenericDataEssenceDescriptor::Dump(stream);
+}
+
+//
+ASDCP::Result_t
+PrivateDCDataDescriptor::InitFromBuffer(const byte_t* p, ui32_t l)
+{
+  return InterchangeObject::InitFromBuffer(p, l);
+}
+
+//
+ASDCP::Result_t
+PrivateDCDataDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
+{
+  return InterchangeObject::WriteToBuffer(Buffer);
+}
+
+//------------------------------------------------------------------------------------------
 // DolbyAtmosSubDescriptor
 
 //
diff --git a/src/Metadata.h b/src/Metadata.h
index 55f06d4..e71ddf2 100755
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -981,6 +981,28 @@ namespace ASDCP
 	};
 
       //
+      class PrivateDCDataDescriptor : public GenericDataEssenceDescriptor
+	{
+	  PrivateDCDataDescriptor();
+
+	public:
+	  const Dictionary*& m_Dict;
+
+      PrivateDCDataDescriptor(const Dictionary*& d);
+      PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
+      virtual ~PrivateDCDataDescriptor() {}
+
+      const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
+      virtual void Copy(const PrivateDCDataDescriptor& rhs);
+      virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
+      virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
+      virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
+      virtual void     Dump(FILE* = 0);
+      virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
+      virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
+	};
+
+      //
       class DolbyAtmosSubDescriptor : public InterchangeObject
 	{
 	  DolbyAtmosSubDescriptor();
diff --git a/src/klvwalk.cpp b/src/klvwalk.cpp
index 779ee72..801389e 100755
--- a/src/klvwalk.cpp
+++ b/src/klvwalk.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2015, John Hurst
+Copyright (c) 2005-2016, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -201,31 +201,33 @@ main(int argc, const char** argv)
 	  ASDCP::MXF::OP1aHeader Header(Dict);
 	  ASDCP::MXF::RIP RIP(Dict);
 	  
-	  result = Reader.OpenRead((*fi).c_str());
+	  result = Reader.OpenRead(*fi);
 	  
 	  if ( ASDCP_SUCCESS(result) )
-	    result = MXF::SeekToRIP(Reader);
-
-	  if ( ASDCP_SUCCESS(result) )
 	    {
-	      result = RIP.InitFromFile(Reader);
-	      ui32_t test_s = RIP.PairArray.size();
-
-	      if ( ASDCP_FAILURE(result) )
+	      result = MXF::SeekToRIP(Reader);
+	      
+	      if ( ASDCP_SUCCESS(result) )
 		{
-		  DefaultLogSink().Error("File contains no RIP\n");
-		  result = RESULT_OK;
+		  result = RIP.InitFromFile(Reader);
+		  ui32_t test_s = RIP.PairArray.size();
+
+		  if ( ASDCP_FAILURE(result) )
+		    {
+		      DefaultLogSink().Error("File contains no RIP\n");
+		      result = RESULT_OK;
+		    }
+		  else if ( RIP.PairArray.empty() )
+		    {
+		      DefaultLogSink().Error("RIP contains no Pairs.\n");
+		    }
+
+		  Reader.Seek(0);
 		}
-	      else if ( RIP.PairArray.empty() )
+	      else
 		{
-		  DefaultLogSink().Error("RIP contains no Pairs.\n");
+		  DefaultLogSink().Error("read_mxf SeekToRIP failed: %s\n", result.Label());
 		}
-
-	      Reader.Seek(0);
-	    }
-	  else
-	    {
-	      DefaultLogSink().Error("read_mxf SeekToRIP failed: %s\n", result.Label());
 	    }
 
 	  if ( ASDCP_SUCCESS(result) )