FFmpeg
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
avf_showcqt.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014-2015 Muhammad Faiz <mfcc64@gmail.com>
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 "config.h"
22 #include "libavutil/mem.h"
23 #include "libavutil/tx.h"
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/xga_font_data.h"
27 #include "libavutil/eval.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/time.h"
30 #include "audio.h"
31 #include "avfilter.h"
32 #include "filters.h"
33 #include "formats.h"
34 #include "lavfutils.h"
35 #include "lswsutils.h"
36 #include "video.h"
37 
38 #if CONFIG_LIBFREETYPE
39 #include <ft2build.h>
40 #include FT_FREETYPE_H
41 #endif
42 
43 #if CONFIG_LIBFONTCONFIG
44 #include <fontconfig/fontconfig.h>
45 #endif
46 
47 #include "avf_showcqt.h"
48 
49 #define BASEFREQ 20.01523126408007475
50 #define ENDFREQ 20495.59681441799654
51 #define TLENGTH "384*tc/(384+tc*f)"
52 #define TLENGTH_MIN 0.001
53 #define VOLUME_MAX 100.0
54 #define FONTCOLOR "st(0, (midi(f)-59.5)/12);" \
55  "st(1, if(between(ld(0),0,1), 0.5-0.5*cos(2*PI*ld(0)), 0));" \
56  "r(1-ld(1)) + b(ld(1))"
57 #define CSCHEME "1|0.5|0|0|0.5|1"
58 
59 #define OFFSET(x) offsetof(ShowCQTContext, x)
60 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
61 
62 static const AVOption showcqt_options[] = {
63  { "size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, { .str = "1920x1080" }, 0, 0, FLAGS },
64  { "s", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, { .str = "1920x1080" }, 0, 0, FLAGS },
65  { "fps", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 1, 1000, FLAGS },
66  { "rate", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 1, 1000, FLAGS },
67  { "r", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 1, 1000, FLAGS },
68  { "bar_h", "set bargraph height", OFFSET(bar_h), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
69  { "axis_h", "set axis height", OFFSET(axis_h), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
70  { "sono_h", "set sonogram height", OFFSET(sono_h), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
71  { "fullhd", "set fullhd size", OFFSET(fullhd), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
72  { "sono_v", "set sonogram volume", OFFSET(sono_v), AV_OPT_TYPE_STRING, { .str = "16" }, 0, 0, FLAGS },
73  { "volume", "set sonogram volume", OFFSET(sono_v), AV_OPT_TYPE_STRING, { .str = "16" }, 0, 0, FLAGS },
74  { "bar_v", "set bargraph volume", OFFSET(bar_v), AV_OPT_TYPE_STRING, { .str = "sono_v" }, 0, 0, FLAGS },
75  { "volume2", "set bargraph volume", OFFSET(bar_v), AV_OPT_TYPE_STRING, { .str = "sono_v" }, 0, 0, FLAGS },
76  { "sono_g", "set sonogram gamma", OFFSET(sono_g), AV_OPT_TYPE_FLOAT, { .dbl = 3.0 }, 1.0, 7.0, FLAGS },
77  { "gamma", "set sonogram gamma", OFFSET(sono_g), AV_OPT_TYPE_FLOAT, { .dbl = 3.0 }, 1.0, 7.0, FLAGS },
78  { "bar_g", "set bargraph gamma", OFFSET(bar_g), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 1.0, 7.0, FLAGS },
79  { "gamma2", "set bargraph gamma", OFFSET(bar_g), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 1.0, 7.0, FLAGS },
80  { "bar_t", "set bar transparency", OFFSET(bar_t), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 0.0, 1.0, FLAGS },
81  { "timeclamp", "set timeclamp", OFFSET(timeclamp), AV_OPT_TYPE_DOUBLE, { .dbl = 0.17 }, 0.002, 1.0, FLAGS },
82  { "tc", "set timeclamp", OFFSET(timeclamp), AV_OPT_TYPE_DOUBLE, { .dbl = 0.17 }, 0.002, 1.0, FLAGS },
83  { "attack", "set attack time", OFFSET(attack), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0.0, 1.0, FLAGS },
84  { "basefreq", "set base frequency", OFFSET(basefreq), AV_OPT_TYPE_DOUBLE, { .dbl = BASEFREQ }, 10.0, 100000.0, FLAGS },
85  { "endfreq", "set end frequency", OFFSET(endfreq), AV_OPT_TYPE_DOUBLE, { .dbl = ENDFREQ }, 10.0, 100000.0, FLAGS },
86  { "coeffclamp", "set coeffclamp", OFFSET(coeffclamp), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 0.1, 10.0, FLAGS },
87  { "tlength", "set tlength", OFFSET(tlength), AV_OPT_TYPE_STRING, { .str = TLENGTH }, 0, 0, FLAGS },
88  { "count", "set transform count", OFFSET(count), AV_OPT_TYPE_INT, { .i64 = 6 }, 1, 30, FLAGS },
89  { "fcount", "set frequency count", OFFSET(fcount), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 10, FLAGS },
90  { "fontfile", "set axis font file", OFFSET(fontfile), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
91  { "font", "set axis font", OFFSET(font), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
92  { "fontcolor", "set font color", OFFSET(fontcolor), AV_OPT_TYPE_STRING, { .str = FONTCOLOR }, 0, 0, FLAGS },
93  { "axisfile", "set axis image", OFFSET(axisfile), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
94  { "axis", "draw axis", OFFSET(axis), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
95  { "text", "draw axis", OFFSET(axis), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
96  { "csp", "set color space", OFFSET(csp), AV_OPT_TYPE_INT, { .i64 = AVCOL_SPC_UNSPECIFIED }, 0, INT_MAX, FLAGS, .unit = "csp" },
97  { "unspecified", "unspecified", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_UNSPECIFIED }, 0, 0, FLAGS, .unit = "csp" },
98  { "bt709", "bt709", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT709 }, 0, 0, FLAGS, .unit = "csp" },
99  { "fcc", "fcc", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_FCC }, 0, 0, FLAGS, .unit = "csp" },
100  { "bt470bg", "bt470bg", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT470BG }, 0, 0, FLAGS, .unit = "csp" },
101  { "smpte170m", "smpte170m", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_SMPTE170M }, 0, 0, FLAGS, .unit = "csp" },
102  { "smpte240m", "smpte240m", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_SMPTE240M }, 0, 0, FLAGS, .unit = "csp" },
103  { "bt2020ncl", "bt2020ncl", 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT2020_NCL }, 0, 0, FLAGS, .unit = "csp" },
104  { "cscheme", "set color scheme", OFFSET(cscheme), AV_OPT_TYPE_STRING, { .str = CSCHEME }, 0, 0, FLAGS },
105  { NULL }
106 };
107 
108 AVFILTER_DEFINE_CLASS(showcqt);
109 
110 static void common_uninit(ShowCQTContext *s)
111 {
112  int k;
113  int level = AV_LOG_DEBUG;
114  int64_t plot_time;
115 
116  if (s->fft_time)
117  av_log(s->ctx, level, "fft_time = %16.3f s.\n", s->fft_time * 1e-6);
118  if (s->cqt_time)
119  av_log(s->ctx, level, "cqt_time = %16.3f s.\n", s->cqt_time * 1e-6);
120  if (s->process_cqt_time)
121  av_log(s->ctx, level, "process_cqt_time = %16.3f s.\n", s->process_cqt_time * 1e-6);
122  if (s->update_sono_time)
123  av_log(s->ctx, level, "update_sono_time = %16.3f s.\n", s->update_sono_time * 1e-6);
124  if (s->alloc_time)
125  av_log(s->ctx, level, "alloc_time = %16.3f s.\n", s->alloc_time * 1e-6);
126  if (s->bar_time)
127  av_log(s->ctx, level, "bar_time = %16.3f s.\n", s->bar_time * 1e-6);
128  if (s->axis_time)
129  av_log(s->ctx, level, "axis_time = %16.3f s.\n", s->axis_time * 1e-6);
130  if (s->sono_time)
131  av_log(s->ctx, level, "sono_time = %16.3f s.\n", s->sono_time * 1e-6);
132 
133  plot_time = s->fft_time + s->cqt_time + s->process_cqt_time + s->update_sono_time
134  + s->alloc_time + s->bar_time + s->axis_time + s->sono_time;
135  if (plot_time)
136  av_log(s->ctx, level, "plot_time = %16.3f s.\n", plot_time * 1e-6);
137 
138  s->fft_time = s->cqt_time = s->process_cqt_time = s->update_sono_time
139  = s->alloc_time = s->bar_time = s->axis_time = s->sono_time = 0;
140  /* axis_frame may be non reference counted frame */
141  if (s->axis_frame && !s->axis_frame->buf[0]) {
142  av_freep(s->axis_frame->data);
143  for (k = 0; k < 4; k++)
144  s->axis_frame->data[k] = NULL;
145  }
146 
147  av_frame_free(&s->axis_frame);
148  av_frame_free(&s->sono_frame);
149  av_tx_uninit(&s->fft_ctx);
150  if (s->coeffs)
151  for (k = 0; k < s->cqt_len; k++)
152  av_freep(&s->coeffs[k].val);
153  av_freep(&s->coeffs);
154  av_freep(&s->fft_data);
155  av_freep(&s->fft_input);
156  av_freep(&s->fft_result);
157  av_freep(&s->cqt_result);
158  av_freep(&s->attack_data);
159  av_freep(&s->c_buf);
160  av_freep(&s->h_buf);
161  av_freep(&s->rcp_h_buf);
162  av_freep(&s->freq);
163  av_freep(&s->sono_v_buf);
164  av_freep(&s->bar_v_buf);
165 }
166 
167 static double *create_freq_table(double base, double end, int n)
168 {
169  double log_base, log_end;
170  double rcp_n = 1.0 / n;
171  double *freq;
172  int x;
173 
174  freq = av_malloc_array(n, sizeof(*freq));
175  if (!freq)
176  return NULL;
177 
178  log_base = log(base);
179  log_end = log(end);
180  for (x = 0; x < n; x++) {
181  double log_freq = log_base + (x + 0.5) * (log_end - log_base) * rcp_n;
182  freq[x] = exp(log_freq);
183  }
184  return freq;
185 }
186 
187 static double clip_with_log(void *log_ctx, const char *name,
188  double val, double min, double max,
189  double nan_replace, int idx)
190 {
191  int level = AV_LOG_WARNING;
192  if (isnan(val)) {
193  av_log(log_ctx, level, "[%d] %s is nan, setting it to %g.\n",
194  idx, name, nan_replace);
195  val = nan_replace;
196  } else if (val < min) {
197  av_log(log_ctx, level, "[%d] %s is too low (%g), setting it to %g.\n",
198  idx, name, val, min);
199  val = min;
200  } else if (val > max) {
201  av_log(log_ctx, level, "[%d] %s it too high (%g), setting it to %g.\n",
202  idx, name, val, max);
203  val = max;
204  }
205  return val;
206 }
207 
208 static double a_weighting(void *p, double f)
209 {
210  double ret = 12200.0*12200.0 * (f*f*f*f);
211  ret /= (f*f + 20.6*20.6) * (f*f + 12200.0*12200.0) *
212  sqrt((f*f + 107.7*107.7) * (f*f + 737.9*737.9));
213  return ret;
214 }
215 
216 static double b_weighting(void *p, double f)
217 {
218  double ret = 12200.0*12200.0 * (f*f*f);
219  ret /= (f*f + 20.6*20.6) * (f*f + 12200.0*12200.0) * sqrt(f*f + 158.5*158.5);
220  return ret;
221 }
222 
223 static double c_weighting(void *p, double f)
224 {
225  double ret = 12200.0*12200.0 * (f*f);
226  ret /= (f*f + 20.6*20.6) * (f*f + 12200.0*12200.0);
227  return ret;
228 }
229 
230 static int init_volume(ShowCQTContext *s)
231 {
232  const char *func_names[] = { "a_weighting", "b_weighting", "c_weighting", NULL };
233  const char *sono_names[] = { "timeclamp", "tc", "frequency", "freq", "f", "bar_v", NULL };
234  const char *bar_names[] = { "timeclamp", "tc", "frequency", "freq", "f", "sono_v", NULL };
235  double (*funcs[])(void *, double) = { a_weighting, b_weighting, c_weighting };
236  AVExpr *sono = NULL, *bar = NULL;
237  int x, ret = AVERROR(ENOMEM);
238 
239  s->sono_v_buf = av_malloc_array(s->cqt_len, sizeof(*s->sono_v_buf));
240  s->bar_v_buf = av_malloc_array(s->cqt_len, sizeof(*s->bar_v_buf));
241  if (!s->sono_v_buf || !s->bar_v_buf)
242  goto error;
243 
244  if ((ret = av_expr_parse(&sono, s->sono_v, sono_names, func_names, funcs, NULL, NULL, 0, s->ctx)) < 0)
245  goto error;
246 
247  if ((ret = av_expr_parse(&bar, s->bar_v, bar_names, func_names, funcs, NULL, NULL, 0, s->ctx)) < 0)
248  goto error;
249 
250  for (x = 0; x < s->cqt_len; x++) {
251  double vars[] = { s->timeclamp, s->timeclamp, s->freq[x], s->freq[x], s->freq[x], 0.0 };
252  double vol = clip_with_log(s->ctx, "sono_v", av_expr_eval(sono, vars, NULL), 0.0, VOLUME_MAX, 0.0, x);
253  vars[5] = vol;
254  vol = clip_with_log(s->ctx, "bar_v", av_expr_eval(bar, vars, NULL), 0.0, VOLUME_MAX, 0.0, x);
255  s->bar_v_buf[x] = vol * vol;
256  vars[5] = vol;
257  vol = clip_with_log(s->ctx, "sono_v", av_expr_eval(sono, vars, NULL), 0.0, VOLUME_MAX, 0.0, x);
258  s->sono_v_buf[x] = vol * vol;
259  }
260  av_expr_free(sono);
261  av_expr_free(bar);
262  return 0;
263 
264 error:
265  av_freep(&s->sono_v_buf);
266  av_freep(&s->bar_v_buf);
267  av_expr_free(sono);
268  av_expr_free(bar);
269  return ret;
270 }
271 
272 static void cqt_calc(AVComplexFloat *dst, const AVComplexFloat *src, const Coeffs *coeffs,
273  int len, int fft_len)
274 {
275  int k, x, i, j;
276  for (k = 0; k < len; k++) {
277  AVComplexFloat l, r, a = {0,0}, b = {0,0};
278 
279  for (x = 0; x < coeffs[k].len; x++) {
280  float u = coeffs[k].val[x];
281  i = coeffs[k].start + x;
282  j = fft_len - i;
283  a.re += u * src[i].re;
284  a.im += u * src[i].im;
285  b.re += u * src[j].re;
286  b.im += u * src[j].im;
287  }
288 
289  /* separate left and right, (and multiply by 2.0) */
290  l.re = a.re + b.re;
291  l.im = a.im - b.im;
292  r.re = b.im + a.im;
293  r.im = b.re - a.re;
294  dst[k].re = l.re * l.re + l.im * l.im;
295  dst[k].im = r.re * r.re + r.im * r.im;
296  }
297 }
298 
299 static int init_cqt(ShowCQTContext *s)
300 {
301  const char *var_names[] = { "timeclamp", "tc", "frequency", "freq", "f", NULL };
302  AVExpr *expr = NULL;
303  int rate = s->ctx->inputs[0]->sample_rate;
304  int nb_cqt_coeffs = 0;
305  int k, x, ret;
306 
307  if ((ret = av_expr_parse(&expr, s->tlength, var_names, NULL, NULL, NULL, NULL, 0, s->ctx)) < 0)
308  goto error;
309 
310  ret = AVERROR(ENOMEM);
311  if (!(s->coeffs = av_calloc(s->cqt_len, sizeof(*s->coeffs))))
312  goto error;
313 
314  for (k = 0; k < s->cqt_len; k++) {
315  double vars[] = { s->timeclamp, s->timeclamp, s->freq[k], s->freq[k], s->freq[k] };
316  double flen, center, tlength;
317  int start, end, m = k;
318 
319  if (s->freq[k] > 0.5 * rate)
320  continue;
321  tlength = clip_with_log(s->ctx, "tlength", av_expr_eval(expr, vars, NULL),
322  TLENGTH_MIN, s->timeclamp, s->timeclamp, k);
323 
324  flen = 8.0 * s->fft_len / (tlength * rate);
325  center = s->freq[k] * s->fft_len / rate;
326  start = FFMAX(0, ceil(center - 0.5 * flen));
327  end = FFMIN(s->fft_len, floor(center + 0.5 * flen));
328 
329  s->coeffs[m].start = start & ~(s->cqt_align - 1);
330  s->coeffs[m].len = (end | (s->cqt_align - 1)) + 1 - s->coeffs[m].start;
331  nb_cqt_coeffs += s->coeffs[m].len;
332  if (!(s->coeffs[m].val = av_calloc(s->coeffs[m].len, sizeof(*s->coeffs[m].val))))
333  goto error;
334 
335  for (x = start; x <= end; x++) {
336  int sign = (x & 1) ? (-1) : 1;
337  double y = 2.0 * M_PI * (x - center) * (1.0 / flen);
338  /* nuttall window */
339  double w = 0.355768 + 0.487396 * cos(y) + 0.144232 * cos(2*y) + 0.012604 * cos(3*y);
340  w *= sign * (1.0 / s->fft_len);
341  s->coeffs[m].val[x - s->coeffs[m].start] = w;
342  }
343 
344  if (s->permute_coeffs)
345  s->permute_coeffs(s->coeffs[m].val, s->coeffs[m].len);
346  }
347 
348  av_expr_free(expr);
349  av_log(s->ctx, AV_LOG_VERBOSE, "nb_cqt_coeffs = %d.\n", nb_cqt_coeffs);
350  return 0;
351 
352 error:
353  av_expr_free(expr);
354  if (s->coeffs)
355  for (k = 0; k < s->cqt_len; k++)
356  av_freep(&s->coeffs[k].val);
357  av_freep(&s->coeffs);
358  return ret;
359 }
360 
361 static AVFrame *alloc_frame_empty(enum AVPixelFormat format, int w, int h)
362 {
363  AVFrame *out;
364  out = av_frame_alloc();
365  if (!out)
366  return NULL;
367  out->format = format;
368  out->width = w;
369  out->height = h;
370  if (av_frame_get_buffer(out, 0) < 0) {
371  av_frame_free(&out);
372  return NULL;
373  }
374  if (format == AV_PIX_FMT_RGB24 || format == AV_PIX_FMT_RGBA) {
375  memset(out->data[0], 0, out->linesize[0] * h);
376  } else {
377  int hh = (format == AV_PIX_FMT_YUV420P || format == AV_PIX_FMT_YUVA420P) ? h / 2 : h;
378  memset(out->data[0], 16, out->linesize[0] * h);
379  memset(out->data[1], 128, out->linesize[1] * hh);
380  memset(out->data[2], 128, out->linesize[2] * hh);
381  if (out->data[3])
382  memset(out->data[3], 0, out->linesize[3] * h);
383  }
384  return out;
385 }
386 
387 static enum AVPixelFormat convert_axis_pixel_format(enum AVPixelFormat format)
388 {
389  switch (format) {
390  case AV_PIX_FMT_RGB24: format = AV_PIX_FMT_RGBA; break;
391  case AV_PIX_FMT_YUV444P:
392  case AV_PIX_FMT_YUV422P:
393  case AV_PIX_FMT_YUV420P: format = AV_PIX_FMT_YUVA444P; break;
394  }
395  return format;
396 }
397 
398 static int init_axis_empty(ShowCQTContext *s)
399 {
400  if (!(s->axis_frame = alloc_frame_empty(convert_axis_pixel_format(s->format), s->width, s->axis_h)))
401  return AVERROR(ENOMEM);
402  return 0;
403 }
404 
405 static int init_axis_from_file(ShowCQTContext *s)
406 {
407  uint8_t *tmp_data[4] = { NULL };
408  int tmp_linesize[4];
409  enum AVPixelFormat tmp_format;
410  int tmp_w, tmp_h, ret;
411 
412  if ((ret = ff_load_image(tmp_data, tmp_linesize, &tmp_w, &tmp_h, &tmp_format,
413  s->axisfile, s->ctx)) < 0)
414  goto error;
415 
416  ret = AVERROR(ENOMEM);
417  if (!(s->axis_frame = av_frame_alloc()))
418  goto error;
419 
420  if ((ret = ff_scale_image(s->axis_frame->data, s->axis_frame->linesize, s->width, s->axis_h,
421  convert_axis_pixel_format(s->format), tmp_data, tmp_linesize, tmp_w, tmp_h,
422  tmp_format, s->ctx)) < 0)
423  goto error;
424 
425  s->axis_frame->width = s->width;
426  s->axis_frame->height = s->axis_h;
427  s->axis_frame->format = convert_axis_pixel_format(s->format);
428  av_freep(tmp_data);
429  return 0;
430 
431 error:
432  av_frame_free(&s->axis_frame);
433  av_freep(tmp_data);
434  return ret;
435 }
436 
437 static double midi(void *p, double f)
438 {
439  return log2(f/440.0) * 12.0 + 69.0;
440 }
441 
442 static double r_func(void *p, double x)
443 {
444  x = av_clipd(x, 0.0, 1.0);
445  return lrint(x*255.0) << 16;
446 }
447 
448 static double g_func(void *p, double x)
449 {
450  x = av_clipd(x, 0.0, 1.0);
451  return lrint(x*255.0) << 8;
452 }
453 
454 static double b_func(void *p, double x)
455 {
456  x = av_clipd(x, 0.0, 1.0);
457  return lrint(x*255.0);
458 }
459 
460 static int init_axis_color(ShowCQTContext *s, AVFrame *tmp, int half)
461 {
462  const char *var_names[] = { "timeclamp", "tc", "frequency", "freq", "f", NULL };
463  const char *func_names[] = { "midi", "r", "g", "b", NULL };
464  double (*funcs[])(void *, double) = { midi, r_func, g_func, b_func };
465  AVExpr *expr = NULL;
466  double *freq = NULL;
467  int x, xs, y, ret;
468  int width = half ? 1920/2 : 1920, height = half ? 16 : 32;
469  int step = half ? 2 : 1;
470 
471  if (s->basefreq != (double) BASEFREQ || s->endfreq != (double) ENDFREQ) {
472  av_log(s->ctx, AV_LOG_WARNING, "font axis rendering is not implemented in non-default frequency range,"
473  " please use axisfile option instead.\n");
474  return AVERROR(EINVAL);
475  }
476 
477  if (s->cqt_len == 1920)
478  freq = s->freq;
479  else if (!(freq = create_freq_table(s->basefreq, s->endfreq, 1920)))
480  return AVERROR(ENOMEM);
481 
482  if ((ret = av_expr_parse(&expr, s->fontcolor, var_names, func_names, funcs, NULL, NULL, 0, s->ctx)) < 0) {
483  if (freq != s->freq)
484  av_freep(&freq);
485  return ret;
486  }
487 
488  for (x = 0, xs = 0; x < width; x++, xs += step) {
489  double vars[] = { s->timeclamp, s->timeclamp, freq[xs], freq[xs], freq[xs] };
490  int color = (int) av_expr_eval(expr, vars, NULL);
491  uint8_t r = (color >> 16) & 0xFF, g = (color >> 8) & 0xFF, b = color & 0xFF;
492  uint8_t *data = tmp->data[0];
493  int linesize = tmp->linesize[0];
494  for (y = 0; y < height; y++) {
495  data[linesize * y + 4 * x] = r;
496  data[linesize * y + 4 * x + 1] = g;
497  data[linesize * y + 4 * x + 2] = b;
498  }
499  }
500 
501  av_expr_free(expr);
502  if (freq != s->freq)
503  av_freep(&freq);
504  return 0;
505 }
506 
507 static int render_freetype(ShowCQTContext *s, AVFrame *tmp, char *fontfile)
508 {
509 #if CONFIG_LIBFREETYPE
510  const char *str = "EF G A BC D ";
511  uint8_t *data = tmp->data[0];
512  int linesize = tmp->linesize[0];
513  FT_Library lib = NULL;
514  FT_Face face = NULL;
515  int font_width = 16, font_height = 32;
516  int font_repeat = font_width * 12;
517  int linear_hori_advance = font_width * 65536;
518  int non_monospace_warning = 0;
519  int x;
520 
521  if (!fontfile)
522  return AVERROR(EINVAL);
523 
524  if (FT_Init_FreeType(&lib))
525  goto fail;
526 
527  if (FT_New_Face(lib, fontfile, 0, &face))
528  goto fail;
529 
530  if (FT_Set_Char_Size(face, 16*64, 0, 0, 0))
531  goto fail;
532 
533  if (FT_Load_Char(face, 'A', FT_LOAD_RENDER))
534  goto fail;
535 
536  if (FT_Set_Char_Size(face, 16*64 * linear_hori_advance / face->glyph->linearHoriAdvance, 0, 0, 0))
537  goto fail;
538 
539  for (x = 0; x < 12; x++) {
540  int sx, sy, rx, bx, by, dx, dy;
541 
542  if (str[x] == ' ')
543  continue;
544 
545  if (FT_Load_Char(face, str[x], FT_LOAD_RENDER))
546  goto fail;
547 
548  if (face->glyph->advance.x != font_width*64 && !non_monospace_warning) {
549  av_log(s->ctx, AV_LOG_WARNING, "font is not monospace.\n");
550  non_monospace_warning = 1;
551  }
552 
553  sy = font_height - 8 - face->glyph->bitmap_top;
554  for (rx = 0; rx < 10; rx++) {
555  sx = rx * font_repeat + x * font_width + face->glyph->bitmap_left;
556  for (by = 0; by < face->glyph->bitmap.rows; by++) {
557  dy = by + sy;
558  if (dy < 0)
559  continue;
560  if (dy >= font_height)
561  break;
562 
563  for (bx = 0; bx < face->glyph->bitmap.width; bx++) {
564  dx = bx + sx;
565  if (dx < 0)
566  continue;
567  if (dx >= 1920)
568  break;
569  data[dy*linesize+4*dx+3] = face->glyph->bitmap.buffer[by*face->glyph->bitmap.width+bx];
570  }
571  }
572  }
573  }
574 
575  FT_Done_Face(face);
576  FT_Done_FreeType(lib);
577  return 0;
578 
579 fail:
580  av_log(s->ctx, AV_LOG_WARNING, "error while loading freetype font.\n");
581  FT_Done_Face(face);
582  FT_Done_FreeType(lib);
583  return AVERROR(EINVAL);
584 #else
585  if (fontfile)
586  av_log(s->ctx, AV_LOG_WARNING, "freetype is not available, ignoring fontfile option.\n");
587  return AVERROR(EINVAL);
588 #endif
589 }
590 
591 static int render_fontconfig(ShowCQTContext *s, AVFrame *tmp, char* font)
592 {
593 #if CONFIG_LIBFONTCONFIG
594  FcConfig *fontconfig;
595  FcPattern *pat, *best;
596  FcResult result = FcResultMatch;
597  char *filename;
598  int i, ret;
599 
600  if (!font)
601  return AVERROR(EINVAL);
602 
603  for (i = 0; font[i]; i++) {
604  if (font[i] == '|')
605  font[i] = ':';
606  }
607 
608  if (!(fontconfig = FcInitLoadConfigAndFonts())) {
609  av_log(s->ctx, AV_LOG_ERROR, "impossible to init fontconfig.\n");
610  return AVERROR_UNKNOWN;
611  }
612 
613  if (!(pat = FcNameParse((uint8_t *)font))) {
614  av_log(s->ctx, AV_LOG_ERROR, "could not parse fontconfig pat.\n");
615  FcConfigDestroy(fontconfig);
616  return AVERROR(EINVAL);
617  }
618 
619  FcDefaultSubstitute(pat);
620 
621  if (!FcConfigSubstitute(fontconfig, pat, FcMatchPattern)) {
622  av_log(s->ctx, AV_LOG_ERROR, "could not substitue fontconfig options.\n");
623  FcPatternDestroy(pat);
624  FcConfigDestroy(fontconfig);
625  return AVERROR(ENOMEM);
626  }
627 
628  best = FcFontMatch(fontconfig, pat, &result);
629  FcPatternDestroy(pat);
630 
631  ret = AVERROR(EINVAL);
632  if (!best || result != FcResultMatch) {
633  av_log(s->ctx, AV_LOG_ERROR, "cannot find a valid font for %s.\n", font);
634  goto fail;
635  }
636 
637  if (FcPatternGetString(best, FC_FILE, 0, (FcChar8 **)&filename) != FcResultMatch) {
638  av_log(s->ctx, AV_LOG_ERROR, "no file path for %s\n", font);
639  goto fail;
640  }
641 
642  ret = render_freetype(s, tmp, filename);
643 
644 fail:
645  FcPatternDestroy(best);
646  FcConfigDestroy(fontconfig);
647  return ret;
648 #else
649  if (font)
650  av_log(s->ctx, AV_LOG_WARNING, "fontconfig is not available, ignoring font option.\n");
651  return AVERROR(EINVAL);
652 #endif
653 }
654 
655 static int render_default_font(AVFrame *tmp)
656 {
657  const char *str = "EF G A BC D ";
658  const uint8_t *vga16_font = avpriv_vga16_font_get();
659  int x, u, v, mask;
660  uint8_t *data = tmp->data[0];
661  int linesize = tmp->linesize[0];
662  int width = 1920/2, height = 16;
663 
664  for (x = 0; x < width; x += width/10) {
665  uint8_t *startptr = data + 4 * x;
666  for (u = 0; u < 12; u++) {
667  for (v = 0; v < height; v++) {
668  uint8_t *p = startptr + v * linesize + height/2 * 4 * u;
669  for (mask = 0x80; mask; mask >>= 1, p += 4) {
670  if (mask & vga16_font[str[u] * 16 + v])
671  p[3] = 255;
672  else
673  p[3] = 0;
674  }
675  }
676  }
677  }
678 
679  return 0;
680 }
681 
682 static int init_axis_from_font(ShowCQTContext *s)
683 {
684  AVFrame *tmp = NULL;
685  int ret = AVERROR(ENOMEM);
686  int width = 1920, height = 32;
687  int default_font = 0;
688 
689  if (!(tmp = alloc_frame_empty(AV_PIX_FMT_RGBA, width, height)))
690  goto fail;
691 
692  if (!(s->axis_frame = av_frame_alloc()))
693  goto fail;
694 
695  if (render_freetype(s, tmp, s->fontfile) < 0 &&
696  render_fontconfig(s, tmp, s->font) < 0 &&
697  (default_font = 1, ret = render_default_font(tmp)) < 0)
698  goto fail;
699 
700  if (default_font)
701  width /= 2, height /= 2;
702 
703  if ((ret = init_axis_color(s, tmp, default_font)) < 0)
704  goto fail;
705 
706  if ((ret = ff_scale_image(s->axis_frame->data, s->axis_frame->linesize, s->width, s->axis_h,
707  convert_axis_pixel_format(s->format), tmp->data, tmp->linesize,
708  width, height, AV_PIX_FMT_RGBA, s->ctx)) < 0)
709  goto fail;
710 
711  av_frame_free(&tmp);
712  s->axis_frame->width = s->width;
713  s->axis_frame->height = s->axis_h;
714  s->axis_frame->format = convert_axis_pixel_format(s->format);
715  return 0;
716 
717 fail:
718  av_frame_free(&tmp);
719  av_frame_free(&s->axis_frame);
720  return ret;
721 }
722 
723 static float calculate_gamma(float v, float g)
724 {
725  if (g == 1.0f)
726  return v;
727  if (g == 2.0f)
728  return sqrtf(v);
729  if (g == 3.0f)
730  return cbrtf(v);
731  if (g == 4.0f)
732  return sqrtf(sqrtf(v));
733  return expf(logf(v) / g);
734 }
735 
736 static void rgb_from_cqt(ColorFloat *c, const AVComplexFloat *v, float g, int len, float cscheme[6])
737 {
738  int x;
739  for (x = 0; x < len; x++) {
740  c[x].rgb.r = 255.0f * calculate_gamma(FFMIN(1.0f, cscheme[0] * v[x].re + cscheme[3] * v[x].im), g);
741  c[x].rgb.g = 255.0f * calculate_gamma(FFMIN(1.0f, cscheme[1] * v[x].re + cscheme[4] * v[x].im), g);
742  c[x].rgb.b = 255.0f * calculate_gamma(FFMIN(1.0f, cscheme[2] * v[x].re + cscheme[5] * v[x].im), g);
743  }
744 }
745 
746 static void yuv_from_cqt(ColorFloat *c, const AVComplexFloat *v, float gamma, int len, float cm[3][3], float cscheme[6])
747 {
748  int x;
749  for (x = 0; x < len; x++) {
750  float r, g, b;
751  r = calculate_gamma(FFMIN(1.0f, cscheme[0] * v[x].re + cscheme[3] * v[x].im), gamma);
752  g = calculate_gamma(FFMIN(1.0f, cscheme[1] * v[x].re + cscheme[4] * v[x].im), gamma);
753  b = calculate_gamma(FFMIN(1.0f, cscheme[2] * v[x].re + cscheme[5] * v[x].im), gamma);
754  c[x].yuv.y = cm[0][0] * r + cm[0][1] * g + cm[0][2] * b;
755  c[x].yuv.u = cm[1][0] * r + cm[1][1] * g + cm[1][2] * b;
756  c[x].yuv.v = cm[2][0] * r + cm[2][1] * g + cm[2][2] * b;
757  }
758 }
759 
760 static void draw_bar_rgb(AVFrame *out, const float *h, const float *rcp_h,
761  const ColorFloat *c, int bar_h, float bar_t)
762 {
763  int x, y, w = out->width;
764  float mul, ht, rcp_bar_h = 1.0f / bar_h, rcp_bar_t = 1.0f / bar_t;
765  uint8_t *v = out->data[0], *lp;
766  int ls = out->linesize[0];
767 
768  for (y = 0; y < bar_h; y++) {
769  ht = (bar_h - y) * rcp_bar_h;
770  lp = v + y * ls;
771  for (x = 0; x < w; x++) {
772  if (h[x] <= ht) {
773  *lp++ = 0;
774  *lp++ = 0;
775  *lp++ = 0;
776  } else {
777  mul = (h[x] - ht) * rcp_h[x];
778  mul = (mul < bar_t) ? (mul * rcp_bar_t) : 1.0f;
779  *lp++ = lrintf(mul * c[x].rgb.r);
780  *lp++ = lrintf(mul * c[x].rgb.g);
781  *lp++ = lrintf(mul * c[x].rgb.b);
782  }
783  }
784  }
785 }
786 
787 #define DRAW_BAR_WITH_CHROMA(x) \
788 do { \
789  if (h[x] <= ht) { \
790  *lpy++ = 16; \
791  *lpu++ = 128; \
792  *lpv++ = 128; \
793  } else { \
794  mul = (h[x] - ht) * rcp_h[x]; \
795  mul = (mul < bar_t) ? (mul * rcp_bar_t) : 1.0f; \
796  *lpy++ = lrintf(mul * c[x].yuv.y + 16.0f); \
797  *lpu++ = lrintf(mul * c[x].yuv.u + 128.0f); \
798  *lpv++ = lrintf(mul * c[x].yuv.v + 128.0f); \
799  } \
800 } while (0)
801 
802 #define DRAW_BAR_WITHOUT_CHROMA(x) \
803 do { \
804  if (h[x] <= ht) { \
805  *lpy++ = 16; \
806  } else { \
807  mul = (h[x] - ht) * rcp_h[x]; \
808  mul = (mul < bar_t) ? (mul * rcp_bar_t) : 1.0f; \
809  *lpy++ = lrintf(mul * c[x].yuv.y + 16.0f); \
810  } \
811 } while (0)
812 
813 static void draw_bar_yuv(AVFrame *out, const float *h, const float *rcp_h,
814  const ColorFloat *c, int bar_h, float bar_t)
815 {
816  int x, y, yh, w = out->width;
817  float mul, ht, rcp_bar_h = 1.0f / bar_h, rcp_bar_t = 1.0f / bar_t;
818  uint8_t *vy = out->data[0], *vu = out->data[1], *vv = out->data[2];
819  uint8_t *lpy, *lpu, *lpv;
820  int lsy = out->linesize[0], lsu = out->linesize[1], lsv = out->linesize[2];
821  int fmt = out->format;
822 
823  for (y = 0; y < bar_h; y += 2) {
824  yh = (fmt == AV_PIX_FMT_YUV420P) ? y / 2 : y;
825  ht = (bar_h - y) * rcp_bar_h;
826  lpy = vy + y * lsy;
827  lpu = vu + yh * lsu;
828  lpv = vv + yh * lsv;
829  if (fmt == AV_PIX_FMT_YUV444P) {
830  for (x = 0; x < w; x += 2) {
831  DRAW_BAR_WITH_CHROMA(x);
832  DRAW_BAR_WITH_CHROMA(x+1);
833  }
834  } else {
835  for (x = 0; x < w; x += 2) {
836  DRAW_BAR_WITH_CHROMA(x);
837  DRAW_BAR_WITHOUT_CHROMA(x+1);
838  }
839  }
840 
841  ht = (bar_h - (y+1)) * rcp_bar_h;
842  lpy = vy + (y+1) * lsy;
843  lpu = vu + (y+1) * lsu;
844  lpv = vv + (y+1) * lsv;
845  if (fmt == AV_PIX_FMT_YUV444P) {
846  for (x = 0; x < w; x += 2) {
847  DRAW_BAR_WITH_CHROMA(x);
848  DRAW_BAR_WITH_CHROMA(x+1);
849  }
850  } else if (fmt == AV_PIX_FMT_YUV422P) {
851  for (x = 0; x < w; x += 2) {
852  DRAW_BAR_WITH_CHROMA(x);
853  DRAW_BAR_WITHOUT_CHROMA(x+1);
854  }
855  } else {
856  for (x = 0; x < w; x += 2) {
857  DRAW_BAR_WITHOUT_CHROMA(x);
858  DRAW_BAR_WITHOUT_CHROMA(x+1);
859  }
860  }
861  }
862 }
863 
864 static void draw_axis_rgb(AVFrame *out, AVFrame *axis, const ColorFloat *c, int off)
865 {
866  int x, y, w = axis->width, h = axis->height;
867  float a, rcp_255 = 1.0f / 255.0f;
868  uint8_t *lp, *lpa;
869 
870  for (y = 0; y < h; y++) {
871  lp = out->data[0] + (off + y) * out->linesize[0];
872  lpa = axis->data[0] + y * axis->linesize[0];
873  for (x = 0; x < w; x++) {
874  if (!lpa[3]) {
875  *lp++ = lrintf(c[x].rgb.r);
876  *lp++ = lrintf(c[x].rgb.g);
877  *lp++ = lrintf(c[x].rgb.b);
878  } else if (lpa[3] == 255) {
879  *lp++ = lpa[0];
880  *lp++ = lpa[1];
881  *lp++ = lpa[2];
882  } else {
883  a = rcp_255 * lpa[3];
884  *lp++ = lrintf(a * lpa[0] + (1.0f - a) * c[x].rgb.r);
885  *lp++ = lrintf(a * lpa[1] + (1.0f - a) * c[x].rgb.g);
886  *lp++ = lrintf(a * lpa[2] + (1.0f - a) * c[x].rgb.b);
887  }
888  lpa += 4;
889  }
890  }
891 }
892 
893 #define BLEND_WITH_CHROMA(c) \
894 do { \
895  if (!*lpaa) { \
896  *lpy = lrintf(c.yuv.y + 16.0f); \
897  *lpu = lrintf(c.yuv.u + 128.0f); \
898  *lpv = lrintf(c.yuv.v + 128.0f); \
899  } else if (255 == *lpaa) { \
900  *lpy = *lpay; \
901  *lpu = *lpau; \
902  *lpv = *lpav; \
903  } else { \
904  float a = (1.0f/255.0f) * (*lpaa); \
905  *lpy = lrintf(a * (*lpay) + (1.0f - a) * (c.yuv.y + 16.0f)); \
906  *lpu = lrintf(a * (*lpau) + (1.0f - a) * (c.yuv.u + 128.0f)); \
907  *lpv = lrintf(a * (*lpav) + (1.0f - a) * (c.yuv.v + 128.0f)); \
908  } \
909  lpy++; lpu++; lpv++; \
910  lpay++; lpau++; lpav++; lpaa++; \
911 } while (0)
912 
913 #define BLEND_WITHOUT_CHROMA(c, alpha_inc) \
914 do { \
915  if (!*lpaa) { \
916  *lpy = lrintf(c.yuv.y + 16.0f); \
917  } else if (255 == *lpaa) { \
918  *lpy = *lpay; \
919  } else { \
920  float a = (1.0f/255.0f) * (*lpaa); \
921  *lpy = lrintf(a * (*lpay) + (1.0f - a) * (c.yuv.y + 16.0f)); \
922  } \
923  lpy++; \
924  lpay++; lpaa += alpha_inc; \
925 } while (0)
926 
927 #define BLEND_CHROMA2(c) \
928 do { \
929  if (!lpaa[0] && !lpaa[1]) { \
930  *lpu = lrintf(c.yuv.u + 128.0f); \
931  *lpv = lrintf(c.yuv.v + 128.0f); \
932  } else if (255 == lpaa[0] && 255 == lpaa[1]) { \
933  *lpu = *lpau; *lpv = *lpav; \
934  } else { \
935  float a0 = (0.5f/255.0f) * lpaa[0]; \
936  float a1 = (0.5f/255.0f) * lpaa[1]; \
937  float b = 1.0f - a0 - a1; \
938  *lpu = lrintf(a0 * lpau[0] + a1 * lpau[1] + b * (c.yuv.u + 128.0f)); \
939  *lpv = lrintf(a0 * lpav[0] + a1 * lpav[1] + b * (c.yuv.v + 128.0f)); \
940  } \
941  lpau += 2; lpav += 2; lpaa++; lpu++; lpv++; \
942 } while (0)
943 
944 #define BLEND_CHROMA2x2(c) \
945 do { \
946  if (!lpaa[0] && !lpaa[1] && !lpaa[lsaa] && !lpaa[lsaa+1]) { \
947  *lpu = lrintf(c.yuv.u + 128.0f); \
948  *lpv = lrintf(c.yuv.v + 128.0f); \
949  } else if (255 == lpaa[0] && 255 == lpaa[1] && \
950  255 == lpaa[lsaa] && 255 == lpaa[lsaa+1]) { \
951  *lpu = *lpau; *lpv = *lpav; \
952  } else { \
953  float a0 = (0.25f/255.0f) * lpaa[0]; \
954  float a1 = (0.25f/255.0f) * lpaa[1]; \
955  float a2 = (0.25f/255.0f) * lpaa[lsaa]; \
956  float a3 = (0.25f/255.0f) * lpaa[lsaa+1]; \
957  float b = 1.0f - a0 - a1 - a2 - a3; \
958  *lpu = lrintf(a0 * lpau[0] + a1 * lpau[1] + a2 * lpau[lsau] + a3 * lpau[lsau+1] \
959  + b * (c.yuv.u + 128.0f)); \
960  *lpv = lrintf(a0 * lpav[0] + a1 * lpav[1] + a2 * lpav[lsav] + a3 * lpav[lsav+1] \
961  + b * (c.yuv.v + 128.0f)); \
962  } \
963  lpau += 2; lpav += 2; lpaa++; lpu++; lpv++; \
964 } while (0)
965 
966 static void draw_axis_yuv(AVFrame *out, AVFrame *axis, const ColorFloat *c, int off)
967 {
968  int fmt = out->format, x, y, yh, w = axis->width, h = axis->height;
969  int offh = (fmt == AV_PIX_FMT_YUV420P) ? off / 2 : off;
970  uint8_t *vy = out->data[0], *vu = out->data[1], *vv = out->data[2];
971  uint8_t *vay = axis->data[0], *vau = axis->data[1], *vav = axis->data[2], *vaa = axis->data[3];
972  int lsy = out->linesize[0], lsu = out->linesize[1], lsv = out->linesize[2];
973  int lsay = axis->linesize[0], lsau = axis->linesize[1], lsav = axis->linesize[2], lsaa = axis->linesize[3];
974  uint8_t *lpy, *lpu, *lpv, *lpay, *lpau, *lpav, *lpaa;
975 
976  for (y = 0; y < h; y += 2) {
977  yh = (fmt == AV_PIX_FMT_YUV420P) ? y / 2 : y;
978  lpy = vy + (off + y) * lsy;
979  lpu = vu + (offh + yh) * lsu;
980  lpv = vv + (offh + yh) * lsv;
981  lpay = vay + y * lsay;
982  lpau = vau + y * lsau;
983  lpav = vav + y * lsav;
984  lpaa = vaa + y * lsaa;
985  if (fmt == AV_PIX_FMT_YUV444P) {
986  for (x = 0; x < w; x += 2) {
987  BLEND_WITH_CHROMA(c[x]);
988  BLEND_WITH_CHROMA(c[x+1]);
989  }
990  } else if (fmt == AV_PIX_FMT_YUV422P) {
991  for (x = 0; x < w; x += 2) {
992  BLEND_WITHOUT_CHROMA(c[x], 0);
993  BLEND_CHROMA2(c[x]);
994  BLEND_WITHOUT_CHROMA(c[x+1], 1);
995  }
996  } else {
997  for (x = 0; x < w; x += 2) {
998  BLEND_WITHOUT_CHROMA(c[x], 0);
999  BLEND_CHROMA2x2(c[x]);
1000  BLEND_WITHOUT_CHROMA(c[x+1], 1);
1001  }
1002  }
1003 
1004  lpy = vy + (off + y + 1) * lsy;
1005  lpu = vu + (off + y + 1) * lsu;
1006  lpv = vv + (off + y + 1) * lsv;
1007  lpay = vay + (y + 1) * lsay;
1008  lpau = vau + (y + 1) * lsau;
1009  lpav = vav + (y + 1) * lsav;
1010  lpaa = vaa + (y + 1) * lsaa;
1011  if (fmt == AV_PIX_FMT_YUV444P) {
1012  for (x = 0; x < w; x += 2) {
1013  BLEND_WITH_CHROMA(c[x]);
1014  BLEND_WITH_CHROMA(c[x+1]);
1015  }
1016  } else if (fmt == AV_PIX_FMT_YUV422P) {
1017  for (x = 0; x < w; x += 2) {
1018  BLEND_WITHOUT_CHROMA(c[x], 0);
1019  BLEND_CHROMA2(c[x]);
1020  BLEND_WITHOUT_CHROMA(c[x+1], 1);
1021  }
1022  } else {
1023  for (x = 0; x < w; x += 2) {
1024  BLEND_WITHOUT_CHROMA(c[x], 1);
1025  BLEND_WITHOUT_CHROMA(c[x+1], 1);
1026  }
1027  }
1028  }
1029 }
1030 
1031 static void draw_sono(AVFrame *out, AVFrame *sono, int off, int idx)
1032 {
1033  int fmt = out->format, h = sono->height;
1034  int nb_planes = (fmt == AV_PIX_FMT_RGB24) ? 1 : 3;
1035  int offh = (fmt == AV_PIX_FMT_YUV420P) ? off / 2 : off;
1036  int inc = (fmt == AV_PIX_FMT_YUV420P) ? 2 : 1;
1037  ptrdiff_t ls;
1038  int i, y, yh;
1039 
1040  ls = FFABS(FFMIN(out->linesize[0], sono->linesize[0]));
1041  for (y = 0; y < h; y++) {
1042  memcpy(out->data[0] + (off + y) * out->linesize[0],
1043  sono->data[0] + (idx + y) % h * sono->linesize[0], ls);
1044  }
1045 
1046  for (i = 1; i < nb_planes; i++) {
1047  ls = FFABS(FFMIN(out->linesize[i], sono->linesize[i]));
1048  for (y = 0; y < h; y += inc) {
1049  yh = (fmt == AV_PIX_FMT_YUV420P) ? y / 2 : y;
1050  memcpy(out->data[i] + (offh + yh) * out->linesize[i],
1051  sono->data[i] + (idx + y) % h * sono->linesize[i], ls);
1052  }
1053  }
1054 }
1055 
1056 static void update_sono_rgb(AVFrame *sono, const ColorFloat *c, int idx)
1057 {
1058  int x, w = sono->width;
1059  uint8_t *lp = sono->data[0] + idx * sono->linesize[0];
1060 
1061  for (x = 0; x < w; x++) {
1062  *lp++ = lrintf(c[x].rgb.r);
1063  *lp++ = lrintf(c[x].rgb.g);
1064  *lp++ = lrintf(c[x].rgb.b);
1065  }
1066 }
1067 
1068 static void update_sono_yuv(AVFrame *sono, const ColorFloat *c, int idx)
1069 {
1070  int x, fmt = sono->format, w = sono->width;
1071  uint8_t *lpy = sono->data[0] + idx * sono->linesize[0];
1072  uint8_t *lpu = sono->data[1] + idx * sono->linesize[1];
1073  uint8_t *lpv = sono->data[2] + idx * sono->linesize[2];
1074 
1075  for (x = 0; x < w; x += 2) {
1076  *lpy++ = lrintf(c[x].yuv.y + 16.0f);
1077  *lpu++ = lrintf(c[x].yuv.u + 128.0f);
1078  *lpv++ = lrintf(c[x].yuv.v + 128.0f);
1079  *lpy++ = lrintf(c[x+1].yuv.y + 16.0f);
1080  if (fmt == AV_PIX_FMT_YUV444P) {
1081  *lpu++ = lrintf(c[x+1].yuv.u + 128.0f);
1082  *lpv++ = lrintf(c[x+1].yuv.v + 128.0f);
1083  }
1084  }
1085 }
1086 
1087 static void process_cqt(ShowCQTContext *s)
1088 {
1089  int x, i;
1090  if (!s->sono_count) {
1091  for (x = 0; x < s->cqt_len; x++) {
1092  s->h_buf[x] = s->bar_v_buf[x] * 0.5f * (s->cqt_result[x].re + s->cqt_result[x].im);
1093  }
1094  if (s->fcount > 1) {
1095  float rcp_fcount = 1.0f / s->fcount;
1096  for (x = 0; x < s->width; x++) {
1097  float h = 0.0f;
1098  for (i = 0; i < s->fcount; i++)
1099  h += s->h_buf[s->fcount * x + i];
1100  s->h_buf[x] = rcp_fcount * h;
1101  }
1102  }
1103  for (x = 0; x < s->width; x++) {
1104  s->h_buf[x] = calculate_gamma(s->h_buf[x], s->bar_g);
1105  s->rcp_h_buf[x] = 1.0f / (s->h_buf[x] + 0.0001f);
1106  }
1107  }
1108 
1109  for (x = 0; x < s->cqt_len; x++) {
1110  s->cqt_result[x].re *= s->sono_v_buf[x];
1111  s->cqt_result[x].im *= s->sono_v_buf[x];
1112  }
1113 
1114  if (s->fcount > 1) {
1115  float rcp_fcount = 1.0f / s->fcount;
1116  for (x = 0; x < s->width; x++) {
1117  AVComplexFloat result = {0.0f, 0.0f};
1118  for (i = 0; i < s->fcount; i++) {
1119  result.re += s->cqt_result[s->fcount * x + i].re;
1120  result.im += s->cqt_result[s->fcount * x + i].im;
1121  }
1122  s->cqt_result[x].re = rcp_fcount * result.re;
1123  s->cqt_result[x].im = rcp_fcount * result.im;
1124  }
1125  }
1126 
1127  if (s->format == AV_PIX_FMT_RGB24)
1128  rgb_from_cqt(s->c_buf, s->cqt_result, s->sono_g, s->width, s->cscheme_v);
1129  else
1130  yuv_from_cqt(s->c_buf, s->cqt_result, s->sono_g, s->width, s->cmatrix, s->cscheme_v);
1131 }
1132 
1133 static int plot_cqt(AVFilterContext *ctx, AVFrame **frameout)
1134 {
1135  AVFilterLink *outlink = ctx->outputs[0];
1136  ShowCQTContext *s = ctx->priv;
1137  int64_t last_time, cur_time;
1138 
1139 #define UPDATE_TIME(t) \
1140  cur_time = av_gettime_relative(); \
1141  t += cur_time - last_time; \
1142  last_time = cur_time
1143 
1144  last_time = av_gettime_relative();
1145 
1146  memcpy(s->fft_input, s->fft_data, s->fft_len * sizeof(*s->fft_data));
1147  if (s->attack_data) {
1148  int k;
1149  for (k = 0; k < s->remaining_fill_max; k++) {
1150  s->fft_input[s->fft_len/2+k].re *= s->attack_data[k];
1151  s->fft_input[s->fft_len/2+k].im *= s->attack_data[k];
1152  }
1153  }
1154 
1155  s->tx_fn(s->fft_ctx, s->fft_result, s->fft_input, sizeof(AVComplexFloat));
1156  UPDATE_TIME(s->fft_time);
1157 
1158  s->cqt_calc(s->cqt_result, s->fft_result, s->coeffs, s->cqt_len, s->fft_len);
1159  UPDATE_TIME(s->cqt_time);
1160 
1161  process_cqt(s);
1162  UPDATE_TIME(s->process_cqt_time);
1163 
1164  if (s->sono_h) {
1165  s->update_sono(s->sono_frame, s->c_buf, s->sono_idx);
1166  UPDATE_TIME(s->update_sono_time);
1167  }
1168 
1169  if (!s->sono_count) {
1170  AVFrame *out = *frameout = ff_get_video_buffer(outlink, outlink->w, outlink->h);
1171  if (!out)
1172  return AVERROR(ENOMEM);
1173  out->sample_aspect_ratio = av_make_q(1, 1);
1174  out->color_range = AVCOL_RANGE_MPEG;
1175  out->colorspace = s->csp;
1176  UPDATE_TIME(s->alloc_time);
1177 
1178  if (s->bar_h) {
1179  s->draw_bar(out, s->h_buf, s->rcp_h_buf, s->c_buf, s->bar_h, s->bar_t);
1180  UPDATE_TIME(s->bar_time);
1181  }
1182 
1183  if (s->axis_h) {
1184  s->draw_axis(out, s->axis_frame, s->c_buf, s->bar_h);
1185  UPDATE_TIME(s->axis_time);
1186  }
1187 
1188  if (s->sono_h) {
1189  s->draw_sono(out, s->sono_frame, s->bar_h + s->axis_h, s->sono_idx);
1190  UPDATE_TIME(s->sono_time);
1191  }
1192  }
1193  s->sono_count = (s->sono_count + 1) % s->count;
1194  if (s->sono_h)
1195  s->sono_idx = (s->sono_idx + s->sono_h - 1) % s->sono_h;
1196  return 0;
1197 }
1198 
1199 static void init_colormatrix(ShowCQTContext *s)
1200 {
1201  double kr, kg, kb;
1202 
1203  /* from vf_colorspace.c */
1204  switch (s->csp) {
1205  default:
1206  av_log(s->ctx, AV_LOG_WARNING, "unsupported colorspace, setting it to unspecified.\n");
1207  s->csp = AVCOL_SPC_UNSPECIFIED;
1208  case AVCOL_SPC_UNSPECIFIED:
1209  case AVCOL_SPC_BT470BG:
1210  case AVCOL_SPC_SMPTE170M:
1211  kr = 0.299; kb = 0.114; break;
1212  case AVCOL_SPC_BT709:
1213  kr = 0.2126; kb = 0.0722; break;
1214  case AVCOL_SPC_FCC:
1215  kr = 0.30; kb = 0.11; break;
1216  case AVCOL_SPC_SMPTE240M:
1217  kr = 0.212; kb = 0.087; break;
1218  case AVCOL_SPC_BT2020_NCL:
1219  kr = 0.2627; kb = 0.0593; break;
1220  }
1221 
1222  kg = 1.0 - kr - kb;
1223  s->cmatrix[0][0] = 219.0 * kr;
1224  s->cmatrix[0][1] = 219.0 * kg;
1225  s->cmatrix[0][2] = 219.0 * kb;
1226  s->cmatrix[1][0] = -112.0 * kr / (1.0 - kb);
1227  s->cmatrix[1][1] = -112.0 * kg / (1.0 - kb);
1228  s->cmatrix[1][2] = 112.0;
1229  s->cmatrix[2][0] = 112.0;
1230  s->cmatrix[2][1] = -112.0 * kg / (1.0 - kr);
1231  s->cmatrix[2][2] = -112.0 * kb / (1.0 - kr);
1232 }
1233 
1234 static int init_cscheme(ShowCQTContext *s)
1235 {
1236  char tail[2];
1237  int k;
1238 
1239  if (sscanf(s->cscheme, " %f | %f | %f | %f | %f | %f %1s", &s->cscheme_v[0],
1240  &s->cscheme_v[1], &s->cscheme_v[2], &s->cscheme_v[3], &s->cscheme_v[4],
1241  &s->cscheme_v[5], tail) != 6)
1242  goto fail;
1243 
1244  for (k = 0; k < 6; k++)
1245  if (isnan(s->cscheme_v[k]) || s->cscheme_v[k] < 0.0f || s->cscheme_v[k] > 1.0f)
1246  goto fail;
1247 
1248  return 0;
1249 
1250 fail:
1251  av_log(s->ctx, AV_LOG_ERROR, "invalid cscheme.\n");
1252  return AVERROR(EINVAL);
1253 }
1254 
1255 /* main filter control */
1256 static av_cold int init(AVFilterContext *ctx)
1257 {
1258  ShowCQTContext *s = ctx->priv;
1259  s->ctx = ctx;
1260 
1261  if (!s->fullhd) {
1262  av_log(ctx, AV_LOG_WARNING, "fullhd option is deprecated, use size/s option instead.\n");
1263  if (s->width != 1920 || s->height != 1080) {
1264  av_log(ctx, AV_LOG_ERROR, "fullhd set to 0 but with custom dimension.\n");
1265  return AVERROR(EINVAL);
1266  }
1267  s->width /= 2;
1268  s->height /= 2;
1269  s->fullhd = 1;
1270  }
1271 
1272  if (s->axis_h < 0) {
1273  s->axis_h = s->width / 60;
1274  if (s->axis_h & 1)
1275  s->axis_h++;
1276  if (s->bar_h >= 0 && s->sono_h >= 0)
1277  s->axis_h = s->height - s->bar_h - s->sono_h;
1278  if (s->bar_h >= 0 && s->sono_h < 0)
1279  s->axis_h = FFMIN(s->axis_h, s->height - s->bar_h);
1280  if (s->bar_h < 0 && s->sono_h >= 0)
1281  s->axis_h = FFMIN(s->axis_h, s->height - s->sono_h);
1282  }
1283 
1284  if (s->bar_h < 0) {
1285  s->bar_h = (s->height - s->axis_h) / 2;
1286  if (s->bar_h & 1)
1287  s->bar_h--;
1288  if (s->sono_h >= 0)
1289  s->bar_h = s->height - s->sono_h - s->axis_h;
1290  }
1291 
1292  if (s->sono_h < 0)
1293  s->sono_h = s->height - s->axis_h - s->bar_h;
1294 
1295  if ((s->width & 1) || (s->height & 1) || (s->bar_h & 1) || (s->axis_h & 1) || (s->sono_h & 1) ||
1296  (s->bar_h < 0) || (s->axis_h < 0) || (s->sono_h < 0) || (s->bar_h > s->height) ||
1297  (s->axis_h > s->height) || (s->sono_h > s->height) || (s->bar_h + s->axis_h + s->sono_h != s->height)) {
1298  av_log(ctx, AV_LOG_ERROR, "invalid dimension.\n");
1299  return AVERROR(EINVAL);
1300  }
1301 
1302  if (!s->fcount) {
1303  do {
1304  s->fcount++;
1305  } while(s->fcount * s->width < 1920 && s->fcount < 10);
1306  }
1307 
1308  init_colormatrix(s);
1309 
1310  return init_cscheme(s);
1311 }
1312 
1313 static av_cold void uninit(AVFilterContext *ctx)
1314 {
1315  common_uninit(ctx->priv);
1316 }
1317 
1318 static int query_formats(const AVFilterContext *ctx,
1319  AVFilterFormatsConfig **cfg_in,
1320  AVFilterFormatsConfig **cfg_out)
1321 {
1322  AVFilterFormats *formats = NULL;
1323  static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE };
1324  static const enum AVPixelFormat pix_fmts[] = {
1325  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
1326  AV_PIX_FMT_YUV444P, AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE
1327  };
1328  static const AVChannelLayout channel_layouts[] = { AV_CHANNEL_LAYOUT_STEREO,
1329  AV_CHANNEL_LAYOUT_STEREO_DOWNMIX, { 0 } };
1330  int ret;
1331 
1332  /* set input audio formats */
1333  formats = ff_make_format_list(sample_fmts);
1334  if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
1335  return ret;
1336 
1337  ret = ff_set_common_channel_layouts_from_list2(ctx, cfg_in, cfg_out, channel_layouts);
1338  if (ret < 0)
1339  return ret;
1340 
1341  /* set output video format */
1342  formats = ff_make_format_list(pix_fmts);
1343  if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
1344  return ret;
1345 
1346  return 0;
1347 }
1348 
1349 static int config_output(AVFilterLink *outlink)
1350 {
1351  FilterLink *l = ff_filter_link(outlink);
1352  AVFilterContext *ctx = outlink->src;
1353  AVFilterLink *inlink = ctx->inputs[0];
1354  ShowCQTContext *s = ctx->priv;
1355  float scale = 1.f;
1356  int ret;
1357 
1358  common_uninit(s);
1359 
1360  outlink->w = s->width;
1361  outlink->h = s->height;
1362  s->format = outlink->format;
1363  outlink->sample_aspect_ratio = av_make_q(1, 1);
1364  l->frame_rate = s->rate;
1365  outlink->time_base = av_inv_q(s->rate);
1366  av_log(ctx, AV_LOG_VERBOSE, "video: %dx%d %s %d/%d fps, bar_h = %d, axis_h = %d, sono_h = %d.\n",
1367  s->width, s->height, av_get_pix_fmt_name(s->format), s->rate.num, s->rate.den,
1368  s->bar_h, s->axis_h, s->sono_h);
1369 
1370  s->cqt_len = s->width * s->fcount;
1371  if (!(s->freq = create_freq_table(s->basefreq, s->endfreq, s->cqt_len)))
1372  return AVERROR(ENOMEM);
1373 
1374  if ((ret = init_volume(s)) < 0)
1375  return ret;
1376 
1377  s->fft_bits = FFMAX(ceil(log2(inlink->sample_rate * s->timeclamp)), 4);
1378  s->fft_len = 1 << s->fft_bits;
1379  av_log(ctx, AV_LOG_VERBOSE, "fft_len = %d, cqt_len = %d.\n", s->fft_len, s->cqt_len);
1380 
1381  ret = av_tx_init(&s->fft_ctx, &s->tx_fn, AV_TX_FLOAT_FFT, 0, s->fft_len, &scale, 0);
1382  s->fft_data = av_calloc(s->fft_len, sizeof(*s->fft_data));
1383  s->fft_input = av_calloc(FFALIGN(s->fft_len + 64, 256), sizeof(*s->fft_input));
1384  s->fft_result = av_calloc(FFALIGN(s->fft_len + 64, 256), sizeof(*s->fft_result));
1385  s->cqt_result = av_malloc_array(s->cqt_len, sizeof(*s->cqt_result));
1386  if (!s->fft_ctx || !s->fft_data || !s->fft_result || !s->cqt_result)
1387  return AVERROR(ENOMEM);
1388 
1389  s->remaining_fill_max = s->fft_len / 2;
1390  if (s->attack > 0.0) {
1391  int k;
1392 
1393  s->remaining_fill_max = FFMIN(s->remaining_fill_max, ceil(inlink->sample_rate * s->attack));
1394  s->attack_data = av_malloc_array(s->remaining_fill_max, sizeof(*s->attack_data));
1395  if (!s->attack_data)
1396  return AVERROR(ENOMEM);
1397 
1398  for (k = 0; k < s->remaining_fill_max; k++) {
1399  double y = M_PI * k / (inlink->sample_rate * s->attack);
1400  s->attack_data[k] = 0.355768 + 0.487396 * cos(y) + 0.144232 * cos(2*y) + 0.012604 * cos(3*y);
1401  }
1402  }
1403 
1404  s->cqt_align = 1;
1405  s->cqt_calc = cqt_calc;
1406  s->permute_coeffs = NULL;
1407  s->draw_sono = draw_sono;
1408  if (s->format == AV_PIX_FMT_RGB24) {
1409  s->draw_bar = draw_bar_rgb;
1410  s->draw_axis = draw_axis_rgb;
1411  s->update_sono = update_sono_rgb;
1412  } else {
1413  s->draw_bar = draw_bar_yuv;
1414  s->draw_axis = draw_axis_yuv;
1415  s->update_sono = update_sono_yuv;
1416  }
1417 
1418 #if ARCH_X86
1419  ff_showcqt_init_x86(s);
1420 #endif
1421 
1422  if ((ret = init_cqt(s)) < 0)
1423  return ret;
1424 
1425  if (s->axis_h) {
1426  if (!s->axis) {
1427  if ((ret = init_axis_empty(s)) < 0)
1428  return ret;
1429  } else if (s->axisfile) {
1430  if (init_axis_from_file(s) < 0) {
1431  av_log(ctx, AV_LOG_WARNING, "loading axis image failed, fallback to font rendering.\n");
1432  if (init_axis_from_font(s) < 0) {
1433  av_log(ctx, AV_LOG_WARNING, "loading axis font failed, disable text drawing.\n");
1434  if ((ret = init_axis_empty(s)) < 0)
1435  return ret;
1436  }
1437  }
1438  } else {
1439  if (init_axis_from_font(s) < 0) {
1440  av_log(ctx, AV_LOG_WARNING, "loading axis font failed, disable text drawing.\n");
1441  if ((ret = init_axis_empty(s)) < 0)
1442  return ret;
1443  }
1444  }
1445  }
1446 
1447  if (s->sono_h) {
1448  s->sono_frame = alloc_frame_empty((outlink->format == AV_PIX_FMT_YUV420P) ?
1449  AV_PIX_FMT_YUV422P : outlink->format, s->width, s->sono_h);
1450  if (!s->sono_frame)
1451  return AVERROR(ENOMEM);
1452  }
1453 
1454  s->h_buf = av_malloc_array(s->cqt_len, sizeof (*s->h_buf));
1455  s->rcp_h_buf = av_malloc_array(s->width, sizeof(*s->rcp_h_buf));
1456  s->c_buf = av_malloc_array(s->width, sizeof(*s->c_buf));
1457  if (!s->h_buf || !s->rcp_h_buf || !s->c_buf)
1458  return AVERROR(ENOMEM);
1459 
1460  s->sono_count = 0;
1461  s->next_pts = 0;
1462  s->sono_idx = 0;
1463  s->remaining_fill = s->remaining_fill_max;
1464  s->remaining_frac = 0;
1465  s->step_frac = av_div_q(av_make_q(inlink->sample_rate, s->count) , s->rate);
1466  s->step = (int)(s->step_frac.num / s->step_frac.den);
1467  s->step_frac.num %= s->step_frac.den;
1468  if (s->step_frac.num) {
1469  av_log(ctx, AV_LOG_VERBOSE, "audio: %d Hz, step = %d + %d/%d.\n",
1470  inlink->sample_rate, s->step, s->step_frac.num, s->step_frac.den);
1471  } else {
1472  av_log(ctx, AV_LOG_VERBOSE, "audio: %d Hz, step = %d.\n",
1473  inlink->sample_rate, s->step);
1474  }
1475 
1476  return 0;
1477 }
1478 
1479 
1480 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
1481 {
1482  AVFilterContext *ctx = inlink->dst;
1483  AVFilterLink *outlink = ctx->outputs[0];
1484  ShowCQTContext *s = ctx->priv;
1485  int remaining, step, ret, x, i, j, m, got_frame = 0;
1486  float *audio_data;
1487  AVFrame *out = NULL;
1488 
1489  if (!insamples) {
1490  while (s->remaining_fill < s->remaining_fill_max) {
1491  memset(&s->fft_data[s->fft_len/2 + s->remaining_fill_max - s->remaining_fill], 0, sizeof(*s->fft_data) * s->remaining_fill);
1492  ret = plot_cqt(ctx, &out);
1493  if (ret < 0)
1494  return ret;
1495 
1496  step = s->step + (s->step_frac.num + s->remaining_frac) / s->step_frac.den;
1497  s->remaining_frac = (s->step_frac.num + s->remaining_frac) % s->step_frac.den;
1498  for (x = 0; x < (s->fft_len/2 + s->remaining_fill_max - step); x++)
1499  s->fft_data[x] = s->fft_data[x+step];
1500  s->remaining_fill += step;
1501  s->next_pts++;
1502 
1503  if (out) {
1504  out->pts = s->next_pts;
1505  out->duration = 1;
1506  return ff_filter_frame(outlink, out);
1507  }
1508  }
1509  return 0;
1510  }
1511 
1512  remaining = insamples->nb_samples;
1513  audio_data = (float*) insamples->data[0];
1514 
1515  while (remaining) {
1516  i = insamples->nb_samples - remaining;
1517  j = s->fft_len/2 + s->remaining_fill_max - s->remaining_fill;
1518  if (remaining >= s->remaining_fill) {
1519  for (m = 0; m < s->remaining_fill; m++) {
1520  s->fft_data[j+m].re = audio_data[2*(i+m)];
1521  s->fft_data[j+m].im = audio_data[2*(i+m)+1];
1522  }
1523  ret = plot_cqt(ctx, &out);
1524  if (ret < 0) {
1525  av_frame_free(&insamples);
1526  return ret;
1527  }
1528  remaining -= s->remaining_fill;
1529  if (out) {
1530  int64_t pts = av_rescale_q(insamples->nb_samples - remaining - s->remaining_fill_max,
1531  av_make_q(1, inlink->sample_rate), inlink->time_base);
1532  out->pts = av_rescale_q(insamples->pts + pts, inlink->time_base, outlink->time_base);
1533  out->duration = 1;
1534  got_frame = 1;
1535  ret = ff_filter_frame(outlink, out);
1536  if (ret < 0) {
1537  av_frame_free(&insamples);
1538  return ret;
1539  }
1540  out = NULL;
1541  }
1542  step = s->step + (s->step_frac.num + s->remaining_frac) / s->step_frac.den;
1543  s->remaining_frac = (s->step_frac.num + s->remaining_frac) % s->step_frac.den;
1544  for (m = 0; m < s->fft_len/2 + s->remaining_fill_max - step; m++)
1545  s->fft_data[m] = s->fft_data[m+step];
1546  s->remaining_fill = step;
1547  } else {
1548  for (m = 0; m < remaining; m++) {
1549  s->fft_data[j+m].re = audio_data[2*(i+m)];
1550  s->fft_data[j+m].im = audio_data[2*(i+m)+1];
1551  }
1552  s->remaining_fill -= remaining;
1553  remaining = 0;
1554  }
1555  }
1556  if (!got_frame)
1557  ff_filter_set_ready(ctx, 100);
1558  av_frame_free(&insamples);
1559  return 0;
1560 }
1561 
1562 static int activate(AVFilterContext *ctx)
1563 {
1564  AVFilterLink *inlink = ctx->inputs[0];
1565  AVFilterLink *outlink = ctx->outputs[0];
1566  ShowCQTContext *s = ctx->priv;
1567  int nb_samples, ret, status;
1568  int64_t pts;
1569  AVFrame *in;
1570 
1571  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
1572 
1573  nb_samples = s->step + (s->step_frac.num + s->remaining_frac) / s->step_frac.den;
1574  ret = ff_inlink_consume_samples(inlink, nb_samples, nb_samples, &in);
1575  if (ret < 0)
1576  return ret;
1577  if (ret > 0)
1578  return filter_frame(inlink, in);
1579 
1580  if (ff_inlink_acknowledge_status(inlink, &status, &pts)) {
1581  if (status == AVERROR_EOF) {
1582  s->next_pts = av_rescale_q(pts, inlink->time_base, outlink->time_base);
1583  ret = filter_frame(inlink, NULL);
1584  ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
1585  return ret;
1586  }
1587  }
1588 
1589  FF_FILTER_FORWARD_WANTED(outlink, inlink);
1590 
1591  return FFERROR_NOT_READY;
1592 }
1593 
1594 static const AVFilterPad showcqt_outputs[] = {
1595  {
1596  .name = "default",
1597  .type = AVMEDIA_TYPE_VIDEO,
1598  .config_props = config_output,
1599  },
1600 };
1601 
1602 const FFFilter ff_avf_showcqt = {
1603  .p.name = "showcqt",
1604  .p.description = NULL_IF_CONFIG_SMALL("Convert input audio to a CQT (Constant/Clamped Q Transform) spectrum video output."),
1605  .p.priv_class = &showcqt_class,
1606  .init = init,
1607  .activate = activate,
1608  .uninit = uninit,
1609  .priv_size = sizeof(ShowCQTContext),
1610  FILTER_INPUTS(ff_audio_default_filterpad),
1611  FILTER_OUTPUTS(showcqt_outputs),
1612  FILTER_QUERY_FUNC2(query_formats),
1613 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
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:116
rgb::b
uint8_t b
Definition: rpzaenc.c:63
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_CHANNEL_LAYOUT_STEREO_DOWNMIX
#define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX
Definition: channel_layout.h:432
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
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 minimum maximum flags name is the option name
Definition: writing_filters.txt:88
level
uint8_t level
Definition: svq3.c:208
draw_axis_yuv
static void draw_axis_yuv(AVFrame *out, AVFrame *axis, const ColorFloat *c, int off)
Definition: avf_showcqt.c:966
r
const char * r
Definition: vf_curves.c:127
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
draw_bar_yuv
static void draw_bar_yuv(AVFrame *out, const float *h, const float *rcp_h, const ColorFloat *c, int bar_h, float bar_t)
Definition: avf_showcqt.c:813
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:435
out
FILE * out
Definition: movenc.c:55
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:205
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:395
color
Definition: vf_paletteuse.c:513
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
ColorFloat
Definition: avf_showcqt.h:40
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
Underlying C type is AVRational.
Definition: opt.h:315
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
init_cscheme
static int init_cscheme(ShowCQTContext *s)
Definition: avf_showcqt.c:1234
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
normalize.log
log
Definition: normalize.py:21
mask
int mask
Definition: mediacodecdec_common.c:154
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:63
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:263
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:523
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
AVFrame::width
int width
Definition: frame.h:493
w
uint8_t w
Definition: llviddspenc.c:38
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:83
AVOption
AVOption.
Definition: opt.h:429
b
#define b
Definition: input.c:42
data
const char data[16]
Definition: mxf.c:149
expf
#define expf(x)
Definition: libm.h:285
FLAGS
#define FLAGS
Definition: avf_showcqt.c:60
half
static uint8_t half(int a, int b)
Definition: mobiclip.c:539
ff_set_common_channel_layouts_from_list2
int ff_set_common_channel_layouts_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const AVChannelLayout *fmts)
Definition: formats.c:920
BLEND_WITH_CHROMA
#define BLEND_WITH_CHROMA(c)
Definition: avf_showcqt.c:893
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
base
uint8_t base
Definition: vp3data.h:128
c_weighting
static double c_weighting(void *p, double f)
Definition: avf_showcqt.c:223
AVComplexFloat
Definition: tx.h:27
max
#define max(a, b)
Definition: cuda_runtime.h:33
CSCHEME
#define CSCHEME
Definition: avf_showcqt.c:57
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_avf_showcqt
const FFFilter ff_avf_showcqt
Definition: avf_showcqt.c:1602
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:215
render_default_font
static int render_default_font(AVFrame *tmp)
Definition: avf_showcqt.c:655
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
video.h
draw_axis_rgb
static void draw_axis_rgb(AVFrame *out, AVFrame *axis, const ColorFloat *c, int off)
Definition: avf_showcqt.c:864
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:638
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
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:442
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:710
avpriv_vga16_font_get
const uint8_t * avpriv_vga16_font_get(void)
Definition: xga_font_data.c:430
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:696
rgb
Definition: rpzaenc.c:60
AVComplexFloat::im
float im
Definition: tx.h:28
a_weighting
static double a_weighting(void *p, double f)
Definition: avf_showcqt.c:208
fail
#define fail()
Definition: checkasm.h:199
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: avf_showcqt.c:1318
val
static double val(void *priv, double ch)
Definition: aeval.c:77
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showcqt.c:1313
pts
static int64_t pts
Definition: transcode_aac.c:644
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:51
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
lrint
#define lrint
Definition: tablegen.h:53
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:90
FFFilter
Definition: filters.h:266
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:628
BLEND_WITHOUT_CHROMA
#define BLEND_WITHOUT_CHROMA(c, alpha_inc)
Definition: avf_showcqt.c:913
s
#define s(width, name)
Definition: cbs_vp9.c:198
UPDATE_TIME
#define UPDATE_TIME(t)
DRAW_BAR_WITHOUT_CHROMA
#define DRAW_BAR_WITHOUT_CHROMA(x)
Definition: avf_showcqt.c:802
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
init_colormatrix
static void init_colormatrix(ShowCQTContext *s)
Definition: avf_showcqt.c:1199
var_names
static const char *const var_names[]
Definition: noise.c:31
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
g
const char * g
Definition: vf_curves.c:128
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:697
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
Definition: opt.h:267
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:678
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:298
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
AVFormatContext * ctx
Definition: movenc.c:49
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
BLEND_CHROMA2x2
#define BLEND_CHROMA2x2(c)
Definition: avf_showcqt.c:944
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
AVExpr
Definition: eval.c:158
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
ShowCQTContext
Definition: avf_showcqt.h:45
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:264
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
clip_with_log
static double clip_with_log(void *log_ctx, const char *name, double val, double min, double max, double nan_replace, int idx)
Definition: avf_showcqt.c:187
xs
#define xs(width, name, var, subs,...)
Definition: cbs_vp9.c:305
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
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:1530
NULL
#define NULL
Definition: coverity.c:32
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
init
static av_cold int init(AVFilterContext *ctx)
Definition: avf_showcqt.c:1256
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
vars
static const uint8_t vars[2][12]
Definition: camellia.c:183
render_freetype
static int render_freetype(ShowCQTContext *s, AVFrame *tmp, char *fontfile)
Definition: avf_showcqt.c:507
isnan
#define isnan(x)
Definition: libm.h:342
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:303
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
double
double
Definition: af_crystalizer.c:132
time.h
rgb_from_cqt
static void rgb_from_cqt(ColorFloat *c, const AVComplexFloat *v, float g, int len, float cscheme[6])
Definition: avf_showcqt.c:736
exp
int8_t exp
Definition: eval.c:73
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:1457
alloc_frame_empty
static AVFrame * alloc_frame_empty(enum AVPixelFormat format, int w, int h)
Definition: avf_showcqt.c:361
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
inc
static int inc(int num, int period)
Definition: perlin.c:34
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
init_axis_from_file
static int init_axis_from_file(ShowCQTContext *s)
Definition: avf_showcqt.c:405
eval.h
f
f
Definition: af_crystalizer.c:122
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
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:94
showcqt_outputs
static const AVFilterPad showcqt_outputs[]
Definition: avf_showcqt.c:1594
height
#define height
Definition: dsp.h:89
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
process_cqt
static void process_cqt(ShowCQTContext *s)
Definition: avf_showcqt.c:1087
calculate_gamma
static float calculate_gamma(float v, float g)
Definition: avf_showcqt.c:723
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
init_axis_color
static int init_axis_color(ShowCQTContext *s, AVFrame *tmp, int half)
Definition: avf_showcqt.c:460
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
init_axis_from_font
static int init_axis_from_font(ShowCQTContext *s)
Definition: avf_showcqt.c:682
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AVComplexFloat::re
float re
Definition: tx.h:28
update_sono_rgb
static void update_sono_rgb(AVFrame *sono, const ColorFloat *c, int idx)
Definition: avf_showcqt.c:1056
Coeffs::val
float * val
Definition: avf_showcqt.h:28
ff_load_image
int ff_load_image(uint8_t *data[4], int linesize[4], int *w, int *h, enum AVPixelFormat *pix_fmt, const char *filename, void *log_ctx)
Load image from filename and put the resulting image in data.
Definition: lavfutils.c:34
TLENGTH
#define TLENGTH
Definition: avf_showcqt.c:51
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:508
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
rgb::g
uint8_t g
Definition: rpzaenc.c:62
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
init_volume
static int init_volume(ShowCQTContext *s)
Definition: avf_showcqt.c:230
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
xga_font_data.h
ENDFREQ
#define ENDFREQ
Definition: avf_showcqt.c:50
M_PI
#define M_PI
Definition: mathematics.h:67
yuv_from_cqt
static void yuv_from_cqt(ColorFloat *c, const AVComplexFloat *v, float gamma, int len, float cm[3][3], float cscheme[6])
Definition: avf_showcqt.c:746
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
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
BLEND_CHROMA2
#define BLEND_CHROMA2(c)
Definition: avf_showcqt.c:927
Coeffs::len
int len
Definition: avf_showcqt.h:29
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:698
convert_axis_pixel_format
static enum AVPixelFormat convert_axis_pixel_format(enum AVPixelFormat format)
Definition: avf_showcqt.c:387
create_freq_table
static double * create_freq_table(double base, double end, int n)
Definition: avf_showcqt.c:167
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:501
b_weighting
static double b_weighting(void *p, double f)
Definition: avf_showcqt.c:216
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
b_func
static double b_func(void *p, double x)
Definition: avf_showcqt.c:454
r_func
static double r_func(void *p, double x)
Definition: avf_showcqt.c:442
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:701
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
VOLUME_MAX
#define VOLUME_MAX
Definition: avf_showcqt.c:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:240
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
cbrtf
static av_always_inline float cbrtf(float x)
Definition: libm.h:63
TLENGTH_MIN
#define TLENGTH_MIN
Definition: avf_showcqt.c:52
rgb::r
uint8_t r
Definition: rpzaenc.c:61
OFFSET
#define OFFSET(x)
Definition: avf_showcqt.c:59
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
draw_bar_rgb
static void draw_bar_rgb(AVFrame *out, const float *h, const float *rcp_h, const ColorFloat *c, int bar_h, float bar_t)
Definition: avf_showcqt.c:760
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:693
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:750
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
Coeffs::start
int start
Definition: avf_showcqt.h:29
log2
#define log2(x)
Definition: libm.h:406
cqt_calc
static void cqt_calc(AVComplexFloat *dst, const AVComplexFloat *src, const Coeffs *coeffs, int len, int fft_len)
Definition: avf_showcqt.c:272
activate
static int activate(AVFilterContext *ctx)
Definition: avf_showcqt.c:1562
common_uninit
static void common_uninit(ShowCQTContext *s)
Definition: avf_showcqt.c:110
plot_cqt
static int plot_cqt(AVFilterContext *ctx, AVFrame **frameout)
Definition: avf_showcqt.c:1133
ret
ret
Definition: filter_design.txt:187
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showcqt.c:1349
FONTCOLOR
#define FONTCOLOR
Definition: avf_showcqt.c:54
showcqt_options
static const AVOption showcqt_options[]
Definition: avf_showcqt.c:62
AVFrame::height
int height
Definition: frame.h:493
Coeffs
Definition: af_atilt.c:28
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
channel_layout.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AVCOL_SPC_FCC
@ AVCOL_SPC_FCC
FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:695
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
midi
static double midi(void *p, double f)
Definition: avf_showcqt.c:437
avf_showcqt.h
cm
#define cm
Definition: dvbsubdec.c:40
init_cqt
static int init_cqt(ShowCQTContext *s)
Definition: avf_showcqt.c:299
update_sono_yuv
static void update_sono_yuv(AVFrame *sono, const ColorFloat *c, int idx)
Definition: avf_showcqt.c:1068
ff_showcqt_init_x86
void ff_showcqt_init_x86(ShowCQTContext *s)
Definition: avf_showcqt_init.c:47
lavfutils.h
g_func
static double g_func(void *p, double x)
Definition: avf_showcqt.c:448
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:269
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: avf_showcqt.c:1480
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
audio.h
BASEFREQ
#define BASEFREQ
Definition: avf_showcqt.c:49
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:112
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:466
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2070
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showcqt)
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:276
width
#define width
Definition: dsp.h:89
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:692
ff_scale_image
int ff_scale_image(uint8_t *dst_data[4], int dst_linesize[4], int dst_w, int dst_h, enum AVPixelFormat dst_pix_fmt, uint8_t *const src_data[4], int src_linesize[4], int src_w, int src_h, enum AVPixelFormat src_pix_fmt, void *log_ctx)
Scale image using libswscale.
Definition: lswsutils.c:22
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
lswsutils.h
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
draw_sono
static void draw_sono(AVFrame *out, AVFrame *sono, int off, int idx)
Definition: avf_showcqt.c:1031
src
#define src
Definition: vp8dsp.c:248
av_clipd
av_clipd
Definition: af_crystalizer.c:132
DRAW_BAR_WITH_CHROMA
#define DRAW_BAR_WITH_CHROMA(x)
Definition: avf_showcqt.c:787
init_axis_empty
static int init_axis_empty(ShowCQTContext *s)
Definition: avf_showcqt.c:398
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3361
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
funcs
CheckasmFunc * funcs
Definition: checkasm.c:405
min
float min
Definition: vorbis_enc_data.h:429
render_fontconfig
static int render_fontconfig(ShowCQTContext *s, AVFrame *tmp, char *font)
Definition: avf_showcqt.c:591
Generated on Thu Jul 24 2025 19:22:36 for FFmpeg by   doxygen 1.8.17