per second.
*/
- boost::shared_ptr<dcp::MonoPictureAsset> picture_asset (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
+ boost::shared_ptr<dcp::MonoPictureAsset> picture_asset (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
/* Start off a write to it */
- boost::shared_ptr<dcp::PictureAssetWriter> picture_writer = picture_asset->start_write ("DCP/picture.mxf", dcp::SMPTE, false);
+ boost::shared_ptr<dcp::PictureAssetWriter> picture_writer = picture_asset->start_write ("DCP/picture.mxf", false);
/* Write 24 frames of the same JPEG2000 file */
dcp::File picture ("examples/help.j2c");
/* Now create a sound MXF. As before, create an object and a writer.
When creating the object we specify the sampling rate (48kHz) and the number of channels (2).
*/
- boost::shared_ptr<dcp::SoundAsset> sound_asset (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 2));
- boost::shared_ptr<dcp::SoundAssetWriter> sound_writer = sound_asset->start_write ("DCP/sound.mxf", dcp::SMPTE);
+ boost::shared_ptr<dcp::SoundAsset> sound_asset (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 2, dcp::SMPTE));
+ boost::shared_ptr<dcp::SoundAssetWriter> sound_writer = sound_asset->start_write ("DCP/sound.mxf");
/* Write some sine waves */
float* audio[2];
* @param mxf MXF that we are writing.
* @param file File to write to.
*/
-AssetWriter::AssetWriter (MXF* mxf, boost::filesystem::path file, Standard standard)
+AssetWriter::AssetWriter (MXF* mxf, boost::filesystem::path file)
: _mxf (mxf)
, _file (file)
, _frames_written (0)
, _finalized (false)
, _started (false)
- , _encryption_context (new EncryptionContext (mxf->key(), standard))
+ , _encryption_context (new EncryptionContext (mxf->key(), mxf->standard()))
{
}
}
protected:
- AssetWriter (MXF* mxf, boost::filesystem::path file, Standard standard);
+ AssetWriter (MXF* mxf, boost::filesystem::path file);
/** MXF that we are writing */
MXF* _mxf;
using namespace dcp;
AtmosAsset::AtmosAsset (Fraction edit_rate, int first_frame, int max_channel_count, int max_object_count, string atmos_id, int atmos_version)
- : _edit_rate (edit_rate)
+ : MXF (SMPTE)
+ , _edit_rate (edit_rate)
, _intrinsic_duration (0)
, _first_frame (first_frame)
, _max_channel_count (max_channel_count)
AtmosAsset::AtmosAsset (boost::filesystem::path file)
: Asset (file)
+ , MXF (SMPTE)
{
ASDCP::ATMOS::MXFReader reader;
Kumu::Result_t r = reader.OpenRead (file.string().c_str());
};
AtmosAssetWriter::AtmosAssetWriter (AtmosAsset* asset, boost::filesystem::path file)
- : AssetWriter (asset, file, SMPTE)
+ : AssetWriter (asset, file)
, _state (new AtmosAssetWriter::ASDCPState)
, _asset (asset)
{
_state->desc.AtmosVersion = 0;
- _asset->fill_writer_info (&_state->writer_info, _asset->id(), SMPTE);
+ _asset->fill_writer_info (&_state->writer_info, _asset->id());
}
void
_id = read_writer_info (info);
}
-MonoPictureAsset::MonoPictureAsset (Fraction edit_rate)
- : PictureAsset (edit_rate)
+MonoPictureAsset::MonoPictureAsset (Fraction edit_rate, Standard standard)
+ : PictureAsset (edit_rate, standard)
{
}
}
shared_ptr<PictureAssetWriter>
-MonoPictureAsset::start_write (boost::filesystem::path file, Standard standard, bool overwrite)
+MonoPictureAsset::start_write (boost::filesystem::path file, bool overwrite)
{
/* XXX: can't we use shared_ptr here? */
- return shared_ptr<MonoPictureAssetWriter> (new MonoPictureAssetWriter (this, file, standard, overwrite));
+ return shared_ptr<MonoPictureAssetWriter> (new MonoPictureAssetWriter (this, file, overwrite));
}
shared_ptr<MonoPictureAssetReader>
/** Create a MonoPictureAsset 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).
*/
- explicit MonoPictureAsset (Fraction edit_rate);
+ explicit MonoPictureAsset (Fraction edit_rate, Standard standard);
/** Start a progressive write to a MonoPictureAsset */
- boost::shared_ptr<PictureAssetWriter> start_write (boost::filesystem::path, Standard standard, bool);
+ boost::shared_ptr<PictureAssetWriter> start_write (boost::filesystem::path, bool);
boost::shared_ptr<MonoPictureAssetReader> start_read () const;
bool equals (
/** @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, Standard standard, bool overwrite)
- : PictureAssetWriter (asset, file, standard, overwrite)
+MonoPictureAssetWriter::MonoPictureAssetWriter (PictureAsset* asset, boost::filesystem::path file, bool overwrite)
+ : PictureAssetWriter (asset, file, overwrite)
, _state (new MonoPictureAssetWriter::ASDCPState)
{
void
MonoPictureAssetWriter::start (uint8_t const * data, int size)
{
- dcp::start (this, _state, _standard, _picture_asset, data, size);
+ dcp::start (this, _state, _picture_asset, data, size);
_picture_asset->set_frame_rate (_picture_asset->edit_rate());
}
private:
friend class MonoPictureAsset;
- MonoPictureAssetWriter (PictureAsset *, boost::filesystem::path file, Standard standard, bool);
+ MonoPictureAssetWriter (PictureAsset *, boost::filesystem::path file, bool);
void start (uint8_t const *, int);
/* do this with an opaque pointer so we don't have to include
MXF::MXF ()
: _context_id (make_uuid ())
{
+ /* Subclasses can create MXFs with unspecified _standard but are expected to fill
+ _standard in once the MXF is read.
+ */
+}
+
+MXF::MXF (Standard standard)
+ : _context_id (make_uuid ())
+ , _standard (standard)
+{
}
void
-MXF::fill_writer_info (ASDCP::WriterInfo* writer_info, string id, Standard standard) const
+MXF::fill_writer_info (ASDCP::WriterInfo* writer_info, string id) const
{
writer_info->ProductVersion = _metadata.product_version;
writer_info->CompanyName = _metadata.company_name;
writer_info->ProductName = _metadata.product_name.c_str();
- if (standard == INTEROP) {
+ DCP_ASSERT (_standard);
+ if (_standard == INTEROP) {
writer_info->LabelSetType = ASDCP::LS_MXF_INTEROP;
} else {
writer_info->LabelSetType = ASDCP::LS_MXF_SMPTE;
_key_id = buffer;
}
+ switch (info.LabelSetType) {
+ case ASDCP::LS_MXF_INTEROP:
+ _standard = INTEROP;
+ break;
+ case ASDCP::LS_MXF_SMPTE:
+ _standard = SMPTE;
+ break;
+ default:
+ DCP_ASSERT (false);
+ }
+
_metadata.read (info);
Kumu::bin2UUIDhex (info.AssetUUID, ASDCP::UUIDlen, buffer, sizeof (buffer));
#include "asset.h"
#include "key.h"
#include "metadata.h"
+#include "dcp_assert.h"
#include <boost/signals2.hpp>
class MXF
{
public:
- MXF ();
+ MXF (Standard standard);
virtual ~MXF () {}
/** @return true if the data is encrypted */
return _metadata;
}
+ Standard standard () const {
+ DCP_ASSERT (_standard);
+ return *_standard;
+ }
+
protected:
template <class P, class Q>
- friend void start (PictureAssetWriter* writer, boost::shared_ptr<P> state, Standard standard, Q* mxf, uint8_t const * data, int size);
+ friend void start (PictureAssetWriter* writer, boost::shared_ptr<P> state, Q* mxf, uint8_t const * data, int size);
+
+ MXF ();
std::string read_writer_info (ASDCP::WriterInfo const &);
/** Fill in a ADSCP::WriteInfo struct.
* @param w struct to fill in.
- * @param standard INTEROP or SMPTE.
*/
- void fill_writer_info (ASDCP::WriterInfo* w, std::string id, Standard standard) const;
+ void fill_writer_info (ASDCP::WriterInfo* w, std::string id) const;
/** ID of the key used for encryption/decryption, if there is one */
boost::optional<std::string> _key_id;
boost::optional<Key> _key;
std::string _context_id;
MXFMetadata _metadata;
+ boost::optional<Standard> _standard;
};
}
using boost::shared_ptr;
using namespace dcp;
+/** Load a PictureAsset from a file */
PictureAsset::PictureAsset (boost::filesystem::path file)
: Asset (file)
, _intrinsic_duration (0)
}
-PictureAsset::PictureAsset (Fraction edit_rate)
- : _edit_rate (edit_rate)
+/** Create a new PictureAsset with a given edit rate and standard */
+PictureAsset::PictureAsset (Fraction edit_rate, Standard standard)
+ : MXF (standard)
+ , _edit_rate (edit_rate)
, _intrinsic_duration (0)
{
{
public:
explicit PictureAsset (boost::filesystem::path file);
- explicit PictureAsset (Fraction edit_rate);
+ explicit PictureAsset (Fraction edit_rate, Standard standard);
virtual boost::shared_ptr<PictureAssetWriter> start_write (
boost::filesystem::path file,
- Standard standard,
bool overwrite
) = 0;
using boost::shared_ptr;
using namespace dcp;
-PictureAssetWriter::PictureAssetWriter (PictureAsset* asset, boost::filesystem::path file, Standard standard, bool overwrite)
- : AssetWriter (asset, file, standard)
+PictureAssetWriter::PictureAssetWriter (PictureAsset* asset, boost::filesystem::path file, bool overwrite)
+ : AssetWriter (asset, file)
, _picture_asset (asset)
- , _standard (standard)
, _overwrite (overwrite)
{
asset->set_file (file);
protected:
template <class P, class Q>
- friend void start (PictureAssetWriter *, boost::shared_ptr<P>, Standard, Q *, uint8_t const *, int);
+ friend void start (PictureAssetWriter *, boost::shared_ptr<P>, Q *, uint8_t const *, int);
- PictureAssetWriter (PictureAsset *, boost::filesystem::path, Standard standard, bool);
+ PictureAssetWriter (PictureAsset *, boost::filesystem::path, bool);
PictureAsset* _picture_asset;
- Standard _standard;
bool _overwrite;
};
}
template <class P, class Q>
-void dcp::start (PictureAssetWriter* writer, shared_ptr<P> state, Standard standard, Q* asset, uint8_t const * data, int size)
+void dcp::start (PictureAssetWriter* writer, shared_ptr<P> state, Q* asset, uint8_t const * data, int size)
{
asset->set_file (writer->_file);
asset->set_size (Size (state->picture_descriptor.StoredWidth, state->picture_descriptor.StoredHeight));
asset->set_screen_aspect_ratio (Fraction (state->picture_descriptor.AspectRatio.Numerator, state->picture_descriptor.AspectRatio.Denominator));
- asset->fill_writer_info (&state->writer_info, asset->id(), standard);
+ asset->fill_writer_info (&state->writer_info, asset->id());
Kumu::Result_t r = state->mxf_writer.OpenWrite (
asset->file()->string().c_str(),
using namespace dcp;
SMPTESubtitleAsset::SMPTESubtitleAsset ()
- : _intrinsic_duration (0)
+ : MXF (SMPTE)
+ , _intrinsic_duration (0)
, _edit_rate (24, 1)
, _time_code_rate (24)
, _xml_id (make_uuid ())
void
SMPTESubtitleAsset::write (boost::filesystem::path p) const
{
- EncryptionContext enc (key (), SMPTE);
+ EncryptionContext enc (key(), SMPTE);
ASDCP::WriterInfo writer_info;
- fill_writer_info (&writer_info, _id, SMPTE);
+ fill_writer_info (&writer_info, _id);
ASDCP::TimedText::TimedTextDescriptor descriptor;
descriptor.EditRate = ASDCP::Rational (_edit_rate.numerator, _edit_rate.denominator);
_id = read_writer_info (info);
}
-SoundAsset::SoundAsset (Fraction edit_rate, int sampling_rate, int channels)
- : _edit_rate (edit_rate)
+SoundAsset::SoundAsset (Fraction edit_rate, int sampling_rate, int channels, Standard standard)
+ : MXF (standard)
+ , _edit_rate (edit_rate)
, _intrinsic_duration (0)
, _channels (channels)
, _sampling_rate (sampling_rate)
}
shared_ptr<SoundAssetWriter>
-SoundAsset::start_write (boost::filesystem::path file, Standard standard)
+SoundAsset::start_write (boost::filesystem::path file)
{
/* XXX: can't we use a shared_ptr here? */
- return shared_ptr<SoundAssetWriter> (new SoundAssetWriter (this, file, standard));
+ return shared_ptr<SoundAssetWriter> (new SoundAssetWriter (this, file));
}
shared_ptr<SoundAssetReader>
{
public:
explicit SoundAsset (boost::filesystem::path file);
- SoundAsset (Fraction edit_rate, int sampling_rate, int channels);
+ SoundAsset (Fraction edit_rate, int sampling_rate, int channels, Standard standard);
- boost::shared_ptr<SoundAssetWriter> start_write (boost::filesystem::path file, Standard standard);
+ boost::shared_ptr<SoundAssetWriter> start_write (boost::filesystem::path file);
boost::shared_ptr<SoundAssetReader> start_read () const;
bool equals (
ASDCP::PCM::AudioDescriptor desc;
};
-SoundAssetWriter::SoundAssetWriter (SoundAsset* asset, boost::filesystem::path file, Standard standard)
- : AssetWriter (asset, file, standard)
+SoundAssetWriter::SoundAssetWriter (SoundAsset* asset, boost::filesystem::path file)
+ : AssetWriter (asset, file)
, _state (new SoundAssetWriter::ASDCPState)
, _asset (asset)
, _frame_buffer_offset (0)
_state->desc.BlockAlign = 3 * _asset->channels();
_state->desc.AvgBps = _asset->sampling_rate() * _state->desc.BlockAlign;
_state->desc.LinkedTrackID = 0;
- if (standard == INTEROP) {
+ if (asset->standard() == INTEROP) {
_state->desc.ChannelFormat = ASDCP::PCM::CF_NONE;
} else {
/* Just use WTF ("wild track format") for SMPTE for now; searches suggest that this
_state->frame_buffer.Size (ASDCP::PCM::CalcFrameBufferSize (_state->desc));
memset (_state->frame_buffer.Data(), 0, _state->frame_buffer.Capacity());
- _asset->fill_writer_info (&_state->writer_info, _asset->id(), standard);
+ _asset->fill_writer_info (&_state->writer_info, _asset->id());
}
void
private:
friend class SoundAsset;
- SoundAssetWriter (SoundAsset *, boost::filesystem::path, Standard standard);
+ SoundAssetWriter (SoundAsset *, boost::filesystem::path);
void write_current_frame ();
_id = read_writer_info (info);
}
-StereoPictureAsset::StereoPictureAsset (Fraction edit_rate)
- : PictureAsset
- (edit_rate)
+StereoPictureAsset::StereoPictureAsset (Fraction edit_rate, Standard standard)
+ : PictureAsset (edit_rate, standard)
{
}
shared_ptr<PictureAssetWriter>
-StereoPictureAsset::start_write (boost::filesystem::path file, Standard standard, bool overwrite)
+StereoPictureAsset::start_write (boost::filesystem::path file, bool overwrite)
{
- return shared_ptr<StereoPictureAssetWriter> (new StereoPictureAssetWriter (this, file, standard, overwrite));
+ return shared_ptr<StereoPictureAssetWriter> (new StereoPictureAssetWriter (this, file, overwrite));
}
shared_ptr<StereoPictureAssetReader>
{
public:
explicit StereoPictureAsset (boost::filesystem::path file);
- explicit StereoPictureAsset (Fraction edit_rate);
+ explicit StereoPictureAsset (Fraction edit_rate, Standard standard);
/** Start a progressive write to a StereoPictureAsset */
- boost::shared_ptr<PictureAssetWriter> start_write (boost::filesystem::path file, Standard, bool);
+ boost::shared_ptr<PictureAssetWriter> start_write (boost::filesystem::path file, bool);
boost::shared_ptr<StereoPictureAssetReader> start_read () const;
bool equals (
ASDCP::JP2K::MXFSWriter mxf_writer;
};
-StereoPictureAssetWriter::StereoPictureAssetWriter (PictureAsset* mxf, boost::filesystem::path file, Standard standard, bool overwrite)
- : PictureAssetWriter (mxf, file, standard, overwrite)
+StereoPictureAssetWriter::StereoPictureAssetWriter (PictureAsset* mxf, boost::filesystem::path file, bool overwrite)
+ : PictureAssetWriter (mxf, file, overwrite)
, _state (new StereoPictureAssetWriter::ASDCPState)
, _next_eye (EYE_LEFT)
{
void
StereoPictureAssetWriter::start (uint8_t const * data, int size)
{
- dcp::start (this, _state, _standard, _picture_asset, data, 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));
}
private:
friend class StereoPictureAsset;
- StereoPictureAssetWriter (PictureAsset *, boost::filesystem::path file, Standard, bool);
+ StereoPictureAssetWriter (PictureAsset *, boost::filesystem::path file, bool);
void start (uint8_t const *, int);
/* do this with an opaque pointer so we don't have to include
cpl->set_content_version_label_text ("81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00");
cpl->set_metadata (xml_meta);
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
mp->set_metadata (mxf_meta);
- shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write (path / "video.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write (path / "video.mxf", false);
dcp::File j2c ("test/data/32x32_red_square.j2c");
for (int i = 0; i < 24; ++i) {
picture_writer->write (j2c.data (), j2c.size ());
}
picture_writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1, dcp::SMPTE));
ms->set_metadata (mxf_meta);
- shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write (path / "audio.mxf", dcp::SMPTE);
+ shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write (path / "audio.mxf");
SF_INFO info;
info.format = 0;
cpl->set_content_version_label_text ("81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00");
cpl->set_metadata (xml_meta);
- shared_ptr<dcp::StereoPictureAsset> mp (new dcp::StereoPictureAsset (dcp::Fraction (24, 1)));
+ shared_ptr<dcp::StereoPictureAsset> mp (new dcp::StereoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
mp->set_metadata (mxf_meta);
- shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write ("build/test/DCP/dcp_test2/video.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write ("build/test/DCP/dcp_test2/video.mxf", false);
dcp::File j2c ("test/data/32x32_red_square.j2c");
for (int i = 0; i < 24; ++i) {
/* Left */
}
picture_writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1, dcp::SMPTE));
ms->set_metadata (mxf_meta);
- shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/dcp_test2/audio.mxf", dcp::SMPTE);
+ shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/dcp_test2/audio.mxf");
SF_INFO info;
info.format = 0;
cpl->set_content_version_label_text ("81fb54df-e1bf-4647-8788-ea7ba154375b_2012-07-17T04:45:18+00:00");
cpl->set_metadata (xml_meta);
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
mp->set_metadata (mxf_meta);
- shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write ("build/test/DCP/dcp_test5/video.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write ("build/test/DCP/dcp_test5/video.mxf", false);
dcp::File j2c ("test/data/32x32_red_square.j2c");
for (int i = 0; i < 24; ++i) {
picture_writer->write (j2c.data (), j2c.size ());
}
picture_writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1, dcp::SMPTE));
ms->set_metadata (mxf_meta);
- shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/dcp_test5/audio.mxf", dcp::SMPTE);
+ shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/dcp_test5/audio.mxf");
SF_INFO info;
info.format = 0;
dcp::Key key;
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
mp->set_metadata (mxf_metadata);
mp->set_key (key);
- shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/DCP/encryption_test/video.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/DCP/encryption_test/video.mxf", false);
dcp::File j2c ("test/data/32x32_red_square.j2c");
for (int i = 0; i < 24; ++i) {
writer->write (j2c.data (), j2c.size ());
}
writer->finalize ();
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1));
+ shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset (dcp::Fraction (24, 1), 48000, 1, dcp::SMPTE));
ms->set_metadata (mxf_metadata);
ms->set_key (key);
- shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/encryption_test/audio.mxf", dcp::SMPTE);
+ shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write ("build/test/DCP/encryption_test/audio.mxf");
SF_INFO info;
info.format = 0;
/** Test the hashing of data written to JPEG2000 MXFs with some random inputs */
BOOST_AUTO_TEST_CASE (frame_info_hash_test)
{
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
- shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/frame_info_hash_test.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/frame_info_hash_test.mxf", false);
unsigned int seed = 42;
boost::filesystem::remove_all ("build/test/baz");
boost::filesystem::create_directories ("build/test/baz");
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
- shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/baz/video1.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::PictureAssetWriter> writer = mp->start_write ("build/test/baz/video1.mxf", false);
int written_size = 0;
for (int i = 0; i < 24; ++i) {
Kumu::ResetTestRNG ();
#endif
- mp.reset (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
- writer = mp->start_write ("build/test/baz/video2.mxf", dcp::SMPTE, true);
+ mp.reset (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ writer = mp->start_write ("build/test/baz/video2.mxf", true);
writer->write (data, size);
boost::filesystem::path work_dir = "build/test/round_trip_test";
boost::filesystem::create_directory (work_dir);
- shared_ptr<dcp::MonoPictureAsset> asset_A (new dcp::MonoPictureAsset (dcp::Fraction (24, 1)));
- shared_ptr<dcp::PictureAssetWriter> writer = asset_A->start_write (work_dir / "video.mxf", dcp::SMPTE, false);
+ shared_ptr<dcp::MonoPictureAsset> asset_A (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ shared_ptr<dcp::PictureAssetWriter> writer = asset_A->start_write (work_dir / "video.mxf", false);
dcp::File j2c ("test/data/32x32_red_square.j2c");
for (int i = 0; i < 24; ++i) {
writer->write (j2c.data (), j2c.size ());