X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=42c22ab7d890db6eab8d80272fec54174cb524e7;hb=86c9cd50e1b73e6d89db312f2ee58e85ff270194;hp=49724f73b3623949c420d72c5a1565831a07b609;hpb=2b92a5fbae6ae11d6d751470b4a44252067ad077;p=dcpomatic.git diff --git a/src/lib/player.cc b/src/lib/player.cc index 49724f73b..42c22ab7d 100644 --- a/src/lib/player.cc +++ b/src/lib/player.cc @@ -278,9 +278,9 @@ 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::optional(); + _next_video_eyes = Eyes::BOTH; + _next_audio_time = boost::optional(); } @@ -560,58 +560,64 @@ Player::get_reel_assets () list reel_assets; for (auto content: playlist()->content()) { - auto j = dynamic_pointer_cast(content); - if (!j) { + auto dcp = dynamic_pointer_cast(content); + if (!dcp) { + continue; + } + + if (!dcp->reference_video() && !dcp->reference_audio() && !dcp->reference_text(TextType::OPEN_SUBTITLE) && !dcp->reference_text(TextType::CLOSED_CAPTION)) { continue; } scoped_ptr decoder; try { - decoder.reset (new DCPDecoder(_film, j, false, false, shared_ptr())); + decoder.reset (new DCPDecoder(_film, dcp, false, false, shared_ptr())); } catch (...) { return reel_assets; } - 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 (); + auto const frame_rate = _film->video_frame_rate(); + DCPOMATIC_ASSERT (dcp->video_frame_rate()); + /* We should only be referencing if the DCP rate is the same as the film rate */ + DCPOMATIC_ASSERT (std::round(dcp->video_frame_rate().get()) == frame_rate); + + Frame const trim_start = dcp->trim_start().frames_round(frame_rate); + Frame const trim_end = dcp->trim_end().frames_round(frame_rate); /* position in the asset from the start */ int64_t offset_from_start = 0; - /* position in the asset from the end */ + /* position i the asset from the end */ int64_t offset_from_end = 0; - for (auto k: decoder->reels()) { + for (auto reel: decoder->reels()) { /* Assume that main picture duration is the length of the reel */ - offset_from_end += k->main_picture()->actual_duration(); + offset_from_end += reel->main_picture()->actual_duration(); } - for (auto k: decoder->reels()) { + for (auto reel: decoder->reels()) { /* Assume that main picture duration is the length of the reel */ - int64_t const reel_duration = k->main_picture()->actual_duration(); + int64_t const reel_duration = reel->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 = content->position() + DCPTime::from_frames (offset_from_start, _film->video_frame_rate()); - if (j->reference_video ()) { - maybe_add_asset (reel_assets, k->main_picture(), reel_trim_start, reel_trim_end, from, ffr); + auto const from = max(DCPTime(), content->position() + DCPTime::from_frames(offset_from_start, frame_rate) - DCPTime::from_frames(trim_start, frame_rate)); + if (dcp->reference_video()) { + maybe_add_asset (reel_assets, reel->main_picture(), reel_trim_start, reel_trim_end, from, frame_rate); } - if (j->reference_audio ()) { - maybe_add_asset (reel_assets, k->main_sound(), reel_trim_start, reel_trim_end, from, ffr); + if (dcp->reference_audio()) { + maybe_add_asset (reel_assets, reel->main_sound(), reel_trim_start, reel_trim_end, from, frame_rate); } - if (j->reference_text (TextType::OPEN_SUBTITLE)) { - maybe_add_asset (reel_assets, k->main_subtitle(), reel_trim_start, reel_trim_end, from, ffr); + if (dcp->reference_text(TextType::OPEN_SUBTITLE)) { + maybe_add_asset (reel_assets, reel->main_subtitle(), reel_trim_start, reel_trim_end, from, frame_rate); } - if (j->reference_text (TextType::CLOSED_CAPTION)) { - for (auto l: k->closed_captions()) { - maybe_add_asset (reel_assets, l, reel_trim_start, reel_trim_end, from, ffr); + if (dcp->reference_text(TextType::CLOSED_CAPTION)) { + for (auto caption: reel->closed_captions()) { + maybe_add_asset (reel_assets, caption, reel_trim_start, reel_trim_end, from, frame_rate); } } @@ -696,11 +702,11 @@ Player::pass () 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 + /* 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). */ - _last_audio_time = dcp->end (_film); + _next_audio_time = dcp->end (_film); } break; } @@ -713,20 +719,20 @@ Player::pass () { 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(); @@ -786,16 +792,16 @@ 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); @@ -806,6 +812,19 @@ Player::pass () for (auto const& i: _delay) { do_emit_video(i.first, i.second); } + + /* Perhaps we should have Empty entries for both eyes in the 3D case (somehow). + * However, if we have L and R video files, and one is shorter than the other, + * the fill code in ::video mostly takes care of filling in the gaps. + * However, since it fills at the point when it knows there is more video coming + * at time t (so it should fill any gap up to t) it can't do anything right at the + * end. This is particularly bad news if the last frame emitted is a LEFT + * eye, as the MXF writer will complain about the 3D sequence being wrong. + * Here's a hack to workaround that particular case. + */ + if (_next_video_eyes && _next_video_time && *_next_video_eyes == Eyes::RIGHT) { + do_emit_video (black_player_video_frame(Eyes::RIGHT), *_next_video_time); + } } return done; @@ -888,7 +907,7 @@ Player::video (weak_ptr wp, ContentVideo video) 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() || (_next_video_time && time < *_next_video_time)) { return; } @@ -901,8 +920,8 @@ Player::video (weak_ptr wp, ContentVideo video) */ DCPTime fill_to = min (time, piece->content->end(_film)); - if (_last_video_time) { - DCPTime fill_from = max (*_last_video_time, piece->content->position()); + if (_next_video_time) { + DCPTime fill_from = max (*_next_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) { @@ -917,7 +936,7 @@ Player::video (weak_ptr wp, ContentVideo video) fill_to_eyes = Eyes::LEFT; } auto j = fill_from; - auto eyes = _last_video_eyes.get_value_or(Eyes::LEFT); + auto eyes = _next_video_eyes.get_value_or(Eyes::LEFT); if (eyes == Eyes::BOTH) { eyes = Eyes::LEFT; } @@ -1228,13 +1247,13 @@ 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_video_eyes = Eyes::LEFT; + _next_audio_time = time; } else { - _last_video_time = optional(); - _last_video_eyes = optional(); - _last_audio_time = optional(); + _next_video_time = optional(); + _next_video_eyes = optional(); + _next_audio_time = optional(); } _black.set_position (time); @@ -1257,15 +1276,15 @@ Player::emit_video (shared_ptr pv, DCPTime time) } } - /* We need a delay to give a little wiggle room to ensure that relevent subtitles arrive at the + /* 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) { - _last_video_time = time + one_video_frame(); + _next_video_time = time + one_video_frame(); } - _last_video_eyes = increment_eyes (pv->eyes()); + _next_video_eyes = increment_eyes (pv->eyes()); if (_delay.size() < 3) { return; @@ -1299,14 +1318,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()); } @@ -1400,12 +1419,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); }