src/lib/player.cc

   1 /*
   2     Copyright (C) 2013-2018 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 #include "player.h"
  22 #include "film.h"
  23 #include "audio_buffers.h"
  24 #include "content_audio.h"
  25 #include "dcp_content.h"
  26 #include "job.h"
  27 #include "image.h"
  28 #include "raw_image_proxy.h"
  29 #include "ratio.h"
  30 #include "log.h"
  31 #include "render_subtitles.h"
  32 #include "config.h"
  33 #include "content_video.h"
  34 #include "player_video.h"
  35 #include "frame_rate_change.h"
  36 #include "audio_processor.h"
  37 #include "playlist.h"
  38 #include "referenced_reel_asset.h"
  39 #include "decoder_factory.h"
  40 #include "decoder.h"
  41 #include "video_decoder.h"
  42 #include "audio_decoder.h"
  43 #include "subtitle_content.h"
  44 #include "subtitle_decoder.h"
  45 #include "ffmpeg_content.h"
  46 #include "audio_content.h"
  47 #include "content_subtitle.h"
  48 #include "dcp_decoder.h"
  49 #include "image_decoder.h"
  50 #include "compose.hpp"
  51 #include "shuffler.h"
  52 #include <dcp/reel.h>
  53 #include <dcp/reel_sound_asset.h>
  54 #include <dcp/reel_subtitle_asset.h>
  55 #include <dcp/reel_picture_asset.h>
  56 #include <boost/foreach.hpp>
  57 #include <stdint.h>
  58 #include <algorithm>
  59 #include <iostream>
  60
  61 #include "i18n.h"
  62
  63 #define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
  64
  65 using std::list;
  66 using std::cout;
  67 using std::min;
  68 using std::max;
  69 using std::min;
  70 using std::vector;
  71 using std::pair;
  72 using std::map;
  73 using std::make_pair;
  74 using std::copy;
  75 using boost::shared_ptr;
  76 using boost::weak_ptr;
  77 using boost::dynamic_pointer_cast;
  78 using boost::optional;
  79 using boost::scoped_ptr;
  80
  81 Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist)
  82         : _film (film)
  83         , _playlist (playlist)
  84         , _have_valid_pieces (false)
  85         , _ignore_video (false)
  86         , _ignore_subtitle (false)
  87         , _always_burn_subtitles (false)
  88         , _fast (false)
  89         , _play_referenced (false)
  90         , _audio_merger (_film->audio_frame_rate())
  91         , _shuffler (0)
  92 {
  93         _film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1));
  94         _playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this));
  95         _playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Player::playlist_content_changed, this, _1, _2, _3));
  96         set_video_container_size (_film->frame_size ());
  97
  98         film_changed (Film::AUDIO_PROCESSOR);
  99
 100         seek (DCPTime (), true);
 101 }
 102
 103 Player::~Player ()
 104 {
 105         delete _shuffler;
 106 }
 107
 108 void
 109 Player::setup_pieces ()
 110 {
 111         _pieces.clear ();
 112
 113         delete _shuffler;
 114         _shuffler = new Shuffler();
 115         _shuffler->Video.connect(bind(&Player::video, this, _1, _2));
 116
 117         BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
 118
 119                 if (!i->paths_valid ()) {
 120                         continue;
 121                 }
 122
 123                 shared_ptr<Decoder> decoder = decoder_factory (i, _film->log(), _fast);
 124                 FrameRateChange frc (i->active_video_frame_rate(), _film->video_frame_rate());
 125
 126                 if (!decoder) {
 127                         /* Not something that we can decode; e.g. Atmos content */
 128                         continue;
 129                 }
 130
 131                 if (decoder->video && _ignore_video) {
 132                         decoder->video->set_ignore (true);
 133                 }
 134
 135                 if (decoder->subtitle && _ignore_subtitle) {
 136                         decoder->subtitle->set_ignore (true);
 137                 }
 138
 139                 shared_ptr<DCPDecoder> dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
 140                 if (dcp) {
 141                         dcp->set_decode_referenced (_play_referenced);
 142                         if (_play_referenced) {
 143                                 dcp->set_forced_reduction (_dcp_decode_reduction);
 144                         }
 145                 }
 146
 147                 shared_ptr<Piece> piece (new Piece (i, decoder, frc));
 148                 _pieces.push_back (piece);
 149
 150                 if (decoder->video) {
 151                         if (i->video->frame_type() == VIDEO_FRAME_TYPE_3D_LEFT || i->video->frame_type() == VIDEO_FRAME_TYPE_3D_RIGHT) {
 152                                 /* We need a Shuffler to cope with 3D L/R video data arriving out of sequence */
 153                                 decoder->video->Data.connect (bind (&Shuffler::video, _shuffler, weak_ptr<Piece>(piece), _1));
 154                         } else {
 155                                 decoder->video->Data.connect (bind (&Player::video, this, weak_ptr<Piece>(piece), _1));
 156                         }
 157                 }
 158
 159                 if (decoder->audio) {
 160                         decoder->audio->Data.connect (bind (&Player::audio, this, weak_ptr<Piece> (piece), _1, _2));
 161                 }
 162
 163                 if (decoder->subtitle) {
 164                         decoder->subtitle->ImageStart.connect (bind (&Player::image_subtitle_start, this, weak_ptr<Piece> (piece), _1));
 165                         decoder->subtitle->TextStart.connect (bind (&Player::text_subtitle_start, this, weak_ptr<Piece> (piece), _1));
 166                         decoder->subtitle->Stop.connect (bind (&Player::subtitle_stop, this, weak_ptr<Piece> (piece), _1));
 167                 }
 168         }
 169
 170         _stream_states.clear ();
 171         BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 172                 if (i->content->audio) {
 173                         BOOST_FOREACH (AudioStreamPtr j, i->content->audio->streams()) {
 174                                 _stream_states[j] = StreamState (i, i->content->position ());
 175                         }
 176                 }
 177         }
 178
 179         _black = Empty (_film->content(), _film->length(), bind(&Content::video, _1));
 180         _silent = Empty (_film->content(), _film->length(), bind(&Content::audio, _1));
 181
 182         _last_video_time = DCPTime ();
 183         _last_video_eyes = EYES_BOTH;
 184         _last_audio_time = DCPTime ();
 185         _have_valid_pieces = true;
 186 }
 187
 188 void
 189 Player::playlist_content_changed (weak_ptr<Content> w, int property, bool frequent)
 190 {
 191         shared_ptr<Content> c = w.lock ();
 192         if (!c) {
 193                 return;
 194         }
 195
 196         if (
 197                 property == ContentProperty::POSITION ||
 198                 property == ContentProperty::LENGTH ||
 199                 property == ContentProperty::TRIM_START ||
 200                 property == ContentProperty::TRIM_END ||
 201                 property == ContentProperty::PATH ||
 202                 property == VideoContentProperty::FRAME_TYPE ||
 203                 property == DCPContentProperty::NEEDS_ASSETS ||
 204                 property == DCPContentProperty::NEEDS_KDM ||
 205                 property == SubtitleContentProperty::COLOUR ||
 206                 property == SubtitleContentProperty::EFFECT ||
 207                 property == SubtitleContentProperty::EFFECT_COLOUR ||
 208                 property == FFmpegContentProperty::SUBTITLE_STREAM ||
 209                 property == FFmpegContentProperty::FILTERS ||
 210                 property == VideoContentProperty::COLOUR_CONVERSION
 211                 ) {
 212
 213                 _have_valid_pieces = false;
 214                 Changed (frequent);
 215
 216         } else if (
 217                 property == SubtitleContentProperty::LINE_SPACING ||
 218                 property == SubtitleContentProperty::OUTLINE_WIDTH ||
 219                 property == SubtitleContentProperty::Y_SCALE ||
 220                 property == SubtitleContentProperty::FADE_IN ||
 221                 property == SubtitleContentProperty::FADE_OUT ||
 222                 property == ContentProperty::VIDEO_FRAME_RATE ||
 223                 property == SubtitleContentProperty::USE ||
 224                 property == SubtitleContentProperty::X_OFFSET ||
 225                 property == SubtitleContentProperty::Y_OFFSET ||
 226                 property == SubtitleContentProperty::X_SCALE ||
 227                 property == SubtitleContentProperty::FONTS ||
 228                 property == VideoContentProperty::CROP ||
 229                 property == VideoContentProperty::SCALE ||
 230                 property == VideoContentProperty::FADE_IN ||
 231                 property == VideoContentProperty::FADE_OUT
 232                 ) {
 233
 234                 Changed (frequent);
 235         }
 236 }
 237
 238 void
 239 Player::set_video_container_size (dcp::Size s)
 240 {
 241         if (s == _video_container_size) {
 242                 return;
 243         }
 244
 245         _video_container_size = s;
 246
 247         _black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true));
 248         _black_image->make_black ();
 249
 250         Changed (false);
 251 }
 252
 253 void
 254 Player::playlist_changed ()
 255 {
 256         _have_valid_pieces = false;
 257         Changed (false);
 258 }
 259
 260 void
 261 Player::film_changed (Film::Property p)
 262 {
 263         /* Here we should notice Film properties that affect our output, and
 264            alert listeners that our output now would be different to how it was
 265            last time we were run.
 266         */
 267
 268         if (p == Film::CONTAINER) {
 269                 Changed (false);
 270         } else if (p == Film::VIDEO_FRAME_RATE) {
 271                 /* Pieces contain a FrameRateChange which contains the DCP frame rate,
 272                    so we need new pieces here.
 273                 */
 274                 _have_valid_pieces = false;
 275                 Changed (false);
 276         } else if (p == Film::AUDIO_PROCESSOR) {
 277                 if (_film->audio_processor ()) {
 278                         _audio_processor = _film->audio_processor()->clone (_film->audio_frame_rate ());
 279                 }
 280         }
 281 }
 282
 283 list<PositionImage>
 284 Player::transform_image_subtitles (list<ImageSubtitle> subs) const
 285 {
 286         list<PositionImage> all;
 287
 288         for (list<ImageSubtitle>::const_iterator i = subs.begin(); i != subs.end(); ++i) {
 289                 if (!i->image) {
 290                         continue;
 291                 }
 292
 293                 /* We will scale the subtitle up to fit _video_container_size */
 294                 dcp::Size scaled_size (i->rectangle.width * _video_container_size.width, i->rectangle.height * _video_container_size.height);
 295
 296                 /* Then we need a corrective translation, consisting of two parts:
 297                  *
 298                  * 1.  that which is the result of the scaling of the subtitle by _video_container_size; this will be
 299                  *     rect.x * _video_container_size.width and rect.y * _video_container_size.height.
 300                  *
 301                  * 2.  that to shift the origin of the scale by subtitle_scale to the centre of the subtitle; this will be
 302                  *     (width_before_subtitle_scale * (1 - subtitle_x_scale) / 2) and
 303                  *     (height_before_subtitle_scale * (1 - subtitle_y_scale) / 2).
 304                  *
 305                  * Combining these two translations gives these expressions.
 306                  */
 307
 308                 all.push_back (
 309                         PositionImage (
 310                                 i->image->scale (
 311                                         scaled_size,
 312                                         dcp::YUV_TO_RGB_REC601,
 313                                         i->image->pixel_format (),
 314                                         true,
 315                                         _fast
 316                                         ),
 317                                 Position<int> (
 318                                         lrint (_video_container_size.width * i->rectangle.x),
 319                                         lrint (_video_container_size.height * i->rectangle.y)
 320                                         )
 321                                 )
 322                         );
 323         }
 324
 325         return all;
 326 }
 327
 328 shared_ptr<PlayerVideo>
 329 Player::black_player_video_frame (Eyes eyes) const
 330 {
 331         return shared_ptr<PlayerVideo> (
 332                 new PlayerVideo (
 333                         shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)),
 334                         Crop (),
 335                         optional<double> (),
 336                         _video_container_size,
 337                         _video_container_size,
 338                         eyes,
 339                         PART_WHOLE,
 340                         PresetColourConversion::all().front().conversion
 341                 )
 342         );
 343 }
 344
 345 Frame
 346 Player::dcp_to_content_video (shared_ptr<const Piece> piece, DCPTime t) const
 347 {
 348         DCPTime s = t - piece->content->position ();
 349         s = min (piece->content->length_after_trim(), s);
 350         s = max (DCPTime(), s + DCPTime (piece->content->trim_start(), piece->frc));
 351
 352         /* It might seem more logical here to convert s to a ContentTime (using the FrameRateChange)
 353            then convert that ContentTime to frames at the content's rate.  However this fails for
 354            situations like content at 29.9978733fps, DCP at 30fps.  The accuracy of the Time type is not
 355            enough to distinguish between the two with low values of time (e.g. 3200 in Time units).
 356
 357            Instead we convert the DCPTime using the DCP video rate then account for any skip/repeat.
 358         */
 359         return s.frames_floor (piece->frc.dcp) / piece->frc.factor ();
 360 }
 361
 362 DCPTime
 363 Player::content_video_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 364 {
 365         /* See comment in dcp_to_content_video */
 366         DCPTime const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime(piece->content->trim_start(), piece->frc);
 367         return d + piece->content->position();
 368 }
 369
 370 Frame
 371 Player::dcp_to_resampled_audio (shared_ptr<const Piece> piece, DCPTime t) const
 372 {
 373         DCPTime s = t - piece->content->position ();
 374         s = min (piece->content->length_after_trim(), s);
 375         /* See notes in dcp_to_content_video */
 376         return max (DCPTime (), DCPTime (piece->content->trim_start (), piece->frc) + s).frames_floor (_film->audio_frame_rate ());
 377 }
 378
 379 DCPTime
 380 Player::resampled_audio_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 381 {
 382         /* See comment in dcp_to_content_video */
 383         return DCPTime::from_frames (f, _film->audio_frame_rate())
 384                 - DCPTime (piece->content->trim_start(), piece->frc)
 385                 + piece->content->position();
 386 }
 387
 388 ContentTime
 389 Player::dcp_to_content_time (shared_ptr<const Piece> piece, DCPTime t) const
 390 {
 391         DCPTime s = t - piece->content->position ();
 392         s = min (piece->content->length_after_trim(), s);
 393         return max (ContentTime (), ContentTime (s, piece->frc) + piece->content->trim_start());
 394 }
 395
 396 DCPTime
 397 Player::content_time_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
 398 {
 399         return max (DCPTime (), DCPTime (t - piece->content->trim_start(), piece->frc) + piece->content->position());
 400 }
 401
 402 list<shared_ptr<Font> >
 403 Player::get_subtitle_fonts ()
 404 {
 405         if (!_have_valid_pieces) {
 406                 setup_pieces ();
 407         }
 408
 409         list<shared_ptr<Font> > fonts;
 410         BOOST_FOREACH (shared_ptr<Piece>& p, _pieces) {
 411                 if (p->content->subtitle) {
 412                         /* XXX: things may go wrong if there are duplicate font IDs
 413                            with different font files.
 414                         */
 415                         list<shared_ptr<Font> > f = p->content->subtitle->fonts ();
 416                         copy (f.begin(), f.end(), back_inserter (fonts));
 417                 }
 418         }
 419
 420         return fonts;
 421 }
 422
 423 /** Set this player never to produce any video data */
 424 void
 425 Player::set_ignore_video ()
 426 {
 427         _ignore_video = true;
 428 }
 429
 430 void
 431 Player::set_ignore_subtitle ()
 432 {
 433         _ignore_subtitle = true;
 434 }
 435
 436 /** Set whether or not this player should always burn text subtitles into the image,
 437  *  regardless of the content settings.
 438  *  @param burn true to always burn subtitles, false to obey content settings.
 439  */
 440 void
 441 Player::set_always_burn_subtitles (bool burn)
 442 {
 443         _always_burn_subtitles = burn;
 444 }
 445
 446 /** Sets up the player to be faster, possibly at the expense of quality */
 447 void
 448 Player::set_fast ()
 449 {
 450         _fast = true;
 451         _have_valid_pieces = false;
 452 }
 453
 454 void
 455 Player::set_play_referenced ()
 456 {
 457         _play_referenced = true;
 458         _have_valid_pieces = false;
 459 }
 460
 461 list<ReferencedReelAsset>
 462 Player::get_reel_assets ()
 463 {
 464         list<ReferencedReelAsset> a;
 465
 466         BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
 467                 shared_ptr<DCPContent> j = dynamic_pointer_cast<DCPContent> (i);
 468                 if (!j) {
 469                         continue;
 470                 }
 471
 472                 scoped_ptr<DCPDecoder> decoder;
 473                 try {
 474                         decoder.reset (new DCPDecoder (j, _film->log(), false));
 475                 } catch (...) {
 476                         return a;
 477                 }
 478
 479                 int64_t offset = 0;
 480                 BOOST_FOREACH (shared_ptr<dcp::Reel> k, decoder->reels()) {
 481
 482                         DCPOMATIC_ASSERT (j->video_frame_rate ());
 483                         double const cfr = j->video_frame_rate().get();
 484                         Frame const trim_start = j->trim_start().frames_round (cfr);
 485                         Frame const trim_end = j->trim_end().frames_round (cfr);
 486                         int const ffr = _film->video_frame_rate ();
 487
 488                         DCPTime const from = i->position() + DCPTime::from_frames (offset, _film->video_frame_rate());
 489                         if (j->reference_video ()) {
 490                                 shared_ptr<dcp::ReelAsset> ra = k->main_picture ();
 491                                 DCPOMATIC_ASSERT (ra);
 492                                 ra->set_entry_point (ra->entry_point() + trim_start);
 493                                 ra->set_duration (ra->duration() - trim_start - trim_end);
 494                                 a.push_back (
 495                                         ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
 496                                         );
 497                         }
 498
 499                         if (j->reference_audio ()) {
 500                                 shared_ptr<dcp::ReelAsset> ra = k->main_sound ();
 501                                 DCPOMATIC_ASSERT (ra);
 502                                 ra->set_entry_point (ra->entry_point() + trim_start);
 503                                 ra->set_duration (ra->duration() - trim_start - trim_end);
 504                                 a.push_back (
 505                                         ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
 506                                         );
 507                         }
 508
 509                         if (j->reference_subtitle ()) {
 510                                 shared_ptr<dcp::ReelAsset> ra = k->main_subtitle ();
 511                                 DCPOMATIC_ASSERT (ra);
 512                                 ra->set_entry_point (ra->entry_point() + trim_start);
 513                                 ra->set_duration (ra->duration() - trim_start - trim_end);
 514                                 a.push_back (
 515                                         ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
 516                                         );
 517                         }
 518
 519                         /* Assume that main picture duration is the length of the reel */
 520                         offset += k->main_picture()->duration ();
 521                 }
 522         }
 523
 524         return a;
 525 }
 526
 527 bool
 528 Player::pass ()
 529 {
 530         if (!_have_valid_pieces) {
 531                 setup_pieces ();
 532         }
 533
 534         if (_playlist->length() == DCPTime()) {
 535                 /* Special case of an empty Film; just give one black frame */
 536                 emit_video (black_player_video_frame(EYES_BOTH), DCPTime());
 537                 return true;
 538         }
 539
 540         /* Find the decoder or empty which is farthest behind where we are and make it emit some data */
 541
 542         shared_ptr<Piece> earliest_content;
 543         optional<DCPTime> earliest_time;
 544
 545         BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 546                 if (i->done) {
 547                         continue;
 548                 }
 549
 550                 DCPTime const t = content_time_to_dcp (i, i->decoder->position());
 551                 if (t > i->content->end()) {
 552                         i->done = true;
 553                 } else {
 554
 555                         /* Given two choices at the same time, pick the one with a subtitle so we see it before
 556                            the video.
 557                         */
 558                         if (!earliest_time || t < *earliest_time || (t == *earliest_time && i->decoder->subtitle)) {
 559                                 earliest_time = t;
 560                                 earliest_content = i;
 561                         }
 562                 }
 563         }
 564
 565         bool done = false;
 566
 567         enum {
 568                 NONE,
 569                 CONTENT,
 570                 BLACK,
 571                 SILENT
 572         } which = NONE;
 573
 574         if (earliest_content) {
 575                 which = CONTENT;
 576         }
 577
 578         if (!_black.done() && (!earliest_time || _black.position() < *earliest_time)) {
 579                 earliest_time = _black.position ();
 580                 which = BLACK;
 581         }
 582
 583         if (!_silent.done() && (!earliest_time || _silent.position() < *earliest_time)) {
 584                 earliest_time = _silent.position ();
 585                 which = SILENT;
 586         }
 587
 588         switch (which) {
 589         case CONTENT:
 590                 earliest_content->done = earliest_content->decoder->pass ();
 591                 break;
 592         case BLACK:
 593                 emit_video (black_player_video_frame(EYES_BOTH), _black.position());
 594                 _black.set_position (_black.position() + one_video_frame());
 595                 break;
 596         case SILENT:
 597         {
 598                 DCPTimePeriod period (_silent.period_at_position());
 599                 if (_last_audio_time) {
 600                         /* Sometimes the thing that happened last finishes fractionally before
 601                            this silence.  Bodge the start time of the silence to fix it.  I'm
 602                            not sure if this is the right solution --- maybe the last thing should
 603                            be padded `forward' rather than this thing padding `back'.
 604                         */
 605                         period.from = min(period.from, *_last_audio_time);
 606                 }
 607                 if (period.duration() > one_video_frame()) {
 608                         period.to = period.from + one_video_frame();
 609                 }
 610                 fill_audio (period);
 611                 _silent.set_position (period.to);
 612                 break;
 613         }
 614         case NONE:
 615                 done = true;
 616                 break;
 617         }
 618
 619         /* Emit any audio that is ready */
 620
 621         /* Work out the time before which the audio is definitely all here.  This is the earliest last_push_end of one
 622            of our streams, or the position of the _silent.
 623         */
 624         DCPTime pull_to = _film->length ();
 625         for (map<AudioStreamPtr, StreamState>::const_iterator i = _stream_states.begin(); i != _stream_states.end(); ++i) {
 626                 if (!i->second.piece->done && i->second.last_push_end < pull_to) {
 627                         pull_to = i->second.last_push_end;
 628                 }
 629         }
 630         if (!_silent.done() && _silent.position() < pull_to) {
 631                 pull_to = _silent.position();
 632         }
 633
 634         list<pair<shared_ptr<AudioBuffers>, DCPTime> > audio = _audio_merger.pull (pull_to);
 635         for (list<pair<shared_ptr<AudioBuffers>, DCPTime> >::iterator i = audio.begin(); i != audio.end(); ++i) {
 636                 if (_last_audio_time && i->second < *_last_audio_time) {
 637                         /* This new data comes before the last we emitted (or the last seek); discard it */
 638                         pair<shared_ptr<AudioBuffers>, DCPTime> cut = discard_audio (i->first, i->second, *_last_audio_time);
 639                         if (!cut.first) {
 640                                 continue;
 641                         }
 642                         *i = cut;
 643                 } else if (_last_audio_time && i->second > *_last_audio_time) {
 644                         /* There's a gap between this data and the last we emitted; fill with silence */
 645                         fill_audio (DCPTimePeriod (*_last_audio_time, i->second));
 646                 }
 647
 648                 emit_audio (i->first, i->second);
 649         }
 650
 651         if (done) {
 652                 _shuffler->flush ();
 653                 for (list<pair<shared_ptr<PlayerVideo>, DCPTime> >::const_iterator i = _delay.begin(); i != _delay.end(); ++i) {
 654                         do_emit_video(i->first, i->second);
 655                 }
 656         }
 657
 658         return done;
 659 }
 660
 661 optional<PositionImage>
 662 Player::subtitles_for_frame (DCPTime time) const
 663 {
 664         list<PositionImage> subtitles;
 665
 666         int const vfr = _film->video_frame_rate();
 667
 668         BOOST_FOREACH (PlayerSubtitles i, _active_subtitles.get_burnt (DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_subtitles)) {
 669
 670                 /* Image subtitles */
 671                 list<PositionImage> c = transform_image_subtitles (i.image);
 672                 copy (c.begin(), c.end(), back_inserter (subtitles));
 673
 674                 /* Text subtitles (rendered to an image) */
 675                 if (!i.text.empty ()) {
 676                         list<PositionImage> s = render_subtitles (i.text, i.fonts, _video_container_size, time, vfr);
 677                         copy (s.begin(), s.end(), back_inserter (subtitles));
 678                 }
 679         }
 680
 681         if (subtitles.empty ()) {
 682                 return optional<PositionImage> ();
 683         }
 684
 685         return merge (subtitles);
 686 }
 687
 688 void
 689 Player::video (weak_ptr<Piece> wp, ContentVideo video)
 690 {
 691         shared_ptr<Piece> piece = wp.lock ();
 692         if (!piece) {
 693                 return;
 694         }
 695
 696         FrameRateChange frc(piece->content->active_video_frame_rate(), _film->video_frame_rate());
 697         if (frc.skip && (video.frame % 2) == 1) {
 698                 return;
 699         }
 700
 701         /* Time of the first frame we will emit */
 702         DCPTime const time = content_video_to_dcp (piece, video.frame);
 703
 704         /* Discard if it's before the content's period or the last accurate seek.  We can't discard
 705            if it's after the content's period here as in that case we still need to fill any gap between
 706            `now' and the end of the content's period.
 707         */
 708         if (time < piece->content->position() || (_last_video_time && time < *_last_video_time)) {
 709                 return;
 710         }
 711
 712         /* Fill gaps that we discover now that we have some video which needs to be emitted.
 713            This is where we need to fill to.
 714         */
 715         DCPTime fill_to = min (time, piece->content->end());
 716
 717         if (_last_video_time) {
 718                 DCPTime fill_from = max (*_last_video_time, piece->content->position());
 719                 LastVideoMap::const_iterator last = _last_video.find (wp);
 720                 if (_film->three_d()) {
 721                         DCPTime j = fill_from;
 722                         Eyes eyes = _last_video_eyes.get_value_or(EYES_LEFT);
 723                         if (eyes == EYES_BOTH) {
 724                                 eyes = EYES_LEFT;
 725                         }
 726                         while (j < fill_to || eyes != video.eyes) {
 727                                 if (last != _last_video.end()) {
 728                                         shared_ptr<PlayerVideo> copy = last->second->shallow_copy();
 729                                         copy->set_eyes (eyes);
 730                                         emit_video (copy, j);
 731                                 } else {
 732                                         emit_video (black_player_video_frame(eyes), j);
 733                                 }
 734                                 if (eyes == EYES_RIGHT) {
 735                                         j += one_video_frame();
 736                                 }
 737                                 eyes = increment_eyes (eyes);
 738                         }
 739                 } else {
 740                         for (DCPTime j = fill_from; j < fill_to; j += one_video_frame()) {
 741                                 if (last != _last_video.end()) {
 742                                         emit_video (last->second, j);
 743                                 } else {
 744                                         emit_video (black_player_video_frame(EYES_BOTH), j);
 745                                 }
 746                         }
 747                 }
 748         }
 749
 750         _last_video[wp].reset (
 751                 new PlayerVideo (
 752                         video.image,
 753                         piece->content->video->crop (),
 754                         piece->content->video->fade (video.frame),
 755                         piece->content->video->scale().size (
 756                                 piece->content->video, _video_container_size, _film->frame_size ()
 757                                 ),
 758                         _video_container_size,
 759                         video.eyes,
 760                         video.part,
 761                         piece->content->video->colour_conversion ()
 762                         )
 763                 );
 764
 765         DCPTime t = time;
 766         for (int i = 0; i < frc.repeat; ++i) {
 767                 if (t < piece->content->end()) {
 768                         emit_video (_last_video[wp], t);
 769                 }
 770                 t += one_video_frame ();
 771         }
 772 }
 773
 774 void
 775 Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
 776 {
 777         DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
 778
 779         shared_ptr<Piece> piece = wp.lock ();
 780         if (!piece) {
 781                 return;
 782         }
 783
 784         shared_ptr<AudioContent> content = piece->content->audio;
 785         DCPOMATIC_ASSERT (content);
 786
 787         /* Compute time in the DCP */
 788         DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame);
 789         /* And the end of this block in the DCP */
 790         DCPTime end = time + DCPTime::from_frames(content_audio.audio->frames(), content->resampled_frame_rate());
 791
 792         /* Remove anything that comes before the start or after the end of the content */
 793         if (time < piece->content->position()) {
 794                 pair<shared_ptr<AudioBuffers>, DCPTime> cut = discard_audio (content_audio.audio, time, piece->content->position());
 795                 if (!cut.first) {
 796                         /* This audio is entirely discarded */
 797                         return;
 798                 }
 799                 content_audio.audio = cut.first;
 800                 time = cut.second;
 801         } else if (time > piece->content->end()) {
 802                 /* Discard it all */
 803                 return;
 804         } else if (end > piece->content->end()) {
 805                 Frame const remaining_frames = DCPTime(piece->content->end() - time).frames_round(_film->audio_frame_rate());
 806                 if (remaining_frames == 0) {
 807                         return;
 808                 }
 809                 shared_ptr<AudioBuffers> cut (new AudioBuffers (content_audio.audio->channels(), remaining_frames));
 810                 cut->copy_from (content_audio.audio.get(), remaining_frames, 0, 0);
 811                 content_audio.audio = cut;
 812         }
 813
 814         DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
 815
 816         /* Gain */
 817
 818         if (content->gain() != 0) {
 819                 shared_ptr<AudioBuffers> gain (new AudioBuffers (content_audio.audio));
 820                 gain->apply_gain (content->gain ());
 821                 content_audio.audio = gain;
 822         }
 823
 824         /* Remap */
 825
 826         content_audio.audio = remap (content_audio.audio, _film->audio_channels(), stream->mapping());
 827
 828         /* Process */
 829
 830         if (_audio_processor) {
 831                 content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ());
 832         }
 833
 834         /* Push */
 835
 836         _audio_merger.push (content_audio.audio, time);
 837         DCPOMATIC_ASSERT (_stream_states.find (stream) != _stream_states.end ());
 838         _stream_states[stream].last_push_end = time + DCPTime::from_frames (content_audio.audio->frames(), _film->audio_frame_rate());
 839 }
 840
 841 void
 842 Player::image_subtitle_start (weak_ptr<Piece> wp, ContentImageSubtitle subtitle)
 843 {
 844         shared_ptr<Piece> piece = wp.lock ();
 845         if (!piece) {
 846                 return;
 847         }
 848
 849         /* Apply content's subtitle offsets */
 850         subtitle.sub.rectangle.x += piece->content->subtitle->x_offset ();
 851         subtitle.sub.rectangle.y += piece->content->subtitle->y_offset ();
 852
 853         /* Apply content's subtitle scale */
 854         subtitle.sub.rectangle.width *= piece->content->subtitle->x_scale ();
 855         subtitle.sub.rectangle.height *= piece->content->subtitle->y_scale ();
 856
 857         /* Apply a corrective translation to keep the subtitle centred after that scale */
 858         subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * (piece->content->subtitle->x_scale() - 1);
 859         subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * (piece->content->subtitle->y_scale() - 1);
 860
 861         PlayerSubtitles ps;
 862         ps.image.push_back (subtitle.sub);
 863         DCPTime from (content_time_to_dcp (piece, subtitle.from()));
 864
 865         _active_subtitles.add_from (wp, ps, from);
 866 }
 867
 868 void
 869 Player::text_subtitle_start (weak_ptr<Piece> wp, ContentTextSubtitle subtitle)
 870 {
 871         shared_ptr<Piece> piece = wp.lock ();
 872         if (!piece) {
 873                 return;
 874         }
 875
 876         PlayerSubtitles ps;
 877         DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
 878
 879         BOOST_FOREACH (dcp::SubtitleString s, subtitle.subs) {
 880                 s.set_h_position (s.h_position() + piece->content->subtitle->x_offset ());
 881                 s.set_v_position (s.v_position() + piece->content->subtitle->y_offset ());
 882                 float const xs = piece->content->subtitle->x_scale();
 883                 float const ys = piece->content->subtitle->y_scale();
 884                 float size = s.size();
 885
 886                 /* Adjust size to express the common part of the scaling;
 887                    e.g. if xs = ys = 0.5 we scale size by 2.
 888                 */
 889                 if (xs > 1e-5 && ys > 1e-5) {
 890                         size *= 1 / min (1 / xs, 1 / ys);
 891                 }
 892                 s.set_size (size);
 893
 894                 /* Then express aspect ratio changes */
 895                 if (fabs (1.0 - xs / ys) > dcp::ASPECT_ADJUST_EPSILON) {
 896                         s.set_aspect_adjust (xs / ys);
 897                 }
 898
 899                 s.set_in (dcp::Time(from.seconds(), 1000));
 900                 ps.text.push_back (SubtitleString (s, piece->content->subtitle->outline_width()));
 901                 ps.add_fonts (piece->content->subtitle->fonts ());
 902         }
 903
 904         _active_subtitles.add_from (wp, ps, from);
 905 }
 906
 907 void
 908 Player::subtitle_stop (weak_ptr<Piece> wp, ContentTime to)
 909 {
 910         if (!_active_subtitles.have (wp)) {
 911                 return;
 912         }
 913
 914         shared_ptr<Piece> piece = wp.lock ();
 915         if (!piece) {
 916                 return;
 917         }
 918
 919         DCPTime const dcp_to = content_time_to_dcp (piece, to);
 920
 921         pair<PlayerSubtitles, DCPTime> from = _active_subtitles.add_to (wp, dcp_to);
 922
 923         if (piece->content->subtitle->use() && !_always_burn_subtitles && !piece->content->subtitle->burn()) {
 924                 Subtitle (from.first, DCPTimePeriod (from.second, dcp_to));
 925         }
 926 }
 927
 928 void
 929 Player::seek (DCPTime time, bool accurate)
 930 {
 931         if (!_have_valid_pieces) {
 932                 setup_pieces ();
 933         }
 934
 935         if (_shuffler) {
 936                 _shuffler->clear ();
 937         }
 938
 939         _delay.clear ();
 940
 941         if (_audio_processor) {
 942                 _audio_processor->flush ();
 943         }
 944
 945         _audio_merger.clear ();
 946         _active_subtitles.clear ();
 947
 948         BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 949                 if (time < i->content->position()) {
 950                         /* Before; seek to 0 */
 951                         i->decoder->seek (ContentTime(), accurate);
 952                         i->done = false;
 953                 } else if (i->content->position() <= time && time < i->content->end()) {
 954                         /* During; seek to position */
 955                         i->decoder->seek (dcp_to_content_time (i, time), accurate);
 956                         i->done = false;
 957                 } else {
 958                         /* After; this piece is done */
 959                         i->done = true;
 960                 }
 961         }
 962
 963         if (accurate) {
 964                 _last_video_time = time;
 965                 _last_video_eyes = EYES_LEFT;
 966                 _last_audio_time = time;
 967         } else {
 968                 _last_video_time = optional<DCPTime>();
 969                 _last_video_eyes = optional<Eyes>();
 970                 _last_audio_time = optional<DCPTime>();
 971         }
 972
 973         _black.set_position (time);
 974         _silent.set_position (time);
 975
 976         _last_video.clear ();
 977 }
 978
 979 void
 980 Player::emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 981 {
 982         /* We need a delay to give a little wiggle room to ensure that relevent subtitles arrive at the
 983            player before the video that requires them.
 984         */
 985         _delay.push_back (make_pair (pv, time));
 986
 987         if (pv->eyes() == EYES_BOTH || pv->eyes() == EYES_RIGHT) {
 988                 _last_video_time = time + one_video_frame();
 989         }
 990         _last_video_eyes = increment_eyes (pv->eyes());
 991
 992         if (_delay.size() < 3) {
 993                 return;
 994         }
 995
 996         pair<shared_ptr<PlayerVideo>, DCPTime> to_do = _delay.front();
 997         _delay.pop_front();
 998         do_emit_video (to_do.first, to_do.second);
 999 }
1000
1001 void
1002 Player::do_emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
1003 {
1004         if (pv->eyes() == EYES_BOTH || pv->eyes() == EYES_RIGHT) {
1005                 _active_subtitles.clear_before (time);
1006         }
1007
1008         optional<PositionImage> subtitles = subtitles_for_frame (time);
1009         if (subtitles) {
1010                 pv->set_subtitle (subtitles.get ());
1011         }
1012
1013         Video (pv, time);
1014 }
1015
1016 void
1017 Player::emit_audio (shared_ptr<AudioBuffers> data, DCPTime time)
1018 {
1019         /* Log if the assert below is about to fail */
1020         if (_last_audio_time && time != *_last_audio_time) {
1021                 _film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_last_audio_time)), LogEntry::TYPE_WARNING);
1022         }
1023
1024         /* This audio must follow on from the previous */
1025         DCPOMATIC_ASSERT (!_last_audio_time || time == *_last_audio_time);
1026         Audio (data, time);
1027         _last_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate());
1028 }
1029
1030 void
1031 Player::fill_audio (DCPTimePeriod period)
1032 {
1033         if (period.from == period.to) {
1034                 return;
1035         }
1036
1037         DCPOMATIC_ASSERT (period.from < period.to);
1038
1039         DCPTime t = period.from;
1040         while (t < period.to) {
1041                 DCPTime block = min (DCPTime::from_seconds (0.5), period.to - t);
1042                 Frame const samples = block.frames_round(_film->audio_frame_rate());
1043                 if (samples) {
1044                         shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), samples));
1045                         silence->make_silent ();
1046                         emit_audio (silence, t);
1047                 }
1048                 t += block;
1049         }
1050 }
1051
1052 DCPTime
1053 Player::one_video_frame () const
1054 {
1055         return DCPTime::from_frames (1, _film->video_frame_rate ());
1056 }
1057
1058 pair<shared_ptr<AudioBuffers>, DCPTime>
1059 Player::discard_audio (shared_ptr<const AudioBuffers> audio, DCPTime time, DCPTime discard_to) const
1060 {
1061         DCPTime const discard_time = discard_to - time;
1062         Frame const discard_frames = discard_time.frames_round(_film->audio_frame_rate());
1063         Frame remaining_frames = audio->frames() - discard_frames;
1064         if (remaining_frames <= 0) {
1065                 return make_pair(shared_ptr<AudioBuffers>(), DCPTime());
1066         }
1067         shared_ptr<AudioBuffers> cut (new AudioBuffers (audio->channels(), remaining_frames));
1068         cut->copy_from (audio.get(), remaining_frames, discard_frames, 0);
1069         return make_pair(cut, time + discard_time);
1070 }
1071
1072 void
1073 Player::set_dcp_decode_reduction (optional<int> reduction)
1074 {
1075         if (reduction == _dcp_decode_reduction) {
1076                 return;
1077         }
1078
1079         _dcp_decode_reduction = reduction;
1080         _have_valid_pieces = false;
1081         Changed (false);
1082 }