X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=981078636bf87764fe172783a371668b7fcbe380;hb=8cabf6045c7b101fda647ed65db6a9066b8a0efd;hp=f7b75babcdc3d8f2750900a4925878b3e3f96fda;hpb=03ac5ddb97fdaf7c8c46bd3c012cec8f04e8eabd;p=dcpomatic.git diff --git a/src/lib/player.cc b/src/lib/player.cc index f7b75babc..981078636 100644 --- a/src/lib/player.cc +++ b/src/lib/player.cc @@ -20,46 +20,48 @@ #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 "ratio.h" +#include "raw_image_proxy.h" #include "referenced_reel_asset.h" -#include "decoder_factory.h" -#include "decoder.h" -#include "video_decoder.h" -#include "audio_decoder.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,6 +72,7 @@ using std::dynamic_pointer_cast; using std::list; using std::make_pair; using std::make_shared; +using std::make_shared; using std::max; using std::min; using std::min; @@ -77,7 +80,6 @@ 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 @@ -145,7 +147,7 @@ Player::setup_pieces () 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(); } @@ -278,9 +280,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::none; + _next_video_eyes = Eyes::BOTH; + _next_audio_time = boost::none; } @@ -702,11 +704,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; } @@ -719,20 +721,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(); @@ -792,16 +794,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); @@ -812,6 +814,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; @@ -866,13 +881,13 @@ Player::open_subtitles_for_frame (DCPTime time) const void -Player::video (weak_ptr wp, ContentVideo video) +Player::video (weak_ptr weak_piece, ContentVideo video) { if (_suspended) { return; } - auto piece = wp.lock (); + auto piece = weak_piece.lock (); if (!piece) { return; } @@ -894,7 +909,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; } @@ -907,12 +922,12 @@ 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) { - auto last = _last_video.find (wp); + auto last = _last_video.find (weak_piece); if (_film->three_d()) { auto fill_to_eyes = video.eyes; if (fill_to_eyes == Eyes::BOTH) { @@ -923,7 +938,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; } @@ -956,7 +971,7 @@ Player::video (weak_ptr wp, ContentVideo video) auto const content_video = piece->content->video; - _last_video[wp] = std::make_shared( + _last_video[weak_piece] = std::make_shared( video.image, content_video->actual_crop(), content_video->fade (_film, video.frame), @@ -979,7 +994,7 @@ Player::video (weak_ptr wp, ContentVideo video) DCPTime t = time; for (int i = 0; i < frc.repeat; ++i) { if (t < piece->content->end(_film)) { - emit_video (_last_video[wp], t); + emit_video (_last_video[weak_piece], t); } t += one_video_frame (); } @@ -987,7 +1002,7 @@ Player::video (weak_ptr wp, ContentVideo video) 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; @@ -995,7 +1010,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; } @@ -1034,12 +1049,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 */ @@ -1061,29 +1092,29 @@ 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 (); + subtitle.sub.rectangle.x += content->x_offset (); + subtitle.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); + subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * ((content->x_scale() - 1) / 2); + subtitle.sub.rectangle.y -= subtitle.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 (); + subtitle.sub.rectangle.width *= content->x_scale (); + subtitle.sub.rectangle.height *= content->y_scale (); PlayerText ps; auto image = subtitle.sub.image; @@ -1099,20 +1130,20 @@ Player::bitmap_text_start (weak_ptr wp, weak_ptr wc, C ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUVToRGB::REC601, image->pixel_format(), Image::Alignment::PADDED, _fast), subtitle.sub.rectangle)); DCPTime from (content_time_to_dcp (piece, subtitle.from())); - _active_texts[static_cast(text->type())].add_from (wc, ps, from); + _active_texts[static_cast(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; } @@ -1124,10 +1155,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; @@ -1144,31 +1175,31 @@ 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 (StringText (s, content->outline_width())); + ps.add_fonts (content->fonts ()); } - _active_texts[static_cast(text->type())].add_from (wc, ps, from); + _active_texts[static_cast(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[static_cast(content->type())].have(weak_content)) { return; } - shared_ptr piece = wp.lock (); + auto piece = weak_piece.lock (); if (!piece) { return; } @@ -1179,11 +1210,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[static_cast(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)); } } @@ -1234,13 +1265,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 = boost::none; + _next_video_eyes = boost::none; + _next_audio_time = boost::none; } _black.set_position (time); @@ -1263,15 +1294,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; @@ -1305,14 +1336,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()); } @@ -1383,7 +1414,7 @@ Player::set_dcp_decode_reduction (optional reduction) optional -Player::content_time_to_dcp (shared_ptr content, ContentTime t) +Player::content_time_to_dcp (shared_ptr content, ContentTime t) { boost::mutex::scoped_lock lm (_mutex);