FFmpeg
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/cpu.h"
29 #include "libavutil/tx.h"
30 #include "libavutil/avstring.h"
32 #include "libavutil/common.h"
33 #include "libavutil/float_dsp.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/log.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/rational.h"
40 
41 #include "audio.h"
42 #include "avfilter.h"
43 #include "filters.h"
44 #include "formats.h"
45 #include "internal.h"
46 #include "af_afir.h"
47 #include "af_afirdsp.h"
48 #include "video.h"
49 
50 static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
51 {
52  const uint8_t *font;
53  int font_height;
54  int i;
55 
56  font = avpriv_cga_font, font_height = 8;
57 
58  for (i = 0; txt[i]; i++) {
59  int char_y, mask;
60 
61  uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
62  for (char_y = 0; char_y < font_height; char_y++) {
63  for (mask = 0x80; mask; mask >>= 1) {
64  if (font[txt[i] * font_height + char_y] & mask)
65  AV_WL32(p, color);
66  p += 4;
67  }
68  p += pic->linesize[0] - 8 * 4;
69  }
70  }
71 }
72 
73 static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
74 {
75  int dx = FFABS(x1-x0);
76  int dy = FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
77  int err = (dx>dy ? dx : -dy) / 2, e2;
78 
79  for (;;) {
80  AV_WL32(out->data[0] + y0 * out->linesize[0] + x0 * 4, color);
81 
82  if (x0 == x1 && y0 == y1)
83  break;
84 
85  e2 = err;
86 
87  if (e2 >-dx) {
88  err -= dy;
89  x0--;
90  }
91 
92  if (e2 < dy) {
93  err += dx;
94  y0 += sy;
95  }
96  }
97 }
98 
99 #define DEPTH 32
100 #include "afir_template.c"
101 
102 #undef DEPTH
103 #define DEPTH 64
104 #include "afir_template.c"
105 
106 static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
107 {
108  AudioFIRContext *s = ctx->priv;
109  const int min_part_size = s->min_part_size;
110  const int prev_selir = s->prev_selir;
111  const int selir = s->selir;
112 
113  for (int offset = 0; offset < out->nb_samples; offset += min_part_size) {
114  switch (s->format) {
115  case AV_SAMPLE_FMT_FLTP:
116  if (prev_selir != selir && s->loading[ch] != 0) {
117  const float *xfade0 = (const float *)s->xfade[0]->extended_data[ch];
118  const float *xfade1 = (const float *)s->xfade[1]->extended_data[ch];
119  float *src0 = (float *)s->fadein[0]->extended_data[ch];
120  float *src1 = (float *)s->fadein[1]->extended_data[ch];
121  float *dst = ((float *)out->extended_data[ch]) + offset;
122 
123  memset(src0, 0, min_part_size * sizeof(float));
124  memset(src1, 0, min_part_size * sizeof(float));
125 
126  fir_quantum_float(ctx, s->fadein[0], ch, offset, 0, prev_selir);
127  fir_quantum_float(ctx, s->fadein[1], ch, offset, 0, selir);
128 
129  if (s->loading[ch] > s->max_offset[selir]) {
130  for (int n = 0; n < min_part_size; n++)
131  dst[n] = xfade1[n] * src0[n] + xfade0[n] * src1[n];
132  s->loading[ch] = 0;
133  } else {
134  memcpy(dst, src0, min_part_size * sizeof(float));
135  }
136  } else {
137  fir_quantum_float(ctx, out, ch, offset, offset, selir);
138  }
139  break;
140  case AV_SAMPLE_FMT_DBLP:
141  if (prev_selir != selir && s->loading[ch] != 0) {
142  const double *xfade0 = (const double *)s->xfade[0]->extended_data[ch];
143  const double *xfade1 = (const double *)s->xfade[1]->extended_data[ch];
144  double *src0 = (double *)s->fadein[0]->extended_data[ch];
145  double *src1 = (double *)s->fadein[1]->extended_data[ch];
146  double *dst = ((double *)out->extended_data[ch]) + offset;
147 
148  memset(src0, 0, min_part_size * sizeof(double));
149  memset(src1, 0, min_part_size * sizeof(double));
150 
151  fir_quantum_double(ctx, s->fadein[0], ch, offset, 0, prev_selir);
152  fir_quantum_double(ctx, s->fadein[1], ch, offset, 0, selir);
153 
154  if (s->loading[ch] > s->max_offset[selir]) {
155  for (int n = 0; n < min_part_size; n++)
156  dst[n] = xfade1[n] * src0[n] + xfade0[n] * src1[n];
157  s->loading[ch] = 0;
158  } else {
159  memcpy(dst, src0, min_part_size * sizeof(double));
160  }
161  } else {
162  fir_quantum_double(ctx, out, ch, offset, offset, selir);
163  }
164  break;
165  }
166 
167  if (selir != prev_selir && s->loading[ch] != 0)
168  s->loading[ch] += min_part_size;
169  }
170 
171  return 0;
172 }
173 
174 static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
175 {
176  AVFrame *out = arg;
177  const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
178  const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
179 
180  for (int ch = start; ch < end; ch++)
181  fir_channel(ctx, out, ch);
182 
183  return 0;
184 }
185 
186 static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
187 {
188  AVFilterContext *ctx = outlink->src;
189  AVFrame *out;
190 
191  out = ff_get_audio_buffer(outlink, in->nb_samples);
192  if (!out) {
193  av_frame_free(&in);
194  return AVERROR(ENOMEM);
195  }
197  out->pts = s->pts = in->pts;
198 
199  s->in = in;
202 
203  av_frame_free(&in);
204  s->in = NULL;
205 
206  return ff_filter_frame(outlink, out);
207 }
208 
209 static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int selir,
210  int offset, int nb_partitions, int part_size, int index)
211 {
212  AudioFIRContext *s = ctx->priv;
213  const size_t cpu_align = av_cpu_max_align();
214  union { double d; float f; } cscale, scale, iscale;
215  enum AVTXType tx_type;
216  int ret;
217 
218  seg->tx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->tx));
219  seg->ctx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->ctx));
220  seg->itx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->itx));
221  if (!seg->tx || !seg->ctx || !seg->itx)
222  return AVERROR(ENOMEM);
223 
224  seg->fft_length = (part_size + 1) * 2;
225  seg->part_size = part_size;
226  seg->coeff_size = FFALIGN(seg->part_size + 1, cpu_align);
227  seg->block_size = FFMAX(seg->coeff_size * 2, FFALIGN(seg->fft_length, cpu_align));
228  seg->nb_partitions = nb_partitions;
229  seg->input_size = offset + s->min_part_size;
230  seg->input_offset = offset;
231 
232  seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index));
233  seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset));
234  if (!seg->part_index || !seg->output_offset)
235  return AVERROR(ENOMEM);
236 
237  switch (s->format) {
238  case AV_SAMPLE_FMT_FLTP:
239  cscale.f = 1.f;
240  scale.f = 1.f / sqrtf(2.f * part_size);
241  iscale.f = 1.f / sqrtf(2.f * part_size);
242  tx_type = AV_TX_FLOAT_RDFT;
243  break;
244  case AV_SAMPLE_FMT_DBLP:
245  cscale.d = 1.0;
246  scale.d = 1.0 / sqrt(2.0 * part_size);
247  iscale.d = 1.0 / sqrt(2.0 * part_size);
248  tx_type = AV_TX_DOUBLE_RDFT;
249  break;
250  }
251 
252  for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) {
253  ret = av_tx_init(&seg->ctx[ch], &seg->ctx_fn, tx_type,
254  0, 2 * part_size, &cscale, 0);
255  if (ret < 0)
256  return ret;
257 
258  ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type,
259  0, 2 * part_size, &scale, 0);
260  if (ret < 0)
261  return ret;
262  ret = av_tx_init(&seg->itx[ch], &seg->itx_fn, tx_type,
263  1, 2 * part_size, &iscale, 0);
264  if (ret < 0)
265  return ret;
266  }
267 
268  seg->sumin = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
269  seg->sumout = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
270  seg->blockout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size * seg->nb_partitions);
271  seg->tempin = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
272  seg->tempout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
273  seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
274  seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
275  seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size * 5);
276  if (!seg->buffer || !seg->sumin || !seg->sumout || !seg->blockout ||
277  !seg->input || !seg->output || !seg->tempin || !seg->tempout)
278  return AVERROR(ENOMEM);
279 
280  return 0;
281 }
282 
284 {
285  AudioFIRContext *s = ctx->priv;
286 
287  if (seg->ctx) {
288  for (int ch = 0; ch < s->nb_channels; ch++)
289  av_tx_uninit(&seg->ctx[ch]);
290  }
291  av_freep(&seg->ctx);
292 
293  if (seg->tx) {
294  for (int ch = 0; ch < s->nb_channels; ch++)
295  av_tx_uninit(&seg->tx[ch]);
296  }
297  av_freep(&seg->tx);
298 
299  if (seg->itx) {
300  for (int ch = 0; ch < s->nb_channels; ch++)
301  av_tx_uninit(&seg->itx[ch]);
302  }
303  av_freep(&seg->itx);
304 
305  av_freep(&seg->output_offset);
306  av_freep(&seg->part_index);
307 
308  av_frame_free(&seg->tempin);
309  av_frame_free(&seg->tempout);
310  av_frame_free(&seg->blockout);
311  av_frame_free(&seg->sumin);
312  av_frame_free(&seg->sumout);
313  av_frame_free(&seg->buffer);
314  av_frame_free(&seg->input);
315  av_frame_free(&seg->output);
316  seg->input_size = 0;
317 
318  for (int i = 0; i < MAX_IR_STREAMS; i++)
319  av_frame_free(&seg->coeff);
320 }
321 
322 static int convert_coeffs(AVFilterContext *ctx, int selir)
323 {
324  AudioFIRContext *s = ctx->priv;
325  int ret, nb_taps, cur_nb_taps;
326 
327  if (!s->nb_taps[selir]) {
328  int part_size, max_part_size;
329  int left, offset = 0;
330 
331  s->nb_taps[selir] = ff_inlink_queued_samples(ctx->inputs[1 + selir]);
332  if (s->nb_taps[selir] <= 0)
333  return AVERROR(EINVAL);
334 
335  if (s->minp > s->maxp)
336  s->maxp = s->minp;
337 
338  if (s->nb_segments[selir])
339  goto skip;
340 
341  left = s->nb_taps[selir];
342  part_size = 1 << av_log2(s->minp);
343  max_part_size = 1 << av_log2(s->maxp);
344 
345  for (int i = 0; left > 0; i++) {
346  int step = (part_size == max_part_size) ? INT_MAX : 1 + (i == 0);
347  int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
348 
349  s->nb_segments[selir] = i + 1;
350  ret = init_segment(ctx, &s->seg[selir][i], selir, offset, nb_partitions, part_size, i);
351  if (ret < 0)
352  return ret;
353  offset += nb_partitions * part_size;
354  s->max_offset[selir] = offset;
355  left -= nb_partitions * part_size;
356  part_size *= 2;
357  part_size = FFMIN(part_size, max_part_size);
358  }
359  }
360 
361 skip:
362  if (!s->ir[selir]) {
363  ret = ff_inlink_consume_samples(ctx->inputs[1 + selir], s->nb_taps[selir], s->nb_taps[selir], &s->ir[selir]);
364  if (ret < 0)
365  return ret;
366  if (ret == 0)
367  return AVERROR_BUG;
368  }
369 
370  if (s->response) {
371  switch (s->format) {
372  case AV_SAMPLE_FMT_FLTP:
373  draw_response_float(ctx, s->video);
374  break;
375  case AV_SAMPLE_FMT_DBLP:
376  draw_response_double(ctx, s->video);
377  break;
378  }
379  }
380 
381  cur_nb_taps = s->ir[selir]->nb_samples;
382  nb_taps = cur_nb_taps;
383 
384  if (!s->norm_ir[selir] || s->norm_ir[selir]->nb_samples < nb_taps) {
385  av_frame_free(&s->norm_ir[selir]);
386  s->norm_ir[selir] = ff_get_audio_buffer(ctx->inputs[0], FFALIGN(nb_taps, 8));
387  if (!s->norm_ir[selir])
388  return AVERROR(ENOMEM);
389  }
390 
391  av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
392  av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments[selir]);
393 
394  switch (s->format) {
395  case AV_SAMPLE_FMT_FLTP:
396  for (int ch = 0; ch < s->nb_channels; ch++) {
397  const float *tsrc = (const float *)s->ir[selir]->extended_data[!s->one2many * ch];
398  float *time = (float *)s->norm_ir[selir]->extended_data[ch];
399 
400  memcpy(time, tsrc, sizeof(*time) * nb_taps);
401  for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
402  time[i] = 0;
403 
404  get_power_float(ctx, s, nb_taps, ch, time);
405 
406  for (int n = 0; n < s->nb_segments[selir]; n++) {
407  AudioFIRSegment *seg = &s->seg[selir][n];
408 
409  if (!seg->coeff)
410  seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
411  if (!seg->coeff)
412  return AVERROR(ENOMEM);
413 
414  for (int i = 0; i < seg->nb_partitions; i++)
415  convert_channel_float(ctx, s, ch, seg, i, selir);
416  }
417  }
418  break;
419  case AV_SAMPLE_FMT_DBLP:
420  for (int ch = 0; ch < s->nb_channels; ch++) {
421  const double *tsrc = (const double *)s->ir[selir]->extended_data[!s->one2many * ch];
422  double *time = (double *)s->norm_ir[selir]->extended_data[ch];
423 
424  memcpy(time, tsrc, sizeof(*time) * nb_taps);
425  for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
426  time[i] = 0;
427 
428  get_power_double(ctx, s, nb_taps, ch, time);
429  for (int n = 0; n < s->nb_segments[selir]; n++) {
430  AudioFIRSegment *seg = &s->seg[selir][n];
431 
432  if (!seg->coeff)
433  seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
434  if (!seg->coeff)
435  return AVERROR(ENOMEM);
436 
437  for (int i = 0; i < seg->nb_partitions; i++)
438  convert_channel_double(ctx, s, ch, seg, i, selir);
439  }
440  }
441  break;
442  }
443 
444  s->have_coeffs[selir] = 1;
445 
446  return 0;
447 }
448 
449 static int check_ir(AVFilterLink *link, int selir)
450 {
451  AVFilterContext *ctx = link->dst;
452  AudioFIRContext *s = ctx->priv;
453  int nb_taps, max_nb_taps;
454 
455  nb_taps = ff_inlink_queued_samples(link);
456  max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
457  if (nb_taps > max_nb_taps) {
458  av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
459  return AVERROR(EINVAL);
460  }
461 
462  if (ff_inlink_check_available_samples(link, nb_taps + 1) == 1)
463  s->eof_coeffs[selir] = 1;
464 
465  return 0;
466 }
467 
469 {
470  AudioFIRContext *s = ctx->priv;
471  AVFilterLink *outlink = ctx->outputs[0];
472  int ret, status, available, wanted;
473  AVFrame *in = NULL;
474  int64_t pts;
475 
477  if (s->response)
479 
480  for (int i = 0; i < s->nb_irs; i++) {
481  const int selir = i;
482 
483  if (s->ir_load && selir != s->selir)
484  continue;
485 
486  if (!s->eof_coeffs[selir]) {
487  ret = check_ir(ctx->inputs[1 + selir], selir);
488  if (ret < 0)
489  return ret;
490 
491  if (!s->eof_coeffs[selir]) {
492  if (ff_outlink_frame_wanted(ctx->outputs[0]))
493  ff_inlink_request_frame(ctx->inputs[1 + selir]);
494  else if (s->response && ff_outlink_frame_wanted(ctx->outputs[1]))
495  ff_inlink_request_frame(ctx->inputs[1 + selir]);
496  return 0;
497  }
498  }
499 
500  if (!s->have_coeffs[selir] && s->eof_coeffs[selir]) {
501  ret = convert_coeffs(ctx, selir);
502  if (ret < 0)
503  return ret;
504  }
505  }
506 
507  available = ff_inlink_queued_samples(ctx->inputs[0]);
508  wanted = FFMAX(s->min_part_size, (available / s->min_part_size) * s->min_part_size);
509  ret = ff_inlink_consume_samples(ctx->inputs[0], wanted, wanted, &in);
510  if (ret > 0)
511  ret = fir_frame(s, in, outlink);
512 
513  if (s->selir != s->prev_selir && s->loading[0] == 0)
514  s->prev_selir = s->selir;
515 
516  if (ret < 0)
517  return ret;
518 
519  if (s->response && s->have_coeffs[s->selir]) {
520  int64_t old_pts = s->video->pts;
521  int64_t new_pts = av_rescale_q(s->pts, ctx->inputs[0]->time_base, ctx->outputs[1]->time_base);
522 
523  if (ff_outlink_frame_wanted(ctx->outputs[1]) && old_pts < new_pts) {
524  AVFrame *clone;
525  s->video->pts = new_pts;
526  clone = av_frame_clone(s->video);
527  if (!clone)
528  return AVERROR(ENOMEM);
529  return ff_filter_frame(ctx->outputs[1], clone);
530  }
531  }
532 
533  if (ff_inlink_queued_samples(ctx->inputs[0]) >= s->min_part_size) {
535  return 0;
536  }
537 
538  if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
539  if (status == AVERROR_EOF) {
540  ff_outlink_set_status(ctx->outputs[0], status, pts);
541  if (s->response)
542  ff_outlink_set_status(ctx->outputs[1], status, pts);
543  return 0;
544  }
545  }
546 
547  if (ff_outlink_frame_wanted(ctx->outputs[0])) {
548  ff_inlink_request_frame(ctx->inputs[0]);
549  return 0;
550  }
551 
552  if (s->response &&
553  ff_outlink_frame_wanted(ctx->outputs[1])) {
554  ff_inlink_request_frame(ctx->inputs[0]);
555  return 0;
556  }
557 
558  return FFERROR_NOT_READY;
559 }
560 
562 {
563  AudioFIRContext *s = ctx->priv;
564  static const enum AVSampleFormat sample_fmts[3][3] = {
568  };
569  static const enum AVPixelFormat pix_fmts[] = {
572  };
573  int ret;
574 
575  if (s->response) {
576  AVFilterLink *videolink = ctx->outputs[1];
578  if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)
579  return ret;
580  }
581 
582  if (s->ir_format) {
584  if (ret < 0)
585  return ret;
586  } else {
589 
590  if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
591  return ret;
592  if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
593  return ret;
594 
596  if (ret)
597  return ret;
598  for (int i = 1; i < ctx->nb_inputs; i++) {
599  if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
600  return ret;
601  }
602  }
603 
604  if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts[s->precision])) < 0)
605  return ret;
606 
608 }
609 
610 static int config_output(AVFilterLink *outlink)
611 {
612  AVFilterContext *ctx = outlink->src;
613  AudioFIRContext *s = ctx->priv;
614  int ret;
615 
616  s->one2many = ctx->inputs[1 + s->selir]->ch_layout.nb_channels == 1;
617  outlink->sample_rate = ctx->inputs[0]->sample_rate;
618  outlink->time_base = ctx->inputs[0]->time_base;
619 #if FF_API_OLD_CHANNEL_LAYOUT
621  outlink->channel_layout = ctx->inputs[0]->channel_layout;
623 #endif
624  if ((ret = av_channel_layout_copy(&outlink->ch_layout, &ctx->inputs[0]->ch_layout)) < 0)
625  return ret;
626  outlink->ch_layout.nb_channels = ctx->inputs[0]->ch_layout.nb_channels;
627 
628  s->format = outlink->format;
629  s->nb_channels = outlink->ch_layout.nb_channels;
630  s->loading = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*s->loading));
631  if (!s->loading)
632  return AVERROR(ENOMEM);
633 
634  s->fadein[0] = ff_get_audio_buffer(outlink, s->min_part_size);
635  s->fadein[1] = ff_get_audio_buffer(outlink, s->min_part_size);
636  if (!s->fadein[0] || !s->fadein[1])
637  return AVERROR(ENOMEM);
638 
639  s->xfade[0] = ff_get_audio_buffer(outlink, s->min_part_size);
640  s->xfade[1] = ff_get_audio_buffer(outlink, s->min_part_size);
641  if (!s->xfade[0] || !s->xfade[1])
642  return AVERROR(ENOMEM);
643 
644  switch (s->format) {
645  case AV_SAMPLE_FMT_FLTP:
646  for (int ch = 0; ch < s->nb_channels; ch++) {
647  float *dst0 = (float *)s->xfade[0]->extended_data[ch];
648  float *dst1 = (float *)s->xfade[1]->extended_data[ch];
649 
650  for (int n = 0; n < s->min_part_size; n++) {
651  dst0[n] = (n + 1.f) / s->min_part_size;
652  dst1[n] = 1.f - dst0[n];
653  }
654  }
655  break;
656  case AV_SAMPLE_FMT_DBLP:
657  for (int ch = 0; ch < s->nb_channels; ch++) {
658  double *dst0 = (double *)s->xfade[0]->extended_data[ch];
659  double *dst1 = (double *)s->xfade[1]->extended_data[ch];
660 
661  for (int n = 0; n < s->min_part_size; n++) {
662  dst0[n] = (n + 1.0) / s->min_part_size;
663  dst1[n] = 1.0 - dst0[n];
664  }
665  }
666  break;
667  }
668 
669  return 0;
670 }
671 
673 {
674  AudioFIRContext *s = ctx->priv;
675 
676  av_freep(&s->fdsp);
677  av_freep(&s->loading);
678 
679  for (int i = 0; i < s->nb_irs; i++) {
680  for (int j = 0; j < s->nb_segments[i]; j++)
681  uninit_segment(ctx, &s->seg[i][j]);
682 
683  av_frame_free(&s->ir[i]);
684  av_frame_free(&s->norm_ir[i]);
685  }
686 
687  av_frame_free(&s->fadein[0]);
688  av_frame_free(&s->fadein[1]);
689 
690  av_frame_free(&s->xfade[0]);
691  av_frame_free(&s->xfade[1]);
692 
693  av_frame_free(&s->video);
694 }
695 
696 static int config_video(AVFilterLink *outlink)
697 {
698  AVFilterContext *ctx = outlink->src;
699  AudioFIRContext *s = ctx->priv;
700 
701  outlink->sample_aspect_ratio = (AVRational){1,1};
702  outlink->w = s->w;
703  outlink->h = s->h;
704  outlink->frame_rate = s->frame_rate;
705  outlink->time_base = av_inv_q(outlink->frame_rate);
706 
707  av_frame_free(&s->video);
708  s->video = ff_get_video_buffer(outlink, outlink->w, outlink->h);
709  if (!s->video)
710  return AVERROR(ENOMEM);
711 
712  return 0;
713 }
714 
716 {
717  AudioFIRContext *s = ctx->priv;
718  AVFilterPad pad, vpad;
719  int ret;
720 
721  s->prev_selir = FFMIN(s->nb_irs - 1, s->selir);
722 
723  pad = (AVFilterPad) {
724  .name = "main",
725  .type = AVMEDIA_TYPE_AUDIO,
726  };
727 
728  ret = ff_append_inpad(ctx, &pad);
729  if (ret < 0)
730  return ret;
731 
732  for (int n = 0; n < s->nb_irs; n++) {
733  pad = (AVFilterPad) {
734  .name = av_asprintf("ir%d", n),
735  .type = AVMEDIA_TYPE_AUDIO,
736  };
737 
738  if (!pad.name)
739  return AVERROR(ENOMEM);
740 
742  if (ret < 0)
743  return ret;
744  }
745 
746  pad = (AVFilterPad) {
747  .name = "default",
748  .type = AVMEDIA_TYPE_AUDIO,
749  .config_props = config_output,
750  };
751 
752  ret = ff_append_outpad(ctx, &pad);
753  if (ret < 0)
754  return ret;
755 
756  if (s->response) {
757  vpad = (AVFilterPad){
758  .name = "filter_response",
759  .type = AVMEDIA_TYPE_VIDEO,
760  .config_props = config_video,
761  };
762 
763  ret = ff_append_outpad(ctx, &vpad);
764  if (ret < 0)
765  return ret;
766  }
767 
768  s->fdsp = avpriv_float_dsp_alloc(0);
769  if (!s->fdsp)
770  return AVERROR(ENOMEM);
771 
772  ff_afir_init(&s->afirdsp);
773 
774  s->min_part_size = 1 << av_log2(s->minp);
775  s->max_part_size = 1 << av_log2(s->maxp);
776 
777  return 0;
778 }
779 
781  const char *cmd,
782  const char *arg,
783  char *res,
784  int res_len,
785  int flags)
786 {
787  AudioFIRContext *s = ctx->priv;
788  int prev_selir, ret;
789 
790  prev_selir = s->selir;
791  ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
792  if (ret < 0)
793  return ret;
794 
795  s->selir = FFMIN(s->nb_irs - 1, s->selir);
796  if (s->selir != prev_selir) {
797  s->prev_selir = prev_selir;
798 
799  for (int ch = 0; ch < s->nb_channels; ch++)
800  s->loading[ch] = 1;
801  }
802 
803  return 0;
804 }
805 
806 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
807 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
808 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
809 #define OFFSET(x) offsetof(AudioFIRContext, x)
810 
811 static const AVOption afir_options[] = {
812  { "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
813  { "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
814  { "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
815  { "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 4, AF, "gtype" },
816  { "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF, "gtype" },
817  { "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "gtype" },
818  { "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "gtype" },
819  { "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "gtype" },
820  { "ac", "AC gain", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, AF, "gtype" },
821  { "rms", "RMS gain", 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, AF, "gtype" },
822  { "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
823  { "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, "irfmt" },
824  { "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "irfmt" },
825  { "input", "same as input", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "irfmt" },
826  { "maxir", "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
827  { "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
828  { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF },
829  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF },
830  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF },
831  { "minp", "set min partition size", OFFSET(minp), AV_OPT_TYPE_INT, {.i64=8192}, 1, 65536, AF },
832  { "maxp", "set max partition size", OFFSET(maxp), AV_OPT_TYPE_INT, {.i64=8192}, 8, 65536, AF },
833  { "nbirs", "set number of input IRs",OFFSET(nb_irs),AV_OPT_TYPE_INT, {.i64=1}, 1, 32, AF },
834  { "ir", "select IR", OFFSET(selir), AV_OPT_TYPE_INT, {.i64=0}, 0, 31, AFR },
835  { "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, AF, "precision" },
836  { "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "precision" },
837  { "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "precision" },
838  { "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "precision" },
839  { "irload", "set IR loading type", OFFSET(ir_load), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, "irload" },
840  { "init", "load all IRs on init", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "irload" },
841  { "access", "load IR on access", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "irload" },
842  { NULL }
843 };
844 
846 
848  .name = "afir",
849  .description = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
850  .priv_size = sizeof(AudioFIRContext),
851  .priv_class = &afir_class,
853  .init = init,
854  .activate = activate,
855  .uninit = uninit,
856  .process_command = process_command,
860 };
formats
formats
Definition: signature.h:48
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:108
activate
static int activate(AVFilterContext *ctx)
Definition: af_afir.c:468
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:107
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:401
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AudioFIRSegment::block_size
int block_size
Definition: af_afir.h:36
out
FILE * out
Definition: movenc.c:54
color
Definition: vf_paletteuse.c:511
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:947
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:612
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:326
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:238
VF
#define VF
Definition: af_afir.c:808
src1
const pixel * src1
Definition: h264pred_template.c:421
rational.h
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
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:587
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AudioFIRSegment::buffer
AVFrame * buffer
Definition: af_afir.h:50
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:251
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:169
AudioFIRSegment::input_offset
int input_offset
Definition: af_afir.h:40
ff_set_common_all_samplerates
int ff_set_common_all_samplerates(AVFilterContext *ctx)
Equivalent to ff_set_common_samplerates(ctx, ff_all_samplerates())
Definition: formats.c:760
AudioFIRSegment::tx_fn
av_tx_fn tx_fn
Definition: af_afir.h:56
float.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
AudioFIRSegment::part_size
int part_size
Definition: af_afir.h:35
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:317
AudioFIRSegment::input_size
int input_size
Definition: af_afir.h:39
video.h
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:901
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
AudioFIRSegment::ctx_fn
av_tx_fn ctx_fn
Definition: af_afir.h:56
FF_FILTER_FORWARD_STATUS_BACK_ALL
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:212
ff_append_inpad
int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
Append a new input/output pad to the filter's list of such pads.
Definition: avfilter.c:127
AudioFIRSegment::coeff
AVFrame * coeff
Definition: af_afir.h:51
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afir.c:672
convert_coeffs
static int convert_coeffs(AVFilterContext *ctx, int selir)
Definition: af_afir.c:322
af_afirdsp.h
fir_channels
static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afir.c:174
afir_options
static const AVOption afir_options[]
Definition: af_afir.c:811
ff_afir_init
static av_unused void ff_afir_init(AudioFIRDSPContext *dsp)
Definition: af_afirdsp.h:72
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
pts
static int64_t pts
Definition: transcode_aac.c:643
AudioFIRSegment::blockout
AVFrame * blockout
Definition: af_afir.h:47
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:106
uninit_segment
static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
Definition: af_afir.c:283
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:47
AudioFIRSegment
Definition: af_afir.h:33
AudioFIRSegment::tx
AVTXContext ** tx
Definition: af_afir.h:55
check_ir
static int check_ir(AVFilterLink *link, int selir)
Definition: af_afir.c:449
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_inlink_check_available_samples
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
Test if enough samples are available on the link.
Definition: avfilter.c:1367
av_cold
#define av_cold
Definition: attributes.h:90
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(afir)
mask
static const uint16_t mask[17]
Definition: lzw.c:38
ff_outlink_set_status
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
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1506
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:617
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:776
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
afir_template.c
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:609
av_rescale_q
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
link
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 link
Definition: filter_design.txt:23
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1402
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:736
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:132
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
draw_line
static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
Definition: af_afir.c:73
AudioFIRSegment::itx_fn
av_tx_fn itx_fn
Definition: af_afir.h:56
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
av_cpu_max_align
size_t av_cpu_max_align(void)
Get the maximum data alignment that may be required by FFmpeg.
Definition: cpu.c:268
ff_set_common_all_channel_counts
int ff_set_common_all_channel_counts(AVFilterContext *ctx)
Equivalent to ff_set_common_channel_layouts(ctx, ff_all_channel_counts())
Definition: formats.c:742
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:487
ff_inlink_acknowledge_status
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:1337
AFR
#define AFR
Definition: af_afir.c:807
index
int index
Definition: gxfenc.c:89
float_dsp.h
AudioFIRSegment::output
AVFrame * output
Definition: af_afir.h:53
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:112
AudioFIRSegment::tempout
AVFrame * tempout
Definition: af_afir.h:49
MAX_IR_STREAMS
#define MAX_IR_STREAMS
Definition: af_afir.h:31
f
f
Definition: af_crystalizer.c:121
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:106
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:307
cpu.h
AVTXType
AVTXType
Definition: tx.h:39
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AF
#define AF
Definition: af_afir.c:806
AudioFIRSegment::sumin
AVFrame * sumin
Definition: af_afir.h:45
frame.h
ff_filter_process_command
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:851
af_afir.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:256
xga_font_data.h
AudioFIRSegment::tempin
AVFrame * tempin
Definition: af_afir.h:48
AudioFIRSegment::ctx
AVTXContext ** ctx
Definition: af_afir.h:55
ff_af_afir
const AVFilter ff_af_afir
Definition: af_afir.c:847
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_afir.c:561
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
OFFSET
#define OFFSET(x)
Definition: af_afir.c:809
config_video
static int config_video(AVFilterLink *outlink)
Definition: af_afir.c:696
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AudioFIRSegment::input
AVFrame * input
Definition: af_afir.h:52
AudioFIRSegment::coeff_size
int coeff_size
Definition: af_afir.h:38
available
if no frame is available
Definition: filter_design.txt:166
common.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:786
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AudioFIRSegment::nb_partitions
int nb_partitions
Definition: af_afir.h:34
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_TX_DOUBLE_RDFT
@ AV_TX_DOUBLE_RDFT
Definition: tx.h:91
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:53
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1362
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
AudioFIRSegment::itx
AVTXContext ** itx
Definition: af_afir.h:55
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_TX_FLOAT_RDFT
@ AV_TX_FLOAT_RDFT
Real to complex and complex to real DFTs.
Definition: tx.h:90
status
ov_status_e status
Definition: dnn_backend_openvino.c:119
AudioFIRSegment::fft_length
int fft_length
Definition: af_afir.h:37
channel_layout.h
AudioFIRSegment::sumout
AVFrame * sumout
Definition: af_afir.h:46
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_afir.c:610
AudioFIRContext
Definition: af_afir.h:59
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
fir_channel
static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
Definition: af_afir.c:106
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
src0
const pixel *const src0
Definition: h264pred_template.c:420
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:647
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
fir_frame
static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
Definition: af_afir.c:186
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:505
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:382
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:138
avpriv_cga_font
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_afir.c:715
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
d
d
Definition: ffmpeg_filter.c:368
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: af_afir.c:780
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
init_segment
static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int selir, int offset, int nb_partitions, int part_size, int index)
Definition: af_afir.c:209
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
avstring.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:144
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AudioFIRSegment::output_offset
int * output_offset
Definition: af_afir.h:42
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
drawtext
static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
Definition: af_afir.c:50
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:216
tx.h
AudioFIRSegment::part_index
int * part_index
Definition: af_afir.h:43