FFmpeg  4.4.5
af_adenorm.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/avassert.h"
21 #include "libavutil/opt.h"
22 #include "audio.h"
23 #include "avfilter.h"
24 #include "internal.h"
25 
26 enum FilterType {
32 };
33 
34 typedef struct ADenormContext {
35  const AVClass *class;
36 
37  double level;
38  double level_db;
39  int type;
41 
42  void (*filter)(AVFilterContext *ctx, void *dst,
43  const void *src, int nb_samples);
45 
47 {
50  static const enum AVSampleFormat sample_fmts[] = {
53  };
54  int ret;
55 
57  if (!formats)
58  return AVERROR(ENOMEM);
60  if (ret < 0)
61  return ret;
62 
64  if (!layouts)
65  return AVERROR(ENOMEM);
66 
68  if (ret < 0)
69  return ret;
70 
73 }
74 
75 static void dc_denorm_fltp(AVFilterContext *ctx, void *dstp,
76  const void *srcp, int nb_samples)
77 {
78  ADenormContext *s = ctx->priv;
79  const float *src = (const float *)srcp;
80  float *dst = (float *)dstp;
81  const float dc = s->level;
82 
83  for (int n = 0; n < nb_samples; n++) {
84  dst[n] = src[n] + dc;
85  }
86 }
87 
88 static void dc_denorm_dblp(AVFilterContext *ctx, void *dstp,
89  const void *srcp, int nb_samples)
90 {
91  ADenormContext *s = ctx->priv;
92  const double *src = (const double *)srcp;
93  double *dst = (double *)dstp;
94  const double dc = s->level;
95 
96  for (int n = 0; n < nb_samples; n++) {
97  dst[n] = src[n] + dc;
98  }
99 }
100 
101 static void ac_denorm_fltp(AVFilterContext *ctx, void *dstp,
102  const void *srcp, int nb_samples)
103 {
104  ADenormContext *s = ctx->priv;
105  const float *src = (const float *)srcp;
106  float *dst = (float *)dstp;
107  const float dc = s->level;
108  const int64_t N = s->in_samples;
109 
110  for (int n = 0; n < nb_samples; n++) {
111  dst[n] = src[n] + dc * (((N + n) & 1) ? -1.f : 1.f);
112  }
113 }
114 
115 static void ac_denorm_dblp(AVFilterContext *ctx, void *dstp,
116  const void *srcp, int nb_samples)
117 {
118  ADenormContext *s = ctx->priv;
119  const double *src = (const double *)srcp;
120  double *dst = (double *)dstp;
121  const double dc = s->level;
122  const int64_t N = s->in_samples;
123 
124  for (int n = 0; n < nb_samples; n++) {
125  dst[n] = src[n] + dc * (((N + n) & 1) ? -1. : 1.);
126  }
127 }
128 
129 static void sq_denorm_fltp(AVFilterContext *ctx, void *dstp,
130  const void *srcp, int nb_samples)
131 {
132  ADenormContext *s = ctx->priv;
133  const float *src = (const float *)srcp;
134  float *dst = (float *)dstp;
135  const float dc = s->level;
136  const int64_t N = s->in_samples;
137 
138  for (int n = 0; n < nb_samples; n++) {
139  dst[n] = src[n] + dc * ((((N + n) >> 8) & 1) ? -1.f : 1.f);
140  }
141 }
142 
143 static void sq_denorm_dblp(AVFilterContext *ctx, void *dstp,
144  const void *srcp, int nb_samples)
145 {
146  ADenormContext *s = ctx->priv;
147  const double *src = (const double *)srcp;
148  double *dst = (double *)dstp;
149  const double dc = s->level;
150  const int64_t N = s->in_samples;
151 
152  for (int n = 0; n < nb_samples; n++) {
153  dst[n] = src[n] + dc * ((((N + n) >> 8) & 1) ? -1. : 1.);
154  }
155 }
156 
157 static void ps_denorm_fltp(AVFilterContext *ctx, void *dstp,
158  const void *srcp, int nb_samples)
159 {
160  ADenormContext *s = ctx->priv;
161  const float *src = (const float *)srcp;
162  float *dst = (float *)dstp;
163  const float dc = s->level;
164  const int64_t N = s->in_samples;
165 
166  for (int n = 0; n < nb_samples; n++) {
167  dst[n] = src[n] + dc * (((N + n) & 255) ? 0.f : 1.f);
168  }
169 }
170 
171 static void ps_denorm_dblp(AVFilterContext *ctx, void *dstp,
172  const void *srcp, int nb_samples)
173 {
174  ADenormContext *s = ctx->priv;
175  const double *src = (const double *)srcp;
176  double *dst = (double *)dstp;
177  const double dc = s->level;
178  const int64_t N = s->in_samples;
179 
180  for (int n = 0; n < nb_samples; n++) {
181  dst[n] = src[n] + dc * (((N + n) & 255) ? 0. : 1.);
182  }
183 }
184 
185 static int config_output(AVFilterLink *outlink)
186 {
187  AVFilterContext *ctx = outlink->src;
188  ADenormContext *s = ctx->priv;
189 
190  switch (s->type) {
191  case DC_TYPE:
192  switch (outlink->format) {
193  case AV_SAMPLE_FMT_FLTP: s->filter = dc_denorm_fltp; break;
194  case AV_SAMPLE_FMT_DBLP: s->filter = dc_denorm_dblp; break;
195  }
196  break;
197  case AC_TYPE:
198  switch (outlink->format) {
199  case AV_SAMPLE_FMT_FLTP: s->filter = ac_denorm_fltp; break;
200  case AV_SAMPLE_FMT_DBLP: s->filter = ac_denorm_dblp; break;
201  }
202  break;
203  case SQ_TYPE:
204  switch (outlink->format) {
205  case AV_SAMPLE_FMT_FLTP: s->filter = sq_denorm_fltp; break;
206  case AV_SAMPLE_FMT_DBLP: s->filter = sq_denorm_dblp; break;
207  }
208  break;
209  case PS_TYPE:
210  switch (outlink->format) {
211  case AV_SAMPLE_FMT_FLTP: s->filter = ps_denorm_fltp; break;
212  case AV_SAMPLE_FMT_DBLP: s->filter = ps_denorm_dblp; break;
213  }
214  break;
215  default:
216  av_assert0(0);
217  }
218 
219  return 0;
220 }
221 
222 typedef struct ThreadData {
224 } ThreadData;
225 
226 static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
227 {
228  ADenormContext *s = ctx->priv;
229  ThreadData *td = arg;
230  AVFrame *out = td->out;
231  AVFrame *in = td->in;
232  const int start = (in->channels * jobnr) / nb_jobs;
233  const int end = (in->channels * (jobnr+1)) / nb_jobs;
234 
235  for (int ch = start; ch < end; ch++) {
236  s->filter(ctx, out->extended_data[ch],
237  in->extended_data[ch],
238  in->nb_samples);
239  }
240 
241  return 0;
242 }
243 
244 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
245 {
246  AVFilterContext *ctx = inlink->dst;
247  ADenormContext *s = ctx->priv;
248  AVFilterLink *outlink = ctx->outputs[0];
249  ThreadData td;
250  AVFrame *out;
251 
252  if (av_frame_is_writable(in)) {
253  out = in;
254  } else {
255  out = ff_get_audio_buffer(outlink, in->nb_samples);
256  if (!out) {
257  av_frame_free(&in);
258  return AVERROR(ENOMEM);
259  }
261  }
262 
263  s->level = exp(s->level_db / 20. * M_LN10);
264  td.in = in; td.out = out;
265  ctx->internal->execute(ctx, filter_channels, &td, NULL, FFMIN(inlink->channels,
267 
268  s->in_samples += in->nb_samples;
269 
270  if (out != in)
271  av_frame_free(&in);
272  return ff_filter_frame(outlink, out);
273 }
274 
275 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
276  char *res, int res_len, int flags)
277 {
278  AVFilterLink *outlink = ctx->outputs[0];
279  int ret;
280 
281  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
282  if (ret < 0)
283  return ret;
284 
285  return config_output(outlink);
286 }
287 
288 static const AVFilterPad adenorm_inputs[] = {
289  {
290  .name = "default",
291  .type = AVMEDIA_TYPE_AUDIO,
292  .filter_frame = filter_frame,
293  },
294  { NULL }
295 };
296 
297 static const AVFilterPad adenorm_outputs[] = {
298  {
299  .name = "default",
300  .type = AVMEDIA_TYPE_AUDIO,
301  .config_props = config_output,
302  },
303  { NULL }
304 };
305 
306 #define OFFSET(x) offsetof(ADenormContext, x)
307 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
308 
309 static const AVOption adenorm_options[] = {
310  { "level", "set level", OFFSET(level_db), AV_OPT_TYPE_DOUBLE, {.dbl=-351}, -451, -90, FLAGS },
311  { "type", "set type", OFFSET(type), AV_OPT_TYPE_INT, {.i64=DC_TYPE}, 0, NB_TYPES-1, FLAGS, "type" },
312  { "dc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=DC_TYPE}, 0, 0, FLAGS, "type"},
313  { "ac", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AC_TYPE}, 0, 0, FLAGS, "type"},
314  { "square",NULL, 0, AV_OPT_TYPE_CONST, {.i64=SQ_TYPE}, 0, 0, FLAGS, "type"},
315  { "pulse", NULL, 0, AV_OPT_TYPE_CONST, {.i64=PS_TYPE}, 0, 0, FLAGS, "type"},
316  { NULL }
317 };
318 
320 
322  .name = "adenorm",
323  .description = NULL_IF_CONFIG_SMALL("Remedy denormals by adding extremely low-level noise."),
324  .query_formats = query_formats,
325  .priv_size = sizeof(ADenormContext),
328  .priv_class = &adenorm_class,
332 };
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
static void sq_denorm_dblp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:143
static void sq_denorm_fltp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:129
static const AVOption adenorm_options[]
Definition: af_adenorm.c:309
static int query_formats(AVFilterContext *ctx)
Definition: af_adenorm.c:46
static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_adenorm.c:226
static void ac_denorm_dblp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:115
static void ps_denorm_fltp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:157
#define FLAGS
Definition: af_adenorm.c:307
static const AVFilterPad adenorm_inputs[]
Definition: af_adenorm.c:288
FilterType
Definition: af_adenorm.c:26
@ AC_TYPE
Definition: af_adenorm.c:28
@ PS_TYPE
Definition: af_adenorm.c:30
@ SQ_TYPE
Definition: af_adenorm.c:29
@ DC_TYPE
Definition: af_adenorm.c:27
@ NB_TYPES
Definition: af_adenorm.c:31
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_adenorm.c:244
static void dc_denorm_fltp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:75
AVFilter ff_af_adenorm
Definition: af_adenorm.c:321
static void dc_denorm_dblp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:88
static const AVFilterPad adenorm_outputs[]
Definition: af_adenorm.c:297
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_adenorm.c:275
static void ps_denorm_dblp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:171
AVFILTER_DEFINE_CLASS(adenorm)
#define OFFSET(x)
Definition: af_adenorm.c:306
static int config_output(AVFilterLink *outlink)
Definition: af_adenorm.c:185
static void ac_denorm_fltp(AVFilterContext *ctx, void *dstp, const void *srcp, int nb_samples)
Definition: af_adenorm.c:101
#define N
Definition: af_mcompand.c:54
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:882
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
Main libavfilter public API header.
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
audio channel layout utility functions
#define FFMIN(a, b)
Definition: common.h:105
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
int8_t exp
Definition: eval.c:72
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:436
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:587
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:575
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates.
Definition: formats.c:568
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:421
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:126
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
#define AVERROR(e)
Definition: error.h:43
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
cl_device_type type
const char * arg
Definition: jacosubdec.c:66
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define M_LN10
Definition: mathematics.h:43
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVOptions.
#define td
Definition: regdef.h:70
typedef void(RENAME(mix_any_func_type))
formats
Definition: signature.h:48
int64_t in_samples
Definition: af_adenorm.c:40
double level
Definition: af_adenorm.c:37
void(* filter)(AVFilterContext *ctx, void *dst, const void *src, int nb_samples)
Definition: af_adenorm.c:42
double level_db
Definition: af_adenorm.c:38
Describe the class of an AVClass context structure.
Definition: log.h:67
A list of supported channel layouts.
Definition: formats.h:86
An instance of a filter.
Definition: avfilter.h:341
A list of supported formats for one end of a filter link.
Definition: formats.h:65
A filter pad used for either input or output.
Definition: internal.h:54
const char * name
Pad name.
Definition: internal.h:60
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1699
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
AVOption.
Definition: opt.h:248
Used for passing data between threads.
Definition: dsddec.c:67
AVFrame * out
Definition: af_adeclick.c:502
AVFrame * in
Definition: af_adenorm.c:223
#define src
Definition: vp8dsp.c:255
FILE * out
Definition: movenc.c:54
AVFormatContext * ctx
Definition: movenc.c:48