src/lib/player.cc

   1 /*
   2     Copyright (C) 2013-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 #include "atmos_decoder.h"
  23 #include "audio_buffers.h"
  24 #include "audio_content.h"
  25 #include "audio_decoder.h"
  26 #include "audio_processor.h"
  27 #include "compose.hpp"
  28 #include "config.h"
  29 #include "content_audio.h"
  30 #include "content_video.h"
  31 #include "dcp_content.h"
  32 #include "dcp_decoder.h"
  33 #include "dcpomatic_log.h"
  34 #include "decoder.h"
  35 #include "decoder_factory.h"
  36 #include "ffmpeg_content.h"
  37 #include "film.h"
  38 #include "frame_rate_change.h"
  39 #include "image.h"
  40 #include "image_decoder.h"
  41 #include "job.h"
  42 #include "log.h"
  43 #include "maths_util.h"
  44 #include "piece.h"
  45 #include "player.h"
  46 #include "player_video.h"
  47 #include "playlist.h"
  48 #include "ratio.h"
  49 #include "raw_image_proxy.h"
  50 #include "render_text.h"
  51 #include "shuffler.h"
  52 #include "text_content.h"
  53 #include "text_decoder.h"
  54 #include "timer.h"
  55 #include "video_decoder.h"
  56 #include <dcp/reel.h>
  57 #include <dcp/reel_closed_caption_asset.h>
  58 #include <dcp/reel_picture_asset.h>
  59 #include <dcp/reel_sound_asset.h>
  60 #include <dcp/reel_subtitle_asset.h>
  61 #include <algorithm>
  62 #include <iostream>
  63 #include <stdint.h>
  64
  65 #include "i18n.h"
  66
  67
  68 using std::copy;
  69 using std::cout;
  70 using std::dynamic_pointer_cast;
  71 using std::list;
  72 using std::make_pair;
  73 using std::make_shared;
  74 using std::max;
  75 using std::min;
  76 using std::pair;
  77 using std::shared_ptr;
  78 using std::vector;
  79 using std::weak_ptr;
  80 using boost::optional;
  81 using boost::scoped_ptr;
  82 #if BOOST_VERSION >= 106100
  83 using namespace boost::placeholders;
  84 #endif
  85 using namespace dcpomatic;
  86
  87
  88 int const PlayerProperty::VIDEO_CONTAINER_SIZE = 700;
  89 int const PlayerProperty::PLAYLIST = 701;
  90 int const PlayerProperty::FILM_CONTAINER = 702;
  91 int const PlayerProperty::FILM_VIDEO_FRAME_RATE = 703;
  92 int const PlayerProperty::DCP_DECODE_REDUCTION = 704;
  93 int const PlayerProperty::PLAYBACK_LENGTH = 705;
  94 int const PlayerProperty::IGNORE_VIDEO = 706;
  95 int const PlayerProperty::IGNORE_AUDIO = 707;
  96 int const PlayerProperty::IGNORE_TEXT = 708;
  97 int const PlayerProperty::ALWAYS_BURN_OPEN_SUBTITLES = 709;
  98 int const PlayerProperty::PLAY_REFERENCED = 710;
  99
 100
 101 Player::Player (shared_ptr<const Film> film, Image::Alignment subtitle_alignment)
 102         : _film (film)
 103         , _suspended (0)
 104         , _ignore_video(false)
 105         , _ignore_audio(false)
 106         , _ignore_text(false)
 107         , _always_burn_open_subtitles(false)
 108         , _fast(false)
 109         , _tolerant (film->tolerant())
 110         , _play_referenced(false)
 111         , _audio_merger(film->audio_frame_rate())
 112         , _subtitle_alignment (subtitle_alignment)
 113 {
 114         construct ();
 115 }
 116
 117
 118 Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist_)
 119         : _film (film)
 120         , _playlist (playlist_)
 121         , _suspended (0)
 122         , _ignore_video(false)
 123         , _ignore_audio(false)
 124         , _ignore_text(false)
 125         , _always_burn_open_subtitles(false)
 126         , _fast(false)
 127         , _tolerant (film->tolerant())
 128         , _play_referenced(false)
 129         , _audio_merger(film->audio_frame_rate())
 130 {
 131         construct ();
 132 }
 133
 134
 135 void
 136 Player::construct ()
 137 {
 138         auto film = _film.lock();
 139         DCPOMATIC_ASSERT(film);
 140
 141         connect();
 142         set_video_container_size(film->frame_size());
 143
 144         film_change (ChangeType::DONE, Film::Property::AUDIO_PROCESSOR);
 145
 146         setup_pieces ();
 147         seek (DCPTime (), true);
 148 }
 149
 150
 151 void
 152 Player::connect()
 153 {
 154         auto film = _film.lock();
 155         DCPOMATIC_ASSERT(film);
 156
 157         _film_changed_connection = film->Change.connect(bind(&Player::film_change, this, _1, _2));
 158         /* The butler must hear about this first, so since we are proxying this through to the butler we must
 159            be first.
 160         */
 161         _playlist_change_connection = playlist()->Change.connect (bind (&Player::playlist_change, this, _1), boost::signals2::at_front);
 162         _playlist_content_change_connection = playlist()->ContentChange.connect (bind(&Player::playlist_content_change, this, _1, _3, _4));
 163 }
 164
 165
 166 Player::Player(Player&& other)
 167         : _film(other._film)
 168         , _playlist(std::move(other._playlist))
 169         , _suspended(other._suspended.load())
 170         , _pieces(std::move(other._pieces))
 171         , _video_container_size(other._video_container_size.load())
 172         , _black_image(std::move(other._black_image))
 173         , _ignore_video(other._ignore_video.load())
 174         , _ignore_audio(other._ignore_audio.load())
 175         , _ignore_text(other._ignore_text.load())
 176         , _always_burn_open_subtitles(other._always_burn_open_subtitles.load())
 177         , _fast(other._fast.load())
 178         , _tolerant(other._tolerant)
 179         , _play_referenced(other._play_referenced.load())
 180         , _next_video_time(other._next_video_time)
 181         , _next_audio_time(other._next_audio_time)
 182         , _dcp_decode_reduction(other._dcp_decode_reduction.load())
 183         , _last_video(std::move(other._last_video))
 184         , _audio_merger(std::move(other._audio_merger))
 185         , _shuffler(std::move(other._shuffler))
 186         , _delay(std::move(other._delay))
 187         , _stream_states(std::move(other._stream_states))
 188         , _black(std::move(other._black))
 189         , _silent(std::move(other._silent))
 190         , _active_texts(std::move(other._active_texts))
 191         , _audio_processor(std::move(other._audio_processor))
 192         , _playback_length(other._playback_length.load())
 193         , _subtitle_alignment(other._subtitle_alignment)
 194 {
 195         connect();
 196 }
 197
 198
 199 Player&
 200 Player::operator=(Player&& other)
 201 {
 202         if (this == &other) {
 203                 return *this;
 204         }
 205
 206         _film = std::move(other._film);
 207         _playlist = std::move(other._playlist);
 208         _suspended = other._suspended.load();
 209         _pieces = std::move(other._pieces);
 210         _video_container_size = other._video_container_size.load();
 211         _black_image = std::move(other._black_image);
 212         _ignore_video = other._ignore_video.load();
 213         _ignore_audio = other._ignore_audio.load();
 214         _ignore_text = other._ignore_text.load();
 215         _always_burn_open_subtitles = other._always_burn_open_subtitles.load();
 216         _fast = other._fast.load();
 217         _tolerant = other._tolerant;
 218         _play_referenced = other._play_referenced.load();
 219         _next_video_time = other._next_video_time;
 220         _next_audio_time = other._next_audio_time;
 221         _dcp_decode_reduction = other._dcp_decode_reduction.load();
 222         _last_video = std::move(other._last_video);
 223         _audio_merger = std::move(other._audio_merger);
 224         _shuffler = std::move(other._shuffler);
 225         _delay = std::move(other._delay);
 226         _stream_states = std::move(other._stream_states);
 227         _black = std::move(other._black);
 228         _silent = std::move(other._silent);
 229         _active_texts = std::move(other._active_texts);
 230         _audio_processor = std::move(other._audio_processor);
 231         _playback_length = other._playback_length.load();
 232         _subtitle_alignment = other._subtitle_alignment;
 233
 234         connect();
 235
 236         return *this;
 237 }
 238
 239
 240 bool
 241 have_video (shared_ptr<const Content> content)
 242 {
 243         return static_cast<bool>(content->video) && content->video->use() && content->can_be_played();
 244 }
 245
 246
 247 bool
 248 have_audio (shared_ptr<const Content> content)
 249 {
 250         return static_cast<bool>(content->audio) && content->can_be_played();
 251 }
 252
 253
 254 void
 255 Player::setup_pieces ()
 256 {
 257         boost::mutex::scoped_lock lm (_mutex);
 258
 259         auto old_pieces = _pieces;
 260         _pieces.clear ();
 261
 262         auto film = _film.lock();
 263         if (!film) {
 264                 return;
 265         }
 266
 267         _playback_length = _playlist ? _playlist->length(film) : film->length();
 268
 269         auto playlist_content = playlist()->content();
 270         bool const have_threed = std::any_of(
 271                 playlist_content.begin(),
 272                 playlist_content.end(),
 273                 [](shared_ptr<const Content> c) {
 274                         return c->video && (c->video->frame_type() == VideoFrameType::THREE_D_LEFT || c->video->frame_type() == VideoFrameType::THREE_D_RIGHT);
 275                 });
 276
 277
 278         if (have_threed) {
 279                 _shuffler.reset(new Shuffler());
 280                 _shuffler->Video.connect(bind(&Player::video, this, _1, _2));
 281         }
 282
 283         for (auto content: playlist()->content()) {
 284
 285                 if (!content->paths_valid()) {
 286                         continue;
 287                 }
 288
 289                 if (_ignore_video && _ignore_audio && content->text.empty()) {
 290                         /* We're only interested in text and this content has none */
 291                         continue;
 292                 }
 293
 294                 shared_ptr<Decoder> old_decoder;
 295                 for (auto j: old_pieces) {
 296                         if (j->content == content) {
 297                                 old_decoder = j->decoder;
 298                                 break;
 299                         }
 300                 }
 301
 302                 auto decoder = decoder_factory(film, content, _fast, _tolerant, old_decoder);
 303                 DCPOMATIC_ASSERT (decoder);
 304
 305                 FrameRateChange frc(film, content);
 306
 307                 if (decoder->video && _ignore_video) {
 308                         decoder->video->set_ignore (true);
 309                 }
 310
 311                 if (decoder->audio && _ignore_audio) {
 312                         decoder->audio->set_ignore (true);
 313                 }
 314
 315                 if (_ignore_text) {
 316                         for (auto i: decoder->text) {
 317                                 i->set_ignore (true);
 318                         }
 319                 }
 320
 321                 auto dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
 322                 if (dcp) {
 323                         dcp->set_decode_referenced (_play_referenced);
 324                         if (_play_referenced) {
 325                                 dcp->set_forced_reduction (_dcp_decode_reduction);
 326                         }
 327                 }
 328
 329                 auto piece = make_shared<Piece>(content, decoder, frc);
 330                 _pieces.push_back (piece);
 331
 332                 if (decoder->video) {
 333                         if (have_threed) {
 334                                 /* We need a Shuffler to cope with 3D L/R video data arriving out of sequence */
 335                                 decoder->video->Data.connect (bind(&Shuffler::video, _shuffler.get(), weak_ptr<Piece>(piece), _1));
 336                         } else {
 337                                 decoder->video->Data.connect (bind(&Player::video, this, weak_ptr<Piece>(piece), _1));
 338                         }
 339                 }
 340
 341                 if (decoder->audio) {
 342                         decoder->audio->Data.connect (bind (&Player::audio, this, weak_ptr<Piece> (piece), _1, _2));
 343                 }
 344
 345                 auto j = decoder->text.begin();
 346
 347                 while (j != decoder->text.end()) {
 348                         (*j)->BitmapStart.connect (
 349                                 bind(&Player::bitmap_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
 350                                 );
 351                         (*j)->PlainStart.connect (
 352                                 bind(&Player::plain_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
 353                                 );
 354                         (*j)->Stop.connect (
 355                                 bind(&Player::subtitle_stop, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
 356                                 );
 357
 358                         ++j;
 359                 }
 360
 361                 if (decoder->atmos) {
 362                         decoder->atmos->Data.connect (bind(&Player::atmos, this, weak_ptr<Piece>(piece), _1));
 363                 }
 364         }
 365
 366         _stream_states.clear ();
 367         for (auto i: _pieces) {
 368                 if (i->content->audio) {
 369                         for (auto j: i->content->audio->streams()) {
 370                                 _stream_states[j] = StreamState(i);
 371                         }
 372                 }
 373         }
 374
 375         auto ignore_overlap = [](shared_ptr<VideoContent> v) {
 376                 return v && v->use() && v->frame_type() != VideoFrameType::THREE_D_LEFT && v->frame_type() != VideoFrameType::THREE_D_RIGHT;
 377         };
 378
 379         for (auto i = _pieces.begin(); i != _pieces.end(); ++i) {
 380                 if (ignore_overlap((*i)->content->video)) {
 381                         /* Look for content later in the content list with in-use video that overlaps this */
 382                         auto const period = DCPTimePeriod((*i)->content->position(), (*i)->content->end(film));
 383                         for (auto j = std::next(i); j != _pieces.end(); ++j) {
 384                                 if ((*j)->content->video && ignore_overlap((*j)->content->video)) {
 385                                         (*i)->ignore_video = DCPTimePeriod((*j)->content->position(), (*j)->content->end(film)).overlap(period);
 386                                 }
 387                         }
 388                 }
 389         }
 390
 391         _black = Empty(film, playlist(), bind(&have_video, _1), _playback_length);
 392         _silent = Empty(film, playlist(), bind(&have_audio, _1), _playback_length);
 393
 394         _next_video_time = boost::none;
 395         _next_audio_time = boost::none;
 396 }
 397
 398
 399 void
 400 Player::playlist_content_change (ChangeType type, int property, bool frequent)
 401 {
 402         auto film = _film.lock();
 403         if (!film) {
 404                 return;
 405         }
 406
 407         if (property == VideoContentProperty::CROP) {
 408                 if (type == ChangeType::DONE) {
 409                         boost::mutex::scoped_lock lm (_mutex);
 410                         for (auto const& i: _delay) {
 411                                 i.first->reset_metadata(film, _video_container_size);
 412                         }
 413                 }
 414         } else {
 415                 if (type == ChangeType::PENDING) {
 416                         /* The player content is probably about to change, so we can't carry on
 417                            until that has happened and we've rebuilt our pieces.  Stop pass()
 418                            and seek() from working until then.
 419                         */
 420                         ++_suspended;
 421                 } else if (type == ChangeType::DONE) {
 422                         /* A change in our content has gone through.  Re-build our pieces. */
 423                         setup_pieces ();
 424                         --_suspended;
 425                 } else if (type == ChangeType::CANCELLED) {
 426                         --_suspended;
 427                 }
 428         }
 429
 430         Change (type, property, frequent);
 431 }
 432
 433
 434 void
 435 Player::set_video_container_size (dcp::Size s)
 436 {
 437         ChangeSignaller<Player, int> cc(this, PlayerProperty::VIDEO_CONTAINER_SIZE);
 438
 439         if (s == _video_container_size) {
 440                 cc.abort();
 441                 return;
 442         }
 443
 444         _video_container_size = s;
 445
 446         {
 447                 boost::mutex::scoped_lock lm(_black_image_mutex);
 448                 _black_image = make_shared<Image>(AV_PIX_FMT_RGB24, _video_container_size, Image::Alignment::PADDED);
 449                 _black_image->make_black ();
 450         }
 451 }
 452
 453
 454 void
 455 Player::playlist_change (ChangeType type)
 456 {
 457         if (type == ChangeType::DONE) {
 458                 setup_pieces ();
 459         }
 460         Change (type, PlayerProperty::PLAYLIST, false);
 461 }
 462
 463
 464 void
 465 Player::film_change (ChangeType type, Film::Property p)
 466 {
 467         /* Here we should notice Film properties that affect our output, and
 468            alert listeners that our output now would be different to how it was
 469            last time we were run.
 470         */
 471
 472         auto film = _film.lock();
 473         if (!film) {
 474                 return;
 475         }
 476
 477         if (p == Film::Property::CONTAINER) {
 478                 Change (type, PlayerProperty::FILM_CONTAINER, false);
 479         } else if (p == Film::Property::VIDEO_FRAME_RATE) {
 480                 /* Pieces contain a FrameRateChange which contains the DCP frame rate,
 481                    so we need new pieces here.
 482                 */
 483                 if (type == ChangeType::DONE) {
 484                         setup_pieces ();
 485                 }
 486                 Change (type, PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
 487         } else if (p == Film::Property::AUDIO_PROCESSOR) {
 488                 if (type == ChangeType::DONE && film->audio_processor ()) {
 489                         boost::mutex::scoped_lock lm (_mutex);
 490                         _audio_processor = film->audio_processor()->clone(film->audio_frame_rate());
 491                 }
 492         } else if (p == Film::Property::AUDIO_CHANNELS) {
 493                 if (type == ChangeType::DONE) {
 494                         boost::mutex::scoped_lock lm (_mutex);
 495                         _audio_merger.clear ();
 496                 }
 497         }
 498 }
 499
 500
 501 shared_ptr<PlayerVideo>
 502 Player::black_player_video_frame (Eyes eyes) const
 503 {
 504         boost::mutex::scoped_lock lm(_black_image_mutex);
 505
 506         return std::make_shared<PlayerVideo> (
 507                 make_shared<const RawImageProxy>(_black_image),
 508                 Crop(),
 509                 optional<double>(),
 510                 _video_container_size,
 511                 _video_container_size,
 512                 eyes,
 513                 Part::WHOLE,
 514                 PresetColourConversion::all().front().conversion,
 515                 VideoRange::FULL,
 516                 std::weak_ptr<Content>(),
 517                 boost::optional<dcpomatic::ContentTime>(),
 518                 false
 519         );
 520 }
 521
 522
 523 Frame
 524 Player::dcp_to_content_video (shared_ptr<const Piece> piece, DCPTime t) const
 525 {
 526         auto film = _film.lock();
 527         DCPOMATIC_ASSERT(film);
 528
 529         auto s = t - piece->content->position ();
 530         s = min (piece->content->length_after_trim(film), s);
 531         s = max (DCPTime(), s + DCPTime (piece->content->trim_start(), piece->frc));
 532
 533         /* It might seem more logical here to convert s to a ContentTime (using the FrameRateChange)
 534            then convert that ContentTime to frames at the content's rate.  However this fails for
 535            situations like content at 29.9978733fps, DCP at 30fps.  The accuracy of the Time type is not
 536            enough to distinguish between the two with low values of time (e.g. 3200 in Time units).
 537
 538            Instead we convert the DCPTime using the DCP video rate then account for any skip/repeat.
 539         */
 540         return s.frames_floor (piece->frc.dcp) / piece->frc.factor ();
 541 }
 542
 543
 544 DCPTime
 545 Player::content_video_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 546 {
 547         /* See comment in dcp_to_content_video */
 548         auto const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime(piece->content->trim_start(), piece->frc);
 549         return d + piece->content->position();
 550 }
 551
 552
 553 Frame
 554 Player::dcp_to_resampled_audio (shared_ptr<const Piece> piece, DCPTime t) const
 555 {
 556         auto film = _film.lock();
 557         DCPOMATIC_ASSERT(film);
 558
 559         auto s = t - piece->content->position ();
 560         s = min (piece->content->length_after_trim(film), s);
 561         /* See notes in dcp_to_content_video */
 562         return max (DCPTime(), DCPTime(piece->content->trim_start(), piece->frc) + s).frames_floor(film->audio_frame_rate());
 563 }
 564
 565
 566 DCPTime
 567 Player::resampled_audio_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 568 {
 569         auto film = _film.lock();
 570         DCPOMATIC_ASSERT(film);
 571
 572         /* See comment in dcp_to_content_video */
 573         return DCPTime::from_frames(f, film->audio_frame_rate())
 574                 - DCPTime (piece->content->trim_start(), piece->frc)
 575                 + piece->content->position();
 576 }
 577
 578
 579 ContentTime
 580 Player::dcp_to_content_time (shared_ptr<const Piece> piece, DCPTime t) const
 581 {
 582         auto film = _film.lock();
 583         DCPOMATIC_ASSERT(film);
 584
 585         auto s = t - piece->content->position ();
 586         s = min (piece->content->length_after_trim(film), s);
 587         return max (ContentTime (), ContentTime (s, piece->frc) + piece->content->trim_start());
 588 }
 589
 590
 591 DCPTime
 592 Player::content_time_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
 593 {
 594         return max (DCPTime(), DCPTime(t - piece->content->trim_start(), piece->frc) + piece->content->position());
 595 }
 596
 597
 598 vector<shared_ptr<Font>>
 599 Player::get_subtitle_fonts ()
 600 {
 601         boost::mutex::scoped_lock lm (_mutex);
 602
 603         vector<shared_ptr<Font>> fonts;
 604         for (auto piece: _pieces) {
 605                 for (auto text: piece->content->text) {
 606                         auto text_fonts = text->fonts();
 607                         copy (text_fonts.begin(), text_fonts.end(), back_inserter(fonts));
 608                 }
 609         }
 610
 611         return fonts;
 612 }
 613
 614
 615 /** Set this player never to produce any video data */
 616 void
 617 Player::set_ignore_video ()
 618 {
 619         ChangeSignaller<Player, int> cc(this, PlayerProperty::IGNORE_VIDEO);
 620         _ignore_video = true;
 621         setup_pieces();
 622 }
 623
 624
 625 void
 626 Player::set_ignore_audio ()
 627 {
 628         ChangeSignaller<Player, int> cc(this, PlayerProperty::IGNORE_AUDIO);
 629         _ignore_audio = true;
 630         setup_pieces();
 631 }
 632
 633
 634 void
 635 Player::set_ignore_text ()
 636 {
 637         ChangeSignaller<Player, int> cc(this, PlayerProperty::IGNORE_TEXT);
 638         _ignore_text = true;
 639         setup_pieces();
 640 }
 641
 642
 643 /** Set the player to always burn open texts into the image regardless of the content settings */
 644 void
 645 Player::set_always_burn_open_subtitles ()
 646 {
 647         ChangeSignaller<Player, int> cc(this, PlayerProperty::ALWAYS_BURN_OPEN_SUBTITLES);
 648         _always_burn_open_subtitles = true;
 649 }
 650
 651
 652 /** Sets up the player to be faster, possibly at the expense of quality */
 653 void
 654 Player::set_fast ()
 655 {
 656         _fast = true;
 657         setup_pieces();
 658 }
 659
 660
 661 void
 662 Player::set_play_referenced ()
 663 {
 664         ChangeSignaller<Player, int> cc(this, PlayerProperty::PLAY_REFERENCED);
 665         _play_referenced = true;
 666         setup_pieces();
 667 }
 668
 669
 670 bool
 671 Player::pass ()
 672 {
 673         boost::mutex::scoped_lock lm (_mutex);
 674
 675         if (_suspended) {
 676                 /* We can't pass in this state */
 677                 LOG_DEBUG_PLAYER_NC ("Player is suspended");
 678                 return false;
 679         }
 680
 681         auto film = _film.lock();
 682
 683         if (_playback_length.load() == DCPTime() || !film) {
 684                 /* Special; just give one black frame */
 685                 use_video(black_player_video_frame(Eyes::BOTH), DCPTime(), one_video_frame());
 686                 return true;
 687         }
 688
 689         /* Find the decoder or empty which is farthest behind where we are and make it emit some data */
 690
 691         shared_ptr<Piece> earliest_content;
 692         optional<DCPTime> earliest_time;
 693
 694         for (auto i: _pieces) {
 695                 if (i->done) {
 696                         continue;
 697                 }
 698
 699                 auto const t = content_time_to_dcp (i, max(i->decoder->position(), i->content->trim_start()));
 700                 if (t > i->content->end(film)) {
 701                         i->done = true;
 702                 } else {
 703
 704                         /* Given two choices at the same time, pick the one with texts so we see it before
 705                            the video.
 706                         */
 707                         if (!earliest_time || t < *earliest_time || (t == *earliest_time && !i->decoder->text.empty())) {
 708                                 earliest_time = t;
 709                                 earliest_content = i;
 710                         }
 711                 }
 712         }
 713
 714         bool done = false;
 715
 716         enum {
 717                 NONE,
 718                 CONTENT,
 719                 BLACK,
 720                 SILENT
 721         } which = NONE;
 722
 723         if (earliest_content) {
 724                 which = CONTENT;
 725         }
 726
 727         if (!_black.done() && !_ignore_video && (!earliest_time || _black.position() < *earliest_time)) {
 728                 earliest_time = _black.position ();
 729                 which = BLACK;
 730         }
 731
 732         if (!_silent.done() && !_ignore_audio && (!earliest_time || _silent.position() < *earliest_time)) {
 733                 earliest_time = _silent.position ();
 734                 which = SILENT;
 735         }
 736
 737         switch (which) {
 738         case CONTENT:
 739         {
 740                 LOG_DEBUG_PLAYER ("Calling pass() on %1", earliest_content->content->path(0));
 741                 earliest_content->done = earliest_content->decoder->pass ();
 742                 auto dcp = dynamic_pointer_cast<DCPContent>(earliest_content->content);
 743                 if (dcp && !_play_referenced) {
 744                         if (dcp->reference_video()) {
 745                                 _next_video_time = dcp->end(film);
 746                         }
 747                         if (dcp->reference_audio()) {
 748                                 /* We are skipping some referenced DCP audio content, so we need to update _next_audio_time
 749                                    to `hide' the fact that no audio was emitted during the referenced DCP (though
 750                                    we need to behave as though it was).
 751                                 */
 752                                 _next_audio_time = dcp->end(film);
 753                         }
 754                 }
 755                 break;
 756         }
 757         case BLACK:
 758                 LOG_DEBUG_PLAYER ("Emit black for gap at %1", to_string(_black.position()));
 759                 use_video(black_player_video_frame(Eyes::BOTH), _black.position(), _black.period_at_position().to);
 760                 _black.set_position (_black.position() + one_video_frame());
 761                 break;
 762         case SILENT:
 763         {
 764                 LOG_DEBUG_PLAYER ("Emit silence for gap at %1", to_string(_silent.position()));
 765                 DCPTimePeriod period (_silent.period_at_position());
 766                 if (_next_audio_time) {
 767                         /* Sometimes the thing that happened last finishes fractionally before
 768                            or after this silence.  Bodge the start time of the silence to fix it.
 769                            I think this is nothing to worry about since we will just add or
 770                            remove a little silence at the end of some content.
 771                         */
 772                         int64_t const error = labs(period.from.get() - _next_audio_time->get());
 773                         /* Let's not worry about less than a frame at 24fps */
 774                         int64_t const too_much_error = DCPTime::from_frames(1, 24).get();
 775                         if (error >= too_much_error) {
 776                                 film->log()->log(String::compose("Silence starting before or after last audio by %1", error), LogEntry::TYPE_ERROR);
 777                         }
 778                         DCPOMATIC_ASSERT (error < too_much_error);
 779                         period.from = *_next_audio_time;
 780                 }
 781                 if (period.duration() > one_video_frame()) {
 782                         period.to = period.from + one_video_frame();
 783                 }
 784                 fill_audio (period);
 785                 _silent.set_position (period.to);
 786                 break;
 787         }
 788         case NONE:
 789                 done = true;
 790                 break;
 791         }
 792
 793         /* Emit any audio that is ready */
 794
 795         /* Work out the time before which the audio is definitely all here.  This is the earliest last_push_end of one
 796            of our streams, or the position of the _silent.  First, though we choose only streams that are less than
 797            ignore_streams_behind seconds behind the furthest ahead (we assume that if a stream has fallen that far
 798            behind it has finished).  This is so that we don't withhold audio indefinitely awaiting data from a stream
 799            that will never come, causing bugs like #2101.
 800         */
 801         constexpr int ignore_streams_behind = 5;
 802
 803         using state_pair = std::pair<AudioStreamPtr, StreamState>;
 804
 805         /* Find streams that have pushed */
 806         std::vector<state_pair> have_pushed;
 807         std::copy_if(_stream_states.begin(), _stream_states.end(), std::back_inserter(have_pushed), [](state_pair const& a) { return static_cast<bool>(a.second.last_push_end); });
 808
 809         /* Find the 'leading' stream (i.e. the one that pushed data most recently) */
 810         auto latest_last_push_end = std::max_element(
 811                 have_pushed.begin(),
 812                 have_pushed.end(),
 813                 [](state_pair const& a, state_pair const& b) { return a.second.last_push_end.get() < b.second.last_push_end.get(); }
 814                 );
 815
 816         if (latest_last_push_end != have_pushed.end()) {
 817                 LOG_DEBUG_PLAYER("Leading audio stream is in %1 at %2", latest_last_push_end->second.piece->content->path(0), to_string(latest_last_push_end->second.last_push_end.get()));
 818         }
 819
 820         /* Now make a list of those streams that are less than ignore_streams_behind behind the leader */
 821         std::map<AudioStreamPtr, StreamState> alive_stream_states;
 822         for (auto const& i: _stream_states) {
 823                 if (!i.second.last_push_end || (latest_last_push_end->second.last_push_end.get() - i.second.last_push_end.get()) < dcpomatic::DCPTime::from_seconds(ignore_streams_behind)) {
 824                         alive_stream_states.insert(i);
 825                 } else {
 826                         LOG_DEBUG_PLAYER("Ignoring stream %1 because it is too far behind", i.second.piece->content->path(0));
 827                 }
 828         }
 829
 830         auto pull_to = _playback_length.load();
 831         for (auto const& i: alive_stream_states) {
 832                 auto position = i.second.last_push_end.get_value_or(i.second.piece->content->position());
 833                 if (!i.second.piece->done && position < pull_to) {
 834                         pull_to = position;
 835                 }
 836         }
 837         if (!_silent.done() && _silent.position() < pull_to) {
 838                 pull_to = _silent.position();
 839         }
 840
 841         LOG_DEBUG_PLAYER("Emitting audio up to %1", to_string(pull_to));
 842         auto audio = _audio_merger.pull (pull_to);
 843         for (auto i = audio.begin(); i != audio.end(); ++i) {
 844                 if (_next_audio_time && i->second < *_next_audio_time) {
 845                         /* This new data comes before the last we emitted (or the last seek); discard it */
 846                         auto cut = discard_audio (i->first, i->second, *_next_audio_time);
 847                         if (!cut.first) {
 848                                 continue;
 849                         }
 850                         *i = cut;
 851                 } else if (_next_audio_time && i->second > *_next_audio_time) {
 852                         /* There's a gap between this data and the last we emitted; fill with silence */
 853                         fill_audio (DCPTimePeriod (*_next_audio_time, i->second));
 854                 }
 855
 856                 emit_audio (i->first, i->second);
 857         }
 858
 859         if (done) {
 860                 emit_video_until(film->length());
 861
 862                 if (_shuffler) {
 863                         _shuffler->flush ();
 864                 }
 865                 for (auto const& i: _delay) {
 866                         emit_video(i.first, i.second);
 867                 }
 868         }
 869
 870         return done;
 871 }
 872
 873
 874 /** @return Open subtitles for the frame at the given time, converted to images */
 875 optional<PositionImage>
 876 Player::open_subtitles_for_frame (DCPTime time) const
 877 {
 878         auto film = _film.lock();
 879         if (!film) {
 880                 return {};
 881         }
 882
 883         list<PositionImage> captions;
 884         int const vfr = film->video_frame_rate();
 885
 886         for (
 887                 auto j:
 888                 _active_texts[TextType::OPEN_SUBTITLE].get_burnt(DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_open_subtitles)
 889                 ) {
 890
 891                 /* Bitmap subtitles */
 892                 for (auto i: j.bitmap) {
 893                         if (!i.image) {
 894                                 continue;
 895                         }
 896
 897                         /* i.image will already have been scaled to fit _video_container_size */
 898                         dcp::Size scaled_size (i.rectangle.width * _video_container_size.load().width, i.rectangle.height * _video_container_size.load().height);
 899
 900                         captions.push_back (
 901                                 PositionImage (
 902                                         i.image,
 903                                         Position<int> (
 904                                                 lrint(_video_container_size.load().width * i.rectangle.x),
 905                                                 lrint(_video_container_size.load().height * i.rectangle.y)
 906                                                 )
 907                                         )
 908                                 );
 909                 }
 910
 911                 /* String subtitles (rendered to an image) */
 912                 if (!j.string.empty()) {
 913                         auto s = render_text(j.string, _video_container_size, time, vfr);
 914                         copy (s.begin(), s.end(), back_inserter (captions));
 915                 }
 916         }
 917
 918         if (captions.empty()) {
 919                 return {};
 920         }
 921
 922         return merge (captions, _subtitle_alignment);
 923 }
 924
 925
 926 static
 927 Eyes
 928 increment_eyes (Eyes e)
 929 {
 930         if (e == Eyes::LEFT) {
 931                 return Eyes::RIGHT;
 932         }
 933
 934         return Eyes::LEFT;
 935 }
 936
 937
 938 void
 939 Player::emit_video_until(DCPTime time)
 940 {
 941         auto frame = [this](shared_ptr<PlayerVideo> pv, DCPTime time) {
 942                 /* We need a delay to give a little wiggle room to ensure that relevant subtitles arrive at the
 943                    player before the video that requires them.
 944                 */
 945                 _delay.push_back(make_pair(pv, time));
 946
 947                 if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) {
 948                         _next_video_time = time + one_video_frame();
 949                 }
 950
 951                 if (_delay.size() < 3) {
 952                         return;
 953                 }
 954
 955                 auto to_do = _delay.front();
 956                 _delay.pop_front();
 957                 emit_video(to_do.first, to_do.second);
 958         };
 959
 960         auto const age_threshold = one_video_frame() * 2;
 961
 962         while (_next_video_time.get_value_or({}) < time) {
 963                 auto left = _last_video[Eyes::LEFT];
 964                 auto right = _last_video[Eyes::RIGHT];
 965                 auto both = _last_video[Eyes::BOTH];
 966
 967                 auto const next = _next_video_time.get_value_or({});
 968
 969                 if (
 970                         left.first &&
 971                         right.first &&
 972                         (!both.first || (left.second >= both.second && right.second >= both.second)) &&
 973                         (left.second - next) < age_threshold &&
 974                         (right.second - next) < age_threshold
 975                    ) {
 976                         frame(left.first, next);
 977                         frame(right.first, next);
 978                 } else if (both.first && (both.second - next) < age_threshold) {
 979                         frame(both.first, next);
 980                         LOG_DEBUG_PLAYER("Content %1 selected for DCP %2 (age %3)", to_string(both.second), to_string(next), to_string(both.second - next));
 981                 } else {
 982                         frame(black_player_video_frame(Eyes::BOTH), next);
 983                         LOG_DEBUG_PLAYER("Black selected for DCP %1", to_string(next));
 984                 }
 985         }
 986 }
 987
 988
 989 void
 990 Player::video (weak_ptr<Piece> weak_piece, ContentVideo video)
 991 {
 992         if (_suspended) {
 993                 return;
 994         }
 995
 996         auto piece = weak_piece.lock ();
 997         if (!piece) {
 998                 return;
 999         }
1000
1001         if (!piece->content->video->use()) {
1002                 return;
1003         }
1004
1005         auto film = _film.lock();
1006         if (!film) {
1007                 return;
1008         }
1009
1010         auto const three_d = film->three_d();
1011
1012         if (!three_d) {
1013                 if (video.eyes == Eyes::LEFT) {
1014                         /* Use left-eye images for both eyes... */
1015                         video.eyes = Eyes::BOTH;
1016                 } else if (video.eyes == Eyes::RIGHT) {
1017                         /* ...and discard the right */
1018                         return;
1019                 }
1020         }
1021
1022         /* Time of the frame we just received within the DCP */
1023         auto const time = content_time_to_dcp(piece, video.time);
1024         LOG_DEBUG_PLAYER("Received video frame %1 %2 eyes %3", to_string(video.time), to_string(time), static_cast<int>(video.eyes));
1025
1026         if (time < piece->content->position()) {
1027                 return;
1028         }
1029
1030         if (piece->ignore_video && piece->ignore_video->contains(time)) {
1031                 return;
1032         }
1033
1034         if (!_next_video_time) {
1035                 _next_video_time = time.round(film->video_frame_rate());
1036         }
1037
1038         auto const content_video = piece->content->video;
1039         use_video(
1040                 std::make_shared<PlayerVideo>(
1041                         video.image,
1042                         content_video->actual_crop(),
1043                         content_video->fade(film, video.time),
1044                         scale_for_display(
1045                                 content_video->scaled_size(film->frame_size()),
1046                                 _video_container_size,
1047                                 film->frame_size(),
1048                                 content_video->pixel_quanta()
1049                                 ),
1050                         _video_container_size,
1051                         video.eyes,
1052                         video.part,
1053                         content_video->colour_conversion(),
1054                         content_video->range(),
1055                         piece->content,
1056                         video.time,
1057                         false
1058                         ),
1059                 time,
1060                 piece->content->end(film)
1061         );
1062 }
1063
1064 void
1065 Player::use_video(shared_ptr<PlayerVideo> pv, DCPTime time, DCPTime end)
1066 {
1067         _last_video[pv->eyes()] = { pv, time };
1068         if (pv->eyes() != Eyes::LEFT) {
1069                 emit_video_until(std::min(time + one_video_frame() / 2, end));
1070         }
1071 }
1072
1073
1074 void
1075 Player::audio (weak_ptr<Piece> weak_piece, AudioStreamPtr stream, ContentAudio content_audio)
1076 {
1077         if (_suspended) {
1078                 return;
1079         }
1080
1081         DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
1082
1083         auto piece = weak_piece.lock ();
1084         if (!piece) {
1085                 return;
1086         }
1087
1088         auto film = _film.lock();
1089         if (!film) {
1090                 return;
1091         }
1092
1093         auto content = piece->content->audio;
1094         DCPOMATIC_ASSERT (content);
1095
1096         int const rfr = content->resampled_frame_rate(film);
1097
1098         /* Compute time in the DCP */
1099         auto time = resampled_audio_to_dcp (piece, content_audio.frame);
1100
1101         /* And the end of this block in the DCP */
1102         auto end = time + DCPTime::from_frames(content_audio.audio->frames(), rfr);
1103         LOG_DEBUG_PLAYER("Received audio frame %1 covering %2 to %3 (%4)", content_audio.frame, to_string(time), to_string(end), piece->content->path(0).filename());
1104
1105         /* Remove anything that comes before the start or after the end of the content */
1106         if (time < piece->content->position()) {
1107                 auto cut = discard_audio (content_audio.audio, time, piece->content->position());
1108                 if (!cut.first) {
1109                         /* This audio is entirely discarded */
1110                         return;
1111                 }
1112                 content_audio.audio = cut.first;
1113                 time = cut.second;
1114         } else if (time > piece->content->end(film)) {
1115                 /* Discard it all */
1116                 return;
1117         } else if (end > piece->content->end(film)) {
1118                 Frame const remaining_frames = DCPTime(piece->content->end(film) - time).frames_round(rfr);
1119                 if (remaining_frames == 0) {
1120                         return;
1121                 }
1122                 content_audio.audio = make_shared<AudioBuffers>(content_audio.audio, remaining_frames, 0);
1123         }
1124
1125         DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
1126
1127         /* Gain and fade */
1128
1129         auto const fade_coeffs = content->fade (stream, content_audio.frame, content_audio.audio->frames(), rfr);
1130         if (content->gain() != 0 || !fade_coeffs.empty()) {
1131                 auto gain_buffers = make_shared<AudioBuffers>(content_audio.audio);
1132                 if (!fade_coeffs.empty()) {
1133                         /* Apply both fade and gain */
1134                         DCPOMATIC_ASSERT (fade_coeffs.size() == static_cast<size_t>(gain_buffers->frames()));
1135                         auto const channels = gain_buffers->channels();
1136                         auto const frames = fade_coeffs.size();
1137                         auto data = gain_buffers->data();
1138                         auto const gain = db_to_linear (content->gain());
1139                         for (auto channel = 0; channel < channels; ++channel) {
1140                                 for (auto frame = 0U; frame < frames; ++frame) {
1141                                         data[channel][frame] *= gain * fade_coeffs[frame];
1142                                 }
1143                         }
1144                 } else {
1145                         /* Just apply gain */
1146                         gain_buffers->apply_gain (content->gain());
1147                 }
1148                 content_audio.audio = gain_buffers;
1149         }
1150
1151         /* Remap */
1152
1153         content_audio.audio = remap(content_audio.audio, film->audio_channels(), stream->mapping());
1154
1155         /* Process */
1156
1157         if (_audio_processor) {
1158                 content_audio.audio = _audio_processor->run(content_audio.audio, film->audio_channels());
1159         }
1160
1161         /* Push */
1162
1163         _audio_merger.push (content_audio.audio, time);
1164         DCPOMATIC_ASSERT (_stream_states.find (stream) != _stream_states.end ());
1165         _stream_states[stream].last_push_end = time + DCPTime::from_frames(content_audio.audio->frames(), film->audio_frame_rate());
1166 }
1167
1168
1169 void
1170 Player::bitmap_text_start (weak_ptr<Piece> weak_piece, weak_ptr<const TextContent> weak_content, ContentBitmapText subtitle)
1171 {
1172         if (_suspended) {
1173                 return;
1174         }
1175
1176         auto piece = weak_piece.lock ();
1177         auto content = weak_content.lock ();
1178         if (!piece || !content) {
1179                 return;
1180         }
1181
1182         PlayerText ps;
1183         for (auto& sub: subtitle.subs)
1184         {
1185                 /* Apply content's subtitle offsets */
1186                 sub.rectangle.x += content->x_offset ();
1187                 sub.rectangle.y += content->y_offset ();
1188
1189                 /* Apply a corrective translation to keep the subtitle centred after the scale that is coming up */
1190                 sub.rectangle.x -= sub.rectangle.width * ((content->x_scale() - 1) / 2);
1191                 sub.rectangle.y -= sub.rectangle.height * ((content->y_scale() - 1) / 2);
1192
1193                 /* Apply content's subtitle scale */
1194                 sub.rectangle.width *= content->x_scale ();
1195                 sub.rectangle.height *= content->y_scale ();
1196
1197                 auto image = sub.image;
1198
1199                 /* We will scale the subtitle up to fit _video_container_size */
1200                 int const width = sub.rectangle.width * _video_container_size.load().width;
1201                 int const height = sub.rectangle.height * _video_container_size.load().height;
1202                 if (width == 0 || height == 0) {
1203                         return;
1204                 }
1205
1206                 dcp::Size scaled_size (width, height);
1207                 ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUVToRGB::REC601, image->pixel_format(), Image::Alignment::PADDED, _fast), sub.rectangle));
1208         }
1209
1210         DCPTime from(content_time_to_dcp(piece, subtitle.from()));
1211         _active_texts[content->type()].add_from(weak_content, ps, from);
1212 }
1213
1214
1215 void
1216 Player::plain_text_start (weak_ptr<Piece> weak_piece, weak_ptr<const TextContent> weak_content, ContentStringText subtitle)
1217 {
1218         if (_suspended) {
1219                 return;
1220         }
1221
1222         auto piece = weak_piece.lock ();
1223         auto content = weak_content.lock ();
1224         auto film = _film.lock();
1225         if (!piece || !content || !film) {
1226                 return;
1227         }
1228
1229         PlayerText ps;
1230         DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
1231
1232         if (from > piece->content->end(film)) {
1233                 return;
1234         }
1235
1236         for (auto s: subtitle.subs) {
1237                 s.set_h_position (s.h_position() + content->x_offset());
1238                 s.set_v_position (s.v_position() + content->y_offset());
1239                 float const xs = content->x_scale();
1240                 float const ys = content->y_scale();
1241                 float size = s.size();
1242
1243                 /* Adjust size to express the common part of the scaling;
1244                    e.g. if xs = ys = 0.5 we scale size by 2.
1245                 */
1246                 if (xs > 1e-5 && ys > 1e-5) {
1247                         size *= 1 / min (1 / xs, 1 / ys);
1248                 }
1249                 s.set_size (size);
1250
1251                 /* Then express aspect ratio changes */
1252                 if (fabs (1.0 - xs / ys) > dcp::ASPECT_ADJUST_EPSILON) {
1253                         s.set_aspect_adjust (xs / ys);
1254                 }
1255
1256                 s.set_in (dcp::Time(from.seconds(), 1000));
1257                 ps.string.push_back (s);
1258         }
1259
1260         _active_texts[content->type()].add_from(weak_content, ps, from);
1261 }
1262
1263
1264 void
1265 Player::subtitle_stop (weak_ptr<Piece> weak_piece, weak_ptr<const TextContent> weak_content, ContentTime to)
1266 {
1267         if (_suspended) {
1268                 return;
1269         }
1270
1271         auto content = weak_content.lock ();
1272         if (!content) {
1273                 return;
1274         }
1275
1276         if (!_active_texts[content->type()].have(weak_content)) {
1277                 return;
1278         }
1279
1280         auto piece = weak_piece.lock ();
1281         auto film = _film.lock();
1282         if (!piece || !film) {
1283                 return;
1284         }
1285
1286         DCPTime const dcp_to = content_time_to_dcp (piece, to);
1287
1288         if (dcp_to > piece->content->end(film)) {
1289                 return;
1290         }
1291
1292         auto from = _active_texts[content->type()].add_to(weak_content, dcp_to);
1293
1294         bool const always = (content->type() == TextType::OPEN_SUBTITLE && _always_burn_open_subtitles);
1295         if (content->use() && !always && !content->burn()) {
1296                 Text (from.first, content->type(), content->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod(from.second, dcp_to));
1297         }
1298 }
1299
1300
1301 void
1302 Player::seek (DCPTime time, bool accurate)
1303 {
1304         boost::mutex::scoped_lock lm (_mutex);
1305         LOG_DEBUG_PLAYER("Seek to %1 (%2accurate)", to_string(time), accurate ? "" : "in");
1306
1307         if (_suspended) {
1308                 /* We can't seek in this state */
1309                 return;
1310         }
1311
1312         auto film = _film.lock();
1313         if (!film) {
1314                 return;
1315         }
1316
1317         if (_shuffler) {
1318                 _shuffler->clear ();
1319         }
1320
1321         _delay.clear ();
1322
1323         if (_audio_processor) {
1324                 _audio_processor->flush ();
1325         }
1326
1327         _audio_merger.clear ();
1328         std::for_each(_active_texts.begin(), _active_texts.end(), [](ActiveText& a) { a.clear(); });
1329
1330         for (auto i: _pieces) {
1331                 if (time < i->content->position()) {
1332                         /* Before; seek to the start of the content.  Even if this request is for an inaccurate seek
1333                            we must seek this (following) content accurately, otherwise when we come to the end of the current
1334                            content we may not start right at the beginning of the next, causing a gap (if the next content has
1335                            been trimmed to a point between keyframes, or something).
1336                         */
1337                         i->decoder->seek (dcp_to_content_time (i, i->content->position()), true);
1338                         i->done = false;
1339                 } else if (i->content->position() <= time && time < i->content->end(film)) {
1340                         /* During; seek to position */
1341                         i->decoder->seek (dcp_to_content_time (i, time), accurate);
1342                         i->done = false;
1343                 } else {
1344                         /* After; this piece is done */
1345                         i->done = true;
1346                 }
1347         }
1348
1349         if (accurate) {
1350                 _next_video_time = time;
1351                 _next_audio_time = time;
1352         } else {
1353                 _next_video_time = boost::none;
1354                 _next_audio_time = boost::none;
1355         }
1356
1357         _black.set_position (time);
1358         _silent.set_position (time);
1359
1360         _last_video[Eyes::LEFT] = {};
1361         _last_video[Eyes::RIGHT] = {};
1362         _last_video[Eyes::BOTH] = {};
1363
1364         for (auto& state: _stream_states) {
1365                 state.second.last_push_end = boost::none;
1366         }
1367 }
1368
1369
1370 void
1371 Player::emit_video(shared_ptr<PlayerVideo> pv, DCPTime time)
1372 {
1373         if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) {
1374                 std::for_each(_active_texts.begin(), _active_texts.end(), [time](ActiveText& a) { a.clear_before(time); });
1375         }
1376
1377         auto subtitles = open_subtitles_for_frame (time);
1378         if (subtitles) {
1379                 pv->set_text (subtitles.get ());
1380         }
1381
1382         Video (pv, time);
1383 }
1384
1385
1386 void
1387 Player::emit_audio (shared_ptr<AudioBuffers> data, DCPTime time)
1388 {
1389         auto film = _film.lock();
1390         DCPOMATIC_ASSERT(film);
1391
1392         /* Log if the assert below is about to fail */
1393         if (_next_audio_time && labs(time.get() - _next_audio_time->get()) > 1) {
1394                 film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_next_audio_time)), LogEntry::TYPE_WARNING);
1395         }
1396
1397         /* This audio must follow on from the previous, allowing for half a sample (at 48kHz) leeway */
1398         DCPOMATIC_ASSERT (!_next_audio_time || labs(time.get() - _next_audio_time->get()) < 2);
1399         Audio(data, time, film->audio_frame_rate());
1400         _next_audio_time = time + DCPTime::from_frames(data->frames(), film->audio_frame_rate());
1401 }
1402
1403
1404 void
1405 Player::fill_audio (DCPTimePeriod period)
1406 {
1407         auto film = _film.lock();
1408         DCPOMATIC_ASSERT(film);
1409
1410         if (period.from == period.to) {
1411                 return;
1412         }
1413
1414         DCPOMATIC_ASSERT (period.from < period.to);
1415
1416         DCPTime t = period.from;
1417         while (t < period.to) {
1418                 DCPTime block = min (DCPTime::from_seconds (0.5), period.to - t);
1419                 Frame const samples = block.frames_round(film->audio_frame_rate());
1420                 if (samples) {
1421                         auto silence = make_shared<AudioBuffers>(film->audio_channels(), samples);
1422                         silence->make_silent ();
1423                         emit_audio (silence, t);
1424                 }
1425                 t += block;
1426         }
1427 }
1428
1429
1430 DCPTime
1431 Player::one_video_frame () const
1432 {
1433         auto film = _film.lock();
1434         DCPOMATIC_ASSERT(film);
1435
1436         return DCPTime::from_frames(1, film->video_frame_rate ());
1437 }
1438
1439
1440 pair<shared_ptr<AudioBuffers>, DCPTime>
1441 Player::discard_audio (shared_ptr<const AudioBuffers> audio, DCPTime time, DCPTime discard_to) const
1442 {
1443         auto film = _film.lock();
1444         DCPOMATIC_ASSERT(film);
1445
1446         auto const discard_time = discard_to - time;
1447         auto const discard_frames = discard_time.frames_round(film->audio_frame_rate());
1448         auto remaining_frames = audio->frames() - discard_frames;
1449         if (remaining_frames <= 0) {
1450                 return make_pair(shared_ptr<AudioBuffers>(), DCPTime());
1451         }
1452         auto cut = make_shared<AudioBuffers>(audio, remaining_frames, discard_frames);
1453         return make_pair(cut, time + discard_time);
1454 }
1455
1456
1457 void
1458 Player::set_dcp_decode_reduction (optional<int> reduction)
1459 {
1460         ChangeSignaller<Player, int> cc(this, PlayerProperty::DCP_DECODE_REDUCTION);
1461
1462         if (reduction == _dcp_decode_reduction.load()) {
1463                 cc.abort();
1464                 return;
1465         }
1466
1467         _dcp_decode_reduction = reduction;
1468         setup_pieces();
1469 }
1470
1471
1472 optional<DCPTime>
1473 Player::content_time_to_dcp (shared_ptr<const Content> content, ContentTime t) const
1474 {
1475         boost::mutex::scoped_lock lm (_mutex);
1476
1477         for (auto i: _pieces) {
1478                 if (i->content == content) {
1479                         return content_time_to_dcp (i, t);
1480                 }
1481         }
1482
1483         /* We couldn't find this content; perhaps things are being changed over */
1484         return {};
1485 }
1486
1487
1488 optional<ContentTime>
1489 Player::dcp_to_content_time (shared_ptr<const Content> content, DCPTime t) const
1490 {
1491         boost::mutex::scoped_lock lm (_mutex);
1492
1493         for (auto i: _pieces) {
1494                 if (i->content == content) {
1495                         return dcp_to_content_time (i, t);
1496                 }
1497         }
1498
1499         /* We couldn't find this content; perhaps things are being changed over */
1500         return {};
1501 }
1502
1503
1504 shared_ptr<const Playlist>
1505 Player::playlist () const
1506 {
1507         auto film = _film.lock();
1508         if (!film) {
1509                 return {};
1510         }
1511
1512         return _playlist ? _playlist : film->playlist();
1513 }
1514
1515
1516 void
1517 Player::atmos (weak_ptr<Piece> weak_piece, ContentAtmos data)
1518 {
1519         if (_suspended) {
1520                 return;
1521         }
1522
1523         auto film = _film.lock();
1524         DCPOMATIC_ASSERT(film);
1525
1526         auto piece = weak_piece.lock ();
1527         DCPOMATIC_ASSERT (piece);
1528
1529         auto const vfr = film->video_frame_rate();
1530
1531         DCPTime const dcp_time = DCPTime::from_frames(data.frame, vfr) - DCPTime(piece->content->trim_start(), FrameRateChange(vfr, vfr));
1532         if (dcp_time < piece->content->position() || dcp_time >= (piece->content->end(film))) {
1533                 return;
1534         }
1535
1536         Atmos (data.data, dcp_time, data.metadata);
1537 }
1538
1539
1540 void
1541 Player::signal_change(ChangeType type, int property)
1542 {
1543         Change(type, property, false);
1544 }
1545