+
+
+ 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<ui32_t>(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;