ASDCP::Result_t
ASDCP::ATMOS::MXFWriter::h__Writer::Atmos_ADesc_to_MD(const AtmosDescriptor& ADesc)
{
ASDCP_TEST_NULL(m_EssenceDescriptor);
ASDCP_TEST_NULL(m_EssenceSubDescriptor);
MXF::DolbyAtmosSubDescriptor * ADescObj = m_EssenceSubDescriptor;
ADescObj->MaxChannelCount = ADesc.MaxChannelCount;
ADescObj->MaxObjectCount = ADesc.MaxObjectCount;
ADescObj->AtmosID.Set(ADesc.AtmosID);
ADescObj->AtmosVersion = ADesc.AtmosVersion;
ADescObj->FirstFrame = ADesc.FirstFrame;
return RESULT_OK;
}
Result_t
ASDCP::IntegrityPack::TestValues(const ASDCP::FrameBuffer& FB, const byte_t* AssetID,
ui32_t sequence, HMACContext* HMAC)
{
ASDCP_TEST_NULL(AssetID);
ASDCP_TEST_NULL(HMAC);
// find the start of the intpack
byte_t* p = (byte_t*)FB.RoData() + ( FB.Size() - klv_intpack_size );
// test the AssetID length
if ( ! Kumu::read_test_BER(&p, UUIDlen) )
return RESULT_HMACFAIL;
// test the AssetID
if ( memcmp(p, AssetID, UUIDlen) != 0 )
{
DefaultLogSink().Error("IntegrityPack failure: AssetID mismatch.\n");
return RESULT_HMACFAIL;
}
p += UUIDlen;
// test the sequence length
if ( ! Kumu::read_test_BER(&p, sizeof(ui64_t)) )
return RESULT_HMACFAIL;
ui32_t test_sequence = (ui32_t)KM_i64_BE(Kumu::cp2i<ui64_t>(p));
// test the sequence value
if ( test_sequence != sequence )
{
DefaultLogSink().Error("IntegrityPack failure: sequence is %u, expecting %u.\n", test_sequence, sequence);
return RESULT_HMACFAIL;
}
p += sizeof(ui64_t);
// test the HMAC length
if ( ! Kumu::read_test_BER(&p, HMAC_SIZE) )
return RESULT_HMACFAIL;
// test the HMAC
HMAC->Reset();
HMAC->Update(FB.RoData(), FB.Size() - HMAC_SIZE);
HMAC->Finalize();
return HMAC->TestHMACValue(p);
}
Result_t
ASDCP::IntegrityPack::CalcValues(const ASDCP::FrameBuffer& FB, const byte_t* AssetID,
ui32_t sequence, HMACContext* HMAC)
{
ASDCP_TEST_NULL(AssetID);
ASDCP_TEST_NULL(HMAC);
byte_t* p = Data;
HMAC->Reset();
static byte_t ber_4[MXF_BER_LENGTH] = {0x83, 0, 0, 0};
// update HMAC with essence data
HMAC->Update(FB.RoData(), FB.Size());
// track file ID length
memcpy(p, ber_4, MXF_BER_LENGTH);
*(p+3) = UUIDlen;;
p += MXF_BER_LENGTH;
// track file ID
memcpy(p, AssetID, UUIDlen);
p += UUIDlen;
// sequence length
memcpy(p, ber_4, MXF_BER_LENGTH);
*(p+3) = sizeof(ui64_t);
p += MXF_BER_LENGTH;
// sequence number
Kumu::i2p<ui64_t>(KM_i64_BE(sequence), p);
p += sizeof(ui64_t);
// HMAC length
memcpy(p, ber_4, MXF_BER_LENGTH);
*(p+3) = HMAC_SIZE;
p += MXF_BER_LENGTH;
// update HMAC with intpack values
HMAC->Update(Data, klv_intpack_size - HMAC_SIZE);
// finish & write HMAC
HMAC->Finalize();
HMAC->GetHMACValue(p);
assert(p + HMAC_SIZE == Data + klv_intpack_size);
return RESULT_OK;
}
Result_t
ASDCP::MD_to_CryptoInfo(CryptographicContext* InfoObj, WriterInfo& Info, const Dictionary& Dict)
{
ASDCP_TEST_NULL(InfoObj);
Info.EncryptedEssence = true;
memcpy(Info.ContextID, InfoObj->ContextID.Value(), UUIDlen);
memcpy(Info.CryptographicKeyID, InfoObj->CryptographicKeyID.Value(), UUIDlen);
UL MIC_SHA1(Dict.ul(MDD_MICAlgorithm_HMAC_SHA1));
UL MIC_NONE(Dict.ul(MDD_MICAlgorithm_NONE));
if ( InfoObj->MICAlgorithm == MIC_SHA1 )
Info.UsesHMAC = true;
else if ( InfoObj->MICAlgorithm == MIC_NONE )
Info.UsesHMAC = false;
else
{
DefaultLogSink().Error("Unexpected MICAlgorithm UL.\n");
return RESULT_FORMAT;
}
return RESULT_OK;
}
ASDCP::Result_t
ASDCP::ATMOS::MXFReader::h__Reader::MD_to_Atmos_ADesc(ATMOS::AtmosDescriptor& ADesc)
{
ASDCP_TEST_NULL(m_EssenceSubDescriptor);
Result_t result = MD_to_DCData_DDesc(ADesc);
if( ASDCP_SUCCESS(result) )
{
MXF::DolbyAtmosSubDescriptor* ADescObj = m_EssenceSubDescriptor;
ADesc.MaxChannelCount = ADescObj->MaxChannelCount;
ADesc.MaxObjectCount = ADescObj->MaxObjectCount;
::memcpy(ADesc.AtmosID, ADescObj->AtmosID.Value(), UUIDlen);
ADesc.AtmosVersion = ADescObj->AtmosVersion;
ADesc.FirstFrame = ADescObj->FirstFrame;
}
return result;
}
Result_t
ASDCP::PCM_ADesc_to_MD(PCM::AudioDescriptor& ADesc, MXF::WaveAudioDescriptor* ADescObj)
{
ASDCP_TEST_NULL(ADescObj);
ADescObj->SampleRate = ADesc.EditRate;
ADescObj->AudioSamplingRate = ADesc.AudioSamplingRate;
ADescObj->Locked = ADesc.Locked;
ADescObj->ChannelCount = ADesc.ChannelCount;
ADescObj->QuantizationBits = ADesc.QuantizationBits;
ADescObj->BlockAlign = ADesc.BlockAlign;
ADescObj->AvgBps = ADesc.AvgBps;
ADescObj->LinkedTrackID = ADesc.LinkedTrackID;
ADescObj->ContainerDuration = ADesc.ContainerDuration;
ADescObj->ChannelAssignment.get().Reset();
switch ( ADesc.ChannelFormat )
{
case PCM::CF_CFG_1:
ADescObj->ChannelAssignment = DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_1_5p1).ul;
break;
case PCM::CF_CFG_2:
ADescObj->ChannelAssignment = DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_2_6p1).ul;
break;
case PCM::CF_CFG_3:
ADescObj->ChannelAssignment = DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_3_7p1).ul;
break;
case PCM::CF_CFG_4:
ADescObj->ChannelAssignment = DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_4_WTF).ul;
break;
case PCM::CF_CFG_5:
ADescObj->ChannelAssignment = DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_5_7p1_DS).ul;
break;
case PCM::CF_CFG_6:
ADescObj->ChannelAssignment = DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_MCA).ul;
break;
}
return RESULT_OK;
}
ASDCP::Result_t
ASDCP::MD_to_PCM_ADesc(MXF::WaveAudioDescriptor* ADescObj, PCM::AudioDescriptor& ADesc)
{
ASDCP_TEST_NULL(ADescObj);
ADesc.EditRate = ADescObj->SampleRate;
ADesc.AudioSamplingRate = ADescObj->AudioSamplingRate;
ADesc.Locked = ADescObj->Locked;
ADesc.ChannelCount = ADescObj->ChannelCount;
ADesc.QuantizationBits = ADescObj->QuantizationBits;
ADesc.BlockAlign = ADescObj->BlockAlign;
ADesc.AvgBps = ADescObj->AvgBps;
ADesc.LinkedTrackID = ADescObj->LinkedTrackID;
assert(ADescObj->ContainerDuration <= 0xFFFFFFFFL);
ADesc.ContainerDuration = (ui32_t) ADescObj->ContainerDuration;
ADesc.ChannelFormat = PCM::CF_NONE;
if ( ! ADescObj->ChannelAssignment.empty() )
{
if ( ADescObj->ChannelAssignment == DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_1_5p1).ul )
ADesc.ChannelFormat = PCM::CF_CFG_1;
else if ( ADescObj->ChannelAssignment == DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_2_6p1).ul )
ADesc.ChannelFormat = PCM::CF_CFG_2;
else if ( ADescObj->ChannelAssignment == DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_3_7p1).ul )
ADesc.ChannelFormat = PCM::CF_CFG_3;
else if ( ADescObj->ChannelAssignment == DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_4_WTF).ul )
ADesc.ChannelFormat = PCM::CF_CFG_4;
else if ( ADescObj->ChannelAssignment == DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_5_7p1_DS).ul )
ADesc.ChannelFormat = PCM::CF_CFG_5;
else if ( ADescObj->ChannelAssignment == DefaultSMPTEDict().Type(MDD_DCAudioChannelCfg_MCA).ul )
ADesc.ChannelFormat = PCM::CF_CFG_6;
}
return RESULT_OK;
}
Result_t
ASDCP::MD_to_WriterInfo(Identification* InfoObj, WriterInfo& Info)
{
ASDCP_TEST_NULL(InfoObj);
char tmp_str[IdentBufferLen];
Info.ProductName = "Unknown Product";
Info.ProductVersion = "Unknown Version";
Info.CompanyName = "Unknown Company";
memset(Info.ProductUUID, 0, UUIDlen);
InfoObj->ProductName.EncodeString(tmp_str, IdentBufferLen);
if ( *tmp_str ) Info.ProductName = tmp_str;
InfoObj->VersionString.EncodeString(tmp_str, IdentBufferLen);
if ( *tmp_str ) Info.ProductVersion = tmp_str;
InfoObj->CompanyName.EncodeString(tmp_str, IdentBufferLen);
if ( *tmp_str ) Info.CompanyName = tmp_str;
memcpy(Info.ProductUUID, InfoObj->ProductUID.Value(), UUIDlen);
return RESULT_OK;
}
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;
}
Result_t
ASDCP::EncryptFrameBuffer(const ASDCP::FrameBuffer& FBin, ASDCP::FrameBuffer& FBout, AESEncContext* Ctx)
{
ASDCP_TEST_NULL(Ctx);
FBout.Size(0);
// size the buffer
Result_t result = FBout.Capacity(calc_esv_length(FBin.Size(), FBin.PlaintextOffset()));
// write the IV
byte_t* p = FBout.Data();
// write the IV to the frame buffer
Ctx->GetIVec(p);
p += CBC_BLOCK_SIZE;
// encrypt the check value to the frame buffer
if ( ASDCP_SUCCESS(result) )
{
result = Ctx->EncryptBlock(ESV_CheckValue, p, CBC_BLOCK_SIZE);
p += CBC_BLOCK_SIZE;
}
// write optional plaintext region
if ( FBin.PlaintextOffset() > 0 )
{
assert(FBin.PlaintextOffset() <= FBin.Size());
memcpy(p, FBin.RoData(), FBin.PlaintextOffset());
p += FBin.PlaintextOffset();
}
ui32_t ct_size = FBin.Size() - FBin.PlaintextOffset();
ui32_t diff = ct_size % CBC_BLOCK_SIZE;
ui32_t block_size = ct_size - diff;
assert((block_size % CBC_BLOCK_SIZE) == 0);
// encrypt the ciphertext region essence data
if ( ASDCP_SUCCESS(result) )
{
result = Ctx->EncryptBlock(FBin.RoData() + FBin.PlaintextOffset(), p, block_size);
p += block_size;
}
// construct and encrypt the padding
if ( ASDCP_SUCCESS(result) )
{
byte_t the_last_block[CBC_BLOCK_SIZE];
if ( diff > 0 )
memcpy(the_last_block, FBin.RoData() + FBin.PlaintextOffset() + block_size, diff);
for (ui32_t i = 0; diff < CBC_BLOCK_SIZE; diff++, i++ )
the_last_block[diff] = i;
result = Ctx->EncryptBlock(the_last_block, p, CBC_BLOCK_SIZE);
}
if ( ASDCP_SUCCESS(result) )
FBout.Size(calc_esv_length(FBin.Size(), FBin.PlaintextOffset()));
return result;
}