Fix crash brought on by previous.
[dcpomatic.git] / src / lib / player.cc
index 1e0a6dcf03b6044fc1dda191217cdf72d85834a1..035af81feba6215ee61a52eac3fa453f3fa205f8 100644 (file)
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2013-2016 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2013-2017 Carl Hetherington <cth@carlh.net>
 
     This file is part of DCP-o-matic.
 
@@ -47,6 +47,8 @@
 #include "content_subtitle.h"
 #include "dcp_decoder.h"
 #include "image_decoder.h"
+#include "resampler.h"
+#include "compose.hpp"
 #include <dcp/reel.h>
 #include <dcp/reel_sound_asset.h>
 #include <dcp/reel_subtitle_asset.h>
@@ -76,24 +78,6 @@ using boost::dynamic_pointer_cast;
 using boost::optional;
 using boost::scoped_ptr;
 
-static bool
-has_video (Content* c)
-{
-       return static_cast<bool>(c->video);
-}
-
-static bool
-has_audio (Content* c)
-{
-       return static_cast<bool>(c->audio);
-}
-
-static bool
-has_subtitle (Content* c)
-{
-       return static_cast<bool>(c->subtitle);
-}
-
 Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist)
        : _film (film)
        , _playlist (playlist)
@@ -103,7 +87,7 @@ Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist
        , _always_burn_subtitles (false)
        , _fast (false)
        , _play_referenced (false)
-       , _audio_merger (_film->audio_channels(), _film->audio_frame_rate())
+       , _audio_merger (_film->audio_frame_rate())
 {
        _film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1));
        _playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this));
@@ -111,6 +95,8 @@ Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist
        set_video_container_size (_film->frame_size ());
 
        film_changed (Film::AUDIO_PROCESSOR);
+
+       seek (DCPTime (), true);
 }
 
 void
@@ -140,10 +126,6 @@ Player::setup_pieces ()
                        decoder->audio->set_ignore ();
                }
 
-               if (decoder->audio && _fast) {
-                       decoder->audio->set_fast ();
-               }
-
                shared_ptr<DCPDecoder> dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
                if (dcp && _play_referenced) {
                        dcp->set_decode_referenced ();
@@ -166,6 +148,28 @@ Player::setup_pieces ()
                }
        }
 
+       BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
+               if (i->content->audio) {
+                       BOOST_FOREACH (AudioStreamPtr j, i->content->audio->streams()) {
+                               _stream_states[j] = StreamState (i, i->content->position ());
+                       }
+               }
+       }
+
+       if (!_play_referenced) {
+               BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
+                       shared_ptr<DCPContent> dc = dynamic_pointer_cast<DCPContent> (i->content);
+                       if (dc) {
+                               if (dc->reference_video()) {
+                                       _no_video.push_back (DCPTimePeriod (dc->position(), dc->end()));
+                               }
+                               if (dc->reference_audio()) {
+                                       _no_audio.push_back (DCPTimePeriod (dc->position(), dc->end()));
+                               }
+                       }
+               }
+       }
+
        _have_valid_pieces = true;
 }
 
@@ -304,12 +308,11 @@ Player::transform_image_subtitles (list<ImageSubtitle> subs) const
 }
 
 shared_ptr<PlayerVideo>
-Player::black_player_video_frame (DCPTime time) const
+Player::black_player_video_frame () const
 {
        return shared_ptr<PlayerVideo> (
                new PlayerVideo (
                        shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)),
-                       time,
                        Crop (),
                        optional<double> (),
                        _video_container_size,
@@ -364,7 +367,7 @@ Player::resampled_audio_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 }
 
 ContentTime
-Player::dcp_to_content_subtitle (shared_ptr<const Piece> piece, DCPTime t) const
+Player::dcp_to_content_time (shared_ptr<const Piece> piece, DCPTime t) const
 {
        DCPTime s = t - piece->content->position ();
        s = min (piece->content->length_after_trim(), s);
@@ -372,7 +375,7 @@ Player::dcp_to_content_subtitle (shared_ptr<const Piece> piece, DCPTime t) const
 }
 
 DCPTime
-Player::content_subtitle_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
+Player::content_time_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
 {
        return max (DCPTime (), DCPTime (t - piece->content->trim_start(), piece->frc) + piece->content->position());
 }
@@ -527,18 +530,55 @@ Player::pass ()
        }
 
        shared_ptr<Piece> earliest;
-       DCPTime earliest_position;
+       DCPTime earliest_content;
+
        BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
-               DCPTime const t = i->content->position() + DCPTime (i->decoder->position(), i->frc);
-               if (t < earliest_position) {
-                       earliest_position = t;
-                       earliest = i;
+               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 (!earliest) {
+               /* No more content; fill up with silent black */
+               DCPTimePeriod remaining_video (DCPTime(), _playlist->length());
+               if (_last_time) {
+                       remaining_video.from = _last_time.get() + one_video_frame();
+               }
+               fill_video (remaining_video);
+               fill_audio (DCPTimePeriod (_last_audio_time, _playlist->length()));
+               return true;
+       }
+
+       earliest->done = earliest->decoder->pass ();
+       if (earliest->done && earliest->content->audio) {
+               /* Flush the Player audio system for this piece */
+               BOOST_FOREACH (AudioStreamPtr i, earliest->content->audio->streams()) {
+                       audio_flush (earliest, i);
+               }
+       }
+
+       /* Emit any audio that is ready */
+
+       DCPTime pull_from = _playlist->length ();
+       for (map<AudioStreamPtr, StreamState>::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;
                }
        }
 
-       earliest->decoder->pass ();
+       list<pair<shared_ptr<AudioBuffers>, DCPTime> > audio = _audio_merger.pull (pull_from);
+       for (list<pair<shared_ptr<AudioBuffers>, DCPTime> >::iterator i = audio.begin(); i != audio.end(); ++i) {
+               DCPOMATIC_ASSERT (i->second >= _last_audio_time);
+               fill_audio (DCPTimePeriod (_last_audio_time, i->second));
+               Audio (i->first, i->second);
+               _last_audio_time = i->second + DCPTime::from_frames(i->first->frames(), _film->audio_frame_rate());
+       }
 
-       /* XXX: collect audio and maybe emit some */
+       return false;
 }
 
 void
@@ -549,69 +589,127 @@ Player::video (weak_ptr<Piece> wp, ContentVideo video)
                return;
        }
 
-       /* XXX: get subs to burn in and burn them in */
+       FrameRateChange frc(piece->content->active_video_frame_rate(), _film->video_frame_rate());
+       if (frc.skip && (video.frame % 2) == 1) {
+               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 + one_video_frame());
 
+       /* Discard if it's outside the content's period */
+       if (time < piece->content->position() || time >= piece->content->end()) {
+               return;
+       }
 
-       /* Fill gaps */
+       /* Get any subtitles */
 
-       DCPTime const time = content_video_to_dcp (piece, video.frame.index());
+       optional<PositionImage> subtitles;
 
-       for (DCPTime i = _last_video_time; i < time; i += DCPTime::from_frames (1, _film->video_frame_rate())) {
-               if (_playlist->video_content_at(i) && _last_video) {
-                       Video (_last_video->clone (i));
-               } else {
-                       Video (black_player_video_frame (i));
+       for (list<pair<PlayerSubtitles, DCPTimePeriod> >::const_iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) {
+
+               if (!i->second.overlap (period)) {
+                       continue;
+               }
+
+               list<PositionImage> sub_images;
+
+               /* Image subtitles */
+               list<PositionImage> 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<PositionImage> s = render_subtitles (i->first.text, i->first.fonts, _video_container_size, time);
+                       copy (s.begin (), s.end (), back_inserter (sub_images));
+               }
+
+               if (!sub_images.empty ()) {
+                       subtitles = merge (sub_images);
                }
        }
 
+       /* Fill gaps */
+
+       if (_last_time) {
+               fill_video (DCPTimePeriod (_last_time.get() + one_video_frame(), time));
+       }
+
        _last_video.reset (
                new PlayerVideo (
                        video.image,
-                       time,
                        piece->content->video->crop (),
-                       piece->content->video->fade (video.frame.index()),
+                       piece->content->video->fade (video.frame),
                        piece->content->video->scale().size (
                                piece->content->video, _video_container_size, _film->frame_size ()
                                ),
                        _video_container_size,
-                       video.frame.eyes(),
+                       video.eyes,
                        video.part,
                        piece->content->video->colour_conversion ()
                        )
                );
 
-       _last_video_time = time;
+       if (subtitles) {
+               _last_video->set_subtitle (subtitles.get ());
+       }
+
+       _last_time = time;
+
+       Video (_last_video, *_last_time);
 
-       Video (_last_video);
+       /* Discard any subtitles we no longer need */
+
+       for (list<pair<PlayerSubtitles, DCPTimePeriod> >::iterator i = _subtitles.begin (); i != _subtitles.end(); ) {
+               list<pair<PlayerSubtitles, DCPTimePeriod> >::iterator tmp = i;
+               ++tmp;
+
+               if (i->second.to < time) {
+                       _subtitles.erase (i);
+               }
+
+               i = tmp;
+       }
 }
 
 void
-Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
+Player::audio_flush (shared_ptr<Piece> piece, AudioStreamPtr stream)
 {
-       shared_ptr<Piece> piece = wp.lock ();
-       if (!piece) {
+       shared_ptr<AudioContent> content = piece->content->audio;
+       DCPOMATIC_ASSERT (content);
+
+       shared_ptr<Resampler> r = resampler (content, stream, false);
+       if (!r) {
                return;
        }
 
-       shared_ptr<AudioContent> content = piece->content->audio;
-       DCPOMATIC_ASSERT (content);
+       pair<shared_ptr<const AudioBuffers>, Frame> ro = r->flush ();
+       ContentAudio content_audio;
+       content_audio.audio = ro.first;
+       content_audio.frame = ro.second;
+
+       /* Compute time in the DCP */
+       DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame) + DCPTime::from_seconds (content->delay() / 1000.0);
 
-       shared_ptr<AudioBuffers> audio = content_audio.audio;
+       audio_transform (content, stream, content_audio, time);
+}
 
+/** Do our common processing on some audio */
+void
+Player::audio_transform (shared_ptr<AudioContent> content, AudioStreamPtr stream, ContentAudio content_audio, DCPTime time)
+{
        /* Gain */
+
        if (content->gain() != 0) {
-               shared_ptr<AudioBuffers> gain (new AudioBuffers (audio));
+               shared_ptr<AudioBuffers> gain (new AudioBuffers (content_audio.audio));
                gain->apply_gain (content->gain ());
-               audio = gain;
+               content_audio.audio = gain;
        }
 
-       /* XXX: end-trimming used to be checked here */
-
-       /* Compute time in the DCP */
-       DCPTime const time = resampled_audio_to_dcp (piece, content_audio.frame) + DCPTime::from_seconds (content->delay() / 1000);
+       /* Remap */
 
-       /* Remap channels */
-       shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), audio->frames()));
+       shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), content_audio.audio->frames()));
        dcp_mapped->make_silent ();
 
        AudioMapping map = stream->mapping ();
@@ -619,7 +717,7 @@ Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_a
                for (int j = 0; j < dcp_mapped->channels(); ++j) {
                        if (map.get (i, static_cast<dcp::Channel> (j)) > 0) {
                                dcp_mapped->accumulate_channel (
-                                       audio.get(),
+                                       content_audio.audio.get(),
                                        i,
                                        static_cast<dcp::Channel> (j),
                                        map.get (i, static_cast<dcp::Channel> (j))
@@ -628,33 +726,221 @@ Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_a
                }
        }
 
-       audio = dcp_mapped;
+       content_audio.audio = dcp_mapped;
+
+       /* Process */
 
        if (_audio_processor) {
-               audio = _audio_processor->run (audio, _film->audio_channels ());
+               content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ());
+       }
+
+       /* 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::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
+{
+       shared_ptr<Piece> piece = wp.lock ();
+       if (!piece) {
+               return;
+       }
+
+       shared_ptr<AudioContent> content = piece->content->audio;
+       DCPOMATIC_ASSERT (content);
+
+       /* Resample */
+       if (stream->frame_rate() != content->resampled_frame_rate()) {
+               shared_ptr<Resampler> r = resampler (content, stream, true);
+               pair<shared_ptr<const AudioBuffers>, 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);
+
+       /* Remove anything that comes before the start 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) {
+                       /* This audio is entirely discarded */
+                       return;
+               }
+               shared_ptr<AudioBuffers> cut (new AudioBuffers (content_audio.audio->channels(), remaining_frames));
+               cut->copy_from (content_audio.audio.get(), remaining_frames, discard_frames, 0);
+               content_audio.audio = cut;
+               time += discard_time;
        }
 
-       _audio_merger.push (audio, time);
+       audio_transform (content, stream, content_audio, time);
 }
 
 void
-Player::image_subtitle (weak_ptr<Piece> piece, ContentImageSubtitle subtitle)
+Player::image_subtitle (weak_ptr<Piece> wp, ContentImageSubtitle subtitle)
 {
-       /* XXX: Store for video to see */
+       shared_ptr<Piece> piece = wp.lock ();
+       if (!piece) {
+               return;
+       }
+
+       /* Apply content's subtitle offsets */
+       subtitle.sub.rectangle.x += piece->content->subtitle->x_offset ();
+       subtitle.sub.rectangle.y += piece->content->subtitle->y_offset ();
+
+       /* Apply content's subtitle scale */
+       subtitle.sub.rectangle.width *= piece->content->subtitle->x_scale ();
+       subtitle.sub.rectangle.height *= piece->content->subtitle->y_scale ();
+
+       /* Apply a corrective translation to keep the subtitle centred after that scale */
+       subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * (piece->content->subtitle->x_scale() - 1);
+       subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * (piece->content->subtitle->y_scale() - 1);
+
+       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));
+
+       if (piece->content->subtitle->use() && (piece->content->subtitle->burn() || _always_burn_subtitles)) {
+               _subtitles.push_back (make_pair (ps, period));
+       } else {
+               Subtitle (ps, period);
+       }
 }
 
 void
-Player::text_subtitle (weak_ptr<Piece> piece, ContentTextSubtitle subtitle)
+Player::text_subtitle (weak_ptr<Piece> wp, ContentTextSubtitle subtitle)
 {
-       /* XXX: Store for video to see, or emit */
+       shared_ptr<Piece> piece = wp.lock ();
+       if (!piece) {
+               return;
+       }
+
+       PlayerSubtitles ps;
+       DCPTimePeriod const period (content_time_to_dcp (piece, subtitle.period().from), content_time_to_dcp (piece, subtitle.period().to));
+
+       BOOST_FOREACH (dcp::SubtitleString s, subtitle.subs) {
+               s.set_h_position (s.h_position() + piece->content->subtitle->x_offset ());
+               s.set_v_position (s.v_position() + piece->content->subtitle->y_offset ());
+               float const xs = piece->content->subtitle->x_scale();
+               float const ys = piece->content->subtitle->y_scale();
+               float size = s.size();
+
+               /* Adjust size to express the common part of the scaling;
+                  e.g. if xs = ys = 0.5 we scale size by 2.
+               */
+               if (xs > 1e-5 && ys > 1e-5) {
+                       size *= 1 / min (1 / xs, 1 / ys);
+               }
+               s.set_size (size);
+
+               /* Then express aspect ratio changes */
+               if (fabs (1.0 - xs / ys) > dcp::ASPECT_ADJUST_EPSILON) {
+                       s.set_aspect_adjust (xs / ys);
+               }
+
+               s.set_in (dcp::Time(period.from.seconds(), 1000));
+               s.set_out (dcp::Time(period.to.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);
+       }
 }
 
 void
 Player::seek (DCPTime time, bool accurate)
 {
-       /* XXX: seek decoders */
+       if (_audio_processor) {
+               _audio_processor->flush ();
+       }
+
+       BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
+               if (i->content->position() <= time && time < i->content->end()) {
+                       i->decoder->seek (dcp_to_content_time (i, time), accurate);
+                       i->done = false;
+               }
+       }
 
        if (accurate) {
-               _last_video_time = time - DCPTime::from_frames (1, _film->video_frame_rate ());
+               _last_time = time - one_video_frame ();
+       } else {
+               _last_time = optional<DCPTime> ();
+       }
+}
+
+shared_ptr<Resampler>
+Player::resampler (shared_ptr<const AudioContent> content, AudioStreamPtr stream, bool create)
+{
+       ResamplerMap::const_iterator i = _resamplers.find (make_pair (content, stream));
+       if (i != _resamplers.end ()) {
+               return i->second;
+       }
+
+       if (!create) {
+               return shared_ptr<Resampler> ();
+       }
+
+       LOG_GENERAL (
+               "Creating new resampler from %1 to %2 with %3 channels",
+               stream->frame_rate(),
+               content->resampled_frame_rate(),
+               stream->channels()
+               );
+
+       shared_ptr<Resampler> r (
+               new Resampler (stream->frame_rate(), content->resampled_frame_rate(), stream->channels())
+               );
+
+       _resamplers[make_pair(content, stream)] = r;
+       return r;
+}
+
+void
+Player::fill_video (DCPTimePeriod period)
+{
+       /* XXX: this may not work for 3D */
+       BOOST_FOREACH (DCPTimePeriod i, subtract(period, _no_video)) {
+               for (DCPTime j = i.from; j < i.to; j += one_video_frame()) {
+                       if (_playlist->video_content_at(j) && _last_video) {
+                               Video (shared_ptr<PlayerVideo> (new PlayerVideo (*_last_video)), j);
+                       } else {
+                               Video (black_player_video_frame(), j);
+                       }
+               }
+       }
+}
+
+void
+Player::fill_audio (DCPTimePeriod period)
+{
+       BOOST_FOREACH (DCPTimePeriod i, subtract(period, _no_audio)) {
+               DCPTime t = i.from;
+               while (t < i.to) {
+                       DCPTime block = min (DCPTime::from_seconds (0.5), i.to - t);
+                       Frame const samples = block.frames_round(_film->audio_frame_rate());
+                       if (samples) {
+                               shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), samples));
+                               silence->make_silent ();
+                               Audio (silence, t);
+                       }
+                       t += block;
+               }
        }
 }
+
+DCPTime
+Player::one_video_frame () const
+{
+       return DCPTime::from_frames (1, _film->video_frame_rate ());
+}