, _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));
set_video_container_size (_film->frame_size ());
film_changed (Film::AUDIO_PROCESSOR);
+
+ seek (DCPTime (), true);
}
void
}
}
+ 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;
}
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
Player::resampled_audio_to_dcp (shared_ptr<const Piece> 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);
+ 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 ());
}
}
if (!earliest) {
- /* No more content; fill up to the length of our playlist with silent black */
-
- DCPTime const length = _playlist->length ();
-
- 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);
+ /* No more content; fill up with silent black */
+ DCPTimePeriod remaining_video (DCPTime(), _playlist->length());
+ if (_last_video_time) {
+ remaining_video.from = _last_video_time.get() + one_video_frame();
}
-
- DCPTime t = _last_audio_time;
- while (t < length) {
- DCPTime block = min (DCPTime::from_seconds (0.5), length - t);
- shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), block.frames_round(_film->audio_frame_rate())));
- silence->make_silent ();
- Audio (silence, t);
- t += block;
+ fill_video (remaining_video);
+ DCPTimePeriod remaining_audio (DCPTime(), _playlist->length());
+ if (_last_audio_time) {
+ remaining_audio.from = _last_audio_time.get();
}
-
+ fill_audio (remaining_audio);
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 */
- optional<DCPTime> earliest_audio;
- BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
- if (i->decoder->audio) {
- DCPTime t = i->content->position()
- + DCPTime (i->decoder->audio->position(), i->frc)
- + DCPTime::from_seconds (i->content->audio->delay() / 1000.0);
-
- if (t < DCPTime()) {
- t = DCPTime();
- }
-
- if (!earliest_audio || t < *earliest_audio) {
- earliest_audio = t;
- }
+ 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;
}
}
- pair<shared_ptr<AudioBuffers>, DCPTime> audio = _audio_merger.pull (earliest_audio.get_value_or(DCPTime()));
- 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<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), block.frames_round(_film->audio_frame_rate())));
- silence->make_silent ();
- Audio (silence, t);
- t += block;
+ 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 (!_last_audio_time || i->second >= _last_audio_time.get());
+ if (_last_audio_time) {
+ fill_audio (DCPTimePeriod (_last_audio_time.get(), i->second));
}
-
- Audio (audio.first, audio.second);
- _last_audio_time = audio.second + DCPTime::from_frames(audio.first->frames(), _film->audio_frame_rate());
+ Audio (i->first, i->second);
+ _last_audio_time = i->second + DCPTime::from_frames(i->first->frames(), _film->audio_frame_rate());
}
return false;
return;
}
+ 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 + DCPTime::from_frames (1, _film->video_frame_rate()));
+ 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()) {
/* Fill gaps */
- 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<PlayerVideo> (new PlayerVideo (*_last_video)), i);
- } else {
- Video (black_player_video_frame (), i);
- }
- }
+ if (_last_video_time) {
+ fill_video (DCPTimePeriod (_last_video_time.get() + one_video_frame(), time));
}
_last_video.reset (
_last_video->set_subtitle (subtitles.get ());
}
- _last_time = time;
+ _last_video_time = time;
- Video (_last_video, *_last_time);
+ Video (_last_video, *_last_video_time);
/* Discard any subtitles we no longer need */
}
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);
+ 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 (content_audio.audio));
gain->apply_gain (content->gain ());
content_audio.audio = gain;
}
- /* 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);
+ /* Remap */
- /* 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;
- }
-
- /* Remap channels */
shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), content_audio.audio->frames()));
dcp_mapped->make_silent ();
content_audio.audio = dcp_mapped;
+ /* Process */
+
if (_audio_processor) {
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;
+ }
+
+ /* Compute time in the DCP */
+ DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame) + DCPTime::from_seconds (content->delay() / 1000.0);
+ /* 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 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) {
+ /* 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;
+ } 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());
+ shared_ptr<AudioBuffers> cut (new AudioBuffers (content_audio.audio->channels(), remaining_frames));
+ cut->copy_from (content_audio.audio.get(), remaining_frames, 0, 0);
+ content_audio.audio = cut;
+ }
+
+ audio_transform (content, stream, content_audio, time);
}
void
void
Player::seek (DCPTime time, bool accurate)
{
+ 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);
}
if (accurate) {
- _last_time = time - DCPTime::from_frames (1, _film->video_frame_rate ());
+ _last_video_time = time - one_video_frame ();
+ _last_audio_time = time;
} else {
- _last_time = optional<DCPTime> ();
+ _last_video_time = optional<DCPTime> ();
+ _last_audio_time = optional<DCPTime> ();
}
}
_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 ());
+}
projects / dcpomatic.git / blobdiff