Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avfilter: various cosmetics

Browse Source 
Signed-off-by: Paul B Mahol <onemda@gmail.com>
pull/36/head
Paul B Mahol 11 years ago
parent ba5e77814e
commit b211607b5c
109 changed files with 750 additions and 896 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      libavfilter/af_aconvert.c
  2. 8
      libavfilter/af_aecho.c
  3. 2
      libavfilter/af_afade.c
  4. 3
      libavfilter/af_aformat.c
  5. 2
      libavfilter/af_amerge.c
  6. 5
      libavfilter/af_amix.c
  7. 6
      libavfilter/af_apad.c
  8. 2
      libavfilter/af_aphaser.c
  9. 4
      libavfilter/af_aresample.c
  10. 2
      libavfilter/af_asetnsamples.c
  11. 4
      libavfilter/af_ashowinfo.c
  12. 2
      libavfilter/af_astats.c
  13. 5
      libavfilter/af_asyncts.c
  14. 20
      libavfilter/af_biquads.c
  15. 3
      libavfilter/af_channelmap.c
  16. 5
      libavfilter/af_channelsplit.c
  17. 6
      libavfilter/af_compand.c
  18. 6
      libavfilter/af_join.c
  19. 1
      libavfilter/af_pan.c
  20. 3
      libavfilter/af_resample.c
  21. 2
      libavfilter/af_silencedetect.c
  22. 2
      libavfilter/af_volume.c
  23. 1
      libavfilter/af_volumedetect.c
  24. 3
      libavfilter/asrc_aevalsrc.c
  25. 5
      libavfilter/asrc_anullsrc.c
  26. 2
      libavfilter/asrc_sine.c
  27. 2
      libavfilter/avf_avectorscope.c
  28. 2
      libavfilter/avf_concat.c
  29. 2
      libavfilter/avf_showspectrum.c
  30. 2
      libavfilter/avf_showwaves.c
  31. 2
      libavfilter/f_ebur128.c
  32. 2
      libavfilter/f_interleave.c
  33. 2
      libavfilter/f_select.c
  34. 2
      libavfilter/f_sendcmd.c
  35. 3
      libavfilter/f_settb.c
  36. 2
      libavfilter/setpts.c
  37. 10
      libavfilter/split.c
  38. 1
      libavfilter/transform.c
  39. 10
      libavfilter/trim.c
  40. 4
      libavfilter/vf_aspect.c
  41. 2
      libavfilter/vf_blackdetect.c
  42. 6
      libavfilter/vf_blackframe.c
  43. 2
      libavfilter/vf_blend.c
  44. 1
      libavfilter/vf_boxblur.c
  45. 1
      libavfilter/vf_colormatrix.c
  46. 1
      libavfilter/vf_copy.c
  47. 3
      libavfilter/vf_crop.c
  48. 3
      libavfilter/vf_cropdetect.c
  49. 3
      libavfilter/vf_delogo.c
  50. 1
      libavfilter/vf_drawbox.c
  51. 3
      libavfilter/vf_drawtext.c
  52. 2
      libavfilter/vf_edgedetect.c
  53. 3
      libavfilter/vf_fade.c
  54. 2
      libavfilter/vf_field.c
  55. 2
      libavfilter/vf_fieldorder.c
  56. 10
      libavfilter/vf_format.c
  57. 5
      libavfilter/vf_fps.c
  58. 10
      libavfilter/vf_frei0r.c
  59. 2
      libavfilter/vf_gradfun.c
  60. 1
      libavfilter/vf_hflip.c
  61. 1
      libavfilter/vf_histeq.c
  62. 2
      libavfilter/vf_histogram.c
  63. 4
      libavfilter/vf_hqdn3d.c
  64. 2
      libavfilter/vf_hue.c
  65. 1
      libavfilter/vf_idet.c
  66. 3
      libavfilter/vf_interlace.c
  67. 4
      libavfilter/vf_kerndeint.c
  68. 6
      libavfilter/vf_libopencv.c
  69. 13
      libavfilter/vf_lut.c
  70. 3
      libavfilter/vf_mpdecimate.c
  71. 4
      libavfilter/vf_overlay.c
  72. 5
      libavfilter/vf_pad.c
  73. 3
      libavfilter/vf_pixdesctest.c
  74. 2
      libavfilter/vf_psnr.c
  75. 6
      libavfilter/vf_scale.c
  76. 2
      libavfilter/vf_setfield.c
  77. 2
      libavfilter/vf_showinfo.c
  78. 2
      libavfilter/vf_smartblur.c
  79. 2
      libavfilter/vf_stereo3d.c
  80. 1
      libavfilter/vf_swapuv.c
  81. 2
      libavfilter/vf_tile.c
  82. 5
      libavfilter/vf_transpose.c
  83. 5
      libavfilter/vf_unsharp.c
  84. 2
      libavfilter/vf_vflip.c
  85. 1
      libavfilter/vf_vidstabdetect.c
  86. 1
      libavfilter/vf_vidstabtransform.c
  87. 4
      libavfilter/vf_yadif.c
  88. 4
      libavfilter/vsrc_cellauto.c
  89. 4
      libavfilter/vsrc_life.c
  90. 6
      libavfilter/vsrc_mandelbrot.c
  91. 6
      libavfilter/vsrc_mptestsrc.c
  92. 13
      libavfilter/vsrc_testsrc.c

2
libavfilter/af_aconvert.c
Unescape View File

@ -47,7 +47,7 @@ typedef struct {
static const AVOption aconvert_options[] = {
{ "sample_fmt", "", OFFSET(format_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ "channel_layout", "", OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(aconvert);

8
libavfilter/af_aecho.c
Unescape View File

@ -19,10 +19,10 @@
*
*/
#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"
#include "libavutil/avassert.h"
#include "avfilter.h"
#include "audio.h"
#include "internal.h"
@ -52,7 +52,7 @@ static const AVOption aecho_options[] = {
{ "out_gain", "set signal output gain", OFFSET(out_gain), AV_OPT_TYPE_FLOAT, {.dbl=0.3}, 0, 1, A },
{ "delays", "set list of signal delays", OFFSET(delays), AV_OPT_TYPE_STRING, {.str="1000"}, 0, 0, A },
{ "decays", "set list of signal decays", OFFSET(decays), AV_OPT_TYPE_STRING, {.str="0.5"}, 0, 0, A },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(aecho);
@ -333,7 +333,7 @@ static const AVFilterPad aecho_inputs[] = {
.type = AVMEDIA_TYPE_AUDIO,
.filter_frame = filter_frame,
},
{ NULL },
{ NULL }
};
static const AVFilterPad aecho_outputs[] = {
@ -343,7 +343,7 @@ static const AVFilterPad aecho_outputs[] = {
.config_props = config_output,
.type = AVMEDIA_TYPE_AUDIO,
},
{ NULL },
{ NULL }
};
AVFilter avfilter_af_aecho = {

2
libavfilter/af_afade.c
Unescape View File

@ -72,7 +72,7 @@ static const AVOption afade_options[] = {
{ "cub", "cubic", 0, AV_OPT_TYPE_CONST, {.i64 = CUB }, 0, 0, FLAGS, "curve" },
{ "squ", "square root", 0, AV_OPT_TYPE_CONST, {.i64 = SQU }, 0, 0, FLAGS, "curve" },
{ "cbr", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64 = CBR }, 0, 0, FLAGS, "curve" },
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(afade);

3
libavfilter/af_aformat.c
Unescape View File

@ -52,7 +52,7 @@ static const AVOption aformat_options[] = {
{ "sample_fmts", "A comma-separated list of sample formats.", OFFSET(formats_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ "sample_rates", "A comma-separated list of sample rates.", OFFSET(sample_rates_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ "channel_layouts", "A comma-separated list of channel layouts.", OFFSET(channel_layouts_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(aformat);
@ -142,7 +142,6 @@ AVFilter avfilter_af_aformat = {
.query_formats = query_formats,
.priv_size = sizeof(AFormatContext),
.priv_class = &aformat_class,
.inputs = avfilter_af_aformat_inputs,
.outputs = avfilter_af_aformat_outputs,
};

2
libavfilter/af_amerge.c
Unescape View File

@ -52,7 +52,7 @@ typedef struct {
static const AVOption amerge_options[] = {
{ "inputs", "specify the number of inputs", OFFSET(nb_inputs),
AV_OPT_TYPE_INT, { .i64 = 2 }, 2, SWR_CH_MAX, FLAGS },
{0}
{ NULL }
};
AVFILTER_DEFINE_CLASS(amerge);

5
libavfilter/af_amix.c
Unescape View File

@ -187,7 +187,7 @@ static const AVOption amix_options[] = {
{ "dropout_transition", "Transition time, in seconds, for volume "
"renormalization when an input stream ends.",
OFFSET(dropout_transition), AV_OPT_TYPE_FLOAT, { .dbl = 2.0 }, 0, INT_MAX, A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(amix);
@ -551,13 +551,10 @@ AVFilter avfilter_af_amix = {
.description = NULL_IF_CONFIG_SMALL("Audio mixing."),
.priv_size = sizeof(MixContext),
.priv_class = &amix_class,
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = NULL,
.outputs = avfilter_af_amix_outputs,
.flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
};

6
libavfilter/af_apad.c
Unescape View File

@ -51,7 +51,7 @@ static const AVOption apad_options[] = {
{ "packet_size", "set silence packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, { .i64 = 4096 }, 0, INT_MAX, A },
{ "pad_len", "number of samples of silence to add", OFFSET(pad_len), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, A },
{ "whole_len", "target number of samples in the audio stream", OFFSET(whole_len), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, A },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(apad);
@ -132,7 +132,7 @@ static const AVFilterPad apad_inputs[] = {
.type = AVMEDIA_TYPE_AUDIO,
.filter_frame = filter_frame,
},
{ NULL },
{ NULL }
};
static const AVFilterPad apad_outputs[] = {
@ -141,7 +141,7 @@ static const AVFilterPad apad_outputs[] = {
.request_frame = request_frame,
.type = AVMEDIA_TYPE_AUDIO,
},
{ NULL },
{ NULL }
};
AVFilter avfilter_af_apad = {

2
libavfilter/af_aphaser.c
Unescape View File

@ -71,7 +71,7 @@ static const AVOption aphaser_options[] = {
{ "t", NULL, 0, AV_OPT_TYPE_CONST, {.i64=WAVE_TRI}, 0, 0, FLAGS, "type" },
{ "sinusoidal", NULL, 0, AV_OPT_TYPE_CONST, {.i64=WAVE_SIN}, 0, 0, FLAGS, "type" },
{ "s", NULL, 0, AV_OPT_TYPE_CONST, {.i64=WAVE_SIN}, 0, 0, FLAGS, "type" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(aphaser);

4
libavfilter/af_aresample.c
Unescape View File

@ -283,7 +283,7 @@ static const AVFilterPad aresample_inputs[] = {
.type = AVMEDIA_TYPE_AUDIO,
.filter_frame = filter_frame,
},
{ NULL },
{ NULL }
};
static const AVFilterPad aresample_outputs[] = {
@ -293,7 +293,7 @@ static const AVFilterPad aresample_outputs[] = {
.request_frame = request_frame,
.type = AVMEDIA_TYPE_AUDIO,
},
{ NULL },
{ NULL }
};
AVFilter avfilter_af_aresample = {

2
libavfilter/af_asetnsamples.c
Unescape View File

@ -188,9 +188,9 @@ AVFilter avfilter_af_asetnsamples = {
.name = "asetnsamples",
.description = NULL_IF_CONFIG_SMALL("Set the number of samples for each output audio frames."),
.priv_size = sizeof(ASNSContext),
.priv_class = &asetnsamples_class,
.init = init,
.uninit = uninit,
.inputs = asetnsamples_inputs,
.outputs = asetnsamples_outputs,
.priv_class = &asetnsamples_class,
};

4
libavfilter/af_ashowinfo.c
Unescape View File

@ -105,7 +105,7 @@ static const AVFilterPad inputs[] = {
.type = AVMEDIA_TYPE_AUDIO,
.filter_frame = filter_frame,
},
{ NULL },
{ NULL }
};
static const AVFilterPad outputs[] = {
@ -113,7 +113,7 @@ static const AVFilterPad outputs[] = {
.name = "default",
.type = AVMEDIA_TYPE_AUDIO,
},
{ NULL },
{ NULL }
};
AVFilter avfilter_af_ashowinfo = {

2
libavfilter/af_astats.c
Unescape View File

@ -51,7 +51,7 @@ typedef struct {
static const AVOption astats_options[] = {
{ "length", "set the window length", OFFSET(time_constant), AV_OPT_TYPE_DOUBLE, {.dbl=.05}, .01, 10, FLAGS },
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(astats);

5
libavfilter/af_asyncts.c
Unescape View File

@ -56,7 +56,7 @@ static const AVOption asyncts_options[] = {
"(in seconds) to trigger padding/trimmin the data.", OFFSET(min_delta_sec), AV_OPT_TYPE_FLOAT, { .dbl = 0.1 }, 0, INT_MAX, A|F },
{ "max_comp", "Maximum compensation in samples per second.", OFFSET(max_comp), AV_OPT_TYPE_INT, { .i64 = 500 }, 0, INT_MAX, A|F },
{ "first_pts", "Assume the first pts should be this value.", OFFSET(first_pts), AV_OPT_TYPE_INT64, { .i64 = AV_NOPTS_VALUE }, INT64_MIN, INT64_MAX, A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(asyncts);
@ -312,13 +312,10 @@ static const AVFilterPad avfilter_af_asyncts_outputs[] = {
AVFilter avfilter_af_asyncts = {
.name = "asyncts",
.description = NULL_IF_CONFIG_SMALL("Sync audio data to timestamps"),
.init = init,
.uninit = uninit,
.priv_size = sizeof(ASyncContext),
.priv_class = &asyncts_class,
.inputs = avfilter_af_asyncts_inputs,
.outputs = avfilter_af_asyncts_outputs,
};

20
libavfilter/af_biquads.c
Unescape View File

@ -62,8 +62,8 @@
* V
*/
#include "libavutil/opt.h"
#include "libavutil/avassert.h"
#include "libavutil/opt.h"
#include "audio.h"
#include "avfilter.h"
#include "internal.h"
@ -479,7 +479,7 @@ static const AVOption equalizer_options[] = {
{"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},
{"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
{"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
@ -497,7 +497,7 @@ static const AVOption bass_options[] = {
{"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
{"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
{"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
@ -515,7 +515,7 @@ static const AVOption treble_options[] = {
{"w", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
{"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
{"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
@ -532,7 +532,7 @@ static const AVOption bandpass_options[] = {
{"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
{"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
{"csg", "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
@ -548,7 +548,7 @@ static const AVOption bandreject_options[] = {
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
{"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
{"w", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
@ -566,7 +566,7 @@ static const AVOption lowpass_options[] = {
{"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
{"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
{"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
@ -584,7 +584,7 @@ static const AVOption highpass_options[] = {
{"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
{"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
{"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
@ -600,7 +600,7 @@ static const AVOption allpass_options[] = {
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
{"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
{"w", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
@ -613,7 +613,7 @@ static const AVOption biquad_options[] = {
{"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
{"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
{"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
{NULL},
{NULL}
};
DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");

3
libavfilter/af_channelmap.c
Unescape View File

@ -74,7 +74,7 @@ static const AVOption channelmap_options[] = {
OFFSET(mapping_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ "channel_layout", "Output channel layout.",
OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(channelmap);
@ -404,7 +404,6 @@ AVFilter avfilter_af_channelmap = {
.query_formats = channelmap_query_formats,
.priv_size = sizeof(ChannelMapContext),
.priv_class = &channelmap_class,
.inputs = avfilter_af_channelmap_inputs,
.outputs = avfilter_af_channelmap_outputs,
};

5
libavfilter/af_channelsplit.c
Unescape View File

@ -45,7 +45,7 @@ typedef struct ChannelSplitContext {
#define F AV_OPT_FLAG_FILTERING_PARAM
static const AVOption channelsplit_options[] = {
{ "channel_layout", "Input channel layout.", OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, { .str = "stereo" }, .flags = A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(channelsplit);
@ -141,12 +141,9 @@ AVFilter avfilter_af_channelsplit = {
.description = NULL_IF_CONFIG_SMALL("Split audio into per-channel streams."),
.priv_size = sizeof(ChannelSplitContext),
.priv_class = &channelsplit_class,
.init = init,
.query_formats = query_formats,
.inputs = avfilter_af_channelsplit_inputs,
.outputs = NULL,
.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
};

6
libavfilter/af_compand.c
Unescape View File

@ -72,7 +72,7 @@ static const AVOption compand_options[] = {
{ "gain", "set output gain", OFFSET(gain_dB), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, A },
{ "volume", "set initial volume", OFFSET(initial_volume), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 0, A },
{ "delay", "set delay for samples before sending them to volume adjuster", OFFSET(delay), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 20, A },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(compand);
@ -492,7 +492,7 @@ static const AVFilterPad compand_inputs[] = {
.type = AVMEDIA_TYPE_AUDIO,
.filter_frame = filter_frame,
},
{ NULL },
{ NULL }
};
static const AVFilterPad compand_outputs[] = {
@ -502,7 +502,7 @@ static const AVFilterPad compand_outputs[] = {
.config_props = config_output,
.type = AVMEDIA_TYPE_AUDIO,
},
{ NULL },
{ NULL }
};
AVFilter avfilter_af_compand = {

6
libavfilter/af_join.c
Unescape View File

@ -1,5 +1,4 @@
/*
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
@ -74,7 +73,7 @@ static const AVOption join_options[] = {
{ "map", "A comma-separated list of channels maps in the format "
"'input_stream.input_channel-output_channel.",
OFFSET(map), AV_OPT_TYPE_STRING, .flags = A|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(join);
@ -513,13 +512,10 @@ AVFilter avfilter_af_join = {
"multi-channel output."),
.priv_size = sizeof(JoinContext),
.priv_class = &join_class,
.init = join_init,
.uninit = join_uninit,
.query_formats = join_query_formats,
.inputs = NULL,
.outputs = avfilter_af_join_outputs,
.flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
};

1
libavfilter/af_pan.c
Unescape View File

@ -391,7 +391,6 @@ static const AVOption pan_options[] = {
AVFILTER_DEFINE_CLASS(pan);
static const AVFilterPad pan_inputs[] = {
{
.name = "default",

3
libavfilter/af_resample.c
Unescape View File

@ -1,5 +1,4 @@
/*
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
@ -320,11 +319,9 @@ AVFilter avfilter_af_resample = {
.description = NULL_IF_CONFIG_SMALL("Audio resampling and conversion."),
.priv_size = sizeof(ResampleContext),
.priv_class = &resample_class,
.init_dict = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_af_resample_inputs,
.outputs = avfilter_af_resample_outputs,
};

2
libavfilter/af_silencedetect.c
Unescape View File

@ -48,7 +48,7 @@ static const AVOption silencedetect_options[] = {
{ "noise", "set noise tolerance", OFFSET(noise), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0, DBL_MAX, FLAGS },
{ "d", "set minimum duration in seconds", OFFSET(duration), AV_OPT_TYPE_DOUBLE, {.dbl=2.}, 0, 24*60*60, FLAGS },
{ "duration", "set minimum duration in seconds", OFFSET(duration), AV_OPT_TYPE_DOUBLE, {.dbl=2.}, 0, 24*60*60, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(silencedetect);

2
libavfilter/af_volume.c
Unescape View File

@ -51,7 +51,7 @@ static const AVOption volume_options[] = {
{ "fixed", "select 8-bit fixed-point", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FIXED }, INT_MIN, INT_MAX, A|F, "precision" },
{ "float", "select 32-bit floating-point", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FLOAT }, INT_MIN, INT_MAX, A|F, "precision" },
{ "double", "select 64-bit floating-point", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_DOUBLE }, INT_MIN, INT_MAX, A|F, "precision" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(volume);

1
libavfilter/af_volumedetect.c
Unescape View File

@ -151,7 +151,6 @@ static const AVFilterPad volumedetect_outputs[] = {
AVFilter avfilter_af_volumedetect = {
.name = "volumedetect",
.description = NULL_IF_CONFIG_SMALL("Detect audio volume."),
.priv_size = sizeof(VolDetectContext),
.query_formats = query_formats,
.uninit = uninit,

3
libavfilter/asrc_aevalsrc.c
Unescape View File

@ -76,7 +76,7 @@ static const AVOption aevalsrc_options[]= {
{ "d", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },
{ "channel_layout", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
{ "c", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(aevalsrc);
@ -232,7 +232,6 @@ static const AVFilterPad aevalsrc_outputs[] = {
AVFilter avfilter_asrc_aevalsrc = {
.name = "aevalsrc",
.description = NULL_IF_CONFIG_SMALL("Generate an audio signal generated by an expression."),
.query_formats = query_formats,
.init = init,
.uninit = uninit,

5
libavfilter/asrc_anullsrc.c
Unescape View File

@ -54,7 +54,7 @@ static const AVOption anullsrc_options[]= {
{ "r", "set sample rate", OFFSET(sample_rate_str) , AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0, FLAGS },
{ "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 0, INT_MAX, FLAGS },
{ "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 0, INT_MAX, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(anullsrc);
@ -137,13 +137,10 @@ static const AVFilterPad avfilter_asrc_anullsrc_outputs[] = {
AVFilter avfilter_asrc_anullsrc = {
.name = "anullsrc",
.description = NULL_IF_CONFIG_SMALL("Null audio source, return empty audio frames."),
.init = init,
.query_formats = query_formats,
.priv_size = sizeof(ANullContext),
.inputs = NULL,
.outputs = avfilter_asrc_anullsrc_outputs,
.priv_class = &anullsrc_class,
};

2
libavfilter/asrc_sine.c
Unescape View File

@ -71,7 +71,7 @@ static const AVOption sine_options[] = {
OPT_DUR("duration", duration, 0, 0, INT64_MAX, "set the audio duration"),
OPT_DUR("d", duration, 0, 0, INT64_MAX, "set the audio duration"),
OPT_INT("samples_per_frame", samples_per_frame, 1024, 0, INT_MAX, "set the number of samples per frame"),
{NULL},
{NULL}
};
AVFILTER_DEFINE_CLASS(sine);

2
libavfilter/avf_avectorscope.c
Unescape View File

@ -70,7 +70,7 @@ static const AVOption avectorscope_options[] = {
{ "gf", "set green fade", OFFSET(fade[1]), AV_OPT_TYPE_INT, {.i64=10}, 0, 255, FLAGS },
{ "bf", "set blue fade", OFFSET(fade[2]), AV_OPT_TYPE_INT, {.i64=5}, 0, 255, FLAGS },
{ "zoom", "set zoom factor", OFFSET(zoom), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 1, 10, FLAGS },
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(avectorscope);

2
libavfilter/avf_concat.c
Unescape View File

@ -69,7 +69,7 @@ static const AVOption concat_options[] = {
{ "unsafe", "enable unsafe mode",
OFFSET(unsafe),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, V|A|F},
{ 0 }
{ NULL }
};
AVFILTER_DEFINE_CLASS(concat);

2
libavfilter/avf_showspectrum.c
Unescape View File

@ -79,7 +79,7 @@ static const AVOption showspectrum_options[] = {
{ "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=LOG}, 0, 0, FLAGS, "scale" },
{ "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, "scale" },
{ "saturation", "color saturation multiplier", OFFSET(saturation), AV_OPT_TYPE_FLOAT, {.dbl = 1}, -10, 10, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(showspectrum);

2
libavfilter/avf_showwaves.c
Unescape View File

@ -62,7 +62,7 @@ static const AVOption showwaves_options[] = {
{ "n", "set how many samples to show in the same point", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
{ "rate", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },
{ "r", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(showwaves);

2
libavfilter/f_ebur128.c
Unescape View File

@ -142,7 +142,7 @@ static const AVOption ebur128_options[] = {
{ "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" },
{ "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" },
{ "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, A|V|F },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(ebur128);

2
libavfilter/f_interleave.c
Unescape View File

@ -45,7 +45,7 @@ typedef struct {
static const AVOption filt_name##_options[] = { \
{ "nb_inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
{ "n", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
{ NULL }, \
{ NULL } \
}
inline static int push_frame(AVFilterContext *ctx)

2
libavfilter/f_select.c
Unescape View File

@ -525,10 +525,8 @@ AVFilter avfilter_vf_select = {
.init = select_init,
.uninit = uninit,
.query_formats = query_formats,
.priv_size = sizeof(SelectContext),
.priv_class = &select_class,
.inputs = avfilter_vf_select_inputs,
.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
};

2
libavfilter/f_sendcmd.c
Unescape View File

@ -86,7 +86,7 @@ static const AVOption options[] = {
{ "c", "set commands", OFFSET(commands_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
{ "filename", "set commands file", OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
{ "f", "set commands file", OFFSET(commands_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
{NULL},
{ NULL }
};
#define SPACES " \f\t\n\r"

3
libavfilter/f_settb.c
Unescape View File

@ -146,10 +146,8 @@ static const AVFilterPad avfilter_vf_settb_outputs[] = {
AVFilter avfilter_vf_settb = {
.name = "settb",
.description = NULL_IF_CONFIG_SMALL("Set timebase for the video output link."),
.priv_size = sizeof(SetTBContext),
.priv_class = &settb_class,
.inputs = avfilter_vf_settb_inputs,
.outputs = avfilter_vf_settb_outputs,
};
@ -181,7 +179,6 @@ static const AVFilterPad avfilter_af_asettb_outputs[] = {
AVFilter avfilter_af_asettb = {
.name = "asettb",
.description = NULL_IF_CONFIG_SMALL("Set timebase for the audio output link."),
.priv_size = sizeof(SetTBContext),
.inputs = avfilter_af_asettb_inputs,
.outputs = avfilter_af_asettb_outputs,

2
libavfilter/setpts.c
Unescape View File

@ -221,7 +221,7 @@ static av_cold void uninit(AVFilterContext *ctx)
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
static const AVOption options[] = {
{ "expr", "Expression determining the frame timestamp", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "PTS" }, .flags = FLAGS },
{ NULL },
{ NULL }
};
#if CONFIG_SETPTS_FILTER

10
libavfilter/split.c
Unescape View File

@ -95,7 +95,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
#define FLAGS AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM
static const AVOption options[] = {
{ "outputs", "set number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, INT_MAX, FLAGS },
{ NULL },
{ NULL }
};
#define split_options options
@ -116,16 +116,12 @@ static const AVFilterPad avfilter_vf_split_inputs[] = {
AVFilter avfilter_vf_split = {
.name = "split",
.description = NULL_IF_CONFIG_SMALL("Pass on the input to N video outputs."),
.priv_size = sizeof(SplitContext),
.priv_class = &split_class,
.init = split_init,
.uninit = split_uninit,
.inputs = avfilter_vf_split_inputs,
.outputs = NULL,
.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
};
@ -141,15 +137,11 @@ static const AVFilterPad avfilter_af_asplit_inputs[] = {
AVFilter avfilter_af_asplit = {
.name = "asplit",
.description = NULL_IF_CONFIG_SMALL("Pass on the audio input to N audio outputs."),
.priv_size = sizeof(SplitContext),
.priv_class = &asplit_class,
.init = split_init,
.uninit = split_uninit,
.inputs = avfilter_af_asplit_inputs,
.outputs = NULL,
.flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
};

1
libavfilter/transform.c
Unescape View File

@ -199,4 +199,3 @@ int avfilter_transform(const uint8_t *src, uint8_t *dst,
}
return 0;
}

10
libavfilter/trim.c
Unescape View File

@ -202,7 +202,7 @@ static const AVOption trim_options[] = {
{ "end_frame", "Number of the first frame that should be dropped "
"again", OFFSET(end_frame), AV_OPT_TYPE_INT64, { .i64 = INT64_MAX }, 0, INT64_MAX, FLAGS },
COMPAT_OPTS
{ NULL },
{ NULL }
};
#undef FLAGS
@ -230,12 +230,9 @@ static const AVFilterPad trim_outputs[] = {
AVFilter avfilter_vf_trim = {
.name = "trim",
.description = NULL_IF_CONFIG_SMALL("Pick one continuous section from the input, drop the rest."),
.init = init,
.priv_size = sizeof(TrimContext),
.priv_class = &trim_class,
.inputs = trim_inputs,
.outputs = trim_outputs,
};
@ -360,7 +357,7 @@ static const AVOption atrim_options[] = {
{ "end_sample", "Number of the first audio sample that should be "
"dropped again", OFFSET(end_sample), AV_OPT_TYPE_INT64, { .i64 = INT64_MAX }, 0, INT64_MAX, FLAGS },
COMPAT_OPTS
{ NULL },
{ NULL }
};
#undef FLAGS
@ -388,12 +385,9 @@ static const AVFilterPad atrim_outputs[] = {
AVFilter avfilter_af_atrim = {
.name = "atrim",
.description = NULL_IF_CONFIG_SMALL("Pick one continuous section from the input, drop the rest."),
.init = init,
.priv_size = sizeof(TrimContext),
.priv_class = &atrim_class,
.inputs = atrim_inputs,
.outputs = atrim_outputs,
};

4
libavfilter/vf_aspect.c
Unescape View File

@ -162,9 +162,7 @@ AVFilter avfilter_vf_setdar = {
.init = init,
.priv_size = sizeof(AspectContext),
.priv_class = &setdar_class,
.inputs = avfilter_vf_setdar_inputs,
.outputs = avfilter_vf_setdar_outputs,
};
@ -226,9 +224,7 @@ AVFilter avfilter_vf_setsar = {
.init = init,
.priv_size = sizeof(AspectContext),
.priv_class = &setsar_class,
.inputs = avfilter_vf_setsar_inputs,
.outputs = avfilter_vf_setsar_outputs,
};

2
libavfilter/vf_blackdetect.c
Unescape View File

@ -56,7 +56,7 @@ static const AVOption blackdetect_options[] = {
{ "pic_th", "set the picture black ratio threshold", OFFSET(picture_black_ratio_th), AV_OPT_TYPE_DOUBLE, {.dbl=.98}, 0, 1, FLAGS },
{ "pixel_black_th", "set the pixel black threshold", OFFSET(pixel_black_th), AV_OPT_TYPE_DOUBLE, {.dbl=.10}, 0, 1, FLAGS },
{ "pix_th", "set the pixel black threshold", OFFSET(pixel_black_th), AV_OPT_TYPE_DOUBLE, {.dbl=.10}, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(blackdetect);

6
libavfilter/vf_blackframe.c
Unescape View File

@ -98,7 +98,7 @@ static const AVOption blackframe_options[] = {
OFFSET(bthresh), AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 255, FLAGS },
{ "thresh", "threshold below which a pixel value is considered black",
OFFSET(bthresh), AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 255, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(blackframe);
@ -123,13 +123,9 @@ static const AVFilterPad avfilter_vf_blackframe_outputs[] = {
AVFilter avfilter_vf_blackframe = {
.name = "blackframe",
.description = NULL_IF_CONFIG_SMALL("Detect frames that are (almost) black."),
.priv_size = sizeof(BlackFrameContext),
.priv_class = &blackframe_class,
.query_formats = query_formats,
.inputs = avfilter_vf_blackframe_inputs,
.outputs = avfilter_vf_blackframe_outputs,
};

2
libavfilter/vf_blend.c
Unescape View File

@ -142,7 +142,7 @@ static const AVOption blend_options[] = {
{ "all_opacity", "set opacity for all color components", OFFSET(all_opacity), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 1, FLAGS},
{ "shortest", "force termination when the shortest input terminates", OFFSET(dinput.shortest), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS },
{ "repeatlast", "repeat last bottom frame", OFFSET(dinput.repeatlast), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(blend);

1
libavfilter/vf_boxblur.c
Unescape View File

@ -380,7 +380,6 @@ AVFilter avfilter_vf_boxblur = {
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_boxblur_inputs,
.outputs = avfilter_vf_boxblur_outputs,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

1
libavfilter/vf_colormatrix.c
Unescape View File

@ -378,7 +378,6 @@ static const AVFilterPad colormatrix_outputs[] = {
AVFilter avfilter_vf_colormatrix = {
.name = "colormatrix",
.description = NULL_IF_CONFIG_SMALL("Convert color matrix."),
.priv_size = sizeof(ColorMatrixContext),
.init = init,
.query_formats = query_formats,

1
libavfilter/vf_copy.c
Unescape View File

@ -64,7 +64,6 @@ static const AVFilterPad avfilter_vf_copy_outputs[] = {
AVFilter avfilter_vf_copy = {
.name = "copy",
.description = NULL_IF_CONFIG_SMALL("Copy the input video unchanged to the output."),
.inputs = avfilter_vf_copy_inputs,
.outputs = avfilter_vf_copy_outputs,
};

3
libavfilter/vf_crop.c
Unescape View File

@ -335,13 +335,10 @@ static const AVFilterPad avfilter_vf_crop_outputs[] = {
AVFilter avfilter_vf_crop = {
.name = "crop",
.description = NULL_IF_CONFIG_SMALL("Crop the input video to width:height:x:y."),
.priv_size = sizeof(CropContext),
.priv_class = &crop_class,
.query_formats = query_formats,
.uninit = uninit,
.inputs = avfilter_vf_crop_inputs,
.outputs = avfilter_vf_crop_outputs,
};

3
libavfilter/vf_cropdetect.c
Unescape View File

@ -216,7 +216,7 @@ static const AVOption cropdetect_options[] = {
{ "round", "Value by which the width/height should be divisible", OFFSET(round), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, INT_MAX, FLAGS },
{ "reset", "Recalculate the crop area after this many frames", OFFSET(reset_count), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
{ "reset_count", "Recalculate the crop area after this many frames",OFFSET(reset_count),AV_OPT_TYPE_INT,{ .i64 = 0 }, 0, INT_MAX, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(cropdetect);
@ -242,7 +242,6 @@ static const AVFilterPad avfilter_vf_cropdetect_outputs[] = {
AVFilter avfilter_vf_cropdetect = {
.name = "cropdetect",
.description = NULL_IF_CONFIG_SMALL("Auto-detect crop size."),
.priv_size = sizeof(CropDetectContext),
.priv_class = &cropdetect_class,
.init = init,

3
libavfilter/vf_delogo.c
Unescape View File

@ -164,7 +164,7 @@ static const AVOption delogo_options[]= {
{ "band", "set delogo area band size", OFFSET(band), AV_OPT_TYPE_INT, { .i64 = 4 }, 1, INT_MAX, FLAGS },
{ "t", "set delogo area band size", OFFSET(band), AV_OPT_TYPE_INT, { .i64 = 4 }, 1, INT_MAX, FLAGS },
{ "show", "show delogo area", OFFSET(show), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(delogo);
@ -284,7 +284,6 @@ AVFilter avfilter_vf_delogo = {
.priv_class = &delogo_class,
.init = init,
.query_formats = query_formats,
.inputs = avfilter_vf_delogo_inputs,
.outputs = avfilter_vf_delogo_outputs,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

1
libavfilter/vf_drawbox.c
Unescape View File

@ -277,7 +277,6 @@ AVFilter avfilter_vf_drawbox = {
.priv_size = sizeof(DrawBoxContext),
.priv_class = &drawbox_class,
.init = init,
.query_formats = query_formats,
.inputs = drawbox_inputs,
.outputs = drawbox_outputs,

3
libavfilter/vf_drawtext.c
Unescape View File

@ -223,7 +223,7 @@ static const AVOption drawtext_options[]= {
{ "monochrome", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_MONOCHROME }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "linear_design", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_LINEAR_DESIGN }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "no_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },
{ NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(drawtext);
@ -1064,7 +1064,6 @@ AVFilter avfilter_vf_drawtext = {
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_drawtext_inputs,
.outputs = avfilter_vf_drawtext_outputs,
.process_command = command,

2
libavfilter/vf_edgedetect.c
Unescape View File

@ -45,7 +45,7 @@ typedef struct {
static const AVOption edgedetect_options[] = {
{ "high", "set high threshold", OFFSET(high), AV_OPT_TYPE_DOUBLE, {.dbl=50/255.}, 0, 1, FLAGS },
{ "low", "set low threshold", OFFSET(low), AV_OPT_TYPE_DOUBLE, {.dbl=20/255.}, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(edgedetect);

3
libavfilter/vf_fade.c
Unescape View File

@ -316,7 +316,7 @@ static const AVOption fade_options[] = {
OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },
{ "d", "Duration of the effect in seconds.",
OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(fade);
@ -347,7 +347,6 @@ AVFilter avfilter_vf_fade = {
.priv_size = sizeof(FadeContext),
.priv_class = &fade_class,
.query_formats = query_formats,
.inputs = avfilter_vf_fade_inputs,
.outputs = avfilter_vf_fade_outputs,
.flags = AVFILTER_FLAG_SLICE_THREADS,

2
libavfilter/vf_field.c
Unescape View File

@ -44,7 +44,6 @@ static const AVOption field_options[] = {
{"type", "set field type (top or bottom)", OFFSET(type), AV_OPT_TYPE_INT, {.i64=FIELD_TYPE_TOP}, 0, 1, FLAGS, "field_type" },
{"top", "select top field", 0, AV_OPT_TYPE_CONST, {.i64=FIELD_TYPE_TOP}, INT_MIN, INT_MAX, FLAGS, "field_type"},
{"bottom", "select bottom field", 0, AV_OPT_TYPE_CONST, {.i64=FIELD_TYPE_BOTTOM}, INT_MIN, INT_MAX, FLAGS, "field_type"},
{NULL}
};
@ -105,7 +104,6 @@ static const AVFilterPad field_outputs[] = {
AVFilter avfilter_vf_field = {
.name = "field",
.description = NULL_IF_CONFIG_SMALL("Extract a field from the input video."),
.priv_size = sizeof(FieldContext),
.inputs = field_inputs,
.outputs = field_outputs,

2
libavfilter/vf_fieldorder.c
Unescape View File

@ -157,7 +157,7 @@ static const AVOption fieldorder_options[] = {
{ "order", "output field order", OFFSET(dst_tff), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "order" },
{ "bff", "bottom field first", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags=FLAGS, .unit = "order" },
{ "tff", "top field first", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags=FLAGS, .unit = "order" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(fieldorder);

10
libavfilter/vf_format.c
Unescape View File

@ -99,7 +99,7 @@ static AVFilterFormats *make_format_list(FormatContext *s, int flag)
#define OFFSET(x) offsetof(FormatContext, x)
static const AVOption options[] = {
{ "pix_fmts", "A '|'-separated list of pixel formats", OFFSET(pix_fmts), AV_OPT_TYPE_STRING, .flags = AV_OPT_FLAG_VIDEO_PARAM },
{ NULL },
{ NULL }
};
#if CONFIG_FORMAT_FILTER
@ -132,14 +132,10 @@ static const AVFilterPad avfilter_vf_format_outputs[] = {
AVFilter avfilter_vf_format = {
.name = "format",
.description = NULL_IF_CONFIG_SMALL("Convert the input video to one of the specified pixel formats."),
.init = init,
.query_formats = query_formats_format,
.priv_size = sizeof(FormatContext),
.priv_class = &format_class,
.inputs = avfilter_vf_format_inputs,
.outputs = avfilter_vf_format_outputs,
};
@ -175,14 +171,10 @@ static const AVFilterPad avfilter_vf_noformat_outputs[] = {
AVFilter avfilter_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."),
.init = init,
.query_formats = query_formats_noformat,
.priv_size = sizeof(FormatContext),
.priv_class = &noformat_class,
.inputs = avfilter_vf_noformat_inputs,
.outputs = avfilter_vf_noformat_outputs,
};

5
libavfilter/vf_fps.c
Unescape View File

@ -70,7 +70,7 @@ static const AVOption fps_options[] = {
{ "down", "round towards -infty", OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_DOWN }, 0, 5, V|F, "round" },
{ "up", "round towards +infty", OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_UP }, 0, 5, V|F, "round" },
{ "near", "round to nearest", OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_NEAR_INF }, 0, 5, V|F, "round" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(fps);
@ -293,13 +293,10 @@ static const AVFilterPad avfilter_vf_fps_outputs[] = {
AVFilter avfilter_vf_fps = {
.name = "fps",
.description = NULL_IF_CONFIG_SMALL("Force constant framerate."),
.init = init,
.uninit = uninit,
.priv_size = sizeof(FPSContext),
.priv_class = &fps_class,
.inputs = avfilter_vf_fps_inputs,
.outputs = avfilter_vf_fps_outputs,
};

10
libavfilter/vf_frei0r.c
Unescape View File

@ -412,7 +412,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static const AVOption frei0r_options[] = {
{ "filter_name", NULL, OFFSET(dl_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
{ "filter_params", NULL, OFFSET(params), AV_OPT_TYPE_STRING, .flags = FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(frei0r);
@ -438,16 +438,12 @@ static const AVFilterPad avfilter_vf_frei0r_outputs[] = {
AVFilter avfilter_vf_frei0r = {
.name = "frei0r",
.description = NULL_IF_CONFIG_SMALL("Apply a frei0r effect."),
.query_formats = query_formats,
.init = filter_init,
.uninit = uninit,
.priv_size = sizeof(Frei0rContext),
.priv_class = &frei0r_class,
.inputs = avfilter_vf_frei0r_inputs,
.outputs = avfilter_vf_frei0r_outputs,
};
@ -523,15 +519,11 @@ static const AVFilterPad avfilter_vsrc_frei0r_src_outputs[] = {
AVFilter avfilter_vsrc_frei0r_src = {
.name = "frei0r_src",
.description = NULL_IF_CONFIG_SMALL("Generate a frei0r source."),
.priv_size = sizeof(Frei0rContext),
.priv_class = &frei0r_src_class,
.init = source_init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = NULL,
.outputs = avfilter_vsrc_frei0r_src_outputs,
};

2
libavfilter/vf_gradfun.c
Unescape View File

@ -228,7 +228,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static const AVOption gradfun_options[] = {
{ "strength", "The maximum amount by which the filter will change any one pixel.", OFFSET(strength), AV_OPT_TYPE_FLOAT, { .dbl = 1.2 }, 0.51, 64, FLAGS },
{ "radius", "The neighborhood to fit the gradient to.", OFFSET(radius), AV_OPT_TYPE_INT, { .i64 = 16 }, 4, 32, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(gradfun);

1
libavfilter/vf_hflip.c
Unescape View File

@ -170,7 +170,6 @@ AVFilter avfilter_vf_hflip = {
.description = NULL_IF_CONFIG_SMALL("Horizontally flip the input video."),
.priv_size = sizeof(FlipContext),
.query_formats = query_formats,
.inputs = avfilter_vf_hflip_inputs,
.outputs = avfilter_vf_hflip_outputs,
};

1
libavfilter/vf_histeq.c
Unescape View File

@ -274,7 +274,6 @@ AVFilter avfilter_vf_histeq = {
.priv_size = sizeof(HisteqContext),
.init = init,
.query_formats = query_formats,
.inputs = histeq_inputs,
.outputs = histeq_outputs,
.priv_class = &histeq_class,

2
libavfilter/vf_histogram.c
Unescape View File

@ -71,7 +71,7 @@ static const AVOption histogram_options[] = {
{ "levels_mode", "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"},
{ "linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "levels_mode" },
{ "logarithmic", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "levels_mode" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(histogram);

4
libavfilter/vf_hqdn3d.c
Unescape View File

@ -325,7 +325,7 @@ static const AVOption hqdn3d_options[] = {
{ "chroma_spatial", "spatial chroma strength", OFFSET(strength[CHROMA_SPATIAL]), AV_OPT_TYPE_DOUBLE, { .dbl = 0.0 }, 0, DBL_MAX, FLAGS },
{ "luma_tmp", "temporal luma strength", OFFSET(strength[LUMA_TMP]), AV_OPT_TYPE_DOUBLE, { .dbl = 0.0 }, 0, DBL_MAX, FLAGS },
{ "chroma_tmp", "temporal chroma strength", OFFSET(strength[CHROMA_TMP]), AV_OPT_TYPE_DOUBLE, { .dbl = 0.0 }, 0, DBL_MAX, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(hqdn3d);
@ -352,13 +352,11 @@ static const AVFilterPad avfilter_vf_hqdn3d_outputs[] = {
AVFilter avfilter_vf_hqdn3d = {
.name = "hqdn3d",
.description = NULL_IF_CONFIG_SMALL("Apply a High Quality 3D Denoiser."),
.priv_size = sizeof(HQDN3DContext),
.priv_class = &hqdn3d_class,
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_hqdn3d_inputs,
.outputs = avfilter_vf_hqdn3d_outputs,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

2
libavfilter/vf_hue.c
Unescape View File

@ -437,9 +437,7 @@ static const AVFilterPad hue_outputs[] = {
AVFilter avfilter_vf_hue = {
.name = "hue",
.description = NULL_IF_CONFIG_SMALL("Adjust the hue and saturation of the input video."),
.priv_size = sizeof(HueContext),
.init = init,
.uninit = uninit,
.query_formats = query_formats,

1
libavfilter/vf_idet.c
Unescape View File

@ -298,7 +298,6 @@ static const AVFilterPad idet_outputs[] = {
AVFilter avfilter_vf_idet = {
.name = "idet",
.description = NULL_IF_CONFIG_SMALL("Interlace detect Filter."),
.priv_size = sizeof(IDETContext),
.init = init,
.uninit = uninit,

3
libavfilter/vf_interlace.c
Unescape View File

@ -225,12 +225,9 @@ AVFilter avfilter_vf_interlace = {
.name = "interlace",
.description = NULL_IF_CONFIG_SMALL("Convert progressive video into interlaced."),
.uninit = uninit,
.priv_class = &interlace_class,
.priv_size = sizeof(InterlaceContext),
.query_formats = query_formats,
.inputs = inputs,
.outputs = outputs,
};

4
libavfilter/vf_kerndeint.c
Unescape View File

@ -310,11 +310,9 @@ AVFilter avfilter_vf_kerndeint = {
.name = "kerndeint",
.description = NULL_IF_CONFIG_SMALL("Apply kernel deinterlacing to the input."),
.priv_size = sizeof(KerndeintContext),
.priv_class = &kerndeint_class,
.uninit = uninit,
.query_formats = query_formats,
.inputs = kerndeint_inputs,
.outputs = kerndeint_outputs,
.priv_class = &kerndeint_class,
};

6
libavfilter/vf_libopencv.c
Unescape View File

@ -381,7 +381,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static const AVOption ocv_options[] = {
{ "filter_name", NULL, OFFSET(name), AV_OPT_TYPE_STRING, .flags = FLAGS },
{ "filter_params", NULL, OFFSET(params), AV_OPT_TYPE_STRING, .flags = FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(ocv);
@ -406,15 +406,11 @@ static const AVFilterPad avfilter_vf_ocv_outputs[] = {
AVFilter avfilter_vf_ocv = {
.name = "ocv",
.description = NULL_IF_CONFIG_SMALL("Apply transform using libopencv."),
.priv_size = sizeof(OCVContext),
.priv_class = &ocv_class,
.query_formats = query_formats,
.init = init,
.uninit = uninit,
.inputs = avfilter_vf_ocv_inputs,
.outputs = avfilter_vf_ocv_outputs,
};

13
libavfilter/vf_lut.c
Unescape View File

@ -92,7 +92,7 @@ static const AVOption options[] = {
{ "g", "set G expression", OFFSET(comp_expr_str[G]), AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
{ "b", "set B expression", OFFSET(comp_expr_str[B]), AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
{ "a", "set A expression", OFFSET(comp_expr_str[A]), AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
{ NULL },
{ NULL }
};
static av_cold void uninit(AVFilterContext *ctx)
@ -336,12 +336,13 @@ static const AVFilterPad inputs[] = {
.filter_frame = filter_frame,
.config_props = config_props,
},
{ .name = NULL}
{ NULL }
};
static const AVFilterPad outputs[] = {
{ .name = "default",
.type = AVMEDIA_TYPE_VIDEO, },
{ .name = NULL}
.type = AVMEDIA_TYPE_VIDEO,
},
{ NULL }
};
#define DEFINE_LUT_FILTER(name_, description_) \
@ -350,11 +351,9 @@ static const AVFilterPad outputs[] = {
.description = NULL_IF_CONFIG_SMALL(description_), \
.priv_size = sizeof(LutContext), \
.priv_class = &name_ ## _class, \
\
.init = name_##_init, \
.uninit = uninit, \
.query_formats = query_formats, \
\
.inputs = inputs, \
.outputs = outputs, \
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, \
@ -411,7 +410,7 @@ DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input vid
static const AVOption negate_options[] = {
{ "negate_alpha", NULL, OFFSET(negate_alpha), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(negate);

3
libavfilter/vf_mpdecimate.c
Unescape View File

@ -249,10 +249,9 @@ AVFilter avfilter_vf_mpdecimate = {
.description = NULL_IF_CONFIG_SMALL("Remove near-duplicate frames."),
.init = init,
.uninit = uninit,
.priv_size = sizeof(DecimateContext),
.priv_class = &mpdecimate_class,
.query_formats = query_formats,
.inputs = mpdecimate_inputs,
.outputs = mpdecimate_outputs,
.priv_class = &mpdecimate_class,
};

4
libavfilter/vf_overlay.c
Unescape View File

@ -627,16 +627,12 @@ static const AVFilterPad avfilter_vf_overlay_outputs[] = {
AVFilter avfilter_vf_overlay = {
.name = "overlay",
.description = NULL_IF_CONFIG_SMALL("Overlay a video source on top of the input."),
.init = init,
.uninit = uninit,
.priv_size = sizeof(OverlayContext),
.priv_class = &overlay_class,
.query_formats = query_formats,
.process_command = process_command,
.inputs = avfilter_vf_overlay_inputs,
.outputs = avfilter_vf_overlay_outputs,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

5
libavfilter/vf_pad.c
Unescape View File

@ -367,7 +367,7 @@ static const AVOption pad_options[] = {
{ "x", "set the x offset expression for the input image position", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "y", "set the y offset expression for the input image position", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "color", "set the color of the padded area border", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str = "black"}, .flags = FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(pad);
@ -395,12 +395,9 @@ static const AVFilterPad avfilter_vf_pad_outputs[] = {
AVFilter avfilter_vf_pad = {
.name = "pad",
.description = NULL_IF_CONFIG_SMALL("Pad input image to width:height[:x:y[:color]] (default x and y: 0, default color: black)."),
.priv_size = sizeof(PadContext),
.priv_class = &pad_class,
.query_formats = query_formats,
.inputs = avfilter_vf_pad_inputs,
.outputs = avfilter_vf_pad_outputs,
};

3
libavfilter/vf_pixdesctest.c
Unescape View File

@ -128,11 +128,8 @@ static const AVFilterPad avfilter_vf_pixdesctest_outputs[] = {
AVFilter avfilter_vf_pixdesctest = {
.name = "pixdesctest",
.description = NULL_IF_CONFIG_SMALL("Test pixel format definitions."),
.priv_size = sizeof(PixdescTestContext),
.uninit = uninit,
.inputs = avfilter_vf_pixdesctest_inputs,
.outputs = avfilter_vf_pixdesctest_outputs,
};

2
libavfilter/vf_psnr.c
Unescape View File

@ -61,7 +61,7 @@ typedef struct PSNRContext {
static const AVOption psnr_options[] = {
{"stats_file", "Set file where to store per-frame difference information", OFFSET(stats_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
{"f", "Set file where to store per-frame difference information", OFFSET(stats_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(psnr);

6
libavfilter/vf_scale.c
Unescape View File

@ -538,7 +538,7 @@ static const AVOption scale_options[] = {
{ "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
{ "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
{ "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
{ NULL },
{ NULL }
};
static const AVClass scale_class = {
@ -570,15 +570,11 @@ static const AVFilterPad avfilter_vf_scale_outputs[] = {
AVFilter avfilter_vf_scale = {
.name = "scale",
.description = NULL_IF_CONFIG_SMALL("Scale the input video to width:height size and/or convert the image format."),
.init_dict = init_dict,
.uninit = uninit,
.query_formats = query_formats,
.priv_size = sizeof(ScaleContext),
.priv_class = &scale_class,
.inputs = avfilter_vf_scale_inputs,
.outputs = avfilter_vf_scale_outputs,
};

2
libavfilter/vf_setfield.c
Unescape View File

@ -88,7 +88,7 @@ AVFilter avfilter_vf_setfield = {
.name = "setfield",
.description = NULL_IF_CONFIG_SMALL("Force field for the output video frame."),
.priv_size = sizeof(SetFieldContext),
.priv_class = &setfield_class,
.inputs = setfield_inputs,
.outputs = setfield_outputs,
.priv_class = &setfield_class,
};

2
libavfilter/vf_showinfo.c
Unescape View File

@ -95,8 +95,6 @@ static const AVFilterPad avfilter_vf_showinfo_outputs[] = {
AVFilter avfilter_vf_showinfo = {
.name = "showinfo",
.description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
.inputs = avfilter_vf_showinfo_inputs,
.outputs = avfilter_vf_showinfo_outputs,
};

2
libavfilter/vf_smartblur.c
Unescape View File

@ -293,9 +293,7 @@ static const AVFilterPad smartblur_outputs[] = {
AVFilter avfilter_vf_smartblur = {
.name = "smartblur",
.description = NULL_IF_CONFIG_SMALL("Blur the input video without impacting the outlines."),
.priv_size = sizeof(SmartblurContext),
.init = init,
.uninit = uninit,
.query_formats = query_formats,

2
libavfilter/vf_stereo3d.c
Unescape View File

@ -187,7 +187,7 @@ static const AVOption stereo3d_options[] = {
{ "sbs2r", "side by side half width right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_RL}, 0, 0, FLAGS, "out" },
{ "sbsl", "side by side left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_LR}, 0, 0, FLAGS, "out" },
{ "sbsr", "side by side right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_RL}, 0, 0, FLAGS, "out" },
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(stereo3d);

1
libavfilter/vf_swapuv.c
Unescape View File

@ -104,7 +104,6 @@ static const AVFilterPad swapuv_outputs[] = {
AVFilter avfilter_vf_swapuv = {
.name = "swapuv",
.description = NULL_IF_CONFIG_SMALL("Swap U and V components."),
.priv_size = 0,
.query_formats = query_formats,
.inputs = swapuv_inputs,
.outputs = swapuv_outputs,

2
libavfilter/vf_tile.c
Unescape View File

@ -59,7 +59,7 @@ static const AVOption tile_options[] = {
{ "padding", "set inner border thickness in pixels", OFFSET(padding),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1024, FLAGS },
{ "color", "set the color of the unused area", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str = "black"}, .flags = FLAGS },
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(tile);

5
libavfilter/vf_transpose.c
Unescape View File

@ -267,7 +267,7 @@ static const AVOption transpose_options[] = {
{ "portrait", "preserve portrait geometry", 0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_PORTRAIT}, INT_MIN, INT_MAX, FLAGS, "passthrough" },
{ "landscape", "preserve landscape geometry", 0, AV_OPT_TYPE_CONST, {.i64=TRANSPOSE_PT_TYPE_LANDSCAPE}, INT_MIN, INT_MAX, FLAGS, "passthrough" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(transpose);
@ -294,12 +294,9 @@ static const AVFilterPad avfilter_vf_transpose_outputs[] = {
AVFilter avfilter_vf_transpose = {
.name = "transpose",
.description = NULL_IF_CONFIG_SMALL("Transpose input video."),
.priv_size = sizeof(TransContext),
.priv_class = &transpose_class,
.query_formats = query_formats,
.inputs = avfilter_vf_transpose_inputs,
.outputs = avfilter_vf_transpose_outputs,
.flags = AVFILTER_FLAG_SLICE_THREADS,

5
libavfilter/vf_unsharp.c
Unescape View File

@ -275,7 +275,7 @@ static const AVOption unsharp_options[] = {
{ "chroma_amount", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
{ "ca", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
{ "opencl", "use OpenCL filtering capabilities", OFFSET(opencl), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(unsharp);
@ -301,14 +301,11 @@ static const AVFilterPad avfilter_vf_unsharp_outputs[] = {
AVFilter avfilter_vf_unsharp = {
.name = "unsharp",
.description = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."),
.priv_size = sizeof(UnsharpContext),
.priv_class = &unsharp_class,
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_unsharp_inputs,
.outputs = avfilter_vf_unsharp_outputs,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,

2
libavfilter/vf_vflip.c
Unescape View File

@ -105,9 +105,7 @@ static const AVFilterPad avfilter_vf_vflip_outputs[] = {
AVFilter avfilter_vf_vflip = {
.name = "vflip",
.description = NULL_IF_CONFIG_SMALL("Flip the input video vertically."),
.priv_size = sizeof(FlipContext),
.inputs = avfilter_vf_vflip_inputs,
.outputs = avfilter_vf_vflip_outputs,
};

1
libavfilter/vf_vidstabdetect.c
Unescape View File

@ -211,7 +211,6 @@ AVFilter avfilter_vf_vidstabdetect = {
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_vidstabdetect_inputs,
.outputs = avfilter_vf_vidstabdetect_outputs,
.priv_class = &vidstabdetect_class,

1
libavfilter/vf_vidstabtransform.c
Unescape View File

@ -285,7 +285,6 @@ AVFilter avfilter_vf_vidstabtransform = {
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_vidstabtransform_inputs,
.outputs = avfilter_vf_vidstabtransform_outputs,
.priv_class = &vidstabtransform_class,

4
libavfilter/vf_yadif.c
Unescape View File

@ -512,7 +512,7 @@ static const AVOption yadif_options[] = {
CONST("all", "deinterlace all frames", YADIF_DEINT_ALL, "deint"),
CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED, "deint"),
{NULL},
{ NULL }
};
AVFILTER_DEFINE_CLASS(yadif);
@ -539,12 +539,10 @@ static const AVFilterPad avfilter_vf_yadif_outputs[] = {
AVFilter avfilter_vf_yadif = {
.name = "yadif",
.description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
.priv_size = sizeof(YADIFContext),
.priv_class = &yadif_class,
.uninit = uninit,
.query_formats = query_formats,
.inputs = avfilter_vf_yadif_inputs,
.outputs = avfilter_vf_yadif_outputs,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,

4
libavfilter/vsrc_cellauto.c
Unescape View File

@ -77,7 +77,7 @@ static const AVOption cellauto_options[] = {
{ "start_full", "start filling the whole video", OFFSET(start_full), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, FLAGS },
{ "full", "start filling the whole video", OFFSET(start_full), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, FLAGS },
{ "stitch", "stitch boundaries", OFFSET(stitch), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(cellauto);
@ -328,10 +328,10 @@ AVFilter avfilter_vsrc_cellauto = {
.name = "cellauto",
.description = NULL_IF_CONFIG_SMALL("Create pattern generated by an elementary cellular automaton."),
.priv_size = sizeof(CellAutoContext),
.priv_class = &cellauto_class,
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = NULL,
.outputs = cellauto_outputs,
.priv_class = &cellauto_class,
};

4
libavfilter/vsrc_life.c
Unescape View File

@ -93,7 +93,7 @@ static const AVOption life_options[] = {
{ "life_color", "set life color", OFFSET( life_color), AV_OPT_TYPE_COLOR, {.str="white"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "death_color", "set death color", OFFSET(death_color), AV_OPT_TYPE_COLOR, {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ "mold_color", "set mold color", OFFSET( mold_color), AV_OPT_TYPE_COLOR, {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(life);
@ -441,10 +441,10 @@ AVFilter avfilter_vsrc_life = {
.name = "life",
.description = NULL_IF_CONFIG_SMALL("Create life."),
.priv_size = sizeof(LifeContext),
.priv_class = &life_class,
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = NULL,
.outputs = life_outputs,
.priv_class = &life_class,
};

6
libavfilter/vsrc_mandelbrot.c
Unescape View File

@ -414,19 +414,17 @@ static const AVFilterPad mandelbrot_outputs[] = {
.request_frame = request_frame,
.config_props = config_props,
},
{ NULL },
{ NULL }
};
AVFilter avfilter_vsrc_mandelbrot = {
.name = "mandelbrot",
.description = NULL_IF_CONFIG_SMALL("Render a Mandelbrot fractal."),
.priv_size = sizeof(MBContext),
.priv_class = &mandelbrot_class,
.init = init,
.uninit = uninit,
.query_formats = query_formats,
.inputs = NULL,
.outputs = mandelbrot_outputs,
.priv_class = &mandelbrot_class,
};

6
libavfilter/vsrc_mptestsrc.c
Unescape View File

@ -79,7 +79,7 @@ static const AVOption mptestsrc_options[]= {
{ "ring1", "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_RING1}, INT_MIN, INT_MAX, FLAGS, "test" },
{ "ring2", "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_RING2}, INT_MIN, INT_MAX, FLAGS, "test" },
{ "all", "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_ALL}, INT_MIN, INT_MAX, FLAGS, "test" },
{ NULL },
{ NULL }
};
AVFILTER_DEFINE_CLASS(mptestsrc);
@ -353,11 +353,9 @@ AVFilter avfilter_vsrc_mptestsrc = {
.name = "mptestsrc",
.description = NULL_IF_CONFIG_SMALL("Generate various test pattern."),
.priv_size = sizeof(MPTestContext),
.priv_class = &mptestsrc_class,
.init = init,
.query_formats = query_formats,
.inputs = NULL,
.outputs = mptestsrc_outputs,
.priv_class = &mptestsrc_class,
};

13
libavfilter/vsrc_testsrc.c
Unescape View File

@ -261,12 +261,10 @@ static const AVFilterPad color_outputs[] = {
AVFilter avfilter_vsrc_color = {
.name = "color",
.description = NULL_IF_CONFIG_SMALL("Provide an uniformly colored input."),
.priv_class = &color_class,
.priv_size = sizeof(TestSourceContext),
.init = color_init,
.uninit = uninit,
.query_formats = color_query_formats,
.inputs = NULL,
.outputs = color_outputs,
@ -669,9 +667,7 @@ AVFilter avfilter_vsrc_testsrc = {
.priv_class = &testsrc_class,
.init = test_init,
.uninit = uninit,
.query_formats = test_query_formats,
.inputs = NULL,
.outputs = avfilter_vsrc_testsrc_outputs,
};
@ -787,11 +783,8 @@ AVFilter avfilter_vsrc_rgbtestsrc = {
.priv_class = &rgbtestsrc_class,
.init = rgbtest_init,
.uninit = uninit,
.query_formats = rgbtest_query_formats,
.inputs = NULL,
.outputs = avfilter_vsrc_rgbtestsrc_outputs,
};
@ -941,13 +934,12 @@ AVFilter avfilter_vsrc_smptebars = {
.name = "smptebars",
.description = NULL_IF_CONFIG_SMALL("Generate SMPTE color bars."),
.priv_size = sizeof(TestSourceContext),
.priv_class = &smptebars_class,
.init = smptebars_init,
.uninit = uninit,
.query_formats = smptebars_query_formats,
.inputs = NULL,
.outputs = smptebars_outputs,
.priv_class = &smptebars_class,
};
#endif /* CONFIG_SMPTEBARS_FILTER */
@ -1045,13 +1037,12 @@ AVFilter avfilter_vsrc_smptehdbars = {
.name = "smptehdbars",
.description = NULL_IF_CONFIG_SMALL("Generate SMPTE HD color bars."),
.priv_size = sizeof(TestSourceContext),
.priv_class = &smptehdbars_class,
.init = smptehdbars_init,
.uninit = uninit,
.query_formats = smptebars_query_formats,
.inputs = NULL,
.outputs = smptebars_outputs,
.priv_class = &smptehdbars_class,
};
#endif /* CONFIG_SMPTEHDBARS_FILTER */

Write Preview
Loading…
Cancel
Save