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;
60 
61  double draw_persistent_duration; /* in second */
62  uint8_t persistant_max_rgba[4];
63  int persistent_max_frames; /* number of frames to check max value */
64  float *max_persistent; /* max value for draw_persistent_max for each channel */
65  int *nb_frames_max_display; /* number of frame for each channel, for displaying the max value */
66 
67  void (*meter)(float *src, int nb_samples, float *max);
69 
70 #define OFFSET(x) offsetof(ShowVolumeContext, x)
71 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
72 
73 static const AVOption showvolume_options[] = {
74  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
75  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
76  { "b", "set border width", OFFSET(b), AV_OPT_TYPE_INT, {.i64=1}, 0, 5, FLAGS },
77  { "w", "set channel width", OFFSET(w), AV_OPT_TYPE_INT, {.i64=400}, 80, 8192, FLAGS },
78  { "h", "set channel height", OFFSET(h), AV_OPT_TYPE_INT, {.i64=20}, 1, 900, FLAGS },
79  { "f", "set fade", OFFSET(f), AV_OPT_TYPE_DOUBLE, {.dbl=0.95}, 0, 1, FLAGS },
80  { "c", "set volume color expression", OFFSET(color), AV_OPT_TYPE_STRING, {.str="PEAK*255+floor((1-PEAK)*255)*256+0xff000000"}, 0, 0, FLAGS },
81  { "t", "display channel names", OFFSET(draw_text), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
82  { "v", "display volume value", OFFSET(draw_volume), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
83  { "dm", "duration for max value display", OFFSET(draw_persistent_duration), AV_OPT_TYPE_DOUBLE, {.dbl=0.}, 0, 9000, FLAGS},
84  { "dmc","set color of the max value line", OFFSET(persistant_max_rgba), AV_OPT_TYPE_COLOR, {.str = "orange"}, 0, 0, FLAGS },
85  { "o", "set orientation", OFFSET(orientation), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "orientation" },
86  { "h", "horizontal", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "orientation" },
87  { "v", "vertical", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "orientation" },
88  { "s", "set step size", OFFSET(step), AV_OPT_TYPE_INT, {.i64=0}, 0, 5, FLAGS },
89  { "p", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, FLAGS },
90  { "m", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "mode" },
91  { "p", "peak", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "mode" },
92  { "r", "rms", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "mode" },
93  { "ds", "set display scale", OFFSET(display_scale), AV_OPT_TYPE_INT, {.i64=LINEAR}, LINEAR, NB_DISPLAY_SCALE - 1, FLAGS, .unit = "display_scale" },
94  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, .unit = "display_scale" },
95  { "log", "log", 0, AV_OPT_TYPE_CONST, {.i64=LOG}, 0, 0, FLAGS, .unit = "display_scale" },
96  { NULL }
97 };
98 
99 AVFILTER_DEFINE_CLASS(showvolume);
100 
102 {
103  ShowVolumeContext *s = ctx->priv;
104  int ret;
105 
106  if (s->color) {
107  ret = av_expr_parse(&s->c_expr, s->color, var_names,
108  NULL, NULL, NULL, NULL, 0, ctx);
109  if (ret < 0)
110  return ret;
111  }
112 
113  return 0;
114 }
115 
117 {
120  AVFilterLink *inlink = ctx->inputs[0];
121  AVFilterLink *outlink = ctx->outputs[0];
123  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
124  int ret;
125 
127  if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
128  return ret;
129 
131  if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
132  return ret;
133 
135  if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
136  return ret;
137 
139  if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
140  return ret;
141 
142  return 0;
143 }
144 
145 static void find_peak(float *src, int nb_samples, float *peak)
146 {
147  float max = 0.f;
148 
149  max = 0;
150  for (int i = 0; i < nb_samples; i++)
151  max = fmaxf(max, fabsf(src[i]));
152  *peak = max;
153 }
154 
155 static void find_rms(float *src, int nb_samples, float *rms)
156 {
157  float sum = 0.f;
158 
159  for (int i = 0; i < nb_samples; i++)
160  sum += src[i] * src[i];
161  *rms = sqrtf(sum / nb_samples);
162 }
163 
165 {
166  AVFilterContext *ctx = inlink->dst;
167  ShowVolumeContext *s = ctx->priv;
168 
169  s->nb_samples = FFMAX(1, av_rescale(inlink->sample_rate, s->frame_rate.den, s->frame_rate.num));
170  s->values = av_calloc(inlink->ch_layout.nb_channels * VAR_VARS_NB, sizeof(double));
171  if (!s->values)
172  return AVERROR(ENOMEM);
173 
174  s->color_lut = av_calloc(s->w, sizeof(*s->color_lut) * inlink->ch_layout.nb_channels);
175  if (!s->color_lut)
176  return AVERROR(ENOMEM);
177 
178  s->max = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->max));
179  if (!s->max)
180  return AVERROR(ENOMEM);
181 
182  switch (s->mode) {
183  case 0: s->meter = find_peak; break;
184  case 1: s->meter = find_rms; break;
185  default: return AVERROR_BUG;
186  }
187 
188  if (s->draw_persistent_duration > 0.) {
189  s->persistent_max_frames = (int) FFMAX(av_q2d(s->frame_rate) * s->draw_persistent_duration, 1.);
190  s->max_persistent = av_calloc(inlink->ch_layout.nb_channels * s->persistent_max_frames, sizeof(*s->max_persistent));
191  s->nb_frames_max_display = av_calloc(inlink->ch_layout.nb_channels * s->persistent_max_frames, sizeof(*s->nb_frames_max_display));
192  if (!s->max_persistent ||
193  !s->nb_frames_max_display)
194  return AVERROR(ENOMEM);
195  }
196  return 0;
197 }
198 
199 static int config_output(AVFilterLink *outlink)
200 {
201  ShowVolumeContext *s = outlink->src->priv;
202  AVFilterLink *inlink = outlink->src->inputs[0];
203  int ch;
204 
205  if (s->orientation) {
206  outlink->h = s->w;
207  outlink->w = s->h * inlink->ch_layout.nb_channels + (inlink->ch_layout.nb_channels - 1) * s->b;
208  } else {
209  outlink->w = s->w;
210  outlink->h = s->h * inlink->ch_layout.nb_channels + (inlink->ch_layout.nb_channels - 1) * s->b;
211  }
212 
213  outlink->sample_aspect_ratio = (AVRational){1,1};
214  outlink->frame_rate = s->frame_rate;
215  outlink->time_base = av_inv_q(outlink->frame_rate);
216 
217  for (ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
218  int i;
219 
220  for (i = 0; i < s->w; i++) {
221  float max = i / (float)(s->w - 1);
222 
223  s->values[ch * VAR_VARS_NB + VAR_PEAK] = max;
224  s->values[ch * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
225  s->values[ch * VAR_VARS_NB + VAR_CHANNEL] = ch;
226  s->color_lut[ch * s->w + i] = av_expr_eval(s->c_expr, &s->values[ch * VAR_VARS_NB], NULL);
227  }
228  }
229 
230  return 0;
231 }
232 
233 static void drawtext(AVFrame *pic, int x, int y, const char *txt, int o)
234 {
235  const uint8_t *font;
236  int font_height;
237  int i;
238 
239  font = avpriv_cga_font, font_height = 8;
240 
241  for (i = 0; txt[i]; i++) {
242  int char_y, mask;
243 
244  if (o) { /* vertical orientation */
245  for (char_y = font_height - 1; char_y >= 0; char_y--) {
246  uint8_t *p = pic->data[0] + (y + i * 10) * pic->linesize[0] + x * 4;
247  for (mask = 0x80; mask; mask >>= 1) {
248  if (font[txt[i] * font_height + font_height - 1 - char_y] & mask)
249  AV_WN32(&p[char_y * 4], ~AV_RN32(&p[char_y * 4]));
250  p += pic->linesize[0];
251  }
252  }
253  } else { /* horizontal orientation */
254  uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
255  for (char_y = 0; char_y < font_height; char_y++) {
256  for (mask = 0x80; mask; mask >>= 1) {
257  if (font[txt[i] * font_height + char_y] & mask)
258  AV_WN32(p, ~AV_RN32(p));
259  p += 4;
260  }
261  p += pic->linesize[0] - 8 * 4;
262  }
263  }
264  }
265 }
266 
268 {
269  int i, j;
270  const uint32_t bg = (uint32_t)(s->bgopacity * 255) << 24;
271 
272  for (i = 0; i < outlink->h; i++) {
273  uint32_t *dst = (uint32_t *)(s->out->data[0] + i * s->out->linesize[0]);
274  for (j = 0; j < outlink->w; j++)
275  AV_WN32A(dst + j, bg);
276  }
277 }
278 
279 static inline int calc_max_draw(ShowVolumeContext *s, AVFilterLink *outlink, float max)
280 {
281  float max_val;
282  if (s->display_scale == LINEAR) {
283  max_val = max;
284  } else { /* log */
285  max_val = av_clipf(0.21 * log10(max) + 1, 0, 1);
286  }
287  if (s->orientation) { /* vertical */
288  return outlink->h - outlink->h * max_val;
289  } else { /* horizontal */
290  return s->w * max_val;
291  }
292 }
293 
294 static inline void calc_persistent_max(ShowVolumeContext *s, float max, int channel)
295 {
296  /* update max value for persistent max display */
297  if ((max >= s->max_persistent[channel]) || (s->nb_frames_max_display[channel] >= s->persistent_max_frames)) { /* update max value for display */
298  s->max_persistent[channel] = max;
299  s->nb_frames_max_display[channel] = 0;
300  } else {
301  s->nb_frames_max_display[channel] += 1; /* incremente display frame count */
302  }
303 }
304 
305 static inline void draw_max_line(ShowVolumeContext *s, int max_draw, int channel)
306 {
307  int k;
308  if (s->orientation) { /* vertical */
309  uint8_t *dst = s->out->data[0] + max_draw * s->out->linesize[0] + channel * (s->b + s->h) * 4;
310  for (k = 0; k < s->h; k++) {
311  memcpy(dst + k * 4, s->persistant_max_rgba, sizeof(s->persistant_max_rgba));
312  }
313  } else { /* horizontal */
314  for (k = 0; k < s->h; k++) {
315  uint8_t *dst = s->out->data[0] + (channel * s->h + channel * s->b + k) * s->out->linesize[0];
316  memcpy(dst + max_draw * 4, s->persistant_max_rgba, sizeof(s->persistant_max_rgba));
317  }
318  }
319 }
320 
321 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
322 {
323  AVFilterContext *ctx = inlink->dst;
324  AVFilterLink *outlink = ctx->outputs[0];
325  ShowVolumeContext *s = ctx->priv;
326  const int step = s->step;
327  int c, j, k, max_draw, ret;
328  char channel_name[64];
329  AVFrame *out;
330 
331  if (!s->out || s->out->width != outlink->w ||
332  s->out->height != outlink->h) {
333  av_frame_free(&s->out);
334  s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
335  if (!s->out) {
336  av_frame_free(&insamples);
337  return AVERROR(ENOMEM);
338  }
339  clear_picture(s, outlink);
340  }
341  s->out->pts = av_rescale_q(insamples->pts, inlink->time_base, outlink->time_base);
342  s->out->duration = 1;
343 
344  if ((s->f < 1.) && (s->f > 0.)) {
345  for (j = 0; j < outlink->h; j++) {
346  uint8_t *dst = s->out->data[0] + j * s->out->linesize[0];
347  const uint32_t alpha = s->bgopacity * 255;
348 
349  for (k = 0; k < outlink->w; k++) {
350  dst[k * 4 + 0] = FFMAX(dst[k * 4 + 0] * s->f, 0);
351  dst[k * 4 + 1] = FFMAX(dst[k * 4 + 1] * s->f, 0);
352  dst[k * 4 + 2] = FFMAX(dst[k * 4 + 2] * s->f, 0);
353  dst[k * 4 + 3] = FFMAX(dst[k * 4 + 3] * s->f, alpha);
354  }
355  }
356  } else if (s->f == 0.) {
357  clear_picture(s, outlink);
358  }
359 
360  if (s->orientation) { /* vertical */
361  for (c = 0; c < inlink->ch_layout.nb_channels; c++) {
362  float *src = (float *)insamples->extended_data[c];
363  uint32_t *lut = s->color_lut + s->w * c;
364  float max;
365 
366  s->meter(src, insamples->nb_samples, &s->max[c]);
367  max = s->max[c];
368 
369  s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
370  max = av_clipf(max, 0, 1);
371  max_draw = calc_max_draw(s, outlink, max);
372 
373  for (j = s->w - 1; j >= max_draw; j--) {
374  uint8_t *dst = s->out->data[0] + j * s->out->linesize[0] + c * (s->b + s->h) * 4;
375  for (k = 0; k < s->h; k++) {
376  AV_WN32A(&dst[k * 4], lut[s->w - j - 1]);
377  }
378  if (j & step)
379  j -= step;
380  }
381 
382  if (s->draw_persistent_duration > 0.) {
384  max_draw = FFMAX(0, calc_max_draw(s, outlink, s->max_persistent[c]) - 1);
385  draw_max_line(s, max_draw, c);
386  }
387  }
388  } else { /* horizontal */
389  for (c = 0; c < inlink->ch_layout.nb_channels; c++) {
390  float *src = (float *)insamples->extended_data[c];
391  uint32_t *lut = s->color_lut + s->w * c;
392  float max;
393 
394  s->meter(src, insamples->nb_samples, &s->max[c]);
395  max = s->max[c];
396 
397  s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
398  max = av_clipf(max, 0, 1);
399  max_draw = calc_max_draw(s, outlink, max);
400 
401  for (j = 0; j < s->h; j++) {
402  uint8_t *dst = s->out->data[0] + (c * s->h + c * s->b + j) * s->out->linesize[0];
403 
404  for (k = 0; k < max_draw; k++) {
405  AV_WN32A(dst + k * 4, lut[k]);
406  if (k & step)
407  k += step;
408  }
409  }
410 
411  if (s->draw_persistent_duration > 0.) {
413  max_draw = FFMAX(0, calc_max_draw(s, outlink, s->max_persistent[c]) - 1);
414  draw_max_line(s, max_draw, c);
415  }
416  }
417  }
418 
419  av_frame_free(&insamples);
420  out = av_frame_clone(s->out);
421  if (!out)
422  return AVERROR(ENOMEM);
424  if (ret < 0) {
425  av_frame_free(&out);
426  return ret;
427  }
428 
429  /* draw channel names */
430  for (c = 0; c < inlink->ch_layout.nb_channels && s->h >= 10 && s->draw_text; c++) {
431  if (s->orientation) { /* vertical */
433  if (ret < 0)
434  continue;
435  drawtext(out, c * (s->h + s->b) + (s->h - 10) / 2, outlink->h - 35, channel_name, 1);
436  } else { /* horizontal */
438  if (ret < 0)
439  continue;
440  drawtext(out, 2, c * (s->h + s->b) + (s->h - 8) / 2, channel_name, 0);
441  }
442  }
443 
444  /* draw volume level */
445  for (c = 0; c < inlink->ch_layout.nb_channels && s->h >= 8 && s->draw_volume; c++) {
446  char buf[16];
447 
448  if (s->orientation) { /* vertical */
449  snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
450  drawtext(out, c * (s->h + s->b) + (s->h - 8) / 2, 2, buf, 1);
451  } else { /* horizontal */
452  snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
453  drawtext(out, FFMAX(0, s->w - 8 * (int)strlen(buf)), c * (s->h + s->b) + (s->h - 8) / 2, buf, 0);
454  }
455  }
456 
457  return ff_filter_frame(outlink, out);
458 }
459 
461 {
462  AVFilterLink *inlink = ctx->inputs[0];
463  AVFilterLink *outlink = ctx->outputs[0];
464  ShowVolumeContext *s = ctx->priv;
465  AVFrame *in = NULL;
466  int ret;
467 
469 
470  ret = ff_inlink_consume_samples(inlink, s->nb_samples, s->nb_samples, &in);
471  if (ret < 0)
472  return ret;
473  if (ret > 0)
474  return filter_frame(inlink, in);
475 
476  if (ff_inlink_queued_samples(inlink) >= s->nb_samples) {
478  return 0;
479  }
480 
483 
484  return FFERROR_NOT_READY;
485 }
486 
488 {
489  ShowVolumeContext *s = ctx->priv;
490 
491  av_frame_free(&s->out);
492  av_expr_free(s->c_expr);
493  av_freep(&s->values);
494  av_freep(&s->color_lut);
495  av_freep(&s->max);
496  av_freep(&s->max_persistent);
497  av_freep(&s->nb_frames_max_display);
498 }
499 
500 static const AVFilterPad showvolume_inputs[] = {
501  {
502  .name = "default",
503  .type = AVMEDIA_TYPE_AUDIO,
504  .config_props = config_input,
505  },
506 };
507 
508 static const AVFilterPad showvolume_outputs[] = {
509  {
510  .name = "default",
511  .type = AVMEDIA_TYPE_VIDEO,
512  .config_props = config_output,
513  },
514 };
515 
517  .name = "showvolume",
518  .description = NULL_IF_CONFIG_SMALL("Convert input audio volume to video output."),
519  .init = init,
520  .activate = activate,
521  .uninit = uninit,
522  .priv_size = sizeof(ShowVolumeContext),
526  .priv_class = &showvolume_class,
527 };
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:112
ShowVolumeContext
Definition: avf_showvolume.c:39
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
out
FILE * out
Definition: movenc.c:54
color
Definition: vf_paletteuse.c:511
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:947
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:673
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:261
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
showvolume_inputs
static const AVFilterPad showvolume_inputs[]
Definition: avf_showvolume.c:500
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:248
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:64
ShowVolumeContext::meter
void(* meter)(float *src, int nb_samples, float *max)
Definition: avf_showvolume.c:67
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:130
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:621
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:344
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:456
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
av_channel_layout_channel_from_index
enum AVChannel av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx)
Get the channel with the given index in a channel layout.
Definition: channel_layout.c:664
AVOption
AVOption.
Definition: opt.h:346
b
#define b
Definition: input.c:41
clear_picture
static void clear_picture(ShowVolumeContext *s, AVFilterLink *outlink)
Definition: avf_showvolume.c:267
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
ShowVolumeContext::c_expr
AVExpr * c_expr
Definition: avf_showvolume.c:53
ShowVolumeContext::display_scale
int display_scale
Definition: avf_showvolume.c:59
ShowVolumeContext::draw_volume
int draw_volume
Definition: avf_showvolume.c:55
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:536
max
#define max(a, b)
Definition: cuda_runtime.h:33
channel_name
Definition: channel_layout.c:41
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
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:365
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:279
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:711
ShowVolumeContext::mode
int mode
Definition: avf_showvolume.c:49
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:422
showvolume_options
static const AVOption showvolume_options[]
Definition: avf_showvolume.c:73
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:359
drawtext
static void drawtext(AVFrame *pic, int x, int y, const char *txt, int o)
Definition: avf_showvolume.c:233
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showvolume)
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
draw_max_line
static void draw_max_line(ShowVolumeContext *s, int max_draw, int channel)
Definition: avf_showvolume.c:305
av_cold
#define av_cold
Definition: attributes.h:90
mask
static const uint16_t mask[17]
Definition: lzw.c:38
float
float
Definition: af_crystalizer.c:121
VAR_PEAK
@ VAR_PEAK
Definition: avf_showvolume.c:36
intreadwrite.h
ShowVolumeContext::orientation
int orientation
Definition: avf_showvolume.c:46
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:237
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
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:304
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:793
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:563
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
activate
static int activate(AVFilterContext *ctx)
Definition: avf_showvolume.c:460
AVExpr
Definition: eval.c:159
init
static av_cold int init(AVFilterContext *ctx)
Definition: avf_showvolume.c:101
find_rms
static void find_rms(float *src, int nb_samples, float *rms)
Definition: avf_showvolume.c:155
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
ShowVolumeContext::w
int w
Definition: avf_showvolume.c:41
ff_inlink_make_frame_writable
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1492
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avf_showvolume.c:36
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:1465
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:250
calc_persistent_max
static void calc_persistent_max(ShowVolumeContext *s, float max, int channel)
Definition: avf_showvolume.c:294
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:415
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:362
parseutils.h
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
find_peak
static void find_peak(float *src, int nb_samples, float *peak)
Definition: avf_showvolume.c:145
av_clipf
av_clipf
Definition: af_crystalizer.c:121
config_output
static int config_output(AVFilterLink *outlink)
Definition: avf_showvolume.c:199
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
ShowVolumeContext::nb_frames_max_display
int * nb_frames_max_display
Definition: avf_showvolume.c:65
ff_avf_showvolume
const AVFilter ff_avf_showvolume
Definition: avf_showvolume.c:516
eval.h
ShowVolumeContext::nb_samples
int nb_samples
Definition: avf_showvolume.c:51
f
f
Definition: af_crystalizer.c:121
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:106
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:374
ShowVolumeContext::persistent_max_frames
int persistent_max_frames
Definition: avf_showvolume.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
fmaxf
float fmaxf(float, float)
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
OFFSET
#define OFFSET(x)
Definition: avf_showvolume.c:70
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:238
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:424
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
av_channel_name
int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel_id)
Get a human readable string in an abbreviated form describing a given channel.
Definition: channel_layout.c:97
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:405
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1420
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
showvolume_outputs
static const AVFilterPad showvolume_outputs[]
Definition: avf_showvolume.c:508
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AVFilter
Filter definition.
Definition: avfilter.h:166
LINEAR
@ LINEAR
Definition: avf_showvolume.c:37
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: avf_showvolume.c:116
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
draw_text
static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color, int x0, int y0, const uint8_t *text)
Definition: src_avsynctest.c:247
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:606
channel_layout.h
ShowVolumeContext::draw_persistent_duration
double draw_persistent_duration
Definition: avf_showvolume.c:61
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
Definition: opt.h:235
avfilter.h
VAR_VOLUME
@ VAR_VOLUME
Definition: avf_showvolume.c:36
FLAGS
#define FLAGS
Definition: avf_showvolume.c:71
ShowVolumeContext::bgopacity
float bgopacity
Definition: avf_showvolume.c:48
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
VAR_CHANNEL
@ VAR_CHANNEL
Definition: avf_showvolume.c:36
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: avf_showvolume.c:321
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:510
DisplayScale
DisplayScale
Definition: avf_ahistogram.c:31
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:251
NB_DISPLAY_SCALE
@ NB_DISPLAY_SCALE
Definition: avf_showvolume.c:37
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
config_input
static int config_input(AVFilterLink *inlink)
Definition: avf_showvolume.c:164
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:389
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showvolume.c:487
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:239
int
int
Definition: ffmpeg_filter.c:409
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
snprintf
#define snprintf
Definition: snprintf.h:34
ShowVolumeContext::persistant_max_rgba
uint8_t persistant_max_rgba[4]
Definition: avf_showvolume.c:62
channel
channel
Definition: ebur128.h:39
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:234
ShowVolumeContext::f
double f
Definition: avf_showvolume.c:43