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 "compose.hpp"
  51 #include <dcp/reel.h>
  52 #include <dcp/reel_sound_asset.h>
  53 #include <dcp/reel_subtitle_asset.h>
  54 #include <dcp/reel_picture_asset.h>
  55 #include <boost/foreach.hpp>
  56 #include <stdint.h>
  57 #include <algorithm>
  58 #include <iostream>
  59
  60 #include "i18n.h"
  61
  62 #define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
  63
  64 using std::list;
  65 using std::cout;
  66 using std::min;
  67 using std::max;
  68 using std::min;
  69 using std::vector;
  70 using std::pair;
  71 using std::map;
  72 using std::make_pair;
  73 using std::copy;
  74 using boost::shared_ptr;
  75 using boost::weak_ptr;
  76 using boost::dynamic_pointer_cast;
  77 using boost::optional;
  78 using boost::scoped_ptr;
  79
  80 Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist)
  81         : _film (film)
  82         , _playlist (playlist)
  83         , _have_valid_pieces (false)
  84         , _ignore_video (false)
  85         , _ignore_subtitle (false)
  86         , _always_burn_subtitles (false)
  87         , _fast (false)
  88         , _play_referenced (false)
  89         , _audio_merger (_film->audio_frame_rate())
  90 {
  91         _film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1));
  92         _playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this));
  93         _playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Player::playlist_content_changed, this, _1, _2, _3));
  94         set_video_container_size (_film->frame_size ());
  95
  96         film_changed (Film::AUDIO_PROCESSOR);
  97
  98         seek (DCPTime (), true);
  99 }
 100
 101 void
 102 Player::setup_pieces ()
 103 {
 104         _pieces.clear ();
 105
 106         BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
 107
 108                 if (!i->paths_valid ()) {
 109                         continue;
 110                 }
 111
 112                 shared_ptr<Decoder> decoder = decoder_factory (i, _film->log(), _fast);
 113                 FrameRateChange frc (i->active_video_frame_rate(), _film->video_frame_rate());
 114
 115                 if (!decoder) {
 116                         /* Not something that we can decode; e.g. Atmos content */
 117                         continue;
 118                 }
 119
 120                 if (decoder->video && _ignore_video) {
 121                         decoder->video->set_ignore ();
 122                 }
 123
 124                 if (decoder->subtitle && _ignore_subtitle) {
 125                         decoder->subtitle->set_ignore ();
 126                 }
 127
 128                 shared_ptr<DCPDecoder> dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
 129                 if (dcp && _play_referenced) {
 130                         if (_play_referenced) {
 131                                 dcp->set_decode_referenced ();
 132                         }
 133                         dcp->set_forced_reduction (_dcp_decode_reduction);
 134                 }
 135
 136                 shared_ptr<Piece> piece (new Piece (i, decoder, frc));
 137                 _pieces.push_back (piece);
 138
 139                 if (decoder->video) {
 140                         decoder->video->Data.connect (bind (&Player::video, this, weak_ptr<Piece> (piece), _1));
 141                 }
 142
 143                 if (decoder->audio) {
 144                         decoder->audio->Data.connect (bind (&Player::audio, this, weak_ptr<Piece> (piece), _1, _2));
 145                 }
 146
 147                 if (decoder->subtitle) {
 148                         decoder->subtitle->ImageStart.connect (bind (&Player::image_subtitle_start, this, weak_ptr<Piece> (piece), _1));
 149                         decoder->subtitle->TextStart.connect (bind (&Player::text_subtitle_start, this, weak_ptr<Piece> (piece), _1));
 150                         decoder->subtitle->Stop.connect (bind (&Player::subtitle_stop, this, weak_ptr<Piece> (piece), _1));
 151                 }
 152         }
 153
 154         _stream_states.clear ();
 155         BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 156                 if (i->content->audio) {
 157                         BOOST_FOREACH (AudioStreamPtr j, i->content->audio->streams()) {
 158                                 _stream_states[j] = StreamState (i, i->content->position ());
 159                         }
 160                 }
 161         }
 162
 163         _black = Empty (_film->content(), _film->length(), bind(&Content::video, _1));
 164         _silent = Empty (_film->content(), _film->length(), bind(&Content::audio, _1));
 165
 166         _last_video_time = DCPTime ();
 167         _last_audio_time = DCPTime ();
 168         _have_valid_pieces = true;
 169 }
 170
 171 void
 172 Player::playlist_content_changed (weak_ptr<Content> w, int property, bool frequent)
 173 {
 174         shared_ptr<Content> c = w.lock ();
 175         if (!c) {
 176                 return;
 177         }
 178
 179         if (
 180                 property == ContentProperty::POSITION ||
 181                 property == ContentProperty::LENGTH ||
 182                 property == ContentProperty::TRIM_START ||
 183                 property == ContentProperty::TRIM_END ||
 184                 property == ContentProperty::PATH ||
 185                 property == VideoContentProperty::FRAME_TYPE ||
 186                 property == DCPContentProperty::NEEDS_ASSETS ||
 187                 property == DCPContentProperty::NEEDS_KDM ||
 188                 property == SubtitleContentProperty::COLOUR ||
 189                 property == SubtitleContentProperty::OUTLINE ||
 190                 property == SubtitleContentProperty::SHADOW ||
 191                 property == SubtitleContentProperty::EFFECT_COLOUR ||
 192                 property == FFmpegContentProperty::SUBTITLE_STREAM ||
 193                 property == VideoContentProperty::COLOUR_CONVERSION
 194                 ) {
 195
 196                 _have_valid_pieces = false;
 197                 Changed (frequent);
 198
 199         } else if (
 200                 property == SubtitleContentProperty::LINE_SPACING ||
 201                 property == SubtitleContentProperty::OUTLINE_WIDTH ||
 202                 property == SubtitleContentProperty::Y_SCALE ||
 203                 property == SubtitleContentProperty::FADE_IN ||
 204                 property == SubtitleContentProperty::FADE_OUT ||
 205                 property == ContentProperty::VIDEO_FRAME_RATE ||
 206                 property == SubtitleContentProperty::USE ||
 207                 property == SubtitleContentProperty::X_OFFSET ||
 208                 property == SubtitleContentProperty::Y_OFFSET ||
 209                 property == SubtitleContentProperty::X_SCALE ||
 210                 property == SubtitleContentProperty::FONTS ||
 211                 property == VideoContentProperty::CROP ||
 212                 property == VideoContentProperty::SCALE ||
 213                 property == VideoContentProperty::FADE_IN ||
 214                 property == VideoContentProperty::FADE_OUT
 215                 ) {
 216
 217                 Changed (frequent);
 218         }
 219 }
 220
 221 void
 222 Player::set_video_container_size (dcp::Size s)
 223 {
 224         if (s == _video_container_size) {
 225                 return;
 226         }
 227
 228         _video_container_size = s;
 229
 230         _black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true));
 231         _black_image->make_black ();
 232
 233         Changed (false);
 234 }
 235
 236 void
 237 Player::playlist_changed ()
 238 {
 239         _have_valid_pieces = false;
 240         Changed (false);
 241 }
 242
 243 void
 244 Player::film_changed (Film::Property p)
 245 {
 246         /* Here we should notice Film properties that affect our output, and
 247            alert listeners that our output now would be different to how it was
 248            last time we were run.
 249         */
 250
 251         if (p == Film::CONTAINER) {
 252                 Changed (false);
 253         } else if (p == Film::VIDEO_FRAME_RATE) {
 254                 /* Pieces contain a FrameRateChange which contains the DCP frame rate,
 255                    so we need new pieces here.
 256                 */
 257                 _have_valid_pieces = false;
 258                 Changed (false);
 259         } else if (p == Film::AUDIO_PROCESSOR) {
 260                 if (_film->audio_processor ()) {
 261                         _audio_processor = _film->audio_processor()->clone (_film->audio_frame_rate ());
 262                 }
 263         }
 264 }
 265
 266 list<PositionImage>
 267 Player::transform_image_subtitles (list<ImageSubtitle> subs) const
 268 {
 269         list<PositionImage> all;
 270
 271         for (list<ImageSubtitle>::const_iterator i = subs.begin(); i != subs.end(); ++i) {
 272                 if (!i->image) {
 273                         continue;
 274                 }
 275
 276                 /* We will scale the subtitle up to fit _video_container_size */
 277                 dcp::Size scaled_size (i->rectangle.width * _video_container_size.width, i->rectangle.height * _video_container_size.height);
 278
 279                 /* Then we need a corrective translation, consisting of two parts:
 280                  *
 281                  * 1.  that which is the result of the scaling of the subtitle by _video_container_size; this will be
 282                  *     rect.x * _video_container_size.width and rect.y * _video_container_size.height.
 283                  *
 284                  * 2.  that to shift the origin of the scale by subtitle_scale to the centre of the subtitle; this will be
 285                  *     (width_before_subtitle_scale * (1 - subtitle_x_scale) / 2) and
 286                  *     (height_before_subtitle_scale * (1 - subtitle_y_scale) / 2).
 287                  *
 288                  * Combining these two translations gives these expressions.
 289                  */
 290
 291                 all.push_back (
 292                         PositionImage (
 293                                 i->image->scale (
 294                                         scaled_size,
 295                                         dcp::YUV_TO_RGB_REC601,
 296                                         i->image->pixel_format (),
 297                                         true,
 298                                         _fast
 299                                         ),
 300                                 Position<int> (
 301                                         lrint (_video_container_size.width * i->rectangle.x),
 302                                         lrint (_video_container_size.height * i->rectangle.y)
 303                                         )
 304                                 )
 305                         );
 306         }
 307
 308         return all;
 309 }
 310
 311 shared_ptr<PlayerVideo>
 312 Player::black_player_video_frame () const
 313 {
 314         return shared_ptr<PlayerVideo> (
 315                 new PlayerVideo (
 316                         shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)),
 317                         Crop (),
 318                         optional<double> (),
 319                         _video_container_size,
 320                         _video_container_size,
 321                         EYES_BOTH,
 322                         PART_WHOLE,
 323                         PresetColourConversion::all().front().conversion
 324                 )
 325         );
 326 }
 327
 328 Frame
 329 Player::dcp_to_content_video (shared_ptr<const Piece> piece, DCPTime t) const
 330 {
 331         DCPTime s = t - piece->content->position ();
 332         s = min (piece->content->length_after_trim(), s);
 333         s = max (DCPTime(), s + DCPTime (piece->content->trim_start(), piece->frc));
 334
 335         /* It might seem more logical here to convert s to a ContentTime (using the FrameRateChange)
 336            then convert that ContentTime to frames at the content's rate.  However this fails for
 337            situations like content at 29.9978733fps, DCP at 30fps.  The accuracy of the Time type is not
 338            enough to distinguish between the two with low values of time (e.g. 3200 in Time units).
 339
 340            Instead we convert the DCPTime using the DCP video rate then account for any skip/repeat.
 341         */
 342         return s.frames_floor (piece->frc.dcp) / piece->frc.factor ();
 343 }
 344
 345 DCPTime
 346 Player::content_video_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 347 {
 348         /* See comment in dcp_to_content_video */
 349         DCPTime const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime (piece->content->trim_start (), piece->frc);
 350         return max (DCPTime (), d + piece->content->position ());
 351 }
 352
 353 Frame
 354 Player::dcp_to_resampled_audio (shared_ptr<const Piece> piece, DCPTime t) const
 355 {
 356         DCPTime s = t - piece->content->position ();
 357         s = min (piece->content->length_after_trim(), s);
 358         /* See notes in dcp_to_content_video */
 359         return max (DCPTime (), DCPTime (piece->content->trim_start (), piece->frc) + s).frames_floor (_film->audio_frame_rate ());
 360 }
 361
 362 DCPTime
 363 Player::resampled_audio_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 364 {
 365         /* See comment in dcp_to_content_video */
 366         return DCPTime::from_frames (f, _film->audio_frame_rate())
 367                 - DCPTime (piece->content->trim_start(), piece->frc)
 368                 + piece->content->position();
 369 }
 370
 371 ContentTime
 372 Player::dcp_to_content_time (shared_ptr<const Piece> piece, DCPTime t) const
 373 {
 374         DCPTime s = t - piece->content->position ();
 375         s = min (piece->content->length_after_trim(), s);
 376         return max (ContentTime (), ContentTime (s, piece->frc) + piece->content->trim_start());
 377 }
 378
 379 DCPTime
 380 Player::content_time_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
 381 {
 382         return max (DCPTime (), DCPTime (t - piece->content->trim_start(), piece->frc) + piece->content->position());
 383 }
 384
 385 list<shared_ptr<Font> >
 386 Player::get_subtitle_fonts ()
 387 {
 388         if (!_have_valid_pieces) {
 389                 setup_pieces ();
 390         }
 391
 392         list<shared_ptr<Font> > fonts;
 393         BOOST_FOREACH (shared_ptr<Piece>& p, _pieces) {
 394                 if (p->content->subtitle) {
 395                         /* XXX: things may go wrong if there are duplicate font IDs
 396                            with different font files.
 397                         */
 398                         list<shared_ptr<Font> > f = p->content->subtitle->fonts ();
 399                         copy (f.begin(), f.end(), back_inserter (fonts));
 400                 }
 401         }
 402
 403         return fonts;
 404 }
 405
 406 /** Set this player never to produce any video data */
 407 void
 408 Player::set_ignore_video ()
 409 {
 410         _ignore_video = true;
 411 }
 412
 413 void
 414 Player::set_ignore_subtitle ()
 415 {
 416         _ignore_subtitle = true;
 417 }
 418
 419 /** Set whether or not this player should always burn text subtitles into the image,
 420  *  regardless of the content settings.
 421  *  @param burn true to always burn subtitles, false to obey content settings.
 422  */
 423 void
 424 Player::set_always_burn_subtitles (bool burn)
 425 {
 426         _always_burn_subtitles = burn;
 427 }
 428
 429 /** Sets up the player to be faster, possibly at the expense of quality */
 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(), false));
 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         if (_playlist->length() == DCPTime()) {
 518                 /* Special case of an empty Film; just give one black frame */
 519                 emit_video (black_player_video_frame(), DCPTime());
 520                 return true;
 521         }
 522
 523         /* Find the decoder or empty which is farthest behind where we are and make it emit some data */
 524
 525         shared_ptr<Piece> earliest_content;
 526         optional<DCPTime> earliest_time;
 527
 528         BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 529                 if (!i->done) {
 530                         DCPTime const t = content_time_to_dcp (i, i->decoder->position());
 531                         /* Given two choices at the same time, pick the one with a subtitle so we see it before
 532                            the video.
 533                         */
 534                         if (!earliest_time || t < *earliest_time || (t == *earliest_time && i->decoder->subtitle)) {
 535                                 earliest_time = t;
 536                                 earliest_content = i;
 537                         }
 538                 }
 539         }
 540
 541         bool done = false;
 542
 543         enum {
 544                 NONE,
 545                 CONTENT,
 546                 BLACK,
 547                 SILENT
 548         } which = NONE;
 549
 550         if (earliest_content) {
 551                 which = CONTENT;
 552         }
 553
 554         if (!_black.done() && (!earliest_time || _black.position() < *earliest_time)) {
 555                 earliest_time = _black.position ();
 556                 which = BLACK;
 557         }
 558
 559         if (!_silent.done() && (!earliest_time || _silent.position() < *earliest_time)) {
 560                 earliest_time = _silent.position ();
 561                 which = SILENT;
 562         }
 563
 564         switch (which) {
 565         case CONTENT:
 566                 earliest_content->done = earliest_content->decoder->pass ();
 567                 break;
 568         case BLACK:
 569                 emit_video (black_player_video_frame(), _black.position());
 570                 _black.set_position (_black.position() + one_video_frame());
 571                 break;
 572         case SILENT:
 573         {
 574                 DCPTimePeriod period (_silent.period_at_position());
 575                 if (period.duration() > one_video_frame()) {
 576                         period.to = period.from + one_video_frame();
 577                 }
 578                 fill_audio (period);
 579                 _silent.set_position (period.to);
 580                 break;
 581         }
 582         case NONE:
 583                 done = true;
 584                 break;
 585         }
 586
 587         /* Emit any audio that is ready */
 588
 589         DCPTime pull_to = _film->length ();
 590         for (map<AudioStreamPtr, StreamState>::const_iterator i = _stream_states.begin(); i != _stream_states.end(); ++i) {
 591                 if (!i->second.piece->done && i->second.last_push_end < pull_to) {
 592                         pull_to = i->second.last_push_end;
 593                 }
 594         }
 595
 596         list<pair<shared_ptr<AudioBuffers>, DCPTime> > audio = _audio_merger.pull (pull_to);
 597         for (list<pair<shared_ptr<AudioBuffers>, DCPTime> >::iterator i = audio.begin(); i != audio.end(); ++i) {
 598                 if (_last_audio_time && i->second < *_last_audio_time) {
 599                         /* This new data comes before the last we emitted (or the last seek); discard it */
 600                         pair<shared_ptr<AudioBuffers>, DCPTime> cut = discard_audio (i->first, i->second, *_last_audio_time);
 601                         if (!cut.first) {
 602                                 continue;
 603                         }
 604                         *i = cut;
 605                 } else if (_last_audio_time && i->second > *_last_audio_time) {
 606                         /* There's a gap between this data and the last we emitted; fill with silence */
 607                         fill_audio (DCPTimePeriod (*_last_audio_time, i->second));
 608                 }
 609
 610                 emit_audio (i->first, i->second);
 611         }
 612
 613         return done;
 614 }
 615
 616 optional<PositionImage>
 617 Player::subtitles_for_frame (DCPTime time) const
 618 {
 619         list<PositionImage> subtitles;
 620
 621         BOOST_FOREACH (PlayerSubtitles i, _active_subtitles.get_burnt (time, _always_burn_subtitles)) {
 622
 623                 /* Image subtitles */
 624                 list<PositionImage> c = transform_image_subtitles (i.image);
 625                 copy (c.begin(), c.end(), back_inserter (subtitles));
 626
 627                 /* Text subtitles (rendered to an image) */
 628                 if (!i.text.empty ()) {
 629                         list<PositionImage> s = render_subtitles (i.text, i.fonts, _video_container_size, time);
 630                         copy (s.begin(), s.end(), back_inserter (subtitles));
 631                 }
 632         }
 633
 634         if (subtitles.empty ()) {
 635                 return optional<PositionImage> ();
 636         }
 637
 638         return merge (subtitles);
 639 }
 640
 641 bool
 642 Player::video (weak_ptr<Piece> wp, ContentVideo video)
 643 {
 644         shared_ptr<Piece> piece = wp.lock ();
 645         if (!piece) {
 646                 return false;
 647         }
 648
 649         FrameRateChange frc(piece->content->active_video_frame_rate(), _film->video_frame_rate());
 650         if (frc.skip && (video.frame % 2) == 1) {
 651                 return false;
 652         }
 653
 654         /* Time of the first frame we will emit */
 655         DCPTime const time = content_video_to_dcp (piece, video.frame);
 656
 657         /* Discard if it's outside the content's period or if it's before the last accurate seek */
 658         if (
 659                 time < piece->content->position() ||
 660                 time >= piece->content->end() ||
 661                 (_last_video_time && time < *_last_video_time)) {
 662                 return false;
 663         }
 664
 665         /* Fill gaps that we discover now that we have some video which needs to be emitted */
 666
 667         if (_last_video_time) {
 668                 /* XXX: this may not work for 3D */
 669                 DCPTime fill_from = max (*_last_video_time, piece->content->position());
 670                 for (DCPTime j = fill_from; j < time; j += one_video_frame()) {
 671                         LastVideoMap::const_iterator k = _last_video.find (wp);
 672                         if (k != _last_video.end ()) {
 673                                 emit_video (k->second, j);
 674                         } else {
 675                                 emit_video (black_player_video_frame(), j);
 676                         }
 677                 }
 678         }
 679
 680         _last_video[wp].reset (
 681                 new PlayerVideo (
 682                         video.image,
 683                         piece->content->video->crop (),
 684                         piece->content->video->fade (video.frame),
 685                         piece->content->video->scale().size (
 686                                 piece->content->video, _video_container_size, _film->frame_size ()
 687                                 ),
 688                         _video_container_size,
 689                         video.eyes,
 690                         video.part,
 691                         piece->content->video->colour_conversion ()
 692                         )
 693                 );
 694
 695         DCPTime t = time;
 696         for (int i = 0; i < frc.repeat; ++i) {
 697                 emit_video (_last_video[wp], t);
 698                 t += one_video_frame ();
 699         }
 700
 701         return true;
 702 }
 703
 704 /** @return Number of input frames that were `accepted'.  This is the number of frames passed in
 705  *  unless some were discarded at the end of the block.
 706  */
 707 Frame
 708 Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
 709 {
 710         DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
 711
 712         shared_ptr<Piece> piece = wp.lock ();
 713         if (!piece) {
 714                 return 0;
 715         }
 716
 717         shared_ptr<AudioContent> content = piece->content->audio;
 718         DCPOMATIC_ASSERT (content);
 719
 720         /* Compute time in the DCP */
 721         DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame);
 722         /* And the end of this block in the DCP */
 723         DCPTime end = time + DCPTime::from_frames(content_audio.audio->frames(), content->resampled_frame_rate());
 724
 725         /* We consider frames trimmed off the beginning to nevertheless be `accepted'; it's only frames trimmed
 726            off the end that are considered as discarded.  This logic is necessary to ensure correct reel lengths,
 727            although the precise details escape me at the moment.
 728         */
 729         Frame accepted = content_audio.audio->frames();
 730
 731         /* Remove anything that comes before the start or after the end of the content */
 732         if (time < piece->content->position()) {
 733                 pair<shared_ptr<AudioBuffers>, DCPTime> cut = discard_audio (content_audio.audio, time, piece->content->position());
 734                 if (!cut.first) {
 735                         /* This audio is entirely discarded */
 736                         return accepted;
 737                 }
 738                 content_audio.audio = cut.first;
 739                 time = cut.second;
 740         } else if (time > piece->content->end()) {
 741                 /* Discard it all */
 742                 return 0;
 743         } else if (end > piece->content->end()) {
 744                 Frame const remaining_frames = DCPTime(piece->content->end() - time).frames_round(_film->audio_frame_rate());
 745                 if (remaining_frames == 0) {
 746                         return 0;
 747                 }
 748                 shared_ptr<AudioBuffers> cut (new AudioBuffers (content_audio.audio->channels(), remaining_frames));
 749                 cut->copy_from (content_audio.audio.get(), remaining_frames, 0, 0);
 750                 content_audio.audio = cut;
 751                 accepted = content_audio.audio->frames();
 752         }
 753
 754         DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
 755
 756         /* Gain */
 757
 758         if (content->gain() != 0) {
 759                 shared_ptr<AudioBuffers> gain (new AudioBuffers (content_audio.audio));
 760                 gain->apply_gain (content->gain ());
 761                 content_audio.audio = gain;
 762         }
 763
 764         /* Remap */
 765
 766         content_audio.audio = remap (content_audio.audio, _film->audio_channels(), stream->mapping());
 767
 768         /* Process */
 769
 770         if (_audio_processor) {
 771                 content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ());
 772         }
 773
 774         /* Push */
 775
 776         _audio_merger.push (content_audio.audio, time);
 777         DCPOMATIC_ASSERT (_stream_states.find (stream) != _stream_states.end ());
 778         _stream_states[stream].last_push_end = time + DCPTime::from_frames (content_audio.audio->frames(), _film->audio_frame_rate());
 779         return accepted;
 780 }
 781
 782 void
 783 Player::image_subtitle_start (weak_ptr<Piece> wp, ContentImageSubtitle subtitle)
 784 {
 785         shared_ptr<Piece> piece = wp.lock ();
 786         if (!piece) {
 787                 return;
 788         }
 789
 790         /* Apply content's subtitle offsets */
 791         subtitle.sub.rectangle.x += piece->content->subtitle->x_offset ();
 792         subtitle.sub.rectangle.y += piece->content->subtitle->y_offset ();
 793
 794         /* Apply content's subtitle scale */
 795         subtitle.sub.rectangle.width *= piece->content->subtitle->x_scale ();
 796         subtitle.sub.rectangle.height *= piece->content->subtitle->y_scale ();
 797
 798         /* Apply a corrective translation to keep the subtitle centred after that scale */
 799         subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * (piece->content->subtitle->x_scale() - 1);
 800         subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * (piece->content->subtitle->y_scale() - 1);
 801
 802         PlayerSubtitles ps;
 803         ps.image.push_back (subtitle.sub);
 804         DCPTime from (content_time_to_dcp (piece, subtitle.from()));
 805
 806         _active_subtitles.add_from (wp, ps, from);
 807 }
 808
 809 void
 810 Player::text_subtitle_start (weak_ptr<Piece> wp, ContentTextSubtitle subtitle)
 811 {
 812         shared_ptr<Piece> piece = wp.lock ();
 813         if (!piece) {
 814                 return;
 815         }
 816
 817         PlayerSubtitles ps;
 818         DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
 819
 820         BOOST_FOREACH (dcp::SubtitleString s, subtitle.subs) {
 821                 s.set_h_position (s.h_position() + piece->content->subtitle->x_offset ());
 822                 s.set_v_position (s.v_position() + piece->content->subtitle->y_offset ());
 823                 float const xs = piece->content->subtitle->x_scale();
 824                 float const ys = piece->content->subtitle->y_scale();
 825                 float size = s.size();
 826
 827                 /* Adjust size to express the common part of the scaling;
 828                    e.g. if xs = ys = 0.5 we scale size by 2.
 829                 */
 830                 if (xs > 1e-5 && ys > 1e-5) {
 831                         size *= 1 / min (1 / xs, 1 / ys);
 832                 }
 833                 s.set_size (size);
 834
 835                 /* Then express aspect ratio changes */
 836                 if (fabs (1.0 - xs / ys) > dcp::ASPECT_ADJUST_EPSILON) {
 837                         s.set_aspect_adjust (xs / ys);
 838                 }
 839
 840                 s.set_in (dcp::Time(from.seconds(), 1000));
 841                 ps.text.push_back (SubtitleString (s, piece->content->subtitle->outline_width()));
 842                 ps.add_fonts (piece->content->subtitle->fonts ());
 843         }
 844
 845         _active_subtitles.add_from (wp, ps, from);
 846 }
 847
 848 void
 849 Player::subtitle_stop (weak_ptr<Piece> wp, ContentTime to)
 850 {
 851         if (!_active_subtitles.have (wp)) {
 852                 return;
 853         }
 854
 855         shared_ptr<Piece> piece = wp.lock ();
 856         if (!piece) {
 857                 return;
 858         }
 859
 860         DCPTime const dcp_to = content_time_to_dcp (piece, to);
 861
 862         pair<PlayerSubtitles, DCPTime> from = _active_subtitles.add_to (wp, dcp_to);
 863
 864         if (piece->content->subtitle->use() && !_always_burn_subtitles && !piece->content->subtitle->burn()) {
 865                 Subtitle (from.first, DCPTimePeriod (from.second, dcp_to));
 866         }
 867 }
 868
 869 void
 870 Player::seek (DCPTime time, bool accurate)
 871 {
 872         if (!_have_valid_pieces) {
 873                 setup_pieces ();
 874         }
 875
 876         if (_audio_processor) {
 877                 _audio_processor->flush ();
 878         }
 879
 880         _audio_merger.clear ();
 881         _active_subtitles.clear ();
 882
 883         BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 884                 if (time < i->content->position()) {
 885                         /* Before; seek to 0 */
 886                         i->decoder->seek (ContentTime(), accurate);
 887                         i->done = false;
 888                 } else if (i->content->position() <= time && time < i->content->end()) {
 889                         /* During; seek to position */
 890                         i->decoder->seek (dcp_to_content_time (i, time), accurate);
 891                         i->done = false;
 892                 } else {
 893                         /* After; this piece is done */
 894                         i->done = true;
 895                 }
 896         }
 897
 898         if (accurate) {
 899                 _last_video_time = time;
 900                 _last_audio_time = time;
 901         } else {
 902                 _last_video_time = optional<DCPTime>();
 903                 _last_audio_time = optional<DCPTime>();
 904         }
 905
 906         _black.set_position (time);
 907         _silent.set_position (time);
 908
 909         _last_video.clear ();
 910 }
 911
 912 void
 913 Player::emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 914 {
 915         optional<PositionImage> subtitles = subtitles_for_frame (time);
 916         if (subtitles) {
 917                 pv->set_subtitle (subtitles.get ());
 918         }
 919
 920         Video (pv, time);
 921
 922         if (pv->eyes() == EYES_BOTH || pv->eyes() == EYES_RIGHT) {
 923                 _last_video_time = time + one_video_frame();
 924                 _active_subtitles.clear_before (time);
 925         }
 926 }
 927
 928 void
 929 Player::emit_audio (shared_ptr<AudioBuffers> data, DCPTime time)
 930 {
 931         Audio (data, time);
 932         _last_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate());
 933 }
 934
 935 void
 936 Player::fill_audio (DCPTimePeriod period)
 937 {
 938         if (period.from == period.to) {
 939                 return;
 940         }
 941
 942         DCPOMATIC_ASSERT (period.from < period.to);
 943
 944         DCPTime t = period.from;
 945         while (t < period.to) {
 946                 DCPTime block = min (DCPTime::from_seconds (0.5), period.to - t);
 947                 Frame const samples = block.frames_round(_film->audio_frame_rate());
 948                 if (samples) {
 949                         shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), samples));
 950                         silence->make_silent ();
 951                         emit_audio (silence, t);
 952                 }
 953                 t += block;
 954         }
 955 }
 956
 957 DCPTime
 958 Player::one_video_frame () const
 959 {
 960         return DCPTime::from_frames (1, _film->video_frame_rate ());
 961 }
 962
 963 pair<shared_ptr<AudioBuffers>, DCPTime>
 964 Player::discard_audio (shared_ptr<const AudioBuffers> audio, DCPTime time, DCPTime discard_to) const
 965 {
 966         DCPTime const discard_time = discard_to - time;
 967         Frame const discard_frames = discard_time.frames_round(_film->audio_frame_rate());
 968         Frame remaining_frames = audio->frames() - discard_frames;
 969         if (remaining_frames <= 0) {
 970                 return make_pair(shared_ptr<AudioBuffers>(), DCPTime());
 971         }
 972         shared_ptr<AudioBuffers> cut (new AudioBuffers (audio->channels(), remaining_frames));
 973         cut->copy_from (audio.get(), remaining_frames, discard_frames, 0);
 974         return make_pair(cut, time + discard_time);
 975 }
 976
 977 void
 978 Player::set_dcp_decode_reduction (optional<int> reduction)
 979 {
 980         if (reduction == _dcp_decode_reduction) {
 981                 return;
 982         }
 983
 984         _dcp_decode_reduction = reduction;
 985         _have_valid_pieces = false;
 986         Changed (false);
 987 }