src/lib/ffmpeg.cc

   1 /*
   2     Copyright (C) 2013-2016 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 #include "ffmpeg.h"
  21 #include "ffmpeg_content.h"
  22 #include "film.h"
  23 #include "exceptions.h"
  24 #include "util.h"
  25 #include "raw_convert.h"
  26 #include "log.h"
  27 #include "ffmpeg_subtitle_stream.h"
  28 #include "ffmpeg_audio_stream.h"
  29 #include "md5_digester.h"
  30 #include "compose.hpp"
  31 extern "C" {
  32 #include <libavcodec/avcodec.h>
  33 #include <libavformat/avformat.h>
  34 #include <libswscale/swscale.h>
  35 }
  36 #include <boost/algorithm/string.hpp>
  37 #include <boost/foreach.hpp>
  38 #include <iostream>
  39
  40 #include "i18n.h"
  41
  42 using std::string;
  43 using std::cout;
  44 using std::cerr;
  45 using std::vector;
  46 using boost::shared_ptr;
  47 using boost::optional;
  48
  49 boost::mutex FFmpeg::_mutex;
  50 boost::weak_ptr<Log> FFmpeg::_ffmpeg_log;
  51
  52 FFmpeg::FFmpeg (boost::shared_ptr<const FFmpegContent> c)
  53         : _ffmpeg_content (c)
  54         , _avio_buffer (0)
  55         , _avio_buffer_size (4096)
  56         , _avio_context (0)
  57         , _format_context (0)
  58         , _frame (0)
  59 {
  60         setup_general ();
  61         setup_decoders ();
  62 }
  63
  64 FFmpeg::~FFmpeg ()
  65 {
  66         boost::mutex::scoped_lock lm (_mutex);
  67
  68         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
  69                 avcodec_close (_format_context->streams[i]->codec);
  70         }
  71
  72         av_frame_free (&_frame);
  73         avformat_close_input (&_format_context);
  74 }
  75
  76 static int
  77 avio_read_wrapper (void* data, uint8_t* buffer, int amount)
  78 {
  79         return reinterpret_cast<FFmpeg*>(data)->avio_read (buffer, amount);
  80 }
  81
  82 static int64_t
  83 avio_seek_wrapper (void* data, int64_t offset, int whence)
  84 {
  85         return reinterpret_cast<FFmpeg*>(data)->avio_seek (offset, whence);
  86 }
  87
  88 void
  89 FFmpeg::ffmpeg_log_callback (void* ptr, int level, const char* fmt, va_list vl)
  90 {
  91         if (level > AV_LOG_WARNING) {
  92                 return;
  93         }
  94
  95         char line[1024];
  96         static int prefix = 0;
  97         av_log_format_line (ptr, level, fmt, vl, line, sizeof (line), &prefix);
  98         shared_ptr<Log> log = _ffmpeg_log.lock ();
  99         if (log) {
 100                 string str (line);
 101                 boost::algorithm::trim (str);
 102                 log->log (String::compose ("FFmpeg: %1", str), LogEntry::TYPE_GENERAL);
 103         } else {
 104                 cerr << line;
 105         }
 106 }
 107
 108 void
 109 FFmpeg::setup_general ()
 110 {
 111         av_register_all ();
 112
 113         /* This might not work too well in some cases of multiple FFmpeg decoders,
 114            but it's probably good enough.
 115         */
 116         _ffmpeg_log = _ffmpeg_content->film()->log ();
 117         av_log_set_callback (FFmpeg::ffmpeg_log_callback);
 118
 119         _file_group.set_paths (_ffmpeg_content->paths ());
 120         _avio_buffer = static_cast<uint8_t*> (wrapped_av_malloc (_avio_buffer_size));
 121         _avio_context = avio_alloc_context (_avio_buffer, _avio_buffer_size, 0, this, avio_read_wrapper, 0, avio_seek_wrapper);
 122         _format_context = avformat_alloc_context ();
 123         _format_context->pb = _avio_context;
 124
 125         AVDictionary* options = 0;
 126         /* These durations are in microseconds, and represent how far into the content file
 127            we will look for streams.
 128         */
 129         av_dict_set (&options, "analyzeduration", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
 130         av_dict_set (&options, "probesize", raw_convert<string> (5 * 60 * 1000000).c_str(), 0);
 131
 132         if (avformat_open_input (&_format_context, 0, 0, &options) < 0) {
 133                 throw OpenFileError (_ffmpeg_content->path(0).string ());
 134         }
 135
 136         if (avformat_find_stream_info (_format_context, 0) < 0) {
 137                 throw DecodeError (_("could not find stream information"));
 138         }
 139
 140         /* Find video stream */
 141
 142         optional<int> video_stream_undefined_frame_rate;
 143
 144         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 145                 AVStream* s = _format_context->streams[i];
 146                 if (s->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 147                         if (s->avg_frame_rate.num > 0 && s->avg_frame_rate.den > 0) {
 148                                 /* This is definitely our video stream */
 149                                 _video_stream = i;
 150                         } else {
 151                                 /* This is our video stream if we don't get a better offer */
 152                                 video_stream_undefined_frame_rate = i;
 153                         }
 154                 }
 155         }
 156
 157         /* Files from iTunes sometimes have two video streams, one with the avg_frame_rate.num and .den set
 158            to zero.  Only use such a stream if there is no alternative.
 159         */
 160         if (!_video_stream && video_stream_undefined_frame_rate) {
 161                 _video_stream = video_stream_undefined_frame_rate.get();
 162         }
 163
 164         /* Hack: if the AVStreams have duplicate IDs, replace them with our
 165            own.  We use the IDs so that we can cope with VOBs, in which streams
 166            move about in index but remain with the same ID in different
 167            VOBs.  However, some files have duplicate IDs, hence this hack.
 168         */
 169
 170         bool duplicates = false;
 171         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 172                 for (uint32_t j = i + 1; j < _format_context->nb_streams; ++j) {
 173                         if (_format_context->streams[i]->id == _format_context->streams[j]->id) {
 174                                 duplicates = true;
 175                         }
 176                 }
 177         }
 178
 179         if (duplicates) {
 180                 /* Put in our own IDs */
 181                 for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 182                         _format_context->streams[i]->id = i;
 183                 }
 184         }
 185
 186         _frame = av_frame_alloc ();
 187         if (_frame == 0) {
 188                 throw DecodeError (N_("could not allocate frame"));
 189         }
 190 }
 191
 192 void
 193 FFmpeg::setup_decoders ()
 194 {
 195         boost::mutex::scoped_lock lm (_mutex);
 196
 197         for (uint32_t i = 0; i < _format_context->nb_streams; ++i) {
 198                 AVCodecContext* context = _format_context->streams[i]->codec;
 199
 200                 AVCodec* codec = avcodec_find_decoder (context->codec_id);
 201                 if (codec) {
 202
 203                         /* This option disables decoding of DCA frame footers in our patched version
 204                            of FFmpeg.  I believe these footers are of no use to us, and they can cause
 205                            problems when FFmpeg fails to decode them (mantis #352).
 206                         */
 207                         AVDictionary* options = 0;
 208                         av_dict_set (&options, "disable_footer", "1", 0);
 209
 210                         if (avcodec_open2 (context, codec, &options) < 0) {
 211                                 throw DecodeError (N_("could not open decoder"));
 212                         }
 213                 }
 214
 215                 /* We are silently ignoring any failures to find suitable decoders here */
 216         }
 217 }
 218
 219 AVCodecContext *
 220 FFmpeg::video_codec_context () const
 221 {
 222         DCPOMATIC_ASSERT (_video_stream);
 223         return _format_context->streams[_video_stream.get()]->codec;
 224 }
 225
 226 AVCodecContext *
 227 FFmpeg::subtitle_codec_context () const
 228 {
 229         if (!_ffmpeg_content->subtitle_stream ()) {
 230                 return 0;
 231         }
 232
 233         return _ffmpeg_content->subtitle_stream()->stream(_format_context)->codec;
 234 }
 235
 236 int
 237 FFmpeg::avio_read (uint8_t* buffer, int const amount)
 238 {
 239         return _file_group.read (buffer, amount);
 240 }
 241
 242 int64_t
 243 FFmpeg::avio_seek (int64_t const pos, int whence)
 244 {
 245         if (whence == AVSEEK_SIZE) {
 246                 return _file_group.length ();
 247         }
 248
 249         return _file_group.seek (pos, whence);
 250 }
 251
 252 FFmpegSubtitlePeriod
 253 FFmpeg::subtitle_period (AVSubtitle const & sub)
 254 {
 255         ContentTime const packet_time = ContentTime::from_seconds (static_cast<double> (sub.pts) / AV_TIME_BASE);
 256
 257         if (sub.end_display_time == static_cast<uint32_t> (-1)) {
 258                 /* End time is not known */
 259                 return FFmpegSubtitlePeriod (packet_time + ContentTime::from_seconds (sub.start_display_time / 1e3));
 260         }
 261
 262         return FFmpegSubtitlePeriod (
 263                 packet_time + ContentTime::from_seconds (sub.start_display_time / 1e3),
 264                 packet_time + ContentTime::from_seconds (sub.end_display_time / 1e3)
 265                 );
 266 }
 267
 268 string
 269 FFmpeg::subtitle_id (AVSubtitle const & sub)
 270 {
 271         MD5Digester digester;
 272         digester.add (sub.pts);
 273         for (unsigned int i = 0; i < sub.num_rects; ++i) {
 274                 AVSubtitleRect* rect = sub.rects[i];
 275                 digester.add (rect->x);
 276                 digester.add (rect->y);
 277                 digester.add (rect->w);
 278                 digester.add (rect->h);
 279 #ifdef DCPOMATIC_HAVE_AVSUBTITLERECT_PICT
 280                 int const line = rect->pict.linesize[0];
 281                 for (int j = 0; j < rect->h; ++j) {
 282                         digester.add (rect->pict.data[0] + j * line, line);
 283                 }
 284 #else
 285                 int const line = rect->linesize[0];
 286                 for (int j = 0; j < rect->h; ++j) {
 287                         digester.add (rect->data[0] + j * line, line);
 288                 }
 289 #endif
 290         }
 291         return digester.get ();
 292 }
 293
 294 /** @return true if sub starts a new image subtitle */
 295 bool
 296 FFmpeg::subtitle_starts_image (AVSubtitle const & sub)
 297 {
 298         bool image = false;
 299         bool text = false;
 300
 301         for (unsigned int i = 0; i < sub.num_rects; ++i) {
 302                 switch (sub.rects[i]->type) {
 303                 case SUBTITLE_BITMAP:
 304                         image = true;
 305                         break;
 306                 case SUBTITLE_TEXT:
 307                 case SUBTITLE_ASS:
 308                         text = true;
 309                         break;
 310                 default:
 311                         break;
 312                 }
 313         }
 314
 315         /* We can't cope with mixed image/text in one AVSubtitle */
 316         DCPOMATIC_ASSERT (!image || !text);
 317
 318         return image;
 319 }
 320
 321 /** Compute the pts offset to use given a set of audio streams and some video details.
 322  *  Sometimes these parameters will have just been determined by an Examiner, sometimes
 323  *  they will have been retrieved from a piece of Content, hence the need for this method
 324  *  in FFmpeg.
 325  */
 326 ContentTime
 327 FFmpeg::pts_offset (vector<shared_ptr<FFmpegAudioStream> > audio_streams, optional<ContentTime> first_video, double video_frame_rate) const
 328 {
 329         /* Audio and video frame PTS values may not start with 0.  We want
 330            to fiddle them so that:
 331
 332            1.  One of them starts at time 0.
 333            2.  The first video PTS value ends up on a frame boundary.
 334
 335            Then we remove big initial gaps in PTS and we allow our
 336            insertion of black frames to work.
 337
 338            We will do:
 339              audio_pts_to_use = audio_pts_from_ffmpeg + pts_offset;
 340              video_pts_to_use = video_pts_from_ffmpeg + pts_offset;
 341         */
 342
 343         /* First, make one of them start at 0 */
 344
 345         ContentTime po = ContentTime::min ();
 346
 347         if (first_video) {
 348                 po = - first_video.get ();
 349         }
 350
 351         BOOST_FOREACH (shared_ptr<FFmpegAudioStream> i, audio_streams) {
 352                 if (i->first_audio) {
 353                         po = max (po, - i->first_audio.get ());
 354                 }
 355         }
 356
 357         /* If the offset is positive we would be pushing things from a -ve PTS to be played.
 358            I don't think we ever want to do that, as it seems things at -ve PTS are not meant
 359            to be seen (use for alignment bars etc.); see mantis #418.
 360         */
 361         if (po > ContentTime ()) {
 362                 po = ContentTime ();
 363         }
 364
 365         /* Now adjust so that the video pts starts on a frame */
 366         if (first_video) {
 367                 ContentTime const fvc = first_video.get() + po;
 368                 po += fvc.round_up (video_frame_rate) - fvc;
 369         }
 370
 371         return po;
 372 }