// platforms that support it. For each call to Writev(const byte_t*, ui32_t, ui32_t*),
// the given buffer is added to an internal iovec struct. All items on the list
// are written to disk by a call to Writev();
- Result_t Writev(const byte_t*, ui32_t); // queue buffer for "gather" write
+ Result_t Writev(const byte_t*, ui32_t); // queue buffer for write
Result_t Writev(ui32_t* = 0); // write all queued buffers
// if you call this while there are unwritten items on the iovec list,
I have tested this build on win32, Linux and Darwin platforms.
Others may work as well.
-If you do not want to use or do not have OpenSSL, invoke
-make with ASDCP_WITHOUT_OPENSSL defined:
-
- make ASDCP_WITHOUT_OPENSSL=1
-
Build Versions
Change History
+2006.01.04 - full read-write
+ o Removed ASDCP_WITHOUT_OPENSSL compile-time option.
+
+
2005.00.00 - A New Hope
o The temporary mxf-lite has been removed. MXF files are now
managed via the objects in KLV.h, MXFTypes.h MXF.h and
const int KEY_SIZE_BITS = 128;
-#ifndef ASDCP_WITHOUT_OPENSSL
#include <openssl/aes.h>
#include <openssl/sha.h>
#include <openssl/err.h>
DefaultLogSink().Error("OpenSSL: %s\n", ERR_error_string(errval, err_buf));
}
-#endif
-
-
//------------------------------------------------------------------------------------------
-#ifdef ASDCP_WITHOUT_OPENSSL
-class ASDCP::AESEncContext::h__AESContext
-#else
class ASDCP::AESEncContext::h__AESContext : public AES_KEY
-#endif
{
public:
byte_t m_IVec[CBC_BLOCK_SIZE];
if ( m_Context )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
m_Context = new h__AESContext;
if ( AES_set_encrypt_key(key, KEY_SIZE_BITS, m_Context) )
}
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
if ( ! m_Context )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
memcpy(m_Context->m_IVec, i_vec, CBC_BLOCK_SIZE);
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
if ( ! m_Context )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
memcpy(i_vec, m_Context->m_IVec, CBC_BLOCK_SIZE);
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
if ( m_Context.empty() )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
h__AESContext* Ctx = m_Context;
byte_t tmp_buf[CBC_BLOCK_SIZE];
const byte_t* in_p = pt_buf;
}
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
//------------------------------------------------------------------------------------------
-#ifdef ASDCP_WITHOUT_OPENSSL
-class ASDCP::AESDecContext::h__AESContext
-#else
class ASDCP::AESDecContext::h__AESContext : public AES_KEY
-#endif
{
public:
byte_t m_IVec[CBC_BLOCK_SIZE];
if ( m_Context )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
m_Context = new h__AESContext;
if ( AES_set_decrypt_key(key, KEY_SIZE_BITS, m_Context) )
}
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
// Initializes 16 byte CBC Initialization Vector. This operation may be performed
if ( ! m_Context )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
memcpy(m_Context->m_IVec, i_vec, CBC_BLOCK_SIZE);
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
// Decrypt a 16 byte block of data.
if ( m_Context.empty() )
return RESULT_INIT;
-#ifndef ASDCP_WITHOUT_OPENSSL
register h__AESContext* Ctx = m_Context;
const byte_t* in_p = ct_buf;
}
return RESULT_OK;
-#else // ASDCP_WITHOUT_OPENSSL
- return RESULT_FAIL;
-#endif // ASDCP_WITHOUT_OPENSSL
}
//------------------------------------------------------------------------------------------
class HMACContext::h__HMACContext
{
-#ifndef ASDCP_WITHOUT_OPENSSL
SHA_CTX m_SHA;
-#endif // ASDCP_WITHOUT_OPENSSL
byte_t m_key[KeyLen];
ASDCP_NO_COPY_CONSTRUCT(h__HMACContext);
{
static byte_t key_nonce[KeyLen] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
-#ifndef ASDCP_WITHOUT_OPENSSL
byte_t sha_buf[SHA_DIGEST_LENGTH];
// 7.10: MICKey = trunc( SHA1 ( key, key_nonce ) )
memcpy(m_key, sha_buf, KeyLen);
Reset();
-#endif // ASDCP_WITHOUT_OPENSSL
}
void
Reset()
{
-#ifndef ASDCP_WITHOUT_OPENSSL
byte_t xor_buf[KeyLen];
memset(sha_value, 0, HMAC_SIZE);
m_Final = false;
xor_buf[i] = m_key[i] ^ ipad[i];
SHA1_Update(&m_SHA, xor_buf, KeyLen);
-#endif // ASDCP_WITHOUT_OPENSSL
}
//
void
Update(const byte_t* buf, ui32_t buf_len)
{
-#ifndef ASDCP_WITHOUT_OPENSSL
// H(K XOR opad, H(K XOR ipad, text))
// ^^^^
SHA1_Update(&m_SHA, buf, buf_len);
-#endif // ASDCP_WITHOUT_OPENSSL
}
//
void
Finalize()
{
-#ifndef ASDCP_WITHOUT_OPENSSL
// H(K XOR opad, H(K XOR ipad, text))
// ^^^^^^^^^^^^^^^
SHA1_Final(sha_value, &m_SHA);
SHA1_Final(sha_value, &SHA);
m_Final = true;
-#endif // ASDCP_WITHOUT_OPENSSL
}
};
}
+//
+ASDCP::Result_t
+ASDCP::MPEG2_VDesc_to_MD(MPEG2::VideoDescriptor&, MXF::MPEG2VideoDescriptor*)
+{
+ return RESULT_OK;
+}
+
+
//
void
ASDCP::MPEG2::VideoDescriptorDump(const VideoDescriptor& VDesc, FILE* stream)
//------------------------------------------------------------------------------------------
-#if 0
-
//
class ASDCP::MPEG2::MXFWriter::h__Writer : public ASDCP::h__Writer
if ( ! m_State.Test_BEGIN() )
return RESULT_STATE;
- m_File = new MXFFile;
-
- Result_t result = m_File->OpenWrite(filename);
+ Result_t result = m_File.OpenWrite(filename);
if ( ASDCP_SUCCESS(result) )
{
- m_EssenceDescriptor = new MDObject("MPEG2VideoDescriptor");
+ // m_EssenceDescriptor = new MDObject("MPEG2VideoDescriptor");
result = m_State.Goto_INIT();
}
return RESULT_STATE;
m_VDesc = VDesc;
- Result_t result = MPEG2_VDesc_to_MD(m_VDesc, *m_EssenceDescriptor);
+ Result_t result = RESULT_OK; // MPEG2_VDesc_to_MD(m_VDesc, *m_EssenceDescriptor);
if ( ASDCP_SUCCESS(result) )
result = WriteMXFHeader(ESS_MPEG2_VES, m_VDesc.EditRate, 24 /* TCFrameRate */);
}
// update the index manager
+#if 0
m_IndexMan->OfferEditUnit(0, m_FramesWritten, m_GOPOffset, Flags);
m_IndexMan->OfferTemporalOffset(m_FramesWritten, m_GOPOffset - FrameBuf.TemporalOffset());
m_IndexMan->OfferOffset(0, m_FramesWritten, ThisOffset);
+#endif
m_FramesWritten++;
m_GOPOffset++;
if ( ! m_State.Test_RUNNING() )
return RESULT_STATE;
- if ( ! m_File )
- return RESULT_INIT;
-
m_State.Goto_FINAL();
return WriteMXFFooter(ESS_MPEG2_VES);
return m_Writer->Finalize();
}
-#endif
+
//
// end AS_DCP_MPEG2.cpp
/*
-Copyright (c) 2004-2005, John Hurst
+Copyright (c) 2004-2006, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
//------------------------------------------------------------------------------------------
//
- // MDObject* GetMDObjectByPath(MDObject&, const std::string);
- // MDObject* GetMDObjectByType(MDObject&, const std::string);
- // void DumpMDObject(MDObject&, std::string = " ", FILE* = 0);
- // void DumpHeader(Partition&, FILE* = 0);
- // void DumpIndexTable(IndexTablePtr, ui64_t = 0, FILE* = 0);
- // Result_t init_mxf_types();
Result_t MD_to_MPEG2_VDesc(MXF::MPEG2VideoDescriptor*, MPEG2::VideoDescriptor&);
Result_t MD_to_JP2K_PDesc(MXF::RGBAEssenceDescriptor*, JP2K::PictureDescriptor&);
Result_t MD_to_PCM_ADesc(MXF::WaveAudioDescriptor*, PCM::AudioDescriptor&);
Result_t MD_to_WriterInfo(MXF::Identification*, WriterInfo&);
Result_t MD_to_CryptoInfo(MXF::CryptographicContext*, WriterInfo&);
-
-#if 0
- Result_t MPEG2_VDesc_to_MD(MPEG2::VideoDescriptor&, MDObject&);
- Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor&, MDObject&);
- Result_t PCM_ADesc_to_MD(PCM::AudioDescriptor&, MDObject&);
- void AddDMScrypt(PackagePtr, WriterInfo&, const byte_t*);
-#endif
-
+ Result_t MPEG2_VDesc_to_MD(MPEG2::VideoDescriptor&, MXF::MPEG2VideoDescriptor*);
+ Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor&, MXF::RGBAEssenceDescriptor*);
+ Result_t PCM_ADesc_to_MD(PCM::AudioDescriptor&, MXF::WaveAudioDescriptor*);
+ // void AddDMScrypt(PackagePtr, WriterInfo&, const byte_t*);
Result_t EncryptFrameBuffer(const ASDCP::FrameBuffer&, ASDCP::FrameBuffer&, AESEncContext*);
Result_t DecryptFrameBuffer(const ASDCP::FrameBuffer&, ASDCP::FrameBuffer&, AESDecContext*);
h__Reader();
virtual ~h__Reader();
- //
- // MDObject* GetMDObjectByType(const std::string ObjName);
- // MDObject* GetMDObjectByPath(const std::string ObjPath);
+
Result_t InitInfo(WriterInfo& Info);
Result_t OpenMXFRead(const char* filename);
Result_t InitMXFIndex();
void Close();
};
+
+ // state machine for mxf writer
+ enum WriterState_t {
+ ST_BEGIN, // waiting for Open()
+ ST_INIT, // waiting for SetSourceStream()
+ ST_READY, // ready to write frames
+ ST_RUNNING, // one or more frames written
+ ST_FINAL, // index written, file closed
+ };
+
+ // implementation of h__WriterState class Goto_* methods
+#define Goto_body(s1,s2) if ( m_State != (s1) ) \
+ return RESULT_STATE; \
+ m_State = (s2); \
+ return RESULT_OK
+ //
+ class h__WriterState
+ {
+ ASDCP_NO_COPY_CONSTRUCT(h__WriterState);
+
+ public:
+ WriterState_t m_State;
+ h__WriterState() : m_State(ST_BEGIN) {}
+ ~h__WriterState() {}
+
+ inline bool Test_BEGIN() { return m_State == ST_BEGIN; }
+ inline bool Test_INIT() { return m_State == ST_INIT; }
+ inline bool Test_READY() { return m_State == ST_READY;}
+ inline bool Test_RUNNING() { return m_State == ST_RUNNING; }
+ inline bool Test_FINAL() { return m_State == ST_FINAL; }
+ inline Result_t Goto_INIT() { Goto_body(ST_BEGIN, ST_INIT); }
+ inline Result_t Goto_READY() { Goto_body(ST_INIT, ST_READY); }
+ inline Result_t Goto_RUNNING() { Goto_body(ST_READY, ST_RUNNING); }
+ inline Result_t Goto_FINAL() { Goto_body(ST_RUNNING, ST_FINAL); }
+ };
+
+ //
+ class h__Writer
+ {
+ ASDCP_NO_COPY_CONSTRUCT(h__Writer);
+
+ public:
+ FileWriter m_File;
+ OPAtomHeader m_HeaderPart;
+ Partition m_BodyPart;
+ OPAtomIndexFooter m_FooterPart;
+
+#if 0
+ ui64_t m_EssenceStart;
+ WriterInfo m_Info;
+ ASDCP::FrameBuffer m_CtFrameBuf;
+
+ mem_ptr<MXFFile> m_File;
+ mem_ptr<Metadata> m_Metadata;
+ mem_ptr<Package> m_FilePackage;
+ mem_ptr<Partition> m_HeaderPart;
+ mem_ptr<MDObject> m_EssenceDescriptor;
+ mem_ptr<Package> m_MaterialPackage;
+ mem_ptr<Track> m_MPTrack; //! Material Package track for each essence stream
+ mem_ptr<Track> m_FPTrack; //! File Package track for each essence stream
+ mem_ptr<TimecodeComponent> m_MPTimecode;
+ mem_ptr<TimecodeComponent> m_FPTimecode;
+ mem_ptr<IndexManager> m_IndexMan;
+ SourceClip* m_MPClip; //! Material Package SourceClip for each essence stream
+ SourceClip* m_FPClip; //! File Package SourceClip for each essence stream
+#endif
+
+ i32_t m_EssenceID; //! Essence stream ID for each essence stream
+ ui32_t m_FramesWritten;
+ ui64_t m_StreamOffset;
+ ASDCP::FrameBuffer m_CtFrameBuf;
+ h__WriterState m_State;
+ WriterInfo m_Info;
+ FrameBuffer m_CryptFrameBuf;
+
+ h__Writer();
+ virtual ~h__Writer();
+
+ Result_t WriteMXFHeader(EssenceType_t EssenceType, Rational& EditRate,
+ ui32_t TCFrameRate, ui32_t BytesPerEditUnit = 0);
+ Result_t WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf,
+ const byte_t* EssenceUL, AESEncContext* Ctx, HMACContext* HMAC);
+ Result_t WriteMXFFooter(EssenceType_t EssenceType);
+
+ };
+
+
// helper class for calculating Integrity Packs, used by WriteEKLVPacket() below.
//
class IntegrityPack
inline const ui64_t Length() { return m_Length; }
inline const ui64_t KLLength() { return m_BERLength + klv_key_size; }
Result_t ReadKLFromFile(ASDCP::FileReader& Reader);
-#if 0
- //
- {
- 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;
- }
-#endif
-
};
} // namespace ASDCP
case 'V': version_flag = true; break;
case 'h': help_flag = true; break;
case 'v': verbose_flag = true; break;
- case 'g':
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
- genkey_flag = true;
-#endif
- break;
-
- case 'u':
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
- genid_flag = true;
-#endif
- break;
-
+ case 'g': genkey_flag = true; break;
+ case 'u': genid_flag = true; break;
case 'e': encrypt_header_flag = true; break;
case 'E': encrypt_header_flag = false; break;
case 'M': write_hmac = false; break;
break;
case 'k': key_flag = true;
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
TEST_EXTRA_ARG(i, 'k');
{
ui32_t length;
return;
}
}
-#endif
break;
case 'j': key_id_flag = true;
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
TEST_EXTRA_ARG(i, 'j');
{
ui32_t length;
return;
}
}
-#endif
break;
case 'f':
//------------------------------------------------------------------------------------------
// MPEG2 essence
-#if 0
+
// Write a plaintext MPEG2 Video Elementary Stream to a plaintext ASDCP file
// Write a plaintext MPEG2 Video Elementary Stream to a ciphertext ASDCP file
//
MPEG2::Parser Parser;
MPEG2::MXFWriter Writer;
MPEG2::VideoDescriptor VDesc;
-
-#ifndef ASDCP_WITHOUT_OPENSSL
byte_t IV_buf[CBC_BLOCK_SIZE];
FortunaRNG RNG;
-#endif
// set up essence parser
Result_t result = Parser.OpenRead(Options.filenames[0]);
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
GenRandomUUID(RNG, Info.AssetUUID);
// configure encryption
result = HMAC->InitKey(Options.key_value);
}
}
-#endif // ASDCP_WITHOUT_OPENSSL
if ( ASDCP_SUCCESS(result) )
result = Writer.OpenWrite(Options.out_file, Info, VDesc);
{
result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
// The Writer class will forward the last block of ciphertext
// to the encryption context for use as the IV for the next
// frame. If you want to use non-sequitur IV values, un-comment
// the following line of code.
// if ( ASDCP_SUCCESS(result) && Options.key_flag )
// Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
}
}
return result;
}
-#endif
// Read a plaintext MPEG2 Video Elementary Stream from a plaintext ASDCP file
// Read a plaintext MPEG2 Video Elementary Stream from a ciphertext ASDCP file
return result;
}
-#if 0
//------------------------------------------------------------------------------------------
// JPEG 2000 essence
JP2K::FrameBuffer FrameBuffer(Options.fb_size);
JP2K::PictureDescriptor PDesc;
JP2K::SequenceParser Parser;
-
-#ifndef ASDCP_WITHOUT_OPENSSL
byte_t IV_buf[CBC_BLOCK_SIZE];
FortunaRNG RNG;
-#endif
// set up essence parser
Result_t result = Parser.OpenRead(Options.filenames[0]);
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
GenRandomUUID(RNG, Info.AssetUUID);
// configure encryption
result = HMAC->InitKey(Options.key_value);
}
}
-#endif // ASDCP_WITHOUT_OPENSSL
if ( ASDCP_SUCCESS(result) )
result = Writer.OpenWrite(Options.out_file, Info, PDesc);
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
+
// The Writer class will forward the last block of ciphertext
// to the encryption context for use as the IV for the next
// frame. If you want to use non-sequitur IV values, un-comment
// the following line of code.
// if ( ASDCP_SUCCESS(result) && Options.key_flag )
// Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
}
}
return result;
}
-#endif
// Read one or more plaintext JPEG 2000 codestreams from a plaintext ASDCP file
// Read one or more plaintext JPEG 2000 codestreams from a ciphertext ASDCP file
return result;
}
-#if 0
//------------------------------------------------------------------------------------------
// PCM essence
PCM::FrameBuffer FrameBuffer;
PCM::AudioDescriptor ADesc;
Rational PictureRate = Options.PictureRate();
-
-#ifndef ASDCP_WITHOUT_OPENSSL
byte_t IV_buf[CBC_BLOCK_SIZE];
FortunaRNG RNG;
-#endif
// set up essence parser
Result_t result = Parser.OpenRead(Options.file_count, Options.filenames, PictureRate);
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
GenRandomUUID(RNG, Info.AssetUUID);
// configure encryption
result = HMAC->InitKey(Options.key_value);
}
}
-#endif // ASDCP_WITHOUT_OPENSSL
if ( ASDCP_SUCCESS(result) )
result = Writer.OpenWrite(Options.out_file, Info, ADesc);
{
result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
// The Writer class will forward the last block of ciphertext
// to the encryption context for use as the IV for the next
// frame. If you want to use non-sequitur IV values, un-comment
// the following line of code.
// if ( ASDCP_SUCCESS(result) && Options.key_flag )
// Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
}
}
}
return result;
}
-#endif
// Read one or more plaintext PCM audio streams from a plaintext ASDCP file
// Read one or more plaintext PCM audio streams from a ciphertext ASDCP file
{
result = gop_start_test(Options);
}
-#ifndef ASDCP_WITHOUT_OPENSSL
else if ( Options.genkey_flag )
{
FortunaRNG RNG;
bin2hex(bin_buf, KeyLen, str_buf, 40);
printf("%s\n", hyphenate_UUID(str_buf, 40));
}
-#endif // ASDCP_WITHOUT_OPENSSL
else if ( Options.extract_flag )
{
EssenceType_t EssenceType;
{
fprintf(stderr, "ATTENTION! This version of asdcplib does not support writing MXF files.\n");
-#if 0
if ( Options.do_repeat && ! Options.duration_flag )
{
fputs("Option -R requires -d <duration>\n", stderr);
return 5;
}
}
-#endif
}
if ( result != RESULT_OK )
/*
-Copyright (c) 2004-2005, John Hurst
+Copyright (c) 2004-2006, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
#include "AS_DCP_internal.h"
#include "MemIO.h"
#include "Timecode.h"
+#include "KLV.h"
+#include "MDD.h"
#include <assert.h>
-using namespace mxflib;
using namespace ASDCP;
+using namespace ASDCP::MXF;
ASDCP::h__Writer::h__Writer() : m_FramesWritten(0), m_StreamOffset(0)
{
- init_mxf_types();
}
ASDCP::h__Writer::~h__Writer()
ASDCP::h__Writer::WriteMXFHeader(EssenceType_t EssenceType, ASDCP::Rational& EditRate,
ui32_t TCFrameRate, ui32_t BytesPerEditUnit)
{
+#if 0
// write the stream metadata
m_Metadata = new Metadata();
assert(m_Metadata);
UMID PackageUMID;
PackageUMID.MakeUMID(0x0d); // mixed type
-#if ASDCP_USE_MXFLIB
- mxflib::Rational EditRate_;
- EditRate_.Numerator = EditRate.Numerator;
- EditRate_.Denominator = EditRate.Denominator;
-#else
-#define EditRate_ EditRate
-#endif
-
m_MaterialPackage = m_Metadata->AddMaterialPackage("AS-DCP Material Package", PackageUMID);
m_Metadata->SetPrimaryPackage(m_MaterialPackage); // This will be overwritten for OP-Atom
- TrackPtr MPTimecodeTrack = m_MaterialPackage->AddTimecodeTrack(EditRate_);
+ TrackPtr MPTimecodeTrack = m_MaterialPackage->AddTimecodeTrack(EditRate);
m_MPTimecode = MPTimecodeTrack->AddTimecodeComponent(TCFrameRate, 0, 0);
TrackPtr FPTimecodeTrack = 0;
case ESS_MPEG2_VES:
PackageUMID.MakeUMID(0x0f, assetUUID);
m_FilePackage = m_Metadata->AddFilePackage(1, MPEG_PACKAGE_LABEL, PackageUMID);
- m_MPTrack = m_MaterialPackage->AddPictureTrack(EditRate_);
- m_FPTrack = m_FilePackage->AddPictureTrack(0, EditRate_);
+ m_MPTrack = m_MaterialPackage->AddPictureTrack(EditRate);
+ m_FPTrack = m_FilePackage->AddPictureTrack(0, EditRate);
break;
case ESS_JPEG_2000:
PackageUMID.MakeUMID(0x0f, assetUUID);
m_FilePackage = m_Metadata->AddFilePackage(1, JP2K_PACKAGE_LABEL, PackageUMID);
- m_MPTrack = m_MaterialPackage->AddPictureTrack(EditRate_);
- m_FPTrack = m_FilePackage->AddPictureTrack(0, EditRate_);
+ m_MPTrack = m_MaterialPackage->AddPictureTrack(EditRate);
+ m_FPTrack = m_FilePackage->AddPictureTrack(0, EditRate);
break;
case ESS_PCM_24b_48k:
PackageUMID.MakeUMID(0x0f, assetUUID);
m_FilePackage = m_Metadata->AddFilePackage(1, PCM_PACKAGE_LABEL, PackageUMID);
- m_MPTrack = m_MaterialPackage->AddSoundTrack(EditRate_);
- m_FPTrack = m_FilePackage->AddSoundTrack(0, EditRate_);
+ m_MPTrack = m_MaterialPackage->AddSoundTrack(EditRate);
+ m_FPTrack = m_FilePackage->AddSoundTrack(0, EditRate);
break;
default: return RESULT_RAW_ESS;
}
// Add an essence element
- FPTimecodeTrack = m_FilePackage->AddTimecodeTrack(EditRate_);
+ FPTimecodeTrack = m_FilePackage->AddTimecodeTrack(EditRate);
m_FPTimecode = FPTimecodeTrack->AddTimecodeComponent(TCFrameRate, 0/* NDF */,
tc_to_frames(TCFrameRate, 1, 0, 0, 0) );
m_IndexMan->SetBodySID(1);
m_IndexMan->SetIndexSID(129);
- m_IndexMan->SetEditRate(EditRate_);
+ m_IndexMan->SetEditRate(EditRate);
+#endif
return RESULT_OK;
}
Overhead.WriteUi64BE(FrameBuf.Size()); // write SourceLength
Overhead.WriteBER(m_CtFrameBuf.Size(), klv_length_size); // write ESV length
- result = m_File->Writev(Overhead.Data(), Overhead.Size());
+ result = m_File.Writev(Overhead.Data(), Overhead.Size());
}
if ( ASDCP_SUCCESS(result) )
{
m_StreamOffset += Overhead.Size();
// write encrypted source value
- result = m_File->Writev((byte_t*)m_CtFrameBuf.RoData(), m_CtFrameBuf.Size());
+ result = m_File.Writev((byte_t*)m_CtFrameBuf.RoData(), m_CtFrameBuf.Size());
}
if ( ASDCP_SUCCESS(result) )
}
// write HMAC
- result = m_File->Writev(HMACOverhead.Data(), HMACOverhead.Size());
+ result = m_File.Writev(HMACOverhead.Data(), HMACOverhead.Size());
m_StreamOffset += HMACOverhead.Size();
}
}
{
Overhead.WriteRaw((byte_t*)EssenceUL, klv_key_size);
Overhead.WriteBER(FrameBuf.Size(), klv_length_size);
- result = m_File->Writev(Overhead.Data(), Overhead.Size());
+ result = m_File.Writev(Overhead.Data(), Overhead.Size());
if ( ASDCP_SUCCESS(result) )
- result = m_File->Writev((byte_t*)FrameBuf.RoData(), FrameBuf.Size());
+ result = m_File.Writev((byte_t*)FrameBuf.RoData(), FrameBuf.Size());
if ( ASDCP_SUCCESS(result) )
m_StreamOffset += Overhead.Size() + FrameBuf.Size();
}
if ( ASDCP_SUCCESS(result) )
- result = m_File->Writev();
+ result = m_File.Writev();
return result;
}
Result_t
ASDCP::h__Writer::WriteMXFFooter(EssenceType_t EssenceType)
{
+#if 0
// write the index
DataChunk IndexChunk;
ui32_t IndexSID = 0;
m_HeaderPart->UpdateMetadata(m_Metadata);
// Actually write the footer
- m_File->WritePartitionWithIndex(*m_HeaderPart, &IndexChunk, false);
+ m_File.WritePartitionWithIndex(*m_HeaderPart, &IndexChunk, false);
// Add a RIP
- m_File->WriteRIP();
+ m_File.WriteRIP();
//
// ** Update the header **
// For OP-Atom re-write the entire header
//
ASDCP::fpos_t FooterPos = m_HeaderPart->GetUint64("FooterPartition");
- m_File->Seek(0);
+ m_File.Seek(0);
m_HeaderPart->ChangeType("ClosedCompleteHeader");
m_HeaderPart->SetUint64("FooterPartition", FooterPos);
m_HeaderPart->SetUint64("BodySID", 1);
- m_File->ReWritePartition(*m_HeaderPart);
- m_File->Close();
-
+ m_File.ReWritePartition(*m_HeaderPart);
+ m_File.Close();
+#endif
return RESULT_OK;
}
projects / asdcplib.git / commitdiff