, _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;
}
}
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;
+ /* No more content; fill up with silent black */
+ DCPTimePeriod remaining_video (DCPTime(), _playlist->length());
if (_last_time) {
- from = _last_time.get() + frame;
- }
- for (DCPTime i = from; i < length; i += frame) {
- Video (black_player_video_frame (), i);
+ remaining_video.from = _last_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);
+ 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 */
- 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;
- }
-
- Audio (audio.first, audio.second);
- _last_audio_time = audio.second + DCPTime::from_frames(audio.first->frames(), _film->audio_frame_rate());
+ 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());
}
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);
- }
- }
+ fill_video (DCPTimePeriod (_last_time.get() + one_video_frame(), time));
}
_last_video.reset (
}
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;
}
+ /* Remap */
+
+ shared_ptr<AudioBuffers> 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<dcp::Channel> (j)) > 0) {
+ dcp_mapped->accumulate_channel (
+ content_audio.audio.get(),
+ i,
+ static_cast<dcp::Channel> (j),
+ map.get (i, static_cast<dcp::Channel> (j))
+ );
+ }
+ }
+ }
+
+ 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);
time += discard_time;
}
- /* Remap channels */
- shared_ptr<AudioBuffers> 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<dcp::Channel> (j)) > 0) {
- dcp_mapped->accumulate_channel (
- content_audio.audio.get(),
- i,
- static_cast<dcp::Channel> (j),
- map.get (i, static_cast<dcp::Channel> (j))
- );
- }
- }
- }
-
- content_audio.audio = dcp_mapped;
-
- if (_audio_processor) {
- content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ());
- }
-
- _audio_merger.push (content_audio.audio, time);
+ 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_time = time - one_video_frame ();
} else {
_last_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 ());
+}