X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fbutler.cc;h=b2128efdb28f0b9cb7660d7ff42d94c94c6648ee;hp=882d8bf580d54d32d01f6a53730ff52b57543207;hb=8963f0007af1a312017b9627c18b82ec2a577591;hpb=52094ba65baa38dfcedc907cfb4314efb1a549b4 diff --git a/src/lib/butler.cc b/src/lib/butler.cc index 882d8bf58..b2128efdb 100644 --- a/src/lib/butler.cc +++ b/src/lib/butler.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2016-2017 Carl Hetherington + Copyright (C) 2016-2020 Carl Hetherington This file is part of DCP-o-matic. @@ -22,66 +22,94 @@ #include "player.h" #include "util.h" #include "log.h" +#include "dcpomatic_log.h" #include "cross.h" #include "compose.hpp" #include "exceptions.h" -#include -#include +#include "video_content.h" -#define LOG_TIMING(...) _log->log (String::compose(__VA_ARGS__), LogEntry::TYPE_TIMING); -#define LOG_WARNING(...) _log->log (String::compose(__VA_ARGS__), LogEntry::TYPE_WARNING); using std::cout; using std::pair; using std::make_pair; using std::string; -using boost::weak_ptr; -using boost::shared_ptr; +using std::weak_ptr; +using std::shared_ptr; using boost::bind; using boost::optional; +using std::function; +using namespace dcpomatic; +#if BOOST_VERSION >= 106100 +using namespace boost::placeholders; +#endif /** Minimum video readahead in frames */ #define MINIMUM_VIDEO_READAHEAD 10 -/** Maximum video readahead in frames; should never be reached unless there are bugs in Player */ -#define MAXIMUM_VIDEO_READAHEAD 24 +/** Maximum video readahead in frames; should never be exceeded (by much) unless there are bugs in Player */ +#define MAXIMUM_VIDEO_READAHEAD 48 /** Minimum audio readahead in frames */ #define MINIMUM_AUDIO_READAHEAD (48000 * MINIMUM_VIDEO_READAHEAD / 24) -/** Minimum audio readahead in frames; should never be reached unless there are bugs in Player */ +/** Maximum audio readahead in frames; should never be exceeded (by much) unless there are bugs in Player */ #define MAXIMUM_AUDIO_READAHEAD (48000 * MAXIMUM_VIDEO_READAHEAD / 24) -Butler::Butler (shared_ptr player, shared_ptr log, AudioMapping audio_mapping, int audio_channels) - : _player (player) - , _log (log) +/** @param pixel_format Pixel format functor that will be used when calling ::image on PlayerVideos coming out of this + * butler. This will be used (where possible) to prepare the PlayerVideos so that calling image() on them is quick. + * @param aligned Same as above for the `aligned' flag. + * @param fast Same as above for the `fast' flag. + */ +Butler::Butler ( + weak_ptr film, + shared_ptr player, + AudioMapping audio_mapping, + int audio_channels, + function pixel_format, + VideoRange video_range, + bool aligned, + bool fast + ) + : _film (film) + , _player (player) , _prepare_work (new boost::asio::io_service::work (_prepare_service)) , _pending_seek_accurate (false) + , _suspended (0) , _finished (false) , _died (false) , _stop_thread (false) , _audio_mapping (audio_mapping) , _audio_channels (audio_channels) , _disable_audio (false) + , _pixel_format (pixel_format) + , _video_range (video_range) + , _aligned (aligned) + , _fast (fast) { _player_video_connection = _player->Video.connect (bind (&Butler::video, this, _1, _2)); - _player_audio_connection = _player->Audio.connect (bind (&Butler::audio, this, _1, _2)); - _player_text_connection = _player->Text.connect (bind (&Butler::text, this, _1, _2, _3)); - _player_changed_connection = _player->Changed.connect (bind (&Butler::player_changed, this)); - _thread = new boost::thread (bind (&Butler::thread, this)); + _player_audio_connection = _player->Audio.connect (bind (&Butler::audio, this, _1, _2, _3)); + _player_text_connection = _player->Text.connect (bind (&Butler::text, this, _1, _2, _3, _4)); + /* The butler must hear about things first, otherwise it might not sort out suspensions in time for + get_video() to be called in response to this signal. + */ + _player_change_connection = _player->Change.connect (bind (&Butler::player_change, this, _1, _2), boost::signals2::at_front); + _thread = boost::thread (bind(&Butler::thread, this)); #ifdef DCPOMATIC_LINUX - pthread_setname_np (_thread->native_handle(), "butler"); + pthread_setname_np (_thread.native_handle(), "butler"); #endif /* Create some threads to do work on the PlayerVideos we are creating; at present this is used to multi-thread JPEG2000 decoding. */ - LOG_TIMING("start-prepare-threads %1", boost::thread::hardware_concurrency()); - for (size_t i = 0; i < boost::thread::hardware_concurrency(); ++i) { + LOG_TIMING("start-prepare-threads %1", boost::thread::hardware_concurrency() * 2); + + for (size_t i = 0; i < boost::thread::hardware_concurrency() * 2; ++i) { _prepare_pool.create_thread (bind (&boost::asio::io_service::run, &_prepare_service)); } } Butler::~Butler () { + boost::this_thread::disable_interruption dis; + { boost::mutex::scoped_lock lm (_mutex); _stop_thread = true; @@ -91,13 +119,10 @@ Butler::~Butler () _prepare_pool.join_all (); _prepare_service.stop (); - _thread->interrupt (); + _thread.interrupt (); try { - _thread->join (); - } catch (boost::thread_interrupted& e) { - /* No problem */ - } - delete _thread; + _thread.join (); + } catch (...) {} } /** Caller must hold a lock on _mutex */ @@ -106,14 +131,26 @@ Butler::should_run () const { if (_video.size() >= MAXIMUM_VIDEO_READAHEAD * 10) { /* This is way too big */ - throw ProgrammingError - (__FILE__, __LINE__, String::compose ("Butler video buffers reached %1 frames (audio is %2)", _video.size(), _audio.size())); + optional pos = _audio.peek(); + if (pos) { + throw ProgrammingError + (__FILE__, __LINE__, String::compose ("Butler video buffers reached %1 frames (audio is %2 at %3)", _video.size(), _audio.size(), pos->get())); + } else { + throw ProgrammingError + (__FILE__, __LINE__, String::compose ("Butler video buffers reached %1 frames (audio is %2)", _video.size(), _audio.size())); + } } if (_audio.size() >= MAXIMUM_AUDIO_READAHEAD * 10) { /* This is way too big */ - throw ProgrammingError - (__FILE__, __LINE__, String::compose ("Butler audio buffers reached %1 frames (video is %2)", _audio.size(), _video.size())); + optional pos = _audio.peek(); + if (pos) { + throw ProgrammingError + (__FILE__, __LINE__, String::compose ("Butler audio buffers reached %1 frames at %2 (video is %3)", _audio.size(), pos->get(), _video.size())); + } else { + throw ProgrammingError + (__FILE__, __LINE__, String::compose ("Butler audio buffers reached %1 frames (video is %3)", _audio.size(), _video.size())); + } } if (_video.size() >= MAXIMUM_VIDEO_READAHEAD * 2) { @@ -124,7 +161,7 @@ Butler::should_run () const LOG_WARNING ("Butler audio buffers reached %1 frames (video is %2)", _audio.size(), _video.size()); } - if (_stop_thread || _finished || _died) { + if (_stop_thread || _finished || _died || _suspended) { /* Definitely do not run */ return false; } @@ -142,6 +179,8 @@ void Butler::thread () try { + start_of_thread ("Butler"); + while (true) { boost::mutex::scoped_lock lm (_mutex); @@ -178,6 +217,12 @@ try boost::mutex::scoped_lock lm (_mutex); _finished = true; _arrived.notify_all (); +} catch (std::exception& e) { + store_current (); + boost::mutex::scoped_lock lm (_mutex); + _died = true; + _died_message = e.what (); + _arrived.notify_all (); } catch (...) { store_current (); boost::mutex::scoped_lock lm (_mutex); @@ -185,26 +230,49 @@ try _arrived.notify_all (); } +/** @param blocking true if we should block until video is available. If blocking is false + * and no video is immediately available the method will return a 0 PlayerVideo and the error AGAIN. + * @param e if non-0 this is filled with an error code (if an error occurs) or is untouched if no error occurs. + */ pair, DCPTime> -Butler::get_video () +Butler::get_video (bool blocking, Error* e) { boost::mutex::scoped_lock lm (_mutex); + auto setup_error = [this](Error* e, Error::Code fallback) { + if (e) { + if (_died) { + e->code = Error::DIED; + e->message = _died_message; + } else if (_finished) { + e->code = Error::FINISHED; + } else { + e->code = fallback; + } + } + }; + + if (_video.empty() && (_finished || _died || (_suspended && !blocking))) { + setup_error (e, Error::AGAIN); + return make_pair(shared_ptr(), DCPTime()); + } + /* Wait for data if we have none */ while (_video.empty() && !_finished && !_died) { _arrived.wait (lm); } if (_video.empty()) { - return make_pair (shared_ptr(), DCPTime()); + setup_error (e, Error::NONE); + return make_pair(shared_ptr(), DCPTime()); } - pair, DCPTime> const r = _video.get (); + auto const r = _video.get (); _summon.notify_all (); return r; } -optional > +optional Butler::get_closed_caption () { boost::mutex::scoped_lock lm (_mutex); @@ -215,6 +283,7 @@ void Butler::seek (DCPTime position, bool accurate) { boost::mutex::scoped_lock lm (_mutex); + _awaiting = optional(); seek_unlocked (position, accurate); } @@ -229,27 +298,38 @@ Butler::seek_unlocked (DCPTime position, bool accurate) _pending_seek_position = position; _pending_seek_accurate = accurate; - { - boost::mutex::scoped_lock lm (_buffers_mutex); - _video.clear (); - _audio.clear (); - _closed_caption.clear (); - } + _video.clear (); + _audio.clear (); + _closed_caption.clear (); _summon.notify_all (); } void -Butler::prepare (weak_ptr weak_video) const +Butler::prepare (weak_ptr weak_video) +try { - shared_ptr video = weak_video.lock (); + auto video = weak_video.lock (); /* If the weak_ptr cannot be locked the video obviously no longer requires any work */ if (video) { LOG_TIMING("start-prepare in %1", thread_id()); - video->prepare (); + video->prepare (_pixel_format, _video_range, _aligned, _fast); LOG_TIMING("finish-prepare in %1", thread_id()); } } +catch (std::exception& e) +{ + store_current (); + boost::mutex::scoped_lock lm (_mutex); + _died = true; + _died_message = e.what (); +} +catch (...) +{ + store_current (); + boost::mutex::scoped_lock lm (_mutex); + _died = true; +} void Butler::video (shared_ptr video, DCPTime time) @@ -257,29 +337,25 @@ Butler::video (shared_ptr video, DCPTime time) boost::mutex::scoped_lock lm (_mutex); if (_pending_seek_position) { - /* Don't store any video while a seek is pending */ + /* Don't store any video in this case */ return; } _prepare_service.post (bind (&Butler::prepare, this, weak_ptr(video))); - boost::mutex::scoped_lock lm2 (_buffers_mutex); _video.put (video, time); } void -Butler::audio (shared_ptr audio, DCPTime time) +Butler::audio (shared_ptr audio, DCPTime time, int frame_rate) { - { - boost::mutex::scoped_lock lm (_mutex); - if (_pending_seek_position || _disable_audio) { - /* Don't store any audio while a seek is pending, or if audio is disabled */ - return; - } + boost::mutex::scoped_lock lm (_mutex); + if (_pending_seek_position || _disable_audio) { + /* Don't store any audio in these cases */ + return; } - boost::mutex::scoped_lock lm2 (_buffers_mutex); - _audio.put (remap (audio, _audio_channels, _audio_mapping), time); + _audio.put (remap (audio, _audio_channels, _audio_mapping), time, frame_rate); } /** Try to get `frames' frames of audio and copy it into `out'. Silence @@ -289,7 +365,7 @@ Butler::audio (shared_ptr audio, DCPTime time) optional Butler::get_audio (float* out, Frame frames) { - optional t = _audio.get (out, _audio_channels, frames); + auto t = _audio.get (out, _audio_channels, frames); _summon.notify_all (); return t; } @@ -309,35 +385,78 @@ Butler::memory_used () const } void -Butler::player_changed () +Butler::player_change (ChangeType type, int property) { - boost::mutex::scoped_lock lm (_mutex); - if (_died || _pending_seek_position) { + if (property == VideoContentProperty::CROP) { + if (type == ChangeType::DONE) { + auto film = _film.lock(); + if (film) { + _video.reset_metadata (film, _player->video_container_size()); + } + } return; } - DCPTime seek_to; - DCPTime next = _video.get().second; - if (_awaiting && _awaiting > next) { - /* We have recently done a player_changed seek and our buffers haven't been refilled yet, - so assume that we're seeking to the same place as last time. - */ - seek_to = *_awaiting; - } else { - seek_to = next; + boost::mutex::scoped_lock lm (_mutex); + + if (type == ChangeType::PENDING) { + ++_suspended; + } else if (type == ChangeType::DONE) { + --_suspended; + if (_died || _pending_seek_position) { + lm.unlock (); + _summon.notify_all (); + return; + } + + DCPTime seek_to; + auto next = _video.get().second; + if (_awaiting && _awaiting > next) { + /* We have recently done a player_changed seek and our buffers haven't been refilled yet, + so assume that we're seeking to the same place as last time. + */ + seek_to = *_awaiting; + } else { + seek_to = next; + } + + seek_unlocked (seek_to, true); + _awaiting = seek_to; + } else if (type == ChangeType::CANCELLED) { + --_suspended; } - seek_unlocked (seek_to, true); - _awaiting = seek_to; + lm.unlock (); + _summon.notify_all (); } void -Butler::text (PlayerText pt, TextType type, DCPTimePeriod period) +Butler::text (PlayerText pt, TextType type, optional track, DCPTimePeriod period) { - if (type != TEXT_CLOSED_CAPTION) { + if (type != TextType::CLOSED_CAPTION) { return; } - boost::mutex::scoped_lock lm2 (_buffers_mutex); - _closed_caption.put (make_pair(pt, period)); + DCPOMATIC_ASSERT (track); + + _closed_caption.put (pt, *track, period); +} + +string +Butler::Error::summary () const +{ + switch (code) + { + case Error::NONE: + return "No error registered"; + case Error::AGAIN: + return "Butler not ready"; + case Error::DIED: + return String::compose("Butler died (%1)", message); + case Error::FINISHED: + return "Butler finished"; + } + + return ""; } +