Hi,
I have attached the patch.
Thanks,
Ganesh
From 990253559e14d9075ab6a29cab0991ea2fe4fc3b Mon Sep 17 00:00:00 2001
From: Ganesh Ajjanagadde <gajjanaga...@gmail.com>
Date: Sun, 4 Oct 2015 23:39:25 -0400
Subject: [PATCH 1/2] avfilter/all: propagate errors of functions from
avfilter/formats
Many of the functions from avfilter/formats can return errors, usually AVERROR(ENOMEM).
This propagates the return values.
All of these were found by using av_warn_unused_result, demonstrating its utility.
The second patch in this series adds av_warn_unused_result to avfilter/formats.
There are two reasons for this ordering:
1. Applying the other patch first will result in a huge number of noisy
warnings. This patch first corrects the behavior, so that the second
patch does not trigger any "warning regressions".
2. I have currently used av_warn_unused_result liberally in the second
patch, since I see no loss and only benefits as outlined in its
justification. However, a policy should be adopted regarding when to use
av_warn_unused_result, and consensus may be difficult to achieve.
Tested with FATE. I am least sure of the changes to avfilter/filtergraph,
since I don't know what/how reduce_format is intended to behave and how it should
react to errors.
Signed-off-by: Ganesh Ajjanagadde <gajjanaga...@gmail.com>
---
libavfilter/aeval.c | 33 ++++++++++++++++++++-------
libavfilter/af_aformat.c | 14 +++++++-----
libavfilter/af_agate.c | 3 ++-
libavfilter/af_amerge.c | 33 ++++++++++++++++++++-------
libavfilter/af_amix.c | 8 +++++--
libavfilter/af_aresample.c | 35 ++++++++++++++++++++++++-----
libavfilter/af_astreamsync.c | 25 +++++++++++++++------
libavfilter/af_channelmap.c | 21 ++++++++++++-----
libavfilter/af_channelsplit.c | 21 +++++++++++------
libavfilter/af_earwax.c | 20 ++++++++++++-----
libavfilter/af_extrastereo.c | 17 ++++++++++----
libavfilter/af_join.c | 20 ++++++++++++-----
libavfilter/af_pan.c | 26 ++++++++++++++++-----
libavfilter/af_replaygain.c | 29 +++++++++++++++++-------
libavfilter/af_resample.c | 46 ++++++++++++++++++++++++++++----------
libavfilter/af_sidechaincompress.c | 19 ++++++++++++----
libavfilter/af_stereotools.c | 17 ++++++++++----
libavfilter/af_stereowiden.c | 16 +++++++++----
libavfilter/asrc_anullsrc.c | 8 ++++---
libavfilter/asrc_flite.c | 23 ++++++++++++++-----
libavfilter/avf_aphasemeter.c | 24 +++++++++++++++-----
libavfilter/avf_avectorscope.c | 23 ++++++++++++++-----
libavfilter/avf_concat.c | 32 +++++++++++++++++++++-----
libavfilter/avf_showcqt.c | 21 +++++++++++++----
libavfilter/avf_showfreqs.c | 21 +++++++++++++----
libavfilter/avf_showspectrum.c | 21 +++++++++++++----
libavfilter/avf_showvolume.c | 21 +++++++++++++----
libavfilter/avf_showwaves.c | 21 +++++++++++++----
libavfilter/avfiltergraph.c | 29 +++++++++++++++++-------
libavfilter/buffersink.c | 21 ++++++++++++-----
libavfilter/buffersrc.c | 33 +++++++++++++++++++--------
libavfilter/drawutils.c | 6 +++--
libavfilter/f_drawgraph.c | 6 ++++-
libavfilter/f_ebur128.c | 27 ++++++++++++++++------
libavfilter/formats.c | 15 ++++++++++---
libavfilter/src_movie.c | 16 ++++++++-----
libavfilter/vf_alphamerge.c | 23 ++++++++++++++-----
libavfilter/vf_boxblur.c | 13 +++++++----
libavfilter/vf_crop.c | 13 +++++++----
libavfilter/vf_detelecine.c | 13 +++++++----
libavfilter/vf_displace.c | 4 +++-
libavfilter/vf_elbg.c | 6 +++--
libavfilter/vf_extractplanes.c | 8 ++++---
libavfilter/vf_fieldorder.c | 7 ++++--
libavfilter/vf_frei0r.c | 12 +++++++---
libavfilter/vf_hflip.c | 13 +++++++----
libavfilter/vf_histogram.c | 7 ++++--
libavfilter/vf_il.c | 14 ++++++++----
libavfilter/vf_maskedmerge.c | 3 +--
libavfilter/vf_mergeplanes.c | 22 +++++++++++++-----
libavfilter/vf_neighbor.c | 3 +--
libavfilter/vf_noise.c | 11 ++++++---
libavfilter/vf_overlay.c | 36 ++++++++++++++++++++---------
libavfilter/vf_palettegen.c | 11 +++++++--
libavfilter/vf_paletteuse.c | 16 ++++++++++---
libavfilter/vf_scale.c | 9 ++++++--
libavfilter/vf_showpalette.c | 11 +++++++--
libavfilter/vf_stack.c | 13 +++++++----
libavfilter/vf_swapuv.c | 12 ++++++----
libavfilter/vf_telecine.c | 13 +++++++----
libavfilter/vf_transpose.c | 13 +++++++----
libavfilter/vf_vectorscope.c | 8 ++++---
libavfilter/vsrc_life.c | 6 ++++-
63 files changed, 812 insertions(+), 279 deletions(-)
diff --git a/libavfilter/aeval.c b/libavfilter/aeval.c
index b6c420a..c10e2af 100644
--- a/libavfilter/aeval.c
+++ b/libavfilter/aeval.c
@@ -350,36 +350,53 @@ static int aeval_query_formats(AVFilterContext *ctx)
static const enum AVSampleFormat sample_fmts[] = {
AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE
};
+ int ret;
// inlink supports any channel layout
layouts = ff_all_channel_counts();
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if (!layouts)
+ return AVERROR(ENOMEM);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
if (eval->same_chlayout) {
layouts = ff_all_channel_counts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_set_common_channel_layouts(ctx, layouts);
+ if ((ret = ff_set_common_channel_layouts(ctx, layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
} else {
// outlink supports only requested output channel layout
layouts = NULL;
- ff_add_channel_layout(&layouts,
+ if ((ret = ff_add_channel_layout(&layouts,
eval->out_channel_layout ? eval->out_channel_layout :
- FF_COUNT2LAYOUT(eval->nb_channels));
- ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
+ FF_COUNT2LAYOUT(eval->nb_channels))) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
+ if ((ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_set_common_samplerates(ctx, formats);
- return 0;
+ return ff_set_common_samplerates(ctx, formats);
}
static int aeval_config_output(AVFilterLink *outlink)
diff --git a/libavfilter/af_aformat.c b/libavfilter/af_aformat.c
index 4fdcb09..fbe09aa 100644
--- a/libavfilter/af_aformat.c
+++ b/libavfilter/af_aformat.c
@@ -57,9 +57,10 @@ static const AVOption aformat_options[] = {
AVFILTER_DEFINE_CLASS(aformat);
-#define PARSE_FORMATS(str, type, list, add_to_list, get_fmt, none, desc) \
+#define PARSE_FORMATS(str, type, list, add_to_list, unref, get_fmt, none, desc) \
do { \
char *next, *cur = str, sep; \
+ int ret; \
\
if (str && strchr(str, ',')) { \
av_log(ctx, AV_LOG_WARNING, "This syntax is deprecated, use '|' to "\
@@ -78,7 +79,10 @@ do { \
av_log(ctx, AV_LOG_ERROR, "Error parsing " desc ": %s.\n", cur);\
return AVERROR(EINVAL); \
} \
- add_to_list(&list, fmt); \
+ if ((ret = add_to_list(&list, fmt)) < 0) { \
+ unref(&list); \
+ return ret; \
+ } \
\
cur = next; \
} \
@@ -95,11 +99,11 @@ static av_cold int init(AVFilterContext *ctx)
AFormatContext *s = ctx->priv;
PARSE_FORMATS(s->formats_str, enum AVSampleFormat, s->formats,
- ff_add_format, av_get_sample_fmt, AV_SAMPLE_FMT_NONE, "sample format");
- PARSE_FORMATS(s->sample_rates_str, int, s->sample_rates, ff_add_format,
+ ff_add_format, ff_formats_unref, av_get_sample_fmt, AV_SAMPLE_FMT_NONE, "sample format");
+ PARSE_FORMATS(s->sample_rates_str, int, s->sample_rates, ff_add_format, ff_formats_unref,
get_sample_rate, 0, "sample rate");
PARSE_FORMATS(s->channel_layouts_str, uint64_t, s->channel_layouts,
- ff_add_channel_layout, av_get_channel_layout, 0,
+ ff_add_channel_layout, ff_channel_layouts_unref, av_get_channel_layout, 0,
"channel layout");
return 0;
diff --git a/libavfilter/af_agate.c b/libavfilter/af_agate.c
index 46ee226..a8dd161 100644
--- a/libavfilter/af_agate.c
+++ b/libavfilter/af_agate.c
@@ -77,7 +77,8 @@ static int query_formats(AVFilterContext *ctx)
AVFilterChannelLayouts *layouts;
int ret;
- ff_add_format(&formats, AV_SAMPLE_FMT_DBL);
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_DBL)) < 0)
+ return ret;
ret = ff_set_common_formats(ctx, formats);
if (ret < 0)
return ret;
diff --git a/libavfilter/af_amerge.c b/libavfilter/af_amerge.c
index 410d613..cc26e3e 100644
--- a/libavfilter/af_amerge.c
+++ b/libavfilter/af_amerge.c
@@ -78,7 +78,7 @@ static int query_formats(AVFilterContext *ctx)
int64_t inlayout[SWR_CH_MAX], outlayout = 0;
AVFilterFormats *formats;
AVFilterChannelLayouts *layouts;
- int i, overlap = 0, nb_ch = 0;
+ int i, ret, overlap = 0, nb_ch = 0;
for (i = 0; i < s->nb_inputs; i++) {
if (!ctx->inputs[i]->in_channel_layouts ||
@@ -125,17 +125,34 @@ static int query_formats(AVFilterContext *ctx)
*(route[i]++) = out_ch_number++;
}
formats = ff_make_format_list(ff_packed_sample_fmts_array);
- ff_set_common_formats(ctx, formats);
+ if (!formats)
+ return AVERROR(ENOMEM);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
for (i = 0; i < s->nb_inputs; i++) {
layouts = NULL;
- ff_add_channel_layout(&layouts, inlayout[i]);
- ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
+ if ((ret = ff_add_channel_layout(&layouts, inlayout[i])) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
layouts = NULL;
- ff_add_channel_layout(&layouts, outlayout);
- ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
- ff_set_common_samplerates(ctx, ff_all_samplerates());
- return 0;
+ if ((ret = ff_add_channel_layout(&layouts, outlayout)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
+
+ return ff_set_common_samplerates(ctx, ff_all_samplerates());
}
static int config_output(AVFilterLink *outlink)
diff --git a/libavfilter/af_amix.c b/libavfilter/af_amix.c
index 9a3cbd4..4957577 100644
--- a/libavfilter/af_amix.c
+++ b/libavfilter/af_amix.c
@@ -541,8 +541,12 @@ static int query_formats(AVFilterContext *ctx)
if (!layouts)
return AVERROR(ENOMEM);
- ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
- ff_add_format(&formats, AV_SAMPLE_FMT_FLTP);
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT)) < 0)
+ return ret;
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
ret = ff_set_common_formats(ctx, formats);
if (ret < 0)
return ret;
diff --git a/libavfilter/af_aresample.c b/libavfilter/af_aresample.c
index f6fdd08..15c8624 100644
--- a/libavfilter/af_aresample.c
+++ b/libavfilter/af_aresample.c
@@ -89,6 +89,7 @@ static int query_formats(AVFilterContext *ctx)
AVFilterFormats *in_formats, *out_formats;
AVFilterFormats *in_samplerates, *out_samplerates;
AVFilterChannelLayouts *in_layouts, *out_layouts;
+ int ret;
av_opt_get_sample_fmt(aresample->swr, "osf", 0, &out_format);
av_opt_get_int(aresample->swr, "osr", 0, &out_rate);
@@ -97,17 +98,26 @@ static int query_formats(AVFilterContext *ctx)
in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
if (!in_formats)
return AVERROR(ENOMEM);
- ff_formats_ref (in_formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(in_formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&in_formats);
+ return ret;
+ }
in_samplerates = ff_all_samplerates();
if (!in_samplerates)
return AVERROR(ENOMEM);
- ff_formats_ref (in_samplerates, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(in_samplerates, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&in_samplerates);
+ return ret;
+ }
in_layouts = ff_all_channel_counts();
if (!in_layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&in_layouts);
+ return ret;
+ }
if(out_rate > 0) {
int ratelist[] = { out_rate, -1 };
@@ -120,21 +130,34 @@ static int query_formats(AVFilterContext *ctx)
return AVERROR(ENOMEM);
}
- ff_formats_ref(out_samplerates, &outlink->in_samplerates);
+ if ((ret = ff_formats_ref(out_samplerates, &outlink->in_samplerates)) < 0) {
+ ff_formats_unref(&out_samplerates);
+ return ret;
+ }
if(out_format != AV_SAMPLE_FMT_NONE) {
int formatlist[] = { out_format, -1 };
out_formats = ff_make_format_list(formatlist);
} else
out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
- ff_formats_ref(out_formats, &outlink->in_formats);
+ if (!out_formats)
+ return AVERROR(ENOMEM);
+ if ((ret = ff_formats_ref(out_formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&out_formats);
+ return ret;
+ }
if(out_layout) {
int64_t layout_list[] = { out_layout, -1 };
out_layouts = avfilter_make_format64_list(layout_list);
} else
out_layouts = ff_all_channel_counts();
- ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
+ if (!out_layouts)
+ return AVERROR(ENOMEM);
+ if ((ret = ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&out_layouts);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/af_astreamsync.c b/libavfilter/af_astreamsync.c
index becfe34..d260b41 100644
--- a/libavfilter/af_astreamsync.c
+++ b/libavfilter/af_astreamsync.c
@@ -89,20 +89,31 @@ static av_cold int init(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
- int i;
+ int i, ret;
AVFilterFormats *formats, *rates;
AVFilterChannelLayouts *layouts;
for (i = 0; i < 2; i++) {
formats = ctx->inputs[i]->in_formats;
- ff_formats_ref(formats, &ctx->inputs[i]->out_formats);
- ff_formats_ref(formats, &ctx->outputs[i]->in_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->inputs[i]->out_formats)) < 0 ||
+ (ret = ff_formats_ref(formats, &ctx->outputs[i]->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
rates = ff_all_samplerates();
- ff_formats_ref(rates, &ctx->inputs[i]->out_samplerates);
- ff_formats_ref(rates, &ctx->outputs[i]->in_samplerates);
+ if (!rates)
+ return AVERROR(ENOMEM);
+ if ((ret = ff_formats_ref(rates, &ctx->inputs[i]->out_samplerates)) < 0 ||
+ (ret = ff_formats_ref(rates, &ctx->outputs[i]->in_samplerates)) < 0) {
+ ff_formats_unref(&rates);
+ return ret;
+ }
layouts = ctx->inputs[i]->in_channel_layouts;
- ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
- ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0 ||
+ (ret = ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
return 0;
}
diff --git a/libavfilter/af_channelmap.c b/libavfilter/af_channelmap.c
index 37b47b2..b9504ff 100644
--- a/libavfilter/af_channelmap.c
+++ b/libavfilter/af_channelmap.c
@@ -289,18 +289,29 @@ static int channelmap_query_formats(AVFilterContext *ctx)
ChannelMapContext *s = ctx->priv;
AVFilterChannelLayouts *layouts;
AVFilterChannelLayouts *channel_layouts = NULL;
+ int ret;
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_add_channel_layout(&channel_layouts, s->output_layout);
+ if ((ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0) {
+ ff_channel_layouts_unref(&channel_layouts);
+ return ret;
+ }
- ff_set_common_formats(ctx, ff_planar_sample_fmts());
- ff_set_common_samplerates(ctx, ff_all_samplerates());
+ if ((ret = ff_set_common_formats(ctx, ff_planar_sample_fmts())) < 0 ||
+ (ret = ff_set_common_samplerates(ctx, ff_all_samplerates())) < 0)
+ return ret;
- ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts);
- ff_channel_layouts_ref(channel_layouts, &ctx->outputs[0]->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
+ if ((ret = ff_channel_layouts_ref(channel_layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&channel_layouts);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/af_channelsplit.c b/libavfilter/af_channelsplit.c
index b3756e2..fa7fb64 100644
--- a/libavfilter/af_channelsplit.c
+++ b/libavfilter/af_channelsplit.c
@@ -82,20 +82,27 @@ static int query_formats(AVFilterContext *ctx)
{
ChannelSplitContext *s = ctx->priv;
AVFilterChannelLayouts *in_layouts = NULL;
- int i;
+ int i, ret;
- ff_set_common_formats (ctx, ff_planar_sample_fmts());
- ff_set_common_samplerates(ctx, ff_all_samplerates());
+ if ((ret = ff_set_common_formats(ctx, ff_planar_sample_fmts())) < 0 ||
+ (ret = ff_set_common_samplerates(ctx, ff_all_samplerates())) < 0)
+ return ret;
- ff_add_channel_layout(&in_layouts, s->channel_layout);
- ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->out_channel_layouts);
+ if ((ret = ff_add_channel_layout(&in_layouts, s->channel_layout)) < 0 ||
+ (ret = ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&in_layouts);
+ return ret;
+ }
for (i = 0; i < ctx->nb_outputs; i++) {
AVFilterChannelLayouts *out_layouts = NULL;
uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, i);
- ff_add_channel_layout(&out_layouts, channel);
- ff_channel_layouts_ref(out_layouts, &ctx->outputs[i]->in_channel_layouts);
+ if ((ret = ff_add_channel_layout(&out_layouts, channel)) < 0 ||
+ (ret = ff_channel_layouts_ref(out_layouts, &ctx->outputs[i]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&out_layouts);
+ return ret;
+ }
}
return 0;
diff --git a/libavfilter/af_earwax.c b/libavfilter/af_earwax.c
index c310997..3331e9c 100644
--- a/libavfilter/af_earwax.c
+++ b/libavfilter/af_earwax.c
@@ -78,15 +78,25 @@ typedef struct {
static int query_formats(AVFilterContext *ctx)
{
static const int sample_rates[] = { 44100, -1 };
+ int ret;
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
- ff_add_format(&formats, AV_SAMPLE_FMT_S16);
- ff_set_common_formats(ctx, formats);
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_set_common_channel_layouts(ctx, layout);
- ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates));
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_S16)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, layout)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ return ret;
+ }
+ if ((ret = ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates))) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/af_extrastereo.c b/libavfilter/af_extrastereo.c
index b4f8c85..4742544 100644
--- a/libavfilter/af_extrastereo.c
+++ b/libavfilter/af_extrastereo.c
@@ -45,11 +45,20 @@ static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
+ int ret;
- ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
- ff_set_common_formats(ctx, formats);
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_set_common_channel_layouts(ctx, layout);
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, layout)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
diff --git a/libavfilter/af_join.c b/libavfilter/af_join.c
index 4c1f6a0..d6fd52a 100644
--- a/libavfilter/af_join.c
+++ b/libavfilter/af_join.c
@@ -245,20 +245,28 @@ static int join_query_formats(AVFilterContext *ctx)
{
JoinContext *s = ctx->priv;
AVFilterChannelLayouts *layouts = NULL;
- int i;
+ int i, ret;
- ff_add_channel_layout(&layouts, s->channel_layout);
- ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
+ if ((ret = ff_add_channel_layout(&layouts, s->channel_layout)) < 0)
+ return ret;
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
for (i = 0; i < ctx->nb_inputs; i++) {
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
- ff_set_common_formats (ctx, ff_planar_sample_fmts());
- ff_set_common_samplerates(ctx, ff_all_samplerates());
+ if ((ret = ff_set_common_formats(ctx, ff_planar_sample_fmts())) < 0 ||
+ (ret = ff_set_common_samplerates(ctx, ff_all_samplerates())) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/af_pan.c b/libavfilter/af_pan.c
index 9117cc0..eb45061 100644
--- a/libavfilter/af_pan.c
+++ b/libavfilter/af_pan.c
@@ -227,26 +227,40 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layouts;
+ int ret;
pan->pure_gains = are_gains_pure(pan);
/* libswr supports any sample and packing formats */
- ff_set_common_formats(ctx, ff_all_formats(AVMEDIA_TYPE_AUDIO));
+ if ((ret = ff_set_common_formats(ctx, ff_all_formats(AVMEDIA_TYPE_AUDIO))) < 0)
+ return ret;
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_set_common_samplerates(ctx, formats);
+ if ((ret = ff_set_common_samplerates(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
// inlink supports any channel layout
layouts = ff_all_channel_counts();
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if (!layouts)
+ return AVERROR(ENOMEM);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
// outlink supports only requested output channel layout
layouts = NULL;
- ff_add_channel_layout(&layouts,
+ if ((ret = ff_add_channel_layout(&layouts,
pan->out_channel_layout ? pan->out_channel_layout :
- FF_COUNT2LAYOUT(pan->nb_output_channels));
- ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
+ FF_COUNT2LAYOUT(pan->nb_output_channels))) < 0)
+ return ret;
+ if ((ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/af_replaygain.c b/libavfilter/af_replaygain.c
index c419857..20e2a6a 100644
--- a/libavfilter/af_replaygain.c
+++ b/libavfilter/af_replaygain.c
@@ -323,17 +323,30 @@ static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
- int i;
+ int i, ret;
- ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
- ff_set_common_formats(ctx, formats);
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_set_common_channel_layouts(ctx, layout);
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, layout)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ return ret;
+ }
formats = NULL;
- for (i = 0; i < FF_ARRAY_ELEMS(freqinfos); i++)
- ff_add_format(&formats, freqinfos[i].sample_rate);
- ff_set_common_samplerates(ctx, formats);
+ for (i = 0; i < FF_ARRAY_ELEMS(freqinfos); i++) {
+ if ((ret = ff_add_format(&formats, freqinfos[i].sample_rate)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+ }
+ if ((ret = ff_set_common_samplerates(ctx, formats)) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/af_resample.c b/libavfilter/af_resample.c
index 375f480..87f79e3 100644
--- a/libavfilter/af_resample.c
+++ b/libavfilter/af_resample.c
@@ -90,22 +90,44 @@ static int query_formats(AVFilterContext *ctx)
{
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
+ AVFilterFormats *in_formats, *out_formats, *in_samplerates, *out_samplerates;
+ AVFilterChannelLayouts *in_layouts, *out_layouts;
+ int ret;
- AVFilterFormats *in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
- AVFilterFormats *out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
- AVFilterFormats *in_samplerates = ff_all_samplerates();
- AVFilterFormats *out_samplerates = ff_all_samplerates();
- AVFilterChannelLayouts *in_layouts = ff_all_channel_layouts();
- AVFilterChannelLayouts *out_layouts = ff_all_channel_layouts();
+ if (!(in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO)) ||
+ !(out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO)) ||
+ !(in_samplerates = ff_all_samplerates()) ||
+ !(out_samplerates = ff_all_samplerates()) ||
+ !(in_layouts = ff_all_channel_layouts()) ||
+ !(out_layouts = ff_all_channel_layouts()))
+ return AVERROR(ENOMEM);
- ff_formats_ref(in_formats, &inlink->out_formats);
- ff_formats_ref(out_formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(in_formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&in_formats);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(out_formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&out_formats);
+ return ret;
+ }
- ff_formats_ref(in_samplerates, &inlink->out_samplerates);
- ff_formats_ref(out_samplerates, &outlink->in_samplerates);
+ if ((ret = ff_formats_ref(in_samplerates, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&in_samplerates);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(out_samplerates, &outlink->in_samplerates)) < 0) {
+ ff_formats_unref(&out_samplerates);
+ return ret;
+ }
- ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
- ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&in_layouts);
+ return ret;
+ }
+ if ((ret = ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&out_layouts);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/af_sidechaincompress.c b/libavfilter/af_sidechaincompress.c
index b8a81fc..47e1f39 100644
--- a/libavfilter/af_sidechaincompress.c
+++ b/libavfilter/af_sidechaincompress.c
@@ -229,24 +229,35 @@ static int query_formats(AVFilterContext *ctx)
return AVERROR(EAGAIN);
}
- ff_add_channel_layout(&layouts, ctx->inputs[0]->in_channel_layouts->channel_layouts[0]);
+ if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->in_channel_layouts->channel_layouts[0])) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
for (i = 0; i < 2; i++) {
layouts = ff_all_channel_counts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
ret = ff_set_common_formats(ctx, formats);
- if (ret < 0)
+ if (ret < 0) {
+ ff_formats_unref(&formats);
return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
diff --git a/libavfilter/af_stereotools.c b/libavfilter/af_stereotools.c
index f4030b7..c926e4f 100644
--- a/libavfilter/af_stereotools.c
+++ b/libavfilter/af_stereotools.c
@@ -92,11 +92,20 @@ static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
+ int ret;
- ff_add_format(&formats, AV_SAMPLE_FMT_DBL);
- ff_set_common_formats(ctx, formats);
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_set_common_channel_layouts(ctx, layout);
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_DBL)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, layout)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
diff --git a/libavfilter/af_stereowiden.c b/libavfilter/af_stereowiden.c
index 8f671ca..38f81f1 100644
--- a/libavfilter/af_stereowiden.c
+++ b/libavfilter/af_stereowiden.c
@@ -55,11 +55,19 @@ static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
+ int ret;
- ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
- ff_set_common_formats(ctx, formats);
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_set_common_channel_layouts(ctx, layout);
+ if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, layout)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ }
formats = ff_all_samplerates();
if (!formats)
diff --git a/libavfilter/asrc_anullsrc.c b/libavfilter/asrc_anullsrc.c
index 28d4500..338464f 100644
--- a/libavfilter/asrc_anullsrc.c
+++ b/libavfilter/asrc_anullsrc.c
@@ -80,10 +80,12 @@ static int query_formats(AVFilterContext *ctx)
ANullContext *null = ctx->priv;
int64_t chlayouts[] = { null->channel_layout, -1 };
int sample_rates[] = { null->sample_rate, -1 };
+ int ret;
- ff_set_common_formats (ctx, ff_all_formats(AVMEDIA_TYPE_AUDIO));
- ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
- ff_set_common_samplerates (ctx, ff_make_format_list(sample_rates));
+ if ((ret = ff_set_common_formats(ctx, ff_all_formats(AVMEDIA_TYPE_AUDIO))) < 0 ||
+ (ret = ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts))) < 0 ||
+ (ret = ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates))) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/asrc_flite.c b/libavfilter/asrc_flite.c
index a99f2dc..b5f202a 100644
--- a/libavfilter/asrc_flite.c
+++ b/libavfilter/asrc_flite.c
@@ -205,18 +205,29 @@ static av_cold void uninit(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
FliteContext *flite = ctx->priv;
+ int ret;
AVFilterChannelLayouts *chlayouts = NULL;
int64_t chlayout = av_get_default_channel_layout(flite->wave->num_channels);
AVFilterFormats *sample_formats = NULL;
AVFilterFormats *sample_rates = NULL;
- ff_add_channel_layout(&chlayouts, chlayout);
- ff_set_common_channel_layouts(ctx, chlayouts);
- ff_add_format(&sample_formats, AV_SAMPLE_FMT_S16);
- ff_set_common_formats(ctx, sample_formats);
- ff_add_format(&sample_rates, flite->wave->sample_rate);
- ff_set_common_samplerates (ctx, sample_rates);
+ if ((ret = ff_add_channel_layout(&chlayouts, chlayout)) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0) {
+ ff_channel_layouts_unref(&chlayouts);
+ return ret;
+ }
+ if ((ret = ff_add_format(&sample_formats, AV_SAMPLE_FMT_S16)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, sample_formats)) < 0) {
+ ff_formats_unref(&sample_formats);
+ return ret;
+ }
+ if ((ret = ff_add_format(&sample_rates, flite->wave->sample_rate)) < 0)
+ return ret;
+ if ((ret = ff_set_common_samplerates (ctx, sample_rates)) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/avf_aphasemeter.c b/libavfilter/avf_aphasemeter.c
index 5a470cf..941d948 100644
--- a/libavfilter/avf_aphasemeter.c
+++ b/libavfilter/avf_aphasemeter.c
@@ -70,24 +70,38 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
+ int ret;
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_channel_layouts_ref(layout, &inlink->out_channel_layouts);
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0)
+ return ret;
+ if ((ret = ff_channel_layouts_ref(layout, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avf_avectorscope.c b/libavfilter/avf_avectorscope.c
index bc9e235..a8f6371 100644
--- a/libavfilter/avf_avectorscope.c
+++ b/libavfilter/avf_avectorscope.c
@@ -126,24 +126,37 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
+ int ret;
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
- ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
- ff_channel_layouts_ref(layout, &inlink->out_channel_layouts);
+ if ((ret = ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO)) < 0 ||
+ (ret = ff_channel_layouts_ref(layout, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layout);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avf_concat.c b/libavfilter/avf_concat.c
index 8d736a4..46a250b 100644
--- a/libavfilter/avf_concat.c
+++ b/libavfilter/avf_concat.c
@@ -80,6 +80,7 @@ static int query_formats(AVFilterContext *ctx)
unsigned type, nb_str, idx0 = 0, idx, str, seg;
AVFilterFormats *formats, *rates = NULL;
AVFilterChannelLayouts *layouts = NULL;
+ int ret;
for (type = 0; type < TYPE_ALL; type++) {
nb_str = cat->nb_streams[type];
@@ -90,24 +91,43 @@ static int query_formats(AVFilterContext *ctx)
formats = ff_all_formats(type);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &ctx->outputs[idx]->in_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->outputs[idx]->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
+
if (type == AVMEDIA_TYPE_AUDIO) {
rates = ff_all_samplerates();
if (!rates)
return AVERROR(ENOMEM);
- ff_formats_ref(rates, &ctx->outputs[idx]->in_samplerates);
+ if ((ret = ff_formats_ref(rates, &ctx->outputs[idx]->in_samplerates)) < 0) {
+ ff_formats_unref(&rates);
+ return ret;
+ }
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &ctx->outputs[idx]->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[idx]->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
/* Set the same formats for each corresponding input */
for (seg = 0; seg < cat->nb_segments; seg++) {
- ff_formats_ref(formats, &ctx->inputs[idx]->out_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->inputs[idx]->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
if (type == AVMEDIA_TYPE_AUDIO) {
- ff_formats_ref(rates, &ctx->inputs[idx]->out_samplerates);
- ff_channel_layouts_ref(layouts, &ctx->inputs[idx]->out_channel_layouts);
+ if ((ret = ff_formats_ref(rates, &ctx->inputs[idx]->out_samplerates)) < 0) {
+ ff_formats_unref(&rates);
+ return ret;
+ }
+ if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[idx]->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
idx += ctx->nb_outputs;
}
diff --git a/libavfilter/avf_showcqt.c b/libavfilter/avf_showcqt.c
index 7089758..d8c3f6c 100644
--- a/libavfilter/avf_showcqt.c
+++ b/libavfilter/avf_showcqt.c
@@ -137,28 +137,41 @@ static int query_formats(AVFilterContext *ctx)
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE };
static const int64_t channel_layouts[] = { AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_STEREO_DOWNMIX, -1 };
static const int samplerates[] = { 44100, 48000, -1 };
+ int ret;
/* set input audio formats */
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
layouts = avfilter_make_format64_list(channel_layouts);
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
formats = ff_make_format_list(samplerates);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
/* set output video format */
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avf_showfreqs.c b/libavfilter/avf_showfreqs.c
index 8961d3c..bf37b8f 100644
--- a/libavfilter/avf_showfreqs.c
+++ b/libavfilter/avf_showfreqs.c
@@ -128,28 +128,41 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
+ int ret;
/* set input audio formats */
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
/* set output video format */
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avf_showspectrum.c b/libavfilter/avf_showspectrum.c
index e29687d..e85b659 100644
--- a/libavfilter/avf_showspectrum.c
+++ b/libavfilter/avf_showspectrum.c
@@ -127,28 +127,41 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE };
+ int ret;
/* set input audio formats */
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
/* set output video format */
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avf_showvolume.c b/libavfilter/avf_showvolume.c
index 9accfb0..410f59e 100644
--- a/libavfilter/avf_showvolume.c
+++ b/libavfilter/avf_showvolume.c
@@ -85,26 +85,39 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
+ int ret;
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avf_showwaves.c b/libavfilter/avf_showwaves.c
index ec5291a..6b521c3 100644
--- a/libavfilter/avf_showwaves.c
+++ b/libavfilter/avf_showwaves.c
@@ -118,28 +118,41 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
+ int ret;
/* set input audio formats */
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
/* set output video format */
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index b429831..92e75df 100644
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -319,16 +319,23 @@ static int filter_query_formats(AVFilterContext *ctx)
formats = ff_all_formats(type);
if (!formats)
return AVERROR(ENOMEM);
- ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
if (type == AVMEDIA_TYPE_AUDIO) {
samplerates = ff_all_samplerates();
if (!samplerates)
return AVERROR(ENOMEM);
- ff_set_common_samplerates(ctx, samplerates);
+ if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
+ return ret;
chlayouts = ff_all_channel_layouts();
if (!chlayouts)
return AVERROR(ENOMEM);
- ff_set_common_channel_layouts(ctx, chlayouts);
+ if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0) {
+ ff_channel_layouts_unref(&chlayouts);
+ return ret;
+ }
}
return 0;
}
@@ -728,7 +735,7 @@ static int pick_format(AVFilterLink *link, AVFilterLink *ref)
return 0;
}
-#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
+#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format, unref_format) \
do { \
for (i = 0; i < filter->nb_inputs; i++) { \
AVFilterLink *link = filter->inputs[i]; \
@@ -748,7 +755,9 @@ do { \
fmts = out_link->in_ ## list; \
\
if (!out_link->in_ ## list->nb) { \
- add_format(&out_link->in_ ##list, fmt); \
+ if (add_format(&out_link->in_ ##list, fmt) < 0) { \
+ unref_format(&out_link->in_ ##list); \
+ } \
ret = 1; \
break; \
} \
@@ -769,9 +778,10 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
int i, j, k, ret = 0;
REDUCE_FORMATS(int, AVFilterFormats, formats, formats,
- nb_formats, ff_add_format);
+ nb_formats, ff_add_format, ff_formats_unref);
+#define UNUSED(x)
REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
- nb_formats, ff_add_format);
+ nb_formats, ff_add_format, UNUSED);
/* reduce channel layouts */
for (i = 0; i < filter->nb_inputs; i++) {
@@ -795,7 +805,10 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
(!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
/* Turn the infinite list into a singleton */
fmts->all_layouts = fmts->all_counts = 0;
- ff_add_channel_layout(&outlink->in_channel_layouts, fmt);
+ if (ff_add_channel_layout(&outlink->in_channel_layouts, fmt) < 0) {
+ ff_channel_layouts_unref(&outlink->in_channel_layouts);
+ ret = 1;
+ }
break;
}
diff --git a/libavfilter/buffersink.c b/libavfilter/buffersink.c
index 3206bd9..e6de61f 100644
--- a/libavfilter/buffersink.c
+++ b/libavfilter/buffersink.c
@@ -306,9 +306,13 @@ static int vsink_query_formats(AVFilterContext *ctx)
ff_formats_unref(&formats);
return ret;
}
- ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
} else {
- ff_default_query_formats(ctx);
+ if ((ret = ff_default_query_formats(ctx)) < 0)
+ return ret;
}
return 0;
@@ -350,7 +354,10 @@ static int asink_query_formats(AVFilterContext *ctx)
ff_formats_unref(&formats);
return ret;
}
- ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
if (buf->channel_layouts_size || buf->channel_counts_size ||
@@ -372,7 +379,10 @@ static int asink_query_formats(AVFilterContext *ctx)
else if (!(layouts = ff_all_channel_counts()))
return AVERROR(ENOMEM);
}
- ff_set_common_channel_layouts(ctx, layouts);
+ if ((ret = ff_set_common_channel_layouts(ctx, layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
}
if (buf->sample_rates_size) {
@@ -382,7 +392,8 @@ static int asink_query_formats(AVFilterContext *ctx)
ff_formats_unref(&formats);
return ret;
}
- ff_set_common_samplerates(ctx, formats);
+ if ((ret = ff_set_common_samplerates(ctx, formats)) < 0)
+ return ret;
}
return 0;
diff --git a/libavfilter/buffersrc.c b/libavfilter/buffersrc.c
index 45e219a..3801192 100644
--- a/libavfilter/buffersrc.c
+++ b/libavfilter/buffersrc.c
@@ -314,23 +314,38 @@ static int query_formats(AVFilterContext *ctx)
AVFilterChannelLayouts *channel_layouts = NULL;
AVFilterFormats *formats = NULL;
AVFilterFormats *samplerates = NULL;
+ int ret;
switch (ctx->outputs[0]->type) {
case AVMEDIA_TYPE_VIDEO:
- ff_add_format(&formats, c->pix_fmt);
- ff_set_common_formats(ctx, formats);
+ if ((ret = ff_add_format(&formats, c->pix_fmt)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
break;
case AVMEDIA_TYPE_AUDIO:
- ff_add_format(&formats, c->sample_fmt);
- ff_set_common_formats(ctx, formats);
+ if ((ret = ff_add_format(&formats, c->sample_fmt)) < 0)
+ return ret;
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
- ff_add_format(&samplerates, c->sample_rate);
- ff_set_common_samplerates(ctx, samplerates);
+ if ((ret = ff_add_format(&samplerates, c->sample_rate)) < 0)
+ return ret;
+ if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
+ return ret;
- ff_add_channel_layout(&channel_layouts,
+ if ((ret = ff_add_channel_layout(&channel_layouts,
c->channel_layout ? c->channel_layout :
- FF_COUNT2LAYOUT(c->channels));
- ff_set_common_channel_layouts(ctx, channel_layouts);
+ FF_COUNT2LAYOUT(c->channels))) < 0)
+ return ret;
+ if ((ret = ff_set_common_channel_layouts(ctx, channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&channel_layouts);
+ return ret;
+ }
break;
default:
return AVERROR(EINVAL);
diff --git a/libavfilter/drawutils.c b/libavfilter/drawutils.c
index b65d57c..554736e 100644
--- a/libavfilter/drawutils.c
+++ b/libavfilter/drawutils.c
@@ -532,10 +532,12 @@ AVFilterFormats *ff_draw_supported_pixel_formats(unsigned flags)
enum AVPixelFormat i;
FFDrawContext draw;
AVFilterFormats *fmts = NULL;
+ int ret;
for (i = 0; av_pix_fmt_desc_get(i); i++)
- if (ff_draw_init(&draw, i, flags) >= 0)
- ff_add_format(&fmts, i);
+ if (ff_draw_init(&draw, i, flags) >= 0
+ && (ret = ff_add_format(&fmts, i)) < 0)
+ ff_formats_unref(&fmts);
return fmts;
}
diff --git a/libavfilter/f_drawgraph.c b/libavfilter/f_drawgraph.c
index 2b9340b..5227183 100644
--- a/libavfilter/f_drawgraph.c
+++ b/libavfilter/f_drawgraph.c
@@ -110,11 +110,15 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_RGBA,
AV_PIX_FMT_NONE
};
+ int ret;
AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
if (!fmts_list)
return AVERROR(ENOMEM);
- ff_formats_ref(fmts_list, &outlink->in_formats);
+ if ((ret = ff_formats_ref(fmts_list, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&fmts_list);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/f_ebur128.c b/libavfilter/f_ebur128.c
index 20c9426..ffad432 100644
--- a/libavfilter/f_ebur128.c
+++ b/libavfilter/f_ebur128.c
@@ -826,6 +826,7 @@ static int query_formats(AVFilterContext *ctx)
AVFilterChannelLayouts *layouts;
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
+ int ret;
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE };
static const int input_srate[] = {48000, -1}; // ITU-R BS.1770 provides coeff only for 48kHz
@@ -836,7 +837,10 @@ static int query_formats(AVFilterContext *ctx)
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
outlink = ctx->outputs[1];
}
@@ -846,20 +850,29 @@ static int query_formats(AVFilterContext *ctx)
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_formats);
- ff_formats_ref(formats, &outlink->in_formats);
+ if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 ||
+ (ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
layouts = ff_all_channel_layouts();
if (!layouts)
return AVERROR(ENOMEM);
- ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
- ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 ||
+ (ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0) {
+ ff_channel_layouts_unref(&layouts);
+ return ret;
+ }
formats = ff_make_format_list(input_srate);
if (!formats)
return AVERROR(ENOMEM);
- ff_formats_ref(formats, &inlink->out_samplerates);
- ff_formats_ref(formats, &outlink->in_samplerates);
+ if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
+ (ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/formats.c b/libavfilter/formats.c
index a28be60..f65cd10 100644
--- a/libavfilter/formats.c
+++ b/libavfilter/formats.c
@@ -340,12 +340,18 @@ AVFilterFormats *ff_all_formats(enum AVMediaType type)
if (type == AVMEDIA_TYPE_VIDEO) {
const AVPixFmtDescriptor *desc = NULL;
while ((desc = av_pix_fmt_desc_next(desc))) {
- ff_add_format(&ret, av_pix_fmt_desc_get_id(desc));
+ if (ff_add_format(&ret, av_pix_fmt_desc_get_id(desc)) < 0) {
+ ff_formats_unref(&ret);
+ return NULL;
+ }
}
} else if (type == AVMEDIA_TYPE_AUDIO) {
enum AVSampleFormat fmt = 0;
while (av_get_sample_fmt_name(fmt)) {
- ff_add_format(&ret, fmt);
+ if (ff_add_format(&ret, fmt) < 0) {
+ ff_formats_unref(&ret);
+ return NULL;
+ }
fmt++;
}
}
@@ -370,7 +376,10 @@ AVFilterFormats *ff_planar_sample_fmts(void)
for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
if (av_sample_fmt_is_planar(fmt))
- ff_add_format(&ret, fmt);
+ if (ff_add_format(&ret, fmt) < 0) {
+ ff_formats_unref(&ret);
+ return NULL;
+ }
return ret;
}
diff --git a/libavfilter/src_movie.c b/libavfilter/src_movie.c
index bbdcbc8..0c2ceed 100644
--- a/libavfilter/src_movie.c
+++ b/libavfilter/src_movie.c
@@ -333,7 +333,7 @@ static int movie_query_formats(AVFilterContext *ctx)
MovieContext *movie = ctx->priv;
int list[] = { 0, -1 };
int64_t list64[] = { 0, -1 };
- int i;
+ int i, ret;
for (i = 0; i < ctx->nb_outputs; i++) {
MovieStream *st = &movie->st[i];
@@ -343,16 +343,20 @@ static int movie_query_formats(AVFilterContext *ctx)
switch (c->codec_type) {
case AVMEDIA_TYPE_VIDEO:
list[0] = c->pix_fmt;
- ff_formats_ref(ff_make_format_list(list), &outlink->in_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_formats)) < 0)
+ return ret;
break;
case AVMEDIA_TYPE_AUDIO:
list[0] = c->sample_fmt;
- ff_formats_ref(ff_make_format_list(list), &outlink->in_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_formats)) < 0)
+ return ret;
list[0] = c->sample_rate;
- ff_formats_ref(ff_make_format_list(list), &outlink->in_samplerates);
+ if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_samplerates)) < 0)
+ return ret;
list64[0] = c->channel_layout;
- ff_channel_layouts_ref(avfilter_make_format64_list(list64),
- &outlink->in_channel_layouts);
+ if ((ret = ff_channel_layouts_ref(avfilter_make_format64_list(list64),
+ &outlink->in_channel_layouts)) < 0)
+ return ret;
break;
}
}
diff --git a/libavfilter/vf_alphamerge.c b/libavfilter/vf_alphamerge.c
index 5f0da35..2cc18b9 100644
--- a/libavfilter/vf_alphamerge.c
+++ b/libavfilter/vf_alphamerge.c
@@ -58,11 +58,24 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_NONE
};
static const enum AVPixelFormat alpha_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
- AVFilterFormats *main_formats = ff_make_format_list(main_fmts);
- AVFilterFormats *alpha_formats = ff_make_format_list(alpha_fmts);
- ff_formats_ref(main_formats, &ctx->inputs[0]->out_formats);
- ff_formats_ref(alpha_formats, &ctx->inputs[1]->out_formats);
- ff_formats_ref(main_formats, &ctx->outputs[0]->in_formats);
+ AVFilterFormats *main_formats, *alpha_formats;
+ int ret;
+
+ if (!(main_formats = ff_make_format_list(main_fmts)) ||
+ !(alpha_formats = ff_make_format_list(alpha_fmts)))
+ return AVERROR(ENOMEM);
+ if ((ret = ff_formats_ref(main_formats, &ctx->inputs[0]->out_formats)) < 0) {
+ ff_formats_unref(&main_formats);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(alpha_formats, &ctx->inputs[1]->out_formats)) < 0) {
+ ff_formats_unref(&alpha_formats);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(main_formats, &ctx->outputs[0]->in_formats)) < 0) {
+ ff_formats_unref(&main_formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/vf_boxblur.c b/libavfilter/vf_boxblur.c
index 0e9bafd..a0234aa 100644
--- a/libavfilter/vf_boxblur.c
+++ b/libavfilter/vf_boxblur.c
@@ -118,17 +118,22 @@ static av_cold void uninit(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & (AV_PIX_FMT_FLAG_HWACCEL | AV_PIX_FMT_FLAG_BITSTREAM | AV_PIX_FMT_FLAG_PAL)) &&
(desc->flags & AV_PIX_FMT_FLAG_PLANAR || desc->nb_components == 1) &&
- (!(desc->flags & AV_PIX_FMT_FLAG_BE) == !HAVE_BIGENDIAN || desc->comp[0].depth == 8))
- ff_add_format(&formats, fmt);
+ (!(desc->flags & AV_PIX_FMT_FLAG_BE) == !HAVE_BIGENDIAN || desc->comp[0].depth == 8) &&
+ (ret = ff_add_format(&formats, fmt)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+ ff_formats_unref(&formats);
+ return ret;
}
static int config_input(AVFilterLink *inlink)
diff --git a/libavfilter/vf_crop.c b/libavfilter/vf_crop.c
index b695a6f..73ee0d5 100644
--- a/libavfilter/vf_crop.c
+++ b/libavfilter/vf_crop.c
@@ -93,16 +93,21 @@ typedef struct CropContext {
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & (AV_PIX_FMT_FLAG_HWACCEL | AV_PIX_FMT_FLAG_BITSTREAM)) &&
- !((desc->log2_chroma_w || desc->log2_chroma_h) && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)))
- ff_add_format(&formats, fmt);
+ !((desc->log2_chroma_w || desc->log2_chroma_h) && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) &&
+ (ret = ff_add_format(&formats, fmt)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+ ff_formats_unref(&formats);
+ return ret;
}
static av_cold void uninit(AVFilterContext *ctx)
diff --git a/libavfilter/vf_detelecine.c b/libavfilter/vf_detelecine.c
index 320e90d..bf877eb 100644
--- a/libavfilter/vf_detelecine.c
+++ b/libavfilter/vf_detelecine.c
@@ -116,17 +116,22 @@ static av_cold int init(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *pix_fmts = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
desc->flags & AV_PIX_FMT_FLAG_PAL ||
- desc->flags & AV_PIX_FMT_FLAG_BITSTREAM))
- ff_add_format(&pix_fmts, fmt);
+ desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
+ (ret = ff_add_format(&pix_fmts, fmt)) < 0) {
+ ff_formats_unref(&pix_fmts);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, pix_fmts);
+ if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+ ff_formats_unref(&pix_fmts);
+ return ret;
}
static int config_input(AVFilterLink *inlink)
diff --git a/libavfilter/vf_displace.c b/libavfilter/vf_displace.c
index 8c7b435..0005077 100644
--- a/libavfilter/vf_displace.c
+++ b/libavfilter/vf_displace.c
@@ -75,8 +75,10 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
};
+ int ret;
- ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
+ if ((ret = ff_set_common_formats(ctx, ff_make_format_list(pix_fmts))) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/vf_elbg.c b/libavfilter/vf_elbg.c
index 9805ecc..b34136b 100644
--- a/libavfilter/vf_elbg.c
+++ b/libavfilter/vf_elbg.c
@@ -83,6 +83,7 @@ static av_cold int init(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
ELBGContext *elbg = ctx->priv;
+ int ret;
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
@@ -99,8 +100,9 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_PAL8,
AV_PIX_FMT_NONE
};
- ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->inputs[0]->out_formats);
- ff_formats_ref(ff_make_format_list(pal8_fmt), &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->inputs[0]->out_formats)) < 0 ||
+ (ret = ff_formats_ref(ff_make_format_list(pal8_fmt), &ctx->outputs[0]->in_formats)) < 0)
+ return ret;
}
return 0;
}
diff --git a/libavfilter/vf_extractplanes.c b/libavfilter/vf_extractplanes.c
index 47a1748..1cb05e4 100644
--- a/libavfilter/vf_extractplanes.c
+++ b/libavfilter/vf_extractplanes.c
@@ -99,7 +99,7 @@ static int query_formats(AVFilterContext *ctx)
const enum AVPixelFormat *out_pixfmts;
const AVPixFmtDescriptor *desc;
AVFilterFormats *avff;
- int i, depth = 0, be = 0;
+ int i, ret, depth = 0, be = 0;
if (!ctx->inputs[0]->in_formats ||
!ctx->inputs[0]->in_formats->nb_formats) {
@@ -107,7 +107,8 @@ static int query_formats(AVFilterContext *ctx)
}
if (!ctx->inputs[0]->out_formats)
- ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->out_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->out_formats)) < 0)
+ return ret;
avff = ctx->inputs[0]->in_formats;
desc = av_pix_fmt_desc_get(avff->formats[0]);
@@ -129,7 +130,8 @@ static int query_formats(AVFilterContext *ctx)
out_pixfmts = out16le_pixfmts;
for (i = 0; i < ctx->nb_outputs; i++)
- ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->in_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->in_formats)) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/vf_fieldorder.c b/libavfilter/vf_fieldorder.c
index d0d6807..1c6f1e8 100644
--- a/libavfilter/vf_fieldorder.c
+++ b/libavfilter/vf_fieldorder.c
@@ -60,8 +60,11 @@ static int query_formats(AVFilterContext *ctx)
return ret;
}
}
- ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
- ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0 ||
+ (ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
return 0;
diff --git a/libavfilter/vf_frei0r.c b/libavfilter/vf_frei0r.c
index bbefe51..7d8d2eb 100644
--- a/libavfilter/vf_frei0r.c
+++ b/libavfilter/vf_frei0r.c
@@ -370,11 +370,14 @@ static int query_formats(AVFilterContext *ctx)
{
Frei0rContext *s = ctx->priv;
AVFilterFormats *formats = NULL;
+ int ret;
if (s->plugin_info.color_model == F0R_COLOR_MODEL_BGRA8888) {
- ff_add_format(&formats, AV_PIX_FMT_BGRA);
+ if ((ret = ff_add_format(&formats, AV_PIX_FMT_BGRA)) < 0)
+ return ret;
} else if (s->plugin_info.color_model == F0R_COLOR_MODEL_RGBA8888) {
- ff_add_format(&formats, AV_PIX_FMT_RGBA);
+ if ((ret = ff_add_format(&formats, AV_PIX_FMT_RGBA)) < 0)
+ return ret;
} else { /* F0R_COLOR_MODEL_PACKED32 */
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_ARGB, AV_PIX_FMT_NONE
@@ -385,7 +388,10 @@ static int query_formats(AVFilterContext *ctx)
if (!formats)
return AVERROR(ENOMEM);
- return ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
diff --git a/libavfilter/vf_hflip.c b/libavfilter/vf_hflip.c
index 362bd01..98a1697 100644
--- a/libavfilter/vf_hflip.c
+++ b/libavfilter/vf_hflip.c
@@ -44,18 +44,23 @@ typedef struct FlipContext {
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *pix_fmts = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ||
(desc->log2_chroma_w != desc->log2_chroma_h &&
- desc->comp[0].plane == desc->comp[1].plane)))
- ff_add_format(&pix_fmts, fmt);
+ desc->comp[0].plane == desc->comp[1].plane)) &&
+ (ret = ff_add_format(&pix_fmts, fmt)) < 0) {
+ ff_formats_unref(&pix_fmts);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, pix_fmts);
+ if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+ ff_formats_unref(&pix_fmts);
+ return ret;
}
static int config_props(AVFilterLink *inlink)
diff --git a/libavfilter/vf_histogram.c b/libavfilter/vf_histogram.c
index d8e935a..12ab21c 100644
--- a/libavfilter/vf_histogram.c
+++ b/libavfilter/vf_histogram.c
@@ -155,6 +155,7 @@ static int query_formats(AVFilterContext *ctx)
HistogramContext *h = ctx->priv;
const enum AVPixelFormat *pix_fmts;
AVFilterFormats *fmts_list;
+ int ret;
switch (h->mode) {
case MODE_WAVEFORM:
@@ -173,7 +174,8 @@ static int query_formats(AVFilterContext *ctx)
}
if (!ctx->inputs[0]->out_formats)
- ff_formats_ref(ff_make_format_list(levels_in_pix_fmts), &ctx->inputs[0]->out_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(levels_in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0)
+ return ret;
avff = ctx->inputs[0]->in_formats;
desc = av_pix_fmt_desc_get(avff->formats[0]);
rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
@@ -197,7 +199,8 @@ static int query_formats(AVFilterContext *ctx)
out_pix_fmts = levels_out_yuv9_pix_fmts;
else // if (bits == 10)
out_pix_fmts = levels_out_yuv10_pix_fmts;
- ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/vf_il.c b/libavfilter/vf_il.c
index d370b52..2b8f881 100644
--- a/libavfilter/vf_il.c
+++ b/libavfilter/vf_il.c
@@ -84,15 +84,21 @@ AVFILTER_DEFINE_CLASS(il);
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
- if (!(desc->flags & AV_PIX_FMT_FLAG_PAL) && !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
- ff_add_format(&formats, fmt);
+ if (!(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
+ !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
+ (ret = ff_add_format(&formats, fmt)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+ ff_formats_unref(&formats);
+ return ret;
}
static int config_input(AVFilterLink *inlink)
diff --git a/libavfilter/vf_maskedmerge.c b/libavfilter/vf_maskedmerge.c
index aa11d31..38a4663 100644
--- a/libavfilter/vf_maskedmerge.c
+++ b/libavfilter/vf_maskedmerge.c
@@ -58,8 +58,7 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_NONE
};
- ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
- return 0;
+ return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
}
static int process_frame(FFFrameSync *fs)
diff --git a/libavfilter/vf_mergeplanes.c b/libavfilter/vf_mergeplanes.c
index ea796be..9a91c98 100644
--- a/libavfilter/vf_mergeplanes.c
+++ b/libavfilter/vf_mergeplanes.c
@@ -116,22 +116,32 @@ static int query_formats(AVFilterContext *ctx)
{
MergePlanesContext *s = ctx->priv;
AVFilterFormats *formats = NULL;
- int i;
+ int i, ret;
s->outdesc = av_pix_fmt_desc_get(s->out_fmt);
for (i = 0; av_pix_fmt_desc_get(i); i++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
if (desc->comp[0].depth == s->outdesc->comp[0].depth &&
- av_pix_fmt_count_planes(i) == desc->nb_components)
- ff_add_format(&formats, i);
+ av_pix_fmt_count_planes(i) == desc->nb_components &&
+ (ret = ff_add_format(&formats, i)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
for (i = 0; i < s->nb_inputs; i++)
- ff_formats_ref(formats, &ctx->inputs[i]->out_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->inputs[i]->out_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
formats = NULL;
- ff_add_format(&formats, s->out_fmt);
- ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
+ if ((ret = ff_add_format(&formats, s->out_fmt)) < 0)
+ return ret;
+ if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/vf_neighbor.c b/libavfilter/vf_neighbor.c
index c3c7f74..7e4f605 100644
--- a/libavfilter/vf_neighbor.c
+++ b/libavfilter/vf_neighbor.c
@@ -49,8 +49,7 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
};
- ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
- return 0;
+ return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
}
static av_cold void uninit(AVFilterContext *ctx)
diff --git a/libavfilter/vf_noise.c b/libavfilter/vf_noise.c
index c658bba..6bce791 100644
--- a/libavfilter/vf_noise.c
+++ b/libavfilter/vf_noise.c
@@ -133,15 +133,20 @@ static av_cold int init_noise(NoiseContext *n, int comp)
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (desc->flags & AV_PIX_FMT_FLAG_PLANAR && !(desc->comp[0].depth & 7))
- ff_add_format(&formats, fmt);
+ if ((ret = ff_add_format(&formats, fmt)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+ ff_formats_unref(&formats);
+ return ret;
}
static int config_input(AVFilterLink *inlink)
diff --git a/libavfilter/vf_overlay.c b/libavfilter/vf_overlay.c
index 81c9cc1..398e5d7 100644
--- a/libavfilter/vf_overlay.c
+++ b/libavfilter/vf_overlay.c
@@ -247,31 +247,45 @@ static int query_formats(AVFilterContext *ctx)
AVFilterFormats *main_formats;
AVFilterFormats *overlay_formats;
+ int ret;
switch (s->format) {
case OVERLAY_FORMAT_YUV420:
- main_formats = ff_make_format_list(main_pix_fmts_yuv420);
- overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv420);
+ if (!(main_formats = ff_make_format_list(main_pix_fmts_yuv420)) ||
+ !(overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv420)))
+ return AVERROR(ENOMEM);
break;
case OVERLAY_FORMAT_YUV422:
- main_formats = ff_make_format_list(main_pix_fmts_yuv422);
- overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv422);
+ if (!(main_formats = ff_make_format_list(main_pix_fmts_yuv422)) ||
+ !(overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv422)))
+ return AVERROR(ENOMEM);
break;
case OVERLAY_FORMAT_YUV444:
- main_formats = ff_make_format_list(main_pix_fmts_yuv444);
- overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv444);
+ if (!(main_formats = ff_make_format_list(main_pix_fmts_yuv444)) ||
+ !(overlay_formats = ff_make_format_list(overlay_pix_fmts_yuv444)))
+ return AVERROR(ENOMEM);
break;
case OVERLAY_FORMAT_RGB:
- main_formats = ff_make_format_list(main_pix_fmts_rgb);
- overlay_formats = ff_make_format_list(overlay_pix_fmts_rgb);
+ if (!(main_formats = ff_make_format_list(main_pix_fmts_rgb)) ||
+ !(overlay_formats = ff_make_format_list(overlay_pix_fmts_rgb)))
+ return AVERROR(ENOMEM);
break;
default:
av_assert0(0);
}
- ff_formats_ref(main_formats, &ctx->inputs [MAIN ]->out_formats);
- ff_formats_ref(overlay_formats, &ctx->inputs [OVERLAY]->out_formats);
- ff_formats_ref(main_formats, &ctx->outputs[MAIN ]->in_formats );
+ if ((ret = ff_formats_ref(main_formats, &ctx->inputs[MAIN]->out_formats)) < 0) {
+ ff_formats_unref(&main_formats);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(overlay_formats, &ctx->inputs[OVERLAY]->out_formats)) < 0) {
+ ff_formats_unref(&overlay_formats);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(main_formats, &ctx->outputs[MAIN]->in_formats)) < 0) {
+ ff_formats_unref(&main_formats);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/vf_palettegen.c b/libavfilter/vf_palettegen.c
index 025bb53..d58c51b 100644
--- a/libavfilter/vf_palettegen.c
+++ b/libavfilter/vf_palettegen.c
@@ -92,6 +92,7 @@ static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat in_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
+ int ret;
AVFilterFormats *in = ff_make_format_list(in_fmts);
AVFilterFormats *out = ff_make_format_list(out_fmts);
if (!in || !out) {
@@ -99,8 +100,14 @@ static int query_formats(AVFilterContext *ctx)
av_freep(&out);
return AVERROR(ENOMEM);
}
- ff_formats_ref(in, &ctx->inputs[0]->out_formats);
- ff_formats_ref(out, &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(in, &ctx->inputs[0]->out_formats)) < 0) {
+ ff_formats_unref(&in);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(out, &ctx->outputs[0]->in_formats)) < 0) {
+ ff_formats_unref(&out);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/vf_paletteuse.c b/libavfilter/vf_paletteuse.c
index f8350ac..af79d99 100644
--- a/libavfilter/vf_paletteuse.c
+++ b/libavfilter/vf_paletteuse.c
@@ -132,6 +132,7 @@ static int query_formats(AVFilterContext *ctx)
static const enum AVPixelFormat in_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
static const enum AVPixelFormat inpal_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE};
+ int ret;
AVFilterFormats *in = ff_make_format_list(in_fmts);
AVFilterFormats *inpal = ff_make_format_list(inpal_fmts);
AVFilterFormats *out = ff_make_format_list(out_fmts);
@@ -141,9 +142,18 @@ static int query_formats(AVFilterContext *ctx)
av_freep(&out);
return AVERROR(ENOMEM);
}
- ff_formats_ref(in, &ctx->inputs[0]->out_formats);
- ff_formats_ref(inpal, &ctx->inputs[1]->out_formats);
- ff_formats_ref(out, &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(in, &ctx->inputs[0]->out_formats)) < 0) {
+ ff_formats_unref(&in);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(inpal, &ctx->inputs[1]->out_formats)) < 0) {
+ ff_formats_unref(&inpal);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(out, &ctx->outputs[0]->in_formats)) < 0) {
+ ff_formats_unref(&out);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/vf_scale.c b/libavfilter/vf_scale.c
index fd98abf..f669d38 100644
--- a/libavfilter/vf_scale.c
+++ b/libavfilter/vf_scale.c
@@ -192,7 +192,8 @@ static int query_formats(AVFilterContext *ctx)
return ret;
}
}
- ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0)
+ goto fail;
}
if (ctx->outputs[0]) {
const AVPixFmtDescriptor *desc = NULL;
@@ -206,10 +207,14 @@ static int query_formats(AVFilterContext *ctx)
return ret;
}
}
- ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0)
+ goto fail;
}
return 0;
+fail:
+ ff_formats_unref(&formats);
+ return ret;
}
static const int *parse_yuv_type(const char *s, enum AVColorSpace colorspace)
diff --git a/libavfilter/vf_showpalette.c b/libavfilter/vf_showpalette.c
index e4d59b6..259d624 100644
--- a/libavfilter/vf_showpalette.c
+++ b/libavfilter/vf_showpalette.c
@@ -46,6 +46,7 @@ static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat in_fmts[] = {AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE};
static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
+ int ret;
AVFilterFormats *in = ff_make_format_list(in_fmts);
AVFilterFormats *out = ff_make_format_list(out_fmts);
if (!in || !out) {
@@ -53,8 +54,14 @@ static int query_formats(AVFilterContext *ctx)
av_freep(&out);
return AVERROR(ENOMEM);
}
- ff_formats_ref(in, &ctx->inputs[0]->out_formats);
- ff_formats_ref(out, &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(in, &ctx->inputs[0]->out_formats)) < 0) {
+ ff_formats_unref(&in);
+ return ret;
+ }
+ if ((ret = ff_formats_ref(out, &ctx->outputs[0]->in_formats)) < 0) {
+ ff_formats_unref(&out);
+ return ret;
+ }
return 0;
}
diff --git a/libavfilter/vf_stack.c b/libavfilter/vf_stack.c
index 8a90caa..d344840 100644
--- a/libavfilter/vf_stack.c
+++ b/libavfilter/vf_stack.c
@@ -43,17 +43,22 @@ typedef struct StackContext {
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *pix_fmts = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & AV_PIX_FMT_FLAG_PAL ||
desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
- desc->flags & AV_PIX_FMT_FLAG_BITSTREAM))
- ff_add_format(&pix_fmts, fmt);
+ desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
+ (ret = ff_add_format(&pix_fmts, fmt)) < 0) {
+ ff_formats_unref(&pix_fmts);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, pix_fmts);
+ if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+ ff_formats_unref(&pix_fmts);
+ return ret;
}
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
diff --git a/libavfilter/vf_swapuv.c b/libavfilter/vf_swapuv.c
index 624e6b6..c9c98ac 100644
--- a/libavfilter/vf_swapuv.c
+++ b/libavfilter/vf_swapuv.c
@@ -77,15 +77,19 @@ static int is_planar_yuv(const AVPixFmtDescriptor *desc)
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
- if (is_planar_yuv(desc))
- ff_add_format(&formats, fmt);
+ if (is_planar_yuv(desc) && (ret = ff_add_format(&formats, fmt)) < 0) {
+ ff_formats_unref(&formats);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, formats);
+ if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+ ff_formats_unref(&formats);
+ return ret;
}
static const AVFilterPad swapuv_inputs[] = {
diff --git a/libavfilter/vf_telecine.c b/libavfilter/vf_telecine.c
index bb091e1..471a9cf 100644
--- a/libavfilter/vf_telecine.c
+++ b/libavfilter/vf_telecine.c
@@ -102,17 +102,22 @@ static av_cold int init(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *pix_fmts = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
desc->flags & AV_PIX_FMT_FLAG_PAL ||
- desc->flags & AV_PIX_FMT_FLAG_BITSTREAM))
- ff_add_format(&pix_fmts, fmt);
+ desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
+ (ret = ff_add_format(&pix_fmts, fmt)) < 0) {
+ ff_formats_unref(&pix_fmts);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, pix_fmts);
+ if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+ ff_formats_unref(&pix_fmts);
+ return ret;
}
static int config_input(AVFilterLink *inlink)
diff --git a/libavfilter/vf_transpose.c b/libavfilter/vf_transpose.c
index 484b8e8..a3b6933 100644
--- a/libavfilter/vf_transpose.c
+++ b/libavfilter/vf_transpose.c
@@ -63,19 +63,24 @@ typedef struct TransContext {
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *pix_fmts = NULL;
- int fmt;
+ int fmt, ret;
for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & AV_PIX_FMT_FLAG_PAL ||
desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ||
- desc->log2_chroma_w != desc->log2_chroma_h))
- ff_add_format(&pix_fmts, fmt);
+ desc->log2_chroma_w != desc->log2_chroma_h) &&
+ (ret = ff_add_format(&pix_fmts, fmt)) < 0) {
+ ff_formats_unref(&pix_fmts);
+ return ret;
+ }
}
- return ff_set_common_formats(ctx, pix_fmts);
+ if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+ ff_formats_unref(&pix_fmts);
+ return ret;
}
static int config_props_output(AVFilterLink *outlink)
diff --git a/libavfilter/vf_vectorscope.c b/libavfilter/vf_vectorscope.c
index 730f55f..5f7cd56 100644
--- a/libavfilter/vf_vectorscope.c
+++ b/libavfilter/vf_vectorscope.c
@@ -140,7 +140,7 @@ static int query_formats(AVFilterContext *ctx)
const enum AVPixelFormat *out_pix_fmts;
const AVPixFmtDescriptor *desc;
AVFilterFormats *avff;
- int depth, rgb, i;
+ int depth, rgb, i, ret;
if (!ctx->inputs[0]->in_formats ||
!ctx->inputs[0]->in_formats->nb_formats) {
@@ -154,7 +154,8 @@ static int query_formats(AVFilterContext *ctx)
in_pix_fmts = in2_pix_fmts;
else
in_pix_fmts = in1_pix_fmts;
- ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0)
+ return ret;
}
avff = ctx->inputs[0]->in_formats;
@@ -180,7 +181,8 @@ static int query_formats(AVFilterContext *ctx)
out_pix_fmts = out_yuv10_pix_fmts;
else
out_pix_fmts = out_yuv8_pix_fmts;
- ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats);
+ if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
+ return ret;
return 0;
}
diff --git a/libavfilter/vsrc_life.c b/libavfilter/vsrc_life.c
index 314746d..0fd4253 100644
--- a/libavfilter/vsrc_life.c
+++ b/libavfilter/vsrc_life.c
@@ -417,6 +417,7 @@ static int query_formats(AVFilterContext *ctx)
LifeContext *life = ctx->priv;
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_NONE, AV_PIX_FMT_NONE };
AVFilterFormats *fmts_list;
+ int ret;
if (life->mold || memcmp(life-> life_color, "\xff\xff\xff", 3)
|| memcmp(life->death_color, "\x00\x00\x00", 3)) {
@@ -430,7 +431,10 @@ static int query_formats(AVFilterContext *ctx)
fmts_list = ff_make_format_list(pix_fmts);
if (!fmts_list)
return AVERROR(ENOMEM);
- ff_set_common_formats(ctx, fmts_list);
+ if ((ret = ff_set_common_formats(ctx, fmts_list)) < 0) {
+ ff_formats_unref(&fmts_list);
+ return ret;
+ }
return 0;
}
--
2.6.0
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
http://ffmpeg.org/mailman/listinfo/ffmpeg-devel
