FFmpeg  4.3.9
af_afir.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 Paul B Mahol
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  * An arbitrary audio FIR filter
24  */
25 
26 #include <float.h>
27 
28 #include "libavutil/avstring.h"
29 #include "libavutil/common.h"
30 #include "libavutil/float_dsp.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/opt.h"
34 #include "libavcodec/avfft.h"
35 
36 #include "audio.h"
37 #include "avfilter.h"
38 #include "filters.h"
39 #include "formats.h"
40 #include "internal.h"
41 #include "af_afir.h"
42 
43 static void fcmul_add_c(float *sum, const float *t, const float *c, ptrdiff_t len)
44 {
45  int n;
46 
47  for (n = 0; n < len; n++) {
48  const float cre = c[2 * n ];
49  const float cim = c[2 * n + 1];
50  const float tre = t[2 * n ];
51  const float tim = t[2 * n + 1];
52 
53  sum[2 * n ] += tre * cre - tim * cim;
54  sum[2 * n + 1] += tre * cim + tim * cre;
55  }
56 
57  sum[2 * n] += t[2 * n] * c[2 * n];
58 }
59 
60 static void direct(const float *in, const FFTComplex *ir, int len, float *out)
61 {
62  for (int n = 0; n < len; n++)
63  for (int m = 0; m <= n; m++)
64  out[n] += ir[m].re * in[n - m];
65 }
66 
67 static int fir_quantum(AVFilterContext *ctx, AVFrame *out, int ch, int offset)
68 {
69  AudioFIRContext *s = ctx->priv;
70  const float *in = (const float *)s->in->extended_data[ch] + offset;
71  float *block, *buf, *ptr = (float *)out->extended_data[ch] + offset;
72  const int nb_samples = FFMIN(s->min_part_size, out->nb_samples - offset);
73  int n, i, j;
74 
75  for (int segment = 0; segment < s->nb_segments; segment++) {
76  AudioFIRSegment *seg = &s->seg[segment];
77  float *src = (float *)seg->input->extended_data[ch];
78  float *dst = (float *)seg->output->extended_data[ch];
79  float *sum = (float *)seg->sum->extended_data[ch];
80 
81  if (s->min_part_size >= 8) {
82  s->fdsp->vector_fmul_scalar(src + seg->input_offset, in, s->dry_gain, FFALIGN(nb_samples, 4));
83  emms_c();
84  } else {
85  for (n = 0; n < nb_samples; n++)
86  src[seg->input_offset + n] = in[n] * s->dry_gain;
87  }
88 
89  seg->output_offset[ch] += s->min_part_size;
90  if (seg->output_offset[ch] == seg->part_size) {
91  seg->output_offset[ch] = 0;
92  } else {
93  memmove(src, src + s->min_part_size, (seg->input_size - s->min_part_size) * sizeof(*src));
94 
95  dst += seg->output_offset[ch];
96  for (n = 0; n < nb_samples; n++) {
97  ptr[n] += dst[n];
98  }
99  continue;
100  }
101 
102  if (seg->part_size < 8) {
103  memset(dst, 0, sizeof(*dst) * seg->part_size * seg->nb_partitions);
104 
105  j = seg->part_index[ch];
106 
107  for (i = 0; i < seg->nb_partitions; i++) {
108  const int coffset = j * seg->coeff_size;
109  const FFTComplex *coeff = (const FFTComplex *)seg->coeff->extended_data[ch * !s->one2many] + coffset;
110 
111  direct(src, coeff, nb_samples, dst);
112 
113  if (j == 0)
114  j = seg->nb_partitions;
115  j--;
116  }
117 
118  seg->part_index[ch] = (seg->part_index[ch] + 1) % seg->nb_partitions;
119 
120  memmove(src, src + s->min_part_size, (seg->input_size - s->min_part_size) * sizeof(*src));
121 
122  for (n = 0; n < nb_samples; n++) {
123  ptr[n] += dst[n];
124  }
125  continue;
126  }
127 
128  memset(sum, 0, sizeof(*sum) * seg->fft_length);
129  block = (float *)seg->block->extended_data[ch] + seg->part_index[ch] * seg->block_size;
130  memset(block + seg->part_size, 0, sizeof(*block) * (seg->fft_length - seg->part_size));
131 
132  memcpy(block, src, sizeof(*src) * seg->part_size);
133 
134  av_rdft_calc(seg->rdft[ch], block);
135  block[2 * seg->part_size] = block[1];
136  block[1] = 0;
137 
138  j = seg->part_index[ch];
139 
140  for (i = 0; i < seg->nb_partitions; i++) {
141  const int coffset = j * seg->coeff_size;
142  const float *block = (const float *)seg->block->extended_data[ch] + i * seg->block_size;
143  const FFTComplex *coeff = (const FFTComplex *)seg->coeff->extended_data[ch * !s->one2many] + coffset;
144 
145  s->afirdsp.fcmul_add(sum, block, (const float *)coeff, seg->part_size);
146 
147  if (j == 0)
148  j = seg->nb_partitions;
149  j--;
150  }
151 
152  sum[1] = sum[2 * seg->part_size];
153  av_rdft_calc(seg->irdft[ch], sum);
154 
155  buf = (float *)seg->buffer->extended_data[ch];
156  for (n = 0; n < seg->part_size; n++) {
157  buf[n] += sum[n];
158  }
159 
160  memcpy(dst, buf, seg->part_size * sizeof(*dst));
161 
162  buf = (float *)seg->buffer->extended_data[ch];
163  memcpy(buf, sum + seg->part_size, seg->part_size * sizeof(*buf));
164 
165  seg->part_index[ch] = (seg->part_index[ch] + 1) % seg->nb_partitions;
166 
167  memmove(src, src + s->min_part_size, (seg->input_size - s->min_part_size) * sizeof(*src));
168 
169  for (n = 0; n < nb_samples; n++) {
170  ptr[n] += dst[n];
171  }
172  }
173 
174  if (s->min_part_size >= 8) {
175  s->fdsp->vector_fmul_scalar(ptr, ptr, s->wet_gain, FFALIGN(nb_samples, 4));
176  emms_c();
177  } else {
178  for (n = 0; n < nb_samples; n++)
179  ptr[n] *= s->wet_gain;
180  }
181 
182  return 0;
183 }
184 
185 static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
186 {
187  AudioFIRContext *s = ctx->priv;
188 
189  for (int offset = 0; offset < out->nb_samples; offset += s->min_part_size) {
190  fir_quantum(ctx, out, ch, offset);
191  }
192 
193  return 0;
194 }
195 
196 static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
197 {
198  AVFrame *out = arg;
199  const int start = (out->channels * jobnr) / nb_jobs;
200  const int end = (out->channels * (jobnr+1)) / nb_jobs;
201 
202  for (int ch = start; ch < end; ch++) {
203  fir_channel(ctx, out, ch);
204  }
205 
206  return 0;
207 }
208 
210 {
211  AVFilterContext *ctx = outlink->src;
212  AVFrame *out = NULL;
213 
214  out = ff_get_audio_buffer(outlink, in->nb_samples);
215  if (!out) {
216  av_frame_free(&in);
217  return AVERROR(ENOMEM);
218  }
219 
220  if (s->pts == AV_NOPTS_VALUE)
221  s->pts = in->pts;
222  s->in = in;
223  ctx->internal->execute(ctx, fir_channels, out, NULL, FFMIN(outlink->channels,
225 
226  out->pts = s->pts;
227  if (s->pts != AV_NOPTS_VALUE)
228  s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
229 
230  av_frame_free(&in);
231  s->in = NULL;
232 
233  return ff_filter_frame(outlink, out);
234 }
235 
236 static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
237 {
238  const uint8_t *font;
239  int font_height;
240  int i;
241 
242  font = avpriv_cga_font, font_height = 8;
243 
244  for (i = 0; txt[i]; i++) {
245  int char_y, mask;
246 
247  uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
248  for (char_y = 0; char_y < font_height; char_y++) {
249  for (mask = 0x80; mask; mask >>= 1) {
250  if (font[txt[i] * font_height + char_y] & mask)
251  AV_WL32(p, color);
252  p += 4;
253  }
254  p += pic->linesize[0] - 8 * 4;
255  }
256  }
257 }
258 
259 static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
260 {
261  int dx = FFABS(x1-x0);
262  int dy = FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
263  int err = (dx>dy ? dx : -dy) / 2, e2;
264 
265  for (;;) {
266  AV_WL32(out->data[0] + y0 * out->linesize[0] + x0 * 4, color);
267 
268  if (x0 == x1 && y0 == y1)
269  break;
270 
271  e2 = err;
272 
273  if (e2 >-dx) {
274  err -= dy;
275  x0--;
276  }
277 
278  if (e2 < dy) {
279  err += dx;
280  y0 += sy;
281  }
282  }
283 }
284 
286 {
287  AudioFIRContext *s = ctx->priv;
288  float *mag, *phase, *delay, min = FLT_MAX, max = FLT_MIN;
289  float min_delay = FLT_MAX, max_delay = FLT_MIN;
290  int prev_ymag = -1, prev_yphase = -1, prev_ydelay = -1;
291  char text[32];
292  int channel, i, x;
293 
294  memset(out->data[0], 0, s->h * out->linesize[0]);
295 
296  phase = av_malloc_array(s->w, sizeof(*phase));
297  mag = av_malloc_array(s->w, sizeof(*mag));
298  delay = av_malloc_array(s->w, sizeof(*delay));
299  if (!mag || !phase || !delay)
300  goto end;
301 
302  channel = av_clip(s->ir_channel, 0, s->ir[s->selir]->channels - 1);
303  for (i = 0; i < s->w; i++) {
304  const float *src = (const float *)s->ir[s->selir]->extended_data[channel];
305  double w = i * M_PI / (s->w - 1);
306  double div, real_num = 0., imag_num = 0., real = 0., imag = 0.;
307 
308  for (x = 0; x < s->nb_taps; x++) {
309  real += cos(-x * w) * src[x];
310  imag += sin(-x * w) * src[x];
311  real_num += cos(-x * w) * src[x] * x;
312  imag_num += sin(-x * w) * src[x] * x;
313  }
314 
315  mag[i] = hypot(real, imag);
316  phase[i] = atan2(imag, real);
317  div = real * real + imag * imag;
318  delay[i] = (real_num * real + imag_num * imag) / div;
319  min = fminf(min, mag[i]);
320  max = fmaxf(max, mag[i]);
321  min_delay = fminf(min_delay, delay[i]);
322  max_delay = fmaxf(max_delay, delay[i]);
323  }
324 
325  for (i = 0; i < s->w; i++) {
326  int ymag = mag[i] / max * (s->h - 1);
327  int ydelay = (delay[i] - min_delay) / (max_delay - min_delay) * (s->h - 1);
328  int yphase = (0.5 * (1. + phase[i] / M_PI)) * (s->h - 1);
329 
330  ymag = s->h - 1 - av_clip(ymag, 0, s->h - 1);
331  yphase = s->h - 1 - av_clip(yphase, 0, s->h - 1);
332  ydelay = s->h - 1 - av_clip(ydelay, 0, s->h - 1);
333 
334  if (prev_ymag < 0)
335  prev_ymag = ymag;
336  if (prev_yphase < 0)
337  prev_yphase = yphase;
338  if (prev_ydelay < 0)
339  prev_ydelay = ydelay;
340 
341  draw_line(out, i, ymag, FFMAX(i - 1, 0), prev_ymag, 0xFFFF00FF);
342  draw_line(out, i, yphase, FFMAX(i - 1, 0), prev_yphase, 0xFF00FF00);
343  draw_line(out, i, ydelay, FFMAX(i - 1, 0), prev_ydelay, 0xFF00FFFF);
344 
345  prev_ymag = ymag;
346  prev_yphase = yphase;
347  prev_ydelay = ydelay;
348  }
349 
350  if (s->w > 400 && s->h > 100) {
351  drawtext(out, 2, 2, "Max Magnitude:", 0xDDDDDDDD);
352  snprintf(text, sizeof(text), "%.2f", max);
353  drawtext(out, 15 * 8 + 2, 2, text, 0xDDDDDDDD);
354 
355  drawtext(out, 2, 12, "Min Magnitude:", 0xDDDDDDDD);
356  snprintf(text, sizeof(text), "%.2f", min);
357  drawtext(out, 15 * 8 + 2, 12, text, 0xDDDDDDDD);
358 
359  drawtext(out, 2, 22, "Max Delay:", 0xDDDDDDDD);
360  snprintf(text, sizeof(text), "%.2f", max_delay);
361  drawtext(out, 11 * 8 + 2, 22, text, 0xDDDDDDDD);
362 
363  drawtext(out, 2, 32, "Min Delay:", 0xDDDDDDDD);
364  snprintf(text, sizeof(text), "%.2f", min_delay);
365  drawtext(out, 11 * 8 + 2, 32, text, 0xDDDDDDDD);
366  }
367 
368 end:
369  av_free(delay);
370  av_free(phase);
371  av_free(mag);
372 }
373 
375  int offset, int nb_partitions, int part_size)
376 {
377  AudioFIRContext *s = ctx->priv;
378 
379  seg->rdft = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->rdft));
380  seg->irdft = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->irdft));
381  if (!seg->rdft || !seg->irdft)
382  return AVERROR(ENOMEM);
383 
384  seg->fft_length = part_size * 2 + 1;
385  seg->part_size = part_size;
386  seg->block_size = FFALIGN(seg->fft_length, 32);
387  seg->coeff_size = FFALIGN(seg->part_size + 1, 32);
388  seg->nb_partitions = nb_partitions;
389  seg->input_size = offset + s->min_part_size;
390  seg->input_offset = offset;
391 
392  seg->part_index = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->part_index));
393  seg->output_offset = av_calloc(ctx->inputs[0]->channels, sizeof(*seg->output_offset));
394  if (!seg->part_index || !seg->output_offset)
395  return AVERROR(ENOMEM);
396 
397  for (int ch = 0; ch < ctx->inputs[0]->channels && part_size >= 8; ch++) {
398  seg->rdft[ch] = av_rdft_init(av_log2(2 * part_size), DFT_R2C);
399  seg->irdft[ch] = av_rdft_init(av_log2(2 * part_size), IDFT_C2R);
400  if (!seg->rdft[ch] || !seg->irdft[ch])
401  return AVERROR(ENOMEM);
402  }
403 
404  seg->sum = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
405  seg->block = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->block_size);
406  seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
407  seg->coeff = ff_get_audio_buffer(ctx->inputs[1 + s->selir], seg->nb_partitions * seg->coeff_size * 2);
408  seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
409  seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
410  if (!seg->buffer || !seg->sum || !seg->block || !seg->coeff || !seg->input || !seg->output)
411  return AVERROR(ENOMEM);
412 
413  return 0;
414 }
415 
417 {
418  AudioFIRContext *s = ctx->priv;
419 
420  if (seg->rdft) {
421  for (int ch = 0; ch < s->nb_channels; ch++) {
422  av_rdft_end(seg->rdft[ch]);
423  }
424  }
425  av_freep(&seg->rdft);
426 
427  if (seg->irdft) {
428  for (int ch = 0; ch < s->nb_channels; ch++) {
429  av_rdft_end(seg->irdft[ch]);
430  }
431  }
432  av_freep(&seg->irdft);
433 
434  av_freep(&seg->output_offset);
435  av_freep(&seg->part_index);
436 
437  av_frame_free(&seg->block);
438  av_frame_free(&seg->sum);
439  av_frame_free(&seg->buffer);
440  av_frame_free(&seg->coeff);
441  av_frame_free(&seg->input);
442  av_frame_free(&seg->output);
443  seg->input_size = 0;
444 }
445 
447 {
448  AudioFIRContext *s = ctx->priv;
449  int ret, i, ch, n, cur_nb_taps;
450  float power = 0;
451 
452  if (!s->nb_taps) {
453  int part_size, max_part_size;
454  int left, offset = 0;
455 
456  s->nb_taps = ff_inlink_queued_samples(ctx->inputs[1 + s->selir]);
457  if (s->nb_taps <= 0)
458  return AVERROR(EINVAL);
459 
460  if (s->minp > s->maxp) {
461  s->maxp = s->minp;
462  }
463 
464  left = s->nb_taps;
465  part_size = 1 << av_log2(s->minp);
466  max_part_size = 1 << av_log2(s->maxp);
467 
468  s->min_part_size = part_size;
469 
470  for (i = 0; left > 0; i++) {
471  int step = part_size == max_part_size ? INT_MAX : 1 + (i == 0);
472  int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
473 
474  s->nb_segments = i + 1;
475  ret = init_segment(ctx, &s->seg[i], offset, nb_partitions, part_size);
476  if (ret < 0)
477  return ret;
478  offset += nb_partitions * part_size;
479  left -= nb_partitions * part_size;
480  part_size *= 2;
481  part_size = FFMIN(part_size, max_part_size);
482  }
483  }
484 
485  if (!s->ir[s->selir]) {
486  ret = ff_inlink_consume_samples(ctx->inputs[1 + s->selir], s->nb_taps, s->nb_taps, &s->ir[s->selir]);
487  if (ret < 0)
488  return ret;
489  if (ret == 0)
490  return AVERROR_BUG;
491  }
492 
493  if (s->response)
494  draw_response(ctx, s->video);
495 
496  s->gain = 1;
497  cur_nb_taps = s->ir[s->selir]->nb_samples;
498 
499  switch (s->gtype) {
500  case -1:
501  /* nothing to do */
502  break;
503  case 0:
504  for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
505  float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
506 
507  for (i = 0; i < cur_nb_taps; i++)
508  power += FFABS(time[i]);
509  }
510  s->gain = ctx->inputs[1 + s->selir]->channels / power;
511  break;
512  case 1:
513  for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
514  float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
515 
516  for (i = 0; i < cur_nb_taps; i++)
517  power += time[i];
518  }
519  s->gain = ctx->inputs[1 + s->selir]->channels / power;
520  break;
521  case 2:
522  for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
523  float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
524 
525  for (i = 0; i < cur_nb_taps; i++)
526  power += time[i] * time[i];
527  }
528  s->gain = sqrtf(ch / power);
529  break;
530  default:
531  return AVERROR_BUG;
532  }
533 
534  s->gain = FFMIN(s->gain * s->ir_gain, 1.f);
535  av_log(ctx, AV_LOG_DEBUG, "power %f, gain %f\n", power, s->gain);
536  for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
537  float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
538 
539  s->fdsp->vector_fmul_scalar(time, time, s->gain, FFALIGN(cur_nb_taps, 4));
540  }
541 
542  av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
543  av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments);
544 
545  for (ch = 0; ch < ctx->inputs[1 + s->selir]->channels; ch++) {
546  float *time = (float *)s->ir[s->selir]->extended_data[!s->one2many * ch];
547  int toffset = 0;
548 
549  for (i = FFMAX(1, s->length * s->nb_taps); i < s->nb_taps; i++)
550  time[i] = 0;
551 
552  av_log(ctx, AV_LOG_DEBUG, "channel: %d\n", ch);
553 
554  for (int segment = 0; segment < s->nb_segments; segment++) {
555  AudioFIRSegment *seg = &s->seg[segment];
556  float *block = (float *)seg->block->extended_data[ch];
558 
559  av_log(ctx, AV_LOG_DEBUG, "segment: %d\n", segment);
560 
561  for (i = 0; i < seg->nb_partitions; i++) {
562  const float scale = 1.f / seg->part_size;
563  const int coffset = i * seg->coeff_size;
564  const int remaining = s->nb_taps - toffset;
565  const int size = remaining >= seg->part_size ? seg->part_size : remaining;
566 
567  if (size < 8) {
568  for (n = 0; n < size; n++)
569  coeff[coffset + n].re = time[toffset + n];
570 
571  toffset += size;
572  continue;
573  }
574 
575  memset(block, 0, sizeof(*block) * seg->fft_length);
576  memcpy(block, time + toffset, size * sizeof(*block));
577 
578  av_rdft_calc(seg->rdft[0], block);
579 
580  coeff[coffset].re = block[0] * scale;
581  coeff[coffset].im = 0;
582  for (n = 1; n < seg->part_size; n++) {
583  coeff[coffset + n].re = block[2 * n] * scale;
584  coeff[coffset + n].im = block[2 * n + 1] * scale;
585  }
586  coeff[coffset + seg->part_size].re = block[1] * scale;
587  coeff[coffset + seg->part_size].im = 0;
588 
589  toffset += size;
590  }
591 
592  av_log(ctx, AV_LOG_DEBUG, "nb_partitions: %d\n", seg->nb_partitions);
593  av_log(ctx, AV_LOG_DEBUG, "partition size: %d\n", seg->part_size);
594  av_log(ctx, AV_LOG_DEBUG, "block size: %d\n", seg->block_size);
595  av_log(ctx, AV_LOG_DEBUG, "fft_length: %d\n", seg->fft_length);
596  av_log(ctx, AV_LOG_DEBUG, "coeff_size: %d\n", seg->coeff_size);
597  av_log(ctx, AV_LOG_DEBUG, "input_size: %d\n", seg->input_size);
598  av_log(ctx, AV_LOG_DEBUG, "input_offset: %d\n", seg->input_offset);
599  }
600  }
601 
602  s->have_coeffs = 1;
603 
604  return 0;
605 }
606 
607 static int check_ir(AVFilterLink *link, AVFrame *frame)
608 {
609  AVFilterContext *ctx = link->dst;
610  AudioFIRContext *s = ctx->priv;
611  int nb_taps, max_nb_taps;
612 
613  nb_taps = ff_inlink_queued_samples(link);
614  max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
615  if (nb_taps > max_nb_taps) {
616  av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
617  return AVERROR(EINVAL);
618  }
619 
620  return 0;
621 }
622 
624 {
625  AudioFIRContext *s = ctx->priv;
626  AVFilterLink *outlink = ctx->outputs[0];
627  int ret, status, available, wanted;
628  AVFrame *in = NULL;
629  int64_t pts;
630 
632  if (s->response)
634  if (!s->eof_coeffs[s->selir]) {
635  AVFrame *ir = NULL;
636 
637  ret = check_ir(ctx->inputs[1 + s->selir], ir);
638  if (ret < 0)
639  return ret;
640 
641  if (ff_outlink_get_status(ctx->inputs[1 + s->selir]) == AVERROR_EOF)
642  s->eof_coeffs[s->selir] = 1;
643 
644  if (!s->eof_coeffs[s->selir]) {
645  if (ff_outlink_frame_wanted(ctx->outputs[0]))
646  ff_inlink_request_frame(ctx->inputs[1 + s->selir]);
647  else if (s->response && ff_outlink_frame_wanted(ctx->outputs[1]))
648  ff_inlink_request_frame(ctx->inputs[1 + s->selir]);
649  return 0;
650  }
651  }
652 
653  if (!s->have_coeffs && s->eof_coeffs[s->selir]) {
654  ret = convert_coeffs(ctx);
655  if (ret < 0)
656  return ret;
657  }
658 
659  available = ff_inlink_queued_samples(ctx->inputs[0]);
660  wanted = FFMAX(s->min_part_size, (available / s->min_part_size) * s->min_part_size);
661  ret = ff_inlink_consume_samples(ctx->inputs[0], wanted, wanted, &in);
662  if (ret > 0)
663  ret = fir_frame(s, in, outlink);
664 
665  if (ret < 0)
666  return ret;
667 
668  if (s->response && s->have_coeffs) {
669  int64_t old_pts = s->video->pts;
670  int64_t new_pts = av_rescale_q(s->pts, ctx->inputs[0]->time_base, ctx->outputs[1]->time_base);
671 
672  if (ff_outlink_frame_wanted(ctx->outputs[1]) && old_pts < new_pts) {
673  AVFrame *clone;
674  s->video->pts = new_pts;
675  clone = av_frame_clone(s->video);
676  if (!clone)
677  return AVERROR(ENOMEM);
678  return ff_filter_frame(ctx->outputs[1], clone);
679  }
680  }
681 
682  if (ff_inlink_queued_samples(ctx->inputs[0]) >= s->min_part_size) {
683  ff_filter_set_ready(ctx, 10);
684  return 0;
685  }
686 
687  if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
688  if (status == AVERROR_EOF) {
689  ff_outlink_set_status(ctx->outputs[0], status, pts);
690  if (s->response)
691  ff_outlink_set_status(ctx->outputs[1], status, pts);
692  return 0;
693  }
694  }
695 
696  if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
697  !ff_outlink_get_status(ctx->inputs[0])) {
699  return 0;
700  }
701 
702  if (s->response &&
703  ff_outlink_frame_wanted(ctx->outputs[1]) &&
704  !ff_outlink_get_status(ctx->inputs[0])) {
706  return 0;
707  }
708 
709  return FFERROR_NOT_READY;
710 }
711 
713 {
714  AudioFIRContext *s = ctx->priv;
717  static const enum AVSampleFormat sample_fmts[] = {
720  };
721  static const enum AVPixelFormat pix_fmts[] = {
724  };
725  int ret;
726 
727  if (s->response) {
728  AVFilterLink *videolink = ctx->outputs[1];
729  formats = ff_make_format_list(pix_fmts);
730  if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)
731  return ret;
732  }
733 
734  layouts = ff_all_channel_counts();
735  if (!layouts)
736  return AVERROR(ENOMEM);
737 
738  if (s->ir_format) {
739  ret = ff_set_common_channel_layouts(ctx, layouts);
740  if (ret < 0)
741  return ret;
742  } else {
744 
745  if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts)) < 0)
746  return ret;
747  if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0)
748  return ret;
749 
751  if (ret)
752  return ret;
753  for (int i = 1; i < ctx->nb_inputs; i++) {
754  if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->out_channel_layouts)) < 0)
755  return ret;
756  }
757  }
758 
759  formats = ff_make_format_list(sample_fmts);
760  if ((ret = ff_set_common_formats(ctx, formats)) < 0)
761  return ret;
762 
763  formats = ff_all_samplerates();
764  return ff_set_common_samplerates(ctx, formats);
765 }
766 
767 static int config_output(AVFilterLink *outlink)
768 {
769  AVFilterContext *ctx = outlink->src;
770  AudioFIRContext *s = ctx->priv;
771 
772  s->one2many = ctx->inputs[1 + s->selir]->channels == 1;
773  outlink->sample_rate = ctx->inputs[0]->sample_rate;
774  outlink->time_base = ctx->inputs[0]->time_base;
775  outlink->channel_layout = ctx->inputs[0]->channel_layout;
776  outlink->channels = ctx->inputs[0]->channels;
777 
778  s->nb_channels = outlink->channels;
779  s->nb_coef_channels = ctx->inputs[1 + s->selir]->channels;
780  s->pts = AV_NOPTS_VALUE;
781 
782  return 0;
783 }
784 
786 {
787  AudioFIRContext *s = ctx->priv;
788 
789  for (int i = 0; i < s->nb_segments; i++) {
790  uninit_segment(ctx, &s->seg[i]);
791  }
792 
793  av_freep(&s->fdsp);
794 
795  for (int i = 0; i < s->nb_irs; i++) {
796  av_frame_free(&s->ir[i]);
797  }
798 
799  for (int i = 0; i < ctx->nb_inputs; i++)
800  av_freep(&ctx->input_pads[i].name);
801 
802  for (int i = 0; i < ctx->nb_outputs; i++)
803  av_freep(&ctx->output_pads[i].name);
804  av_frame_free(&s->video);
805 }
806 
807 static int config_video(AVFilterLink *outlink)
808 {
809  AVFilterContext *ctx = outlink->src;
810  AudioFIRContext *s = ctx->priv;
811 
812  outlink->sample_aspect_ratio = (AVRational){1,1};
813  outlink->w = s->w;
814  outlink->h = s->h;
815  outlink->frame_rate = s->frame_rate;
816  outlink->time_base = av_inv_q(outlink->frame_rate);
817 
818  av_frame_free(&s->video);
819  s->video = ff_get_video_buffer(outlink, outlink->w, outlink->h);
820  if (!s->video)
821  return AVERROR(ENOMEM);
822 
823  return 0;
824 }
825 
827 {
828  dsp->fcmul_add = fcmul_add_c;
829 
830  if (ARCH_X86)
831  ff_afir_init_x86(dsp);
832 }
833 
835 {
836  AudioFIRContext *s = ctx->priv;
837  AVFilterPad pad, vpad;
838  int ret;
839 
840  pad = (AVFilterPad) {
841  .name = av_strdup("main"),
842  .type = AVMEDIA_TYPE_AUDIO,
843  };
844 
845  if (!pad.name)
846  return AVERROR(ENOMEM);
847 
848  ret = ff_insert_inpad(ctx, 0, &pad);
849  if (ret < 0) {
850  av_freep(&pad.name);
851  return ret;
852  }
853 
854  for (int n = 0; n < s->nb_irs; n++) {
855  pad = (AVFilterPad) {
856  .name = av_asprintf("ir%d", n),
857  .type = AVMEDIA_TYPE_AUDIO,
858  };
859 
860  if (!pad.name)
861  return AVERROR(ENOMEM);
862 
863  ret = ff_insert_inpad(ctx, n + 1, &pad);
864  if (ret < 0) {
865  av_freep(&pad.name);
866  return ret;
867  }
868  }
869 
870  pad = (AVFilterPad) {
871  .name = av_strdup("default"),
872  .type = AVMEDIA_TYPE_AUDIO,
873  .config_props = config_output,
874  };
875 
876  if (!pad.name)
877  return AVERROR(ENOMEM);
878 
879  ret = ff_insert_outpad(ctx, 0, &pad);
880  if (ret < 0) {
881  av_freep(&pad.name);
882  return ret;
883  }
884 
885  if (s->response) {
886  vpad = (AVFilterPad){
887  .name = av_strdup("filter_response"),
888  .type = AVMEDIA_TYPE_VIDEO,
889  .config_props = config_video,
890  };
891  if (!vpad.name)
892  return AVERROR(ENOMEM);
893 
894  ret = ff_insert_outpad(ctx, 1, &vpad);
895  if (ret < 0) {
896  av_freep(&vpad.name);
897  return ret;
898  }
899  }
900 
902  if (!s->fdsp)
903  return AVERROR(ENOMEM);
904 
905  ff_afir_init(&s->afirdsp);
906 
907  return 0;
908 }
909 
911  const char *cmd,
912  const char *arg,
913  char *res,
914  int res_len,
915  int flags)
916 {
917  AudioFIRContext *s = ctx->priv;
918  int prev_ir = s->selir;
919  int ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
920 
921  if (ret < 0)
922  return ret;
923 
924  s->selir = FFMIN(s->nb_irs - 1, s->selir);
925 
926  if (prev_ir != s->selir) {
927  s->have_coeffs = 0;
928  }
929 
930  return 0;
931 }
932 
933 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
934 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
935 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
936 #define OFFSET(x) offsetof(AudioFIRContext, x)
937 
938 static const AVOption afir_options[] = {
939  { "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AF },
940  { "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AF },
941  { "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
942  { "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 2, AF, "gtype" },
943  { "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF, "gtype" },
944  { "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "gtype" },
945  { "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "gtype" },
946  { "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "gtype" },
947  { "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
948  { "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, "irfmt" },
949  { "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "irfmt" },
950  { "input", "same as input", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "irfmt" },
951  { "maxir", "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
952  { "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
953  { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF },
954  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF },
955  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF },
956  { "minp", "set min partition size", OFFSET(minp), AV_OPT_TYPE_INT, {.i64=8192}, 1, 32768, AF },
957  { "maxp", "set max partition size", OFFSET(maxp), AV_OPT_TYPE_INT, {.i64=8192}, 8, 32768, AF },
958  { "nbirs", "set number of input IRs",OFFSET(nb_irs),AV_OPT_TYPE_INT, {.i64=1}, 1, 32, AF },
959  { "ir", "select IR", OFFSET(selir), AV_OPT_TYPE_INT, {.i64=0}, 0, 31, AFR },
960  { NULL }
961 };
962 
964 
966  .name = "afir",
967  .description = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
968  .priv_size = sizeof(AudioFIRContext),
969  .priv_class = &afir_class,
971  .init = init,
972  .activate = activate,
973  .uninit = uninit,
978 };
float, planar
Definition: samplefmt.h:69
#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:586
int size
static av_cold int init(AVFilterContext *ctx)
Definition: af_afir.c:834
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVOption.
Definition: opt.h:246
static int check_ir(AVFilterLink *link, AVFrame *frame)
Definition: af_afir.c:607
int nb_coef_channels
Definition: af_afir.h:86
float re
Definition: fft.c:82
int * part_index
Definition: af_afir.h:44
int nb_channels
Definition: af_afir.h:85
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:212
Main libavfilter public API header.
AVFrame * block
Definition: af_afir.h:47
int input_offset
Definition: af_afir.h:41
int eof_coeffs[32]
Definition: af_afir.h:82
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:105
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afir.c:785
float fminf(float, float)
int input_size
Definition: af_afir.h:40
static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int offset, int nb_partitions, int part_size)
Definition: af_afir.c:374
#define FFERROR_NOT_READY
Filters implementation helper functions.
Definition: filters.h:34
int min_part_size
Definition: af_afir.h:95
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:104
float ir_gain
Definition: af_afir.h:68
AVFrame * coeff
Definition: af_afir.h:49
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1602
static int ff_outlink_frame_wanted(AVFilterLink *link)
Test if a frame is wanted on an output link.
Definition: filters.h:172
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:300
static int16_t block[64]
Definition: dct.c:115
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
static void draw_response(AVFilterContext *ctx, AVFrame *out)
Definition: af_afir.c:285
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:479
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
uint8_t
#define av_cold
Definition: attributes.h:88
float dry_gain
Definition: af_afir.h:65
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:238
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
Definition: af_afir.c:259
AVFrame * buffer
Definition: af_afir.h:48
#define emms_c()
Definition: internal.h:55
void ff_afir_init_x86(AudioFIRDSPContext *s)
Definition: af_afir_init.c:30
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
Definition: af_afir.c:209
static AVFrame * frame
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
#define max(a, b)
Definition: cuda_runtime.h:33
static int process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: af_afir.c:910
#define FFALIGN(x, a)
Definition: macros.h:48
static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
Definition: af_afir.c:416
#define av_log(a,...)
AVFrame * ir[32]
Definition: af_afir.h:93
A filter pad used for either input or output.
Definition: internal.h:54
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVFrame * output
Definition: af_afir.h:51
#define src
Definition: vp8dsp.c:254
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1431
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
AVFrame * sum
Definition: af_afir.h:46
#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:605
#define AFR
Definition: af_afir.c:934
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
static int convert_coeffs(AVFilterContext *ctx)
Definition: af_afir.c:446
AVFILTER_DEFINE_CLASS(afir)
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:356
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
static const uint16_t mask[17]
Definition: lzw.c:38
#define ARCH_X86
Definition: config.h:38
#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
RDFTContext ** irdft
Definition: af_afir.h:53
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:188
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:869
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
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * arg
Definition: jacosubdec.c:66
static void direct(const float *in, const FFTComplex *ir, int len, float *out)
Definition: af_afir.c:60
Definition: avfft.h:73
static const uint8_t offset[127][2]
Definition: vf_spp.c:93
#define FFMAX(a, b)
Definition: common.h:94
void av_rdft_calc(RDFTContext *s, FFTSample *data)
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
Definition: hls.c:68
static av_const double hypot(double x, double y)
Definition: libm.h:366
int channels
number of audio channels, only used for audio.
Definition: frame.h:606
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:784
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
#define FFMIN(a, b)
Definition: common.h:96
float fmaxf(float, float)
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:484
int coeff_size
Definition: af_afir.h:39
uint8_t w
Definition: llviddspenc.c:38
RDFTContext ** rdft
Definition: af_afir.h:53
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1456
AudioFIRDSPContext afirdsp
Definition: af_afir.h:98
AVFormatContext * ctx
Definition: movenc.c:48
int ir_channel
Definition: af_afir.h:74
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
void(* fcmul_add)(float *sum, const float *t, const float *c, ptrdiff_t len)
Definition: af_afir.h:57
Definition: avfft.h:72
void av_rdft_end(RDFTContext *s)
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
void ff_afir_init(AudioFIRDSPContext *dsp)
Definition: af_afir.c:826
#define av_log2
Definition: intmath.h:83
static void fcmul_add_c(float *sum, const float *t, const float *c, ptrdiff_t len)
Definition: af_afir.c:43
A list of supported channel layouts.
Definition: formats.h:85
int64_t pts
Definition: af_afir.h:96
static int query_formats(AVFilterContext *ctx)
Definition: af_afir.c:712
AVFloatDSPContext * fdsp
Definition: af_afir.h:99
AVFrame * input
Definition: af_afir.h:50
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afir.c:196
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link&#39;s FIFO and update the link&#39;s stats.
Definition: avfilter.c:1495
FFT functions.
long long int64_t
Definition: coverity.c:34
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
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
Filter definition.
Definition: avfilter.h:144
static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
Definition: af_afir.c:185
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1625
int have_coeffs
Definition: af_afir.h:83
Rational number (pair of numerator and denominator).
Definition: rational.h:58
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:85
float max_ir_len
Definition: af_afir.h:70
offset must point to AVRational
Definition: opt.h:236
const char * name
Filter name.
Definition: avfilter.h:148
AVFrame * in
Definition: af_afir.h:92
#define snprintf
Definition: snprintf.h:34
offset must point to two consecutive integers
Definition: opt.h:233
#define AF
Definition: af_afir.c:933
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
float length
Definition: af_afir.h:66
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:439
AVFilter ff_af_afir
Definition: af_afir.c:965
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:576
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
Definition: af_afir.c:236
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
int nb_partitions
Definition: af_afir.h:35
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:279
static double c[64]
AudioFIRSegment seg[1024]
Definition: af_afir.h:89
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
#define OFFSET(x)
Definition: af_afir.c:936
static int config_video(AVFilterLink *outlink)
Definition: af_afir.c:807
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:193
avfilter_execute_func * execute
Definition: internal.h:144
static const AVOption afir_options[]
Definition: af_afir.c:938
AVFrame * video
Definition: af_afir.h:94
float gain
Definition: af_afir.h:80
static int activate(AVFilterContext *ctx)
Definition: af_afir.c:623
int fft_length
Definition: af_afir.h:38
#define av_free(p)
int len
float wet_gain
Definition: af_afir.h:64
int * output_offset
Definition: af_afir.h:43
int block_size
Definition: af_afir.h:37
A list of supported formats for one end of a filter link.
Definition: formats.h:64
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
AVRational frame_rate
Definition: af_afir.h:73
An instance of a filter.
Definition: avfilter.h:338
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:731
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define M_PI
Definition: mathematics.h:52
#define av_malloc_array(a, b)
formats
Definition: signature.h:48
static int config_output(AVFilterLink *outlink)
Definition: af_afir.c:767
internal API functions
#define VF
Definition: af_afir.c:935
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:454
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
#define AV_CH_LAYOUT_MONO
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:274
float min
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int nb_segments
Definition: af_afir.h:90
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:593
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
CGA/EGA/VGA ROM font data.
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
Definition: internal.h:266
static int fir_quantum(AVFilterContext *ctx, AVFrame *out, int ch, int offset)
Definition: af_afir.c:67