har0ke/FFmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fftools/ffmpeg: make decoding AVCodecContext private to the decoder

Browse Source
This commit is contained in:
Anton Khirnov 2024-01-10 14:54:34 +01:00
parent d47bb91f8b
commit f2a2094c47
3 changed files with 60 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
fftools/ffmpeg.h
View File

@ -306,7 +306,6 @@ typedef struct InputStream {
*/ */
AVCodecParameters *par; AVCodecParameters *par;
Decoder *decoder; Decoder *decoder;
AVCodecContext *dec_ctx;
const AVCodec *dec; const AVCodec *dec;
AVRational framerate_guessed; AVRational framerate_guessed;
@ -733,6 +732,8 @@ int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input);
int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx); int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx);
void dec_free(Decoder **pdec); void dec_free(Decoder **pdec);
int dec_add_filter(Decoder *dec, InputFilter *ifilter);
int enc_alloc(Encoder **penc, const AVCodec *codec, int enc_alloc(Encoder **penc, const AVCodec *codec,
Scheduler *sch, unsigned sch_idx); Scheduler *sch, unsigned sch_idx);
void enc_free(Encoder **penc); void enc_free(Encoder **penc);

90
fftools/ffmpeg_dec.c
View File

@ -37,6 +37,8 @@
typedef struct DecoderPriv { typedef struct DecoderPriv {
Decoder dec; Decoder dec;
AVCodecContext *dec_ctx;
AVFrame *frame; AVFrame *frame;
AVPacket *pkt; AVPacket *pkt;
@ -79,6 +81,8 @@ void dec_free(Decoder **pdec)
return; return;
dp = dp_from_dec(dec); dp = dp_from_dec(dec);
avcodec_free_context(&dp->dec_ctx);
av_frame_free(&dp->frame); av_frame_free(&dp->frame);
av_packet_free(&dp->pkt); av_packet_free(&dp->pkt);
@ -216,9 +220,9 @@ static int64_t video_duration_estimate(const InputStream *ist, const AVFrame *fr
if (frame->duration > 0 && (!ifile->format_nots || ist->framerate.num)) if (frame->duration > 0 && (!ifile->format_nots || ist->framerate.num))
return frame->duration; return frame->duration;
if (ist->dec_ctx->framerate.den && ist->dec_ctx->framerate.num) { if (dp->dec_ctx->framerate.den && dp->dec_ctx->framerate.num) {
int fields = frame->repeat_pict + 2; int fields = frame->repeat_pict + 2;
AVRational field_rate = av_mul_q(ist->dec_ctx->framerate, AVRational field_rate = av_mul_q(dp->dec_ctx->framerate,
(AVRational){ 2, 1 }); (AVRational){ 2, 1 });
codec_duration = av_rescale_q(fields, av_inv_q(field_rate), codec_duration = av_rescale_q(fields, av_inv_q(field_rate),
frame->time_base); frame->time_base);
@ -258,29 +262,29 @@ static int video_frame_process(InputStream *ist, AVFrame *frame)
// The following line may be required in some cases where there is no parser // The following line may be required in some cases where there is no parser
// or the parser does not has_b_frames correctly // or the parser does not has_b_frames correctly
if (ist->par->video_delay < ist->dec_ctx->has_b_frames) { if (ist->par->video_delay < dp->dec_ctx->has_b_frames) {
if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) { if (dp->dec_ctx->codec_id == AV_CODEC_ID_H264) {
ist->par->video_delay = ist->dec_ctx->has_b_frames; ist->par->video_delay = dp->dec_ctx->has_b_frames;
} else } else
av_log(ist->dec_ctx, AV_LOG_WARNING, av_log(dp->dec_ctx, AV_LOG_WARNING,
"video_delay is larger in decoder than demuxer %d > %d.\n" "video_delay is larger in decoder than demuxer %d > %d.\n"
"If you want to help, upload a sample " "If you want to help, upload a sample "
"of this file to https://streams.videolan.org/upload/ " "of this file to https://streams.videolan.org/upload/ "
"and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n", "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
ist->dec_ctx->has_b_frames, dp->dec_ctx->has_b_frames,
ist->par->video_delay); ist->par->video_delay);
} }
if (ist->dec_ctx->width != frame->width || if (dp->dec_ctx->width != frame->width ||
ist->dec_ctx->height != frame->height || dp->dec_ctx->height != frame->height ||
ist->dec_ctx->pix_fmt != frame->format) { dp->dec_ctx->pix_fmt != frame->format) {
av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n", av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
frame->width, frame->width,
frame->height, frame->height,
frame->format, frame->format,
ist->dec_ctx->width, dp->dec_ctx->width,
ist->dec_ctx->height, dp->dec_ctx->height,
ist->dec_ctx->pix_fmt); dp->dec_ctx->pix_fmt);
} }
#if FFMPEG_OPT_TOP #if FFMPEG_OPT_TOP
@ -291,7 +295,7 @@ static int video_frame_process(InputStream *ist, AVFrame *frame)
#endif #endif
if (frame->format == dp->hwaccel_pix_fmt) { if (frame->format == dp->hwaccel_pix_fmt) {
int err = hwaccel_retrieve_data(ist->dec_ctx, frame); int err = hwaccel_retrieve_data(dp->dec_ctx, frame);
if (err < 0) if (err < 0)
return err; return err;
} }
@ -431,7 +435,7 @@ static int transcode_subtitles(InputStream *ist, const AVPacket *pkt,
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
ret = avcodec_decode_subtitle2(ist->dec_ctx, &subtitle, &got_output, ret = avcodec_decode_subtitle2(dp->dec_ctx, &subtitle, &got_output,
pkt ? pkt : flush_pkt); pkt ? pkt : flush_pkt);
av_packet_free(&flush_pkt); av_packet_free(&flush_pkt);
@ -457,8 +461,8 @@ static int transcode_subtitles(InputStream *ist, const AVPacket *pkt,
return ret; return ret;
} }
frame->width = ist->dec_ctx->width; frame->width = dp->dec_ctx->width;
frame->height = ist->dec_ctx->height; frame->height = dp->dec_ctx->height;
return process_subtitle(ist, frame); return process_subtitle(ist, frame);
} }
@ -467,7 +471,7 @@ static int packet_decode(InputStream *ist, AVPacket *pkt, AVFrame *frame)
{ {
const InputFile *ifile = ist->file; const InputFile *ifile = ist->file;
DecoderPriv *dp = dp_from_dec(ist->decoder); DecoderPriv *dp = dp_from_dec(ist->decoder);
AVCodecContext *dec = ist->dec_ctx; AVCodecContext *dec = dp->dec_ctx;
const char *type_desc = av_get_media_type_string(dec->codec_type); const char *type_desc = av_get_media_type_string(dec->codec_type);
int ret; int ret;
@ -582,11 +586,11 @@ static int packet_decode(InputStream *ist, AVPacket *pkt, AVFrame *frame)
} }
} }
static void dec_thread_set_name(const InputStream *ist) static void dec_thread_set_name(const InputStream *ist, const DecoderPriv *dp)
{ {
char name[16]; char name[16];
snprintf(name, sizeof(name), "dec%d:%d:%s", ist->file->index, ist->index, snprintf(name, sizeof(name), "dec%d:%d:%s", ist->file->index, ist->index,
ist->dec_ctx->codec->name); dp->dec_ctx->codec->name);
ff_thread_setname(name); ff_thread_setname(name);
} }
@ -628,7 +632,7 @@ void *decoder_thread(void *arg)
if (ret < 0) if (ret < 0)
goto finish; goto finish;
dec_thread_set_name(ist); dec_thread_set_name(ist, dp);
while (!input_status) { while (!input_status) {
int flush_buffers, have_data; int flush_buffers, have_data;
@ -669,7 +673,7 @@ void *decoder_thread(void *arg)
dt.pkt->time_base = dp->last_frame_tb; dt.pkt->time_base = dp->last_frame_tb;
} }
avcodec_flush_buffers(ist->dec_ctx); avcodec_flush_buffers(dp->dec_ctx);
} else if (ret < 0) { } else if (ret < 0) {
av_log(ist, AV_LOG_ERROR, "Error processing packet in decoder: %s\n", av_log(ist, AV_LOG_ERROR, "Error processing packet in decoder: %s\n",
av_err2str(ret)); av_err2str(ret));
@ -769,7 +773,7 @@ static HWDevice *hw_device_match_by_codec(const AVCodec *codec)
} }
} }
static int hw_device_setup_for_decode(InputStream *ist) static int hw_device_setup_for_decode(InputStream *ist, DecoderPriv *dp)
{ {
const AVCodecHWConfig *config; const AVCodecHWConfig *config;
enum AVHWDeviceType type; enum AVHWDeviceType type;
@ -890,8 +894,8 @@ static int hw_device_setup_for_decode(InputStream *ist)
return err; return err;
} }
ist->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref); dp->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
if (!ist->dec_ctx->hw_device_ctx) if (!dp->dec_ctx->hw_device_ctx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
return 0; return 0;
@ -906,7 +910,7 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx)
if (!codec) { if (!codec) {
av_log(ist, AV_LOG_ERROR, av_log(ist, AV_LOG_ERROR,
"Decoding requested, but no decoder found for: %s\n", "Decoding requested, but no decoder found for: %s\n",
avcodec_get_name(ist->dec_ctx->codec_id)); avcodec_get_name(ist->par->codec_id));
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -929,10 +933,20 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
ist->dec_ctx->opaque = ist; dp->dec_ctx = avcodec_alloc_context3(codec);
ist->dec_ctx->get_format = get_format; if (!dp->dec_ctx)
return AVERROR(ENOMEM);
if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE && ret = avcodec_parameters_to_context(dp->dec_ctx, ist->par);
if (ret < 0) {
av_log(ist, AV_LOG_ERROR, "Error initializing the decoder context.\n");
return ret;
}
dp->dec_ctx->opaque = ist;
dp->dec_ctx->get_format = get_format;
if (dp->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
(ist->decoding_needed & DECODING_FOR_OST)) { (ist->decoding_needed & DECODING_FOR_OST)) {
av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE); av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
if (ist->decoding_needed & DECODING_FOR_FILTER) if (ist->decoding_needed & DECODING_FOR_FILTER)
@ -941,7 +955,7 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx)
/* Useful for subtitles retiming by lavf (FIXME), skipping samples in /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
* audio, and video decoders such as cuvid or mediacodec */ * audio, and video decoders such as cuvid or mediacodec */
ist->dec_ctx->pkt_timebase = ist->st->time_base; dp->dec_ctx->pkt_timebase = ist->st->time_base;
if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0)) if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
av_dict_set(&ist->decoder_opts, "threads", "auto", 0); av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
@ -951,7 +965,7 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx)
av_dict_set(&ist->decoder_opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY); av_dict_set(&ist->decoder_opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
ret = hw_device_setup_for_decode(ist); ret = hw_device_setup_for_decode(ist, dp);
if (ret < 0) { if (ret < 0) {
av_log(ist, AV_LOG_ERROR, av_log(ist, AV_LOG_ERROR,
"Hardware device setup failed for decoder: %s\n", "Hardware device setup failed for decoder: %s\n",
@ -959,7 +973,7 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx)
return ret; return ret;
} }
if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) { if ((ret = avcodec_open2(dp->dec_ctx, codec, &ist->decoder_opts)) < 0) {
av_log(ist, AV_LOG_ERROR, "Error while opening decoder: %s\n", av_log(ist, AV_LOG_ERROR, "Error while opening decoder: %s\n",
av_err2str(ret)); av_err2str(ret));
return ret; return ret;
@ -969,8 +983,16 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx)
if (ret < 0) if (ret < 0)
return ret; return ret;
dp->dec.subtitle_header = ist->dec_ctx->subtitle_header; dp->dec.subtitle_header = dp->dec_ctx->subtitle_header;
dp->dec.subtitle_header_size = ist->dec_ctx->subtitle_header_size; dp->dec.subtitle_header_size = dp->dec_ctx->subtitle_header_size;
return 0; return 0;
} }
int dec_add_filter(Decoder *dec, InputFilter *ifilter)
{
DecoderPriv *dp = dp_from_dec(dec);
// initialize fallback parameters for filtering
return ifilter_parameters_from_dec(ifilter, dp->dec_ctx);
}

16
fftools/ffmpeg_demux.c
View File

@ -825,7 +825,6 @@ static void ist_free(InputStream **pist)
av_freep(&ist->outputs); av_freep(&ist->outputs);
av_freep(&ist->hwaccel_device); av_freep(&ist->hwaccel_device);
avcodec_free_context(&ist->dec_ctx);
avcodec_parameters_free(&ist->par); avcodec_parameters_free(&ist->par);
av_bsf_free(&ds->bsf); av_bsf_free(&ds->bsf);
@ -886,16 +885,6 @@ static int ist_use(InputStream *ist, int decoding_needed)
if (decoding_needed && ds->sch_idx_dec < 0) { if (decoding_needed && ds->sch_idx_dec < 0) {
int is_audio = ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO; int is_audio = ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
ist->dec_ctx = avcodec_alloc_context3(ist->dec);
if (!ist->dec_ctx)
return AVERROR(ENOMEM);
ret = avcodec_parameters_to_context(ist->dec_ctx, ist->par);
if (ret < 0) {
av_log(ist, AV_LOG_ERROR, "Error initializing the decoder context.\n");
return ret;
}
ret = sch_add_dec(d->sch, decoder_thread, ist, d->loop && is_audio); ret = sch_add_dec(d->sch, decoder_thread, ist, d->loop && is_audio);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -950,12 +939,11 @@ int ist_filter_add(InputStream *ist, InputFilter *ifilter, int is_simple)
ist->filters[ist->nb_filters - 1] = ifilter; ist->filters[ist->nb_filters - 1] = ifilter;
// initialize fallback parameters for filtering ret = dec_add_filter(ist->decoder, ifilter);
ret = ifilter_parameters_from_dec(ifilter, ist->dec_ctx);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (ist->dec_ctx->codec_type == AVMEDIA_TYPE_SUBTITLE) { if (ist->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
if (!d->pkt_heartbeat) { if (!d->pkt_heartbeat) {
d->pkt_heartbeat = av_packet_alloc(); d->pkt_heartbeat = av_packet_alloc();
if (!d->pkt_heartbeat) if (!d->pkt_heartbeat)