X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fbutler.cc;h=3e557cffa1b8a1f9e5e82cddb0d811279cbc2c90;hp=33938ece4025bd1e059715ac916002874245ab55;hb=HEAD;hpb=6abf2fdd53b14608561fcc1900507daea5b79fb7 diff --git a/src/lib/butler.cc b/src/lib/butler.cc index 33938ece4..b2fbc6c60 100644 --- a/src/lib/butler.cc +++ b/src/lib/butler.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2016-2018 Carl Hetherington + Copyright (C) 2016-2021 Carl Hetherington This file is part of DCP-o-matic. @@ -18,27 +18,32 @@ */ + #include "butler.h" -#include "player.h" -#include "util.h" -#include "log.h" -#include "dcpomatic_log.h" -#include "cross.h" #include "compose.hpp" +#include "cross.h" +#include "dcpomatic_log.h" #include "exceptions.h" -#include -#include +#include "log.h" +#include "player.h" +#include "util.h" +#include "video_content.h" + using std::cout; -using std::pair; +using std::function; using std::make_pair; +using std::pair; +using std::shared_ptr; using std::string; -using boost::weak_ptr; -using boost::shared_ptr; +using std::weak_ptr; using boost::bind; using boost::optional; -using boost::function; using namespace dcpomatic; +#if BOOST_VERSION >= 106100 +using namespace boost::placeholders; +#endif + /** Minimum video readahead in frames */ #define MINIMUM_VIDEO_READAHEAD 10 @@ -49,21 +54,27 @@ using namespace dcpomatic; /** 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) + /** @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 alignment Same as above for the `alignment' value. * @param fast Same as above for the `fast' flag. */ Butler::Butler ( - shared_ptr player, + weak_ptr film, + Player& player, AudioMapping audio_mapping, int audio_channels, function pixel_format, - bool aligned, - bool fast + VideoRange video_range, + Image::Alignment alignment, + bool fast, + bool prepare_only_proxy, + Audio audio ) - : _player (player) - , _prepare_work (new boost::asio::io_service::work (_prepare_service)) + : _film (film) + , _player (player) + , _prepare_work (new boost::asio::io_service::work(_prepare_service)) , _pending_seek_accurate (false) , _suspended (0) , _finished (false) @@ -71,18 +82,20 @@ Butler::Butler ( , _stop_thread (false) , _audio_mapping (audio_mapping) , _audio_channels (audio_channels) - , _disable_audio (false) + , _disable_audio (audio == Audio::DISABLED) , _pixel_format (pixel_format) - , _aligned (aligned) + , _video_range (video_range) + , _alignment (alignment) , _fast (fast) + , _prepare_only_proxy (prepare_only_proxy) { - _player_video_connection = _player->Video.connect (bind (&Butler::video, this, _1, _2)); - _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)); + _player_video_connection = _player.Video.connect(bind(&Butler::video, this, _1, _2)); + _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), boost::signals2::at_front); + _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"); @@ -99,6 +112,7 @@ Butler::Butler ( } } + Butler::~Butler () { boost::this_thread::disable_interruption dis; @@ -136,7 +150,7 @@ Butler::should_run () const if (_audio.size() >= MAXIMUM_AUDIO_READAHEAD * 10) { /* This is way too big */ - optional pos = _audio.peek(); + auto 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())); @@ -168,10 +182,13 @@ Butler::should_run () const return (_video.size() < MAXIMUM_VIDEO_READAHEAD) && (_audio.size() < MAXIMUM_AUDIO_READAHEAD); } + void Butler::thread () try { + start_of_thread ("Butler"); + while (true) { boost::mutex::scoped_lock lm (_mutex); @@ -183,7 +200,7 @@ try /* Do any seek that has been requested */ if (_pending_seek_position) { _finished = false; - _player->seek (*_pending_seek_position, _pending_seek_accurate); + _player.seek(*_pending_seek_position, _pending_seek_accurate); _pending_seek_position = optional (); } @@ -193,7 +210,7 @@ try */ while (should_run() && !_pending_seek_position) { lm.unlock (); - bool const r = _player->pass (); + bool const r = _player.pass(); lm.lock (); if (r) { _finished = true; @@ -221,19 +238,31 @@ try _arrived.notify_all (); } -/** @param blocking true if we should block until video is available. If blocking is false + +/** @param behaviour BLOCKING if we should block until video is available. If behaviour is NON_BLOCKING * 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 (bool blocking, Error* e) +Butler::get_video (Behaviour behaviour, Error* e) { boost::mutex::scoped_lock lm (_mutex); - if (_suspended || (_video.empty() && !blocking)) { + auto setup_error = [this](Error* e, Error::Code fallback) { if (e) { - e->code = Error::AGAIN; + if (_died) { + e->code = Error::Code::DIED; + e->message = _died_message; + } else if (_finished) { + e->code = Error::Code::FINISHED; + } else { + e->code = fallback; + } } + }; + + if (_video.empty() && (_finished || _died || (_suspended && behaviour == Behaviour::NON_BLOCKING))) { + setup_error (e, Error::Code::AGAIN); return make_pair(shared_ptr(), DCPTime()); } @@ -243,24 +272,16 @@ Butler::get_video (bool blocking, Error* e) } if (_video.empty()) { - if (e) { - if (_died) { - e->code = Error::DIED; - e->message = _died_message; - } else if (_finished) { - e->code = Error::FINISHED; - } else { - e->code = Error::NONE; - } - } + setup_error (e, Error::Code::NONE); return make_pair(shared_ptr(), DCPTime()); } - pair, DCPTime> const r = _video.get (); + auto const r = _video.get (); _summon.notify_all (); return r; } + optional Butler::get_closed_caption () { @@ -268,6 +289,7 @@ Butler::get_closed_caption () return _closed_caption.get (); } + void Butler::seek (DCPTime position, bool accurate) { @@ -276,6 +298,7 @@ Butler::seek (DCPTime position, bool accurate) seek_unlocked (position, accurate); } + void Butler::seek_unlocked (DCPTime position, bool accurate) { @@ -294,15 +317,16 @@ Butler::seek_unlocked (DCPTime position, bool accurate) _summon.notify_all (); } + void 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 (_pixel_format, _aligned, _fast); + video->prepare (_pixel_format, _video_range, _alignment, _fast, _prepare_only_proxy); LOG_TIMING("finish-prepare in %1", thread_id()); } } @@ -320,6 +344,7 @@ catch (...) _died = true; } + void Butler::video (shared_ptr video, DCPTime time) { @@ -330,11 +355,12 @@ Butler::video (shared_ptr video, DCPTime time) return; } - _prepare_service.post (bind (&Butler::prepare, this, weak_ptr(video))); + _prepare_service.post (bind(&Butler::prepare, this, weak_ptr(video))); _video.put (video, time); } + void Butler::audio (shared_ptr audio, DCPTime time, int frame_rate) { @@ -344,27 +370,30 @@ Butler::audio (shared_ptr audio, DCPTime time, int frame_rate) return; } - _audio.put (remap (audio, _audio_channels, _audio_mapping), time, frame_rate); + _audio.put (remap(audio, _audio_channels, _audio_mapping), time, frame_rate); } -/** Try to get `frames' frames of audio and copy it into `out'. Silence - * will be filled if no audio is available. - * @return time of this audio, or unset if there was a buffer underrun. + +/** Try to get `frames' frames of audio and copy it into `out'. + * @param behaviour BLOCKING if we should block until audio is available. If behaviour is NON_BLOCKING + * and no audio is immediately available the buffer will be filled with silence and boost::none + * will be returned. + * @return time of this audio, or unset if blocking was false and no data was available. */ optional -Butler::get_audio (float* out, Frame frames) +Butler::get_audio (Behaviour behaviour, float* out, Frame frames) { - optional t = _audio.get (out, _audio_channels, frames); + boost::mutex::scoped_lock lm (_mutex); + + while (behaviour == Behaviour::BLOCKING && !_finished && !_died && _audio.size() < frames) { + _arrived.wait (lm); + } + + auto t = _audio.get (out, _audio_channels, frames); _summon.notify_all (); return t; } -void -Butler::disable_audio () -{ - boost::mutex::scoped_lock lm (_mutex); - _disable_audio = true; -} pair Butler::memory_used () const @@ -373,14 +402,25 @@ Butler::memory_used () const return _video.memory_used(); } + void -Butler::player_change (ChangeType type) +Butler::player_change (ChangeType type, int property) { + if (property == VideoContentProperty::CROP) { + if (type == ChangeType::DONE) { + auto film = _film.lock(); + if (film) { + _video.reset_metadata(film, _player.video_container_size()); + } + } + return; + } + boost::mutex::scoped_lock lm (_mutex); - if (type == CHANGE_TYPE_PENDING) { + if (type == ChangeType::PENDING) { ++_suspended; - } else if (type == CHANGE_TYPE_DONE) { + } else if (type == ChangeType::DONE) { --_suspended; if (_died || _pending_seek_position) { lm.unlock (); @@ -389,7 +429,7 @@ Butler::player_change (ChangeType type) } DCPTime seek_to; - DCPTime next = _video.get().second; + 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. @@ -401,7 +441,7 @@ Butler::player_change (ChangeType type) seek_unlocked (seek_to, true); _awaiting = seek_to; - } else if (type == CHANGE_TYPE_CANCELLED) { + } else if (type == ChangeType::CANCELLED) { --_suspended; } @@ -409,10 +449,11 @@ Butler::player_change (ChangeType type) _summon.notify_all (); } + void Butler::text (PlayerText pt, TextType type, optional track, DCPTimePeriod period) { - if (type != TEXT_CLOSED_CAPTION) { + if (type != TextType::CLOSED_CAPTION) { return; } @@ -421,18 +462,19 @@ Butler::text (PlayerText pt, TextType type, optional track, DCPTim _closed_caption.put (pt, *track, period); } + string Butler::Error::summary () const { switch (code) { - case Error::NONE: + case Error::Code::NONE: return "No error registered"; - case Error::AGAIN: + case Error::Code::AGAIN: return "Butler not ready"; - case Error::DIED: + case Error::Code::DIED: return String::compose("Butler died (%1)", message); - case Error::FINISHED: + case Error::Code::FINISHED: return "Butler finished"; }