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