X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FAS_DCP_JP2K.cpp;h=009586a0370e0efef37b8078d0b566c9aa95fd85;hb=7088ba5125e89164ccf1d4d810b819bdd2e3ccff;hp=6558a06c2b43fc66575afb67adee60c407d957dc;hpb=9bfe9676115531eb76649e1ebd5e14b904b53ae2;p=asdcplib.git diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp index 6558a06..009586a 100755 --- a/src/AS_DCP_JP2K.cpp +++ b/src/AS_DCP_JP2K.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2004-2006, John Hurst +Copyright (c) 2004-2009, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -30,16 +30,84 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "AS_DCP_internal.h" +#include +#include +using namespace ASDCP::JP2K; +using Kumu::GenRandomValue; //------------------------------------------------------------------------------------------ +static std::string JP2K_PACKAGE_LABEL = "File Package: SMPTE 429-4 frame wrapping of JPEG 2000 codestreams"; +static std::string JP2K_S_PACKAGE_LABEL = "File Package: SMPTE 429-10 frame wrapping of stereoscopic JPEG 2000 codestreams"; +static std::string PICT_DEF_LABEL = "Picture Track"; + +int s_exp_lookup[16] = { 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,2048, 4096, 8192, 16384, 32768 }; + // -const byte_t JP2KEssenceCompressionLabel[klv_key_size] = +std::ostream& +ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc) { - 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x09, - 0x04, 0x01, 0x02, 0x02, 0x03, 0x01, 0x01, 0x01 }; + strm << " AspectRatio: " << PDesc.AspectRatio.Numerator << "/" << PDesc.AspectRatio.Denominator << std::endl; + strm << " EditRate: " << PDesc.EditRate.Numerator << "/" << PDesc.EditRate.Denominator << std::endl; + strm << " SampleRate: " << PDesc.SampleRate.Numerator << "/" << PDesc.SampleRate.Denominator << std::endl; + strm << " StoredWidth: " << (unsigned) PDesc.StoredWidth << std::endl; + strm << " StoredHeight: " << (unsigned) PDesc.StoredHeight << std::endl; + strm << " Rsize: " << (unsigned) PDesc.Rsize << std::endl; + strm << " Xsize: " << (unsigned) PDesc.Xsize << std::endl; + strm << " Ysize: " << (unsigned) PDesc.Ysize << std::endl; + strm << " XOsize: " << (unsigned) PDesc.XOsize << std::endl; + strm << " YOsize: " << (unsigned) PDesc.YOsize << std::endl; + strm << " XTsize: " << (unsigned) PDesc.XTsize << std::endl; + strm << " YTsize: " << (unsigned) PDesc.YTsize << std::endl; + strm << " XTOsize: " << (unsigned) PDesc.XTOsize << std::endl; + strm << " YTOsize: " << (unsigned) PDesc.YTOsize << std::endl; + strm << " ContainerDuration: " << (unsigned) PDesc.ContainerDuration << std::endl; + + strm << "-- JPEG 2000 Metadata --" << std::endl; + strm << " ImageComponents:" << std::endl; + strm << " bits h-sep v-sep" << std::endl; + + ui32_t i; + for ( i = 0; i < PDesc.Csize; i++ ) + { + strm << " " << std::setw(4) << PDesc.ImageComponents[i].Ssize + 1 /* See ISO 15444-1, Table A11, for the origin of '+1' */ + << " " << std::setw(5) << PDesc.ImageComponents[i].XRsize + << " " << std::setw(5) << PDesc.ImageComponents[i].YRsize + << std::endl; + } + + strm << " Scod: " << (short) PDesc.CodingStyleDefault.Scod << std::endl; + strm << " ProgressionOrder: " << (short) PDesc.CodingStyleDefault.SGcod.ProgressionOrder << std::endl; + strm << " NumberOfLayers: " << (short) KM_i16_BE(Kumu::cp2i(PDesc.CodingStyleDefault.SGcod.NumberOfLayers)) << std::endl; + strm << " MultiCompTransform: " << (short) PDesc.CodingStyleDefault.SGcod.MultiCompTransform << std::endl; + strm << "DecompositionLevels: " << (short) PDesc.CodingStyleDefault.SPcod.DecompositionLevels << std::endl; + strm << " CodeblockWidth: " << (short) PDesc.CodingStyleDefault.SPcod.CodeblockWidth << std::endl; + strm << " CodeblockHeight: " << (short) PDesc.CodingStyleDefault.SPcod.CodeblockHeight << std::endl; + strm << " CodeblockStyle: " << (short) PDesc.CodingStyleDefault.SPcod.CodeblockStyle << std::endl; + strm << " Transformation: " << (short) PDesc.CodingStyleDefault.SPcod.Transformation << std::endl; + + + ui32_t precinct_set_size = 0; + + for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ ) + precinct_set_size++; + strm << " Precincts: " << (short) precinct_set_size << std::endl; + strm << "precinct dimensions:" << std::endl; + + for ( i = 0; i < precinct_set_size; i++ ) + strm << " " << i + 1 << ": " << s_exp_lookup[PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]&0x0f] << " x " + << s_exp_lookup[(PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]>>4)&0x0f] << std::endl; + + strm << " Sqcd: " << (short) PDesc.QuantizationDefault.Sqcd << std::endl; + + char tmp_buf[MaxDefaults*2]; + strm << " SPqcd: " << Kumu::bin2hex(PDesc.QuantizationDefault.SPqcd, PDesc.QuantizationDefault.SPqcdLength, tmp_buf, MaxDefaults*2) + << std::endl; + + return strm; +} // void @@ -49,22 +117,24 @@ 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", - PDesc.AspectRatio.Numerator ,PDesc.AspectRatio.Denominator, - PDesc.EditRate.Numerator ,PDesc.EditRate.Denominator, + AspectRatio: %d/%d\n\ + EditRate: %d/%d\n\ + SampleRate: %d/%d\n\ + StoredWidth: %u\n\ + StoredHeight: %u\n\ + Rsize: %u\n\ + Xsize: %u\n\ + Ysize: %u\n\ + XOsize: %u\n\ + YOsize: %u\n\ + XTsize: %u\n\ + YTsize: %u\n\ + XTOsize: %u\n\ + YTOsize: %u\n\ + ContainerDuration: %u\n", + PDesc.AspectRatio.Numerator, PDesc.AspectRatio.Denominator, + PDesc.EditRate.Numerator, PDesc.EditRate.Denominator, + PDesc.SampleRate.Numerator, PDesc.SampleRate.Denominator, PDesc.StoredWidth, PDesc.StoredHeight, PDesc.Rsize, @@ -79,109 +149,133 @@ ContainerDuration: %lu\n", PDesc.ContainerDuration ); - fprintf(stream, "Color Components:\n"); + fprintf(stream, "-- JPEG 2000 Metadata --\n"); + fprintf(stream, " ImageComponents:\n"); + fprintf(stream, " bits h-sep v-sep\n"); - for ( ui32_t i = 0; i < PDesc.Csize; i++ ) + ui32_t i; + for ( i = 0; i < PDesc.Csize; i++ ) { - fprintf(stream, " %lu.%lu.%lu\n", - PDesc.ImageComponents[i].Ssize, + fprintf(stream, " %4d %5d %5d\n", + PDesc.ImageComponents[i].Ssize + 1, // See ISO 15444-1, Table A11, for the origin of '+1' PDesc.ImageComponents[i].XRsize, PDesc.ImageComponents[i].YRsize ); } + + fprintf(stream, " Scod: %hd\n", PDesc.CodingStyleDefault.Scod); + fprintf(stream, " ProgressionOrder: %hd\n", PDesc.CodingStyleDefault.SGcod.ProgressionOrder); + fprintf(stream, " NumberOfLayers: %hd\n", + KM_i16_BE(Kumu::cp2i(PDesc.CodingStyleDefault.SGcod.NumberOfLayers))); - const ui32_t tmp_buf_len = 256; - char tmp_buf[tmp_buf_len]; + fprintf(stream, " MultiCompTransform: %hd\n", PDesc.CodingStyleDefault.SGcod.MultiCompTransform); + fprintf(stream, "DecompositionLevels: %hd\n", PDesc.CodingStyleDefault.SPcod.DecompositionLevels); + fprintf(stream, " CodeblockWidth: %hd\n", PDesc.CodingStyleDefault.SPcod.CodeblockWidth); + fprintf(stream, " CodeblockHeight: %hd\n", PDesc.CodingStyleDefault.SPcod.CodeblockHeight); + fprintf(stream, " CodeblockStyle: %hd\n", PDesc.CodingStyleDefault.SPcod.CodeblockStyle); + fprintf(stream, " Transformation: %hd\n", PDesc.CodingStyleDefault.SPcod.Transformation); - if ( PDesc.CodingStyleLength ) - fprintf(stream, "Default Coding (%lu): %s\n", - PDesc.CodingStyleLength, - bin2hex(PDesc.CodingStyle, PDesc.CodingStyleLength, - tmp_buf, tmp_buf_len) - ); - if ( PDesc.QuantDefaultLength ) - fprintf(stream, "Default Coding (%lu): %s\n", - PDesc.QuantDefaultLength, - bin2hex(PDesc.QuantDefault, PDesc.QuantDefaultLength, - tmp_buf, tmp_buf_len) + ui32_t precinct_set_size = 0; + + for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ ) + precinct_set_size++; + + fprintf(stream, " Precincts: %hd\n", precinct_set_size); + fprintf(stream, "precinct dimensions:\n"); + + for ( i = 0; i < precinct_set_size; i++ ) + fprintf(stream, " %d: %d x %d\n", i + 1, + s_exp_lookup[PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]&0x0f], + s_exp_lookup[(PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]>>4)&0x0f] ); + + fprintf(stream, " Sqcd: %hd\n", PDesc.QuantizationDefault.Sqcd); + + char tmp_buf[MaxDefaults*2]; + fprintf(stream, " SPqcd: %s\n", + Kumu::bin2hex(PDesc.QuantizationDefault.SPqcd, PDesc.QuantizationDefault.SPqcdLength, + tmp_buf, MaxDefaults*2) + ); } + //------------------------------------------------------------------------------------------ // // hidden, internal implementation of JPEG 2000 reader -class ASDCP::JP2K::MXFReader::h__Reader : public ASDCP::h__Reader + +class lh__Reader : public ASDCP::h__Reader { - ASDCP_NO_COPY_CONSTRUCT(h__Reader); + RGBAEssenceDescriptor* m_EssenceDescriptor; + JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor; + ASDCP::Rational m_EditRate; + ASDCP::Rational m_SampleRate; + EssenceType_t m_Format; + + ASDCP_NO_COPY_CONSTRUCT(lh__Reader); public: PictureDescriptor m_PDesc; // codestream parameter list - h__Reader() {} - Result_t OpenRead(const char*); - Result_t ReadFrame(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*); - Result_t ReadFrameGOPStart(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*); - Result_t MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor* PDescObj, JP2K::PictureDescriptor& PDesc); + lh__Reader(const Dictionary& d) : + ASDCP::h__Reader(d), m_EssenceDescriptor(0), m_EssenceSubDescriptor(0), m_Format(ESS_UNKNOWN) {} + Result_t OpenRead(const char*, EssenceType_t); + Result_t ReadFrame(ui32_t, JP2K::FrameBuffer&, AESDecContext*, HMACContext*); + Result_t MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc); }; // ASDCP::Result_t -ASDCP::JP2K::MXFReader::h__Reader::MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor* PDescObj, JP2K::PictureDescriptor& PDesc) +lh__Reader::MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc) { - ASDCP_TEST_NULL(PDescObj); memset(&PDesc, 0, sizeof(PDesc)); + MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor; - PDesc.EditRate = PDescObj->SampleRate; - PDesc.ContainerDuration = PDescObj->ContainerDuration; + PDesc.EditRate = m_EditRate; + PDesc.SampleRate = m_SampleRate; + assert(PDescObj->ContainerDuration <= 0xFFFFFFFFL); + PDesc.ContainerDuration = (ui32_t) PDescObj->ContainerDuration; PDesc.StoredWidth = PDescObj->StoredWidth; PDesc.StoredHeight = PDescObj->StoredHeight; PDesc.AspectRatio = PDescObj->AspectRatio; - InterchangeObject* MDObject; - if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &MDObject)) ) + if ( m_EssenceSubDescriptor != 0 ) { - if ( MDObject == 0 ) - { - DefaultLogSink().Error("Unable to locate JPEG2000PictureSubDescriptor"); - return RESULT_FALSE; - } - - JPEG2000PictureSubDescriptor* PSubDescObj = (JPEG2000PictureSubDescriptor*)MDObject; - - PDesc.Rsize = PSubDescObj->Rsize; - PDesc.Xsize = PSubDescObj->Xsize; - PDesc.Ysize = PSubDescObj->Ysize; - PDesc.XOsize = PSubDescObj->XOsize; - PDesc.YOsize = PSubDescObj->YOsize; - PDesc.XTsize = PSubDescObj->XTsize; - PDesc.YTsize = PSubDescObj->YTsize; - PDesc.XTOsize = PSubDescObj->XTOsize; - PDesc.YTOsize = PSubDescObj->YTOsize; - PDesc.Csize = PSubDescObj->Csize; - } + PDesc.Rsize = m_EssenceSubDescriptor->Rsize; + PDesc.Xsize = m_EssenceSubDescriptor->Xsize; + PDesc.Ysize = m_EssenceSubDescriptor->Ysize; + PDesc.XOsize = m_EssenceSubDescriptor->XOsize; + PDesc.YOsize = m_EssenceSubDescriptor->YOsize; + PDesc.XTsize = m_EssenceSubDescriptor->XTsize; + PDesc.YTsize = m_EssenceSubDescriptor->YTsize; + PDesc.XTOsize = m_EssenceSubDescriptor->XTOsize; + PDesc.YTOsize = m_EssenceSubDescriptor->YTOsize; + PDesc.Csize = m_EssenceSubDescriptor->Csize; -#if 0 // PictureComponentSizing + ui32_t tmp_size = m_EssenceSubDescriptor->PictureComponentSizing.Length(); + + if ( tmp_size == 17 ) // ( 2 * sizeof(ui32_t) ) + 3 components * 3 byte each + memcpy(&PDesc.ImageComponents, m_EssenceSubDescriptor->PictureComponentSizing.RoData() + 8, tmp_size - 8); - if ( DC3.Size == 17 ) // ( 2* sizeof(ui32_t) ) + 3 components * 3 byte each - { - memcpy(&PDesc.ImageComponents, DC3.Data + 8, DC3.Size - 8); - } else - { - DefaultLogSink().Error("Unexpected PictureComponentSizing size: %lu, should be 17\n", DC3.Size); - } -#endif + DefaultLogSink().Error("Unexpected PictureComponentSizing size: %u, should be 17\n", tmp_size); - // CodingStyleDefault - // PDesc.CodingStyleLength = DC1.Size; - // memcpy(PDesc.CodingStyle, DC1.Data, DC1.Size); + // CodingStyleDefault + memset(&m_PDesc.CodingStyleDefault, 0, sizeof(CodingStyleDefault_t)); + memcpy(&m_PDesc.CodingStyleDefault, + m_EssenceSubDescriptor->CodingStyleDefault.RoData(), + m_EssenceSubDescriptor->CodingStyleDefault.Length()); - // QuantizationDefault - // PDesc.QuantDefaultLength = DC2.Size; - // memcpy(PDesc.QuantDefault, DC2.Data, DC2.Size); + // QuantizationDefault + memset(&m_PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t)); + memcpy(&m_PDesc.QuantizationDefault, + m_EssenceSubDescriptor->QuantizationDefault.RoData(), + m_EssenceSubDescriptor->QuantizationDefault.Length()); + + m_PDesc.QuantizationDefault.SPqcdLength = m_EssenceSubDescriptor->QuantizationDefault.Length() - 1; + } return RESULT_OK; } @@ -189,25 +283,69 @@ ASDCP::JP2K::MXFReader::h__Reader::MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor* // // ASDCP::Result_t -ASDCP::JP2K::MXFReader::h__Reader::OpenRead(const char* filename) +lh__Reader::OpenRead(const char* filename, EssenceType_t type) { Result_t result = OpenMXFRead(filename); if( ASDCP_SUCCESS(result) ) { - InterchangeObject* Object; - if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), &Object)) ) + InterchangeObject* tmp_iobj = 0; + m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), &tmp_iobj); + m_EssenceDescriptor = static_cast(tmp_iobj); + + m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &tmp_iobj); + m_EssenceSubDescriptor = static_cast(tmp_iobj); + + std::list ObjectList; + m_HeaderPart.GetMDObjectsByType(OBJ_TYPE_ARGS(Track), ObjectList); + + if ( ObjectList.empty() ) + { + DefaultLogSink().Error("MXF Metadata contains no Track Sets.\n"); + return RESULT_FORMAT; + } + + m_EditRate = ((Track*)ObjectList.front())->EditRate; + m_SampleRate = m_EssenceDescriptor->SampleRate; + + if ( type == ASDCP::ESS_JPEG_2000 ) + { + if ( m_EditRate != m_SampleRate ) + { + DefaultLogSink().Error("EditRate and SampleRate do not match (%.03f, %.03f).\n", + m_EditRate.Quotient(), m_SampleRate.Quotient()); + + if ( m_EditRate == EditRate_24 && m_SampleRate == EditRate_48 ) + { + DefaultLogSink().Debug("File may contain JPEG Interop stereoscopic images.\n"); + return RESULT_SFORMAT; + } + + return RESULT_FORMAT; + } + } + else if ( type == ASDCP::ESS_JPEG_2000_S ) + { + if ( ! ( m_EditRate == EditRate_24 && m_SampleRate == EditRate_48 ) ) + { + DefaultLogSink().Error("EditRate and SampleRate not correct for 24/48 stereoscopic essence.\n"); + return RESULT_FORMAT; + } + } + else { - assert(Object); - result = MD_to_JP2K_PDesc((MXF::RGBAEssenceDescriptor*)Object, m_PDesc); + DefaultLogSink().Error("'type' argument unexpected: %x\n", type); + return RESULT_STATE; } + + result = MD_to_JP2K_PDesc(m_PDesc); } if( ASDCP_SUCCESS(result) ) result = InitMXFIndex(); if( ASDCP_SUCCESS(result) ) - result = InitInfo(m_Info); + result = InitInfo(); return result; } @@ -215,15 +353,29 @@ ASDCP::JP2K::MXFReader::h__Reader::OpenRead(const char* filename) // // ASDCP::Result_t -ASDCP::JP2K::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, FrameBuffer& FrameBuf, - AESDecContext* Ctx, HMACContext* HMAC) +lh__Reader::ReadFrame(ui32_t FrameNum, JP2K::FrameBuffer& FrameBuf, + AESDecContext* Ctx, HMACContext* HMAC) { if ( ! m_File.IsOpen() ) return RESULT_INIT; - return ReadEKLVPacket(FrameNum, FrameBuf, JP2KEssenceUL_Data, Ctx, HMAC); + assert(m_Dict); + return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_JPEG2000Essence), Ctx, HMAC); } + +// +class ASDCP::JP2K::MXFReader::h__Reader : public lh__Reader +{ + ASDCP_NO_COPY_CONSTRUCT(h__Reader); + h__Reader(); + +public: + h__Reader(const Dictionary& d) : lh__Reader(d) {} +}; + + + //------------------------------------------------------------------------------------------ @@ -234,12 +386,12 @@ ASDCP::JP2K::FrameBuffer::Dump(FILE* stream, ui32_t dump_len) const if ( stream == 0 ) stream = stderr; - fprintf(stream, "Frame: %06lu, %7lu bytes", m_FrameNumber, m_Size); + fprintf(stream, "Frame: %06u, %7u bytes", m_FrameNumber, m_Size); fputc('\n', stream); if ( dump_len > 0 ) - hexdump(m_Data, dump_len, stream); + Kumu::hexdump(m_Data, dump_len, stream); } @@ -247,7 +399,7 @@ ASDCP::JP2K::FrameBuffer::Dump(FILE* stream, ui32_t dump_len) const ASDCP::JP2K::MXFReader::MXFReader() { - m_Reader = new h__Reader; + m_Reader = new h__Reader(DefaultCompositeDict()); } @@ -260,7 +412,7 @@ ASDCP::JP2K::MXFReader::~MXFReader() ASDCP::Result_t ASDCP::JP2K::MXFReader::OpenRead(const char* filename) const { - return m_Reader->OpenRead(filename); + return m_Reader->OpenRead(filename, ASDCP::ESS_JPEG_2000); } // @@ -325,68 +477,281 @@ ASDCP::JP2K::MXFReader::DumpIndex(FILE* stream) const //------------------------------------------------------------------------------------------ +class ASDCP::JP2K::MXFSReader::h__SReader : public lh__Reader +{ + ui32_t m_StereoFrameReady; + +public: + h__SReader(const Dictionary& d) : lh__Reader(d), m_StereoFrameReady(0xffffffff) {} + + // + Result_t ReadFrame(ui32_t FrameNum, StereoscopicPhase_t phase, FrameBuffer& FrameBuf, + AESDecContext* Ctx, HMACContext* HMAC) + { + // look up frame index node + IndexTableSegment::IndexEntry TmpEntry; + + if ( ASDCP_FAILURE(m_FooterPart.Lookup(FrameNum, TmpEntry)) ) + { + DefaultLogSink().Error("Frame value out of range: %u\n", FrameNum); + return RESULT_RANGE; + } + + // get frame position + Kumu::fpos_t FilePosition = m_EssenceStart + TmpEntry.StreamOffset; + Result_t result = RESULT_OK; + + if ( phase == SP_LEFT ) + { + if ( FilePosition != m_LastPosition ) + { + m_LastPosition = FilePosition; + result = m_File.Seek(FilePosition); + } + + // the call to ReadEKLVPacket() will leave the file on an R frame + m_StereoFrameReady = FrameNum; + } + else if ( phase == SP_RIGHT ) + { + if ( m_StereoFrameReady != FrameNum ) + { + // the file is not already positioned, we must do some work + // seek to the companion SP_LEFT frame and read the frame's key and length + if ( FilePosition != m_LastPosition ) + { + m_LastPosition = FilePosition; + result = m_File.Seek(FilePosition); + } + + KLReader Reader; + result = Reader.ReadKLFromFile(m_File); + + if ( ASDCP_SUCCESS(result) ) + { + // skip over the companion SP_LEFT frame + Kumu::fpos_t new_pos = FilePosition + SMPTE_UL_LENGTH + Reader.KLLength() + Reader.Length(); + result = m_File.Seek(new_pos); + } + } + + // the call to ReadEKLVPacket() will leave the file not on an R frame + m_StereoFrameReady = 0xffffffff; + } + else + { + DefaultLogSink().Error("Unexpected stereoscopic phase value: %u\n", phase); + return RESULT_STATE; + } + + if( ASDCP_SUCCESS(result) ) + { + ui32_t SequenceNum = FrameNum * 2; + SequenceNum += ( phase == SP_RIGHT ) ? 2 : 1; + assert(m_Dict); + result = ReadEKLVPacket(FrameNum, SequenceNum, FrameBuf, m_Dict->ul(MDD_JPEG2000Essence), Ctx, HMAC); + } + + return result; + } +}; + + + +ASDCP::JP2K::MXFSReader::MXFSReader() +{ + m_Reader = new h__SReader(DefaultCompositeDict()); +} + + +ASDCP::JP2K::MXFSReader::~MXFSReader() +{ +} + +// Open the file for reading. The file must exist. Returns error if the +// operation cannot be completed. +ASDCP::Result_t +ASDCP::JP2K::MXFSReader::OpenRead(const char* filename) const +{ + return m_Reader->OpenRead(filename, ASDCP::ESS_JPEG_2000_S); +} + +// +ASDCP::Result_t +ASDCP::JP2K::MXFSReader::ReadFrame(ui32_t FrameNum, SFrameBuffer& FrameBuf, AESDecContext* Ctx, HMACContext* HMAC) const +{ + Result_t result = RESULT_INIT; + + if ( m_Reader && m_Reader->m_File.IsOpen() ) + { + result = m_Reader->ReadFrame(FrameNum, SP_LEFT, FrameBuf.Left, Ctx, HMAC); + + if ( ASDCP_SUCCESS(result) ) + result = m_Reader->ReadFrame(FrameNum, SP_RIGHT, FrameBuf.Right, Ctx, HMAC); + } + + return result; +} + +// +ASDCP::Result_t +ASDCP::JP2K::MXFSReader::ReadFrame(ui32_t FrameNum, StereoscopicPhase_t phase, FrameBuffer& FrameBuf, + AESDecContext* Ctx, HMACContext* HMAC) const +{ + if ( m_Reader && m_Reader->m_File.IsOpen() ) + return m_Reader->ReadFrame(FrameNum, phase, FrameBuf, Ctx, HMAC); + + return RESULT_INIT; +} + +// Fill the struct with the values from the file's header. +// Returns RESULT_INIT if the file is not open. +ASDCP::Result_t +ASDCP::JP2K::MXFSReader::FillPictureDescriptor(PictureDescriptor& PDesc) const +{ + if ( m_Reader && m_Reader->m_File.IsOpen() ) + { + PDesc = m_Reader->m_PDesc; + return RESULT_OK; + } + + return RESULT_INIT; +} + + +// Fill the struct with the values from the file's header. +// Returns RESULT_INIT if the file is not open. +ASDCP::Result_t +ASDCP::JP2K::MXFSReader::FillWriterInfo(WriterInfo& Info) const +{ + if ( m_Reader && m_Reader->m_File.IsOpen() ) + { + Info = m_Reader->m_Info; + return RESULT_OK; + } + + return RESULT_INIT; +} + +// +void +ASDCP::JP2K::MXFSReader::DumpHeaderMetadata(FILE* stream) const +{ + if ( m_Reader->m_File.IsOpen() ) + m_Reader->m_HeaderPart.Dump(stream); +} + + +// +void +ASDCP::JP2K::MXFSReader::DumpIndex(FILE* stream) const +{ + if ( m_Reader->m_File.IsOpen() ) + m_Reader->m_FooterPart.Dump(stream); +} + +//------------------------------------------------------------------------------------------ + // -class ASDCP::JP2K::MXFWriter::h__Writer : public ASDCP::h__Writer +class lh__Writer : public ASDCP::h__Writer { + ASDCP_NO_COPY_CONSTRUCT(lh__Writer); + lh__Writer(); + + JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor; + public: PictureDescriptor m_PDesc; - ui32_t m_GOPOffset; + byte_t m_EssenceUL[SMPTE_UL_LENGTH]; - ASDCP_NO_COPY_CONSTRUCT(h__Writer); + lh__Writer(const Dictionary& d) : ASDCP::h__Writer(d), m_EssenceSubDescriptor(0) { + memset(m_EssenceUL, 0, SMPTE_UL_LENGTH); + } - h__Writer() : m_GOPOffset(0) {} - ~h__Writer(){} + ~lh__Writer(){} - Result_t OpenWrite(const char*, ui32_t HeaderSize); - Result_t SetSourceStream(const PictureDescriptor&); - Result_t WriteFrame(const FrameBuffer&, AESEncContext* = 0, HMACContext* = 0); + Result_t OpenWrite(const char*, EssenceType_t type, ui32_t HeaderSize); + Result_t SetSourceStream(const PictureDescriptor&, const std::string& label, + ASDCP::Rational LocalEditRate = ASDCP::Rational(0,0)); + Result_t WriteFrame(const JP2K::FrameBuffer&, bool add_index, AESEncContext*, HMACContext*); Result_t Finalize(); - Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc, MXF::RGBAEssenceDescriptor* PDescObj); + Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc); }; +const int VideoLineMapSize = 16; // See SMPTE 377M D.2.1 +const int PixelLayoutSize = 8*2; // See SMPTE 377M D.2.3 +static const byte_t s_PixelLayoutXYZ[PixelLayoutSize] = { 0xd8, 0x0c, 0xd9, 0x0c, 0xda, 0x0c, 0x00 }; // ASDCP::Result_t -ASDCP::JP2K::MXFWriter::h__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc, MXF::RGBAEssenceDescriptor* PDescObj) +lh__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc) { - // Codec - PDescObj->SampleRate = PDesc.EditRate; + assert(m_EssenceDescriptor); + assert(m_EssenceSubDescriptor); + MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor; + PDescObj->ContainerDuration = PDesc.ContainerDuration; + PDescObj->SampleRate = PDesc.EditRate; + PDescObj->FrameLayout = 0; PDescObj->StoredWidth = PDesc.StoredWidth; PDescObj->StoredHeight = PDesc.StoredHeight; PDescObj->AspectRatio = PDesc.AspectRatio; - PDescObj->FrameLayout = 0; - InterchangeObject* MDObject; - if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &MDObject)) ) + // if ( m_Info.LabelSetType == LS_MXF_SMPTE ) + // { + // PictureEssenceCoding UL = + // Video Line Map ui32_t[VideoLineMapSize] = { 2, 4, 0, 0 } + // CaptureGamma UL = + // ComponentMaxRef ui32_t = 4095 + // ComponentMinRef ui32_t = 0 + // PixelLayout byte_t[PixelLayoutSize] = s_PixelLayoutXYZ + // } + + assert(m_Dict); + if ( PDesc.StoredWidth < 2049 ) + { + PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_2K)); + m_EssenceSubDescriptor->Rsize = 3; + } + else { - assert(MDObject); - JPEG2000PictureSubDescriptor* PSubDescObj = (JPEG2000PictureSubDescriptor*)MDObject; - - PSubDescObj->Rsize = PDesc.Rsize; - PSubDescObj->Xsize = PDesc.Xsize; - PSubDescObj->Ysize = PDesc.Ysize; - PSubDescObj->XOsize = PDesc.XOsize; - PSubDescObj->YOsize = PDesc.YOsize; - PSubDescObj->XTsize = PDesc.XTsize; - PSubDescObj->YTsize = PDesc.YTsize; - PSubDescObj->XTOsize = PDesc.XTOsize; - PSubDescObj->YTOsize = PDesc.YTOsize; - PSubDescObj->Csize = PDesc.Csize; + PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_4K)); + m_EssenceSubDescriptor->Rsize = 4; } -#if 0 - const ui32_t tmp_buffer_len = 64; + + m_EssenceSubDescriptor->Xsize = PDesc.Xsize; + m_EssenceSubDescriptor->Ysize = PDesc.Ysize; + m_EssenceSubDescriptor->XOsize = PDesc.XOsize; + m_EssenceSubDescriptor->YOsize = PDesc.YOsize; + m_EssenceSubDescriptor->XTsize = PDesc.XTsize; + m_EssenceSubDescriptor->YTsize = PDesc.YTsize; + m_EssenceSubDescriptor->XTOsize = PDesc.XTOsize; + m_EssenceSubDescriptor->YTOsize = PDesc.YTOsize; + m_EssenceSubDescriptor->Csize = PDesc.Csize; + + const ui32_t tmp_buffer_len = 1024; byte_t tmp_buffer[tmp_buffer_len]; - *(ui32_t*)tmp_buffer = ASDCP_i32_BE(3L); // three components - *(ui32_t*)(tmp_buffer+4) = ASDCP_i32_BE(3L); - memcpy(tmp_buffer + 8, &PDesc.ImageComponents, sizeof(ASDCP::JP2K::ImageComponent) * 3L); + *(ui32_t*)tmp_buffer = KM_i32_BE(MaxComponents); // three components + *(ui32_t*)(tmp_buffer+4) = KM_i32_BE(sizeof(ASDCP::JP2K::ImageComponent_t)); + memcpy(tmp_buffer + 8, &PDesc.ImageComponents, sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents); + + const ui32_t pcomp_size = (sizeof(int) * 2) + (sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents); + memcpy(m_EssenceSubDescriptor->PictureComponentSizing.Data(), tmp_buffer, pcomp_size); + m_EssenceSubDescriptor->PictureComponentSizing.Length(pcomp_size); + + ui32_t precinct_set_size = 0, i; + for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ ) + precinct_set_size++; + + ui32_t csd_size = sizeof(CodingStyleDefault_t) - MaxPrecincts + precinct_set_size; + memcpy(m_EssenceSubDescriptor->CodingStyleDefault.Data(), &PDesc.CodingStyleDefault, csd_size); + m_EssenceSubDescriptor->CodingStyleDefault.Length(csd_size); - PSubDescObj->SetValue("PictureComponentSizing", DataChunk(17, tmp_buffer)); - PSubDescObj->SetValue("CodingStyleDefault", DataChunk(PDesc.CodingStyleLength, PDesc.CodingStyle)); - PSubDescObj->SetValue("QuantizationDefault", DataChunk(PDesc.QuantDefaultLength, PDesc.QuantDefault)); -#endif + ui32_t qdflt_size = PDesc.QuantizationDefault.SPqcdLength + 1; + memcpy(m_EssenceSubDescriptor->QuantizationDefault.Data(), &PDesc.QuantizationDefault, qdflt_size); + m_EssenceSubDescriptor->QuantizationDefault.Length(qdflt_size); return RESULT_OK; } @@ -395,7 +760,7 @@ ASDCP::JP2K::MXFWriter::h__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDe // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. ASDCP::Result_t -ASDCP::JP2K::MXFWriter::h__Writer::OpenWrite(const char* filename, ui32_t HeaderSize) +lh__Writer::OpenWrite(const char* filename, EssenceType_t type, ui32_t HeaderSize) { if ( ! m_State.Test_BEGIN() ) return RESULT_STATE; @@ -404,13 +769,26 @@ ASDCP::JP2K::MXFWriter::h__Writer::OpenWrite(const char* filename, ui32_t Header if ( ASDCP_SUCCESS(result) ) { - RGBAEssenceDescriptor* rgbDesc = new RGBAEssenceDescriptor; + m_HeaderSize = HeaderSize; + RGBAEssenceDescriptor* tmp_rgba = new RGBAEssenceDescriptor(m_Dict); + tmp_rgba->ComponentMaxRef = 4095; + tmp_rgba->ComponentMinRef = 0; - JPEG2000PictureSubDescriptor* jp2kSubDesc = new JPEG2000PictureSubDescriptor; - m_HeaderPart.AddChildObject(jp2kSubDesc); - rgbDesc->SubDescriptors.push_back(jp2kSubDesc->InstanceUID); + m_EssenceDescriptor = tmp_rgba; + m_EssenceSubDescriptor = new JPEG2000PictureSubDescriptor(m_Dict); + m_EssenceSubDescriptorList.push_back((InterchangeObject*)m_EssenceSubDescriptor); + + GenRandomValue(m_EssenceSubDescriptor->InstanceUID); + m_EssenceDescriptor->SubDescriptors.push_back(m_EssenceSubDescriptor->InstanceUID); + + if ( type == ASDCP::ESS_JPEG_2000_S && m_Info.LabelSetType == LS_MXF_SMPTE ) + { + InterchangeObject* StereoSubDesc = new StereoscopicPictureSubDescriptor(m_Dict); + m_EssenceSubDescriptorList.push_back(StereoSubDesc); + GenRandomValue(StereoSubDesc->InstanceUID); + m_EssenceDescriptor->SubDescriptors.push_back(StereoSubDesc->InstanceUID); + } - m_EssenceDescriptor = rgbDesc; result = m_State.Goto_INIT(); } @@ -419,21 +797,29 @@ ASDCP::JP2K::MXFWriter::h__Writer::OpenWrite(const char* filename, ui32_t Header // Automatically sets the MXF file's metadata from the first jpeg codestream stream. ASDCP::Result_t -ASDCP::JP2K::MXFWriter::h__Writer::SetSourceStream(const PictureDescriptor& PDesc) +lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& label, ASDCP::Rational LocalEditRate) { + assert(m_Dict); if ( ! m_State.Test_INIT() ) return RESULT_STATE; + if ( LocalEditRate == ASDCP::Rational(0,0) ) + LocalEditRate = PDesc.EditRate; + m_PDesc = PDesc; - Result_t result = JP2K_PDesc_to_MD(m_PDesc, (RGBAEssenceDescriptor*)m_EssenceDescriptor); + Result_t result = JP2K_PDesc_to_MD(m_PDesc); if ( ASDCP_SUCCESS(result) ) - result = WriteMXFHeader(JP2K_PACKAGE_LABEL, - UL(WrappingUL_Data_JPEG_2000), - m_PDesc.EditRate, 24 /* TCFrameRate */); + result = WriteMXFHeader(label, UL(m_Dict->ul(MDD_JPEG_2000Wrapping)), + PICT_DEF_LABEL, UL(m_Dict->ul(MDD_PictureDataDef)), + LocalEditRate, 24 /* TCFrameRate */); if ( ASDCP_SUCCESS(result) ) - result = m_State.Goto_READY(); + { + memcpy(m_EssenceUL, m_Dict->ul(MDD_JPEG2000Essence), SMPTE_UL_LENGTH); + m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container + result = m_State.Goto_READY(); + } return result; } @@ -444,27 +830,27 @@ ASDCP::JP2K::MXFWriter::h__Writer::SetSourceStream(const PictureDescriptor& PDes // error occurs. // ASDCP::Result_t -ASDCP::JP2K::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESEncContext* Ctx, - HMACContext* HMAC) +lh__Writer::WriteFrame(const JP2K::FrameBuffer& FrameBuf, bool add_index, + AESEncContext* Ctx, HMACContext* HMAC) { Result_t result = RESULT_OK; if ( m_State.Test_READY() ) result = m_State.Goto_RUNNING(); // first time through - - fpos_t ThisOffset = m_StreamOffset; - if ( ASDCP_SUCCESS(result) ) - result = WriteEKLVPacket(FrameBuf, JP2KEssenceUL_Data, Ctx, HMAC); + ui64_t StreamOffset = m_StreamOffset; if ( ASDCP_SUCCESS(result) ) + result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC); + + if ( ASDCP_SUCCESS(result) && add_index ) { IndexTableSegment::IndexEntry Entry; - Entry.StreamOffset = ThisOffset - m_FooterPart.m_ECOffset; + Entry.StreamOffset = StreamOffset; m_FooterPart.PushIndexEntry(Entry); - m_FramesWritten++; } + m_FramesWritten++; return result; } @@ -472,7 +858,7 @@ ASDCP::JP2K::MXFWriter::h__Writer::WriteFrame(const FrameBuffer& FrameBuf, AESEn // Closes the MXF file, writing the index and other closing information. // ASDCP::Result_t -ASDCP::JP2K::MXFWriter::h__Writer::Finalize() +lh__Writer::Finalize() { if ( ! m_State.Test_RUNNING() ) return RESULT_STATE; @@ -483,6 +869,17 @@ ASDCP::JP2K::MXFWriter::h__Writer::Finalize() } +// +class ASDCP::JP2K::MXFWriter::h__Writer : public lh__Writer +{ + ASDCP_NO_COPY_CONSTRUCT(h__Writer); + h__Writer(); + +public: + h__Writer(const Dictionary& d) : lh__Writer(d) {} +}; + + //------------------------------------------------------------------------------------------ @@ -502,15 +899,17 @@ ASDCP::Result_t ASDCP::JP2K::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info, const PictureDescriptor& PDesc, ui32_t HeaderSize) { - m_Writer = new h__Writer; - - Result_t result = m_Writer->OpenWrite(filename, HeaderSize); + if ( Info.LabelSetType == LS_MXF_SMPTE ) + m_Writer = new h__Writer(DefaultSMPTEDict()); + else + m_Writer = new h__Writer(DefaultInteropDict()); + + m_Writer->m_Info = Info; + + Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000, HeaderSize); if ( ASDCP_SUCCESS(result) ) - { - m_Writer->m_Info = Info; - result = m_Writer->SetSourceStream(PDesc); - } + result = m_Writer->SetSourceStream(PDesc, JP2K_PACKAGE_LABEL); if ( ASDCP_FAILURE(result) ) m_Writer.release(); @@ -529,7 +928,7 @@ ASDCP::JP2K::MXFWriter::WriteFrame(const FrameBuffer& FrameBuf, AESEncContext* C if ( m_Writer.empty() ) return RESULT_INIT; - return m_Writer->WriteFrame(FrameBuf, Ctx, HMAC); + return m_Writer->WriteFrame(FrameBuf, true, Ctx, HMAC); } // Closes the MXF file, writing the index and other closing information. @@ -543,6 +942,135 @@ ASDCP::JP2K::MXFWriter::Finalize() } +//------------------------------------------------------------------------------------------ +// + +// +class ASDCP::JP2K::MXFSWriter::h__SWriter : public lh__Writer +{ + ASDCP_NO_COPY_CONSTRUCT(h__SWriter); + h__SWriter(); + StereoscopicPhase_t m_NextPhase; + +public: + h__SWriter(const Dictionary& d) : lh__Writer(d), m_NextPhase(SP_LEFT) {} + + // + Result_t WriteFrame(const FrameBuffer& FrameBuf, StereoscopicPhase_t phase, + AESEncContext* Ctx, HMACContext* HMAC) + { + if ( m_NextPhase != phase ) + return RESULT_SPHASE; + + if ( phase == SP_LEFT ) + { + m_NextPhase = SP_RIGHT; + return lh__Writer::WriteFrame(FrameBuf, true, Ctx, HMAC); + } + + m_NextPhase = SP_LEFT; + return lh__Writer::WriteFrame(FrameBuf, false, Ctx, HMAC); + } + + // + Result_t Finalize() + { + if ( m_NextPhase != SP_LEFT ) + return RESULT_SPHASE; + + assert( m_FramesWritten % 2 == 0 ); + m_FramesWritten /= 2; + return lh__Writer::Finalize(); + } +}; + + +// +ASDCP::JP2K::MXFSWriter::MXFSWriter() +{ +} + +ASDCP::JP2K::MXFSWriter::~MXFSWriter() +{ +} + + +// Open the file for writing. The file must not exist. Returns error if +// the operation cannot be completed. +ASDCP::Result_t +ASDCP::JP2K::MXFSWriter::OpenWrite(const char* filename, const WriterInfo& Info, + const PictureDescriptor& PDesc, ui32_t HeaderSize) +{ + if ( Info.LabelSetType == LS_MXF_SMPTE ) + m_Writer = new h__SWriter(DefaultSMPTEDict()); + else + m_Writer = new h__SWriter(DefaultInteropDict()); + + if ( PDesc.EditRate != ASDCP::EditRate_24 ) + { + DefaultLogSink().Error("Stereoscopic wrapping requires 24 fps input streams.\n"); + return RESULT_FORMAT; + } + + if ( PDesc.StoredWidth > 2048 ) + DefaultLogSink().Warn("Wrapping non-standard 4K stereoscopic content. I hope you know what you are doing!\n"); + + m_Writer->m_Info = Info; + + Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000_S, HeaderSize); + + if ( ASDCP_SUCCESS(result) ) + { + PictureDescriptor TmpPDesc = PDesc; + TmpPDesc.EditRate = ASDCP::EditRate_48; + + result = m_Writer->SetSourceStream(TmpPDesc, JP2K_S_PACKAGE_LABEL, ASDCP::EditRate_24); + } + + if ( ASDCP_FAILURE(result) ) + m_Writer.release(); + + return result; +} + +ASDCP::Result_t +ASDCP::JP2K::MXFSWriter::WriteFrame(const SFrameBuffer& FrameBuf, AESEncContext* Ctx, HMACContext* HMAC) +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + Result_t result = m_Writer->WriteFrame(FrameBuf.Left, SP_LEFT, Ctx, HMAC); + + if ( ASDCP_SUCCESS(result) ) + result = m_Writer->WriteFrame(FrameBuf.Right, SP_RIGHT, Ctx, HMAC); + + return result; +} + +// Writes a frame of essence to the MXF file. If the optional AESEncContext +// argument is present, the essence is encrypted prior to writing. +// Fails if the file is not open, is finalized, or an operating system +// error occurs. +ASDCP::Result_t +ASDCP::JP2K::MXFSWriter::WriteFrame(const FrameBuffer& FrameBuf, StereoscopicPhase_t phase, + AESEncContext* Ctx, HMACContext* HMAC) +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + return m_Writer->WriteFrame(FrameBuf, phase, Ctx, HMAC); +} + +// Closes the MXF file, writing the index and other closing information. +ASDCP::Result_t +ASDCP::JP2K::MXFSWriter::Finalize() +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + return m_Writer->Finalize(); +} + // // end AS_DCP_JP2K.cpp //