Added support for CAP, PRF and CPF markers

Improved Marker vs Marker Segment discrimination

7 files changed, 386 insertions, 32 deletions

diff --git a/src/AS_DCP.h b/src/AS_DCP.h
index 96d066c..b28f114 100755
--- a/src/AS_DCP.h
+++ b/src/AS_DCP.h
@@ -1048,6 +1048,9 @@ namespace ASDCP {
       const ui32_t MaxComponents = 3;
       const ui32_t MaxPrecincts = 32; // ISO 15444-1 Annex A.6.1
       const ui32_t MaxDefaults = 256; // made up
+      const ui8_t  MaxCapabilities = 32;
+			const ui16_t MaxPRFN = 4;
+			const ui16_t MaxCPFN = 4;
 
 #pragma pack(1)
       struct ImageComponent_t  // ISO 15444-1 Annex A.5.1
@@ -1085,6 +1088,25 @@ namespace ASDCP {
 	ui8_t  SPqcd[MaxDefaults];
 	ui8_t  SPqcdLength;
       };
+
+      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]
+      };
+
+			struct Profile_t // ISO 15444-1
+      {
+	ui16_t  N; // N = 0 means that the profile is signaled through Rsiz exclusively
+	ui16_t  Pprf[MaxPRFN]; // Pprf^i in ISO/IEC 15444-1 corresponds to Pprf[i -1]
+      };
+
+			struct CorrespondingProfile_t // ISO 15444-1
+      {
+	ui16_t  N; // N = 0 means that no corresponding profile is signaled
+	ui16_t  Pcpf[MaxCPFN]; // Pcpf^i in ISO/IEC 15444-1 corresponds to Pcpf[i -1]
+      };
+
 #pragma pack()
 
       struct PictureDescriptor
@@ -1108,6 +1130,9 @@ namespace ASDCP {
 	ImageComponent_t      ImageComponents[MaxComponents];
 	CodingStyleDefault_t  CodingStyleDefault;
 	QuantizationDefault_t QuantizationDefault;
+  ExtendedCapabilities_t ExtendedCapabilities;
+  Profile_t   Profile;
+	CorrespondingProfile_t   CorrespondingProfile;    
       };
 
       // Print debugging information to std::ostream
diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp
index a4bffc6..ccb6b09 100755
--- a/src/AS_DCP_JP2K.cpp
+++ b/src/AS_DCP_JP2K.cpp
@@ -106,6 +106,46 @@ ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc)
   strm << "              SPqcd: " << Kumu::bin2hex(PDesc.QuantizationDefault.SPqcd, PDesc.QuantizationDefault.SPqcdLength, tmp_buf, MaxDefaults*2)
        << std::endl;
 
+  if (PDesc.Profile.N != 0) {
+	  strm << "Profile:" << std::endl;
+
+	  for (ui16_t i = 0; i < PDesc.Profile.N; i++) {
+		  strm << "              Pprf(" << (i + 1) << "): "
+			  << std::hex << std::showbase << PDesc.Profile.Pprf[i] << std::dec << std::noshowbase
+			  << std::endl;
+	  }
+  }
+
+  if (PDesc.CorrespondingProfile.N != 0) {
+	  strm << "Corresponding Profile:" << std::endl;
+
+	  for (ui16_t i = 0; i < PDesc.CorrespondingProfile.N; i++) {
+
+		  strm << "              Pcpf(" << (i + 1) << "): "
+			  << std::hex << std::showbase <<  PDesc.CorrespondingProfile.Pcpf[i] << std::dec << std::noshowbase
+			  << std::endl;
+	  }
+  }
+
+  if (PDesc.ExtendedCapabilities.Pcap != 0) {
+
+	  strm << "Extended Capabilities:" << std::endl;
+
+
+	  strm << "                     Pcap:" << PDesc.ExtendedCapabilities.Pcap << std::endl;
+
+	  for (i32_t b = 0; b < JP2K::MaxCapabilities; b++) {
+
+		  if ((PDesc.ExtendedCapabilities.Pcap >> b) & 0x1) {
+
+			  strm << "              Ccap(" << (JP2K::MaxCapabilities - b) << "): " <<
+				  std::hex << std::showbase << PDesc.ExtendedCapabilities.Ccap[JP2K::MaxCapabilities - b - 1] << std::dec << std::noshowbase
+				  << std::endl;
+
+		  }
+	  }
+  }
+
   return strm;
 }
 
@@ -197,6 +237,38 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream)
 	  Kumu::bin2hex(PDesc.QuantizationDefault.SPqcd, PDesc.QuantizationDefault.SPqcdLength,
 			tmp_buf, MaxDefaults*2)
 	  );
+
+
+  if (PDesc.Profile.N != 0) {
+	  fprintf(stream, "               Profile:\n");
+
+	  for (ui16_t i = 0; i < PDesc.Profile.N; i++) {
+
+		  fprintf(stream, "              Pprf(%d): %hx\n", i + 1, PDesc.Profile.Pprf[i]);
+
+	  }
+  }
+
+  if (PDesc.CorrespondingProfile.N != 0) {
+	  fprintf(stream, "Corresponding Profile:\n");
+
+	  for (ui16_t i = 0; i < PDesc.CorrespondingProfile.N; i++) {
+		  fprintf(stream, "              Pcpf(%d): %hx\n", i + 1, PDesc.CorrespondingProfile.Pcpf[i]);
+
+	  }
+  }
+
+  fprintf(stream, "Extended Capabilities: %x\n", PDesc.ExtendedCapabilities.Pcap);
+
+	for (i32_t b = 0; b < JP2K::MaxCapabilities; b++) {
+
+		if ((PDesc.ExtendedCapabilities.Pcap >> b) & 0x1) {
+
+			fprintf(stream, "           Ccap(%d): %hx\n", JP2K::MaxCapabilities - b, PDesc.ExtendedCapabilities.Ccap[JP2K::MaxCapabilities - b - 1]);
+
+		}
+	}
+  
 }
 
 
diff --git a/src/JP2K.cpp b/src/JP2K.cpp
index a0f2a8a..4d2c130 100755
--- a/src/JP2K.cpp
+++ b/src/JP2K.cpp
@@ -37,45 +37,17 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using Kumu::DefaultLogSink;
 
 
-// when indexed with the second byte of a marker code, this table will procuce one of
-// two values:
-//   0 - the marker is a standalone marker
-//   1 - the marker designates a marker segment
-//
-const byte_t MarkerSegmentMap[] =
-  {
-    /*      0   1   2   3   4   5   6   7      8   9   a   b   c   d   e   f */
-    /* 0 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 0
-    /* 1 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 1
-    /* 2 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 2
-    /* 3 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 3
-    /* 4 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 4
-    /* 5 */ 0,  1,  1,  1,  1,  1,  0,  1,     1,  0,  0,  0,  1,  1,  1,  1, // 5
-    /* 6 */ 1,  1,  0,  1,  1,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 6
-    /* 7 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 7
-    /* 8 */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 8
-    /* 9 */ 1,  1,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // 9
-    /* a */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // a
-    /* b */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // b
-    /* c */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // c
-    /* d */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // d
-    /* e */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // e
-    /* f */ 0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0, // f
-    /*      0   1   2   3   4   5   6   7      8   9   a   b   c   d   e   f */
-  };
-
-
 //
 ASDCP::Result_t
 ASDCP::JP2K::GetNextMarker(const byte_t** buf, JP2K::Marker& Marker)
 {
   assert((buf != 0) && (*buf != 0 ));
   
-  if ( **buf != 0xff )
+  if (*(*buf)++ != 0xff )
     return ASDCP::RESULT_FAIL;
 
-  Marker.m_IsSegment = (MarkerSegmentMap[*(++(*buf))] == 1);
   Marker.m_Type = (Marker_t)(0xff00 | *(*buf)++);
+  Marker.m_IsSegment = Marker.m_Type != MRK_SOC && Marker.m_Type != MRK_SOD && Marker.m_Type != MRK_EOC;
 
   if ( Marker.m_IsSegment )
     {
@@ -86,13 +58,13 @@ ASDCP::JP2K::GetNextMarker(const byte_t** buf, JP2K::Marker& Marker)
       *buf += Marker.m_DataSize;
     }
 
-
+  /* TODO: why is this here?
   if ( Marker.m_DataSize != 0 && Marker.m_DataSize < 3 )
     {
       DefaultLogSink().Error("Illegal data size: %u\n", Marker.m_DataSize);
       return ASDCP::RESULT_FAIL;
     }
-
+	*/
   return ASDCP::RESULT_OK;
 }
 
@@ -227,6 +199,78 @@ ASDCP::JP2K::Accessor::COM::Dump(FILE* stream) const
     }
 }
 
+//
+void
+ASDCP::JP2K::Accessor::PRF::Dump(FILE* stream) const
+{
+  if ( stream == 0 )
+    stream = stderr;
+
+  fprintf(stream, "PRF: \n");
+
+  if (N() == 0) {
+
+	  fprintf(stream, "     N/A");
+
+  } else {
+
+	  for (ui16_t i = 1; i <= N(); i++) {
+		  fprintf(stream, "pprf(%d): %d\n", i, pprf(i));
+	  }
+
+  }
+}
+
+//
+void
+ASDCP::JP2K::Accessor::CPF::Dump(FILE* stream) const
+{
+  if ( stream == 0 )
+    stream = stderr;
+
+  fprintf(stream, "CPF: \n");
+
+  if (N() == 0) {
+
+	  fprintf(stream, "     N/A");
+
+  } else {
+
+	  for (ui16_t i = 1; i <= N(); i++) {
+		  fprintf(stream, "pcpf(%d): %d\n", i, pcpf(i));
+	  }
+
+  }
+}
+
+
+//
+void
+ASDCP::JP2K::Accessor::CAP::Dump(FILE* stream) const
+{
+  if ( stream == 0 )
+    stream = stderr;
+
+  fprintf(stream, "CAP: \n");
+
+  ui32_t pcap = this->pcap();
+
+  if (pcap == 0) {
+
+	  fprintf(stream, "     None");
+
+  } else {
+
+	  for (i32_t b = 32, i = 1; b > 0; b--) {
+
+		  if ((pcap >> (32 - b)) & 0x1) {
+
+			  fprintf(stream, "     ccap(%d): %d\n", b, this->ccap(i++));
+
+		  }
+	  }
+  }
+}
 
 //-------------------------------------------------------------------------------------------------------
 //
@@ -274,6 +318,9 @@ ASDCP::JP2K::GetMarkerString(Marker_t m)
     case MRK_EPH: return "EPH: End of packet header"; break;
     case MRK_CRG: return "CRG: Component registration"; break;
     case MRK_COM: return "COM: Comment"; break;
+    case MRK_CPF: return "CPF: Corresponding profile"; break;
+    case MRK_CAP: return "CAP: Capabilities"; break;
+    case MRK_PRF: return "PRF: Profile"; break;
     }
 
   return "Unknown marker code";
diff --git a/src/JP2K.h b/src/JP2K.h
index b043dfc..5599b2b 100755
--- a/src/JP2K.h
+++ b/src/JP2K.h
@@ -54,9 +54,12 @@ namespace JP2K
       MRK_SOT = 0xff90, // Start of tile-part
       MRK_SOD = 0xff93, // Start of data
       MRK_EOC = 0xffd9, // End of codestream
+      MRK_CAP = 0xff50,  // Extended capabilities
       MRK_SIZ = 0xff51, // Image and tile size
       MRK_COD = 0xff52, // Coding style default
       MRK_COC = 0xff53, // Coding style component
+      MRK_PRF = 0xff56, // Profile
+      MRK_CPF = 0xff59, // Corresponding profile
       MRK_RGN = 0xff5e, // Region of interest
       MRK_QCD = 0xff5c, // Quantization default
       MRK_QCC = 0xff5d, // Quantization component
@@ -219,6 +222,85 @@ namespace JP2K
 	  inline ui32_t CommentSize() const { return m_DataSize; }
 	  void Dump(FILE* stream = 0) const;
 	};
+
+      // Corresponding Profile
+      class CPF {
+
+          const ui16_t* m_Data;
+		  ui16_t m_N;
+
+          KM_NO_COPY_CONSTRUCT(CPF);
+          CPF();
+
+      public:
+          CPF(const Marker& M) {
+              assert(M.m_Type == MRK_CPF);
+
+              m_Data = (ui16_t*) M.m_Data;
+			  m_N = M.m_DataSize >> 1;
+          }
+
+          ~CPF() {}
+
+          inline ui16_t N() const { return m_N; }
+
+          inline ui16_t pcpf(ui16_t i) const { return KM_i16_BE(m_Data[2 * (i - 1)]); }
+
+          void Dump(FILE* stream = 0) const;
+      };
+
+      // Profile
+      class PRF {
+
+          const ui16_t* m_Data;
+		  ui16_t m_N;
+
+          KM_NO_COPY_CONSTRUCT(PRF);
+          PRF();
+
+      public:
+          PRF(const Marker& M) {
+              assert(M.m_Type == MRK_CPF);
+
+			  m_Data = (ui16_t*) M.m_Data;
+			  m_N = M.m_DataSize >> 1;
+		  }
+
+          ~PRF() {}
+
+          inline ui16_t N() const { return m_N; }
+
+          inline ui16_t pprf(ui16_t i) const { return KM_i16_BE(m_Data[2 * (i - 1)]); }
+
+          void Dump(FILE* stream = 0) const;
+      };
+
+      // Extended capabilities
+      class CAP {
+
+          const ui16_t* m_Data;
+
+		  ui32_t m_Pcap;
+
+          KM_NO_COPY_CONSTRUCT(CAP);
+          CAP();
+
+      public:
+          CAP(const Marker& M) {
+              assert(M.m_Type == MRK_CAP);
+
+              m_Data = (ui16_t *) (M.m_Data + 4);
+			  m_Pcap = KM_i32_BE(*(ui32_t*)(M.m_Data));
+          }
+
+          ~CAP() {}
+
+          inline ui32_t pcap() const { return m_Pcap; }
+
+          inline ui16_t ccap(ui16_t i) const { return KM_i16_BE(m_Data[2 * (i - 1)]); }
+
+          void Dump(FILE* stream = 0) const;
+      };
     } // namespace Accessor
 } // namespace JP2K
 } // namespace ASDCP
diff --git a/src/JP2K_Codestream_Parser.cpp b/src/JP2K_Codestream_Parser.cpp
index 0ed2649..43665e6 100755
--- a/src/JP2K_Codestream_Parser.cpp
+++ b/src/JP2K_Codestream_Parser.cpp
@@ -178,6 +178,71 @@ ASDCP::JP2K::ParseMetadataIntoDesc(const FrameBuffer& FB, PictureDescriptor& PDe
 	  memcpy(&PDesc.QuantizationDefault, NextMarker.m_Data, NextMarker.m_DataSize);
 	  PDesc.QuantizationDefault.SPqcdLength = NextMarker.m_DataSize - 1;
 	  break;
+
+	case MRK_CAP:
+	  {
+	    Accessor::CAP CAP_(NextMarker);
+	    
+			PDesc.ExtendedCapabilities.Pcap = CAP_.pcap();
+
+			for(i32_t b = 32, i = 1; b > 0; b--) {
+
+				if ( (PDesc.ExtendedCapabilities.Pcap >> (b - 1)) & 0x1 ) {
+
+					PDesc.ExtendedCapabilities.Ccap[32 - b] = CAP_.ccap(i++);
+
+				} else {
+
+					PDesc.ExtendedCapabilities.Ccap[32 - b] = 0;
+
+				}
+
+			}
+	  }
+	  break;
+
+		case MRK_PRF:
+	  {
+	    Accessor::PRF PRF_(NextMarker);
+
+		ui16_t n = PRF_.N();
+
+		if ( n > MaxPRFN )
+	    {
+	      DefaultLogSink().Error("Number (%d) of Pprf^i exceeds maximum supported\n", n);
+	      return RESULT_RAW_FORMAT;
+	    }
+
+			PDesc.Profile.N = n;
+
+			for(i32_t i = 0; i < n ; i++) {
+
+				PDesc.Profile.Pprf[i] = PRF_.pprf(i+1);
+			}
+	  }
+	  break;
+
+		case MRK_CPF:
+	  {
+	    Accessor::CPF CPF_(NextMarker);
+
+		ui16_t n = CPF_.N();
+
+		if ( n > MaxCPFN )
+	    {
+	      DefaultLogSink().Error("Number (%d) of Pcpf^i exceeds maximum supported\n", n);
+	      return RESULT_RAW_FORMAT;
+	    }
+
+			PDesc.CorrespondingProfile.N = n;
+
+			for(i32_t i = 0; i < n; i++) {
+
+				PDesc.CorrespondingProfile.Pcpf[i] = CPF_.pcpf(i+1);
+			}
+	  }
+	  break;
+
 	}
     }
 
diff --git a/src/JP2K_Sequence_Parser.cpp b/src/JP2K_Sequence_Parser.cpp
index a0fd5d0..a1ece3f 100755
--- a/src/JP2K_Sequence_Parser.cpp
+++ b/src/JP2K_Sequence_Parser.cpp
@@ -251,6 +251,51 @@ operator==(const ASDCP::JP2K::CodingStyleDefault_t& lhs, const ASDCP::JP2K::Codi
 
 //
 bool
+operator==(const ASDCP::JP2K::ExtendedCapabilities_t& lhs, const ASDCP::JP2K::ExtendedCapabilities_t& rhs)
+{
+	if (lhs.Pcap != rhs.Pcap) return false;
+
+	for (ui32_t i = 0; i < JP2K::MaxCapabilities; i++)
+	{
+		if (lhs.Ccap[i] != rhs.Ccap[i])
+			return false;
+	}
+
+	return true;
+}
+
+//
+bool
+operator==(const ASDCP::JP2K::CorrespondingProfile_t& lhs, const ASDCP::JP2K::CorrespondingProfile_t& rhs)
+{
+	if (lhs.N != rhs.N) return false;
+
+	for (ui32_t i = 0; i < lhs.N; i++)
+	{
+		if (lhs.Pcpf[i] != rhs.Pcpf[i])
+			return false;
+	}
+
+	return true;
+}
+
+//
+bool
+operator==(const ASDCP::JP2K::Profile_t& lhs, const ASDCP::JP2K::Profile_t& rhs)
+{
+	if (lhs.N != rhs.N) return false;
+
+	for (ui32_t i = 0; i < lhs.N; i++)
+	{
+		if (lhs.Pprf[i] != rhs.Pprf[i])
+			return false;
+	}
+
+	return true;
+}
+
+//
+bool
 operator==(const ASDCP::JP2K::PictureDescriptor& lhs, const ASDCP::JP2K::PictureDescriptor& rhs)
 {
   if ( lhs.EditRate != rhs.EditRate ) return false;
@@ -271,6 +316,9 @@ operator==(const ASDCP::JP2K::PictureDescriptor& lhs, const ASDCP::JP2K::Picture
   if ( lhs.Csize != rhs.Csize ) return false;
   if ( ! ( lhs.CodingStyleDefault == rhs.CodingStyleDefault ) ) return false;
   if ( ! ( lhs.QuantizationDefault == rhs.QuantizationDefault ) ) return false;
+  if (!(lhs.Profile == rhs.Profile)) return false;
+  if (!(lhs.CorrespondingProfile == rhs.CorrespondingProfile)) return false;
+  if (!(lhs.ExtendedCapabilities == rhs.ExtendedCapabilities)) return false;
   
   for ( ui32_t i = 0; i < JP2K::MaxComponents; i++ )
     {
diff --git a/src/j2c-test.cpp b/src/j2c-test.cpp
index 9184982..bcf95d0 100755
--- a/src/j2c-test.cpp
+++ b/src/j2c-test.cpp
@@ -246,6 +246,21 @@ main(int argc, const char** argv)
 		{
 		  has_tlm = true;
 		}
+	      else if ( current_marker.m_Type == MRK_CAP )
+		{
+			Accessor::CAP CAP_(current_marker);
+			CAP_.Dump(stdout);
+		}
+	      else if ( current_marker.m_Type == MRK_PRF )
+		{
+			Accessor::PRF PRF_(current_marker);
+			PRF_.Dump(stdout);
+		}
+	      else if ( current_marker.m_Type == MRK_CPF )
+		{
+			Accessor::CPF CPF_(current_marker);
+			CPF_.Dump(stdout);
+		}
 	      else
 		{
 		  fprintf(stderr, "Unprocessed marker - %s\n", GetMarkerString(current_marker.m_Type));