+ namespace MXF
+ {
+ //---------------------------------------------------------------------------------
+ //
+
+ /// void default_md_object_init();
+
+ template <class HeaderType, class IndexAccessType>
+ class TrackFileReader
+ {
+ KM_NO_COPY_CONSTRUCT(TrackFileReader);
+ TrackFileReader();
+
+ public:
+ const Dictionary* m_Dict;
+ Kumu::FileReader m_File;
+ HeaderType m_HeaderPart;
+ IndexAccessType m_IndexAccess;
+ RIP m_RIP;
+ WriterInfo m_Info;
+ ASDCP::FrameBuffer m_CtFrameBuf;
+ Kumu::fpos_t m_LastPosition;
+
+ TrackFileReader(const Dictionary& d) :
+ m_HeaderPart(m_Dict), m_IndexAccess(m_Dict), m_RIP(m_Dict), m_Dict(&d)
+ {
+ default_md_object_init();
+ }
+
+ virtual ~TrackFileReader() {
+ Close();
+ }
+
+ const MXF::RIP& GetRIP() const { return m_RIP; }
+
+ //
+ Result_t OpenMXFRead(const char* filename)
+ {
+ m_LastPosition = 0;
+ Result_t result = m_File.OpenRead(filename);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = SeekToRIP(m_File);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ result = m_RIP.InitFromFile(m_File);
+ ui32_t test_s = m_RIP.PairArray.size();
+
+ if ( ASDCP_FAILURE(result) )
+ {
+ DefaultLogSink().Error("File contains no RIP\n");
+ }
+ else if ( m_RIP.PairArray.empty() )
+ {
+ DefaultLogSink().Error("RIP contains no Pairs.\n");
+ }
+ }
+ else
+ {
+ DefaultLogSink().Error("TrackFileReader::OpenMXFRead, SeekToRIP failed\n");
+ }
+
+ m_File.Seek(0);
+ result = m_HeaderPart.InitFromFile(m_File);
+
+ if ( KM_FAILURE(result) )
+ {
+ DefaultLogSink().Error("TrackFileReader::OpenMXFRead, header init failed\n");
+ }
+
+ return result;
+ }
+
+ //
+ Result_t InitInfo()
+ {
+ assert(m_Dict);
+ InterchangeObject* Object;
+
+ // Identification
+ Result_t result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(Identification), &Object);
+
+ // Writer Info and SourcePackage
+ if ( KM_SUCCESS(result) )
+ {
+ MD_to_WriterInfo((Identification*)Object, m_Info);
+ result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(SourcePackage), &Object);
+ }
+
+ if ( KM_SUCCESS(result) )
+ {
+ SourcePackage* SP = (SourcePackage*)Object;
+ memcpy(m_Info.AssetUUID, SP->PackageUID.Value() + 16, UUIDlen);
+ }
+
+ // optional CryptographicContext
+ if ( KM_SUCCESS(result) )
+ {
+ Result_t cr_result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(CryptographicContext), &Object);
+
+ if ( KM_SUCCESS(cr_result) )
+ MD_to_CryptoInfo((CryptographicContext*)Object, m_Info, *m_Dict);
+ }
+
+ return result;
+ }
+
+ // positions file before reading
+ // allows external control of index offset
+ Result_t ReadEKLVFrame(const ui64_t& body_offset,
+ ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
+ const byte_t* EssenceUL, AESDecContext* Ctx, HMACContext* HMAC)
+ {
+ // look up frame index node
+ IndexTableSegment::IndexEntry TmpEntry;
+
+ if ( KM_FAILURE(m_IndexAccess.Lookup(FrameNum, TmpEntry)) )
+ {
+ DefaultLogSink().Error("Frame value out of range: %u\n", FrameNum);
+ return RESULT_RANGE;
+ }
+
+ // get relative frame position, apply offset and go read the frame's key and length
+ Kumu::fpos_t FilePosition = body_offset + TmpEntry.StreamOffset;
+ Result_t result = RESULT_OK;
+
+ if ( FilePosition != m_LastPosition )
+ {
+ m_LastPosition = FilePosition;
+ result = m_File.Seek(FilePosition);
+ }
+
+ if ( KM_SUCCESS(result) )
+ result = ReadEKLVPacket(FrameNum, FrameNum + 1, FrameBuf, EssenceUL, Ctx, HMAC);
+
+ return result;
+ }
+
+ // positions file before reading
+ // assumes "processed" index entries have absolute positions
+ Result_t ReadEKLVFrame(ui32_t FrameNum, ASDCP::FrameBuffer& FrameBuf,
+ const byte_t* EssenceUL, AESDecContext* Ctx, HMACContext* HMAC)
+ {
+ // look up frame index node
+ IndexTableSegment::IndexEntry TmpEntry;
+
+ if ( KM_FAILURE(m_IndexAccess.Lookup(FrameNum, TmpEntry)) )
+ {
+ DefaultLogSink().Error("Frame value out of range: %u\n", FrameNum);
+ return RESULT_RANGE;
+ }
+
+ // get absolute frame position and go read the frame's key and length
+ Result_t result = RESULT_OK;
+
+ if ( TmpEntry.StreamOffset != m_LastPosition )
+ {
+ m_LastPosition = TmpEntry.StreamOffset;
+ result = m_File.Seek(TmpEntry.StreamOffset);
+ }
+
+ if ( KM_SUCCESS(result) )
+ result = ReadEKLVPacket(FrameNum, FrameNum + 1, FrameBuf, EssenceUL, Ctx, HMAC);
+
+ return result;
+ }
+
+ // reads from current position
+ Result_t ReadEKLVPacket(ui32_t FrameNum, ui32_t SequenceNum, ASDCP::FrameBuffer& FrameBuf,
+ const byte_t* EssenceUL, AESDecContext* Ctx, HMACContext* HMAC)
+ {
+ assert(m_Dict);
+ return Read_EKLV_Packet(m_File, *m_Dict, m_Info, m_LastPosition, m_CtFrameBuf,
+ FrameNum, SequenceNum, FrameBuf, EssenceUL, Ctx, HMAC);
+ }
+
+ // Get the position of a frame from a track file
+ Result_t LocateFrame(const ui64_t& body_offset,
+ ui32_t FrameNum, Kumu::fpos_t& streamOffset,
+ i8_t& temporalOffset, i8_t& keyFrameOffset)
+ {
+ // look up frame index node
+ IndexTableSegment::IndexEntry TmpEntry;
+
+ if ( KM_FAILURE(m_IndexAccess.Lookup(FrameNum, TmpEntry)) )
+ {
+ DefaultLogSink().Error("Frame value out of range: %u\n", FrameNum);
+ return RESULT_RANGE;
+ }
+
+ // get frame position, temporal offset, and key frame ofset
+ streamOffset = body_offset + TmpEntry.StreamOffset;
+ temporalOffset = TmpEntry.TemporalOffset;
+ keyFrameOffset = TmpEntry.KeyFrameOffset;
+
+ return RESULT_OK;
+ }
+
+ //
+ void Close()
+ {
+ m_File.Close();
+ }
+ };
+
+ //------------------------------------------------------------------------------------------
+ //
+
+ //
+ template <class ClipT>
+ struct TrackSet
+ {
+ MXF::Track* Track;
+ MXF::Sequence* Sequence;
+ ClipT* Clip;
+
+ TrackSet() : Track(0), Sequence(0), Clip(0) {}
+ };
+
+ //
+ template <class PackageT, class ClipT>
+ TrackSet<ClipT>
+ CreateTrackAndSequence(OP1aHeader& Header, PackageT& Package, const std::string TrackName,
+ const MXF::Rational& clip_edit_rate, const UL& Definition, ui32_t TrackID, const Dictionary*& Dict)
+ {
+ TrackSet<ClipT> NewTrack;
+
+ NewTrack.Track = new Track(Dict);
+ Header.AddChildObject(NewTrack.Track);
+ NewTrack.Track->EditRate = clip_edit_rate;
+ Package.Tracks.push_back(NewTrack.Track->InstanceUID);
+ NewTrack.Track->TrackID = TrackID;
+ NewTrack.Track->TrackName = TrackName.c_str();
+
+ NewTrack.Sequence = new Sequence(Dict);
+ Header.AddChildObject(NewTrack.Sequence);
+ NewTrack.Track->Sequence = NewTrack.Sequence->InstanceUID;
+ NewTrack.Sequence->DataDefinition = Definition;
+
+ return NewTrack;
+ }
+
+ //
+ template <class PackageT>
+ TrackSet<TimecodeComponent>
+ CreateTimecodeTrack(OP1aHeader& Header, PackageT& Package,
+ const MXF::Rational& tc_edit_rate, ui32_t tc_frame_rate, ui64_t TCStart, const Dictionary*& Dict)
+ {
+ assert(Dict);
+ UL TCUL(Dict->ul(MDD_TimecodeDataDef));
+
+ TrackSet<TimecodeComponent> NewTrack =
+ CreateTrackAndSequence<PackageT, TimecodeComponent>(Header, Package, "Timecode Track",
+ tc_edit_rate, TCUL, 1, Dict);
+
+ NewTrack.Clip = new TimecodeComponent(Dict);
+ Header.AddChildObject(NewTrack.Clip);
+ NewTrack.Sequence->StructuralComponents.push_back(NewTrack.Clip->InstanceUID);
+ NewTrack.Clip->RoundedTimecodeBase = tc_frame_rate;
+ NewTrack.Clip->StartTimecode = TCStart;
+ NewTrack.Clip->DataDefinition = TCUL;
+
+ return NewTrack;
+ }
+
+
+ // 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
+ ST_MAX
+ };
+
+ // 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); }
+ };
+
+ //------------------------------------------------------------------------------------------
+ //
+
+ //
+ template <class HeaderType>
+ class TrackFileWriter
+ {
+ KM_NO_COPY_CONSTRUCT(TrackFileWriter);
+ TrackFileWriter();
+
+ public:
+ const Dictionary* m_Dict;
+ Kumu::FileWriter m_File;
+ ui32_t m_HeaderSize;
+ HeaderType m_HeaderPart;
+ RIP m_RIP;
+
+ MaterialPackage* m_MaterialPackage;
+ SourcePackage* m_FilePackage;
+
+ FileDescriptor* m_EssenceDescriptor;
+ std::list<InterchangeObject*> m_EssenceSubDescriptorList;
+
+ ui32_t m_FramesWritten;
+ ui64_t m_StreamOffset;
+ ASDCP::FrameBuffer m_CtFrameBuf;
+ h__WriterState m_State;
+ WriterInfo m_Info;
+
+ typedef std::list<ui64_t*> DurationElementList_t;
+ DurationElementList_t m_DurationUpdateList;
+
+ TrackFileWriter(const Dictionary& d) :
+ m_Dict(&d), m_HeaderPart(m_Dict), m_RIP(m_Dict),
+ m_HeaderSize(0), m_EssenceDescriptor(0),
+ m_FramesWritten(0), m_StreamOffset(0)
+ {
+ default_md_object_init();
+ }
+
+ virtual ~TrackFileWriter() {
+ Close();
+ }
+
+ const MXF::RIP& GetRIP() const { return m_RIP; }
+
+ void InitHeader()
+ {
+ assert(m_Dict);
+ assert(m_EssenceDescriptor);
+
+ m_HeaderPart.m_Primer.ClearTagList();
+ m_HeaderPart.m_Preface = new Preface(m_Dict);
+ m_HeaderPart.AddChildObject(m_HeaderPart.m_Preface);
+
+ // Set the Operational Pattern label -- we're just starting and have no RIP or index,
+ // so we tell the world by using OP1a
+ m_HeaderPart.m_Preface->OperationalPattern = UL(m_Dict->ul(MDD_OP1a));
+ m_HeaderPart.OperationalPattern = m_HeaderPart.m_Preface->OperationalPattern;
+
+ // Identification
+ Identification* Ident = new Identification(m_Dict);
+ m_HeaderPart.AddChildObject(Ident);
+ m_HeaderPart.m_Preface->Identifications.push_back(Ident->InstanceUID);
+
+ Kumu::GenRandomValue(Ident->ThisGenerationUID);
+ Ident->CompanyName = m_Info.CompanyName.c_str();
+ Ident->ProductName = m_Info.ProductName.c_str();
+ Ident->VersionString = m_Info.ProductVersion.c_str();
+ Ident->ProductUID.Set(m_Info.ProductUUID);
+ Ident->Platform = ASDCP_PLATFORM;
+
+ std::vector<int> version = version_split(Version());
+
+ Ident->ToolkitVersion.Major = version[0];
+ Ident->ToolkitVersion.Minor = version[1];
+ Ident->ToolkitVersion.Patch = version[2];
+ Ident->ToolkitVersion.Build = ASDCP_BUILD_NUMBER;
+ Ident->ToolkitVersion.Release = VersionType::RL_RELEASE;
+ }
+
+ //
+ void AddSourceClip(const MXF::Rational& clip_edit_rate,
+ const MXF::Rational& tc_edit_rate, ui32_t TCFrameRate,
+ const std::string& TrackName, const UL& EssenceUL,
+ const UL& DataDefinition, const std::string& PackageLabel)
+ {
+ //
+ ContentStorage* Storage = new ContentStorage(m_Dict);
+ m_HeaderPart.AddChildObject(Storage);
+ m_HeaderPart.m_Preface->ContentStorage = Storage->InstanceUID;
+
+ EssenceContainerData* ECD = new EssenceContainerData(m_Dict);
+ m_HeaderPart.AddChildObject(ECD);
+ Storage->EssenceContainerData.push_back(ECD->InstanceUID);
+ ECD->IndexSID = 129;
+ ECD->BodySID = 1;
+
+ UUID assetUUID(m_Info.AssetUUID);
+ UMID SourcePackageUMID, MaterialPackageUMID;
+ SourcePackageUMID.MakeUMID(0x0f, assetUUID);
+ MaterialPackageUMID.MakeUMID(0x0f); // unidentified essence
+
+ //
+ // Material Package
+ //
+ m_MaterialPackage = new MaterialPackage(m_Dict);
+ m_MaterialPackage->Name = "AS-DCP Material Package";
+ m_MaterialPackage->PackageUID = MaterialPackageUMID;
+ m_HeaderPart.AddChildObject(m_MaterialPackage);
+ Storage->Packages.push_back(m_MaterialPackage->InstanceUID);
+
+ TrackSet<TimecodeComponent> MPTCTrack =
+ CreateTimecodeTrack<MaterialPackage>(m_HeaderPart, *m_MaterialPackage,
+ tc_edit_rate, TCFrameRate, 0, m_Dict);
+ m_DurationUpdateList.push_back(&(MPTCTrack.Sequence->Duration.get()));
+ m_DurationUpdateList.push_back(&(MPTCTrack.Clip->Duration.get()));
+
+ TrackSet<SourceClip> MPTrack =
+ CreateTrackAndSequence<MaterialPackage, SourceClip>(m_HeaderPart, *m_MaterialPackage,
+ TrackName, clip_edit_rate, DataDefinition,
+ 2, m_Dict);
+ m_DurationUpdateList.push_back(&(MPTrack.Sequence->Duration.get()));
+
+ MPTrack.Clip = new SourceClip(m_Dict);
+ m_HeaderPart.AddChildObject(MPTrack.Clip);
+ MPTrack.Sequence->StructuralComponents.push_back(MPTrack.Clip->InstanceUID);
+ MPTrack.Clip->DataDefinition = DataDefinition;
+ MPTrack.Clip->SourcePackageID = SourcePackageUMID;
+ MPTrack.Clip->SourceTrackID = 2;
+ m_DurationUpdateList.push_back(&(MPTrack.Clip->Duration.get()));