/*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2007, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
*/
#include "MXF.h"
-#include "hex_utils.h"
+#include <KM_log.h>
+using Kumu::DefaultLogSink;
+// index segments must be < 64K
+// NOTE: this value may too high if advanced index entry elements are used.
+const ui32_t CBRIndexEntriesPerSegment = 5000;
//------------------------------------------------------------------------------------------
//
//
ASDCP::Result_t
-ASDCP::MXF::SeekToRIP(const ASDCP::FileReader& Reader)
+ASDCP::MXF::SeekToRIP(const Kumu::FileReader& Reader)
{
- ASDCP::fpos_t end_pos;
+ Kumu::fpos_t end_pos;
// go to the end - 4 bytes
- Result_t result = Reader.Seek(0, ASDCP::SP_END);
+ Result_t result = Reader.Seek(0, Kumu::SP_END);
if ( ASDCP_SUCCESS(result) )
result = Reader.Tell(&end_pos);
if ( ASDCP_SUCCESS(result) )
{
- rip_size = ASDCP_i32_BE(cp2i<ui32_t>(intbuf));
+ rip_size = KM_i32_BE(Kumu::cp2i<ui32_t>(intbuf));
if ( rip_size > end_pos ) // RIP can't be bigger than the file
return RESULT_FAIL;
//
ASDCP::Result_t
-ASDCP::MXF::RIP::InitFromFile(const ASDCP::FileReader& Reader)
+ASDCP::MXF::RIP::InitFromFile(const Kumu::FileReader& Reader)
{
Result_t result = KLVFilePacket::InitFromFile(Reader, Dict::ul(MDD_RandomIndexMetadata));
if ( ASDCP_SUCCESS(result) )
{
- MemIOReader MemRDR(m_ValueStart, m_ValueLength - 4);
- result = PairArray.Unarchive(MemRDR);
+ Kumu::MemIOReader MemRDR(m_ValueStart, m_ValueLength - 4);
+ result = PairArray.Unarchive(&MemRDR) ? RESULT_OK : RESULT_KLV_CODING;
}
if ( ASDCP_FAILURE(result) )
//
ASDCP::Result_t
-ASDCP::MXF::RIP::WriteToFile(ASDCP::FileWriter& Writer)
+ASDCP::MXF::RIP::WriteToFile(Kumu::FileWriter& Writer)
{
ASDCP::FrameBuffer Buffer;
ui32_t RIPSize = ( PairArray.size() * (sizeof(ui32_t) + sizeof(ui64_t)) ) + 4;
if ( ASDCP_SUCCESS(result) )
{
- MemIOWriter MemWRT(Buffer.Data(), Buffer.Capacity());
- result = PairArray.Archive(MemWRT);
+ result = RESULT_KLV_CODING;
- if ( ASDCP_SUCCESS(result) )
- MemWRT.WriteUi32BE(RIPSize + 20);
-
- if ( ASDCP_SUCCESS(result) )
- Buffer.Size(MemWRT.Size());
+ Kumu::MemIOWriter MemWRT(Buffer.Data(), Buffer.Capacity());
+ if ( PairArray.Archive(&MemWRT) )
+ if ( MemWRT.WriteUi32BE(RIPSize + 20) )
+ {
+ Buffer.Size(MemWRT.Length());
+ result = RESULT_OK;
+ }
}
if ( ASDCP_SUCCESS(result) )
ASDCP::MXF::Partition::AddChildObject(InterchangeObject* Object)
{
assert(Object);
- UUID TmpID;
- TmpID.GenRandomValue();
- Object->InstanceUID = TmpID;
+
+ if ( ! Object->InstanceUID.HasValue() )
+ GenRandomValue(Object->InstanceUID);
+
m_PacketList->AddPacket(Object);
}
//
ASDCP::Result_t
-ASDCP::MXF::Partition::InitFromFile(const ASDCP::FileReader& Reader)
+ASDCP::MXF::Partition::InitFromFile(const Kumu::FileReader& Reader)
{
Result_t result = KLVFilePacket::InitFromFile(Reader);
// test the UL
if ( ASDCP_SUCCESS(result) )
{
- MemIOReader MemRDR(m_ValueStart, m_ValueLength);
- result = MemRDR.ReadUi16BE(&MajorVersion);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi16BE(&MinorVersion);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32BE(&KAGSize);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64BE(&ThisPartition);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64BE(&PreviousPartition);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64BE(&FooterPartition);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64BE(&HeaderByteCount);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64BE(&IndexByteCount);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32BE(&IndexSID);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi64BE(&BodyOffset);
- if ( ASDCP_SUCCESS(result) ) result = MemRDR.ReadUi32BE(&BodySID);
- if ( ASDCP_SUCCESS(result) ) result = OperationalPattern.Unarchive(MemRDR);
- if ( ASDCP_SUCCESS(result) ) result = EssenceContainers.Unarchive(MemRDR);
+ Kumu::MemIOReader MemRDR(m_ValueStart, m_ValueLength);
+ result = RESULT_KLV_CODING;
+
+ if ( MemRDR.ReadUi16BE(&MajorVersion) )
+ if ( MemRDR.ReadUi16BE(&MinorVersion) )
+ if ( MemRDR.ReadUi32BE(&KAGSize) )
+ if ( MemRDR.ReadUi64BE(&ThisPartition) )
+ if ( MemRDR.ReadUi64BE(&PreviousPartition) )
+ if ( MemRDR.ReadUi64BE(&FooterPartition) )
+ if ( MemRDR.ReadUi64BE(&HeaderByteCount) )
+ if ( MemRDR.ReadUi64BE(&IndexByteCount) )
+ if ( MemRDR.ReadUi32BE(&IndexSID) )
+ if ( MemRDR.ReadUi64BE(&BodyOffset) )
+ if ( MemRDR.ReadUi32BE(&BodySID) )
+ if ( OperationalPattern.Unarchive(&MemRDR) )
+ if ( EssenceContainers.Unarchive(&MemRDR) )
+ result = RESULT_OK;
}
if ( ASDCP_FAILURE(result) )
//
ASDCP::Result_t
-ASDCP::MXF::Partition::WriteToFile(ASDCP::FileWriter& Writer, UL& PartitionLabel)
+ASDCP::MXF::Partition::WriteToFile(Kumu::FileWriter& Writer, UL& PartitionLabel)
{
ASDCP::FrameBuffer Buffer;
Result_t result = Buffer.Capacity(1024);
if ( ASDCP_SUCCESS(result) )
{
- MemIOWriter MemWRT(Buffer.Data(), Buffer.Capacity());
- result = MemWRT.WriteUi16BE(MajorVersion);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi16BE(MinorVersion);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi32BE(KAGSize);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi64BE(ThisPartition);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi64BE(PreviousPartition);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi64BE(FooterPartition);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi64BE(HeaderByteCount);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi64BE(IndexByteCount);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi32BE(IndexSID);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi64BE(BodyOffset);
- if ( ASDCP_SUCCESS(result) ) result = MemWRT.WriteUi32BE(BodySID);
- if ( ASDCP_SUCCESS(result) ) result = OperationalPattern.Archive(MemWRT);
- if ( ASDCP_SUCCESS(result) ) result = EssenceContainers.Archive(MemWRT);
- if ( ASDCP_SUCCESS(result) ) Buffer.Size(MemWRT.Size());
+ Kumu::MemIOWriter MemWRT(Buffer.Data(), Buffer.Capacity());
+ result = RESULT_KLV_CODING;
+ if ( MemWRT.WriteUi16BE(MajorVersion) )
+ if ( MemWRT.WriteUi16BE(MinorVersion) )
+ if ( MemWRT.WriteUi32BE(KAGSize) )
+ if ( MemWRT.WriteUi64BE(ThisPartition) )
+ if ( MemWRT.WriteUi64BE(PreviousPartition) )
+ if ( MemWRT.WriteUi64BE(FooterPartition) )
+ if ( MemWRT.WriteUi64BE(HeaderByteCount) )
+ if ( MemWRT.WriteUi64BE(IndexByteCount) )
+ if ( MemWRT.WriteUi32BE(IndexSID) )
+ if ( MemWRT.WriteUi64BE(BodyOffset) )
+ if ( MemWRT.WriteUi32BE(BodySID) )
+ if ( OperationalPattern.Archive(&MemWRT) )
+ if ( EssenceContainers.Archive(&MemWRT) )
+ {
+ Buffer.Size(MemWRT.Length());
+ result = RESULT_OK;
+ }
}
if ( ASDCP_SUCCESS(result) )
ASDCP::MXF::Partition::Dump(FILE* stream)
{
char identbuf[IdentBufferLen];
- char intbuf[IntBufferLen];
if ( stream == 0 )
stream = stderr;
KLVFilePacket::Dump(stream, false);
fprintf(stream, " MajorVersion = %hu\n", MajorVersion);
fprintf(stream, " MinorVersion = %hu\n", MinorVersion);
- fprintf(stream, " KAGSize = %lu\n", KAGSize);
- fprintf(stream, " ThisPartition = %s\n", ui64sz(ThisPartition, intbuf));
- fprintf(stream, " PreviousPartition = %s\n", ui64sz(PreviousPartition, intbuf));
- fprintf(stream, " FooterPartition = %s\n", ui64sz(FooterPartition, intbuf));
- fprintf(stream, " HeaderByteCount = %s\n", ui64sz(HeaderByteCount, intbuf));
- fprintf(stream, " IndexByteCount = %s\n", ui64sz(IndexByteCount, intbuf));
- fprintf(stream, " IndexSID = %lu\n", IndexSID);
- fprintf(stream, " BodyOffset = %s\n", ui64sz(BodyOffset, intbuf));
- fprintf(stream, " BodySID = %lu\n", BodySID);
- fprintf(stream, " OperationalPattern = %s\n", OperationalPattern.ToString(identbuf));
+ fprintf(stream, " KAGSize = %u\n", KAGSize);
+ fprintf(stream, " ThisPartition = %s\n", ui64sz(ThisPartition, identbuf));
+ fprintf(stream, " PreviousPartition = %s\n", ui64sz(PreviousPartition, identbuf));
+ fprintf(stream, " FooterPartition = %s\n", ui64sz(FooterPartition, identbuf));
+ fprintf(stream, " HeaderByteCount = %s\n", ui64sz(HeaderByteCount, identbuf));
+ fprintf(stream, " IndexByteCount = %s\n", ui64sz(IndexByteCount, identbuf));
+ fprintf(stream, " IndexSID = %u\n", IndexSID);
+ fprintf(stream, " BodyOffset = %s\n", ui64sz(BodyOffset, identbuf));
+ fprintf(stream, " BodySID = %u\n", BodySID);
+ fprintf(stream, " OperationalPattern = %s\n", OperationalPattern.EncodeString(identbuf, IdentBufferLen));
fputs("Essence Containers:\n", stream); EssenceContainers.Dump(stream, false);
fputs("==========================================================================\n", stream);
if ( ASDCP_SUCCESS(result) )
{
- MemIOReader MemRDR(m_ValueStart, m_ValueLength);
- result = LocalTagEntryBatch.Unarchive(MemRDR);
+ Kumu::MemIOReader MemRDR(m_ValueStart, m_ValueLength);
+ result = LocalTagEntryBatch.Unarchive(&MemRDR) ? RESULT_OK : RESULT_KLV_CODING;
}
if ( ASDCP_SUCCESS(result) )
//
ASDCP::Result_t
-ASDCP::MXF::Primer::WriteToFile(ASDCP::FileWriter& Writer)
+ASDCP::MXF::Primer::WriteToFile(Kumu::FileWriter& Writer)
{
ASDCP::FrameBuffer Buffer;
Result_t result = Buffer.Capacity(128*1024);
ASDCP::MXF::Primer::WriteToBuffer(ASDCP::FrameBuffer& Buffer)
{
ASDCP::FrameBuffer LocalTagBuffer;
- MemIOWriter MemWRT(Buffer.Data() + kl_length, Buffer.Capacity() - kl_length);
- Result_t result = LocalTagEntryBatch.Archive(MemWRT);
+ Kumu::MemIOWriter MemWRT(Buffer.Data() + kl_length, Buffer.Capacity() - kl_length);
+ Result_t result = LocalTagEntryBatch.Archive(&MemWRT) ? RESULT_OK : RESULT_KLV_CODING;
if ( ASDCP_SUCCESS(result) )
{
- ui32_t packet_length = MemWRT.Size();
+ ui32_t packet_length = MemWRT.Length();
result = WriteKLToBuffer(Buffer, Dict::ul(MDD_Primer), packet_length);
if ( ASDCP_SUCCESS(result) )
stream = stderr;
KLVPacket::Dump(stream, false);
- fprintf(stream, "Primer: %lu %s\n",
+ fprintf(stream, "Primer: %u %s\n",
LocalTagEntryBatch.size(),
( LocalTagEntryBatch.size() == 1 ? "entry" : "entries" ));
for ( ; i != LocalTagEntryBatch.end(); i++ )
{
const MDDEntry* Entry = Dict::FindUL((*i).UL.Value());
- fprintf(stream, " %s %s\n", (*i).ToString(identbuf), (Entry ? Entry->name : "Unknown"));
+ fprintf(stream, " %s %s\n", (*i).EncodeString(identbuf, IdentBufferLen), (Entry ? Entry->name : "Unknown"));
}
fputs("==========================================================================\n", stream);
stream = stderr;
InterchangeObject::Dump(stream);
- fprintf(stream, " %22s = %s\n", "LastModifiedDate", LastModifiedDate.ToString(identbuf));
+ fprintf(stream, " %22s = %s\n", "LastModifiedDate", LastModifiedDate.EncodeString(identbuf, IdentBufferLen));
fprintf(stream, " %22s = %hu\n", "Version", Version);
- fprintf(stream, " %22s = %lu\n", "ObjectModelVersion", ObjectModelVersion);
- fprintf(stream, " %22s = %s\n", "PrimaryPackage", PrimaryPackage.ToString(identbuf));
+ fprintf(stream, " %22s = %u\n", "ObjectModelVersion", ObjectModelVersion);
+ fprintf(stream, " %22s = %s\n", "PrimaryPackage", PrimaryPackage.EncodeHex(identbuf, IdentBufferLen));
fprintf(stream, " %22s:\n", "Identifications"); Identifications.Dump(stream);
- fprintf(stream, " %22s = %s\n", "ContentStorage", ContentStorage.ToString(identbuf));
- fprintf(stream, " %22s = %s\n", "OperationalPattern", OperationalPattern.ToString(identbuf));
+ fprintf(stream, " %22s = %s\n", "ContentStorage", ContentStorage.EncodeHex(identbuf, IdentBufferLen));
+ fprintf(stream, " %22s = %s\n", "OperationalPattern", OperationalPattern.EncodeString(identbuf, IdentBufferLen));
fprintf(stream, " %22s:\n", "EssenceContainers"); EssenceContainers.Dump(stream);
fprintf(stream, " %22s:\n", "DMSchemes"); DMSchemes.Dump(stream);
}
//
ASDCP::Result_t
-ASDCP::MXF::OPAtomHeader::InitFromFile(const ASDCP::FileReader& Reader)
+ASDCP::MXF::OPAtomHeader::InitFromFile(const Kumu::FileReader& Reader)
{
m_HasRIP = false;
Result_t result = SeekToRIP(Reader);
{
// OP-Atom states that there will be either two or three partitions,
// one closed header and one closed footer with an optional body
- DefaultLogSink().Error("RIP count is not 2 or 3: %lu\n", test_s);
+ DefaultLogSink().Error("RIP count is not 2 or 3: %u\n", test_s);
return RESULT_FORMAT;
}
else
if ( ASDCP_SUCCESS(result) )
result = Partition::InitFromFile(Reader); // test UL and OP
- Partition::Dump();
-
// is it really OP-Atom?
UL OPAtomUL(Dict::ul(MDD_OPAtom));
UL InteropOPAtomUL(Dict::ul(MDD_MXFInterop_OPAtom));
if ( ! ( OperationalPattern == OPAtomUL || OperationalPattern == InteropOPAtomUL ) )
{
- char strbuf[IntBufferLen];
+ char strbuf[IdentBufferLen];
const MDDEntry* Entry = Dict::FindUL(OperationalPattern.Value());
if ( Entry == 0 )
- DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", OperationalPattern.ToString(strbuf));
+ DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", OperationalPattern.EncodeString(strbuf, IdentBufferLen));
else
DefaultLogSink().Warn("Operational pattern is not OP-Atom: %s\n", Entry->name);
}
if ( ASDCP_SUCCESS(result) )
{
if ( HeaderByteCount < 1024 )
- DefaultLogSink().Warn("Improbably small HeaderByteCount value: %lu\n", HeaderByteCount);
+ DefaultLogSink().Warn("Improbably small HeaderByteCount value: %u\n", HeaderByteCount);
result = m_Buffer.Capacity(HeaderByteCount);
}
if ( ASDCP_SUCCESS(result) && read_count != m_Buffer.Capacity() )
{
- DefaultLogSink().Error("Short read of OP-Atom header metadata; wanted %lu, got %lu\n",
+ DefaultLogSink().Error("Short read of OP-Atom header metadata; wanted %u, got %u\n",
m_Buffer.Capacity(), read_count);
return RESULT_FAIL;
}
//
ASDCP::Result_t
-ASDCP::MXF::OPAtomHeader::WriteToFile(ASDCP::FileWriter& Writer, ui32_t HeaderSize)
+ASDCP::MXF::OPAtomHeader::WriteToFile(Kumu::FileWriter& Writer, ui32_t HeaderSize)
{
if ( m_Preface == 0 )
return RESULT_STATE;
if ( HeaderSize < 4096 )
{
- DefaultLogSink().Error("HeaderSize %lu is too small. Must be >= 4096\n", HeaderSize);
+ DefaultLogSink().Error("HeaderSize %u is too small. Must be >= 4096\n", HeaderSize);
return RESULT_FAIL;
}
// KLV Fill
if ( ASDCP_SUCCESS(result) )
{
- ASDCP::fpos_t pos = Writer.Tell();
+ Kumu::fpos_t pos = Writer.Tell();
- if ( pos > (ASDCP::fpos_t)HeaderByteCount )
+ if ( pos > (Kumu::fpos_t)HeaderByteCount )
{
char intbuf[IntBufferLen];
- DefaultLogSink().Error("Header size %s exceeds specified value %lu\n",
+ DefaultLogSink().Error("Header size %s exceeds specified value %u\n",
ui64sz(pos, intbuf),
HeaderSize);
return RESULT_FAIL;
ASDCP::Result_t
-ASDCP::MXF::OPAtomIndexFooter::InitFromFile(const ASDCP::FileReader& Reader)
+ASDCP::MXF::OPAtomIndexFooter::InitFromFile(const Kumu::FileReader& Reader)
{
Result_t result = Partition::InitFromFile(Reader); // test UL and OP
if ( ASDCP_SUCCESS(result) && read_count != m_Buffer.Capacity() )
{
- DefaultLogSink().Error("Short read of footer partition: got %lu, expecting %lu\n",
+ DefaultLogSink().Error("Short read of footer partition: got %u, expecting %u\n",
read_count, m_Buffer.Capacity());
return RESULT_FAIL;
}
//
ASDCP::Result_t
-ASDCP::MXF::OPAtomIndexFooter::WriteToFile(ASDCP::FileWriter& Writer, ui64_t duration)
+ASDCP::MXF::OPAtomIndexFooter::WriteToFile(Kumu::FileWriter& Writer, ui64_t duration)
{
ASDCP::FrameBuffer FooterBuffer;
ui32_t footer_size = m_PacketList->m_List.size() * MaxIndexSegmentSize; // segment-count * max-segment-size
//
void
-ASDCP::MXF::OPAtomIndexFooter::SetIndexParamsVBR(IPrimerLookup* lookup, const Rational& Rate, fpos_t offset)
+ASDCP::MXF::OPAtomIndexFooter::SetIndexParamsVBR(IPrimerLookup* lookup, const Rational& Rate, Kumu::fpos_t offset)
{
assert(lookup);
m_Lookup = lookup;
m_CurrentSegment->IndexEditRate = m_EditRate;
m_CurrentSegment->IndexStartPosition = 0;
}
- else if ( m_CurrentSegment->IndexEntryArray.size() >= 1486 ) // 1486 gets us 16K packets
+ else if ( m_CurrentSegment->IndexEntryArray.size() >= CBRIndexEntriesPerSegment )
{ // no, this one is full, start another
m_CurrentSegment->IndexDuration = m_CurrentSegment->IndexEntryArray.size();
ui64_t StartPosition = m_CurrentSegment->IndexStartPosition + m_CurrentSegment->IndexDuration;
ASDCP::MXF::InterchangeObject::InitFromBuffer(const byte_t* p, ui32_t l)
{
ASDCP_TEST_NULL(p);
- Result_t result;
+ Result_t result = RESULT_FALSE;
if ( m_Typeinfo == 0 )
{
if ( ASDCP_SUCCESS(result) )
{
- ui32_t packet_length = MemWRT.Size();
+ ui32_t packet_length = MemWRT.Length();
result = WriteKLToBuffer(Buffer, m_Typeinfo->ul, packet_length);
if ( ASDCP_SUCCESS(result) )
fputc('\n', stream);
KLVPacket::Dump(stream, false);
- fprintf(stream, " InstanceUID = %s\n", InstanceUID.ToString(identbuf));
- fprintf(stream, " GenerationUID = %s\n", GenerationUID.ToString(identbuf));
+ fprintf(stream, " InstanceUID = %s\n", InstanceUID.EncodeHex(identbuf, IdentBufferLen));
+ fprintf(stream, " GenerationUID = %s\n", GenerationUID.EncodeHex(identbuf, IdentBufferLen));
}
//
projects / asdcplib.git / blobdiff