X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=test%2Ftest.cc;h=11ca56031df8f22869a06b6d574e665960ecd9a4;hb=dc5e11944a30a9d381dc0e67cf657c5f2cb65845;hp=39a921d3682149a88f7485c5cc584b5688512b53;hpb=7ee21d16c01b90c22192cd10f118419881fe504e;p=dcpomatic.git diff --git a/test/test.cc b/test/test.cc index 39a921d36..f1fd40fb7 100644 --- a/test/test.cc +++ b/test/test.cc @@ -1,67 +1,172 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-2021 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ -#include -#include -#include -#include -#include -#include "format.h" -#include "film.h" -#include "filter.h" -#include "job_manager.h" -#include "util.h" -#include "exceptions.h" -#include "delay_line.h" -#include "image.h" -#include "log.h" -#include "dcp_video_frame.h" -#include "config.h" -#include "server.h" -#include "cross.h" -#include "job.h" -#include "subtitle.h" -#include "scaler.h" -#include "ffmpeg_decoder.h" -#include "sndfile_decoder.h" -#include "dcp_content_type.h" + + +/** @file test/test.cc + * @brief Overall test stuff and useful methods for tests. + */ + + +#include "lib/compose.hpp" +#include "lib/config.h" +#include "lib/cross.h" +#include "lib/dcp_content_type.h" +#include "lib/dcpomatic_log.h" +#include "lib/encode_server_finder.h" +#include "lib/ffmpeg_image_proxy.h" +#include "lib/file_log.h" +#include "lib/film.h" +#include "lib/image.h" +#include "lib/job.h" +#include "lib/job_manager.h" +#include "lib/log_entry.h" +#include "lib/make_dcp.h" +#include "lib/ratio.h" +#include "lib/signal_manager.h" +#include "lib/util.h" +#include "test.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +extern "C" { +#include +} #define BOOST_TEST_DYN_LINK #define BOOST_TEST_MODULE dcpomatic_test +#include +LIBDCP_DISABLE_WARNINGS +#include +LIBDCP_ENABLE_WARNINGS #include +#include +#include +#include -using std::string; + +using std::abs; +using std::cerr; +using std::cout; using std::list; -using std::stringstream; +using std::make_shared; +using std::min; +using std::shared_ptr; +using std::string; using std::vector; -using boost::shared_ptr; -using boost::thread; -using boost::dynamic_pointer_cast; +using boost::scoped_array; +using std::dynamic_pointer_cast; +#if BOOST_VERSION >= 106100 +using namespace boost::placeholders; +#endif -void + +boost::filesystem::path +TestPaths::TestPaths::private_data () +{ + char* env = getenv("DCPOMATIC_TEST_PRIVATE"); + if (env) { + return boost::filesystem::path(env); + } + + return boost::filesystem::canonical(boost::filesystem::path ("..") / boost::filesystem::path ("dcpomatic-test-private")); +} + + +boost::filesystem::path TestPaths::xsd () +{ + return boost::filesystem::canonical(boost::filesystem::path("..") / boost::filesystem::path("libdcp") / boost::filesystem::path("xsd")); +} + + +static void setup_test_config () { - Config::instance()->set_num_local_encoding_threads (1); - Config::instance()->set_servers (vector ()); - Config::instance()->set_server_port (61920); - Config::instance()->set_default_dci_metadata (DCIMetadata ()); + Config::instance()->set_master_encoding_threads (boost::thread::hardware_concurrency() / 2); + Config::instance()->set_server_encoding_threads (1); + Config::instance()->set_server_port_base (61921); + Config::instance()->set_default_container (Ratio::from_id ("185")); + Config::instance()->set_default_dcp_content_type (static_cast (0)); + Config::instance()->set_default_audio_delay (0); + Config::instance()->set_default_j2k_bandwidth (100000000); + Config::instance()->set_default_interop (false); + Config::instance()->set_default_still_length (10); + Config::instance()->set_log_types ( + LogEntry::TYPE_GENERAL | LogEntry::TYPE_WARNING | + LogEntry::TYPE_ERROR | LogEntry::TYPE_DISK + ); + Config::instance()->set_automatic_audio_analysis (false); + auto signer = make_shared(dcp::file_to_string("test/data/signer_chain")); + signer->set_key(dcp::file_to_string("test/data/signer_key")); + Config::instance()->set_signer_chain (signer); + auto decryption = make_shared(dcp::file_to_string("test/data/decryption_chain")); + decryption->set_key(dcp::file_to_string("test/data/decryption_key")); + Config::instance()->set_decryption_chain (decryption); } + +class TestSignalManager : public SignalManager +{ +public: + /* No wakes in tests: we call ui_idle ourselves */ + void wake_ui () override + { + + } +}; + +struct TestConfig +{ + TestConfig () + { + State::override_path = "build/test/state"; + boost::filesystem::remove_all (*State::override_path); + + dcpomatic_setup (); + setup_test_config (); + + EncodeServerFinder::instance()->stop (); + + signal_manager = new TestSignalManager (); + + dcpomatic_log.reset (new FileLog("build/test/log")); + } + + ~TestConfig () + { + JobManager::drop (); + } +}; + + +BOOST_GLOBAL_FIXTURE (TestConfig); + + boost::filesystem::path test_film_dir (string name) { @@ -72,725 +177,806 @@ test_film_dir (string name) return p; } + shared_ptr new_test_film (string name) { - boost::filesystem::path p = test_film_dir (name); + auto p = test_film_dir (name); if (boost::filesystem::exists (p)) { boost::filesystem::remove_all (p); } - - return shared_ptr (new Film (p.string(), false)); + + auto film = make_shared(p); + film->write_metadata (); + return film; } -/* Check that Image::make_black works, and doesn't use values which crash - sws_scale(). -*/ -BOOST_AUTO_TEST_CASE (make_black_test) -{ - /* This needs to happen in the first test */ - dcpomatic_setup (); - - libdcp::Size in_size (512, 512); - libdcp::Size out_size (1024, 1024); - - list pix_fmts; - pix_fmts.push_back (AV_PIX_FMT_RGB24); - pix_fmts.push_back (AV_PIX_FMT_YUV420P); - pix_fmts.push_back (AV_PIX_FMT_YUV422P10LE); - pix_fmts.push_back (AV_PIX_FMT_YUV444P9LE); - pix_fmts.push_back (AV_PIX_FMT_YUV444P9BE); - pix_fmts.push_back (AV_PIX_FMT_YUV444P10LE); - pix_fmts.push_back (AV_PIX_FMT_YUV444P10BE); - pix_fmts.push_back (AV_PIX_FMT_UYVY422); - - int N = 0; - for (list::const_iterator i = pix_fmts.begin(); i != pix_fmts.end(); ++i) { - boost::shared_ptr foo (new SimpleImage (*i, in_size, true)); - foo->make_black (); - boost::shared_ptr bar = foo->scale_and_convert_to_rgb (out_size, 0, Scaler::from_id ("bicubic"), true); - - uint8_t* p = bar->data()[0]; - for (int y = 0; y < bar->size().height; ++y) { - uint8_t* q = p; - for (int x = 0; x < bar->line_size()[0]; ++x) { - BOOST_CHECK_EQUAL (*q++, 0); - } - p += bar->stride()[0]; - } +shared_ptr +new_test_film2 (string name, vector> content, Cleanup* cleanup) +{ + auto p = test_film_dir (name); + if (boost::filesystem::exists (p)) { + boost::filesystem::remove_all (p); + } + if (cleanup) { + cleanup->add (p); + } + + auto film = make_shared(p); + film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TST")); + film->set_container (Ratio::from_id ("185")); + film->write_metadata (); + + for (auto i: content) { + film->examine_and_add_content (i); + BOOST_REQUIRE (!wait_for_jobs()); + } - ++N; - } -} - -BOOST_AUTO_TEST_CASE (film_metadata_test) -{ - setup_test_config (); - - string const test_film = "build/test/film_metadata_test"; - - if (boost::filesystem::exists (test_film)) { - boost::filesystem::remove_all (test_film); - } - - BOOST_CHECK_THROW (new Film (test_film, true), OpenFileError); - - shared_ptr f (new Film (test_film, false)); - f->_dci_date = boost::gregorian::from_undelimited_string ("20130211"); - BOOST_CHECK (f->format() == 0); - BOOST_CHECK (f->dcp_content_type() == 0); - BOOST_CHECK (f->filters ().empty()); - - f->set_name ("fred"); -// BOOST_CHECK_THROW (f->set_content ("jim"), OpenFileError); - f->set_dcp_content_type (DCPContentType::from_pretty_name ("Short")); - f->set_format (Format::from_nickname ("Flat")); - f->set_left_crop (1); - f->set_right_crop (2); - f->set_top_crop (3); - f->set_bottom_crop (4); - vector f_filters; - f_filters.push_back (Filter::from_id ("pphb")); - f_filters.push_back (Filter::from_id ("unsharp")); - f->set_filters (f_filters); - f->set_trim_start (42); - f->set_trim_end (99); - f->set_ab (true); - f->write_metadata (); - - stringstream s; - s << "diff -u test/metadata.ref " << test_film << "/metadata"; - BOOST_CHECK_EQUAL (::system (s.str().c_str ()), 0); - - shared_ptr g (new Film (test_film, true)); - - BOOST_CHECK_EQUAL (g->name(), "fred"); - BOOST_CHECK_EQUAL (g->dcp_content_type(), DCPContentType::from_pretty_name ("Short")); - BOOST_CHECK_EQUAL (g->format(), Format::from_nickname ("Flat")); - BOOST_CHECK_EQUAL (g->crop().left, 1); - BOOST_CHECK_EQUAL (g->crop().right, 2); - BOOST_CHECK_EQUAL (g->crop().top, 3); - BOOST_CHECK_EQUAL (g->crop().bottom, 4); - vector g_filters = g->filters (); - BOOST_CHECK_EQUAL (g_filters.size(), 2); - BOOST_CHECK_EQUAL (g_filters.front(), Filter::from_id ("pphb")); - BOOST_CHECK_EQUAL (g_filters.back(), Filter::from_id ("unsharp")); - BOOST_CHECK_EQUAL (g->trim_start(), 42); - BOOST_CHECK_EQUAL (g->trim_end(), 99); - BOOST_CHECK_EQUAL (g->ab(), true); - - g->write_metadata (); - BOOST_CHECK_EQUAL (::system (s.str().c_str ()), 0); -} - -BOOST_AUTO_TEST_CASE (format_test) -{ - Format::setup_formats (); - - Format const * f = Format::from_nickname ("Flat"); - BOOST_CHECK (f); -// BOOST_CHECK_EQUAL (f->ratio_as_integer(shared_ptr ()), 185); - - f = Format::from_nickname ("Scope"); - BOOST_CHECK (f); -// BOOST_CHECK_EQUAL (f->ratio_as_integer(shared_ptr ()), 239); -} - -BOOST_AUTO_TEST_CASE (util_test) -{ - string t = "Hello this is a string \"with quotes\" and indeed without them"; - vector b = split_at_spaces_considering_quotes (t); - vector::iterator i = b.begin (); - BOOST_CHECK_EQUAL (*i++, "Hello"); - BOOST_CHECK_EQUAL (*i++, "this"); - BOOST_CHECK_EQUAL (*i++, "is"); - BOOST_CHECK_EQUAL (*i++, "a"); - BOOST_CHECK_EQUAL (*i++, "string"); - BOOST_CHECK_EQUAL (*i++, "with quotes"); - BOOST_CHECK_EQUAL (*i++, "and"); - BOOST_CHECK_EQUAL (*i++, "indeed"); - BOOST_CHECK_EQUAL (*i++, "without"); - BOOST_CHECK_EQUAL (*i++, "them"); -} - -class NullLog : public Log + return film; +} + + +void +check_wav_file (boost::filesystem::path ref, boost::filesystem::path check) { -public: - void do_log (string) {} -}; + SF_INFO ref_info; + ref_info.format = 0; + auto ref_file = sf_open (ref.string().c_str(), SFM_READ, &ref_info); + BOOST_CHECK (ref_file); + + SF_INFO check_info; + check_info.format = 0; + auto check_file = sf_open (check.string().c_str(), SFM_READ, &check_info); + BOOST_CHECK (check_file); + + BOOST_CHECK_EQUAL (ref_info.frames, check_info.frames); + BOOST_CHECK_EQUAL (ref_info.samplerate, check_info.samplerate); + BOOST_CHECK_EQUAL (ref_info.channels, check_info.channels); + BOOST_CHECK_EQUAL (ref_info.format, check_info.format); + + /* buffer_size is in frames */ + sf_count_t const buffer_size = 65536 * ref_info.channels; + scoped_array ref_buffer (new int32_t[buffer_size]); + scoped_array check_buffer (new int32_t[buffer_size]); + + sf_count_t N = ref_info.frames; + while (N) { + sf_count_t this_time = min (buffer_size, N); + sf_count_t r = sf_readf_int (ref_file, ref_buffer.get(), this_time); + BOOST_CHECK_EQUAL (r, this_time); + r = sf_readf_int (check_file, check_buffer.get(), this_time); + BOOST_CHECK_EQUAL (r, this_time); + + for (sf_count_t i = 0; i < this_time; ++i) { + BOOST_REQUIRE_MESSAGE ( + abs (ref_buffer[i] - check_buffer[i]) <= 65536, + ref << " differs from " << check << " at " << (ref_info.frames - N + i) << " of " << ref_info.frames + << "(" << ref_buffer[i] << " vs " << check_buffer[i] << ")" + ); + } + + N -= this_time; + } +} + void -do_positive_delay_line_test (int delay_length, int data_length) -{ - shared_ptr log (new NullLog); - - DelayLine d (log, 6, delay_length); - shared_ptr data (new AudioBuffers (6, data_length)); - - int in = 0; - int out = 0; - int returned = 0; - int zeros = 0; - - for (int i = 0; i < 64; ++i) { - for (int j = 0; j < data_length; ++j) { - for (int c = 0; c < 6; ++c ) { - data->data(c)[j] = in; - ++in; +check_mxf_audio_file (boost::filesystem::path ref, boost::filesystem::path check) +{ + ASDCP::PCM::MXFReader ref_reader; + BOOST_REQUIRE (!ASDCP_FAILURE (ref_reader.OpenRead (ref.string().c_str()))); + + ASDCP::PCM::AudioDescriptor ref_desc; + BOOST_REQUIRE (!ASDCP_FAILURE (ref_reader.FillAudioDescriptor (ref_desc))); + + ASDCP::PCM::MXFReader check_reader; + BOOST_REQUIRE (!ASDCP_FAILURE (check_reader.OpenRead (check.string().c_str()))); + + ASDCP::PCM::AudioDescriptor check_desc; + BOOST_REQUIRE (!ASDCP_FAILURE (check_reader.FillAudioDescriptor (check_desc))); + + BOOST_REQUIRE_EQUAL (ref_desc.ContainerDuration, check_desc.ContainerDuration); + + ASDCP::PCM::FrameBuffer ref_buffer (Kumu::Megabyte); + ASDCP::PCM::FrameBuffer check_buffer (Kumu::Megabyte); + for (size_t i = 0; i < ref_desc.ContainerDuration; ++i) { + ref_reader.ReadFrame (i, ref_buffer, 0); + check_reader.ReadFrame (i, check_buffer, 0); + BOOST_REQUIRE (memcmp(ref_buffer.RoData(), check_buffer.RoData(), ref_buffer.Size()) == 0); + } +} + + +/** @return true if the files are the same, otherwise false */ +bool +mxf_atmos_files_same (boost::filesystem::path ref, boost::filesystem::path check, bool verbose) +{ + ASDCP::ATMOS::MXFReader ref_reader; + BOOST_REQUIRE (!ASDCP_FAILURE(ref_reader.OpenRead(ref.string().c_str()))); + + ASDCP::ATMOS::AtmosDescriptor ref_desc; + BOOST_REQUIRE (!ASDCP_FAILURE(ref_reader.FillAtmosDescriptor(ref_desc))); + + ASDCP::ATMOS::MXFReader check_reader; + BOOST_REQUIRE (!ASDCP_FAILURE(check_reader.OpenRead(check.string().c_str()))); + + ASDCP::ATMOS::AtmosDescriptor check_desc; + BOOST_REQUIRE (!ASDCP_FAILURE(check_reader.FillAtmosDescriptor(check_desc))); + + if (ref_desc.EditRate.Numerator != check_desc.EditRate.Numerator) { + if (verbose) { + std::cout << "EditRate.Numerator differs.\n"; + } + return false; + } + if (ref_desc.EditRate.Denominator != check_desc.EditRate.Denominator) { + if (verbose) { + std::cout << "EditRate.Denominator differs.\n"; + } + return false; + } + if (ref_desc.ContainerDuration != check_desc.ContainerDuration) { + if (verbose) { + std::cout << "EditRate.ContainerDuration differs.\n"; + } + return false; + } + if (ref_desc.FirstFrame != check_desc.FirstFrame) { + if (verbose) { + std::cout << "EditRate.FirstFrame differs.\n"; + } + return false; + } + if (ref_desc.MaxChannelCount != check_desc.MaxChannelCount) { + if (verbose) { + std::cout << "EditRate.MaxChannelCount differs.\n"; + } + return false; + } + if (ref_desc.MaxObjectCount != check_desc.MaxObjectCount) { + if (verbose) { + std::cout << "EditRate.MaxObjectCount differs.\n"; + } + return false; + } + if (ref_desc.AtmosVersion != check_desc.AtmosVersion) { + if (verbose) { + std::cout << "EditRate.AtmosVersion differs.\n"; + } + return false; + } + + ASDCP::DCData::FrameBuffer ref_buffer (Kumu::Megabyte); + ASDCP::DCData::FrameBuffer check_buffer (Kumu::Megabyte); + for (size_t i = 0; i < ref_desc.ContainerDuration; ++i) { + ref_reader.ReadFrame (i, ref_buffer, 0); + check_reader.ReadFrame (i, check_buffer, 0); + if (memcmp(ref_buffer.RoData(), check_buffer.RoData(), ref_buffer.Size())) { + if (verbose) { + std::cout << "data differs.\n"; } + return false; } + } + + return true; +} - /* This only works because the delay line modifies the parameter */ - d.process_audio (data); - returned += data->frames (); - for (int j = 0; j < data->frames(); ++j) { - if (zeros < delay_length) { - for (int c = 0; c < 6; ++c) { - BOOST_CHECK_EQUAL (data->data(c)[j], 0); +static +double +rms_error (boost::filesystem::path ref, boost::filesystem::path check) +{ + FFmpegImageProxy ref_proxy (ref); + auto ref_image = ref_proxy.image(Image::Alignment::COMPACT).image; + FFmpegImageProxy check_proxy (check); + auto check_image = check_proxy.image(Image::Alignment::COMPACT).image; + + BOOST_REQUIRE_EQUAL (ref_image->planes(), check_image->planes()); + + BOOST_REQUIRE_EQUAL (ref_image->pixel_format(), check_image->pixel_format()); + auto const format = ref_image->pixel_format(); + + BOOST_REQUIRE (ref_image->size() == check_image->size()); + int const width = ref_image->size().width; + int const height = ref_image->size().height; + + double sum_square = 0; + switch (format) { + case AV_PIX_FMT_RGBA: + { + for (int y = 0; y < height; ++y) { + uint8_t* p = ref_image->data()[0] + y * ref_image->stride()[0]; + uint8_t* q = check_image->data()[0] + y * check_image->stride()[0]; + for (int x = 0; x < width; ++x) { + for (int c = 0; c < 4; ++c) { + sum_square += pow((*p++ - *q++), 2); + } + } + } + break; + } + case AV_PIX_FMT_RGB24: + { + for (int y = 0; y < height; ++y) { + uint8_t* p = ref_image->data()[0] + y * ref_image->stride()[0]; + uint8_t* q = check_image->data()[0] + y * check_image->stride()[0]; + for (int x = 0; x < width; ++x) { + for (int c = 0; c < 3; ++c) { + sum_square += pow((*p++ - *q++), 2); + } + } + } + break; + } + case AV_PIX_FMT_RGB48BE: + { + for (int y = 0; y < height; ++y) { + uint16_t* p = reinterpret_cast(ref_image->data()[0] + y * ref_image->stride()[0]); + uint16_t* q = reinterpret_cast(check_image->data()[0] + y * check_image->stride()[0]); + for (int x = 0; x < width; ++x) { + for (int c = 0; c < 3; ++c) { + sum_square += pow((*p++ - *q++), 2); + } } - ++zeros; - } else { - for (int c = 0; c < 6; ++c) { - BOOST_CHECK_EQUAL (data->data(c)[j], out); - ++out; + } + break; + } + case AV_PIX_FMT_YUVJ420P: + { + for (int c = 0; c < ref_image->planes(); ++c) { + for (int y = 0; y < height / ref_image->vertical_factor(c); ++y) { + auto p = ref_image->data()[c] + y * ref_image->stride()[c]; + auto q = check_image->data()[c] + y * check_image->stride()[c]; + for (int x = 0; x < ref_image->line_size()[c]; ++x) { + sum_square += pow((*p++ - *q++), 2); + } } } + break; } + default: + BOOST_REQUIRE_MESSAGE (false, "unrecognised pixel format " << format); } - BOOST_CHECK_EQUAL (returned, 64 * data_length); + return sqrt(sum_square / (height * width)); +} + + +BOOST_AUTO_TEST_CASE (rms_error_test) +{ + BOOST_CHECK_CLOSE (rms_error("test/data/check_image0.png", "test/data/check_image0.png"), 0, 0.001); + BOOST_CHECK_CLOSE (rms_error("test/data/check_image0.png", "test/data/check_image1.png"), 2.2778, 0.001); + BOOST_CHECK_CLOSE (rms_error("test/data/check_image0.png", "test/data/check_image2.png"), 59.8896, 0.001); + BOOST_CHECK_CLOSE (rms_error("test/data/check_image0.png", "test/data/check_image3.png"), 0.89164, 0.001); } + void -do_negative_delay_line_test (int delay_length, int data_length) -{ - shared_ptr log (new NullLog); - - DelayLine d (log, 6, delay_length); - shared_ptr data (new AudioBuffers (6, data_length)); - - int in = 0; - int out = -delay_length * 6; - int returned = 0; - - for (int i = 0; i < 256; ++i) { - data->set_frames (data_length); - for (int j = 0; j < data_length; ++j) { - for (int c = 0; c < 6; ++c) { - data->data(c)[j] = in; - ++in; - } - } +check_image (boost::filesystem::path ref, boost::filesystem::path check, double threshold) +{ + double const e = rms_error (ref, check); + BOOST_CHECK_MESSAGE (e < threshold, ref << " differs from " << check << " " << e); +} - /* This only works because the delay line modifies the parameter */ - d.process_audio (data); - returned += data->frames (); - for (int j = 0; j < data->frames(); ++j) { - for (int c = 0; c < 6; ++c) { - BOOST_CHECK_EQUAL (data->data(c)[j], out); - ++out; - } +void +check_file (boost::filesystem::path ref, boost::filesystem::path check) +{ + auto N = boost::filesystem::file_size (ref); + BOOST_CHECK_EQUAL (N, boost::filesystem::file_size (check)); + dcp::File ref_file(ref, "rb"); + BOOST_CHECK (ref_file); + dcp::File check_file(check, "rb"); + BOOST_CHECK (check_file); + + int const buffer_size = 65536; + std::vector ref_buffer(buffer_size); + std::vector check_buffer(buffer_size); + + string error = "File " + check.string() + " differs from reference " + ref.string(); + + while (N) { + uintmax_t this_time = min (uintmax_t (buffer_size), N); + size_t r = ref_file.read (ref_buffer.data(), 1, this_time); + BOOST_CHECK_EQUAL (r, this_time); + r = check_file.read(check_buffer.data(), 1, this_time); + BOOST_CHECK_EQUAL (r, this_time); + + BOOST_CHECK_MESSAGE (memcmp (ref_buffer.data(), check_buffer.data(), this_time) == 0, error); + if (memcmp (ref_buffer.data(), check_buffer.data(), this_time)) { + break; } - } - returned += -delay_length; - BOOST_CHECK_EQUAL (returned, 256 * data_length); + N -= this_time; + } } -BOOST_AUTO_TEST_CASE (delay_line_test) + +void +check_text_file (boost::filesystem::path ref, boost::filesystem::path check) { - do_positive_delay_line_test (64, 128); - do_positive_delay_line_test (128, 64); - do_positive_delay_line_test (3, 512); - do_positive_delay_line_test (512, 3); + dcp::File ref_file(ref, "r"); + BOOST_CHECK (ref_file); + dcp::File check_file(check, "r"); + BOOST_CHECK (check_file); + + int const buffer_size = std::max( + boost::filesystem::file_size(ref), + boost::filesystem::file_size(check) + ); + + DCPOMATIC_ASSERT (buffer_size < 1024 * 1024); - do_positive_delay_line_test (0, 64); + std::vector ref_buffer(buffer_size); + auto ref_read = ref_file.read(ref_buffer.data(), 1, buffer_size); + std::vector check_buffer(buffer_size); + auto check_read = check_file.read(check_buffer.data(), 1, buffer_size); + BOOST_CHECK_EQUAL (ref_read, check_read); - do_negative_delay_line_test (-64, 128); - do_negative_delay_line_test (-128, 64); - do_negative_delay_line_test (-3, 512); - do_negative_delay_line_test (-512, 3); + string const error = "File " + check.string() + " differs from reference " + ref.string(); + BOOST_CHECK_MESSAGE(memcmp(ref_buffer.data(), check_buffer.data(), ref_read) == 0, error); } -BOOST_AUTO_TEST_CASE (md5_digest_test) + +static void +note (dcp::NoteType t, string n) +{ + if (t == dcp::NoteType::ERROR) { + cerr << n << "\n"; + } +} + + +void +check_dcp (boost::filesystem::path ref, shared_ptr film) { - string const t = md5_digest ("test/md5.test"); - BOOST_CHECK_EQUAL (t, "15058685ba99decdc4398c7634796eb0"); + check_dcp (ref, film->dir(film->dcp_name())); +} + - BOOST_CHECK_THROW (md5_digest ("foobar"), OpenFileError); +void +check_dcp (boost::filesystem::path ref, boost::filesystem::path check) +{ + dcp::DCP ref_dcp (ref); + ref_dcp.read (); + dcp::DCP check_dcp (check); + check_dcp.read (); + + dcp::EqualityOptions options; + options.max_mean_pixel_error = 5; + options.max_std_dev_pixel_error = 5; + options.max_audio_sample_error = 255; + options.cpl_annotation_texts_can_differ = true; + options.reel_annotation_texts_can_differ = true; + options.reel_hashes_can_differ = true; + options.issue_dates_can_differ = true; + + BOOST_CHECK (ref_dcp.equals (check_dcp, options, boost::bind (note, _1, _2))); } void -do_remote_encode (shared_ptr frame, ServerDescription* description, shared_ptr locally_encoded) -{ - shared_ptr remotely_encoded; - BOOST_CHECK_NO_THROW (remotely_encoded = frame->encode_remotely (description)); - BOOST_CHECK (remotely_encoded); - - BOOST_CHECK_EQUAL (locally_encoded->size(), remotely_encoded->size()); - BOOST_CHECK (memcmp (locally_encoded->data(), remotely_encoded->data(), locally_encoded->size()) == 0); -} - -BOOST_AUTO_TEST_CASE (client_server_test) -{ - shared_ptr image (new SimpleImage (PIX_FMT_RGB24, libdcp::Size (1998, 1080), true)); - uint8_t* p = image->data()[0]; - - for (int y = 0; y < 1080; ++y) { - uint8_t* q = p; - for (int x = 0; x < 1998; ++x) { - *q++ = x % 256; - *q++ = y % 256; - *q++ = (x + y) % 256; +check_xml (xmlpp::Element* ref, xmlpp::Element* test, list ignore) +{ + BOOST_CHECK_EQUAL (ref->get_name (), test->get_name ()); + BOOST_CHECK_EQUAL (ref->get_namespace_prefix (), test->get_namespace_prefix ()); + + if (find (ignore.begin(), ignore.end(), ref->get_name()) != ignore.end ()) { + return; + } + + auto ref_children = ref->get_children (); + auto test_children = test->get_children (); + BOOST_REQUIRE_MESSAGE ( + ref_children.size() == test_children.size(), + ref->get_name() << " has " << ref_children.size() << " or " << test_children.size() << " children" + ); + + auto k = ref_children.begin (); + auto l = test_children.begin (); + while (k != ref_children.end ()) { + + /* XXX: should be doing xmlpp::EntityReference, xmlpp::XIncludeEnd, xmlpp::XIncludeStart */ + + auto ref_el = dynamic_cast(*k); + auto test_el = dynamic_cast(*l); + BOOST_CHECK ((ref_el && test_el) || (!ref_el && !test_el)); + if (ref_el && test_el) { + check_xml (ref_el, test_el, ignore); } - p += image->stride()[0]; - } - - shared_ptr sub_image (new SimpleImage (PIX_FMT_RGBA, libdcp::Size (100, 200), true)); - p = sub_image->data()[0]; - for (int y = 0; y < 200; ++y) { - uint8_t* q = p; - for (int x = 0; x < 100; ++x) { - *q++ = y % 256; - *q++ = x % 256; - *q++ = (x + y) % 256; - *q++ = 1; + + auto ref_cn = dynamic_cast(*k); + auto test_cn = dynamic_cast(*l); + BOOST_CHECK ((ref_cn && test_cn) || (!ref_cn && !test_cn)); + if (ref_cn && test_cn) { + BOOST_CHECK_EQUAL (ref_cn->get_content(), test_cn->get_content ()); } - p += sub_image->stride()[0]; - } - - shared_ptr subtitle (new Subtitle (Position (50, 60), sub_image)); - - shared_ptr log (new FileLog ("build/test/client_server_test.log")); - - shared_ptr frame ( - new DCPVideoFrame ( - image, - subtitle, - libdcp::Size (1998, 1080), - 0, - 0, - 1, - Scaler::from_id ("bicubic"), - 0, - 24, - "", - 0, - 200000000, - log - ) - ); - shared_ptr locally_encoded = frame->encode_locally (); - BOOST_ASSERT (locally_encoded); - - Server* server = new Server (log); + ++k; + ++l; + } - new thread (boost::bind (&Server::run, server, 2)); + auto ref_attributes = ref->get_attributes (); + auto test_attributes = test->get_attributes (); + BOOST_CHECK_EQUAL (ref_attributes.size(), test_attributes.size ()); - /* Let the server get itself ready */ - dcpomatic_sleep (1); + auto m = ref_attributes.begin(); + auto n = test_attributes.begin(); + while (m != ref_attributes.end ()) { + BOOST_CHECK_EQUAL ((*m)->get_name(), (*n)->get_name()); + BOOST_CHECK_EQUAL ((*m)->get_value(), (*n)->get_value()); - ServerDescription description ("localhost", 2); + ++m; + ++n; + } +} - list threads; - for (int i = 0; i < 8; ++i) { - threads.push_back (new thread (boost::bind (do_remote_encode, frame, &description, locally_encoded))); +void +check_xml (boost::filesystem::path ref, boost::filesystem::path test, list ignore) +{ + auto ref_parser = new xmlpp::DomParser(ref.string()); + auto ref_root = ref_parser->get_document()->get_root_node(); + auto test_parser = new xmlpp::DomParser(test.string()); + auto test_root = test_parser->get_document()->get_root_node(); + + check_xml (ref_root, test_root, ignore); +} + +bool +wait_for_jobs () +{ + auto jm = JobManager::instance (); + while (jm->work_to_do()) { + while (signal_manager->ui_idle()) {} + dcpomatic_sleep_seconds (1); } - for (list::iterator i = threads.begin(); i != threads.end(); ++i) { - (*i)->join (); + if (jm->errors ()) { + int N = 0; + for (auto i: jm->_jobs) { + if (i->finished_in_error()) { + ++N; + } + } + cerr << N << " errors.\n"; + + for (auto i: jm->_jobs) { + if (i->finished_in_error()) { + cerr << i->name() << ":\n" + << "\tsummary: " << i->error_summary() << "\n" + << "\tdetails: " << i->error_details() << "\n"; + } + } } - for (list::iterator i = threads.begin(); i != threads.end(); ++i) { - delete *i; + while (signal_manager->ui_idle ()) {} + + if (jm->errors ()) { + JobManager::drop (); + return true; } + + return false; } -BOOST_AUTO_TEST_CASE (make_dcp_test) -{ - shared_ptr film = new_test_film ("make_dcp_test"); - film->set_name ("test_film2"); -// film->set_content ("../../../test/test.mp4"); - film->set_format (Format::from_nickname ("Flat")); - film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test")); - film->make_dcp (); - film->write_metadata (); - while (JobManager::instance()->work_to_do ()) { - dcpomatic_sleep (1); - } - - BOOST_CHECK_EQUAL (JobManager::instance()->errors(), false); -} - -/** Test Film::have_dcp(). Requires the output from make_dcp_test above */ -BOOST_AUTO_TEST_CASE (have_dcp_test) -{ - boost::filesystem::path p = test_film_dir ("make_dcp_test"); - Film f (p.string ()); - BOOST_CHECK (f.have_dcp()); - - p /= f.dcp_name(); - p /= "video.mxf"; - boost::filesystem::remove (p); - BOOST_CHECK (!f.have_dcp ()); -} - -BOOST_AUTO_TEST_CASE (make_dcp_with_range_test) -{ - shared_ptr film = new_test_film ("make_dcp_with_range_test"); - film->set_name ("test_film3"); -// film->set_content ("../../../test/test.mp4"); -// film->examine_content (); - film->set_format (Format::from_nickname ("Flat")); - film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test")); - film->set_trim_end (42); - film->make_dcp (); - - while (JobManager::instance()->work_to_do() && !JobManager::instance()->errors()) { - dcpomatic_sleep (1); - } - - BOOST_CHECK_EQUAL (JobManager::instance()->errors(), false); -} - -/* Test best_dcp_frame_rate and FrameRateConversion */ -BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test) -{ - /* Run some tests with a limited range of allowed rates */ - - std::list afr; - afr.push_back (24); - afr.push_back (25); - afr.push_back (30); - Config::instance()->set_allowed_dcp_frame_rates (afr); - - int best = best_dcp_frame_rate (60); - FrameRateConversion frc = FrameRateConversion (60, best); - BOOST_CHECK_EQUAL (best, 30); - BOOST_CHECK_EQUAL (frc.skip, true); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (50); - frc = FrameRateConversion (50, best); - BOOST_CHECK_EQUAL (best, 25); - BOOST_CHECK_EQUAL (frc.skip, true); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (48); - frc = FrameRateConversion (48, best); - BOOST_CHECK_EQUAL (best, 24); - BOOST_CHECK_EQUAL (frc.skip, true); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (30); - frc = FrameRateConversion (30, best); - BOOST_CHECK_EQUAL (best, 30); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (29.97); - frc = FrameRateConversion (29.97, best); - BOOST_CHECK_EQUAL (best, 30); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, true); - - best = best_dcp_frame_rate (25); - frc = FrameRateConversion (25, best); - BOOST_CHECK_EQUAL (best, 25); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (24); - frc = FrameRateConversion (24, best); - BOOST_CHECK_EQUAL (best, 24); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (14.5); - frc = FrameRateConversion (14.5, best); - BOOST_CHECK_EQUAL (best, 30); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, true); - BOOST_CHECK_EQUAL (frc.change_speed, true); - - best = best_dcp_frame_rate (12.6); - frc = FrameRateConversion (12.6, best); - BOOST_CHECK_EQUAL (best, 25); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, true); - BOOST_CHECK_EQUAL (frc.change_speed, true); - - best = best_dcp_frame_rate (12.4); - frc = FrameRateConversion (12.4, best); - BOOST_CHECK_EQUAL (best, 25); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, true); - BOOST_CHECK_EQUAL (frc.change_speed, true); - - best = best_dcp_frame_rate (12); - frc = FrameRateConversion (12, best); - BOOST_CHECK_EQUAL (best, 24); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, true); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - /* Now add some more rates and see if it will use them - in preference to skip/repeat. - */ - - afr.push_back (48); - afr.push_back (50); - afr.push_back (60); - Config::instance()->set_allowed_dcp_frame_rates (afr); - - best = best_dcp_frame_rate (60); - frc = FrameRateConversion (60, best); - BOOST_CHECK_EQUAL (best, 60); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (50); - frc = FrameRateConversion (50, best); - BOOST_CHECK_EQUAL (best, 50); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - best = best_dcp_frame_rate (48); - frc = FrameRateConversion (48, best); - BOOST_CHECK_EQUAL (best, 48); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, false); - - /* Check some out-there conversions (not the best) */ - - frc = FrameRateConversion (14.99, 24); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, true); - BOOST_CHECK_EQUAL (frc.change_speed, true); - - /* Check some conversions with limited DCP targets */ - - afr.clear (); - afr.push_back (24); - Config::instance()->set_allowed_dcp_frame_rates (afr); - - best = best_dcp_frame_rate (25); - frc = FrameRateConversion (25, best); - BOOST_CHECK_EQUAL (best, 24); - BOOST_CHECK_EQUAL (frc.skip, false); - BOOST_CHECK_EQUAL (frc.repeat, false); - BOOST_CHECK_EQUAL (frc.change_speed, true); -} - -BOOST_AUTO_TEST_CASE (audio_sampling_rate_test) -{ - std::list afr; - afr.push_back (24); - afr.push_back (25); - afr.push_back (30); - Config::instance()->set_allowed_dcp_frame_rates (afr); - - shared_ptr f = new_test_film ("audio_sampling_rate_test"); -// f->set_source_frame_rate (24); - f->set_dcp_frame_rate (24); - -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 48000, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 48000); - -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 44100, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 48000); - -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 80000, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 96000); - -// f->set_source_frame_rate (23.976); - f->set_dcp_frame_rate (best_dcp_frame_rate (23.976)); -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 48000, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 47952); - -// f->set_source_frame_rate (29.97); - f->set_dcp_frame_rate (best_dcp_frame_rate (29.97)); - BOOST_CHECK_EQUAL (f->dcp_frame_rate (), 30); -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 48000, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 47952); - -// f->set_source_frame_rate (25); - f->set_dcp_frame_rate (24); -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 48000, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 50000); - -// f->set_source_frame_rate (25); - f->set_dcp_frame_rate (24); -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 44100, 0))); - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), 50000); - - /* Check some out-there conversions (not the best) */ - -// f->set_source_frame_rate (14.99); - f->set_dcp_frame_rate (25); -// f->set_content_audio_stream (shared_ptr (new FFmpegAudioStream ("a", 42, 16000, 0))); - /* The FrameRateConversion within target_audio_sample_rate should choose to double-up - the 14.99 fps video to 30 and then run it slow at 25. - */ - BOOST_CHECK_EQUAL (f->target_audio_sample_rate(), rint (48000 * 2 * 14.99 / 25)); -} - -class TestJob : public Job +class Memory { public: - TestJob (shared_ptr f) - : Job (f) + Memory () {} + + ~Memory () { + free (data); + } + + Memory (Memory const&) = delete; + Memory& operator= (Memory const&) = delete; + + uint8_t* data = nullptr; + size_t size = 0; +}; + +static void +png_write_data (png_structp png_ptr, png_bytep data, png_size_t length) +{ + auto mem = reinterpret_cast(png_get_io_ptr(png_ptr)); + size_t size = mem->size + length; + + if (mem->data) { + mem->data = reinterpret_cast(realloc(mem->data, size)); + } else { + mem->data = reinterpret_cast(malloc(size)); } - void set_finished_ok () { - set_state (FINISHED_OK); + BOOST_REQUIRE (mem->data); + + memcpy (mem->data + mem->size, data, length); + mem->size += length; +} + + +static void +png_flush (png_structp) +{ + +} + + +static void +png_error_fn (png_structp, char const * message) +{ + throw EncodeError (String::compose("Error during PNG write: %1", message)); +} + + +void +write_image (shared_ptr image, boost::filesystem::path file) +{ + int png_color_type = PNG_COLOR_TYPE_RGB; + int bits_per_pixel = 0; + switch (image->pixel_format()) { + case AV_PIX_FMT_RGB24: + bits_per_pixel = 8; + break; + case AV_PIX_FMT_XYZ12LE: + bits_per_pixel = 16; + break; + default: + BOOST_REQUIRE_MESSAGE (false, "unexpected pixel format " << image->pixel_format()); } - void set_finished_error () { - set_state (FINISHED_ERROR); + /* error handling? */ + png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, reinterpret_cast(const_cast(image.get())), png_error_fn, 0); + BOOST_REQUIRE (png_ptr); + + Memory state; + + png_set_write_fn (png_ptr, &state, png_write_data, png_flush); + + png_infop info_ptr = png_create_info_struct(png_ptr); + BOOST_REQUIRE (info_ptr); + + png_set_IHDR (png_ptr, info_ptr, image->size().width, image->size().height, bits_per_pixel, png_color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + + auto const width = image->size().width; + auto const height = image->size().height; + auto const stride = image->stride()[0]; + + vector> data_to_write(height); + for (int y = 0; y < height; ++y) { + data_to_write[y].resize(stride); } - void run () - { - while (1) { - if (finished ()) { - return; + switch (image->pixel_format()) { + case AV_PIX_FMT_RGB24: + for (int y = 0; y < height; ++y) { + memcpy(data_to_write[y].data(), image->data()[0] + y * stride, stride); + } + break; + case AV_PIX_FMT_XYZ12LE: + /* 16-bit pixel values must be written MSB first */ + for (int y = 0; y < height; ++y) { + data_to_write[y].resize(stride); + uint8_t* original = image->data()[0] + y * stride; + for (int x = 0; x < width * 3; ++x) { + data_to_write[y][x * 2] = original[1]; + data_to_write[y][x * 2 + 1] = original[0]; + original += 2; } } + break; + default: + break; } - string name () const { - return ""; + png_byte ** row_pointers = reinterpret_cast(png_malloc(png_ptr, image->size().height * sizeof(png_byte *))); + for (int y = 0; y < height; ++y) { + row_pointers[y] = reinterpret_cast(data_to_write[y].data()); } -}; -BOOST_AUTO_TEST_CASE (job_manager_test) -{ - shared_ptr f; - - /* Single job */ - shared_ptr a (new TestJob (f)); - - JobManager::instance()->add (a); - dcpomatic_sleep (1); - BOOST_CHECK_EQUAL (a->running (), true); - a->set_finished_ok (); - dcpomatic_sleep (2); - BOOST_CHECK_EQUAL (a->finished_ok(), true); -} - -BOOST_AUTO_TEST_CASE (compact_image_test) -{ - SimpleImage* s = new SimpleImage (PIX_FMT_RGB24, libdcp::Size (50, 50), false); - BOOST_CHECK_EQUAL (s->components(), 1); - BOOST_CHECK_EQUAL (s->stride()[0], 50 * 3); - BOOST_CHECK_EQUAL (s->line_size()[0], 50 * 3); - BOOST_CHECK (s->data()[0]); - BOOST_CHECK (!s->data()[1]); - BOOST_CHECK (!s->data()[2]); - BOOST_CHECK (!s->data()[3]); - - /* copy constructor */ - SimpleImage* t = new SimpleImage (*s); - BOOST_CHECK_EQUAL (t->components(), 1); - BOOST_CHECK_EQUAL (t->stride()[0], 50 * 3); - BOOST_CHECK_EQUAL (t->line_size()[0], 50 * 3); - BOOST_CHECK (t->data()[0]); - BOOST_CHECK (!t->data()[1]); - BOOST_CHECK (!t->data()[2]); - BOOST_CHECK (!t->data()[3]); - BOOST_CHECK (t->data() != s->data()); - BOOST_CHECK (t->data()[0] != s->data()[0]); - BOOST_CHECK (t->line_size() != s->line_size()); - BOOST_CHECK (t->line_size()[0] == s->line_size()[0]); - BOOST_CHECK (t->stride() != s->stride()); - BOOST_CHECK (t->stride()[0] == s->stride()[0]); - - /* assignment operator */ - SimpleImage* u = new SimpleImage (PIX_FMT_YUV422P, libdcp::Size (150, 150), true); - *u = *s; - BOOST_CHECK_EQUAL (u->components(), 1); - BOOST_CHECK_EQUAL (u->stride()[0], 50 * 3); - BOOST_CHECK_EQUAL (u->line_size()[0], 50 * 3); - BOOST_CHECK (u->data()[0]); - BOOST_CHECK (!u->data()[1]); - BOOST_CHECK (!u->data()[2]); - BOOST_CHECK (!u->data()[3]); - BOOST_CHECK (u->data() != s->data()); - BOOST_CHECK (u->data()[0] != s->data()[0]); - BOOST_CHECK (u->line_size() != s->line_size()); - BOOST_CHECK (u->line_size()[0] == s->line_size()[0]); - BOOST_CHECK (u->stride() != s->stride()); - BOOST_CHECK (u->stride()[0] == s->stride()[0]); - - delete s; - delete t; - delete u; -} - -BOOST_AUTO_TEST_CASE (aligned_image_test) -{ - SimpleImage* s = new SimpleImage (PIX_FMT_RGB24, libdcp::Size (50, 50), true); - BOOST_CHECK_EQUAL (s->components(), 1); - /* 160 is 150 aligned to the nearest 32 bytes */ - BOOST_CHECK_EQUAL (s->stride()[0], 160); - BOOST_CHECK_EQUAL (s->line_size()[0], 150); - BOOST_CHECK (s->data()[0]); - BOOST_CHECK (!s->data()[1]); - BOOST_CHECK (!s->data()[2]); - BOOST_CHECK (!s->data()[3]); - - /* copy constructor */ - SimpleImage* t = new SimpleImage (*s); - BOOST_CHECK_EQUAL (t->components(), 1); - BOOST_CHECK_EQUAL (t->stride()[0], 160); - BOOST_CHECK_EQUAL (t->line_size()[0], 150); - BOOST_CHECK (t->data()[0]); - BOOST_CHECK (!t->data()[1]); - BOOST_CHECK (!t->data()[2]); - BOOST_CHECK (!t->data()[3]); - BOOST_CHECK (t->data() != s->data()); - BOOST_CHECK (t->data()[0] != s->data()[0]); - BOOST_CHECK (t->line_size() != s->line_size()); - BOOST_CHECK (t->line_size()[0] == s->line_size()[0]); - BOOST_CHECK (t->stride() != s->stride()); - BOOST_CHECK (t->stride()[0] == s->stride()[0]); - - /* assignment operator */ - SimpleImage* u = new SimpleImage (PIX_FMT_YUV422P, libdcp::Size (150, 150), false); - *u = *s; - BOOST_CHECK_EQUAL (u->components(), 1); - BOOST_CHECK_EQUAL (u->stride()[0], 160); - BOOST_CHECK_EQUAL (u->line_size()[0], 150); - BOOST_CHECK (u->data()[0]); - BOOST_CHECK (!u->data()[1]); - BOOST_CHECK (!u->data()[2]); - BOOST_CHECK (!u->data()[3]); - BOOST_CHECK (u->data() != s->data()); - BOOST_CHECK (u->data()[0] != s->data()[0]); - BOOST_CHECK (u->line_size() != s->line_size()); - BOOST_CHECK (u->line_size()[0] == s->line_size()[0]); - BOOST_CHECK (u->stride() != s->stride()); - BOOST_CHECK (u->stride()[0] == s->stride()[0]); - - delete s; - delete t; - delete u; + png_write_info (png_ptr, info_ptr); + png_write_image (png_ptr, row_pointers); + png_write_end (png_ptr, info_ptr); + + png_destroy_write_struct (&png_ptr, &info_ptr); + png_free (png_ptr, row_pointers); + + dcp::ArrayData(state.data, state.size).write(file); +} + + +void +check_ffmpeg (boost::filesystem::path ref, boost::filesystem::path check, int audio_tolerance) +{ + int const r = system (String::compose("ffcmp -t %1 %2 %3", audio_tolerance, ref.string(), check.string()).c_str()); + BOOST_REQUIRE_EQUAL (WEXITSTATUS(r), 0); +} + +void +check_one_frame (boost::filesystem::path dcp_dir, int64_t index, boost::filesystem::path ref) +{ + dcp::DCP dcp (dcp_dir); + dcp.read (); + auto asset = dynamic_pointer_cast (dcp.cpls().front()->reels().front()->main_picture()->asset()); + BOOST_REQUIRE (asset); + auto frame = asset->start_read()->get_frame(index); + auto ref_frame (new dcp::MonoPictureFrame (ref)); + + auto image = frame->xyz_image (); + auto ref_image = ref_frame->xyz_image (); + + BOOST_REQUIRE (image->size() == ref_image->size()); + + int off = 0; + for (int y = 0; y < ref_image->size().height; ++y) { + for (int x = 0; x < ref_image->size().width; ++x) { + BOOST_REQUIRE_EQUAL (ref_image->data(0)[off], image->data(0)[off]); + BOOST_REQUIRE_EQUAL (ref_image->data(1)[off], image->data(1)[off]); + BOOST_REQUIRE_EQUAL (ref_image->data(2)[off], image->data(2)[off]); + ++off; + } + } +} + +boost::filesystem::path +dcp_file (shared_ptr film, string prefix) +{ + auto i = boost::filesystem::recursive_directory_iterator(film->dir(film->dcp_name())); + while (i != boost::filesystem::recursive_directory_iterator() && !boost::algorithm::starts_with(i->path().leaf().string(), prefix)) { + ++i; + } + + BOOST_REQUIRE_MESSAGE(i != boost::filesystem::recursive_directory_iterator(), "Could not find file with prefix " << prefix); + return i->path(); +} + +boost::filesystem::path +subtitle_file (shared_ptr film) +{ + for (auto i: boost::filesystem::recursive_directory_iterator(film->directory().get() / film->dcp_name(false))) { + if (boost::algorithm::starts_with(i.path().leaf().string(), "sub_")) { + return i.path(); + } + } + + BOOST_REQUIRE (false); + /* Remove warning */ + return boost::filesystem::path("/"); +} + + +void +make_random_file (boost::filesystem::path path, size_t size) +{ + dcp::File random_file(path, "wb"); + BOOST_REQUIRE (random_file); + + boost::random::mt19937 rng(1); + boost::random::uniform_int_distribution dist(0); + + while (size > 0) { + auto this_time = std::min(size, size_t(8)); + uint64_t random = dist(rng); + random_file.write(&random, this_time, 1); + size -= this_time; + } +} + + +LogSwitcher::LogSwitcher (shared_ptr log) + : _old (dcpomatic_log) +{ + dcpomatic_log = log; +} + + +LogSwitcher::~LogSwitcher () +{ + dcpomatic_log = _old; +} + +std::ostream& +dcp::operator<< (std::ostream& s, dcp::Size i) +{ + s << i.width << "x" << i.height; + return s; +} + +std::ostream& +dcp::operator<< (std::ostream& s, dcp::Standard t) +{ + switch (t) { + case Standard::INTEROP: + s << "interop"; + break; + case Standard::SMPTE: + s << "smpte"; + break; + } + return s; +} + +std::ostream& +operator<< (std::ostream&s, VideoFrameType f) +{ + s << video_frame_type_to_string(f); + return s; +} + + +void +Cleanup::add (boost::filesystem::path path) +{ + _paths.push_back (path); +} + + +void +Cleanup::run () +{ + boost::system::error_code ec; + for (auto i: _paths) { + boost::filesystem::remove_all (i, ec); + } +} + + +void stage (string, boost::optional) {} +void progress (float) {} + + +void +make_and_verify_dcp (shared_ptr film, vector ignore) +{ + film->write_metadata (); + make_dcp (film, TranscodeJob::ChangedBehaviour::IGNORE); + BOOST_REQUIRE (!wait_for_jobs()); + auto notes = dcp::verify ({film->dir(film->dcp_name())}, &stage, &progress, TestPaths::xsd()); + bool ok = true; + for (auto i: notes) { + if (find(ignore.begin(), ignore.end(), i.code()) == ignore.end()) { + std::cout << "\t" << dcp::note_to_string(i) << "\n"; + ok = false; + } + } + BOOST_CHECK(ok); +} + + +void +check_int_close (int a, int b, int d) +{ + BOOST_CHECK_MESSAGE (std::abs(a - b) < d, a << " differs from " << b << " by more than " << d); +} + + +void +check_int_close (std::pair a, std::pair b, int d) +{ + check_int_close (a.first, b.first, d); + check_int_close (a.second, b.second, d); +} + + +ConfigRestorer::~ConfigRestorer() +{ + setup_test_config(); +} + + +boost::filesystem::path +find_file (boost::filesystem::path dir, string filename_part) +{ + boost::optional 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; }