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 
49 static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
50 {
51  const uint8_t *font;
52  int font_height;
53  int i;
54 
55  font = avpriv_cga_font, font_height = 8;
56 
57  for (i = 0; txt[i]; i++) {
58  int char_y, mask;
59 
60  uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
61  for (char_y = 0; char_y < font_height; char_y++) {
62  for (mask = 0x80; mask; mask >>= 1) {
63  if (font[txt[i] * font_height + char_y] & mask)
64  AV_WL32(p, color);
65  p += 4;
66  }
67  p += pic->linesize[0] - 8 * 4;
68  }
69  }
70 }
71 
72 static void draw_line(AVFrame *out, int x0, int y0, int x1, int y1, uint32_t color)
73 {
74  int dx = FFABS(x1-x0);
75  int dy = FFABS(y1-y0), sy = y0 < y1 ? 1 : -1;
76  int err = (dx>dy ? dx : -dy) / 2, e2;
77 
78  for (;;) {
79  AV_WL32(out->data[0] + y0 * out->linesize[0] + x0 * 4, color);
80 
81  if (x0 == x1 && y0 == y1)
82  break;
83 
84  e2 = err;
85 
86  if (e2 >-dx) {
87  err -= dy;
88  x0--;
89  }
90 
91  if (e2 < dy) {
92  err += dx;
93  y0 += sy;
94  }
95  }
96 }
97 
98 #define DEPTH 32
99 #include "afir_template.c"
100 
101 #undef DEPTH
102 #define DEPTH 64
103 #include "afir_template.c"
104 
105 static int fir_channel(AVFilterContext *ctx, AVFrame *out, int ch)
106 {
107  AudioFIRContext *s = ctx->priv;
108  const int min_part_size = s->min_part_size;
109 
110  for (int offset = 0; offset < out->nb_samples; offset += min_part_size) {
111  switch (s->format) {
112  case AV_SAMPLE_FMT_FLTP:
113  fir_quantum_float(ctx, out, ch, offset);
114  break;
115  case AV_SAMPLE_FMT_DBLP:
116  fir_quantum_double(ctx, out, ch, offset);
117  break;
118  }
119  }
120 
121  return 0;
122 }
123 
124 static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
125 {
126  AVFrame *out = arg;
127  const int start = (out->ch_layout.nb_channels * jobnr) / nb_jobs;
128  const int end = (out->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
129 
130  for (int ch = start; ch < end; ch++)
131  fir_channel(ctx, out, ch);
132 
133  return 0;
134 }
135 
136 static int fir_frame(AudioFIRContext *s, AVFrame *in, AVFilterLink *outlink)
137 {
138  AVFilterContext *ctx = outlink->src;
139  AVFrame *out;
140 
141  out = ff_get_audio_buffer(outlink, in->nb_samples);
142  if (!out) {
143  av_frame_free(&in);
144  return AVERROR(ENOMEM);
145  }
147  out->pts = s->pts = in->pts;
148 
149  s->in = in;
152 
153  av_frame_free(&in);
154  s->in = NULL;
155 
156  return ff_filter_frame(outlink, out);
157 }
158 
159 static int init_segment(AVFilterContext *ctx, AudioFIRSegment *seg, int selir,
160  int offset, int nb_partitions, int part_size, int index)
161 {
162  AudioFIRContext *s = ctx->priv;
163  const size_t cpu_align = av_cpu_max_align();
164  union { double d; float f; } cscale, scale, iscale;
165  enum AVTXType tx_type;
166  int ret;
167 
168  seg->tx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->tx));
169  seg->ctx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->ctx));
170  seg->itx = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->itx));
171  if (!seg->tx || !seg->ctx || !seg->itx)
172  return AVERROR(ENOMEM);
173 
174  seg->fft_length = (part_size + 1) * 2;
175  seg->part_size = part_size;
176  seg->block_size = FFALIGN(seg->fft_length, cpu_align);
177  seg->coeff_size = FFALIGN(seg->part_size + 1, cpu_align);
178  seg->nb_partitions = nb_partitions;
179  seg->input_size = offset + s->min_part_size;
180  seg->input_offset = offset;
181 
182  seg->loading = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->loading));
183  seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index));
184  seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset));
185  if (!seg->part_index || !seg->output_offset || !seg->loading)
186  return AVERROR(ENOMEM);
187 
188  switch (s->format) {
189  case AV_SAMPLE_FMT_FLTP:
190  cscale.f = 1.f;
191  scale.f = 1.f / sqrtf(2.f * part_size);
192  iscale.f = 1.f / sqrtf(2.f * part_size);
193  tx_type = AV_TX_FLOAT_RDFT;
194  break;
195  case AV_SAMPLE_FMT_DBLP:
196  cscale.d = 1.0;
197  scale.d = 1.0 / sqrt(2.0 * part_size);
198  iscale.d = 1.0 / sqrt(2.0 * part_size);
199  tx_type = AV_TX_DOUBLE_RDFT;
200  break;
201  }
202 
203  for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) {
204  ret = av_tx_init(&seg->ctx[ch], &seg->ctx_fn, tx_type,
205  0, 2 * part_size, &cscale, 0);
206  if (ret < 0)
207  return ret;
208 
209  ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type,
210  0, 2 * part_size, &scale, 0);
211  if (ret < 0)
212  return ret;
213  ret = av_tx_init(&seg->itx[ch], &seg->itx_fn, tx_type,
214  1, 2 * part_size, &iscale, 0);
215  if (ret < 0)
216  return ret;
217  }
218 
219  seg->sumin = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
220  seg->sumout = ff_get_audio_buffer(ctx->inputs[0], seg->fft_length);
221  seg->blockout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size * seg->nb_partitions);
222  seg->tempin = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
223  seg->tempout = ff_get_audio_buffer(ctx->inputs[0], seg->block_size);
224  seg->buffer = ff_get_audio_buffer(ctx->inputs[0], seg->part_size);
225  seg->input = ff_get_audio_buffer(ctx->inputs[0], seg->input_size);
226  seg->output = ff_get_audio_buffer(ctx->inputs[0], seg->part_size * 5);
227  if (!seg->buffer || !seg->sumin || !seg->sumout || !seg->blockout ||
228  !seg->input || !seg->output || !seg->tempin || !seg->tempout)
229  return AVERROR(ENOMEM);
230 
231  return 0;
232 }
233 
235 {
236  AudioFIRContext *s = ctx->priv;
237 
238  if (seg->ctx) {
239  for (int ch = 0; ch < s->nb_channels; ch++)
240  av_tx_uninit(&seg->ctx[ch]);
241  }
242  av_freep(&seg->ctx);
243 
244  if (seg->tx) {
245  for (int ch = 0; ch < s->nb_channels; ch++)
246  av_tx_uninit(&seg->tx[ch]);
247  }
248  av_freep(&seg->tx);
249 
250  if (seg->itx) {
251  for (int ch = 0; ch < s->nb_channels; ch++)
252  av_tx_uninit(&seg->itx[ch]);
253  }
254  av_freep(&seg->itx);
255 
256  av_freep(&seg->loading);
257  av_freep(&seg->output_offset);
258  av_freep(&seg->part_index);
259 
260  av_frame_free(&seg->tempin);
261  av_frame_free(&seg->tempout);
262  av_frame_free(&seg->blockout);
263  av_frame_free(&seg->sumin);
264  av_frame_free(&seg->sumout);
265  av_frame_free(&seg->buffer);
266  av_frame_free(&seg->input);
267  av_frame_free(&seg->output);
268  seg->input_size = 0;
269 
270  for (int i = 0; i < MAX_IR_STREAMS; i++)
271  av_frame_free(&seg->coeff[i]);
272 }
273 
274 static int convert_coeffs(AVFilterContext *ctx, int selir)
275 {
276  AudioFIRContext *s = ctx->priv;
277  int ret, nb_taps, cur_nb_taps;
278 
279  if (!s->nb_taps[selir]) {
280  int part_size, max_part_size;
281  int left, offset = 0;
282 
283  s->nb_taps[selir] = ff_inlink_queued_samples(ctx->inputs[1 + selir]);
284  if (s->nb_taps[selir] <= 0)
285  return AVERROR(EINVAL);
286 
287  if (s->minp > s->maxp)
288  s->maxp = s->minp;
289 
290  if (s->nb_segments)
291  goto skip;
292 
293  left = s->nb_taps[selir];
294  part_size = 1 << av_log2(s->minp);
295  max_part_size = 1 << av_log2(s->maxp);
296 
297  s->min_part_size = part_size;
298 
299  for (int i = 0; left > 0; i++) {
300  int step = part_size == max_part_size ? INT_MAX : 1 + (i == 0);
301  int nb_partitions = FFMIN(step, (left + part_size - 1) / part_size);
302 
303  s->nb_segments = i + 1;
304  ret = init_segment(ctx, &s->seg[i], selir, offset, nb_partitions, part_size, i);
305  if (ret < 0)
306  return ret;
307  offset += nb_partitions * part_size;
308  left -= nb_partitions * part_size;
309  part_size *= 2;
310  part_size = FFMIN(part_size, max_part_size);
311  }
312  }
313 
314 skip:
315  if (!s->ir[selir]) {
316  ret = ff_inlink_consume_samples(ctx->inputs[1 + selir], s->nb_taps[selir], s->nb_taps[selir], &s->ir[selir]);
317  if (ret < 0)
318  return ret;
319  if (ret == 0)
320  return AVERROR_BUG;
321  }
322 
323  if (s->response) {
324  switch (s->format) {
325  case AV_SAMPLE_FMT_FLTP:
326  draw_response_float(ctx, s->video);
327  break;
328  case AV_SAMPLE_FMT_DBLP:
329  draw_response_double(ctx, s->video);
330  break;
331  }
332  }
333 
334  cur_nb_taps = s->ir[selir]->nb_samples;
335  nb_taps = cur_nb_taps;
336 
337  if (!s->norm_ir[selir] || s->norm_ir[selir]->nb_samples < nb_taps) {
338  av_frame_free(&s->norm_ir[selir]);
339  s->norm_ir[selir] = ff_get_audio_buffer(ctx->inputs[0], FFALIGN(nb_taps, 8));
340  if (!s->norm_ir[selir])
341  return AVERROR(ENOMEM);
342  }
343 
344  av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", cur_nb_taps);
345  av_log(ctx, AV_LOG_DEBUG, "nb_segments: %d\n", s->nb_segments);
346 
347  switch (s->format) {
348  case AV_SAMPLE_FMT_FLTP:
349  for (int ch = 0; ch < s->nb_channels; ch++) {
350  const float *tsrc = (const float *)s->ir[selir]->extended_data[!s->one2many * ch];
351  float *time = (float *)s->norm_ir[selir]->extended_data[ch];
352 
353  memcpy(time, tsrc, sizeof(*time) * nb_taps);
354  for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
355  time[i] = 0;
356 
357  get_power_float(ctx, s, nb_taps, ch, time);
358 
359  for (int n = 0; n < s->nb_segments; n++) {
360  AudioFIRSegment *seg = &s->seg[n];
361 
362  if (!seg->coeff[selir])
363  seg->coeff[selir] = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
364  if (!seg->coeff[selir])
365  return AVERROR(ENOMEM);
366 
367  for (int i = 0; i < seg->nb_partitions; i++)
368  convert_channel_float(ctx, s, ch, seg, i, selir);
369  }
370  }
371  break;
372  case AV_SAMPLE_FMT_DBLP:
373  for (int ch = 0; ch < s->nb_channels; ch++) {
374  const double *tsrc = (const double *)s->ir[selir]->extended_data[!s->one2many * ch];
375  double *time = (double *)s->norm_ir[selir]->extended_data[ch];
376 
377  memcpy(time, tsrc, sizeof(*time) * nb_taps);
378  for (int i = FFMAX(1, s->length * nb_taps); i < nb_taps; i++)
379  time[i] = 0;
380 
381  get_power_double(ctx, s, nb_taps, ch, time);
382  for (int n = 0; n < s->nb_segments; n++) {
383  AudioFIRSegment *seg = &s->seg[n];
384 
385  if (!seg->coeff[selir])
386  seg->coeff[selir] = ff_get_audio_buffer(ctx->inputs[0], seg->nb_partitions * seg->coeff_size * 2);
387  if (!seg->coeff[selir])
388  return AVERROR(ENOMEM);
389 
390  for (int i = 0; i < seg->nb_partitions; i++)
391  convert_channel_double(ctx, s, ch, seg, i, selir);
392  }
393  }
394  break;
395  }
396 
397  s->have_coeffs[selir] = 1;
398 
399  return 0;
400 }
401 
403 {
404  AVFilterContext *ctx = link->dst;
405  AudioFIRContext *s = ctx->priv;
406  int nb_taps, max_nb_taps;
407 
408  nb_taps = ff_inlink_queued_samples(link);
409  max_nb_taps = s->max_ir_len * ctx->outputs[0]->sample_rate;
410  if (nb_taps > max_nb_taps) {
411  av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
412  return AVERROR(EINVAL);
413  }
414 
415  return 0;
416 }
417 
419 {
420  AudioFIRContext *s = ctx->priv;
421  AVFilterLink *outlink = ctx->outputs[0];
422  int ret, status, available, wanted;
423  AVFrame *in = NULL;
424  int64_t pts;
425 
427  if (s->response)
429  if (!s->eof_coeffs[s->selir]) {
430  ret = check_ir(ctx->inputs[1 + s->selir]);
431  if (ret < 0)
432  return ret;
433 
434  if (ff_outlink_get_status(ctx->inputs[1 + s->selir]) == AVERROR_EOF)
435  s->eof_coeffs[s->selir] = 1;
436 
437  if (!s->eof_coeffs[s->selir]) {
438  if (ff_outlink_frame_wanted(ctx->outputs[0]))
439  ff_inlink_request_frame(ctx->inputs[1 + s->selir]);
440  else if (s->response && ff_outlink_frame_wanted(ctx->outputs[1]))
441  ff_inlink_request_frame(ctx->inputs[1 + s->selir]);
442  return 0;
443  }
444  }
445 
446  if (!s->have_coeffs[s->selir] && s->eof_coeffs[s->selir]) {
447  ret = convert_coeffs(ctx, s->selir);
448  if (ret < 0)
449  return ret;
450  }
451 
452  available = ff_inlink_queued_samples(ctx->inputs[0]);
453  wanted = FFMAX(s->min_part_size, (available / s->min_part_size) * s->min_part_size);
454  ret = ff_inlink_consume_samples(ctx->inputs[0], wanted, wanted, &in);
455  if (ret > 0)
456  ret = fir_frame(s, in, outlink);
457 
458  if (ret < 0)
459  return ret;
460 
461  if (s->response && s->have_coeffs[s->selir]) {
462  int64_t old_pts = s->video->pts;
463  int64_t new_pts = av_rescale_q(s->pts, ctx->inputs[0]->time_base, ctx->outputs[1]->time_base);
464 
465  if (ff_outlink_frame_wanted(ctx->outputs[1]) && old_pts < new_pts) {
466  AVFrame *clone;
467  s->video->pts = new_pts;
468  clone = av_frame_clone(s->video);
469  if (!clone)
470  return AVERROR(ENOMEM);
471  return ff_filter_frame(ctx->outputs[1], clone);
472  }
473  }
474 
475  if (ff_inlink_queued_samples(ctx->inputs[0]) >= s->min_part_size) {
477  return 0;
478  }
479 
480  if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
481  if (status == AVERROR_EOF) {
482  ff_outlink_set_status(ctx->outputs[0], status, pts);
483  if (s->response)
484  ff_outlink_set_status(ctx->outputs[1], status, pts);
485  return 0;
486  }
487  }
488 
489  if (ff_outlink_frame_wanted(ctx->outputs[0]) &&
490  !ff_outlink_get_status(ctx->inputs[0])) {
491  ff_inlink_request_frame(ctx->inputs[0]);
492  return 0;
493  }
494 
495  if (s->response &&
496  ff_outlink_frame_wanted(ctx->outputs[1]) &&
497  !ff_outlink_get_status(ctx->inputs[0])) {
498  ff_inlink_request_frame(ctx->inputs[0]);
499  return 0;
500  }
501 
502  return FFERROR_NOT_READY;
503 }
504 
506 {
507  AudioFIRContext *s = ctx->priv;
508  static const enum AVSampleFormat sample_fmts[3][3] = {
512  };
513  static const enum AVPixelFormat pix_fmts[] = {
516  };
517  int ret;
518 
519  if (s->response) {
520  AVFilterLink *videolink = ctx->outputs[1];
522  if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)
523  return ret;
524  }
525 
526  if (s->ir_format) {
528  if (ret < 0)
529  return ret;
530  } else {
533 
534  if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
535  return ret;
536  if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
537  return ret;
538 
540  if (ret)
541  return ret;
542  for (int i = 1; i < ctx->nb_inputs; i++) {
543  if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
544  return ret;
545  }
546  }
547 
548  if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts[s->precision])) < 0)
549  return ret;
550 
552 }
553 
554 static int config_output(AVFilterLink *outlink)
555 {
556  AVFilterContext *ctx = outlink->src;
557  AudioFIRContext *s = ctx->priv;
558  int ret;
559 
560  s->one2many = ctx->inputs[1 + s->selir]->ch_layout.nb_channels == 1;
561  outlink->sample_rate = ctx->inputs[0]->sample_rate;
562  outlink->time_base = ctx->inputs[0]->time_base;
563 #if FF_API_OLD_CHANNEL_LAYOUT
565  outlink->channel_layout = ctx->inputs[0]->channel_layout;
567 #endif
568  if ((ret = av_channel_layout_copy(&outlink->ch_layout, &ctx->inputs[0]->ch_layout)) < 0)
569  return ret;
570  outlink->ch_layout.nb_channels = ctx->inputs[0]->ch_layout.nb_channels;
571 
572  s->format = outlink->format;
573  s->nb_channels = outlink->ch_layout.nb_channels;
574 
575  return 0;
576 }
577 
579 {
580  AudioFIRContext *s = ctx->priv;
581 
582  for (int i = 0; i < s->nb_segments; i++)
583  uninit_segment(ctx, &s->seg[i]);
584 
585  av_freep(&s->fdsp);
586 
587  for (int i = 0; i < s->nb_irs; i++) {
588  av_frame_free(&s->ir[i]);
589  av_frame_free(&s->norm_ir[i]);
590  }
591 
592  av_frame_free(&s->video);
593 }
594 
595 static int config_video(AVFilterLink *outlink)
596 {
597  AVFilterContext *ctx = outlink->src;
598  AudioFIRContext *s = ctx->priv;
599 
600  outlink->sample_aspect_ratio = (AVRational){1,1};
601  outlink->w = s->w;
602  outlink->h = s->h;
603  outlink->frame_rate = s->frame_rate;
604  outlink->time_base = av_inv_q(outlink->frame_rate);
605 
606  av_frame_free(&s->video);
607  s->video = ff_get_video_buffer(outlink, outlink->w, outlink->h);
608  if (!s->video)
609  return AVERROR(ENOMEM);
610 
611  return 0;
612 }
613 
615 {
616  AudioFIRContext *s = ctx->priv;
617  AVFilterPad pad, vpad;
618  int ret;
619 
620  s->prev_selir = FFMIN(s->nb_irs - 1, s->selir);
621 
622  pad = (AVFilterPad) {
623  .name = "main",
624  .type = AVMEDIA_TYPE_AUDIO,
625  };
626 
627  ret = ff_append_inpad(ctx, &pad);
628  if (ret < 0)
629  return ret;
630 
631  for (int n = 0; n < s->nb_irs; n++) {
632  pad = (AVFilterPad) {
633  .name = av_asprintf("ir%d", n),
634  .type = AVMEDIA_TYPE_AUDIO,
635  };
636 
637  if (!pad.name)
638  return AVERROR(ENOMEM);
639 
641  if (ret < 0)
642  return ret;
643  }
644 
645  pad = (AVFilterPad) {
646  .name = "default",
647  .type = AVMEDIA_TYPE_AUDIO,
648  .config_props = config_output,
649  };
650 
651  ret = ff_append_outpad(ctx, &pad);
652  if (ret < 0)
653  return ret;
654 
655  if (s->response) {
656  vpad = (AVFilterPad){
657  .name = "filter_response",
658  .type = AVMEDIA_TYPE_VIDEO,
659  .config_props = config_video,
660  };
661 
662  ret = ff_append_outpad(ctx, &vpad);
663  if (ret < 0)
664  return ret;
665  }
666 
667  s->fdsp = avpriv_float_dsp_alloc(0);
668  if (!s->fdsp)
669  return AVERROR(ENOMEM);
670 
671  ff_afir_init(&s->afirdsp);
672 
673  return 0;
674 }
675 
677  const char *cmd,
678  const char *arg,
679  char *res,
680  int res_len,
681  int flags)
682 {
683  AudioFIRContext *s = ctx->priv;
684  int prev_selir, ret;
685 
686  prev_selir = s->selir;
687  ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags);
688  if (ret < 0)
689  return ret;
690 
691  s->selir = FFMIN(s->nb_irs - 1, s->selir);
692  if (s->selir != prev_selir) {
693  s->prev_selir = prev_selir;
694  for (int n = 0; n < s->nb_segments; n++) {
695  AudioFIRSegment *seg = &s->seg[n];
696 
697  for (int ch = 0; ch < s->nb_channels; ch++)
698  seg->loading[ch] = 0;
699  }
700  }
701 
702  return 0;
703 }
704 
705 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
706 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
707 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
708 #define OFFSET(x) offsetof(AudioFIRContext, x)
709 
710 static const AVOption afir_options[] = {
711  { "dry", "set dry gain", OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
712  { "wet", "set wet gain", OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 10, AFR },
713  { "length", "set IR length", OFFSET(length), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
714  { "gtype", "set IR auto gain type",OFFSET(gtype), AV_OPT_TYPE_INT, {.i64=0}, -1, 4, AF, "gtype" },
715  { "none", "without auto gain", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF, "gtype" },
716  { "peak", "peak gain", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "gtype" },
717  { "dc", "DC gain", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "gtype" },
718  { "gn", "gain to noise", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "gtype" },
719  { "ac", "AC gain", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, AF, "gtype" },
720  { "rms", "RMS gain", 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, AF, "gtype" },
721  { "irgain", "set IR gain", OFFSET(ir_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
722  { "irfmt", "set IR format", OFFSET(ir_format), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, AF, "irfmt" },
723  { "mono", "single channel", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "irfmt" },
724  { "input", "same as input", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "irfmt" },
725  { "maxir", "set max IR length", OFFSET(max_ir_len), AV_OPT_TYPE_FLOAT, {.dbl=30}, 0.1, 60, AF },
726  { "response", "show IR frequency response", OFFSET(response), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
727  { "channel", "set IR channel to display frequency response", OFFSET(ir_channel), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, VF },
728  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, VF },
729  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT32_MAX, VF },
730  { "minp", "set min partition size", OFFSET(minp), AV_OPT_TYPE_INT, {.i64=8192}, 1, 65536, AF },
731  { "maxp", "set max partition size", OFFSET(maxp), AV_OPT_TYPE_INT, {.i64=8192}, 8, 65536, AF },
732  { "nbirs", "set number of input IRs",OFFSET(nb_irs),AV_OPT_TYPE_INT, {.i64=1}, 1, 32, AF },
733  { "ir", "select IR", OFFSET(selir), AV_OPT_TYPE_INT, {.i64=0}, 0, 31, AFR },
734  { "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, AF, "precision" },
735  { "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "precision" },
736  { "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "precision" },
737  { "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "precision" },
738  { NULL }
739 };
740 
742 
744  .name = "afir",
745  .description = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in additional stream(s)."),
746  .priv_size = sizeof(AudioFIRContext),
747  .priv_class = &afir_class,
749  .init = init,
750  .activate = activate,
751  .uninit = uninit,
752  .process_command = process_command,
756 };
AudioFIRSegment::loading
int * loading
Definition: af_afir.h:42
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:101
activate
static int activate(AVFilterContext *ctx)
Definition: af_afir.c:418
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:100
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
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
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
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:380
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AudioFIRSegment::block_size
int block_size
Definition: af_afir.h:36
out
FILE * out
Definition: movenc.c:54
color
Definition: vf_paletteuse.c:509
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:591
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:707
rational.h
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:116
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
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:566
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
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:51
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:167
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:739
AudioFIRSegment::tx_fn
av_tx_fn tx_fn
Definition: af_afir.h:57
float.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
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:311
AudioFIRSegment::input_size
int input_size
Definition: af_afir.h:39
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:883
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
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:57
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
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afir.c:578
convert_coeffs
static int convert_coeffs(AVFilterContext *ctx, int selir)
Definition: af_afir.c:274
af_afirdsp.h
fir_channels
static int fir_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afir.c:124
afir_options
static const AVOption afir_options[]
Definition: af_afir.c:710
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:654
AudioFIRSegment::blockout
AVFrame * blockout
Definition: af_afir.h:48
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:116
uninit_segment
static void uninit_segment(AVFilterContext *ctx, AudioFIRSegment *seg)
Definition: af_afir.c:234
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
AudioFIRSegment
Definition: af_afir.h:33
AudioFIRSegment::tx
AVTXContext ** tx
Definition: af_afir.h:56
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
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:1490
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:596
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:755
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
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:474
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:64
AudioFIRSegment::coeff
AVFrame * coeff[MAX_IR_STREAMS]
Definition: af_afir.h:52
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:1392
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:603
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:131
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:72
AudioFIRSegment::itx_fn
av_tx_fn itx_fn
Definition: af_afir.h:57
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:265
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:721
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:466
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:1327
AFR
#define AFR
Definition: af_afir.c:706
index
int index
Definition: gxfenc.c:89
float_dsp.h
AudioFIRSegment::output
AVFrame * output
Definition: af_afir.h:54
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:122
AudioFIRSegment::tempout
AVFrame * tempout
Definition: af_afir.h:50
MAX_IR_STREAMS
#define MAX_IR_STREAMS
Definition: af_afir.h:31
f
f
Definition: af_crystalizer.c:122
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:115
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:301
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:705
check_ir
static int check_ir(AVFilterLink *link)
Definition: af_afir.c:402
AudioFIRSegment::sumin
AVFrame * sumin
Definition: af_afir.h:46
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:858
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:49
AudioFIRSegment::ctx
AVTXContext ** ctx
Definition: af_afir.h:56
ff_af_afir
const AVFilter ff_af_afir
Definition: af_afir.c:743
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:505
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:410
OFFSET
#define OFFSET(x)
Definition: af_afir.c:708
config_video
static int config_video(AVFilterLink *outlink)
Definition: af_afir.c:595
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AudioFIRSegment::input
AVFrame * input
Definition: af_afir.h:53
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:793
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:55
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1352
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
AVFilter
Filter definition.
Definition: avfilter.h:171
ret
ret
Definition: filter_design.txt:187
AudioFIRSegment::itx
AVTXContext ** itx
Definition: af_afir.h:56
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
AudioFIRSegment::fft_length
int fft_length
Definition: af_afir.h:37
channel_layout.h
AudioFIRSegment::sumout
AVFrame * sumout
Definition: af_afir.h:47
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_afir.c:554
AudioFIRContext
Definition: af_afir.h:60
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:105
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
ff_outlink_get_status
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1513
AVFilterContext
An instance of a filter.
Definition: avfilter.h:402
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:639
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
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:127
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:136
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:506
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:368
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:137
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:614
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:156
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:676
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:375
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:159
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:142
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:43
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:49
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:199
tx.h
AudioFIRSegment::part_index
int * part_index
Definition: af_afir.h:44