#include "cpl.h"
#include "dcp.h"
#include "interop_subtitle_asset.h"
+#include "file.h"
+#include "j2k_transcode.h"
#include "mono_picture_asset.h"
+#include "mono_picture_asset.h"
+#include "openjpeg_image.h"
+#include "picture_asset_writer.h"
#include "picture_asset_writer.h"
#include "reel.h"
+#include "reel_asset.h"
+#include "reel_interop_closed_caption_asset.h"
+#include "reel_interop_subtitle_asset.h"
+#include "reel_markers_asset.h"
+#include "reel_mono_picture_asset.h"
#include "reel_mono_picture_asset.h"
+#include "reel_smpte_closed_caption_asset.h"
+#include "reel_smpte_subtitle_asset.h"
#include "reel_sound_asset.h"
-#include "reel_closed_caption_asset.h"
-#include "reel_subtitle_asset.h"
+#include "smpte_subtitle_asset.h"
#include "sound_asset.h"
#include "sound_asset_writer.h"
-#include "smpte_subtitle_asset.h"
-#include "mono_picture_asset.h"
-#include "openjpeg_image.h"
-#include "j2k.h"
-#include "picture_asset_writer.h"
-#include "reel_mono_picture_asset.h"
-#include "reel_asset.h"
#include "test.h"
#include "util.h"
+#include "warnings.h"
+LIBDCP_DISABLE_WARNINGS
#include <asdcp/KM_util.h>
#include <asdcp/KM_prng.h>
+LIBDCP_ENABLE_WARNINGS
#include <sndfile.h>
+LIBDCP_DISABLE_WARNINGS
#include <libxml++/libxml++.h>
+LIBDCP_ENABLE_WARNINGS
#include <boost/test/unit_test.hpp>
#include <cstdio>
#include <iostream>
+
using std::string;
using std::min;
-using std::list;
using std::vector;
using std::shared_ptr;
+using std::make_shared;
using boost::optional;
}
};
+
void
-check_xml (xmlpp::Element* ref, xmlpp::Element* test, list<string> ignore_tags, bool ignore_whitespace)
+check_xml (xmlpp::Element* ref, xmlpp::Element* test, vector<string> ignore_tags, bool ignore_whitespace)
{
BOOST_CHECK_EQUAL (ref->get_name (), test->get_name ());
BOOST_CHECK_EQUAL (ref->get_namespace_prefix (), test->get_namespace_prefix ());
}
void
-check_xml (string ref, string test, list<string> ignore, bool ignore_whitespace)
+check_xml (string ref, string test, vector<string> ignore, bool ignore_whitespace)
{
- xmlpp::DomParser* ref_parser = new xmlpp::DomParser ();
+ auto ref_parser = new xmlpp::DomParser ();
ref_parser->parse_memory (ref);
- xmlpp::Element* ref_root = ref_parser->get_document()->get_root_node ();
- xmlpp::DomParser* test_parser = new xmlpp::DomParser ();
+ auto ref_root = ref_parser->get_document()->get_root_node ();
+ auto test_parser = new xmlpp::DomParser ();
test_parser->parse_memory (test);
- xmlpp::Element* test_root = test_parser->get_document()->get_root_node ();
+ auto test_root = test_parser->get_document()->get_root_node ();
check_xml (ref_root, test_root, ignore, ignore_whitespace);
}
{
uintmax_t size = boost::filesystem::file_size (ref);
BOOST_CHECK_EQUAL (size, boost::filesystem::file_size(check));
- FILE* ref_file = dcp::fopen_boost (ref, "rb");
+ dcp::File ref_file(ref, "rb");
BOOST_REQUIRE (ref_file);
- FILE* check_file = dcp::fopen_boost (check, "rb");
+ dcp::File check_file(check, "rb");
BOOST_REQUIRE (check_file);
int const buffer_size = 65536;
- uint8_t* ref_buffer = new uint8_t[buffer_size];
- uint8_t* check_buffer = new uint8_t[buffer_size];
+ std::vector<uint8_t> ref_buffer(buffer_size);
+ std::vector<uint8_t> check_buffer(buffer_size);
uintmax_t pos = 0;
while (pos < size) {
uintmax_t this_time = min (uintmax_t(buffer_size), size - pos);
- size_t r = fread (ref_buffer, 1, this_time, ref_file);
+ size_t r = ref_file.read(ref_buffer.data(), 1, this_time);
BOOST_CHECK_EQUAL (r, this_time);
- r = fread (check_buffer, 1, this_time, check_file);
+ r = check_file.read(check_buffer.data(), 1, this_time);
BOOST_CHECK_EQUAL (r, this_time);
- if (memcmp(ref_buffer, check_buffer, this_time) != 0) {
+ if (memcmp(ref_buffer.data(), check_buffer.data(), this_time) != 0) {
for (int i = 0; i < buffer_size; ++i) {
if (ref_buffer[i] != check_buffer[i]) {
BOOST_CHECK_MESSAGE (
pos += this_time;
}
-
- delete[] ref_buffer;
- delete[] check_buffer;
-
- fclose (ref_file);
- fclose (check_file);
}
shared_ptr<dcp::MonoPictureAsset>
-simple_picture (boost::filesystem::path path, string suffix)
+simple_picture (boost::filesystem::path path, string suffix, int frames, optional<dcp::Key> key)
{
dcp::MXFMetadata mxf_meta;
mxf_meta.company_name = "OpenDCP";
mxf_meta.product_name = "OpenDCP";
mxf_meta.product_version = "0.0.25";
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (dcp::Fraction (24, 1), dcp::SMPTE));
+ auto mp = make_shared<dcp::MonoPictureAsset>(dcp::Fraction (24, 1), dcp::Standard::SMPTE);
mp->set_metadata (mxf_meta);
- shared_ptr<dcp::PictureAssetWriter> picture_writer = mp->start_write (path / dcp::String::compose("video%1.mxf", suffix), false);
- dcp::ArrayData j2c ("test/data/flat_red.j2c");
- for (int i = 0; i < 24; ++i) {
- picture_writer->write (j2c.data (), j2c.size ());
+ 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);
+
+ dcp::Size const size (1998, 1080);
+ auto image = make_shared<dcp::OpenJPEGImage>(size);
+ for (int i = 0; i < 3; ++i) {
+ memset (image->data(i), 0, 2 * size.width * size.height);
+ }
+ auto j2c = dcp::compress_j2k (image, 100000000, 24, false, false);
+
+ for (int i = 0; i < frames; ++i) {
+ picture_writer->write (j2c.data(), j2c.size());
}
picture_writer->finalize ();
shared_ptr<dcp::SoundAsset>
-simple_sound (boost::filesystem::path path, string suffix, dcp::MXFMetadata mxf_meta, string language)
+simple_sound(boost::filesystem::path path, string suffix, dcp::MXFMetadata mxf_meta, string language, int frames, int sample_rate, optional<dcp::Key> key, int channels)
{
/* Set a valid language, then overwrite it, so that the language parameter can be badly formed */
- shared_ptr<dcp::SoundAsset> ms (new dcp::SoundAsset(dcp::Fraction(24, 1), 48000, 1, dcp::LanguageTag("en-US"), dcp::SMPTE));
+ auto ms = make_shared<dcp::SoundAsset>(dcp::Fraction(24, 1), sample_rate, channels, dcp::LanguageTag("en-US"), dcp::Standard::SMPTE);
+ if (key) {
+ ms->set_key (*key);
+ }
ms->_language = language;
ms->set_metadata (mxf_meta);
- vector<dcp::Channel> active_channels;
- active_channels.push_back (dcp::LEFT);
- shared_ptr<dcp::SoundAssetWriter> sound_writer = ms->start_write (path / dcp::String::compose("audio%1.mxf", suffix), active_channels);
-
- SF_INFO info;
- info.format = 0;
- SNDFILE* sndfile = sf_open ("test/data/1s_24-bit_48k_silence.wav", SFM_READ, &info);
- BOOST_CHECK (sndfile);
- float buffer[4096*6];
- float* channels[1];
- channels[0] = buffer;
- while (true) {
- sf_count_t N = sf_readf_float (sndfile, buffer, 4096);
- sound_writer->write (channels, N);
- if (N < 4096) {
- break;
- }
+ auto sound_writer = ms->start_write(path / dcp::String::compose("audio%1.mxf", suffix), {}, dcp::SoundAsset::AtmosSync::DISABLED, dcp::SoundAsset::MCASubDescriptors::ENABLED);
+
+ int const samples_per_frame = sample_rate / 24;
+
+ float* silence[channels];
+ for (auto i = 0; i < channels; ++i) {
+ silence[i] = new float[samples_per_frame];
+ memset (silence[i], 0, samples_per_frame * sizeof(float));
+ }
+
+ for (auto i = 0; i < frames; ++i) {
+ sound_writer->write(silence, channels, samples_per_frame);
}
sound_writer->finalize ();
+ for (auto i = 0; i < channels; ++i) {
+ delete[] silence[i];
+ }
+
return ms;
}
shared_ptr<dcp::DCP>
-make_simple (boost::filesystem::path path, int reels)
+make_simple (boost::filesystem::path path, int reels, int frames, dcp::Standard standard, optional<dcp::Key> key)
{
/* Some known metadata */
dcp::MXFMetadata mxf_meta;
mxf_meta.product_name = "OpenDCP";
mxf_meta.product_version = "0.0.25";
+ auto constexpr sample_rate = 48000;
+
boost::filesystem::remove_all (path);
boost::filesystem::create_directories (path);
- shared_ptr<dcp::DCP> d (new dcp::DCP (path));
- shared_ptr<dcp::CPL> cpl (new dcp::CPL ("A Test DCP", dcp::FEATURE));
+ auto d = make_shared<dcp::DCP>(path);
+ auto cpl = make_shared<dcp::CPL>("A Test DCP", dcp::ContentKind::TRAILER, standard);
cpl->set_annotation_text ("A Test DCP");
cpl->set_issuer ("OpenDCP 0.0.25");
cpl->set_creator ("OpenDCP 0.0.25");
cpl->set_content_version (
dcp::ContentVersion("urn:uuid:75ac29aa-42ac-1234-ecae-49251abefd11", "content-version-label-text")
);
+ cpl->set_main_sound_configuration(dcp::MainSoundConfiguration("51/L,R,C,LFE,Ls,Rs"));
+ cpl->set_main_sound_sample_rate(sample_rate);
+ cpl->set_main_picture_stored_area(dcp::Size(1998, 1080));
+ cpl->set_main_picture_active_area(dcp::Size(1998, 1080));
+ cpl->set_version_number(1);
for (int i = 0; i < reels; ++i) {
string suffix = reels == 1 ? "" : dcp::String::compose("%1", i);
- shared_ptr<dcp::MonoPictureAsset> mp = simple_picture (path, suffix);
- shared_ptr<dcp::SoundAsset> ms = simple_sound (path, suffix, mxf_meta, "en-US");
+ auto mp = simple_picture (path, suffix, frames, key);
+ auto ms = simple_sound (path, suffix, mxf_meta, "en-US", frames, sample_rate, key);
+
+ auto reel = make_shared<dcp::Reel>(
+ shared_ptr<dcp::ReelMonoPictureAsset>(new dcp::ReelMonoPictureAsset(mp, 0)),
+ shared_ptr<dcp::ReelSoundAsset>(new dcp::ReelSoundAsset(ms, 0))
+ );
+
+ auto markers = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(24, 1), frames);
+ if (i == 0) {
+ markers->set (dcp::Marker::FFOC, dcp::Time(0, 0, 0, 1, 24));
+ }
+ if (i == reels - 1) {
+ markers->set (dcp::Marker::LFOC, dcp::Time(0, 0, 0, frames - 1, 24));
+ }
+ reel->add (markers);
- cpl->add (shared_ptr<dcp::Reel> (
- new dcp::Reel (
- shared_ptr<dcp::ReelMonoPictureAsset>(new dcp::ReelMonoPictureAsset(mp, 0)),
- shared_ptr<dcp::ReelSoundAsset>(new dcp::ReelSoundAsset(ms, 0))
- )
- ));
+ cpl->add (reel);
}
d->add (cpl);
shared_ptr<dcp::Subtitle>
simple_subtitle ()
{
- return shared_ptr<dcp::Subtitle>(
- new dcp::SubtitleString(
- optional<string>(),
- false,
- false,
- false,
- dcp::Colour(255, 255, 255),
- 42,
- 1,
- dcp::Time(0, 0, 4, 0, 24),
- dcp::Time(0, 0, 8, 0, 24),
- 0.5,
- dcp::HALIGN_CENTER,
- 0.8,
- dcp::VALIGN_TOP,
- dcp::DIRECTION_LTR,
- "Hello world",
- dcp::NONE,
- dcp::Colour(255, 255, 255),
- dcp::Time(),
- dcp::Time()
- )
+ return std::make_shared<dcp::SubtitleString>(
+ optional<string>(),
+ false,
+ false,
+ false,
+ dcp::Colour(255, 255, 255),
+ 42,
+ 1,
+ dcp::Time(0, 0, 4, 0, 24),
+ dcp::Time(0, 0, 8, 0, 24),
+ 0.5,
+ dcp::HAlign::CENTER,
+ 0.8,
+ dcp::VAlign::TOP,
+ 0,
+ dcp::Direction::LTR,
+ "Hello world",
+ dcp::Effect::NONE,
+ dcp::Colour(255, 255, 255),
+ dcp::Time(),
+ dcp::Time(),
+ 0
);
}
+shared_ptr<dcp::ReelMarkersAsset>
+simple_markers (int frames)
+{
+ auto markers = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(24, 1), frames);
+ markers->set (dcp::Marker::FFOC, dcp::Time(1, 24, 24));
+ markers->set (dcp::Marker::LFOC, dcp::Time(frames - 1, 24, 24));
+ return markers;
+}
+
+
shared_ptr<dcp::DCP>
make_simple_with_interop_subs (boost::filesystem::path path)
{
- shared_ptr<dcp::DCP> dcp = make_simple (path);
+ auto dcp = make_simple (path, 1, 24, dcp::Standard::INTEROP);
- shared_ptr<dcp::InteropSubtitleAsset> subs(new dcp::InteropSubtitleAsset());
+ auto subs = make_shared<dcp::InteropSubtitleAsset>();
subs->add (simple_subtitle());
boost::filesystem::create_directory (path / "subs");
dcp::ArrayData data(4096);
+ memset(data.data(), 0, data.size());
subs->add_font ("afont", data);
subs->write (path / "subs" / "subs.xml");
- shared_ptr<dcp::ReelSubtitleAsset> reel_subs(new dcp::ReelSubtitleAsset(subs, dcp::Fraction(24, 1), 240, 0));
+ auto reel_subs = make_shared<dcp::ReelInteropSubtitleAsset>(subs, dcp::Fraction(24, 1), 240, 0);
dcp->cpls().front()->reels().front()->add (reel_subs);
return dcp;
shared_ptr<dcp::DCP>
make_simple_with_smpte_subs (boost::filesystem::path path)
{
- shared_ptr<dcp::DCP> dcp = make_simple (path);
+ auto dcp = make_simple (path, 1, 192);
- shared_ptr<dcp::SMPTESubtitleAsset> subs(new dcp::SMPTESubtitleAsset());
+ auto subs = make_shared<dcp::SMPTESubtitleAsset>();
+ subs->set_language (dcp::LanguageTag("de-DE"));
+ subs->set_start_time (dcp::Time());
subs->add (simple_subtitle());
- dcp::ArrayData data(4096);
subs->write (path / "subs.mxf");
- shared_ptr<dcp::ReelSubtitleAsset> reel_subs(new dcp::ReelSubtitleAsset(subs, dcp::Fraction(24, 1), 240, 0));
+ auto reel_subs = make_shared<dcp::ReelSMPTESubtitleAsset>(subs, dcp::Fraction(24, 1), 192, 0);
dcp->cpls().front()->reels().front()->add (reel_subs);
return dcp;
shared_ptr<dcp::DCP>
make_simple_with_interop_ccaps (boost::filesystem::path path)
{
- shared_ptr<dcp::DCP> dcp = make_simple (path);
+ auto dcp = make_simple (path, 1, 24, dcp::Standard::INTEROP);
- shared_ptr<dcp::InteropSubtitleAsset> subs(new dcp::InteropSubtitleAsset());
+ auto subs = make_shared<dcp::InteropSubtitleAsset>();
subs->add (simple_subtitle());
subs->write (path / "ccap.xml");
- shared_ptr<dcp::ReelClosedCaptionAsset> reel_caps(new dcp::ReelClosedCaptionAsset(subs, dcp::Fraction(24, 1), 240, 0));
- dcp->cpls().front()->reels().front()->add (reel_caps);
+ auto reel_caps = make_shared<dcp::ReelInteropClosedCaptionAsset>(subs, dcp::Fraction(24, 1), 240, 0);
+ dcp->cpls()[0]->reels()[0]->add (reel_caps);
return dcp;
}
shared_ptr<dcp::DCP>
make_simple_with_smpte_ccaps (boost::filesystem::path path)
{
- shared_ptr<dcp::DCP> dcp = make_simple (path);
+ auto dcp = make_simple (path, 1, 192);
- shared_ptr<dcp::SMPTESubtitleAsset> subs(new dcp::SMPTESubtitleAsset());
+ auto subs = make_shared<dcp::SMPTESubtitleAsset>();
+ subs->set_language (dcp::LanguageTag("de-DE"));
+ subs->set_start_time (dcp::Time());
subs->add (simple_subtitle());
subs->write (path / "ccap.mxf");
- shared_ptr<dcp::ReelClosedCaptionAsset> reel_caps(new dcp::ReelClosedCaptionAsset(subs, dcp::Fraction(24, 1), 240, 0));
- dcp->cpls().front()->reels().front()->add (reel_caps);
+ auto reel_caps = make_shared<dcp::ReelSMPTEClosedCaptionAsset>(subs, dcp::Fraction(24, 1), 192, 0);
+ dcp->cpls()[0]->reels()[0]->add(reel_caps);
return dcp;
}
shared_ptr<dcp::OpenJPEGImage>
black_image (dcp::Size size)
{
- shared_ptr<dcp::OpenJPEGImage> image(new dcp::OpenJPEGImage(size));
+ auto image = make_shared<dcp::OpenJPEGImage>(size);
int const pixels = size.width * size.height;
for (int i = 0; i < 3; ++i) {
memset (image->data(i), 0, pixels * sizeof(int));
shared_ptr<dcp::ReelAsset>
black_picture_asset (boost::filesystem::path dir, int frames)
{
- shared_ptr<dcp::OpenJPEGImage> image = black_image ();
- dcp::ArrayData frame = dcp::compress_j2k (image, 100000000, 24, false, false);
+ auto image = black_image ();
+ auto frame = dcp::compress_j2k (image, 100000000, 24, false, false);
BOOST_REQUIRE (frame.size() < 230000000 / (24 * 8));
- shared_ptr<dcp::MonoPictureAsset> asset(new dcp::MonoPictureAsset(dcp::Fraction(24, 1), dcp::SMPTE));
+ auto asset = make_shared<dcp::MonoPictureAsset>(dcp::Fraction(24, 1), dcp::Standard::SMPTE);
+ asset->set_metadata (dcp::MXFMetadata("libdcp", "libdcp", "1.6.4devel"));
boost::filesystem::create_directories (dir);
- shared_ptr<dcp::PictureAssetWriter> writer = asset->start_write (dir / "pic.mxf", true);
+ auto writer = asset->start_write(dir / "pic.mxf", dcp::PictureAsset::Behaviour::MAKE_NEW);
for (int i = 0; i < frames; ++i) {
writer->write (frame.data(), frame.size());
}
writer->finalize ();
- return shared_ptr<dcp::ReelAsset>(new dcp::ReelMonoPictureAsset(asset, 0));
+ return make_shared<dcp::ReelMonoPictureAsset>(asset, 0);
+}
+
+
+boost::filesystem::path
+find_file (boost::filesystem::path dir, string filename_part)
+{
+ boost::optional<boost::filesystem::path> found;
+ for (auto i: boost::filesystem::directory_iterator(dir)) {
+ if (i.path().filename().string().find(filename_part) != string::npos) {
+ BOOST_REQUIRE (!found);
+ found = i;
+ }
+ }
+ BOOST_REQUIRE (found);
+ return *found;
}
projects / libdcp.git / blobdiff