Implemented J2K desc to/from MD

diff --git a/src/AS_DCP.h b/src/AS_DCP.h
index b28f1143f7588567025e3fb1b4c1004d7177d110..0948cbf5b2bff9f854d5b60c5b6cb5b52a4e142b 100755 (executable)
--- a/src/AS_DCP.h
+++ b/src/AS_DCP.h
@@ -1092,7 +1092,7 @@ namespace ASDCP {
       struct ExtendedCapabilities_t // ISO 15444-1 Annex A.5.2
       {
        ui32_t  Pcap; // Pcap = 0 means that no extended capabilities are required
-       ui16_t  Ccap[MaxCapabilities]; // Ccap^i in ISO/IEC 15444-1 corresponds to Ccap[i -1]
+       ui16_t  Ccap[MaxCapabilities]; // Ccap^i in ISO/IEC 15444-1 corresponds to Ccap[i - 1]
       };
 
                        struct Profile_t // ISO 15444-1

diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index ccb6b09bb62945037ef039efff7beccce40a8880..a980e0f3ba06f3c44a88d438ceba9d4927952919 100755 (executable)
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -32,6 +32,7 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "AS_DCP_internal.h"
 #include <iostream>
 #include <iomanip>
+#include <algorithm>
 
 using namespace ASDCP::JP2K;
 using Kumu::GenRandomValue;
@@ -327,6 +328,54 @@ ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc,
   EssenceSubDescriptor.QuantizationDefault.get().Length(qdflt_size);
   EssenceSubDescriptor.QuantizationDefault.set_has_value();
 
+  // Profile
+
+  if (PDesc.Profile.N == 0) {
+         EssenceSubDescriptor.J2KProfile.set_has_value(false);
+  } else {
+         EssenceSubDescriptor.J2KProfile.get().resize(PDesc.Profile.N);
+
+         std::copy(PDesc.Profile.Pprf,
+                 PDesc.Profile.Pprf + PDesc.Profile.N,
+                  EssenceSubDescriptor.J2KProfile.get().begin());
+
+         EssenceSubDescriptor.J2KProfile.set_has_value();
+  }
+
+  // Corresponding profile
+
+  if (PDesc.CorrespondingProfile.N == 0) {
+       
+         EssenceSubDescriptor.J2KCorrespondingProfile.set_has_value(false);
+  
+  } else {
+         EssenceSubDescriptor.J2KCorrespondingProfile.get().resize(PDesc.CorrespondingProfile.N);
+
+         std::copy(PDesc.CorrespondingProfile.Pcpf,
+                 PDesc.CorrespondingProfile.Pcpf + PDesc.CorrespondingProfile.N,
+                 EssenceSubDescriptor.J2KCorrespondingProfile.get().begin());
+
+         EssenceSubDescriptor.J2KCorrespondingProfile.set_has_value();
+  }
+
+  // Extended capabilities
+
+  if (PDesc.ExtendedCapabilities.Pcap == 0) {
+
+         EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(false);
+
+  } else {
+
+         EssenceSubDescriptor.J2KExtendedCapabilities.get().Pcap = PDesc.ExtendedCapabilities.Pcap;
+
+         std::copy(PDesc.ExtendedCapabilities.Ccap,
+                 PDesc.ExtendedCapabilities.Ccap + JP2K::MaxCapabilities,
+                 EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap);
+
+         EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(true);
+
+  }
+
   return RESULT_OK;
 }
 
@@ -384,6 +433,65 @@ ASDCP::MD_to_JP2K_PDesc(const ASDCP::MXF::GenericPictureEssenceDescriptor&  Esse
         EssenceSubDescriptor.QuantizationDefault.const_get().Length());
   
   PDesc.QuantizationDefault.SPqcdLength = EssenceSubDescriptor.QuantizationDefault.const_get().Length() - 1;
+
+  // Profile
+
+  std::fill(PDesc.Profile.Pprf, PDesc.Profile.Pprf + JP2K::MaxPRFN, 0);
+
+  if (EssenceSubDescriptor.J2KProfile.empty() ||
+         EssenceSubDescriptor.J2KProfile.const_get().size() == 0) {
+
+         PDesc.Profile.N = 0;
+
+  } else {
+
+         PDesc.Profile.N = EssenceSubDescriptor.J2KProfile.const_get().size();
+
+         std::copy(EssenceSubDescriptor.J2KProfile.const_get().begin(),
+                 EssenceSubDescriptor.J2KProfile.const_get().end(),
+                 PDesc.Profile.Pprf);
+
+  }
+
+  // Corresponding profile
+
+  std::fill(PDesc.CorrespondingProfile.Pcpf, PDesc.CorrespondingProfile.Pcpf + JP2K::MaxCPFN, 0);
+
+  if (EssenceSubDescriptor.J2KCorrespondingProfile.empty() ||
+         EssenceSubDescriptor.J2KCorrespondingProfile.const_get().size() == 0) {
+
+         PDesc.CorrespondingProfile.N = 0;
+
+  }
+  else {
+
+         PDesc.CorrespondingProfile.N = EssenceSubDescriptor.J2KCorrespondingProfile.const_get().size();
+
+         std::copy(EssenceSubDescriptor.J2KCorrespondingProfile.const_get().begin(),
+                 EssenceSubDescriptor.J2KCorrespondingProfile.const_get().end(),
+                 PDesc.CorrespondingProfile.Pcpf);
+
+  }
+
+  // Extended capabilities
+
+  std::fill(PDesc.ExtendedCapabilities.Ccap, PDesc.ExtendedCapabilities.Ccap + JP2K::MaxCapabilities, 0);
+
+  if (EssenceSubDescriptor.J2KExtendedCapabilities.empty()) {
+
+         PDesc.ExtendedCapabilities.Pcap = 0;
+
+  }
+  else {
+
+         PDesc.ExtendedCapabilities.Pcap = EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Pcap;
+
+         std::copy(EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap,
+                 EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap + JP2K::MaxCapabilities,
+                 PDesc.ExtendedCapabilities.Ccap);
+
+  }
+
   return RESULT_OK;
 }
 

diff --git a/src/KM_util.h b/src/KM_util.h
index ab5a837f5e5fcbb7add7c9277ef23ab38386359d..8a71ef7fe5d8208fc2c7a33ade498c6f8f1dc0bb 100755 (executable)
--- a/src/KM_util.h
+++ b/src/KM_util.h
@@ -269,6 +269,8 @@ namespace Kumu
       bool   HasValue() const { return true; }
       ui32_t ArchiveLength() const { return sizeof(ui16_t); }
 
+         operator ui16_t() const { return value; }
+
       bool   Archive(MemIOWriter* Writer) const {
        if ( Writer == 0 ) return false;
        return Writer->WriteUi16BE(value);

diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp
index ec55f87315480877c553aff60a168ce79a484d26..7346b6c66006ee2a29931167a6f4ff3ea45ec982 100755 (executable)
--- a/src/MXFTypes.cpp
+++ b/src/MXFTypes.cpp
@@ -785,7 +785,7 @@ ASDCP::MXF::J2KExtendedCapabilities::Archive(Kumu::MemIOWriter* Writer) const {
 
   for ( int i = 0; i < JP2K::MaxCapabilities; ++i )
     {
-      if ( ! Writer->WriteUi16BE(Ccapi[i]) )
+      if ( ! Writer->WriteUi16BE(Ccap[i]) )
         {
           return false;
         }
@@ -804,7 +804,7 @@ ASDCP::MXF::J2KExtendedCapabilities::Unarchive(Kumu::MemIOReader* Reader) {
 
   for ( int i = 0; i < JP2K::MaxCapabilities; ++i )
     {
-      if ( ! Reader->ReadUi16BE(&Ccapi[i]) )
+      if ( ! Reader->ReadUi16BE(&Ccap[i]) )
         {
           return false;
         }
@@ -823,7 +823,7 @@ ASDCP::MXF::J2KExtendedCapabilities::EncodeString(char* str_buf, ui32_t buf_len)
     {
       for ( int i = 0; i < JP2K::MaxCapabilities; ++i )
         {
-         snprintf(str_buf+(i*3), 4, "%02hx.", Ccapi[i]);
+         snprintf(str_buf+(i*3), 4, "%02hx.", Ccap[i]);
         }
 
       str_buf[str_len-1] = 0;

diff --git a/src/MXFTypes.h b/src/MXFTypes.h
index a39c96711f7bf4fb2fbae5a565cf1543e1d68c0d..39f75d5caceb3b01e55086a98a05ac2b7cea9c4c 100755 (executable)
--- a/src/MXFTypes.h
+++ b/src/MXFTypes.h
@@ -694,7 +694,7 @@ namespace ASDCP
         {
         public:
          ui32_t Pcap;
-         ui16_t Ccapi[JP2K::MaxCapabilities];
+         ui16_t Ccap[JP2K::MaxCapabilities];
        
          bool HasValue() const { return true; }
          ui32_t ArchiveLength() const { return 0; }