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"
39 
40 #include "audio.h"
41 #include "avfilter.h"
42 #include "filters.h"
43 #include "formats.h"
44 #include "internal.h"
45 #include "af_afir.h"
46 #include "af_afirdsp.h"
47 #include "video.h"
48 
49 #define DEPTH 32
50 #include "afir_template.c"
51 
52 #undef DEPTH
53 #define DEPTH 64
54 #include "afir_template.c"
55 
56 static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
57 {
58  AudioFIRContext *s = ctx->priv;
59  const int min_part_size = s->min_part_size;
60  const int prev_selir = s->prev_selir;
61  const int selir = s->selir;
62 
63  for (int offset = 0; offset < out->nb_samples; offset += min_part_size) {
64  switch (s->format) {
65  case AV_SAMPLE_FMT_FLTP:
66  fir_quantums_float(ctx, s, out, min_part_size, ch, offset, prev_selir, selir);
67  break;
68  case AV_SAMPLE_FMT_DBLP:
69  fir_quantums_double(ctx, s, out, min_part_size, ch, offset, prev_selir, selir);
70  break;
71  }
72 
73  if (selir != prev_selir && s->loading[ch] != 0)
74  s->loading[ch] += min_part_size;
75  }
76 
77  return 0;
78 }
79 
80 static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
81 {
82  AVFrame *out = arg;
83  const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
84  const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
85 
86  for (int ch = start; ch < end; ch++)
87  fir_channel(ctx, out, ch);
88 
89  return 0;
90 }
91 
92 static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
93 {
94  AVFilterContext *ctx = outlink->src;
95  AVFrame *out;
96 
97  out = ff_get_audio_buffer(outlink, in->nb_samples);
98  if (!out) {
99  av_frame_free(&in);
100  return AVERROR(ENOMEM);
101  }
103  out->pts = s->pts = in->pts;
104 
105  s->in = in;
108  s->prev_is_disabled = ctx->is_disabled;
109 
110  av_frame_free(&in);
111  s->in = NULL;
112 
113  return ff_filter_frame(outlink, out);
114 }
115 
116 static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int selir,
117  int offset, int nb_partitions, int part_size, int index)
118 {
119  AudioFIRContext *s = ctx->priv;
120  const size_t cpu_align = av_cpu_max_align();
121  union { double d; float f; } cscale, scale, iscale;
122  enum AVTXType tx_type;
123  int ret;
124 
125  seg->tx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->tx));
126  seg->ctx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->ctx));
127  seg->itx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->itx));
128  if (!seg->tx || !seg->ctx || !seg->itx)
129  return AVERROR(ENOMEM);
130 
131  seg->fft_length = (part_size + 1) * 2;
132  seg->part_size = part_size;
133  seg->coeff_size = FFALIGN(seg->part_size + 1, cpu_align);
134  seg->block_size = FFMAX(seg->coeff_size * 2, FFALIGN(seg->fft_length, cpu_align));
135  seg->nb_partitions = nb_partitions;
136  seg->input_size = offset + s->min_part_size;
137  seg->input_offset = offset;
138 
139  seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index));
140  seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset));
141  if (!seg->part_index || !seg->output_offset)
142  return AVERROR(ENOMEM);
143 
144  switch (s->format) {
145  case AV_SAMPLE_FMT_FLTP:
146  cscale.f = 1.f;
147  scale.f = 1.f / sqrtf(2.f * part_size);
148  iscale.f = 1.f / sqrtf(2.f * part_size);
149  tx_type = AV_TX_FLOAT_RDFT;
150  break;
151  case AV_SAMPLE_FMT_DBLP:
152  cscale.d = 1.0;
153  scale.d = 1.0 / sqrt(2.0 * part_size);
154  iscale.d = 1.0 / sqrt(2.0 * part_size);
155  tx_type = AV_TX_DOUBLE_RDFT;
156  break;
157  }
158 
159  for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) {
160  ret = av_tx_init(&seg->ctx[ch], &seg->ctx_fn, tx_type,
161  0, 2 * part_size, &cscale, 0);
162  if (ret < 0)
163  return ret;
164 
165  ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type,
166  0, 2 * part_size, &scale, 0);
167  if (ret < 0)
168  return ret;
169  ret = av_tx_init(&seg->itx[ch], &seg->itx_fn, tx_type,
170  1, 2 * part_size, &iscale, 0);
171  if (ret < 0)
172  return ret;
173  }
174 
175  seg->sumin = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
176  seg->sumout = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
177  seg->blockout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size * seg->nb_partitions);
178  seg->tempin = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
179  seg->tempout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
180  seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
181  seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
182  seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size * 5);
183  if (!seg->buffer || !seg->sumin || !seg->sumout || !seg->blockout ||
184  !seg->input || !seg->output || !seg->tempin || !seg->tempout)
185  return AVERROR(ENOMEM);
186 
187  return 0;
188 }
189 
191 {
192  AudioFIRContext *s = ctx->priv;
193 
194  if (seg->ctx) {
195  for (int ch = 0; ch < s->nb_channels; ch++)
196  av_tx_uninit(&seg->ctx[ch]);
197  }
198  av_freep(&seg->ctx);
199 
200  if (seg->tx) {
201  for (int ch = 0; ch < s->nb_channels; ch++)
202  av_tx_uninit(&seg->tx[ch]);
203  }
204  av_freep(&seg->tx);
205 
206  if (seg->itx) {
207  for (int ch = 0; ch < s->nb_channels; ch++)
208  av_tx_uninit(&seg->itx[ch]);
209  }
210  av_freep(&seg->itx);
211 
212  av_freep(&seg->output_offset);
213  av_freep(&seg->part_index);
214 
215  av_frame_free(&seg->tempin);
216  av_frame_free(&seg->tempout);
217  av_frame_free(&seg->blockout);
218  av_frame_free(&seg->sumin);
219  av_frame_free(&seg->sumout);
220  av_frame_free(&seg->buffer);
221  av_frame_free(&seg->input);
222  av_frame_free(&seg->output);
223  seg->input_size = 0;
224 
225  for (int i = 0; i < MAX_IR_STREAMS; i++)
226  av_frame_free(&seg->coeff);
227 }
228 
229 static int convert_coeffs(AVFilterContext *ctx, int selir)
230 {
231  AudioFIRContext *s = ctx->priv;
232  int ret, nb_taps, cur_nb_taps;
233 
234  if (!s->nb_taps[selir]) {
235  int part_size, max_part_size;
236  int left, offset = 0;
237 
238  s->nb_taps[selir] = ff_inlink_queued_samples(ctx->inputs[1 + selir]);
239  if (s->nb_taps[selir] <= 0)
240  return AVERROR(EINVAL);
241 
242  if (s->minp > s->maxp)
243  s->maxp = s->minp;
244 
245  if (s->nb_segments[selir])
246  goto skip;
247 
248  left = s->nb_taps[selir];
249  part_size = 1 << av_log2(s->minp);
250  max_part_size = 1 << av_log2(s->maxp);
251 
252  for (int i = 0; left > 0; i++) {
253  int step = (part_size == max_part_size) ? INT_MAX : 1 + (i == 0);
254  int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
255 
256  s->nb_segments[selir] = i + 1;
257  ret = init_segment(ctx, &s->seg[selir][i], selir, offset, nb_partitions, part_size, i);
258  if (ret < 0)
259  return ret;
260  offset += nb_partitions * part_size;
261  s->max_offset[selir] = offset;
262  left -= nb_partitions * part_size;
263  part_size *= 2;
264  part_size = FFMIN(part_size, max_part_size);
265  }
266  }
267 
268 skip:
269  if (!s->ir[selir]) {
270  ret = ff_inlink_consume_samples(ctx->inputs[1 + selir], s->nb_taps[selir], s->nb_taps[selir], &s->ir[selir]);
271  if (ret < 0)
272  return ret;
273  if (ret == 0)
274  return AVERROR_BUG;
275  }
276 
277  cur_nb_taps = s->ir[selir]->nb_samples;
278  nb_taps = cur_nb_taps;
279 
280  if (!s->norm_ir[selir] || s->norm_ir[selir]->nb_samples < nb_taps) {
281  av_frame_free(&s->norm_ir[selir]);
282  s->norm_ir[selir] = ff_get_audio_buffer(ctx->inputs[0], FFALIGN(nb_taps, 8));
283  if (!s->norm_ir[selir])
284  return AVERROR(ENOMEM);
285  }
286 
287  av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
288  av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments[selir]);
289 
290  switch (s->format) {
291  case AV_SAMPLE_FMT_FLTP:
292  for (int ch = 0; ch < s->nb_channels; ch++) {
293  const float *tsrc = (const float *)s->ir[selir]->extended_data[!s->one2many * ch];
294 
295  s->ch_gain[ch] = ir_gain_float(ctx, s, nb_taps, tsrc);
296  }
297 
298  if (s->ir_link) {
299  float gain = +INFINITY;
300 
301  for (int ch = 0; ch < s->nb_channels; ch++)
302  gain = fminf(gain, s->ch_gain[ch]);
303 
304  for (int ch = 0; ch < s->nb_channels; ch++)
305  s->ch_gain[ch] = gain;
306  }
307 
308  for (int ch = 0; ch < s->nb_channels; ch++) {
309  const float *tsrc = (const float *)s->ir[selir]->extended_data[!s->one2many * ch];
310  float *time = (float *)s->norm_ir[selir]->extended_data[ch];
311 
312  memcpy(time, tsrc, sizeof(*time) * nb_taps);
313  for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
314  time[i] = 0;
315 
316  ir_scale_float(ctx, s, nb_taps, ch, time, s->ch_gain[ch]);
317 
318  for (int n = 0; n < s->nb_segments[selir]; n++) {
319  AudioFIRSegment *seg = &s->seg[selir][n];
320 
321  if (!seg->coeff)
322  seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
323  if (!seg->coeff)
324  return AVERROR(ENOMEM);
325 
326  for (int i = 0; i < seg->nb_partitions; i++)
327  convert_channel_float(ctx, s, ch, seg, i, selir);
328  }
329  }
330  break;
331  case AV_SAMPLE_FMT_DBLP:
332  for (int ch = 0; ch < s->nb_channels; ch++) {
333  const double *tsrc = (const double *)s->ir[selir]->extended_data[!s->one2many * ch];
334 
335  s->ch_gain[ch] = ir_gain_double(ctx, s, nb_taps, tsrc);
336  }
337 
338  if (s->ir_link) {
339  double gain = +INFINITY;
340 
341  for (int ch = 0; ch < s->nb_channels; ch++)
342  gain = fmin(gain, s->ch_gain[ch]);
343 
344  for (int ch = 0; ch < s->nb_channels; ch++)
345  s->ch_gain[ch] = gain;
346  }
347 
348  for (int ch = 0; ch < s->nb_channels; ch++) {
349  const double *tsrc = (const double *)s->ir[selir]->extended_data[!s->one2many * ch];
350  double *time = (double *)s->norm_ir[selir]->extended_data[ch];
351 
352  memcpy(time, tsrc, sizeof(*time) * nb_taps);
353  for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
354  time[i] = 0;
355 
356  ir_scale_double(ctx, s, nb_taps, ch, time, s->ch_gain[ch]);
357 
358  for (int n = 0; n < s->nb_segments[selir]; n++) {
359  AudioFIRSegment *seg = &s->seg[selir][n];
360 
361  if (!seg->coeff)
362  seg->coeff = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
363  if (!seg->coeff)
364  return AVERROR(ENOMEM);
365 
366  for (int i = 0; i < seg->nb_partitions; i++)
367  convert_channel_double(ctx, s, ch, seg, i, selir);
368  }
369  }
370  break;
371  }
372 
373  s->have_coeffs[selir] = 1;
374 
375  return 0;
376 }
377 
378 static int check_ir(AVFilterLink *link, int selir)
379 {
380  AVFilterContext *ctx = link->dst;
381  AudioFIRContext *s = ctx->priv;
382  int nb_taps, max_nb_taps;
383 
384  nb_taps = ff_inlink_queued_samples(link);
385  max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
386  if (nb_taps > max_nb_taps) {
387  av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
388  return AVERROR(EINVAL);
389  }
390 
391  if (ff_inlink_check_available_samples(link, nb_taps + 1) == 1)
392  s->eof_coeffs[selir] = 1;
393 
394  return 0;
395 }
396 
398 {
399  AudioFIRContext *s = ctx->priv;
400  AVFilterLink *outlink = ctx->outputs[0];
401  int ret, status, available, wanted;
402  AVFrame *in = NULL;
403  int64_t pts;
404 
406 
407  for (int i = 0; i < s->nb_irs; i++) {
408  const int selir = i;
409 
410  if (s->ir_load && selir != s->selir)
411  continue;
412 
413  if (!s->eof_coeffs[selir]) {
414  ret = check_ir(ctx->inputs[1 + selir], selir);
415  if (ret < 0)
416  return ret;
417 
418  if (!s->eof_coeffs[selir]) {
419  if (ff_outlink_frame_wanted(ctx->outputs[0]))
420  ff_inlink_request_frame(ctx->inputs[1 + selir]);
421  return 0;
422  }
423  }
424 
425  if (!s->have_coeffs[selir] && s->eof_coeffs[selir]) {
426  ret = convert_coeffs(ctx, selir);
427  if (ret < 0)
428  return ret;
429  }
430  }
431 
432  available = ff_inlink_queued_samples(ctx->inputs[0]);
433  wanted = FFMAX(s->min_part_size, (available / s->min_part_size) * s->min_part_size);
434  ret = ff_inlink_consume_samples(ctx->inputs[0], wanted, wanted, &in);
435  if (ret > 0)
436  ret = fir_frame(s, in, outlink);
437 
438  if (s->selir != s->prev_selir && s->loading[0] == 0)
439  s->prev_selir = s->selir;
440 
441  if (ret < 0)
442  return ret;
443 
444  if (ff_inlink_queued_samples(ctx->inputs[0]) >= s->min_part_size) {
446  return 0;
447  }
448 
449  if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
450  if (status == AVERROR_EOF) {
451  ff_outlink_set_status(ctx->outputs[0], status, pts);
452  return 0;
453  }
454  }
455 
456  if (ff_outlink_frame_wanted(ctx->outputs[0])) {
457  ff_inlink_request_frame(ctx->inputs[0]);
458  return 0;
459  }
460 
461  return FFERROR_NOT_READY;
462 }
463 
465 {
466  AudioFIRContext *s = ctx->priv;
467  static const enum AVSampleFormat sample_fmts[3][3] = {
471  };
472  int ret;
473 
474  if (s->ir_format) {
476  if (ret < 0)
477  return ret;
478  } else {
481 
482  if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
483  return ret;
484  if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
485  return ret;
486 
488  if (ret)
489  return ret;
490  for (int i = 1; i < ctx->nb_inputs; i++) {
491  if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
492  return ret;
493  }
494  }
495 
496  if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts[s->precision])) < 0)
497  return ret;
498 
500 }
501 
502 static int config_output(AVFilterLink *outlink)
503 {
504  AVFilterContext *ctx = outlink->src;
505  AudioFIRContext *s = ctx->priv;
506  int ret;
507 
508  s->one2many = ctx->inputs[1 + s->selir]->ch_layout.nb_channels == 1;
509  outlink->sample_rate = ctx->inputs[0]->sample_rate;
510  outlink->time_base = ctx->inputs[0]->time_base;
511 #if FF_API_OLD_CHANNEL_LAYOUT
513  outlink->channel_layout = ctx->inputs[0]->channel_layout;
515 #endif
516  if ((ret = av_channel_layout_copy(&outlink->ch_layout, &ctx->inputs[0]->ch_layout)) < 0)
517  return ret;
518  outlink->ch_layout.nb_channels = ctx->inputs[0]->ch_layout.nb_channels;
519 
520  s->format = outlink->format;
521  s->nb_channels = outlink->ch_layout.nb_channels;
522  s->ch_gain = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*s->ch_gain));
523  s->loading = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*s->loading));
524  if (!s->loading || !s->ch_gain)
525  return AVERROR(ENOMEM);
526 
527  s->fadein[0] = ff_get_audio_buffer(outlink, s->min_part_size);
528  s->fadein[1] = ff_get_audio_buffer(outlink, s->min_part_size);
529  if (!s->fadein[0] || !s->fadein[1])
530  return AVERROR(ENOMEM);
531 
532  s->xfade[0] = ff_get_audio_buffer(outlink, s->min_part_size);
533  s->xfade[1] = ff_get_audio_buffer(outlink, s->min_part_size);
534  if (!s->xfade[0] || !s->xfade[1])
535  return AVERROR(ENOMEM);
536 
537  switch (s->format) {
538  case AV_SAMPLE_FMT_FLTP:
539  for (int ch = 0; ch < s->nb_channels; ch++) {
540  float *dst0 = (float *)s->xfade[0]->extended_data[ch];
541  float *dst1 = (float *)s->xfade[1]->extended_data[ch];
542 
543  for (int n = 0; n < s->min_part_size; n++) {
544  dst0[n] = (n + 1.f) / s->min_part_size;
545  dst1[n] = 1.f - dst0[n];
546  }
547  }
548  break;
549  case AV_SAMPLE_FMT_DBLP:
550  for (int ch = 0; ch < s->nb_channels; ch++) {
551  double *dst0 = (double *)s->xfade[0]->extended_data[ch];
552  double *dst1 = (double *)s->xfade[1]->extended_data[ch];
553 
554  for (int n = 0; n < s->min_part_size; n++) {
555  dst0[n] = (n + 1.0) / s->min_part_size;
556  dst1[n] = 1.0 - dst0[n];
557  }
558  }
559  break;
560  }
561 
562  return 0;
563 }
564 
566 {
567  AudioFIRContext *s = ctx->priv;
568 
569  av_freep(&s->fdsp);
570  av_freep(&s->ch_gain);
571  av_freep(&s->loading);
572 
573  for (int i = 0; i < s->nb_irs; i++) {
574  for (int j = 0; j < s->nb_segments[i]; j++)
575  uninit_segment(ctx, &s->seg[i][j]);
576 
577  av_frame_free(&s->ir[i]);
578  av_frame_free(&s->norm_ir[i]);
579  }
580 
581  av_frame_free(&s->fadein[0]);
582  av_frame_free(&s->fadein[1]);
583 
584  av_frame_free(&s->xfade[0]);
585  av_frame_free(&s->xfade[1]);
586 }
587 
589 {
590  AudioFIRContext *s = ctx->priv;
591  AVFilterPad pad;
592  int ret;
593 
594  s->prev_selir = FFMIN(s->nb_irs - 1, s->selir);
595 
596  pad = (AVFilterPad) {
597  .name = "main",
598  .type = AVMEDIA_TYPE_AUDIO,
599  };
600 
601  ret = ff_append_inpad(ctx, &pad);
602  if (ret < 0)
603  return ret;
604 
605  for (int n = 0; n < s->nb_irs; n++) {
606  pad = (AVFilterPad) {
607  .name = av_asprintf("ir%d", n),
608  .type = AVMEDIA_TYPE_AUDIO,
609  };
610 
611  if (!pad.name)
612  return AVERROR(ENOMEM);
613 
615  if (ret < 0)
616  return ret;
617  }
618 
619  s->fdsp = avpriv_float_dsp_alloc(0);
620  if (!s->fdsp)
621  return AVERROR(ENOMEM);
622 
623  ff_afir_init(&s->afirdsp);
624 
625  s->min_part_size = 1 << av_log2(s->minp);
626  s->max_part_size = 1 << av_log2(s->maxp);
627 
628  return 0;
629 }
630 
632  const char *cmd,
633  const char *arg,
634  char *res,
635  int res_len,
636  int flags)
637 {
638  AudioFIRContext *s = ctx->priv;
639  int prev_selir, ret;
640 
641  prev_selir = s->selir;
642  ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
643  if (ret < 0)
644  return ret;
645 
646  s->selir = FFMIN(s->nb_irs - 1, s->selir);
647  if (s->selir != prev_selir) {
648  s->prev_selir = prev_selir;
649 
650  for (int ch = 0; ch < s->nb_channels; ch++)
651  s->loading[ch] = 1;
652  }
653 
654  return 0;
655 }
656 
657 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
658 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
659 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
660 #define OFFSET(x) offsetof(AudioFIRContext, x)
661 
662 static const AVOption afir_options[] = {
663  { "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
664  { "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
665  { "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
666  { "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 4, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
667  { "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
668  { "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
669  { "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
670  { "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
671  { "ac", "AC gain", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
672  { "rms", "RMS gain", 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, AF|AV_OPT_FLAG_DEPRECATED, .unit = "gtype" },
673  { "irnorm", "set IR norm", OFFSET(ir_norm), AV_OPT_TYPE_FLOAT, {.dbl=1}, -1, 2, AF },
674  { "irlink", "set IR link", OFFSET(ir_link), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, AF },
675  { "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
676  { "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, .unit = "irfmt" },
677  { "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "irfmt" },
678  { "input", "same as input", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "irfmt" },
679  { "maxir", "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
680  { "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF|AV_OPT_FLAG_DEPRECATED },
681  { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF|AV_OPT_FLAG_DEPRECATED },
682  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF|AV_OPT_FLAG_DEPRECATED },
683  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF|AV_OPT_FLAG_DEPRECATED },
684  { "minp", "set min partition size", OFFSET(minp), AV_OPT_TYPE_INT, {.i64=8192}, 1, 65536, AF },
685  { "maxp", "set max partition size", OFFSET(maxp), AV_OPT_TYPE_INT, {.i64=8192}, 8, 65536, AF },
686  { "nbirs", "set number of input IRs",OFFSET(nb_irs),AV_OPT_TYPE_INT, {.i64=1}, 1, 32, AF },
687  { "ir", "select IR", OFFSET(selir), AV_OPT_TYPE_INT, {.i64=0}, 0, 31, AFR },
688  { "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, AF, .unit = "precision" },
689  { "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "precision" },
690  { "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "precision" },
691  { "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, .unit = "precision" },
692  { "irload", "set IR loading type", OFFSET(ir_load), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AF, .unit = "irload" },
693  { "init", "load all IRs on init", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "irload" },
694  { "access", "load IR on access", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "irload" },
695  { NULL }
696 };
697 
699 
700 static const AVFilterPad outputs[] = {
701  {
702  .name = "default",
703  .type = AVMEDIA_TYPE_AUDIO,
704  .config_props = config_output,
705  },
706 };
707 
709  .name = "afir",
710  .description = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
711  .priv_size = sizeof(AudioFIRContext),
712  .priv_class = &afir_class,
715  .init = init,
716  .activate = activate,
717  .uninit = uninit,
718  .process_command = process_command,
722 };
activate
static int activate(AVFilterContext *ctx)
Definition: af_afir.c:397
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:109
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
INFINITY
#define INFINITY
Definition: mathematics.h:118
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
AudioFIRSegment::block_size
int block_size
Definition: af_afir.h:36
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
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:673
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:659
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:621
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:159
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:821
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:323
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
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:126
AudioFIRSegment::coeff
AVFrame * coeff
Definition: af_afir.h:51
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afir.c:565
convert_coeffs
static int convert_coeffs(AVFilterContext *ctx, int selir)
Definition: af_afir.c:229
af_afirdsp.h
fir_channels
static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afir.c:80
afir_options
static const AVOption afir_options[]
Definition: af_afir.c:662
ff_afir_init
static av_unused void ff_afir_init(AudioFIRDSPContext *dsp)
Definition: af_afirdsp.h:73
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:190
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
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:378
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:1420
av_cold
#define av_cold
Definition: attributes.h:90
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(afir)
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:1564
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
fminf
float fminf(float, float)
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:873
filters.h
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
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
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:1458
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
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:131
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
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:803
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:521
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:1386
AFR
#define AFR
Definition: af_afir.c:658
index
int index
Definition: gxfenc.c:89
float_dsp.h
AudioFIRSegment::output
AVFrame * output
Definition: af_afir.h:53
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
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:290
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:313
cpu.h
AVTXType
AVTXType
Definition: tx.h:39
fmin
double fmin(double, double)
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AF
#define AF
Definition: af_afir.c:657
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:879
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
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:708
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:464
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:660
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
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:814
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
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1414
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
ir_gain
static ftype fn() ir_gain(AVFilterContext *ctx, AudioFIRContext *s, int cur_nb_taps, const ftype *time)
Definition: afir_template.c:58
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:120
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:502
AudioFIRContext
Definition: af_afir.h:59
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:56
outputs
static const AVFilterPad outputs[]
Definition: af_afir.c:700
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
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:669
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
audio.h
fir_frame
static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
Definition: af_afir.c:92
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:388
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_afir.c:588
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
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:424
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:155
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:631
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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:116
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:134
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
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:223
tx.h
AV_OPT_FLAG_DEPRECATED
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information
Definition: opt.h:298
AudioFIRSegment::part_index
int * part_index
Definition: af_afir.h:43