X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fffmpeg_examiner.cc;h=d9bcedfc528f196ba9a85b064d1f3900f32fdbbc;hb=3574212ee42b2bd924eb95d5c0f4f69ec9e0a2f0;hp=e5d356a27b7b213ffeaaa2a04f6e09f9c168ca94;hpb=f1bf21a9c2581591ab80bfc997a22b93046f8c56;p=dcpomatic.git diff --git a/src/lib/ffmpeg_examiner.cc b/src/lib/ffmpeg_examiner.cc index e5d356a27..d9bcedfc5 100644 --- a/src/lib/ffmpeg_examiner.cc +++ b/src/lib/ffmpeg_examiner.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2013 Carl Hetherington + Copyright (C) 2013-2014 Carl Hetherington This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -23,10 +23,18 @@ extern "C" { } #include "ffmpeg_examiner.h" #include "ffmpeg_content.h" +#include "ffmpeg_audio_stream.h" +#include "ffmpeg_subtitle_stream.h" +#include "util.h" + +#include "i18n.h" using std::string; +using std::cout; +using std::max; using std::stringstream; using boost::shared_ptr; +using boost::optional; FFmpegExaminer::FFmpegExaminer (shared_ptr c) : FFmpeg (c) @@ -47,40 +55,159 @@ FFmpegExaminer::FFmpegExaminer (shared_ptr c) _audio_streams.push_back ( shared_ptr ( - new FFmpegAudioStream (stream_name (s), i, s->codec->sample_rate, s->codec->channels) + new FFmpegAudioStream (audio_stream_name (s), s->id, s->codec->sample_rate, s->codec->channels) ) ); } else if (s->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) { - _subtitle_streams.push_back (shared_ptr (new FFmpegSubtitleStream (stream_name (s), i))); + _subtitle_streams.push_back (shared_ptr (new FFmpegSubtitleStream (subtitle_stream_name (s), s->id))); } } + /* Run through until we find: + * - the first video. + * - the first audio for each stream. + * - the subtitle periods for each stream. + * + * We have to note subtitle periods as otherwise we have no way of knowing + * where we should look for subtitles (video and audio are always present, + * so they are ok). + */ + while (1) { + int r = av_read_frame (_format_context, &_packet); + if (r < 0) { + break; + } + + AVCodecContext* context = _format_context->streams[_packet.stream_index]->codec; + + if (_packet.stream_index == _video_stream) { + video_packet (context); + } + + for (size_t i = 0; i < _audio_streams.size(); ++i) { + if (_audio_streams[i]->uses_index (_format_context, _packet.stream_index)) { + audio_packet (context, _audio_streams[i]); + } + } + + for (size_t i = 0; i < _subtitle_streams.size(); ++i) { + if (_subtitle_streams[i]->uses_index (_format_context, _packet.stream_index)) { + subtitle_packet (context, _subtitle_streams[i]); + } + } + + av_free_packet (&_packet); + } } -float -FFmpegExaminer::video_frame_rate () const +void +FFmpegExaminer::video_packet (AVCodecContext* context) { - AVStream* s = _format_context->streams[_video_stream]; + if (_first_video) { + return; + } - if (s->avg_frame_rate.num && s->avg_frame_rate.den) { - return av_q2d (s->avg_frame_rate); + int frame_finished; + if (avcodec_decode_video2 (context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) { + _first_video = frame_time (_format_context->streams[_video_stream]); + } +} + +void +FFmpegExaminer::audio_packet (AVCodecContext* context, shared_ptr stream) +{ + if (stream->first_audio) { + return; + } + + int frame_finished; + if (avcodec_decode_audio4 (context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) { + stream->first_audio = frame_time (stream->stream (_format_context)); + } +} + +void +FFmpegExaminer::subtitle_packet (AVCodecContext* context, shared_ptr stream) +{ + int frame_finished; + AVSubtitle sub; + if (avcodec_decode_subtitle2 (context, &sub, &frame_finished, &_packet) >= 0 && frame_finished) { + ContentTimePeriod const period = subtitle_period (sub); + if (sub.num_rects == 0 && !stream->periods.empty () && stream->periods.back().to > period.from) { + /* Finish the last subtitle */ + stream->periods.back().to = period.from; + } else if (sub.num_rects == 1) { + stream->periods.push_back (period); + } + } +} + +optional +FFmpegExaminer::frame_time (AVStream* s) const +{ + optional t; + + int64_t const bet = av_frame_get_best_effort_timestamp (_frame); + if (bet != AV_NOPTS_VALUE) { + t = ContentTime::from_seconds (bet * av_q2d (s->time_base)); } - return av_q2d (s->r_frame_rate); + return t; } -libdcp::Size +float +FFmpegExaminer::video_frame_rate () const +{ + /* This use of r_frame_rate is debateable; there's a few different + * frame rates in the format context, but this one seems to be the most + * reliable. + */ + return av_q2d (av_stream_get_r_frame_rate (_format_context->streams[_video_stream])); +} + +dcp::Size FFmpegExaminer::video_size () const { - return libdcp::Size (_video_codec_context->width, _video_codec_context->height); + return dcp::Size (video_codec_context()->width, video_codec_context()->height); } -/** @return Length (in video frames) according to our content's header */ -ContentVideoFrame +/** @return Length according to our content's header */ +ContentTime FFmpegExaminer::video_length () const { - return (double (_format_context->duration) / AV_TIME_BASE) * video_frame_rate(); + ContentTime const length = ContentTime::from_seconds (double (_format_context->duration - _format_context->start_time) / AV_TIME_BASE); + return ContentTime (max (int64_t (1), length.get ())); +} + +string +FFmpegExaminer::audio_stream_name (AVStream* s) const +{ + stringstream n; + + n << stream_name (s); + + if (!n.str().empty()) { + n << "; "; + } + + n << s->codec->channels << " channels"; + + return n.str (); +} + +string +FFmpegExaminer::subtitle_stream_name (AVStream* s) const +{ + stringstream n; + + n << stream_name (s); + + if (n.str().empty()) { + n << _("unknown"); + } + + return n.str (); } string @@ -103,9 +230,5 @@ FFmpegExaminer::stream_name (AVStream* s) const } } - if (n.str().empty()) { - n << "unknown"; - } - return n.str (); }