#include "atmos_decoder.h"
-#include "player.h"
-#include "film.h"
#include "audio_buffers.h"
-#include "content_audio.h"
+#include "audio_content.h"
+#include "audio_decoder.h"
+#include "audio_processor.h"
+#include "compose.hpp"
+#include "config.h"
#include "dcp_content.h"
+#include "dcp_decoder.h"
#include "dcpomatic_log.h"
-#include "job.h"
+#include "decoder.h"
+#include "decoder_factory.h"
+#include "ffmpeg_content.h"
+#include "film.h"
+#include "frame_rate_change.h"
#include "image.h"
-#include "raw_image_proxy.h"
-#include "ratio.h"
+#include "image_decoder.h"
+#include "job.h"
#include "log.h"
-#include "render_text.h"
-#include "config.h"
-#include "content_video.h"
+#include "piece_video.h"
+#include "player.h"
#include "player_video.h"
-#include "frame_rate_change.h"
-#include "audio_processor.h"
#include "playlist.h"
+#include "ratio.h"
+#include "raw_image_proxy.h"
#include "referenced_reel_asset.h"
-#include "decoder_factory.h"
-#include "decoder.h"
-#include "video_decoder.h"
-#include "audio_decoder.h"
+#include "render_text.h"
+#include "shuffler.h"
#include "text_content.h"
#include "text_decoder.h"
-#include "ffmpeg_content.h"
-#include "audio_content.h"
-#include "dcp_decoder.h"
-#include "image_decoder.h"
-#include "compose.hpp"
-#include "shuffler.h"
#include "timer.h"
+#include "video_decoder.h"
#include <dcp/reel.h>
#include <dcp/reel_sound_asset.h>
#include <dcp/reel_subtitle_asset.h>
using std::list;
using std::make_pair;
using std::make_shared;
+using std::make_shared;
using std::map;
using std::max;
using std::min;
using std::shared_ptr;
using std::vector;
using std::weak_ptr;
-using std::make_shared;
+using std::unique_ptr;
using boost::optional;
-using boost::scoped_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
int const PlayerProperty::PLAYBACK_LENGTH = 705;
+/** About 0.01dB */
+#define AUDIO_GAIN_EPSILON 0.001
+
+
Player::Player (shared_ptr<const Film> film)
: _film (film)
, _suspended (0)
}
-Player::~Player ()
-{
- delete _shuffler;
-}
-
-
void
Player::setup_pieces ()
{
}
+vector<vector<shared_ptr<Content>>>
+collect (shared_ptr<const Film> film, ContentList content)
+{
+ vector<shared_ptr<Content>> ungrouped;
+ vector<vector<shared_ptr<Content>>> grouped;
+
+ auto same_settings = [](shared_ptr<const Film> film, shared_ptr<const AudioContent> a, shared_ptr<const AudioContent> b) {
+
+ auto a_streams = a->streams();
+ auto b_streams = b->streams();
+
+ if (a_streams.size() != b_streams.size()) {
+ return false;
+ }
+
+ for (size_t i = 0; i < a_streams.size(); ++i) {
+ auto a_stream = a_streams[i];
+ auto b_stream = b_streams[i];
+ if (
+ !a_stream->mapping().equals(b_stream->mapping(), AUDIO_GAIN_EPSILON) ||
+ a_stream->frame_rate() != b_stream->frame_rate() ||
+ a_stream->channels() != b_stream->channels()) {
+ return false;
+ }
+ }
+
+ return (
+ fabs(a->gain() - b->gain()) < AUDIO_GAIN_EPSILON &&
+ a->delay() == b->delay() &&
+ a->language() == b->language() &&
+ a->resampled_frame_rate(film) == b->resampled_frame_rate(film) &&
+ a->channel_names() == b->channel_names()
+ );
+ };
+
+ for (auto i: content) {
+ if (i->video || !i->audio || !i->text.empty()) {
+ ungrouped.push_back (i);
+ } else {
+ bool done = false;
+ for (auto& g: grouped) {
+ if (same_settings(film, g.front()->audio, i->audio) && i->position() == g.back()->end(film)) {
+ g.push_back (i);
+ done = true;
+ }
+ }
+ if (!done) {
+ grouped.push_back ({i});
+ }
+ }
+ }
+
+ for (auto i: ungrouped) {
+ grouped.push_back({i});
+ }
+
+ return grouped;
+}
+
+
void
Player::setup_pieces_unlocked ()
{
auto old_pieces = _pieces;
_pieces.clear ();
- delete _shuffler;
- _shuffler = new Shuffler();
+ _shuffler.reset (new Shuffler());
_shuffler->Video.connect(bind(&Player::video, this, _1, _2));
for (auto i: playlist()->content()) {
shared_ptr<Decoder> old_decoder;
for (auto j: old_pieces) {
- if (j->content == i) {
- old_decoder = j->decoder;
+ auto decoder = j->decoder_for(i);
+ if (decoder) {
+ old_decoder = decoder;
break;
}
}
- auto decoder = decoder_factory (_film, i, _fast, _tolerant, old_decoder);
+ auto decoder = decoder_factory (_film, i, _tolerant, old_decoder);
DCPOMATIC_ASSERT (decoder);
FrameRateChange frc (_film, i);
}
}
- auto piece = make_shared<Piece>(i, decoder, frc);
+ vector<Piece::Pair> content = {
+ Piece::Pair(i, decoder)
+ };
+
+ auto piece = make_shared<Piece>(_film, content, frc, _fast);
_pieces.push_back (piece);
- if (decoder->video) {
+ if (i->video) {
if (i->video->frame_type() == VideoFrameType::THREE_D_LEFT || i->video->frame_type() == VideoFrameType::THREE_D_RIGHT) {
/* We need a Shuffler to cope with 3D L/R video data arriving out of sequence */
-
decoder->video->Data.connect (bind(&Shuffler::video, _shuffler, weak_ptr<Piece>(piece), _1));
+
piece->Video.connect (bind(&Shuffler::video, _shuffler.get(), weak_ptr<Piece>(piece), _1));
} else {
-
decoder->video->Data.connect (bind(&Player::video, this, weak_ptr<Piece>(piece), _1));
+
piece->Video.connect (bind(&Player::video, this, weak_ptr<Piece>(piece), _1));
}
}
- if (decoder->audio) {
- decoder->audio->Data.connect (bind (&Player::audio, this, weak_ptr<Piece> (piece), _1, _2));
- }
-
- auto j = decoder->text.begin();
-
- while (j != decoder->text.end()) {
- (*j)->BitmapStart.connect (
- bind(&Player::bitmap_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
- );
- (*j)->PlainStart.connect (
- bind(&Player::plain_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
- );
- (*j)->Stop.connect (
- bind(&Player::subtitle_stop, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
- );
-
- ++j;
+ if (i->audio) {
+ piece->Audio.connect (bind(&Player::audio, this, weak_ptr<Piece>(piece), _1));
}
- if (decoder->atmos) {
- decoder->atmos->Data.connect (bind(&Player::atmos, this, weak_ptr<Piece>(piece), _1));
- }
+ piece->BitmapTextStart.connect (bind(&Player::bitmap_text_start, this, piece, _1));
+ piece->StringTextStart.connect (bind(&Player::string_text_start, this, piece, _1));
+ piece->TextStop.connect (bind(&Player::subtitle_stop, this, piece, _1));
+ piece->Atmos.connect (bind(&Player::atmos, this, piece, _1));
}
for (auto i = _pieces.begin(); i != _pieces.end(); ++i) {
- if ((*i)->use_video() && (*i)->content->video->frame_type() != VideoFrameType::THREE_D_LEFT && (*i)->content->video->frame_type() != VideoFrameType::THREE_D_RIGHT) {
+ if ((*i)->use_video() && (*i)->video_frame_type() != VideoFrameType::THREE_D_LEFT && (*i)->video_frame_type() != VideoFrameType::THREE_D_RIGHT) {
/* Look for content later in the content list with in-use video that overlaps this */
- auto period = DCPTimePeriod((*i)->position(), (*i)->end(_film));
- auto j = i;
- ++j;
- for (; j != _pieces.end(); ++j) {
+ for (auto j = std::next(i); j != _pieces.end(); ++j) {
if ((*j)->use_video()) {
- (*i)->ignore_video = DCPTimePeriod((*j)->position(), (*j)->end(_film)).overlap(period);
+ (*i)->set_ignore_video ((*j)->period().overlap((*i)->period()));
}
}
}
}
+optional<DCPTime>
+Player::content_time_to_dcp (shared_ptr<Content> content, ContentTime t)
+{
+ boost::mutex::scoped_lock lm (_mutex);
+
+ for (auto i: _pieces) {
+ auto dcp = i->content_time_to_dcp(content, t);
+ if (dcp) {
+ return *dcp;
+ }
+ }
+
+ /* We couldn't find this content; perhaps things are being changed over */
+ return {};
+}
+
+
void
Player::playlist_content_change (ChangeType type, int property, bool frequent)
{
/* XXX: things may go wrong if there are duplicate font IDs
with different font files.
*/
- auto f = i->decoder->fonts ();
+ auto f = i->fonts ();
copy (f.begin(), f.end(), back_inserter(fonts));
}
continue;
}
- scoped_ptr<DCPDecoder> decoder;
+ unique_ptr<DCPDecoder> decoder;
try {
- decoder.reset (new DCPDecoder(_film, j, false, false, shared_ptr<DCPDecoder>()));
+ decoder.reset (new DCPDecoder(_film, j, false, shared_ptr<DCPDecoder>()));
} catch (...) {
return a;
}
optional<DCPTime> earliest_time;
for (auto i: _pieces) {
- if (i->done) {
- continue;
- }
-
- auto const t = i->content_time_to_dcp (max(i->decoder->position(), i->content->trim_start()));
- if (t > i->end(_film)) {
- i->done = true;
- } else {
-
- /* Given two choices at the same time, pick the one with texts so we see it before
- the video.
- */
- if (!earliest_time || t < *earliest_time || (t == *earliest_time && !i->decoder->text.empty())) {
- earliest_time = t;
- earliest_content = i;
- }
+ auto time = i->decoder_before(earliest_time);
+ if (time) {
+ earliest_time = *time;
+ earliest_content = i;
}
}
switch (which) {
case CONTENT:
{
- LOG_DEBUG_PLAYER ("Calling pass() on %1", earliest_content->content->path(0));
- earliest_content->done = earliest_content->decoder->pass ();
- auto dcp = dynamic_pointer_cast<DCPContent>(earliest_content->content);
- if (dcp && !_play_referenced && dcp->reference_audio()) {
+ earliest_content->pass();
+ if (!_play_referenced && earliest_content->reference_dcp_audio()) {
/* We are skipping some referenced DCP audio content, so we need to update _last_audio_time
to `hide' the fact that no audio was emitted during the referenced DCP (though
we need to behave as though it was).
*/
- _last_audio_time = dcp->end (_film);
+ _last_audio_time = earliest_content->end ();
}
break;
}
void
-Player::video (weak_ptr<Piece> wp, ContentVideo video)
+Player::video (weak_ptr<Piece> wp, PieceVideo video)
{
auto piece = wp.lock ();
if (!piece) {
return;
}
- if (!piece->use_video()) {
- return;
- }
-
- auto frc = piece->frame_rate_change();
- if (frc.skip && (video.frame % 2) == 1) {
- return;
- }
-
- /* Time of the first frame we will emit */
- DCPTime const time = piece->content_video_to_dcp (video.frame);
- LOG_DEBUG_PLAYER("Received video frame %1 at %2", video.frame, to_string(time));
+ LOG_DEBUG_PLAYER("Received video frame %1 at %2", video.frame, to_string(video.time));
/* Discard if it's before the content's period or the last accurate seek. We can't discard
if it's after the content's period here as in that case we still need to fill any gap between
`now' and the end of the content's period.
*/
- if (time < piece->position() || (_last_video_time && time < *_last_video_time)) {
- return;
- }
-
- if (piece->ignore_video && piece->ignore_video->contains(time)) {
+ if (video.time < piece->position() || (_last_video_time && video.time < *_last_video_time)) {
return;
}
/* Fill gaps that we discover now that we have some video which needs to be emitted.
This is where we need to fill to.
*/
- DCPTime fill_to = min (time, piece->end(_film));
+ DCPTime fill_to = min (video.time, piece->end());
if (_last_video_time) {
DCPTime fill_from = max (*_last_video_time, piece->position());
if (fill_to_eyes == Eyes::BOTH) {
fill_to_eyes = Eyes::LEFT;
}
- if (fill_to == piece->end(_film)) {
+ if (fill_to == piece->end()) {
/* Don't fill after the end of the content */
fill_to_eyes = Eyes::LEFT;
}
}
}
- _last_video[wp] = piece->player_video (video, _film, _video_container_size);
+ _last_video[wp] = piece->player_video (video, _video_container_size);
- DCPTime t = time;
+ DCPTime t = video.time;
+ auto const frc = piece->frame_rate_change();
for (int i = 0; i < frc.repeat; ++i) {
- if (t < piece->end(_film)) {
+ if (t < piece->end()) {
emit_video (_last_video[wp], t);
}
t += one_video_frame ();
void
-Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
+Player::audio (weak_ptr<Piece> wp, PieceAudio audio)
{
- DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
+ DCPOMATIC_ASSERT (audio.audio->frames() > 0);
auto piece = wp.lock ();
if (!piece) {
return;
}
- auto content = piece->content->audio;
- DCPOMATIC_ASSERT (content);
-
- int const rfr = content->resampled_frame_rate (_film);
+ LOG_DEBUG_PLAYER("Received audio at %1", to_string(audio.time));
- /* Compute time in the DCP */
- auto time = piece->resampled_audio_to_dcp (content_audio.frame, _film);
- LOG_DEBUG_PLAYER("Received audio frame %1 at %2", content_audio.frame, to_string(time));
+ /* The end of this block in the DCP */
+ int const rfr = piece->resampled_audio_frame_rate ();
+ auto end = audio.time + DCPTime::from_frames(audio.audio->frames(), rfr);
- /* And the end of this block in the DCP */
- auto end = time + DCPTime::from_frames(content_audio.audio->frames(), rfr);
+ /* XXX: is this still necessary? don't the checks in Piece take care of this now?
+ * Maybe replace with some assertions & run tests.
+ */
/* Remove anything that comes before the start or after the end of the content */
- if (time < piece->position()) {
- auto cut = discard_audio (content_audio.audio, time, piece->position());
+ if (audio.time < piece->position()) {
+ auto cut = discard_audio (audio.audio, audio.time, piece->position());
if (!cut.first) {
/* This audio is entirely discarded */
return;
}
- content_audio.audio = cut.first;
- time = cut.second;
- } else if (time > piece->end(_film)) {
+ audio.audio = cut.first;
+ audio.time = cut.second;
+ } else if (audio.time > piece->end()) {
/* Discard it all */
return;
- } else if (end > piece->end(_film)) {
- Frame const remaining_frames = DCPTime(piece->end(_film) - time).frames_round(rfr);
+ } else if (end > piece->end()) {
+ Frame const remaining_frames = DCPTime(piece->end() - audio.time).frames_round(rfr);
if (remaining_frames == 0) {
return;
}
- content_audio.audio = make_shared<AudioBuffers>(content_audio.audio, remaining_frames, 0);
+ audio.audio = make_shared<AudioBuffers>(audio.audio, remaining_frames, 0);
}
- DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
+ DCPOMATIC_ASSERT (audio.audio->frames() > 0);
/* Gain */
- if (content->gain() != 0) {
- auto gain = make_shared<AudioBuffers>(content_audio.audio);
- gain->apply_gain (content->gain());
- content_audio.audio = gain;
+ if (piece->audio_gain() != 0) {
+ auto gain = make_shared<AudioBuffers>(audio.audio);
+ gain->apply_gain (piece->audio_gain());
+ audio.audio = gain;
}
/* Remap */
- content_audio.audio = remap (content_audio.audio, _film->audio_channels(), stream->mapping());
+ audio.audio = remap (audio.audio, _film->audio_channels(), audio.mapping);
/* Process */
if (_audio_processor) {
- content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ());
+ audio.audio = _audio_processor->run (audio.audio, _film->audio_channels());
}
/* Push */
- _audio_merger.push (content_audio.audio, time);
- piece->set_last_push_end (stream, time + DCPTime::from_frames(content_audio.audio->frames(), _film->audio_frame_rate()));
+ _audio_merger.push (audio.audio, audio.time);
+ piece->set_last_push_end (audio.stream, audio.time + DCPTime::from_frames(audio.audio->frames(), _film->audio_frame_rate()));
}
void
-Player::bitmap_text_start (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, ContentBitmapText subtitle)
+Player::bitmap_text_start (weak_ptr<Piece> wp, PieceBitmapTextStart subtitle)
{
auto piece = wp.lock ();
- auto text = wc.lock ();
- if (!piece || !text) {
+ auto content = subtitle.content().lock();
+ auto text = subtitle.text().lock();
+ if (!piece || !content || !text) {
return;
}
dcp::Size scaled_size (width, height);
ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUVToRGB::REC601, image->pixel_format(), true, _fast), subtitle.sub.rectangle));
- DCPTime from (piece->content_time_to_dcp(subtitle.from()));
+ auto from = piece->content_time_to_dcp(content, subtitle.time());
+ DCPOMATIC_ASSERT (from);
- _active_texts[static_cast<int>(text->type())].add_from (wc, ps, from);
+ _active_texts[static_cast<int>(text->type())].add_from(text, ps, *from);
}
void
-Player::plain_text_start (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, ContentStringText subtitle)
+Player::string_text_start (weak_ptr<Piece> wp, PieceStringTextStart subtitle)
{
auto piece = wp.lock ();
- auto text = wc.lock ();
- if (!piece || !text) {
+ auto content = subtitle.content().lock();
+ auto text = subtitle.text().lock();
+ if (!piece || !content || !text) {
return;
}
PlayerText ps;
- DCPTime const from (piece->content_time_to_dcp(subtitle.from()));
+ auto const from = piece->content_time_to_dcp(content, subtitle.time());
+ DCPOMATIC_ASSERT (from);
- if (from > piece->end(_film)) {
+ if (from > piece->end()) {
return;
}
for (auto s: subtitle.subs) {
- s.set_h_position (s.h_position() + text->x_offset ());
- s.set_v_position (s.v_position() + text->y_offset ());
+ s.set_h_position (s.h_position() + text->x_offset());
+ s.set_v_position (s.v_position() + text->y_offset());
float const xs = text->x_scale();
float const ys = text->y_scale();
float size = s.size();
s.set_aspect_adjust (xs / ys);
}
- s.set_in (dcp::Time(from.seconds(), 1000));
+ s.set_in (dcp::Time(from->seconds(), 1000));
ps.string.push_back (StringText (s, text->outline_width()));
ps.add_fonts (text->fonts ());
}
- _active_texts[static_cast<int>(text->type())].add_from (wc, ps, from);
+ _active_texts[static_cast<int>(text->type())].add_from(text, ps, *from);
}
void
-Player::subtitle_stop (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, ContentTime to)
+Player::subtitle_stop (weak_ptr<Piece> wp, PieceTextStop stop)
{
- auto text = wc.lock ();
+ auto content = stop.content().lock();
+ auto text = stop.text().lock();
if (!text) {
return;
}
- if (!_active_texts[static_cast<int>(text->type())].have(wc)) {
+ if (!_active_texts[static_cast<int>(text->type())].have(stop.text())) {
return;
}
return;
}
- auto const dcp_to = piece->content_time_to_dcp(to);
+ auto const dcp_to = piece->content_time_to_dcp(content, stop.time());
+ DCPOMATIC_ASSERT (dcp_to);
- if (dcp_to > piece->end(_film)) {
+ if (*dcp_to > piece->end()) {
return;
}
- auto from = _active_texts[static_cast<int>(text->type())].add_to (wc, dcp_to);
+ auto from = _active_texts[static_cast<int>(text->type())].add_to(stop.text(), *dcp_to);
bool const always = (text->type() == TextType::OPEN_SUBTITLE && _always_burn_open_subtitles);
if (text->use() && !always && !text->burn()) {
- Text (from.first, text->type(), text->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod (from.second, dcp_to));
+ Text (from.first, text->type(), text->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod (from.second, *dcp_to));
}
}
}
for (auto i: _pieces) {
- if (time < i->position()) {
- /* Before; seek to the start of the content. Even if this request is for an inaccurate seek
- we must seek this (following) content accurately, otherwise when we come to the end of the current
- content we may not start right at the beginning of the next, causing a gap (if the next content has
- been trimmed to a point between keyframes, or something).
- */
- i->decoder->seek (i->dcp_to_content_time(i->position(), _film), true);
- i->done = false;
- } else if (i->position() <= time && time < i->end(_film)) {
- /* During; seek to position */
- i->decoder->seek (i->dcp_to_content_time(time, _film), accurate);
- i->done = false;
- } else {
- /* After; this piece is done */
- i->done = true;
- }
+ i->seek (time, accurate);
}
if (accurate) {
}
-optional<DCPTime>
-Player::content_time_to_dcp (shared_ptr<Content> content, ContentTime t)
-{
- boost::mutex::scoped_lock lm (_mutex);
-
- for (auto i: _pieces) {
- if (i->content == content) {
- return i->content_time_to_dcp(t);
- }
- }
-
- /* We couldn't find this content; perhaps things are being changed over */
- return {};
-}
-
-
shared_ptr<const Playlist>
Player::playlist () const
{
void
-Player::atmos (weak_ptr<Piece>, ContentAtmos data)
+Player::atmos (weak_ptr<Piece>, PieceAtmos data)
{
Atmos (data.data, DCPTime::from_frames(data.frame, _film->video_frame_rate()), data.metadata);
}
projects / dcpomatic.git / blobdiff