From 27915a74438fcf264d8dfd621dd5e79fa4065813 Mon Sep 17 00:00:00 2001 From: jhurst Date: Sat, 5 May 2007 23:51:23 +0000 Subject: new stuff --- src/AS_DCP_TimedText.cpp | 241 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 src/AS_DCP_TimedText.cpp (limited to 'src/AS_DCP_TimedText.cpp') diff --git a/src/AS_DCP_TimedText.cpp b/src/AS_DCP_TimedText.cpp new file mode 100644 index 0000000..ccb7c3e --- /dev/null +++ b/src/AS_DCP_TimedText.cpp @@ -0,0 +1,241 @@ +/* +Copyright (c) 2007, John Hurst +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/*! \file AS_DCP_TimedText.cpp + \version $Id$ + \brief AS-DCP library, PCM essence reader and writer implementation +*/ + + +#include "AS_DCP_internal.h" +#include "AS_DCP_TimedText.h" +#include "KM_xml.h" + +using namespace Kumu; +using namespace ASDCP; + + +//------------------------------------------------------------------------------------------ + +// +void +ASDCP::TimedText::FrameBuffer::Dump(FILE* stream, ui32_t dump_len) const +{ + if ( stream == 0 ) + stream = stderr; + + UUID TmpID(m_AssetID); + char buf[64]; + fprintf(stream, "ID: %s (type %s)\n", TmpID.EncodeHex(buf, 64), m_MIMEType.c_str()); + + if ( dump_len > 0 ) + Kumu::hexdump(m_Data, dump_len, stream); +} + +//------------------------------------------------------------------------------------------ + +class ASDCP::TimedText::MXFReader::h__Reader : public ASDCP::h__Reader +{ + TimedTextDescriptor* m_EssenceDescriptor; + + ASDCP_NO_COPY_CONSTRUCT(h__Reader); + +public: + TimedTextDescriptor m_TDesc; + + h__Reader() : m_EssenceDescriptor(0) {} + Result_t OpenRead(const char*); + Result_t ReadFrame(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*); + Result_t ReadFrameGOPStart(ui32_t, FrameBuffer&, AESDecContext*, HMACContext*); + Result_t MD_to_TimedText_PDesc(TimedText::TimedTextDescriptor& TDesc); +}; + +//------------------------------------------------------------------------------------------ + +ASDCP::TimedText::MXFReader::MXFReader() +{ + m_Reader = new h__Reader; +} + + +ASDCP::TimedText::MXFReader::~MXFReader() +{ +} + +// 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 +{ + return m_Reader->OpenRead(filename); +} + +// +ASDCP::Result_t +ASDCP::TimedText::MXFReader::ReadFrame(ui32_t FrameNum, FrameBuffer& FrameBuf, + AESDecContext* Ctx, HMACContext* HMAC) const +{ + if ( m_Reader && m_Reader->m_File.IsOpen() ) + return m_Reader->ReadFrame(FrameNum, FrameBuf, Ctx, HMAC); + + return RESULT_INIT; +} + + +// 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 +{ + if ( m_Reader && m_Reader->m_File.IsOpen() ) + { + TDesc = m_Reader->m_TDesc; + return RESULT_OK; + } + + return RESULT_INIT; +} + + +// 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::FillWriterInfo(WriterInfo& Info) const +{ + if ( m_Reader && m_Reader->m_File.IsOpen() ) + { + Info = m_Reader->m_Info; + return RESULT_OK; + } + + return RESULT_INIT; +} + +// +void +ASDCP::TimedText::MXFReader::DumpHeaderMetadata(FILE* stream) const +{ + if ( m_Reader->m_File.IsOpen() ) + m_Reader->m_HeaderPart.Dump(stream); +} + + +// +void +ASDCP::TimedText::MXFReader::DumpIndex(FILE* stream) const +{ + if ( m_Reader->m_File.IsOpen() ) + m_Reader->m_FooterPart.Dump(stream); +} + +//------------------------------------------------------------------------------------------ + + +// +class ASDCP::TimedText::MXFWriter::h__Writer : public ASDCP::h__Writer +{ +public: + TimedTextDescriptor m_TDesc; + byte_t m_EssenceUL[SMPTE_UL_LENGTH]; + + ASDCP_NO_COPY_CONSTRUCT(h__Writer); + + h__Writer() { + memset(m_EssenceUL, 0, SMPTE_UL_LENGTH); + } + + ~h__Writer(){} + + Result_t OpenWrite(const char*, ui32_t HeaderSize); + Result_t SetSourceStream(const TimedTextDescriptor&); + Result_t WriteFrame(const FrameBuffer&, AESEncContext* = 0, HMACContext* = 0); + Result_t Finalize(); + Result_t TimedText_PDesc_to_MD(TimedText::TimedTextDescriptor& PDesc); +}; + + +//------------------------------------------------------------------------------------------ + +ASDCP::TimedText::MXFWriter::MXFWriter() +{ +} + +ASDCP::TimedText::MXFWriter::~MXFWriter() +{ +} + + +// 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, + const TimedTextDescriptor& TDesc, ui32_t HeaderSize) +{ + m_Writer = new h__Writer; + + Result_t result = m_Writer->OpenWrite(filename, HeaderSize); + + if ( ASDCP_SUCCESS(result) ) + { + m_Writer->m_Info = Info; + result = m_Writer->SetSourceStream(TDesc); + } + + if ( ASDCP_FAILURE(result) ) + m_Writer.release(); + + return result; +} + + +// Writes a frame of essence to the MXF file. If the optional AESEncContext +// argument is present, the essence is encrypted prior to writing. +// Fails if the file is not open, is finalized, or an operating system +// error occurs. +ASDCP::Result_t +ASDCP::TimedText::MXFWriter::WriteFrame(const FrameBuffer& FrameBuf, AESEncContext* Ctx, HMACContext* HMAC) +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + return m_Writer->WriteFrame(FrameBuf, Ctx, HMAC); +} + +// Closes the MXF file, writing the index and other closing information. +ASDCP::Result_t +ASDCP::TimedText::MXFWriter::Finalize() +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + return m_Writer->Finalize(); +} + + + +// +// end AS_DCP_timedText.cpp +// -- cgit v1.2.3