src/lib/player.cc

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