FFmpeg
aeval.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * eval audio source
24  */
25 
26 #include "libavutil/avstring.h"
28 #include "libavutil/eval.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/parseutils.h"
31 #include "avfilter.h"
32 #include "audio.h"
33 #include "internal.h"
34 
35 static const char * const var_names[] = {
36  "ch", ///< the value of the current channel
37  "n", ///< number of frame
38  "nb_in_channels",
39  "nb_out_channels",
40  "t", ///< timestamp expressed in seconds
41  "s", ///< sample rate
42  NULL
43 };
44 
45 enum var_name {
53 };
54 
55 typedef struct EvalContext {
56  const AVClass *class;
59  int64_t chlayout;
60  char *chlayout_str;
61  int nb_channels; ///< number of output channels
62  int nb_in_channels; ///< number of input channels
63  int same_chlayout; ///< set output as input channel layout
64  int64_t pts;
66  char *exprs;
67  int nb_samples; ///< number of samples per requested frame
68  int64_t duration;
69  uint64_t n;
71  double *channel_values;
73 } EvalContext;
74 
75 static double val(void *priv, double ch)
76 {
77  EvalContext *eval = priv;
78  return eval->channel_values[FFMIN((int)ch, eval->nb_in_channels-1)];
79 }
80 
81 static double (* const aeval_func1[])(void *, double) = { val, NULL };
82 static const char * const aeval_func1_names[] = { "val", NULL };
83 
84 #define OFFSET(x) offsetof(EvalContext, x)
85 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
86 
87 static const AVOption aevalsrc_options[]= {
88  { "exprs", "set the '|'-separated list of channels expressions", OFFSET(exprs), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = FLAGS },
89  { "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 0, INT_MAX, FLAGS },
90  { "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 0, INT_MAX, FLAGS },
91  { "sample_rate", "set the sample rate", OFFSET(sample_rate_str), AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0, FLAGS },
92  { "s", "set the sample rate", OFFSET(sample_rate_str), AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0, FLAGS },
93  { "duration", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },
94  { "d", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },
95  { "channel_layout", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
96  { "c", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
97  { NULL }
98 };
99 
100 AVFILTER_DEFINE_CLASS(aevalsrc);
101 
103  int expected_nb_channels)
104 {
105  EvalContext *eval = ctx->priv;
106  char *args1 = av_strdup(eval->exprs);
107  char *expr, *last_expr = NULL, *buf;
108  double (* const *func1)(void *, double) = NULL;
109  const char * const *func1_names = NULL;
110  int i, ret = 0;
111 
112  if (!args1)
113  return AVERROR(ENOMEM);
114 
115  if (!eval->exprs) {
116  av_log(ctx, AV_LOG_ERROR, "Channels expressions list is empty\n");
117  return AVERROR(EINVAL);
118  }
119 
120  if (!strcmp(ctx->filter->name, "aeval")) {
121  func1 = aeval_func1;
123  }
124 
125 #define ADD_EXPRESSION(expr_) do { \
126  if (!av_dynarray2_add((void **)&eval->expr, &eval->nb_channels, \
127  sizeof(*eval->expr), NULL)) { \
128  ret = AVERROR(ENOMEM); \
129  goto end; \
130  } \
131  eval->expr[eval->nb_channels-1] = NULL; \
132  ret = av_expr_parse(&eval->expr[eval->nb_channels - 1], expr_, \
133  var_names, func1_names, func1, \
134  NULL, NULL, 0, ctx); \
135  if (ret < 0) \
136  goto end; \
137  } while (0)
138 
139  /* reset expressions */
140  for (i = 0; i < eval->nb_channels; i++) {
141  av_expr_free(eval->expr[i]);
142  eval->expr[i] = NULL;
143  }
144  av_freep(&eval->expr);
145  eval->nb_channels = 0;
146 
147  buf = args1;
148  while (expr = av_strtok(buf, "|", &buf)) {
149  ADD_EXPRESSION(expr);
150  last_expr = expr;
151  }
152 
153  if (expected_nb_channels > eval->nb_channels)
154  for (i = eval->nb_channels; i < expected_nb_channels; i++)
155  ADD_EXPRESSION(last_expr);
156 
157  if (expected_nb_channels > 0 && eval->nb_channels != expected_nb_channels) {
159  "Mismatch between the specified number of channel expressions '%d' "
160  "and the number of expected output channels '%d' for the specified channel layout\n",
161  eval->nb_channels, expected_nb_channels);
162  ret = AVERROR(EINVAL);
163  goto end;
164  }
165 
166 end:
167  av_free(args1);
168  return ret;
169 }
170 
172 {
173  EvalContext *eval = ctx->priv;
174  int ret = 0;
175 
176  if (eval->chlayout_str) {
177  if (!strcmp(eval->chlayout_str, "same") && !strcmp(ctx->filter->name, "aeval")) {
178  eval->same_chlayout = 1;
179  } else {
181  if (ret < 0)
182  return ret;
183 
185  if (ret < 0)
186  return ret;
187  }
188  } else {
189  /* guess channel layout from nb expressions/channels */
190  if ((ret = parse_channel_expressions(ctx, -1)) < 0)
191  return ret;
192 
194  if (!eval->chlayout && eval->nb_channels <= 0) {
195  av_log(ctx, AV_LOG_ERROR, "Invalid number of channels '%d' provided\n",
196  eval->nb_channels);
197  return AVERROR(EINVAL);
198  }
199  }
200 
201  if (eval->sample_rate_str)
202  if ((ret = ff_parse_sample_rate(&eval->sample_rate, eval->sample_rate_str, ctx)))
203  return ret;
204  eval->n = 0;
205 
206  return ret;
207 }
208 
210 {
211  EvalContext *eval = ctx->priv;
212  int i;
213 
214  for (i = 0; i < eval->nb_channels; i++) {
215  av_expr_free(eval->expr[i]);
216  eval->expr[i] = NULL;
217  }
218  av_freep(&eval->expr);
219  av_freep(&eval->channel_values);
220 }
221 
222 static int config_props(AVFilterLink *outlink)
223 {
224  EvalContext *eval = outlink->src->priv;
225  char buf[128];
226 
227  outlink->time_base = (AVRational){1, eval->sample_rate};
228  outlink->sample_rate = eval->sample_rate;
229 
230  eval->var_values[VAR_S] = eval->sample_rate;
232  eval->var_values[VAR_NB_OUT_CHANNELS] = outlink->channels;
233 
234  av_get_channel_layout_string(buf, sizeof(buf), 0, eval->chlayout);
235 
236  av_log(outlink->src, AV_LOG_VERBOSE,
237  "sample_rate:%d chlayout:%s duration:%"PRId64"\n",
238  eval->sample_rate, buf, eval->duration);
239 
240  return 0;
241 }
242 
244 {
245  EvalContext *eval = ctx->priv;
247  int64_t chlayouts[] = { eval->chlayout ? eval->chlayout : FF_COUNT2LAYOUT(eval->nb_channels) , -1 };
248  int sample_rates[] = { eval->sample_rate, -1 };
251  int ret;
252 
254  if (!formats)
255  return AVERROR(ENOMEM);
257  if (ret < 0)
258  return ret;
259 
260  layouts = ff_make_format64_list(chlayouts);
261  if (!layouts)
262  return AVERROR(ENOMEM);
264  if (ret < 0)
265  return ret;
266 
268  if (!formats)
269  return AVERROR(ENOMEM);
271 }
272 
273 static int request_frame(AVFilterLink *outlink)
274 {
275  EvalContext *eval = outlink->src->priv;
276  AVFrame *samplesref;
277  int i, j;
278  int64_t t = av_rescale(eval->n, AV_TIME_BASE, eval->sample_rate);
279  int nb_samples;
280 
281  if (eval->duration >= 0 && t >= eval->duration)
282  return AVERROR_EOF;
283 
284  if (eval->duration >= 0) {
285  nb_samples = FFMIN(eval->nb_samples, av_rescale(eval->duration, eval->sample_rate, AV_TIME_BASE) - eval->pts);
286  if (!nb_samples)
287  return AVERROR_EOF;
288  } else {
289  nb_samples = eval->nb_samples;
290  }
291  samplesref = ff_get_audio_buffer(outlink, nb_samples);
292  if (!samplesref)
293  return AVERROR(ENOMEM);
294 
295  /* evaluate expression for each single sample and for each channel */
296  for (i = 0; i < nb_samples; i++, eval->n++) {
297  eval->var_values[VAR_N] = eval->n;
298  eval->var_values[VAR_T] = eval->var_values[VAR_N] * (double)1/eval->sample_rate;
299 
300  for (j = 0; j < eval->nb_channels; j++) {
301  *((double *) samplesref->extended_data[j] + i) =
302  av_expr_eval(eval->expr[j], eval->var_values, NULL);
303  }
304  }
305 
306  samplesref->pts = eval->pts;
307  samplesref->sample_rate = eval->sample_rate;
308  eval->pts += nb_samples;
309 
310  return ff_filter_frame(outlink, samplesref);
311 }
312 
313 #if CONFIG_AEVALSRC_FILTER
314 static const AVFilterPad aevalsrc_outputs[] = {
315  {
316  .name = "default",
317  .type = AVMEDIA_TYPE_AUDIO,
318  .config_props = config_props,
319  .request_frame = request_frame,
320  },
321  { NULL }
322 };
323 
324 const AVFilter ff_asrc_aevalsrc = {
325  .name = "aevalsrc",
326  .description = NULL_IF_CONFIG_SMALL("Generate an audio signal generated by an expression."),
327  .query_formats = query_formats,
328  .init = init,
329  .uninit = uninit,
330  .priv_size = sizeof(EvalContext),
331  .inputs = NULL,
332  .outputs = aevalsrc_outputs,
333  .priv_class = &aevalsrc_class,
334 };
335 
336 #endif /* CONFIG_AEVALSRC_FILTER */
337 
338 #define OFFSET(x) offsetof(EvalContext, x)
339 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
340 
341 static const AVOption aeval_options[]= {
342  { "exprs", "set the '|'-separated list of channels expressions", OFFSET(exprs), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = FLAGS },
343  { "channel_layout", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
344  { "c", "set channel layout", OFFSET(chlayout_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
345  { NULL }
346 };
347 
348 AVFILTER_DEFINE_CLASS(aeval);
349 
351 {
354  AVFilterLink *inlink = ctx->inputs[0];
355  AVFilterLink *outlink = ctx->outputs[0];
356  EvalContext *eval = ctx->priv;
357  static const enum AVSampleFormat sample_fmts[] = {
359  };
360  int ret;
361 
362  // inlink supports any channel layout
364  if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
365  return ret;
366 
367  if (eval->same_chlayout) {
370  return ret;
371  } else {
372  // outlink supports only requested output channel layout
373  layouts = NULL;
375  eval->out_channel_layout ? eval->out_channel_layout :
376  FF_COUNT2LAYOUT(eval->nb_channels))) < 0)
377  return ret;
378  if ((ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
379  return ret;
380  }
381 
383  if ((ret = ff_set_common_formats(ctx, formats)) < 0)
384  return ret;
385 
388 }
389 
390 static int aeval_config_output(AVFilterLink *outlink)
391 {
392  AVFilterContext *ctx = outlink->src;
393  EvalContext *eval = ctx->priv;
394  AVFilterLink *inlink = ctx->inputs[0];
395  int ret;
396 
397  if (eval->same_chlayout) {
398  eval->chlayout = inlink->channel_layout;
399 
400  if ((ret = parse_channel_expressions(ctx, inlink->channels)) < 0)
401  return ret;
402  }
403 
404  eval->n = 0;
405  eval->nb_in_channels = eval->var_values[VAR_NB_IN_CHANNELS] = inlink->channels;
406  eval->var_values[VAR_NB_OUT_CHANNELS] = outlink->channels;
407  eval->var_values[VAR_S] = inlink->sample_rate;
408  eval->var_values[VAR_T] = NAN;
409 
411  inlink->channels, sizeof(*eval->channel_values));
412  if (!eval->channel_values)
413  return AVERROR(ENOMEM);
414 
415  return 0;
416 }
417 
419 {
420  EvalContext *eval = inlink->dst->priv;
421  AVFilterLink *outlink = inlink->dst->outputs[0];
422  int nb_samples = in->nb_samples;
423  AVFrame *out;
424  double t0;
425  int i, j;
426 
427  out = ff_get_audio_buffer(outlink, nb_samples);
428  if (!out) {
429  av_frame_free(&in);
430  return AVERROR(ENOMEM);
431  }
433 
434  t0 = TS2T(in->pts, inlink->time_base);
435 
436  /* evaluate expression for each single sample and for each channel */
437  for (i = 0; i < nb_samples; i++, eval->n++) {
438  eval->var_values[VAR_N] = eval->n;
439  eval->var_values[VAR_T] = t0 + i * (double)1/inlink->sample_rate;
440 
441  for (j = 0; j < inlink->channels; j++)
442  eval->channel_values[j] = *((double *) in->extended_data[j] + i);
443 
444  for (j = 0; j < outlink->channels; j++) {
445  eval->var_values[VAR_CH] = j;
446  *((double *) out->extended_data[j] + i) =
447  av_expr_eval(eval->expr[j], eval->var_values, eval);
448  }
449  }
450 
451  av_frame_free(&in);
452  return ff_filter_frame(outlink, out);
453 }
454 
455 #if CONFIG_AEVAL_FILTER
456 
457 static const AVFilterPad aeval_inputs[] = {
458  {
459  .name = "default",
460  .type = AVMEDIA_TYPE_AUDIO,
461  .filter_frame = filter_frame,
462  },
463  { NULL }
464 };
465 
466 static const AVFilterPad aeval_outputs[] = {
467  {
468  .name = "default",
469  .type = AVMEDIA_TYPE_AUDIO,
470  .config_props = aeval_config_output,
471  },
472  { NULL }
473 };
474 
475 const AVFilter ff_af_aeval = {
476  .name = "aeval",
477  .description = NULL_IF_CONFIG_SMALL("Filter audio signal according to a specified expression."),
478  .query_formats = aeval_query_formats,
479  .init = init,
480  .uninit = uninit,
481  .priv_size = sizeof(EvalContext),
482  .inputs = aeval_inputs,
483  .outputs = aeval_outputs,
484  .priv_class = &aeval_class,
486 };
487 
488 #endif /* CONFIG_AEVAL_FILTER */
EvalContext::expr
AVExpr ** expr
Definition: aeval.c:65
formats
formats
Definition: signature.h:48
EvalContext::out_channel_layout
int64_t out_channel_layout
Definition: aeval.c:72
ff_get_audio_buffer
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
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:447
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:454
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
EvalContext::duration
int64_t duration
Definition: aeval.c:68
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:429
init
static av_cold int init(AVFilterContext *ctx)
Definition: aeval.c:171
aeval_query_formats
static int aeval_query_formats(AVFilterContext *ctx)
Definition: aeval.c:350
av_get_channel_layout_string
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
Definition: channel_layout.c:217
ff_make_format64_list
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:295
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:396
ADD_EXPRESSION
#define ADD_EXPRESSION(expr_)
AVOption
AVOption.
Definition: opt.h:247
t0
#define t0
Definition: regdef.h:28
FLAGS
#define FLAGS
Definition: aeval.c:339
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:238
aeval_func1_names
static const char *const aeval_func1_names[]
Definition: aeval.c:82
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
config_props
static int config_props(AVFilterLink *outlink)
Definition: aeval.c:222
EvalContext::exprs
char * exprs
Definition: aeval.c:66
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: aeval.c:209
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
VAR_T
@ VAR_T
Definition: aeval.c:50
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:348
EvalContext::same_chlayout
int same_chlayout
set output as input channel layout
Definition: aeval.c:63
val
static double val(void *priv, double ch)
Definition: aeval.c:75
func1_names
static const char *const func1_names[]
Definition: vf_rotate.c:196
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
EvalContext::var_values
double var_values[VAR_VARS_NB]
Definition: aeval.c:70
TS2T
#define TS2T(ts, tb)
Definition: internal.h:209
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
ff_set_common_formats
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:580
duration
int64_t duration
Definition: movenc.c:64
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:331
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:186
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
var_name
var_name
Definition: noise_bsf.c:47
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:766
AVExpr
Definition: eval.c:157
NAN
#define NAN
Definition: mathematics.h:64
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
aevalsrc_options
static const AVOption aevalsrc_options[]
Definition: aeval.c:87
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:537
aeval_config_output
static int aeval_config_output(AVFilterLink *outlink)
Definition: aeval.c:390
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_af_aeval
const AVFilter ff_af_aeval
parseutils.h
VAR_CH
@ VAR_CH
Definition: aeval.c:46
EvalContext
Definition: aeval.c:55
EvalContext::nb_in_channels
int nb_in_channels
number of input channels
Definition: aeval.c:62
OFFSET
#define OFFSET(x)
Definition: aeval.c:338
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
eval.h
aeval_options
static const AVOption aeval_options[]
Definition: aeval.c:341
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
ff_parse_channel_layout
int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:637
EvalContext::pts
int64_t pts
Definition: aeval.c:64
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:458
EvalContext::chlayout
int64_t chlayout
Definition: aeval.c:59
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
EvalContext::nb_channels
int nb_channels
number of output channels
Definition: aeval.c:61
VAR_VARS_NB
@ VAR_VARS_NB
Definition: aeval.c:52
aeval_func1
static double(*const aeval_func1[])(void *, double)
Definition: aeval.c:81
VAR_NB_IN_CHANNELS
@ VAR_NB_IN_CHANNELS
Definition: aeval.c:48
sample_rates
sample_rates
Definition: ffmpeg_filter.c:156
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#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
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:369
i
int i
Definition: input.c:406
func1
static double(*const func1[])(void *, double)
Definition: vf_rotate.c:190
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:350
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:128
AVFilter
Filter definition.
Definition: avfilter.h:145
EvalContext::sample_rate_str
char * sample_rate_str
Definition: aeval.c:57
ret
ret
Definition: filter_design.txt:187
EvalContext::chlayout_str
char * chlayout_str
Definition: aeval.c:60
FF_COUNT2LAYOUT
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition: formats.h:102
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(aevalsrc)
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:414
var_names
static const char *const var_names[]
Definition: aeval.c:35
channel_layout.h
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: aeval.c:418
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
VAR_NB_OUT_CHANNELS
@ VAR_NB_OUT_CHANNELS
Definition: aeval.c:49
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
VAR_N
@ VAR_N
Definition: aeval.c:47
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:259
parse_channel_expressions
static int parse_channel_expressions(AVFilterContext *ctx, int expected_nb_channels)
Definition: aeval.c:102
audio.h
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
EvalContext::n
uint64_t n
Definition: aeval.c:69
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:243
ff_parse_sample_rate
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:625
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:568
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
EvalContext::sample_rate
int sample_rate
Definition: aeval.c:58
ff_asrc_aevalsrc
const AVFilter ff_asrc_aevalsrc
VAR_S
@ VAR_S
Definition: aeval.c:51
EvalContext::channel_values
double * channel_values
Definition: aeval.c:71
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: aeval.c:273
ff_set_common_channel_layouts
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:561
EvalContext::nb_samples
int nb_samples
number of samples per requested frame
Definition: aeval.c:67