#include <stdexcept>
#include <vector>
-#include <sstream>
#include <iomanip>
#include <iostream>
#include <stdint.h>
-#include <boost/lexical_cast.hpp>
#include <sndfile.h>
extern "C" {
#include <libavcodec/avcodec.h>
#include "util.h"
#include "log.h"
#include "ffmpeg_decoder.h"
+#include "ffmpeg_audio_stream.h"
+#include "ffmpeg_subtitle_stream.h"
#include "filter_graph.h"
#include "audio_buffers.h"
#include "ffmpeg_content.h"
+#include "raw_image_proxy.h"
+#include "film.h"
+#include "timer.h"
#include "i18n.h"
+#define LOG_GENERAL(...) _video_content->film()->log()->log (String::compose (__VA_ARGS__), Log::TYPE_GENERAL);
+#define LOG_ERROR(...) _video_content->film()->log()->log (String::compose (__VA_ARGS__), Log::TYPE_ERROR);
+#define LOG_WARNING_NC(...) _video_content->film()->log()->log (__VA_ARGS__, Log::TYPE_WARNING);
+#define LOG_WARNING(...) _video_content->film()->log()->log (String::compose (__VA_ARGS__), Log::TYPE_WARNING);
+
using std::cout;
using std::string;
using std::vector;
-using std::stringstream;
using std::list;
using std::min;
using std::pair;
+using std::make_pair;
using boost::shared_ptr;
using boost::optional;
using boost::dynamic_pointer_cast;
FFmpegDecoder::FFmpegDecoder (shared_ptr<const FFmpegContent> c, shared_ptr<Log> log)
: VideoDecoder (c)
, AudioDecoder (c)
+ , SubtitleDecoder (c)
, FFmpeg (c)
, _log (log)
- , _subtitle_codec_context (0)
- , _subtitle_codec (0)
{
- setup_subtitle ();
-
/* Audio and video frame PTS values may not start with 0. We want
to fiddle them so that:
_pts_offset = - c->audio_stream()->first_audio.get();
}
+ /* If _pts_offset is positive we would be pushing things from a -ve PTS to be played.
+ I don't think we ever want to do that, as it seems things at -ve PTS are not meant
+ to be seen (use for alignment bars etc.); see mantis #418.
+ */
+ if (_pts_offset > ContentTime ()) {
+ _pts_offset = ContentTime ();
+ }
+
/* Now adjust both so that the video pts starts on a frame */
if (have_video && have_audio) {
ContentTime first_video = c->first_video().get() + _pts_offset;
}
}
-FFmpegDecoder::~FFmpegDecoder ()
-{
- boost::mutex::scoped_lock lm (_mutex);
-
- if (_subtitle_codec_context) {
- avcodec_close (_subtitle_codec_context);
- }
-}
-
void
FFmpegDecoder::flush ()
{
{
int r = av_read_frame (_format_context, &_packet);
- if (r < 0) {
+ /* AVERROR_INVALIDDATA can apparently be returned sometimes even when av_read_frame
+ has pretty-much succeeded (and hence generated data which should be processed).
+ Hence it makes sense to continue here in that case.
+ */
+ if (r < 0 && r != AVERROR_INVALIDDATA) {
if (r != AVERROR_EOF) {
/* Maybe we should fail here, but for now we'll just finish off instead */
char buf[256];
av_strerror (r, buf, sizeof(buf));
- _log->log (String::compose (N_("error on av_read_frame (%1) (%2)"), buf, r));
+ LOG_ERROR (N_("error on av_read_frame (%1) (%2)"), buf, r);
}
-
+
flush ();
return true;
}
int const si = _packet.stream_index;
-
- if (si == _video_stream) {
+
+ if (si == _video_stream && !_ignore_video) {
decode_video_packet ();
} else if (_ffmpeg_content->audio_stream() && _ffmpeg_content->audio_stream()->uses_index (_format_context, si)) {
decode_audio_packet ();
shared_ptr<AudioBuffers>
FFmpegDecoder::deinterleave_audio (uint8_t** data, int size)
{
- assert (_ffmpeg_content->audio_channels());
- assert (bytes_per_audio_sample());
+ DCPOMATIC_ASSERT (_ffmpeg_content->audio_channels());
+ DCPOMATIC_ASSERT (bytes_per_audio_sample());
/* Deinterleave and convert to float */
- assert ((size % (bytes_per_audio_sample() * _ffmpeg_content->audio_channels())) == 0);
-
+ /* total_samples and frames will be rounded down here, so if there are stray samples at the end
+ of the block that do not form a complete sample or frame they will be dropped.
+ */
int const total_samples = size / bytes_per_audio_sample();
int const frames = total_samples / _ffmpeg_content->audio_channels();
shared_ptr<AudioBuffers> audio (new AudioBuffers (_ffmpeg_content->audio_channels(), frames));
return av_get_bytes_per_sample (audio_sample_format ());
}
-int
-FFmpegDecoder::minimal_run (boost::function<bool (optional<ContentTime>, optional<ContentTime>, int)> finished)
-{
- int frames_read = 0;
- optional<ContentTime> last_video;
- optional<ContentTime> last_audio;
-
- while (!finished (last_video, last_audio, frames_read)) {
- int r = av_read_frame (_format_context, &_packet);
- if (r < 0) {
- /* We should flush our decoders here, possibly yielding a few more frames,
- but the consequence of having to do that is too hideous to contemplate.
- Instead we give up and say that you can't seek too close to the end
- of a file.
- */
- return frames_read;
- }
-
- ++frames_read;
-
- double const time_base = av_q2d (_format_context->streams[_packet.stream_index]->time_base);
-
- if (_packet.stream_index == _video_stream) {
-
- avcodec_get_frame_defaults (_frame);
-
- int got_picture = 0;
- r = avcodec_decode_video2 (video_codec_context(), _frame, &got_picture, &_packet);
- if (r >= 0 && got_picture) {
- last_video = ContentTime::from_seconds (av_frame_get_best_effort_timestamp (_frame) * time_base) + _pts_offset;
- }
-
- } else if (_ffmpeg_content->audio_stream() && _ffmpeg_content->audio_stream()->uses_index (_format_context, _packet.stream_index)) {
- AVPacket copy_packet = _packet;
- while (copy_packet.size > 0) {
-
- int got_frame;
- r = avcodec_decode_audio4 (audio_codec_context(), _frame, &got_frame, &_packet);
- if (r >= 0 && got_frame) {
- last_audio = ContentTime::from_seconds (av_frame_get_best_effort_timestamp (_frame) * time_base) + _pts_offset;
- }
-
- copy_packet.data += r;
- copy_packet.size -= r;
- }
- }
-
- av_free_packet (&_packet);
- }
-
- return frames_read;
-}
-
-bool
-FFmpegDecoder::seek_overrun_finished (ContentTime seek, optional<ContentTime> last_video, optional<ContentTime> last_audio) const
-{
- return (last_video && last_video.get() >= seek) || (last_audio && last_audio.get() >= seek);
-}
-
-bool
-FFmpegDecoder::seek_final_finished (int n, int done) const
-{
- return n == done;
-}
-
-void
-FFmpegDecoder::seek_and_flush (ContentTime t)
-{
- ContentTime const u = t - _pts_offset;
- int64_t s = u.seconds() / av_q2d (_format_context->streams[_video_stream]->time_base);
-
- if (_ffmpeg_content->audio_stream ()) {
- s = min (
- s, int64_t (u.seconds() / av_q2d (_ffmpeg_content->audio_stream()->stream(_format_context)->time_base))
- );
- }
-
- /* Ridiculous empirical hack */
- s--;
- if (s < 0) {
- s = 0;
- }
-
- av_seek_frame (_format_context, _video_stream, s, 0);
-
- avcodec_flush_buffers (video_codec_context());
- if (audio_codec_context ()) {
- avcodec_flush_buffers (audio_codec_context ());
- }
- if (_subtitle_codec_context) {
- avcodec_flush_buffers (_subtitle_codec_context);
- }
-}
-
void
FFmpegDecoder::seek (ContentTime time, bool accurate)
{
VideoDecoder::seek (time, accurate);
AudioDecoder::seek (time, accurate);
-
- /* If we are doing an accurate seek, our initial shot will be 2s (2 being
- a number plucked from the air) earlier than we want to end up. The loop below
- will hopefully then step through to where we want to be.
+ SubtitleDecoder::seek (time, accurate);
+
+ /* If we are doing an `accurate' seek, we need to use pre-roll, as
+ we don't really know what the seek will give us.
*/
ContentTime pre_roll = accurate ? ContentTime::from_seconds (2) : ContentTime (0);
- ContentTime initial_seek = time - pre_roll;
- if (initial_seek < ContentTime (0)) {
- initial_seek = ContentTime (0);
- }
+ time -= pre_roll;
- /* Initial seek time in the video stream's timebase */
-
- seek_and_flush (initial_seek);
+ /* XXX: it seems debatable whether PTS should be used here...
+ http://www.mjbshaw.com/2012/04/seeking-in-ffmpeg-know-your-timestamp.html
+ */
+
+ ContentTime const u = time - _pts_offset;
+ av_seek_frame (_format_context, _video_stream, u.seconds() / av_q2d (_format_context->streams[_video_stream]->time_base), 0);
- if (!accurate) {
- /* That'll do */
- return;
+ avcodec_flush_buffers (video_codec_context());
+ if (audio_codec_context ()) {
+ avcodec_flush_buffers (audio_codec_context ());
}
-
- int const N = minimal_run (boost::bind (&FFmpegDecoder::seek_overrun_finished, this, time, _1, _2));
-
- seek_and_flush (initial_seek);
- if (N > 0) {
- minimal_run (boost::bind (&FFmpegDecoder::seek_final_finished, this, N - 1, _3));
+ if (subtitle_codec_context ()) {
+ avcodec_flush_buffers (subtitle_codec_context ());
}
}
while (copy_packet.size > 0) {
int frame_finished;
- int const decode_result = avcodec_decode_audio4 (audio_codec_context(), _frame, &frame_finished, ©_packet);
-
+ int decode_result = avcodec_decode_audio4 (audio_codec_context(), _frame, &frame_finished, ©_packet);
if (decode_result < 0) {
- _log->log (String::compose ("avcodec_decode_audio4 failed (%1)", decode_result));
- return;
+ /* avcodec_decode_audio4 can sometimes return an error even though it has decoded
+ some valid data; for example dca_subframe_footer can return AVERROR_INVALIDDATA
+ if it overreads the auxiliary data. ffplay carries on if frame_finished is true,
+ even in the face of such an error, so I think we should too.
+
+ Returning from the method here caused mantis #352.
+ */
+ LOG_WARNING ("avcodec_decode_audio4 failed (%1)", decode_result);
+
+ /* Fudge decode_result so that we come out of the while loop when
+ we've processed this data.
+ */
+ decode_result = copy_packet.size;
}
if (frame_finished) {
if (i == _filter_graphs.end ()) {
graph.reset (new FilterGraph (_ffmpeg_content, dcp::Size (_frame->width, _frame->height), (AVPixelFormat) _frame->format));
_filter_graphs.push_back (graph);
- _log->log (String::compose (N_("New graph for %1x%2, pixel format %3"), _frame->width, _frame->height, _frame->format));
+ LOG_GENERAL (N_("New graph for %1x%2, pixel format %3"), _frame->width, _frame->height, _frame->format);
} else {
graph = *i;
}
if (i->second != AV_NOPTS_VALUE) {
double const pts = i->second * av_q2d (_format_context->streams[_video_stream]->time_base) + _pts_offset.seconds ();
- video (image, rint (pts * _ffmpeg_content->video_frame_rate ()));
+ video (
+ shared_ptr<ImageProxy> (new RawImageProxy (image)),
+ rint (pts * _ffmpeg_content->video_frame_rate ())
+ );
} else {
- _log->log ("Dropping frame without PTS");
+ LOG_WARNING_NC ("Dropping frame without PTS");
}
}
return true;
}
-
-
-void
-FFmpegDecoder::setup_subtitle ()
-{
- boost::mutex::scoped_lock lm (_mutex);
-
- if (!_ffmpeg_content->subtitle_stream()) {
- return;
- }
-
- _subtitle_codec_context = _ffmpeg_content->subtitle_stream()->stream(_format_context)->codec;
- if (_subtitle_codec_context == 0) {
- throw DecodeError (N_("could not find subtitle stream"));
- }
-
- _subtitle_codec = avcodec_find_decoder (_subtitle_codec_context->codec_id);
-
- if (_subtitle_codec == 0) {
- throw DecodeError (N_("could not find subtitle decoder"));
- }
- if (avcodec_open2 (_subtitle_codec_context, _subtitle_codec, 0) < 0) {
- throw DecodeError (N_("could not open subtitle decoder"));
- }
-}
-
void
FFmpegDecoder::decode_subtitle_packet ()
{
int got_subtitle;
AVSubtitle sub;
- if (avcodec_decode_subtitle2 (_subtitle_codec_context, &sub, &got_subtitle, &_packet) < 0 || !got_subtitle) {
+ if (avcodec_decode_subtitle2 (subtitle_codec_context(), &sub, &got_subtitle, &_packet) < 0 || !got_subtitle) {
return;
}
-
- /* Sometimes we get an empty AVSubtitle, which is used by some codecs to
- indicate that the previous subtitle should stop.
- */
+
if (sub.num_rects <= 0) {
- image_subtitle (ContentTime (), ContentTime (), shared_ptr<Image> (), dcpomatic::Rect<double> ());
+ /* Sometimes we get an empty AVSubtitle, which is used by some codecs to
+ indicate that the previous subtitle should stop. We can ignore it here.
+ */
return;
} else if (sub.num_rects > 1) {
throw DecodeError (_("multi-part subtitles not yet supported"));
}
-
+
/* Subtitle PTS (within the source, not taking into account any of the
- source that we may have chopped off for the DCP)
+ source that we may have chopped off for the DCP).
*/
- ContentTime packet_time = ContentTime::from_seconds (static_cast<double> (sub.pts) / AV_TIME_BASE) + _pts_offset;
+ FFmpegSubtitlePeriod sub_period = subtitle_period (sub);
+ ContentTimePeriod period;
+ period.from = sub_period.from + _pts_offset;
+ if (sub_period.to) {
+ /* We already know the subtitle period `to' time */
+ period.to = sub_period.to.get() + _pts_offset;
+ } else {
+ /* We have to look up the `to' time in the stream's records */
+ period.to = ffmpeg_content()->subtitle_stream()->find_subtitle_to (sub_period.from);
+ }
- /* hence start time for this sub */
- ContentTime const from = packet_time + ContentTime::from_seconds (sub.start_display_time / 1e3);
- ContentTime const to = packet_time + ContentTime::from_seconds (sub.end_display_time / 1e3);
-
AVSubtitleRect const * rect = sub.rects[0];
if (rect->type != SUBTITLE_BITMAP) {
- /* XXX */
- // throw DecodeError (_("non-bitmap subtitles not yet supported"));
- return;
+ throw DecodeError (_("non-bitmap subtitles not yet supported"));
}
/* Note RGBA is expressed little-endian, so the first byte in the word is R, second
}
dcp::Size const vs = _ffmpeg_content->video_size ();
-
- image_subtitle (
- from,
- to,
- image,
- dcpomatic::Rect<double> (
- static_cast<double> (rect->x) / vs.width,
- static_cast<double> (rect->y) / vs.height,
- static_cast<double> (rect->w) / vs.width,
- static_cast<double> (rect->h) / vs.height
- )
+ dcpomatic::Rect<double> const scaled_rect (
+ static_cast<double> (rect->x) / vs.width,
+ static_cast<double> (rect->y) / vs.height,
+ static_cast<double> (rect->w) / vs.width,
+ static_cast<double> (rect->h) / vs.height
);
+
+ image_subtitle (ContentTimePeriod (period.from, period.to), image, scaled_rect);
avsubtitle_free (&sub);
}
+
+list<ContentTimePeriod>
+FFmpegDecoder::image_subtitles_during (ContentTimePeriod p, bool starting) const
+{
+ return _ffmpeg_content->subtitles_during (p, starting);
+}
+
+list<ContentTimePeriod>
+FFmpegDecoder::text_subtitles_during (ContentTimePeriod, bool) const
+{
+ return list<ContentTimePeriod> ();
+}