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 #include <libpostproc/postprocess.h>
  25 }
  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 std::stringstream;
  36 using boost::shared_ptr;
  37 using boost::lexical_cast;
  38
  39 boost::mutex FFmpeg::_mutex;
  40
  41 FFmpeg::FFmpeg (boost::shared_ptr<const FFmpegContent> c)
  42         : _ffmpeg_content (c)
  43         , _avio_buffer (0)
  44         , _avio_buffer_size (4096)
  45         , _avio_context (0)
  46         , _format_context (0)
  47         , _frame (0)
  48         , _video_stream (-1)
  49 {
  50         setup_general ();
  51         setup_video ();
  52         setup_audio ();
  53 }
  54
  55 FFmpeg::~FFmpeg ()
  56 {
  57         boost::mutex::scoped_lock lm (_mutex);
  58
  59         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
  60                 AVCodecContext* context = _format_context->streams[i]->codec;
  61                 if (context->codec_type == AVMEDIA_TYPE_VIDEO || context->codec_type == AVMEDIA_TYPE_AUDIO) {
  62                         avcodec_close (context);
  63                 }
  64         }
  65
  66         av_frame_free (&_frame);
  67
  68         avformat_close_input (&_format_context);
  69 }
  70
  71 static int
  72 avio_read_wrapper (void* data, uint8_t* buffer, int amount)
  73 {
  74         return reinterpret_cast<FFmpeg*>(data)->avio_read (buffer, amount);
  75 }
  76
  77 static int64_t
  78 avio_seek_wrapper (void* data, int64_t offset, int whence)
  79 {
  80         return reinterpret_cast<FFmpeg*>(data)->avio_seek (offset, whence);
  81 }
  82
  83 void
  84 FFmpeg::setup_general ()
  85 {
  86         av_register_all ();
  87
  88         _file_group.set_paths (_ffmpeg_content->paths ());
  89         _avio_buffer = static_cast<uint8_t*> (wrapped_av_malloc (_avio_buffer_size));
  90         _avio_context = avio_alloc_context (_avio_buffer, _avio_buffer_size, 0, this, avio_read_wrapper, 0, avio_seek_wrapper);
  91         _format_context = avformat_alloc_context ();
  92         _format_context->pb = _avio_context;
  93
  94         AVDictionary* options = 0;
  95         /* These durations are in microseconds, and represent how far into the content file
  96            we will look for streams.
  97         */
  98         av_dict_set (&options, "analyzeduration", lexical_cast<string> (5 * 60 * 1e6).c_str(), 0);
  99         av_dict_set (&options, "probesize", lexical_cast<string> (5 * 60 * 1e6).c_str(), 0);
 100
 101         if (avformat_open_input (&_format_context, 0, 0, &options) < 0) {
 102                 throw OpenFileError (_ffmpeg_content->path(0).string ());
 103         }
 104
 105         if (avformat_find_stream_info (_format_context, 0) < 0) {
 106                 throw DecodeError (_("could not find stream information"));
 107         }
 108
 109         /* Find video stream */
 110
 111         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 112                 AVStream* s = _format_context->streams[i];
 113                 if (s->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 114                         _video_stream = i;
 115                 }
 116         }
 117
 118         if (_video_stream < 0) {
 119                 throw DecodeError (N_("could not find video stream"));
 120         }
 121
 122         /* Hack: if the AVStreams have zero IDs, put some in.  We
 123            use the IDs so that we can cope with VOBs, in which streams
 124            move about in index but remain with the same ID in different
 125            VOBs.  However, some files have all-zero IDs, hence this hack.
 126         */
 127
 128         uint32_t i = 0;
 129         while (i < _format_context->nb_streams && _format_context->streams[i]->id == 0) {
 130                 ++i;
 131         }
 132
 133         if (i == _format_context->nb_streams) {
 134                 /* Put in our own IDs */
 135                 for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 136                         _format_context->streams[i]->id = i;
 137                 }
 138         }
 139
 140         _frame = av_frame_alloc ();
 141         if (_frame == 0) {
 142                 throw DecodeError (N_("could not allocate frame"));
 143         }
 144 }
 145
 146 void
 147 FFmpeg::setup_video ()
 148 {
 149         boost::mutex::scoped_lock lm (_mutex);
 150
 151         assert (_video_stream >= 0);
 152         AVCodecContext* context = _format_context->streams[_video_stream]->codec;
 153         AVCodec* codec = avcodec_find_decoder (context->codec_id);
 154
 155         if (codec == 0) {
 156                 throw DecodeError (_("could not find video decoder"));
 157         }
 158
 159         if (avcodec_open2 (context, codec, 0) < 0) {
 160                 throw DecodeError (N_("could not open video decoder"));
 161         }
 162 }
 163
 164 void
 165 FFmpeg::setup_audio ()
 166 {
 167         boost::mutex::scoped_lock lm (_mutex);
 168
 169         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 170                 AVCodecContext* context = _format_context->streams[i]->codec;
 171                 if (context->codec_type != AVMEDIA_TYPE_AUDIO) {
 172                         continue;
 173                 }
 174
 175                 AVCodec* codec = avcodec_find_decoder (context->codec_id);
 176                 if (codec == 0) {
 177                         throw DecodeError (_("could not find audio decoder"));
 178                 }
 179
 180                 if (avcodec_open2 (context, codec, 0) < 0) {
 181                         throw DecodeError (N_("could not open audio decoder"));
 182                 }
 183         }
 184 }
 185
 186
 187 AVCodecContext *
 188 FFmpeg::video_codec_context () const
 189 {
 190         return _format_context->streams[_video_stream]->codec;
 191 }
 192
 193 AVCodecContext *
 194 FFmpeg::audio_codec_context () const
 195 {
 196         if (!_ffmpeg_content->audio_stream ()) {
 197                 return 0;
 198         }
 199
 200         return _ffmpeg_content->audio_stream()->stream(_format_context)->codec;
 201 }
 202
 203 int
 204 FFmpeg::avio_read (uint8_t* buffer, int const amount)
 205 {
 206         return _file_group.read (buffer, amount);
 207 }
 208
 209 int64_t
 210 FFmpeg::avio_seek (int64_t const pos, int whence)
 211 {
 212         if (whence == AVSEEK_SIZE) {
 213                 return _file_group.length ();
 214         }
 215
 216         return _file_group.seek (pos, whence);
 217 }