X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=test%2Ftest.cc;h=b82af3e2f4570782ccffbde6ef88e8f575642041;hb=8fedaaa75c4586a4cc7ffb393bd71d1fdb091dc8;hp=1ca06c105584b43baa5d71961f70babe1a6b2639;hpb=95ddf1c4ff4eb3d40e64bc8dd3971267535e0ba6;p=dcpomatic.git diff --git a/test/test.cc b/test/test.cc index 1ca06c105..b82af3e2f 100644 --- a/test/test.cc +++ b/test/test.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2017 Carl Hetherington + Copyright (C) 2012-2020 Carl Hetherington This file is part of DCP-o-matic. @@ -30,10 +30,15 @@ #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" #include "lib/log_entry.h" +#include "lib/compose.hpp" +#include "lib/file_log.h" +#include "lib/dcpomatic_log.h" +#include "test.h" #include #include #include @@ -42,9 +47,9 @@ #include #include #include +#include #include #include -#include extern "C" { #include } @@ -63,11 +68,53 @@ 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::path ("..") / boost::filesystem::path ("dcpomatic-test-private"); +void +setup_test_config () +{ + 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 ()); + 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_DEBUG_THREE_D | + LogEntry::TYPE_DEBUG_ENCODE | LogEntry::TYPE_DEBUG_PLAYER | + LogEntry::TYPE_DISK + ); + Config::instance()->set_automatic_audio_analysis (false); +} class TestSignalManager : public SignalManager { @@ -83,29 +130,17 @@ struct TestConfig { TestConfig () { - dcpomatic_setup (); + State::override_path = "build/test/state"; + boost::filesystem::remove_all (*State::override_path); - Config::instance()->set_master_encoding_threads (1); - Config::instance()->set_server_encoding_threads (1); - Config::instance()->set_server_port_base (61921); - Config::instance()->set_default_isdcf_metadata (ISDCFMetadata ()); - 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); - Config::instance()->set_automatic_audio_analysis (false); + dcpomatic_setup (); + setup_test_config (); EncodeServerFinder::instance()->stop (); 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")); } ~TestConfig () @@ -223,22 +258,165 @@ check_mxf_audio_file (boost::filesystem::path ref, boost::filesystem::path check } } -void -check_image (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) { -#ifdef DCPOMATIC_IMAGE_MAGICK - using namespace MagickCore; -#else - using namespace MagickLib; -#endif + 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; + } + } - Magick::Image ref_image; - ref_image.read (ref.string ()); - Magick::Image check_image; - check_image.read (check.string ()); - BOOST_CHECK_MESSAGE (ref_image.compare (check_image), ref << " differs from " << check); + return true; } + +static +double +rms_error (boost::filesystem::path ref, boost::filesystem::path check) +{ + FFmpegImageProxy ref_proxy (ref, VideoRange::FULL); + shared_ptr ref_image = ref_proxy.image().image; + FFmpegImageProxy check_proxy (check, VideoRange::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) +{ + 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) { @@ -280,11 +458,19 @@ check_file (boost::filesystem::path ref, boost::filesystem::path check) static void note (dcp::NoteType t, string n) { - if (t == dcp::DCP_ERROR) { + if (t == dcp::NoteType::ERROR) { cerr << n << "\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) { @@ -378,7 +564,7 @@ wait_for_jobs () JobManager* jm = JobManager::instance (); while (jm->work_to_do ()) { while (signal_manager->ui_idle ()) {} - dcpomatic_sleep (1); + dcpomatic_sleep_seconds (1); } if (jm->errors ()) { @@ -409,43 +595,110 @@ wait_for_jobs () return false; } -void -write_image (shared_ptr image, boost::filesystem::path file, string format) + +class Memory { -#ifdef DCPOMATIC_IMAGE_MAGICK - using namespace MagickCore; -#else - using namespace MagickLib; -#endif +public: + Memory () + : data(0) + , size(0) + {} + + ~Memory () + { + free (data); + } - Magick::Image m (image->size().width, image->size().height, format.c_str(), CharPixel, (void *) image->data()[0]); - m.write (file.string ()); + 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 + +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 -check_ffmpeg_stream (boost::filesystem::path ref, boost::filesystem::path check, string stream) +write_image (shared_ptr image, boost::filesystem::path file) { - FILE* ref_file = popen(string("ffmpeg -loglevel error -i " + ref.string() + " -map 0:" + stream + " -f md5 -").c_str(), "r"); - BOOST_REQUIRE (ref_file); - char ref_md5[64]; - fscanf (ref_file, "%63s", ref_md5); - pclose (ref_file); + 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); + + 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); - FILE* check_file = popen(string("ffmpeg -loglevel error -i " + check.string() + " -map 0:" + stream + " -f md5 -").c_str(), "r"); - BOOST_REQUIRE (check_file); - char check_md5[64]; - fscanf (check_file, "%63s", check_md5); - pclose (check_file); + png_destroy_write_struct (&png_ptr, &info_ptr); + png_free (png_ptr, row_pointers); - BOOST_REQUIRE_EQUAL (strcmp(ref_md5, check_md5), 0); + dcp::ArrayData(state.data, state.size).write(file); } + void -check_ffmpeg (boost::filesystem::path ref, boost::filesystem::path check, int skip_packet_stream) +check_ffmpeg (boost::filesystem::path ref, boost::filesystem::path check, int audio_tolerance) { - check_ffmpeg_stream (ref, check, "v"); - check_ffmpeg_stream (ref, check, "a"); + 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 @@ -456,19 +709,22 @@ check_one_frame (boost::filesystem::path dcp_dir, int64_t index, boost::filesyst shared_ptr asset = dynamic_pointer_cast (dcp.cpls().front()->reels().front()->main_picture()->asset()); BOOST_REQUIRE (asset); shared_ptr frame = asset->start_read()->get_frame(index); + shared_ptr ref_frame (new dcp::MonoPictureFrame (ref)); - boost::uintmax_t const ref_size = boost::filesystem::file_size(ref); - BOOST_CHECK_EQUAL (frame->j2k_size(), ref_size); + shared_ptr image = frame->xyz_image (); + shared_ptr ref_image = ref_frame->xyz_image (); - FILE* ref_file = fopen_boost(ref, "rb"); - BOOST_REQUIRE (ref_file); - - uint8_t* ref_data = new uint8_t[ref_size]; - fread (ref_data, ref_size, 1, ref_file); - fclose (ref_file); + BOOST_REQUIRE (image->size() == ref_image->size()); - BOOST_CHECK (memcmp(ref_data, frame->j2k_data(), ref_size) == 0); - delete[] ref_data; + 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 @@ -482,3 +738,83 @@ dcp_file (shared_ptr film, string prefix) BOOST_REQUIRE (i != boost::filesystem::directory_iterator()); return i->path(); } + +boost::filesystem::path +subtitle_file (shared_ptr film) +{ + for ( + boost::filesystem::directory_iterator i = boost::filesystem::directory_iterator (film->directory().get() / film->dcp_name (false)); + i != boost::filesystem::directory_iterator (); + ++i) { + + if (boost::filesystem::is_directory (i->path ())) { + for ( + boost::filesystem::directory_iterator j = boost::filesystem::directory_iterator (i->path ()); + j != boost::filesystem::directory_iterator (); + ++j) { + + if (boost::algorithm::starts_with (j->path().leaf().string(), "sub_")) { + return j->path(); + } + } + } + } + + BOOST_REQUIRE (false); + /* Remove warning */ + return boost::filesystem::path("/"); +} + +void +make_random_file (boost::filesystem::path path, size_t size) +{ + FILE* t = fopen_boost(path, "wb"); + BOOST_REQUIRE (t); + for (size_t i = 0; i < size; ++i) { + uint8_t r = rand() & 0xff; + fwrite (&r, 1, 1, t); + } + fclose (t); +} + + +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; +} +