// encrypted headers.
Result_t OpenReadFrame(const char* filename, FrameBuffer&) const;
+ Result_t OpenReadFrame(const unsigned char * data, unsigned int size, FrameBuffer&) const;
+
// Fill a PictureDescriptor struct with the values from the file's codestream.
// Returns RESULT_INIT if the file is not open.
Result_t FillPictureDescriptor(PictureDescriptor&) const;
return result;
}
+
+ Result_t OpenReadFrame(const unsigned char * data, unsigned int size, FrameBuffer& FB)
+ {
+ if ( FB.Capacity() < size )
+ {
+ DefaultLogSink().Error("FrameBuf.Capacity: %u frame length: %u\n", FB.Capacity(), (ui32_t) size);
+ return RESULT_SMALLBUF;
+ }
+
+ memcpy (FB.Data(), data, size);
+ FB.Size(size);
+
+ byte_t start_of_data = 0; // out param
+ const Result_t result = ParseMetadataIntoDesc(FB, m_PDesc, &start_of_data);
+
+ if ( ASDCP_SUCCESS(result) )
+ FB.PlaintextOffset(start_of_data);
+
+ return result;
+ }
};
ASDCP::Result_t
return m_Parser->OpenReadFrame(filename, FB);
}
+// Opens the stream for reading, parses enough data to provide a complete
+// set of stream metadata for the MXFWriter below.
+ASDCP::Result_t
+ASDCP::JP2K::CodestreamParser::OpenReadFrame(const unsigned char* data, unsigned int size, FrameBuffer& FB) const
+{
+ const_cast<ASDCP::JP2K::CodestreamParser*>(this)->m_Parser = new h__CodestreamParser;
+ return m_Parser->OpenReadFrame(data, size, FB);
+}
+
//
ASDCP::Result_t
ASDCP::JP2K::CodestreamParser::FillPictureDescriptor(PictureDescriptor& PDesc) const
return _uuid;
}
+ boost::filesystem::path path () const;
+
virtual bool equals (boost::shared_ptr<const Asset> other, EqualityOptions opt, std::list<std::string>& notes) const = 0;
protected:
- friend class PictureAsset;
- friend class SoundAsset;
std::string digest () const;
- boost::filesystem::path path () const;
/** Directory that our MXF or XML file is in */
std::string _directory;
}
void
-MXFAsset::fill_writer_info (ASDCP::WriterInfo* writer_info) const
+MXFAsset::fill_writer_info (ASDCP::WriterInfo* writer_info, string uuid)
{
writer_info->ProductVersion = Metadata::instance()->product_version;
writer_info->CompanyName = Metadata::instance()->company_name;
writer_info->LabelSetType = ASDCP::LS_MXF_SMPTE;
unsigned int c;
- Kumu::hex2bin (_uuid.c_str(), writer_info->AssetUUID, Kumu::UUID_Length, &c);
+ Kumu::hex2bin (uuid.c_str(), writer_info->AssetUUID, Kumu::UUID_Length, &c);
assert (c == Kumu::UUID_Length);
}
virtual bool equals (boost::shared_ptr<const Asset> other, EqualityOptions opt, std::list<std::string>& notes) const;
int intrinsic_duration () const;
+ int frames_per_second () const {
+ return _fps;
+ }
+
+ void set_intrinsic_duration (int d) {
+ _intrinsic_duration = d;
+ }
-protected:
/** Fill in a ADSCP::WriteInfo struct.
* @param w struct to fill in.
+ * @param uuid uuid to use.
*/
- void fill_writer_info (ASDCP::WriterInfo* w) const;
+ static void fill_writer_info (ASDCP::WriterInfo* w, std::string uuid);
+
+protected:
/** Signal to emit to report progress */
boost::signals2::signal<void (float)>* _progress;
using boost::lexical_cast;
using namespace libdcp;
-PictureAsset::PictureAsset (string directory, string mxf_name, boost::signals2::signal<void (float)>* progress, int fps, int intrinsic_duration)
+PictureAsset::PictureAsset (string directory, string mxf_name, boost::signals2::signal<void (float)>* progress, int fps, int intrinsic_duration, Size size)
: MXFAsset (directory, mxf_name, progress, fps, intrinsic_duration)
+ , _size (size)
{
}
int fps,
int intrinsic_duration,
Size size)
- : PictureAsset (directory, mxf_name, progress, fps, intrinsic_duration)
+ : PictureAsset (directory, mxf_name, progress, fps, intrinsic_duration, size)
{
- _size = size;
construct (get_path);
}
int fps,
int intrinsic_duration,
Size size)
- : PictureAsset (directory, mxf_name, progress, fps, intrinsic_duration)
+ : PictureAsset (directory, mxf_name, progress, fps, intrinsic_duration, size)
{
- _size = size;
construct (boost::bind (&MonoPictureAsset::path_from_list, this, _1, files));
}
+MonoPictureAsset::MonoPictureAsset (string directory, string mxf_name, int fps, Size size)
+ : PictureAsset (directory, mxf_name, 0, fps, 0, size)
+{
+
+}
+
MonoPictureAsset::MonoPictureAsset (string directory, string mxf_name, int fps, int intrinsic_duration)
- : PictureAsset (directory, mxf_name, 0, fps, intrinsic_duration)
+ : PictureAsset (directory, mxf_name, 0, fps, intrinsic_duration, Size (0, 0))
{
ASDCP::JP2K::MXFReader reader;
if (ASDCP_FAILURE (reader.OpenRead (path().string().c_str()))) {
picture_desc.EditRate = ASDCP::Rational (_fps, 1);
ASDCP::WriterInfo writer_info;
- fill_writer_info (&writer_info);
+ fill_writer_info (&writer_info, _uuid);
ASDCP::JP2K::MXFWriter mxf_writer;
if (ASDCP_FAILURE (mxf_writer.OpenWrite (path().string().c_str(), writer_info, picture_desc))) {
StereoPictureAsset::StereoPictureAsset (string directory, string mxf_name, int fps, int intrinsic_duration)
- : PictureAsset (directory, mxf_name, 0, fps, intrinsic_duration)
+ : PictureAsset (directory, mxf_name, 0, fps, intrinsic_duration, Size (0, 0))
{
ASDCP::JP2K::MXFSReader reader;
if (ASDCP_FAILURE (reader.OpenRead (path().string().c_str()))) {
{
return shared_ptr<const StereoPictureFrame> (new StereoPictureFrame (path().string(), n + _entry_point));
}
+
+shared_ptr<MonoPictureAssetWriter>
+MonoPictureAsset::start_write ()
+{
+ /* XXX: can't we use a shared_ptr here? */
+ return shared_ptr<MonoPictureAssetWriter> (new MonoPictureAssetWriter (this));
+}
+
+MonoPictureAssetWriter::MonoPictureAssetWriter (MonoPictureAsset* a)
+ : _frame_buffer (4 * Kumu::Megabyte)
+ , _asset (a)
+ , _frames_written (0)
+ , _finalized (false)
+{
+
+}
+
+void
+MonoPictureAssetWriter::write (uint8_t* data, int size)
+{
+ if (ASDCP_FAILURE (_j2k_parser.OpenReadFrame (data, size, _frame_buffer))) {
+ throw MiscError ("could not parse J2K frame");
+ }
+
+ if (_frames_written == 0) {
+ _j2k_parser.FillPictureDescriptor (_picture_descriptor);
+ _picture_descriptor.EditRate = ASDCP::Rational (_asset->frames_per_second(), 1);
+
+ MXFAsset::fill_writer_info (&_writer_info, _asset->uuid());
+
+ if (ASDCP_FAILURE (_mxf_writer.OpenWrite (_asset->path().c_str(), _writer_info, _picture_descriptor))) {
+ throw MXFFileError ("could not open MXF file for writing", _asset->path().string());
+ }
+ }
+
+ if (ASDCP_FAILURE (_mxf_writer.WriteFrame (_frame_buffer, 0, 0))) {
+ throw MiscError ("error in writing video MXF");
+ }
+
+ _frames_written++;
+}
+
+void
+MonoPictureAssetWriter::finalize ()
+{
+ if (ASDCP_FAILURE (_mxf_writer.Finalize())) {
+ throw MiscError ("error in finalizing video MXF");
+ }
+
+ _finalized = true;
+ _asset->set_intrinsic_duration (_frames_written);
+}
+
+MonoPictureAssetWriter::~MonoPictureAssetWriter ()
+{
+ assert (_finalized);
+}
*/
#include <openjpeg.h>
+#include "AS_DCP.h"
#include "mxf_asset.h"
#include "util.h"
class PictureAsset : public MXFAsset
{
public:
- PictureAsset (std::string directory, std::string mxf_name, boost::signals2::signal<void (float)>* progress, int fps, int intrinsic_duration);
+ PictureAsset (std::string directory, std::string mxf_name, boost::signals2::signal<void (float)>* progress, int fps, int intrinsic_duration, Size size);
/** Write details of this asset to a CPL stream.
* @param s Stream.
Size _size;
};
+class MonoPictureAsset;
+
+class MonoPictureAssetWriter
+{
+public:
+ ~MonoPictureAssetWriter ();
+
+ void write (uint8_t* data, int size);
+ void finalize ();
+
+private:
+ friend class MonoPictureAsset;
+
+ MonoPictureAssetWriter (MonoPictureAsset *);
+
+ ASDCP::JP2K::CodestreamParser _j2k_parser;
+ ASDCP::JP2K::FrameBuffer _frame_buffer;
+ ASDCP::JP2K::MXFWriter _mxf_writer;
+ ASDCP::WriterInfo _writer_info;
+ ASDCP::JP2K::PictureDescriptor _picture_descriptor;
+ MonoPictureAsset* _asset;
+ int _frames_written;
+ bool _finalized;
+};
+
/** A 2D (monoscopic) picture asset */
class MonoPictureAsset : public PictureAsset
{
Size size
);
+ MonoPictureAsset (
+ std::string directory,
+ std::string mxf_name,
+ int fps,
+ Size size
+ );
+
+ boost::shared_ptr<MonoPictureAssetWriter> start_write ();
+
MonoPictureAsset (std::string directory, std::string mxf_name, int fps, int intrinsic_duration);
boost::shared_ptr<const MonoPictureFrame> get_frame (int n) const;
frame_buffer.Size (ASDCP::PCM::CalcFrameBufferSize (audio_desc));
ASDCP::WriterInfo writer_info;
- fill_writer_info (&writer_info);
+ fill_writer_info (&writer_info, _uuid);
ASDCP::PCM::MXFWriter mxf_writer;
if (ASDCP_FAILURE (mxf_writer.OpenWrite (path().string().c_str(), writer_info, audio_desc))) {