X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=eb7b177ecd21aacc86bc5c96d89e404a8333f7e1;hb=c3362d7b12e425fa9549579be10e708c88d5feea;hp=ec20892effe9ec571d89e3c6cbb33bb2a68c70cd;hpb=a6d892268ccdf8e50194c0168491c8a360bbb687;p=dcpomatic.git diff --git a/src/lib/player.cc b/src/lib/player.cc index ec20892ef..eb7b177ec 100644 --- a/src/lib/player.cc +++ b/src/lib/player.cc @@ -18,12 +18,13 @@ */ #include +#include #include "player.h" #include "film.h" #include "ffmpeg_decoder.h" #include "ffmpeg_content.h" -#include "imagemagick_decoder.h" -#include "imagemagick_content.h" +#include "image_decoder.h" +#include "image_content.h" #include "sndfile_decoder.h" #include "sndfile_content.h" #include "subtitle_content.h" @@ -31,7 +32,7 @@ #include "job.h" #include "image.h" #include "ratio.h" -#include "resampler.h" +#include "log.h" #include "scaler.h" using std::list; @@ -44,48 +45,22 @@ using std::map; using boost::shared_ptr; using boost::weak_ptr; using boost::dynamic_pointer_cast; - -#define DEBUG_PLAYER 1 +using boost::optional; class Piece { public: - Piece (shared_ptr c) - : content (c) - , video_position (c->start ()) - , audio_position (c->start ()) - {} - - Piece (shared_ptr c, shared_ptr d) + Piece (shared_ptr c, shared_ptr d, FrameRateChange f) : content (c) , decoder (d) - , video_position (c->start ()) - , audio_position (c->start ()) + , frc (f) {} - + shared_ptr content; shared_ptr decoder; - Time video_position; - Time audio_position; + FrameRateChange frc; }; -#ifdef DEBUG_PLAYER -std::ostream& operator<<(std::ostream& s, Piece const & p) -{ - if (dynamic_pointer_cast (p.content)) { - s << "\tffmpeg "; - } else if (dynamic_pointer_cast (p.content)) { - s << "\timagemagick"; - } else if (dynamic_pointer_cast (p.content)) { - s << "\tsndfile "; - } - - s << " at " << p.content->start() << " until " << p.content->end(); - - return s; -} -#endif - Player::Player (shared_ptr f, shared_ptr p) : _film (f) , _playlist (p) @@ -94,12 +69,15 @@ Player::Player (shared_ptr f, shared_ptr p) , _have_valid_pieces (false) , _video_position (0) , _audio_position (0) - , _audio_buffers (f->dcp_audio_channels(), 0) + , _audio_merger (f->audio_channels(), bind (&Film::time_to_audio_frames, f.get(), _1), bind (&Film::audio_frames_to_time, f.get(), _1)) + , _last_emit_was_black (false) + , _just_did_inaccurate_seek (false) + , _approximate_size (false) { - _playlist->Changed.connect (bind (&Player::playlist_changed, this)); - _playlist->ContentChanged.connect (bind (&Player::content_changed, this, _1, _2, _3)); - _film->Changed.connect (bind (&Player::film_changed, this, _1)); - set_video_container_size (_film->container()->size (_film->full_frame ())); + _playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this)); + _playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Player::content_changed, this, _1, _2, _3)); + _film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1)); + set_video_container_size (fit_ratio_within (_film->container()->ratio (), _film->full_frame ())); } void @@ -119,91 +97,165 @@ Player::pass () { if (!_have_valid_pieces) { setup_pieces (); - _have_valid_pieces = true; } -#ifdef DEBUG_PLAYER - cout << "= PASS\n"; -#endif + /* Interrogate all our pieces to find the one with the earliest decoded data */ - Time earliest_t = TIME_MAX; - shared_ptr earliest; - enum { - VIDEO, - AUDIO - } type = VIDEO; + shared_ptr earliest_piece; + shared_ptr earliest_decoded; + DCPTime earliest_time = TIME_MAX; + DCPTime earliest_audio = TIME_MAX; for (list >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) { - if ((*i)->decoder->done ()) { + + DCPTime const offset = (*i)->content->position() - (*i)->content->trim_start(); + + bool done = false; + shared_ptr dec; + while (!done) { + dec = (*i)->decoder->peek (); + if (!dec) { + /* Decoder has nothing else to give us */ + break; + } + + dec->set_dcp_times (_film->video_frame_rate(), _film->audio_frame_rate(), (*i)->frc, offset); + DCPTime const t = dec->dcp_time - offset; + if (t >= ((*i)->content->full_length() - (*i)->content->trim_end ())) { + /* In the end-trimmed part; decoder has nothing else to give us */ + dec.reset (); + done = true; + } else if (t >= (*i)->content->trim_start ()) { + /* Within the un-trimmed part; everything's ok */ + done = true; + } else { + /* Within the start-trimmed part; get something else */ + (*i)->decoder->consume (); + } + } + + if (!dec) { continue; } - if (_video && dynamic_pointer_cast ((*i)->decoder)) { - if ((*i)->video_position < earliest_t) { - earliest_t = (*i)->video_position; - earliest = *i; - type = VIDEO; - } + if (dec->dcp_time < earliest_time) { + earliest_piece = *i; + earliest_decoded = dec; + earliest_time = dec->dcp_time; } - if (_audio && dynamic_pointer_cast ((*i)->decoder)) { - if ((*i)->audio_position < earliest_t) { - earliest_t = (*i)->audio_position; - earliest = *i; - type = AUDIO; - } + if (dynamic_pointer_cast (dec) && dec->dcp_time < earliest_audio) { + earliest_audio = dec->dcp_time; } } - - if (!earliest) { -#ifdef DEBUG_PLAYER - cout << "no earliest piece.\n"; -#endif + if (!earliest_piece) { flush (); return true; } - switch (type) { - case VIDEO: - if (earliest_t > _video_position) { -#ifdef DEBUG_PLAYER - cout << "no video here; emitting black frame (earliest=" << earliest_t << ", video_position=" << _video_position << ").\n"; -#endif - emit_black (); + if (earliest_audio != TIME_MAX) { + TimedAudioBuffers tb = _audio_merger.pull (max (int64_t (0), earliest_audio)); + Audio (tb.audio, tb.time); + /* This assumes that the audio_frames_to_time conversion is exact + so that there are no accumulated errors caused by rounding. + */ + _audio_position += _film->audio_frames_to_time (tb.audio->frames ()); + } + + /* Emit the earliest thing */ + + shared_ptr dv = dynamic_pointer_cast (earliest_decoded); + shared_ptr da = dynamic_pointer_cast (earliest_decoded); + shared_ptr ds = dynamic_pointer_cast (earliest_decoded); + + /* Will be set to false if we shouldn't consume the peeked DecodedThing */ + bool consume = true; + + /* This is the margin either side of _{video,audio}_position that we will accept + as a starting point for a frame consecutive to the previous. + */ + DCPTime const margin = TIME_HZ / (2 * _film->video_frame_rate ()); + + if (dv && _video) { + + if (_just_did_inaccurate_seek) { + + /* Just emit; no subtlety */ + emit_video (earliest_piece, dv); + step_video_position (dv); + + } else if (dv->dcp_time - _video_position > margin) { + + /* Too far ahead */ + + list >::iterator i = _pieces.begin(); + while (i != _pieces.end() && ((*i)->content->position() >= _video_position || _video_position >= (*i)->content->end())) { + ++i; + } + + if (i == _pieces.end() || !_last_incoming_video.video || !_have_valid_pieces) { + /* We're outside all video content */ + emit_black (); + _statistics.video.black++; + } else { + /* We're inside some video; repeat the frame */ + _last_incoming_video.video->dcp_time = _video_position; + emit_video (_last_incoming_video.weak_piece, _last_incoming_video.video); + step_video_position (_last_incoming_video.video); + _statistics.video.repeat++; + } + + consume = false; + + } else if (abs (dv->dcp_time - _video_position) < margin) { + /* We're ok */ + emit_video (earliest_piece, dv); + step_video_position (dv); + _statistics.video.good++; } else { -#ifdef DEBUG_PLAYER - cout << "Pass " << *earliest << "\n"; -#endif - earliest->decoder->pass (); + /* Too far behind: skip */ + _statistics.video.skip++; } - break; - case AUDIO: - if (earliest_t > _audio_position) { -#ifdef DEBUG_PLAYER - cout << "no audio here; emitting silence.\n"; -#endif - emit_silence (_film->time_to_audio_frames (earliest_t - _audio_position)); + _just_did_inaccurate_seek = false; + + } else if (da && _audio) { + + if (da->dcp_time - _audio_position > margin) { + /* Too far ahead */ + emit_silence (da->dcp_time - _audio_position); + consume = false; + _statistics.audio.silence += (da->dcp_time - _audio_position); + } else if (abs (da->dcp_time - _audio_position) < margin) { + /* We're ok */ + emit_audio (earliest_piece, da); + _statistics.audio.good += da->data->frames(); } else { -#ifdef DEBUG_PLAYER - cout << "Pass " << *earliest << "\n"; -#endif - earliest->decoder->pass (); + /* Too far behind: skip */ + _statistics.audio.skip += da->data->frames(); } - break; + + } else if (ds && _video) { + _in_subtitle.piece = earliest_piece; + _in_subtitle.subtitle = ds; + update_subtitle (); } -#ifdef DEBUG_PLAYER - cout << "\tpost pass " << _video_position << " " << _audio_position << "\n"; -#endif - + if (consume) { + earliest_piece->decoder->consume (); + } + return false; } void -Player::process_video (weak_ptr weak_piece, shared_ptr image, bool same, VideoContent::Frame frame) +Player::emit_video (weak_ptr weak_piece, shared_ptr video) { + /* Keep a note of what came in so that we can repeat it if required */ + _last_incoming_video.weak_piece = weak_piece; + _last_incoming_video.video = video; + shared_ptr piece = weak_piece.lock (); if (!piece) { return; @@ -212,49 +264,62 @@ Player::process_video (weak_ptr weak_piece, shared_ptr image shared_ptr content = dynamic_pointer_cast (piece->content); assert (content); - FrameRateConversion frc (content->video_frame_rate(), _film->dcp_video_frame_rate()); - if (frc.skip && (frame % 2) == 1) { - return; - } + FrameRateChange frc (content->video_frame_rate(), _film->video_frame_rate()); - shared_ptr work_image = image->crop (content->crop(), true); + float const ratio = content->ratio() ? content->ratio()->ratio() : content->video_size_after_crop().ratio(); + libdcp::Size image_size = fit_ratio_within (ratio, _video_container_size); + if (_approximate_size) { + image_size.width &= ~3; + image_size.height &= ~3; + } - libdcp::Size const image_size = content->ratio()->size (_video_container_size); + shared_ptr pi ( + new PlayerImage ( + video->image, + content->crop(), + image_size, + _video_container_size, + _film->scaler() + ) + ); - work_image = work_image->scale_and_convert_to_rgb (image_size, _film->scaler(), true); + if ( + _film->with_subtitles () && + _out_subtitle.image && + video->dcp_time >= _out_subtitle.from && video->dcp_time <= _out_subtitle.to + ) { - Time time = content->start() + (frame * frc.factor() * TIME_HZ / _film->dcp_video_frame_rate()); - - if (_film->with_subtitles () && _out_subtitle.image && time >= _out_subtitle.from && time <= _out_subtitle.to) { - work_image->alpha_blend (_out_subtitle.image, _out_subtitle.position); - } + Position const container_offset ( + (_video_container_size.width - image_size.width) / 2, + (_video_container_size.height - image_size.height) / 2 + ); - if (image_size != _video_container_size) { - assert (image_size.width <= _video_container_size.width); - assert (image_size.height <= _video_container_size.height); - shared_ptr im (new Image (PIX_FMT_RGB24, _video_container_size, true)); - im->make_black (); - im->copy (work_image, Position ((_video_container_size.width - image_size.width) / 2, (_video_container_size.height - image_size.height) / 2)); - work_image = im; + pi->set_subtitle (_out_subtitle.image, _out_subtitle.position + container_offset); } - + #ifdef DCPOMATIC_DEBUG _last_video = piece->content; -#endif +#endif - Video (work_image, same, time); - time += TIME_HZ / _film->dcp_video_frame_rate(); + Video (pi, video->eyes, content->colour_conversion(), video->same, video->dcp_time); + + _last_emit_was_black = false; +} - if (frc.repeat) { - Video (work_image, true, time); - time += TIME_HZ / _film->dcp_video_frame_rate(); +void +Player::step_video_position (shared_ptr video) +{ + /* This is a bit of a hack; don't update _video_position if EYES_RIGHT is on its way */ + if (video->eyes != EYES_LEFT) { + /* This assumes that the video_frames_to_time conversion is exact + so that there are no accumulated errors caused by rounding. + */ + _video_position += _film->video_frames_to_time (1); } - - _video_position = piece->video_position = time; } void -Player::process_audio (weak_ptr weak_piece, shared_ptr audio, AudioContent::Frame frame) +Player::emit_audio (weak_ptr weak_piece, shared_ptr audio) { shared_ptr piece = weak_piece.lock (); if (!piece) { @@ -264,90 +329,58 @@ Player::process_audio (weak_ptr weak_piece, shared_ptr content = dynamic_pointer_cast (piece->content); assert (content); - /* Resample */ - if (content->content_audio_frame_rate() != content->output_audio_frame_rate()) { - shared_ptr r = resampler (content); - audio = r->run (audio); + /* Gain */ + if (content->audio_gain() != 0) { + shared_ptr gain (new AudioBuffers (audio->data)); + gain->apply_gain (content->audio_gain ()); + audio->data = gain; } /* Remap channels */ - shared_ptr dcp_mapped (new AudioBuffers (_film->dcp_audio_channels(), audio->frames())); + shared_ptr dcp_mapped (new AudioBuffers (_film->audio_channels(), audio->data->frames())); dcp_mapped->make_silent (); list > map = content->audio_mapping().content_to_dcp (); for (list >::iterator i = map.begin(); i != map.end(); ++i) { - if (i->first < audio->channels() && i->second < dcp_mapped->channels()) { - dcp_mapped->accumulate_channel (audio.get(), i->first, i->second); + if (i->first < audio->data->channels() && i->second < dcp_mapped->channels()) { + dcp_mapped->accumulate_channel (audio->data.get(), i->first, i->second); } } - audio = dcp_mapped; + audio->data = dcp_mapped; - Time time = content->start() + (frame * TIME_HZ / _film->dcp_audio_frame_rate()) + (content->audio_delay() * TIME_HZ / 1000); - - /* We must cut off anything that comes before the start of all time */ - if (time < 0) { - int const frames = - time * _film->dcp_audio_frame_rate() / TIME_HZ; - if (frames >= audio->frames ()) { + /* Delay */ + audio->dcp_time += content->audio_delay() * TIME_HZ / 1000; + if (audio->dcp_time < 0) { + int const frames = - audio->dcp_time * _film->audio_frame_rate() / TIME_HZ; + if (frames >= audio->data->frames ()) { return; } - shared_ptr trimmed (new AudioBuffers (audio->channels(), audio->frames() - frames)); - trimmed->copy_from (audio.get(), audio->frames() - frames, frames, 0); - - audio = trimmed; - time = 0; - } - - /* The time of this audio may indicate that some of our buffered audio is not going to - be added to any more, so it can be emitted. - */ + shared_ptr trimmed (new AudioBuffers (audio->data->channels(), audio->data->frames() - frames)); + trimmed->copy_from (audio->data.get(), audio->data->frames() - frames, frames, 0); - if (time > _audio_position) { - /* We can emit some audio from our buffers */ - OutputAudioFrame const N = _film->time_to_audio_frames (time - _audio_position); - if (N > _audio_buffers.frames()) { - /* We need some extra silence before whatever is in the buffers */ - _audio_buffers.ensure_size (N); - _audio_buffers.move (0, N - _audio_buffers.frames(), _audio_buffers.frames ()); - _audio_buffers.make_silent (0, _audio_buffers.frames()); - _audio_buffers.set_frames (N); - } - assert (N <= _audio_buffers.frames()); - shared_ptr emit (new AudioBuffers (_audio_buffers.channels(), N)); - emit->copy_from (&_audio_buffers, N, 0, 0); - Audio (emit, _audio_position); - _audio_position = piece->audio_position = time + _film->audio_frames_to_time (N); - - /* And remove it from our buffers */ - if (_audio_buffers.frames() > N) { - _audio_buffers.move (N, 0, _audio_buffers.frames() - N); - } - _audio_buffers.set_frames (_audio_buffers.frames() - N); + audio->data = trimmed; + audio->dcp_time = 0; } - /* Now accumulate the new audio into our buffers */ - _audio_buffers.ensure_size (_audio_buffers.frames() + audio->frames()); - _audio_buffers.accumulate_frames (audio.get(), 0, 0, audio->frames ()); - _audio_buffers.set_frames (_audio_buffers.frames() + audio->frames()); + _audio_merger.push (audio->data, audio->dcp_time); } void Player::flush () { - if (_audio_buffers.frames() > 0) { - shared_ptr emit (new AudioBuffers (_audio_buffers.channels(), _audio_buffers.frames())); - emit->copy_from (&_audio_buffers, _audio_buffers.frames(), 0, 0); - Audio (emit, _audio_position); - _audio_position += _film->audio_frames_to_time (_audio_buffers.frames ()); - _audio_buffers.set_frames (0); + TimedAudioBuffers tb = _audio_merger.flush (); + if (_audio && tb.audio) { + Audio (tb.audio, tb.time); + _audio_position += _film->audio_frames_to_time (tb.audio->frames ()); } - while (_video_position < _audio_position) { + while (_video && _video_position < _audio_position) { emit_black (); } - while (_audio_position < _video_position) { - emit_silence (_film->time_to_audio_frames (_video_position - _audio_position)); + while (_audio && _audio_position < _video_position) { + emit_silence (_video_position - _audio_position); } } @@ -357,11 +390,10 @@ Player::flush () * @return true on error */ void -Player::seek (Time t, bool accurate) +Player::seek (DCPTime t, bool accurate) { if (!_have_valid_pieces) { setup_pieces (); - _have_valid_pieces = true; } if (_pieces.empty ()) { @@ -369,95 +401,114 @@ Player::seek (Time t, bool accurate) } for (list >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) { - shared_ptr vc = dynamic_pointer_cast ((*i)->content); - if (!vc) { - continue; - } - - Time s = t - vc->start (); - s = max (static_cast