6c47cce19f5198cfe6e6055940f30dbe55b29ba5
[ffmpeg.git] / libavfilter / avf_showvolume.c
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"
22 #include "libavutil/channel_layout.h"
23 #include "libavutil/eval.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/parseutils.h"
27 #include "libavutil/xga_font_data.h"
28 #include "avfilter.h"
29 #include "formats.h"
30 #include "audio.h"
31 #include "video.h"
32 #include "internal.h"
33
34 static const char *const var_names[] = {   "VOLUME",   "CHANNEL",   "PEAK",        NULL };
35 enum                                   { VAR_VOLUME, VAR_CHANNEL, VAR_PEAK, VAR_VARS_NB };
36
37 typedef struct ShowVolumeContext {
38     const AVClass *class;
39     int w, h;
40     int b;
41     double f;
42     AVRational frame_rate;
43     char *color;
44     int orientation;
45     int step;
46     float bgopacity;
47     int mode;
48
49     AVFrame *out;
50     AVExpr *c_expr;
51     int draw_text;
52     int draw_volume;
53     double *values;
54     uint32_t *color_lut;
55     float *max;
56     float rms_factor;
57
58     void (*meter)(float *src, int nb_samples, float *max, float factor);
59 } ShowVolumeContext;
60
61 #define OFFSET(x) offsetof(ShowVolumeContext, x)
62 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
63
64 static const AVOption showvolume_options[] = {
65     { "rate", "set video rate",  OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
66     { "r",    "set video rate",  OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
67     { "b", "set border width",   OFFSET(b), AV_OPT_TYPE_INT, {.i64=1}, 0, 5, FLAGS },
68     { "w", "set channel width",  OFFSET(w), AV_OPT_TYPE_INT, {.i64=400}, 80, 8192, FLAGS },
69     { "h", "set channel height", OFFSET(h), AV_OPT_TYPE_INT, {.i64=20}, 1, 900, FLAGS },
70     { "f", "set fade",           OFFSET(f), AV_OPT_TYPE_DOUBLE, {.dbl=0.95}, 0.001, 1, FLAGS },
71     { "c", "set volume color expression", OFFSET(color), AV_OPT_TYPE_STRING, {.str="PEAK*255+floor((1-PEAK)*255)*256+0xff000000"}, 0, 0, FLAGS },
72     { "t", "display channel names", OFFSET(draw_text), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
73     { "v", "display volume value", OFFSET(draw_volume), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
74     { "o", "set orientation", OFFSET(orientation), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "orientation" },
75     {   "h", "horizontal", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "orientation" },
76     {   "v", "vertical",   0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "orientation" },
77     { "s", "set step size", OFFSET(step), AV_OPT_TYPE_INT, {.i64=0}, 0, 5, FLAGS },
78     { "p", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, FLAGS },
79     { "m", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "mode" },
80     {   "p", "peak", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" },
81     {   "r", "rms",  0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" },
82     { NULL }
83 };
84
85 AVFILTER_DEFINE_CLASS(showvolume);
86
87 static av_cold int init(AVFilterContext *ctx)
88 {
89     ShowVolumeContext *s = ctx->priv;
90     int ret;
91
92     if (s->color) {
93         ret = av_expr_parse(&s->c_expr, s->color, var_names,
94                             NULL, NULL, NULL, NULL, 0, ctx);
95         if (ret < 0)
96             return ret;
97     }
98
99     return 0;
100 }
101
102 static int query_formats(AVFilterContext *ctx)
103 {
104     AVFilterFormats *formats = NULL;
105     AVFilterChannelLayouts *layouts = NULL;
106     AVFilterLink *inlink = ctx->inputs[0];
107     AVFilterLink *outlink = ctx->outputs[0];
108     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
109     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
110     int ret;
111
112     formats = ff_make_format_list(sample_fmts);
113     if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0)
114         return ret;
115
116     layouts = ff_all_channel_counts();
117     if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0)
118         return ret;
119
120     formats = ff_all_samplerates();
121     if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
122         return ret;
123
124     formats = ff_make_format_list(pix_fmts);
125     if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
126         return ret;
127
128     return 0;
129 }
130
131 static void find_peak(float *src, int nb_samples, float *peak, float factor)
132 {
133     int i;
134
135     *peak = 0;
136     for (i = 0; i < nb_samples; i++)
137         *peak = FFMAX(*peak, FFABS(src[i]));
138 }
139
140 static void find_rms(float *src, int nb_samples, float *rms, float factor)
141 {
142     int i;
143
144     for (i = 0; i < nb_samples; i++)
145         *rms += factor * (src[i] * src[i] - *rms);
146 }
147
148 static int config_input(AVFilterLink *inlink)
149 {
150     AVFilterContext *ctx = inlink->dst;
151     ShowVolumeContext *s = ctx->priv;
152     int nb_samples;
153
154     nb_samples = FFMAX(1024, ((double)inlink->sample_rate / av_q2d(s->frame_rate)) + 0.5);
155     inlink->partial_buf_size =
156     inlink->min_samples =
157     inlink->max_samples = nb_samples;
158     s->values = av_calloc(inlink->channels * VAR_VARS_NB, sizeof(double));
159     if (!s->values)
160         return AVERROR(ENOMEM);
161
162     s->color_lut = av_calloc(s->w, sizeof(*s->color_lut) * inlink->channels);
163     if (!s->color_lut)
164         return AVERROR(ENOMEM);
165
166     s->max = av_calloc(inlink->channels, sizeof(*s->max));
167     if (!s->max)
168         return AVERROR(ENOMEM);
169
170     s->rms_factor = 10000. / inlink->sample_rate;
171
172     switch (s->mode) {
173     case 0: s->meter = find_peak; break;
174     case 1: s->meter = find_rms;  break;
175     default: return AVERROR_BUG;
176     }
177
178     return 0;
179 }
180
181 static int config_output(AVFilterLink *outlink)
182 {
183     ShowVolumeContext *s = outlink->src->priv;
184     AVFilterLink *inlink = outlink->src->inputs[0];
185     int ch;
186
187     if (s->orientation) {
188         outlink->h = s->w;
189         outlink->w = s->h * inlink->channels + (inlink->channels - 1) * s->b;
190     } else {
191         outlink->w = s->w;
192         outlink->h = s->h * inlink->channels + (inlink->channels - 1) * s->b;
193     }
194
195     outlink->sample_aspect_ratio = (AVRational){1,1};
196     outlink->frame_rate = s->frame_rate;
197
198     for (ch = 0; ch < inlink->channels; ch++) {
199         int i;
200
201         for (i = 0; i < s->w; i++) {
202             float max = i / (float)(s->w - 1);
203
204             s->values[ch * VAR_VARS_NB + VAR_PEAK] = max;
205             s->values[ch * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
206             s->values[ch * VAR_VARS_NB + VAR_CHANNEL] = ch;
207             s->color_lut[ch * s->w + i] = av_expr_eval(s->c_expr, &s->values[ch * VAR_VARS_NB], NULL);
208         }
209     }
210
211     return 0;
212 }
213
214 static void drawtext(AVFrame *pic, int x, int y, const char *txt, int o)
215 {
216     const uint8_t *font;
217     int font_height;
218     int i;
219
220     font = avpriv_cga_font,   font_height =  8;
221
222     for (i = 0; txt[i]; i++) {
223         int char_y, mask;
224
225         if (o) { /* vertical orientation */
226             for (char_y = font_height - 1; char_y >= 0; char_y--) {
227                 uint8_t *p = pic->data[0] + (y + i * 10) * pic->linesize[0] + x * 4;
228                 for (mask = 0x80; mask; mask >>= 1) {
229                     if (font[txt[i] * font_height + font_height - 1 - char_y] & mask)
230                         AV_WN32(&p[char_y * 4], ~AV_RN32(&p[char_y * 4]));
231                     p += pic->linesize[0];
232                 }
233             }
234         } else { /* horizontal orientation */
235             uint8_t *p = pic->data[0] + y * pic->linesize[0] + (x + i * 8) * 4;
236             for (char_y = 0; char_y < font_height; char_y++) {
237                 for (mask = 0x80; mask; mask >>= 1) {
238                     if (font[txt[i] * font_height + char_y] & mask)
239                         AV_WN32(p, ~AV_RN32(p));
240                     p += 4;
241                 }
242                 p += pic->linesize[0] - 8 * 4;
243             }
244         }
245     }
246 }
247
248 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
249 {
250     AVFilterContext *ctx = inlink->dst;
251     AVFilterLink *outlink = ctx->outputs[0];
252     ShowVolumeContext *s = ctx->priv;
253     const int step = s->step;
254     int c, i, j, k;
255     AVFrame *out;
256
257     if (!s->out || s->out->width  != outlink->w ||
258                    s->out->height != outlink->h) {
259         av_frame_free(&s->out);
260         s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
261         if (!s->out) {
262             av_frame_free(&insamples);
263             return AVERROR(ENOMEM);
264         }
265
266         for (i = 0; i < outlink->h; i++) {
267             uint32_t *dst = (uint32_t *)(s->out->data[0] + i * s->out->linesize[0]);
268             const uint32_t bg = (uint32_t)(s->bgopacity * 255) << 24;
269
270             for (j = 0; j < outlink->w; j++)
271                 AV_WN32A(dst + j, bg);
272         }
273     }
274     s->out->pts = insamples->pts;
275
276     if (s->f < 1.) {
277         for (j = 0; j < outlink->h; j++) {
278             uint8_t *dst = s->out->data[0] + j * s->out->linesize[0];
279             const uint32_t alpha = s->bgopacity * 255;
280
281             for (k = 0; k < outlink->w; k++) {
282                 dst[k * 4 + 0] = FFMAX(dst[k * 4 + 0] * s->f, 0);
283                 dst[k * 4 + 1] = FFMAX(dst[k * 4 + 1] * s->f, 0);
284                 dst[k * 4 + 2] = FFMAX(dst[k * 4 + 2] * s->f, 0);
285                 dst[k * 4 + 3] = FFMAX(dst[k * 4 + 3] * s->f, alpha);
286             }
287         }
288     }
289
290     if (s->orientation) { /* vertical */
291         for (c = 0; c < inlink->channels; c++) {
292             float *src = (float *)insamples->extended_data[c];
293             uint32_t *lut = s->color_lut + s->w * c;
294             float max;
295
296             s->meter(src, insamples->nb_samples, &s->max[c], s->rms_factor);
297             max = s->max[c];
298
299             s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
300             max = av_clipf(max, 0, 1);
301
302             for (j = outlink->h - outlink->h * max; j < s->w; j++) {
303                 uint8_t *dst = s->out->data[0] + j * s->out->linesize[0] + c * (s->b + s->h) * 4;
304                 for (k = 0; k < s->h; k++) {
305                     AV_WN32A(&dst[k * 4], lut[s->w - j - 1]);
306                     if (j & step)
307                         j += step;
308                 }
309             }
310
311             if (s->h >= 8 && s->draw_text) {
312                 const char *channel_name = av_get_channel_name(av_channel_layout_extract_channel(insamples->channel_layout, c));
313                 if (!channel_name)
314                     continue;
315                 drawtext(s->out, c * (s->h + s->b) + (s->h - 10) / 2, outlink->h - 35, channel_name, 1);
316             }
317         }
318     } else { /* horizontal */
319         for (c = 0; c < inlink->channels; c++) {
320             float *src = (float *)insamples->extended_data[c];
321             uint32_t *lut = s->color_lut + s->w * c;
322             float max;
323
324             s->meter(src, insamples->nb_samples, &s->max[c], s->rms_factor);
325             max = s->max[c];
326
327             s->values[c * VAR_VARS_NB + VAR_VOLUME] = 20.0 * log10(max);
328             max = av_clipf(max, 0, 1);
329
330             for (j = 0; j < s->h; j++) {
331                 uint8_t *dst = s->out->data[0] + (c * s->h + c * s->b + j) * s->out->linesize[0];
332
333                 for (k = 0; k < s->w * max; k++) {
334                     AV_WN32A(dst + k * 4, lut[k]);
335                     if (k & step)
336                         k += step;
337                 }
338             }
339
340             if (s->h >= 8 && s->draw_text) {
341                 const char *channel_name = av_get_channel_name(av_channel_layout_extract_channel(insamples->channel_layout, c));
342                 if (!channel_name)
343                     continue;
344                 drawtext(s->out, 2, c * (s->h + s->b) + (s->h - 8) / 2, channel_name, 0);
345             }
346         }
347     }
348
349     av_frame_free(&insamples);
350     out = av_frame_clone(s->out);
351     if (!out)
352         return AVERROR(ENOMEM);
353     av_frame_make_writable(out);
354
355     for (c = 0; c < inlink->channels && s->draw_volume; c++) {
356         char buf[16];
357         if (s->orientation) {
358             if (s->h >= 8) {
359                 snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
360                 drawtext(out, c * (s->h + s->b) + (s->h - 8) / 2, 2, buf, 1);
361             }
362         } else {
363             if (s->h >= 8) {
364                 snprintf(buf, sizeof(buf), "%.2f", s->values[c * VAR_VARS_NB + VAR_VOLUME]);
365                 drawtext(out, FFMAX(0, s->w - 8 * (int)strlen(buf)), c * (s->h + s->b) + (s->h - 8) / 2, buf, 0);
366             }
367         }
368     }
369
370     return ff_filter_frame(outlink, out);
371 }
372
373 static av_cold void uninit(AVFilterContext *ctx)
374 {
375     ShowVolumeContext *s = ctx->priv;
376
377     av_frame_free(&s->out);
378     av_expr_free(s->c_expr);
379     av_freep(&s->values);
380     av_freep(&s->color_lut);
381     av_freep(&s->max);
382 }
383
384 static const AVFilterPad showvolume_inputs[] = {
385     {
386         .name         = "default",
387         .type         = AVMEDIA_TYPE_AUDIO,
388         .config_props = config_input,
389         .filter_frame = filter_frame,
390     },
391     { NULL }
392 };
393
394 static const AVFilterPad showvolume_outputs[] = {
395     {
396         .name         = "default",
397         .type         = AVMEDIA_TYPE_VIDEO,
398         .config_props = config_output,
399     },
400     { NULL }
401 };
402
403 AVFilter ff_avf_showvolume = {
404     .name          = "showvolume",
405     .description   = NULL_IF_CONFIG_SMALL("Convert input audio volume to video output."),
406     .init          = init,
407     .uninit        = uninit,
408     .query_formats = query_formats,
409     .priv_size     = sizeof(ShowVolumeContext),
410     .inputs        = showvolume_inputs,
411     .outputs       = showvolume_outputs,
412     .priv_class    = &showvolume_class,
413 };