per second.
*/
- auto picture_asset = std::make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ auto picture_asset = std::make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
/* Start off a write to it */
- auto picture_writer = picture_asset->start_write("DCP/picture.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto picture_writer = picture_asset->start_write("DCP/picture.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
/* Write 24 frames of the same JPEG2000 file */
dcp::ArrayData picture("examples/help.j2c");
auto assets = dcp.assets();
std::cout << "DCP has " << assets.size() << " assets.\n";
for (auto i: assets) {
- if (std::dynamic_pointer_cast<dcp::MonoPictureAsset>(i)) {
+ if (std::dynamic_pointer_cast<dcp::MonoJ2KPictureAsset>(i)) {
std::cout << "2D picture\n";
- } else if (std::dynamic_pointer_cast<dcp::StereoPictureAsset>(i)) {
+ } else if (std::dynamic_pointer_cast<dcp::StereoJ2KPictureAsset>(i)) {
std::cout << "3D picture\n";
} else if (std::dynamic_pointer_cast<dcp::SoundAsset>(i)) {
std::cout << "Sound\n";
auto cpl = dcp.cpls().front();
/* Get the picture asset in the first reel */
- auto picture_asset = std::dynamic_pointer_cast<dcp::MonoPictureAsset>(
+ auto picture_asset = std::dynamic_pointer_cast<dcp::MonoJ2KPictureAsset>(
cpl->reels()[0]->main_picture()->asset()
);
throw ReadError ("MPEG2 video essences are not supported");
case ASDCP::ESS_JPEG_2000:
try {
- return make_shared<MonoPictureAsset>(path);
+ return make_shared<MonoJ2KPictureAsset>(path);
} catch (dcp::MXFFileError& e) {
if (ignore_incorrect_picture_mxf_type && e.number() == ASDCP::RESULT_SFORMAT) {
/* Tried to load it as mono but the error says it's stereo; try that instead */
- auto stereo = make_shared<StereoPictureAsset>(path);
+ auto stereo = make_shared<StereoJ2KPictureAsset>(path);
if (stereo && found_threed_marked_as_twod) {
*found_threed_marked_as_twod = true;
}
case ASDCP::ESS_PCM_24b_96k:
return make_shared<SoundAsset>(path);
case ASDCP::ESS_JPEG_2000_S:
- return make_shared<StereoPictureAsset>(path);
+ return make_shared<StereoJ2KPictureAsset>(path);
case ASDCP::ESS_TIMED_TEXT:
return make_shared<SMPTESubtitleAsset>(path);
case ASDCP::ESS_DCDATA_DOLBY_ATMOS:
class AtmosAsset;
-class MonoPictureAsset;
+class MonoJ2KPictureAsset;
class SoundAsset;
-class StereoPictureAsset;
+class StereoJ2KPictureAsset;
template <class R, class F>
private:
friend class AtmosAsset;
- friend class MonoPictureAsset;
+ friend class MonoJ2KPictureAsset;
friend class SoundAsset;
- friend class StereoPictureAsset;
+ friend class StereoJ2KPictureAsset;
explicit AssetReader (Asset const * asset, boost::optional<Key> key, Standard standard)
: _crypto_context (new DecryptionContext(key, standard))
other_assets.push_back (make_shared<InteropSubtitleAsset>(path));
}
} else if (
- *pkl_type == remove_parameters(PictureAsset::static_pkl_type(standard)) ||
+ *pkl_type == remove_parameters(J2KPictureAsset::static_pkl_type(standard)) ||
*pkl_type == remove_parameters(SoundAsset::static_pkl_type(standard)) ||
*pkl_type == remove_parameters(AtmosAsset::static_pkl_type(standard)) ||
*pkl_type == remove_parameters(SMPTESubtitleAsset::static_pkl_type(standard))
/** @file src/picture_asset.cc
- * @brief PictureAsset class
+ * @brief J2KPictureAsset class
*/
using namespace dcp;
-PictureAsset::PictureAsset (boost::filesystem::path file)
+J2KPictureAsset::J2KPictureAsset (boost::filesystem::path file)
: Asset (file)
{
}
-PictureAsset::PictureAsset (Fraction edit_rate, Standard standard)
+J2KPictureAsset::J2KPictureAsset (Fraction edit_rate, Standard standard)
: MXF (standard)
, _edit_rate (edit_rate)
{
void
-PictureAsset::read_picture_descriptor (ASDCP::JP2K::PictureDescriptor const & desc)
+J2KPictureAsset::read_picture_descriptor (ASDCP::JP2K::PictureDescriptor const & desc)
{
_size.width = desc.StoredWidth;
_size.height = desc.StoredHeight;
bool
-PictureAsset::descriptor_equals (
+J2KPictureAsset::descriptor_equals (
ASDCP::JP2K::PictureDescriptor const & a, ASDCP::JP2K::PictureDescriptor const & b, NoteHandler note
) const
{
bool
-PictureAsset::frame_buffer_equals (
+J2KPictureAsset::frame_buffer_equals (
int frame, EqualityOptions const& opt, NoteHandler note,
uint8_t const * data_A, unsigned int size_A, uint8_t const * data_B, unsigned int size_B
) const
string
-PictureAsset::static_pkl_type (Standard standard)
+J2KPictureAsset::static_pkl_type (Standard standard)
{
switch (standard) {
case Standard::INTEROP:
string
-PictureAsset::pkl_type (Standard standard) const
+J2KPictureAsset::pkl_type (Standard standard) const
{
return static_pkl_type (standard);
}
/** @file src/picture_asset.h
- * @brief PictureAsset class
+ * @brief J2KPictureAsset class
*/
namespace dcp {
-class MonoPictureFrame;
-class StereoPictureFrame;
-class PictureAssetWriter;
+class MonoJ2KPictureFrame;
+class StereoJ2KPictureFrame;
+class J2KPictureAssetWriter;
-/** @class PictureAsset
+/** @class J2KPictureAsset
* @brief An asset made up of JPEG2000 data
*/
-class PictureAsset : public Asset, public MXF
+class J2KPictureAsset : public Asset, public MXF
{
public:
- /** Load a PictureAsset from a file */
- explicit PictureAsset (boost::filesystem::path file);
+ /** Load a J2KPictureAsset from a file */
+ explicit J2KPictureAsset (boost::filesystem::path file);
- /** Create a new PictureAsset with a given edit rate and standard */
- PictureAsset(Fraction edit_rate, Standard standard);
+ /** Create a new J2KPictureAsset with a given edit rate and standard */
+ J2KPictureAsset (Fraction edit_rate, Standard standard);
enum class Behaviour {
OVERWRITE_EXISTING,
MAKE_NEW
};
- virtual std::shared_ptr<PictureAssetWriter> start_write (
+ virtual std::shared_ptr<J2KPictureAssetWriter> start_write (
boost::filesystem::path file,
Behaviour behaviour
) = 0;
static std::string static_pkl_type (Standard standard);
protected:
- friend class MonoPictureAssetWriter;
- friend class StereoPictureAssetWriter;
+ friend class MonoJ2KPictureAssetWriter;
+ friend class StereoJ2KPictureAssetWriter;
bool frame_buffer_equals (
int frame, EqualityOptions const& opt, NoteHandler note,
/** @file src/picture_asset_writer.cc
- * @brief PictureAssetWriter and FrameInfo classes
+ * @brief J2KPictureAssetWriter and FrameInfo classes
*/
using namespace dcp;
-PictureAssetWriter::PictureAssetWriter (PictureAsset* asset, boost::filesystem::path file, bool overwrite)
+J2KPictureAssetWriter::J2KPictureAssetWriter (J2KPictureAsset* asset, boost::filesystem::path file, bool overwrite)
: AssetWriter (asset, file)
, _picture_asset (asset)
, _overwrite (overwrite)
FrameInfo
-PictureAssetWriter::write (Data const& data)
+J2KPictureAssetWriter::write (Data const& data)
{
return write (data.data(), data.size());
}
/** @file src/picture_asset_writer.h
- * @brief PictureAssetWriter and FrameInfo classes.
+ * @brief J2KPictureAssetWriter and FrameInfo classes.
*/
class Data;
-class PictureAsset;
+class J2KPictureAsset;
/** @class FrameInfo
};
-/** @class PictureAssetWriter
+/** @class J2KPictureAssetWriter
* @brief Parent class for classes which write picture assets.
*/
-class PictureAssetWriter : public AssetWriter
+class J2KPictureAssetWriter : public AssetWriter
{
public:
virtual FrameInfo write (uint8_t const *, int) = 0;
protected:
template <class P, class Q>
- friend void start (PictureAssetWriter *, std::shared_ptr<P>, Q *, uint8_t const *, int);
+ friend void start (
J2KPictureAssetWriter *, std::shared_ptr<P>, Q *, uint8_t const *, int);
- PictureAssetWriter (PictureAsset *, boost::filesystem::path, bool);
+ J2KPictureAssetWriter (J2KPictureAsset *, boost::filesystem::path, bool);
- PictureAsset* _picture_asset = nullptr;
+ J2KPictureAsset* _picture_asset = nullptr;
bool _overwrite = false;
};
/** @file src/picture_asset_writer_common.cc
- * @brief Common parts of PictureAssetWriter
+ * @brief Common parts of J2KPictureAssetWriter
*/
template <class P, class Q>
-void dcp::start (PictureAssetWriter* writer, shared_ptr<P> state, Q* asset, uint8_t const * data, int size)
+void dcp::start (
J2KPictureAssetWriter* writer, shared_ptr<P> state, Q* asset, uint8_t const * data, int size)
{
asset->set_file (writer->_file);
/** @file src/mono_picture_asset.cc
- * @brief MonoPictureAsset class
+ * @brief MonoJ2KPictureAsset class
*/
using namespace dcp;
-MonoPictureAsset::MonoPictureAsset (boost::filesystem::path file)
- : PictureAsset (file)
+MonoJ2KPictureAsset::MonoJ2KPictureAsset (boost::filesystem::path file)
+ : J2KPictureAsset (file)
{
Kumu::FileReaderFactory factory;
ASDCP::JP2K::MXFReader reader(factory);
}
-MonoPictureAsset::MonoPictureAsset (Fraction edit_rate, Standard standard)
- : PictureAsset (edit_rate, standard)
+MonoJ2KPictureAsset::MonoJ2KPictureAsset (Fraction edit_rate, Standard standard)
+ : J2KPictureAsset (edit_rate, standard)
{
}
bool
-MonoPictureAsset::equals(shared_ptr<const Asset> other, EqualityOptions const& opt, NoteHandler note) const
+MonoJ2KPictureAsset::equals(shared_ptr<const Asset> other, EqualityOptions const& opt, NoteHandler note) const
{
- if (!dynamic_pointer_cast<const MonoPictureAsset>(other)) {
+ if (!dynamic_pointer_cast<const MonoJ2KPictureAsset>(other)) {
return false;
}
return false;
}
- auto other_picture = dynamic_pointer_cast<const MonoPictureAsset> (other);
+ auto other_picture = dynamic_pointer_cast<const MonoJ2KPictureAsset> (other);
DCP_ASSERT (other_picture);
bool result = true;
}
-shared_ptr<PictureAssetWriter>
-MonoPictureAsset::start_write(boost::filesystem::path file, Behaviour behaviour)
+shared_ptr<J2KPictureAssetWriter>
+MonoJ2KPictureAsset::start_write(boost::filesystem::path file, Behaviour behaviour)
{
- /* Can't use make_shared here as the MonoPictureAssetWriter constructor is private */
- return shared_ptr<MonoPictureAssetWriter>(new MonoPictureAssetWriter(this, file, behaviour == Behaviour::OVERWRITE_EXISTING));
+ /* Can't use make_shared here as the MonoJ2KPictureAssetWriter constructor is private */
+ return shared_ptr<MonoJ2KPictureAssetWriter>(new MonoJ2KPictureAssetWriter(this, file, behaviour == Behaviour::OVERWRITE_EXISTING));
}
-shared_ptr<MonoPictureAssetReader>
-MonoPictureAsset::start_read () const
+shared_ptr<MonoJ2KPictureAssetReader>
+MonoJ2KPictureAsset::start_read () const
{
- /* Can't use make_shared here as the MonoPictureAssetReader constructor is private */
- return shared_ptr<MonoPictureAssetReader>(new MonoPictureAssetReader(this, key(), standard()));
+ /* Can't use make_shared here as the MonoJ2KPictureAssetReader constructor is private */
+ return shared_ptr<MonoJ2KPictureAssetReader>(new MonoJ2KPictureAssetReader(this, key(), standard()));
}
string
-MonoPictureAsset::cpl_node_name () const
+MonoJ2KPictureAsset::cpl_node_name () const
{
return "MainPicture";
}
/** @file src/mono_picture_asset.cc
- * @brief MonoPictureAsset class
+ * @brief MonoJ2KPictureAsset class
*/
namespace dcp {
-class MonoPictureAssetWriter;
+class MonoJ2KPictureAssetWriter;
-/** @class MonoPictureAsset
+/** @class MonoJ2KPictureAsset
* @brief A 2D (monoscopic) picture asset
*/
-class MonoPictureAsset : public PictureAsset
+class MonoJ2KPictureAsset : public J2KPictureAsset
{
public:
- /** Create a MonoPictureAsset by reading a file.
+ /** Create a MonoJ2KPictureAsset by reading a file.
* @param file Asset file to read.
*/
- explicit MonoPictureAsset (boost::filesystem::path file);
+ explicit MonoJ2KPictureAsset (boost::filesystem::path file);
- /** Create a MonoPictureAsset with a given edit rate.
+ /** Create a MonoJ2KPictureAsset with a given edit rate.
* @param edit_rate Edit rate (i.e. frame rate) in frames per second.
* @param standard DCP standard (INTEROP or SMPTE).
*/
- MonoPictureAsset(Fraction edit_rate, Standard standard);
+ MonoJ2KPictureAsset(Fraction edit_rate, Standard standard);
- /** Start a progressive write to a MonoPictureAsset.
+ /** Start a progressive write to a MonoJ2KPictureAsset.
* @path file File to write to.
* @path behaviour OVERWRITE_EXISTING to overwrite and potentially add to an existing file
* (after a write previously failed), MAKE_NEW to create a new file.
* If in doubt, use MAKE_NEW here.
*/
- std::shared_ptr<PictureAssetWriter> start_write(boost::filesystem::path file, Behaviour behaviour) override;
- std::shared_ptr<MonoPictureAssetReader> start_read () const;
+ std::shared_ptr<J2KPictureAssetWriter> start_write(boost::filesystem::path file, Behaviour behaviour) override;
+ std::shared_ptr<MonoJ2KPictureAssetReader> start_read () const;
bool equals (
std::shared_ptr<const Asset> other,
/** @file src/mono_picture_asset_reader.h
- * @brief MonoPictureAssetReader typedef
+ * @brief MonoJ2KPictureAssetReader typedef
*/
namespace dcp {
-typedef AssetReader<ASDCP::JP2K::MXFReader, MonoPictureFrame> MonoPictureAssetReader;
+typedef AssetReader<ASDCP::JP2K::MXFReader, MonoJ2KPictureFrame> MonoJ2KPictureAssetReader;
}
/** @file src/mono_picture_asset_writer.cc
- * @brief MonoPictureAssetWriter class
+ * @brief MonoJ2KPictureAssetWriter class
*/
using namespace dcp;
-struct MonoPictureAssetWriter::ASDCPState : public ASDCPStateBase
+struct MonoJ2KPictureAssetWriter::ASDCPState : public ASDCPStateBase
{
ASDCP::JP2K::MXFWriter mxf_writer;
};
/** @param a Asset to write to. `a' must not be deleted while
* this writer class still exists, or bad things will happen.
*/
-MonoPictureAssetWriter::MonoPictureAssetWriter (PictureAsset* asset, boost::filesystem::path file, bool overwrite)
- : PictureAssetWriter (asset, file, overwrite)
- , _state (new MonoPictureAssetWriter::ASDCPState)
+MonoJ2KPictureAssetWriter::MonoJ2KPictureAssetWriter (J2KPictureAsset* asset, boost::filesystem::path file, bool overwrite)
+ : J2KPictureAssetWriter (asset, file, overwrite)
+ , _state (new MonoJ2KPictureAssetWriter::ASDCPState)
{
}
-MonoPictureAssetWriter::~MonoPictureAssetWriter()
+MonoJ2KPictureAssetWriter::~MonoJ2KPictureAssetWriter()
{
try {
/* Last-resort finalization to close the file, at least */
void
-MonoPictureAssetWriter::start (uint8_t const * data, int size)
+MonoJ2KPictureAssetWriter::start (uint8_t const * data, int size)
{
dcp::start (this, _state, _picture_asset, data, size);
_picture_asset->set_frame_rate (_picture_asset->edit_rate());
FrameInfo
-MonoPictureAssetWriter::write (uint8_t const * data, int size)
+MonoJ2KPictureAssetWriter::write (uint8_t const * data, int size)
{
DCP_ASSERT (!_finalized);
void
-MonoPictureAssetWriter::fake_write (int size)
+MonoJ2KPictureAssetWriter::fake_write (int size)
{
DCP_ASSERT (_started);
DCP_ASSERT (!_finalized);
bool
-MonoPictureAssetWriter::finalize ()
+MonoJ2KPictureAssetWriter::finalize ()
{
if (_started) {
auto r = _state->mxf_writer.Finalize();
}
_picture_asset->_intrinsic_duration = _frames_written;
- return PictureAssetWriter::finalize ();
+ return J2KPictureAssetWriter::finalize ();
}
/** @file src/mono_picture_asset_writer.h
- * @brief MonoPictureAssetWriter class
+ * @brief MonoJ2KPictureAssetWriter class
*/
namespace dcp {
-/** @class MonoPictureAssetWriter
- * @brief A helper class for writing to MonoPictureAssets
+/** @class MonoJ2KPictureAssetWriter
+ * @brief A helper class for writing to MonoJ2KPictureAssets
*
- * Objects of this class can only be created with MonoPictureAsset::start_write().
+ * Objects of this class can only be created with MonoJ2KPictureAsset::start_write().
*
- * Frames can be written to the MonoPictureAsset by calling write() with a JPEG2000 image
+ * Frames can be written to the MonoJ2KPictureAsset by calling write() with a JPEG2000 image
* (a verbatim .j2c file). finalize() should be called after the last frame has been written,
* but if it is not, it will be called by the destructor (though in that case any error
* during finalization will be ignored).
*/
-class MonoPictureAssetWriter : public PictureAssetWriter
+class MonoJ2KPictureAssetWriter : public J2KPictureAssetWriter
{
public:
- ~MonoPictureAssetWriter();
+ ~MonoJ2KPictureAssetWriter();
FrameInfo write (uint8_t const *, int) override;
void fake_write (int size) override;
bool finalize () override;
private:
- friend class MonoPictureAsset;
+ friend class MonoJ2KPictureAsset;
- MonoPictureAssetWriter (PictureAsset* a, boost::filesystem::path file, bool);
+ MonoJ2KPictureAssetWriter (J2KPictureAsset* a, boost::filesystem::path file, bool);
void start (uint8_t const *, int);
/** @file src/mono_picture_frame.cc
- * @brief MonoPictureFrame class
+ * @brief MonoJ2KPictureFrame class
*/
using namespace dcp;
-MonoPictureFrame::MonoPictureFrame (boost::filesystem::path path)
+MonoJ2KPictureFrame::MonoJ2KPictureFrame (boost::filesystem::path path)
{
auto const size = filesystem::file_size(path);
_buffer.reset(new ASDCP::JP2K::FrameBuffer(size));
* @param c Context for decryption, or 0.
* @param check_hmac true to check the HMAC and give an error if it is not as expected.
*/
-MonoPictureFrame::MonoPictureFrame (ASDCP::JP2K::MXFReader* reader, int n, shared_ptr<DecryptionContext> c, bool check_hmac)
+MonoJ2KPictureFrame::MonoJ2KPictureFrame (ASDCP::JP2K::MXFReader* reader, int n, shared_ptr<DecryptionContext> c, bool check_hmac)
{
/* XXX: unfortunate guesswork on this buffer size */
_buffer = make_shared<ASDCP::JP2K::FrameBuffer>(4 * Kumu::Megabyte);
}
-MonoPictureFrame::MonoPictureFrame (uint8_t const * data, int size)
+MonoJ2KPictureFrame::MonoJ2KPictureFrame (uint8_t const * data, int size)
{
_buffer = make_shared<ASDCP::JP2K::FrameBuffer>(size);
_buffer->Size (size);
uint8_t const *
-MonoPictureFrame::data () const
+MonoJ2KPictureFrame::data () const
{
return _buffer->RoData ();
}
uint8_t *
-MonoPictureFrame::data ()
+MonoJ2KPictureFrame::data ()
{
return _buffer->Data ();
}
int
-MonoPictureFrame::size () const
+MonoJ2KPictureFrame::size () const
{
return _buffer->Size ();
}
shared_ptr<OpenJPEGImage>
-MonoPictureFrame::xyz_image (int reduce) const
+MonoJ2KPictureFrame::xyz_image (int reduce) const
{
return decompress_j2k (const_cast<uint8_t*>(_buffer->RoData()), _buffer->Size(), reduce);
}
/** @file src/mono_picture_frame.h
- * @brief MonoPictureFrame class
+ * @brief MonoJ2KPictureFrame class
*/
class OpenJPEGImage;
-/** @class MonoPictureFrame
+/** @class MonoJ2KPictureFrame
* @brief A single frame of a 2D (monoscopic) picture asset
*/
-class MonoPictureFrame : public Data
+class MonoJ2KPictureFrame : public Data
{
public:
/** Make a picture frame from a JPEG2000 file.
* @param path Path to JPEG2000 file.
*/
- explicit MonoPictureFrame (boost::filesystem::path path);
- MonoPictureFrame (uint8_t const * data, int size);
+ explicit MonoJ2KPictureFrame (boost::filesystem::path path);
+ MonoJ2KPictureFrame (uint8_t const * data, int size);
- MonoPictureFrame (MonoPictureFrame const&) = delete;
- MonoPictureFrame& operator= (MonoPictureFrame const&) = delete;
+ MonoJ2KPictureFrame (MonoJ2KPictureFrame const&) = delete;
+ MonoJ2KPictureFrame& operator= (MonoJ2KPictureFrame const&) = delete;
/** @param reduce a factor by which to reduce the resolution
* of the image, expressed as a power of two (pass 0 for no
int size () const override;
private:
- /* XXX: this is a bit of a shame, but I tried friend MonoPictureAssetReader and it's
+ /* XXX: this is a bit of a shame, but I tried friend MonoJ2KPictureAssetReader and it's
rejected by some (seemingly older) GCCs.
*/
- friend class AssetReader<ASDCP::JP2K::MXFReader, MonoPictureFrame>;
+ friend class AssetReader<ASDCP::JP2K::MXFReader, MonoJ2KPictureFrame>;
- MonoPictureFrame (ASDCP::JP2K::MXFReader* reader, int n, std::shared_ptr<DecryptionContext>, bool check_hmac);
+ MonoJ2KPictureFrame (ASDCP::JP2K::MXFReader* reader, int n, std::shared_ptr<DecryptionContext>, bool check_hmac);
std::shared_ptr<ASDCP::JP2K::FrameBuffer> _buffer;
};
class MXFMetadata;
-class PictureAssetWriter;
+class J2KPictureAssetWriter;
/** @class MXF
protected:
template <class P, class Q>
- friend void start (PictureAssetWriter* writer, std::shared_ptr<P> state, Q* mxf, uint8_t const * data, int size);
+ friend void start (
J2KPictureAssetWriter* writer, std::shared_ptr<P> state, Q* mxf, uint8_t const * data, int size);
MXF ();
using namespace dcp;
-ReelMonoPictureAsset::ReelMonoPictureAsset (std::shared_ptr<MonoPictureAsset> asset, int64_t entry_point)
+ReelMonoPictureAsset::ReelMonoPictureAsset (std::shared_ptr<MonoJ2KPictureAsset> asset, int64_t entry_point)
: ReelPictureAsset (asset, entry_point)
{
namespace dcp {
-class MonoPictureAsset;
+class MonoJ2KPictureAsset;
/** @class ReelMonoPictureAsset
class ReelMonoPictureAsset : public ReelPictureAsset
{
public:
- ReelMonoPictureAsset (std::shared_ptr<MonoPictureAsset> asset, int64_t entry_point);
+ ReelMonoPictureAsset (std::shared_ptr<MonoJ2KPictureAsset> asset, int64_t entry_point);
explicit ReelMonoPictureAsset (std::shared_ptr<const cxml::Node>);
- /** @return the MonoPictureAsset that this object refers to */
- std::shared_ptr<const MonoPictureAsset> mono_asset () const {
- return asset_of_type<const MonoPictureAsset>();
+ /** @return the MonoJ2KPictureAsset that this object refers to */
+ std::shared_ptr<const MonoJ2KPictureAsset> mono_asset () const {
+ return asset_of_type<const MonoJ2KPictureAsset>();
}
- /** @return the MonoPictureAsset that this object refers to */
- std::shared_ptr<MonoPictureAsset> mono_asset () {
- return asset_of_type<MonoPictureAsset>();
+ /** @return the MonoJ2KPictureAsset that this object refers to */
+ std::shared_ptr<MonoJ2KPictureAsset> mono_asset () {
+ return asset_of_type<MonoJ2KPictureAsset>();
}
private:
using namespace dcp;
-ReelPictureAsset::ReelPictureAsset (shared_ptr<PictureAsset> asset, int64_t entry_point)
+ReelPictureAsset::ReelPictureAsset (shared_ptr<J2KPictureAsset> asset, int64_t entry_point)
: ReelFileAsset (asset, asset->key_id(), asset->id(), asset->edit_rate(), asset->intrinsic_duration(), entry_point)
, _frame_rate (asset->frame_rate ())
, _screen_aspect_ratio (asset->screen_aspect_ratio ())
class ReelPictureAsset : public ReelFileAsset
{
public:
- ReelPictureAsset (std::shared_ptr<PictureAsset> asset, int64_t entry_point);
+ ReelPictureAsset (std::shared_ptr<J2KPictureAsset> asset, int64_t entry_point);
explicit ReelPictureAsset (std::shared_ptr<const cxml::Node>);
- /** @return the PictureAsset that this object refers to */
- std::shared_ptr<const PictureAsset> asset () const {
- return asset_of_type<const PictureAsset>();
+ /** @return the J2KPictureAsset that this object refers to */
+ std::shared_ptr<const J2KPictureAsset> asset () const {
+ return asset_of_type<const J2KPictureAsset>();
}
- /** @return the PictureAsset that this object refers to */
- std::shared_ptr<PictureAsset> asset () {
- return asset_of_type<PictureAsset>();
+ /** @return the J2KPictureAsset that this object refers to */
+ std::shared_ptr<J2KPictureAsset> asset () {
+ return asset_of_type<J2KPictureAsset>();
}
virtual xmlpp::Element* write_to_cpl(xmlpp::Element* node, Standard standard) const override;
using namespace dcp;
-ReelStereoPictureAsset::ReelStereoPictureAsset (std::shared_ptr<StereoPictureAsset> mxf, int64_t entry_point)
+ReelStereoPictureAsset::ReelStereoPictureAsset (std::shared_ptr<StereoJ2KPictureAsset> mxf, int64_t entry_point)
: ReelPictureAsset (mxf, entry_point)
{
namespace dcp {
-class StereoPictureAsset;
+class StereoJ2KPictureAsset;
/** @class ReelStereoPictureAsset
class ReelStereoPictureAsset : public ReelPictureAsset
{
public:
- ReelStereoPictureAsset (std::shared_ptr<StereoPictureAsset> content, int64_t entry_point);
+ ReelStereoPictureAsset (std::shared_ptr<StereoJ2KPictureAsset> content, int64_t entry_point);
explicit ReelStereoPictureAsset (std::shared_ptr<const cxml::Node>);
- /** @return the StereoPictureAsset that this object refers to */
- std::shared_ptr<const StereoPictureAsset> stereo_asset () const {
- return asset_of_type<const StereoPictureAsset>();
+ /** @return the StereoJ2KPictureAsset that this object refers to */
+ std::shared_ptr<const StereoJ2KPictureAsset> stereo_asset () const {
+ return asset_of_type<const StereoJ2KPictureAsset>();
}
- /** @return the StereoPictureAsset that this object refers to */
- std::shared_ptr<StereoPictureAsset> stereo_asset () {
- return asset_of_type<StereoPictureAsset>();
+ /** @return the StereoJ2KPictureAsset that this object refers to */
+ std::shared_ptr<StereoJ2KPictureAsset> stereo_asset () {
+ return asset_of_type<StereoJ2KPictureAsset>();
}
private:
/** @file src/stereo_picture_asset.cc
- * @brief StereoPictureAsset class
+ * @brief StereoJ2KPictureAsset class
*/
using namespace dcp;
-StereoPictureAsset::StereoPictureAsset (boost::filesystem::path file)
- : PictureAsset (file)
+StereoJ2KPictureAsset::StereoJ2KPictureAsset (boost::filesystem::path file)
+ : J2KPictureAsset (file)
{
Kumu::FileReaderFactory factory;
ASDCP::JP2K::MXFSReader reader(factory);
}
-StereoPictureAsset::StereoPictureAsset (Fraction edit_rate, Standard standard)
- : PictureAsset (edit_rate, standard)
+StereoJ2KPictureAsset::StereoJ2KPictureAsset (Fraction edit_rate, Standard standard)
+ : J2KPictureAsset (edit_rate, standard)
{
}
-shared_ptr<PictureAssetWriter>
-StereoPictureAsset::start_write(boost::filesystem::path file, Behaviour behaviour)
+shared_ptr<J2KPictureAssetWriter>
+StereoJ2KPictureAsset::start_write(boost::filesystem::path file, Behaviour behaviour)
{
- return shared_ptr<StereoPictureAssetWriter>(new StereoPictureAssetWriter(this, file, behaviour == Behaviour::OVERWRITE_EXISTING));
+ return shared_ptr<StereoJ2KPictureAssetWriter>(new StereoJ2KPictureAssetWriter(this, file, behaviour == Behaviour::OVERWRITE_EXISTING));
}
-shared_ptr<StereoPictureAssetReader>
-StereoPictureAsset::start_read () const
+shared_ptr<StereoJ2KPictureAssetReader>
+StereoJ2KPictureAsset::start_read () const
{
- return shared_ptr<StereoPictureAssetReader> (new StereoPictureAssetReader(this, key(), standard()));
+ return shared_ptr<StereoJ2KPictureAssetReader> (new StereoJ2KPictureAssetReader(this, key(), standard()));
}
bool
-StereoPictureAsset::equals(shared_ptr<const Asset> other, EqualityOptions const& opt, NoteHandler note) const
+StereoJ2KPictureAsset::equals(shared_ptr<const Asset> other, EqualityOptions const& opt, NoteHandler note) const
{
Kumu::FileReaderFactory factory;
ASDCP::JP2K::MXFSReader reader_A(factory);
return false;
}
- auto other_picture = dynamic_pointer_cast<const StereoPictureAsset> (other);
+ auto other_picture = dynamic_pointer_cast<const StereoJ2KPictureAsset> (other);
DCP_ASSERT (other_picture);
auto reader = start_read ();
bool result = true;
for (int i = 0; i < _intrinsic_duration; ++i) {
- shared_ptr<const StereoPictureFrame> frame_A;
- shared_ptr<const StereoPictureFrame> frame_B;
+ shared_ptr<const StereoJ2KPictureFrame> frame_A;
+ shared_ptr<const StereoJ2KPictureFrame> frame_B;
try {
frame_A = reader->get_frame (i);
frame_B = other_reader->get_frame (i);
/** @file src/stereo_picture_asset.h
- * @brief StereoPictureAsset class
+ * @brief StereoJ2KPictureAsset class
*/
namespace dcp {
-/** @class StereoPictureAsset
+/** @class StereoJ2KPictureAsset
* @brief A 3D (stereoscopic) picture asset
*/
-class StereoPictureAsset : public PictureAsset
+class StereoJ2KPictureAsset : public J2KPictureAsset
{
public:
- explicit StereoPictureAsset (boost::filesystem::path file);
- explicit StereoPictureAsset (Fraction edit_rate, Standard standard);
+ explicit StereoJ2KPictureAsset (boost::filesystem::path file);
+ explicit StereoJ2KPictureAsset (Fraction edit_rate, Standard standard);
- /** Start a progressive write to a StereoPictureAsset */
- std::shared_ptr<PictureAssetWriter> start_write(boost::filesystem::path file, Behaviour behaviour) override;
- std::shared_ptr<StereoPictureAssetReader> start_read () const;
+ /** Start a progressive write to a StereoJ2KPictureAsset */
+ std::shared_ptr<J2KPictureAssetWriter> start_write(boost::filesystem::path file, Behaviour behaviour) override;
+ std::shared_ptr<StereoJ2KPictureAssetReader> start_read () const;
bool equals (
std::shared_ptr<const Asset> other,
/** @file src/stereo_picture_asset_reader.h
- * @brief StereoPictureAssetReader typedef
+ * @brief StereoJ2KPictureAssetReader typedef
*/
namespace dcp {
-typedef AssetReader<ASDCP::JP2K::MXFSReader, StereoPictureFrame> StereoPictureAssetReader;
+typedef AssetReader<ASDCP::JP2K::MXFSReader, StereoJ2KPictureFrame> StereoJ2KPictureAssetReader;
}
/** @file src/stereo_picture_asset_writer.cc
- * @brief StereoPictureAssetWriter class
+ * @brief StereoJ2KPictureAssetWriter class
*/
using namespace dcp;
-struct StereoPictureAssetWriter::ASDCPState : public ASDCPStateBase
+struct StereoJ2KPictureAssetWriter::ASDCPState : public ASDCPStateBase
{
ASDCP::JP2K::MXFSWriter mxf_writer;
};
-StereoPictureAssetWriter::StereoPictureAssetWriter (PictureAsset* mxf, boost::filesystem::path file, bool overwrite)
- : PictureAssetWriter (mxf, file, overwrite)
- , _state (new StereoPictureAssetWriter::ASDCPState)
+StereoJ2KPictureAssetWriter::StereoJ2KPictureAssetWriter (J2KPictureAsset* mxf, boost::filesystem::path file, bool overwrite)
+ : J2KPictureAssetWriter (mxf, file, overwrite)
+ , _state (new StereoJ2KPictureAssetWriter::ASDCPState)
{
}
-StereoPictureAssetWriter::~StereoPictureAssetWriter()
+StereoJ2KPictureAssetWriter::~StereoJ2KPictureAssetWriter()
{
try {
/* Last-resort finalization to close the file, at least */
void
-StereoPictureAssetWriter::start (uint8_t const * data, int size)
+StereoJ2KPictureAssetWriter::start (uint8_t const * data, int size)
{
dcp::start (this, _state, _picture_asset, data, size);
_picture_asset->set_frame_rate (Fraction (_picture_asset->edit_rate().numerator * 2, _picture_asset->edit_rate().denominator));
FrameInfo
-StereoPictureAssetWriter::write (uint8_t const * data, int size)
+StereoJ2KPictureAssetWriter::write (uint8_t const * data, int size)
{
DCP_ASSERT (!_finalized);
void
-StereoPictureAssetWriter::fake_write (int size)
+StereoJ2KPictureAssetWriter::fake_write (int size)
{
DCP_ASSERT (_started);
DCP_ASSERT (!_finalized);
bool
-StereoPictureAssetWriter::finalize ()
+StereoJ2KPictureAssetWriter::finalize ()
{
if (_started) {
auto r = _state->mxf_writer.Finalize();
}
_picture_asset->_intrinsic_duration = _frames_written;
- return PictureAssetWriter::finalize ();
+ return J2KPictureAssetWriter::finalize ();
}
/** @file src/stereo_picture_asset_writer.h
- * @brief StereoPictureAssetWriter class
+ * @brief StereoJ2KPictureAssetWriter class
*/
namespace dcp {
-/** @class StereoPictureAssetWriter
- * @brief A helper class for writing to StereoPictureAssets.
+/** @class StereoJ2KPictureAssetWriter
+ * @brief A helper class for writing to StereoJ2KPictureAssets.
*
- * Objects of this class can only be created with StereoPictureAsset::start_write().
+ * Objects of this class can only be created with StereoJ2KPictureAsset::start_write().
*
- * Frames can be written to the StereoPictureAsset by calling write() with a JPEG2000 image
+ * Frames can be written to the StereoJ2KPictureAsset by calling write() with a JPEG2000 image
* (a verbatim .j2c file). finalize() should be called after the last frame has been written,
* but if it is not, it will be called by the destructor (though in that case any error
* during finalization will be ignored).
*/
-class StereoPictureAssetWriter : public PictureAssetWriter
+class StereoJ2KPictureAssetWriter : public J2KPictureAssetWriter
{
public:
- ~StereoPictureAssetWriter();
+ ~StereoJ2KPictureAssetWriter();
/** Write a frame for one eye. Frames must be written left, then right, then left etc.
* @param data JPEG2000 data.
bool finalize () override;
private:
- friend class StereoPictureAsset;
+ friend class StereoJ2KPictureAsset;
- StereoPictureAssetWriter (PictureAsset *, boost::filesystem::path file, bool);
+ StereoJ2KPictureAssetWriter (J2KPictureAsset *, boost::filesystem::path file, bool);
void start (uint8_t const *, int);
/* do this with an opaque pointer so we don't have to include
/** @file src/stereo_picture_frame.cc
- * @brief StereoPictureFrame class
+ * @brief StereoJ2KPictureFrame class
*/
using namespace dcp;
-StereoPictureFrame::Part::Part (shared_ptr<ASDCP::JP2K::SFrameBuffer> buffer, Eye eye)
+Stereo
J2KPictureFrame::Part::Part (shared_ptr<ASDCP::JP2K::SFrameBuffer> buffer, Eye eye)
: _buffer (buffer)
, _eye (eye)
{
ASDCP::JP2K::FrameBuffer &
-StereoPictureFrame::Part::mono () const
+StereoJ2KPictureFrame::Part::mono () const
{
return _eye == Eye::LEFT ? _buffer->Left : _buffer->Right;
}
uint8_t const *
-StereoPictureFrame::Part::data () const
+StereoJ2KPictureFrame::Part::data () const
{
return mono().RoData();
}
uint8_t *
-StereoPictureFrame::Part::data ()
+StereoJ2KPictureFrame::Part::data ()
{
return mono().Data();
}
int
-StereoPictureFrame::Part::size () const
+StereoJ2KPictureFrame::Part::size () const
{
return mono().Size();
}
* @param n Frame within the asset, not taking EntryPoint into account.
* @param check_hmac true to check the HMAC and give an error if it is not as expected.
*/
-StereoPictureFrame::StereoPictureFrame (ASDCP::JP2K::MXFSReader* reader, int n, shared_ptr<DecryptionContext> c, bool check_hmac)
+StereoJ2KPictureFrame::StereoJ2KPictureFrame (ASDCP::JP2K::MXFSReader* reader, int n, shared_ptr<DecryptionContext> c, bool check_hmac)
{
/* XXX: unfortunate guesswork on this buffer size */
_buffer = make_shared<ASDCP::JP2K::SFrameBuffer>(4 * Kumu::Megabyte);
}
-StereoPictureFrame::StereoPictureFrame ()
+StereoJ2KPictureFrame::StereoJ2KPictureFrame ()
{
_buffer = make_shared<ASDCP::JP2K::SFrameBuffer>(4 * Kumu::Megabyte);
}
* reduction).
*/
shared_ptr<OpenJPEGImage>
-StereoPictureFrame::xyz_image (Eye eye, int reduce) const
+StereoJ2KPictureFrame::xyz_image (Eye eye, int reduce) const
{
switch (eye) {
case Eye::LEFT:
}
-shared_ptr<StereoPictureFrame::Part>
-StereoPictureFrame::right () const
+shared_ptr<StereoJ2KPictureFrame::Part>
+StereoJ2KPictureFrame::right () const
{
return make_shared<Part>(_buffer, Eye::RIGHT);
}
-shared_ptr<StereoPictureFrame::Part>
-StereoPictureFrame::left () const
+shared_ptr<StereoJ2KPictureFrame::Part>
+StereoJ2KPictureFrame::left () const
{
return make_shared<Part>(_buffer, Eye::LEFT);
}
/** @file src/stereo_picture_frame.h
- * @brief StereoPictureFrame class
+ * @brief StereoJ2KPictureFrame class
*/
class OpenJPEGImage;
-class StereoPictureFrame;
+class StereoJ2KPictureFrame;
-/** @class StereoPictureFrame
+/** @class StereoJ2KPictureFrame
* @brief A single frame of a 3D (stereoscopic) picture asset
*/
-class StereoPictureFrame
+class StereoJ2KPictureFrame
{
public:
- StereoPictureFrame ();
+ StereoJ2KPictureFrame ();
- StereoPictureFrame (StereoPictureFrame const &) = delete;
- StereoPictureFrame& operator= (StereoPictureFrame const &) = delete;
+ StereoJ2KPictureFrame (StereoJ2KPictureFrame const &) = delete;
+ StereoJ2KPictureFrame& operator= (StereoJ2KPictureFrame const &) = delete;
std::shared_ptr<OpenJPEGImage> xyz_image (Eye eye, int reduce = 0) const;
int size () const override;
private:
- friend class StereoPictureFrame;
+ friend class StereoJ2KPictureFrame;
ASDCP::JP2K::FrameBuffer& mono () const;
std::shared_ptr<Part> right () const;
private:
- /* XXX: this is a bit of a shame, but I tried friend StereoPictureAssetReader and it's
+ /* XXX: this is a bit of a shame, but I tried friend StereoJ2KPictureAssetReader and it's
rejected by some (seemingly older) GCCs.
*/
- friend class AssetReader<ASDCP::JP2K::MXFSReader, StereoPictureFrame>;
+ friend class AssetReader<ASDCP::JP2K::MXFSReader, StereoJ2KPictureFrame>;
- StereoPictureFrame (ASDCP::JP2K::MXFSReader* reader, int n, std::shared_ptr<DecryptionContext>, bool check_hmac);
+ StereoJ2KPictureFrame (ASDCP::JP2K::MXFSReader* reader, int n, std::shared_ptr<DecryptionContext>, bool check_hmac);
std::shared_ptr<ASDCP::JP2K::SFrameBuffer> _buffer;
};
int64_t start_frame
)
{
- auto asset = dynamic_pointer_cast<PictureAsset>(reel_file_asset->asset_ref().asset());
+ auto asset = dynamic_pointer_cast<J2KPictureAsset>(reel_file_asset->asset_ref().asset());
auto const duration = asset->intrinsic_duration ();
auto check_and_add = [&context](vector<VerificationNote> const& j2k_notes) {
}
};
- if (auto mono_asset = dynamic_pointer_cast<MonoPictureAsset>(reel_file_asset->asset_ref().asset())) {
+ if (auto mono_asset = dynamic_pointer_cast<MonoJ2KPictureAsset>(reel_file_asset->asset_ref().asset())) {
auto reader = mono_asset->start_read ();
for (int64_t i = 0; i < duration; ++i) {
auto frame = reader->get_frame (i);
}
context.progress(float(i) / duration);
}
- } else if (auto stereo_asset = dynamic_pointer_cast<StereoPictureAsset>(asset)) {
+ } else if (auto stereo_asset = dynamic_pointer_cast<StereoJ2KPictureAsset>(asset)) {
auto reader = stereo_asset->start_read ();
for (int64_t i = 0; i < duration; ++i) {
auto frame = reader->get_frame (i);
}
/* Only 2D allowed for 4K */
- if (dynamic_pointer_cast<const StereoPictureAsset>(asset)) {
+ if (dynamic_pointer_cast<const StereoJ2KPictureAsset>(asset)) {
context.bv21_error(
VerificationNote::Code::INVALID_PICTURE_ASSET_RESOLUTION_FOR_3D,
String::compose("%1/%2", asset->edit_rate().numerator, asset->edit_rate().denominator),
BOOST_AUTO_TEST_CASE (cpl_sar)
{
auto pa = make_shared<dcp::ReelMonoPictureAsset>(
- make_shared<dcp::MonoPictureAsset>("test/ref/DCP/dcp_test1/video.mxf"), 0
+ make_shared<dcp::MonoJ2KPictureAsset>("test/ref/DCP/dcp_test1/video.mxf"), 0
);
/* Easy ones */
cpl->set_issue_date ("2012-07-17T04:45:18+00:00");
cpl->set_annotation_text ("A Test DCP");
- auto mp = make_shared<dcp::StereoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto mp = make_shared<dcp::StereoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_metadata (mxf_meta);
- auto picture_writer = mp->start_write("build/test/DCP/dcp_test2/video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto picture_writer = mp->start_write("build/test/DCP/dcp_test2/video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
/* Left */
BOOST_REQUIRE (A_picture->mono_asset());
BOOST_REQUIRE (A_picture->mono_asset()->file());
copy_file (A_picture->mono_asset()->file().get(), path("build") / "test" / name / picture);
- reel->add(make_shared<dcp::ReelMonoPictureAsset>(make_shared<dcp::MonoPictureAsset>(path("build") / "test" / name / picture), 0));
+ reel->add(make_shared<dcp::ReelMonoPictureAsset>(make_shared<dcp::MonoJ2KPictureAsset>(path("build") / "test" / name / picture), 0));
auto reader = A_sound->asset()->start_read();
auto sound = make_shared<dcp::SoundAsset>(A_sound->asset()->edit_rate(), A_sound->asset()->sampling_rate(), A_sound->asset()->channels(), dcp::LanguageTag("en-US"), dcp::Standard::SMPTE);
cpl->set_issue_date ("2012-07-17T04:45:18+00:00");
cpl->set_annotation_text ("A Test DCP");
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_metadata (mxf_meta);
- auto picture_writer = mp->start_write("build/test/DCP/dcp_test5/video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto picture_writer = mp->start_write("build/test/DCP/dcp_test5/video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
picture_writer->write (j2c.data (), j2c.size ());
auto dcp = make_simple(dir / "1");
dcp->write_xml();
- auto asset_1_id = dcp::MonoPictureAsset(dir / "1" / "video.mxf").id();
- auto asset_1_hash = dcp::MonoPictureAsset(dir / "1" / "video.mxf").hash();
+ auto asset_1_id = dcp::MonoJ2KPictureAsset(dir / "1" / "video.mxf").id();
+ auto asset_1_hash = dcp::MonoJ2KPictureAsset(dir / "1" / "video.mxf").hash();
/* Replace the hash in the CPL (the one that corresponds to the actual file)
* with an incorrect one new_hash.
auto picture = reel->main_picture()->asset();
BOOST_CHECK (picture);
- auto mono_picture = dynamic_pointer_cast<const dcp::MonoPictureAsset>(picture);
+ auto mono_picture = dynamic_pointer_cast<const dcp::MonoJ2KPictureAsset>(picture);
auto reader = mono_picture->start_read();
auto j2k_frame = reader->get_frame(0);
auto xyz = j2k_frame->xyz_image();
auto context_id = dcp::make_uuid();
dcp::Key key;
- auto picture_asset = std::make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ auto picture_asset = std::make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
picture_asset->set_key (key);
picture_asset->set_context_id (context_id);
- auto picture_writer = picture_asset->start_write(dir / "picture.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto picture_writer = picture_asset->start_write(dir / "picture.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData picture("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
picture_writer->write(picture);
dcp::Key key;
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_metadata (mxf_metadata);
mp->set_key (key);
- auto writer = mp->start_write("build/test/DCP/encryption_test/video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto writer = mp->start_write("build/test/DCP/encryption_test/video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
writer->write (j2c.data (), j2c.size ());
static void
-check (shared_ptr<dcp::PictureAssetWriter> writer, boost::random::uniform_int_distribution<>& dist, boost::random::mt19937& rng, string hash)
+check (shared_ptr<dcp::J2KPictureAssetWriter> writer, boost::random::uniform_int_distribution<>& dist, boost::random::mt19937& rng, string hash)
{
auto xyz = make_shared<dcp::OpenJPEGImage>(dcp::Size(1998, 1080));
for (int c = 0; c < 3; ++c) {
/** Test the hashing of data written to JPEG2000 MXFs with some random inputs */
BOOST_AUTO_TEST_CASE (frame_info_hash_test)
{
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
- auto writer = mp->start_write("build/test/frame_info_hash_test.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto writer = mp->start_write("build/test/frame_info_hash_test.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
boost::random::mt19937 rng(1);
boost::random::uniform_int_distribution<> dist(0, 4095);
auto signer = make_shared<dcp::CertificateChain>(dcp::file_to_string("test/data/certificate_chain"));
signer->set_key(dcp::file_to_string("test/data/private.key"));
- auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ auto asset = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
asset->set_key (dcp::Key());
- auto writer = asset->start_write("build/test/validity_period_test1.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto writer = asset->start_write("build/test/validity_period_test1.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData frame ("test/data/flat_red.j2c");
writer->write (frame.data(), frame.size());
writer->finalize ();
BOOST_REQUIRE_EQUAL(reload_vf.cpls()[0]->reels().size(), 1U);
BOOST_REQUIRE(reload_vf.cpls()[0]->reels()[0]->main_picture());
BOOST_REQUIRE(reload_vf.cpls()[0]->reels()[0]->main_picture()->asset());
- auto mono_asset = dynamic_pointer_cast<dcp::MonoPictureAsset>(reload_vf.cpls()[0]->reels()[0]->main_picture()->asset());
+ auto mono_asset = dynamic_pointer_cast<dcp::MonoJ2KPictureAsset>(reload_vf.cpls()[0]->reels()[0]->main_picture()->asset());
BOOST_REQUIRE(mono_asset);
auto reader = mono_asset->start_read();
reader->set_check_hmac(false);
boost::filesystem::remove_all ("build/test/baz");
boost::filesystem::create_directories ("build/test/baz");
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
- auto writer = mp->start_write("build/test/baz/video1.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto writer = mp->start_write("build/test/baz/video1.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
int written_size = 0;
for (int i = 0; i < 24; ++i) {
Kumu::ResetTestRNG ();
- mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
- writer = mp->start_write("build/test/baz/video2.mxf", dcp::PictureAsset::Behaviour::OVERWRITE_EXISTING);
+ mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ writer = mp->start_write("build/test/baz/video2.mxf", dcp::J2KPictureAsset::Behaviour::OVERWRITE_EXISTING);
writer->write (data.data(), data.size());
boost::filesystem::path work_dir = "build/test/round_trip_test";
boost::filesystem::create_directory (work_dir);
- auto asset_A = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
- auto writer = asset_A->start_write(work_dir / "video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto asset_A = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto writer = asset_A->start_write(work_dir / "video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
writer->write (j2c.data (), j2c.size ());
}
/* Reload the picture asset */
- auto asset_B = make_shared<dcp::MonoPictureAsset>(work_dir / "video.mxf");
+ auto asset_B = make_shared<dcp::MonoJ2KPictureAsset>(work_dir / "video.mxf");
BOOST_CHECK (!kdm_B.keys().empty ());
asset_B->set_key (kdm_B.keys().front().key());
}
-shared_ptr<dcp::MonoPictureAsset>
+shared_ptr<dcp::MonoJ2KPictureAsset>
simple_picture (boost::filesystem::path path, string suffix, int frames, optional<dcp::Key> key)
{
dcp::MXFMetadata mxf_meta;
mxf_meta.product_name = "OpenDCP";
mxf_meta.product_version = "0.0.25";
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_metadata (mxf_meta);
if (key) {
mp->set_key (*key);
}
- auto picture_writer = mp->start_write(path / dcp::String::compose("video%1.mxf", suffix), dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto picture_writer = mp->start_write(path / dcp::String::compose("video%1.mxf", suffix), dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::Size const size (1998, 1080);
auto image = make_shared<dcp::OpenJPEGImage>(size);
auto frame = dcp::compress_j2k (image, 100000000, 24, false, false);
BOOST_REQUIRE (frame.size() < 230000000 / (24 * 8));
- auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ auto asset = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
asset->set_metadata (dcp::MXFMetadata("libdcp", "libdcp", "1.6.4devel"));
boost::filesystem::create_directories (dir);
- auto writer = asset->start_write(dir / "pic.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto writer = asset->start_write(dir / "pic.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
for (int i = 0; i < frames; ++i) {
writer->write (frame.data(), frame.size());
}
namespace dcp {
class DCP;
- class MonoPictureAsset;
+ class MonoJ2KPictureAsset;
class SoundAsset;
}
extern void check_xml (xmlpp::Element* ref, xmlpp::Element* test, std::vector<std::string> ignore_tags, bool ignore_whitespace = false);
extern void check_xml (std::string ref, std::string test, std::vector<std::string> ignore, bool ignore_whitespace = false);
extern void check_file (boost::filesystem::path ref, boost::filesystem::path check);
-extern std::shared_ptr<dcp::MonoPictureAsset> simple_picture (
+extern std::shared_ptr<dcp::MonoJ2KPictureAsset> simple_picture (
boost::filesystem::path path,
std::string suffix,
int frames = 24,
shared_ptr<dcp::CPL>
dcp_from_frame (dcp::ArrayData const& frame, path dir)
{
- auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ auto asset = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
create_directories (dir);
- auto writer = asset->start_write(dir / "pic.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto writer = asset->start_write(dir / "pic.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
for (int i = 0; i < 24; ++i) {
writer->write (frame.data(), frame.size());
}
path dcp_path = "build/test/verify_picture_test";
prepare_directory (dcp_path);
- shared_ptr<dcp::PictureAsset> mp;
+ shared_ptr<dcp::J2KPictureAsset> mp;
if (three_d) {
- mp = make_shared<dcp::StereoPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::Standard::SMPTE);
+ mp = make_shared<dcp::StereoJ2KPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::Standard::SMPTE);
} else {
- mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::Standard::SMPTE);
+ mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(frame_rate, 1), dcp::Standard::SMPTE);
}
- auto picture_writer = mp->start_write(dcp_path / "video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto picture_writer = mp->start_write(dcp_path / "video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
auto image = black_image (dcp::Size(width, height));
auto j2c = dcp::compress_j2k (image, 100000000, frame_rate, three_d, width > 2048);
auto reel = make_shared<dcp::Reel>();
if (three_d) {
- reel->add (make_shared<dcp::ReelStereoPictureAsset>(std::dynamic_pointer_cast<dcp::StereoPictureAsset>(mp), 0));
+ reel->add (make_shared<dcp::ReelStereoPictureAsset>(std::dynamic_pointer_cast<dcp::StereoJ2KPictureAsset>(mp), 0));
} else {
- reel->add (make_shared<dcp::ReelMonoPictureAsset>(std::dynamic_pointer_cast<dcp::MonoPictureAsset>(mp), 0));
+ reel->add (make_shared<dcp::ReelMonoPictureAsset>(std::dynamic_pointer_cast<dcp::MonoJ2KPictureAsset>(mp), 0));
}
reel->add (simple_markers(frame_rate));
shared_ptr<dcp::DCP> dcp (new dcp::DCP(dir));
auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER, dcp::Standard::SMPTE);
- shared_ptr<dcp::MonoPictureAsset> mp = simple_picture (dir, "", 24);
+ shared_ptr<dcp::MonoJ2KPictureAsset> mp = simple_picture (dir, "", 24);
shared_ptr<dcp::SoundAsset> ms = simple_sound (dir, "", dcp::MXFMetadata(), "en-US", 25);
auto reel = make_shared<dcp::Reel>(
dcp::Key key;
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_key (key);
- auto writer = mp->start_write(dir / "video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto writer = mp->start_write(dir / "video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::ArrayData j2c ("test/data/flat_red.j2c");
for (int i = 0; i < 24; ++i) {
writer->write (j2c.data(), j2c.size());
BOOST_AUTO_TEST_CASE (verify_jpeg2000_codestream_2k)
{
vector<dcp::VerificationNote> notes;
- dcp::MonoPictureAsset picture (find_file(private_test / "data" / "JourneyToJah_TLR-1_F_EN-DE-FR_CH_51_2K_LOK_20140225_DGL_SMPTE_OV", "j2c.mxf"));
+ dcp::MonoJ2KPictureAsset picture (find_file(private_test / "data" / "JourneyToJah_TLR-1_F_EN-DE-FR_CH_51_2K_LOK_20140225_DGL_SMPTE_OV", "j2c.mxf"));
auto reader = picture.start_read ();
auto frame = reader->get_frame (0);
verify_j2k(frame, 0, 0, 24, notes);
BOOST_AUTO_TEST_CASE (verify_jpeg2000_codestream_4k)
{
vector<dcp::VerificationNote> notes;
- dcp::MonoPictureAsset picture (find_file(private_test / "data" / "sul", "TLR"));
+ dcp::MonoJ2KPictureAsset picture (find_file(private_test / "data" / "sul", "TLR"));
auto reader = picture.start_read ();
auto frame = reader->get_frame (0);
verify_j2k(frame, 0, 0, 24, notes);
auto dcp = make_simple (dir);
dcp->write_xml ();
vector<dcp::VerificationNote> notes;
- dcp::MonoPictureAsset picture (find_file(dir, "video"));
+ dcp::MonoJ2KPictureAsset picture (find_file(dir, "video"));
auto reader = picture.start_read ();
auto frame = reader->get_frame (0);
verify_j2k(frame, 0, 0, 24, notes);
boost::filesystem::remove_all(path);
boost::filesystem::create_directories(path);
- auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
- auto picture_writer = mp->start_write(path / "video.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
+ auto mp = make_shared<dcp::MonoJ2KPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ auto picture_writer = mp->start_write(path / "video.mxf", dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
dcp::Size const size(1998, 1080);
auto image = make_shared<dcp::OpenJPEGImage>(size);
dcp1->write_xml();
auto cpl = dcp1->cpls()[0];
- auto const asset_1 = dcp::MonoPictureAsset(dir / "1" / "video.mxf").id();
+ auto const asset_1 = dcp::MonoJ2KPictureAsset(dir / "1" / "video.mxf").id();
auto dcp2 = make_simple(dir / "2");
dcp2->write_xml();
- auto const asset_2 = dcp::MonoPictureAsset(dir / "2" / "video.mxf").id();
+ auto const asset_2 = dcp::MonoJ2KPictureAsset(dir / "2" / "video.mxf").id();
boost::filesystem::remove(dir / "1" / "video.mxf");
boost::filesystem::copy_file(dir / "2" / "video.mxf", dir / "1" / "video.mxf");
}
case Type::PICTURE:
{
- dcp::MonoPictureAsset in (input_file);
+ dcp::MonoJ2KPictureAsset in (input_file);
add_key (in, decrypted_kdm);
- dcp::MonoPictureAsset out (in.edit_rate(), dcp::Standard::SMPTE);
- auto writer = out.start_write(output_file.get(), dcp::PictureAsset::Behaviour::MAKE_NEW);
+ dcp::MonoJ2KPictureAsset out (in.edit_rate(), dcp::Standard::SMPTE);
+ auto writer = out.start_write(output_file.get(), dcp::J2KPictureAsset::Behaviour::MAKE_NEW);
copy (in, writer, ignore_hmac);
break;
}
if (frame_index >= duration) {
frame_index -= duration;
} else {
- auto reader = dynamic_pointer_cast<dcp::MonoPictureAsset>(reel->main_picture()->asset())->start_read();
+ auto reader = dynamic_pointer_cast<dcp::MonoJ2KPictureAsset>(reel->main_picture()->asset())->start_read();
auto frame = reader->get_frame(frame_index);
auto xyz = frame->xyz_image();
std::vector<uint8_t> rgba(xyz->size().width * xyz->size().height * 4);
OUTPUT_PICTURE("\n Picture: %1x%2\n", mp->asset()->size().width, mp->asset()->size().height);
}
- shared_ptr<MonoPictureAsset> ma = dynamic_pointer_cast<MonoPictureAsset>(mp->asset());
+ shared_ptr<MonoJ2KPictureAsset> ma = dynamic_pointer_cast<MonoJ2KPictureAsset>(mp->asset());
if (analyse && ma) {
- shared_ptr<MonoPictureAssetReader> reader = ma->start_read ();
+ shared_ptr<MonoJ2KPictureAssetReader> reader = ma->start_read ();
pair<int, int> j2k_size_range (INT_MAX, 0);
for (int64_t i = 0; i < ma->intrinsic_duration(); ++i) {
- shared_ptr<const MonoPictureFrame> frame = reader->get_frame (i);
+ shared_ptr<const MonoJ2KPictureFrame> frame = reader->get_frame (i);
if (SHOULD_PICTURE) {
printf("Frame %" PRId64 " J2K size %7d", i, frame->size());
}
projects / libdcp.git / commitdiff