src/lib/player.cc

   1 /*
   2     Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <stdint.h>
  21 #include "player.h"
  22 #include "film.h"
  23 #include "ffmpeg_decoder.h"
  24 #include "ffmpeg_content.h"
  25 #include "imagemagick_decoder.h"
  26 #include "imagemagick_content.h"
  27 #include "sndfile_decoder.h"
  28 #include "sndfile_content.h"
  29 #include "subtitle_content.h"
  30 #include "playlist.h"
  31 #include "job.h"
  32 #include "image.h"
  33 #include "ratio.h"
  34 #include "resampler.h"
  35 #include "scaler.h"
  36
  37 using std::list;
  38 using std::cout;
  39 using std::min;
  40 using std::max;
  41 using std::vector;
  42 using std::pair;
  43 using std::map;
  44 using boost::shared_ptr;
  45 using boost::weak_ptr;
  46 using boost::dynamic_pointer_cast;
  47
  48 //#define DEBUG_PLAYER 1
  49
  50 class Piece
  51 {
  52 public:
  53         Piece (shared_ptr<Content> c)
  54                 : content (c)
  55                 , video_position (c->start ())
  56                 , audio_position (c->start ())
  57         {}
  58
  59         Piece (shared_ptr<Content> c, shared_ptr<Decoder> d)
  60                 : content (c)
  61                 , decoder (d)
  62                 , video_position (c->start ())
  63                 , audio_position (c->start ())
  64         {}
  65
  66         shared_ptr<Content> content;
  67         shared_ptr<Decoder> decoder;
  68         Time video_position;
  69         Time audio_position;
  70 };
  71
  72 #ifdef DEBUG_PLAYER
  73 std::ostream& operator<<(std::ostream& s, Piece const & p)
  74 {
  75         if (dynamic_pointer_cast<FFmpegContent> (p.content)) {
  76                 s << "\tffmpeg     ";
  77         } else if (dynamic_pointer_cast<ImageMagickContent> (p.content)) {
  78                 s << "\timagemagick";
  79         } else if (dynamic_pointer_cast<SndfileContent> (p.content)) {
  80                 s << "\tsndfile    ";
  81         }
  82
  83         s << " at " << p.content->start() << " until " << p.content->end();
  84
  85         return s;
  86 }
  87 #endif
  88
  89 Player::Player (shared_ptr<const Film> f, shared_ptr<const Playlist> p)
  90         : _film (f)
  91         , _playlist (p)
  92         , _video (true)
  93         , _audio (true)
  94         , _have_valid_pieces (false)
  95         , _video_position (0)
  96         , _audio_position (0)
  97         , _audio_buffers (f->dcp_audio_channels(), 0)
  98 {
  99         _playlist->Changed.connect (bind (&Player::playlist_changed, this));
 100         _playlist->ContentChanged.connect (bind (&Player::content_changed, this, _1, _2, _3));
 101         _film->Changed.connect (bind (&Player::film_changed, this, _1));
 102         set_video_container_size (_film->container()->size (_film->full_frame ()));
 103 }
 104
 105 void
 106 Player::disable_video ()
 107 {
 108         _video = false;
 109 }
 110
 111 void
 112 Player::disable_audio ()
 113 {
 114         _audio = false;
 115 }
 116
 117 bool
 118 Player::pass ()
 119 {
 120         if (!_have_valid_pieces) {
 121                 setup_pieces ();
 122                 _have_valid_pieces = true;
 123         }
 124
 125 #ifdef DEBUG_PLAYER
 126         cout << "= PASS\n";
 127 #endif
 128
 129         Time earliest_t = TIME_MAX;
 130         shared_ptr<Piece> earliest;
 131         enum {
 132                 VIDEO,
 133                 AUDIO
 134         } type = VIDEO;
 135
 136         for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 137                 if ((*i)->decoder->done ()) {
 138                         continue;
 139                 }
 140
 141                 if (_video && dynamic_pointer_cast<VideoDecoder> ((*i)->decoder)) {
 142                         if ((*i)->video_position < earliest_t) {
 143                                 earliest_t = (*i)->video_position;
 144                                 earliest = *i;
 145                                 type = VIDEO;
 146                         }
 147                 }
 148
 149                 if (_audio && dynamic_pointer_cast<AudioDecoder> ((*i)->decoder)) {
 150                         if ((*i)->audio_position < earliest_t) {
 151                                 earliest_t = (*i)->audio_position;
 152                                 earliest = *i;
 153                                 type = AUDIO;
 154                         }
 155                 }
 156         }
 157
 158         if (!earliest) {
 159 #ifdef DEBUG_PLAYER
 160                 cout << "no earliest piece.\n";
 161 #endif
 162
 163                 flush ();
 164                 return true;
 165         }
 166
 167         switch (type) {
 168         case VIDEO:
 169                 if (earliest_t > _video_position) {
 170 #ifdef DEBUG_PLAYER
 171                         cout << "no video here; emitting black frame (earliest=" << earliest_t << ", video_position=" << _video_position << ").\n";
 172 #endif
 173                         emit_black ();
 174                 } else {
 175 #ifdef DEBUG_PLAYER
 176                         cout << "Pass " << *earliest << "\n";
 177 #endif
 178                         earliest->decoder->pass ();
 179                 }
 180                 break;
 181
 182         case AUDIO:
 183                 if (earliest_t > _audio_position) {
 184 #ifdef DEBUG_PLAYER
 185                         cout << "no audio here; emitting silence.\n";
 186 #endif
 187                         emit_silence (_film->time_to_audio_frames (earliest_t - _audio_position));
 188                 } else {
 189 #ifdef DEBUG_PLAYER
 190                         cout << "Pass " << *earliest << "\n";
 191 #endif
 192                         earliest->decoder->pass ();
 193                 }
 194                 break;
 195         }
 196
 197 #ifdef DEBUG_PLAYER
 198         cout << "\tpost pass " << _video_position << " " << _audio_position << "\n";
 199 #endif
 200
 201         return false;
 202 }
 203
 204 void
 205 Player::process_video (weak_ptr<Piece> weak_piece, shared_ptr<const Image> image, bool same, VideoContent::Frame frame)
 206 {
 207         shared_ptr<Piece> piece = weak_piece.lock ();
 208         if (!piece) {
 209                 return;
 210         }
 211
 212         shared_ptr<VideoContent> content = dynamic_pointer_cast<VideoContent> (piece->content);
 213         assert (content);
 214
 215         FrameRateConversion frc (content->video_frame_rate(), _film->dcp_video_frame_rate());
 216         if (frc.skip && (frame % 2) == 1) {
 217                 return;
 218         }
 219
 220         shared_ptr<Image> work_image = image->crop (content->crop(), true);
 221
 222         libdcp::Size const image_size = content->ratio()->size (_video_container_size);
 223
 224         work_image = work_image->scale_and_convert_to_rgb (image_size, _film->scaler(), true);
 225
 226         Time time = content->start() + (frame * frc.factor() * TIME_HZ / _film->dcp_video_frame_rate());
 227
 228         if (_film->with_subtitles () && _out_subtitle.image && time >= _out_subtitle.from && time <= _out_subtitle.to) {
 229                 work_image->alpha_blend (_out_subtitle.image, _out_subtitle.position);
 230         }
 231
 232         if (image_size != _video_container_size) {
 233                 assert (image_size.width <= _video_container_size.width);
 234                 assert (image_size.height <= _video_container_size.height);
 235                 shared_ptr<Image> im (new Image (PIX_FMT_RGB24, _video_container_size, true));
 236                 im->make_black ();
 237                 im->copy (work_image, Position<int> ((_video_container_size.width - image_size.width) / 2, (_video_container_size.height - image_size.height) / 2));
 238                 work_image = im;
 239         }
 240
 241 #ifdef DCPOMATIC_DEBUG
 242         _last_video = piece->content;
 243 #endif
 244
 245         Video (work_image, same, time);
 246         time += TIME_HZ / _film->dcp_video_frame_rate();
 247
 248         if (frc.repeat) {
 249                 Video (work_image, true, time);
 250                 time += TIME_HZ / _film->dcp_video_frame_rate();
 251         }
 252
 253         _video_position = piece->video_position = time;
 254 }
 255
 256 void
 257 Player::process_audio (weak_ptr<Piece> weak_piece, shared_ptr<const AudioBuffers> audio, AudioContent::Frame frame)
 258 {
 259         shared_ptr<Piece> piece = weak_piece.lock ();
 260         if (!piece) {
 261                 return;
 262         }
 263
 264         shared_ptr<AudioContent> content = dynamic_pointer_cast<AudioContent> (piece->content);
 265         assert (content);
 266
 267         /* Resample */
 268         if (content->content_audio_frame_rate() != content->output_audio_frame_rate()) {
 269                 shared_ptr<Resampler> r = resampler (content);
 270                 audio = r->run (audio);
 271         }
 272
 273         /* Remap channels */
 274         shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->dcp_audio_channels(), audio->frames()));
 275         dcp_mapped->make_silent ();
 276         list<pair<int, libdcp::Channel> > map = content->audio_mapping().content_to_dcp ();
 277         for (list<pair<int, libdcp::Channel> >::iterator i = map.begin(); i != map.end(); ++i) {
 278                 if (i->first < audio->channels() && i->second < dcp_mapped->channels()) {
 279                         dcp_mapped->accumulate_channel (audio.get(), i->first, i->second);
 280                 }
 281         }
 282
 283         audio = dcp_mapped;
 284
 285         Time time = content->start() + (frame * TIME_HZ / _film->dcp_audio_frame_rate()) + (content->audio_delay() * TIME_HZ / 1000);
 286
 287         /* We must cut off anything that comes before the start of all time */
 288         if (time < 0) {
 289                 int const frames = - time * _film->dcp_audio_frame_rate() / TIME_HZ;
 290                 if (frames >= audio->frames ()) {
 291                         return;
 292                 }
 293
 294                 shared_ptr<AudioBuffers> trimmed (new AudioBuffers (audio->channels(), audio->frames() - frames));
 295                 trimmed->copy_from (audio.get(), audio->frames() - frames, frames, 0);
 296
 297                 audio = trimmed;
 298                 time = 0;
 299         }
 300
 301         /* The time of this audio may indicate that some of our buffered audio is not going to
 302            be added to any more, so it can be emitted.
 303         */
 304
 305         if (time > _audio_position) {
 306                 /* We can emit some audio from our buffers */
 307                 OutputAudioFrame const N = _film->time_to_audio_frames (time - _audio_position);
 308                 if (N > _audio_buffers.frames()) {
 309                         /* We need some extra silence before whatever is in the buffers */
 310                         _audio_buffers.ensure_size (N);
 311                         _audio_buffers.move (0, N - _audio_buffers.frames(), _audio_buffers.frames ());
 312                         _audio_buffers.make_silent (0, _audio_buffers.frames());
 313                         _audio_buffers.set_frames (N);
 314                 }
 315                 assert (N <= _audio_buffers.frames());
 316                 shared_ptr<AudioBuffers> emit (new AudioBuffers (_audio_buffers.channels(), N));
 317                 emit->copy_from (&_audio_buffers, N, 0, 0);
 318                 Audio (emit, _audio_position);
 319                 _audio_position = piece->audio_position = time + _film->audio_frames_to_time (N);
 320
 321                 /* And remove it from our buffers */
 322                 if (_audio_buffers.frames() > N) {
 323                         _audio_buffers.move (N, 0, _audio_buffers.frames() - N);
 324                 }
 325                 _audio_buffers.set_frames (_audio_buffers.frames() - N);
 326         }
 327
 328         /* Now accumulate the new audio into our buffers */
 329         _audio_buffers.ensure_size (_audio_buffers.frames() + audio->frames());
 330         _audio_buffers.accumulate_frames (audio.get(), 0, 0, audio->frames ());
 331         _audio_buffers.set_frames (_audio_buffers.frames() + audio->frames());
 332 }
 333
 334 void
 335 Player::flush ()
 336 {
 337         if (_audio_buffers.frames() > 0) {
 338                 shared_ptr<AudioBuffers> emit (new AudioBuffers (_audio_buffers.channels(), _audio_buffers.frames()));
 339                 emit->copy_from (&_audio_buffers, _audio_buffers.frames(), 0, 0);
 340                 Audio (emit, _audio_position);
 341                 _audio_position += _film->audio_frames_to_time (_audio_buffers.frames ());
 342                 _audio_buffers.set_frames (0);
 343         }
 344
 345         while (_video_position < _audio_position) {
 346                 emit_black ();
 347         }
 348
 349         while (_audio_position < _video_position) {
 350                 emit_silence (_film->time_to_audio_frames (_video_position - _audio_position));
 351         }
 352
 353 }
 354
 355 /** Seek so that the next pass() will yield (approximately) the requested frame.
 356  *  Pass accurate = true to try harder to get close to the request.
 357  *  @return true on error
 358  */
 359 void
 360 Player::seek (Time t, bool accurate)
 361 {
 362         if (!_have_valid_pieces) {
 363                 setup_pieces ();
 364                 _have_valid_pieces = true;
 365         }
 366
 367         if (_pieces.empty ()) {
 368                 return;
 369         }
 370
 371         for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 372                 shared_ptr<VideoContent> vc = dynamic_pointer_cast<VideoContent> ((*i)->content);
 373                 if (!vc) {
 374                         continue;
 375                 }
 376
 377                 Time s = t - vc->start ();
 378                 s = max (static_cast<Time> (0), s);
 379                 s = min (vc->length(), s);
 380
 381                 (*i)->video_position = (*i)->audio_position = vc->start() + s;
 382
 383                 FrameRateConversion frc (vc->video_frame_rate(), _film->dcp_video_frame_rate());
 384                 /* Here we are converting from time (in the DCP) to a frame number in the content.
 385                    Hence we need to use the DCP's frame rate and the double/skip correction, not
 386                    the source's rate.
 387                 */
 388                 VideoContent::Frame f = s * _film->dcp_video_frame_rate() / (frc.factor() * TIME_HZ);
 389                 dynamic_pointer_cast<VideoDecoder>((*i)->decoder)->seek (f, accurate);
 390         }
 391
 392         _video_position = _audio_position = t;
 393
 394         /* XXX: don't seek audio because we don't need to... */
 395 }
 396
 397 void
 398 Player::setup_pieces ()
 399 {
 400         list<shared_ptr<Piece> > old_pieces = _pieces;
 401
 402         _pieces.clear ();
 403
 404         Playlist::ContentList content = _playlist->content ();
 405         sort (content.begin(), content.end(), ContentSorter ());
 406
 407         for (Playlist::ContentList::iterator i = content.begin(); i != content.end(); ++i) {
 408
 409                 shared_ptr<Piece> piece (new Piece (*i));
 410
 411                 /* XXX: into content? */
 412
 413                 shared_ptr<const FFmpegContent> fc = dynamic_pointer_cast<const FFmpegContent> (*i);
 414                 if (fc) {
 415                         shared_ptr<FFmpegDecoder> fd (new FFmpegDecoder (_film, fc, _video, _audio));
 416
 417                         fd->Video.connect (bind (&Player::process_video, this, piece, _1, _2, _3));
 418                         fd->Audio.connect (bind (&Player::process_audio, this, piece, _1, _2));
 419                         fd->Subtitle.connect (bind (&Player::process_subtitle, this, piece, _1, _2, _3, _4));
 420
 421                         piece->decoder = fd;
 422                 }
 423
 424                 shared_ptr<const ImageMagickContent> ic = dynamic_pointer_cast<const ImageMagickContent> (*i);
 425                 if (ic) {
 426                         shared_ptr<ImageMagickDecoder> id;
 427
 428                         /* See if we can re-use an old ImageMagickDecoder */
 429                         for (list<shared_ptr<Piece> >::const_iterator j = old_pieces.begin(); j != old_pieces.end(); ++j) {
 430                                 shared_ptr<ImageMagickDecoder> imd = dynamic_pointer_cast<ImageMagickDecoder> ((*j)->decoder);
 431                                 if (imd && imd->content() == ic) {
 432                                         id = imd;
 433                                 }
 434                         }
 435
 436                         if (!id) {
 437                                 id.reset (new ImageMagickDecoder (_film, ic));
 438                                 id->Video.connect (bind (&Player::process_video, this, piece, _1, _2, _3));
 439                         }
 440
 441                         piece->decoder = id;
 442                 }
 443
 444                 shared_ptr<const SndfileContent> sc = dynamic_pointer_cast<const SndfileContent> (*i);
 445                 if (sc) {
 446                         shared_ptr<AudioDecoder> sd (new SndfileDecoder (_film, sc));
 447                         sd->Audio.connect (bind (&Player::process_audio, this, piece, _1, _2));
 448
 449                         piece->decoder = sd;
 450                 }
 451
 452                 _pieces.push_back (piece);
 453         }
 454
 455 #ifdef DEBUG_PLAYER
 456         cout << "=== Player setup:\n";
 457         for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 458                 cout << *(i->get()) << "\n";
 459         }
 460 #endif
 461 }
 462
 463 void
 464 Player::content_changed (weak_ptr<Content> w, int property, bool frequent)
 465 {
 466         shared_ptr<Content> c = w.lock ();
 467         if (!c) {
 468                 return;
 469         }
 470
 471         if (
 472                 property == ContentProperty::START || property == ContentProperty::LENGTH ||
 473                 property == VideoContentProperty::VIDEO_CROP || property == VideoContentProperty::VIDEO_RATIO
 474                 ) {
 475
 476                 _have_valid_pieces = false;
 477                 Changed (frequent);
 478
 479         } else if (property == SubtitleContentProperty::SUBTITLE_OFFSET || property == SubtitleContentProperty::SUBTITLE_SCALE) {
 480                 update_subtitle ();
 481                 Changed (frequent);
 482         }
 483 }
 484
 485 void
 486 Player::playlist_changed ()
 487 {
 488         _have_valid_pieces = false;
 489         Changed (false);
 490 }
 491
 492 void
 493 Player::set_video_container_size (libdcp::Size s)
 494 {
 495         _video_container_size = s;
 496         _black_frame.reset (new Image (PIX_FMT_RGB24, _video_container_size, true));
 497         _black_frame->make_black ();
 498 }
 499
 500 shared_ptr<Resampler>
 501 Player::resampler (shared_ptr<AudioContent> c)
 502 {
 503         map<shared_ptr<AudioContent>, shared_ptr<Resampler> >::iterator i = _resamplers.find (c);
 504         if (i != _resamplers.end ()) {
 505                 return i->second;
 506         }
 507
 508         shared_ptr<Resampler> r (new Resampler (c->content_audio_frame_rate(), c->output_audio_frame_rate(), c->audio_channels()));
 509         _resamplers[c] = r;
 510         return r;
 511 }
 512
 513 void
 514 Player::emit_black ()
 515 {
 516 #ifdef DCPOMATIC_DEBUG
 517         _last_video.reset ();
 518 #endif
 519
 520         /* XXX: use same here */
 521         Video (_black_frame, false, _video_position);
 522         _video_position += _film->video_frames_to_time (1);
 523 }
 524
 525 void
 526 Player::emit_silence (OutputAudioFrame most)
 527 {
 528         OutputAudioFrame N = min (most, _film->dcp_audio_frame_rate() / 2);
 529         shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->dcp_audio_channels(), N));
 530         silence->make_silent ();
 531         Audio (silence, _audio_position);
 532         _audio_position += _film->audio_frames_to_time (N);
 533 }
 534
 535 void
 536 Player::film_changed (Film::Property p)
 537 {
 538         /* Here we should notice Film properties that affect our output, and
 539            alert listeners that our output now would be different to how it was
 540            last time we were run.
 541         */
 542
 543         if (p == Film::SCALER || p == Film::WITH_SUBTITLES || p == Film::CONTAINER) {
 544                 Changed (false);
 545         }
 546 }
 547
 548 void
 549 Player::process_subtitle (weak_ptr<Piece> weak_piece, shared_ptr<Image> image, dcpomatic::Rect<double> rect, Time from, Time to)
 550 {
 551         _in_subtitle.piece = weak_piece;
 552         _in_subtitle.image = image;
 553         _in_subtitle.rect = rect;
 554         _in_subtitle.from = from;
 555         _in_subtitle.to = to;
 556
 557         update_subtitle ();
 558 }
 559
 560 void
 561 Player::update_subtitle ()
 562 {
 563         shared_ptr<Piece> piece = _in_subtitle.piece.lock ();
 564         if (!piece) {
 565                 return;
 566         }
 567
 568         if (!_in_subtitle.image) {
 569                 _out_subtitle.image.reset ();
 570                 return;
 571         }
 572
 573         shared_ptr<SubtitleContent> sc = dynamic_pointer_cast<SubtitleContent> (piece->content);
 574         assert (sc);
 575
 576         dcpomatic::Rect<double> in_rect = _in_subtitle.rect;
 577         libdcp::Size scaled_size;
 578
 579         in_rect.y += sc->subtitle_offset ();
 580
 581         /* We will scale the subtitle up to fit _video_container_size, and also by the additional subtitle_scale */
 582         scaled_size.width = in_rect.width * _video_container_size.width * sc->subtitle_scale ();
 583         scaled_size.height = in_rect.height * _video_container_size.height * sc->subtitle_scale ();
 584
 585         /* Then we need a corrective translation, consisting of two parts:
 586          *
 587          * 1.  that which is the result of the scaling of the subtitle by _video_container_size; this will be
 588          *     rect.x * _video_container_size.width and rect.y * _video_container_size.height.
 589          *
 590          * 2.  that to shift the origin of the scale by subtitle_scale to the centre of the subtitle; this will be
 591          *     (width_before_subtitle_scale * (1 - subtitle_scale) / 2) and
 592          *     (height_before_subtitle_scale * (1 - subtitle_scale) / 2).
 593          *
 594          * Combining these two translations gives these expressions.
 595          */
 596
 597         _out_subtitle.position.x = rint (_video_container_size.width * (in_rect.x + (in_rect.width * (1 - sc->subtitle_scale ()) / 2)));
 598         _out_subtitle.position.y = rint (_video_container_size.height * (in_rect.y + (in_rect.height * (1 - sc->subtitle_scale ()) / 2)));
 599
 600         _out_subtitle.image = _in_subtitle.image->scale (libdcp::Size (scaled_size.width, scaled_size.height), Scaler::from_id ("bicubic"), true);
 601         _out_subtitle.from = _in_subtitle.from + piece->content->start ();
 602         _out_subtitle.to = _in_subtitle.to + piece->content->start ();
 603 }