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