// Open the file for writing. The file must not exist. Returns error if
// the operation cannot be completed.
ASDCP::Result_t
ASDCP::ATMOS::MXFWriter::OpenWrite(const std::string& filename, const WriterInfo& Info,
const AtmosDescriptor& ADesc, ui32_t HeaderSize)
{
if ( Info.LabelSetType != LS_MXF_SMPTE )
{
DefaultLogSink().Error("Atmos support requires LS_MXF_SMPTE\n");
return RESULT_FORMAT;
}
m_Writer = new h__Writer(DefaultSMPTEDict());
m_Writer->m_Info = Info;
Result_t result = m_Writer->OpenWrite(filename, HeaderSize, ADesc);
if ( ASDCP_SUCCESS(result) )
result = m_Writer->SetSourceStream(ADesc, ATMOS_ESSENCE_CODING, ATMOS_PACKAGE_LABEL,
ATMOS_DEF_LABEL);
if ( ASDCP_FAILURE(result) )
m_Writer.release();
return result;
}
Result_t
ASDCP::DecryptFrameBuffer(const ASDCP::FrameBuffer& FBin, ASDCP::FrameBuffer& FBout, AESDecContext* Ctx)
{
ASDCP_TEST_NULL(Ctx);
assert(FBout.Capacity() >= FBin.SourceLength());
ui32_t ct_size = FBin.SourceLength() - FBin.PlaintextOffset();
ui32_t diff = ct_size % CBC_BLOCK_SIZE;
ui32_t block_size = ct_size - diff;
assert(block_size);
assert((block_size % CBC_BLOCK_SIZE) == 0);
const byte_t* buf = FBin.RoData();
// get ivec
Ctx->SetIVec(buf);
buf += CBC_BLOCK_SIZE;
// decrypt and test check value
byte_t CheckValue[CBC_BLOCK_SIZE];
Result_t result = Ctx->DecryptBlock(buf, CheckValue, CBC_BLOCK_SIZE);
buf += CBC_BLOCK_SIZE;
if ( memcmp(CheckValue, ESV_CheckValue, CBC_BLOCK_SIZE) != 0 )
return RESULT_CHECKFAIL;
// copy plaintext region
if ( FBin.PlaintextOffset() > 0 )
{
memcpy(FBout.Data(), buf, FBin.PlaintextOffset());
buf += FBin.PlaintextOffset();
}
// decrypt all but last block
if ( ASDCP_SUCCESS(result) )
{
result = Ctx->DecryptBlock(buf, FBout.Data() + FBin.PlaintextOffset(), block_size);
buf += block_size;
}
// decrypt last block
if ( ASDCP_SUCCESS(result) )
{
byte_t the_last_block[CBC_BLOCK_SIZE];
result = Ctx->DecryptBlock(buf, the_last_block, CBC_BLOCK_SIZE);
if ( the_last_block[diff] != 0 )
{
DefaultLogSink().Error("Unexpected non-zero padding value.\n");
return RESULT_FORMAT;
}
if ( diff > 0 )
memcpy(FBout.Data() + FBin.PlaintextOffset() + block_size, the_last_block, diff);
}
if ( ASDCP_SUCCESS(result) )
FBout.Size(FBin.SourceLength());
return result;
}
ASDCP::Result_t
ASDCP::EssenceType(const std::string& filename, EssenceType_t& type)
{
const Dictionary* m_Dict = &DefaultCompositeDict();
InterchangeObject* md_object = 0;
assert(m_Dict);
Kumu::FileReader Reader;
OP1aHeader TestHeader(m_Dict);
Result_t result = Reader.OpenRead(filename);
if ( ASDCP_SUCCESS(result) )
result = TestHeader.InitFromFile(Reader); // test UL and OP
if ( ASDCP_SUCCESS(result) )
{
type = ESS_UNKNOWN;
if ( TestHeader.OperationalPattern == UL(m_Dict->ul(MDD_OPAtom))
|| TestHeader.OperationalPattern == UL(m_Dict->ul(MDD_MXFInterop_OPAtom)) )
{
if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor))) )
{
if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(StereoscopicPictureSubDescriptor))) )
{
type = ESS_JPEG_2000_S;
}
else
{
type = ESS_JPEG_2000;
}
}
else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(WaveAudioDescriptor), &md_object)) )
{
assert(md_object);
if ( static_cast<ASDCP::MXF::WaveAudioDescriptor*>(md_object)->AudioSamplingRate == SampleRate_96k )
{
type = ESS_PCM_24b_96k;
}
else
{
type = ESS_PCM_24b_48k;
}
}
else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(MPEG2VideoDescriptor))) )
{
type = ESS_MPEG2_VES;
}
else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(TimedTextDescriptor))) )
{
type = ESS_TIMED_TEXT;
}
else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(DCDataDescriptor))) )
{
if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(DolbyAtmosSubDescriptor))) )
{
type = ESS_DCDATA_DOLBY_ATMOS;
}
else
{
type = ESS_DCDATA_UNKNOWN;
}
}
}
else if ( TestHeader.OperationalPattern == UL(m_Dict->ul(MDD_OP1a)) )
{
if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor))) )
{
type = ESS_AS02_JPEG_2000;
}
else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(WaveAudioDescriptor), &md_object)) )
{
assert(md_object);
if ( static_cast<ASDCP::MXF::WaveAudioDescriptor*>(md_object)->AudioSamplingRate == SampleRate_96k )
{
type = ESS_AS02_PCM_24b_96k;
}
else
{
type = ESS_AS02_PCM_24b_48k;
}
}
else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(TimedTextDescriptor))) )
{
type = ESS_AS02_TIMED_TEXT;
}
}
else
{
DefaultLogSink().Error("Unsupported MXF Operational Pattern.\n");
return RESULT_FORMAT;
}
}
return result;
}
ASDCP::Result_t
ASDCP::PCM::MXFReader::h__Reader::OpenRead(const std::string& filename)
{
Result_t result = OpenMXFRead(filename);
if( ASDCP_SUCCESS(result) )
{
InterchangeObject* Object = 0
;
if ( ASDCP_SUCCESS(m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(WaveAudioDescriptor), &Object)) )
{
if ( Object == 0 )
{
DefaultLogSink().Error("WaveAudioDescriptor object not found.\n");
return RESULT_FORMAT;
}
result = MD_to_PCM_ADesc((MXF::WaveAudioDescriptor*)Object, m_ADesc);
}
}
if ( m_ADesc.ContainerDuration == 0 )
{
DefaultLogSink().Error("ContainerDuration unset.\n");
return RESULT_FORMAT;
}
// check for sample/frame rate sanity
if ( ASDCP_SUCCESS(result)
&& m_ADesc.EditRate != EditRate_24
&& m_ADesc.EditRate != EditRate_25
&& m_ADesc.EditRate != EditRate_30
&& m_ADesc.EditRate != EditRate_48
&& m_ADesc.EditRate != EditRate_50
&& m_ADesc.EditRate != EditRate_60
&& m_ADesc.EditRate != EditRate_96
&& m_ADesc.EditRate != EditRate_100
&& m_ADesc.EditRate != EditRate_120
&& m_ADesc.EditRate != EditRate_16
&& m_ADesc.EditRate != EditRate_18
&& m_ADesc.EditRate != EditRate_20
&& m_ADesc.EditRate != EditRate_22
&& m_ADesc.EditRate != EditRate_23_98 )
{
DefaultLogSink().Error("PCM file EditRate is not a supported value: %d/%d\n", // lu
m_ADesc.EditRate.Numerator, m_ADesc.EditRate.Denominator);
// oh, they gave us the audio sampling rate instead, assume 24/1
if ( m_ADesc.EditRate == SampleRate_48k || m_ADesc.EditRate == SampleRate_96k )
{
DefaultLogSink().Warn("adjusting EditRate to 24/1\n");
m_ADesc.EditRate = EditRate_24;
}
else
{
DefaultLogSink().Error("PCM EditRate not in expected value range.\n");
// or we just drop the hammer
return RESULT_FORMAT;
}
}
// TODO: test file for sane CBR index BytesPerEditUnit
return result;
}
