From: Carl Hetherington Date: Thu, 21 Mar 2024 19:29:47 +0000 (+0100) Subject: Allow overwrite (i.e. continue) when writing JPEG2000 MXFs. X-Git-Tag: v1.0.0~11 X-Git-Url: https://main.carlh.net/gitweb/?a=commitdiff_plain;h=8b59eda953e7fa37506e6cb6add7dcb7d5ae8dce;p=asdcplib.git Allow overwrite (i.e. continue) when writing JPEG2000 MXFs. --- diff --git a/src/AS_DCP.h b/src/AS_DCP.h index 8a87bf2..dac5cd1 100755 --- a/src/AS_DCP.h +++ b/src/AS_DCP.h @@ -1262,11 +1262,11 @@ namespace ASDCP { virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); virtual MXF::RIP& RIP(); - // Open the file for writing. The file must not exist. Returns error if + // Open the file for writing. The file must not exist unless overwrite is true. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. Result_t OpenWrite(const std::string& filename, const WriterInfo&, - const PictureDescriptor&, ui32_t HeaderSize = 16384); + const PictureDescriptor&, ui32_t HeaderSize = 16384, bool overwrite = false); // Writes a frame of essence to the MXF file. If the optional AESEncContext // argument is present, the essence is encrypted prior to writing. @@ -1274,8 +1274,13 @@ namespace ASDCP { // error occurs. Result_t WriteFrame(const FrameBuffer&, AESEncContext* = 0, HMACContext* = 0); + Result_t FakeWriteFrame(int size); + // Closes the MXF file, writing the index and revised header. Result_t Finalize(); + + // Return the current file offset in the MXF file that we are writing. + ui64_t Tell() const; }; // @@ -1367,11 +1372,11 @@ namespace ASDCP { virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); virtual MXF::RIP& RIP(); - // Open the file for writing. The file must not exist. Returns error if + // Open the file for writing. The file must not exist unless overwrite is true. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. Result_t OpenWrite(const std::string& filename, const WriterInfo&, - const PictureDescriptor&, ui32_t HeaderSize = 16384); + const PictureDescriptor&, ui32_t HeaderSize = 16384, bool overwrite = false); // Writes a pair of frames of essence to the MXF file. If the optional AESEncContext // argument is present, the essence is encrypted prior to writing. @@ -1388,9 +1393,14 @@ namespace ASDCP { Result_t WriteFrame(const FrameBuffer&, StereoscopicPhase_t phase, AESEncContext* = 0, HMACContext* = 0); + Result_t FakeWriteFrame(int size, StereoscopicPhase_t phase); + // Closes the MXF file, writing the index and revised header. Returns // RESULT_SPHASE if WriteFrame was called an odd number of times. Result_t Finalize(); + + // Return the current file offset in the MXF file that we are writing + ui64_t Tell() const; }; // diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp index 87961c3..5e7d7a3 100755 --- a/src/AS_DCP_JP2K.cpp +++ b/src/AS_DCP_JP2K.cpp @@ -1158,24 +1158,34 @@ public: virtual ~lh__Writer(){} - Result_t OpenWrite(const std::string&, EssenceType_t type, ui32_t HeaderSize); + Result_t OpenWrite(const std::string&, EssenceType_t type, ui32_t HeaderSize, bool); Result_t SetSourceStream(const PictureDescriptor&, const std::string& label, ASDCP::Rational LocalEditRate = ASDCP::Rational(0,0)); Result_t WriteFrame(const JP2K::FrameBuffer&, bool add_index, AESEncContext*, HMACContext*); + Result_t FakeWriteFrame(int size, bool add_index); Result_t Finalize(); }; } // namespace JP2K } // namespace asdcp -// Open the file for writing. The file must not exist. Returns error if +// Open the file for writing. The file must not exist unless overwrite is true. Returns error if // the operation cannot be completed. ASDCP::Result_t -lh__Writer::OpenWrite(const std::string& filename, EssenceType_t type, ui32_t HeaderSize) +lh__Writer::OpenWrite(const std::string& filename, EssenceType_t type, ui32_t HeaderSize, bool overwrite) { if ( ! m_State.Test_BEGIN() ) return RESULT_STATE; - Result_t result = m_File.OpenWrite(filename); + Result_t result = RESULT_OK; + if (overwrite) + { + result = m_File.OpenModify(filename); + m_File.Seek(0); + } + else + { + result = m_File.OpenWrite(filename); + } if ( ASDCP_SUCCESS(result) ) { @@ -1283,6 +1293,31 @@ lh__Writer::WriteFrame(const JP2K::FrameBuffer& FrameBuf, bool add_index, } +Result_t +lh__Writer::FakeWriteFrame(int size, bool add_index) +{ + Result_t result = RESULT_OK; + + if ( m_State.Test_READY() ) + result = m_State.Goto_RUNNING(); + + ui64_t StreamOffset = m_StreamOffset; + + if ( ASDCP_SUCCESS(result) ) + result = FakeWriteEKLVPacket(size); + + if ( ASDCP_SUCCESS(result) && add_index ) + { + IndexTableSegment::IndexEntry Entry; + Entry.StreamOffset = StreamOffset; + m_FooterPart.PushIndexEntry(Entry); + } + + m_FramesWritten++; + return result; +} + + // Closes the MXF file, writing the index and other closing information. // ASDCP::Result_t @@ -1365,11 +1400,11 @@ ASDCP::JP2K::MXFWriter::RIP() return m_Writer->m_RIP; } -// Open the file for writing. The file must not exist. Returns error if +// Open the file for writing. The file must not exist unless overwrite is true. Returns error if // the operation cannot be completed. ASDCP::Result_t ASDCP::JP2K::MXFWriter::OpenWrite(const std::string& filename, const WriterInfo& Info, - const PictureDescriptor& PDesc, ui32_t HeaderSize) + const PictureDescriptor& PDesc, ui32_t HeaderSize, bool overwrite) { if ( Info.LabelSetType == LS_MXF_SMPTE ) m_Writer = new h__Writer(&DefaultSMPTEDict()); @@ -1378,7 +1413,7 @@ ASDCP::JP2K::MXFWriter::OpenWrite(const std::string& filename, const WriterInfo& m_Writer->m_Info = Info; - Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000, HeaderSize); + Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000, HeaderSize, overwrite); if ( ASDCP_SUCCESS(result) ) result = m_Writer->SetSourceStream(PDesc, JP2K_PACKAGE_LABEL); @@ -1403,6 +1438,15 @@ ASDCP::JP2K::MXFWriter::WriteFrame(const FrameBuffer& FrameBuf, AESEncContext* C return m_Writer->WriteFrame(FrameBuf, true, Ctx, HMAC); } +ASDCP::Result_t +ASDCP::JP2K::MXFWriter::FakeWriteFrame(int size) +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + return m_Writer->FakeWriteFrame(size, true); +} + // Closes the MXF file, writing the index and other closing information. ASDCP::Result_t ASDCP::JP2K::MXFWriter::Finalize() @@ -1413,6 +1457,11 @@ ASDCP::JP2K::MXFWriter::Finalize() return m_Writer->Finalize(); } +ui64_t +ASDCP::JP2K::MXFWriter::Tell() const +{ + return m_Writer->m_File.TellPosition(); +} //------------------------------------------------------------------------------------------ // @@ -1444,6 +1493,21 @@ public: return lh__Writer::WriteFrame(FrameBuf, false, Ctx, HMAC); } + Result_t FakeWriteFrame(int size, StereoscopicPhase_t phase) + { + if ( m_NextPhase != phase ) + return RESULT_SPHASE; + + if ( phase == SP_LEFT ) + { + m_NextPhase = SP_RIGHT; + return lh__Writer::FakeWriteFrame(size, true); + } + + m_NextPhase = SP_LEFT; + return lh__Writer::FakeWriteFrame(size, false); + } + // Result_t Finalize() { @@ -1515,7 +1579,7 @@ ASDCP::JP2K::MXFSWriter::RIP() // the operation cannot be completed. ASDCP::Result_t ASDCP::JP2K::MXFSWriter::OpenWrite(const std::string& filename, const WriterInfo& Info, - const PictureDescriptor& PDesc, ui32_t HeaderSize) + const PictureDescriptor& PDesc, ui32_t HeaderSize, bool overwrite) { if ( Info.LabelSetType == LS_MXF_SMPTE ) m_Writer = new h__SWriter(&DefaultSMPTEDict()); @@ -1541,7 +1605,7 @@ ASDCP::JP2K::MXFSWriter::OpenWrite(const std::string& filename, const WriterInfo m_Writer->m_Info = Info; - Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000_S, HeaderSize); + Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000_S, HeaderSize, overwrite); if ( ASDCP_SUCCESS(result) ) { @@ -1611,6 +1675,15 @@ ASDCP::JP2K::MXFSWriter::WriteFrame(const FrameBuffer& FrameBuf, StereoscopicPha return m_Writer->WriteFrame(FrameBuf, phase, Ctx, HMAC); } +ASDCP::Result_t +ASDCP::JP2K::MXFSWriter::FakeWriteFrame(int size, StereoscopicPhase_t phase) +{ + if ( m_Writer.empty() ) + return RESULT_INIT; + + return m_Writer->FakeWriteFrame(size, phase); +} + // Closes the MXF file, writing the index and other closing information. ASDCP::Result_t ASDCP::JP2K::MXFSWriter::Finalize() @@ -1621,6 +1694,12 @@ ASDCP::JP2K::MXFSWriter::Finalize() return m_Writer->Finalize(); } +ui64_t +ASDCP::JP2K::MXFSWriter::Tell() const +{ + return m_Writer->m_File.TellPosition(); +} + // // end AS_DCP_JP2K.cpp // diff --git a/src/AS_DCP_internal.h b/src/AS_DCP_internal.h index 6d8688f..31c141c 100755 --- a/src/AS_DCP_internal.h +++ b/src/AS_DCP_internal.h @@ -966,6 +966,7 @@ extern MXF::RIP *g_RIP; Result_t WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf,const byte_t* EssenceUL, const ui32_t& MinEssenceElementBerLength, AESEncContext* Ctx, HMACContext* HMAC); + Result_t FakeWriteEKLVPacket(int size); Result_t WriteASDCPFooter(); }; diff --git a/src/KM_fileio.cpp b/src/KM_fileio.cpp index 2d3fd27..3ccb3f6 100644 --- a/src/KM_fileio.cpp +++ b/src/KM_fileio.cpp @@ -1010,6 +1010,48 @@ Kumu::FileWriter::OpenWrite(const std::string& filename) return Kumu::RESULT_OK; } + +/** @param filename File name (UTF-8 encoded) */ +Kumu::Result_t +Kumu::FileWriter::OpenModify(const std::string& filename) +{ + m_Filename = filename; + + // suppress popup window on error + UINT prev = ::SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX); + + int const wn = MultiByteToWideChar(CP_UTF8, 0, filename.c_str(), -1, 0, 0); + wchar_t* buffer = new wchar_t[wn]; + if (MultiByteToWideChar(CP_UTF8, 0, filename.c_str(), -1, buffer, wn) == 0) { + delete[] buffer; + return Kumu::RESULT_FAIL; + } + + m_Handle = ::CreateFileW(buffer, + (GENERIC_WRITE|GENERIC_READ), // open for reading + FILE_SHARE_READ, // share for reading + NULL, // no security + OPEN_ALWAYS, // don't truncate existing + FILE_ATTRIBUTE_NORMAL, // normal file + NULL // no template file + ); + + delete[] buffer; + HRESULT const last_error = GetLastError(); + + ::SetErrorMode(prev); + + if (m_Handle == INVALID_HANDLE_VALUE) + { + DefaultLogSink().Error("CreateFileW failed: %lu\n", last_error); + return Kumu::RESULT_FILEOPEN; + } + + m_IOVec = new h__iovec; + return Kumu::RESULT_OK; +} + + // Kumu::Result_t Kumu::FileWriter::Writev(ui32_t* bytes_written) diff --git a/src/h__Writer.cpp b/src/h__Writer.cpp index b36af64..c7aa8ab 100755 --- a/src/h__Writer.cpp +++ b/src/h__Writer.cpp @@ -327,6 +327,15 @@ ASDCP::h__ASDCPWriter::WriteEKLVPacket(const ASDCP::FrameBuffer& FrameBuf,const Ctx, HMAC); } +Result_t +ASDCP::h__ASDCPWriter::FakeWriteEKLVPacket(int size) +{ + m_StreamOffset += size; + m_File.Seek(size, Kumu::SP_POS); + + return RESULT_OK; +} + // standard method of writing the header and footer of a completed MXF file // Result_t