FFmpeg
avf_showcwt.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2022 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 #include <float.h>
22 #include <math.h>
23 
24 #include "libavutil/mem.h"
25 #include "libavutil/tx.h"
26 #include "libavutil/channel_layout.h"
27 #include "libavutil/float_dsp.h"
28 #include "libavutil/cpu.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/parseutils.h"
31 #include "audio.h"
32 #include "formats.h"
33 #include "video.h"
34 #include "avfilter.h"
35 #include "filters.h"
36 
37 enum FrequencyScale {
38  FSCALE_LINEAR,
39  FSCALE_LOG,
40  FSCALE_BARK,
41  FSCALE_MEL,
42  FSCALE_ERBS,
43  FSCALE_SQRT,
44  FSCALE_CBRT,
45  FSCALE_QDRT,
46  FSCALE_FM,
47  NB_FSCALE
48 };
49 
50 enum IntensityScale {
51  ISCALE_LOG,
52  ISCALE_LINEAR,
53  ISCALE_SQRT,
54  ISCALE_CBRT,
55  ISCALE_QDRT,
56  NB_ISCALE
57 };
58 
59 enum DirectionMode {
60  DIRECTION_LR,
61  DIRECTION_RL,
62  DIRECTION_UD,
63  DIRECTION_DU,
64  NB_DIRECTION
65 };
66 
67 enum SlideMode {
68  SLIDE_REPLACE,
69  SLIDE_SCROLL,
70  SLIDE_FRAME,
71  NB_SLIDE
72 };
73 
74 typedef struct ShowCWTContext {
75  const AVClass *class;
76  int w, h;
77  int mode;
78  char *rate_str;
79  AVRational auto_frame_rate;
80  AVRational frame_rate;
81  AVTXContext **fft, **ifft;
82  av_tx_fn tx_fn, itx_fn;
83  int fft_size, ifft_size;
84  int pos;
85  int64_t in_pts;
86  int64_t old_pts;
87  int64_t eof_pts;
88  float *frequency_band;
89  AVComplexFloat **kernel;
90  unsigned *index;
91  int *kernel_start, *kernel_stop;
92  AVFrame *cache;
93  AVFrame *outpicref;
94  AVFrame *fft_in;
95  AVFrame *fft_out;
96  AVFrame *dst_x;
97  AVFrame *src_x;
98  AVFrame *ifft_in;
99  AVFrame *ifft_out;
100  AVFrame *ch_out;
101  AVFrame *over;
102  AVFrame *bh_out;
103  int nb_threads;
104  int nb_channels;
105  int nb_consumed_samples;
106  int pps;
107  int eof;
108  int slide;
109  int new_frame;
110  int direction;
111  int hop_size, ihop_size;
112  int hop_index, ihop_index;
113  int input_padding_size, output_padding_size;
114  int input_sample_count, output_sample_count;
115  int frequency_band_count;
116  float logarithmic_basis;
117  int intensity_scale;
118  int frequency_scale;
119  float minimum_frequency, maximum_frequency;
120  float minimum_intensity, maximum_intensity;
121  float deviation;
122  float bar_ratio;
123  int bar_size;
124  int sono_size;
125  float rotation;
126 
127  AVFloatDSPContext *fdsp;
128 } ShowCWTContext;
129 
130 #define OFFSET(x) offsetof(ShowCWTContext, x)
131 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
132 
133 static const AVOption showcwt_options[] = {
134  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x512"}, 0, 0, FLAGS },
135  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x512"}, 0, 0, FLAGS },
136  { "rate", "set video rate", OFFSET(rate_str), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, FLAGS },
137  { "r", "set video rate", OFFSET(rate_str), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, FLAGS },
138  { "scale", "set frequency scale", OFFSET(frequency_scale), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_FSCALE-1, FLAGS, .unit = "scale" },
139  { "linear", "linear", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_LINEAR}, 0, 0, FLAGS, .unit = "scale" },
140  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_LOG}, 0, 0, FLAGS, .unit = "scale" },
141  { "bark", "bark", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_BARK}, 0, 0, FLAGS, .unit = "scale" },
142  { "mel", "mel", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_MEL}, 0, 0, FLAGS, .unit = "scale" },
143  { "erbs", "erbs", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_ERBS}, 0, 0, FLAGS, .unit = "scale" },
144  { "sqrt", "sqrt", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_SQRT}, 0, 0, FLAGS, .unit = "scale" },
145  { "cbrt", "cbrt", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_CBRT}, 0, 0, FLAGS, .unit = "scale" },
146  { "qdrt", "qdrt", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_QDRT}, 0, 0, FLAGS, .unit = "scale" },
147  { "fm", "fm", 0, AV_OPT_TYPE_CONST,{.i64=FSCALE_FM}, 0, 0, FLAGS, .unit = "scale" },
148  { "iscale", "set intensity scale", OFFSET(intensity_scale),AV_OPT_TYPE_INT, {.i64=0}, 0, NB_ISCALE-1, FLAGS, .unit = "iscale" },
149  { "linear", "linear", 0, AV_OPT_TYPE_CONST,{.i64=ISCALE_LINEAR}, 0, 0, FLAGS, .unit = "iscale" },
150  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST,{.i64=ISCALE_LOG}, 0, 0, FLAGS, .unit = "iscale" },
151  { "sqrt", "sqrt", 0, AV_OPT_TYPE_CONST,{.i64=ISCALE_SQRT}, 0, 0, FLAGS, .unit = "iscale" },
152  { "cbrt", "cbrt", 0, AV_OPT_TYPE_CONST,{.i64=ISCALE_CBRT}, 0, 0, FLAGS, .unit = "iscale" },
153  { "qdrt", "qdrt", 0, AV_OPT_TYPE_CONST,{.i64=ISCALE_QDRT}, 0, 0, FLAGS, .unit = "iscale" },
154  { "min", "set minimum frequency", OFFSET(minimum_frequency), AV_OPT_TYPE_FLOAT, {.dbl = 20.}, 1, 192000, FLAGS },
155  { "max", "set maximum frequency", OFFSET(maximum_frequency), AV_OPT_TYPE_FLOAT, {.dbl = 20000.}, 1, 192000, FLAGS },
156  { "imin", "set minimum intensity", OFFSET(minimum_intensity), AV_OPT_TYPE_FLOAT, {.dbl = 0.}, 0, 1, FLAGS },
157  { "imax", "set maximum intensity", OFFSET(maximum_intensity), AV_OPT_TYPE_FLOAT, {.dbl = 1.}, 0, 1, FLAGS },
158  { "logb", "set logarithmic basis", OFFSET(logarithmic_basis), AV_OPT_TYPE_FLOAT, {.dbl = 0.0001}, 0, 1, FLAGS },
159  { "deviation", "set frequency deviation", OFFSET(deviation), AV_OPT_TYPE_FLOAT, {.dbl = 1.}, 0, 100, FLAGS },
160  { "pps", "set pixels per second", OFFSET(pps), AV_OPT_TYPE_INT, {.i64 = 64}, 1, 1024, FLAGS },
161  { "mode", "set output mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 4, FLAGS, .unit = "mode" },
162  { "magnitude", "magnitude", 0, AV_OPT_TYPE_CONST,{.i64=0}, 0, 0, FLAGS, .unit = "mode" },
163  { "phase", "phase", 0, AV_OPT_TYPE_CONST,{.i64=1}, 0, 0, FLAGS, .unit = "mode" },
164  { "magphase", "magnitude+phase", 0, AV_OPT_TYPE_CONST,{.i64=2}, 0, 0, FLAGS, .unit = "mode" },
165  { "channel", "color per channel", 0, AV_OPT_TYPE_CONST,{.i64=3}, 0, 0, FLAGS, .unit = "mode" },
166  { "stereo", "stereo difference", 0, AV_OPT_TYPE_CONST,{.i64=4}, 0, 0, FLAGS, .unit = "mode" },
167  { "slide", "set slide mode", OFFSET(slide), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_SLIDE-1, FLAGS, .unit = "slide" },
168  { "replace", "replace", 0, AV_OPT_TYPE_CONST,{.i64=SLIDE_REPLACE},0, 0, FLAGS, .unit = "slide" },
169  { "scroll", "scroll", 0, AV_OPT_TYPE_CONST,{.i64=SLIDE_SCROLL}, 0, 0, FLAGS, .unit = "slide" },
170  { "frame", "frame", 0, AV_OPT_TYPE_CONST,{.i64=SLIDE_FRAME}, 0, 0, FLAGS, .unit = "slide" },
171  { "direction", "set direction mode", OFFSET(direction), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_DIRECTION-1, FLAGS, .unit = "direction" },
172  { "lr", "left to right", 0, AV_OPT_TYPE_CONST,{.i64=DIRECTION_LR}, 0, 0, FLAGS, .unit = "direction" },
173  { "rl", "right to left", 0, AV_OPT_TYPE_CONST,{.i64=DIRECTION_RL}, 0, 0, FLAGS, .unit = "direction" },
174  { "ud", "up to down", 0, AV_OPT_TYPE_CONST,{.i64=DIRECTION_UD}, 0, 0, FLAGS, .unit = "direction" },
175  { "du", "down to up", 0, AV_OPT_TYPE_CONST,{.i64=DIRECTION_DU}, 0, 0, FLAGS, .unit = "direction" },
176  { "bar", "set bargraph ratio", OFFSET(bar_ratio), AV_OPT_TYPE_FLOAT, {.dbl = 0.}, 0, 1, FLAGS },
177  { "rotation", "set color rotation", OFFSET(rotation), AV_OPT_TYPE_FLOAT, {.dbl = 0}, -1, 1, FLAGS },
178  { NULL }
179 };
180 
181 AVFILTER_DEFINE_CLASS(showcwt);
182 
183 static av_cold void uninit(AVFilterContext *ctx)
184 {
185  ShowCWTContext *s = ctx->priv;
186 
187  av_freep(&s->frequency_band);
188  av_freep(&s->kernel_start);
189  av_freep(&s->kernel_stop);
190  av_freep(&s->index);
191 
192  av_frame_free(&s->cache);
193  av_frame_free(&s->outpicref);
194  av_frame_free(&s->fft_in);
195  av_frame_free(&s->fft_out);
196  av_frame_free(&s->dst_x);
197  av_frame_free(&s->src_x);
198  av_frame_free(&s->ifft_in);
199  av_frame_free(&s->ifft_out);
200  av_frame_free(&s->ch_out);
201  av_frame_free(&s->over);
202  av_frame_free(&s->bh_out);
203 
204  if (s->fft) {
205  for (int n = 0; n < s->nb_threads; n++)
206  av_tx_uninit(&s->fft[n]);
207  av_freep(&s->fft);
208  }
209 
210  if (s->ifft) {
211  for (int n = 0; n < s->nb_threads; n++)
212  av_tx_uninit(&s->ifft[n]);
213  av_freep(&s->ifft);
214  }
215 
216  if (s->kernel) {
217  for (int n = 0; n < s->frequency_band_count; n++)
218  av_freep(&s->kernel[n]);
219  }
220  av_freep(&s->kernel);
221 
222  av_freep(&s->fdsp);
223 }
224 
225 static int query_formats(const AVFilterContext *ctx,
226  AVFilterFormatsConfig **cfg_in,
227  AVFilterFormatsConfig **cfg_out)
228 {
229  AVFilterFormats *formats = NULL;
230  static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
231  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
232  int ret;
233 
234  formats = ff_make_sample_format_list(sample_fmts);
235  if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
236  return ret;
237 
238  formats = ff_make_pixel_format_list(pix_fmts);
239  if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
240  return ret;
241 
242  return 0;
243 }
244 
245 static float frequency_band(float *frequency_band,
246  int frequency_band_count,
247  float frequency_range,
248  float frequency_offset,
249  int frequency_scale, float deviation)
250 {
251  float ret = 0.f;
252 
253  deviation = sqrtf(deviation / (4.f * M_PI)); // Heisenberg Gabor Limit
254  for (int y = 0; y < frequency_band_count; y++) {
255  float frequency = frequency_range * (1.f - (float)y / frequency_band_count) + frequency_offset;
256  float frequency_derivative = frequency_range / frequency_band_count;
257 
258  switch (frequency_scale) {
259  case FSCALE_LOG:
260  frequency = powf(2.f, frequency);
261  frequency_derivative *= logf(2.f) * frequency;
262  break;
263  case FSCALE_BARK:
264  frequency = 600.f * sinhf(frequency / 6.f);
265  frequency_derivative *= sqrtf(frequency * frequency + 360000.f) / 6.f;
266  break;
267  case FSCALE_MEL:
268  frequency = 700.f * (powf(10.f, frequency / 2595.f) - 1.f);
269  frequency_derivative *= (frequency + 700.f) * logf(10.f) / 2595.f;
270  break;
271  case FSCALE_ERBS:
272  frequency = 676170.4f / (47.06538f - expf(frequency * 0.08950404f)) - 14678.49f;
273  frequency_derivative *= (frequency * frequency + 14990.4f * frequency + 4577850.f) / 160514.f;
274  break;
275  case FSCALE_SQRT:
276  frequency = frequency * frequency;
277  frequency_derivative *= 2.f * sqrtf(frequency);
278  break;
279  case FSCALE_CBRT:
280  frequency = frequency * frequency * frequency;
281  frequency_derivative *= 3.f * powf(frequency, 2.f / 3.f);
282  break;
283  case FSCALE_QDRT:
284  frequency = frequency * frequency * frequency * frequency;
285  frequency_derivative *= 4.f * powf(frequency, 3.f / 4.f);
286  break;
287  case FSCALE_FM:
288  frequency = 2.f * powf(frequency, 3.f / 2.f) / 3.f;
289  frequency_derivative *= sqrtf(frequency);
290  break;
291  }
292 
293  frequency_band[y*2 ] = frequency;
294  frequency_band[y*2+1] = frequency_derivative * deviation;
295 
296  ret = 1.f / (frequency_derivative * deviation);
297  }
298 
299  return ret;
300 }
301 
302 static float remap_log(ShowCWTContext *s, float value, int iscale, float log_factor)
303 {
304  const float max = s->maximum_intensity;
305  const float min = s->minimum_intensity;
306  float ret;
307 
308  value += min;
309 
310  switch (iscale) {
311  case ISCALE_LINEAR:
312  ret = max - expf(value / log_factor);
313  break;
314  case ISCALE_LOG:
315  value = logf(value) * log_factor;
316  ret = max - av_clipf(value, 0.f, 1.f);
317  break;
318  case ISCALE_SQRT:
319  value = max - expf(value / log_factor);
320  ret = sqrtf(value);
321  break;
322  case ISCALE_CBRT:
323  value = max - expf(value / log_factor);
324  ret = cbrtf(value);
325  break;
326  case ISCALE_QDRT:
327  value = max - expf(value / log_factor);
328  ret = powf(value, 0.25f);
329  break;
330  }
331 
332  return av_clipf(ret, 0.f, 1.f);
333 }
334 
335 static int run_channel_cwt_prepare(AVFilterContext *ctx, void *arg, int jobnr, int ch)
336 {
337  ShowCWTContext *s = ctx->priv;
338  const int hop_size = s->hop_size;
339  AVFrame *fin = arg;
340  float *cache = (float *)s->cache->extended_data[ch];
341  AVComplexFloat *src = (AVComplexFloat *)s->fft_in->extended_data[ch];
342  AVComplexFloat *dst = (AVComplexFloat *)s->fft_out->extended_data[ch];
343  const int offset = (s->input_padding_size - hop_size) >> 1;
344 
345  if (fin) {
346  const float *input = (const float *)fin->extended_data[ch];
347  const int offset = s->hop_size - fin->nb_samples;
348 
349  memmove(cache, &cache[fin->nb_samples], offset * sizeof(float));
350  memcpy(&cache[offset], input, fin->nb_samples * sizeof(float));
351  }
352 
353  if (fin && s->hop_index + fin->nb_samples < hop_size)
354  return 0;
355 
356  memset(src, 0, sizeof(float) * s->fft_size);
357  for (int n = 0; n < hop_size; n++)
358  src[n+offset].re = cache[n];
359 
360  s->tx_fn(s->fft[jobnr], dst, src, sizeof(*src));
361 
362  return 0;
363 }
364 
365 #define DRAW_BAR_COLOR(x) \
366 do { \
367  if (Y <= ht) { \
368  dstY[x] = 0; \
369  dstU[x] = 128; \
370  dstV[x] = 128; \
371  } else { \
372  float mul = (Y - ht) * bh[0]; \
373  dstY[x] = av_clip_uint8(lrintf(Y * mul * 255.f)); \
374  dstU[x] = av_clip_uint8(lrintf((U-0.5f) * 128.f + 128)); \
375  dstV[x] = av_clip_uint8(lrintf((V-0.5f) * 128.f + 128)); \
376  } \
377 } while (0)
378 
379 static void draw_bar(ShowCWTContext *s, int y,
380  float Y, float U, float V)
381 {
382  float *bh = ((float *)s->bh_out->extended_data[0]) + y;
383  const ptrdiff_t ylinesize = s->outpicref->linesize[0];
384  const ptrdiff_t ulinesize = s->outpicref->linesize[1];
385  const ptrdiff_t vlinesize = s->outpicref->linesize[2];
386  const int direction = s->direction;
387  const int sono_size = s->sono_size;
388  const int bar_size = s->bar_size;
389  const float rcp_bar_h = 1.f / bar_size;
390  uint8_t *dstY, *dstU, *dstV;
391  const int w = s->w;
392 
393  bh[0] = 1.f / (Y + 0.0001f);
394  switch (direction) {
395  case DIRECTION_LR:
396  dstY = s->outpicref->data[0] + y * ylinesize;
397  dstU = s->outpicref->data[1] + y * ulinesize;
398  dstV = s->outpicref->data[2] + y * vlinesize;
399  for (int x = 0; x < bar_size; x++) {
400  float ht = (bar_size - x) * rcp_bar_h;
401  DRAW_BAR_COLOR(x);
402  }
403  break;
404  case DIRECTION_RL:
405  dstY = s->outpicref->data[0] + y * ylinesize;
406  dstU = s->outpicref->data[1] + y * ulinesize;
407  dstV = s->outpicref->data[2] + y * vlinesize;
408  for (int x = 0; x < bar_size; x++) {
409  float ht = x * rcp_bar_h;
410  DRAW_BAR_COLOR(w - bar_size + x);
411  }
412  break;
413  case DIRECTION_UD:
414  dstY = s->outpicref->data[0] + w - 1 - y;
415  dstU = s->outpicref->data[1] + w - 1 - y;
416  dstV = s->outpicref->data[2] + w - 1 - y;
417  for (int x = 0; x < bar_size; x++) {
418  float ht = (bar_size - x) * rcp_bar_h;
419  DRAW_BAR_COLOR(0);
420  dstY += ylinesize;
421  dstU += ulinesize;
422  dstV += vlinesize;
423  }
424  break;
425  case DIRECTION_DU:
426  dstY = s->outpicref->data[0] + w - 1 - y + ylinesize * sono_size;
427  dstU = s->outpicref->data[1] + w - 1 - y + ulinesize * sono_size;
428  dstV = s->outpicref->data[2] + w - 1 - y + vlinesize * sono_size;
429  for (int x = 0; x < bar_size; x++) {
430  float ht = x * rcp_bar_h;
431  DRAW_BAR_COLOR(0);
432  dstY += ylinesize;
433  dstU += ulinesize;
434  dstV += vlinesize;
435  }
436  break;
437  }
438 }
439 
440 static int draw(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
441 {
442  ShowCWTContext *s = ctx->priv;
443  const ptrdiff_t ylinesize = s->outpicref->linesize[0];
444  const ptrdiff_t ulinesize = s->outpicref->linesize[1];
445  const ptrdiff_t vlinesize = s->outpicref->linesize[2];
446  const ptrdiff_t alinesize = s->outpicref->linesize[3];
447  const float log_factor = 1.f/logf(s->logarithmic_basis);
448  const int count = s->frequency_band_count;
449  const int start = ff_slice_pos(count, jobnr, nb_jobs);
450  const int end = ff_slice_pos(count, jobnr + 1, nb_jobs);
451  const int nb_channels = s->nb_channels;
452  const int iscale = s->intensity_scale;
453  const int ihop_index = s->ihop_index;
454  const int ihop_size = s->ihop_size;
455  const float rotation = s->rotation;
456  const int direction = s->direction;
457  uint8_t *dstY, *dstU, *dstV, *dstA;
458  const int sono_size = s->sono_size;
459  const int bar_size = s->bar_size;
460  const int mode = s->mode;
461  const int w_1 = s->w - 1;
462  const int x = s->pos;
463  float Y, U, V;
464 
465  for (int y = start; y < end; y++) {
466  const AVComplexFloat *src = ((const AVComplexFloat *)s->ch_out->extended_data[y]) +
467  0 * ihop_size + ihop_index;
468 
469  if (sono_size <= 0)
470  goto skip;
471 
472  switch (direction) {
473  case DIRECTION_LR:
474  case DIRECTION_RL:
475  dstY = s->outpicref->data[0] + y * ylinesize;
476  dstU = s->outpicref->data[1] + y * ulinesize;
477  dstV = s->outpicref->data[2] + y * vlinesize;
478  dstA = s->outpicref->data[3] ? s->outpicref->data[3] + y * alinesize : NULL;
479  break;
480  case DIRECTION_UD:
481  case DIRECTION_DU:
482  dstY = s->outpicref->data[0] + x * ylinesize + w_1 - y;
483  dstU = s->outpicref->data[1] + x * ulinesize + w_1 - y;
484  dstV = s->outpicref->data[2] + x * vlinesize + w_1 - y;
485  dstA = s->outpicref->data[3] ? s->outpicref->data[3] + x * alinesize + w_1 - y : NULL;
486  break;
487  }
488 
489  switch (s->slide) {
490  case SLIDE_REPLACE:
491  case SLIDE_FRAME:
492  /* nothing to do here */
493  break;
494  case SLIDE_SCROLL:
495  switch (s->direction) {
496  case DIRECTION_RL:
497  memmove(dstY, dstY + 1, w_1);
498  memmove(dstU, dstU + 1, w_1);
499  memmove(dstV, dstV + 1, w_1);
500  if (dstA != NULL)
501  memmove(dstA, dstA + 1, w_1);
502  break;
503  case DIRECTION_LR:
504  memmove(dstY + 1, dstY, w_1);
505  memmove(dstU + 1, dstU, w_1);
506  memmove(dstV + 1, dstV, w_1);
507  if (dstA != NULL)
508  memmove(dstA + 1, dstA, w_1);
509  break;
510  }
511  break;
512  }
513 
514  if (direction == DIRECTION_RL ||
515  direction == DIRECTION_LR) {
516  dstY += x;
517  dstU += x;
518  dstV += x;
519  if (dstA != NULL)
520  dstA += x;
521  }
522 skip:
523 
524  switch (mode) {
525  case 4:
526  {
527  const AVComplexFloat *src2 = (nb_channels > 1) ? src + ihop_size: src;
528  float z, u, v;
529 
530  z = hypotf(src[0].re + src2[0].re, src[0].im + src2[0].im);
531  u = hypotf(src[0].re, src[0].im);
532  v = hypotf(src2[0].re, src2[0].im);
533 
534  z = remap_log(s, z, iscale, log_factor);
535  u = remap_log(s, u, iscale, log_factor);
536  v = remap_log(s, v, iscale, log_factor);
537 
538  Y = z;
539  U = sinf((v - u) * M_PI_2);
540  V = sinf((u - v) * M_PI_2);
541 
542  u = U * cosf(rotation * M_PI) - V * sinf(rotation * M_PI);
543  v = U * sinf(rotation * M_PI) + V * cosf(rotation * M_PI);
544 
545  U = 0.5f + 0.5f * z * u;
546  V = 0.5f + 0.5f * z * v;
547 
548  if (sono_size > 0) {
549  dstY[0] = av_clip_uint8(lrintf(Y * 255.f));
550  dstU[0] = av_clip_uint8(lrintf(U * 255.f));
551  dstV[0] = av_clip_uint8(lrintf(V * 255.f));
552  if (dstA)
553  dstA[0] = dstY[0];
554  }
555 
556  if (bar_size > 0)
557  draw_bar(s, y, Y, U, V);
558  }
559  break;
560  case 3:
561  {
562  const int nb_channels = s->nb_channels;
563  const float yf = 1.f / nb_channels;
564 
565  Y = 0.f;
566  U = V = 0.5f;
567  for (int ch = 0; ch < nb_channels; ch++) {
568  const AVComplexFloat *srcn = src + ihop_size * ch;
569  float z;
570 
571  z = hypotf(srcn[0].re, srcn[0].im);
572  z = remap_log(s, z, iscale, log_factor);
573 
574  Y += z * yf;
575  U += z * yf * sinf(2.f * M_PI * (ch * yf + rotation));
576  V += z * yf * cosf(2.f * M_PI * (ch * yf + rotation));
577  }
578 
579  if (sono_size > 0) {
580  dstY[0] = av_clip_uint8(lrintf(Y * 255.f));
581  dstU[0] = av_clip_uint8(lrintf(U * 255.f));
582  dstV[0] = av_clip_uint8(lrintf(V * 255.f));
583  if (dstA)
584  dstA[0] = dstY[0];
585  }
586 
587  if (bar_size > 0)
588  draw_bar(s, y, Y, U, V);
589  }
590  break;
591  case 2:
592  Y = hypotf(src[0].re, src[0].im);
593  Y = remap_log(s, Y, iscale, log_factor);
594  U = atan2f(src[0].im, src[0].re);
595  U = 0.5f + 0.5f * U * Y / M_PI;
596  V = 1.f - U;
597 
598  if (sono_size > 0) {
599  dstY[0] = av_clip_uint8(lrintf(Y * 255.f));
600  dstU[0] = av_clip_uint8(lrintf(U * 255.f));
601  dstV[0] = av_clip_uint8(lrintf(V * 255.f));
602  if (dstA)
603  dstA[0] = dstY[0];
604  }
605 
606  if (bar_size > 0)
607  draw_bar(s, y, Y, U, V);
608  break;
609  case 1:
610  Y = atan2f(src[0].im, src[0].re);
611  Y = 0.5f + 0.5f * Y / M_PI;
612 
613  if (sono_size > 0) {
614  dstY[0] = av_clip_uint8(lrintf(Y * 255.f));
615  if (dstA)
616  dstA[0] = dstY[0];
617  }
618 
619  if (bar_size > 0)
620  draw_bar(s, y, Y, 0.5f, 0.5f);
621  break;
622  case 0:
623  Y = hypotf(src[0].re, src[0].im);
624  Y = remap_log(s, Y, iscale, log_factor);
625 
626  if (sono_size > 0) {
627  dstY[0] = av_clip_uint8(lrintf(Y * 255.f));
628  if (dstA)
629  dstA[0] = dstY[0];
630  }
631 
632  if (bar_size > 0)
633  draw_bar(s, y, Y, 0.5f, 0.5f);
634  break;
635  }
636  }
637 
638  return 0;
639 }
640 
641 static int run_channel_cwt(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
642 {
643  ShowCWTContext *s = ctx->priv;
644  const int ch = *(int *)arg;
645  const AVComplexFloat *fft_out = (const AVComplexFloat *)s->fft_out->extended_data[ch];
646  AVComplexFloat *isrc = (AVComplexFloat *)s->ifft_in->extended_data[jobnr];
647  AVComplexFloat *idst = (AVComplexFloat *)s->ifft_out->extended_data[jobnr];
648  const int output_padding_size = s->output_padding_size;
649  const int input_padding_size = s->input_padding_size;
650  const float scale = 1.f / input_padding_size;
651  const int ihop_size = s->ihop_size;
652  const int count = s->frequency_band_count;
653  const int start = ff_slice_pos(count, jobnr, nb_jobs);
654  const int end = ff_slice_pos(count, jobnr + 1, nb_jobs);
655 
656  for (int y = start; y < end; y++) {
657  AVComplexFloat *chout = ((AVComplexFloat *)s->ch_out->extended_data[y]) + ch * ihop_size;
658  AVComplexFloat *over = ((AVComplexFloat *)s->over->extended_data[ch]) + y * ihop_size;
659  AVComplexFloat *dstx = (AVComplexFloat *)s->dst_x->extended_data[jobnr];
660  AVComplexFloat *srcx = (AVComplexFloat *)s->src_x->extended_data[jobnr];
661  const AVComplexFloat *kernel = s->kernel[y];
662  const unsigned *index = (const unsigned *)s->index;
663  const int kernel_start = s->kernel_start[y];
664  const int kernel_stop = s->kernel_stop[y];
665  const int kernel_range = kernel_stop - kernel_start + 1;
666  int offset;
667 
668  if (kernel_start >= 0) {
669  offset = 0;
670  memcpy(srcx, fft_out + kernel_start, sizeof(*fft_out) * kernel_range);
671  } else {
672  offset = -kernel_start;
673  memcpy(srcx+offset, fft_out, sizeof(*fft_out) * (kernel_range-offset));
674  memcpy(srcx, fft_out+input_padding_size-offset, sizeof(*fft_out)*offset);
675  }
676 
677  s->fdsp->vector_fmul_scalar((float *)srcx, (const float *)srcx, scale, FFALIGN(kernel_range * 2, 4));
678  s->fdsp->vector_fmul((float *)dstx, (const float *)srcx,
679  (const float *)kernel, FFALIGN(kernel_range * 2, 16));
680 
681  memset(isrc, 0, sizeof(*isrc) * output_padding_size);
682  if (offset == 0) {
683  const unsigned *kindex = index + kernel_start;
684  for (int i = 0; i < kernel_range; i++) {
685  const unsigned n = kindex[i];
686 
687  isrc[n].re += dstx[i].re;
688  isrc[n].im += dstx[i].im;
689  }
690  } else {
691  for (int i = 0; i < kernel_range; i++) {
692  const unsigned n = (i-kernel_start) & (output_padding_size-1);
693 
694  isrc[n].re += dstx[i].re;
695  isrc[n].im += dstx[i].im;
696  }
697  }
698 
699  s->itx_fn(s->ifft[jobnr], idst, isrc, sizeof(*isrc));
700 
701  memcpy(chout, idst, sizeof(*chout) * ihop_size);
702  for (int n = 0; n < ihop_size; n++) {
703  chout[n].re += over[n].re;
704  chout[n].im += over[n].im;
705  }
706  memcpy(over, idst + ihop_size, sizeof(*over) * ihop_size);
707  }
708 
709  return 0;
710 }
711 
712 static int compute_kernel(AVFilterContext *ctx)
713 {
714  ShowCWTContext *s = ctx->priv;
715  const int size = s->input_padding_size;
716  const int output_sample_count = s->output_sample_count;
717  const int fsize = s->frequency_band_count;
718  int *kernel_start = s->kernel_start;
719  int *kernel_stop = s->kernel_stop;
720  unsigned *index = s->index;
721  int range_min = INT_MAX;
722  int range_max = 0, ret = 0;
723  float *tkernel;
724 
725  tkernel = av_malloc_array(size, sizeof(*tkernel));
726  if (!tkernel)
727  return AVERROR(ENOMEM);
728 
729  for (int y = 0; y < fsize; y++) {
730  AVComplexFloat *kernel = s->kernel[y];
731  int start = INT_MIN, stop = INT_MAX;
732  const float frequency = s->frequency_band[y*2];
733  const float deviation = 1.f / (s->frequency_band[y*2+1] *
734  output_sample_count);
735  const int a = FFMAX(frequency-12.f*sqrtf(1.f/deviation)-0.5f, -size);
736  const int b = FFMIN(frequency+12.f*sqrtf(1.f/deviation)-0.5f, size+a);
737  const int range = -a;
738 
739  memset(tkernel, 0, size * sizeof(*tkernel));
740  for (int n = a; n < b; n++) {
741  float ff, f = n+0.5f-frequency;
742 
743  ff = expf(-f*f*deviation);
744  tkernel[n+range] = ff;
745  }
746 
747  for (int n = a; n < b; n++) {
748  if (tkernel[n+range] != 0.f) {
749  if (tkernel[n+range] > FLT_MIN)
750  av_log(ctx, AV_LOG_DEBUG, "out of range kernel %g\n", tkernel[n+range]);
751  start = n;
752  break;
753  }
754  }
755 
756  for (int n = b - 1; n >= a; n--) {
757  if (tkernel[n+range] != 0.f) {
758  if (tkernel[n+range] > FLT_MIN)
759  av_log(ctx, AV_LOG_DEBUG, "out of range kernel %g\n", tkernel[n+range]);
760  stop = n;
761  break;
762  }
763  }
764 
765  if (start == INT_MIN || stop == INT_MAX) {
766  ret = AVERROR(EINVAL);
767  break;
768  }
769 
770  kernel_start[y] = start;
771  kernel_stop[y] = stop;
772 
773  kernel = av_calloc(FFALIGN(stop-start+1, 16), sizeof(*kernel));
774  if (!kernel) {
775  ret = AVERROR(ENOMEM);
776  break;
777  }
778 
779  for (int n = 0; n <= stop - start; n++) {
780  kernel[n].re = tkernel[n+range+start];
781  kernel[n].im = tkernel[n+range+start];
782  }
783 
784  range_min = FFMIN(range_min, stop+1-start);
785  range_max = FFMAX(range_max, stop+1-start);
786 
787  s->kernel[y] = kernel;
788  }
789 
790  for (int n = 0; n < size; n++)
791  index[n] = n & (s->output_padding_size - 1);
792 
793  av_log(ctx, AV_LOG_DEBUG, "range_min: %d\n", range_min);
794  av_log(ctx, AV_LOG_DEBUG, "range_max: %d\n", range_max);
795 
796  av_freep(&tkernel);
797 
798  return ret;
799 }
800 
801 static int config_output(AVFilterLink *outlink)
802 {
803  FilterLink *l = ff_filter_link(outlink);
804  AVFilterContext *ctx = outlink->src;
805  AVFilterLink *inlink = ctx->inputs[0];
806  ShowCWTContext *s = ctx->priv;
807  const float limit_frequency = inlink->sample_rate * 0.5f;
808  float maximum_frequency = fminf(s->maximum_frequency, limit_frequency);
809  float minimum_frequency = s->minimum_frequency;
810  float scale = 1.f, factor;
811  double nb_samples;
812  int ret;
813 
814  if (minimum_frequency >= maximum_frequency) {
815  av_log(ctx, AV_LOG_ERROR, "min frequency (%f) >= (%f) max frequency\n",
816  minimum_frequency, maximum_frequency);
817  return AVERROR(EINVAL);
818  }
819 
820  uninit(ctx);
821 
822  s->fdsp = avpriv_float_dsp_alloc(0);
823  if (!s->fdsp)
824  return AVERROR(ENOMEM);
825 
826  switch (s->direction) {
827  case DIRECTION_LR:
828  case DIRECTION_RL:
829  s->bar_size = s->w * s->bar_ratio;
830  s->sono_size = s->w - s->bar_size;
831  s->frequency_band_count = s->h;
832  break;
833  case DIRECTION_UD:
834  case DIRECTION_DU:
835  s->bar_size = s->h * s->bar_ratio;
836  s->sono_size = s->h - s->bar_size;
837  s->frequency_band_count = s->w;
838  break;
839  }
840 
841  switch (s->frequency_scale) {
842  case FSCALE_LOG:
843  minimum_frequency = logf(minimum_frequency) / logf(2.f);
844  maximum_frequency = logf(maximum_frequency) / logf(2.f);
845  break;
846  case FSCALE_BARK:
847  minimum_frequency = 6.f * asinhf(minimum_frequency / 600.f);
848  maximum_frequency = 6.f * asinhf(maximum_frequency / 600.f);
849  break;
850  case FSCALE_MEL:
851  minimum_frequency = 2595.f * log10f(1.f + minimum_frequency / 700.f);
852  maximum_frequency = 2595.f * log10f(1.f + maximum_frequency / 700.f);
853  break;
854  case FSCALE_ERBS:
855  minimum_frequency = 11.17268f * logf(1.f + (46.06538f * minimum_frequency) / (minimum_frequency + 14678.49f));
856  maximum_frequency = 11.17268f * logf(1.f + (46.06538f * maximum_frequency) / (maximum_frequency + 14678.49f));
857  break;
858  case FSCALE_SQRT:
859  minimum_frequency = sqrtf(minimum_frequency);
860  maximum_frequency = sqrtf(maximum_frequency);
861  break;
862  case FSCALE_CBRT:
863  minimum_frequency = cbrtf(minimum_frequency);
864  maximum_frequency = cbrtf(maximum_frequency);
865  break;
866  case FSCALE_QDRT:
867  minimum_frequency = powf(minimum_frequency, 0.25f);
868  maximum_frequency = powf(maximum_frequency, 0.25f);
869  break;
870  case FSCALE_FM:
871  minimum_frequency = powf(9.f * (minimum_frequency * minimum_frequency) / 4.f, 1.f / 3.f);
872  maximum_frequency = powf(9.f * (maximum_frequency * maximum_frequency) / 4.f, 1.f / 3.f);
873  break;
874  }
875 
876  s->frequency_band = av_calloc(s->frequency_band_count,
877  sizeof(*s->frequency_band) * 2);
878  if (!s->frequency_band)
879  return AVERROR(ENOMEM);
880 
881  nb_samples = inlink->sample_rate *
882  frequency_band(s->frequency_band,
883  s->frequency_band_count, maximum_frequency - minimum_frequency,
884  minimum_frequency, s->frequency_scale, s->deviation);
885  s->nb_consumed_samples = av_clipd(nb_samples, 1, 65536);
886 
887  s->nb_threads = FFMIN(s->frequency_band_count, ff_filter_get_nb_threads(ctx));
888  s->nb_channels = inlink->ch_layout.nb_channels;
889  s->old_pts = AV_NOPTS_VALUE;
890  s->eof_pts = AV_NOPTS_VALUE;
891 
892  s->input_sample_count = 1 << (32 - ff_clz(s->nb_consumed_samples));
893  s->input_padding_size = 1 << (32 - ff_clz(s->input_sample_count));
894  s->output_sample_count = FFMAX(1, av_rescale(s->input_sample_count, s->pps, inlink->sample_rate));
895  s->output_padding_size = 1 << (32 - ff_clz(s->output_sample_count));
896 
897  s->hop_size = s->input_sample_count;
898  s->ihop_size = s->output_padding_size >> 1;
899 
900  outlink->w = s->w;
901  outlink->h = s->h;
902  outlink->sample_aspect_ratio = (AVRational){1,1};
903 
904  s->fft_size = FFALIGN(s->input_padding_size, av_cpu_max_align());
905  s->ifft_size = FFALIGN(s->output_padding_size, av_cpu_max_align());
906 
907  s->fft = av_calloc(s->nb_threads, sizeof(*s->fft));
908  if (!s->fft)
909  return AVERROR(ENOMEM);
910 
911  for (int n = 0; n < s->nb_threads; n++) {
912  ret = av_tx_init(&s->fft[n], &s->tx_fn, AV_TX_FLOAT_FFT, 0, s->input_padding_size, &scale, 0);
913  if (ret < 0)
914  return ret;
915  }
916 
917  s->ifft = av_calloc(s->nb_threads, sizeof(*s->ifft));
918  if (!s->ifft)
919  return AVERROR(ENOMEM);
920 
921  for (int n = 0; n < s->nb_threads; n++) {
922  ret = av_tx_init(&s->ifft[n], &s->itx_fn, AV_TX_FLOAT_FFT, 1, s->output_padding_size, &scale, 0);
923  if (ret < 0)
924  return ret;
925  }
926 
927  s->outpicref = ff_get_video_buffer(outlink, outlink->w, outlink->h);
928  s->fft_in = ff_get_audio_buffer(inlink, s->fft_size * 2);
929  s->fft_out = ff_get_audio_buffer(inlink, s->fft_size * 2);
930  s->dst_x = av_frame_alloc();
931  s->src_x = av_frame_alloc();
932  s->kernel = av_calloc(s->frequency_band_count, sizeof(*s->kernel));
933  s->cache = ff_get_audio_buffer(inlink, s->hop_size);
934  s->over = ff_get_audio_buffer(inlink, s->frequency_band_count * 2 * s->ihop_size);
935  s->bh_out = ff_get_audio_buffer(inlink, s->frequency_band_count);
936  s->ifft_in = av_frame_alloc();
937  s->ifft_out = av_frame_alloc();
938  s->ch_out = av_frame_alloc();
939  s->index = av_calloc(s->input_padding_size, sizeof(*s->index));
940  s->kernel_start = av_calloc(s->frequency_band_count, sizeof(*s->kernel_start));
941  s->kernel_stop = av_calloc(s->frequency_band_count, sizeof(*s->kernel_stop));
942  if (!s->outpicref || !s->fft_in || !s->fft_out || !s->src_x || !s->dst_x || !s->over ||
943  !s->ifft_in || !s->ifft_out || !s->kernel_start || !s->kernel_stop || !s->ch_out ||
944  !s->cache || !s->index || !s->bh_out || !s->kernel)
945  return AVERROR(ENOMEM);
946 
947  s->ch_out->format = inlink->format;
948  s->ch_out->nb_samples = 2 * s->ihop_size * inlink->ch_layout.nb_channels;
949  s->ch_out->ch_layout.nb_channels = s->frequency_band_count;
950  ret = av_frame_get_buffer(s->ch_out, 0);
951  if (ret < 0)
952  return ret;
953 
954  s->ifft_in->format = inlink->format;
955  s->ifft_in->nb_samples = s->ifft_size * 2;
956  s->ifft_in->ch_layout.nb_channels = s->nb_threads;
957  ret = av_frame_get_buffer(s->ifft_in, 0);
958  if (ret < 0)
959  return ret;
960 
961  s->ifft_out->format = inlink->format;
962  s->ifft_out->nb_samples = s->ifft_size * 2;
963  s->ifft_out->ch_layout.nb_channels = s->nb_threads;
964  ret = av_frame_get_buffer(s->ifft_out, 0);
965  if (ret < 0)
966  return ret;
967 
968  s->src_x->format = inlink->format;
969  s->src_x->nb_samples = s->fft_size * 2;
970  s->src_x->ch_layout.nb_channels = s->nb_threads;
971  ret = av_frame_get_buffer(s->src_x, 0);
972  if (ret < 0)
973  return ret;
974 
975  s->dst_x->format = inlink->format;
976  s->dst_x->nb_samples = s->fft_size * 2;
977  s->dst_x->ch_layout.nb_channels = s->nb_threads;
978  ret = av_frame_get_buffer(s->dst_x, 0);
979  if (ret < 0)
980  return ret;
981 
982  s->outpicref->sample_aspect_ratio = (AVRational){1,1};
983 
984  for (int y = 0; y < outlink->h; y++) {
985  memset(s->outpicref->data[0] + y * s->outpicref->linesize[0], 0, outlink->w);
986  memset(s->outpicref->data[1] + y * s->outpicref->linesize[1], 128, outlink->w);
987  memset(s->outpicref->data[2] + y * s->outpicref->linesize[2], 128, outlink->w);
988  if (s->outpicref->data[3])
989  memset(s->outpicref->data[3] + y * s->outpicref->linesize[3], 0, outlink->w);
990  }
991 
992  s->outpicref->color_range = AVCOL_RANGE_JPEG;
993 
994  factor = s->input_padding_size / (float)inlink->sample_rate;
995  for (int n = 0; n < s->frequency_band_count; n++) {
996  s->frequency_band[2*n ] *= factor;
997  s->frequency_band[2*n+1] *= factor;
998  }
999 
1000  av_log(ctx, AV_LOG_DEBUG, "factor: %f\n", factor);
1001  av_log(ctx, AV_LOG_DEBUG, "nb_consumed_samples: %d\n", s->nb_consumed_samples);
1002  av_log(ctx, AV_LOG_DEBUG, "hop_size: %d\n", s->hop_size);
1003  av_log(ctx, AV_LOG_DEBUG, "ihop_size: %d\n", s->ihop_size);
1004  av_log(ctx, AV_LOG_DEBUG, "input_sample_count: %d\n", s->input_sample_count);
1005  av_log(ctx, AV_LOG_DEBUG, "input_padding_size: %d\n", s->input_padding_size);
1006  av_log(ctx, AV_LOG_DEBUG, "output_sample_count: %d\n", s->output_sample_count);
1007  av_log(ctx, AV_LOG_DEBUG, "output_padding_size: %d\n", s->output_padding_size);
1008 
1009  switch (s->direction) {
1010  case DIRECTION_LR:
1011  case DIRECTION_UD:
1012  s->pos = s->bar_size;
1013  break;
1014  case DIRECTION_RL:
1015  case DIRECTION_DU:
1016  s->pos = FFMAX(s->sono_size - 1, 0);
1017  break;
1018  }
1019 
1020  s->auto_frame_rate = av_make_q(inlink->sample_rate, s->hop_size);
1021  if (strcmp(s->rate_str, "auto")) {
1022  ret = av_parse_video_rate(&s->frame_rate, s->rate_str);
1023  if (ret < 0)
1024  return ret;
1025  } else {
1026  s->frame_rate = s->auto_frame_rate;
1027  }
1028  l->frame_rate = s->frame_rate;
1029  outlink->time_base = av_inv_q(l->frame_rate);
1030 
1031  ret = compute_kernel(ctx);
1032  if (ret < 0)
1033  return ret;
1034 
1035  return 0;
1036 }
1037 
1038 static int output_frame(AVFilterContext *ctx)
1039 {
1040  AVFilterLink *outlink = ctx->outputs[0];
1041  AVFilterLink *inlink = ctx->inputs[0];
1042  ShowCWTContext *s = ctx->priv;
1043  const int nb_planes = 3 + (s->outpicref->data[3] != NULL);
1044  int ret;
1045 
1046  switch (s->slide) {
1047  case SLIDE_SCROLL:
1048  switch (s->direction) {
1049  case DIRECTION_UD:
1050  for (int p = 0; p < nb_planes; p++) {
1051  ptrdiff_t linesize = s->outpicref->linesize[p];
1052 
1053  for (int y = s->h - 1; y > s->bar_size; y--) {
1054  uint8_t *dst = s->outpicref->data[p] + y * linesize;
1055 
1056  memmove(dst, dst - linesize, s->w);
1057  }
1058  }
1059  break;
1060  case DIRECTION_DU:
1061  for (int p = 0; p < nb_planes; p++) {
1062  ptrdiff_t linesize = s->outpicref->linesize[p];
1063 
1064  for (int y = 0; y < s->sono_size - 1; y++) {
1065  uint8_t *dst = s->outpicref->data[p] + y * linesize;
1066 
1067  memmove(dst, dst + linesize, s->w);
1068  }
1069  }
1070  break;
1071  }
1072  break;
1073  }
1074 
1075  ff_filter_execute(ctx, draw, NULL, NULL, s->nb_threads);
1076 
1077  switch (s->slide) {
1078  case SLIDE_REPLACE:
1079  case SLIDE_FRAME:
1080  switch (s->direction) {
1081  case DIRECTION_LR:
1082  s->pos++;
1083  if (s->pos >= s->w) {
1084  s->pos = s->bar_size;
1085  s->new_frame = 1;
1086  }
1087  break;
1088  case DIRECTION_RL:
1089  s->pos--;
1090  if (s->pos < 0) {
1091  s->pos = FFMAX(s->sono_size - 1, 0);
1092  s->new_frame = 1;
1093  }
1094  break;
1095  case DIRECTION_UD:
1096  s->pos++;
1097  if (s->pos >= s->h) {
1098  s->pos = s->bar_size;
1099  s->new_frame = 1;
1100  }
1101  break;
1102  case DIRECTION_DU:
1103  s->pos--;
1104  if (s->pos < 0) {
1105  s->pos = FFMAX(s->sono_size - 1, 0);
1106  s->new_frame = 1;
1107  }
1108  break;
1109  }
1110  break;
1111  case SLIDE_SCROLL:
1112  switch (s->direction) {
1113  case DIRECTION_UD:
1114  case DIRECTION_LR:
1115  s->pos = s->bar_size;
1116  break;
1117  case DIRECTION_RL:
1118  case DIRECTION_DU:
1119  s->pos = FFMAX(s->sono_size - 1, 0);
1120  break;
1121  }
1122  break;
1123  }
1124 
1125  if (s->slide == SLIDE_FRAME && s->eof) {
1126  switch (s->direction) {
1127  case DIRECTION_LR:
1128  for (int p = 0; p < nb_planes; p++) {
1129  ptrdiff_t linesize = s->outpicref->linesize[p];
1130  const int size = s->w - s->pos;
1131  const int fill = p > 0 && p < 3 ? 128 : 0;
1132  const int x = s->pos;
1133 
1134  for (int y = 0; y < s->h; y++) {
1135  uint8_t *dst = s->outpicref->data[p] + y * linesize + x;
1136 
1137  memset(dst, fill, size);
1138  }
1139  }
1140  break;
1141  case DIRECTION_RL:
1142  for (int p = 0; p < nb_planes; p++) {
1143  ptrdiff_t linesize = s->outpicref->linesize[p];
1144  const int size = FFMIN(s->pos + 1, s->sono_size);
1145  const int fill = p > 0 && p < 3 ? 128 : 0;
1146 
1147  for (int y = 0; y < s->h; y++) {
1148  uint8_t *dst = s->outpicref->data[p] + y * linesize;
1149 
1150  memset(dst, fill, size);
1151  }
1152  }
1153  break;
1154  case DIRECTION_UD:
1155  for (int p = 0; p < nb_planes; p++) {
1156  ptrdiff_t linesize = s->outpicref->linesize[p];
1157  const int fill = p > 0 && p < 3 ? 128 : 0;
1158 
1159  for (int y = s->pos; y < s->h; y++) {
1160  uint8_t *dst = s->outpicref->data[p] + y * linesize;
1161 
1162  memset(dst, fill, s->w);
1163  }
1164  }
1165  break;
1166  case DIRECTION_DU:
1167  for (int p = 0; p < nb_planes; p++) {
1168  ptrdiff_t linesize = s->outpicref->linesize[p];
1169  const int fill = p > 0 && p < 3 ? 128 : 0;
1170 
1171  for (int y = FFMIN(s->pos, s->sono_size - 1); y >= 0; y--) {
1172  uint8_t *dst = s->outpicref->data[p] + y * linesize;
1173 
1174  memset(dst, fill, s->w);
1175  }
1176  }
1177  break;
1178  }
1179  }
1180 
1181  s->new_frame = s->slide == SLIDE_FRAME && (s->new_frame || s->eof);
1182 
1183  if (s->slide != SLIDE_FRAME || s->new_frame == 1) {
1184  int64_t pts_offset = s->new_frame ? 0LL : av_rescale(s->ihop_index, s->hop_size, s->ihop_size);
1185  const int offset = (s->input_padding_size - s->hop_size) >> 1;
1186 
1187  pts_offset = av_rescale_q(pts_offset - offset, av_make_q(1, inlink->sample_rate), inlink->time_base);
1188  s->outpicref->pts = av_rescale_q(s->in_pts + pts_offset, inlink->time_base, outlink->time_base);
1189  s->outpicref->duration = 1;
1190  }
1191 
1192  s->ihop_index++;
1193  if (s->ihop_index >= s->ihop_size)
1194  s->ihop_index = s->hop_index = 0;
1195 
1196  if (s->slide == SLIDE_FRAME && s->new_frame == 0)
1197  return 1;
1198 
1199  if (s->old_pts < s->outpicref->pts) {
1200  AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
1201  if (!out)
1202  return AVERROR(ENOMEM);
1203  ret = av_frame_copy_props(out, s->outpicref);
1204  if (ret < 0)
1205  goto fail;
1206  ret = av_frame_copy(out, s->outpicref);
1207  if (ret < 0)
1208  goto fail;
1209  s->old_pts = s->outpicref->pts;
1210  s->new_frame = 0;
1211  ret = ff_filter_frame(outlink, out);
1212  if (ret <= 0)
1213  return ret;
1214 fail:
1215  av_frame_free(&out);
1216  return ret;
1217  }
1218 
1219  return 1;
1220 }
1221 
1222 static int run_channels_cwt_prepare(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
1223 {
1224  ShowCWTContext *s = ctx->priv;
1225  const int count = s->nb_channels;
1226  const int start = ff_slice_pos(count, jobnr, nb_jobs);
1227  const int end = ff_slice_pos(count, jobnr + 1, nb_jobs);
1228 
1229  for (int ch = start; ch < end; ch++)
1230  run_channel_cwt_prepare(ctx, arg, jobnr, ch);
1231 
1232  return 0;
1233 }
1234 
1235 static int activate(AVFilterContext *ctx)
1236 {
1237  AVFilterLink *inlink = ctx->inputs[0];
1238  AVFilterLink *outlink = ctx->outputs[0];
1239  ShowCWTContext *s = ctx->priv;
1240  int ret = 0, status;
1241  int64_t pts;
1242 
1243  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
1244 
1245  if (s->outpicref) {
1246  AVFrame *fin = NULL;
1247 
1248  if (s->hop_index < s->hop_size) {
1249  if (!s->eof) {
1250  ret = ff_inlink_consume_samples(inlink, 1, s->hop_size - s->hop_index, &fin);
1251  if (ret < 0)
1252  return ret;
1253  }
1254 
1255  if (ret > 0 || s->eof) {
1256  ff_filter_execute(ctx, run_channels_cwt_prepare, fin, NULL,
1257  FFMIN(s->nb_threads, s->nb_channels));
1258  if (fin) {
1259  if (s->hop_index == 0) {
1260  s->in_pts = fin->pts;
1261  if (s->old_pts == AV_NOPTS_VALUE)
1262  s->old_pts = av_rescale_q(s->in_pts, inlink->time_base, outlink->time_base) - 1;
1263  }
1264  s->hop_index += fin->nb_samples;
1265  av_frame_free(&fin);
1266  } else {
1267  s->hop_index = s->hop_size;
1268  }
1269  }
1270  }
1271 
1272  if (s->hop_index >= s->hop_size || s->ihop_index > 0) {
1273  for (int ch = 0; ch < s->nb_channels && s->ihop_index == 0; ch++) {
1274  ff_filter_execute(ctx, run_channel_cwt, (void *)&ch, NULL,
1275  s->nb_threads);
1276  }
1277 
1278  ret = output_frame(ctx);
1279  if (ret != 1)
1280  return ret;
1281  }
1282  }
1283 
1284  if (s->eof) {
1285  if (s->slide == SLIDE_FRAME)
1286  ret = output_frame(ctx);
1287  ff_outlink_set_status(outlink, AVERROR_EOF, s->eof_pts);
1288  return ret;
1289  }
1290 
1291  if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
1292  if (status == AVERROR_EOF) {
1293  s->eof = 1;
1294  ff_filter_set_ready(ctx, 10);
1295  s->eof_pts = av_rescale_q(pts, inlink->time_base, outlink->time_base);
1296  return 0;
1297  }
1298  }
1299 
1300  if (ff_inlink_queued_samples(inlink) > 0 || s->ihop_index ||
1301  s->hop_index >= s->hop_size || s->eof) {
1302  ff_filter_set_ready(ctx, 10);
1303  return 0;
1304  }
1305 
1306  if (ff_outlink_frame_wanted(outlink)) {
1307  ff_inlink_request_frame(inlink);
1308  return 0;
1309  }
1310 
1311  return FFERROR_NOT_READY;
1312 }
1313 
1314 static const AVFilterPad showcwt_outputs[] = {
1315  {
1316  .name = "default",
1317  .type = AVMEDIA_TYPE_VIDEO,
1318  .config_props = config_output,
1319  },
1320 };
1321 
1322 const FFFilter ff_avf_showcwt = {
1323  .p.name = "showcwt",
1324  .p.description = NULL_IF_CONFIG_SMALL("Convert input audio to a CWT (Continuous Wavelet Transform) spectrum video output."),
1325  .p.priv_class = &showcwt_class,
1326  .p.flags = AVFILTER_FLAG_SLICE_THREADS,
1327  .uninit = uninit,
1328  .priv_size = sizeof(ShowCWTContext),
1329  FILTER_INPUTS(ff_audio_default_filterpad),
1330  FILTER_OUTPUTS(showcwt_outputs),
1331  FILTER_QUERY_FUNC2(query_formats),
1332  .activate = activate,
1333 };
ShowCWTContext::dst_x
AVFrame * dst_x
Definition: avf_showcwt.c:96
formats
formats
Definition: signature.h:47
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:89
FSCALE_LINEAR
@ FSCALE_LINEAR
Definition: avf_showcwt.c:38
ISCALE_LINEAR
@ ISCALE_LINEAR
Definition: avf_showcwt.c:52
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:74
factor
static const int factor[16]
Definition: vf_pp7.c:98
IntensityScale
IntensityScale
Definition: avf_showcwt.c:50
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
ShowCWTContext::frequency_scale
int frequency_scale
Definition: avf_showcwt.c:118
FSCALE_FM
@ FSCALE_FM
Definition: avf_showcwt.c:46
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
DIRECTION_LR
@ DIRECTION_LR
Definition: avf_showcwt.c:60
out
static FILE * out
Definition: movenc.c:55
run_channels_cwt_prepare
static int run_channels_cwt_prepare(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: avf_showcwt.c:1222
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:206
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1068
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:933
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FSCALE_ERBS
@ FSCALE_ERBS
Definition: avf_showcwt.c:42
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AVTXContext
Definition: tx_priv.h:235
atan2f
#define atan2f(y, x)
Definition: libm.h:47
ShowCWTContext::input_sample_count
int input_sample_count
Definition: avf_showcwt.c:114
av_cold
#define av_cold
Definition: attributes.h:119
int64_t
long long int64_t
Definition: coverity.c:34
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
ShowCWTContext::rate_str
char * rate_str
Definition: avf_showcwt.c:78
ShowCWTContext::itx_fn
av_tx_fn itx_fn
Definition: avf_showcwt.c:82
ShowCWTContext::bar_size
int bar_size
Definition: avf_showcwt.c:123
ff_clz
#define ff_clz
Definition: intmath.h:141
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
mode
Definition: swscale.c:71
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:466
FSCALE_SQRT
@ FSCALE_SQRT
Definition: avf_showcwt.c:43
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:568
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:777
FSCALE_LOG
@ FSCALE_LOG
Definition: avf_showcwt.c:39
M_PI_2
#define M_PI_2
Definition: mathematics.h:73
ISCALE_LOG
@ ISCALE_LOG
Definition: avf_showcwt.c:51
ShowCWTContext::bh_out
AVFrame * bh_out
Definition: avf_showcwt.c:102
AVOption
AVOption.
Definition: opt.h:428
ShowCWTContext::slide
int slide
Definition: avf_showcwt.c:108
b
#define b
Definition: input.c:43
showcwt_options
static const AVOption showcwt_options[]
Definition: avf_showcwt.c:133
ff_make_pixel_format_list
av_warn_unused_result AVFilterFormats * ff_make_pixel_format_list(const enum AVPixelFormat *fmts)
Create a list of supported pixel formats.
filters.h
ShowCWTContext::nb_threads
int nb_threads
Definition: avf_showcwt.c:103
expf
#define expf(x)
Definition: libm.h:285
FLAGS
#define FLAGS
Definition: avf_showcwt.c:131
float.h
AVComplexFloat
Definition: tx.h:27
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:219
output_frame
static int output_frame(AVFilterContext *ctx)
Definition: avf_showcwt.c:1038
video.h
ShowCWTContext::index
unsigned * index
Definition: avf_showcwt.c:90
cpu.h
ShowCWTContext::ifft_size
int ifft_size
Definition: avf_showcwt.c:83
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:903
DIRECTION_RL
@ DIRECTION_RL
Definition: avf_showcwt.c:61
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
SLIDE_REPLACE
@ SLIDE_REPLACE
Definition: avf_showcwt.c:68
AVComplexFloat::im
float im
Definition: tx.h:28
ISCALE_QDRT
@ ISCALE_QDRT
Definition: avf_showcwt.c:55
cosf
#define cosf(x)
Definition: libm.h:80
log10f
#define log10f(x)
Definition: libm.h:416
NB_FSCALE
@ NB_FSCALE
Definition: avf_showcwt.c:47
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: avf_showcwt.c:225
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showcwt.c:183
pts
static int64_t pts
Definition: transcode_aac.c:649
ShowCWTContext::kernel_start
int * kernel_start
Definition: avf_showcwt.c:91
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:241
ShowCWTContext::output_sample_count
int output_sample_count
Definition: avf_showcwt.c:114
FSCALE_CBRT
@ FSCALE_CBRT
Definition: avf_showcwt.c:44
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:40
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
ShowCWTContext::frequency_band
float * frequency_band
Definition: avf_showcwt.c:88
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
FFFilter
Definition: filters.h:267
float
float
Definition: af_crystalizer.c:122
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1619
s
#define s(width, name)
Definition: cbs_vp9.c:198
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:265
ShowCWTContext::logarithmic_basis
float logarithmic_basis
Definition: avf_showcwt.c:116
ShowCWTContext::eof_pts
int64_t eof_pts
Definition: avf_showcwt.c:87
ShowCWTContext::frequency_band_count
int frequency_band_count
Definition: avf_showcwt.c:115
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:199
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:756
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:629
ShowCWTContext::nb_channels
int nb_channels
Definition: avf_showcwt.c:104
fminf
float fminf(float, float)
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_TX_FLOAT_FFT
@ AV_TX_FLOAT_FFT
Standard complex to complex FFT with sample data type of AVComplexFloat, AVComplexDouble or AVComplex...
Definition: tx.h:47
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
ShowCWTContext::maximum_frequency
float maximum_frequency
Definition: avf_showcwt.c:119
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
ShowCWTContext::direction
int direction
Definition: avf_showcwt.c:110
ShowCWTContext
Definition: avf_showcwt.c:74
ShowCWTContext::fft_in
AVFrame * fft_in
Definition: avf_showcwt.c:94
ff_avf_showcwt
const FFFilter ff_avf_showcwt
Definition: avf_showcwt.c:1322
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
ShowCWTContext::ifft_out
AVFrame * ifft_out
Definition: avf_showcwt.c:99
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
ShowCWTContext::fft
AVTXContext ** fft
Definition: avf_showcwt.c:81
arg
const char * arg
Definition: jacosubdec.c:65
ShowCWTContext::deviation
float deviation
Definition: avf_showcwt.c:121
if
if(ret)
Definition: filter_design.txt:179
ShowCWTContext::ch_out
AVFrame * ch_out
Definition: avf_showcwt.c:100
fail
#define fail
Definition: test.h:478
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:1536
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:599
ShowCWTContext::rotation
float rotation
Definition: avf_showcwt.c:125
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ShowCWTContext::bar_ratio
float bar_ratio
Definition: avf_showcwt.c:122
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:302
ShowCWTContext::ihop_size
int ihop_size
Definition: avf_showcwt.c:111
V
#define V
Definition: avdct.c:32
ShowCWTContext::outpicref
AVFrame * outpicref
Definition: avf_showcwt.c:93
parseutils.h
ShowCWTContext::ihop_index
int ihop_index
Definition: avf_showcwt.c:112
ShowCWTContext::cache
AVFrame * cache
Definition: avf_showcwt.c:92
ff_audio_default_filterpad
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
Definition: audio.c:34
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
ShowCWTContext::kernel
AVComplexFloat ** kernel
Definition: avf_showcwt.c:89
ShowCWTContext::h
int h
Definition: avf_showcwt.c:76
sinf
#define sinf(x)
Definition: libm.h:421
av_clipf
av_clipf
Definition: af_crystalizer.c:122
DIRECTION_DU
@ DIRECTION_DU
Definition: avf_showcwt.c:63
compute_kernel
static int compute_kernel(AVFilterContext *ctx)
Definition: avf_showcwt.c:712
ISCALE_CBRT
@ ISCALE_CBRT
Definition: avf_showcwt.c:54
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:1463
index
int index
Definition: gxfenc.c:90
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:120
float_dsp.h
ShowCWTContext::fft_out
AVFrame * fft_out
Definition: avf_showcwt.c:95
ShowCWTContext::over
AVFrame * over
Definition: avf_showcwt.c:101
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:88
powf
#define powf(x, y)
Definition: libm.h:52
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:711
ISCALE_SQRT
@ ISCALE_SQRT
Definition: avf_showcwt.c:53
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
ShowCWTContext::src_x
AVFrame * src_x
Definition: avf_showcwt.c:97
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
run_channel_cwt
static int run_channel_cwt(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: avf_showcwt.c:641
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
ShowCWTContext::in_pts
int64_t in_pts
Definition: avf_showcwt.c:85
AVComplexFloat::re
float re
Definition: tx.h:28
ShowCWTContext::maximum_intensity
float maximum_intensity
Definition: avf_showcwt.c:120
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
ShowCWTContext::intensity_scale
int intensity_scale
Definition: avf_showcwt.c:117
DIRECTION_UD
@ DIRECTION_UD
Definition: avf_showcwt.c:62
AVFloatDSPContext
Definition: float_dsp.h:24
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2594
ShowCWTContext::mode
int mode
Definition: avf_showcwt.c:77
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
FrequencyScale
FrequencyScale
Definition: avf_showcwt.c:37
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
ShowCWTContext::minimum_intensity
float minimum_intensity
Definition: avf_showcwt.c:120
draw_bar
static void draw_bar(ShowCWTContext *s, int y, float Y, float U, float V)
Definition: avf_showcwt.c:379
frequency_band
static float frequency_band(float *frequency_band, int frequency_band_count, float frequency_range, float frequency_offset, int frequency_scale, float deviation)
Definition: avf_showcwt.c:245
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
ShowCWTContext::ifft
AVTXContext ** ifft
Definition: avf_showcwt.c:81
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
M_PI
#define M_PI
Definition: mathematics.h:67
Y
#define Y
Definition: boxblur.h:37
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:295
NB_DIRECTION
@ NB_DIRECTION
Definition: avf_showcwt.c:64
draw
static int draw(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: avf_showcwt.c:440
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:270
ShowCWTContext::nb_consumed_samples
int nb_consumed_samples
Definition: avf_showcwt.c:105
av_parse_video_rate
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:181
ShowCWTContext::output_padding_size
int output_padding_size
Definition: avf_showcwt.c:113
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:546
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
ShowCWTContext::kernel_stop
int * kernel_stop
Definition: avf_showcwt.c:91
run_channel_cwt_prepare
static int run_channel_cwt_prepare(AVFilterContext *ctx, void *arg, int jobnr, int ch)
Definition: avf_showcwt.c:335
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:527
DirectionMode
DirectionMode
Definition: avf_showcwt.c:59
src2
const pixel * src2
Definition: h264pred_template.c:421
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
NB_SLIDE
@ NB_SLIDE
Definition: avf_showcwt.c:71
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:846
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:287
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
value
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 default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
cbrtf
static av_always_inline float cbrtf(float x)
Definition: libm.h:63
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showcwt)
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
ShowCWTContext::tx_fn
av_tx_fn tx_fn
Definition: avf_showcwt.c:82
ShowCWTContext::sono_size
int sono_size
Definition: avf_showcwt.c:124
OFFSET
#define OFFSET(x)
Definition: avf_showcwt.c:130
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:46
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1491
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
ShowCWTContext::minimum_frequency
float minimum_frequency
Definition: avf_showcwt.c:119
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
ff_make_sample_format_list
av_warn_unused_result AVFilterFormats * ff_make_sample_format_list(const enum AVSampleFormat *fmts)
Create a list of supported sample formats.
activate
static int activate(AVFilterContext *ctx)
Definition: avf_showcwt.c:1235
ShowCWTContext::auto_frame_rate
AVRational auto_frame_rate
Definition: avf_showcwt.c:79
ShowCWTContext::hop_index
int hop_index
Definition: avf_showcwt.c:112
ret
ret
Definition: filter_design.txt:187
ShowCWTContext::frame_rate
AVRational frame_rate
Definition: avf_showcwt.c:80
NB_ISCALE
@ NB_ISCALE
Definition: avf_showcwt.c:56
ShowCWTContext::fdsp
AVFloatDSPContext * fdsp
Definition: avf_showcwt.c:127
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:264
ShowCWTContext::pos
int pos
Definition: avf_showcwt.c:84
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showcwt.c:801
U
#define U(x)
Definition: vpx_arith.h:37
FSCALE_QDRT
@ FSCALE_QDRT
Definition: avf_showcwt.c:45
SLIDE_SCROLL
@ SLIDE_SCROLL
Definition: avf_showcwt.c:69
ShowCWTContext::fft_size
int fft_size
Definition: avf_showcwt.c:83
ShowCWTContext::pps
int pps
Definition: avf_showcwt.c:106
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
channel_layout.h
ff_filter_execute
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:1692
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:258
avfilter.h
DRAW_BAR_COLOR
#define DRAW_BAR_COLOR(x)
Definition: avf_showcwt.c:365
pps
uint64_t pps
Definition: dovi_rpuenc.c:36
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:273
ShowCWTContext::old_pts
int64_t old_pts
Definition: avf_showcwt.c:86
ShowCWTContext::hop_size
int hop_size
Definition: avf_showcwt.c:111
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:639
ShowCWTContext::eof
int eof
Definition: avf_showcwt.c:107
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:166
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:271
mem.h
audio.h
ShowCWTContext::w
int w
Definition: avf_showcwt.c:76
w
uint8_t w
Definition: llvidencdsp.c:39
FSCALE_BARK
@ FSCALE_BARK
Definition: avf_showcwt.c:40
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:278
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
ShowCWTContext::new_frame
int new_frame
Definition: avf_showcwt.c:109
ff_slice_pos
static int ff_slice_pos(int total, int jobnr, int nb_jobs)
Compute the boundary index for a slice when work of size total is split into nb_jobs slices.
Definition: filters.h:763
ShowCWTContext::input_padding_size
int input_padding_size
Definition: avf_showcwt.c:113
ShowCWTContext::ifft_in
AVFrame * ifft_in
Definition: avf_showcwt.c:98
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2070
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
FSCALE_MEL
@ FSCALE_MEL
Definition: avf_showcwt.c:41
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:275
showcwt_outputs
static const AVFilterPad showcwt_outputs[]
Definition: avf_showcwt.c:1314
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:298
remap_log
static float remap_log(ShowCWTContext *s, float value, int iscale, float log_factor)
Definition: avf_showcwt.c:302
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:383
src
#define src
Definition: vp8dsp.c:248
av_clipd
av_clipd
Definition: af_crystalizer.c:132
SlideMode
SlideMode
Definition: avf_ahistogram.c:31
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:229
tx.h
min
float min
Definition: vorbis_enc_data.h:429
SLIDE_FRAME
@ SLIDE_FRAME
Definition: avf_showcwt.c:70
Generated on Wed Jun 24 2026 19:23:13 for FFmpeg by   doxygen 1.8.17