X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Flib%2Fplayer.cc;h=ec7a93dac2163ff54470b35ef1ce4208d996e4a3;hb=9aec1f8069ab8d08d79e0021157d85991de6535e;hp=0011f7ab25cdfef3704e8f4c6a68b2ededa7293b;hpb=c20b1952c9a3187b91ce49423fa8093fcf9661bc;p=dcpomatic.git diff --git a/src/lib/player.cc b/src/lib/player.cc index 0011f7ab2..ec7a93dac 100644 --- a/src/lib/player.cc +++ b/src/lib/player.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2013-2017 Carl Hetherington + Copyright (C) 2013-2018 Carl Hetherington This file is part of DCP-o-matic. @@ -47,8 +47,8 @@ #include "content_subtitle.h" #include "dcp_decoder.h" #include "image_decoder.h" -#include "resampler.h" #include "compose.hpp" +#include "shuffler.h" #include #include #include @@ -83,11 +83,12 @@ Player::Player (shared_ptr film, shared_ptr playlist , _playlist (playlist) , _have_valid_pieces (false) , _ignore_video (false) - , _ignore_audio (false) + , _ignore_subtitle (false) , _always_burn_subtitles (false) , _fast (false) , _play_referenced (false) - , _audio_merger (_film->audio_channels(), _film->audio_frame_rate()) + , _audio_merger (_film->audio_frame_rate()) + , _shuffler (0) { _film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1)); _playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this)); @@ -95,6 +96,13 @@ Player::Player (shared_ptr film, shared_ptr playlist set_video_container_size (_film->frame_size ()); film_changed (Film::AUDIO_PROCESSOR); + + seek (DCPTime (), true); +} + +Player::~Player () +{ + delete _shuffler; } void @@ -102,13 +110,17 @@ Player::setup_pieces () { _pieces.clear (); + delete _shuffler; + _shuffler = new Shuffler(); + _shuffler->Video.connect(bind(&Player::video, this, _1, _2)); + BOOST_FOREACH (shared_ptr i, _playlist->content ()) { if (!i->paths_valid ()) { continue; } - shared_ptr decoder = decoder_factory (i, _film->log()); + shared_ptr decoder = decoder_factory (i, _film->log(), _fast); FrameRateChange frc (i->active_video_frame_rate(), _film->video_frame_rate()); if (!decoder) { @@ -120,20 +132,27 @@ Player::setup_pieces () decoder->video->set_ignore (); } - if (decoder->audio && _ignore_audio) { - decoder->audio->set_ignore (); + if (decoder->subtitle && _ignore_subtitle) { + decoder->subtitle->set_ignore (); } shared_ptr dcp = dynamic_pointer_cast (decoder); if (dcp && _play_referenced) { - dcp->set_decode_referenced (); + if (_play_referenced) { + dcp->set_decode_referenced (); + } + dcp->set_forced_reduction (_dcp_decode_reduction); } shared_ptr piece (new Piece (i, decoder, frc)); _pieces.push_back (piece); if (decoder->video) { - decoder->video->Data.connect (bind (&Player::video, this, weak_ptr (piece), _1)); + if (i->video->frame_type() == VIDEO_FRAME_TYPE_3D_LEFT || i->video->frame_type() == VIDEO_FRAME_TYPE_3D_RIGHT) { + decoder->video->Data.connect (bind (&Shuffler::video, _shuffler, weak_ptr(piece), _1)); + } else { + decoder->video->Data.connect (bind (&Player::video, this, weak_ptr(piece), _1)); + } } if (decoder->audio) { @@ -141,11 +160,13 @@ Player::setup_pieces () } if (decoder->subtitle) { - decoder->subtitle->ImageData.connect (bind (&Player::image_subtitle, this, weak_ptr (piece), _1)); - decoder->subtitle->TextData.connect (bind (&Player::text_subtitle, this, weak_ptr (piece), _1)); + decoder->subtitle->ImageStart.connect (bind (&Player::image_subtitle_start, this, weak_ptr (piece), _1)); + decoder->subtitle->TextStart.connect (bind (&Player::text_subtitle_start, this, weak_ptr (piece), _1)); + decoder->subtitle->Stop.connect (bind (&Player::subtitle_stop, this, weak_ptr (piece), _1)); } } + _stream_states.clear (); BOOST_FOREACH (shared_ptr i, _pieces) { if (i->content->audio) { BOOST_FOREACH (AudioStreamPtr j, i->content->audio->streams()) { @@ -154,6 +175,12 @@ Player::setup_pieces () } } + _black = Empty (_film->content(), _film->length(), bind(&Content::video, _1)); + _silent = Empty (_film->content(), _film->length(), bind(&Content::audio, _1)); + + _last_video_time = DCPTime (); + _last_video_eyes = EYES_BOTH; + _last_audio_time = DCPTime (); _have_valid_pieces = true; } @@ -175,10 +202,10 @@ Player::playlist_content_changed (weak_ptr w, int property, bool freque property == DCPContentProperty::NEEDS_ASSETS || property == DCPContentProperty::NEEDS_KDM || property == SubtitleContentProperty::COLOUR || - property == SubtitleContentProperty::OUTLINE || - property == SubtitleContentProperty::SHADOW || + property == SubtitleContentProperty::EFFECT || property == SubtitleContentProperty::EFFECT_COLOUR || property == FFmpegContentProperty::SUBTITLE_STREAM || + property == FFmpegContentProperty::FILTERS || property == VideoContentProperty::COLOUR_CONVERSION ) { @@ -210,10 +237,16 @@ Player::playlist_content_changed (weak_ptr w, int property, bool freque void Player::set_video_container_size (dcp::Size s) { + if (s == _video_container_size) { + return; + } + _video_container_size = s; _black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true)); _black_image->make_black (); + + Changed (false); } void @@ -292,7 +325,7 @@ Player::transform_image_subtitles (list subs) const } shared_ptr -Player::black_player_video_frame () const +Player::black_player_video_frame (Eyes eyes) const { return shared_ptr ( new PlayerVideo ( @@ -301,7 +334,7 @@ Player::black_player_video_frame () const optional (), _video_container_size, _video_container_size, - EYES_BOTH, + eyes, PART_WHOLE, PresetColourConversion::all().front().conversion ) @@ -329,8 +362,8 @@ DCPTime Player::content_video_to_dcp (shared_ptr piece, Frame f) const { /* See comment in dcp_to_content_video */ - DCPTime const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime (piece->content->trim_start (), piece->frc); - return max (DCPTime (), d + piece->content->position ()); + DCPTime const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime(piece->content->trim_start(), piece->frc); + return d + piece->content->position(); } Frame @@ -346,8 +379,9 @@ DCPTime Player::resampled_audio_to_dcp (shared_ptr piece, Frame f) const { /* See comment in dcp_to_content_video */ - DCPTime const d = DCPTime::from_frames (f, _film->audio_frame_rate()) - DCPTime (piece->content->trim_start (), piece->frc); - return max (DCPTime (), d + piece->content->position ()); + return DCPTime::from_frames (f, _film->audio_frame_rate()) + - DCPTime (piece->content->trim_start(), piece->frc) + + piece->content->position(); } ContentTime @@ -392,11 +426,10 @@ Player::set_ignore_video () _ignore_video = true; } -/** Set this player never to produce any audio data */ void -Player::set_ignore_audio () +Player::set_ignore_subtitle () { - _ignore_audio = true; + _ignore_subtitle = true; } /** Set whether or not this player should always burn text subtitles into the image, @@ -409,6 +442,7 @@ Player::set_always_burn_subtitles (bool burn) _always_burn_subtitles = burn; } +/** Sets up the player to be faster, possibly at the expense of quality */ void Player::set_fast () { @@ -436,7 +470,7 @@ Player::get_reel_assets () scoped_ptr decoder; try { - decoder.reset (new DCPDecoder (j, _film->log())); + decoder.reset (new DCPDecoder (j, _film->log(), false)); } catch (...) { return a; } @@ -489,99 +523,161 @@ Player::get_reel_assets () return a; } -list > -Player::overlaps (DCPTime from, DCPTime to, boost::function valid) +bool +Player::pass () { if (!_have_valid_pieces) { setup_pieces (); } - list > overlaps; - BOOST_FOREACH (shared_ptr i, _pieces) { - if (valid (i->content.get ()) && i->content->position() < to && i->content->end() > from) { - overlaps.push_back (i); - } + if (_playlist->length() == DCPTime()) { + /* Special case of an empty Film; just give one black frame */ + emit_video (black_player_video_frame(EYES_BOTH), DCPTime()); + return true; } - return overlaps; -} + /* Find the decoder or empty which is farthest behind where we are and make it emit some data */ -bool -Player::pass () -{ - if (!_have_valid_pieces) { - setup_pieces (); - } - - shared_ptr earliest; - DCPTime earliest_content; + shared_ptr earliest_content; + optional earliest_time; BOOST_FOREACH (shared_ptr i, _pieces) { - if (!i->done) { - DCPTime const t = i->content->position() + DCPTime (i->decoder->position(), i->frc); - if (!earliest || t < earliest_content) { - earliest_content = t; - earliest = i; + if (i->done) { + continue; + } + + DCPTime const t = content_time_to_dcp (i, i->decoder->position()); + if (t > i->content->end()) { + i->done = true; + } else { + + /* Given two choices at the same time, pick the one with a subtitle so we see it before + the video. + */ + if (!earliest_time || t < *earliest_time || (t == *earliest_time && i->decoder->subtitle)) { + earliest_time = t; + earliest_content = i; } } } - if (!earliest) { - /* No more content; fill up to the length of our playlist with silent black */ + bool done = false; - DCPTime const length = _playlist->length (); + enum { + NONE, + CONTENT, + BLACK, + SILENT + } which = NONE; - DCPTime const frame = DCPTime::from_frames (1, _film->video_frame_rate()); - DCPTime from; - if (_last_time) { - from = _last_time.get() + frame; - } - for (DCPTime i = from; i < length; i += frame) { - Video (black_player_video_frame (), i); - } + if (earliest_content) { + which = CONTENT; + } - DCPTime t = _last_audio_time; - while (t < length) { - DCPTime block = min (DCPTime::from_seconds (0.5), length - t); - shared_ptr silence (new AudioBuffers (_film->audio_channels(), block.frames_round(_film->audio_frame_rate()))); - silence->make_silent (); - Audio (silence, t); - t += block; - } + if (!_black.done() && (!earliest_time || _black.position() < *earliest_time)) { + earliest_time = _black.position (); + which = BLACK; + } - return true; + if (!_silent.done() && (!earliest_time || _silent.position() < *earliest_time)) { + earliest_time = _silent.position (); + which = SILENT; } - earliest->done = earliest->decoder->pass (); + switch (which) { + case CONTENT: + earliest_content->done = earliest_content->decoder->pass (); + break; + case BLACK: + emit_video (black_player_video_frame(EYES_BOTH), _black.position()); + _black.set_position (_black.position() + one_video_frame()); + break; + case SILENT: + { + DCPTimePeriod period (_silent.period_at_position()); + if (_last_audio_time) { + /* Sometimes the thing that happened last finishes fractionally before + this silence. Bodge the start time of the silence to fix it. I'm + not sure if this is the right solution --- maybe the last thing should + be padded `forward' rather than this thing padding `back'. + */ + period.from = min(period.from, *_last_audio_time); + } + if (period.duration() > one_video_frame()) { + period.to = period.from + one_video_frame(); + } + fill_audio (period); + _silent.set_position (period.to); + break; + } + case NONE: + done = true; + break; + } /* Emit any audio that is ready */ - DCPTime pull_from = _playlist->length (); + /* 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. + */ + DCPTime pull_to = _film->length (); for (map::const_iterator i = _stream_states.begin(); i != _stream_states.end(); ++i) { - if (!i->second.piece->done && i->second.last_push_end < pull_from) { - pull_from = i->second.last_push_end; + if (!i->second.piece->done && i->second.last_push_end < pull_to) { + pull_to = i->second.last_push_end; } } + if (!_silent.done() && _silent.position() < pull_to) { + pull_to = _silent.position(); + } -// cout << "PULL " << to_string(pull_from) << "\n"; - pair, DCPTime> audio = _audio_merger.pull (pull_from); - if (audio.first->frames() > 0) { - DCPOMATIC_ASSERT (audio.second >= _last_audio_time); - DCPTime t = _last_audio_time; - while (t < audio.second) { - /* Silence up to the time of this new audio */ - DCPTime block = min (DCPTime::from_seconds (0.5), audio.second - t); - shared_ptr silence (new AudioBuffers (_film->audio_channels(), block.frames_round(_film->audio_frame_rate()))); - silence->make_silent (); - Audio (silence, t); - t += block; + list, DCPTime> > audio = _audio_merger.pull (pull_to); + for (list, DCPTime> >::iterator i = audio.begin(); i != audio.end(); ++i) { + if (_last_audio_time && i->second < *_last_audio_time) { + /* This new data comes before the last we emitted (or the last seek); discard it */ + pair, DCPTime> cut = discard_audio (i->first, i->second, *_last_audio_time); + if (!cut.first) { + continue; + } + *i = cut; + } else if (_last_audio_time && i->second > *_last_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)); } - Audio (audio.first, audio.second); - _last_audio_time = audio.second + DCPTime::from_frames(audio.first->frames(), _film->audio_frame_rate()); + emit_audio (i->first, i->second); } - return false; + if (done) { + _shuffler->flush (); + } + return done; +} + +optional +Player::subtitles_for_frame (DCPTime time) const +{ + list subtitles; + + int const vfr = _film->video_frame_rate(); + + BOOST_FOREACH (PlayerSubtitles i, _active_subtitles.get_burnt (DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_subtitles)) { + + /* Image subtitles */ + list c = transform_image_subtitles (i.image); + copy (c.begin(), c.end(), back_inserter (subtitles)); + + /* Text subtitles (rendered to an image) */ + if (!i.text.empty ()) { + list s = render_subtitles (i.text, i.fonts, _video_container_size, time, vfr); + copy (s.begin(), s.end(), back_inserter (subtitles)); + } + } + + if (subtitles.empty ()) { + return optional (); + } + + return merge (subtitles); } void @@ -592,57 +688,58 @@ Player::video (weak_ptr wp, ContentVideo video) return; } - /* Time and period of the frame we will emit */ - DCPTime const time = content_video_to_dcp (piece, video.frame); - DCPTimePeriod const period (time, time + DCPTime::from_frames (1, _film->video_frame_rate())); - - /* Discard if it's outside the content's period */ - if (time < piece->content->position() || time >= piece->content->end()) { + FrameRateChange frc(piece->content->active_video_frame_rate(), _film->video_frame_rate()); + if (frc.skip && (video.frame % 2) == 1) { return; } - /* Get any subtitles */ - - optional subtitles; - - for (list >::const_iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) { - - if (!i->second.overlap (period)) { - continue; - } - - list sub_images; - - /* Image subtitles */ - list c = transform_image_subtitles (i->first.image); - copy (c.begin(), c.end(), back_inserter (sub_images)); - - /* Text subtitles (rendered to an image) */ - if (!i->first.text.empty ()) { - list s = render_subtitles (i->first.text, i->first.fonts, _video_container_size, time); - copy (s.begin (), s.end (), back_inserter (sub_images)); - } + /* Time of the first frame we will emit */ + DCPTime const time = content_video_to_dcp (piece, video.frame); - if (!sub_images.empty ()) { - subtitles = merge (sub_images); - } + /* Discard if it's outside the content's period or if it's before the last accurate seek */ + if ( + time < piece->content->position() || + time >= piece->content->end() || + (_last_video_time && time < *_last_video_time)) { + return; } - /* Fill gaps */ + /* Fill gaps that we discover now that we have some video which needs to be emitted */ - if (_last_time) { - /* XXX: this may not work for 3D */ - DCPTime const frame = DCPTime::from_frames (1, _film->video_frame_rate()); - for (DCPTime i = _last_time.get() + frame; i < time; i += frame) { - if (_playlist->video_content_at(i) && _last_video) { - Video (shared_ptr (new PlayerVideo (*_last_video)), i); - } else { - Video (black_player_video_frame (), i); + if (_last_video_time) { + DCPTime fill_from = max (*_last_video_time, piece->content->position()); + LastVideoMap::const_iterator last = _last_video.find (wp); + if (_film->three_d()) { + DCPTime j = fill_from; + Eyes eyes = _last_video_eyes.get_value_or(EYES_LEFT); + if (eyes == EYES_BOTH) { + eyes = EYES_LEFT; + } + while (j < time || eyes != video.eyes) { + if (last != _last_video.end()) { + shared_ptr copy = last->second->shallow_copy(); + copy->set_eyes (eyes); + emit_video (copy, j); + } else { + 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 < time; j += one_video_frame()) { + if (last != _last_video.end()) { + emit_video (last->second, j); + } else { + emit_video (black_player_video_frame(EYES_BOTH), j); + } } } } - _last_video.reset ( + _last_video[wp].reset ( new PlayerVideo ( video.image, piece->content->video->crop (), @@ -657,31 +754,18 @@ Player::video (weak_ptr wp, ContentVideo video) ) ); - if (subtitles) { - _last_video->set_subtitle (subtitles.get ()); - } - - _last_time = time; - - Video (_last_video, *_last_time); - - /* Discard any subtitles we no longer need */ - - for (list >::iterator i = _subtitles.begin (); i != _subtitles.end(); ) { - list >::iterator tmp = i; - ++tmp; - - if (i->second.to < time) { - _subtitles.erase (i); - } - - i = tmp; + DCPTime t = time; + for (int i = 0; i < frc.repeat; ++i) { + emit_video (_last_video[wp], t); + t += one_video_frame (); } } void Player::audio (weak_ptr wp, AudioStreamPtr stream, ContentAudio content_audio) { + DCPOMATIC_ASSERT (content_audio.audio->frames() > 0); + shared_ptr piece = wp.lock (); if (!piece) { return; @@ -690,74 +774,62 @@ Player::audio (weak_ptr wp, AudioStreamPtr stream, ContentAudio content_a shared_ptr content = piece->content->audio; DCPOMATIC_ASSERT (content); - /* Gain */ - if (content->gain() != 0) { - shared_ptr gain (new AudioBuffers (content_audio.audio)); - gain->apply_gain (content->gain ()); - content_audio.audio = gain; - } - - /* Resample */ - if (stream->frame_rate() != content->resampled_frame_rate()) { - shared_ptr r = resampler (content, stream, true); - pair, Frame> ro = r->run (content_audio.audio, content_audio.frame); - content_audio.audio = ro.first; - content_audio.frame = ro.second; - } - - /* XXX: end-trimming used to be checked here */ - /* Compute time in the DCP */ - DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame) + DCPTime::from_seconds (content->delay() / 1000.0); + DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame); + /* And the end of this block in the DCP */ + DCPTime end = time + DCPTime::from_frames(content_audio.audio->frames(), content->resampled_frame_rate()); - /* Remove anything that comes before the start of the content */ + /* Remove anything that comes before the start or after the end of the content */ if (time < piece->content->position()) { - DCPTime const discard_time = piece->content->position() - time; - Frame discard_frames = discard_time.frames_round(_film->audio_frame_rate()); - Frame remaining_frames = content_audio.audio->frames() - discard_frames; - if (remaining_frames <= 0) { + pair, DCPTime> cut = discard_audio (content_audio.audio, time, piece->content->position()); + if (!cut.first) { /* This audio is entirely discarded */ return; } + content_audio.audio = cut.first; + time = cut.second; + } else if (time > piece->content->end()) { + /* Discard it all */ + return; + } else if (end > piece->content->end()) { + Frame const remaining_frames = DCPTime(piece->content->end() - time).frames_round(_film->audio_frame_rate()); + if (remaining_frames == 0) { + return; + } shared_ptr cut (new AudioBuffers (content_audio.audio->channels(), remaining_frames)); - cut->copy_from (content_audio.audio.get(), remaining_frames, discard_frames, 0); + cut->copy_from (content_audio.audio.get(), remaining_frames, 0, 0); content_audio.audio = cut; - time += discard_time; - } - - /* Remap channels */ - shared_ptr dcp_mapped (new AudioBuffers (_film->audio_channels(), content_audio.audio->frames())); - dcp_mapped->make_silent (); - - AudioMapping map = stream->mapping (); - for (int i = 0; i < map.input_channels(); ++i) { - for (int j = 0; j < dcp_mapped->channels(); ++j) { - if (map.get (i, static_cast (j)) > 0) { - dcp_mapped->accumulate_channel ( - content_audio.audio.get(), - i, - static_cast (j), - map.get (i, static_cast (j)) - ); - } - } } - content_audio.audio = dcp_mapped; + DCPOMATIC_ASSERT (content_audio.audio->frames() > 0); + + /* Gain */ + + if (content->gain() != 0) { + shared_ptr gain (new AudioBuffers (content_audio.audio)); + gain->apply_gain (content->gain ()); + content_audio.audio = gain; + } + + /* Remap */ + + content_audio.audio = remap (content_audio.audio, _film->audio_channels(), stream->mapping()); + + /* Process */ if (_audio_processor) { content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ()); } -// cout << "PUSH " << content_audio.audio->frames() << " @ " << to_string(time) << "\n"; - _audio_merger.push (content_audio.audio, time); + /* Push */ + _audio_merger.push (content_audio.audio, time); DCPOMATIC_ASSERT (_stream_states.find (stream) != _stream_states.end ()); _stream_states[stream].last_push_end = time + DCPTime::from_frames (content_audio.audio->frames(), _film->audio_frame_rate()); } void -Player::image_subtitle (weak_ptr wp, ContentImageSubtitle subtitle) +Player::image_subtitle_start (weak_ptr wp, ContentImageSubtitle subtitle) { shared_ptr piece = wp.lock (); if (!piece) { @@ -778,17 +850,13 @@ Player::image_subtitle (weak_ptr wp, ContentImageSubtitle subtitle) PlayerSubtitles ps; ps.image.push_back (subtitle.sub); - DCPTimePeriod period (content_time_to_dcp (piece, subtitle.period().from), content_time_to_dcp (piece, subtitle.period().to)); + DCPTime from (content_time_to_dcp (piece, subtitle.from())); - if (piece->content->subtitle->use() && (piece->content->subtitle->burn() || _always_burn_subtitles)) { - _subtitles.push_back (make_pair (ps, period)); - } else { - Subtitle (ps, period); - } + _active_subtitles.add_from (wp, ps, from); } void -Player::text_subtitle (weak_ptr wp, ContentTextSubtitle subtitle) +Player::text_subtitle_start (weak_ptr wp, ContentTextSubtitle subtitle) { shared_ptr piece = wp.lock (); if (!piece) { @@ -796,7 +864,7 @@ Player::text_subtitle (weak_ptr wp, ContentTextSubtitle subtitle) } PlayerSubtitles ps; - DCPTimePeriod const period (content_time_to_dcp (piece, subtitle.period().from), content_time_to_dcp (piece, subtitle.period().to)); + DCPTime const from (content_time_to_dcp (piece, subtitle.from())); BOOST_FOREACH (dcp::SubtitleString s, subtitle.subs) { s.set_h_position (s.h_position() + piece->content->subtitle->x_offset ()); @@ -818,59 +886,160 @@ Player::text_subtitle (weak_ptr wp, ContentTextSubtitle subtitle) s.set_aspect_adjust (xs / ys); } - s.set_in (dcp::Time(period.from.seconds(), 1000)); - s.set_out (dcp::Time(period.to.seconds(), 1000)); + s.set_in (dcp::Time(from.seconds(), 1000)); ps.text.push_back (SubtitleString (s, piece->content->subtitle->outline_width())); ps.add_fonts (piece->content->subtitle->fonts ()); } - if (piece->content->subtitle->use() && (piece->content->subtitle->burn() || _always_burn_subtitles)) { - _subtitles.push_back (make_pair (ps, period)); - } else { - Subtitle (ps, period); + _active_subtitles.add_from (wp, ps, from); +} + +void +Player::subtitle_stop (weak_ptr wp, ContentTime to) +{ + if (!_active_subtitles.have (wp)) { + return; + } + + shared_ptr piece = wp.lock (); + if (!piece) { + return; + } + + DCPTime const dcp_to = content_time_to_dcp (piece, to); + + pair from = _active_subtitles.add_to (wp, dcp_to); + + if (piece->content->subtitle->use() && !_always_burn_subtitles && !piece->content->subtitle->burn()) { + Subtitle (from.first, DCPTimePeriod (from.second, dcp_to)); } } void Player::seek (DCPTime time, bool accurate) { + if (!_have_valid_pieces) { + setup_pieces (); + } + + if (_shuffler) { + _shuffler->clear (); + } + + if (_audio_processor) { + _audio_processor->flush (); + } + + _audio_merger.clear (); + _active_subtitles.clear (); + BOOST_FOREACH (shared_ptr i, _pieces) { - if (i->content->position() <= time && time < i->content->end()) { + if (time < i->content->position()) { + /* Before; seek to 0 */ + i->decoder->seek (ContentTime(), accurate); + i->done = false; + } else if (i->content->position() <= time && time < i->content->end()) { + /* During; seek to position */ i->decoder->seek (dcp_to_content_time (i, time), accurate); i->done = false; + } else { + /* After; this piece is done */ + i->done = true; } } if (accurate) { - _last_time = time - DCPTime::from_frames (1, _film->video_frame_rate ()); + _last_video_time = time; + _last_video_eyes = EYES_LEFT; + _last_audio_time = time; } else { - _last_time = optional (); + _last_video_time = optional(); + _last_video_eyes = optional(); + _last_audio_time = optional(); } + + _black.set_position (time); + _silent.set_position (time); + + _last_video.clear (); } -shared_ptr -Player::resampler (shared_ptr content, AudioStreamPtr stream, bool create) +void +Player::emit_video (shared_ptr pv, DCPTime time) { - ResamplerMap::const_iterator i = _resamplers.find (make_pair (content, stream)); - if (i != _resamplers.end ()) { - return i->second; + optional subtitles = subtitles_for_frame (time); + if (subtitles) { + pv->set_subtitle (subtitles.get ()); } - if (!create) { - return shared_ptr (); + Video (pv, time); + + if (pv->eyes() == EYES_BOTH || pv->eyes() == EYES_RIGHT) { + _last_video_time = time + one_video_frame(); + _active_subtitles.clear_before (time); } + _last_video_eyes = increment_eyes (pv->eyes()); +} - LOG_GENERAL ( - "Creating new resampler from %1 to %2 with %3 channels", - stream->frame_rate(), - content->resampled_frame_rate(), - stream->channels() - ); +void +Player::emit_audio (shared_ptr data, DCPTime time) +{ + /* This audio must follow on from the previous */ + DCPOMATIC_ASSERT (!_last_audio_time || time == *_last_audio_time); + Audio (data, time); + _last_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate()); +} - shared_ptr r ( - new Resampler (stream->frame_rate(), content->resampled_frame_rate(), stream->channels()) - ); +void +Player::fill_audio (DCPTimePeriod period) +{ + if (period.from == period.to) { + return; + } + + DCPOMATIC_ASSERT (period.from < period.to); + + DCPTime t = period.from; + while (t < period.to) { + DCPTime block = min (DCPTime::from_seconds (0.5), period.to - t); + Frame const samples = block.frames_round(_film->audio_frame_rate()); + if (samples) { + shared_ptr silence (new AudioBuffers (_film->audio_channels(), samples)); + silence->make_silent (); + emit_audio (silence, t); + } + t += block; + } +} + +DCPTime +Player::one_video_frame () const +{ + return DCPTime::from_frames (1, _film->video_frame_rate ()); +} - _resamplers[make_pair(content, stream)] = r; - return r; +pair, DCPTime> +Player::discard_audio (shared_ptr audio, DCPTime time, DCPTime discard_to) const +{ + DCPTime const discard_time = discard_to - time; + Frame const discard_frames = discard_time.frames_round(_film->audio_frame_rate()); + Frame remaining_frames = audio->frames() - discard_frames; + if (remaining_frames <= 0) { + return make_pair(shared_ptr(), DCPTime()); + } + shared_ptr cut (new AudioBuffers (audio->channels(), remaining_frames)); + cut->copy_from (audio.get(), remaining_frames, discard_frames, 0); + return make_pair(cut, time + discard_time); +} + +void +Player::set_dcp_decode_reduction (optional reduction) +{ + if (reduction == _dcp_decode_reduction) { + return; + } + + _dcp_decode_reduction = reduction; + _have_valid_pieces = false; + Changed (false); }