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