FFmpeg
avf_showwaves.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Stefano Sabatini
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * audio to video multimedia filter
24  */
25 
26 #include "config_components.h"
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/avstring.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/parseutils.h"
35 #include "avfilter.h"
36 #include "filters.h"
37 #include "formats.h"
38 #include "audio.h"
39 #include "video.h"
40 
47 };
48 
55 };
56 
61 };
62 
67 };
68 
69 struct frame_node {
71  struct frame_node *next;
72 };
73 
74 typedef struct ShowWavesContext {
75  const AVClass *class;
76  int w, h;
78  char *colors;
79  int buf_idx;
80  int16_t *buf_idy; /* y coordinate of previous sample for each channel */
81  int16_t *history;
86  int pixstep;
87  int mode; ///< ShowWavesMode
88  int scale; ///< ShowWavesScale
89  int draw_mode; ///< ShowWavesDrawMode
92  uint8_t *fg;
93 
94  int (*get_h)(int16_t sample, int height);
95  void (*draw_sample)(uint8_t *buf, int height, int linesize,
96  int16_t *prev_y, const uint8_t color[4], int h);
97 
98  /* single picture */
103  int64_t *sum; /* abs sum of the samples per channel */
105 
106 #define OFFSET(x) offsetof(ShowWavesContext, x)
107 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
108 
109 static const AVOption showwaves_options[] = {
110  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
111  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
112  { "mode", "select display mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_POINT}, 0, MODE_NB-1, .flags=FLAGS, .unit="mode"},
113  { "point", "draw a point for each sample", 0, AV_OPT_TYPE_CONST, {.i64=MODE_POINT}, .flags=FLAGS, .unit="mode"},
114  { "line", "draw a line for each sample", 0, AV_OPT_TYPE_CONST, {.i64=MODE_LINE}, .flags=FLAGS, .unit="mode"},
115  { "p2p", "draw a line between samples", 0, AV_OPT_TYPE_CONST, {.i64=MODE_P2P}, .flags=FLAGS, .unit="mode"},
116  { "cline", "draw a centered line for each sample", 0, AV_OPT_TYPE_CONST, {.i64=MODE_CENTERED_LINE}, .flags=FLAGS, .unit="mode"},
117  { "n", "set how many samples to show in the same point", OFFSET(n), AV_OPT_TYPE_RATIONAL, {.i64 = 0}, 0, INT_MAX, FLAGS },
118  { "rate", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
119  { "r", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
120  { "split_channels", "draw channels separately", OFFSET(split_channels), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
121  { "colors", "set channels colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, FLAGS },
122  { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },
123  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},
124  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},
125  { "sqrt", "square root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_SQRT}, .flags=FLAGS, .unit="scale"},
126  { "cbrt", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_CBRT}, .flags=FLAGS, .unit="scale"},
127  { "draw", "set draw mode", OFFSET(draw_mode), AV_OPT_TYPE_INT, {.i64 = DRAW_SCALE}, 0, DRAW_NB-1, FLAGS, .unit="draw" },
128  { "scale", "scale pixel values for each drawn sample", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_SCALE}, .flags=FLAGS, .unit="draw"},
129  { "full", "draw every pixel for sample directly", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_FULL}, .flags=FLAGS, .unit="draw"},
130  { NULL }
131 };
132 
133 AVFILTER_DEFINE_CLASS(showwaves);
134 
136 {
137  ShowWavesContext *showwaves = ctx->priv;
138 
139  av_frame_free(&showwaves->outpicref);
140  av_freep(&showwaves->buf_idy);
141  av_freep(&showwaves->history);
142  av_freep(&showwaves->fg);
143 
144  if (showwaves->single_pic) {
145  struct frame_node *node = showwaves->audio_frames;
146  while (node) {
147  struct frame_node *tmp = node;
148 
149  node = node->next;
150  av_frame_free(&tmp->frame);
151  av_freep(&tmp);
152  }
153  av_freep(&showwaves->sum);
154  showwaves->last_frame = NULL;
155  }
156 }
157 
159  AVFilterFormatsConfig **cfg_in,
160  AVFilterFormatsConfig **cfg_out)
161 {
165  int ret;
166 
167  /* set input audio formats */
169  if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
170  return ret;
171 
172  /* set output video format */
174  if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
175  return ret;
176 
177  return 0;
178 }
179 
180 static int get_lin_h(int16_t sample, int height)
181 {
182  return height/2 - av_rescale(sample, height/2, INT16_MAX);
183 }
184 
185 static int get_lin_h2(int16_t sample, int height)
186 {
187  return av_rescale(FFABS(sample), height, INT16_MAX);
188 }
189 
190 static int get_log_h(int16_t sample, int height)
191 {
192  return height/2 - FFSIGN(sample) * (log10(1 + FFABS(sample)) * (height/2) / log10(1 + INT16_MAX));
193 }
194 
195 static int get_log_h2(int16_t sample, int height)
196 {
197  return log10(1 + FFABS(sample)) * height / log10(1 + INT16_MAX);
198 }
199 
200 static int get_sqrt_h(int16_t sample, int height)
201 {
202  return height/2 - FFSIGN(sample) * (sqrt(FFABS(sample)) * (height/2) / sqrt(INT16_MAX));
203 }
204 
205 static int get_sqrt_h2(int16_t sample, int height)
206 {
207  return sqrt(FFABS(sample)) * height / sqrt(INT16_MAX);
208 }
209 
210 static int get_cbrt_h(int16_t sample, int height)
211 {
212  return height/2 - FFSIGN(sample) * (cbrt(FFABS(sample)) * (height/2) / cbrt(INT16_MAX));
213 }
214 
215 static int get_cbrt_h2(int16_t sample, int height)
216 {
217  return cbrt(FFABS(sample)) * height / cbrt(INT16_MAX);
218 }
219 
220 static void draw_sample_point_rgba_scale(uint8_t *buf, int height, int linesize,
221  int16_t *prev_y,
222  const uint8_t color[4], int h)
223 {
224  if (h >= 0 && h < height) {
225  buf[h * linesize + 0] += color[0];
226  buf[h * linesize + 1] += color[1];
227  buf[h * linesize + 2] += color[2];
228  buf[h * linesize + 3] += color[3];
229  }
230 }
231 
232 static void draw_sample_point_rgba_full(uint8_t *buf, int height, int linesize,
233  int16_t *prev_y,
234  const uint8_t color[4], int h)
235 {
236  uint32_t clr = AV_RN32(color);
237  if (h >= 0 && h < height)
238  AV_WN32(buf + h * linesize, clr);
239 }
240 
241 static void draw_sample_line_rgba_scale(uint8_t *buf, int height, int linesize,
242  int16_t *prev_y,
243  const uint8_t color[4], int h)
244 {
245  int start = height/2;
246  int end = av_clip(h, 0, height-1);
247  uint8_t *bufk;
248  if (start > end)
249  FFSWAP(int16_t, start, end);
250  bufk = buf + start * linesize;
251  for (int k = start; k < end; k++, bufk += linesize) {
252  bufk[0] += color[0];
253  bufk[1] += color[1];
254  bufk[2] += color[2];
255  bufk[3] += color[3];
256  }
257 }
258 
259 static void draw_sample_line_rgba_full(uint8_t *buf, int height, int linesize,
260  int16_t *prev_y,
261  const uint8_t color[4], int h)
262 {
263  int start = height/2;
264  int end = av_clip(h, 0, height-1);
265  uint32_t clr = AV_RN32(color);
266  uint8_t *bufk;
267  if (start > end)
268  FFSWAP(int16_t, start, end);
269  bufk = buf + start * linesize;
270  for (int k = start; k < end; k++, bufk += linesize)
271  AV_WN32(bufk, clr);
272 }
273 
274 static void draw_sample_p2p_rgba_scale(uint8_t *buf, int height, int linesize,
275  int16_t *prev_y,
276  const uint8_t color[4], int h)
277 {
278  if (h >= 0 && h < height) {
279  buf[h * linesize + 0] += color[0];
280  buf[h * linesize + 1] += color[1];
281  buf[h * linesize + 2] += color[2];
282  buf[h * linesize + 3] += color[3];
283  if (*prev_y && h != *prev_y) {
284  int start = *prev_y;
285  uint8_t *bufk;
286  int end = av_clip(h, 0, height-1);
287  if (start > end)
288  FFSWAP(int16_t, start, end);
289  bufk = buf + (start + 1) * linesize;
290  for (int k = start + 1; k < end; k++, bufk += linesize) {
291  bufk[0] += color[0];
292  bufk[1] += color[1];
293  bufk[2] += color[2];
294  bufk[3] += color[3];
295  }
296  }
297  }
298  *prev_y = h;
299 }
300 
301 static void draw_sample_p2p_rgba_full(uint8_t *buf, int height, int linesize,
302  int16_t *prev_y,
303  const uint8_t color[4], int h)
304 {
305  uint32_t clr = AV_RN32(color);
306  if (h >= 0 && h < height) {
307  AV_WN32(buf + h * linesize, clr);
308  if (*prev_y && h != *prev_y) {
309  int start = *prev_y;
310  uint8_t *bufk;
311  int end = av_clip(h, 0, height-1);
312  if (start > end)
313  FFSWAP(int16_t, start, end);
314  bufk = buf + (start + 1) * linesize;
315  for (int k = start + 1; k < end; k++, bufk += linesize)
316  AV_WN32(bufk, clr);
317  }
318  }
319  *prev_y = h;
320 }
321 
322 static void draw_sample_cline_rgba_scale(uint8_t *buf, int height, int linesize,
323  int16_t *prev_y,
324  const uint8_t color[4], int h)
325 {
326  const int start = (height - h) / 2;
327  const int end = start + h;
328  uint8_t *bufk = buf + start * linesize;
329  for (int k = start; k < end; k++, bufk += linesize) {
330  bufk[0] += color[0];
331  bufk[1] += color[1];
332  bufk[2] += color[2];
333  bufk[3] += color[3];
334  }
335 }
336 
337 static void draw_sample_cline_rgba_full(uint8_t *buf, int height, int linesize,
338  int16_t *prev_y,
339  const uint8_t color[4], int h)
340 {
341  uint32_t clr = AV_RN32(color);
342  const int start = (height - h) / 2;
343  const int end = start + h;
344  uint8_t *bufk = buf + start * linesize;
345  for (int k = start; k < end; k++, bufk += linesize)
346  AV_WN32(bufk, clr);
347 }
348 
349 static void draw_sample_point_gray(uint8_t *buf, int height, int linesize,
350  int16_t *prev_y,
351  const uint8_t color[4], int h)
352 {
353  if (h >= 0 && h < height)
354  buf[h * linesize] += color[0];
355 }
356 
357 static void draw_sample_line_gray(uint8_t *buf, int height, int linesize,
358  int16_t *prev_y,
359  const uint8_t color[4], int h)
360 {
361  int k;
362  int start = height/2;
363  int end = av_clip(h, 0, height-1);
364  if (start > end)
365  FFSWAP(int16_t, start, end);
366  for (k = start; k < end; k++)
367  buf[k * linesize] += color[0];
368 }
369 
370 static void draw_sample_p2p_gray(uint8_t *buf, int height, int linesize,
371  int16_t *prev_y,
372  const uint8_t color[4], int h)
373 {
374  int k;
375  if (h >= 0 && h < height) {
376  buf[h * linesize] += color[0];
377  if (*prev_y && h != *prev_y) {
378  int start = *prev_y;
379  int end = av_clip(h, 0, height-1);
380  if (start > end)
381  FFSWAP(int16_t, start, end);
382  for (k = start + 1; k < end; k++)
383  buf[k * linesize] += color[0];
384  }
385  }
386  *prev_y = h;
387 }
388 
389 static void draw_sample_cline_gray(uint8_t *buf, int height, int linesize,
390  int16_t *prev_y,
391  const uint8_t color[4], int h)
392 {
393  int k;
394  const int start = (height - h) / 2;
395  const int end = start + h;
396  for (k = start; k < end; k++)
397  buf[k * linesize] += color[0];
398 }
399 
400 static int config_output(AVFilterLink *outlink)
401 {
402  FilterLink *l = ff_filter_link(outlink);
403  AVFilterContext *ctx = outlink->src;
404  AVFilterLink *inlink = ctx->inputs[0];
405  ShowWavesContext *showwaves = ctx->priv;
406  int nb_channels = inlink->ch_layout.nb_channels;
407  char *colors, *saveptr = NULL;
408  uint8_t x;
409  int ch;
410 
411  showwaves->q = av_make_q(0, 1);
412  showwaves->c = av_make_q(0, 1);
413 
414  if (showwaves->single_pic) {
415  showwaves->n = av_make_q(1, 1);
416  l->frame_rate = av_make_q(1, 1);
417  } else {
418  if (!showwaves->n.num || !showwaves->n.den) {
419  showwaves->n = av_mul_q(av_make_q(inlink->sample_rate,
420  showwaves->w), av_inv_q(showwaves->rate));
421  l->frame_rate = showwaves->rate;
422  } else {
423  l->frame_rate = av_div_q(av_make_q(inlink->sample_rate, showwaves->w), showwaves->n);
424  }
425  }
426 
427  showwaves->buf_idx = 0;
428  if (!FF_ALLOCZ_TYPED_ARRAY(showwaves->buf_idy, nb_channels)) {
429  av_log(ctx, AV_LOG_ERROR, "Could not allocate showwaves buffer\n");
430  return AVERROR(ENOMEM);
431  }
432 
433  showwaves->history_nb_samples = av_rescale(showwaves->w * nb_channels * 2,
434  showwaves->n.num, showwaves->n.den);
435  if (showwaves->history_nb_samples <= 0)
436  return AVERROR(EINVAL);
437  showwaves->history = av_calloc(showwaves->history_nb_samples,
438  sizeof(*showwaves->history));
439  if (!showwaves->history)
440  return AVERROR(ENOMEM);
441 
442  outlink->time_base = av_inv_q(l->frame_rate);
443  outlink->w = showwaves->w;
444  outlink->h = showwaves->h;
445  outlink->sample_aspect_ratio = (AVRational){1,1};
446 
447  av_log(ctx, AV_LOG_VERBOSE, "s:%dx%d r:%f n:%f\n",
448  showwaves->w, showwaves->h, av_q2d(l->frame_rate), av_q2d(showwaves->n));
449 
450  switch (outlink->format) {
451  case AV_PIX_FMT_GRAY8:
452  switch (showwaves->mode) {
453  case MODE_POINT: showwaves->draw_sample = draw_sample_point_gray; break;
454  case MODE_LINE: showwaves->draw_sample = draw_sample_line_gray; break;
455  case MODE_P2P: showwaves->draw_sample = draw_sample_p2p_gray; break;
456  case MODE_CENTERED_LINE: showwaves->draw_sample = draw_sample_cline_gray; break;
457  default:
458  return AVERROR_BUG;
459  }
460  showwaves->pixstep = 1;
461  break;
462  case AV_PIX_FMT_RGBA:
463  switch (showwaves->mode) {
468  default:
469  return AVERROR_BUG;
470  }
471  showwaves->pixstep = 4;
472  break;
473  }
474 
475  switch (showwaves->scale) {
476  case SCALE_LIN:
477  switch (showwaves->mode) {
478  case MODE_POINT:
479  case MODE_LINE:
480  case MODE_P2P: showwaves->get_h = get_lin_h; break;
481  case MODE_CENTERED_LINE: showwaves->get_h = get_lin_h2; break;
482  default:
483  return AVERROR_BUG;
484  }
485  break;
486  case SCALE_LOG:
487  switch (showwaves->mode) {
488  case MODE_POINT:
489  case MODE_LINE:
490  case MODE_P2P: showwaves->get_h = get_log_h; break;
491  case MODE_CENTERED_LINE: showwaves->get_h = get_log_h2; break;
492  default:
493  return AVERROR_BUG;
494  }
495  break;
496  case SCALE_SQRT:
497  switch (showwaves->mode) {
498  case MODE_POINT:
499  case MODE_LINE:
500  case MODE_P2P: showwaves->get_h = get_sqrt_h; break;
501  case MODE_CENTERED_LINE: showwaves->get_h = get_sqrt_h2; break;
502  default:
503  return AVERROR_BUG;
504  }
505  break;
506  case SCALE_CBRT:
507  switch (showwaves->mode) {
508  case MODE_POINT:
509  case MODE_LINE:
510  case MODE_P2P: showwaves->get_h = get_cbrt_h; break;
511  case MODE_CENTERED_LINE: showwaves->get_h = get_cbrt_h2; break;
512  default:
513  return AVERROR_BUG;
514  }
515  break;
516  }
517 
518  showwaves->fg = av_malloc_array(nb_channels, 4 * sizeof(*showwaves->fg));
519  if (!showwaves->fg)
520  return AVERROR(ENOMEM);
521 
522  colors = av_strdup(showwaves->colors);
523  if (!colors)
524  return AVERROR(ENOMEM);
525 
526  if (showwaves->draw_mode == DRAW_SCALE) {
527  /* multiplication factor, pre-computed to avoid in-loop divisions */
528  x = (showwaves->n.den * 255) / ((showwaves->split_channels ? 1 : nb_channels) * showwaves->n.num);
529  } else {
530  x = 255;
531  }
532  if (outlink->format == AV_PIX_FMT_RGBA) {
533  uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff };
534 
535  for (ch = 0; ch < nb_channels; ch++) {
536  char *color;
537 
538  color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr);
539  if (color)
540  av_parse_color(fg, color, -1, ctx);
541  showwaves->fg[4*ch + 0] = fg[0] * x / 255.;
542  showwaves->fg[4*ch + 1] = fg[1] * x / 255.;
543  showwaves->fg[4*ch + 2] = fg[2] * x / 255.;
544  showwaves->fg[4*ch + 3] = fg[3] * x / 255.;
545  }
546  } else {
547  for (ch = 0; ch < nb_channels; ch++)
548  showwaves->fg[4 * ch + 0] = x;
549  }
550  av_free(colors);
551 
552  return 0;
553 }
554 
555 inline static int push_frame(AVFilterLink *outlink, int i, int64_t pts)
556 {
557  AVFilterContext *ctx = outlink->src;
558  AVFilterLink *inlink = ctx->inputs[0];
559  ShowWavesContext *showwaves = outlink->src->priv;
560  int nb_channels = inlink->ch_layout.nb_channels;
561  int ret;
562 
563  showwaves->outpicref->duration = 1;
564  showwaves->outpicref->pts = av_rescale_q(pts + i,
565  inlink->time_base,
566  outlink->time_base);
567 
568  ret = ff_filter_frame(outlink, showwaves->outpicref);
569  showwaves->outpicref = NULL;
570  showwaves->buf_idx = 0;
571  for (int i = 0; i < nb_channels; i++)
572  showwaves->buf_idy[i] = 0;
573  return ret;
574 }
575 
576 static int push_single_pic(AVFilterLink *outlink)
577 {
578  AVFilterContext *ctx = outlink->src;
579  AVFilterLink *inlink = ctx->inputs[0];
580  ShowWavesContext *showwaves = ctx->priv;
581  int64_t n = 0, column_max_samples = showwaves->total_samples / outlink->w;
582  int64_t remaining_samples = showwaves->total_samples - (column_max_samples * outlink->w);
583  int64_t last_column_samples = column_max_samples + remaining_samples;
584  AVFrame *out = showwaves->outpicref;
585  struct frame_node *node;
586  const int nb_channels = inlink->ch_layout.nb_channels;
587  const int ch_height = showwaves->split_channels ? outlink->h / nb_channels : outlink->h;
588  const int linesize = out->linesize[0];
589  const int pixstep = showwaves->pixstep;
590  int col = 0;
591  int64_t *sum = showwaves->sum;
592 
593  if (column_max_samples == 0) {
594  av_log(ctx, AV_LOG_ERROR, "Too few samples\n");
595  return AVERROR(EINVAL);
596  }
597 
598  av_log(ctx, AV_LOG_DEBUG, "Create frame averaging %"PRId64" samples per column\n", column_max_samples);
599 
600  memset(sum, 0, nb_channels * sizeof(*sum));
601 
602  for (node = showwaves->audio_frames; node; node = node->next) {
603  int i;
604  const AVFrame *frame = node->frame;
605  const int16_t *p = (const int16_t *)frame->data[0];
606 
607  for (i = 0; i < frame->nb_samples; i++) {
608  int64_t max_samples = col == outlink->w - 1 ? last_column_samples: column_max_samples;
609  int ch;
610 
611  switch (showwaves->filter_mode) {
612  case FILTER_AVERAGE:
613  for (ch = 0; ch < nb_channels; ch++)
614  sum[ch] += abs(p[ch + i*nb_channels]);
615  break;
616  case FILTER_PEAK:
617  for (ch = 0; ch < nb_channels; ch++)
618  sum[ch] = FFMAX(sum[ch], abs(p[ch + i*nb_channels]));
619  break;
620  }
621 
622  n++;
623  if (n == max_samples) {
624  for (ch = 0; ch < nb_channels; ch++) {
625  int16_t sample = sum[ch] / (showwaves->filter_mode == FILTER_AVERAGE ? max_samples : 1);
626  uint8_t *buf = out->data[0] + col * pixstep;
627  int h;
628 
629  if (showwaves->split_channels)
630  buf += ch*ch_height*linesize;
631  av_assert0(col < outlink->w);
632  h = showwaves->get_h(sample, ch_height);
633  showwaves->draw_sample(buf, ch_height, linesize, &showwaves->buf_idy[ch], &showwaves->fg[ch * 4], h);
634  sum[ch] = 0;
635  }
636  col++;
637  n = 0;
638  }
639  }
640  }
641 
642  return push_frame(outlink, 0, 0);
643 }
644 
645 
646 static int request_frame(AVFilterLink *outlink)
647 {
648  ShowWavesContext *showwaves = outlink->src->priv;
649  AVFilterLink *inlink = outlink->src->inputs[0];
650  int ret;
651 
653  if (ret == AVERROR_EOF && showwaves->outpicref) {
654  push_single_pic(outlink);
655  }
656 
657  return ret;
658 }
659 
660 static int alloc_out_frame(ShowWavesContext *showwaves,
661  AVFilterLink *outlink)
662 {
663  if (!showwaves->outpicref) {
664  AVFrame *out = showwaves->outpicref =
665  ff_get_video_buffer(outlink, outlink->w, outlink->h);
666  if (!out)
667  return AVERROR(ENOMEM);
668  out->width = outlink->w;
669  out->height = outlink->h;
670  for (int j = 0; j < outlink->h; j++)
671  memset(out->data[0] + j*out->linesize[0], 0, outlink->w * showwaves->pixstep);
672  }
673  return 0;
674 }
675 
677 {
678  ShowWavesContext *showwaves = ctx->priv;
679 
680  if (!strcmp(ctx->filter->name, "showwavespic")) {
681  showwaves->single_pic = 1;
682  showwaves->mode = MODE_CENTERED_LINE;
683  }
684 
685  return 0;
686 }
687 
688 #if CONFIG_SHOWWAVES_FILTER
689 
690 static int showwaves_filter_frame(AVFilterLink *inlink, AVFrame *insamples)
691 {
692  AVFilterContext *ctx = inlink->dst;
693  AVFilterLink *outlink = ctx->outputs[0];
694  ShowWavesContext *showwaves = ctx->priv;
695  const int nb_samples = insamples->nb_samples;
696  AVFrame *outpicref = showwaves->outpicref;
697  const int16_t *p = (const int16_t *)insamples->data[0];
698  int16_t *history = showwaves->history;
699  const int nb_channels = inlink->ch_layout.nb_channels;
700  int i, j, ret = 0, linesize;
701  const int pixstep = showwaves->pixstep;
702  const int ch_height = showwaves->split_channels ? outlink->h / nb_channels : outlink->h;
703  const int history_nb_samples = showwaves->history_nb_samples;
704  const int split_channels = showwaves->split_channels;
705  const AVRational i_n = av_inv_q(showwaves->n);
706  const AVRational u_q = av_make_q(1, 1);
707  const AVRational z_q = av_make_q(0, 1);
708  int16_t *buf_idy = showwaves->buf_idy;
709  int idx = showwaves->history_index;
710  int buf_idx = showwaves->buf_idx;
711  const uint8_t *fg = showwaves->fg;
712  const int w = showwaves->w;
713  uint8_t *dst;
714 
715  for (int n = 0; n < nb_samples * nb_channels; n++) {
716  history[idx++] = p[n];
717  if (idx >= history_nb_samples)
718  idx = 0;
719  }
720  showwaves->history_index = idx;
721 
722  ret = alloc_out_frame(showwaves, outlink);
723  if (ret < 0)
724  goto end;
725  outpicref = showwaves->outpicref;
726  linesize = outpicref->linesize[0];
727 
728  /* draw data in the buffer */
729  dst = outpicref->data[0];
730  for (i = 0; i < history_nb_samples; i++) {
731  for (j = 0; j < nb_channels; j++) {
732  uint8_t *buf = dst + buf_idx * pixstep;
733  int h;
734 
735  if (split_channels)
736  buf += j*ch_height*linesize;
737  h = showwaves->get_h(history[idx++], ch_height);
738  if (idx >= history_nb_samples)
739  idx = 0;
740  showwaves->draw_sample(buf, ch_height, linesize,
741  &buf_idy[j], &fg[j * 4], h);
742  }
743 
744  showwaves->c = av_add_q(showwaves->c, i_n);
745  if (av_cmp_q(showwaves->c, u_q) >= 0) {
746  showwaves->c = z_q;
747  buf_idx++;
748  }
749  if (buf_idx == w)
750  break;
751  }
752 
753  showwaves->buf_idx = buf_idx;
754 
755  if ((ret = push_frame(outlink, history_nb_samples - i - 1, insamples->pts)) < 0)
756  goto end;
757  outpicref = showwaves->outpicref;
758 end:
759  av_frame_free(&insamples);
760  return ret;
761 }
762 
763 static int activate(AVFilterContext *ctx)
764 {
765  AVFilterLink *inlink = ctx->inputs[0];
766  AVFilterLink *outlink = ctx->outputs[0];
767  ShowWavesContext *showwaves = ctx->priv;
768  AVRational q;
769  AVFrame *in;
770  int nb_samples;
771  int ret;
772 
774 
775  q = av_add_q(showwaves->q, av_mul_q(av_make_q(outlink->w, 1), showwaves->n));
776  nb_samples = (q.num + (q.den / 2)) / q.den;
777  ret = ff_inlink_consume_samples(inlink, nb_samples, nb_samples, &in);
778  if (ret < 0)
779  return ret;
780  if (ret > 0) {
781  showwaves->q = av_sub_q(q, av_make_q(nb_samples, 1));
782  return showwaves_filter_frame(inlink, in);
783  }
784 
787 
788  return FFERROR_NOT_READY;
789 }
790 
791 static const AVFilterPad showwaves_outputs[] = {
792  {
793  .name = "default",
794  .type = AVMEDIA_TYPE_VIDEO,
795  .config_props = config_output,
796  },
797 };
798 
799 const AVFilter ff_avf_showwaves = {
800  .name = "showwaves",
801  .description = NULL_IF_CONFIG_SMALL("Convert input audio to a video output."),
802  .init = init,
803  .uninit = uninit,
804  .priv_size = sizeof(ShowWavesContext),
806  .activate = activate,
807  FILTER_OUTPUTS(showwaves_outputs),
809  .priv_class = &showwaves_class,
810 };
811 
812 #endif // CONFIG_SHOWWAVES_FILTER
813 
814 #if CONFIG_SHOWWAVESPIC_FILTER
815 
816 #define OFFSET(x) offsetof(ShowWavesContext, x)
817 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
818 
819 static const AVOption showwavespic_options[] = {
820  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
821  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
822  { "split_channels", "draw channels separately", OFFSET(split_channels), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
823  { "colors", "set channels colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, FLAGS },
824  { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },
825  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},
826  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},
827  { "sqrt", "square root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_SQRT}, .flags=FLAGS, .unit="scale"},
828  { "cbrt", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64=SCALE_CBRT}, .flags=FLAGS, .unit="scale"},
829  { "draw", "set draw mode", OFFSET(draw_mode), AV_OPT_TYPE_INT, {.i64 = DRAW_SCALE}, 0, DRAW_NB-1, FLAGS, .unit="draw" },
830  { "scale", "scale pixel values for each drawn sample", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_SCALE}, .flags=FLAGS, .unit="draw"},
831  { "full", "draw every pixel for sample directly", 0, AV_OPT_TYPE_CONST, {.i64=DRAW_FULL}, .flags=FLAGS, .unit="draw"},
832  { "filter", "set filter mode", OFFSET(filter_mode), AV_OPT_TYPE_INT, {.i64 = FILTER_AVERAGE}, 0, FILTER_NB-1, FLAGS, .unit="filter" },
833  { "average", "use average samples", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_AVERAGE}, .flags=FLAGS, .unit="filter"},
834  { "peak", "use peak samples", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_PEAK}, .flags=FLAGS, .unit="filter"},
835  { NULL }
836 };
837 
838 AVFILTER_DEFINE_CLASS(showwavespic);
839 
840 static int showwavespic_config_input(AVFilterLink *inlink)
841 {
842  AVFilterContext *ctx = inlink->dst;
843  ShowWavesContext *showwaves = ctx->priv;
844 
845  if (showwaves->single_pic) {
846  showwaves->sum = av_calloc(inlink->ch_layout.nb_channels, sizeof(*showwaves->sum));
847  if (!showwaves->sum)
848  return AVERROR(ENOMEM);
849  }
850 
851  return 0;
852 }
853 
854 static int showwavespic_filter_frame(AVFilterLink *inlink, AVFrame *insamples)
855 {
856  AVFilterContext *ctx = inlink->dst;
857  AVFilterLink *outlink = ctx->outputs[0];
858  ShowWavesContext *showwaves = ctx->priv;
859  int ret = 0;
860 
861  if (showwaves->single_pic) {
862  struct frame_node *f;
863 
864  ret = alloc_out_frame(showwaves, outlink);
865  if (ret < 0)
866  goto end;
867 
868  /* queue the audio frame */
869  f = av_malloc(sizeof(*f));
870  if (!f) {
871  ret = AVERROR(ENOMEM);
872  goto end;
873  }
874  f->frame = insamples;
875  f->next = NULL;
876  if (!showwaves->last_frame) {
877  showwaves->audio_frames =
878  showwaves->last_frame = f;
879  } else {
880  showwaves->last_frame->next = f;
881  showwaves->last_frame = f;
882  }
883  showwaves->total_samples += insamples->nb_samples;
884 
885  return 0;
886  }
887 
888 end:
889  av_frame_free(&insamples);
890  return ret;
891 }
892 
893 static const AVFilterPad showwavespic_inputs[] = {
894  {
895  .name = "default",
896  .type = AVMEDIA_TYPE_AUDIO,
897  .config_props = showwavespic_config_input,
898  .filter_frame = showwavespic_filter_frame,
899  },
900 };
901 
902 static const AVFilterPad showwavespic_outputs[] = {
903  {
904  .name = "default",
905  .type = AVMEDIA_TYPE_VIDEO,
906  .config_props = config_output,
907  .request_frame = request_frame,
908  },
909 };
910 
912  .name = "showwavespic",
913  .description = NULL_IF_CONFIG_SMALL("Convert input audio to a video output single picture."),
914  .init = init,
915  .uninit = uninit,
916  .priv_size = sizeof(ShowWavesContext),
917  FILTER_INPUTS(showwavespic_inputs),
918  FILTER_OUTPUTS(showwavespic_outputs),
920  .priv_class = &showwavespic_class,
921 };
922 
923 #endif // CONFIG_SHOWWAVESPIC_FILTER
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:78
ShowWavesContext::c
AVRational c
Definition: avf_showwaves.c:85
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
SCALE_SQRT
@ SCALE_SQRT
Definition: avf_showwaves.c:52
DRAW_SCALE
@ DRAW_SCALE
Definition: avf_showwaves.c:58
FILTER_PEAK
@ FILTER_PEAK
Definition: avf_showwaves.c:65
FILTER_AVERAGE
@ FILTER_AVERAGE
Definition: avf_showwaves.c:64
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
av_clip
#define av_clip
Definition: common.h:100
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:435
get_cbrt_h
static int get_cbrt_h(int16_t sample, int height)
Definition: avf_showwaves.c:210
ShowWavesContext::history_nb_samples
int history_nb_samples
Definition: avf_showwaves.c:82
out
FILE * out
Definition: movenc.c:55
color
Definition: vf_paletteuse.c:511
ShowWavesContext::filter_mode
int filter_mode
Definition: avf_showwaves.c:91
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
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:795
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_parse_color
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition: parseutils.c:356
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
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
frame_node::frame
AVFrame * frame
Definition: avf_showwaves.c:70
ShowWavesContext::get_h
int(* get_h)(int16_t sample, int height)
Definition: avf_showwaves.c:94
int64_t
long long int64_t
Definition: coverity.c:34
frame_node::next
struct frame_node * next
Definition: avf_showwaves.c:71
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
draw_sample_point_rgba_scale
static void draw_sample_point_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:220
ShowWavesContext::buf_idy
int16_t * buf_idy
Definition: avf_showwaves.c:80
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:501
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:429
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:475
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
get_cbrt_h2
static int get_cbrt_h2(int16_t sample, int height)
Definition: avf_showwaves.c:215
ShowWavesContext::buf_idx
int buf_idx
Definition: avf_showwaves.c:79
ShowWavesContext::w
int w
Definition: avf_showwaves.c:76
showwaves_options
static const AVOption showwaves_options[]
Definition: avf_showwaves.c:109
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showwaves)
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
av_sub_q
AVRational av_sub_q(AVRational b, AVRational c)
Subtract one rational from another.
Definition: rational.c:101
frame_node
Definition: avf_showwaves.c:69
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Underlying C type is AVRational.
Definition: opt.h:280
video.h
get_sqrt_h2
static int get_sqrt_h2(int16_t sample, int height)
Definition: avf_showwaves.c:205
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:434
DRAW_FULL
@ DRAW_FULL
Definition: avf_showwaves.c:59
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
draw_sample_line_rgba_scale
static void draw_sample_line_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:241
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
draw_sample_cline_rgba_full
static void draw_sample_cline_rgba_full(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:337
get_log_h2
static int get_log_h2(int16_t sample, int height)
Definition: avf_showwaves.c:195
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:472
MODE_NB
@ MODE_NB
Definition: avf_showwaves.c:46
FILTER_NB
@ FILTER_NB
Definition: avf_showwaves.c:66
get_sqrt_h
static int get_sqrt_h(int16_t sample, int height)
Definition: avf_showwaves.c:200
get_lin_h2
static int get_lin_h2(int16_t sample, int height)
Definition: avf_showwaves.c:185
FFSIGN
#define FFSIGN(a)
Definition: common.h:75
SCALE_CBRT
@ SCALE_CBRT
Definition: avf_showwaves.c:53
pts
static int64_t pts
Definition: transcode_aac.c:644
get_lin_h
static int get_lin_h(int16_t sample, int height)
Definition: avf_showwaves.c:180
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
cbrt
#define cbrt
Definition: tablegen.h:35
draw_sample_point_gray
static void draw_sample_point_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:349
draw_sample_p2p_gray
static void draw_sample_p2p_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:370
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
DRAW_NB
@ DRAW_NB
Definition: avf_showwaves.c:60
ShowWavesContext::n
AVRational n
Definition: avf_showwaves.c:85
intreadwrite.h
FLAGS
#define FLAGS
Definition: avf_showwaves.c:107
ShowWavesContext::sum
int64_t * sum
Definition: avf_showwaves.c:103
ShowWavesContext::last_frame
struct frame_node * last_frame
Definition: avf_showwaves.c:101
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:678
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
ShowWavesContext::audio_frames
struct frame_node * audio_frames
Definition: avf_showwaves.c:100
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ctx
AVFormatContext * ctx
Definition: movenc.c:49
init
static av_cold int init(AVFilterContext *ctx)
Definition: avf_showwaves.c:676
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
push_frame
static int push_frame(AVFilterLink *outlink, int i, int64_t pts)
Definition: avf_showwaves.c:555
ShowWavesContext::rate
AVRational rate
Definition: avf_showwaves.c:77
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
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
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showwaves.c:400
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
ShowWavesContext::scale
int scale
ShowWavesScale.
Definition: avf_showwaves.c:88
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:1511
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
get_log_h
static int get_log_h(int16_t sample, int height)
Definition: avf_showwaves.c:190
activate
filter_frame For filters that do not use the activate() callback
ShowWavesContext::single_pic
int single_pic
Definition: avf_showwaves.c:99
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:303
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:465
ShowWavesContext::mode
int mode
ShowWavesMode.
Definition: avf_showwaves.c:87
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:360
parseutils.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showwaves.c:135
ff_avf_showwavespic
const AVFilter ff_avf_showwavespic
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
ShowWavesContext::total_samples
int64_t total_samples
Definition: avf_showwaves.c:102
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: avf_showwaves.c:646
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
MODE_POINT
@ MODE_POINT
Definition: avf_showwaves.c:42
ShowWavesContext::draw_mode
int draw_mode
ShowWavesDrawMode.
Definition: avf_showwaves.c:89
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:111
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
draw_sample_cline_gray
static void draw_sample_cline_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:389
f
f
Definition: af_crystalizer.c:122
ShowWavesFilterMode
ShowWavesFilterMode
Definition: avf_showwaves.c:63
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
height
#define height
Definition: dsp.h:85
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:372
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
MODE_CENTERED_LINE
@ MODE_CENTERED_LINE
Definition: avf_showwaves.c:45
draw_sample_p2p_rgba_full
static void draw_sample_p2p_rgba_full(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:301
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
ShowWavesContext::history
int16_t * history
Definition: avf_showwaves.c:81
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
sample
#define sample
Definition: flacdsp_template.c:44
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
SCALE_LIN
@ SCALE_LIN
Definition: avf_showwaves.c:50
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
MODE_P2P
@ MODE_P2P
Definition: avf_showwaves.c:44
ShowWavesContext::outpicref
AVFrame * outpicref
Definition: avf_showwaves.c:84
ShowWavesContext::h
int h
Definition: avf_showwaves.c:76
ShowWavesScale
ShowWavesScale
Definition: avf_showwaves.c:49
push_single_pic
static int push_single_pic(AVFilterLink *outlink)
Definition: avf_showwaves.c:576
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:469
ff_avf_showwaves
const AVFilter ff_avf_showwaves
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ShowWavesContext::history_index
int history_index
Definition: avf_showwaves.c:83
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
draw_sample_line_gray
static void draw_sample_line_gray(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:357
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:239
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
draw_sample_p2p_rgba_scale
static void draw_sample_p2p_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:274
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
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
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: avf_showwaves.c:158
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVFilter
Filter definition.
Definition: avfilter.h:201
ret
ret
Definition: filter_design.txt:187
ShowWavesContext::draw_sample
void(* draw_sample)(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:95
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ShowWavesContext::fg
uint8_t * fg
Definition: avf_showwaves.c:92
SCALE_LOG
@ SCALE_LOG
Definition: avf_showwaves.c:51
channel_layout.h
AVRational::den
int den
Denominator.
Definition: rational.h:60
mode
mode
Definition: ebur128.h:83
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:259
avfilter.h
draw_sample_cline_rgba_scale
static void draw_sample_cline_rgba_scale(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:322
ShowWavesContext::split_channels
int split_channels
Definition: avf_showwaves.c:90
ShowWavesContext::colors
char * colors
Definition: avf_showwaves.c:78
alloc_out_frame
static int alloc_out_frame(ShowWavesContext *showwaves, AVFilterLink *outlink)
Definition: avf_showwaves.c:660
MODE_LINE
@ MODE_LINE
Definition: avf_showwaves.c:43
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
ShowWavesMode
ShowWavesMode
Definition: avf_showwaves.c:41
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
audio.h
OFFSET
#define OFFSET(x)
Definition: avf_showwaves.c:106
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
av_add_q
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
Definition: rational.c:93
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:434
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2070
ShowWavesDrawMode
ShowWavesDrawMode
Definition: avf_showwaves.c:57
avstring.h
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
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
ShowWavesContext::pixstep
int pixstep
Definition: avf_showwaves.c:86
ShowWavesContext
Definition: avf_showwaves.c:74
ShowWavesContext::q
AVRational q
Definition: avf_showwaves.c:85
SCALE_NB
@ SCALE_NB
Definition: avf_showwaves.c:54
draw_sample_line_rgba_full
static void draw_sample_line_rgba_full(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:259
draw_sample_point_rgba_full
static void draw_sample_point_rgba_full(uint8_t *buf, int height, int linesize, int16_t *prev_y, const uint8_t color[4], int h)
Definition: avf_showwaves.c:232