X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=test%2Ftest.cc;h=19e8f978a481977ee51bb59c84252fe3c8bc9679;hp=b111a3b6b85a62dfe591e81aac2c78c2aae822b1;hb=dd9be86db6cde0afa5da0d1d1ac43b42e05dca26;hpb=ffe35585f08d0a5aeccf3e32f9c4cd2a5a6f43f5 diff --git a/test/test.cc b/test/test.cc index b111a3b6b..19e8f978a 100644 --- a/test/test.cc +++ b/test/test.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2019 Carl Hetherington + Copyright (C) 2012-2020 Carl Hetherington This file is part of DCP-o-matic. @@ -30,6 +30,7 @@ #include "lib/job.h" #include "lib/cross.h" #include "lib/encode_server_finder.h" +#include "lib/ffmpeg_image_proxy.h" #include "lib/image.h" #include "lib/ratio.h" #include "lib/dcp_content_type.h" @@ -46,9 +47,9 @@ #include #include #include +#include #include #include -#include extern "C" { #include } @@ -67,17 +68,36 @@ using std::cout; using std::cerr; using std::list; using std::abs; -using boost::shared_ptr; +using std::shared_ptr; using boost::scoped_array; -using boost::dynamic_pointer_cast; +using std::dynamic_pointer_cast; +#if BOOST_VERSION >= 106100 +using namespace boost::placeholders; +#endif + + +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")); +} -boost::filesystem::path private_data = boost::filesystem::canonical(boost::filesystem::path ("..") / boost::filesystem::path ("dcpomatic-test-private")); -boost::filesystem::path TestPaths::xsd = boost::filesystem::canonical(boost::filesystem::path("..") / boost::filesystem::path("libdcp") / boost::filesystem::path("xsd")); void setup_test_config () { - Config::instance()->set_master_encoding_threads (1); + Config::instance()->set_master_encoding_threads (boost::thread::hardware_concurrency()); Config::instance()->set_server_encoding_threads (1); Config::instance()->set_server_port_base (61921); Config::instance()->set_default_isdcf_metadata (ISDCFMetadata ()); @@ -87,7 +107,12 @@ setup_test_config () 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); + Config::instance()->set_log_types ( + LogEntry::TYPE_GENERAL | LogEntry::TYPE_WARNING | + LogEntry::TYPE_ERROR | LogEntry::TYPE_DEBUG_THREED | + LogEntry::TYPE_DEBUG_ENCODE | LogEntry::TYPE_DEBUG_PLAYER | + LogEntry::TYPE_DISK + ); Config::instance()->set_automatic_audio_analysis (false); } @@ -105,6 +130,9 @@ struct TestConfig { TestConfig () { + State::override_path = "build/test/state"; + boost::filesystem::remove_all (*State::override_path); + dcpomatic_setup (); setup_test_config (); @@ -112,11 +140,6 @@ struct TestConfig signal_manager = new TestSignalManager (); - char* env_private = getenv("DCPOMATIC_TEST_PRIVATE"); - if (env_private) { - private_data = env_private; - } - dcpomatic_log.reset (new FileLog("build/test/log")); } @@ -235,22 +258,165 @@ check_mxf_audio_file (boost::filesystem::path ref, boost::filesystem::path check } } + +/** @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; +} + + +static +double +rms_error (boost::filesystem::path ref, boost::filesystem::path check) +{ + FFmpegImageProxy ref_proxy (ref, VIDEO_RANGE_FULL); + shared_ptr ref_image = ref_proxy.image().image; + FFmpegImageProxy check_proxy (check, VIDEO_RANGE_FULL); + shared_ptr check_image = check_proxy.image().image; + + BOOST_REQUIRE_EQUAL (ref_image->pixel_format(), check_image->pixel_format()); + AVPixelFormat 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); + } + } + } + break; + } + default: + BOOST_REQUIRE_MESSAGE (false, "unrecognised pixel format " << format); + } + + 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 check_image (boost::filesystem::path ref, boost::filesystem::path check, double threshold) { - using namespace MagickCore; - - Magick::Image ref_image; - ref_image.read (ref.string ()); - Magick::Image check_image; - check_image.read (check.string ()); - /* XXX: this is a hack; we really want the ImageMagick call but GraphicsMagick doesn't have it; - this may cause random test failures on platforms that use GraphicsMagick. - */ - double const dist = ref_image.compare(check_image, Magick::RootMeanSquaredErrorMetric); - BOOST_CHECK_MESSAGE (dist < threshold, ref << " differs from " << check << " " << dist); + double const e = rms_error (ref, check); + BOOST_CHECK_MESSAGE (e < threshold, ref << " differs from " << check << " " << e); } + void check_file (boost::filesystem::path ref, boost::filesystem::path check) { @@ -297,6 +463,14 @@ note (dcp::NoteType t, string n) } } + +void +check_dcp (boost::filesystem::path ref, shared_ptr film) +{ + check_dcp (ref, film->dir(film->dcp_name())); +} + + void check_dcp (boost::filesystem::path ref, boost::filesystem::path check) { @@ -421,15 +595,105 @@ wait_for_jobs () return false; } + +class Memory +{ +public: + Memory () + : data(0) + , size(0) + {} + + ~Memory () + { + free (data); + } + + uint8_t* data; + size_t size; +}; + + +static void +png_write_data (png_structp png_ptr, png_bytep data, png_size_t length) +{ + Memory* 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)); + } + + 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 png_ptr, char const * message) +{ + reinterpret_cast(png_get_error_ptr(png_ptr))->png_error (message); +} + + void -write_image (shared_ptr image, boost::filesystem::path file, string format, MagickCore::StorageType pixel_type) +write_image (shared_ptr image, boost::filesystem::path file) { - using namespace MagickCore; + int png_color_type = 0; + int bits_per_pixel = 0; + switch (image->pixel_format()) { + case AV_PIX_FMT_RGB24: + png_color_type = PNG_COLOR_TYPE_RGB; + bits_per_pixel = 8; + break; + case AV_PIX_FMT_XYZ12LE: + png_color_type = PNG_COLOR_TYPE_RGB; + bits_per_pixel = 16; + break; + default: + BOOST_REQUIRE_MESSAGE (false, "unexpected pixel format " << image->pixel_format()); + } + + /* 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); - Magick::Image m (image->size().width, image->size().height, format.c_str(), pixel_type, (void *) image->data()[0]); - m.write (file.string ()); + 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); + + png_byte ** row_pointers = reinterpret_cast(png_malloc(png_ptr, image->size().height * sizeof(png_byte *))); + for (int i = 0; i < image->size().height; ++i) { + row_pointers[i] = (png_byte *) (image->data()[0] + i * image->stride()[0]); + } + + 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) { @@ -504,22 +768,25 @@ subtitle_file (shared_ptr film) void make_random_file (boost::filesystem::path path, size_t size) { - size_t const chunk = 128 * 1024; - uint8_t* buffer = static_cast (malloc(chunk)); - BOOST_REQUIRE (buffer); - FILE* r = fopen("/dev/urandom", "rb"); - BOOST_REQUIRE (r); FILE* t = fopen_boost(path, "wb"); BOOST_REQUIRE (t); - while (size) { - size_t this_time = min (size, chunk); - size_t N = fread (buffer, 1, this_time, r); - BOOST_REQUIRE (N == this_time); - N = fwrite (buffer, 1, this_time, t); - BOOST_REQUIRE (N == this_time); - size -= this_time; + for (size_t i = 0; i < size; ++i) { + uint8_t r = rand() & 0xff; + fwrite (&r, 1, 1, t); } fclose (t); - fclose (r); - free (buffer); } + + +LogSwitcher::LogSwitcher (shared_ptr log) + : _old (dcpomatic_log) +{ + dcpomatic_log = log; +} + + +LogSwitcher::~LogSwitcher () +{ + dcpomatic_log = _old; +} +