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, "orientation" },
86  { "h", "horizontal", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "orientation" },
87  { "v", "vertical", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "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, "mode" },
91  { "p", "peak", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" },
92  { "r", "rms", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" },
93  { "ds", "set display scale", OFFSET(display_scale), AV_OPT_TYPE_INT, {.i64=LINEAR}, LINEAR, NB_DISPLAY_SCALE - 1, FLAGS, "display_scale" },
94  { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, "display_scale" },
95  { "log", "log", 0, AV_OPT_TYPE_CONST, {.i64=LOG}, 0, 0, FLAGS, "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;
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 = max_draw; j < s->w; 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  if (j & step)
378  j += step;
379  }
380  }
381 
382  if (s->h >= 8 && s->draw_text) {
384  if (ret < 0)
385  continue;
386  drawtext(s->out, c * (s->h + s->b) + (s->h - 10) / 2, outlink->h - 35, channel_name, 1);
387  }
388 
389  if (s->draw_persistent_duration > 0.) {
391  max_draw = FFMAX(0, calc_max_draw(s, outlink, s->max_persistent[c]) - 1);
392  draw_max_line(s, max_draw, c);
393  }
394  }
395  } else { /* horizontal */
396  for (c = 0; c < inlink->ch_layout.nb_channels; c++) {
397  float *src = (float *)insamples->extended_data[c];
398  uint32_t *lut = s->color_lut + s->w * c;
399  float max;
400 
401  s->meter(src, insamples->nb_samples, &s->max[c]);
402  max = s->max[c];
403 
404  s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
405  max = av_clipf(max, 0, 1);
406  max_draw = calc_max_draw(s, outlink, max);
407 
408  for (j = 0; j < s->h; j++) {
409  uint8_t *dst = s->out->data[0] + (c * s->h + c * s->b + j) * s->out->linesize[0];
410 
411  for (k = 0; k < max_draw; k++) {
412  AV_WN32A(dst + k * 4, lut[k]);
413  if (k & step)
414  k += step;
415  }
416  }
417 
418  if (s->h >= 8 && s->draw_text) {
420  if (ret < 0)
421  continue;
422  drawtext(s->out, 2, c * (s->h + s->b) + (s->h - 8) / 2, channel_name, 0);
423  }
424 
425  if (s->draw_persistent_duration > 0.) {
427  max_draw = FFMAX(0, calc_max_draw(s, outlink, s->max_persistent[c]) - 1);
428  draw_max_line(s, max_draw, c);
429  }
430  }
431  }
432 
433  av_frame_free(&insamples);
434  out = av_frame_clone(s->out);
435  if (!out)
436  return AVERROR(ENOMEM);
438 
439  /* draw volume level */
440  for (c = 0; c < inlink->ch_layout.nb_channels && s->h >= 8 && s->draw_volume; c++) {
441  char buf[16];
442 
443  if (s->orientation) { /* vertical */
444  snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
445  drawtext(out, c * (s->h + s->b) + (s->h - 8) / 2, 2, buf, 1);
446  } else { /* horizontal */
447  snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
448  drawtext(out, FFMAX(0, s->w - 8 * (int)strlen(buf)), c * (s->h + s->b) + (s->h - 8) / 2, buf, 0);
449  }
450  }
451 
452  return ff_filter_frame(outlink, out);
453 }
454 
456 {
457  AVFilterLink *inlink = ctx->inputs[0];
458  AVFilterLink *outlink = ctx->outputs[0];
459  ShowVolumeContext *s = ctx->priv;
460  AVFrame *in = NULL;
461  int ret;
462 
464 
465  ret = ff_inlink_consume_samples(inlink, s->nb_samples, s->nb_samples, &in);
466  if (ret < 0)
467  return ret;
468  if (ret > 0)
469  return filter_frame(inlink, in);
470 
471  if (ff_inlink_queued_samples(inlink) >= s->nb_samples) {
473  return 0;
474  }
475 
478 
479  return FFERROR_NOT_READY;
480 }
481 
483 {
484  ShowVolumeContext *s = ctx->priv;
485 
486  av_frame_free(&s->out);
487  av_expr_free(s->c_expr);
488  av_freep(&s->values);
489  av_freep(&s->color_lut);
490  av_freep(&s->max);
491  av_freep(&s->max_persistent);
492  av_freep(&s->nb_frames_max_display);
493 }
494 
495 static const AVFilterPad showvolume_inputs[] = {
496  {
497  .name = "default",
498  .type = AVMEDIA_TYPE_AUDIO,
499  .config_props = config_input,
500  },
501 };
502 
503 static const AVFilterPad showvolume_outputs[] = {
504  {
505  .name = "default",
506  .type = AVMEDIA_TYPE_VIDEO,
507  .config_props = config_output,
508  },
509 };
510 
512  .name = "showvolume",
513  .description = NULL_IF_CONFIG_SMALL("Convert input audio volume to video output."),
514  .init = init,
515  .activate = activate,
516  .uninit = uninit,
517  .priv_size = sizeof(ShowVolumeContext),
521  .priv_class = &showvolume_class,
522 };
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:101
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: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:509
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
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:591
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:326
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
showvolume_inputs
static const AVFilterPad showvolume_inputs[]
Definition: avf_showvolume.c:495
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:238
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:116
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:566
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
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:554
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
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:796
AVOption
AVOption.
Definition: opt.h:251
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:167
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:538
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:175
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:351
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:685
ShowVolumeContext::mode
int mode
Definition: avf_showvolume.c:49
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:417
showvolume_options
static const AVOption showvolume_options[]
Definition: avf_showvolume.c:73
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:719
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:336
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:49
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:122
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:256
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:227
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:596
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:296
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:478
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:455
AVExpr
Definition: eval.c:157
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:190
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
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:1392
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:240
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:410
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
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:122
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:511
eval.h
ShowVolumeContext::nb_samples
int nb_samples
Definition: avf_showvolume.c:51
f
f
Definition: af_crystalizer.c:122
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:115
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
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:228
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:410
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avf_showvolume.c:36
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:101
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:391
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:55
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1352
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:503
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
AVFilter
Filter definition.
Definition: avfilter.h:171
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
VAR_VOLUME
@ VAR_VOLUME
Definition: avf_showvolume.c:36
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:245
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:551
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:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
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:402
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:321
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:506
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:244
NB_DISPLAY_SCALE
@ NB_DISPLAY_SCALE
Definition: avf_showvolume.c:37
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
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:375
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: avf_showvolume.c:482
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:229
VAR_CHANNEL
@ VAR_CHANNEL
Definition: avf_showvolume.c:36
int
int
Definition: ffmpeg_filter.c:156
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
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:199
ShowVolumeContext::f
double f
Definition: avf_showvolume.c:43