X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=f83e4ed26b7368228db0cad5e476d27c05a1ab7b;hb=2e504b33eb9f38cac629ad31b7c107fb0cf5efda;hp=d1098be24d8f4d3ac0e918a756c920d54277d75f;hpb=570d4c4489b49c3915674085ee24414f738cb914;p=dcpomatic.git diff --git a/src/lib/player.cc b/src/lib/player.cc index d1098be24..f83e4ed26 100644 --- a/src/lib/player.cc +++ b/src/lib/player.cc @@ -18,21 +18,26 @@ */ #include +#include #include "player.h" #include "film.h" #include "ffmpeg_decoder.h" +#include "audio_buffers.h" #include "ffmpeg_content.h" #include "image_decoder.h" #include "image_content.h" #include "sndfile_decoder.h" #include "sndfile_content.h" #include "subtitle_content.h" +#include "subrip_decoder.h" +#include "subrip_content.h" #include "playlist.h" #include "job.h" #include "image.h" #include "ratio.h" #include "log.h" #include "scaler.h" +#include "render_subtitles.h" using std::list; using std::cout; @@ -68,14 +73,15 @@ Player::Player (shared_ptr f, shared_ptr p) , _have_valid_pieces (false) , _video_position (0) , _audio_position (0) - , _audio_merger (f->audio_channels(), bind (&Film::time_to_audio_frames, f.get(), _1), bind (&Film::audio_frames_to_time, f.get(), _1)) + , _audio_merger (f->audio_channels(), f->audio_frame_rate ()) , _last_emit_was_black (false) , _just_did_inaccurate_seek (false) + , _approximate_size (false) { _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 ())); + set_video_container_size (_film->frame_size ()); } void @@ -101,18 +107,42 @@ Player::pass () shared_ptr earliest_piece; shared_ptr earliest_decoded; - DCPTime earliest_time = TIME_MAX; - DCPTime earliest_audio = TIME_MAX; + DCPTime earliest_time = DCPTime::max (); + DCPTime earliest_audio = DCPTime::max (); for (list >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) { - shared_ptr dec = (*i)->decoder->peek (); + 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 ((*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) { - dec->set_dcp_times ((*i)->frc.speed_up, (*i)->content->position()); + if (!dec) { + continue; } - if (dec && dec->dcp_time < earliest_time) { + if (dec->dcp_time < earliest_time) { earliest_piece = *i; earliest_decoded = dec; earliest_time = dec->dcp_time; @@ -128,22 +158,40 @@ Player::pass () return true; } - if (earliest_audio != TIME_MAX) { - TimedAudioBuffers tb = _audio_merger.pull (earliest_audio); + if (earliest_audio != DCPTime::max ()) { + if (earliest_audio.get() < 0) { + earliest_audio = DCPTime (); + } + TimedAudioBuffers tb = _audio_merger.pull (earliest_audio); Audio (tb.audio, tb.time); - _audio_position += _film->audio_frames_to_time (tb.audio->frames ()); + /* This assumes that the audio-frames-to-time conversion is exact + so that there are no accumulated errors caused by rounding. + */ + _audio_position += DCPTime::from_frames (tb.audio->frames(), _film->audio_frame_rate ()); } /* 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); + shared_ptr dis = dynamic_pointer_cast (earliest_decoded); + shared_ptr dts = dynamic_pointer_cast (earliest_decoded); + + /* Will be set to false if we shouldn't consume the peeked DecodedThing */ + bool consume = true; if (dv && _video) { - if (!_just_did_inaccurate_seek && earliest_time > _video_position) { - /* See if we're inside some video content */ + 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) { + + /* Too far ahead */ + list >::iterator i = _pieces.begin(); while (i != _pieces.end() && ((*i)->content->position() >= _video_position || _video_position >= (*i)->content->end())) { ++i; @@ -152,30 +200,59 @@ Player::pass () 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++; } - } else { + + consume = false; + + } else if (dv->dcp_time == _video_position) { + /* We're ok */ emit_video (earliest_piece, dv); - earliest_piece->decoder->get (); + step_video_position (dv); + _statistics.video.good++; + } else { + /* Too far behind: skip */ + _statistics.video.skip++; } + + _just_did_inaccurate_seek = false; + } else if (da && _audio) { - if (!_just_did_inaccurate_seek && earliest_time > _audio_position) { - emit_silence (earliest_time - _audio_position); - } else { + + if (da->dcp_time > _audio_position) { + /* Too far ahead */ + emit_silence (da->dcp_time - _audio_position); + consume = false; + _statistics.audio.silence += (da->dcp_time - _audio_position); + } else if (da->dcp_time == _audio_position) { + /* We're ok */ emit_audio (earliest_piece, da); - earliest_piece->decoder->get (); + _statistics.audio.good += da->data->frames(); + } else { + /* Too far behind: skip */ + _statistics.audio.skip += da->data->frames(); } - } else if (ds && _video) { - _in_subtitle.piece = earliest_piece; - _in_subtitle.subtitle = ds; - update_subtitle (); - earliest_piece->decoder->get (); + + } else if (dis && _video) { + _image_subtitle.piece = earliest_piece; + _image_subtitle.subtitle = dis; + update_subtitle_from_image (); + } else if (dts && _video) { + _text_subtitle.piece = earliest_piece; + _text_subtitle.subtitle = dts; + update_subtitle_from_text (); } - _just_did_inaccurate_seek = false; - + if (consume) { + earliest_piece->decoder->consume (); + } + return false; } @@ -195,20 +272,13 @@ Player::emit_video (weak_ptr weak_piece, shared_ptr video) assert (content); FrameRateChange frc (content->video_frame_rate(), _film->video_frame_rate()); -#if 0 - XXX - if (frc.skip && (frame % 2) == 1) { - return; - } -#endif - if (content->trimmed (video->dcp_time - content->position ())) { - return; + dcp::Size image_size = content->scale().size (content, _video_container_size); + if (_approximate_size) { + image_size.width &= ~3; + image_size.height &= ~3; } - float const ratio = content->ratio() ? content->ratio()->ratio() : content->video_size_after_crop().ratio(); - libdcp::Size const image_size = fit_ratio_within (ratio, _video_container_size); - shared_ptr pi ( new PlayerImage ( video->image, @@ -221,26 +291,38 @@ Player::emit_video (weak_ptr weak_piece, shared_ptr video) if ( _film->with_subtitles () && - _out_subtitle.subtitle->image && - video->dcp_time >= _out_subtitle.subtitle->dcp_time && video->dcp_time <= _out_subtitle.subtitle->dcp_time_to + _out_subtitle.image && + video->dcp_time >= _out_subtitle.from && video->dcp_time <= _out_subtitle.to ) { Position const container_offset ( (_video_container_size.width - image_size.width) / 2, - (_video_container_size.height - image_size.width) / 2 + (_video_container_size.height - image_size.height) / 2 ); - pi->set_subtitle (_out_subtitle.subtitle->image, _out_subtitle.position + container_offset); + pi->set_subtitle (_out_subtitle.image, _out_subtitle.position + container_offset); } + #ifdef DCPOMATIC_DEBUG _last_video = piece->content; #endif Video (pi, video->eyes, content->colour_conversion(), video->same, video->dcp_time); - + _last_emit_was_black = false; - _video_position = rint (video->dcp_time + TIME_HZ / _film->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 += DCPTime::from_frames (1, _film->video_frame_rate ()); + } } void @@ -261,26 +343,29 @@ Player::emit_audio (weak_ptr weak_piece, shared_ptr audio) audio->data = gain; } - if (content->trimmed (audio->dcp_time - content->position ())) { - return; - } - /* Remap channels */ 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->data->channels() && i->second < dcp_mapped->channels()) { - dcp_mapped->accumulate_channel (audio->data.get(), i->first, i->second); + AudioMapping map = content->audio_mapping (); + for (int i = 0; i < map.content_channels(); ++i) { + for (int j = 0; j < _film->audio_channels(); ++j) { + if (map.get (i, static_cast (j)) > 0) { + dcp_mapped->accumulate_channel ( + audio->data.get(), + i, + static_cast (j), + map.get (i, static_cast (j)) + ); + } } } audio->data = dcp_mapped; /* 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; + audio->dcp_time += DCPTime::from_seconds (content->audio_delay() / 1000.0); + if (audio->dcp_time < DCPTime (0)) { + int const frames = - audio->dcp_time.frames (_film->audio_frame_rate()); if (frames >= audio->data->frames ()) { return; } @@ -289,7 +374,7 @@ Player::emit_audio (weak_ptr weak_piece, shared_ptr audio) trimmed->copy_from (audio->data.get(), audio->data->frames() - frames, frames, 0); audio->data = trimmed; - audio->dcp_time = 0; + audio->dcp_time = DCPTime (); } _audio_merger.push (audio->data, audio->dcp_time); @@ -298,20 +383,19 @@ Player::emit_audio (weak_ptr weak_piece, shared_ptr audio) void Player::flush () { - TimedAudioBuffers tb = _audio_merger.flush (); - if (tb.audio) { + TimedAudioBuffers tb = _audio_merger.flush (); + if (_audio && tb.audio) { Audio (tb.audio, tb.time); - _audio_position += _film->audio_frames_to_time (tb.audio->frames ()); + _audio_position += DCPTime::from_frames (tb.audio->frames (), _film->audio_frame_rate ()); } - while (_video_position < _audio_position) { + while (_video && _video_position < _audio_position) { emit_black (); } - while (_audio_position < _video_position) { + while (_audio && _audio_position < _video_position) { emit_silence (_video_position - _audio_position); } - } /** Seek so that the next pass() will yield (approximately) the requested frame. @@ -336,14 +420,14 @@ Player::seek (DCPTime t, bool accurate) s = min ((*i)->content->length_after_trim(), s); /* Convert this to the content time */ - ContentTime ct = (s * (*i)->frc.speed_up) + (*i)->content->trim_start (); + ContentTime ct (s + (*i)->content->trim_start(), (*i)->frc); /* And seek the decoder */ (*i)->decoder->seek (ct, accurate); } - _video_position = time_round_up (t, TIME_HZ / _film->video_frame_rate()); - _audio_position = time_round_up (t, TIME_HZ / _film->audio_frame_rate()); + _video_position = t.round_up (_film->video_frame_rate()); + _audio_position = t.round_up (_film->audio_frame_rate()); _audio_merger.clear (_audio_position); @@ -368,15 +452,45 @@ Player::setup_pieces () for (ContentList::iterator i = content.begin(); i != content.end(); ++i) { + if (!(*i)->paths_valid ()) { + continue; + } + shared_ptr decoder; optional frc; + /* Work out a FrameRateChange for the best overlap video for this content, in case we need it below */ + DCPTime best_overlap_t; + shared_ptr best_overlap; + for (ContentList::iterator j = content.begin(); j != content.end(); ++j) { + shared_ptr vc = dynamic_pointer_cast (*j); + if (!vc) { + continue; + } + + DCPTime const overlap = max (vc->position(), (*i)->position()) - min (vc->end(), (*i)->end()); + if (overlap > best_overlap_t) { + best_overlap = vc; + best_overlap_t = overlap; + } + } + + optional best_overlap_frc; + if (best_overlap) { + best_overlap_frc = FrameRateChange (best_overlap->video_frame_rate(), _film->video_frame_rate ()); + } else { + /* No video overlap; e.g. if the DCP is just audio */ + best_overlap_frc = FrameRateChange (_film->video_frame_rate(), _film->video_frame_rate ()); + } + + /* FFmpeg */ shared_ptr fc = dynamic_pointer_cast (*i); if (fc) { - decoder.reset (new FFmpegDecoder (_film, fc, _video, _audio)); + decoder.reset (new FFmpegDecoder (fc, _film->log(), _video, _audio, _film->with_subtitles ())); frc = FrameRateChange (fc->video_frame_rate(), _film->video_frame_rate()); } - + + /* ImageContent */ shared_ptr ic = dynamic_pointer_cast (*i); if (ic) { /* See if we can re-use an old ImageDecoder */ @@ -388,50 +502,39 @@ Player::setup_pieces () } if (!decoder) { - decoder.reset (new ImageDecoder (_film, ic)); + decoder.reset (new ImageDecoder (ic)); } frc = FrameRateChange (ic->video_frame_rate(), _film->video_frame_rate()); } + /* SndfileContent */ shared_ptr sc = dynamic_pointer_cast (*i); if (sc) { - decoder.reset (new SndfileDecoder (_film, sc)); - - /* Working out the frc for this content is a bit tricky: what if it overlaps - two pieces of video content with different frame rates? For now, use - the one with the best overlap. - */ - - DCPTime best_overlap_t = 0; - shared_ptr best_overlap; - for (ContentList::iterator j = content.begin(); j != content.end(); ++j) { - shared_ptr vc = dynamic_pointer_cast (*j); - if (!vc) { - continue; - } - - DCPTime const overlap = max (vc->position(), sc->position()) - min (vc->end(), sc->end()); - if (overlap > best_overlap_t) { - best_overlap = vc; - best_overlap_t = overlap; - } - } + decoder.reset (new SndfileDecoder (sc)); + frc = best_overlap_frc; + } - if (best_overlap) { - frc = FrameRateChange (best_overlap->video_frame_rate(), _film->video_frame_rate ()); - } else { - /* No video overlap; e.g. if the DCP is just audio */ - frc = FrameRateChange (_film->video_frame_rate(), _film->video_frame_rate ()); - } + /* SubRipContent */ + shared_ptr rc = dynamic_pointer_cast (*i); + if (rc) { + decoder.reset (new SubRipDecoder (rc)); + frc = best_overlap_frc; } - decoder->seek ((*i)->trim_start (), true); + ContentTime st ((*i)->trim_start(), frc.get ()); + decoder->seek (st, true); _pieces.push_back (shared_ptr (new Piece (*i, decoder, frc.get ()))); } _have_valid_pieces = true; + + /* The Piece for the _last_incoming_video will no longer be valid */ + _last_incoming_video.video.reset (); + + _video_position = DCPTime (); + _audio_position = DCPTime (); } void @@ -451,17 +554,26 @@ Player::content_changed (weak_ptr w, int property, bool frequent) _have_valid_pieces = false; Changed (frequent); - } else if (property == SubtitleContentProperty::SUBTITLE_OFFSET || property == SubtitleContentProperty::SUBTITLE_SCALE) { + } else if ( + property == SubtitleContentProperty::SUBTITLE_X_OFFSET || + property == SubtitleContentProperty::SUBTITLE_Y_OFFSET || + property == SubtitleContentProperty::SUBTITLE_SCALE + ) { - update_subtitle (); + update_subtitle_from_image (); + update_subtitle_from_text (); Changed (frequent); - } else if (property == VideoContentProperty::VIDEO_CROP || property == VideoContentProperty::VIDEO_RATIO) { + } else if ( + property == VideoContentProperty::VIDEO_CROP || property == VideoContentProperty::VIDEO_SCALE || + property == VideoContentProperty::VIDEO_FRAME_RATE + ) { Changed (frequent); } else if (property == ContentProperty::PATH) { + _have_valid_pieces = false; Changed (frequent); } } @@ -474,7 +586,7 @@ Player::playlist_changed () } void -Player::set_video_container_size (libdcp::Size s) +Player::set_video_container_size (dcp::Size s) { _video_container_size = s; @@ -500,21 +612,22 @@ Player::emit_black () #endif Video (_black_frame, EYES_BOTH, ColourConversion(), _last_emit_was_black, _video_position); - _video_position += _film->video_frames_to_time (1); + _video_position += DCPTime::from_frames (1, _film->video_frame_rate ()); _last_emit_was_black = true; } void Player::emit_silence (DCPTime most) { - if (most == 0) { + if (most == DCPTime ()) { return; } - DCPTime t = min (most, TIME_HZ / 2); - shared_ptr silence (new AudioBuffers (_film->audio_channels(), t * _film->audio_frame_rate() / TIME_HZ)); + DCPTime t = min (most, DCPTime::from_seconds (0.5)); + shared_ptr silence (new AudioBuffers (_film->audio_channels(), t.frames (_film->audio_frame_rate()))); silence->make_silent (); Audio (silence, _audio_position); + _audio_position += t; } @@ -526,31 +639,32 @@ Player::film_changed (Film::Property p) last time we were run. */ - if (p == Film::SCALER || p == Film::WITH_SUBTITLES || p == Film::CONTAINER) { + if (p == Film::SCALER || p == Film::WITH_SUBTITLES || p == Film::CONTAINER || p == Film::VIDEO_FRAME_RATE) { Changed (false); } } void -Player::update_subtitle () +Player::update_subtitle_from_image () { - shared_ptr piece = _in_subtitle.piece.lock (); + shared_ptr piece = _image_subtitle.piece.lock (); if (!piece) { return; } - if (!_in_subtitle.subtitle->image) { - _out_subtitle.subtitle->image.reset (); + if (!_image_subtitle.subtitle->image) { + _out_subtitle.image.reset (); return; } shared_ptr sc = dynamic_pointer_cast (piece->content); assert (sc); - dcpomatic::Rect in_rect = _in_subtitle.subtitle->rect; - libdcp::Size scaled_size; + dcpomatic::Rect in_rect = _image_subtitle.subtitle->rect; + dcp::Size scaled_size; - in_rect.y += sc->subtitle_offset (); + in_rect.x += sc->subtitle_x_offset (); + in_rect.y += sc->subtitle_y_offset (); /* We will scale the subtitle up to fit _video_container_size, and also by the additional subtitle_scale */ scaled_size.width = in_rect.width * _video_container_size.width * sc->subtitle_scale (); @@ -571,15 +685,15 @@ Player::update_subtitle () _out_subtitle.position.x = rint (_video_container_size.width * (in_rect.x + (in_rect.width * (1 - sc->subtitle_scale ()) / 2))); _out_subtitle.position.y = rint (_video_container_size.height * (in_rect.y + (in_rect.height * (1 - sc->subtitle_scale ()) / 2))); - _out_subtitle.subtitle->image = _in_subtitle.subtitle->image->scale ( + _out_subtitle.image = _image_subtitle.subtitle->image->scale ( scaled_size, Scaler::from_id ("bicubic"), - _in_subtitle.subtitle->image->pixel_format (), + _image_subtitle.subtitle->image->pixel_format (), true ); - _out_subtitle.subtitle->dcp_time = _in_subtitle.subtitle->dcp_time; - _out_subtitle.subtitle->dcp_time = _in_subtitle.subtitle->dcp_time; + _out_subtitle.from = _image_subtitle.subtitle->dcp_time + piece->content->position (); + _out_subtitle.to = _image_subtitle.subtitle->dcp_time_to + piece->content->position (); } /** Re-emit the last frame that was emitted, using current settings for crop, ratio, scaler and subtitles. @@ -600,11 +714,28 @@ Player::repeat_last_video () return true; } +void +Player::update_subtitle_from_text () +{ + if (_text_subtitle.subtitle->subs.empty ()) { + _out_subtitle.image.reset (); + return; + } + + render_subtitles (_text_subtitle.subtitle->subs, _video_container_size, _out_subtitle.image, _out_subtitle.position); +} + +void +Player::set_approximate_size () +{ + _approximate_size = true; +} + PlayerImage::PlayerImage ( shared_ptr in, Crop crop, - libdcp::Size inter_size, - libdcp::Size out_size, + dcp::Size inter_size, + dcp::Size out_size, Scaler const * scaler ) : _in (in) @@ -624,10 +755,10 @@ PlayerImage::set_subtitle (shared_ptr image, Position pos) } shared_ptr -PlayerImage::image () +PlayerImage::image (AVPixelFormat format, bool aligned) { - shared_ptr out = _in->crop_scale_window (_crop, _inter_size, _out_size, _scaler, PIX_FMT_RGB24, false); - + shared_ptr out = _in->crop_scale_window (_crop, _inter_size, _out_size, _scaler, format, aligned); + Position const container_offset ((_out_size.width - _inter_size.width) / 2, (_out_size.height - _inter_size.width) / 2); if (_subtitle_image) { @@ -636,3 +767,16 @@ PlayerImage::image () return out; } + +void +PlayerStatistics::dump (shared_ptr log) const +{ + log->log (String::compose ("Video: %1 good %2 skipped %3 black %4 repeat", video.good, video.skip, video.black, video.repeat)); + log->log (String::compose ("Audio: %1 good %2 skipped %3 silence", audio.good, audio.skip, audio.silence.seconds())); +} + +PlayerStatistics const & +Player::statistics () const +{ + return _statistics; +}