X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=ae79a457f428f6330121c77833f38c1a4f512626;hb=835dd8938830b615d5b3e66272eb56d60bf7c45f;hp=810d949d971278e81512138a203b78b9e743c3a0;hpb=9bfa07293928c371d59db2091ba2b7e715ce5994;p=dcpomatic.git diff --git a/src/lib/player.cc b/src/lib/player.cc index 810d949d9..ae79a457f 100644 --- a/src/lib/player.cc +++ b/src/lib/player.cc @@ -20,46 +20,47 @@ #include "atmos_decoder.h" -#include "player.h" -#include "film.h" #include "audio_buffers.h" +#include "audio_content.h" +#include "audio_decoder.h" +#include "audio_processor.h" +#include "compose.hpp" +#include "config.h" #include "content_audio.h" +#include "content_video.h" #include "dcp_content.h" +#include "dcp_decoder.h" #include "dcpomatic_log.h" -#include "job.h" +#include "decoder.h" +#include "decoder_factory.h" +#include "ffmpeg_content.h" +#include "film.h" +#include "frame_rate_change.h" #include "image.h" -#include "raw_image_proxy.h" -#include "ratio.h" +#include "image_decoder.h" +#include "job.h" #include "log.h" -#include "render_text.h" -#include "config.h" -#include "content_video.h" +#include "maths_util.h" +#include "piece.h" +#include "player.h" #include "player_video.h" -#include "frame_rate_change.h" -#include "audio_processor.h" #include "playlist.h" -#include "referenced_reel_asset.h" -#include "decoder_factory.h" -#include "decoder.h" -#include "video_decoder.h" -#include "audio_decoder.h" +#include "ratio.h" +#include "raw_image_proxy.h" +#include "render_text.h" +#include "shuffler.h" #include "text_content.h" #include "text_decoder.h" -#include "ffmpeg_content.h" -#include "audio_content.h" -#include "dcp_decoder.h" -#include "image_decoder.h" -#include "compose.hpp" -#include "shuffler.h" #include "timer.h" +#include "video_decoder.h" #include +#include +#include #include #include -#include -#include -#include #include #include +#include #include "i18n.h" @@ -70,15 +71,12 @@ using std::dynamic_pointer_cast; using std::list; using std::make_pair; using std::make_shared; -using std::map; using std::max; using std::min; -using std::min; using std::pair; using std::shared_ptr; using std::vector; using std::weak_ptr; -using std::make_shared; using boost::optional; using boost::scoped_ptr; #if BOOST_VERSION >= 106100 @@ -95,12 +93,18 @@ int const PlayerProperty::DCP_DECODE_REDUCTION = 704; int const PlayerProperty::PLAYBACK_LENGTH = 705; -Player::Player (shared_ptr film, bool aligned) +Player::Player (shared_ptr film, Image::Alignment subtitle_alignment) : _film (film) , _suspended (0) + , _ignore_video(false) + , _ignore_audio(false) + , _ignore_text(false) + , _always_burn_open_subtitles(false) + , _fast(false) , _tolerant (film->tolerant()) + , _play_referenced(false) , _audio_merger (_film->audio_frame_rate()) - , _aligned_subtitles (aligned) + , _subtitle_alignment (subtitle_alignment) { construct (); } @@ -110,7 +114,13 @@ Player::Player (shared_ptr film, shared_ptr playlist : _film (film) , _playlist (playlist_) , _suspended (0) + , _ignore_video(false) + , _ignore_audio(false) + , _ignore_text(false) + , _always_burn_open_subtitles(false) + , _fast(false) , _tolerant (film->tolerant()) + , _play_referenced(false) , _audio_merger (_film->audio_frame_rate()) { construct (); @@ -135,38 +145,43 @@ Player::construct () } -void -Player::setup_pieces () -{ - boost::mutex::scoped_lock lm (_mutex); - setup_pieces_unlocked (); -} - - bool have_video (shared_ptr content) { - return static_cast(content->video) && content->video->use(); + return static_cast(content->video) && content->video->use() && content->can_be_played(); } bool have_audio (shared_ptr content) { - return static_cast(content->audio); + return static_cast(content->audio) && content->can_be_played(); } void -Player::setup_pieces_unlocked () +Player::setup_pieces () { + boost::mutex::scoped_lock lm (_mutex); + _playback_length = _playlist ? _playlist->length(_film) : _film->length(); auto old_pieces = _pieces; _pieces.clear (); - _shuffler.reset (new Shuffler()); - _shuffler->Video.connect(bind(&Player::video, this, _1, _2)); + auto playlist_content = playlist()->content(); + bool const have_threed = std::any_of( + playlist_content.begin(), + playlist_content.end(), + [](shared_ptr c) { + return c->video && (c->video->frame_type() == VideoFrameType::THREE_D_LEFT || c->video->frame_type() == VideoFrameType::THREE_D_RIGHT); + }); + + + if (have_threed) { + _shuffler.reset(new Shuffler()); + _shuffler->Video.connect(bind(&Player::video, this, _1, _2)); + } for (auto i: playlist()->content()) { @@ -218,7 +233,7 @@ Player::setup_pieces_unlocked () _pieces.push_back (piece); if (decoder->video) { - if (i->video->frame_type() == VideoFrameType::THREE_D_LEFT || i->video->frame_type() == VideoFrameType::THREE_D_RIGHT) { + if (have_threed) { /* We need a Shuffler to cope with 3D L/R video data arriving out of sequence */ decoder->video->Data.connect (bind(&Shuffler::video, _shuffler.get(), weak_ptr(piece), _1)); } else { @@ -260,17 +275,17 @@ Player::setup_pieces_unlocked () } } + auto ignore_overlap = [](shared_ptr v) { + return v && v->use() && v->frame_type() != VideoFrameType::THREE_D_LEFT && v->frame_type() != VideoFrameType::THREE_D_RIGHT; + }; + for (auto i = _pieces.begin(); i != _pieces.end(); ++i) { - if (auto video = (*i)->content->video) { - if (video->use() && video->frame_type() != VideoFrameType::THREE_D_LEFT && video->frame_type() != VideoFrameType::THREE_D_RIGHT) { - /* Look for content later in the content list with in-use video that overlaps this */ - auto period = DCPTimePeriod((*i)->content->position(), (*i)->content->end(_film)); - auto j = i; - ++j; - for (; j != _pieces.end(); ++j) { - if ((*j)->content->video && (*j)->content->video->use()) { - (*i)->ignore_video = DCPTimePeriod((*j)->content->position(), (*j)->content->end(_film)).overlap(period); - } + if (ignore_overlap((*i)->content->video)) { + /* Look for content later in the content list with in-use video that overlaps this */ + auto const period = DCPTimePeriod((*i)->content->position(), (*i)->content->end(_film)); + for (auto j = std::next(i); j != _pieces.end(); ++j) { + if ((*j)->content->video && ignore_overlap((*j)->content->video)) { + (*i)->ignore_video = DCPTimePeriod((*j)->content->position(), (*j)->content->end(_film)).overlap(period); } } } @@ -279,9 +294,8 @@ Player::setup_pieces_unlocked () _black = Empty (_film, playlist(), bind(&have_video, _1), _playback_length); _silent = Empty (_film, playlist(), bind(&have_audio, _1), _playback_length); - _last_video_time = boost::optional(); - _last_video_eyes = Eyes::BOTH; - _last_audio_time = boost::optional(); + _next_video_time = boost::none; + _next_audio_time = boost::none; } @@ -290,10 +304,9 @@ Player::playlist_content_change (ChangeType type, int property, bool frequent) { if (property == VideoContentProperty::CROP) { if (type == ChangeType::DONE) { - auto const vcs = video_container_size(); boost::mutex::scoped_lock lm (_mutex); for (auto const& i: _delay) { - i.first->reset_metadata (_film, vcs); + i.first->reset_metadata(_film, _video_container_size); } } } else { @@ -321,18 +334,16 @@ Player::set_video_container_size (dcp::Size s) { Change (ChangeType::PENDING, PlayerProperty::VIDEO_CONTAINER_SIZE, false); - { - boost::mutex::scoped_lock lm (_mutex); - - if (s == _video_container_size) { - lm.unlock (); - Change (ChangeType::CANCELLED, PlayerProperty::VIDEO_CONTAINER_SIZE, false); - return; - } + if (s == _video_container_size) { + Change(ChangeType::CANCELLED, PlayerProperty::VIDEO_CONTAINER_SIZE, false); + return; + } - _video_container_size = s; + _video_container_size = s; - _black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true)); + { + boost::mutex::scoped_lock lm(_black_image_mutex); + _black_image = make_shared(AV_PIX_FMT_RGB24, _video_container_size, Image::Alignment::PADDED); _black_image->make_black (); } @@ -385,8 +396,10 @@ Player::film_change (ChangeType type, Film::Property p) shared_ptr Player::black_player_video_frame (Eyes eyes) const { + boost::mutex::scoped_lock lm(_black_image_mutex); + return std::make_shared ( - std::make_shared(_black_image), + make_shared(_black_image), Crop(), optional(), _video_container_size, @@ -396,7 +409,7 @@ Player::black_player_video_frame (Eyes eyes) const PresetColourConversion::all().front().conversion, VideoRange::FULL, std::weak_ptr(), - boost::optional(), + boost::optional(), false ); } @@ -465,18 +478,17 @@ Player::content_time_to_dcp (shared_ptr piece, ContentTime t) const } -vector +vector> Player::get_subtitle_fonts () { boost::mutex::scoped_lock lm (_mutex); - vector fonts; - for (auto i: _pieces) { - /* XXX: things may go wrong if there are duplicate font IDs - with different font files. - */ - auto f = i->decoder->fonts (); - copy (f.begin(), f.end(), back_inserter(fonts)); + vector> fonts; + for (auto piece: _pieces) { + for (auto text: piece->content->text) { + auto text_fonts = text->fonts(); + copy (text_fonts.begin(), text_fonts.end(), back_inserter(fonts)); + } } return fonts; @@ -487,27 +499,24 @@ Player::get_subtitle_fonts () void Player::set_ignore_video () { - boost::mutex::scoped_lock lm (_mutex); _ignore_video = true; - setup_pieces_unlocked (); + setup_pieces(); } void Player::set_ignore_audio () { - boost::mutex::scoped_lock lm (_mutex); _ignore_audio = true; - setup_pieces_unlocked (); + setup_pieces(); } void Player::set_ignore_text () { - boost::mutex::scoped_lock lm (_mutex); _ignore_text = true; - setup_pieces_unlocked (); + setup_pieces(); } @@ -515,7 +524,6 @@ Player::set_ignore_text () void Player::set_always_burn_open_subtitles () { - boost::mutex::scoped_lock lm (_mutex); _always_burn_open_subtitles = true; } @@ -524,104 +532,16 @@ Player::set_always_burn_open_subtitles () void Player::set_fast () { - boost::mutex::scoped_lock lm (_mutex); _fast = true; - setup_pieces_unlocked (); + setup_pieces(); } void Player::set_play_referenced () { - boost::mutex::scoped_lock lm (_mutex); _play_referenced = true; - setup_pieces_unlocked (); -} - - -static void -maybe_add_asset (list& a, shared_ptr r, Frame reel_trim_start, Frame reel_trim_end, DCPTime from, int const ffr) -{ - DCPOMATIC_ASSERT (r); - r->set_entry_point (r->entry_point().get_value_or(0) + reel_trim_start); - r->set_duration (r->actual_duration() - reel_trim_start - reel_trim_end); - if (r->actual_duration() > 0) { - a.push_back ( - ReferencedReelAsset(r, DCPTimePeriod(from, from + DCPTime::from_frames(r->actual_duration(), ffr))) - ); - } -} - - -list -Player::get_reel_assets () -{ - /* Does not require a lock on _mutex as it's only called from DCPEncoder */ - - list a; - - for (auto i: playlist()->content()) { - auto j = dynamic_pointer_cast (i); - if (!j) { - continue; - } - - scoped_ptr decoder; - try { - decoder.reset (new DCPDecoder(_film, j, false, false, shared_ptr())); - } catch (...) { - return a; - } - - DCPOMATIC_ASSERT (j->video_frame_rate ()); - double const cfr = j->video_frame_rate().get(); - Frame const trim_start = j->trim_start().frames_round (cfr); - Frame const trim_end = j->trim_end().frames_round (cfr); - int const ffr = _film->video_frame_rate (); - - /* position in the asset from the start */ - int64_t offset_from_start = 0; - /* position in the asset from the end */ - int64_t offset_from_end = 0; - for (auto k: decoder->reels()) { - /* Assume that main picture duration is the length of the reel */ - offset_from_end += k->main_picture()->actual_duration(); - } - - for (auto k: decoder->reels()) { - - /* Assume that main picture duration is the length of the reel */ - int64_t const reel_duration = k->main_picture()->actual_duration(); - - /* See doc/design/trim_reels.svg */ - Frame const reel_trim_start = min(reel_duration, max(int64_t(0), trim_start - offset_from_start)); - Frame const reel_trim_end = min(reel_duration, max(int64_t(0), reel_duration - (offset_from_end - trim_end))); - - auto const from = i->position() + DCPTime::from_frames (offset_from_start, _film->video_frame_rate()); - if (j->reference_video ()) { - maybe_add_asset (a, k->main_picture(), reel_trim_start, reel_trim_end, from, ffr); - } - - if (j->reference_audio ()) { - maybe_add_asset (a, k->main_sound(), reel_trim_start, reel_trim_end, from, ffr); - } - - if (j->reference_text (TextType::OPEN_SUBTITLE)) { - maybe_add_asset (a, k->main_subtitle(), reel_trim_start, reel_trim_end, from, ffr); - } - - if (j->reference_text (TextType::CLOSED_CAPTION)) { - for (auto l: k->closed_captions()) { - maybe_add_asset (a, l, reel_trim_start, reel_trim_end, from, ffr); - } - } - - offset_from_start += reel_duration; - offset_from_end -= reel_duration; - } - } - - return a; + setup_pieces(); } @@ -636,9 +556,9 @@ Player::pass () return false; } - if (_playback_length == DCPTime()) { + if (_playback_length.load() == DCPTime()) { /* Special; just give one black frame */ - emit_video (black_player_video_frame(Eyes::BOTH), DCPTime()); + use_video(black_player_video_frame(Eyes::BOTH), DCPTime(), one_video_frame()); return true; } @@ -696,38 +616,43 @@ Player::pass () LOG_DEBUG_PLAYER ("Calling pass() on %1", earliest_content->content->path(0)); earliest_content->done = earliest_content->decoder->pass (); auto dcp = dynamic_pointer_cast(earliest_content->content); - if (dcp && !_play_referenced && dcp->reference_audio()) { - /* We are skipping some referenced DCP audio content, so we need to update _last_audio_time - to `hide' the fact that no audio was emitted during the referenced DCP (though - we need to behave as though it was). - */ - _last_audio_time = dcp->end (_film); + if (dcp && !_play_referenced) { + if (dcp->reference_video()) { + _next_video_time = dcp->end(_film); + } + if (dcp->reference_audio()) { + /* We are skipping some referenced DCP audio content, so we need to update _next_audio_time + to `hide' the fact that no audio was emitted during the referenced DCP (though + we need to behave as though it was). + */ + _next_audio_time = dcp->end(_film); + } } break; } case BLACK: LOG_DEBUG_PLAYER ("Emit black for gap at %1", to_string(_black.position())); - emit_video (black_player_video_frame(Eyes::BOTH), _black.position()); + use_video(black_player_video_frame(Eyes::BOTH), _black.position(), _black.period_at_position().to); _black.set_position (_black.position() + one_video_frame()); break; case SILENT: { LOG_DEBUG_PLAYER ("Emit silence for gap at %1", to_string(_silent.position())); DCPTimePeriod period (_silent.period_at_position()); - if (_last_audio_time) { + if (_next_audio_time) { /* Sometimes the thing that happened last finishes fractionally before or after this silence. Bodge the start time of the silence to fix it. I think this is nothing to worry about since we will just add or remove a little silence at the end of some content. */ - int64_t const error = labs(period.from.get() - _last_audio_time->get()); + int64_t const error = labs(period.from.get() - _next_audio_time->get()); /* Let's not worry about less than a frame at 24fps */ int64_t const too_much_error = DCPTime::from_frames(1, 24).get(); if (error >= too_much_error) { _film->log()->log(String::compose("Silence starting before or after last audio by %1", error), LogEntry::TYPE_ERROR); } DCPOMATIC_ASSERT (error < too_much_error); - period.from = *_last_audio_time; + period.from = *_next_audio_time; } if (period.duration() > one_video_frame()) { period.to = period.from + one_video_frame(); @@ -744,10 +669,38 @@ Player::pass () /* Emit any audio that is ready */ /* Work out the time before which the audio is definitely all here. This is the earliest last_push_end of one - of our streams, or the position of the _silent. + of our streams, or the position of the _silent. First, though we choose only streams that are less than + ignore_streams_behind seconds behind the furthest ahead (we assume that if a stream has fallen that far + behind it has finished). This is so that we don't withhold audio indefinitely awaiting data from a stream + that will never come, causing bugs like #2101. */ - auto pull_to = _playback_length; + constexpr int ignore_streams_behind = 5; + + using state_pair = std::pair; + + /* Find the 'leading' stream (i.e. the one that pushed data most recently) */ + auto latest_last_push_end = std::max_element( + _stream_states.begin(), + _stream_states.end(), + [](state_pair const& a, state_pair const& b) { return a.second.last_push_end < b.second.last_push_end; } + ); + + if (latest_last_push_end != _stream_states.end()) { + LOG_DEBUG_PLAYER("Leading audio stream is in %1 at %2", latest_last_push_end->second.piece->content->path(0), to_string(latest_last_push_end->second.last_push_end)); + } + + /* Now make a list of those streams that are less than ignore_streams_behind behind the leader */ + std::map alive_stream_states; for (auto const& i: _stream_states) { + if ((latest_last_push_end->second.last_push_end - i.second.last_push_end) < dcpomatic::DCPTime::from_seconds(ignore_streams_behind)) { + alive_stream_states.insert(i); + } else { + LOG_DEBUG_PLAYER("Ignoring stream %1 because it is too far behind", i.second.piece->content->path(0)); + } + } + + auto pull_to = _playback_length.load(); + for (auto const& i: alive_stream_states) { if (!i.second.piece->done && i.second.last_push_end < pull_to) { pull_to = i.second.last_push_end; } @@ -759,25 +712,29 @@ Player::pass () LOG_DEBUG_PLAYER("Emitting audio up to %1", to_string(pull_to)); auto audio = _audio_merger.pull (pull_to); for (auto i = audio.begin(); i != audio.end(); ++i) { - if (_last_audio_time && i->second < *_last_audio_time) { + if (_next_audio_time && i->second < *_next_audio_time) { /* This new data comes before the last we emitted (or the last seek); discard it */ - auto cut = discard_audio (i->first, i->second, *_last_audio_time); + auto cut = discard_audio (i->first, i->second, *_next_audio_time); if (!cut.first) { continue; } *i = cut; - } else if (_last_audio_time && i->second > *_last_audio_time) { + } else if (_next_audio_time && i->second > *_next_audio_time) { /* There's a gap between this data and the last we emitted; fill with silence */ - fill_audio (DCPTimePeriod (*_last_audio_time, i->second)); + fill_audio (DCPTimePeriod (*_next_audio_time, i->second)); } emit_audio (i->first, i->second); } if (done) { - _shuffler->flush (); + emit_video_until(_film->length()); + + if (_shuffler) { + _shuffler->flush (); + } for (auto const& i: _delay) { - do_emit_video(i.first, i.second); + emit_video(i.first, i.second); } } @@ -794,7 +751,7 @@ Player::open_subtitles_for_frame (DCPTime time) const for ( auto j: - _active_texts[static_cast(TextType::OPEN_SUBTITLE)].get_burnt(DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_open_subtitles) + _active_texts[TextType::OPEN_SUBTITLE].get_burnt(DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_open_subtitles) ) { /* Bitmap subtitles */ @@ -804,14 +761,14 @@ Player::open_subtitles_for_frame (DCPTime time) const } /* i.image will already have been scaled to fit _video_container_size */ - dcp::Size scaled_size (i.rectangle.width * _video_container_size.width, i.rectangle.height * _video_container_size.height); + dcp::Size scaled_size (i.rectangle.width * _video_container_size.load().width, i.rectangle.height * _video_container_size.load().height); captions.push_back ( PositionImage ( i.image, Position ( - lrint(_video_container_size.width * i.rectangle.x), - lrint(_video_container_size.height * i.rectangle.y) + lrint(_video_container_size.load().width * i.rectangle.x), + lrint(_video_container_size.load().height * i.rectangle.y) ) ) ); @@ -819,7 +776,7 @@ Player::open_subtitles_for_frame (DCPTime time) const /* String subtitles (rendered to an image) */ if (!j.string.empty()) { - auto s = render_text (j.string, j.fonts, _video_container_size, time, vfr); + auto s = render_text(j.string, _video_container_size, time, vfr); copy (s.begin(), s.end(), back_inserter (captions)); } } @@ -828,18 +785,69 @@ Player::open_subtitles_for_frame (DCPTime time) const return {}; } - return merge (captions, _aligned_subtitles); + return merge (captions, _subtitle_alignment); } void -Player::video (weak_ptr wp, ContentVideo video) +Player::emit_video_until(DCPTime time) +{ + auto frame = [this](shared_ptr pv, DCPTime time) { + /* We need a delay to give a little wiggle room to ensure that relevant subtitles arrive at the + player before the video that requires them. + */ + _delay.push_back(make_pair(pv, time)); + + if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) { + _next_video_time = time + one_video_frame(); + } + + if (_delay.size() < 3) { + return; + } + + auto to_do = _delay.front(); + _delay.pop_front(); + emit_video(to_do.first, to_do.second); + }; + + auto const age_threshold = one_video_frame() * 2; + + while (_next_video_time.get_value_or({}) < time) { + auto left = _last_video[Eyes::LEFT]; + auto right = _last_video[Eyes::RIGHT]; + auto both = _last_video[Eyes::BOTH]; + + auto const next = _next_video_time.get_value_or({}); + + if ( + left.first && + right.first && + (!both.first || (left.second >= both.second && right.second >= both.second)) && + (left.second - next) < age_threshold && + (right.second - next) < age_threshold + ) { + frame(left.first, next); + frame(right.first, next); + } else if (both.first && (both.second - next) < age_threshold) { + frame(both.first, next); + LOG_DEBUG_PLAYER("Content %1 selected for DCP %2 (age %3)", to_string(both.second), to_string(next), to_string(both.second - next)); + } else { + frame(black_player_video_frame(Eyes::BOTH), next); + LOG_DEBUG_PLAYER("Black selected for DCP %1", to_string(next)); + } + } +} + + +void +Player::video (weak_ptr weak_piece, ContentVideo video) { if (_suspended) { return; } - auto piece = wp.lock (); + auto piece = weak_piece.lock (); if (!piece) { return; } @@ -848,20 +856,25 @@ Player::video (weak_ptr wp, ContentVideo video) return; } - FrameRateChange frc (_film, piece->content); - if (frc.skip && (video.frame % 2) == 1) { - return; + auto const three_d = _film->three_d(); + + if (!three_d) { + if (video.eyes == Eyes::LEFT) { + /* Use left-eye images for both eyes... */ + video.eyes = Eyes::BOTH; + } else if (video.eyes == Eyes::RIGHT) { + /* ...and discard the right */ + return; + } } - /* Time of the first frame we will emit */ - DCPTime const time = content_video_to_dcp (piece, video.frame); - LOG_DEBUG_PLAYER("Received video frame %1 at %2", video.frame, to_string(time)); + FrameRateChange frc (_film, piece->content); + + /* Time of the frame we just received within the DCP */ + auto const time = content_time_to_dcp(piece, video.time); + LOG_DEBUG_PLAYER("Received video frame %1 %2 eyes %3", to_string(video.time), to_string(time), static_cast(video.eyes)); - /* Discard if it's before the content's period or the last accurate seek. We can't discard - if it's after the content's period here as in that case we still need to fill any gap between - `now' and the end of the content's period. - */ - if (time < piece->content->position() || (_last_video_time && time < *_last_video_time)) { + if (time < piece->content->position()) { return; } @@ -869,85 +882,49 @@ Player::video (weak_ptr wp, ContentVideo video) return; } - /* Fill gaps that we discover now that we have some video which needs to be emitted. - This is where we need to fill to. - */ - DCPTime fill_to = min (time, piece->content->end(_film)); - - if (_last_video_time) { - DCPTime fill_from = max (*_last_video_time, piece->content->position()); - - /* Fill if we have more than half a frame to do */ - if ((fill_to - fill_from) > one_video_frame() / 2) { - auto last = _last_video.find (wp); - if (_film->three_d()) { - auto fill_to_eyes = video.eyes; - if (fill_to_eyes == Eyes::BOTH) { - fill_to_eyes = Eyes::LEFT; - } - if (fill_to == piece->content->end(_film)) { - /* Don't fill after the end of the content */ - fill_to_eyes = Eyes::LEFT; - } - auto j = fill_from; - auto eyes = _last_video_eyes.get_value_or(Eyes::LEFT); - if (eyes == Eyes::BOTH) { - eyes = Eyes::LEFT; - } - while (j < fill_to || eyes != fill_to_eyes) { - if (last != _last_video.end()) { - LOG_DEBUG_PLAYER("Fill using last video at %1 in 3D mode", to_string(j)); - auto copy = last->second->shallow_copy(); - copy->set_eyes (eyes); - emit_video (copy, j); - } else { - LOG_DEBUG_PLAYER("Fill using black at %1 in 3D mode", to_string(j)); - emit_video (black_player_video_frame(eyes), j); - } - if (eyes == Eyes::RIGHT) { - j += one_video_frame(); - } - eyes = increment_eyes (eyes); - } - } else { - for (DCPTime j = fill_from; j < fill_to; j += one_video_frame()) { - if (last != _last_video.end()) { - emit_video (last->second, j); - } else { - emit_video (black_player_video_frame(Eyes::BOTH), j); - } - } - } - } - } + if (!_next_video_time) { + _next_video_time = time.round(_film->video_frame_rate()); + } + + auto const content_video = piece->content->video; + use_video( + std::make_shared( + video.image, + content_video->actual_crop(), + content_video->fade(_film, video.time), + scale_for_display( + content_video->scaled_size(_film->frame_size()), + _video_container_size, + _film->frame_size(), + content_video->pixel_quanta() + ), + _video_container_size, + video.eyes, + video.part, + content_video->colour_conversion(), + content_video->range(), + piece->content, + video.time, + false + ), + time, + piece->content->end(_film) + ); +} - _last_video[wp] = std::make_shared( - video.image, - piece->content->video->crop (), - piece->content->video->fade (_film, video.frame), - scale_for_display(piece->content->video->scaled_size(_film->frame_size()), _video_container_size, _film->frame_size()), - _video_container_size, - video.eyes, - video.part, - piece->content->video->colour_conversion(), - piece->content->video->range(), - piece->content, - video.frame, - false - ); - DCPTime t = time; - for (int i = 0; i < frc.repeat; ++i) { - if (t < piece->content->end(_film)) { - emit_video (_last_video[wp], t); - } - t += one_video_frame (); +void +Player::use_video(shared_ptr pv, DCPTime time, DCPTime end) +{ + _last_video[pv->eyes()] = { pv, time }; + if (pv->eyes() != Eyes::LEFT) { + emit_video_until(std::min(time + one_video_frame() / 2, end)); } } void -Player::audio (weak_ptr wp, AudioStreamPtr stream, ContentAudio content_audio) +Player::audio (weak_ptr weak_piece, AudioStreamPtr stream, ContentAudio content_audio) { if (_suspended) { return; @@ -955,7 +932,7 @@ Player::audio (weak_ptr wp, AudioStreamPtr stream, ContentAudio content_a DCPOMATIC_ASSERT (content_audio.audio->frames() > 0); - auto piece = wp.lock (); + auto piece = weak_piece.lock (); if (!piece) { return; } @@ -994,12 +971,28 @@ Player::audio (weak_ptr wp, AudioStreamPtr stream, ContentAudio content_a DCPOMATIC_ASSERT (content_audio.audio->frames() > 0); - /* Gain */ - - if (content->gain() != 0) { - auto gain = make_shared(content_audio.audio); - gain->apply_gain (content->gain()); - content_audio.audio = gain; + /* Gain and fade */ + + auto const fade_coeffs = content->fade (stream, content_audio.frame, content_audio.audio->frames(), rfr); + if (content->gain() != 0 || !fade_coeffs.empty()) { + auto gain_buffers = make_shared(content_audio.audio); + if (!fade_coeffs.empty()) { + /* Apply both fade and gain */ + DCPOMATIC_ASSERT (fade_coeffs.size() == static_cast(gain_buffers->frames())); + auto const channels = gain_buffers->channels(); + auto const frames = fade_coeffs.size(); + auto data = gain_buffers->data(); + auto const gain = db_to_linear (content->gain()); + for (auto channel = 0; channel < channels; ++channel) { + for (auto frame = 0U; frame < frames; ++frame) { + data[channel][frame] *= gain * fade_coeffs[frame]; + } + } + } else { + /* Just apply gain */ + gain_buffers->apply_gain (content->gain()); + } + content_audio.audio = gain_buffers; } /* Remap */ @@ -1021,58 +1014,61 @@ Player::audio (weak_ptr wp, AudioStreamPtr stream, ContentAudio content_a void -Player::bitmap_text_start (weak_ptr wp, weak_ptr wc, ContentBitmapText subtitle) +Player::bitmap_text_start (weak_ptr weak_piece, weak_ptr weak_content, ContentBitmapText subtitle) { if (_suspended) { return; } - auto piece = wp.lock (); - auto text = wc.lock (); - if (!piece || !text) { + auto piece = weak_piece.lock (); + auto content = weak_content.lock (); + if (!piece || !content) { return; } - /* Apply content's subtitle offsets */ - subtitle.sub.rectangle.x += text->x_offset (); - subtitle.sub.rectangle.y += text->y_offset (); + PlayerText ps; + for (auto& sub: subtitle.subs) + { + /* Apply content's subtitle offsets */ + sub.rectangle.x += content->x_offset (); + sub.rectangle.y += content->y_offset (); - /* Apply a corrective translation to keep the subtitle centred after the scale that is coming up */ - subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * ((text->x_scale() - 1) / 2); - subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * ((text->y_scale() - 1) / 2); + /* Apply a corrective translation to keep the subtitle centred after the scale that is coming up */ + sub.rectangle.x -= sub.rectangle.width * ((content->x_scale() - 1) / 2); + sub.rectangle.y -= sub.rectangle.height * ((content->y_scale() - 1) / 2); - /* Apply content's subtitle scale */ - subtitle.sub.rectangle.width *= text->x_scale (); - subtitle.sub.rectangle.height *= text->y_scale (); + /* Apply content's subtitle scale */ + sub.rectangle.width *= content->x_scale (); + sub.rectangle.height *= content->y_scale (); - PlayerText ps; - auto image = subtitle.sub.image; + auto image = sub.image; - /* We will scale the subtitle up to fit _video_container_size */ - int const width = subtitle.sub.rectangle.width * _video_container_size.width; - int const height = subtitle.sub.rectangle.height * _video_container_size.height; - if (width == 0 || height == 0) { - return; - } + /* We will scale the subtitle up to fit _video_container_size */ + int const width = sub.rectangle.width * _video_container_size.load().width; + int const height = sub.rectangle.height * _video_container_size.load().height; + if (width == 0 || height == 0) { + return; + } - dcp::Size scaled_size (width, height); - ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUVToRGB::REC601, image->pixel_format(), true, _fast), subtitle.sub.rectangle)); - DCPTime from (content_time_to_dcp (piece, subtitle.from())); + dcp::Size scaled_size (width, height); + ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUVToRGB::REC601, image->pixel_format(), Image::Alignment::PADDED, _fast), sub.rectangle)); + } - _active_texts[static_cast(text->type())].add_from (wc, ps, from); + DCPTime from(content_time_to_dcp(piece, subtitle.from())); + _active_texts[content->type()].add_from(weak_content, ps, from); } void -Player::plain_text_start (weak_ptr wp, weak_ptr wc, ContentStringText subtitle) +Player::plain_text_start (weak_ptr weak_piece, weak_ptr weak_content, ContentStringText subtitle) { if (_suspended) { return; } - auto piece = wp.lock (); - auto text = wc.lock (); - if (!piece || !text) { + auto piece = weak_piece.lock (); + auto content = weak_content.lock (); + if (!piece || !content) { return; } @@ -1084,10 +1080,10 @@ Player::plain_text_start (weak_ptr wp, weak_ptr wc, Co } for (auto s: subtitle.subs) { - s.set_h_position (s.h_position() + text->x_offset ()); - s.set_v_position (s.v_position() + text->y_offset ()); - float const xs = text->x_scale(); - float const ys = text->y_scale(); + s.set_h_position (s.h_position() + content->x_offset()); + s.set_v_position (s.v_position() + content->y_offset()); + float const xs = content->x_scale(); + float const ys = content->y_scale(); float size = s.size(); /* Adjust size to express the common part of the scaling; @@ -1104,31 +1100,30 @@ Player::plain_text_start (weak_ptr wp, weak_ptr wc, Co } s.set_in (dcp::Time(from.seconds(), 1000)); - ps.string.push_back (StringText (s, text->outline_width())); - ps.add_fonts (text->fonts ()); + ps.string.push_back (s); } - _active_texts[static_cast(text->type())].add_from (wc, ps, from); + _active_texts[content->type()].add_from(weak_content, ps, from); } void -Player::subtitle_stop (weak_ptr wp, weak_ptr wc, ContentTime to) +Player::subtitle_stop (weak_ptr weak_piece, weak_ptr weak_content, ContentTime to) { if (_suspended) { return; } - auto text = wc.lock (); - if (!text) { + auto content = weak_content.lock (); + if (!content) { return; } - if (!_active_texts[static_cast(text->type())].have(wc)) { + if (!_active_texts[content->type()].have(weak_content)) { return; } - shared_ptr piece = wp.lock (); + auto piece = weak_piece.lock (); if (!piece) { return; } @@ -1139,11 +1134,11 @@ Player::subtitle_stop (weak_ptr wp, weak_ptr wc, Conte return; } - auto from = _active_texts[static_cast(text->type())].add_to (wc, dcp_to); + auto from = _active_texts[content->type()].add_to(weak_content, dcp_to); - bool const always = (text->type() == TextType::OPEN_SUBTITLE && _always_burn_open_subtitles); - if (text->use() && !always && !text->burn()) { - Text (from.first, text->type(), text->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod (from.second, dcp_to)); + bool const always = (content->type() == TextType::OPEN_SUBTITLE && _always_burn_open_subtitles); + if (content->use() && !always && !content->burn()) { + Text (from.first, content->type(), content->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod(from.second, dcp_to)); } } @@ -1170,9 +1165,7 @@ Player::seek (DCPTime time, bool accurate) } _audio_merger.clear (); - for (int i = 0; i < static_cast(TextType::COUNT); ++i) { - _active_texts[i].clear (); - } + std::for_each(_active_texts.begin(), _active_texts.end(), [](ActiveText& a) { a.clear(); }); for (auto i: _pieces) { if (time < i->content->position()) { @@ -1194,62 +1187,26 @@ Player::seek (DCPTime time, bool accurate) } if (accurate) { - _last_video_time = time; - _last_video_eyes = Eyes::LEFT; - _last_audio_time = time; + _next_video_time = time; + _next_audio_time = time; } else { - _last_video_time = optional(); - _last_video_eyes = optional(); - _last_audio_time = optional(); + _next_video_time = boost::none; + _next_audio_time = boost::none; } _black.set_position (time); _silent.set_position (time); - _last_video.clear (); -} - - -void -Player::emit_video (shared_ptr pv, DCPTime time) -{ - if (!_film->three_d()) { - if (pv->eyes() == Eyes::LEFT) { - /* Use left-eye images for both eyes... */ - pv->set_eyes (Eyes::BOTH); - } else if (pv->eyes() == Eyes::RIGHT) { - /* ...and discard the right */ - return; - } - } - - /* We need a delay to give a little wiggle room to ensure that relevent subtitles arrive at the - player before the video that requires them. - */ - _delay.push_back (make_pair (pv, time)); - - if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) { - _last_video_time = time + one_video_frame(); - } - _last_video_eyes = increment_eyes (pv->eyes()); - - if (_delay.size() < 3) { - return; - } - - auto to_do = _delay.front(); - _delay.pop_front(); - do_emit_video (to_do.first, to_do.second); + _last_video[Eyes::LEFT] = {}; + _last_video[Eyes::RIGHT] = {}; + _last_video[Eyes::BOTH] = {}; } - void -Player::do_emit_video (shared_ptr pv, DCPTime time) +Player::emit_video(shared_ptr pv, DCPTime time) { if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) { - for (int i = 0; i < static_cast(TextType::COUNT); ++i) { - _active_texts[i].clear_before (time); - } + std::for_each(_active_texts.begin(), _active_texts.end(), [time](ActiveText& a) { a.clear_before(time); }); } auto subtitles = open_subtitles_for_frame (time); @@ -1265,14 +1222,14 @@ void Player::emit_audio (shared_ptr data, DCPTime time) { /* Log if the assert below is about to fail */ - if (_last_audio_time && labs(time.get() - _last_audio_time->get()) > 1) { - _film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_last_audio_time)), LogEntry::TYPE_WARNING); + if (_next_audio_time && labs(time.get() - _next_audio_time->get()) > 1) { + _film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_next_audio_time)), LogEntry::TYPE_WARNING); } /* This audio must follow on from the previous, allowing for half a sample (at 48kHz) leeway */ - DCPOMATIC_ASSERT (!_last_audio_time || labs(time.get() - _last_audio_time->get()) < 2); + DCPOMATIC_ASSERT (!_next_audio_time || labs(time.get() - _next_audio_time->get()) < 2); Audio (data, time, _film->audio_frame_rate()); - _last_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate()); + _next_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate()); } @@ -1325,25 +1282,20 @@ Player::set_dcp_decode_reduction (optional reduction) { Change (ChangeType::PENDING, PlayerProperty::DCP_DECODE_REDUCTION, false); - { - boost::mutex::scoped_lock lm (_mutex); - - if (reduction == _dcp_decode_reduction) { - lm.unlock (); - Change (ChangeType::CANCELLED, PlayerProperty::DCP_DECODE_REDUCTION, false); - return; - } - - _dcp_decode_reduction = reduction; - setup_pieces_unlocked (); + if (reduction == _dcp_decode_reduction.load()) { + Change(ChangeType::CANCELLED, PlayerProperty::DCP_DECODE_REDUCTION, false); + return; } + _dcp_decode_reduction = reduction; + setup_pieces(); + Change (ChangeType::DONE, PlayerProperty::DCP_DECODE_REDUCTION, false); } optional -Player::content_time_to_dcp (shared_ptr content, ContentTime t) +Player::content_time_to_dcp (shared_ptr content, ContentTime t) const { boost::mutex::scoped_lock lm (_mutex); @@ -1358,6 +1310,22 @@ Player::content_time_to_dcp (shared_ptr content, ContentTime t) } +optional +Player::dcp_to_content_time (shared_ptr content, DCPTime t) const +{ + boost::mutex::scoped_lock lm (_mutex); + + for (auto i: _pieces) { + if (i->content == content) { + return dcp_to_content_time (i, t); + } + } + + /* We couldn't find this content; perhaps things are being changed over */ + return {}; +} + + shared_ptr Player::playlist () const { @@ -1366,12 +1334,22 @@ Player::playlist () const void -Player::atmos (weak_ptr, ContentAtmos data) +Player::atmos (weak_ptr weak_piece, ContentAtmos data) { if (_suspended) { return; } - Atmos (data.data, DCPTime::from_frames(data.frame, _film->video_frame_rate()), data.metadata); + auto piece = weak_piece.lock (); + DCPOMATIC_ASSERT (piece); + + auto const vfr = _film->video_frame_rate(); + + DCPTime const dcp_time = DCPTime::from_frames(data.frame, vfr) - DCPTime(piece->content->trim_start(), FrameRateChange(vfr, vfr)); + if (dcp_time < piece->content->position() || dcp_time >= (piece->content->end(_film))) { + return; + } + + Atmos (data.data, dcp_time, data.metadata); }