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, Job* j)
  64         : Decoder (f, o, j)
  65         , VideoDecoder (f, o, j)
  66         , AudioDecoder (f, o, j)
  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[0], 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[0], 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 shared_ptr<AudioBuffers>
 354 FFmpegDecoder::deinterleave_audio (uint8_t* data, int size)
 355 {
 356         assert (_film->audio_channels());
 357         assert (bytes_per_audio_sample());
 358
 359         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 360         assert (ffa);
 361
 362         /* Deinterleave and convert to float */
 363
 364         assert ((size % (bytes_per_audio_sample() * ffa->channels())) == 0);
 365
 366         int const total_samples = size / bytes_per_audio_sample();
 367         int const frames = total_samples / _film->audio_channels();
 368         shared_ptr<AudioBuffers> audio (new AudioBuffers (ffa->channels(), frames));
 369
 370         switch (audio_sample_format()) {
 371         case AV_SAMPLE_FMT_S16:
 372         {
 373                 int16_t* p = reinterpret_cast<int16_t *> (data);
 374                 int sample = 0;
 375                 int channel = 0;
 376                 for (int i = 0; i < total_samples; ++i) {
 377                         audio->data(channel)[sample] = float(*p++) / (1 << 15);
 378
 379                         ++channel;
 380                         if (channel == _film->audio_channels()) {
 381                                 channel = 0;
 382                                 ++sample;
 383                         }
 384                 }
 385         }
 386         break;
 387
 388         case AV_SAMPLE_FMT_S16P:
 389         {
 390                 int16_t* p = reinterpret_cast<int16_t *> (data);
 391                 for (int i = 0; i < _film->audio_channels(); ++i) {
 392                         for (int j = 0; j < frames; ++j) {
 393                                 audio->data(i)[j] = static_cast<float>(*p++) / (1 << 15);
 394                         }
 395                 }
 396         }
 397         break;
 398
 399         case AV_SAMPLE_FMT_S32:
 400         {
 401                 int32_t* p = reinterpret_cast<int32_t *> (data);
 402                 int sample = 0;
 403                 int channel = 0;
 404                 for (int i = 0; i < total_samples; ++i) {
 405                         audio->data(channel)[sample] = static_cast<float>(*p++) / (1 << 31);
 406
 407                         ++channel;
 408                         if (channel == _film->audio_channels()) {
 409                                 channel = 0;
 410                                 ++sample;
 411                         }
 412                 }
 413         }
 414         break;
 415
 416         case AV_SAMPLE_FMT_FLT:
 417         {
 418                 float* p = reinterpret_cast<float*> (data);
 419                 int sample = 0;
 420                 int channel = 0;
 421                 for (int i = 0; i < total_samples; ++i) {
 422                         audio->data(channel)[sample] = *p++;
 423
 424                         ++channel;
 425                         if (channel == _film->audio_channels()) {
 426                                 channel = 0;
 427                                 ++sample;
 428                         }
 429                 }
 430         }
 431         break;
 432
 433         case AV_SAMPLE_FMT_FLTP:
 434         {
 435                 float* p = reinterpret_cast<float*> (data);
 436                 for (int i = 0; i < _film->audio_channels(); ++i) {
 437                         memcpy (audio->data(i), p, frames * sizeof(float));
 438                         p += frames;
 439                 }
 440         }
 441         break;
 442
 443         default:
 444                 throw DecodeError (String::compose ("Unrecognised audio sample format (%1)", static_cast<int> (audio_sample_format())));
 445         }
 446
 447         return audio;
 448 }
 449
 450 float
 451 FFmpegDecoder::frames_per_second () const
 452 {
 453         AVStream* s = _format_context->streams[_video_stream];
 454
 455         if (s->avg_frame_rate.num && s->avg_frame_rate.den) {
 456                 return av_q2d (s->avg_frame_rate);
 457         }
 458
 459         return av_q2d (s->r_frame_rate);
 460 }
 461
 462 AVSampleFormat
 463 FFmpegDecoder::audio_sample_format () const
 464 {
 465         if (_audio_codec_context == 0) {
 466                 return (AVSampleFormat) 0;
 467         }
 468
 469         return _audio_codec_context->sample_fmt;
 470 }
 471
 472 libdcp::Size
 473 FFmpegDecoder::native_size () const
 474 {
 475         return libdcp::Size (_video_codec_context->width, _video_codec_context->height);
 476 }
 477
 478 PixelFormat
 479 FFmpegDecoder::pixel_format () const
 480 {
 481         return _video_codec_context->pix_fmt;
 482 }
 483
 484 int
 485 FFmpegDecoder::time_base_numerator () const
 486 {
 487         return _video_codec_context->time_base.num;
 488 }
 489
 490 int
 491 FFmpegDecoder::time_base_denominator () const
 492 {
 493         return _video_codec_context->time_base.den;
 494 }
 495
 496 int
 497 FFmpegDecoder::sample_aspect_ratio_numerator () const
 498 {
 499         return _video_codec_context->sample_aspect_ratio.num;
 500 }
 501
 502 int
 503 FFmpegDecoder::sample_aspect_ratio_denominator () const
 504 {
 505         return _video_codec_context->sample_aspect_ratio.den;
 506 }
 507
 508 string
 509 FFmpegDecoder::stream_name (AVStream* s) const
 510 {
 511         stringstream n;
 512
 513         AVDictionaryEntry const * lang = av_dict_get (s->metadata, "language", 0, 0);
 514         if (lang) {
 515                 n << lang->value;
 516         }
 517
 518         AVDictionaryEntry const * title = av_dict_get (s->metadata, "title", 0, 0);
 519         if (title) {
 520                 if (!n.str().empty()) {
 521                         n << " ";
 522                 }
 523                 n << title->value;
 524         }
 525
 526         if (n.str().empty()) {
 527                 n << "unknown";
 528         }
 529
 530         return n.str ();
 531 }
 532
 533 int
 534 FFmpegDecoder::bytes_per_audio_sample () const
 535 {
 536         return av_get_bytes_per_sample (audio_sample_format ());
 537 }
 538
 539 void
 540 FFmpegDecoder::set_audio_stream (shared_ptr<AudioStream> s)
 541 {
 542         AudioDecoder::set_audio_stream (s);
 543         setup_audio ();
 544 }
 545
 546 void
 547 FFmpegDecoder::set_subtitle_stream (shared_ptr<SubtitleStream> s)
 548 {
 549         VideoDecoder::set_subtitle_stream (s);
 550         setup_subtitle ();
 551         OutputChanged ();
 552 }
 553
 554 void
 555 FFmpegDecoder::filter_and_emit_video (AVFrame* frame)
 556 {
 557         boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 558
 559         shared_ptr<FilterGraph> graph;
 560
 561         list<shared_ptr<FilterGraph> >::iterator i = _filter_graphs.begin();
 562         while (i != _filter_graphs.end() && !(*i)->can_process (libdcp::Size (frame->width, frame->height), (AVPixelFormat) frame->format)) {
 563                 ++i;
 564         }
 565
 566         if (i == _filter_graphs.end ()) {
 567                 graph.reset (new FilterGraph (_film, this, libdcp::Size (frame->width, frame->height), (AVPixelFormat) frame->format));
 568                 _filter_graphs.push_back (graph);
 569                 _film->log()->log (String::compose ("New graph for %1x%2, pixel format %3", frame->width, frame->height, frame->format));
 570         } else {
 571                 graph = *i;
 572         }
 573
 574         list<shared_ptr<Image> > images = graph->process (frame);
 575
 576         for (list<shared_ptr<Image> >::iterator i = images.begin(); i != images.end(); ++i) {
 577                 emit_video (*i, frame_time ());
 578         }
 579 }
 580
 581 bool
 582 FFmpegDecoder::seek (double p)
 583 {
 584         return do_seek (p, false);
 585 }
 586
 587 bool
 588 FFmpegDecoder::seek_to_last ()
 589 {
 590         /* 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
 591            (used when we change decoder parameters and want to re-fetch the frame) we end up going forwards rather than
 592            staying in the same place.
 593         */
 594         return do_seek (last_source_time(), true);
 595 }
 596
 597 bool
 598 FFmpegDecoder::do_seek (double p, bool backwards)
 599 {
 600         int64_t const vt = p / av_q2d (_format_context->streams[_video_stream]->time_base);
 601
 602         int const r = av_seek_frame (_format_context, _video_stream, vt, backwards ? AVSEEK_FLAG_BACKWARD : 0);
 603
 604         avcodec_flush_buffers (_video_codec_context);
 605         if (_subtitle_codec_context) {
 606                 avcodec_flush_buffers (_subtitle_codec_context);
 607         }
 608
 609         return r < 0;
 610 }
 611
 612 shared_ptr<FFmpegAudioStream>
 613 FFmpegAudioStream::create (string t, optional<int> v)
 614 {
 615         if (!v) {
 616                 /* version < 1; no type in the string, and there's only FFmpeg streams anyway */
 617                 return shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream (t, v));
 618         }
 619
 620         stringstream s (t);
 621         string type;
 622         s >> type;
 623         if (type != "ffmpeg") {
 624                 return shared_ptr<FFmpegAudioStream> ();
 625         }
 626
 627         return shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream (t, v));
 628 }
 629
 630 FFmpegAudioStream::FFmpegAudioStream (string t, optional<int> version)
 631 {
 632         stringstream n (t);
 633
 634         int name_index = 4;
 635         if (!version) {
 636                 name_index = 2;
 637                 int channels;
 638                 n >> _id >> channels;
 639                 _channel_layout = av_get_default_channel_layout (channels);
 640                 _sample_rate = 0;
 641         } else {
 642                 string type;
 643                 /* Current (marked version 1) */
 644                 n >> type >> _id >> _sample_rate >> _channel_layout;
 645                 assert (type == "ffmpeg");
 646         }
 647
 648         for (int i = 0; i < name_index; ++i) {
 649                 size_t const s = t.find (' ');
 650                 if (s != string::npos) {
 651                         t = t.substr (s + 1);
 652                 }
 653         }
 654
 655         _name = t;
 656 }
 657
 658 string
 659 FFmpegAudioStream::to_string () const
 660 {
 661         return String::compose ("ffmpeg %1 %2 %3 %4", _id, _sample_rate, _channel_layout, _name);
 662 }
 663
 664 void
 665 FFmpegDecoder::out_with_sync ()
 666 {
 667         /* Where we are in the output, in seconds */
 668         double const out_pts_seconds = video_frame() / frames_per_second();
 669
 670         /* Where we are in the source, in seconds */
 671         double const source_pts_seconds = av_q2d (_format_context->streams[_packet.stream_index]->time_base)
 672                 * av_frame_get_best_effort_timestamp(_frame);
 673
 674         _film->log()->log (
 675                 String::compose ("Source video frame ready; source at %1, output at %2", source_pts_seconds, out_pts_seconds),
 676                 Log::VERBOSE
 677                 );
 678
 679         if (!_first_video) {
 680                 _first_video = source_pts_seconds;
 681         }
 682
 683         /* Difference between where we are and where we should be */
 684         double const delta = source_pts_seconds - _first_video.get() - out_pts_seconds;
 685         double const one_frame = 1 / frames_per_second();
 686
 687         /* Insert frames if required to get out_pts_seconds up to pts_seconds */
 688         if (delta > one_frame) {
 689                 int const extra = rint (delta / one_frame);
 690                 for (int i = 0; i < extra; ++i) {
 691                         repeat_last_video ();
 692                         _film->log()->log (
 693                                 String::compose (
 694                                         "Extra video frame inserted at %1s; source frame %2, source PTS %3 (at %4 fps)",
 695                                         out_pts_seconds, video_frame(), source_pts_seconds, frames_per_second()
 696                                         )
 697                                 );
 698                 }
 699         }
 700
 701         if (delta > -one_frame) {
 702                 /* Process this frame */
 703                 filter_and_emit_video (_frame);
 704         } else {
 705                 /* Otherwise we are omitting a frame to keep things right */
 706                 _film->log()->log (String::compose ("Frame removed at %1s", out_pts_seconds));
 707         }
 708 }
 709
 710 void
 711 FFmpegDecoder::film_changed (Film::Property p)
 712 {
 713         switch (p) {
 714         case Film::CROP:
 715         case Film::FILTERS:
 716         {
 717                 boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 718                 _filter_graphs.clear ();
 719         }
 720         OutputChanged ();
 721         break;
 722
 723         default:
 724                 break;
 725         }
 726 }
 727
 728 /** @return Length (in video frames) according to our content's header */
 729 SourceFrame
 730 FFmpegDecoder::length () const
 731 {
 732         return (double(_format_context->duration) / AV_TIME_BASE) * frames_per_second();
 733 }
 734
 735 double
 736 FFmpegDecoder::frame_time () const
 737 {
 738         return av_frame_get_best_effort_timestamp(_frame) * av_q2d (_format_context->streams[_video_stream]->time_base);
 739 }
 740