src/lib/ffmpeg.cc

   1 /*
   2     Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 extern "C" {
  21 #include <libavcodec/avcodec.h>
  22 #include <libavformat/avformat.h>
  23 #include <libswscale/swscale.h>
  24 }
  25 #include <libdcp/raw_convert.h>
  26 #include "ffmpeg.h"
  27 #include "ffmpeg_content.h"
  28 #include "exceptions.h"
  29 #include "util.h"
  30
  31 #include "i18n.h"
  32
  33 using std::string;
  34 using std::cout;
  35 using boost::shared_ptr;
  36 using libdcp::raw_convert;
  37
  38 boost::mutex FFmpeg::_mutex;
  39
  40 FFmpeg::FFmpeg (boost::shared_ptr<const FFmpegContent> c)
  41         : _ffmpeg_content (c)
  42         , _avio_buffer (0)
  43         , _avio_buffer_size (4096)
  44         , _avio_context (0)
  45         , _format_context (0)
  46         , _frame (0)
  47         , _video_stream (-1)
  48 {
  49         setup_general ();
  50         setup_video ();
  51         setup_audio ();
  52 }
  53
  54 FFmpeg::~FFmpeg ()
  55 {
  56         boost::mutex::scoped_lock lm (_mutex);
  57
  58         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
  59                 AVCodecContext* context = _format_context->streams[i]->codec;
  60                 if (context->codec_type == AVMEDIA_TYPE_VIDEO || context->codec_type == AVMEDIA_TYPE_AUDIO) {
  61                         avcodec_close (context);
  62                 }
  63         }
  64
  65         av_frame_free (&_frame);
  66
  67         avformat_close_input (&_format_context);
  68 }
  69
  70 static int
  71 avio_read_wrapper (void* data, uint8_t* buffer, int amount)
  72 {
  73         return reinterpret_cast<FFmpeg*>(data)->avio_read (buffer, amount);
  74 }
  75
  76 static int64_t
  77 avio_seek_wrapper (void* data, int64_t offset, int whence)
  78 {
  79         return reinterpret_cast<FFmpeg*>(data)->avio_seek (offset, whence);
  80 }
  81
  82 void
  83 FFmpeg::setup_general ()
  84 {
  85         av_register_all ();
  86
  87         _file_group.set_paths (_ffmpeg_content->paths ());
  88         _avio_buffer = static_cast<uint8_t*> (wrapped_av_malloc (_avio_buffer_size));
  89         _avio_context = avio_alloc_context (_avio_buffer, _avio_buffer_size, 0, this, avio_read_wrapper, 0, avio_seek_wrapper);
  90         _format_context = avformat_alloc_context ();
  91         _format_context->pb = _avio_context;
  92
  93         AVDictionary* options = 0;
  94         /* These durations are in microseconds, and represent how far into the content file
  95            we will look for streams.
  96         */
  97         av_dict_set (&options, "analyzeduration", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
  98         av_dict_set (&options, "probesize", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
  99
 100         if (avformat_open_input (&_format_context, 0, 0, &options) < 0) {
 101                 throw OpenFileError (_ffmpeg_content->path(0).string ());
 102         }
 103
 104         if (avformat_find_stream_info (_format_context, 0) < 0) {
 105                 throw DecodeError (_("could not find stream information"));
 106         }
 107
 108         /* Find video stream */
 109
 110         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 111                 AVStream* s = _format_context->streams[i];
 112                 /* Files from iTunes sometimes have two video streams, one with the avg_frame_rate.num and .den set
 113                    to zero.  Ignore these streams.
 114                 */
 115                 if (s->codec->codec_type == AVMEDIA_TYPE_VIDEO && s->avg_frame_rate.num > 0 && s->avg_frame_rate.den > 0) {
 116                         _video_stream = i;
 117                 }
 118         }
 119
 120         if (_video_stream < 0) {
 121                 throw DecodeError (N_("could not find video stream"));
 122         }
 123
 124         /* Hack: if the AVStreams have zero IDs, put some in.  We
 125            use the IDs so that we can cope with VOBs, in which streams
 126            move about in index but remain with the same ID in different
 127            VOBs.  However, some files have all-zero IDs, hence this hack.
 128         */
 129
 130         uint32_t i = 0;
 131         while (i < _format_context->nb_streams && _format_context->streams[i]->id == 0) {
 132                 ++i;
 133         }
 134
 135         if (i == _format_context->nb_streams) {
 136                 /* Put in our own IDs */
 137                 for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 138                         _format_context->streams[i]->id = i;
 139                 }
 140         }
 141
 142         _frame = av_frame_alloc ();
 143         if (_frame == 0) {
 144                 throw DecodeError (N_("could not allocate frame"));
 145         }
 146 }
 147
 148 void
 149 FFmpeg::setup_video ()
 150 {
 151         boost::mutex::scoped_lock lm (_mutex);
 152
 153         assert (_video_stream >= 0);
 154         AVCodecContext* context = _format_context->streams[_video_stream]->codec;
 155         AVCodec* codec = avcodec_find_decoder (context->codec_id);
 156
 157         if (codec == 0) {
 158                 throw DecodeError (_("could not find video decoder"));
 159         }
 160
 161         if (avcodec_open2 (context, codec, 0) < 0) {
 162                 throw DecodeError (N_("could not open video decoder"));
 163         }
 164 }
 165
 166 void
 167 FFmpeg::setup_audio ()
 168 {
 169         boost::mutex::scoped_lock lm (_mutex);
 170
 171         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 172                 AVCodecContext* context = _format_context->streams[i]->codec;
 173                 if (context->codec_type != AVMEDIA_TYPE_AUDIO) {
 174                         continue;
 175                 }
 176
 177                 AVCodec* codec = avcodec_find_decoder (context->codec_id);
 178                 if (codec == 0) {
 179                         throw DecodeError (_("could not find audio decoder"));
 180                 }
 181
 182                 if (avcodec_open2 (context, codec, 0) < 0) {
 183                         throw DecodeError (N_("could not open audio decoder"));
 184                 }
 185         }
 186 }
 187
 188
 189 AVCodecContext *
 190 FFmpeg::video_codec_context () const
 191 {
 192         return _format_context->streams[_video_stream]->codec;
 193 }
 194
 195 AVCodecContext *
 196 FFmpeg::audio_codec_context () const
 197 {
 198         return _ffmpeg_content->audio_stream()->stream(_format_context)->codec;
 199 }
 200
 201 int
 202 FFmpeg::avio_read (uint8_t* buffer, int const amount)
 203 {
 204         return _file_group.read (buffer, amount);
 205 }
 206
 207 int64_t
 208 FFmpeg::avio_seek (int64_t const pos, int whence)
 209 {
 210         if (whence == AVSEEK_SIZE) {
 211                 return _file_group.length ();
 212         }
 213
 214         return _file_group.seek (pos, whence);
 215 }