src/lib/ffmpeg.cc

   1 /*
   2     Copyright (C) 2013-2014 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 <dcp/raw_convert.h>
  26 #include "ffmpeg.h"
  27 #include "ffmpeg_content.h"
  28 #include "ffmpeg_audio_stream.h"
  29 #include "exceptions.h"
  30 #include "util.h"
  31
  32 #include "i18n.h"
  33
  34 using std::string;
  35 using std::cout;
  36 using std::stringstream;
  37 using boost::shared_ptr;
  38 using dcp::raw_convert;
  39
  40 boost::mutex FFmpeg::_mutex;
  41
  42 FFmpeg::FFmpeg (boost::shared_ptr<const FFmpegContent> c)
  43         : _ffmpeg_content (c)
  44         , _avio_buffer (0)
  45         , _avio_buffer_size (4096)
  46         , _avio_context (0)
  47         , _format_context (0)
  48         , _frame (0)
  49         , _video_stream (-1)
  50 {
  51         setup_general ();
  52         setup_decoders ();
  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", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
  99         av_dict_set (&options, "probesize", raw_convert<string> (5 * 60 * 1000000).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_decoders ()
 148 {
 149         boost::mutex::scoped_lock lm (_mutex);
 150
 151         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 152                 AVCodecContext* context = _format_context->streams[i]->codec;
 153
 154                 AVCodec* codec = avcodec_find_decoder (context->codec_id);
 155                 if (codec == 0) {
 156                         throw DecodeError (N_("could not find decoder"));
 157                 }
 158
 159                 if (avcodec_open2 (context, codec, 0) < 0) {
 160                         throw DecodeError (N_("could not open decoder"));
 161                 }
 162         }
 163 }
 164
 165 AVCodecContext *
 166 FFmpeg::video_codec_context () const
 167 {
 168         return _format_context->streams[_video_stream]->codec;
 169 }
 170
 171 AVCodecContext *
 172 FFmpeg::audio_codec_context () const
 173 {
 174         if (!_ffmpeg_content->audio_stream ()) {
 175                 return 0;
 176         }
 177
 178         return _ffmpeg_content->audio_stream()->stream(_format_context)->codec;
 179 }
 180
 181 int
 182 FFmpeg::avio_read (uint8_t* buffer, int const amount)
 183 {
 184         return _file_group.read (buffer, amount);
 185 }
 186
 187 int64_t
 188 FFmpeg::avio_seek (int64_t const pos, int whence)
 189 {
 190         if (whence == AVSEEK_SIZE) {
 191                 return _file_group.length ();
 192         }
 193
 194         return _file_group.seek (pos, whence);
 195 }