/*
-Copyright (c) 2004-2013, John Hurst
+Copyright (c) 2004-2016, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
#include "AS_DCP_internal.h"
#include <iostream>
#include <iomanip>
+#include <algorithm>
using namespace ASDCP::JP2K;
using Kumu::GenRandomValue;
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&
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
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;
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;
}
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'
);
}
- 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<ui16_t>(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++]);
+
+ }
+ }
+
+ }
+
}
ASDCP::Result_t
ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc,
const ASDCP::Dictionary& dict,
- ASDCP::MXF::RGBAEssenceDescriptor *EssenceDescriptor,
- ASDCP::MXF::JPEG2000PictureSubDescriptor *EssenceSubDescriptor)
-{
- if ( EssenceDescriptor == 0 || EssenceSubDescriptor == 0 )
- return RESULT_PTR;
-
- EssenceDescriptor->ContainerDuration = PDesc.ContainerDuration;
- EssenceDescriptor->SampleRate = PDesc.EditRate;
- EssenceDescriptor->FrameLayout = 0;
- EssenceDescriptor->StoredWidth = PDesc.StoredWidth;
- EssenceDescriptor->StoredHeight = PDesc.StoredHeight;
- EssenceDescriptor->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
- // }
-
- if ( PDesc.StoredWidth < 2049 )
- {
- EssenceDescriptor->PictureEssenceCoding.Set(dict.ul(MDD_JP2KEssenceCompression_2K));
- EssenceSubDescriptor->Rsize = 3;
- }
- else
- {
- EssenceDescriptor->PictureEssenceCoding.Set(dict.ul(MDD_JP2KEssenceCompression_4K));
- EssenceSubDescriptor->Rsize = 4;
- }
-
- 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;
+ 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+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(EssenceSubDescriptor->PictureComponentSizing.Data(), tmp_buffer, pcomp_size);
- EssenceSubDescriptor->PictureComponentSizing.Length(pcomp_size);
+ 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, i;
- for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ )
+ 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.Data(), &PDesc.CodingStyleDefault, csd_size);
- EssenceSubDescriptor->CodingStyleDefault.Length(csd_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.Data(), &PDesc.QuantizationDefault, qdflt_size);
- EssenceSubDescriptor->QuantizationDefault.Length(qdflt_size);
+ memcpy(EssenceSubDescriptor.QuantizationDefault.get().Data(), &PDesc.QuantizationDefault, qdflt_size);
+ EssenceSubDescriptor.QuantizationDefault.get().Length(qdflt_size);
+ EssenceSubDescriptor.QuantizationDefault.set_has_value();
- return RESULT_OK;
-}
+ // Profile
+ if (PDesc.Profile.N == 0) {
+ EssenceSubDescriptor.J2KProfile.set_has_value(false);
+ } else {
+ EssenceSubDescriptor.J2KProfile.get().resize(PDesc.Profile.N);
-//
-ASDCP::Result_t
-ASDCP::MD_to_JP2K_PDesc(const ASDCP::MXF::RGBAEssenceDescriptor& EssenceDescriptor,
- const ASDCP::MXF::JPEG2000PictureSubDescriptor& EssenceSubDescriptor,
- const ASDCP::Rational& EditRate, const ASDCP::Rational& SampleRate,
- ASDCP::JP2K::PictureDescriptor& PDesc)
-{
- memset(&PDesc, 0, sizeof(PDesc));
+ std::copy(PDesc.Profile.Pprf,
+ PDesc.Profile.Pprf + PDesc.Profile.N,
+ EssenceSubDescriptor.J2KProfile.get().begin());
- PDesc.EditRate = EditRate;
- PDesc.SampleRate = SampleRate;
- assert(EssenceDescriptor.ContainerDuration <= 0xFFFFFFFFL);
- PDesc.ContainerDuration = (ui32_t) EssenceDescriptor.ContainerDuration;
- PDesc.StoredWidth = EssenceDescriptor.StoredWidth;
- PDesc.StoredHeight = EssenceDescriptor.StoredHeight;
- PDesc.AspectRatio = EssenceDescriptor.AspectRatio;
+ EssenceSubDescriptor.J2KProfile.set_has_value();
+ }
- 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;
+ // Corresponding profile
- // PictureComponentSizing
- ui32_t tmp_size = EssenceSubDescriptor.PictureComponentSizing.Length();
+ if (PDesc.CorrespondingProfile.N == 0) {
+
+ EssenceSubDescriptor.J2KCorrespondingProfile.set_has_value(false);
+
+ } else {
+ EssenceSubDescriptor.J2KCorrespondingProfile.get().resize(PDesc.CorrespondingProfile.N);
- if ( tmp_size == 17 ) // ( 2 * sizeof(ui32_t) ) + 3 components * 3 byte each
- {
- memcpy(&PDesc.ImageComponents, EssenceSubDescriptor.PictureComponentSizing.RoData() + 8, tmp_size - 8);
- }
- else
- {
- DefaultLogSink().Error("Unexpected PictureComponentSizing size: %u, should be 17\n", tmp_size);
- }
+ std::copy(PDesc.CorrespondingProfile.Pcpf,
+ PDesc.CorrespondingProfile.Pcpf + PDesc.CorrespondingProfile.N,
+ EssenceSubDescriptor.J2KCorrespondingProfile.get().begin());
- // CodingStyleDefault
- memset(&PDesc.CodingStyleDefault, 0, sizeof(CodingStyleDefault_t));
- memcpy(&PDesc.CodingStyleDefault,
- EssenceSubDescriptor.CodingStyleDefault.RoData(),
- EssenceSubDescriptor.CodingStyleDefault.Length());
+ EssenceSubDescriptor.J2KCorrespondingProfile.set_has_value();
+ }
- // QuantizationDefault
- memset(&PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t));
- memcpy(&PDesc.QuantizationDefault,
- EssenceSubDescriptor.QuantizationDefault.RoData(),
- EssenceSubDescriptor.QuantizationDefault.Length());
-
- PDesc.QuantizationDefault.SPqcdLength = EssenceSubDescriptor.QuantizationDefault.Length() - 1;
- return RESULT_OK;
-}
+ // Extended capabilities
-//
-ASDCP::Result_t
-ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc,
- const ASDCP::Dictionary& dict,
- ASDCP::MXF::CDCIEssenceDescriptor *EssenceDescriptor,
- ASDCP::MXF::JPEG2000PictureSubDescriptor *EssenceSubDescriptor)
-{
- if ( EssenceDescriptor == 0 || EssenceSubDescriptor == 0 )
- return RESULT_PTR;
-
- EssenceDescriptor->ContainerDuration = PDesc.ContainerDuration;
- EssenceDescriptor->SampleRate = PDesc.EditRate;
- EssenceDescriptor->FrameLayout = 0;
- EssenceDescriptor->StoredWidth = PDesc.StoredWidth;
- EssenceDescriptor->StoredHeight = PDesc.StoredHeight;
- EssenceDescriptor->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
- // }
-
- if ( PDesc.StoredWidth < 2049 )
- {
- EssenceDescriptor->PictureEssenceCoding.Set(dict.ul(MDD_JP2KEssenceCompression_2K));
- EssenceSubDescriptor->Rsize = 3;
- }
- else
- {
- EssenceDescriptor->PictureEssenceCoding.Set(dict.ul(MDD_JP2KEssenceCompression_4K));
- EssenceSubDescriptor->Rsize = 4;
- }
+ if (PDesc.ExtendedCapabilities.N == JP2K::NoExtendedCapabilitiesSignaled) {
- 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;
+ /* No extended capabilities are signaled */
- const ui32_t tmp_buffer_len = 1024;
- byte_t tmp_buffer[tmp_buffer_len];
+ EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(false);
- *(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);
+ } else {
- const ui32_t pcomp_size = (sizeof(int) * 2) + (sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents);
- memcpy(EssenceSubDescriptor->PictureComponentSizing.Data(), tmp_buffer, pcomp_size);
- EssenceSubDescriptor->PictureComponentSizing.Length(pcomp_size);
+ EssenceSubDescriptor.J2KExtendedCapabilities.get().Pcap = PDesc.ExtendedCapabilities.Pcap;
- ui32_t precinct_set_size = 0, i;
- for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ )
- precinct_set_size++;
+ EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap.resize(PDesc.ExtendedCapabilities.N);
- ui32_t csd_size = sizeof(CodingStyleDefault_t) - MaxPrecincts + precinct_set_size;
- memcpy(EssenceSubDescriptor->CodingStyleDefault.Data(), &PDesc.CodingStyleDefault, csd_size);
- EssenceSubDescriptor->CodingStyleDefault.Length(csd_size);
+ std::copy(PDesc.ExtendedCapabilities.Ccap,
+ PDesc.ExtendedCapabilities.Ccap + PDesc.ExtendedCapabilities.N,
+ EssenceSubDescriptor.J2KExtendedCapabilities.get().Ccap.begin());
- ui32_t qdflt_size = PDesc.QuantizationDefault.SPqcdLength + 1;
- memcpy(EssenceSubDescriptor->QuantizationDefault.Data(), &PDesc.QuantizationDefault, qdflt_size);
- EssenceSubDescriptor->QuantizationDefault.Length(qdflt_size);
+ EssenceSubDescriptor.J2KExtendedCapabilities.set_has_value(true);
+
+ }
return RESULT_OK;
}
//
ASDCP::Result_t
-ASDCP::MD_to_JP2K_PDesc(const ASDCP::MXF::CDCIEssenceDescriptor& EssenceDescriptor,
+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)
PDesc.EditRate = EditRate;
PDesc.SampleRate = SampleRate;
- assert(EssenceDescriptor.ContainerDuration <= 0xFFFFFFFFL);
- PDesc.ContainerDuration = (ui32_t) EssenceDescriptor.ContainerDuration;
+ 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.Csize = EssenceSubDescriptor.Csize;
// PictureComponentSizing
- ui32_t tmp_size = EssenceSubDescriptor.PictureComponentSizing.Length();
+ 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.RoData() + 8, tmp_size - 8);
+ memcpy(&PDesc.ImageComponents, EssenceSubDescriptor.PictureComponentSizing.const_get().RoData() + 8, tmp_size - 8);
}
else
{
- DefaultLogSink().Error("Unexpected PictureComponentSizing size: %u, should be 17\n", tmp_size);
+ 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.RoData(),
- EssenceSubDescriptor.CodingStyleDefault.Length());
+ EssenceSubDescriptor.CodingStyleDefault.const_get().RoData(),
+ EssenceSubDescriptor.CodingStyleDefault.const_get().Length());
// QuantizationDefault
memset(&PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t));
memcpy(&PDesc.QuantizationDefault,
- EssenceSubDescriptor.QuantizationDefault.RoData(),
- EssenceSubDescriptor.QuantizationDefault.Length());
+ EssenceSubDescriptor.QuantizationDefault.const_get().RoData(),
+ EssenceSubDescriptor.QuantizationDefault.const_get().Length());
- PDesc.QuantizationDefault.SPqcdLength = EssenceSubDescriptor.QuantizationDefault.Length() - 1;
- return RESULT_OK;
-}
+ PDesc.QuantizationDefault.SPqcdLength = EssenceSubDescriptor.QuantizationDefault.const_get().Length() - 1;
-// Compares the actual floating point value of the rates.
-// This allows, for example, {300000,1001} and {2997,100) to be considered equivalent.
-// to 29.97.
-bool
-epsilon_compare(const ASDCP::Rational& left, const ASDCP::Rational& right, double epsilon = 0.001)
-{
- bool result = false;
- double difference = left.Quotient() - right.Quotient();
+ // Profile
- if (fabs(difference) < epsilon)
- result = true;
+ std::fill(PDesc.Profile.Pprf, PDesc.Profile.Pprf + JP2K::MaxPRFN, 0);
- return result;
+ 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;
}
-// end DOLBY
//------------------------------------------------------------------------------------------
virtual ~lh__Reader() {}
- Result_t OpenRead(const char*, EssenceType_t);
+ Result_t OpenRead(const std::string&, EssenceType_t);
Result_t ReadFrame(ui32_t, JP2K::FrameBuffer&, AESDecContext*, HMACContext*);
};
//
//
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);
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;
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",
// 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);
}
if ( ASDCP_FAILURE(m_IndexAccess.Lookup(FrameNum, TmpEntry)) )
{
- DefaultLogSink().Error("Frame value out of range: %u\n", FrameNum);
return RESULT_RANGE;
}
// 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);
}
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*);
// 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;
m_PDesc = PDesc;
assert(m_Dict);
+ assert(m_EssenceDescriptor);
+ assert(m_EssenceSubDescriptor);
Result_t result = JP2K_PDesc_to_MD(m_PDesc, *m_Dict,
- (ASDCP::MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor,
- m_EssenceSubDescriptor);
+ *static_cast<ASDCP::MXF::GenericPictureEssenceDescriptor*>(m_EssenceDescriptor),
+ *m_EssenceSubDescriptor);
if ( ASDCP_SUCCESS(result) )
{
+ if ( PDesc.StoredWidth < 2049 )
+ {
+ static_cast<ASDCP::MXF::RGBAEssenceDescriptor*>(m_EssenceDescriptor)->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_2K));
+ m_EssenceSubDescriptor->Rsize = 3;
+ }
+ else
+ {
+ static_cast<ASDCP::MXF::RGBAEssenceDescriptor*>(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();
if ( ASDCP_SUCCESS(result) )
{
- result = WriteASDCPHeader(label, UL(m_Dict->ul(MDD_JPEG_2000Wrapping)),
+ 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));
}
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 )
{
// 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 )
// 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 )
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);
}