/*
-Copyright (c) 2007, John Hurst
+Copyright (c) 2008-2014, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
#include "AS_DCP_internal.h"
-#include "AS_DCP_TimedText.h"
#include "KM_xml.h"
+#include <iostream>
+#include <iomanip>
-static std::string TIMED_TEXT_PACKAGE_LABEL = "File Package: SMPTE 429-5 frame wrapping of D-Cinema Timed Text data";
+using Kumu::GenRandomValue;
+
+static std::string TIMED_TEXT_PACKAGE_LABEL = "File Package: SMPTE 429-5 clip wrapping of D-Cinema Timed Text data";
static std::string TIMED_TEXT_DEF_LABEL = "Timed Text Track";
return "image/png";
else if ( m == TimedText::MT_OPENTYPE )
- return "application/x-opentype";
+ return "application/x-font-opentype";
return "application/octet-stream";
}
+//
+std::ostream&
+ASDCP::TimedText::operator << (std::ostream& strm, const TimedTextDescriptor& TDesc)
+{
+ UUID TmpID(TDesc.AssetID);
+ char buf[64];
+
+ strm << " EditRate: " << (unsigned) TDesc.EditRate.Numerator << "/" << (unsigned) TDesc.EditRate.Denominator << std::endl;
+ strm << "ContainerDuration: " << (unsigned) TDesc.ContainerDuration << std::endl;
+ strm << " AssetID: " << TmpID.EncodeHex(buf, 64) << std::endl;
+ strm << " NamespaceName: " << TDesc.NamespaceName << std::endl;
+ strm << " ResourceCount: " << (unsigned long) TDesc.ResourceList.size() << std::endl;
+
+ TimedText::ResourceList_t::const_iterator ri;
+ for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end(); ri++ )
+ {
+ TmpID.Set((*ri).ResourceID);
+ strm << " " << TmpID.EncodeHex(buf, 64) << ": " << MIME2str((*ri).Type) << std::endl;
+ }
+
+ return strm;
+}
+
//
void
ASDCP::TimedText::DescriptorDump(ASDCP::TimedText::TimedTextDescriptor const& TDesc, FILE* stream)
fprintf(stream, " EditRate: %u/%u\n", TDesc.EditRate.Numerator, TDesc.EditRate.Denominator);
fprintf(stream, "ContainerDuration: %u\n", TDesc.ContainerDuration);
fprintf(stream, " AssetID: %s\n", TmpID.EncodeHex(buf, 64));
- fprintf(stream, " NamespaceName: %s\n", TDesc.NamespaceName.c_str());
- fprintf(stream, " ResourceCount: %lu\n", TDesc.ResourceList.size());
+ fprintf(stream, " NamespaceName: %s\n", TDesc.NamespaceName.c_str());
+ fprintf(stream, " ResourceCount: %zu\n", TDesc.ResourceList.size());
TimedText::ResourceList_t::const_iterator ri;
for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end(); ri++ )
typedef std::map<UUID, UUID> ResourceMap_t;
-class ASDCP::TimedText::MXFReader::h__Reader : public ASDCP::h__Reader
+class ASDCP::TimedText::MXFReader::h__Reader : public ASDCP::h__ASDCPReader
{
- TimedTextDescriptor* m_EssenceDescriptor;
- ResourceMap_t m_ResourceMap;
+ MXF::TimedTextDescriptor* m_EssenceDescriptor;
+ ResourceMap_t m_ResourceMap;
ASDCP_NO_COPY_CONSTRUCT(h__Reader);
public:
TimedTextDescriptor m_TDesc;
- h__Reader() : m_EssenceDescriptor(0) {
+ h__Reader(const Dictionary& d) : ASDCP::h__ASDCPReader(d), m_EssenceDescriptor(0) {
memset(&m_TDesc.AssetID, 0, UUIDlen);
}
- Result_t OpenRead(const char*);
+ virtual ~h__Reader() {}
+
+ Result_t OpenRead(const std::string&);
Result_t MD_to_TimedText_TDesc(TimedText::TimedTextDescriptor& TDesc);
Result_t ReadTimedTextResource(FrameBuffer& FrameBuf, AESDecContext* Ctx, HMACContext* HMAC);
Result_t ReadAncillaryResource(const byte_t*, FrameBuffer& FrameBuf, AESDecContext* Ctx, HMACContext* HMAC);
{
assert(m_EssenceDescriptor);
memset(&m_TDesc.AssetID, 0, UUIDlen);
- MXF::DCTimedTextDescriptor* TDescObj = (MXF::DCTimedTextDescriptor*)m_EssenceDescriptor;
+ MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
TDesc.EditRate = TDescObj->SampleRate;
- TDesc.ContainerDuration = TDescObj->ContainerDuration;
- memcpy(TDesc.AssetID, TDescObj->AssetID.Value(), UUIDlen);
- TDesc.NamespaceName = TDescObj->RootNamespaceName;
- TDesc.EncodingName = TDescObj->UTFEncoding;
+ assert(TDescObj->ContainerDuration <= 0xFFFFFFFFL);
+ TDesc.ContainerDuration = (ui32_t) TDescObj->ContainerDuration;
+ memcpy(TDesc.AssetID, TDescObj->ResourceID.Value(), UUIDlen);
+ TDesc.NamespaceName = TDescObj->NamespaceURI;
+ TDesc.EncodingName = TDescObj->UCSEncoding;
Batch<UUID>::const_iterator sdi = TDescObj->SubDescriptors.begin();
- DCTimedTextResourceDescriptor* DescObject = 0;
+ TimedTextResourceSubDescriptor* DescObject = 0;
Result_t result = RESULT_OK;
for ( ; sdi != TDescObj->SubDescriptors.end() && KM_SUCCESS(result); sdi++ )
{
- result = m_HeaderPart.GetMDObjectByID(*sdi, (InterchangeObject**)&DescObject);
+ InterchangeObject* tmp_iobj = 0;
+ result = m_HeaderPart.GetMDObjectByID(*sdi, &tmp_iobj);
+ DescObject = static_cast<TimedTextResourceSubDescriptor*>(tmp_iobj);
if ( KM_SUCCESS(result) )
{
TimedTextResourceDescriptor TmpResource;
- memcpy(TmpResource.ResourceID, DescObject->ResourceID.Value(), UUIDlen);
+ memcpy(TmpResource.ResourceID, DescObject->AncillaryResourceID.Value(), UUIDlen);
- if ( DescObject->ResourceMIMEType.find("font/") != std::string::npos )
+ if ( DescObject->MIMEMediaType.find("application/x-font-opentype") != std::string::npos
+ || DescObject->MIMEMediaType.find("application/x-opentype") != std::string::npos
+ || DescObject->MIMEMediaType.find("font/opentype") != std::string::npos )
TmpResource.Type = MT_OPENTYPE;
- else if ( DescObject->ResourceMIMEType.find("image/png") != std::string::npos )
+ else if ( DescObject->MIMEMediaType.find("image/png") != std::string::npos )
TmpResource.Type = MT_PNG;
else
TmpResource.Type = MT_BIN;
TDesc.ResourceList.push_back(TmpResource);
- m_ResourceMap.insert(ResourceMap_t::value_type(DescObject->ResourceID, *sdi));
+ m_ResourceMap.insert(ResourceMap_t::value_type(DescObject->AncillaryResourceID, *sdi));
}
else
{
//
ASDCP::Result_t
-ASDCP::TimedText::MXFReader::h__Reader::OpenRead(char const* filename)
+ASDCP::TimedText::MXFReader::h__Reader::OpenRead(const std::string& filename)
{
Result_t result = OpenMXFRead(filename);
if( ASDCP_SUCCESS(result) )
{
if ( m_EssenceDescriptor == 0 )
- m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(DCTimedTextDescriptor), (InterchangeObject**)&m_EssenceDescriptor);
+ {
+ InterchangeObject* tmp_iobj = 0;
+ result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(TimedTextDescriptor), &tmp_iobj);
+ m_EssenceDescriptor = static_cast<MXF::TimedTextDescriptor*>(tmp_iobj);
+ }
- result = MD_to_TimedText_TDesc(m_TDesc);
+ if( ASDCP_SUCCESS(result) )
+ result = MD_to_TimedText_TDesc(m_TDesc);
}
- if( ASDCP_SUCCESS(result) )
- result = InitMXFIndex();
-
- if( ASDCP_SUCCESS(result) )
- result = InitInfo();
-
return result;
}
if ( ! m_File.IsOpen() )
return RESULT_INIT;
- Result_t result = ReadEKLVFrame(0, FrameBuf, Dict::ul(MDD_DCTimedTextEssence), Ctx, HMAC);
+ assert(m_Dict);
+ Result_t result = ReadEKLVFrame(0, FrameBuf, m_Dict->ul(MDD_TimedTextEssence), Ctx, HMAC);
if( ASDCP_SUCCESS(result) )
{
return RESULT_RANGE;
}
- DCTimedTextResourceDescriptor* DescObject = 0;
+ TimedTextResourceSubDescriptor* DescObject = 0;
// get the subdescriptor
- Result_t result = m_HeaderPart.GetMDObjectByID((*ri).second, (InterchangeObject**)&DescObject);
+ InterchangeObject* tmp_iobj = 0;
+ Result_t result = m_HeaderPart.GetMDObjectByID((*ri).second, &tmp_iobj);
+ DescObject = static_cast<TimedTextResourceSubDescriptor*>(tmp_iobj);
if ( KM_SUCCESS(result) )
{
Array<RIP::Pair>::const_iterator pi;
RIP::Pair TmpPair;
- ui32_t sequence = 1;
+ ui32_t sequence = 0;
// Look up the partition start in the RIP using the SID.
// Count the sequence length in because this is the sequence
// value needed to complete the HMAC.
- for ( pi = m_HeaderPart.m_RIP.PairArray.begin(); pi != m_HeaderPart.m_RIP.PairArray.end(); pi++, sequence++ )
+ for ( pi = m_RIP.PairArray.begin(); pi != m_RIP.PairArray.end(); ++pi, ++sequence )
{
- if ( (*pi).BodySID == DescObject->ResourceSID )
+ if ( (*pi).BodySID == DescObject->EssenceStreamID )
{
TmpPair = *pi;
break;
if ( TmpPair.ByteOffset == 0 )
{
- DefaultLogSink().Error("Body SID not found in RIP set: %d\n", DescObject->ResourceSID);
+ DefaultLogSink().Error("Body SID not found in RIP set: %d\n", DescObject->EssenceStreamID);
return RESULT_FORMAT;
}
if ( KM_SUCCESS(result) )
{
FrameBuf.AssetID(uuid);
- FrameBuf.MIMEType(DescObject->ResourceMIMEType);
+ FrameBuf.MIMEType(DescObject->MIMEMediaType);
// seek tp the start of the partition
if ( (Kumu::fpos_t)TmpPair.ByteOffset != m_LastPosition )
}
// read the partition header
- MXF::Partition GSPart;
+ MXF::Partition GSPart(m_Dict);
result = GSPart.InitFromFile(m_File);
if( ASDCP_SUCCESS(result) )
{
// check the SID
- if ( DescObject->ResourceSID != GSPart.BodySID )
+ if ( DescObject->EssenceStreamID != GSPart.BodySID )
{
char buf[64];
DefaultLogSink().Error("Generic stream partition body differs: %s\n", RID.EncodeHex(buf, 64));
}
// read the essence packet
+ assert(m_Dict);
if( ASDCP_SUCCESS(result) )
- result = ReadEKLVPacket(0, FrameBuf, Dict::ul(MDD_DCTimedTextDescriptor), Ctx, HMAC);
+ result = ReadEKLVPacket(0, sequence, FrameBuf, m_Dict->ul(MDD_GenericStream_DataElement), Ctx, HMAC);
}
}
}
ASDCP::TimedText::MXFReader::MXFReader()
{
- m_Reader = new h__Reader;
+ m_Reader = new h__Reader(DefaultSMPTEDict());
}
{
}
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper. Caveat emptor!
+//
+ASDCP::MXF::OP1aHeader&
+ASDCP::TimedText::MXFReader::OP1aHeader()
+{
+ if ( m_Reader.empty() )
+ {
+ assert(g_OP1aHeader);
+ return *g_OP1aHeader;
+ }
+
+ return m_Reader->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper. Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::TimedText::MXFReader::OPAtomIndexFooter()
+{
+ if ( m_Reader.empty() )
+ {
+ assert(g_OPAtomIndexFooter);
+ return *g_OPAtomIndexFooter;
+ }
+
+ return m_Reader->m_IndexAccess;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper. Caveat emptor!
+//
+ASDCP::MXF::RIP&
+ASDCP::TimedText::MXFReader::RIP()
+{
+ if ( m_Reader.empty() )
+ {
+ assert(g_RIP);
+ return *g_RIP;
+ }
+
+ return m_Reader->m_RIP;
+}
+
// Open the file for reading. The file must exist. Returns error if the
// operation cannot be completed.
ASDCP::Result_t
-ASDCP::TimedText::MXFReader::OpenRead(const char* filename) const
+ASDCP::TimedText::MXFReader::OpenRead(const std::string& filename) const
{
return m_Reader->OpenRead(filename);
}
// Fill the struct with the values from the file's header.
// Returns RESULT_INIT if the file is not open.
ASDCP::Result_t
-ASDCP::TimedText::MXFReader::FillDescriptor(TimedText::TimedTextDescriptor& TDesc) const
+ASDCP::TimedText::MXFReader::FillTimedTextDescriptor(TimedText::TimedTextDescriptor& TDesc) const
{
if ( m_Reader && m_Reader->m_File.IsOpen() )
{
ASDCP::TimedText::MXFReader::DumpIndex(FILE* stream) const
{
if ( m_Reader->m_File.IsOpen() )
- m_Reader->m_FooterPart.Dump(stream);
+ m_Reader->m_IndexAccess.Dump(stream);
+}
+
+//
+ASDCP::Result_t
+ASDCP::TimedText::MXFReader::Close() const
+{
+ if ( m_Reader && m_Reader->m_File.IsOpen() )
+ {
+ m_Reader->Close();
+ return RESULT_OK;
+ }
+
+ return RESULT_INIT;
}
+
//------------------------------------------------------------------------------------------
//
-class ASDCP::TimedText::MXFWriter::h__Writer : public ASDCP::h__Writer
+class ASDCP::TimedText::MXFWriter::h__Writer : public ASDCP::h__ASDCPWriter
{
+ ASDCP_NO_COPY_CONSTRUCT(h__Writer);
+ h__Writer();
+
public:
TimedTextDescriptor m_TDesc;
byte_t m_EssenceUL[SMPTE_UL_LENGTH];
- ui32_t m_ResourceSID;
+ ui32_t m_EssenceStreamID;
- ASDCP_NO_COPY_CONSTRUCT(h__Writer);
-
- h__Writer() : m_ResourceSID(10) {
+ h__Writer(const Dictionary& d) : ASDCP::h__ASDCPWriter(d), m_EssenceStreamID(10) {
memset(m_EssenceUL, 0, SMPTE_UL_LENGTH);
}
- ~h__Writer(){}
+ virtual ~h__Writer() {}
- Result_t OpenWrite(const char*, ui32_t HeaderSize);
+ Result_t OpenWrite(const std::string&, ui32_t HeaderSize);
Result_t SetSourceStream(const TimedTextDescriptor&);
Result_t WriteTimedTextResource(const std::string& XMLDoc, AESEncContext* = 0, HMACContext* = 0);
Result_t WriteAncillaryResource(const FrameBuffer&, AESEncContext* = 0, HMACContext* = 0);
ASDCP::TimedText::MXFWriter::h__Writer::TimedText_TDesc_to_MD(TimedText::TimedTextDescriptor& TDesc)
{
assert(m_EssenceDescriptor);
- MXF::DCTimedTextDescriptor* TDescObj = (MXF::DCTimedTextDescriptor*)m_EssenceDescriptor;
+ MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
TDescObj->SampleRate = TDesc.EditRate;
TDescObj->ContainerDuration = TDesc.ContainerDuration;
- TDescObj->AssetID.Set(TDesc.AssetID);
- TDescObj->RootNamespaceName = TDesc.NamespaceName;
- TDescObj->UTFEncoding = TDesc.EncodingName;
+ TDescObj->ResourceID.Set(TDesc.AssetID);
+ TDescObj->NamespaceURI = TDesc.NamespaceName;
+ TDescObj->UCSEncoding = TDesc.EncodingName;
return RESULT_OK;
}
//
ASDCP::Result_t
-ASDCP::TimedText::MXFWriter::h__Writer::OpenWrite(char const* filename, ui32_t HeaderSize)
+ASDCP::TimedText::MXFWriter::h__Writer::OpenWrite(const std::string& filename, ui32_t HeaderSize)
{
if ( ! m_State.Test_BEGIN() )
return RESULT_STATE;
if ( ASDCP_SUCCESS(result) )
{
m_HeaderSize = HeaderSize;
- m_EssenceDescriptor = new DCTimedTextDescriptor();
+ m_EssenceDescriptor = new MXF::TimedTextDescriptor(m_Dict);
result = m_State.Goto_INIT();
}
for ( ri = m_TDesc.ResourceList.begin() ; ri != m_TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
{
- DCTimedTextResourceDescriptor* resourceSubdescriptor = new DCTimedTextResourceDescriptor;
+ TimedTextResourceSubDescriptor* resourceSubdescriptor = new TimedTextResourceSubDescriptor(m_Dict);
GenRandomValue(resourceSubdescriptor->InstanceUID);
- resourceSubdescriptor->ResourceID.Set((*ri).ResourceID);
- resourceSubdescriptor->ResourceMIMEType = MIME2str((*ri).Type);
- resourceSubdescriptor->ResourceSID = m_ResourceSID++;
+ resourceSubdescriptor->AncillaryResourceID.Set((*ri).ResourceID);
+ resourceSubdescriptor->MIMEMediaType = MIME2str((*ri).Type);
+ resourceSubdescriptor->EssenceStreamID = m_EssenceStreamID++;
m_EssenceSubDescriptorList.push_back((FileDescriptor*)resourceSubdescriptor);
m_EssenceDescriptor->SubDescriptors.push_back(resourceSubdescriptor->InstanceUID);
}
- m_ResourceSID = 10;
+ m_EssenceStreamID = 10;
+ assert(m_Dict);
if ( ASDCP_SUCCESS(result) )
{
InitHeader();
- AddDMSegment(m_TDesc.EditRate, 24, TIMED_TEXT_DEF_LABEL,
- UL(Dict::ul(MDD_PictureDataDef)), TIMED_TEXT_PACKAGE_LABEL);
- AddEssenceDescriptor(UL(Dict::ul(MDD_DCTimedTextWrapping)));
+ // First RIP Entry
+ if ( m_Info.LabelSetType == LS_MXF_SMPTE ) // ERK
+ {
+ m_RIP.PairArray.push_back(RIP::Pair(0, 0)); // 3-part, no essence in header
+ }
+ else
+ {
+ DefaultLogSink().Error("Unable to write Interop timed-text MXF file. Use SMOTE DCP options instead.\n");
+ return RESULT_FORMAT;
+ }
+
+ // timecode rate and essence rate are the same
+ AddDMSegment(m_TDesc.EditRate, m_TDesc.EditRate, derive_timecode_rate_from_edit_rate(m_TDesc.EditRate), TIMED_TEXT_DEF_LABEL,
+ UL(m_Dict->ul(MDD_DataDataDef)), TIMED_TEXT_PACKAGE_LABEL);
+
+ AddEssenceDescriptor(UL(m_Dict->ul(MDD_TimedTextWrappingClip)));
result = m_HeaderPart.WriteToFile(m_File, m_HeaderSize);
if ( ASDCP_SUCCESS(result) )
{
- memcpy(m_EssenceUL, Dict::ul(MDD_DCTimedTextEssence), SMPTE_UL_LENGTH);
+ memcpy(m_EssenceUL, m_Dict->ul(MDD_TimedTextEssence), SMPTE_UL_LENGTH);
m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
result = m_State.Goto_READY();
}
return RESULT_STATE;
Kumu::fpos_t here = m_File.Tell();
+ assert(m_Dict);
// create generic stream partition header
- MXF::Partition GSPart;
+ static UL GenericStream_DataElement(m_Dict->ul(MDD_GenericStream_DataElement));
+ MXF::Partition GSPart(m_Dict);
GSPart.ThisPartition = here;
- GSPart.PreviousPartition = m_HeaderPart.m_RIP.PairArray.back().ByteOffset;
- GSPart.BodySID = m_ResourceSID;
+ GSPart.PreviousPartition = m_RIP.PairArray.back().ByteOffset;
+ GSPart.BodySID = m_EssenceStreamID;
GSPart.OperationalPattern = m_HeaderPart.OperationalPattern;
- m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(m_ResourceSID++, here));
- GSPart.EssenceContainers.push_back(UL(Dict::ul(MDD_DCTimedTextEssence)));
- UL TmpUL(Dict::ul(MDD_GenericStreamPartition));
+ m_RIP.PairArray.push_back(RIP::Pair(m_EssenceStreamID++, here));
+ GSPart.EssenceContainers.push_back(UL(m_Dict->ul(MDD_TimedTextEssence)));
+ UL TmpUL(m_Dict->ul(MDD_GenericStreamPartition));
Result_t result = GSPart.WriteToFile(m_File, TmpUL);
if ( ASDCP_SUCCESS(result) )
- result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC);
+ result = WriteEKLVPacket(FrameBuf, GenericStream_DataElement.Value(), Ctx, HMAC);
- m_FramesWritten++;
+ m_FramesWritten++;
return result;
}
m_FramesWritten = m_TDesc.ContainerDuration;
m_State.Goto_FINAL();
- return WriteMXFFooter();
+ return WriteASDCPFooter();
}
{
}
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper. Caveat emptor!
+//
+ASDCP::MXF::OP1aHeader&
+ASDCP::TimedText::MXFWriter::OP1aHeader()
+{
+ if ( m_Writer.empty() )
+ {
+ assert(g_OP1aHeader);
+ return *g_OP1aHeader;
+ }
+
+ return m_Writer->m_HeaderPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper. Caveat emptor!
+//
+ASDCP::MXF::OPAtomIndexFooter&
+ASDCP::TimedText::MXFWriter::OPAtomIndexFooter()
+{
+ if ( m_Writer.empty() )
+ {
+ assert(g_OPAtomIndexFooter);
+ return *g_OPAtomIndexFooter;
+ }
+
+ return m_Writer->m_FooterPart;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper. Caveat emptor!
+//
+ASDCP::MXF::RIP&
+ASDCP::TimedText::MXFWriter::RIP()
+{
+ if ( m_Writer.empty() )
+ {
+ assert(g_RIP);
+ return *g_RIP;
+ }
+
+ return m_Writer->m_RIP;
+}
// Open the file for writing. The file must not exist. Returns error if
// the operation cannot be completed.
ASDCP::Result_t
-ASDCP::TimedText::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info,
+ASDCP::TimedText::MXFWriter::OpenWrite(const std::string& filename, const WriterInfo& Info,
const TimedTextDescriptor& TDesc, ui32_t HeaderSize)
{
if ( Info.LabelSetType != LS_MXF_SMPTE )
return RESULT_FORMAT;
}
- m_Writer = new h__Writer;
+ m_Writer = new h__Writer(DefaultSMPTEDict());
+ m_Writer->m_Info = Info;
Result_t result = m_Writer->OpenWrite(filename, HeaderSize);
if ( ASDCP_SUCCESS(result) )
- {
- m_Writer->m_Info = Info;
- result = m_Writer->SetSourceStream(TDesc);
- }
+ result = m_Writer->SetSourceStream(TDesc);
if ( ASDCP_FAILURE(result) )
m_Writer.release();
projects / asdcplib.git / blobdiff