libavfilter: Use type-safe format negotiation functions with enum parameters

Replace generic format functions with type-safe variants to prevent undefined
behavior with -fshort-enums compiler flag.

- 44/20 filters: ff_set_common_formats_from_list2 -> ff_set_*_formats_from_list2 (sample/pixel)
- 16/41 filters: ff_make_format_list → ff_make_*_format_list (sample/pixel)

Signed-off-by: niyinghao <niyinghao@xiaomi.com>

libavfilter/aeval.c

@@ -253,7 +253,7 @@ static int query_formats(const AVFilterContext *ctx,
     int sample_rates[] = { eval->sample_rate, -1 };
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 
@@ -372,7 +372,7 @@ static int aeval_query_formats(const AVFilterContext *ctx,
             return ret;
     }
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)
         return ret;
 
     return 0;

libavfilter/af_aap.c

@@ -107,7 +107,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out,
                                                 sample_fmts[s->precision])) < 0)
         return ret;
 

libavfilter/af_acrossover.c

@@ -138,7 +138,7 @@ static int query_formats(const AVFilterContext *ctx,
     default:
         break;
     }
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts_list);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts_list);
     if (ret < 0)
         return ret;
 

libavfilter/af_adynamicequalizer.c

@@ -122,7 +122,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out,
                                                 sample_fmts[s->precision])) < 0)
         return ret;
 

libavfilter/af_afir.c

@@ -569,7 +569,7 @@ static int query_formats(const AVFilterContext *ctx,
         }
     }
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out,
                                                 sample_fmts[s->precision])) < 0)
         return ret;
 

libavfilter/af_aformat.c

@@ -112,7 +112,7 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     if (s->nb_formats) {
-        ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, s->formats);
+        ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, s->formats);
         if (ret < 0)
             return ret;
     }

libavfilter/af_agate.c

@@ -328,7 +328,7 @@ static int scquery_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)
         return ret;
 
     return 0;

libavfilter/af_aiir.c

@@ -95,13 +95,13 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     if (s->response) {
-        formats = ff_make_format_list(pix_fmts);
+        formats = ff_make_pixel_format_list(pix_fmts);
         if ((ret = ff_formats_ref(formats, &cfg_out[1]->formats)) < 0)
             return ret;
     }
 
     sample_fmts[0] = s->sample_format;
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_amerge.c

@@ -163,7 +163,7 @@ static int query_formats(AVFilterContext *ctx)
     default:
         av_unreachable("Invalid layout_mode");
     }
-    if ((ret = ff_set_common_formats_from_list(ctx, packed_sample_fmts)) < 0)
+    if ((ret = ff_set_sample_formats_from_list(ctx, packed_sample_fmts)) < 0)
         goto out;
     for (i = 0; i < s->nb_inputs; i++) {
         layouts = NULL;

libavfilter/af_anequalizer.c

@@ -230,12 +230,12 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     if (s->draw_curves) {
-        ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+        ret = ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
         if (ret < 0)
             return ret;
     }
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_anlms.c

@@ -99,7 +99,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out,
                                                 sample_fmts[s->precision])) < 0)
         return ret;
 

libavfilter/af_apulsator.c

@@ -200,7 +200,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_aresample.c

@@ -105,8 +105,8 @@ static int query_formats(const AVFilterContext *ctx,
         return ret;
 
     if(out_format != AV_SAMPLE_FMT_NONE) {
-        int formatlist[] = { out_format, -1 };
-        out_formats = ff_make_format_list(formatlist);
+        enum AVSampleFormat formatlist[] = { out_format, AV_SAMPLE_FMT_NONE };
+        out_formats = ff_make_sample_format_list(formatlist);
     } else
         out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
     if ((ret = ff_formats_ref(out_formats, &cfg_out[0]->formats)) < 0)

libavfilter/af_arls.c

@@ -96,7 +96,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out,
                                                 sample_fmts[s->precision])) < 0)
         return ret;
 

libavfilter/af_arnndn.c

@@ -337,7 +337,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret, sample_rates[] = { 48000, -1 };
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_asr.c

@@ -139,7 +139,7 @@ static int query_formats(const AVFilterContext *ctx,
     int sample_rates[] = { s->rate, -1 };
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_biquads.c

@@ -190,7 +190,7 @@ static int query_formats(const AVFilterContext *ctx,
         sample_fmts_list = auto_sample_fmts;
         break;
     }
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts_list);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts_list);
     if (ret < 0)
         return ret;
 

libavfilter/af_bs2b.c

@@ -113,7 +113,7 @@ static int query_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_crossfeed.c

@@ -63,7 +63,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_dialoguenhance.c

@@ -82,7 +82,7 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterChannelLayouts *in_layout = NULL, *out_layout = NULL;
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_earwax.c

@@ -95,7 +95,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_extrastereo.c

@@ -57,7 +57,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_haas.c

@@ -95,7 +95,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_hdcd.c

@@ -1636,12 +1636,12 @@ static int query_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    in_formats = ff_make_format_list(sample_fmts_in);
+    in_formats = ff_make_sample_format_list(sample_fmts_in);
     ret = ff_formats_ref(in_formats, &cfg_in[0]->formats);
     if (ret < 0)
         return ret;
 
-    out_formats = ff_make_format_list(sample_fmts_out);
+    out_formats = ff_make_sample_format_list(sample_fmts_out);
     ret = ff_formats_ref(out_formats, &cfg_out[0]->formats);
     if (ret < 0)
         return ret;

libavfilter/af_headphone.c

@@ -610,7 +610,7 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterChannelLayouts *hrir_layouts = NULL;
     int ret, i;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret)
         return ret;
 

libavfilter/af_ladspa.c

@@ -702,7 +702,7 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterChannelLayouts *layouts;
     static const enum AVSampleFormat sample_fmts[] = {
         AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_loudnorm.c

@@ -740,7 +740,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_lv2.c

@@ -483,7 +483,7 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterChannelLayouts *layouts;
     static const enum AVSampleFormat sample_fmts[] = {
         AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/af_replaygain.c

@@ -343,7 +343,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     int i, ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_sidechaincompress.c

@@ -314,7 +314,7 @@ static int query_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    if ((ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)
+    if ((ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts)) < 0)
         return ret;
 
     return 0;

libavfilter/af_sofalizer.c

@@ -646,7 +646,7 @@ static int query_formats(const AVFilterContext *ctx,
         AV_SAMPLE_FMT_NONE
     };
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret)
         return ret;
 

libavfilter/af_stereotools.c

@@ -117,7 +117,7 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_stereowiden.c

@@ -69,7 +69,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_surround.c

@@ -159,7 +159,7 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterChannelLayouts *layouts = NULL;
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret)
         return ret;
 

libavfilter/af_virtualbass.c

@@ -60,7 +60,7 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterChannelLayouts *in_layout = NULL, *out_layout = NULL;
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/af_volume.c

@@ -155,7 +155,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts[vol->precision]);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts[vol->precision]);
     if (ret < 0)
         return ret;
 

libavfilter/af_whisper.c

@@ -414,7 +414,7 @@ static int query_formats(const AVFilterContext *ctx,
     int sample_rates[] = { WHISPER_SAMPLE_RATE, -1 };
     int ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_afdelaysrc.c

@@ -89,7 +89,7 @@ static int query_formats(const AVFilterContext *ctx,
     int sample_rates[] = { s->sample_rate, -1 };
     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP,
                                                        AV_SAMPLE_FMT_NONE };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_afirsrc.c

@@ -124,7 +124,7 @@ static av_cold int query_formats(const AVFilterContext *ctx,
         AV_SAMPLE_FMT_FLT,
         AV_SAMPLE_FMT_NONE
     };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_anoisesrc.c

@@ -94,7 +94,7 @@ static av_cold int query_formats(const AVFilterContext *ctx,
         AV_SAMPLE_FMT_DBL,
         AV_SAMPLE_FMT_NONE
     };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_flite.c

@@ -278,7 +278,7 @@ static int query_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, formats);
+    ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, formats);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_hilbert.c

@@ -86,7 +86,7 @@ static av_cold int query_formats(const AVFilterContext *ctx,
         AV_SAMPLE_FMT_FLT,
         AV_SAMPLE_FMT_NONE
     };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_sinc.c

@@ -83,7 +83,7 @@ static int query_formats(const AVFilterContext *ctx,
     int sample_rates[] = { s->sample_rate, -1 };
     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLT,
                                                        AV_SAMPLE_FMT_NONE };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/asrc_sine.c

@@ -221,7 +221,7 @@ static av_cold int query_formats(const AVFilterContext *ctx,
     int sample_rates[] = { sine->sample_rate, -1 };
     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_NONE };
-    int ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
+    int ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, sample_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/avf_a3dscope.c

@@ -82,11 +82,11 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_abitscope.c

@@ -77,11 +77,11 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_ahistogram.c

@@ -101,11 +101,11 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
     int ret = AVERROR(EINVAL);
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_aphasemeter.c

@@ -104,7 +104,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0 ||
         (ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
@@ -114,7 +114,7 @@ static int query_formats(const AVFilterContext *ctx,
         return ret;
 
     if (s->do_video) {
-        formats = ff_make_format_list(pix_fmts);
+        formats = ff_make_pixel_format_list(pix_fmts);
         if ((ret = ff_formats_ref(formats, &cfg_out[1]->formats)) < 0)
             return ret;
     }

libavfilter/avf_avectorscope.c

@@ -243,7 +243,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref         (formats, &cfg_in[0]->formats        )) < 0)
         return ret;
 
@@ -251,7 +251,7 @@ static int query_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showcqt.c

@@ -1330,7 +1330,7 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     /* set input audio formats */
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
@@ -1339,7 +1339,7 @@ static int query_formats(const AVFilterContext *ctx,
         return ret;
 
     /* set output video format */
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showcwt.c

@@ -231,11 +231,11 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showfreqs.c

@@ -126,12 +126,12 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     /* set input audio formats */
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
     /* set output video format */
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showspatial.c

@@ -90,7 +90,7 @@ static int query_formats(const AVFilterContext *ctx,
     static const AVChannelLayout layouts[] = { AV_CHANNEL_LAYOUT_STEREO, { .nb_channels = 0 } };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
@@ -98,7 +98,7 @@ static int query_formats(const AVFilterContext *ctx,
     if (ret < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showspectrum.c

@@ -368,12 +368,12 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     /* set input audio formats */
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
     /* set output video format */
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showvolume.c

@@ -119,11 +119,11 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/avf_showwaves.c

@@ -165,12 +165,12 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     /* set input audio formats */
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
         return ret;
 
     /* set output video format */
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/buffersink.c

@@ -400,7 +400,7 @@ static int vsink_query_formats(const AVFilterContext *ctx,
     if (buf->nb_pixel_formats || buf->nb_colorspaces || buf->nb_colorranges || buf->nb_alphamodes) {
 #endif
         if (buf->nb_pixel_formats) {
-            ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, buf->pixel_formats);
+            ret = ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, buf->pixel_formats);
             if (ret < 0)
                 return ret;
         }
@@ -474,7 +474,7 @@ static int asink_query_formats(const AVFilterContext *ctx,
     if (buf->nb_sample_formats || buf->nb_samplerates || buf->nb_channel_layouts) {
 #endif
         if (buf->nb_sample_formats) {
-            ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, buf->sample_formats);
+            ret = ff_set_sample_formats_from_list2(ctx, cfg_in, cfg_out, buf->sample_formats);
             if (ret < 0)
                 return ret;
         }

libavfilter/f_drawgraph.c

@@ -137,7 +137,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    AVFilterFormats *fmts_list = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(fmts_list, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/f_ebur128.c

@@ -1022,7 +1022,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     /* set optional output video format */
     if (ebur128->do_video) {
-        formats = ff_make_format_list(pix_fmts);
+        formats = ff_make_pixel_format_list(pix_fmts);
         if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
             return ret;
         out_idx = 1;
@@ -1031,7 +1031,7 @@ static int query_formats(const AVFilterContext *ctx,
     /* set input and output audio formats
      * Note: ff_set_common_* functions are not used because they affect all the
      * links, and thus break the video format negotiation */
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0 ||
         (ret = ff_formats_ref(formats, &cfg_out[out_idx]->formats)) < 0)
         return ret;

libavfilter/f_graphmonitor.c

@@ -156,7 +156,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    AVFilterFormats *fmts_list = ff_make_pixel_format_list(pix_fmts);
     if ((ret = ff_formats_ref(fmts_list, &cfg_out[0]->formats)) < 0)
         return ret;
 

libavfilter/f_select.c

@@ -527,7 +527,7 @@ static int query_formats(const AVFilterContext *ctx,
             AV_PIX_FMT_YUV420P10,
             AV_PIX_FMT_NONE
         };
-        return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+        return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
     }
     return 0;
 }

libavfilter/src_avsynctest.c

@@ -109,7 +109,7 @@ static av_cold int query_formats(const AVFilterContext *ctx,
     AVFilterFormats *formats;
     int ret;
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)

libavfilter/vaapi_vpp.c

@@ -35,7 +35,7 @@ int ff_vaapi_vpp_query_formats(const AVFilterContext *avctx,
     };
     int err;
 
-    err = ff_set_common_formats_from_list2(avctx, cfg_in, cfg_out, pix_fmts);
+    err = ff_set_pixel_formats_from_list2(avctx, cfg_in, cfg_out, pix_fmts);
     if (err < 0)
         return err;
 

libavfilter/vaf_spectrumsynth.c

@@ -111,7 +111,7 @@ static int query_formats(const AVFilterContext *ctx,
                                                    AV_PIX_FMT_YUV444P16, AV_PIX_FMT_NONE };
     int ret, sample_rates[] = { 48000, -1 };
 
-    formats = ff_make_format_list(sample_fmts);
+    formats = ff_make_sample_format_list(sample_fmts);
     if ((ret = ff_formats_ref         (formats, &cfg_out[0]->formats         )) < 0 ||
         (ret = ff_add_channel_layout  (&layout, &FF_COUNT2LAYOUT(s->channels))) < 0 ||
         (ret = ff_channel_layouts_ref (layout , &cfg_out[0]->channel_layouts)) < 0)
@@ -124,13 +124,13 @@ static int query_formats(const AVFilterContext *ctx,
     if ((ret = ff_formats_ref(formats, &cfg_out[0]->samplerates)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     if ((ret = ff_formats_ref(formats, &cfg_in[MAGNITUDE]->formats)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     if ((ret = ff_formats_ref(formats, &cfg_in[PHASE]->formats)) < 0)

libavfilter/vf_alphamerge.c

@@ -111,12 +111,12 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat alpha_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
     int ret;
 
-    ret = ff_formats_ref(ff_make_format_list(alpha_fmts),
+    ret = ff_formats_ref(ff_make_pixel_format_list(alpha_fmts),
                          &cfg_in[1]->formats);
     if (ret < 0)
         return ret;
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, main_fmts);
+    ret = ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, main_fmts);
     if (ret < 0)
         return ret;
 

libavfilter/vf_amf_common.c

@@ -218,11 +218,11 @@ int amf_setup_input_output_formats(AVFilterContext *avctx,
         }
     }
 
-    input_formats = ff_make_format_list(output_pix_fmts);
+    input_formats = ff_make_pixel_format_list(output_pix_fmts);
     if (!input_formats) {
         return AVERROR(ENOMEM);
     }
-    output_formats = ff_make_format_list(output_pix_fmts);
+    output_formats = ff_make_pixel_format_list(output_pix_fmts);
     if (!output_formats) {
         return AVERROR(ENOMEM);
     }

libavfilter/vf_blackdetect.c

@@ -117,9 +117,9 @@ static int query_format(const AVFilterContext *ctx,
     const BlackDetectContext *s = ctx->priv;
     AVFilterFormats *formats;
     if (s->alpha)
-        formats = ff_make_format_list(yuva_formats);
+        formats = ff_make_pixel_format_list(yuva_formats);
     else
-        formats = ff_make_format_list(yuv_formats);
+        formats = ff_make_pixel_format_list(yuv_formats);
 
     return ff_set_common_formats2(ctx, cfg_in, cfg_out, formats);
 }

libavfilter/vf_ciescope.c

@@ -145,10 +145,10 @@ static int query_formats(const AVFilterContext *ctx,
 {
     int ret;
 
-    if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &cfg_in[0]->formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(in_pix_fmts), &cfg_in[0]->formats)) < 0)
         return ret;
 
-    if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &cfg_out[0]->formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(out_pix_fmts), &cfg_out[0]->formats)) < 0)
         return ret;
 
     return 0;

libavfilter/vf_colorspace.c

@@ -873,7 +873,7 @@ static int query_formats(const AVFilterContext *ctx,
             return res;
     }
 
-    formats = ff_make_format_list(pix_fmts);
+    formats = ff_make_pixel_format_list(pix_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     if (s->user_format == AV_PIX_FMT_NONE)

libavfilter/vf_deband.c

@@ -112,7 +112,7 @@ static int query_formats(const AVFilterContext *ctx,
         AV_PIX_FMT_NONE
     };
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out,
                                             s->coupling ? cpix_fmts : pix_fmts);
 }
 

libavfilter/vf_edgedetect.c

@@ -116,7 +116,7 @@ static int query_formats(const AVFilterContext *ctx,
     } else {
         av_assert0(0);
     }
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
 }
 
 static int config_props(AVFilterLink *inlink)

libavfilter/vf_elbg.c

@@ -98,14 +98,14 @@ static int query_formats(const AVFilterContext *ctx,
         AV_PIX_FMT_NONE
     };
     if (!elbg->pal8) {
-        return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+        return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
     } else {
         static const enum AVPixelFormat pal8_fmt[] = {
             AV_PIX_FMT_PAL8,
             AV_PIX_FMT_NONE
         };
-        if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), &cfg_in[0]->formats)) < 0 ||
-            (ret = ff_formats_ref(ff_make_format_list(pal8_fmt), &cfg_out[0]->formats)) < 0)
+        if ((ret = ff_formats_ref(ff_make_pixel_format_list(pix_fmts), &cfg_in[0]->formats)) < 0 ||
+            (ret = ff_formats_ref(ff_make_pixel_format_list(pal8_fmt), &cfg_out[0]->formats)) < 0)
             return ret;
     }
     return 0;

libavfilter/vf_extractplanes.c

@@ -175,7 +175,7 @@ static int query_formats(AVFilterContext *ctx)
         in_pixfmts = in_pixfmts_le;
     }
     if (!ctx->inputs[0]->outcfg.formats)
-        if ((ret = ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->outcfg.formats)) < 0)
+        if ((ret = ff_formats_ref(ff_make_pixel_format_list(in_pixfmts), &ctx->inputs[0]->outcfg.formats)) < 0)
             return ret;
 
     for (i = 1; i < avff->nb_formats; i++) {
@@ -218,7 +218,7 @@ static int query_formats(AVFilterContext *ctx)
         return ret;
 
     for (i = 0; i < ctx->nb_outputs; i++)
-        if ((ret = ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->incfg.formats)) < 0)
+        if ((ret = ff_formats_ref(ff_make_pixel_format_list(out_pixfmts), &ctx->outputs[i]->incfg.formats)) < 0)
             return ret;
     return 0;
 }

libavfilter/vf_fade.c

@@ -181,7 +181,7 @@ static int query_formats(const AVFilterContext *ctx,
             return ret;
     }
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pixel_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pixel_fmts);
 }
 
 const static enum AVPixelFormat studio_level_pix_fmts[] = {

libavfilter/vf_fieldmatch.c

@@ -927,7 +927,7 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    AVFilterFormats *fmts_list = ff_make_pixel_format_list(pix_fmts);
     if (!fmts_list)
         return AVERROR(ENOMEM);
     if (!fm->ppsrc) {
@@ -936,7 +936,7 @@ static int query_formats(const AVFilterContext *ctx,
 
     if ((ret = ff_formats_ref(fmts_list, &cfg_in[INPUT_MAIN]->formats)) < 0)
         return ret;
-    fmts_list = ff_make_format_list(unproc_pix_fmts);
+    fmts_list = ff_make_pixel_format_list(unproc_pix_fmts);
     if (!fmts_list)
         return AVERROR(ENOMEM);
     if ((ret = ff_formats_ref(fmts_list, &cfg_out[0]->formats)) < 0)

libavfilter/vf_frei0r.c

@@ -348,7 +348,7 @@ static int query_formats(const AVFilterContext *ctx,
         static const enum AVPixelFormat pix_fmts[] = {
             AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_NONE
         };
-        formats = ff_make_format_list(pix_fmts);
+        formats = ff_make_pixel_format_list(pix_fmts);
     }
 
     if (!formats)

libavfilter/vf_geq.c

@@ -373,7 +373,7 @@ static int geq_query_formats(const AVFilterContext *ctx,
     };
     const enum AVPixelFormat *pix_fmts = geq->is_rgb ? rgb_pix_fmts : yuv_pix_fmts;
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
 }
 
 static int geq_config_props(AVFilterLink *inlink)

libavfilter/vf_histogram.c

@@ -177,7 +177,7 @@ static int query_formats(AVFilterContext *ctx)
     }
 
     if (!ctx->inputs[0]->outcfg.formats)
-        if ((ret = ff_formats_ref(ff_make_format_list(levels_in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
+        if ((ret = ff_formats_ref(ff_make_pixel_format_list(levels_in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
             return ret;
     avff = ctx->inputs[0]->incfg.formats;
     desc = av_pix_fmt_desc_get(avff->formats[0]);
@@ -208,7 +208,7 @@ static int query_formats(AVFilterContext *ctx)
         out_pix_fmts = levels_out_yuv12_pix_fmts;
     else
         return AVERROR(EAGAIN);
-    if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
         return ret;
 
     return 0;

libavfilter/vf_hwupload.c

@@ -85,7 +85,7 @@ static int hwupload_query_formats(const AVFilterContext *avctx,
     input_pix_fmts  = constraints->valid_sw_formats;
     output_pix_fmts = constraints->valid_hw_formats;
 
-    input_formats = ff_make_format_list(output_pix_fmts);
+    input_formats = ff_make_pixel_format_list(output_pix_fmts);
     if (!input_formats) {
         err = AVERROR(ENOMEM);
         goto fail;
@@ -99,7 +99,7 @@ static int hwupload_query_formats(const AVFilterContext *avctx,
     }
 
     if ((err = ff_formats_ref(input_formats, &cfg_in[0]->formats)) < 0 ||
-        (err = ff_formats_ref(ff_make_format_list(output_pix_fmts),
+        (err = ff_formats_ref(ff_make_pixel_format_list(output_pix_fmts),
                               &cfg_out[0]->formats)) < 0)
         goto fail;
 

libavfilter/vf_hwupload_cuda.c

@@ -70,14 +70,14 @@ static int cudaupload_query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat output_pix_fmts[] = {
         AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
     };
-    AVFilterFormats *in_fmts  = ff_make_format_list(input_pix_fmts);
+    AVFilterFormats *in_fmts  = ff_make_pixel_format_list(input_pix_fmts);
     AVFilterFormats *out_fmts;
 
     ret = ff_formats_ref(in_fmts, &cfg_in[0]->formats);
     if (ret < 0)
         return ret;
 
-    out_fmts = ff_make_format_list(output_pix_fmts);
+    out_fmts = ff_make_pixel_format_list(output_pix_fmts);
 
     ret = ff_formats_ref(out_fmts, &cfg_out[0]->formats);
     if (ret < 0)

libavfilter/vf_lut.c

@@ -154,7 +154,7 @@ static int query_formats(const AVFilterContext *ctx,
     const enum AVPixelFormat *pix_fmts = s->is_rgb ? rgb_pix_fmts :
                                                      s->is_yuv ? yuv_pix_fmts :
                                                                  all_pix_fmts;
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
 }
 
 /**

libavfilter/vf_lut2.c

@@ -180,9 +180,9 @@ static int query_formats(const AVFilterContext *ctx,
     int ret;
 
     if (s->tlut2 || !s->odepth)
-        return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, all_pix_fmts);
+        return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, all_pix_fmts);
 
-    ret = ff_formats_ref(ff_make_format_list(all_pix_fmts), &cfg_in[0]->formats);
+    ret = ff_formats_ref(ff_make_pixel_format_list(all_pix_fmts), &cfg_in[0]->formats);
     if (ret < 0)
         return ret;
 
@@ -196,7 +196,7 @@ static int query_formats(const AVFilterContext *ctx,
     default: av_assert0(0);
     }
 
-    return ff_formats_ref(ff_make_format_list(pix_fmts), &cfg_out[0]->formats);
+    return ff_formats_ref(ff_make_pixel_format_list(pix_fmts), &cfg_out[0]->formats);
 }
 
 static int config_inputx(AVFilterLink *inlink)

libavfilter/vf_overlay.c

@@ -274,17 +274,17 @@ static int query_formats(const AVFilterContext *ctx,
         overlay_formats = overlay_pix_fmts_gbrp;
         break;
     case OVERLAY_FORMAT_AUTO:
-        return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, alpha_pix_fmts);
+        return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, alpha_pix_fmts);
     default:
         av_assert0(0);
     }
 
-    formats = ff_make_format_list(main_formats);
+    formats = ff_make_pixel_format_list(main_formats);
     if ((ret = ff_formats_ref(formats, &cfg_in[MAIN]->formats)) < 0 ||
         (ret = ff_formats_ref(formats, &cfg_out[MAIN]->formats)) < 0)
         return ret;
 
-    return ff_formats_ref(ff_make_format_list(overlay_formats),
+    return ff_formats_ref(ff_make_pixel_format_list(overlay_formats),
                           &cfg_in[OVERLAY]->formats);
 }
 

libavfilter/vf_overlay_qsv.c

@@ -388,12 +388,12 @@ static int overlay_qsv_query_formats(const AVFilterContext *ctx,
     };
 
     for (i = 0; i < ctx->nb_inputs; i++) {
-        ret = ff_formats_ref(ff_make_format_list(main_in_fmts), &cfg_in[i]->formats);
+        ret = ff_formats_ref(ff_make_pixel_format_list(main_in_fmts), &cfg_in[i]->formats);
         if (ret < 0)
             return ret;
     }
 
-    ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &cfg_out[0]->formats);
+    ret = ff_formats_ref(ff_make_pixel_format_list(out_pix_fmts), &cfg_out[0]->formats);
     if (ret < 0)
         return ret;
 

libavfilter/vf_palettegen.c

@@ -108,9 +108,9 @@ static int query_formats(const AVFilterContext *ctx,
     static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
     int ret;
 
-    if ((ret = ff_formats_ref(ff_make_format_list(in_fmts) , &cfg_in[0]->formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(in_fmts) , &cfg_in[0]->formats)) < 0)
         return ret;
-    if ((ret = ff_formats_ref(ff_make_format_list(out_fmts), &cfg_out[0]->formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(out_fmts), &cfg_out[0]->formats)) < 0)
         return ret;
     return 0;
 }

libavfilter/vf_paletteuse.c

@@ -144,11 +144,11 @@ static int query_formats(const AVFilterContext *ctx,
     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;
-    if ((ret = ff_formats_ref(ff_make_format_list(in_fmts),
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(in_fmts),
                               &cfg_in[0]->formats)) < 0 ||
-        (ret = ff_formats_ref(ff_make_format_list(inpal_fmts),
+        (ret = ff_formats_ref(ff_make_pixel_format_list(inpal_fmts),
                               &cfg_in[1]->formats)) < 0 ||
-        (ret = ff_formats_ref(ff_make_format_list(out_fmts),
+        (ret = ff_formats_ref(ff_make_pixel_format_list(out_fmts),
                               &cfg_out[0]->formats)) < 0)
         return ret;
     return 0;

libavfilter/vf_premultiply.c

@@ -91,7 +91,7 @@ static int query_formats(const AVFilterContext *ctx,
         AV_PIX_FMT_NONE
     };
 
-    ret = ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    ret = ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out,
                                            s->inplace ? alpha_pix_fmts : no_alpha_pix_fmts);
     if (ret < 0)
         return ret;

libavfilter/vf_remap.c

@@ -117,12 +117,12 @@ static int query_formats(const AVFilterContext *ctx,
     AVFilterFormats *pix_formats = NULL, *map_formats = NULL;
     int ret;
 
-    pix_formats = ff_make_format_list(s->format ? gray_pix_fmts : pix_fmts);
+    pix_formats = ff_make_pixel_format_list(s->format ? gray_pix_fmts : pix_fmts);
     if ((ret = ff_formats_ref(pix_formats, &cfg_in[0]->formats)) < 0 ||
         (ret = ff_formats_ref(pix_formats, &cfg_out[0]->formats)) < 0)
         return ret;
 
-    map_formats = ff_make_format_list(map_fmts);
+    map_formats = ff_make_pixel_format_list(map_fmts);
     if ((ret = ff_formats_ref(map_formats, &cfg_in[1]->formats)) < 0)
         return ret;
     return ff_formats_ref(map_formats, &cfg_in[2]->formats);

libavfilter/vf_showpalette.c

@@ -47,12 +47,12 @@ static int query_formats(const 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 = ff_formats_ref(ff_make_format_list(in_fmts),
+    int ret = ff_formats_ref(ff_make_pixel_format_list(in_fmts),
                              &cfg_in[0]->formats);
     if (ret < 0)
         return ret;
 
-    return ff_formats_ref(ff_make_format_list(out_fmts),
+    return ff_formats_ref(ff_make_pixel_format_list(out_fmts),
                           &cfg_out[0]->formats);
 }
 

libavfilter/vf_stereo3d.c

@@ -307,7 +307,7 @@ static int query_formats(const AVFilterContext *ctx,
         pix_fmts = other_pix_fmts;
     }
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
 }
 
 static inline uint8_t ana_convert(const int *coeff, const uint8_t *left, const uint8_t *right)

libavfilter/vf_thumbnail.c

@@ -365,7 +365,7 @@ static int query_formats(const AVFilterContext *ctx,
     const AVPixFmtDescriptor *desc = NULL;
     AVFilterFormats *formats;
 
-    formats = ff_make_format_list(packed_rgb_fmts);
+    formats = ff_make_pixel_format_list(packed_rgb_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
 

libavfilter/vf_v360.c

@@ -252,7 +252,7 @@ static int query_formats(const AVFilterContext *ctx,
         AV_PIX_FMT_NONE
     };
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out,
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out,
                                             s->alpha ? alpha_pix_fmts : pix_fmts);
 }
 

libavfilter/vf_vectorscope.c

@@ -229,7 +229,7 @@ static int query_formats(AVFilterContext *ctx)
             in_pix_fmts = in2_pix_fmts;
         else
             in_pix_fmts = in1_pix_fmts;
-        if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
+        if ((ret = ff_formats_ref(ff_make_pixel_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
             return ret;
     }
 
@@ -262,7 +262,7 @@ static int query_formats(AVFilterContext *ctx)
         out_pix_fmts = out_yuv12_pix_fmts;
     else
         return AVERROR(EAGAIN);
-    if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
         return ret;
 
     return 0;

libavfilter/vf_vpp_qsv.c

@@ -952,7 +952,7 @@ static int vpp_query_formats(const AVFilterContext *ctx,
     };
     static enum AVPixelFormat out_pix_fmts[4];
 
-    ret = ff_formats_ref(ff_make_format_list(in_pix_fmts),
+    ret = ff_formats_ref(ff_make_pixel_format_list(in_pix_fmts),
                          &cfg_in[0]->formats);
     if (ret < 0)
         return ret;
@@ -969,7 +969,7 @@ static int vpp_query_formats(const AVFilterContext *ctx,
     out_pix_fmts[i++] = AV_PIX_FMT_QSV;
     out_pix_fmts[i++] = AV_PIX_FMT_NONE;
 
-    return ff_formats_ref(ff_make_format_list(out_pix_fmts),
+    return ff_formats_ref(ff_make_pixel_format_list(out_pix_fmts),
                           &cfg_out[0]->formats);
 }
 

libavfilter/vf_waveform.c

@@ -345,7 +345,7 @@ static int query_formats(AVFilterContext *ctx)
     }
 
     if (!ctx->inputs[0]->outcfg.formats) {
-        if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
+        if ((ret = ff_formats_ref(ff_make_pixel_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
             return ret;
     }
 
@@ -393,7 +393,7 @@ static int query_formats(AVFilterContext *ctx)
         out_pix_fmts = out_yuv12_lowpass_pix_fmts;
     else
         return AVERROR(EAGAIN);
-    if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
+    if ((ret = ff_formats_ref(ff_make_pixel_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
         return ret;
 
     return 0;

libavfilter/vf_zscale.c

@@ -208,10 +208,10 @@ static int query_formats(const AVFilterContext *ctx,
     };
     int ret;
 
-    ret = ff_formats_ref(ff_make_format_list(pixel_fmts), &cfg_in[0]->formats);
+    ret = ff_formats_ref(ff_make_pixel_format_list(pixel_fmts), &cfg_in[0]->formats);
     if (ret < 0)
         return ret;
-    ret = ff_formats_ref(ff_make_format_list(pixel_fmts), &cfg_out[0]->formats);
+    ret = ff_formats_ref(ff_make_pixel_format_list(pixel_fmts), &cfg_out[0]->formats);
     if (ret < 0)
         return ret;
 

libavfilter/vsrc_life.c

@@ -432,7 +432,7 @@ static int query_formats(const AVFilterContext *ctx,
         AV_PIX_FMT_NONE
     };
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
 }
 
 static const AVFilterPad life_outputs[] = {

libavfilter/vsrc_perlin.c

@@ -148,7 +148,7 @@ static int query_formats(const AVFilterContext *ctx,
 {
     enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
 
-    return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
+    return ff_set_pixel_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
 }
 
 static const AVFilterPad perlin_outputs[] = {