virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

avfilter: Deduplicate default video inputs/outputs

Browse Source 
Lots of video filters use a very simple input or output:
An array with a single AVFilterPad whose name is "default"
and whose type is AVMEDIA_TYPE_VIDEO; everything else is unset.

Given that we never use pointer equality for inputs or outputs*,
we can simply use a single AVFilterPad instead of dozens; this
even saves .data.rel.ro (8312B here) as well as relocations.

*: In fact, several filters (like the filters in vf_lut.c)
already use the same outputs; furthermore, ff_filter_alloc()
duplicates the input and output pads so that we do not even
work with the pads directly.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt 2023-08-03 14:37:51 +02:00
parent 6d15643173
commit 2f62a433f2
147 changed files with 207 additions and 1247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libavfilter/buffersink.c
View File

@ -38,6 +38,7 @@
#include "buffersink.h"
#include "filters.h"
#include "internal.h"
#include "video.h"
typedef struct BufferSinkContext {
const AVClass *class;
@ -377,13 +378,6 @@ static const AVOption abuffersink_options[] = {
AVFILTER_DEFINE_CLASS(buffersink);
AVFILTER_DEFINE_CLASS(abuffersink);
static const AVFilterPad avfilter_vsink_buffer_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vsink_buffer = {
.name = "buffersink",
.description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
@ -391,7 +385,7 @@ const AVFilter ff_vsink_buffer = {
.priv_class = &buffersink_class,
.init = common_init,
.activate = activate,
FILTER_INPUTS(avfilter_vsink_buffer_inputs),
FILTER_INPUTS(ff_video_default_filterpad),
.outputs = NULL,
FILTER_QUERY_FUNC(vsink_query_formats),
};

10
libavfilter/f_bench.c
View File

@ -24,6 +24,7 @@
#include "avfilter.h"
#include "formats.h"
#include "internal.h"
#include "video.h"
enum BenchAction {
ACTION_START,
@ -101,20 +102,13 @@ static const AVFilterPad bench_inputs[] = {
},
};
static const AVFilterPad bench_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_bench = {
.name = "bench",
.description = NULL_IF_CONFIG_SMALL("Benchmark part of a filtergraph."),
.priv_size = sizeof(BenchContext),
.init = init,
FILTER_INPUTS(bench_inputs),
FILTER_OUTPUTS(bench_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.priv_class = &bench_class,
.flags = AVFILTER_FLAG_METADATA_ONLY,
};

19
libavfilter/f_cue.c
View File

@ -26,6 +26,7 @@
#include "avfilter.h"
#include "filters.h"
#include "internal.h"
#include "video.h"
typedef struct CueContext {
const AVClass *class;
@ -100,27 +101,13 @@ static const AVOption options[] = {
AVFILTER_DEFINE_CLASS_EXT(cue_acue, "(a)cue", options);
#if CONFIG_CUE_FILTER
static const AVFilterPad cue_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad cue_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_cue = {
.name = "cue",
.description = NULL_IF_CONFIG_SMALL("Delay filtering to match a cue."),
.priv_class = &cue_acue_class,
.priv_size = sizeof(CueContext),
FILTER_INPUTS(cue_inputs),
FILTER_OUTPUTS(cue_outputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(ff_video_default_filterpad),
.activate = activate,
};
#endif /* CONFIG_CUE_FILTER */

9
libavfilter/f_graphmonitor.c
View File

@ -570,13 +570,6 @@ AVFILTER_DEFINE_CLASS_EXT(graphmonitor, "(a)graphmonitor", graphmonitor_options)
#if CONFIG_GRAPHMONITOR_FILTER
static const AVFilterPad graphmonitor_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad graphmonitor_outputs[] = {
{
.name = "default",
@ -593,7 +586,7 @@ const AVFilter ff_vf_graphmonitor = {
.init = init,
.uninit = uninit,
.activate = activate,
FILTER_INPUTS(graphmonitor_inputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(graphmonitor_outputs),
FILTER_QUERY_FUNC(query_formats),
.process_command = ff_filter_process_command,

19
libavfilter/f_latency.c
View File

@ -26,6 +26,7 @@
#include "filters.h"
#include "formats.h"
#include "internal.h"
#include "video.h"
typedef struct LatencyContext {
int64_t min_latency;
@ -100,20 +101,6 @@ static av_cold void uninit(AVFilterContext *ctx)
#if CONFIG_LATENCY_FILTER
static const AVFilterPad latency_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad latency_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_latency = {
.name = "latency",
.description = NULL_IF_CONFIG_SMALL("Report video filtering latency."),
@ -123,8 +110,8 @@ const AVFilter ff_vf_latency = {
.activate = activate,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(latency_inputs),
FILTER_OUTPUTS(latency_outputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(ff_video_default_filterpad),
};
#endif // CONFIG_LATENCY_FILTER

18
libavfilter/f_loop.c
View File

@ -470,20 +470,6 @@ static const AVOption loop_options[] = {
AVFILTER_DEFINE_CLASS(loop);
static const AVFilterPad inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_loop = {
.name = "loop",
.description = NULL_IF_CONFIG_SMALL("Loop video frames."),
@ -492,7 +478,7 @@ const AVFilter ff_vf_loop = {
.init = init,
.uninit = uninit,
.activate = activate,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(ff_video_default_filterpad),
};
#endif /* CONFIG_LOOP_FILTER */

9
libavfilter/f_metadata.c
View File

@ -404,13 +404,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_metadata = {
.name = "metadata",
.description = NULL_IF_CONFIG_SMALL("Manipulate video frame metadata."),
@ -419,7 +412,7 @@ const AVFilter ff_vf_metadata = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
AVFILTER_FLAG_METADATA_ONLY,
};

9
libavfilter/f_perms.c
View File

@ -149,20 +149,13 @@ static const AVFilterPad perms_inputs[] = {
},
};
static const AVFilterPad perms_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_perms = {
.name = "perms",
.description = NULL_IF_CONFIG_SMALL("Set permissions for the output video frame."),
.init = init,
.priv_size = sizeof(PermsContext),
FILTER_INPUTS(perms_inputs),
FILTER_OUTPUTS(perms_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.priv_class = &perms_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
AVFILTER_FLAG_METADATA_ONLY,

10
libavfilter/f_realtime.c
View File

@ -25,6 +25,7 @@
#include "audio.h"
#include "avfilter.h"
#include "internal.h"
#include "video.h"
#include <float.h>
typedef struct RealtimeContext {
@ -86,13 +87,6 @@ static const AVFilterPad avfilter_vf_realtime_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_realtime_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_realtime = {
.name = "realtime",
.description = NULL_IF_CONFIG_SMALL("Slow down filtering to match realtime."),
@ -100,7 +94,7 @@ const AVFilter ff_vf_realtime = {
.priv_class = &realtime_class,
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_realtime_inputs),
FILTER_OUTPUTS(avfilter_vf_realtime_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.process_command = ff_filter_process_command,
};
#endif /* CONFIG_REALTIME_FILTER */

9
libavfilter/f_sendcmd.c
View File

@ -600,13 +600,6 @@ static const AVFilterPad sendcmd_inputs[] = {
},
};
static const AVFilterPad sendcmd_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_sendcmd = {
.name = "sendcmd",
.description = NULL_IF_CONFIG_SMALL("Send commands to filters."),
@ -615,7 +608,7 @@ const AVFilter ff_vf_sendcmd = {
.priv_size = sizeof(SendCmdContext),
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(sendcmd_inputs),
FILTER_OUTPUTS(sendcmd_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.priv_class = &sendcmd_class,
};

10
libavfilter/f_sidedata.c
View File

@ -31,6 +31,7 @@
#include "avfilter.h"
#include "formats.h"
#include "internal.h"
#include "video.h"
enum SideDataMode {
SIDEDATA_SELECT,
@ -161,13 +162,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_sidedata = {
.name = "sidedata",
.description = NULL_IF_CONFIG_SMALL("Manipulate video frame side data."),
@ -175,7 +169,7 @@ const AVFilter ff_vf_sidedata = {
.priv_class = &sidedata_class,
.init = init,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
AVFILTER_FLAG_METADATA_ONLY,
};

9
libavfilter/f_zmq.c
View File

@ -217,13 +217,6 @@ static const AVFilterPad zmq_inputs[] = {
},
};
static const AVFilterPad zmq_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_zmq = {
.name = "zmq",
.description = NULL_IF_CONFIG_SMALL("Receive commands through ZMQ and broker them to filters."),
@ -231,7 +224,7 @@ const AVFilter ff_vf_zmq = {
.uninit = uninit,
.priv_size = sizeof(ZMQContext),
FILTER_INPUTS(zmq_inputs),
FILTER_OUTPUTS(zmq_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.priv_class = &zmq_class,
};

9
libavfilter/setpts.c
View File

@ -326,13 +326,6 @@ static const AVFilterPad avfilter_vf_setpts_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_setpts_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_setpts = {
.name = "setpts",
.description = NULL_IF_CONFIG_SMALL("Set PTS for the output video frame."),
@ -346,7 +339,7 @@ const AVFilter ff_vf_setpts = {
.priv_class = &setpts_class,
FILTER_INPUTS(avfilter_vf_setpts_inputs),
FILTER_OUTPUTS(avfilter_vf_setpts_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
};
#endif /* CONFIG_SETPTS_FILTER */

9
libavfilter/settb.c
View File

@ -165,13 +165,6 @@ static int activate(AVFilterContext *ctx)
DEFINE_OPTIONS(settb, VIDEO);
AVFILTER_DEFINE_CLASS(settb);
static const AVFilterPad avfilter_vf_settb_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad avfilter_vf_settb_outputs[] = {
{
.name = "default",
@ -185,7 +178,7 @@ const AVFilter ff_vf_settb = {
.description = NULL_IF_CONFIG_SMALL("Set timebase for the video output link."),
.priv_size = sizeof(SetTBContext),
.priv_class = &settb_class,
FILTER_INPUTS(avfilter_vf_settb_inputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(avfilter_vf_settb_outputs),
.activate = activate,
.flags = AVFILTER_FLAG_METADATA_ONLY,

9
libavfilter/split.c
View File

@ -134,13 +134,6 @@ static const AVOption options[] = {
AVFILTER_DEFINE_CLASS_EXT(split, "(a)split", options);
static const AVFilterPad avfilter_vf_split_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_split = {
.name = "split",
.description = NULL_IF_CONFIG_SMALL("Pass on the input to N video outputs."),
@ -148,7 +141,7 @@ const AVFilter ff_vf_split = {
.priv_class = &split_class,
.init = split_init,
.activate = activate,
FILTER_INPUTS(avfilter_vf_split_inputs),
FILTER_INPUTS(ff_video_default_filterpad),
.outputs = NULL,
.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS | AVFILTER_FLAG_METADATA_ONLY,
};

10
libavfilter/trim.c
View File

@ -32,6 +32,7 @@
#include "avfilter.h"
#include "internal.h"
#include "filters.h"
#include "video.h"
typedef struct TrimContext {
const AVClass *class;
@ -356,13 +357,6 @@ static const AVFilterPad trim_inputs[] = {
},
};
static const AVFilterPad trim_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_trim = {
.name = "trim",
.description = NULL_IF_CONFIG_SMALL("Pick one continuous section from the input, drop the rest."),
@ -371,7 +365,7 @@ const AVFilter ff_vf_trim = {
.priv_size = sizeof(TrimContext),
.priv_class = &trim_class,
FILTER_INPUTS(trim_inputs),
FILTER_OUTPUTS(trim_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
};
#endif // CONFIG_TRIM_FILTER

10
libavfilter/vf_addroi.c
View File

@ -21,6 +21,7 @@
#include "libavutil/opt.h"
#include "avfilter.h"
#include "internal.h"
#include "video.h"
enum {
X, Y, W, H,
@ -246,13 +247,6 @@ static const AVFilterPad addroi_inputs[] = {
},
};
static const AVFilterPad addroi_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_addroi = {
.name = "addroi",
.description = NULL_IF_CONFIG_SMALL("Add region of interest to frame."),
@ -265,5 +259,5 @@ const AVFilter ff_vf_addroi = {
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(addroi_inputs),
FILTER_OUTPUTS(addroi_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
};

9
libavfilter/vf_avgblur.c
View File

@ -334,13 +334,6 @@ static const AVFilterPad avgblur_inputs[] = {
},
};
static const AVFilterPad avgblur_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_avgblur = {
.name = "avgblur",
.description = NULL_IF_CONFIG_SMALL("Apply Average Blur filter."),
@ -348,7 +341,7 @@ const AVFilter ff_vf_avgblur = {
.priv_class = &avgblur_class,
.uninit = uninit,
FILTER_INPUTS(avgblur_inputs),
FILTER_OUTPUTS(avgblur_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
.process_command = process_command,

9
libavfilter/vf_bilateral.c
View File

@ -498,13 +498,6 @@ static const AVFilterPad bilateral_inputs[] = {
},
};
static const AVFilterPad bilateral_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_bilateral = {
.name = "bilateral",
.description = NULL_IF_CONFIG_SMALL("Apply Bilateral filter."),
@ -512,7 +505,7 @@ const AVFilter ff_vf_bilateral = {
.priv_class = &bilateral_class,
.uninit = uninit,
FILTER_INPUTS(bilateral_inputs),
FILTER_OUTPUTS(bilateral_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_bitplanenoise.c
View File

@ -197,19 +197,12 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_bitplanenoise = {
.name = "bitplanenoise",
.description = NULL_IF_CONFIG_SMALL("Measure bit plane noise."),
.priv_size = sizeof(BPNContext),
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixfmts),
.priv_class = &bitplanenoise_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

10
libavfilter/vf_blackdetect.c
View File

@ -30,6 +30,7 @@
#include "libavutil/timestamp.h"
#include "avfilter.h"
#include "internal.h"
#include "video.h"
typedef struct BlackDetectContext {
const AVClass *class;
@ -241,19 +242,12 @@ static const AVFilterPad blackdetect_inputs[] = {
},
};
static const AVFilterPad blackdetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_blackdetect = {
.name = "blackdetect",
.description = NULL_IF_CONFIG_SMALL("Detect video intervals that are (almost) black."),
.priv_size = sizeof(BlackDetectContext),
FILTER_INPUTS(blackdetect_inputs),
FILTER_OUTPUTS(blackdetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.uninit = uninit,
.priv_class = &blackdetect_class,

9
libavfilter/vf_blackframe.c
View File

@ -115,13 +115,6 @@ static const AVFilterPad avfilter_vf_blackframe_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_blackframe_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO
},
};
const AVFilter ff_vf_blackframe = {
.name = "blackframe",
.description = NULL_IF_CONFIG_SMALL("Detect frames that are (almost) black."),
@ -129,6 +122,6 @@ const AVFilter ff_vf_blackframe = {
.priv_class = &blackframe_class,
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_blackframe_inputs),
FILTER_OUTPUTS(avfilter_vf_blackframe_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
};

10
libavfilter/vf_blockdetect.c
View File

@ -32,6 +32,7 @@
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "internal.h"
#include "video.h"
typedef struct BLKContext {
const AVClass *class;
@ -272,13 +273,6 @@ static const AVFilterPad blockdetect_inputs[] = {
},
};
static const AVFilterPad blockdetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_blockdetect = {
.name = "blockdetect",
.description = NULL_IF_CONFIG_SMALL("Blockdetect filter."),
@ -286,7 +280,7 @@ const AVFilter ff_vf_blockdetect = {
.uninit = blockdetect_uninit,
FILTER_PIXFMTS_ARRAY(pix_fmts),
FILTER_INPUTS(blockdetect_inputs),
FILTER_OUTPUTS(blockdetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.priv_class = &blockdetect_class,
.flags = AVFILTER_FLAG_METADATA_ONLY,
};

10
libavfilter/vf_blurdetect.c
View File

@ -35,6 +35,7 @@
#include "libavutil/qsort.h"
#include "internal.h"
#include "edge_common.h"
#include "video.h"
static int comp(const float *a,const float *b)
{
@ -356,13 +357,6 @@ static const AVFilterPad blurdetect_inputs[] = {
},
};
static const AVFilterPad blurdetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_blurdetect = {
.name = "blurdetect",
.description = NULL_IF_CONFIG_SMALL("Blurdetect filter."),
@ -371,7 +365,7 @@ const AVFilter ff_vf_blurdetect = {
.uninit = blurdetect_uninit,
FILTER_PIXFMTS_ARRAY(pix_fmts),
FILTER_INPUTS(blurdetect_inputs),
FILTER_OUTPUTS(blurdetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
.priv_class = &blurdetect_class,
.flags = AVFILTER_FLAG_METADATA_ONLY,
};

9
libavfilter/vf_boxblur.c
View File

@ -295,13 +295,6 @@ static const AVFilterPad avfilter_vf_boxblur_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_boxblur_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_boxblur = {
.name = "boxblur",
.description = NULL_IF_CONFIG_SMALL("Blur the input."),
@ -309,7 +302,7 @@ const AVFilter ff_vf_boxblur = {
.priv_class = &boxblur_class,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_boxblur_inputs),
FILTER_OUTPUTS(avfilter_vf_boxblur_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};

9
libavfilter/vf_cas.c
View File

@ -255,13 +255,6 @@ static const AVFilterPad cas_inputs[] = {
},
};
static const AVFilterPad cas_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(CASContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -279,7 +272,7 @@ const AVFilter ff_vf_cas = {
.priv_size = sizeof(CASContext),
.priv_class = &cas_class,
FILTER_INPUTS(cas_inputs),
FILTER_OUTPUTS(cas_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

10
libavfilter/vf_ccrepack.c
View File

@ -32,6 +32,7 @@
#include "avfilter.h"
#include "internal.h"
#include "ccfifo.h"
#include "video.h"
#include "libavutil/opt.h"
typedef struct CCRepackContext
@ -85,13 +86,6 @@ static const AVFilterPad avfilter_vf_ccrepack_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_ccrepack_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_ccrepack = {
.name = "ccrepack",
.description = NULL_IF_CONFIG_SMALL("Repack CEA-708 closed caption metadata"),
@ -99,5 +93,5 @@ const AVFilter ff_vf_ccrepack = {
.priv_size = sizeof(CCRepackContext),
.priv_class = &ccrepack_class,
FILTER_INPUTS(avfilter_vf_ccrepack_inputs),
FILTER_OUTPUTS(avfilter_vf_ccrepack_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
};

9
libavfilter/vf_chromanr.c
View File

@ -289,13 +289,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
AVFILTER_DEFINE_CLASS(chromanr);
const AVFilter ff_vf_chromanr = {
@ -303,7 +296,7 @@ const AVFilter ff_vf_chromanr = {
.description = NULL_IF_CONFIG_SMALL("Reduce chrominance noise."),
.priv_size = sizeof(ChromaNRContext),
.priv_class = &chromanr_class,
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_INPUTS(inputs),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

11
libavfilter/vf_chromashift.c
View File

@ -382,13 +382,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const enum AVPixelFormat yuv_pix_fmts[] = {
AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
@ -411,7 +404,7 @@ const AVFilter ff_vf_chromashift = {
.description = NULL_IF_CONFIG_SMALL("Shift chroma."),
.priv_size = sizeof(ChromaShiftContext),
.priv_class = &chromashift_class,
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_INPUTS(inputs),
FILTER_PIXFMTS_ARRAY(yuv_pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
@ -448,7 +441,7 @@ const AVFilter ff_vf_rgbashift = {
.description = NULL_IF_CONFIG_SMALL("Shift RGBA."),
.priv_size = sizeof(ChromaShiftContext),
.priv_class = &rgbashift_class,
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_INPUTS(inputs),
FILTER_PIXFMTS_ARRAY(rgb_pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

10
libavfilter/vf_codecview.c
View File

@ -36,6 +36,7 @@
#include "avfilter.h"
#include "qp_table.h"
#include "internal.h"
#include "video.h"
#define MV_P_FOR (1<<0)
#define MV_B_FOR (1<<1)
@ -334,19 +335,12 @@ static const AVFilterPad codecview_inputs[] = {
},
};
static const AVFilterPad codecview_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_codecview = {
.name = "codecview",
.description = NULL_IF_CONFIG_SMALL("Visualize information about some codecs."),
.priv_size = sizeof(CodecViewContext),
FILTER_INPUTS(codecview_inputs),
FILTER_OUTPUTS(codecview_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
// TODO: we can probably add way more pixel formats without any other
// changes; anything with 8-bit luma in first plane should be working
FILTER_SINGLE_PIXFMT(AV_PIX_FMT_YUV420P),

9
libavfilter/vf_colorconstancy.c
View File

@ -719,13 +719,6 @@ static const AVFilterPad colorconstancy_inputs[] = {
},
};
static const AVFilterPad colorconstancy_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#if CONFIG_GREYEDGE_FILTER
static const AVOption greyedge_options[] = {
@ -744,7 +737,7 @@ const AVFilter ff_vf_greyedge = {
.priv_class = &greyedge_class,
.uninit = uninit,
FILTER_INPUTS(colorconstancy_inputs),
FILTER_OUTPUTS(colorconstancy_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
// TODO: support more formats
// FIXME: error when saving to .jpg
FILTER_SINGLE_PIXFMT(AV_PIX_FMT_GBRP),

9
libavfilter/vf_colorcontrast.c
View File

@ -359,13 +359,6 @@ static const AVFilterPad colorcontrast_inputs[] = {
},
};
static const AVFilterPad colorcontrast_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(ColorContrastContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -388,7 +381,7 @@ const AVFilter ff_vf_colorcontrast = {
.priv_size = sizeof(ColorContrastContext),
.priv_class = &colorcontrast_class,
FILTER_INPUTS(colorcontrast_inputs),
FILTER_OUTPUTS(colorcontrast_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

9
libavfilter/vf_colorcorrect.c
View File

@ -510,13 +510,6 @@ static const AVFilterPad colorcorrect_inputs[] = {
},
};
static const AVFilterPad colorcorrect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(ColorCorrectContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -543,7 +536,7 @@ const AVFilter ff_vf_colorcorrect = {
.priv_class = &colorcorrect_class,
.uninit = uninit,
FILTER_INPUTS(colorcorrect_inputs),
FILTER_OUTPUTS(colorcorrect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

9
libavfilter/vf_colorize.c
View File

@ -260,13 +260,6 @@ static const AVFilterPad colorize_inputs[] = {
},
};
static const AVFilterPad colorize_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(ColorizeContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -286,7 +279,7 @@ const AVFilter ff_vf_colorize = {
.priv_size = sizeof(ColorizeContext),
.priv_class = &colorize_class,
FILTER_INPUTS(colorize_inputs),
FILTER_OUTPUTS(colorize_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

9
libavfilter/vf_colorlevels.c
View File

@ -559,20 +559,13 @@ static const AVFilterPad colorlevels_inputs[] = {
},
};
static const AVFilterPad colorlevels_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_colorlevels = {
.name = "colorlevels",
.description = NULL_IF_CONFIG_SMALL("Adjust the color levels."),
.priv_size = sizeof(ColorLevelsContext),
.priv_class = &colorlevels_class,
FILTER_INPUTS(colorlevels_inputs),
FILTER_OUTPUTS(colorlevels_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,

9
libavfilter/vf_colormatrix.c
View File

@ -483,20 +483,13 @@ static const AVFilterPad colormatrix_inputs[] = {
},
};
static const AVFilterPad colormatrix_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_colormatrix = {
.name = "colormatrix",
.description = NULL_IF_CONFIG_SMALL("Convert color matrix."),
.priv_size = sizeof(ColorMatrixContext),
.init = init,
FILTER_INPUTS(colormatrix_inputs),
FILTER_OUTPUTS(colormatrix_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_YUV444P,
AV_PIX_FMT_YUV422P,
AV_PIX_FMT_YUV420P,

9
libavfilter/vf_colortemperature.c
View File

@ -325,13 +325,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(ColorTemperatureContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -350,7 +343,7 @@ const AVFilter ff_vf_colortemperature = {
.priv_size = sizeof(ColorTemperatureContext),
.priv_class = &colortemperature_class,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

19
libavfilter/vf_convolution.c
View File

@ -873,13 +873,6 @@ static const AVFilterPad convolution_inputs[] = {
},
};
static const AVFilterPad convolution_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#if CONFIG_CONVOLUTION_FILTER
const AVFilter ff_vf_convolution = {
@ -888,7 +881,7 @@ const AVFilter ff_vf_convolution = {
.priv_size = sizeof(ConvolutionContext),
.priv_class = &convolution_class,
FILTER_INPUTS(convolution_inputs),
FILTER_OUTPUTS(convolution_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,
@ -914,7 +907,7 @@ const AVFilter ff_vf_prewitt = {
.priv_size = sizeof(ConvolutionContext),
.priv_class = &common_class,
FILTER_INPUTS(convolution_inputs),
FILTER_OUTPUTS(convolution_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,
@ -930,7 +923,7 @@ const AVFilter ff_vf_sobel = {
.priv_size = sizeof(ConvolutionContext),
.priv_class = &common_class,
FILTER_INPUTS(convolution_inputs),
FILTER_OUTPUTS(convolution_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,
@ -946,7 +939,7 @@ const AVFilter ff_vf_roberts = {
.priv_size = sizeof(ConvolutionContext),
.priv_class = &common_class,
FILTER_INPUTS(convolution_inputs),
FILTER_OUTPUTS(convolution_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,
@ -962,7 +955,7 @@ const AVFilter ff_vf_kirsch = {
.priv_size = sizeof(ConvolutionContext),
.priv_class = &common_class,
FILTER_INPUTS(convolution_inputs),
FILTER_OUTPUTS(convolution_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,
@ -978,7 +971,7 @@ const AVFilter ff_vf_scharr = {
.priv_size = sizeof(ConvolutionContext),
.priv_class = &common_class,
FILTER_INPUTS(convolution_inputs),
FILTER_OUTPUTS(convolution_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

9
libavfilter/vf_copy.c
View File

@ -65,18 +65,11 @@ static const AVFilterPad avfilter_vf_copy_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_copy_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_copy = {
.name = "copy",
.description = NULL_IF_CONFIG_SMALL("Copy the input video unchanged to the output."),
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_copy_inputs),
FILTER_OUTPUTS(avfilter_vf_copy_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
};

10
libavfilter/vf_cover_rect.c
View File

@ -26,6 +26,7 @@
#include "libavutil/opt.h"
#include "filters.h"
#include "internal.h"
#include "video.h"
#include "lavfutils.h"
@ -232,13 +233,6 @@ static const AVFilterPad cover_rect_inputs[] = {
},
};
static const AVFilterPad cover_rect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_cover_rect = {
.name = "cover_rect",
.description = NULL_IF_CONFIG_SMALL("Find and cover a user specified object."),
@ -246,7 +240,7 @@ const AVFilter ff_vf_cover_rect = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(cover_rect_inputs),
FILTER_OUTPUTS(cover_rect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
.priv_class = &cover_rect_class,
};

9
libavfilter/vf_cropdetect.c
View File

@ -495,13 +495,6 @@ static const AVFilterPad avfilter_vf_cropdetect_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_cropdetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO
},
};
const AVFilter ff_vf_cropdetect = {
.name = "cropdetect",
.description = NULL_IF_CONFIG_SMALL("Auto-detect crop size."),
@ -510,7 +503,7 @@ const AVFilter ff_vf_cropdetect = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_cropdetect_inputs),
FILTER_OUTPUTS(avfilter_vf_cropdetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_METADATA_ONLY,
.process_command = process_command,

9
libavfilter/vf_curves.c
View File

@ -1005,13 +1005,6 @@ static const AVFilterPad curves_inputs[] = {
},
};
static const AVFilterPad curves_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_curves = {
.name = "curves",
.description = NULL_IF_CONFIG_SMALL("Adjust components curves."),
@ -1019,7 +1012,7 @@ const AVFilter ff_vf_curves = {
.init = curves_init,
.uninit = curves_uninit,
FILTER_INPUTS(curves_inputs),
FILTER_OUTPUTS(curves_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,

18
libavfilter/vf_datascope.c
View File

@ -728,20 +728,13 @@ static const AVFilterPad pixscope_inputs[] = {
},
};
static const AVFilterPad pixscope_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_pixscope = {
.name = "pixscope",
.description = NULL_IF_CONFIG_SMALL("Pixel data analysis."),
.priv_size = sizeof(PixscopeContext),
.priv_class = &pixscope_class,
FILTER_INPUTS(pixscope_inputs),
FILTER_OUTPUTS(pixscope_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
.process_command = pixscope_process_command,
@ -1132,13 +1125,6 @@ static const AVFilterPad oscilloscope_inputs[] = {
},
};
static const AVFilterPad oscilloscope_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_oscilloscope = {
.name = "oscilloscope",
.description = NULL_IF_CONFIG_SMALL("2D Video Oscilloscope."),
@ -1146,7 +1132,7 @@ const AVFilter ff_vf_oscilloscope = {
.priv_class = &oscilloscope_class,
.uninit = oscilloscope_uninit,
FILTER_INPUTS(oscilloscope_inputs),
FILTER_OUTPUTS(oscilloscope_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
.process_command = oscilloscope_process_command,

9
libavfilter/vf_dblur.c
View File

@ -299,13 +299,6 @@ static const AVFilterPad dblur_inputs[] = {
},
};
static const AVFilterPad dblur_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_dblur = {
.name = "dblur",
.description = NULL_IF_CONFIG_SMALL("Apply Directional Blur filter."),
@ -313,7 +306,7 @@ const AVFilter ff_vf_dblur = {
.priv_class = &dblur_class,
.uninit = uninit,
FILTER_INPUTS(dblur_inputs),
FILTER_OUTPUTS(dblur_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
.process_command = ff_filter_process_command,

9
libavfilter/vf_dctdnoiz.c
View File

@ -810,13 +810,6 @@ static const AVFilterPad dctdnoiz_inputs[] = {
},
};
static const AVFilterPad dctdnoiz_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_dctdnoiz = {
.name = "dctdnoiz",
.description = NULL_IF_CONFIG_SMALL("Denoise frames using 2D DCT."),
@ -824,7 +817,7 @@ const AVFilter ff_vf_dctdnoiz = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(dctdnoiz_inputs),
FILTER_OUTPUTS(dctdnoiz_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &dctdnoiz_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_deband.c
View File

@ -458,13 +458,6 @@ static const AVFilterPad avfilter_vf_deband_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_deband_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_deband = {
.name = "deband",
.description = NULL_IF_CONFIG_SMALL("Debands video."),
@ -472,7 +465,7 @@ const AVFilter ff_vf_deband = {
.priv_class = &deband_class,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_deband_inputs),
FILTER_OUTPUTS(avfilter_vf_deband_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

9
libavfilter/vf_dedot.c
View File

@ -375,13 +375,6 @@ static const AVOption dedot_options[] = {
{ NULL },
};
static const AVFilterPad inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
@ -399,7 +392,7 @@ const AVFilter ff_vf_dedot = {
.priv_class = &dedot_class,
.activate = activate,
.uninit = uninit,
FILTER_INPUTS(inputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(outputs),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_delogo.c
View File

@ -381,13 +381,6 @@ static const AVFilterPad avfilter_vf_delogo_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_delogo_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_delogo = {
.name = "delogo",
.description = NULL_IF_CONFIG_SMALL("Remove logo from input video."),
@ -396,7 +389,7 @@ const AVFilter ff_vf_delogo = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_delogo_inputs),
FILTER_OUTPUTS(avfilter_vf_delogo_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};

9
libavfilter/vf_derain.c
View File

@ -111,13 +111,6 @@ static const AVFilterPad derain_inputs[] = {
},
};
static const AVFilterPad derain_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_derain = {
.name = "derain",
.description = NULL_IF_CONFIG_SMALL("Apply derain filter to the input."),
@ -125,7 +118,7 @@ const AVFilter ff_vf_derain = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(derain_inputs),
FILTER_OUTPUTS(derain_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_SINGLE_PIXFMT(AV_PIX_FMT_RGB24),
.priv_class = &derain_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_deshake.c
View File

@ -535,13 +535,6 @@ static const AVFilterPad deshake_inputs[] = {
},
};
static const AVFilterPad deshake_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_deshake = {
.name = "deshake",
.description = NULL_IF_CONFIG_SMALL("Stabilize shaky video."),
@ -549,7 +542,7 @@ const AVFilter ff_vf_deshake = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(deshake_inputs),
FILTER_OUTPUTS(deshake_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &deshake_class,
};

19
libavfilter/vf_dnn_classify.c
View File

@ -26,6 +26,7 @@
#include "filters.h"
#include "dnn_filter_common.h"
#include "internal.h"
#include "video.h"
#include "libavutil/time.h"
#include "libavutil/avstring.h"
#include "libavutil/detection_bbox.h"
@ -293,28 +294,14 @@ static av_cold void dnn_classify_uninit(AVFilterContext *context)
free_classify_labels(ctx);
}
static const AVFilterPad dnn_classify_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad dnn_classify_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_dnn_classify = {
.name = "dnn_classify",
.description = NULL_IF_CONFIG_SMALL("Apply DNN classify filter to the input."),
.priv_size = sizeof(DnnClassifyContext),
.init = dnn_classify_init,
.uninit = dnn_classify_uninit,
FILTER_INPUTS(dnn_classify_inputs),
FILTER_OUTPUTS(dnn_classify_outputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &dnn_classify_class,
.activate = dnn_classify_activate,

19
libavfilter/vf_dnn_detect.c
View File

@ -26,6 +26,7 @@
#include "filters.h"
#include "dnn_filter_common.h"
#include "internal.h"
#include "video.h"
#include "libavutil/time.h"
#include "libavutil/avstring.h"
#include "libavutil/detection_bbox.h"
@ -435,28 +436,14 @@ static av_cold void dnn_detect_uninit(AVFilterContext *context)
free_detect_labels(ctx);
}
static const AVFilterPad dnn_detect_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad dnn_detect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_dnn_detect = {
.name = "dnn_detect",
.description = NULL_IF_CONFIG_SMALL("Apply DNN detect filter to the input."),
.priv_size = sizeof(DnnDetectContext),
.init = dnn_detect_init,
.uninit = dnn_detect_uninit,
FILTER_INPUTS(dnn_detect_inputs),
FILTER_OUTPUTS(dnn_detect_outputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &dnn_detect_class,
.activate = dnn_detect_activate,

18
libavfilter/vf_drawbox.c
View File

@ -471,13 +471,6 @@ static const AVFilterPad drawbox_inputs[] = {
},
};
static const AVFilterPad drawbox_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_drawbox = {
.name = "drawbox",
.description = NULL_IF_CONFIG_SMALL("Draw a colored box on the input video."),
@ -485,7 +478,7 @@ const AVFilter ff_vf_drawbox = {
.priv_class = &drawbox_class,
.init = init,
FILTER_INPUTS(drawbox_inputs),
FILTER_OUTPUTS(drawbox_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.process_command = process_command,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
@ -553,13 +546,6 @@ static const AVFilterPad drawgrid_inputs[] = {
},
};
static const AVFilterPad drawgrid_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_drawgrid = {
.name = "drawgrid",
.description = NULL_IF_CONFIG_SMALL("Draw a colored grid on the input video."),
@ -567,7 +553,7 @@ const AVFilter ff_vf_drawgrid = {
.priv_class = &drawgrid_class,
.init = init,
FILTER_INPUTS(drawgrid_inputs),
FILTER_OUTPUTS(drawgrid_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
.process_command = process_command,

9
libavfilter/vf_drawtext.c
View File

@ -2181,13 +2181,6 @@ static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_drawtext_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_drawtext = {
.name = "drawtext",
.description = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
@ -2196,7 +2189,7 @@ const AVFilter ff_vf_drawtext = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_drawtext_inputs),
FILTER_OUTPUTS(avfilter_vf_drawtext_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.process_command = command,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_edgedetect.c
View File

@ -249,13 +249,6 @@ static const AVFilterPad edgedetect_inputs[] = {
},
};
static const AVFilterPad edgedetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_edgedetect = {
.name = "edgedetect",
.description = NULL_IF_CONFIG_SMALL("Detect and draw edge."),
@ -263,7 +256,7 @@ const AVFilter ff_vf_edgedetect = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(edgedetect_inputs),
FILTER_OUTPUTS(edgedetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.priv_class = &edgedetect_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_elbg.c
View File

@ -253,13 +253,6 @@ static const AVFilterPad elbg_inputs[] = {
},
};
static const AVFilterPad elbg_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_elbg = {
.name = "elbg",
.description = NULL_IF_CONFIG_SMALL("Apply posterize effect, using the ELBG algorithm."),
@ -268,6 +261,6 @@ const AVFilter ff_vf_elbg = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(elbg_inputs),
FILTER_OUTPUTS(elbg_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
};

9
libavfilter/vf_entropy.c
View File

@ -176,20 +176,13 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_entropy = {
.name = "entropy",
.description = NULL_IF_CONFIG_SMALL("Measure video frames entropy."),
.priv_size = sizeof(EntropyContext),
.uninit = uninit,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixfmts),
.priv_class = &entropy_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_METADATA_ONLY,

9
libavfilter/vf_eq.c
View File

@ -314,13 +314,6 @@ static const AVFilterPad eq_inputs[] = {
},
};
static const AVFilterPad eq_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(EQContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
#define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -355,7 +348,7 @@ const AVFilter ff_vf_eq = {
.priv_size = sizeof(EQContext),
.priv_class = &eq_class,
FILTER_INPUTS(eq_inputs),
FILTER_OUTPUTS(eq_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts_eq),
.process_command = process_command,
.init = initialize,

9
libavfilter/vf_exposure.c
View File

@ -133,13 +133,6 @@ static const AVFilterPad exposure_inputs[] = {
},
};
static const AVFilterPad exposure_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(ExposureContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -157,7 +150,7 @@ const AVFilter ff_vf_exposure = {
.priv_size = sizeof(ExposureContext),
.priv_class = &exposure_class,
FILTER_INPUTS(exposure_inputs),
FILTER_OUTPUTS(exposure_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

9
libavfilter/vf_fade.c
View File

@ -557,13 +557,6 @@ static const AVFilterPad avfilter_vf_fade_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_fade_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_fade = {
.name = "fade",
.description = NULL_IF_CONFIG_SMALL("Fade in/out input video."),
@ -571,7 +564,7 @@ const AVFilter ff_vf_fade = {
.priv_size = sizeof(FadeContext),
.priv_class = &fade_class,
FILTER_INPUTS(avfilter_vf_fade_inputs),
FILTER_OUTPUTS(avfilter_vf_fade_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SLICE_THREADS |
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_fftfilt.c
View File

@ -593,20 +593,13 @@ static const AVFilterPad fftfilt_inputs[] = {
},
};
static const AVFilterPad fftfilt_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_fftfilt = {
.name = "fftfilt",
.description = NULL_IF_CONFIG_SMALL("Apply arbitrary expressions to pixels in frequency domain."),
.priv_size = sizeof(FFTFILTContext),
.priv_class = &fftfilt_class,
FILTER_INPUTS(fftfilt_inputs),
FILTER_OUTPUTS(fftfilt_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts_fftfilt),
.init = initialize,
.uninit = uninit,

9
libavfilter/vf_fieldorder.c
View File

@ -176,20 +176,13 @@ static const AVFilterPad avfilter_vf_fieldorder_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_fieldorder_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_fieldorder = {
.name = "fieldorder",
.description = NULL_IF_CONFIG_SMALL("Set the field order."),
.priv_size = sizeof(FieldOrderContext),
.priv_class = &fieldorder_class,
FILTER_INPUTS(avfilter_vf_fieldorder_inputs),
FILTER_OUTPUTS(avfilter_vf_fieldorder_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};

9
libavfilter/vf_fillborders.c
View File

@ -707,20 +707,13 @@ static const AVFilterPad fillborders_inputs[] = {
},
};
static const AVFilterPad fillborders_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_fillborders = {
.name = "fillborders",
.description = NULL_IF_CONFIG_SMALL("Fill borders of the input video."),
.priv_size = sizeof(FillBordersContext),
.priv_class = &fillborders_class,
FILTER_INPUTS(fillborders_inputs),
FILTER_OUTPUTS(fillborders_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
.process_command = process_command,

10
libavfilter/vf_find_rect.c
View File

@ -25,6 +25,7 @@
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "internal.h"
#include "video.h"
#include "lavfutils.h"
@ -281,13 +282,6 @@ static const AVFilterPad foc_inputs[] = {
},
};
static const AVFilterPad foc_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_find_rect = {
.name = "find_rect",
.description = NULL_IF_CONFIG_SMALL("Find a user specified object."),
@ -296,7 +290,7 @@ const AVFilter ff_vf_find_rect = {
.uninit = uninit,
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(foc_inputs),
FILTER_OUTPUTS(foc_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
.priv_class = &find_rect_class,
};

9
libavfilter/vf_floodfill.c
View File

@ -385,13 +385,6 @@ static const AVFilterPad floodfill_inputs[] = {
},
};
static const AVFilterPad floodfill_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(FloodfillContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
@ -418,7 +411,7 @@ const AVFilter ff_vf_floodfill = {
.priv_class = &floodfill_class,
.uninit = uninit,
FILTER_INPUTS(floodfill_inputs),
FILTER_OUTPUTS(floodfill_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};

18
libavfilter/vf_format.c
View File

@ -154,13 +154,6 @@ static const AVFilterPad avfilter_vf_format_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_format_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO
},
};
const AVFilter ff_vf_format = {
.name = "format",
.description = NULL_IF_CONFIG_SMALL("Convert the input video to one of the specified pixel formats."),
@ -174,7 +167,7 @@ const AVFilter ff_vf_format = {
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_format_inputs),
FILTER_OUTPUTS(avfilter_vf_format_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
};
@ -190,13 +183,6 @@ static const AVFilterPad avfilter_vf_noformat_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_noformat_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO
},
};
const AVFilter ff_vf_noformat = {
.name = "noformat",
.description = NULL_IF_CONFIG_SMALL("Force libavfilter not to use any of the specified pixel formats for the input to the next filter."),
@ -210,7 +196,7 @@ const AVFilter ff_vf_noformat = {
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_noformat_inputs),
FILTER_OUTPUTS(avfilter_vf_noformat_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
};

10
libavfilter/vf_fps.c
View File

@ -37,6 +37,7 @@
#include "ccfifo.h"
#include "filters.h"
#include "internal.h"
#include "video.h"
enum EOFAction {
EOF_ACTION_ROUND,
@ -376,13 +377,6 @@ static int activate(AVFilterContext *ctx)
return FFERROR_NOT_READY;
}
static const AVFilterPad avfilter_vf_fps_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad avfilter_vf_fps_outputs[] = {
{
.name = "default",
@ -400,6 +394,6 @@ const AVFilter ff_vf_fps = {
.priv_class = &fps_class,
.activate = activate,
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_fps_inputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(avfilter_vf_fps_outputs),
};

10
libavfilter/vf_freezedetect.c
View File

@ -29,6 +29,7 @@
#include "avfilter.h"
#include "filters.h"
#include "scene_sad.h"
#include "video.h"
typedef struct FreezeDetectContext {
const AVClass *class;
@ -204,13 +205,6 @@ static const AVFilterPad freezedetect_inputs[] = {
},
};
static const AVFilterPad freezedetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_freezedetect = {
.name = "freezedetect",
.description = NULL_IF_CONFIG_SMALL("Detects frozen video input."),
@ -219,7 +213,7 @@ const AVFilter ff_vf_freezedetect = {
.uninit = uninit,
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(freezedetect_inputs),
FILTER_OUTPUTS(freezedetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.activate = activate,
};

9
libavfilter/vf_frei0r.c
View File

@ -423,13 +423,6 @@ static const AVFilterPad avfilter_vf_frei0r_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_frei0r_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_frei0r = {
.name = "frei0r",
.description = NULL_IF_CONFIG_SMALL("Apply a frei0r effect."),
@ -438,7 +431,7 @@ const AVFilter ff_vf_frei0r = {
.priv_size = sizeof(Frei0rContext),
.priv_class = &frei0r_class,
FILTER_INPUTS(avfilter_vf_frei0r_inputs),
FILTER_OUTPUTS(avfilter_vf_frei0r_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.process_command = process_command,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_fspp.c
View File

@ -652,20 +652,13 @@ static const AVFilterPad fspp_inputs[] = {
},
};
static const AVFilterPad fspp_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_fspp = {
.name = "fspp",
.description = NULL_IF_CONFIG_SMALL("Apply Fast Simple Post-processing filter."),
.priv_size = sizeof(FSPPContext),
.uninit = uninit,
FILTER_INPUTS(fspp_inputs),
FILTER_OUTPUTS(fspp_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &fspp_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

9
libavfilter/vf_gblur.c
View File

@ -315,13 +315,6 @@ static const AVFilterPad gblur_inputs[] = {
},
};
static const AVFilterPad gblur_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_gblur = {
.name = "gblur",
.description = NULL_IF_CONFIG_SMALL("Apply Gaussian Blur filter."),
@ -329,7 +322,7 @@ const AVFilter ff_vf_gblur = {
.priv_class = &gblur_class,
.uninit = uninit,
FILTER_INPUTS(gblur_inputs),
FILTER_OUTPUTS(gblur_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

9
libavfilter/vf_geq.c
View File

@ -516,13 +516,6 @@ static const AVFilterPad geq_inputs[] = {
},
};
static const AVFilterPad geq_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_geq = {
.name = "geq",
.description = NULL_IF_CONFIG_SMALL("Apply generic equation to each pixel."),
@ -530,7 +523,7 @@ const AVFilter ff_vf_geq = {
.init = geq_init,
.uninit = geq_uninit,
FILTER_INPUTS(geq_inputs),
FILTER_OUTPUTS(geq_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(geq_query_formats),
.priv_class = &geq_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_gradfun.c
View File

@ -236,13 +236,6 @@ static const AVFilterPad avfilter_vf_gradfun_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_gradfun_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_gradfun = {
.name = "gradfun",
.description = NULL_IF_CONFIG_SMALL("Debands video quickly using gradients."),
@ -251,7 +244,7 @@ const AVFilter ff_vf_gradfun = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_gradfun_inputs),
FILTER_OUTPUTS(avfilter_vf_gradfun_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};

9
libavfilter/vf_grayworld.c
View File

@ -308,20 +308,13 @@ static const AVFilterPad grayworld_inputs[] = {
}
};
static const AVFilterPad grayworld_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
}
};
const AVFilter ff_vf_grayworld = {
.name = "grayworld",
.description = NULL_IF_CONFIG_SMALL("Adjust white balance using LAB gray world algorithm"),
.priv_size = sizeof(GrayWorldContext),
.priv_class = &grayworld_class,
FILTER_INPUTS(grayworld_inputs),
FILTER_OUTPUTS(grayworld_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS(AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.uninit = uninit,

9
libavfilter/vf_hflip.c
View File

@ -151,20 +151,13 @@ static const AVFilterPad avfilter_vf_hflip_inputs[] = {
},
};
static const AVFilterPad avfilter_vf_hflip_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_hflip = {
.name = "hflip",
.description = NULL_IF_CONFIG_SMALL("Horizontally flip the input video."),
.priv_size = sizeof(FlipContext),
.priv_class = &hflip_class,
FILTER_INPUTS(avfilter_vf_hflip_inputs),
FILTER_OUTPUTS(avfilter_vf_hflip_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};

9
libavfilter/vf_histeq.c
View File

@ -254,20 +254,13 @@ static const AVFilterPad histeq_inputs[] = {
},
};
static const AVFilterPad histeq_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_histeq = {
.name = "histeq",
.description = NULL_IF_CONFIG_SMALL("Apply global color histogram equalization."),
.priv_size = sizeof(HisteqContext),
.init = init,
FILTER_INPUTS(histeq_inputs),
FILTER_OUTPUTS(histeq_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &histeq_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_hqdn3d.c
View File

@ -383,13 +383,6 @@ static const AVFilterPad avfilter_vf_hqdn3d_inputs[] = {
};
static const AVFilterPad avfilter_vf_hqdn3d_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO
},
};
const AVFilter ff_vf_hqdn3d = {
.name = "hqdn3d",
.description = NULL_IF_CONFIG_SMALL("Apply a High Quality 3D Denoiser."),
@ -398,7 +391,7 @@ const AVFilter ff_vf_hqdn3d = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_hqdn3d_inputs),
FILTER_OUTPUTS(avfilter_vf_hqdn3d_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

9
libavfilter/vf_hue.c
View File

@ -500,13 +500,6 @@ static const AVFilterPad hue_inputs[] = {
},
};
static const AVFilterPad hue_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_hue = {
.name = "hue",
.description = NULL_IF_CONFIG_SMALL("Adjust the hue and saturation of the input video."),
@ -515,7 +508,7 @@ const AVFilter ff_vf_hue = {
.uninit = uninit,
.process_command = process_command,
FILTER_INPUTS(hue_inputs),
FILTER_OUTPUTS(hue_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &hue_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_huesaturation.c
View File

@ -434,13 +434,6 @@ static const AVFilterPad huesaturation_inputs[] = {
},
};
static const AVFilterPad huesaturation_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(HueSaturationContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -472,7 +465,7 @@ const AVFilter ff_vf_huesaturation = {
.priv_size = sizeof(HueSaturationContext),
.priv_class = &huesaturation_class,
FILTER_INPUTS(huesaturation_inputs),
FILTER_OUTPUTS(huesaturation_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

10
libavfilter/vf_iccdetect.c
View File

@ -31,6 +31,7 @@
#include "avfilter.h"
#include "fflcms2.h"
#include "internal.h"
#include "video.h"
typedef struct IccDetectContext {
const AVClass *class;
@ -123,13 +124,6 @@ static const AVFilterPad iccdetect_inputs[] = {
},
};
static const AVFilterPad iccdetect_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_iccdetect = {
.name = "iccdetect",
.description = NULL_IF_CONFIG_SMALL("Detect and parse ICC profiles."),
@ -139,5 +133,5 @@ const AVFilter ff_vf_iccdetect = {
.init = &iccdetect_init,
.uninit = &iccdetect_uninit,
FILTER_INPUTS(iccdetect_inputs),
FILTER_OUTPUTS(iccdetect_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
};

10
libavfilter/vf_iccgen.c
View File

@ -30,6 +30,7 @@
#include "avfilter.h"
#include "fflcms2.h"
#include "internal.h"
#include "video.h"
typedef struct IccGenContext {
const AVClass *class;
@ -161,13 +162,6 @@ static const AVFilterPad iccgen_inputs[] = {
},
};
static const AVFilterPad iccgen_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_iccgen = {
.name = "iccgen",
.description = NULL_IF_CONFIG_SMALL("Generate and attach ICC profiles."),
@ -177,5 +171,5 @@ const AVFilter ff_vf_iccgen = {
.init = &iccgen_init,
.uninit = &iccgen_uninit,
FILTER_INPUTS(iccgen_inputs),
FILTER_OUTPUTS(iccgen_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
};

9
libavfilter/vf_il.c
View File

@ -184,19 +184,12 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_il = {
.name = "il",
.description = NULL_IF_CONFIG_SMALL("Deinterleave or interleave fields."),
.priv_size = sizeof(IlContext),
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.priv_class = &il_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

9
libavfilter/vf_kerndeint.c
View File

@ -295,13 +295,6 @@ static const AVFilterPad kerndeint_inputs[] = {
},
};
static const AVFilterPad kerndeint_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_kerndeint = {
.name = "kerndeint",
@ -310,6 +303,6 @@ const AVFilter ff_vf_kerndeint = {
.priv_class = &kerndeint_class,
.uninit = uninit,
FILTER_INPUTS(kerndeint_inputs),
FILTER_OUTPUTS(kerndeint_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
};

9
libavfilter/vf_lensfun.c
View File

@ -522,13 +522,6 @@ static const AVFilterPad lensfun_inputs[] = {
},
};
static const AVFilterPad lensfun_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_lensfun = {
.name = "lensfun",
.description = NULL_IF_CONFIG_SMALL("Apply correction to an image based on info derived from the lensfun database."),
@ -536,7 +529,7 @@ const AVFilter ff_vf_lensfun = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(lensfun_inputs),
FILTER_OUTPUTS(lensfun_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_SINGLE_PIXFMT(AV_PIX_FMT_RGB24),
.priv_class = &lensfun_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_limiter.c
View File

@ -231,13 +231,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_limiter = {
.name = "limiter",
.description = NULL_IF_CONFIG_SMALL("Limit pixels components to the specified range."),
@ -245,7 +238,7 @@ const AVFilter ff_vf_limiter = {
.priv_class = &limiter_class,
.init = init,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

9
libavfilter/vf_lumakey.c
View File

@ -173,13 +173,6 @@ static const AVFilterPad lumakey_inputs[] = {
},
};
static const AVFilterPad lumakey_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(LumakeyContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -198,7 +191,7 @@ const AVFilter ff_vf_lumakey = {
.priv_size = sizeof(LumakeyContext),
.priv_class = &lumakey_class,
FILTER_INPUTS(lumakey_inputs),
FILTER_OUTPUTS(lumakey_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

7
libavfilter/vf_lut.c
View File

@ -582,11 +582,6 @@ static const AVFilterPad inputs[] = {
.config_props = config_props,
},
};
static const AVFilterPad outputs[] = {
{ .name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define DEFINE_LUT_FILTER(name_, description_, priv_class_) \
const AVFilter ff_vf_##name_ = { \
@ -597,7 +592,7 @@ static const AVFilterPad outputs[] = {
.init = name_##_init, \
.uninit = uninit, \
FILTER_INPUTS(inputs), \
FILTER_OUTPUTS(outputs), \
FILTER_OUTPUTS(ff_video_default_filterpad), \
FILTER_QUERY_FUNC(query_formats), \
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | \
AVFILTER_FLAG_SLICE_THREADS, \

18
libavfilter/vf_lut3d.c
View File

@ -1301,13 +1301,6 @@ static const AVFilterPad lut3d_inputs[] = {
},
};
static const AVFilterPad lut3d_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_lut3d = {
.name = "lut3d",
.description = NULL_IF_CONFIG_SMALL("Adjust colors using a 3D LUT."),
@ -1315,7 +1308,7 @@ const AVFilter ff_vf_lut3d = {
.init = lut3d_init,
.uninit = lut3d_uninit,
FILTER_INPUTS(lut3d_inputs),
FILTER_OUTPUTS(lut3d_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &lut3d_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
@ -2232,20 +2225,13 @@ static const AVFilterPad lut1d_inputs[] = {
},
};
static const AVFilterPad lut1d_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_lut1d = {
.name = "lut1d",
.description = NULL_IF_CONFIG_SMALL("Adjust colors using a 1D LUT."),
.priv_size = sizeof(LUT1DContext),
.init = lut1d_init,
FILTER_INPUTS(lut1d_inputs),
FILTER_OUTPUTS(lut1d_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &lut1d_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_maskfun.c
View File

@ -317,20 +317,13 @@ static const AVFilterPad maskfun_inputs[] = {
},
};
static const AVFilterPad maskfun_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_maskfun = {
.name = "maskfun",
.description = NULL_IF_CONFIG_SMALL("Create Mask."),
.priv_size = sizeof(MaskFunContext),
.uninit = uninit,
FILTER_INPUTS(maskfun_inputs),
FILTER_OUTPUTS(maskfun_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &maskfun_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_mcdeint.c
View File

@ -301,20 +301,13 @@ static const AVFilterPad mcdeint_inputs[] = {
},
};
static const AVFilterPad mcdeint_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_mcdeint = {
.name = "mcdeint",
.description = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
.priv_size = sizeof(MCDeintContext),
.uninit = uninit,
FILTER_INPUTS(mcdeint_inputs),
FILTER_OUTPUTS(mcdeint_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_SINGLE_PIXFMT(AV_PIX_FMT_YUV420P),
.priv_class = &mcdeint_class,
};

9
libavfilter/vf_median.c
View File

@ -270,13 +270,6 @@ static const AVFilterPad median_inputs[] = {
},
};
static const AVFilterPad median_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_median = {
.name = "median",
.description = NULL_IF_CONFIG_SMALL("Apply Median filter."),
@ -284,7 +277,7 @@ const AVFilter ff_vf_median = {
.priv_class = &median_class,
.uninit = uninit,
FILTER_INPUTS(median_inputs),
FILTER_OUTPUTS(median_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

9
libavfilter/vf_mestimate.c
View File

@ -350,13 +350,6 @@ static const AVFilterPad mestimate_inputs[] = {
},
};
static const AVFilterPad mestimate_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_mestimate = {
.name = "mestimate",
.description = NULL_IF_CONFIG_SMALL("Generate motion vectors."),
@ -365,6 +358,6 @@ const AVFilter ff_vf_mestimate = {
.uninit = uninit,
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(mestimate_inputs),
FILTER_OUTPUTS(mestimate_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
};

9
libavfilter/vf_monochrome.c
View File

@ -268,13 +268,6 @@ static const AVFilterPad monochrome_inputs[] = {
},
};
static const AVFilterPad monochrome_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(MonochromeContext, x)
#define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -294,7 +287,7 @@ const AVFilter ff_vf_monochrome = {
.priv_size = sizeof(MonochromeContext),
.priv_class = &monochrome_class,
FILTER_INPUTS(monochrome_inputs),
FILTER_OUTPUTS(monochrome_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = ff_filter_process_command,

9
libavfilter/vf_mpdecimate.c
View File

@ -241,13 +241,6 @@ static const AVFilterPad mpdecimate_inputs[] = {
},
};
static const AVFilterPad mpdecimate_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_mpdecimate = {
.name = "mpdecimate",
.description = NULL_IF_CONFIG_SMALL("Remove near-duplicate frames."),
@ -256,6 +249,6 @@ const AVFilter ff_vf_mpdecimate = {
.priv_size = sizeof(DecimateContext),
.priv_class = &mpdecimate_class,
FILTER_INPUTS(mpdecimate_inputs),
FILTER_OUTPUTS(mpdecimate_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
};

9
libavfilter/vf_negate.c
View File

@ -355,20 +355,13 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_negate = {
.name = "negate",
.description = NULL_IF_CONFIG_SMALL("Negate input video."),
.priv_size = sizeof(NegateContext),
.priv_class = &negate_class,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
.process_command = process_command,

9
libavfilter/vf_neighbor.c
View File

@ -341,13 +341,6 @@ static const AVFilterPad neighbor_inputs[] = {
},
};
static const AVFilterPad neighbor_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
#define OFFSET(x) offsetof(NContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
@ -358,7 +351,7 @@ const AVFilter ff_vf_##name_ = { \
.priv_class = &priv_class_##_class, \
.priv_size = sizeof(NContext), \
FILTER_INPUTS(neighbor_inputs), \
FILTER_OUTPUTS(neighbor_outputs), \
FILTER_OUTPUTS(ff_video_default_filterpad), \
FILTER_PIXFMTS_ARRAY(pix_fmts), \
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC| \
AVFILTER_FLAG_SLICE_THREADS, \

9
libavfilter/vf_nlmeans.c
View File

@ -472,13 +472,6 @@ static const AVFilterPad nlmeans_inputs[] = {
},
};
static const AVFilterPad nlmeans_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_nlmeans = {
.name = "nlmeans",
.description = NULL_IF_CONFIG_SMALL("Non-local means denoiser."),
@ -486,7 +479,7 @@ const AVFilter ff_vf_nlmeans = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(nlmeans_inputs),
FILTER_OUTPUTS(nlmeans_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pix_fmts),
.priv_class = &nlmeans_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_noise.c
View File

@ -330,13 +330,6 @@ static const AVFilterPad noise_inputs[] = {
},
};
static const AVFilterPad noise_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_noise = {
.name = "noise",
.description = NULL_IF_CONFIG_SMALL("Add noise."),
@ -344,7 +337,7 @@ const AVFilter ff_vf_noise = {
.init = init,
.uninit = uninit,
FILTER_INPUTS(noise_inputs),
FILTER_OUTPUTS(noise_outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_QUERY_FUNC(query_formats),
.priv_class = &noise_class,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

9
libavfilter/vf_normalize.c
View File

@ -511,13 +511,6 @@ static const AVFilterPad inputs[] = {
},
};
static const AVFilterPad outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_normalize = {
.name = "normalize",
.description = NULL_IF_CONFIG_SMALL("Normalize RGB video."),
@ -525,7 +518,7 @@ const AVFilter ff_vf_normalize = {
.priv_class = &normalize_class,
.uninit = uninit,
FILTER_INPUTS(inputs),
FILTER_OUTPUTS(outputs),
FILTER_OUTPUTS(ff_video_default_filterpad),
FILTER_PIXFMTS_ARRAY(pixel_fmts),
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
.process_command = ff_filter_process_command,

18
libavfilter/vf_null.c
View File

@ -26,24 +26,10 @@
#include "internal.h"
#include "video.h"
static const AVFilterPad avfilter_vf_null_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
static const AVFilterPad avfilter_vf_null_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_null = {
.name = "null",
.description = NULL_IF_CONFIG_SMALL("Pass the source unchanged to the output."),
.flags = AVFILTER_FLAG_METADATA_ONLY,
FILTER_INPUTS(avfilter_vf_null_inputs),
FILTER_OUTPUTS(avfilter_vf_null_outputs),
FILTER_INPUTS(ff_video_default_filterpad),
FILTER_OUTPUTS(ff_video_default_filterpad),
};

Some files were not shown because too many files have changed in this diff Show More