FFmpeg
avf_showvolume.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/avstring.h"
23 #include "libavutil/eval.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/parseutils.h"
28 #include "avfilter.h"
29 #include "filters.h"
30 #include "formats.h"
31 #include "audio.h"
32 #include "video.h"
33 #include "internal.h"
34 
35 static const char *const var_names[] = { "VOLUME", "CHANNEL", "PEAK", NULL };
38 
39 typedef struct ShowVolumeContext {
40  const AVClass *class;
41  int w, h;
42  int b;
43  double f;
45  char *color;
47  int step;
48  float bgopacity;
49  int mode;
50 
54  int draw_text;
56  double *values;
57  uint32_t *color_lut;
58  float *max;
59  float rms_factor;
61 
62  double draw_persistent_duration; /* in second */
63  uint8_t persistant_max_rgba[4];
64  int persistent_max_frames; /* number of frames to check max value */
65  float *max_persistent; /* max value for draw_persistent_max for each channel */
66  int *nb_frames_max_display; /* number of frame for each channel, for displaying the max value */
67 
68  void (*meter)(float *src, int nb_samples, float *max, float factor);
70 
71 #define OFFSET(x) offsetof(ShowVolumeContext, x)
72 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
73 
74 static const AVOption showvolume_options[] = {
75  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
76  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
77  { "b", "set border width", OFFSET(b), AV_OPT_TYPE_INT, {.i64=1}, 0, 5, FLAGS },
78  { "w", "set channel width", OFFSET(w), AV_OPT_TYPE_INT, {.i64=400}, 80, 8192, FLAGS },
79  { "h", "set channel height", OFFSET(h), AV_OPT_TYPE_INT, {.i64=20}, 1, 900, FLAGS },
80  { "f", "set fade", OFFSET(f), AV_OPT_TYPE_DOUBLE, {.dbl=0.95}, 0, 1, FLAGS },
81  { "c", "set volume color expression", OFFSET(color), AV_OPT_TYPE_STRING, {.str="PEAK*255+floor((1-PEAK)*255)*256+0xff000000"}, 0, 0, FLAGS },
82  { "t", "display channel names", OFFSET(draw_text), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
83  { "v", "display volume value", OFFSET(draw_volume), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
84  { "dm", "duration for max value display", OFFSET(draw_persistent_duration), AV_OPT_TYPE_DOUBLE, {.dbl=0.}, 0, 9000, FLAGS},
85  { "dmc","set color of the max value line", OFFSET(persistant_max_rgba), AV_OPT_TYPE_COLOR, {.str = "orange"}, 0, 0, FLAGS },
86  { "o", "set orientation", OFFSET(orientation), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "orientation" },
87  { "h", "horizontal", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "orientation" },
88  { "v", "vertical", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "orientation" },
89  { "s", "set step size", OFFSET(step), AV_OPT_TYPE_INT, {.i64=0}, 0, 5, FLAGS },
90  { "p", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, FLAGS },
91  { "m", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "mode" },
92  { "p", "peak", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" },
93  { "r", "rms", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" },
94  { "ds", "set display scale", OFFSET(display_scale), AV_OPT_TYPE_INT, {.i64=LINEAR}, LINEAR, NB_DISPLAY_SCALE - 1, FLAGS, "display_scale" },
95  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, "display_scale" },
96  { "log", "log", 0, AV_OPT_TYPE_CONST, {.i64=LOG}, 0, 0, FLAGS, "display_scale" },
97  { NULL }
98 };
99 
100 AVFILTER_DEFINE_CLASS(showvolume);
101 
103 {
104  ShowVolumeContext *s = ctx->priv;
105  int ret;
106 
107  if (s->color) {
108  ret = av_expr_parse(&s->c_expr, s->color, var_names,
109  NULL, NULL, NULL, NULL, 0, ctx);
110  if (ret < 0)
111  return ret;
112  }
113 
114  return 0;
115 }
116 
118 {
121  AVFilterLink *inlink = ctx->inputs[0];
122  AVFilterLink *outlink = ctx->outputs[0];
124  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
125  int ret;
126 
128  if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
129  return ret;
130 
132  if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
133  return ret;
134 
136  if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
137  return ret;
138 
140  if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
141  return ret;
142 
143  return 0;
144 }
145 
146 static void find_peak(float *src, int nb_samples, float *peak, float factor)
147 {
148  int i;
149 
150  *peak = 0;
151  for (i = 0; i < nb_samples; i++)
152  *peak = FFMAX(*peak, FFABS(src[i]));
153 }
154 
155 static void find_rms(float *src, int nb_samples, float *rms, float factor)
156 {
157  int i;
158 
159  for (i = 0; i < nb_samples; i++)
160  *rms += factor * (src[i] * src[i] - *rms);
161 }
162 
164 {
165  AVFilterContext *ctx = inlink->dst;
166  ShowVolumeContext *s = ctx->priv;
167 
168  s->nb_samples = FFMAX(1, av_rescale(inlink->sample_rate, s->frame_rate.den, s->frame_rate.num));
169  s->values = av_calloc(inlink->channels * VAR_VARS_NB, sizeof(double));
170  if (!s->values)
171  return AVERROR(ENOMEM);
172 
173  s->color_lut = av_calloc(s->w, sizeof(*s->color_lut) * inlink->channels);
174  if (!s->color_lut)
175  return AVERROR(ENOMEM);
176 
177  s->max = av_calloc(inlink->channels, sizeof(*s->max));
178  if (!s->max)
179  return AVERROR(ENOMEM);
180 
181  s->rms_factor = 10000. / inlink->sample_rate;
182 
183  switch (s->mode) {
184  case 0: s->meter = find_peak; break;
185  case 1: s->meter = find_rms; break;
186  default: return AVERROR_BUG;
187  }
188 
189  if (s->draw_persistent_duration > 0.) {
190  s->persistent_max_frames = (int) FFMAX(av_q2d(s->frame_rate) * s->draw_persistent_duration, 1.);
191  s->max_persistent = av_calloc(inlink->channels * s->persistent_max_frames, sizeof(*s->max_persistent));
192  s->nb_frames_max_display = av_calloc(inlink->channels * s->persistent_max_frames, sizeof(*s->nb_frames_max_display));
193  }
194  return 0;
195 }
196 
197 static int config_output(AVFilterLink *outlink)
198 {
199  ShowVolumeContext *s = outlink->src->priv;
200  AVFilterLink *inlink = outlink->src->inputs[0];
201  int ch;
202 
203  if (s->orientation) {
204  outlink->h = s->w;
205  outlink->w = s->h * inlink->channels + (inlink->channels - 1) * s->b;
206  } else {
207  outlink->w = s->w;
208  outlink->h = s->h * inlink->channels + (inlink->channels - 1) * s->b;
209  }
210 
211  outlink->sample_aspect_ratio = (AVRational){1,1};
212  outlink->frame_rate = s->frame_rate;
213 
214  for (ch = 0; ch < inlink->channels; ch++) {
215  int i;
216 
217  for (i = 0; i < s->w; i++) {
218  float max = i / (float)(s->w - 1);
219 
220  s->values[ch * VAR_VARS_NB + VAR_PEAK] = max;
221  s->values[ch * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
222  s->values[ch * VAR_VARS_NB + VAR_CHANNEL] = ch;
223  s->color_lut[ch * s->w + i] = av_expr_eval(s->c_expr, &s->values[ch * VAR_VARS_NB], NULL);
224  }
225  }
226 
227  return 0;
228 }
229 
230 static void drawtext(AVFrame *pic, int x, int y, const char *txt, int o)
231 {
232  const uint8_t *font;
233  int font_height;
234  int i;
235 
236  font = avpriv_cga_font, font_height = 8;
237 
238  for (i = 0; txt[i]; i++) {
239  int char_y, mask;
240 
241  if (o) { /* vertical orientation */
242  for (char_y = font_height - 1; char_y >= 0; char_y--) {
243  uint8_t *p = pic->data[0] + (y + i * 10) * pic->linesize[0] + x * 4;
244  for (mask = 0x80; mask; mask >>= 1) {
245  if (font[txt[i] * font_height + font_height - 1 - char_y] & mask)
246  AV_WN32(&p[char_y * 4], ~AV_RN32(&p[char_y * 4]));
247  p += pic->linesize[0];
248  }
249  }
250  } else { /* horizontal orientation */
251  uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
252  for (char_y = 0; char_y < font_height; char_y++) {
253  for (mask = 0x80; mask; mask >>= 1) {
254  if (font[txt[i] * font_height + char_y] & mask)
255  AV_WN32(p, ~AV_RN32(p));
256  p += 4;
257  }
258  p += pic->linesize[0] - 8 * 4;
259  }
260  }
261  }
262 }
263 
265 {
266  int i, j;
267  const uint32_t bg = (uint32_t)(s->bgopacity * 255) << 24;
268 
269  for (i = 0; i < outlink->h; i++) {
270  uint32_t *dst = (uint32_t *)(s->out->data[0] + i * s->out->linesize[0]);
271  for (j = 0; j < outlink->w; j++)
272  AV_WN32A(dst + j, bg);
273  }
274 }
275 
276 static inline int calc_max_draw(ShowVolumeContext *s, AVFilterLink *outlink, float max)
277 {
278  float max_val;
279  if (s->display_scale == LINEAR) {
280  max_val = max;
281  } else { /* log */
282  max_val = av_clipf(0.21 * log10(max) + 1, 0, 1);
283  }
284  if (s->orientation) { /* vertical */
285  return outlink->h - outlink->h * max_val;
286  } else { /* horizontal */
287  return s->w * max_val;
288  }
289 }
290 
291 static inline void calc_persistent_max(ShowVolumeContext *s, float max, int channel)
292 {
293  /* update max value for persistent max display */
294  if ((max >= s->max_persistent[channel]) || (s->nb_frames_max_display[channel] >= s->persistent_max_frames)) { /* update max value for display */
295  s->max_persistent[channel] = max;
296  s->nb_frames_max_display[channel] = 0;
297  } else {
298  s->nb_frames_max_display[channel] += 1; /* incremente display frame count */
299  }
300 }
301 
302 static inline void draw_max_line(ShowVolumeContext *s, int max_draw, int channel)
303 {
304  int k;
305  if (s->orientation) { /* vertical */
306  uint8_t *dst = s->out->data[0] + max_draw * s->out->linesize[0] + channel * (s->b + s->h) * 4;
307  for (k = 0; k < s->h; k++) {
308  memcpy(dst + k * 4, s->persistant_max_rgba, sizeof(s->persistant_max_rgba));
309  }
310  } else { /* horizontal */
311  for (k = 0; k < s->h; k++) {
312  uint8_t *dst = s->out->data[0] + (channel * s->h + channel * s->b + k) * s->out->linesize[0];
313  memcpy(dst + max_draw * 4, s->persistant_max_rgba, sizeof(s->persistant_max_rgba));
314  }
315  }
316 }
317 
318 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
319 {
320  AVFilterContext *ctx = inlink->dst;
321  AVFilterLink *outlink = ctx->outputs[0];
322  ShowVolumeContext *s = ctx->priv;
323  const int step = s->step;
324  int c, j, k, max_draw;
325  AVFrame *out;
326 
327  if (!s->out || s->out->width != outlink->w ||
328  s->out->height != outlink->h) {
329  av_frame_free(&s->out);
330  s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
331  if (!s->out) {
332  av_frame_free(&insamples);
333  return AVERROR(ENOMEM);
334  }
335  clear_picture(s, outlink);
336  }
337  s->out->pts = insamples->pts;
338 
339  if ((s->f < 1.) && (s->f > 0.)) {
340  for (j = 0; j < outlink->h; j++) {
341  uint8_t *dst = s->out->data[0] + j * s->out->linesize[0];
342  const uint32_t alpha = s->bgopacity * 255;
343 
344  for (k = 0; k < outlink->w; k++) {
345  dst[k * 4 + 0] = FFMAX(dst[k * 4 + 0] * s->f, 0);
346  dst[k * 4 + 1] = FFMAX(dst[k * 4 + 1] * s->f, 0);
347  dst[k * 4 + 2] = FFMAX(dst[k * 4 + 2] * s->f, 0);
348  dst[k * 4 + 3] = FFMAX(dst[k * 4 + 3] * s->f, alpha);
349  }
350  }
351  } else if (s->f == 0.) {
352  clear_picture(s, outlink);
353  }
354 
355  if (s->orientation) { /* vertical */
356  for (c = 0; c < inlink->channels; c++) {
357  float *src = (float *)insamples->extended_data[c];
358  uint32_t *lut = s->color_lut + s->w * c;
359  float max;
360 
361  s->meter(src, insamples->nb_samples, &s->max[c], s->rms_factor);
362  max = s->max[c];
363 
364  s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
365  max = av_clipf(max, 0, 1);
366  max_draw = calc_max_draw(s, outlink, max);
367 
368  for (j = max_draw; j < s->w; j++) {
369  uint8_t *dst = s->out->data[0] + j * s->out->linesize[0] + c * (s->b + s->h) * 4;
370  for (k = 0; k < s->h; k++) {
371  AV_WN32A(&dst[k * 4], lut[s->w - j - 1]);
372  if (j & step)
373  j += step;
374  }
375  }
376 
377  if (s->h >= 8 && s->draw_text) {
379  if (!channel_name)
380  continue;
381  drawtext(s->out, c * (s->h + s->b) + (s->h - 10) / 2, outlink->h - 35, channel_name, 1);
382  }
383 
384  if (s->draw_persistent_duration > 0.) {
386  max_draw = FFMAX(0, calc_max_draw(s, outlink, s->max_persistent[c]) - 1);
387  draw_max_line(s, max_draw, c);
388  }
389  }
390  } else { /* horizontal */
391  for (c = 0; c < inlink->channels; c++) {
392  float *src = (float *)insamples->extended_data[c];
393  uint32_t *lut = s->color_lut + s->w * c;
394  float max;
395 
396  s->meter(src, insamples->nb_samples, &s->max[c], s->rms_factor);
397  max = s->max[c];
398 
399  s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
400  max = av_clipf(max, 0, 1);
401  max_draw = calc_max_draw(s, outlink, max);
402 
403  for (j = 0; j < s->h; j++) {
404  uint8_t *dst = s->out->data[0] + (c * s->h + c * s->b + j) * s->out->linesize[0];
405 
406  for (k = 0; k < max_draw; k++) {
407  AV_WN32A(dst + k * 4, lut[k]);
408  if (k & step)
409  k += step;
410  }
411  }
412 
413  if (s->h >= 8 && s->draw_text) {
415  if (!channel_name)
416  continue;
417  drawtext(s->out, 2, c * (s->h + s->b) + (s->h - 8) / 2, channel_name, 0);
418  }
419 
420  if (s->draw_persistent_duration > 0.) {
422  max_draw = FFMAX(0, calc_max_draw(s, outlink, s->max_persistent[c]) - 1);
423  draw_max_line(s, max_draw, c);
424  }
425  }
426  }
427 
428  av_frame_free(&insamples);
429  out = av_frame_clone(s->out);
430  if (!out)
431  return AVERROR(ENOMEM);
433 
434  /* draw volume level */
435  for (c = 0; c < inlink->channels && s->h >= 8 && s->draw_volume; c++) {
436  char buf[16];
437 
438  if (s->orientation) { /* vertical */
439  snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
440  drawtext(out, c * (s->h + s->b) + (s->h - 8) / 2, 2, buf, 1);
441  } else { /* horizontal */
442  snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
443  drawtext(out, FFMAX(0, s->w - 8 * (int)strlen(buf)), c * (s->h + s->b) + (s->h - 8) / 2, buf, 0);
444  }
445  }
446 
447  return ff_filter_frame(outlink, out);
448 }
449 
451 {
452  AVFilterLink *inlink = ctx->inputs[0];
453  AVFilterLink *outlink = ctx->outputs[0];
454  ShowVolumeContext *s = ctx->priv;
455  AVFrame *in = NULL;
456  int ret;
457 
459 
460  ret = ff_inlink_consume_samples(inlink, s->nb_samples, s->nb_samples, &in);
461  if (ret < 0)
462  return ret;
463  if (ret > 0)
464  return filter_frame(inlink, in);
465 
468 
469  return FFERROR_NOT_READY;
470 }
471 
473 {
474  ShowVolumeContext *s = ctx->priv;
475 
476  av_frame_free(&s->out);
477  av_expr_free(s->c_expr);
478  av_freep(&s->values);
479  av_freep(&s->color_lut);
480  av_freep(&s->max);
481 }
482 
483 static const AVFilterPad showvolume_inputs[] = {
484  {
485  .name = "default",
486  .type = AVMEDIA_TYPE_AUDIO,
487  .config_props = config_input,
488  },
489 };
490 
491 static const AVFilterPad showvolume_outputs[] = {
492  {
493  .name = "default",
494  .type = AVMEDIA_TYPE_VIDEO,
495  .config_props = config_output,
496  },
497 };
498 
500  .name = "showvolume",
501  .description = NULL_IF_CONFIG_SMALL("Convert input audio volume to video output."),
502  .init = init,
503  .activate = activate,
504  .uninit = uninit,
505  .query_formats = query_formats,
506  .priv_size = sizeof(ShowVolumeContext),
509  .priv_class = &showvolume_class,
510 };
formats
formats
Definition: signature.h:48
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:98
ShowVolumeContext
Definition: avf_showvolume.c:39
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:380
out
FILE * out
Definition: movenc.c:54
color
Definition: vf_paletteuse.c:587
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1019
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:548
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
showvolume_inputs
static const AVFilterPad showvolume_inputs[]
Definition: avf_showvolume.c:483
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:237
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
ShowVolumeContext::max_persistent
float * max_persistent
Definition: avf_showvolume.c:65
ShowVolumeContext::h
int h
Definition: avf_showvolume.c:41
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:523
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
av_frame_make_writable
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:490
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:396
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
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:247
ShowVolumeContext::meter
void(* meter)(float *src, int nb_samples, float *max, float factor)
Definition: avf_showvolume.c:68
b
#define b
Definition: input.c:40
clear_picture
static void clear_picture(ShowVolumeContext *s, AVFilterLink *outlink)
Definition: avf_showvolume.c:264
ShowVolumeContext::c_expr
AVExpr * c_expr
Definition: avf_showvolume.c:53
ShowVolumeContext::display_scale
int display_scale
Definition: avf_showvolume.c:60
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avf_showvolume.c:36
ShowVolumeContext::draw_volume
int draw_volume
Definition: avf_showvolume.c:55
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
max
#define max(a, b)
Definition: cuda_runtime.h:33
channel_name
Definition: channel_layout.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
ShowVolumeContext::out
AVFrame * out
Definition: avf_showvolume.c:52
video.h
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:199
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
calc_max_draw
static int calc_max_draw(ShowVolumeContext *s, AVFilterLink *outlink, float max)
Definition: avf_showvolume.c:276
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:685
ShowVolumeContext::mode
int mode
Definition: avf_showvolume.c:49
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:361
showvolume_options
static const AVOption showvolume_options[]
Definition: avf_showvolume.c:74
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
drawtext
static void drawtext(AVFrame *pic, int x, int y, const char *txt, int o)
Definition: avf_showvolume.c:230
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showvolume)
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
draw_max_line
static void draw_max_line(ShowVolumeContext *s, int max_draw, int channel)
Definition: avf_showvolume.c:302
av_cold
#define av_cold
Definition: attributes.h:90
mask
static const uint16_t mask[17]
Definition: lzw.c:38
intreadwrite.h
ShowVolumeContext::orientation
int orientation
Definition: avf_showvolume.c:46
s
#define s(width, name)
Definition: cbs_vp9.c:257
LOG
@ LOG
Definition: avf_showvolume.c:37
ShowVolumeContext::max
float * max
Definition: avf_showvolume.c:58
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:226
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:553
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
ShowVolumeContext::b
int b
Definition: avf_showvolume.c:42
ShowVolumeContext::step
int step
Definition: avf_showvolume.c:47
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
av_get_channel_name
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
Definition: channel_layout.c:249
VAR_VOLUME
@ VAR_VOLUME
Definition: avf_showvolume.c:36
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:766
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:424
activate
static int activate(AVFilterContext *ctx)
Definition: avf_showvolume.c:450
AVExpr
Definition: eval.c:157
init
static av_cold int init(AVFilterContext *ctx)
Definition: avf_showvolume.c:102
VAR_CHANNEL
@ VAR_CHANNEL
Definition: avf_showvolume.c:36
f
#define f(width, name)
Definition: cbs_vp9.c:255
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:152
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
ShowVolumeContext::w
int w
Definition: avf_showvolume.c:41
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:1437
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Definition: opt.h:239
calc_persistent_max
static void calc_persistent_max(ShowVolumeContext *s, float max, int channel)
Definition: avf_showvolume.c:291
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:354
av_clipf
#define av_clipf
Definition: common.h:144
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
src
#define src
Definition: vp8dsp.c:255
parseutils.h
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showvolume.c:197
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
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ShowVolumeContext::nb_frames_max_display
int * nb_frames_max_display
Definition: avf_showvolume.c:66
ff_avf_showvolume
const AVFilter ff_avf_showvolume
Definition: avf_showvolume.c:499
eval.h
ShowVolumeContext::nb_samples
int nb_samples
Definition: avf_showvolume.c:51
var_names
static const char *const var_names[]
Definition: avf_showvolume.c:35
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:117
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
ShowVolumeContext::persistent_max_frames
int persistent_max_frames
Definition: avf_showvolume.c:64
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
OFFSET
#define OFFSET(x)
Definition: avf_showvolume.c:71
draw_text
static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color, int x0, int y0, const uint8_t *text, int vertical)
Definition: vf_datascope.c:85
ShowVolumeContext::rms_factor
float rms_factor
Definition: avf_showvolume.c:59
AVFrame::channel_layout
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:463
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
xga_font_data.h
ShowVolumeContext::draw_text
int draw_text
Definition: avf_showvolume.c:54
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:227
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:369
i
int i
Definition: input.c:406
av_channel_layout_extract_channel
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
Definition: channel_layout.c:271
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:350
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
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:128
showvolume_outputs
static const AVFilterPad showvolume_outputs[]
Definition: avf_showvolume.c:491
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
AVFilter
Filter definition.
Definition: avfilter.h:149
LINEAR
@ LINEAR
Definition: avf_showvolume.c:37
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: avf_showvolume.c:117
ShowVolumeContext::color
char * color
Definition: avf_showvolume.c:45
ret
ret
Definition: filter_design.txt:187
ShowVolumeContext::color_lut
uint32_t * color_lut
Definition: avf_showvolume.c:57
ShowVolumeContext::values
double * values
Definition: avf_showvolume.c:56
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:508
channel_layout.h
ShowVolumeContext::draw_persistent_duration
double draw_persistent_duration
Definition: avf_showvolume.c:62
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
FLAGS
#define FLAGS
Definition: avf_showvolume.c:72
ShowVolumeContext::bgopacity
float bgopacity
Definition: avf_showvolume.c:48
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
factor
static const int factor[16]
Definition: vf_pp7.c:76
VAR_PEAK
@ VAR_PEAK
Definition: avf_showvolume.c:36
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: avf_showvolume.c:318
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:450
DisplayScale
DisplayScale
Definition: avf_ahistogram.c:31
find_rms
static void find_rms(float *src, int nb_samples, float *rms, float factor)
Definition: avf_showvolume.c:155
avpriv_cga_font
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
NB_DISPLAY_SCALE
@ NB_DISPLAY_SCALE
Definition: avf_showvolume.c:37
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:153
config_input
static int config_input(AVFilterLink *inlink)
Definition: avf_showvolume.c:163
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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, size in bytes of each picture line.
Definition: frame.h:334
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showvolume.c:472
ShowVolumeContext::frame_rate
AVRational frame_rate
Definition: avf_showvolume.c:44
h
h
Definition: vp9dsp_template.c:2038
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
int
int
Definition: ffmpeg_filter.c:156
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
snprintf
#define snprintf
Definition: snprintf.h:34
ShowVolumeContext::persistant_max_rgba
uint8_t persistant_max_rgba[4]
Definition: avf_showvolume.c:63
channel
channel
Definition: ebur128.h:39
find_peak
static void find_peak(float *src, int nb_samples, float *peak, float factor)
Definition: avf_showvolume.c:146
ShowVolumeContext::f
double f
Definition: avf_showvolume.c:43