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
  62 FFmpegDecoder::FFmpegDecoder (shared_ptr<Film> f, shared_ptr<const Options> o, Job* j)
  63         : Decoder (f, o, j)
  64         , VideoDecoder (f, o, j)
  65         , AudioDecoder (f, o, j)
  66         , _format_context (0)
  67         , _video_stream (-1)
  68         , _frame (0)
  69         , _video_codec_context (0)
  70         , _video_codec (0)
  71         , _audio_codec_context (0)
  72         , _audio_codec (0)
  73         , _subtitle_codec_context (0)
  74         , _subtitle_codec (0)
  75 {
  76         setup_general ();
  77         setup_video ();
  78         setup_audio ();
  79         setup_subtitle ();
  80 }
  81
  82 FFmpegDecoder::~FFmpegDecoder ()
  83 {
  84         if (_audio_codec_context) {
  85                 avcodec_close (_audio_codec_context);
  86         }
  87
  88         if (_video_codec_context) {
  89                 avcodec_close (_video_codec_context);
  90         }
  91
  92         if (_subtitle_codec_context) {
  93                 avcodec_close (_subtitle_codec_context);
  94         }
  95
  96         av_free (_frame);
  97
  98         avformat_close_input (&_format_context);
  99 }
 100
 101 void
 102 FFmpegDecoder::setup_general ()
 103 {
 104         int r;
 105
 106         av_register_all ();
 107
 108         if ((r = avformat_open_input (&_format_context, _film->content_path().c_str(), 0, 0)) != 0) {
 109                 throw OpenFileError (_film->content_path ());
 110         }
 111
 112         if (avformat_find_stream_info (_format_context, 0) < 0) {
 113                 throw DecodeError ("could not find stream information");
 114         }
 115
 116         /* Find video, audio and subtitle streams and choose the first of each */
 117
 118         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 119                 AVStream* s = _format_context->streams[i];
 120                 if (s->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 121                         _video_stream = i;
 122                 } else if (s->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 123                         _audio_streams.push_back (
 124                                 shared_ptr<AudioStream> (
 125                                         new FFmpegAudioStream (stream_name (s), i, s->codec->sample_rate, s->codec->channel_layout)
 126                                         )
 127                                 );
 128                 } else if (s->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 129                         _subtitle_streams.push_back (
 130                                 shared_ptr<SubtitleStream> (
 131                                         new SubtitleStream (stream_name (s), i)
 132                                         )
 133                                 );
 134                 }
 135         }
 136
 137         if (_video_stream < 0) {
 138                 throw DecodeError ("could not find video stream");
 139         }
 140
 141         _frame = avcodec_alloc_frame ();
 142         if (_frame == 0) {
 143                 throw DecodeError ("could not allocate frame");
 144         }
 145 }
 146
 147 void
 148 FFmpegDecoder::setup_video ()
 149 {
 150         _video_codec_context = _format_context->streams[_video_stream]->codec;
 151         _video_codec = avcodec_find_decoder (_video_codec_context->codec_id);
 152
 153         if (_video_codec == 0) {
 154                 throw DecodeError ("could not find video decoder");
 155         }
 156
 157         /* I think this prevents problems with green hash on decodes and
 158            "changing frame properties on the fly is not supported by all filters"
 159            messages with some content.  Although I'm not sure; needs checking.
 160         */
 161         AVDictionary* opts = 0;
 162         av_dict_set (&opts, "threads", "1", 0);
 163
 164         if (avcodec_open2 (_video_codec_context, _video_codec, &opts) < 0) {
 165                 throw DecodeError ("could not open video decoder");
 166         }
 167 }
 168
 169 void
 170 FFmpegDecoder::setup_audio ()
 171 {
 172         if (!_audio_stream) {
 173                 return;
 174         }
 175
 176         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 177         assert (ffa);
 178
 179         _audio_codec_context = _format_context->streams[ffa->id()]->codec;
 180         _audio_codec = avcodec_find_decoder (_audio_codec_context->codec_id);
 181
 182         if (_audio_codec == 0) {
 183                 throw DecodeError ("could not find audio decoder");
 184         }
 185
 186         if (avcodec_open2 (_audio_codec_context, _audio_codec, 0) < 0) {
 187                 throw DecodeError ("could not open audio decoder");
 188         }
 189
 190         /* This is a hack; sometimes it seems that _audio_codec_context->channel_layout isn't set up,
 191            so bodge it here.  No idea why we should have to do this.
 192         */
 193
 194         if (_audio_codec_context->channel_layout == 0) {
 195                 _audio_codec_context->channel_layout = av_get_default_channel_layout (ffa->channels());
 196         }
 197 }
 198
 199 void
 200 FFmpegDecoder::setup_subtitle ()
 201 {
 202         if (!_subtitle_stream) {
 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 ("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 ("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                 while (avcodec_decode_video2 (_video_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
 242                         filter_and_emit_video (_frame);
 243                 }
 244
 245                 if (_audio_stream && _opt->decode_audio) {
 246                         while (avcodec_decode_audio4 (_audio_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
 247                                 int const data_size = av_samples_get_buffer_size (
 248                                         0, _audio_codec_context->channels, _frame->nb_samples, audio_sample_format (), 1
 249                                         );
 250
 251                                 assert (_audio_codec_context->channels == _film->audio_channels());
 252                                 Audio (deinterleave_audio (_frame->data[0], data_size));
 253                         }
 254                 }
 255
 256                 return true;
 257         }
 258
 259         avcodec_get_frame_defaults (_frame);
 260
 261         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 262
 263         if (_packet.stream_index == _video_stream) {
 264
 265                 int frame_finished;
 266                 int const r = avcodec_decode_video2 (_video_codec_context, _frame, &frame_finished, &_packet);
 267                 if (r >= 0 && frame_finished) {
 268
 269                         if (r != _packet.size) {
 270                                 _film->log()->log (String::compose ("Used only %1 bytes of %2 in packet", r, _packet.size));
 271                         }
 272
 273                         /* Where we are in the output, in seconds */
 274                         double const out_pts_seconds = video_frame() / frames_per_second();
 275
 276                         /* Where we are in the source, in seconds */
 277                         double const source_pts_seconds = av_q2d (_format_context->streams[_packet.stream_index]->time_base)
 278                                 * av_frame_get_best_effort_timestamp(_frame);
 279
 280                         _film->log()->log (
 281                                 String::compose ("Source video frame ready; source at %1, output at %2", source_pts_seconds, out_pts_seconds),
 282                                 Log::DEBUG
 283                                 );
 284
 285                         if (!_first_video) {
 286                                 _first_video = source_pts_seconds;
 287                         }
 288
 289                         /* Difference between where we are and where we should be */
 290                         double const delta = source_pts_seconds - _first_video.get() - out_pts_seconds;
 291                         double const one_frame = 1 / frames_per_second();
 292
 293                         /* Insert frames if required to get out_pts_seconds up to pts_seconds */
 294                         if (delta > one_frame) {
 295                                 int const extra = rint (delta / one_frame);
 296                                 for (int i = 0; i < extra; ++i) {
 297                                         repeat_last_video ();
 298                                         _film->log()->log (
 299                                                 String::compose (
 300                                                         "Extra video frame inserted at %1s; source frame %2, source PTS %3 (at %4 fps)",
 301                                                         out_pts_seconds, video_frame(), source_pts_seconds, frames_per_second()
 302                                                         )
 303                                                 );
 304                                 }
 305                         }
 306
 307                         if (delta > -one_frame) {
 308                                 /* Process this frame */
 309                                 filter_and_emit_video (_frame);
 310                         } else {
 311                                 /* Otherwise we are omitting a frame to keep things right */
 312                                 _film->log()->log (String::compose ("Frame removed at %1s", out_pts_seconds));
 313                         }
 314                 }
 315
 316         } else if (ffa && _packet.stream_index == ffa->id() && _opt->decode_audio) {
 317
 318                 int frame_finished;
 319                 if (avcodec_decode_audio4 (_audio_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
 320
 321                         /* Where we are in the source, in seconds */
 322                         double const source_pts_seconds = av_q2d (_format_context->streams[_packet.stream_index]->time_base)
 323                                 * av_frame_get_best_effort_timestamp(_frame);
 324
 325                         /* We only decode audio if we've had our first video packet through, and if it
 326                            was before this packet.  Until then audio is thrown away.
 327                         */
 328
 329                         if (_first_video && _first_video.get() <= source_pts_seconds) {
 330
 331                                 if (!_first_audio) {
 332                                         _first_audio = source_pts_seconds;
 333
 334                                         /* This is our first audio frame, and if we've arrived here we must have had our
 335                                            first video frame.  Push some silence to make up any gap between our first
 336                                            video frame and our first audio.
 337                                         */
 338
 339                                         /* frames of silence that we must push */
 340                                         int const s = rint ((_first_audio.get() - _first_video.get()) * ffa->sample_rate ());
 341
 342                                         _film->log()->log (
 343                                                 String::compose (
 344                                                         "First video at %1, first audio at %2, pushing %3 audio frames of silence for %4 channels (%5 bytes per sample)",
 345                                                         _first_video.get(), _first_audio.get(), s, ffa->channels(), bytes_per_audio_sample()
 346                                                         )
 347                                                 );
 348
 349                                         if (s) {
 350                                                 shared_ptr<AudioBuffers> audio (new AudioBuffers (ffa->channels(), s));
 351                                                 audio->make_silent ();
 352                                                 Audio (audio);
 353                                         }
 354                                 }
 355
 356                                 int const data_size = av_samples_get_buffer_size (
 357                                         0, _audio_codec_context->channels, _frame->nb_samples, audio_sample_format (), 1
 358                                         );
 359
 360                                 assert (_audio_codec_context->channels == _film->audio_channels());
 361                                 Audio (deinterleave_audio (_frame->data[0], data_size));
 362                         }
 363                 }
 364
 365         } else if (_subtitle_stream && _packet.stream_index == _subtitle_stream->id() && _opt->decode_subtitles && _first_video) {
 366
 367                 int got_subtitle;
 368                 AVSubtitle sub;
 369                 if (avcodec_decode_subtitle2 (_subtitle_codec_context, &sub, &got_subtitle, &_packet) && got_subtitle) {
 370                         /* Sometimes we get an empty AVSubtitle, which is used by some codecs to
 371                            indicate that the previous subtitle should stop.
 372                         */
 373                         if (sub.num_rects > 0) {
 374                                 shared_ptr<TimedSubtitle> ts;
 375                                 try {
 376                                         emit_subtitle (shared_ptr<TimedSubtitle> (new TimedSubtitle (sub, _first_video.get())));
 377                                 } catch (...) {
 378                                         /* some problem with the subtitle; we probably didn't understand it */
 379                                 }
 380                         } else {
 381                                 emit_subtitle (shared_ptr<TimedSubtitle> ());
 382                         }
 383                         avsubtitle_free (&sub);
 384                 }
 385         }
 386
 387         av_free_packet (&_packet);
 388         return false;
 389 }
 390
 391 shared_ptr<AudioBuffers>
 392 FFmpegDecoder::deinterleave_audio (uint8_t* data, int size)
 393 {
 394         assert (_film->audio_channels());
 395         assert (bytes_per_audio_sample());
 396
 397         shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (_audio_stream);
 398         assert (ffa);
 399
 400         /* Deinterleave and convert to float */
 401
 402         assert ((size % (bytes_per_audio_sample() * ffa->channels())) == 0);
 403
 404         int const total_samples = size / bytes_per_audio_sample();
 405         int const frames = total_samples / _film->audio_channels();
 406         shared_ptr<AudioBuffers> audio (new AudioBuffers (ffa->channels(), frames));
 407
 408         switch (audio_sample_format()) {
 409         case AV_SAMPLE_FMT_S16:
 410         {
 411                 int16_t* p = (int16_t *) data;
 412                 int sample = 0;
 413                 int channel = 0;
 414                 for (int i = 0; i < total_samples; ++i) {
 415                         audio->data(channel)[sample] = float(*p++) / (1 << 15);
 416
 417                         ++channel;
 418                         if (channel == _film->audio_channels()) {
 419                                 channel = 0;
 420                                 ++sample;
 421                         }
 422                 }
 423         }
 424         break;
 425
 426         case AV_SAMPLE_FMT_S32:
 427         {
 428                 int32_t* p = (int32_t *) data;
 429                 int sample = 0;
 430                 int channel = 0;
 431                 for (int i = 0; i < total_samples; ++i) {
 432                         audio->data(channel)[sample] = float(*p++) / (1 << 31);
 433
 434                         ++channel;
 435                         if (channel == _film->audio_channels()) {
 436                                 channel = 0;
 437                                 ++sample;
 438                         }
 439                 }
 440         }
 441
 442         case AV_SAMPLE_FMT_FLTP:
 443         {
 444                 float* p = reinterpret_cast<float*> (data);
 445                 for (int i = 0; i < _film->audio_channels(); ++i) {
 446                         memcpy (audio->data(i), p, frames * sizeof(float));
 447                         p += frames;
 448                 }
 449         }
 450         break;
 451
 452         default:
 453                 assert (false);
 454         }
 455
 456         return audio;
 457 }
 458
 459 float
 460 FFmpegDecoder::frames_per_second () const
 461 {
 462         AVStream* s = _format_context->streams[_video_stream];
 463
 464         if (s->avg_frame_rate.num && s->avg_frame_rate.den) {
 465                 return av_q2d (s->avg_frame_rate);
 466         }
 467
 468         return av_q2d (s->r_frame_rate);
 469 }
 470
 471 AVSampleFormat
 472 FFmpegDecoder::audio_sample_format () const
 473 {
 474         if (_audio_codec_context == 0) {
 475                 return (AVSampleFormat) 0;
 476         }
 477
 478         return _audio_codec_context->sample_fmt;
 479 }
 480
 481 Size
 482 FFmpegDecoder::native_size () const
 483 {
 484         return Size (_video_codec_context->width, _video_codec_context->height);
 485 }
 486
 487 PixelFormat
 488 FFmpegDecoder::pixel_format () const
 489 {
 490         return _video_codec_context->pix_fmt;
 491 }
 492
 493 int
 494 FFmpegDecoder::time_base_numerator () const
 495 {
 496         return _video_codec_context->time_base.num;
 497 }
 498
 499 int
 500 FFmpegDecoder::time_base_denominator () const
 501 {
 502         return _video_codec_context->time_base.den;
 503 }
 504
 505 int
 506 FFmpegDecoder::sample_aspect_ratio_numerator () const
 507 {
 508         return _video_codec_context->sample_aspect_ratio.num;
 509 }
 510
 511 int
 512 FFmpegDecoder::sample_aspect_ratio_denominator () const
 513 {
 514         return _video_codec_context->sample_aspect_ratio.den;
 515 }
 516
 517 string
 518 FFmpegDecoder::stream_name (AVStream* s) const
 519 {
 520         stringstream n;
 521
 522         AVDictionaryEntry const * lang = av_dict_get (s->metadata, "language", 0, 0);
 523         if (lang) {
 524                 n << lang->value;
 525         }
 526
 527         AVDictionaryEntry const * title = av_dict_get (s->metadata, "title", 0, 0);
 528         if (title) {
 529                 if (!n.str().empty()) {
 530                         n << " ";
 531                 }
 532                 n << title->value;
 533         }
 534
 535         if (n.str().empty()) {
 536                 n << "unknown";
 537         }
 538
 539         return n.str ();
 540 }
 541
 542 int
 543 FFmpegDecoder::bytes_per_audio_sample () const
 544 {
 545         return av_get_bytes_per_sample (audio_sample_format ());
 546 }
 547
 548 void
 549 FFmpegDecoder::set_audio_stream (shared_ptr<AudioStream> s)
 550 {
 551         AudioDecoder::set_audio_stream (s);
 552         setup_audio ();
 553 }
 554
 555 void
 556 FFmpegDecoder::set_subtitle_stream (shared_ptr<SubtitleStream> s)
 557 {
 558         VideoDecoder::set_subtitle_stream (s);
 559         setup_subtitle ();
 560 }
 561
 562 void
 563 FFmpegDecoder::filter_and_emit_video (AVFrame* frame)
 564 {
 565         shared_ptr<FilterGraph> graph;
 566
 567         list<shared_ptr<FilterGraph> >::iterator i = _filter_graphs.begin();
 568         while (i != _filter_graphs.end() && !(*i)->can_process (Size (frame->width, frame->height), (AVPixelFormat) frame->format)) {
 569                 ++i;
 570         }
 571
 572         if (i == _filter_graphs.end ()) {
 573                 graph.reset (new FilterGraph (_film, this, _opt->apply_crop, Size (frame->width, frame->height), (AVPixelFormat) frame->format));
 574                 _filter_graphs.push_back (graph);
 575                 _film->log()->log (String::compose ("New graph for %1x%2, pixel format %3", frame->width, frame->height, frame->format));
 576         } else {
 577                 graph = *i;
 578         }
 579
 580         list<shared_ptr<Image> > images = graph->process (frame);
 581
 582         for (list<shared_ptr<Image> >::iterator i = images.begin(); i != images.end(); ++i) {
 583                 emit_video (*i);
 584         }
 585 }
 586
 587 shared_ptr<FFmpegAudioStream>
 588 FFmpegAudioStream::create (string t, optional<int> v)
 589 {
 590         if (!v) {
 591                 /* version < 1; no type in the string, and there's only FFmpeg streams anyway */
 592                 return shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream (t, v));
 593         }
 594
 595         stringstream s (t);
 596         string type;
 597         s >> type;
 598         if (type != "ffmpeg") {
 599                 return shared_ptr<FFmpegAudioStream> ();
 600         }
 601
 602         return shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream (t, v));
 603 }
 604
 605 FFmpegAudioStream::FFmpegAudioStream (string t, optional<int> version)
 606 {
 607         stringstream n (t);
 608
 609         int name_index = 4;
 610         if (!version) {
 611                 name_index = 2;
 612                 int channels;
 613                 n >> _id >> channels;
 614                 _channel_layout = av_get_default_channel_layout (channels);
 615                 _sample_rate = 0;
 616         } else {
 617                 string type;
 618                 /* Current (marked version 1) */
 619                 n >> type >> _id >> _sample_rate >> _channel_layout;
 620                 assert (type == "ffmpeg");
 621         }
 622
 623         for (int i = 0; i < name_index; ++i) {
 624                 size_t const s = t.find (' ');
 625                 if (s != string::npos) {
 626                         t = t.substr (s + 1);
 627                 }
 628         }
 629
 630         _name = t;
 631 }
 632
 633 string
 634 FFmpegAudioStream::to_string () const
 635 {
 636         return String::compose ("ffmpeg %1 %2 %3 %4", _id, _sample_rate, _channel_layout, _name);
 637 }
 638