X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fffmpeg.C;h=b3915cfc44de133644e71180239b519170199d2d;hp=0f41bd2382ecbbc630b75f5af847bb3c5101b283;hb=HEAD;hpb=85a4302e7031b0285aeb9559aa6dbc531db6e443 diff --git a/cinelerra-5.1/cinelerra/ffmpeg.C b/cinelerra-5.1/cinelerra/ffmpeg.C index 0f41bd23..6685f468 100644 --- a/cinelerra-5.1/cinelerra/ffmpeg.C +++ b/cinelerra-5.1/cinelerra/ffmpeg.C @@ -1,3 +1,22 @@ +/* + * CINELERRA + * Copyright (C) 2012-2014 Paolo Rampino + * + * 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 + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ #include #include @@ -29,7 +48,9 @@ #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" @@ -378,8 +399,11 @@ AVHWDeviceType FFStream::decode_hw_activate() { 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; } @@ -404,7 +428,11 @@ int FFStream::decode_activate() } 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); @@ -576,6 +604,10 @@ int FFStream::write_packet(FFPacket &pkt) ret = av_interleaved_write_frame(ffmpeg->fmt_ctx, pkt); } else { + bsfc->time_base_in = st->time_base; + avcodec_parameters_copy(bsfc->par_in, st->codecpar); + av_bsf_init(bsfc); + ret = av_bsf_send_packet(bsfc, pkt); while( ret >= 0 ) { FFPacket bs; @@ -584,6 +616,9 @@ int FFStream::write_packet(FFPacket &pkt) if( ret == AVERROR_EOF ) return -1; break; } + //printf(" filter name %s \n", bsfc->filter[0].name); + //avcodec_parameters_copy(ffmpeg->fmt_ctx->streams[0]->codecpar, bsfc->par_out); + //avcodec_parameters_copy(st->codecpar, bsfc->par_out); av_packet_rescale_ts(bs, avctx->time_base, st->time_base); bs->stream_index = st->index; ret = av_interleaved_write_frame(ffmpeg->fmt_ctx, bs); @@ -603,10 +638,11 @@ int FFStream::encode_frame(AVFrame *frame) 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( ret < 0 ) break; + if( !frame && (ret == AVERROR_EOF || ret == AVERROR(EAGAIN) )) return pkts; + //if( ret < 0 ) break; ret = write_packet(opkt); if( ret < 0 ) break; ++pkts; @@ -719,10 +755,19 @@ int FFStream::seek(int64_t no, double rate) 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; @@ -1090,8 +1135,11 @@ 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; @@ -1112,7 +1160,14 @@ int FFVideoStream::decode_hw_format(AVCodec *decoder, AVHWDeviceType type) if( hw_pix_fmt >= 0 ) { hw_pixfmt = hw_pix_fmt; avctx->get_format = get_hw_format; + const char *drm_node = getenv("CIN_DRM_DEC"); + if(drm_node && type==AV_HWDEVICE_TYPE_VAAPI) { + ret = av_hwdevice_ctx_create(&hw_device_ctx, type, drm_node, 0, 0); + } + else { ret = av_hwdevice_ctx_create(&hw_device_ctx, type, 0, 0, 0); + } + if( ret >= 0 ) { avctx->hw_device_ctx = av_buffer_ref(hw_device_ctx); ret = 1; @@ -1128,6 +1183,7 @@ int FFVideoStream::decode_hw_format(AVCodec *decoder, AVHWDeviceType type) AVHWDeviceType FFVideoStream::encode_hw_activate(const char *hw_dev) { + const char *drm_node_enc = getenv("CIN_DRM_ENC"); AVBufferRef *hw_device_ctx = 0; AVBufferRef *hw_frames_ref = 0; AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE; @@ -1139,7 +1195,12 @@ AVHWDeviceType FFVideoStream::encode_hw_activate(const char *hw_dev) } } if( type != AV_HWDEVICE_TYPE_NONE ) { - int ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, 0, 0, 0); + int ret = 0; + if (drm_node_enc) { + ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, drm_node_enc, 0, 0); + } else { + ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, 0, 0, 0); + } if( ret < 0 ) { ff_err(ret, "Failed to create a HW device.\n"); type = AV_HWDEVICE_TYPE_NONE; @@ -1222,8 +1283,7 @@ int FFVideoStream::probe(int64_t pos) return -1; } - if (ffmpeg->interlace_from_codec) - return 1; + if (ffmpeg->interlace_from_codec) return 1; ret = read_frame(frame); if( ret > 0 ) { @@ -1244,6 +1304,7 @@ int FFVideoStream::probe(int64_t pos) ret = -1; ret = ret > 0 ? 1 : ret < 0 ? -1 : 0; + av_frame_free(&frame); return ret; } @@ -1590,9 +1651,11 @@ int FFVideoConvert::convert_picture_vframe(VFrame *frame, AVFrame *ip, AVFrame * } 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); @@ -1719,9 +1782,11 @@ int FFVideoConvert::convert_vframe_picture(VFrame *frame, AVFrame *op, AVFrame * } 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); @@ -1843,7 +1908,11 @@ FFMPEG::~FFMPEG() 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; @@ -1854,12 +1923,15 @@ int FFMPEG::check_sample_rate(AVCodec *codec, int 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 }; @@ -2090,7 +2162,11 @@ void FFMPEG::scan_audio_options(Asset *asset, EDL *edl) 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); @@ -2126,7 +2202,11 @@ void FFMPEG::scan_video_options(Asset *asset, EDL *edl) 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 @@ -2320,10 +2400,15 @@ int FFCodecRemaps::add(const char *val) 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; @@ -2459,6 +2544,34 @@ int FFMPEG::info(char *text, int len) enum AVColorRange range = st->codecpar->color_range; const char *rg = av_color_range_name(range); report("/ range:%s\n", rg ? rg : unkn); + + AVRational sar = av_guess_sample_aspect_ratio(fmt_ctx, st, NULL); + AVRational display_aspect_ratio; + if(sar.num) { + + av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den, + st->codecpar->width * (int64_t)sar.num, + st->codecpar->height * (int64_t)sar.den, + 1024 * 1024); +/* report(" Guessed SAR: %d:%d, ", sar.num, sar.den ); + report("DAR: %d:%d \n", display_aspect_ratio.num, display_aspect_ratio.den); */ + } + if (st->sample_aspect_ratio.num) + { + av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den, + st->codecpar->width * (int64_t)st->sample_aspect_ratio.num, + st->codecpar->height * (int64_t)st->sample_aspect_ratio.den, + 1024 * 1024); + report(" container Detected SAR: %d:%d , DAR %d:%d \n", st->sample_aspect_ratio.num, st->sample_aspect_ratio.den, display_aspect_ratio.num, display_aspect_ratio.den); + } + if (st->codecpar->sample_aspect_ratio.num) + { + av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den, + st->codecpar->width * (int64_t)st->codecpar->sample_aspect_ratio.num, + st->codecpar->height * (int64_t)st->codecpar->sample_aspect_ratio.den, + 1024 * 1024); + report(" codec Detected SAR: %d:%d , DAR %d:%d \n", st->codecpar->sample_aspect_ratio.num, st->codecpar->sample_aspect_ratio.den, display_aspect_ratio.num, display_aspect_ratio.den); + } double secs = to_secs(st->duration, st->time_base); int64_t length = secs * vid->frame_rate + 0.5; double ofs = to_secs((vid->nudge - st->start_time), st->time_base); @@ -2543,7 +2656,11 @@ int FFMPEG::init_decoder(const char *filename) 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"); @@ -2636,18 +2753,22 @@ int FFMPEG::open_decoder() } 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; } @@ -2760,7 +2881,11 @@ int FFMPEG::open_encoder(const char *type, const char *spec) 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; @@ -2881,6 +3006,14 @@ int FFMPEG::open_encoder(const char *type, const char *spec) vid->width = asset->width; vid->height = asset->height; vid->frame_rate = asset->frame_rate; +#if 0 + char tc_str[20] = "00:00:00:00"; + double tc_offset; + if(asset->timecode > 0) + Units::totext(tc_str, asset->timecode, TIME_HMSF, 0, asset->frame_rate, 0); + //printf("tc: %s \n", tc_str); + av_dict_set(&st->metadata, "timecode", tc_str, 0); +#endif if( (vid->color_range = asset->ff_color_range) < 0 ) vid->color_range = file_base->file->preferences->yuv_color_range; switch( vid->color_range ) { @@ -2890,9 +3023,11 @@ int FFMPEG::open_encoder(const char *type, const char *spec) 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 ) { @@ -2915,7 +3050,12 @@ int FFMPEG::open_encoder(const char *type, const char *spec) int mask_h = (1<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; @@ -2925,6 +3065,13 @@ int FFMPEG::open_encoder(const char *type, const char *spec) frame_rate.num, frame_rate.den, INT_MAX); ctx->framerate = (AVRational) { frame_rate.num, frame_rate.den }; ctx->time_base = (AVRational) { frame_rate.den, frame_rate.num }; + if(!strcmp(format_name, "webm") || !strcmp(format_name, "matroska") || !strcmp(format_name, "mov") || + !strcmp(format_name, "qt") || !strcmp(format_name, "mp4") || !strcmp(format_name, "avi") || + !strcmp(format_name, "dv") || !strcmp(format_name, "yuv4mpegpipe")) + { + if (to_sample_aspect_ratio(asset).den > 0) + st->sample_aspect_ratio = to_sample_aspect_ratio(asset); + } st->avg_frame_rate = frame_rate; st->time_base = ctx->time_base; vid->writing = -1; @@ -3006,7 +3153,11 @@ int FFMPEG::open_encoder(const char *type, const char *spec) } 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"); @@ -3562,13 +3713,11 @@ float FFMPEG::ff_aspect_ratio(int stream) AVCodecParameters *par = ffvideo[stream]->st->codecpar; AVRational dar; AVRational sar = av_guess_sample_aspect_ratio(fmt_ctx, strm, NULL); - if (sar.num) { - printf("sample_aspect_ratio, %f \n", av_q2d(sar)); + if (sar.num && ffvideo[stream]->get_rotation_angle() == 0) { av_reduce(&dar.num, &dar.den, par->width * sar.num, par->height * sar.den, 1024*1024); - printf("display_aspect_ratio, %f \n", av_q2d(dar)); return av_q2d(dar); } return ffvideo[stream]->aspect_ratio; @@ -3617,7 +3766,6 @@ 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; - printf("interlace from demux: %i\n", interlace0); switch (interlace0) { @@ -3654,7 +3802,11 @@ Preferences *FFMPEG::ff_prefs() 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; @@ -3879,7 +4031,11 @@ AVCodecContext *FFMPEG::activate_decoder(AVStream *st) 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 ) @@ -4071,10 +4227,20 @@ void FFStream::load_markers(IndexMarks &marks, double rate) 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);