From ea1f0d2be28bf833d792a8dd66c94e1d0b0525bd Mon Sep 17 00:00:00 2001 From: jhurst Date: Sat, 30 Nov 2019 08:27:39 -0800 Subject: Finished implementation of J2KExtendedCapabilities --- src/MXFTypes.cpp | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 1 deletion(-) (limited to 'src/MXFTypes.cpp') diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp index a98a4d2..30e36b9 100755 --- a/src/MXFTypes.cpp +++ b/src/MXFTypes.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2016, John Hurst +Copyright (c) 2005-2019, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -774,6 +774,69 @@ ASDCP::MXF::Raw::EncodeString(char* str_buf, ui32_t buf_len) const return str_buf; } + +// +bool +ASDCP::MXF::J2KExtendedCapabilities::Archive(Kumu::MemIOWriter* Writer) const { + if ( ! Writer->WriteUi8(Pcap) ) + { + return false; + } + + for ( int i = 0; i < JP2K::MaxCapabilities; ++i ) + { + if ( ! Writer->WriteUi16BE(Ccapi[i]) ) + { + return false; + } + } + + return true; +} + +// +bool +ASDCP::MXF::J2KExtendedCapabilities::Unarchive(Kumu::MemIOReader* Reader) { + if ( ! Reader->ReadUi8(&Pcap) ) + { + return false; + } + + for ( int i = 0; i < JP2K::MaxCapabilities; ++i ) + { + if ( ! Reader->ReadUi16BE(&Ccapi[i]) ) + { + return false; + } + } + + return true; +} + +// +const char* +ASDCP::MXF::J2KExtendedCapabilities::EncodeString(char* str_buf, ui32_t buf_len) const +{ + const int str_len = ( sizeof(ui16_t) + 1 ) * JP2K::MaxCapabilities; + + if ( Pcap != 0 && buf_len > str_len ) + { + for ( int i = 0; i < JP2K::MaxCapabilities; ++i ) + { + snprintf(str_buf+(i*3), 4, "%02hx.", Ccapi[i]); + } + + str_buf[str_len-1] = 0; + } + else + { + str_buf[0] = 0; + } + + return str_buf; +} + + // // end MXFTypes.cpp // -- cgit v1.2.3 From fb0d1d9e580641c2d7832dcb94661dcd1ebe3374 Mon Sep 17 00:00:00 2001 From: jhurst Date: Sat, 30 Nov 2019 08:40:31 -0800 Subject: Changed Pcap from ui8_t to ui32_t --- src/MXFTypes.cpp | 4 ++-- src/MXFTypes.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'src/MXFTypes.cpp') diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp index 30e36b9..ec55f87 100755 --- a/src/MXFTypes.cpp +++ b/src/MXFTypes.cpp @@ -778,7 +778,7 @@ ASDCP::MXF::Raw::EncodeString(char* str_buf, ui32_t buf_len) const // bool ASDCP::MXF::J2KExtendedCapabilities::Archive(Kumu::MemIOWriter* Writer) const { - if ( ! Writer->WriteUi8(Pcap) ) + if ( ! Writer->WriteUi32BE(Pcap) ) { return false; } @@ -797,7 +797,7 @@ ASDCP::MXF::J2KExtendedCapabilities::Archive(Kumu::MemIOWriter* Writer) const { // bool ASDCP::MXF::J2KExtendedCapabilities::Unarchive(Kumu::MemIOReader* Reader) { - if ( ! Reader->ReadUi8(&Pcap) ) + if ( ! Reader->ReadUi32BE(&Pcap) ) { return false; } diff --git a/src/MXFTypes.h b/src/MXFTypes.h index 3220108..a39c967 100755 --- a/src/MXFTypes.h +++ b/src/MXFTypes.h @@ -693,7 +693,7 @@ namespace ASDCP class J2KExtendedCapabilities : public Kumu::IArchive { public: - ui8_t Pcap; // TODO: is this the right type? + ui32_t Pcap; ui16_t Ccapi[JP2K::MaxCapabilities]; bool HasValue() const { return true; } -- cgit v1.2.3 From dd3acfff947ca52e1a3260243cb38f7035626282 Mon Sep 17 00:00:00 2001 From: Pierre-Anthony Lemieux Date: Sat, 30 Nov 2019 14:32:56 -0800 Subject: Implemented J2K desc to/from MD --- src/AS_DCP.h | 2 +- src/AS_DCP_JP2K.cpp | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/KM_util.h | 2 + src/MXFTypes.cpp | 6 +-- src/MXFTypes.h | 2 +- 5 files changed, 115 insertions(+), 5 deletions(-) (limited to 'src/MXFTypes.cpp') diff --git a/src/AS_DCP.h b/src/AS_DCP.h index b28f114..0948cbf 100755 --- 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 ccb6b09..a980e0f 100755 --- 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 #include +#include 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 ab5a837..8a71ef7 100755 --- 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 ec55f87..7346b6c 100755 --- 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 a39c967..39f75d5 100755 --- 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; } -- cgit v1.2.3 From 166e7b4b202bc8febb13b59710579fbbd724e2b6 Mon Sep 17 00:00:00 2001 From: Pierre-Anthony Lemieux Date: Tue, 17 Dec 2019 12:05:00 -0800 Subject: - Added support for optional CPF, CAP and PRF segments - Fixed encoding of J2KExtendedCapabilities --- src/AS_DCP.h | 10 +++++++--- src/AS_DCP_JP2K.cpp | 38 ++++++++++++++++++++++++-------------- src/JP2K.h | 7 ++++++- src/JP2K_Codestream_Parser.cpp | 19 ++++++++++--------- src/JP2K_Sequence_Parser.cpp | 4 +++- src/MXFTypes.cpp | 16 +++++----------- src/MXFTypes.h | 2 +- 7 files changed, 56 insertions(+), 40 deletions(-) (limited to 'src/MXFTypes.cpp') diff --git a/src/AS_DCP.h b/src/AS_DCP.h index 0948cbf..74991f6 100755 --- a/src/AS_DCP.h +++ b/src/AS_DCP.h @@ -1051,6 +1051,9 @@ namespace ASDCP { const ui8_t MaxCapabilities = 32; const ui16_t MaxPRFN = 4; const ui16_t MaxCPFN = 4; + const i8_t NoExtendedCapabilitiesSignaled = -1; + const ui16_t NoPRFSignaled = 0; + const ui16_t NoCPFSignaled = 0; #pragma pack(1) struct ImageComponent_t // ISO 15444-1 Annex A.5.1 @@ -1092,18 +1095,19 @@ 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] + i8_t N; // Number of Ccap elements, or NoExtendedCapabilitiesSignaled if no Extended Capabilities are signaled + ui16_t Ccap[MaxCapabilities]; }; struct Profile_t // ISO 15444-1 { - ui16_t N; // N = 0 means that the profile is signaled through Rsiz exclusively + ui16_t N; // N = NoPRFSignaled means that 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 N; // N = NoCPFSignaled means that no corresponding profile is signaled ui16_t Pcpf[MaxCPFN]; // Pcpf^i in ISO/IEC 15444-1 corresponds to Pcpf[i -1] }; diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp index a980e0f..129f53d 100755 --- a/src/AS_DCP_JP2K.cpp +++ b/src/AS_DCP_JP2K.cpp @@ -128,19 +128,19 @@ ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc) } } - if (PDesc.ExtendedCapabilities.Pcap != 0) { + if (PDesc.ExtendedCapabilities.N != JP2K::NoExtendedCapabilitiesSignaled && 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++) { + for (i32_t b = 0, i = 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::hex << std::showbase << PDesc.ExtendedCapabilities.Ccap[i++] << std::dec << std::noshowbase << std::endl; } @@ -259,16 +259,20 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream) } } - fprintf(stream, "Extended Capabilities: %x\n", PDesc.ExtendedCapabilities.Pcap); + if (PDesc.ExtendedCapabilities.N != JP2K::NoExtendedCapabilitiesSignaled) { - for (i32_t b = 0; b < JP2K::MaxCapabilities; b++) { + fprintf(stream, "Extended Capabilities: %x\n", PDesc.ExtendedCapabilities.Pcap); - if ((PDesc.ExtendedCapabilities.Pcap >> b) & 0x1) { + for (i32_t b = 0, i = 0; b < JP2K::MaxCapabilities && i < PDesc.ExtendedCapabilities.N; b++) { - fprintf(stream, " Ccap(%d): %hx\n", JP2K::MaxCapabilities - b, PDesc.ExtendedCapabilities.Ccap[JP2K::MaxCapabilities - b - 1]); + if ((PDesc.ExtendedCapabilities.Pcap >> (JP2K::MaxCapabilities - b - 1)) & 0x1) { - } - } + fprintf(stream, " Ccap(%d): %hx\n", b + 1, PDesc.ExtendedCapabilities.Ccap[i++]); + + } + } + + } } @@ -360,7 +364,9 @@ ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc, // Extended capabilities - if (PDesc.ExtendedCapabilities.Pcap == 0) { + if (PDesc.ExtendedCapabilities.N == JP2K::NoExtendedCapabilitiesSignaled) { + + /* No extended capabilities are signaled */ EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(false); @@ -368,9 +374,11 @@ ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc, EssenceSubDescriptor.J2KExtendedCapabilities.get().Pcap = PDesc.ExtendedCapabilities.Pcap; + EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap.resize(PDesc.ExtendedCapabilities.N); + std::copy(PDesc.ExtendedCapabilities.Ccap, - PDesc.ExtendedCapabilities.Ccap + JP2K::MaxCapabilities, - EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap); + PDesc.ExtendedCapabilities.Ccap + PDesc.ExtendedCapabilities.N, + EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap.begin()); EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(true); @@ -480,14 +488,16 @@ ASDCP::MD_to_JP2K_PDesc(const ASDCP::MXF::GenericPictureEssenceDescriptor& Esse if (EssenceSubDescriptor.J2KExtendedCapabilities.empty()) { PDesc.ExtendedCapabilities.Pcap = 0; + PDesc.ExtendedCapabilities.N = JP2K::NoExtendedCapabilitiesSignaled; } else { PDesc.ExtendedCapabilities.Pcap = EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Pcap; + PDesc.ExtendedCapabilities.N = EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap.size(); - std::copy(EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap, - EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap + JP2K::MaxCapabilities, + std::copy(EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap.begin(), + EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap.end(), PDesc.ExtendedCapabilities.Ccap); } diff --git a/src/JP2K.h b/src/JP2K.h index 5599b2b..8128de5 100755 --- a/src/JP2K.h +++ b/src/JP2K.h @@ -260,7 +260,7 @@ namespace JP2K public: PRF(const Marker& M) { - assert(M.m_Type == MRK_CPF); + assert(M.m_Type == MRK_PRF); m_Data = (ui16_t*) M.m_Data; m_N = M.m_DataSize >> 1; @@ -282,6 +282,8 @@ namespace JP2K ui32_t m_Pcap; + i8_t m_N; + KM_NO_COPY_CONSTRUCT(CAP); CAP(); @@ -291,12 +293,15 @@ namespace JP2K m_Data = (ui16_t *) (M.m_Data + 4); m_Pcap = KM_i32_BE(*(ui32_t*)(M.m_Data)); + m_N = (M.m_DataSize - 4) >> 1; } ~CAP() {} inline ui32_t pcap() const { return m_Pcap; } + inline i8_t N() const { return m_N; } + inline ui16_t ccap(ui16_t i) const { return KM_i16_BE(m_Data[2 * (i - 1)]); } void Dump(FILE* stream = 0) const; diff --git a/src/JP2K_Codestream_Parser.cpp b/src/JP2K_Codestream_Parser.cpp index 43665e6..9d55409 100755 --- a/src/JP2K_Codestream_Parser.cpp +++ b/src/JP2K_Codestream_Parser.cpp @@ -101,6 +101,12 @@ ASDCP::JP2K::ParseMetadataIntoDesc(const FrameBuffer& FB, PictureDescriptor& PDe const byte_t* p = FB.RoData(); const byte_t* end_p = p + FB.Size(); + /* initialize optional items */ + + PDesc.ExtendedCapabilities.N = JP2K::NoExtendedCapabilitiesSignaled; + PDesc.Profile.N = 0; + PDesc.CorrespondingProfile.N = 0; + while ( p < end_p && ASDCP_SUCCESS(result) ) { result = GetNextMarker(&p, NextMarker); @@ -185,19 +191,14 @@ ASDCP::JP2K::ParseMetadataIntoDesc(const FrameBuffer& FB, PictureDescriptor& PDe PDesc.ExtendedCapabilities.Pcap = CAP_.pcap(); - for(i32_t b = 32, i = 1; b > 0; b--) { - - if ( (PDesc.ExtendedCapabilities.Pcap >> (b - 1)) & 0x1 ) { + PDesc.ExtendedCapabilities.N = CAP_.N(); - PDesc.ExtendedCapabilities.Ccap[32 - b] = CAP_.ccap(i++); + for (i32_t i = 0; i < CAP_.N(); i++) { - } else { - - PDesc.ExtendedCapabilities.Ccap[32 - b] = 0; - - } + PDesc.ExtendedCapabilities.Ccap[i] = CAP_.ccap(i); } + } break; diff --git a/src/JP2K_Sequence_Parser.cpp b/src/JP2K_Sequence_Parser.cpp index a1ece3f..e8d779c 100755 --- a/src/JP2K_Sequence_Parser.cpp +++ b/src/JP2K_Sequence_Parser.cpp @@ -255,7 +255,9 @@ operator==(const ASDCP::JP2K::ExtendedCapabilities_t& lhs, const ASDCP::JP2K::Ex { if (lhs.Pcap != rhs.Pcap) return false; - for (ui32_t i = 0; i < JP2K::MaxCapabilities; i++) + if (lhs.N != rhs.N) return false; + + for (ui32_t i = 0; i < lhs.N; i++) { if (lhs.Ccap[i] != rhs.Ccap[i]) return false; diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp index 7346b6c..39d928b 100755 --- a/src/MXFTypes.cpp +++ b/src/MXFTypes.cpp @@ -783,12 +783,9 @@ ASDCP::MXF::J2KExtendedCapabilities::Archive(Kumu::MemIOWriter* Writer) const { return false; } - for ( int i = 0; i < JP2K::MaxCapabilities; ++i ) + if ( ! Ccap.Archive(Writer) ) { - if ( ! Writer->WriteUi16BE(Ccap[i]) ) - { - return false; - } + return false; } return true; @@ -802,12 +799,9 @@ ASDCP::MXF::J2KExtendedCapabilities::Unarchive(Kumu::MemIOReader* Reader) { return false; } - for ( int i = 0; i < JP2K::MaxCapabilities; ++i ) + if ( ! Ccap.Unarchive(Reader) ) { - if ( ! Reader->ReadUi16BE(&Ccap[i]) ) - { - return false; - } + return false; } return true; @@ -821,7 +815,7 @@ ASDCP::MXF::J2KExtendedCapabilities::EncodeString(char* str_buf, ui32_t buf_len) if ( Pcap != 0 && buf_len > str_len ) { - for ( int i = 0; i < JP2K::MaxCapabilities; ++i ) + for ( int i = 0; i < Ccap.size(); ++i ) { snprintf(str_buf+(i*3), 4, "%02hx.", Ccap[i]); } diff --git a/src/MXFTypes.h b/src/MXFTypes.h index 39f75d5..eb8b3df 100755 --- a/src/MXFTypes.h +++ b/src/MXFTypes.h @@ -694,7 +694,7 @@ namespace ASDCP { public: ui32_t Pcap; - ui16_t Ccap[JP2K::MaxCapabilities]; + Array Ccap; bool HasValue() const { return true; } ui32_t ArchiveLength() const { return 0; } -- cgit v1.2.3