X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FAS_DCP_JP2K.cpp;h=129f53d97de10fa68a1a5edf76a5ed9b1e9e76c7;hb=5d86f368b2bade7bca7700c74f198ef7f4129b44;hp=9e676aeda996cc2ed98ccc6bcb7d9ebaf9fea28a;hpb=99f3c9bd7e314ed2342598ad0e2357c68c79e732;p=asdcplib.git diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp index 9e676ae..129f53d 100755 --- a/src/AS_DCP_JP2K.cpp +++ b/src/AS_DCP_JP2K.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2004-2012, John Hurst +Copyright (c) 2004-2016, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -32,21 +32,18 @@ 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; //------------------------------------------------------------------------------------------ -static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict(); -static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict); -static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict); - 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 }; +static int s_exp_lookup[16] = { 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,2048, 4096, 8192, 16384, 32768 }; // std::ostream& @@ -73,7 +70,7 @@ ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc) strm << " bits h-sep v-sep" << std::endl; ui32_t i; - for ( i = 0; i < PDesc.Csize; i++ ) + for ( i = 0; i < PDesc.Csize && i < MaxComponents; ++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 @@ -94,13 +91,13 @@ ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc) ui32_t precinct_set_size = 0; - for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ ) + 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++ ) + for ( i = 0; i < precinct_set_size && i < MaxPrecincts; ++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; @@ -110,6 +107,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.N != JP2K::NoExtendedCapabilitiesSignaled && PDesc.ExtendedCapabilities.Pcap != 0) { + + strm << "Extended Capabilities:" << std::endl; + + + strm << " Pcap:" << PDesc.ExtendedCapabilities.Pcap << std::endl; + + 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[i++] << std::dec << std::noshowbase + << std::endl; + + } + } + } + return strm; } @@ -158,7 +195,7 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream) fprintf(stream, " bits h-sep v-sep\n"); ui32_t i; - for ( i = 0; i < PDesc.Csize; i++ ) + for ( i = 0; i < PDesc.Csize && i < MaxComponents; i++ ) { fprintf(stream, " %4d %5d %5d\n", PDesc.ImageComponents[i].Ssize + 1, // See ISO 15444-1, Table A11, for the origin of '+1' @@ -167,40 +204,305 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream) ); } - fprintf(stream, " Scod: %hd\n", PDesc.CodingStyleDefault.Scod); - fprintf(stream, " ProgressionOrder: %hd\n", PDesc.CodingStyleDefault.SGcod.ProgressionOrder); + fprintf(stream, " Scod: %hhu\n", PDesc.CodingStyleDefault.Scod); + fprintf(stream, " ProgressionOrder: %hhu\n", PDesc.CodingStyleDefault.SGcod.ProgressionOrder); fprintf(stream, " NumberOfLayers: %hd\n", KM_i16_BE(Kumu::cp2i(PDesc.CodingStyleDefault.SGcod.NumberOfLayers))); - 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); + fprintf(stream, " MultiCompTransform: %hhu\n", PDesc.CodingStyleDefault.SGcod.MultiCompTransform); + fprintf(stream, "DecompositionLevels: %hhu\n", PDesc.CodingStyleDefault.SPcod.DecompositionLevels); + fprintf(stream, " CodeblockWidth: %hhu\n", PDesc.CodingStyleDefault.SPcod.CodeblockWidth); + fprintf(stream, " CodeblockHeight: %hhu\n", PDesc.CodingStyleDefault.SPcod.CodeblockHeight); + fprintf(stream, " CodeblockStyle: %hhu\n", PDesc.CodingStyleDefault.SPcod.CodeblockStyle); + fprintf(stream, " Transformation: %hhu\n", PDesc.CodingStyleDefault.SPcod.Transformation); ui32_t precinct_set_size = 0; - for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ ) + 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, " Precincts: %u\n", precinct_set_size); fprintf(stream, "precinct dimensions:\n"); - for ( i = 0; i < precinct_set_size; i++ ) + for ( i = 0; i < precinct_set_size && i < MaxPrecincts; 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); + fprintf(stream, " Sqcd: %hhu\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) ); + + + 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]); + + } + } + + if (PDesc.ExtendedCapabilities.N != JP2K::NoExtendedCapabilitiesSignaled) { + + fprintf(stream, "Extended Capabilities: %x\n", PDesc.ExtendedCapabilities.Pcap); + + for (i32_t b = 0, i = 0; b < JP2K::MaxCapabilities && i < PDesc.ExtendedCapabilities.N; b++) { + + if ((PDesc.ExtendedCapabilities.Pcap >> (JP2K::MaxCapabilities - b - 1)) & 0x1) { + + fprintf(stream, " Ccap(%d): %hx\n", b + 1, PDesc.ExtendedCapabilities.Ccap[i++]); + + } + } + + } + +} + + +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_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc, + const ASDCP::Dictionary& dict, + ASDCP::MXF::GenericPictureEssenceDescriptor& EssenceDescriptor, + ASDCP::MXF::JPEG2000PictureSubDescriptor& EssenceSubDescriptor) +{ + EssenceDescriptor.ContainerDuration = PDesc.ContainerDuration; + EssenceDescriptor.SampleRate = PDesc.EditRate; + EssenceDescriptor.FrameLayout = 0; + EssenceDescriptor.StoredWidth = PDesc.StoredWidth; + EssenceDescriptor.StoredHeight = PDesc.StoredHeight; + EssenceDescriptor.AspectRatio = PDesc.AspectRatio; + + EssenceSubDescriptor.Rsize = PDesc.Rsize; + EssenceSubDescriptor.Xsize = PDesc.Xsize; + EssenceSubDescriptor.Ysize = PDesc.Ysize; + EssenceSubDescriptor.XOsize = PDesc.XOsize; + EssenceSubDescriptor.YOsize = PDesc.YOsize; + EssenceSubDescriptor.XTsize = PDesc.XTsize; + EssenceSubDescriptor.YTsize = PDesc.YTsize; + EssenceSubDescriptor.XTOsize = PDesc.XTOsize; + EssenceSubDescriptor.YTOsize = PDesc.YTOsize; + EssenceSubDescriptor.Csize = PDesc.Csize; + + const ui32_t tmp_buffer_len = 1024; + byte_t tmp_buffer[tmp_buffer_len]; + + *(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(ui32_t) * 2) + (sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents); + memcpy(EssenceSubDescriptor.PictureComponentSizing.get().Data(), tmp_buffer, pcomp_size); + EssenceSubDescriptor.PictureComponentSizing.get().Length(pcomp_size); + EssenceSubDescriptor.PictureComponentSizing.set_has_value(); + + ui32_t precinct_set_size = 0; + for ( ui32_t 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(EssenceSubDescriptor.CodingStyleDefault.get().Data(), &PDesc.CodingStyleDefault, csd_size); + EssenceSubDescriptor.CodingStyleDefault.get().Length(csd_size); + EssenceSubDescriptor.CodingStyleDefault.set_has_value(); + + ui32_t qdflt_size = PDesc.QuantizationDefault.SPqcdLength + 1; + memcpy(EssenceSubDescriptor.QuantizationDefault.get().Data(), &PDesc.QuantizationDefault, qdflt_size); + 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.N == JP2K::NoExtendedCapabilitiesSignaled) { + + /* No extended capabilities are signaled */ + + EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(false); + + } else { + + EssenceSubDescriptor.J2KExtendedCapabilities.get().Pcap = PDesc.ExtendedCapabilities.Pcap; + + EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap.resize(PDesc.ExtendedCapabilities.N); + + std::copy(PDesc.ExtendedCapabilities.Ccap, + PDesc.ExtendedCapabilities.Ccap + PDesc.ExtendedCapabilities.N, + EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap.begin()); + + EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(true); + + } + + return RESULT_OK; +} + + +// +ASDCP::Result_t +ASDCP::MD_to_JP2K_PDesc(const ASDCP::MXF::GenericPictureEssenceDescriptor& EssenceDescriptor, + const ASDCP::MXF::JPEG2000PictureSubDescriptor& EssenceSubDescriptor, + const ASDCP::Rational& EditRate, const ASDCP::Rational& SampleRate, + ASDCP::JP2K::PictureDescriptor& PDesc) +{ + memset(&PDesc, 0, sizeof(PDesc)); + + PDesc.EditRate = EditRate; + PDesc.SampleRate = SampleRate; + assert(EssenceDescriptor.ContainerDuration.const_get() <= 0xFFFFFFFFL); + PDesc.ContainerDuration = static_cast(EssenceDescriptor.ContainerDuration.const_get()); + PDesc.StoredWidth = EssenceDescriptor.StoredWidth; + PDesc.StoredHeight = EssenceDescriptor.StoredHeight; + PDesc.AspectRatio = EssenceDescriptor.AspectRatio; + + PDesc.Rsize = EssenceSubDescriptor.Rsize; + PDesc.Xsize = EssenceSubDescriptor.Xsize; + PDesc.Ysize = EssenceSubDescriptor.Ysize; + PDesc.XOsize = EssenceSubDescriptor.XOsize; + PDesc.YOsize = EssenceSubDescriptor.YOsize; + PDesc.XTsize = EssenceSubDescriptor.XTsize; + PDesc.YTsize = EssenceSubDescriptor.YTsize; + PDesc.XTOsize = EssenceSubDescriptor.XTOsize; + PDesc.YTOsize = EssenceSubDescriptor.YTOsize; + PDesc.Csize = EssenceSubDescriptor.Csize; + + // PictureComponentSizing + ui32_t tmp_size = EssenceSubDescriptor.PictureComponentSizing.const_get().Length(); + + if ( tmp_size == 17 ) // ( 2 * sizeof(ui32_t) ) + 3 components * 3 byte each + { + memcpy(&PDesc.ImageComponents, EssenceSubDescriptor.PictureComponentSizing.const_get().RoData() + 8, tmp_size - 8); + } + else + { + DefaultLogSink().Warn("Unexpected PictureComponentSizing size: %u, should be 17.\n", tmp_size); + } + + // CodingStyleDefault + memset(&PDesc.CodingStyleDefault, 0, sizeof(CodingStyleDefault_t)); + memcpy(&PDesc.CodingStyleDefault, + EssenceSubDescriptor.CodingStyleDefault.const_get().RoData(), + EssenceSubDescriptor.CodingStyleDefault.const_get().Length()); + + // QuantizationDefault + memset(&PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t)); + memcpy(&PDesc.QuantizationDefault, + EssenceSubDescriptor.QuantizationDefault.const_get().RoData(), + 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; + 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.begin(), + EssenceSubDescriptor.J2KExtendedCapabilities.const_get().Ccap.end(), + PDesc.ExtendedCapabilities.Ccap); + + } + + return RESULT_OK; } @@ -209,7 +511,7 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream) // hidden, internal implementation of JPEG 2000 reader -class lh__Reader : public ASDCP::h__Reader +class lh__Reader : public ASDCP::h__ASDCPReader { RGBAEssenceDescriptor* m_EssenceDescriptor; JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor; @@ -223,71 +525,19 @@ public: PictureDescriptor m_PDesc; // codestream parameter list 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 -lh__Reader::MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc) -{ - memset(&PDesc, 0, sizeof(PDesc)); - MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor; - - 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; - - if ( m_EssenceSubDescriptor != 0 ) - { - 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; - - // 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); - - else - DefaultLogSink().Error("Unexpected PictureComponentSizing size: %u, should be 17\n", tmp_size); + ASDCP::h__ASDCPReader(d), m_EssenceDescriptor(0), m_EssenceSubDescriptor(0), m_Format(ESS_UNKNOWN) {} - // CodingStyleDefault - memset(&PDesc.CodingStyleDefault, 0, sizeof(CodingStyleDefault_t)); - memcpy(&PDesc.CodingStyleDefault, - m_EssenceSubDescriptor->CodingStyleDefault.RoData(), - m_EssenceSubDescriptor->CodingStyleDefault.Length()); + virtual ~lh__Reader() {} - // QuantizationDefault - memset(&PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t)); - memcpy(&PDesc.QuantizationDefault, - m_EssenceSubDescriptor->QuantizationDefault.RoData(), - m_EssenceSubDescriptor->QuantizationDefault.Length()); - - PDesc.QuantizationDefault.SPqcdLength = m_EssenceSubDescriptor->QuantizationDefault.Length() - 1; - } + Result_t OpenRead(const std::string&, EssenceType_t); + Result_t ReadFrame(ui32_t, JP2K::FrameBuffer&, AESDecContext*, HMACContext*); +}; - return RESULT_OK; -} // // ASDCP::Result_t -lh__Reader::OpenRead(const char* filename, EssenceType_t type) +lh__Reader::OpenRead(const std::string& filename, EssenceType_t type) { Result_t result = OpenMXFRead(filename); @@ -297,9 +547,22 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type) m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), &tmp_iobj); m_EssenceDescriptor = static_cast(tmp_iobj); + if ( m_EssenceDescriptor == 0 ) + { + DefaultLogSink().Error("RGBAEssenceDescriptor object not found.\n"); + return RESULT_FORMAT; + } + m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &tmp_iobj); m_EssenceSubDescriptor = static_cast(tmp_iobj); + if ( m_EssenceSubDescriptor == 0 ) + { + m_EssenceDescriptor = 0; + DefaultLogSink().Error("JPEG2000PictureSubDescriptor object not found.\n"); + return RESULT_FORMAT; + } + std::list ObjectList; m_HeaderPart.GetMDObjectsByType(OBJ_TYPE_ARGS(Track), ObjectList); @@ -319,12 +582,15 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type) DefaultLogSink().Warn("EditRate and SampleRate do not match (%.03f, %.03f).\n", m_EditRate.Quotient(), m_SampleRate.Quotient()); - if ( m_EditRate == EditRate_24 && m_SampleRate == EditRate_48 || - m_EditRate == EditRate_25 && m_SampleRate == EditRate_50 || - m_EditRate == EditRate_30 && m_SampleRate == EditRate_60 || - m_EditRate == EditRate_48 && m_SampleRate == EditRate_96 || - m_EditRate == EditRate_50 && m_SampleRate == EditRate_100 || - m_EditRate == EditRate_60 && m_SampleRate == EditRate_120 ) + if ( ( m_EditRate == EditRate_24 && m_SampleRate == EditRate_48 ) + || ( m_EditRate == EditRate_25 && m_SampleRate == EditRate_50 ) + || ( m_EditRate == EditRate_30 && m_SampleRate == EditRate_60 ) + || ( m_EditRate == EditRate_48 && m_SampleRate == EditRate_96 ) + || ( m_EditRate == EditRate_50 && m_SampleRate == EditRate_100 ) + || ( m_EditRate == EditRate_60 && m_SampleRate == EditRate_120 ) + || ( m_EditRate == EditRate_96 && m_SampleRate == EditRate_192 ) + || ( m_EditRate == EditRate_100 && m_SampleRate == EditRate_200 ) + || ( m_EditRate == EditRate_120 && m_SampleRate == EditRate_240 ) ) { DefaultLogSink().Debug("File may contain JPEG Interop stereoscopic images.\n"); return RESULT_SFORMAT; @@ -383,6 +649,30 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type) return RESULT_FORMAT; } } + else if ( m_EditRate == EditRate_96 ) + { + if ( m_SampleRate != EditRate_192 ) + { + DefaultLogSink().Error("EditRate and SampleRate not correct for 96/192 stereoscopic essence.\n"); + return RESULT_FORMAT; + } + } + else if ( m_EditRate == EditRate_100 ) + { + if ( m_SampleRate != EditRate_200 ) + { + DefaultLogSink().Error("EditRate and SampleRate not correct for 100/200 stereoscopic essence.\n"); + return RESULT_FORMAT; + } + } + else if ( m_EditRate == EditRate_120 ) + { + if ( m_SampleRate != EditRate_240 ) + { + DefaultLogSink().Error("EditRate and SampleRate not correct for 120/240 stereoscopic essence.\n"); + return RESULT_FORMAT; + } + } else { DefaultLogSink().Error("EditRate not correct for stereoscopic essence: %d/%d.\n", @@ -396,15 +686,9 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type) return RESULT_STATE; } - result = MD_to_JP2K_PDesc(m_PDesc); + result = MD_to_JP2K_PDesc(*m_EssenceDescriptor, *m_EssenceSubDescriptor, m_EditRate, m_SampleRate, m_PDesc); } - if( ASDCP_SUCCESS(result) ) - result = InitMXFIndex(); - - if( ASDCP_SUCCESS(result) ) - result = InitInfo(); - return result; } @@ -463,16 +747,21 @@ ASDCP::JP2K::MXFReader::MXFReader() ASDCP::JP2K::MXFReader::~MXFReader() { + if ( m_Reader && m_Reader->m_File.IsOpen() ) + m_Reader->Close(); } // Warning: direct manipulation of MXF structures can interfere // with the normal operation of the wrapper. Caveat emptor! // -ASDCP::MXF::OPAtomHeader& -ASDCP::JP2K::MXFReader::OPAtomHeader() +ASDCP::MXF::OP1aHeader& +ASDCP::JP2K::MXFReader::OP1aHeader() { if ( m_Reader.empty() ) - return sg_OPAtomHeader; + { + assert(g_OP1aHeader); + return *g_OP1aHeader; + } return m_Reader->m_HeaderPart; } @@ -484,15 +773,33 @@ ASDCP::MXF::OPAtomIndexFooter& ASDCP::JP2K::MXFReader::OPAtomIndexFooter() { if ( m_Reader.empty() ) - return sg_OPAtomIndexFooter; + { + assert(g_OPAtomIndexFooter); + return *g_OPAtomIndexFooter; + } + + return m_Reader->m_IndexAccess; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::RIP& +ASDCP::JP2K::MXFReader::RIP() +{ + if ( m_Reader.empty() ) + { + assert(g_RIP); + return *g_RIP; + } - return m_Reader->m_FooterPart; + return m_Reader->m_RIP; } // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. ASDCP::Result_t -ASDCP::JP2K::MXFReader::OpenRead(const char* filename) const +ASDCP::JP2K::MXFReader::OpenRead(const std::string& filename) const { return m_Reader->OpenRead(filename, ASDCP::ESS_JPEG_2000); } @@ -508,6 +815,12 @@ ASDCP::JP2K::MXFReader::ReadFrame(ui32_t FrameNum, FrameBuffer& FrameBuf, return RESULT_INIT; } +ASDCP::Result_t +ASDCP::JP2K::MXFReader::LocateFrame(ui32_t FrameNum, Kumu::fpos_t& streamOffset, i8_t& temporalOffset, i8_t& keyFrameOffset) const +{ + return m_Reader->LocateFrame(FrameNum, streamOffset, temporalOffset, keyFrameOffset); +} + // Fill the struct with the values from the file's header. // Returns RESULT_INIT if the file is not open. @@ -552,7 +865,7 @@ void ASDCP::JP2K::MXFReader::DumpIndex(FILE* stream) const { if ( m_Reader->m_File.IsOpen() ) - m_Reader->m_FooterPart.Dump(stream); + m_Reader->m_IndexAccess.Dump(stream); } // @@ -586,14 +899,13 @@ public: // look up frame index node IndexTableSegment::IndexEntry TmpEntry; - if ( ASDCP_FAILURE(m_FooterPart.Lookup(FrameNum, TmpEntry)) ) + if ( ASDCP_FAILURE(m_IndexAccess.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; + Kumu::fpos_t FilePosition = m_HeaderPart.BodyOffset + TmpEntry.StreamOffset; Result_t result = RESULT_OK; if ( phase == SP_LEFT ) @@ -661,16 +973,21 @@ ASDCP::JP2K::MXFSReader::MXFSReader() ASDCP::JP2K::MXFSReader::~MXFSReader() { + if ( m_Reader && m_Reader->m_File.IsOpen() ) + m_Reader->Close(); } // Warning: direct manipulation of MXF structures can interfere // with the normal operation of the wrapper. Caveat emptor! // -ASDCP::MXF::OPAtomHeader& -ASDCP::JP2K::MXFSReader::OPAtomHeader() +ASDCP::MXF::OP1aHeader& +ASDCP::JP2K::MXFSReader::OP1aHeader() { if ( m_Reader.empty() ) - return sg_OPAtomHeader; + { + assert(g_OP1aHeader); + return *g_OP1aHeader; + } return m_Reader->m_HeaderPart; } @@ -682,15 +999,33 @@ ASDCP::MXF::OPAtomIndexFooter& ASDCP::JP2K::MXFSReader::OPAtomIndexFooter() { if ( m_Reader.empty() ) - return sg_OPAtomIndexFooter; + { + assert(g_OPAtomIndexFooter); + return *g_OPAtomIndexFooter; + } + + return m_Reader->m_IndexAccess; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::RIP& +ASDCP::JP2K::MXFSReader::RIP() +{ + if ( m_Reader.empty() ) + { + assert(g_RIP); + return *g_RIP; + } - return m_Reader->m_FooterPart; + return m_Reader->m_RIP; } // 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 +ASDCP::JP2K::MXFSReader::OpenRead(const std::string& filename) const { return m_Reader->OpenRead(filename, ASDCP::ESS_JPEG_2000_S); } @@ -723,6 +1058,12 @@ ASDCP::JP2K::MXFSReader::ReadFrame(ui32_t FrameNum, StereoscopicPhase_t phase, F return RESULT_INIT; } +ASDCP::Result_t +ASDCP::JP2K::MXFSReader::LocateFrame(ui32_t FrameNum, Kumu::fpos_t& streamOffset, i8_t& temporalOffset, i8_t& keyFrameOffset) const +{ + return m_Reader->LocateFrame(FrameNum, streamOffset, temporalOffset, keyFrameOffset); +} + // Fill the struct with the values from the file's header. // Returns RESULT_INIT if the file is not open. ASDCP::Result_t @@ -766,7 +1107,7 @@ void ASDCP::JP2K::MXFSReader::DumpIndex(FILE* stream) const { if ( m_Reader->m_File.IsOpen() ) - m_Reader->m_FooterPart.Dump(stream); + m_Reader->m_IndexAccess.Dump(stream); } // @@ -787,7 +1128,7 @@ ASDCP::JP2K::MXFSReader::Close() const // -class lh__Writer : public ASDCP::h__Writer +class lh__Writer : public ASDCP::h__ASDCPWriter { ASDCP_NO_COPY_CONSTRUCT(lh__Writer); lh__Writer(); @@ -798,102 +1139,23 @@ public: PictureDescriptor m_PDesc; byte_t m_EssenceUL[SMPTE_UL_LENGTH]; - lh__Writer(const Dictionary& d) : ASDCP::h__Writer(d), m_EssenceSubDescriptor(0) { + lh__Writer(const Dictionary& d) : ASDCP::h__ASDCPWriter(d), m_EssenceSubDescriptor(0) { memset(m_EssenceUL, 0, SMPTE_UL_LENGTH); } - ~lh__Writer(){} + virtual ~lh__Writer(){} - Result_t OpenWrite(const char*, EssenceType_t type, ui32_t HeaderSize); + Result_t OpenWrite(const std::string&, 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); }; -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 -lh__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc) -{ - 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; - - // 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 - { - PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_4K)); - m_EssenceSubDescriptor->Rsize = 4; - } - - 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 = 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); - - 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; -} - - // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. ASDCP::Result_t -lh__Writer::OpenWrite(const char* filename, EssenceType_t type, ui32_t HeaderSize) +lh__Writer::OpenWrite(const std::string& filename, EssenceType_t type, ui32_t HeaderSize) { if ( ! m_State.Test_BEGIN() ) return RESULT_STATE; @@ -940,10 +1202,26 @@ lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& l LocalEditRate = PDesc.EditRate; m_PDesc = PDesc; - Result_t result = JP2K_PDesc_to_MD(m_PDesc); + assert(m_Dict); + assert(m_EssenceDescriptor); + assert(m_EssenceSubDescriptor); + Result_t result = JP2K_PDesc_to_MD(m_PDesc, *m_Dict, + *static_cast(m_EssenceDescriptor), + *m_EssenceSubDescriptor); if ( ASDCP_SUCCESS(result) ) { + if ( PDesc.StoredWidth < 2049 ) + { + static_cast(m_EssenceDescriptor)->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_2K)); + m_EssenceSubDescriptor->Rsize = 3; + } + else + { + static_cast(m_EssenceDescriptor)->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_4K)); + m_EssenceSubDescriptor->Rsize = 4; + } + 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(); @@ -951,11 +1229,9 @@ lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& l if ( ASDCP_SUCCESS(result) ) { - ui32_t TCFrameRate = ( m_PDesc.EditRate == EditRate_23_98 ) ? 24 : m_PDesc.EditRate.Numerator; - - result = WriteMXFHeader(label, UL(m_Dict->ul(MDD_JPEG_2000Wrapping)), - PICT_DEF_LABEL, UL(m_EssenceUL), UL(m_Dict->ul(MDD_PictureDataDef)), - LocalEditRate, TCFrameRate); + result = WriteASDCPHeader(label, UL(m_Dict->ul(MDD_MXFGCFUFrameWrappedPictureElement)), + PICT_DEF_LABEL, UL(m_EssenceUL), UL(m_Dict->ul(MDD_PictureDataDef)), + LocalEditRate, derive_timecode_rate_from_edit_rate(m_PDesc.EditRate)); } return result; @@ -978,7 +1254,7 @@ lh__Writer::WriteFrame(const JP2K::FrameBuffer& FrameBuf, bool add_index, ui64_t StreamOffset = m_StreamOffset; if ( ASDCP_SUCCESS(result) ) - result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC); + result = WriteEKLVPacket(FrameBuf, m_EssenceUL, MXF_BER_LENGTH, Ctx, HMAC); if ( ASDCP_SUCCESS(result) && add_index ) { @@ -1002,7 +1278,7 @@ lh__Writer::Finalize() m_State.Goto_FINAL(); - return WriteMXFFooter(); + return WriteASDCPFooter(); } @@ -1032,11 +1308,14 @@ ASDCP::JP2K::MXFWriter::~MXFWriter() // Warning: direct manipulation of MXF structures can interfere // with the normal operation of the wrapper. Caveat emptor! // -ASDCP::MXF::OPAtomHeader& -ASDCP::JP2K::MXFWriter::OPAtomHeader() +ASDCP::MXF::OP1aHeader& +ASDCP::JP2K::MXFWriter::OP1aHeader() { if ( m_Writer.empty() ) - return sg_OPAtomHeader; + { + assert(g_OP1aHeader); + return *g_OP1aHeader; + } return m_Writer->m_HeaderPart; } @@ -1048,15 +1327,33 @@ ASDCP::MXF::OPAtomIndexFooter& ASDCP::JP2K::MXFWriter::OPAtomIndexFooter() { if ( m_Writer.empty() ) - return sg_OPAtomIndexFooter; + { + assert(g_OPAtomIndexFooter); + return *g_OPAtomIndexFooter; + } return m_Writer->m_FooterPart; } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::RIP& +ASDCP::JP2K::MXFWriter::RIP() +{ + if ( m_Writer.empty() ) + { + assert(g_RIP); + return *g_RIP; + } + + return m_Writer->m_RIP; +} + // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. ASDCP::Result_t -ASDCP::JP2K::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info, +ASDCP::JP2K::MXFWriter::OpenWrite(const std::string& filename, const WriterInfo& Info, const PictureDescriptor& PDesc, ui32_t HeaderSize) { if ( Info.LabelSetType == LS_MXF_SMPTE ) @@ -1157,11 +1454,14 @@ ASDCP::JP2K::MXFSWriter::~MXFSWriter() // Warning: direct manipulation of MXF structures can interfere // with the normal operation of the wrapper. Caveat emptor! // -ASDCP::MXF::OPAtomHeader& -ASDCP::JP2K::MXFSWriter::OPAtomHeader() +ASDCP::MXF::OP1aHeader& +ASDCP::JP2K::MXFSWriter::OP1aHeader() { if ( m_Writer.empty() ) - return sg_OPAtomHeader; + { + assert(g_OP1aHeader); + return *g_OP1aHeader; + } return m_Writer->m_HeaderPart; } @@ -1173,15 +1473,33 @@ ASDCP::MXF::OPAtomIndexFooter& ASDCP::JP2K::MXFSWriter::OPAtomIndexFooter() { if ( m_Writer.empty() ) - return sg_OPAtomIndexFooter; + { + assert(g_OPAtomIndexFooter); + return *g_OPAtomIndexFooter; + } return m_Writer->m_FooterPart; } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::RIP& +ASDCP::JP2K::MXFSWriter::RIP() +{ + if ( m_Writer.empty() ) + { + assert(g_RIP); + return *g_RIP; + } + + return m_Writer->m_RIP; +} + // 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, +ASDCP::JP2K::MXFSWriter::OpenWrite(const std::string& filename, const WriterInfo& Info, const PictureDescriptor& PDesc, ui32_t HeaderSize) { if ( Info.LabelSetType == LS_MXF_SMPTE ) @@ -1229,6 +1547,15 @@ ASDCP::JP2K::MXFSWriter::OpenWrite(const char* filename, const WriterInfo& Info, else if ( PDesc.EditRate == ASDCP::EditRate_60 ) TmpPDesc.EditRate = ASDCP::EditRate_120; + else if ( PDesc.EditRate == ASDCP::EditRate_96 ) + TmpPDesc.EditRate = ASDCP::EditRate_192; + + else if ( PDesc.EditRate == ASDCP::EditRate_100 ) + TmpPDesc.EditRate = ASDCP::EditRate_200; + + else if ( PDesc.EditRate == ASDCP::EditRate_120 ) + TmpPDesc.EditRate = ASDCP::EditRate_240; + result = m_Writer->SetSourceStream(TmpPDesc, JP2K_S_PACKAGE_LABEL, PDesc.EditRate); }