FFmpeg  4.3
af_acrossover.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 /**
20  * @file
21  * Crossover filter
22  *
23  * Split an audio stream into several bands.
24  */
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/avstring.h"
29 #include "libavutil/eval.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/opt.h"
32 
33 #include "audio.h"
34 #include "avfilter.h"
35 #include "formats.h"
36 #include "internal.h"
37 
38 #define MAX_SPLITS 16
39 #define MAX_BANDS MAX_SPLITS + 1
40 
41 typedef struct BiquadContext {
42  double a0, a1, a2;
43  double b1, b2;
44  double i1, i2;
45  double o1, o2;
47 
48 typedef struct CrossoverChannel {
52 
53 typedef struct AudioCrossoverContext {
54  const AVClass *class;
55 
56  char *splits_str;
57  int order;
58 
60  int nb_splits;
61  float *splits;
62 
64 
68 
69 #define OFFSET(x) offsetof(AudioCrossoverContext, x)
70 #define AF AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
71 
72 static const AVOption acrossover_options[] = {
73  { "split", "set split frequencies", OFFSET(splits_str), AV_OPT_TYPE_STRING, {.str="500"}, 0, 0, AF },
74  { "order", "set order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=1}, 0, 2, AF, "m" },
75  { "2nd", "2nd order", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "m" },
76  { "4th", "4th order", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "m" },
77  { "8th", "8th order", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "m" },
78  { NULL }
79 };
80 
81 AVFILTER_DEFINE_CLASS(acrossover);
82 
84 {
86  char *p, *arg, *saveptr = NULL;
87  int i, ret = 0;
88 
89  s->splits = av_calloc(MAX_SPLITS, sizeof(*s->splits));
90  if (!s->splits)
91  return AVERROR(ENOMEM);
92 
93  p = s->splits_str;
94  for (i = 0; i < MAX_SPLITS; i++) {
95  float freq;
96 
97  if (!(arg = av_strtok(p, " |", &saveptr)))
98  break;
99 
100  p = NULL;
101 
102  if (av_sscanf(arg, "%f", &freq) != 1) {
103  av_log(ctx, AV_LOG_ERROR, "Invalid syntax for frequency[%d].\n", i);
104  return AVERROR(EINVAL);
105  }
106  if (freq <= 0) {
107  av_log(ctx, AV_LOG_ERROR, "Frequency %f must be positive number.\n", freq);
108  return AVERROR(EINVAL);
109  }
110 
111  if (i > 0 && freq <= s->splits[i-1]) {
112  av_log(ctx, AV_LOG_ERROR, "Frequency %f must be in increasing order.\n", freq);
113  return AVERROR(EINVAL);
114  }
115 
116  s->splits[i] = freq;
117  }
118 
119  s->nb_splits = i;
120 
121  for (i = 0; i <= s->nb_splits; i++) {
122  AVFilterPad pad = { 0 };
123  char *name;
124 
125  pad.type = AVMEDIA_TYPE_AUDIO;
126  name = av_asprintf("out%d", ctx->nb_outputs);
127  if (!name)
128  return AVERROR(ENOMEM);
129  pad.name = name;
130 
131  if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
132  av_freep(&pad.name);
133  return ret;
134  }
135  }
136 
137  return ret;
138 }
139 
140 static void set_lp(BiquadContext *b, double fc, double q, double sr)
141 {
142  double omega = 2.0 * M_PI * fc / sr;
143  double sn = sin(omega);
144  double cs = cos(omega);
145  double alpha = sn / (2. * q);
146  double inv = 1.0 / (1.0 + alpha);
147 
148  b->a0 = (1. - cs) * 0.5 * inv;
149  b->a1 = (1. - cs) * inv;
150  b->a2 = b->a0;
151  b->b1 = -2. * cs * inv;
152  b->b2 = (1. - alpha) * inv;
153 }
154 
155 static void set_hp(BiquadContext *b, double fc, double q, double sr)
156 {
157  double omega = 2 * M_PI * fc / sr;
158  double sn = sin(omega);
159  double cs = cos(omega);
160  double alpha = sn / (2 * q);
161  double inv = 1.0 / (1.0 + alpha);
162 
163  b->a0 = inv * (1. + cs) / 2.;
164  b->a1 = -2. * b->a0;
165  b->a2 = b->a0;
166  b->b1 = -2. * cs * inv;
167  b->b2 = (1. - alpha) * inv;
168 }
169 
170 static int config_input(AVFilterLink *inlink)
171 {
172  AVFilterContext *ctx = inlink->dst;
173  AudioCrossoverContext *s = ctx->priv;
174  int ch, band, sample_rate = inlink->sample_rate;
175  double q;
176 
177  s->xover = av_calloc(inlink->channels, sizeof(*s->xover));
178  if (!s->xover)
179  return AVERROR(ENOMEM);
180 
181  switch (s->order) {
182  case 0:
183  q = 0.5;
184  s->filter_count = 1;
185  break;
186  case 1:
187  q = M_SQRT1_2;
188  s->filter_count = 2;
189  break;
190  case 2:
191  q = 0.54;
192  s->filter_count = 4;
193  break;
194  }
195 
196  for (ch = 0; ch < inlink->channels; ch++) {
197  for (band = 0; band <= s->nb_splits; band++) {
198  set_lp(&s->xover[ch].lp[band][0], s->splits[band], q, sample_rate);
199  set_hp(&s->xover[ch].hp[band][0], s->splits[band], q, sample_rate);
200 
201  if (s->order > 1) {
202  set_lp(&s->xover[ch].lp[band][1], s->splits[band], 1.34, sample_rate);
203  set_hp(&s->xover[ch].hp[band][1], s->splits[band], 1.34, sample_rate);
204  set_lp(&s->xover[ch].lp[band][2], s->splits[band], q, sample_rate);
205  set_hp(&s->xover[ch].hp[band][2], s->splits[band], q, sample_rate);
206  set_lp(&s->xover[ch].lp[band][3], s->splits[band], 1.34, sample_rate);
207  set_hp(&s->xover[ch].hp[band][3], s->splits[band], 1.34, sample_rate);
208  } else {
209  set_lp(&s->xover[ch].lp[band][1], s->splits[band], q, sample_rate);
210  set_hp(&s->xover[ch].hp[band][1], s->splits[band], q, sample_rate);
211  }
212  }
213  }
214 
215  return 0;
216 }
217 
219 {
222  static const enum AVSampleFormat sample_fmts[] = {
225  };
226  int ret;
227 
228  layouts = ff_all_channel_counts();
229  if (!layouts)
230  return AVERROR(ENOMEM);
231  ret = ff_set_common_channel_layouts(ctx, layouts);
232  if (ret < 0)
233  return ret;
234 
235  formats = ff_make_format_list(sample_fmts);
236  if (!formats)
237  return AVERROR(ENOMEM);
238  ret = ff_set_common_formats(ctx, formats);
239  if (ret < 0)
240  return ret;
241 
242  formats = ff_all_samplerates();
243  if (!formats)
244  return AVERROR(ENOMEM);
245  return ff_set_common_samplerates(ctx, formats);
246 }
247 
248 static double biquad_process(BiquadContext *b, double in)
249 {
250  double out = in * b->a0 + b->i1 * b->a1 + b->i2 * b->a2 - b->o1 * b->b1 - b->o2 * b->b2;
251 
252  b->i2 = b->i1;
253  b->o2 = b->o1;
254  b->i1 = in;
255  b->o1 = out;
256 
257  return out;
258 }
259 
260 static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
261 {
262  AudioCrossoverContext *s = ctx->priv;
263  AVFrame *in = s->input_frame;
264  AVFrame **frames = s->frames;
265  const int start = (in->channels * jobnr) / nb_jobs;
266  const int end = (in->channels * (jobnr+1)) / nb_jobs;
267  int f, band;
268 
269  for (int ch = start; ch < end; ch++) {
270  const double *src = (const double *)in->extended_data[ch];
271  CrossoverChannel *xover = &s->xover[ch];
272 
273  for (int i = 0; i < in->nb_samples; i++) {
274  double sample = src[i], lo, hi;
275 
276  for (band = 0; band < ctx->nb_outputs; band++) {
277  double *dst = (double *)frames[band]->extended_data[ch];
278 
279  lo = sample;
280  hi = sample;
281  for (f = 0; band + 1 < ctx->nb_outputs && f < s->filter_count; f++) {
282  BiquadContext *lp = &xover->lp[band][f];
283  lo = biquad_process(lp, lo);
284  }
285 
286  for (f = 0; band + 1 < ctx->nb_outputs && f < s->filter_count; f++) {
287  BiquadContext *hp = &xover->hp[band][f];
288  hi = biquad_process(hp, hi);
289  }
290 
291  dst[i] = lo;
292 
293  sample = hi;
294  }
295  }
296  }
297 
298  return 0;
299 }
300 
301 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
302 {
303  AVFilterContext *ctx = inlink->dst;
304  AudioCrossoverContext *s = ctx->priv;
305  AVFrame **frames = s->frames;
306  int i, ret = 0;
307 
308  for (i = 0; i < ctx->nb_outputs; i++) {
309  frames[i] = ff_get_audio_buffer(ctx->outputs[i], in->nb_samples);
310 
311  if (!frames[i]) {
312  ret = AVERROR(ENOMEM);
313  break;
314  }
315 
316  frames[i]->pts = in->pts;
317  }
318 
319  if (ret < 0)
320  goto fail;
321 
322  s->input_frame = in;
323  ctx->internal->execute(ctx, filter_channels, NULL, NULL, FFMIN(inlink->channels,
325 
326  for (i = 0; i < ctx->nb_outputs; i++) {
327  ret = ff_filter_frame(ctx->outputs[i], frames[i]);
328  frames[i] = NULL;
329  if (ret < 0)
330  break;
331  }
332 
333 fail:
334  for (i = 0; i < ctx->nb_outputs; i++)
335  av_frame_free(&frames[i]);
336  av_frame_free(&in);
337  s->input_frame = NULL;
338 
339  return ret;
340 }
341 
343 {
344  AudioCrossoverContext *s = ctx->priv;
345  int i;
346 
347  av_freep(&s->splits);
348  av_freep(&s->xover);
349 
350  for (i = 0; i < ctx->nb_outputs; i++)
351  av_freep(&ctx->output_pads[i].name);
352 }
353 
354 static const AVFilterPad inputs[] = {
355  {
356  .name = "default",
357  .type = AVMEDIA_TYPE_AUDIO,
358  .filter_frame = filter_frame,
359  .config_props = config_input,
360  },
361  { NULL }
362 };
363 
365  .name = "acrossover",
366  .description = NULL_IF_CONFIG_SMALL("Split audio into per-bands streams."),
367  .priv_size = sizeof(AudioCrossoverContext),
368  .priv_class = &acrossover_class,
369  .init = init,
370  .uninit = uninit,
372  .inputs = inputs,
373  .outputs = NULL,
376 };
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:581
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
static av_cold int init(AVFilterContext *ctx)
Definition: af_acrossover.c:83
AVOption.
Definition: opt.h:246
AVFrame * frames[MAX_BANDS]
Definition: af_acrossover.c:66
static int config_input(AVFilterLink *inlink)
static const AVFilterPad inputs[]
Main libavfilter public API header.
#define M_SQRT1_2
Definition: mathematics.h:58
double, planar
Definition: samplefmt.h:70
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
#define sample
Macro definitions for various function/variable attributes.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:247
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
#define av_cold
Definition: attributes.h:88
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
BiquadContext lp[MAX_BANDS][4]
Definition: af_acrossover.c:49
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
#define src
Definition: vp8dsp.c:254
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:554
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:600
CrossoverChannel * xover
Definition: af_acrossover.c:63
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
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
unsigned nb_outputs
number of output pads
Definition: avfilter.h:351
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
const char * arg
Definition: jacosubdec.c:66
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
#define fail()
Definition: checkasm.h:123
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Definition: avsscanf.c:962
BiquadContext hp[MAX_BANDS][4]
Definition: af_acrossover.c:50
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
common internal API header
static double biquad_process(BiquadContext *b, double in)
const char * name
Definition: qsvenc.c:46
int channels
number of audio channels, only used for audio.
Definition: frame.h:606
audio channel layout utility functions
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:784
static void set_hp(BiquadContext *b, double fc, double q, double sr)
#define FFMIN(a, b)
Definition: common.h:96
static int query_formats(AVFilterContext *ctx)
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static void set_lp(BiquadContext *b, double fc, double q, double sr)
int frames
Definition: movenc.c:65
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:85
sample_rate
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVFILTER_DEFINE_CLASS(acrossover)
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)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
const char * name
Filter name.
Definition: avfilter.h:148
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:425
#define flags(name, subs,...)
Definition: cbs_av1.c:564
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
AVFilter ff_af_acrossover
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:184
static av_cold void uninit(AVFilterContext *ctx)
avfilter_execute_func * execute
Definition: internal.h:144
#define AF
Definition: af_acrossover.c:70
double b[3]
Definition: af_aiir.c:42
A list of supported formats for one end of a filter link.
Definition: formats.h:64
#define OFFSET(x)
Definition: af_acrossover.c:69
An instance of a filter.
Definition: avfilter.h:338
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:731
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
FILE * out
Definition: movenc.c:54
#define MAX_SPLITS
Definition: af_acrossover.c:38
#define av_freep(p)
#define M_PI
Definition: mathematics.h:52
formats
Definition: signature.h:48
internal API functions
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:440
static const AVOption acrossover_options[]
Definition: af_acrossover.c:72
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:274
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:366
for(j=16;j >0;--j)
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:588
simple arithmetic expression evaluator
#define MAX_BANDS
Definition: af_acrossover.c:39