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 "still_image_decoder.h"
  26 #include "still_image_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 "log.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<StillImageContent> (p.content)) {
  78                 s << "\tstill image";
  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->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, Eyes eyes, 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->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->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, eyes, same, time);
 246         time += TIME_HZ / _film->video_frame_rate();
 247
 248         if (frc.repeat) {
 249                 Video (work_image, eyes, true, time);
 250                 time += TIME_HZ / _film->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         /* Remap channels */
 268         shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), audio->frames()));
 269         dcp_mapped->make_silent ();
 270         list<pair<int, libdcp::Channel> > map = content->audio_mapping().content_to_dcp ();
 271         for (list<pair<int, libdcp::Channel> >::iterator i = map.begin(); i != map.end(); ++i) {
 272                 if (i->first < audio->channels() && i->second < dcp_mapped->channels()) {
 273                         dcp_mapped->accumulate_channel (audio.get(), i->first, i->second);
 274                 }
 275         }
 276
 277         audio = dcp_mapped;
 278
 279         Time time = content->start()
 280                 + _film->audio_frames_to_time (frame)
 281                 + (content->audio_delay() * TIME_HZ / 1000);
 282
 283         /* We must cut off anything that comes before the start of all time */
 284         if (time < 0) {
 285                 int const frames = - time * _film->audio_frame_rate() / TIME_HZ;
 286                 if (frames >= audio->frames ()) {
 287                         return;
 288                 }
 289
 290                 shared_ptr<AudioBuffers> trimmed (new AudioBuffers (audio->channels(), audio->frames() - frames));
 291                 trimmed->copy_from (audio.get(), audio->frames() - frames, frames, 0);
 292
 293                 audio = trimmed;
 294                 time = 0;
 295         }
 296
 297         /* The time of this audio may indicate that some of our buffered audio is not going to
 298            be added to any more, so it can be emitted.
 299         */
 300
 301         if (time > _audio_position) {
 302                 /* We can emit some audio from our buffers; this is how many frames */
 303                 OutputAudioFrame const N = _film->time_to_audio_frames (time - _audio_position);
 304                 if (N > _audio_buffers.frames()) {
 305                         /* We need some extra silence before whatever is in the buffers */
 306                         _audio_buffers.ensure_size (N);
 307                         _audio_buffers.move (0, N - _audio_buffers.frames(), _audio_buffers.frames ());
 308                         _audio_buffers.make_silent (0, _audio_buffers.frames());
 309                         _audio_buffers.set_frames (N);
 310                 }
 311                 assert (N <= _audio_buffers.frames());
 312
 313                 /* XXX: not convinced that a copy is necessary here */
 314                 shared_ptr<AudioBuffers> emit (new AudioBuffers (_audio_buffers.channels(), N));
 315                 emit->copy_from (&_audio_buffers, N, 0, 0);
 316                 Audio (emit, _audio_position);
 317                 _audio_position = piece->audio_position = _audio_position + _film->audio_frames_to_time (N);
 318
 319                 /* And remove it from our buffers */
 320                 if (_audio_buffers.frames() > N) {
 321                         _audio_buffers.move (N, 0, _audio_buffers.frames() - N);
 322                 }
 323                 _audio_buffers.set_frames (_audio_buffers.frames() - N);
 324         }
 325
 326         /* Now accumulate the new audio into our buffers */
 327         _audio_buffers.ensure_size (_audio_buffers.frames() + audio->frames());
 328         _audio_buffers.accumulate_frames (audio.get(), 0, 0, audio->frames ());
 329         _audio_buffers.set_frames (_audio_buffers.frames() + audio->frames());
 330 }
 331
 332 void
 333 Player::flush ()
 334 {
 335         if (_audio_buffers.frames() > 0) {
 336                 shared_ptr<AudioBuffers> emit (new AudioBuffers (_audio_buffers.channels(), _audio_buffers.frames()));
 337                 emit->copy_from (&_audio_buffers, _audio_buffers.frames(), 0, 0);
 338                 Audio (emit, _audio_position);
 339                 _audio_position += _film->audio_frames_to_time (_audio_buffers.frames ());
 340                 _audio_buffers.set_frames (0);
 341         }
 342
 343         while (_video_position < _audio_position) {
 344                 emit_black ();
 345         }
 346
 347         while (_audio_position < _video_position) {
 348                 emit_silence (_film->time_to_audio_frames (_video_position - _audio_position));
 349         }
 350
 351 }
 352
 353 /** Seek so that the next pass() will yield (approximately) the requested frame.
 354  *  Pass accurate = true to try harder to get close to the request.
 355  *  @return true on error
 356  */
 357 void
 358 Player::seek (Time t, bool accurate)
 359 {
 360         if (!_have_valid_pieces) {
 361                 setup_pieces ();
 362                 _have_valid_pieces = true;
 363         }
 364
 365         if (_pieces.empty ()) {
 366                 return;
 367         }
 368
 369         for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 370                 shared_ptr<VideoContent> vc = dynamic_pointer_cast<VideoContent> ((*i)->content);
 371                 if (!vc) {
 372                         continue;
 373                 }
 374
 375                 Time s = t - vc->start ();
 376                 s = max (static_cast<Time> (0), s);
 377                 s = min (vc->length(), s);
 378
 379                 (*i)->video_position = (*i)->audio_position = vc->start() + s;
 380
 381                 FrameRateConversion frc (vc->video_frame_rate(), _film->video_frame_rate());
 382                 /* Here we are converting from time (in the DCP) to a frame number in the content.
 383                    Hence we need to use the DCP's frame rate and the double/skip correction, not
 384                    the source's rate.
 385                 */
 386                 VideoContent::Frame f = s * _film->video_frame_rate() / (frc.factor() * TIME_HZ);
 387                 dynamic_pointer_cast<VideoDecoder>((*i)->decoder)->seek (f, accurate);
 388         }
 389
 390         _video_position = _audio_position = t;
 391
 392         /* XXX: don't seek audio because we don't need to... */
 393 }
 394
 395 void
 396 Player::setup_pieces ()
 397 {
 398         list<shared_ptr<Piece> > old_pieces = _pieces;
 399
 400         _pieces.clear ();
 401
 402         ContentList content = _playlist->content ();
 403         sort (content.begin(), content.end(), ContentSorter ());
 404
 405         for (ContentList::iterator i = content.begin(); i != content.end(); ++i) {
 406
 407                 shared_ptr<Piece> piece (new Piece (*i));
 408
 409                 /* XXX: into content? */
 410
 411                 shared_ptr<const FFmpegContent> fc = dynamic_pointer_cast<const FFmpegContent> (*i);
 412                 if (fc) {
 413                         shared_ptr<FFmpegDecoder> fd (new FFmpegDecoder (_film, fc, _video, _audio));
 414
 415                         fd->Video.connect (bind (&Player::process_video, this, piece, _1, _2, _3, _4));
 416                         fd->Audio.connect (bind (&Player::process_audio, this, piece, _1, _2));
 417                         fd->Subtitle.connect (bind (&Player::process_subtitle, this, piece, _1, _2, _3, _4));
 418
 419                         piece->decoder = fd;
 420                 }
 421
 422                 shared_ptr<const StillImageContent> ic = dynamic_pointer_cast<const StillImageContent> (*i);
 423                 if (ic) {
 424                         shared_ptr<StillImageDecoder> id;
 425
 426                         /* See if we can re-use an old StillImageDecoder */
 427                         for (list<shared_ptr<Piece> >::const_iterator j = old_pieces.begin(); j != old_pieces.end(); ++j) {
 428                                 shared_ptr<StillImageDecoder> imd = dynamic_pointer_cast<StillImageDecoder> ((*j)->decoder);
 429                                 if (imd && imd->content() == ic) {
 430                                         id = imd;
 431                                 }
 432                         }
 433
 434                         if (!id) {
 435                                 id.reset (new StillImageDecoder (_film, ic));
 436                                 id->Video.connect (bind (&Player::process_video, this, piece, _1, _2, _3, _4));
 437                         }
 438
 439                         piece->decoder = id;
 440                 }
 441
 442                 shared_ptr<const SndfileContent> sc = dynamic_pointer_cast<const SndfileContent> (*i);
 443                 if (sc) {
 444                         shared_ptr<AudioDecoder> sd (new SndfileDecoder (_film, sc));
 445                         sd->Audio.connect (bind (&Player::process_audio, this, piece, _1, _2));
 446
 447                         piece->decoder = sd;
 448                 }
 449
 450                 _pieces.push_back (piece);
 451         }
 452
 453 #ifdef DEBUG_PLAYER
 454         cout << "=== Player setup:\n";
 455         for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 456                 cout << *(i->get()) << "\n";
 457         }
 458 #endif
 459 }
 460
 461 void
 462 Player::content_changed (weak_ptr<Content> w, int property, bool frequent)
 463 {
 464         shared_ptr<Content> c = w.lock ();
 465         if (!c) {
 466                 return;
 467         }
 468
 469         if (
 470                 property == ContentProperty::START || property == ContentProperty::LENGTH ||
 471                 property == VideoContentProperty::VIDEO_CROP || property == VideoContentProperty::VIDEO_RATIO
 472                 ) {
 473
 474                 _have_valid_pieces = false;
 475                 Changed (frequent);
 476
 477         } else if (property == SubtitleContentProperty::SUBTITLE_OFFSET || property == SubtitleContentProperty::SUBTITLE_SCALE) {
 478                 update_subtitle ();
 479                 Changed (frequent);
 480         } else if (property == VideoContentProperty::VIDEO_FRAME_TYPE) {
 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 void
 501 Player::emit_black ()
 502 {
 503 #ifdef DCPOMATIC_DEBUG
 504         _last_video.reset ();
 505 #endif
 506
 507         /* XXX: use same here */
 508         Video (_black_frame, EYES_BOTH, false, _video_position);
 509         _video_position += _film->video_frames_to_time (1);
 510 }
 511
 512 void
 513 Player::emit_silence (OutputAudioFrame most)
 514 {
 515         OutputAudioFrame N = min (most, _film->audio_frame_rate() / 2);
 516         shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), N));
 517         silence->make_silent ();
 518         Audio (silence, _audio_position);
 519         _audio_position += _film->audio_frames_to_time (N);
 520 }
 521
 522 void
 523 Player::film_changed (Film::Property p)
 524 {
 525         /* Here we should notice Film properties that affect our output, and
 526            alert listeners that our output now would be different to how it was
 527            last time we were run.
 528         */
 529
 530         if (p == Film::SCALER || p == Film::WITH_SUBTITLES || p == Film::CONTAINER) {
 531                 Changed (false);
 532         }
 533 }
 534
 535 void
 536 Player::process_subtitle (weak_ptr<Piece> weak_piece, shared_ptr<Image> image, dcpomatic::Rect<double> rect, Time from, Time to)
 537 {
 538         _in_subtitle.piece = weak_piece;
 539         _in_subtitle.image = image;
 540         _in_subtitle.rect = rect;
 541         _in_subtitle.from = from;
 542         _in_subtitle.to = to;
 543
 544         update_subtitle ();
 545 }
 546
 547 void
 548 Player::update_subtitle ()
 549 {
 550         shared_ptr<Piece> piece = _in_subtitle.piece.lock ();
 551         if (!piece) {
 552                 return;
 553         }
 554
 555         if (!_in_subtitle.image) {
 556                 _out_subtitle.image.reset ();
 557                 return;
 558         }
 559
 560         shared_ptr<SubtitleContent> sc = dynamic_pointer_cast<SubtitleContent> (piece->content);
 561         assert (sc);
 562
 563         dcpomatic::Rect<double> in_rect = _in_subtitle.rect;
 564         libdcp::Size scaled_size;
 565
 566         in_rect.y += sc->subtitle_offset ();
 567
 568         /* We will scale the subtitle up to fit _video_container_size, and also by the additional subtitle_scale */
 569         scaled_size.width = in_rect.width * _video_container_size.width * sc->subtitle_scale ();
 570         scaled_size.height = in_rect.height * _video_container_size.height * sc->subtitle_scale ();
 571
 572         /* Then we need a corrective translation, consisting of two parts:
 573          *
 574          * 1.  that which is the result of the scaling of the subtitle by _video_container_size; this will be
 575          *     rect.x * _video_container_size.width and rect.y * _video_container_size.height.
 576          *
 577          * 2.  that to shift the origin of the scale by subtitle_scale to the centre of the subtitle; this will be
 578          *     (width_before_subtitle_scale * (1 - subtitle_scale) / 2) and
 579          *     (height_before_subtitle_scale * (1 - subtitle_scale) / 2).
 580          *
 581          * Combining these two translations gives these expressions.
 582          */
 583
 584         _out_subtitle.position.x = rint (_video_container_size.width * (in_rect.x + (in_rect.width * (1 - sc->subtitle_scale ()) / 2)));
 585         _out_subtitle.position.y = rint (_video_container_size.height * (in_rect.y + (in_rect.height * (1 - sc->subtitle_scale ()) / 2)));
 586
 587         _out_subtitle.image = _in_subtitle.image->scale (libdcp::Size (scaled_size.width, scaled_size.height), Scaler::from_id ("bicubic"), true);
 588         _out_subtitle.from = _in_subtitle.from + piece->content->start ();
 589         _out_subtitle.to = _in_subtitle.to + piece->content->start ();
 590 }