/*
-Copyright (c) 2004-2005, John Hurst
+Copyright (c) 2004-2016, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
\brief AS-DCP library, misc classes and subroutines
*/
+#include <KM_fileio.h>
+#include <KM_xml.h>
#include "AS_DCP_internal.h"
-#include "FileIO.h"
-#include "DirScanner.h"
#include "JP2K.h"
+#include "ACES.h"
+#include "MPEG.h"
#include "Wav.h"
-#include "MDD.h"
+#include <iostream>
+#include <iomanip>
//------------------------------------------------------------------------------------------
// misc subroutines
+//
+std::ostream&
+ASDCP::operator << (std::ostream& strm, const WriterInfo& Info)
+{
+ char str_buf[40];
+
+ strm << " ProductUUID: " << UUID(Info.ProductUUID).EncodeHex(str_buf, 40) << std::endl;
+ strm << " ProductVersion: " << Info.ProductVersion << std::endl;
+ strm << " CompanyName: " << Info.CompanyName << std::endl;
+ strm << " ProductName: " << Info.ProductName << std::endl;
+ strm << " EncryptedEssence: " << (Info.EncryptedEssence ? "Yes" : "No") << std::endl;
+
+ if ( Info.EncryptedEssence )
+ {
+ strm << " HMAC: " << (Info.UsesHMAC ? "Yes" : "No") << std::endl;
+ strm << " ContextID: " << UUID(Info.ContextID).EncodeHex(str_buf, 40) << std::endl;
+ strm << "CryptographicKeyID: " << UUID(Info.CryptographicKeyID).EncodeHex(str_buf, 40) << std::endl;
+ }
+
+ strm << " AssetUUID: " << UUID(Info.AssetUUID).EncodeHex(str_buf, 40) << std::endl;
+ strm << " Label Set Type: " << (Info.LabelSetType == LS_MXF_SMPTE ? "SMPTE" :
+ (Info.LabelSetType == LS_MXF_INTEROP ? "MXF Interop" :
+ "Unknown")) << std::endl;
+ return strm;
+}
+
//
void
ASDCP::WriterInfoDump(const WriterInfo& Info, FILE* stream)
char str_buf[40];
- fprintf(stream," ProductUUID: %s\n", bin2hex(Info.ProductUUID, 16, str_buf, 40));
+ fprintf(stream," ProductUUID: %s\n", UUID(Info.ProductUUID).EncodeHex(str_buf, 40));
fprintf(stream,"\
ProductVersion: %s\n\
CompanyName: %s\n\
if ( Info.EncryptedEssence )
{
fprintf(stream, " HMAC: %s\n", ( Info.UsesHMAC ? "Yes" : "No"));
- fprintf(stream, " ContextID: %s\n", bin2hex(Info.ContextID, 16, str_buf, 40));
- fprintf(stream, "CryptographicKeyID: %s\n", bin2hex(Info.CryptographicKeyID, 16, str_buf, 40));
+ fprintf(stream, " ContextID: %s\n", UUID(Info.ContextID).EncodeHex(str_buf, 40));
+ fprintf(stream, "CryptographicKeyID: %s\n", UUID(Info.CryptographicKeyID).EncodeHex(str_buf, 40));
}
- fprintf(stream," AssetUUID: %s\n", bin2hex(Info.AssetUUID, 16, str_buf, 40));
+ fprintf(stream," AssetUUID: %s\n", UUID(Info.AssetUUID).EncodeHex(str_buf, 40));
+ fprintf(stream," Label Set Type: %s\n", ( Info.LabelSetType == LS_MXF_SMPTE ? "SMPTE" :
+ ( Info.LabelSetType == LS_MXF_INTEROP ? "MXF Interop" :
+ "Unknown" ) ));
}
//
Info.CompanyName = "Unknown Company";
memset(Info.ProductUUID, 0, UUIDlen);
- InfoObj->ProductName.ToString(tmp_str);
+ InfoObj->ProductName.EncodeString(tmp_str, IdentBufferLen);
if ( *tmp_str ) Info.ProductName = tmp_str;
- InfoObj->VersionString.ToString(tmp_str);
+ InfoObj->VersionString.EncodeString(tmp_str, IdentBufferLen);
if ( *tmp_str ) Info.ProductVersion = tmp_str;
- InfoObj->CompanyName.ToString(tmp_str);
+ InfoObj->CompanyName.EncodeString(tmp_str, IdentBufferLen);
if ( *tmp_str ) Info.CompanyName = tmp_str;
- memcpy(Info.ProductUUID, InfoObj->ProductUID.Data(), UUIDlen);
+ memcpy(Info.ProductUUID, InfoObj->ProductUID.Value(), UUIDlen);
return RESULT_OK;
}
//
Result_t
-ASDCP::MD_to_CryptoInfo(CryptographicContext* InfoObj, WriterInfo& Info)
+ASDCP::MD_to_CryptoInfo(CryptographicContext* InfoObj, WriterInfo& Info, const Dictionary& Dict)
{
ASDCP_TEST_NULL(InfoObj);
Info.EncryptedEssence = true;
- memcpy(Info.ContextID, InfoObj->ContextID.Data(), UUIDlen);
- memcpy(Info.CryptographicKeyID, InfoObj->CryptographicKeyID.Data(), UUIDlen);
+ memcpy(Info.ContextID, InfoObj->ContextID.Value(), UUIDlen);
+ memcpy(Info.CryptographicKeyID, InfoObj->CryptographicKeyID.Value(), UUIDlen);
- UL MIC_SHA1(MICAlgorithm_HMAC_SHA1);
- UL MIC_NONE(MICAlgorithm_NONE);
+ 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;
return RESULT_OK;
}
-#if 0
-
-
-//
-// add DMS CryptographicFramework entry to source package
-void
-ASDCP::AddDMScrypt(PackagePtr SourcePackage, WriterInfo& Descr, const byte_t* SourceEssenceContainerLabel)
-{
- assert(SourceEssenceContainerLabel);
-
- TrackPtr MPDMTrack = SourcePackage->AddDMTrack(); // zero parameters = static
- DMSegmentPtr MPDMSegment = MPDMTrack->AddDMSegment();
-
- MDObject* Crypto_DMS_Ptr = new MDObject("CryptographicFramework");
- MPDMSegment->AddChild("DMFramework")->MakeLink(*Crypto_DMS_Ptr);
-
- MDObject* Crypto_DMS_BasicPtr = new MDObject("CryptographicContext");
- Crypto_DMS_Ptr->AddChild("ContextSR")->MakeLink(*Crypto_DMS_BasicPtr);
-
- UUID ContextID(Descr.ContextID);
- Crypto_DMS_BasicPtr->SetValue("ContextID", DataChunk(UUIDlen, ContextID.GetValue())); // UUID
- Crypto_DMS_BasicPtr->SetValue("SourceEssenceContainer",
- DataChunk(klv_key_size, SourceEssenceContainerLabel)); // Label
- Crypto_DMS_BasicPtr->SetValue("CipherAlgorithm", DataChunk(klv_key_size, CipherAlgorithm_AES)); // UL Key
-
- Crypto_DMS_BasicPtr->SetValue("MICAlgorithm",
- DataChunk(KeyLen,
- (Descr.UsesHMAC ?
- MICAlgorithm_HMAC_SHA1
- : MICAlgorithm_NONE))); // UL Key
-
- UUID CryptographicKeyID(Descr.CryptographicKeyID);
-
- Crypto_DMS_BasicPtr->SetValue("CryptographicKeyID", DataChunk(UUIDlen, CryptographicKeyID.GetValue())); // UUID
-}
-
-
//
//
ASDCP::Result_t
-ASDCP::FindObject(const char* filename, const char* objname, FILE* stream)
+ASDCP::EssenceType(const std::string& filename, EssenceType_t& type)
{
- ASDCP_TEST_NULL_STR(filename);
- ASDCP_TEST_NULL_STR(objname);
-
- if ( stream == 0 )
- stream = stderr;
+ const Dictionary* m_Dict = &DefaultCompositeDict();
+ InterchangeObject* md_object = 0;
- ASDCP::h__Reader Reader;
- Result_t result = Reader.OpenMXFRead(filename);
-
- if ( ASDCP_FAILURE(result) )
- return result;
-
- MDObject* DescObj = Reader.GetMDObjectByType(objname);
-
- if ( DescObj )
- {
- DumpMDObject(*DescObj, " ", stream);
- return RESULT_OK;
- }
-
- return RESULT_FAIL;
-}
-#endif
-
-//
-//
-ASDCP::Result_t
-ASDCP::EssenceType(const char* filename, EssenceType_t& type)
-{
- ASDCP_TEST_NULL_STR(filename);
- FileReader Reader;
- OPAtomHeader TestHeader;
+ assert(m_Dict);
+ Kumu::FileReader Reader;
+ OP1aHeader TestHeader(m_Dict);
Result_t result = Reader.OpenRead(filename);
if ( ASDCP_SUCCESS(result) )
{
type = ESS_UNKNOWN;
- if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor))) )
- type = ESS_JPEG_2000;
- else
+
+ 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)))
+ || ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(PrivateDCDataDescriptor))) )
+ {
+ 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(WaveAudioDescriptor))) )
- type = ESS_PCM_24b_48k;
- else
+ // ST 2065-5 Picture Descriptor does not have a mandatory SubDescriptor, check EssenceContainer instead
+ if (ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor))) )
+ {
+ MXF::RGBAEssenceDescriptor *rgba_descriptor = 0;
+ char buf[64];
+
+ if ASDCP_SUCCESS(TestHeader.GetMDObjectByType(m_Dict->ul(MDD_RGBAEssenceDescriptor), reinterpret_cast<MXF::InterchangeObject**>(&rgba_descriptor)))
{
- if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(MPEG2VideoDescriptor))) )
- type = ESS_MPEG2_VES;
+ if (rgba_descriptor->EssenceContainer == m_Dict->ul(MDD_MXFGCFrameWrappedACESPictures))
+ type = ESS_AS02_ACES;
}
+ }
+ if (type == ESS_UNKNOWN)
+ {
+
+ 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 if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(PIMFDynamicMetadataDescriptor))) )
+ {
+ type = ESS_DCDATA_UNKNOWN;
+ }
+ else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(ISXDDataEssenceDescriptor))) )
+ {
+ type = ESS_AS02_ISXD;
+ }
+ else if ( ASDCP_SUCCESS(TestHeader.GetMDObjectByType(OBJ_TYPE_ARGS(ACESPictureSubDescriptor))) )
+ {
+ type = ESS_AS02_ACES;
+ }
+ }
+ }
+ else
+ {
+ DefaultLogSink().Error("Unsupported MXF Operational Pattern.\n");
+ return RESULT_FORMAT;
}
}
return result;
}
+//
+static bool
+string_is_xml(const ASDCP::FrameBuffer& buffer)
+{
+ return (strncmp((const char *)buffer.RoData(), "<?xml", 5) == 0 ||
+ strncmp((const char *)buffer.RoData(), "\xEF\xBB\xBF<?xml", 8) == 0); // Allow BOM
+ }
+
+ //
//
ASDCP::Result_t
-ASDCP::RawEssenceType(const char* filename, EssenceType_t& type)
+ASDCP::RawEssenceType(const std::string& filename, EssenceType_t& type)
{
- ASDCP_TEST_NULL_STR(filename);
type = ESS_UNKNOWN;
ASDCP::FrameBuffer FB;
- FileReader Reader;
+ Kumu::FileReader Reader;
+ ASDCP::Wav::SimpleWaveHeader WavHeader;
+ ASDCP::RF64::SimpleRF64Header RF64Header;
+ ASDCP::AIFF::SimpleAIFFHeader AIFFHeader;
+ Kumu::XMLElement TmpElement("Tmp");
+
+ ui32_t data_offset;
ui32_t read_count;
Result_t result = FB.Capacity(Wav::MaxWavHeader); // using Wav max because everything else is much smaller
- if ( ASDCP::PathIsFile(filename) )
+ if ( Kumu::PathIsFile(filename) )
{
result = Reader.OpenRead(filename);
if ( ASDCP_SUCCESS(result) )
{
- ASDCP::Wav::SimpleWaveHeader WavHeader;
- ui32_t data_offset;
const byte_t* p = FB.RoData();
+ FB.Size(read_count);
- if ( p[0] == 0 && p[1] == 0 && p[2] == 1 && (p[3] == 0xb3 || p[3] == 0) )
- type = ESS_MPEG2_VES;
+ ui32_t i = 0;
+ while ( p[i] == 0 ) i++;
- else if ( ASDCP_SUCCESS(WavHeader.ReadFromBuffer(p, read_count, &data_offset)) )
- type = ESS_PCM_24b_48k;
+ if ( i > 1 && p[i] == 1 && (p[i+1] == ASDCP::MPEG2::SEQ_START || p[i+1] == ASDCP::MPEG2::PIC_START) )
+ {
+ type = ESS_MPEG2_VES;
+ }
+ else if ( memcmp(FB.RoData(), ASDCP::JP2K::Magic, sizeof(ASDCP::JP2K::Magic)) == 0 )
+ {
+ type = ESS_JPEG_2000;
+ }
+ else if(memcmp(FB.RoData(), AS_02::ACES::Magic, sizeof(AS_02::ACES::Magic)) == 0)
+ {
+ type = ESS_AS02_ACES;
+ }
+ else if ( std::string((const char*)FB.RoData() + 8, 4) == "WAVE" )
+ {
+ if ( std::string((const char*)FB.RoData(), 4) == "RIFF" )
+ {
+ result = WavHeader.ReadFromBuffer(FB.RoData(), read_count, &data_offset);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ switch ( WavHeader.samplespersec )
+ {
+ case 48000: type = ESS_PCM_24b_48k; break;
+ case 96000: type = ESS_PCM_24b_96k; break;
+ default:
+ DefaultLogSink().Error("Unexpected sample rate: %d\n", WavHeader.samplespersec);
+ result = RESULT_FORMAT;
+ }
+ }
+ }
+ else
+ {
+ result = RF64Header.ReadFromBuffer(FB.RoData(), read_count, &data_offset);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ switch ( RF64Header.samplespersec )
+ {
+ case 48000: type = ESS_PCM_24b_48k; break;
+ case 96000: type = ESS_PCM_24b_96k; break;
+ default:
+ DefaultLogSink().Error("Unexpected sample rate: %d\n", WavHeader.samplespersec);
+ result = RESULT_FORMAT;
+ }
+ }
+ }
+ }
+ else if ( ASDCP_SUCCESS(AIFFHeader.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) )
+ {
+ type = ESS_PCM_24b_48k;
+ }
+ else if ( string_is_xml(FB) )
+ {
+ type = ESS_TIMED_TEXT;
+ }
+ else if ( ASDCP::ATMOS::IsDolbyAtmos(filename) )
+ {
+ type = ESS_DCDATA_DOLBY_ATMOS;
+ }
}
}
- else if ( ASDCP::PathIsDirectory(filename) )
+ else if ( Kumu::PathIsDirectory(filename) )
{
- char next_file[ASDCP_MAX_PATH];
- DirScanner Scanner;
+ char next_file[Kumu::MaxFilePath];
+ Kumu::DirScanner Scanner;
Result_t result = Scanner.Open(filename);
if ( ASDCP_SUCCESS(result) )
if ( next_file[0] == '.' ) // no hidden files or internal links
continue;
- std::string Str(filename);
- Str += "/";
- Str += next_file;
- result = Reader.OpenRead(Str.c_str());
+ result = Reader.OpenRead(Kumu::PathJoin(filename, next_file));
if ( ASDCP_SUCCESS(result) )
{
Reader.Close();
}
- if ( ASDCP_SUCCESS(result)
- && ( memcmp(FB.RoData(), ASDCP::JP2K::Magic, sizeof(ASDCP::JP2K::Magic)) == 0 ) )
- type = ESS_JPEG_2000;
-
+ if ( ASDCP_SUCCESS(result) )
+ {
+ if ( memcmp(FB.RoData(), ASDCP::JP2K::Magic, sizeof(ASDCP::JP2K::Magic)) == 0 )
+ {
+ type = ESS_JPEG_2000;
+ }
+ else if(memcmp(FB.RoData(), AS_02::ACES::Magic, sizeof(AS_02::ACES::Magic)) == 0)
+ {
+ type = ESS_AS02_ACES;
+ }
+ else if ( ASDCP_SUCCESS(WavHeader.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) )
+ {
+ switch ( WavHeader.samplespersec )
+ {
+ case 48000: type = ESS_PCM_24b_48k; break;
+ case 96000: type = ESS_PCM_24b_96k; break;
+ default:
+ return RESULT_FORMAT;
+ }
+ }
+ else if ( ASDCP_SUCCESS(RF64Header.ReadFromBuffer(FB.RoData(), read_count, &data_offset)) )
+ {
+ switch ( RF64Header.samplespersec )
+ {
+ case 48000: type = ESS_PCM_24b_48k; break;
+ case 96000: type = ESS_PCM_24b_96k; break;
+ default:
+ return RESULT_FORMAT;
+ }
+ }
+ else if ( ASDCP::ATMOS::IsDolbyAtmos(Kumu::PathJoin(filename, next_file)) )
+ {
+ type = ESS_DCDATA_DOLBY_ATMOS;
+ }
+ else
+ {
+ type = ESS_DCDATA_UNKNOWN;
+ }
+ }
+
break;
}
}
//
Result_t
-ASDCP::IntegrityPack::CalcValues(const ASDCP::FrameBuffer& FB, byte_t* AssetID,
+ASDCP::IntegrityPack::CalcValues(const ASDCP::FrameBuffer& FB, const byte_t* AssetID,
ui32_t sequence, HMACContext* HMAC)
{
ASDCP_TEST_NULL(AssetID);
byte_t* p = Data;
HMAC->Reset();
- static byte_t ber_4[klv_length_size] = {0x83, 0};
+ 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, klv_length_size);
+ memcpy(p, ber_4, MXF_BER_LENGTH);
*(p+3) = UUIDlen;;
- p += klv_length_size;
+ p += MXF_BER_LENGTH;
// track file ID
memcpy(p, AssetID, UUIDlen);
p += UUIDlen;
// sequence length
- memcpy(p, ber_4, klv_length_size);
+ memcpy(p, ber_4, MXF_BER_LENGTH);
*(p+3) = sizeof(ui64_t);
- p += klv_length_size;
+ p += MXF_BER_LENGTH;
// sequence number
- i2p<ui64_t>(ASDCP_i64_BE(sequence), p);
+ Kumu::i2p<ui64_t>(KM_i64_BE(sequence), p);
p += sizeof(ui64_t);
// HMAC length
- memcpy(p, ber_4, klv_length_size);
+ memcpy(p, ber_4, MXF_BER_LENGTH);
*(p+3) = HMAC_SIZE;
- p += klv_length_size;
+ p += MXF_BER_LENGTH;
// update HMAC with intpack values
HMAC->Update(Data, klv_intpack_size - HMAC_SIZE);
Result_t
-ASDCP::IntegrityPack::TestValues(const ASDCP::FrameBuffer& FB, byte_t* AssetID,
+ASDCP::IntegrityPack::TestValues(const ASDCP::FrameBuffer& FB, const byte_t* AssetID,
ui32_t sequence, HMACContext* HMAC)
{
ASDCP_TEST_NULL(AssetID);
byte_t* p = (byte_t*)FB.RoData() + ( FB.Size() - klv_intpack_size );
// test the AssetID length
- if ( ! read_test_BER(&p, UUIDlen) )
+ if ( ! Kumu::read_test_BER(&p, UUIDlen) )
return RESULT_HMACFAIL;
// test the AssetID
p += UUIDlen;
// test the sequence length
- if ( ! read_test_BER(&p, sizeof(ui64_t)) )
+ if ( ! Kumu::read_test_BER(&p, sizeof(ui64_t)) )
return RESULT_HMACFAIL;
- ui32_t test_sequence = (ui32_t)ASDCP_i64_BE(cp2i<ui64_t>(p));
+ 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 %lu, expecting %lu.\n", 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 ( ! read_test_BER(&p, HMAC_SIZE) )
+ if ( ! Kumu::read_test_BER(&p, HMAC_SIZE) )
return RESULT_HMACFAIL;
// test the HMAC
return HMAC->TestHMACValue(p);
}
-//------------------------------------------------------------------------------------------
-//
-
-
-//
-ASDCP::Result_t
-ASDCP::KLVReader::ReadKLFromFile(ASDCP::FileReader& Reader)
-{
- ui32_t read_count;
- m_HeaderLength = klv_key_size + klv_length_size;
- Result_t result = Reader.Read(m_Key, m_HeaderLength, &read_count);
- assert(read_count == m_HeaderLength);
-
- if ( ASDCP_SUCCESS(result) )
- {
- m_BERLength = BER_length(m_Key + klv_key_size);
-
- if ( m_BERLength != klv_length_size )
- {
- ASDCP::DefaultLogSink().Error("Found packet with BER length %lu; being less efficient...\n",
- m_BERLength);
- // TODO: recover the correct BER value
- // and reposition the file pointer
- assert(0);
- }
-
- if ( ! read_BER(m_Key + klv_key_size, &m_Length) )
- return RESULT_FAIL;
- }
-
- return result;
-}
-
//
// end AS_DCP_MXF.cpp
//
projects / asdcplib.git / blobdiff