src/lib/ffmpeg_decoder.cc

   1 /*
   2     Copyright (C) 2012 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 /** @file  src/ffmpeg_decoder.cc
  21  *  @brief A decoder using FFmpeg to decode content.
  22  */
  23
  24 #include <stdexcept>
  25 #include <vector>
  26 #include <sstream>
  27 #include <iomanip>
  28 #include <iostream>
  29 #include <stdint.h>
  30 #include <boost/lexical_cast.hpp>
  31 extern "C" {
  32 #include <tiffio.h>
  33 #include <libavcodec/avcodec.h>
  34 #include <libavformat/avformat.h>
  35 #include <libswscale/swscale.h>
  36 #include <libpostproc/postprocess.h>
  37 }
  38 #include <sndfile.h>
  39 #include "film.h"
  40 #include "format.h"
  41 #include "transcoder.h"
  42 #include "job.h"
  43 #include "filter.h"
  44 #include "options.h"
  45 #include "exceptions.h"
  46 #include "image.h"
  47 #include "util.h"
  48 #include "log.h"
  49 #include "ffmpeg_decoder.h"
  50 #include "filter_graph.h"
  51 #include "subtitle.h"
  52
  53 using std::cout;
  54 using std::string;
  55 using std::vector;
  56 using std::stringstream;
  57 using std::list;
  58 using boost::shared_ptr;
  59 using boost::optional;
  60 using boost::dynamic_pointer_cast;
  61 using libdcp::Size;
  62
  63 FFmpegDecoder::FFmpegDecoder (shared_ptr<Film> f, DecodeOptions o)
  64         : Decoder (f, o)
  65         , VideoDecoder (f, o)
  66         , AudioDecoder (f, o)
  67         , _format_context (0)
  68         , _video_stream (-1)
  69         , _frame (0)
  70         , _video_codec_context (0)
  71         , _video_codec (0)
  72         , _audio_codec_context (0)
  73         , _audio_codec (0)
  74         , _subtitle_codec_context (0)
  75         , _subtitle_codec (0)
  76 {
  77         setup_general ();
  78         setup_video ();
  79         setup_audio ();
  80         setup_subtitle ();
  81
  82         if (!o.video_sync) {
  83                 _first_video = 0;
  84         }
  85 }
  86
  87 FFmpegDecoder::~FFmpegDecoder ()
  88 {
  89         if (_audio_codec_context) {
  90                 avcodec_close (_audio_codec_context);
  91         }
  92
  93         if (_video_codec_context) {
  94                 avcodec_close (_video_codec_context);
  95         }
  96
  97         if (_subtitle_codec_context) {
  98                 avcodec_close (_subtitle_codec_context);
  99         }
 100
 101         av_free (_frame);
 102
 103         avformat_close_input (&_format_context);
 104 }
 105
 106 void
 107 FFmpegDecoder::setup_general ()
 108 {
 109         av_register_all ();
 110
 111         if (avformat_open_input (&_format_context, _film->content_path().c_str(), 0, 0) < 0) {
 112                 throw OpenFileError (_film->content_path ());
 113         }
 114
 115         if (avformat_find_stream_info (_format_context, 0) < 0) {
 116                 throw DecodeError ("could not find stream information");
 117         }
 118
 119         /* Find video, audio and subtitle streams and choose the first of each */
 120
 121         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 122                 AVStream* s = _format_context->streams[i];
 123                 if (s->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 124                         _video_stream = i;
 125                 } else if (s->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 126
 127                         /* This is a hack; sometimes it seems that _audio_codec_context->channel_layout isn't set up,
 128                            so bodge it here.  No idea why we should have to do this.
 129                         */
 130
 131                         if (s->codec->channel_layout == 0) {
 132                                 s->codec->channel_layout = av_get_default_channel_layout (s->codec->channels);
 133                         }
 134
 135                         _audio_streams.push_back (
 136                                 shared_ptr<AudioStream> (
 137                                         new FFmpegAudioStream (stream_name (s), i, s->codec->sample_rate, s->codec->channel_layout)
 138                                         )
 139                                 );
 140
 141                 } else if (s->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 142                         _subtitle_streams.push_back (
 143                                 shared_ptr<SubtitleStream> (
 144                                         new SubtitleStream (stream_name (s), i)
 145                                         )
 146                                 );
 147                 }
 148         }
 149
 150         if (_video_stream < 0) {
 151                 throw DecodeError ("could not find video stream");
 152         }
 153
 154         _frame = avcodec_alloc_frame ();
 155         if (_frame == 0) {
 156                 throw DecodeError ("could not allocate frame");
 157         }
 158 }
 159
 160 void
 161 FFmpegDecoder::setup_video ()
 162 {
 163         _video_codec_context = _format_context->streams[_video_stream]->codec;
 164         _video_codec = avcodec_find_decoder (_video_codec_context->codec_id);
 165
 166         if (_video_codec == 0) {
 167                 throw DecodeError ("could not find video decoder");
 168         }
 169
 170         if (avcodec_open2 (_video_codec_context, _video_codec, 0) < 0) {
 171                 throw DecodeError ("could not open video decoder");
 172         }
 173 }
 174
 175 void
 176 FFmpegDecoder::setup_audio ()
 177 {
 178         if (!_audio_stream) {
 179                 return;
 180         }
 181
 182         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 183         assert (ffa);
 184
 185         _audio_codec_context = _format_context->streams[ffa->id()]->codec;
 186         _audio_codec = avcodec_find_decoder (_audio_codec_context->codec_id);
 187
 188         if (_audio_codec == 0) {
 189                 throw DecodeError ("could not find audio decoder");
 190         }
 191
 192         if (avcodec_open2 (_audio_codec_context, _audio_codec, 0) < 0) {
 193                 throw DecodeError ("could not open audio decoder");
 194         }
 195 }
 196
 197 void
 198 FFmpegDecoder::setup_subtitle ()
 199 {
 200         if (!_subtitle_stream) {
 201                 return;
 202         }
 203
 204         _subtitle_codec_context = _format_context->streams[_subtitle_stream->id()]->codec;
 205         _subtitle_codec = avcodec_find_decoder (_subtitle_codec_context->codec_id);
 206
 207         if (_subtitle_codec == 0) {
 208                 throw DecodeError ("could not find subtitle decoder");
 209         }
 210
 211         if (avcodec_open2 (_subtitle_codec_context, _subtitle_codec, 0) < 0) {
 212                 throw DecodeError ("could not open subtitle decoder");
 213         }
 214 }
 215
 216
 217 bool
 218 FFmpegDecoder::pass ()
 219 {
 220         int r = av_read_frame (_format_context, &_packet);
 221
 222         if (r < 0) {
 223                 if (r != AVERROR_EOF) {
 224                         /* Maybe we should fail here, but for now we'll just finish off instead */
 225                         char buf[256];
 226                         av_strerror (r, buf, sizeof(buf));
 227                         _film->log()->log (String::compose ("error on av_read_frame (%1) (%2)", buf, r));
 228                 }
 229
 230                 /* Get any remaining frames */
 231
 232                 _packet.data = 0;
 233                 _packet.size = 0;
 234
 235                 /* XXX: should we reset _packet.data and size after each *_decode_* call? */
 236
 237                 int frame_finished;
 238
 239                 while (avcodec_decode_video2 (_video_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
 240                         filter_and_emit_video (_frame);
 241                 }
 242
 243                 if (_audio_stream && _opt.decode_audio) {
 244                         while (avcodec_decode_audio4 (_audio_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
 245                                 int const data_size = av_samples_get_buffer_size (
 246                                         0, _audio_codec_context->channels, _frame->nb_samples, audio_sample_format (), 1
 247                                         );
 248
 249                                 assert (_audio_codec_context->channels == _film->audio_channels());
 250                                 Audio (deinterleave_audio (_frame->data, data_size));
 251                         }
 252                 }
 253
 254                 return true;
 255         }
 256
 257         avcodec_get_frame_defaults (_frame);
 258
 259         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 260
 261         if (_packet.stream_index == _video_stream) {
 262
 263                 int frame_finished;
 264                 int const r = avcodec_decode_video2 (_video_codec_context, _frame, &frame_finished, &_packet);
 265                 if (r >= 0 && frame_finished) {
 266
 267                         if (r != _packet.size) {
 268                                 _film->log()->log (String::compose ("Used only %1 bytes of %2 in packet", r, _packet.size));
 269                         }
 270
 271                         if (_opt.video_sync) {
 272                                 out_with_sync ();
 273                         } else {
 274                                 filter_and_emit_video (_frame);
 275                         }
 276                 }
 277
 278         } else if (ffa && _packet.stream_index == ffa->id() && _opt.decode_audio) {
 279
 280                 int frame_finished;
 281                 if (avcodec_decode_audio4 (_audio_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
 282
 283                         /* Where we are in the source, in seconds */
 284                         double const source_pts_seconds = av_q2d (_format_context->streams[_packet.stream_index]->time_base)
 285                                 * av_frame_get_best_effort_timestamp(_frame);
 286
 287                         /* We only decode audio if we've had our first video packet through, and if it
 288                            was before this packet.  Until then audio is thrown away.
 289                         */
 290
 291                         if (_first_video && _first_video.get() <= source_pts_seconds) {
 292
 293                                 if (!_first_audio) {
 294                                         _first_audio = source_pts_seconds;
 295
 296                                         /* This is our first audio frame, and if we've arrived here we must have had our
 297                                            first video frame.  Push some silence to make up any gap between our first
 298                                            video frame and our first audio.
 299                                         */
 300
 301                                         /* frames of silence that we must push */
 302                                         int const s = rint ((_first_audio.get() - _first_video.get()) * ffa->sample_rate ());
 303
 304                                         _film->log()->log (
 305                                                 String::compose (
 306                                                         "First video at %1, first audio at %2, pushing %3 audio frames of silence for %4 channels (%5 bytes per sample)",
 307                                                         _first_video.get(), _first_audio.get(), s, ffa->channels(), bytes_per_audio_sample()
 308                                                         )
 309                                                 );
 310
 311                                         if (s) {
 312                                                 shared_ptr<AudioBuffers> audio (new AudioBuffers (ffa->channels(), s));
 313                                                 audio->make_silent ();
 314                                                 Audio (audio);
 315                                         }
 316                                 }
 317
 318                                 int const data_size = av_samples_get_buffer_size (
 319                                         0, _audio_codec_context->channels, _frame->nb_samples, audio_sample_format (), 1
 320                                         );
 321
 322                                 assert (_audio_codec_context->channels == _film->audio_channels());
 323                                 Audio (deinterleave_audio (_frame->data, data_size));
 324                         }
 325                 }
 326
 327         } else if (_subtitle_stream && _packet.stream_index == _subtitle_stream->id() && _opt.decode_subtitles && _first_video) {
 328
 329                 int got_subtitle;
 330                 AVSubtitle sub;
 331                 if (avcodec_decode_subtitle2 (_subtitle_codec_context, &sub, &got_subtitle, &_packet) && got_subtitle) {
 332                         /* Sometimes we get an empty AVSubtitle, which is used by some codecs to
 333                            indicate that the previous subtitle should stop.
 334                         */
 335                         if (sub.num_rects > 0) {
 336                                 shared_ptr<TimedSubtitle> ts;
 337                                 try {
 338                                         emit_subtitle (shared_ptr<TimedSubtitle> (new TimedSubtitle (sub)));
 339                                 } catch (...) {
 340                                         /* some problem with the subtitle; we probably didn't understand it */
 341                                 }
 342                         } else {
 343                                 emit_subtitle (shared_ptr<TimedSubtitle> ());
 344                         }
 345                         avsubtitle_free (&sub);
 346                 }
 347         }
 348
 349         av_free_packet (&_packet);
 350         return false;
 351 }
 352
 353 /** @param data pointer to array of pointers to buffers.
 354  *  Only the first buffer will be used for non-planar data, otherwise there will be one per channel.
 355  */
 356 shared_ptr<AudioBuffers>
 357 FFmpegDecoder::deinterleave_audio (uint8_t** data, int size)
 358 {
 359         assert (_film->audio_channels());
 360         assert (bytes_per_audio_sample());
 361
 362         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 363         assert (ffa);
 364
 365         /* Deinterleave and convert to float */
 366
 367         assert ((size % (bytes_per_audio_sample() * ffa->channels())) == 0);
 368
 369         int const total_samples = size / bytes_per_audio_sample();
 370         int const frames = total_samples / _film->audio_channels();
 371         shared_ptr<AudioBuffers> audio (new AudioBuffers (ffa->channels(), frames));
 372
 373         switch (audio_sample_format()) {
 374         case AV_SAMPLE_FMT_S16:
 375         {
 376                 int16_t* p = reinterpret_cast<int16_t *> (data[0]);
 377                 int sample = 0;
 378                 int channel = 0;
 379                 for (int i = 0; i < total_samples; ++i) {
 380                         audio->data(channel)[sample] = float(*p++) / (1 << 15);
 381
 382                         ++channel;
 383                         if (channel == _film->audio_channels()) {
 384                                 channel = 0;
 385                                 ++sample;
 386                         }
 387                 }
 388         }
 389         break;
 390
 391         case AV_SAMPLE_FMT_S16P:
 392         {
 393                 int16_t** p = reinterpret_cast<int16_t **> (data);
 394                 for (int i = 0; i < _film->audio_channels(); ++i) {
 395                         for (int j = 0; j < frames; ++j) {
 396                                 audio->data(i)[j] = static_cast<float>(p[i][j]) / (1 << 15);
 397                         }
 398                 }
 399         }
 400         break;
 401
 402         case AV_SAMPLE_FMT_S32:
 403         {
 404                 int32_t* p = reinterpret_cast<int32_t *> (data[0]);
 405                 int sample = 0;
 406                 int channel = 0;
 407                 for (int i = 0; i < total_samples; ++i) {
 408                         audio->data(channel)[sample] = static_cast<float>(*p++) / (1 << 31);
 409
 410                         ++channel;
 411                         if (channel == _film->audio_channels()) {
 412                                 channel = 0;
 413                                 ++sample;
 414                         }
 415                 }
 416         }
 417         break;
 418
 419         case AV_SAMPLE_FMT_FLT:
 420         {
 421                 float* p = reinterpret_cast<float*> (data[0]);
 422                 int sample = 0;
 423                 int channel = 0;
 424                 for (int i = 0; i < total_samples; ++i) {
 425                         audio->data(channel)[sample] = *p++;
 426
 427                         ++channel;
 428                         if (channel == _film->audio_channels()) {
 429                                 channel = 0;
 430                                 ++sample;
 431                         }
 432                 }
 433         }
 434         break;
 435
 436         case AV_SAMPLE_FMT_FLTP:
 437         {
 438                 float** p = reinterpret_cast<float**> (data);
 439                 for (int i = 0; i < _film->audio_channels(); ++i) {
 440                         memcpy (audio->data(i), p[i], frames * sizeof(float));
 441                 }
 442         }
 443         break;
 444
 445         default:
 446                 throw DecodeError (String::compose ("Unrecognised audio sample format (%1)", static_cast<int> (audio_sample_format())));
 447         }
 448
 449         return audio;
 450 }
 451
 452 float
 453 FFmpegDecoder::frames_per_second () const
 454 {
 455         AVStream* s = _format_context->streams[_video_stream];
 456
 457         if (s->avg_frame_rate.num && s->avg_frame_rate.den) {
 458                 return av_q2d (s->avg_frame_rate);
 459         }
 460
 461         return av_q2d (s->r_frame_rate);
 462 }
 463
 464 AVSampleFormat
 465 FFmpegDecoder::audio_sample_format () const
 466 {
 467         if (_audio_codec_context == 0) {
 468                 return (AVSampleFormat) 0;
 469         }
 470
 471         return _audio_codec_context->sample_fmt;
 472 }
 473
 474 libdcp::Size
 475 FFmpegDecoder::native_size () const
 476 {
 477         return libdcp::Size (_video_codec_context->width, _video_codec_context->height);
 478 }
 479
 480 PixelFormat
 481 FFmpegDecoder::pixel_format () const
 482 {
 483         return _video_codec_context->pix_fmt;
 484 }
 485
 486 int
 487 FFmpegDecoder::time_base_numerator () const
 488 {
 489         return _video_codec_context->time_base.num;
 490 }
 491
 492 int
 493 FFmpegDecoder::time_base_denominator () const
 494 {
 495         return _video_codec_context->time_base.den;
 496 }
 497
 498 int
 499 FFmpegDecoder::sample_aspect_ratio_numerator () const
 500 {
 501         return _video_codec_context->sample_aspect_ratio.num;
 502 }
 503
 504 int
 505 FFmpegDecoder::sample_aspect_ratio_denominator () const
 506 {
 507         return _video_codec_context->sample_aspect_ratio.den;
 508 }
 509
 510 string
 511 FFmpegDecoder::stream_name (AVStream* s) const
 512 {
 513         stringstream n;
 514
 515         AVDictionaryEntry const * lang = av_dict_get (s->metadata, "language", 0, 0);
 516         if (lang) {
 517                 n << lang->value;
 518         }
 519
 520         AVDictionaryEntry const * title = av_dict_get (s->metadata, "title", 0, 0);
 521         if (title) {
 522                 if (!n.str().empty()) {
 523                         n << " ";
 524                 }
 525                 n << title->value;
 526         }
 527
 528         if (n.str().empty()) {
 529                 n << "unknown";
 530         }
 531
 532         return n.str ();
 533 }
 534
 535 int
 536 FFmpegDecoder::bytes_per_audio_sample () const
 537 {
 538         return av_get_bytes_per_sample (audio_sample_format ());
 539 }
 540
 541 void
 542 FFmpegDecoder::set_audio_stream (shared_ptr<AudioStream> s)
 543 {
 544         AudioDecoder::set_audio_stream (s);
 545         setup_audio ();
 546 }
 547
 548 void
 549 FFmpegDecoder::set_subtitle_stream (shared_ptr<SubtitleStream> s)
 550 {
 551         VideoDecoder::set_subtitle_stream (s);
 552         setup_subtitle ();
 553         OutputChanged ();
 554 }
 555
 556 void
 557 FFmpegDecoder::filter_and_emit_video (AVFrame* frame)
 558 {
 559         boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 560
 561         shared_ptr<FilterGraph> graph;
 562
 563         list<shared_ptr<FilterGraph> >::iterator i = _filter_graphs.begin();
 564         while (i != _filter_graphs.end() && !(*i)->can_process (libdcp::Size (frame->width, frame->height), (AVPixelFormat) frame->format)) {
 565                 ++i;
 566         }
 567
 568         if (i == _filter_graphs.end ()) {
 569                 graph.reset (new FilterGraph (_film, this, libdcp::Size (frame->width, frame->height), (AVPixelFormat) frame->format));
 570                 _filter_graphs.push_back (graph);
 571                 _film->log()->log (String::compose ("New graph for %1x%2, pixel format %3", frame->width, frame->height, frame->format));
 572         } else {
 573                 graph = *i;
 574         }
 575
 576         list<shared_ptr<Image> > images = graph->process (frame);
 577
 578         for (list<shared_ptr<Image> >::iterator i = images.begin(); i != images.end(); ++i) {
 579                 emit_video (*i, frame_time ());
 580         }
 581 }
 582
 583 bool
 584 FFmpegDecoder::seek (double p)
 585 {
 586         return do_seek (p, false);
 587 }
 588
 589 bool
 590 FFmpegDecoder::seek_to_last ()
 591 {
 592         /* This AVSEEK_FLAG_BACKWARD in do_seek is a bit of a hack; without it, if we ask for a seek to the same place as last time
 593            (used when we change decoder parameters and want to re-fetch the frame) we end up going forwards rather than
 594            staying in the same place.
 595         */
 596         return do_seek (last_source_time(), true);
 597 }
 598
 599 bool
 600 FFmpegDecoder::do_seek (double p, bool backwards)
 601 {
 602         int64_t const vt = p / av_q2d (_format_context->streams[_video_stream]->time_base);
 603
 604         int const r = av_seek_frame (_format_context, _video_stream, vt, backwards ? AVSEEK_FLAG_BACKWARD : 0);
 605
 606         avcodec_flush_buffers (_video_codec_context);
 607         if (_subtitle_codec_context) {
 608                 avcodec_flush_buffers (_subtitle_codec_context);
 609         }
 610
 611         return r < 0;
 612 }
 613
 614 shared_ptr<FFmpegAudioStream>
 615 FFmpegAudioStream::create (string t, optional<int> v)
 616 {
 617         if (!v) {
 618                 /* version < 1; no type in the string, and there's only FFmpeg streams anyway */
 619                 return shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream (t, v));
 620         }
 621
 622         stringstream s (t);
 623         string type;
 624         s >> type;
 625         if (type != "ffmpeg") {
 626                 return shared_ptr<FFmpegAudioStream> ();
 627         }
 628
 629         return shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream (t, v));
 630 }
 631
 632 FFmpegAudioStream::FFmpegAudioStream (string t, optional<int> version)
 633 {
 634         stringstream n (t);
 635
 636         int name_index = 4;
 637         if (!version) {
 638                 name_index = 2;
 639                 int channels;
 640                 n >> _id >> channels;
 641                 _channel_layout = av_get_default_channel_layout (channels);
 642                 _sample_rate = 0;
 643         } else {
 644                 string type;
 645                 /* Current (marked version 1) */
 646                 n >> type >> _id >> _sample_rate >> _channel_layout;
 647                 assert (type == "ffmpeg");
 648         }
 649
 650         for (int i = 0; i < name_index; ++i) {
 651                 size_t const s = t.find (' ');
 652                 if (s != string::npos) {
 653                         t = t.substr (s + 1);
 654                 }
 655         }
 656
 657         _name = t;
 658 }
 659
 660 string
 661 FFmpegAudioStream::to_string () const
 662 {
 663         return String::compose ("ffmpeg %1 %2 %3 %4", _id, _sample_rate, _channel_layout, _name);
 664 }
 665
 666 void
 667 FFmpegDecoder::out_with_sync ()
 668 {
 669         /* Where we are in the output, in seconds */
 670         double const out_pts_seconds = video_frame() / frames_per_second();
 671
 672         /* Where we are in the source, in seconds */
 673         double const source_pts_seconds = av_q2d (_format_context->streams[_packet.stream_index]->time_base)
 674                 * av_frame_get_best_effort_timestamp(_frame);
 675
 676         _film->log()->log (
 677                 String::compose ("Source video frame ready; source at %1, output at %2", source_pts_seconds, out_pts_seconds),
 678                 Log::VERBOSE
 679                 );
 680
 681         if (!_first_video) {
 682                 _first_video = source_pts_seconds;
 683         }
 684
 685         /* Difference between where we are and where we should be */
 686         double const delta = source_pts_seconds - _first_video.get() - out_pts_seconds;
 687         double const one_frame = 1 / frames_per_second();
 688
 689         /* Insert frames if required to get out_pts_seconds up to pts_seconds */
 690         if (delta > one_frame) {
 691                 int const extra = rint (delta / one_frame);
 692                 for (int i = 0; i < extra; ++i) {
 693                         repeat_last_video ();
 694                         _film->log()->log (
 695                                 String::compose (
 696                                         "Extra video frame inserted at %1s; source frame %2, source PTS %3 (at %4 fps)",
 697                                         out_pts_seconds, video_frame(), source_pts_seconds, frames_per_second()
 698                                         )
 699                                 );
 700                 }
 701         }
 702
 703         if (delta > -one_frame) {
 704                 /* Process this frame */
 705                 filter_and_emit_video (_frame);
 706         } else {
 707                 /* Otherwise we are omitting a frame to keep things right */
 708                 _film->log()->log (String::compose ("Frame removed at %1s", out_pts_seconds));
 709         }
 710 }
 711
 712 void
 713 FFmpegDecoder::film_changed (Film::Property p)
 714 {
 715         switch (p) {
 716         case Film::CROP:
 717         case Film::FILTERS:
 718         {
 719                 boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 720                 _filter_graphs.clear ();
 721         }
 722         OutputChanged ();
 723         break;
 724
 725         default:
 726                 break;
 727         }
 728 }
 729
 730 /** @return Length (in video frames) according to our content's header */
 731 SourceFrame
 732 FFmpegDecoder::length () const
 733 {
 734         return (double(_format_context->duration) / AV_TIME_BASE) * frames_per_second();
 735 }
 736
 737 double
 738 FFmpegDecoder::frame_time () const
 739 {
 740         return av_frame_get_best_effort_timestamp(_frame) * av_q2d (_format_context->streams[_video_stream]->time_base);
 741 }
 742