#include "ffmpeg.h"
#include "indexfile.h"
#include "interlacemodes.h"
+#ifdef HAVE_DV
#include "libdv.h"
+#endif
#include "libmjpeg.h"
#include "mainerror.h"
#include "mwindow.h"
fmt_ctx = 0;
avctx = 0;
filter_graph = 0;
+ filt_ctx = 0;
+ filt_id = 0;
buffersrc_ctx = 0;
buffersink_ctx = 0;
frm_count = 0;
nudge = AV_NOPTS_VALUE;
seek_pos = curr_pos = 0;
- seeked = 1; eof = 0;
+ seeking = 0; seeked = 1;
+ eof = 0;
reading = writing = 0;
hw_pixfmt = AV_PIX_FMT_NONE;
hw_device_ctx = 0;
{
return AV_HWDEVICE_TYPE_NONE;
}
-
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFStream::decode_hw_format(const AVCodec *decoder, AVHWDeviceType type)
+#else
int FFStream::decode_hw_format(AVCodec *decoder, AVHWDeviceType type)
+#endif
{
return 0;
}
}
while( ret >= 0 && st != 0 && !reading ) {
AVCodecID codec_id = st->codecpar->codec_id;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVCodec *decoder = 0;
+#else
AVCodec *decoder = 0;
+#endif
if( is_video() ) {
if( ffmpeg->opt_video_decoder )
decoder = avcodec_find_decoder_by_name(ffmpeg->opt_video_decoder);
ret = avcodec_send_frame(avctx, frame);
if( !ret && frame ) return pkts;
if( ret < 0 && ret != AVERROR(EAGAIN) ) break;
+ if ( ret == AVERROR(EAGAIN) && !frame ) continue;
FFPacket opkt;
ret = avcodec_receive_packet(avctx, opkt);
if( !frame && ret == AVERROR_EOF ) return pkts;
}
}
if( pos == curr_pos ) return 0;
+ seeking = -1;
double secs = pos < 0 ? 0. : pos / rate;
AVRational time_base = st->time_base;
int64_t tstmp = time_base.num > 0 ? secs * time_base.den/time_base.num : 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int nb_index_entries = avformat_index_get_entries_count(st);
+#endif
if( !tstmp ) {
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ if( nb_index_entries > 0 ) tstmp = (avformat_index_get_entry(st, 0))->timestamp;
+#else
if( st->nb_index_entries > 0 ) tstmp = st->index_entries[0].timestamp;
+#endif
else if( st->start_time != AV_NOPTS_VALUE ) tstmp = st->start_time;
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
else if( st->first_dts != AV_NOPTS_VALUE ) tstmp = st->first_dts;
+#endif
else tstmp = INT64_MIN+1;
}
else if( nudge != AV_NOPTS_VALUE ) tstmp += nudge;
top_field_first = 0;
color_space = -1;
color_range = -1;
+ fconvert_ctx = 0;
}
FFVideoStream::~FFVideoStream()
{
+ if( fconvert_ctx ) sws_freeContext(fconvert_ctx);
}
AVHWDeviceType FFVideoStream::decode_hw_activate()
}
return type;
}
-
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFVideoStream::decode_hw_format(const AVCodec *decoder, AVHWDeviceType type)
+#else
int FFVideoStream::decode_hw_format(AVCodec *decoder, AVHWDeviceType type)
+#endif
{
int ret = 0;
hw_pix_fmt = AV_PIX_FMT_NONE;
return 1;
}
+int FFVideoStream::probe(int64_t pos)
+{
+ int ret = video_seek(pos);
+ if( ret < 0 ) return -1;
+ if( !frame && !(frame=av_frame_alloc()) ) {
+ fprintf(stderr, "FFVideoStream::probe: av_frame_alloc failed\n");
+ return -1;
+ }
+
+ if (ffmpeg->interlace_from_codec) return 1;
+
+ ret = read_frame(frame);
+ if( ret > 0 ) {
+ //printf("codec interlace: %i \n",frame->interlaced_frame);
+ //printf("codec tff: %i \n",frame->top_field_first);
+
+ if (!frame->interlaced_frame)
+ ffmpeg->interlace_from_codec = AV_FIELD_PROGRESSIVE;
+ if ((frame->interlaced_frame) && (frame->top_field_first))
+ ffmpeg->interlace_from_codec = AV_FIELD_TT;
+ if ((frame->interlaced_frame) && (!frame->top_field_first))
+ ffmpeg->interlace_from_codec = AV_FIELD_BB;
+ //printf("Interlace mode from codec: %i\n", ffmpeg->interlace_from_codec);
+
+ }
+
+ if( frame->format == AV_PIX_FMT_NONE || frame->width <= 0 || frame->height <= 0 )
+ ret = -1;
+
+ ret = ret > 0 ? 1 : ret < 0 ? -1 : 0;
+ av_frame_free(&frame);
+ return ret;
+}
+
int FFVideoStream::load(VFrame *vframe, int64_t pos)
{
int ret = video_seek(pos);
fprintf(stderr, "FFVideoStream::load: av_frame_alloc failed\n");
return -1;
}
+
+
int i = MAX_RETRY + pos - curr_pos;
+ int64_t cache_start = 0;
while( ret>=0 && !flushed && curr_pos<=pos && --i>=0 ) {
ret = read_frame(frame);
- if( ret > 0 ) ++curr_pos;
+ if( ret > 0 ) {
+ if( frame->key_frame && seeking < 0 ) {
+ int use_cache = ffmpeg->get_use_cache();
+ if( use_cache < 0 ) {
+// for reverse read, reload file frame_cache from keyframe to pos
+ ffmpeg->purge_cache();
+ int count = preferences->cache_size /
+ vframe->get_data_size() / 2; // try to burn only 1/2 of cache
+ cache_start = pos - count + 1;
+ seeking = 1;
+ }
+ else
+ seeking = 0;
+ }
+ if( seeking > 0 && curr_pos >= cache_start && curr_pos < pos ) {
+ int vw =vframe->get_w(), vh = vframe->get_h();
+ int vcolor_model = vframe->get_color_model();
+// do not use shm here, puts too much pressure on 32bit systems
+ VFrame *cache_frame = new VFrame(vw, vh, vcolor_model, 0);
+ ret = convert_cmodel(cache_frame, frame);
+ if( ret > 0 )
+ ffmpeg->put_cache_frame(cache_frame, curr_pos);
+ }
+ ++curr_pos;
+ }
}
+ seeking = 0;
if( frame->format == AV_PIX_FMT_NONE || frame->width <= 0 || frame->height <= 0 )
ret = -1;
if( ret >= 0 ) {
return ret;
}
+int FFVideoStream::convert_hw_frame(AVFrame *ifrm, AVFrame *ofrm)
+{
+ AVPixelFormat ifmt = (AVPixelFormat)ifrm->format;
+ AVPixelFormat ofmt = (AVPixelFormat)st->codecpar->format;
+ ofrm->width = ifrm->width;
+ ofrm->height = ifrm->height;
+ ofrm->format = ofmt;
+ int ret = av_frame_get_buffer(ofrm, 32);
+ if( ret < 0 ) {
+ ff_err(ret, "FFVideoStream::convert_hw_frame:"
+ " av_frame_get_buffer failed\n");
+ return -1;
+ }
+ fconvert_ctx = sws_getCachedContext(fconvert_ctx,
+ ifrm->width, ifrm->height, ifmt,
+ ofrm->width, ofrm->height, ofmt,
+ SWS_POINT, NULL, NULL, NULL);
+ if( !fconvert_ctx ) {
+ ff_err(AVERROR(EINVAL), "FFVideoStream::convert_hw_frame:"
+ " sws_getCachedContext() failed\n");
+ return -1;
+ }
+ int codec_range = st->codecpar->color_range;
+ int codec_space = st->codecpar->color_space;
+ const int *codec_table = sws_getCoefficients(codec_space);
+ int *inv_table, *table, src_range, dst_range;
+ int brightness, contrast, saturation;
+ if( !sws_getColorspaceDetails(fconvert_ctx,
+ &inv_table, &src_range, &table, &dst_range,
+ &brightness, &contrast, &saturation) ) {
+ if( src_range != codec_range || dst_range != codec_range ||
+ inv_table != codec_table || table != codec_table )
+ sws_setColorspaceDetails(fconvert_ctx,
+ codec_table, codec_range, codec_table, codec_range,
+ brightness, contrast, saturation);
+ }
+ ret = sws_scale(fconvert_ctx,
+ ifrm->data, ifrm->linesize, 0, ifrm->height,
+ ofrm->data, ofrm->linesize);
+ if( ret < 0 ) {
+ ff_err(ret, "FFVideoStream::convert_hw_frame:"
+ " sws_scale() failed\nfile: %s\n",
+ ffmpeg->fmt_ctx->url);
+ return -1;
+ }
+ return 0;
+}
+
+int FFVideoStream::load_filter(AVFrame *frame)
+{
+ AVPixelFormat pix_fmt = (AVPixelFormat)frame->format;
+ if( pix_fmt == hw_pixfmt ) {
+ AVFrame *hw_frame = this->frame;
+ av_frame_unref(hw_frame);
+ int ret = av_hwframe_transfer_data(hw_frame, frame, 0);
+ if( ret < 0 ) {
+ eprintf(_("Error retrieving data from GPU to CPU\nfile: %s\n"),
+ ffmpeg->fmt_ctx->url);
+ return -1;
+ }
+ av_frame_unref(frame);
+ ret = convert_hw_frame(hw_frame, frame);
+ if( ret < 0 ) {
+ eprintf(_("Error converting data from GPU to CPU\nfile: %s\n"),
+ ffmpeg->fmt_ctx->url);
+ return -1;
+ }
+ av_frame_unref(hw_frame);
+ }
+ return FFStream::load_filter(frame);
+}
+
int FFVideoStream::encode(VFrame *vframe)
{
if( encode_activate() <= 0 ) return -1;
int FFVideoStream::drain()
{
+
return 0;
}
}
int color_space = SWS_CS_ITU601;
switch( preferences->yuv_color_space ) {
- case BC_COLORS_BT601: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_PAL: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_NTSC: color_space = SWS_CS_SMPTE170M; break;
case BC_COLORS_BT709: color_space = SWS_CS_ITU709; break;
- case BC_COLORS_BT2020: color_space = SWS_CS_BT2020; break;
+ case BC_COLORS_BT2020_NCL:
+ case BC_COLORS_BT2020_CL: color_space = SWS_CS_BT2020; break;
}
const int *color_table = sws_getCoefficients(color_space);
}
int color_space = SWS_CS_ITU601;
switch( preferences->yuv_color_space ) {
- case BC_COLORS_BT601: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_PAL: color_space = SWS_CS_ITU601; break;
+ case BC_COLORS_BT601_NTSC: color_space = SWS_CS_SMPTE170M; break;
case BC_COLORS_BT709: color_space = SWS_CS_ITU709; break;
- case BC_COLORS_BT2020: color_space = SWS_CS_BT2020; break;
+ case BC_COLORS_BT2020_NCL:
+ case BC_COLORS_BT2020_CL: color_space = SWS_CS_BT2020; break;
}
const int *color_table = sws_getCoefficients(color_space);
return !index_state ? 0 : index_state->video_markers[idx];
}
-double FFVideoStream::get_rotation_angle()
-{
- int size = 0;
- int *matrix = (int*)av_stream_get_side_data(st, AV_PKT_DATA_DISPLAYMATRIX, &size);
- int len = size/sizeof(*matrix);
- if( !matrix || len < 5 ) return 0;
- const double s = 1/65536.;
- double theta = (!matrix[0] && !matrix[3]) || (!matrix[1] && !matrix[4]) ? 0 :
- atan2( s*matrix[1] / hypot(s*matrix[1], s*matrix[4]),
- s*matrix[0] / hypot(s*matrix[0], s*matrix[3])) * 180/M_PI;
- return theta;
-}
-
-void FFVideoStream::flip()
-{
- transpose = 0;
- if( !ffmpeg->file_base ) return;
- double theta = get_rotation_angle(), tolerance = 1;
- if( fabs(theta-0) < tolerance ) return;
- if( fabs(theta-90) < tolerance ) {
- create_filter("transpose=clock", st->codecpar);
- transpose = 1;
- }
- else if( fabs(theta-180) < tolerance ) {
- create_filter("hflip", st->codecpar);
- create_filter("vflip", st->codecpar);
- }
- else if (fabs(theta-270) < tolerance ) {
- create_filter("transpose=cclock", st->codecpar);
- transpose = 1;
- }
- else {
- char rotate[BCSTRLEN];
- sprintf(rotate, "rotate=%f", theta*M_PI/180.);
- create_filter(rotate, st->codecpar);
- }
-}
-
FFMPEG::FFMPEG(FileBase *file_base)
{
flow = 1;
decoding = encoding = 0;
has_audio = has_video = 0;
+ interlace_from_codec = 0;
opts = 0;
opt_duration = -1;
opt_video_filter = 0;
delete [] opt_hw_dev;
}
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFMPEG::check_sample_rate(const AVCodec *codec, int sample_rate)
+#else
int FFMPEG::check_sample_rate(AVCodec *codec, int sample_rate)
+#endif
{
const int *p = codec->supported_samplerates;
if( !p ) return sample_rate;
return 0;
}
+// check_frame_rate and std_frame_rate needed for 23.976
+// and 59.94 fps mpeg2
static inline AVRational std_frame_rate(int i)
{
static const int m1 = 1001*12, m2 = 1000*12;
static const int freqs[] = {
40*m1, 48*m1, 50*m1, 60*m1, 80*m1,120*m1, 240*m1,
- 24*m2, 30*m2, 60*m2, 12*m2, 15*m2, 48*m2, 0,
+ 24*m2, 30*m2, 60*m2, 12*m2, 15*m2, 48*m2, 90*m2,
+ 100*m2, 120*m2, 144*m2, 72*m2, 0,
};
int freq = i<30*12 ? (i+1)*1001 : freqs[i-30*12];
return (AVRational) { freq, 1001*12 };
cin_fmt = (int)av_get_sample_fmt(cin_sample_fmt);
if( cin_fmt < 0 ) {
char audio_codec[BCSTRLEN]; audio_codec[0] = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+ const AVCodec *av_codec = !FFMPEG::get_codec(audio_codec, "audio", asset->acodec) ?
+#else
AVCodec *av_codec = !FFMPEG::get_codec(audio_codec, "audio", asset->acodec) ?
+#endif
avcodec_find_encoder_by_name(audio_codec) : 0;
if( av_codec && av_codec->sample_fmts )
cin_fmt = find_best_sample_fmt_of_list(av_codec->sample_fmts, AV_SAMPLE_FMT_FLT);
cin_fmt = (int)av_get_pix_fmt(cin_pix_fmt);
if( cin_fmt < 0 ) {
char video_codec[BCSTRLEN]; video_codec[0] = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+ const AVCodec *av_codec = !get_codec(video_codec, "video", asset->vcodec) ?
+#else
AVCodec *av_codec = !get_codec(video_codec, "video", asset->vcodec) ?
+#endif
avcodec_find_encoder_by_name(video_codec) : 0;
if( av_codec && av_codec->pix_fmts ) {
if( 0 && edl ) { // frequently picks a bad answer
return ret;
}
+void FFMPEG::put_cache_frame(VFrame *frame, int64_t position)
+{
+ file_base->file->put_cache_frame(frame, position, 0);
+}
+
+int FFMPEG::get_use_cache()
+{
+ return file_base->file->get_use_cache();
+}
+
+void FFMPEG::purge_cache()
+{
+ file_base->file->purge_cache();
+}
+
FFCodecRemap::FFCodecRemap()
{
old_codec = 0;
return 0;
}
-
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+int FFCodecRemaps::update(AVCodecID &codec_id, const AVCodec *&decoder)
+{
+ const AVCodec *codec = avcodec_find_decoder(codec_id);
+#else
int FFCodecRemaps::update(AVCodecID &codec_id, AVCodec *&decoder)
{
AVCodec *codec = avcodec_find_decoder(codec_id);
+#endif
if( !codec ) return -1;
const char *name = codec->name;
FFCodecRemaps &map = *this;
AVPixelFormat pix_fmt = (AVPixelFormat)st->codecpar->format;
const char *pfn = av_get_pix_fmt_name(pix_fmt);
report(" pix %s\n", pfn ? pfn : unkn);
+ int interlace = st->codecpar->field_order;
+ report(" interlace (container level): %i\n", interlace ? interlace : -1);
+ int interlace_codec = interlace_from_codec;
+ report(" interlace (codec level): %i\n", interlace_codec ? interlace_codec : -1);
enum AVColorSpace space = st->codecpar->color_space;
const char *nm = av_color_space_name(space);
report(" color space:%s", nm ? nm : unkn);
char *sp = strrchr(bp, '.');
if( !sp ) sp = bp + strlen(bp);
FILE *fp = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+ const AVInputFormat *ifmt = 0;
+#else
AVInputFormat *ifmt = 0;
+#endif
if( sp ) {
strcpy(sp, ".opts");
fp = fopen(file_opts, "r");
}
switch( avpar->color_space ) {
case AVCOL_SPC_BT470BG:
+ vid->color_space = BC_COLORS_BT601_PAL;
+ break;
case AVCOL_SPC_SMPTE170M:
- vid->color_space = BC_COLORS_BT601;
+ vid->color_space = BC_COLORS_BT601_NTSC;
break;
case AVCOL_SPC_BT709:
vid->color_space = BC_COLORS_BT709;
break;
case AVCOL_SPC_BT2020_NCL:
+ vid->color_space = BC_COLORS_BT2020_NCL;
+ break;
case AVCOL_SPC_BT2020_CL:
- vid->color_space = BC_COLORS_BT2020;
+ vid->color_space = BC_COLORS_BT2020_CL;
break;
default:
- vid->color_space = !file_base ? BC_COLORS_BT601 :
+ vid->color_space = !file_base ? BC_COLORS_BT601_NTSC :
file_base->file->preferences->yuv_color_space;
break;
}
vid->aspect_ratio = (double)st->sample_aspect_ratio.num / st->sample_aspect_ratio.den;
vid->nudge = st->start_time;
vid->reading = -1;
- if( opt_video_filter )
- ret = vid->create_filter(opt_video_filter, avpar);
- if( file_base && file_base->file->preferences->auto_rotate )
- vid->flip();
+ ret = vid->create_filter(opt_video_filter);
break; }
case AVMEDIA_TYPE_AUDIO: {
if( avpar->channels < 1 ) continue;
aud->init_swr(aud->channels, avpar->format, aud->sample_rate);
aud->nudge = st->start_time;
aud->reading = -1;
- if( opt_audio_filter )
- ret = aud->create_filter(opt_audio_filter, avpar);
+ ret = aud->create_filter(opt_audio_filter);
break; }
default: break;
}
AVCodecContext *ctx = 0;
const AVCodecDescriptor *codec_desc = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVCodec *codec = avcodec_find_encoder_by_name(codec_name);
+#else
AVCodec *codec = avcodec_find_encoder_by_name(codec_name);
+#endif
if( !codec ) {
eprintf(_("cant find codec %s:%s\n"), codec_name, filename);
ret = 1;
if( (vid->color_space = asset->ff_color_space) < 0 )
vid->color_space = file_base->file->preferences->yuv_color_space;
switch( vid->color_space ) {
- case BC_COLORS_BT601: ctx->colorspace = AVCOL_SPC_SMPTE170M; break;
+ case BC_COLORS_BT601_NTSC: ctx->colorspace = AVCOL_SPC_SMPTE170M; break;
+ case BC_COLORS_BT601_PAL: ctx->colorspace = AVCOL_SPC_BT470BG; break;
case BC_COLORS_BT709: ctx->colorspace = AVCOL_SPC_BT709; break;
- case BC_COLORS_BT2020: ctx->colorspace = AVCOL_SPC_BT2020_NCL; break;
+ case BC_COLORS_BT2020_NCL: ctx->colorspace = AVCOL_SPC_BT2020_NCL; break;
+ case BC_COLORS_BT2020_CL: ctx->colorspace = AVCOL_SPC_BT2020_CL; break;
}
AVPixelFormat pix_fmt = av_get_pix_fmt(asset->ff_pixel_format);
if( opt_hw_dev != 0 ) {
int mask_h = (1<<desc->log2_chroma_h)-1;
ctx->height = (vid->height+mask_h) & ~mask_h;
ctx->sample_aspect_ratio = to_sample_aspect_ratio(asset);
- AVRational frame_rate = check_frame_rate(codec->supported_framerates, vid->frame_rate);
+ AVRational frame_rate;
+ if (ctx->codec->id == AV_CODEC_ID_MPEG1VIDEO ||
+ ctx->codec->id == AV_CODEC_ID_MPEG2VIDEO)
+ frame_rate = check_frame_rate(codec->supported_framerates, vid->frame_rate);
+ else
+ frame_rate = av_d2q(vid->frame_rate, INT_MAX);
if( !frame_rate.num || !frame_rate.den ) {
eprintf(_("check_frame_rate failed %s\n"), filename);
ret = 1;
vid->interlaced = asset->interlace_mode == ILACE_MODE_TOP_FIRST ||
asset->interlace_mode == ILACE_MODE_BOTTOM_FIRST ? 1 : 0;
vid->top_field_first = asset->interlace_mode == ILACE_MODE_TOP_FIRST ? 1 : 0;
+ switch (asset->interlace_mode) {
+ case ILACE_MODE_TOP_FIRST:
+ if (ctx->codec->id == AV_CODEC_ID_MJPEG)
+ av_dict_set(&sopts, "field_order", "tt", 0);
+ else
+ av_dict_set(&sopts, "field_order", "tb", 0);
+ if (ctx->codec_id != AV_CODEC_ID_MJPEG)
+ av_dict_set(&sopts, "flags", "+ilme+ildct", 0);
+ break;
+ case ILACE_MODE_BOTTOM_FIRST:
+ if (ctx->codec->id == AV_CODEC_ID_MJPEG)
+ av_dict_set(&sopts, "field_order", "bb", 0);
+ else
+ av_dict_set(&sopts, "field_order", "bt", 0);
+ if (ctx->codec_id != AV_CODEC_ID_MJPEG)
+ av_dict_set(&sopts, "flags", "+ilme+ildct", 0);
+ break;
+ case ILACE_MODE_NOTINTERLACED: av_dict_set(&sopts, "field_order", "progressive", 0); break;
+ }
break; }
default:
eprintf(_("not audio/video, %s:%s\n"), codec_name, filename);
}
if( ret >= 0 ) {
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
ret = avcodec_copy_context(st->codec, ctx);
+#else
+ ret = avcodec_parameters_to_context(ctx, st->codecpar);
+#endif
_Pragma("GCC diagnostic warning \"-Wdeprecated-declarations\"")
if( ret < 0 )
fprintf(stderr, "Could not copy the stream context\n");
return 0;
}
+int FFMPEG::video_probe(int64_t pos)
+{
+ int vidx = vstrm_index[0].st_idx;
+ FFVideoStream *vid = ffvideo[vidx];
+ vid->probe(pos);
+
+ int interlace1 = interlace_from_codec;
+ //printf("interlace from codec: %i\n", interlace1);
+
+ switch (interlace1)
+ {
+ case AV_FIELD_TT:
+ case AV_FIELD_TB:
+ return ILACE_MODE_TOP_FIRST;
+ case AV_FIELD_BB:
+ case AV_FIELD_BT:
+ return ILACE_MODE_BOTTOM_FIRST;
+ case AV_FIELD_PROGRESSIVE:
+ return ILACE_MODE_NOTINTERLACED;
+ default:
+ return ILACE_MODE_UNDETECTED;
+ }
+
+}
+
+
+
int FFMPEG::video_seek(int stream, int64_t pos)
{
int vidx = vstrm_index[stream].st_idx;
float FFMPEG::ff_aspect_ratio(int stream)
{
- return ffvideo[stream]->aspect_ratio;
+ //return ffvideo[stream]->aspect_ratio;
+ AVFormatContext *fmt_ctx = ffvideo[stream]->fmt_ctx;
+ AVStream *strm = ffvideo[stream]->st;
+ AVCodecParameters *par = ffvideo[stream]->st->codecpar;
+ AVRational dar;
+ AVRational sar = av_guess_sample_aspect_ratio(fmt_ctx, strm, NULL);
+ if (sar.num) {
+ av_reduce(&dar.num, &dar.den,
+ par->width * sar.num,
+ par->height * sar.den,
+ 1024*1024);
+ return av_q2d(dar);
+ }
+ return ffvideo[stream]->aspect_ratio;
}
const char* FFMPEG::ff_video_codec(int stream)
return ffvideo[stream]->st->codecpar->color_range == AVCOL_RANGE_MPEG ? 1 : 0;
}
+int FFMPEG::ff_interlace(int stream)
+{
+// https://ffmpeg.org/doxygen/trunk/structAVCodecParserContext.html
+/* reads from demuxer because codec frame not ready */
+ int interlace0 = ffvideo[stream]->st->codecpar->field_order;
+
+ switch (interlace0)
+ {
+ case AV_FIELD_TT:
+ case AV_FIELD_TB:
+ return ILACE_MODE_TOP_FIRST;
+ case AV_FIELD_BB:
+ case AV_FIELD_BT:
+ return ILACE_MODE_BOTTOM_FIRST;
+ case AV_FIELD_PROGRESSIVE:
+ return ILACE_MODE_NOTINTERLACED;
+ default:
+ return ILACE_MODE_UNDETECTED;
+ }
+
+}
+
+
+
int FFMPEG::ff_cpus()
{
return !file_base ? 1 : file_base->file->cpus;
return !file_base ? 0 : file_base->file->preferences;
}
-int FFVideoStream::create_filter(const char *filter_spec, AVCodecParameters *avpar)
+double FFVideoStream::get_rotation_angle()
+{
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ size_t size = 0;
+#else
+ int size = 0;
+#endif
+ int *matrix = (int*)av_stream_get_side_data(st, AV_PKT_DATA_DISPLAYMATRIX, &size);
+ int len = size/sizeof(*matrix);
+ if( !matrix || len < 5 ) return 0;
+ const double s = 1/65536.;
+ double theta = (!matrix[0] && !matrix[3]) || (!matrix[1] && !matrix[4]) ? 0 :
+ atan2( s*matrix[1] / hypot(s*matrix[1], s*matrix[4]),
+ s*matrix[0] / hypot(s*matrix[0], s*matrix[3])) * 180/M_PI;
+ return theta;
+}
+
+int FFVideoStream::flip(double theta)
{
+ int ret = 0;
+ transpose = 0;
+ Preferences *preferences = ffmpeg->ff_prefs();
+ if( !preferences || !preferences->auto_rotate ) return ret;
+ double tolerance = 1;
+ if( fabs(theta-0) < tolerance ) return ret;
+ if( (theta=fmod(theta, 360)) < 0 ) theta += 360;
+ if( fabs(theta-90) < tolerance ) {
+ if( (ret = insert_filter("transpose", "clock")) < 0 )
+ return ret;
+ transpose = 1;
+ }
+ else if( fabs(theta-180) < tolerance ) {
+ if( (ret=insert_filter("hflip", 0)) < 0 )
+ return ret;
+ if( (ret=insert_filter("vflip", 0)) < 0 )
+ return ret;
+ }
+ else if (fabs(theta-270) < tolerance ) {
+ if( (ret=insert_filter("transpose", "cclock")) < 0 )
+ return ret;
+ transpose = 1;
+ }
+ else {
+ char angle[BCSTRLEN];
+ sprintf(angle, "%f", theta*M_PI/180.);
+ if( (ret=insert_filter("rotate", angle)) < 0 )
+ return ret;
+ }
+ return 1;
+}
+
+int FFVideoStream::create_filter(const char *filter_spec)
+{
+ double theta = get_rotation_angle();
+ if( !theta && !filter_spec )
+ return 0;
avfilter_register_all();
- const char *sp = filter_spec;
- char filter_name[BCSTRLEN], *np = filter_name;
- int i = sizeof(filter_name);
- while( --i>=0 && *sp!=0 && !strchr(" \t:=,",*sp) ) *np++ = *sp++;
- *np = 0;
- const AVFilter *filter = !filter_name[0] ? 0 : avfilter_get_by_name(filter_name);
- if( !filter || avfilter_pad_get_type(filter->inputs,0) != AVMEDIA_TYPE_VIDEO ) {
- ff_err(AVERROR(EINVAL), "FFVideoStream::create_filter: %s\n", filter_spec);
- return -1;
+ if( filter_spec ) {
+ const char *sp = filter_spec;
+ char filter_name[BCSTRLEN], *np = filter_name;
+ int i = sizeof(filter_name);
+ while( --i>=0 && *sp!=0 && !strchr(" \t:=,",*sp) ) *np++ = *sp++;
+ *np = 0;
+ const AVFilter *filter = !filter_name[0] ? 0 : avfilter_get_by_name(filter_name);
+ if( !filter || avfilter_pad_get_type(filter->inputs,0) != AVMEDIA_TYPE_VIDEO ) {
+ ff_err(AVERROR(EINVAL), "FFVideoStream::create_filter: %s\n", filter_spec);
+ return -1;
+ }
}
- filter_graph = avfilter_graph_alloc();
- const AVFilter *buffersrc = avfilter_get_by_name("buffer");
- const AVFilter *buffersink = avfilter_get_by_name("buffersink");
+ AVCodecParameters *avpar = st->codecpar;
int sa_num = avpar->sample_aspect_ratio.num;
if( !sa_num ) sa_num = 1;
int sa_den = avpar->sample_aspect_ratio.den;
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
avpar->width, avpar->height, (int)pix_fmt,
st->time_base.num, st->time_base.den, sa_num, sa_den);
+ if( ret >= 0 ) {
+ filt_ctx = 0;
+ ret = insert_filter("buffer", args, "in");
+ buffersrc_ctx = filt_ctx;
+ }
if( ret >= 0 )
- ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
- args, NULL, filter_graph);
- if( ret >= 0 )
- ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
- NULL, NULL, filter_graph);
- if( ret >= 0 )
+ ret = flip(theta);
+ AVFilterContext *fsrc = filt_ctx;
+ if( ret >= 0 ) {
+ filt_ctx = 0;
+ ret = insert_filter("buffersink", 0, "out");
+ buffersink_ctx = filt_ctx;
+ }
+ if( ret >= 0 ) {
ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
(uint8_t*)&pix_fmt, sizeof(pix_fmt),
AV_OPT_SEARCH_CHILDREN);
- if( ret < 0 )
- ff_err(ret, "FFVideoStream::create_filter");
+ }
+ if( ret >= 0 )
+ ret = config_filters(filter_spec, fsrc);
else
- ret = FFStream::create_filter(filter_spec);
+ ff_err(ret, "FFVideoStream::create_filter");
return ret >= 0 ? 0 : -1;
}
-int FFAudioStream::create_filter(const char *filter_spec, AVCodecParameters *avpar)
+int FFAudioStream::create_filter(const char *filter_spec)
{
+ if( !filter_spec )
+ return 0;
avfilter_register_all();
- const char *sp = filter_spec;
- char filter_name[BCSTRLEN], *np = filter_name;
- int i = sizeof(filter_name);
- while( --i>=0 && *sp!=0 && !strchr(" \t:=,",*sp) ) *np++ = *sp++;
- *np = 0;
- const AVFilter *filter = !filter_name[0] ? 0 : avfilter_get_by_name(filter_name);
- if( !filter || avfilter_pad_get_type(filter->inputs,0) != AVMEDIA_TYPE_AUDIO ) {
- ff_err(AVERROR(EINVAL), "FFAudioStream::create_filter: %s\n", filter_spec);
- return -1;
+ if( filter_spec ) {
+ const char *sp = filter_spec;
+ char filter_name[BCSTRLEN], *np = filter_name;
+ int i = sizeof(filter_name);
+ while( --i>=0 && *sp!=0 && !strchr(" \t:=,",*sp) ) *np++ = *sp++;
+ *np = 0;
+ const AVFilter *filter = !filter_name[0] ? 0 : avfilter_get_by_name(filter_name);
+ if( !filter || avfilter_pad_get_type(filter->inputs,0) != AVMEDIA_TYPE_AUDIO ) {
+ ff_err(AVERROR(EINVAL), "FFAudioStream::create_filter: %s\n", filter_spec);
+ return -1;
+ }
}
- filter_graph = avfilter_graph_alloc();
- const AVFilter *buffersrc = avfilter_get_by_name("abuffer");
- const AVFilter *buffersink = avfilter_get_by_name("abuffersink");
int ret = 0; char args[BCTEXTLEN];
+ AVCodecParameters *avpar = st->codecpar;
AVSampleFormat sample_fmt = (AVSampleFormat)avpar->format;
snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%jx",
st->time_base.num, st->time_base.den, avpar->sample_rate,
av_get_sample_fmt_name(sample_fmt), avpar->channel_layout);
- if( ret >= 0 )
- ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
- args, NULL, filter_graph);
- if( ret >= 0 )
- ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
- NULL, NULL, filter_graph);
+ if( ret >= 0 ) {
+ filt_ctx = 0;
+ ret = insert_filter("abuffer", args, "in");
+ buffersrc_ctx = filt_ctx;
+ }
+ AVFilterContext *fsrc = filt_ctx;
+ if( ret >= 0 ) {
+ filt_ctx = 0;
+ ret = insert_filter("abuffersink", 0, "out");
+ buffersink_ctx = filt_ctx;
+ }
if( ret >= 0 )
ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
(uint8_t*)&sample_fmt, sizeof(sample_fmt),
ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
(uint8_t*)&sample_rate, sizeof(sample_rate),
AV_OPT_SEARCH_CHILDREN);
- if( ret < 0 )
- ff_err(ret, "FFAudioStream::create_filter");
+ if( ret >= 0 )
+ ret = config_filters(filter_spec, fsrc);
else
- ret = FFStream::create_filter(filter_spec);
+ ff_err(ret, "FFAudioStream::create_filter");
return ret >= 0 ? 0 : -1;
}
-int FFStream::create_filter(const char *filter_spec)
+int FFStream::insert_filter(const char *name, const char *arg, const char *inst_name)
{
- /* Endpoints for the filter graph. */
- AVFilterInOut *outputs = avfilter_inout_alloc();
- outputs->name = av_strdup("in");
- outputs->filter_ctx = buffersrc_ctx;
- outputs->pad_idx = 0;
- outputs->next = 0;
-
- AVFilterInOut *inputs = avfilter_inout_alloc();
- inputs->name = av_strdup("out");
- inputs->filter_ctx = buffersink_ctx;
- inputs->pad_idx = 0;
- inputs->next = 0;
-
- int ret = !outputs->name || !inputs->name ? -1 : 0;
+ const AVFilter *filter = avfilter_get_by_name(name);
+ if( !filter ) return -1;
+ char filt_inst[BCSTRLEN];
+ if( !inst_name ) {
+ snprintf(filt_inst, sizeof(filt_inst), "%s_%d", name, ++filt_id);
+ inst_name = filt_inst;
+ }
+ if( !filter_graph )
+ filter_graph = avfilter_graph_alloc();
+ AVFilterContext *fctx = 0;
+ int ret = avfilter_graph_create_filter(&fctx,
+ filter, inst_name, arg, NULL, filter_graph);
+ if( ret >= 0 && filt_ctx )
+ ret = avfilter_link(filt_ctx, 0, fctx, 0);
if( ret >= 0 )
- ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
- &inputs, &outputs, NULL);
+ filt_ctx = fctx;
+ else
+ avfilter_free(fctx);
+ return ret;
+}
+
+int FFStream::config_filters(const char *filter_spec, AVFilterContext *fsrc)
+{
+ int ret = 0;
+ AVFilterContext *fsink = buffersink_ctx;
+ if( filter_spec ) {
+ /* Endpoints for the filter graph. */
+ AVFilterInOut *outputs = avfilter_inout_alloc();
+ AVFilterInOut *inputs = avfilter_inout_alloc();
+ if( !inputs || !outputs ) ret = -1;
+ if( ret >= 0 ) {
+ outputs->filter_ctx = fsrc;
+ outputs->pad_idx = 0;
+ outputs->next = 0;
+ if( !(outputs->name = av_strdup(fsrc->name)) ) ret = -1;
+ }
+ if( ret >= 0 ) {
+ inputs->filter_ctx = fsink;
+ inputs->pad_idx = 0;
+ inputs->next = 0;
+ if( !(inputs->name = av_strdup(fsink->name)) ) ret = -1;
+ }
+ if( ret >= 0 ) {
+ int len = strlen(fsrc->name)+2 + strlen(filter_spec) + 1;
+ char spec[len]; sprintf(spec, "[%s]%s", fsrc->name, filter_spec);
+ ret = avfilter_graph_parse_ptr(filter_graph, spec,
+ &inputs, &outputs, NULL);
+ }
+ avfilter_inout_free(&inputs);
+ avfilter_inout_free(&outputs);
+ }
+ else
+ ret = avfilter_link(fsrc, 0, fsink, 0);
if( ret >= 0 )
ret = avfilter_graph_config(filter_graph, NULL);
-
if( ret < 0 ) {
ff_err(ret, "FFStream::create_filter");
avfilter_graph_free(&filter_graph);
filter_graph = 0;
}
- avfilter_inout_free(&inputs);
- avfilter_inout_free(&outputs);
return ret;
}
AVDictionary *copts = 0;
av_dict_copy(&copts, opts, 0);
AVCodecID codec_id = st->codecpar->codec_id;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVCodec *decoder = 0;
+#else
AVCodec *decoder = 0;
+#endif
switch( st->codecpar->codec_type ) {
case AVMEDIA_TYPE_VIDEO:
if( opt_video_decoder )
int in = 0;
int64_t sz = marks.size();
int max_entries = fmt_ctx->max_index_size / sizeof(AVIndexEntry) - 1;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int nb_ent = avformat_index_get_entries_count(st);
+#endif
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
int nb_ent = st->nb_index_entries;
+#endif
// some formats already have an index
if( nb_ent > 0 ) {
+#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58,134,100)
AVIndexEntry *ep = &st->index_entries[nb_ent-1];
+#endif
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ const AVIndexEntry *ep = avformat_index_get_entry(st, nb_ent-1);
+#endif
int64_t tstmp = ep->timestamp;
if( nudge != AV_NOPTS_VALUE ) tstmp -= nudge;
double secs = ffmpeg->to_secs(tstmp, st->time_base);
fidx = aud->fidx;
nudge = aud->nudge;
st = aud->st;
+ AVDictionaryEntry *tref = av_dict_get(fmt_ctx->metadata, "time_reference", 0, 0);
+ if( tref && aud && aud->sample_rate )
+ return strtod(tref->value, 0) / aud->sample_rate;
break; }
case TRACK_VIDEO: {
codec_type = AVMEDIA_TYPE_VIDEO;