avfilter: Fix max value of AV_OPT_TYPE_VIDEO_RATE
[ffmpeg.git] / libavfilter / avf_showwaves.c
1 /*
2  * Copyright (c) 2012 Stefano Sabatini
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * audio to video multimedia filter
24  */
25
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/channel_layout.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/parseutils.h"
31 #include "avfilter.h"
32 #include "formats.h"
33 #include "audio.h"
34 #include "video.h"
35 #include "internal.h"
36
37 enum ShowWavesMode {
38     MODE_POINT,
39     MODE_LINE,
40     MODE_P2P,
41     MODE_CENTERED_LINE,
42     MODE_NB,
43 };
44
45 enum ShowWavesScale {
46     SCALE_LIN,
47     SCALE_LOG,
48     SCALE_NB,
49 };
50
51 struct frame_node {
52     AVFrame *frame;
53     struct frame_node *next;
54 };
55
56 typedef struct {
57     const AVClass *class;
58     int w, h;
59     AVRational rate;
60     char *colors;
61     int buf_idx;
62     int16_t *buf_idy;    /* y coordinate of previous sample for each channel */
63     AVFrame *outpicref;
64     int n;
65     int pixstep;
66     int sample_count_mod;
67     int mode;                   ///< ShowWavesMode
68     int scale;                  ///< ShowWavesScale
69     int split_channels;
70     uint8_t *fg;
71
72     int (*get_h)(int16_t sample, int height);
73     void (*draw_sample)(uint8_t *buf, int height, int linesize,
74                         int16_t *prev_y, const uint8_t color[4], int h);
75
76     /* single picture */
77     int single_pic;
78     struct frame_node *audio_frames;
79     struct frame_node *last_frame;
80     int64_t total_samples;
81     int64_t *sum; /* abs sum of the samples per channel */
82 } ShowWavesContext;
83
84 #define OFFSET(x) offsetof(ShowWavesContext, x)
85 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
86
87 static const AVOption showwaves_options[] = {
88     { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
89     { "s",    "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
90     { "mode", "select display mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_POINT}, 0, MODE_NB-1, FLAGS, "mode"},
91         { "point", "draw a point for each sample",         0, AV_OPT_TYPE_CONST, {.i64=MODE_POINT},         .flags=FLAGS, .unit="mode"},
92         { "line",  "draw a line for each sample",          0, AV_OPT_TYPE_CONST, {.i64=MODE_LINE},          .flags=FLAGS, .unit="mode"},
93         { "p2p",   "draw a line between samples",          0, AV_OPT_TYPE_CONST, {.i64=MODE_P2P},           .flags=FLAGS, .unit="mode"},
94         { "cline", "draw a centered line for each sample", 0, AV_OPT_TYPE_CONST, {.i64=MODE_CENTERED_LINE}, .flags=FLAGS, .unit="mode"},
95     { "n",    "set how many samples to show in the same point", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
96     { "rate", "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
97     { "r",    "set video rate", OFFSET(rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },
98     { "split_channels", "draw channels separately", OFFSET(split_channels), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
99     { "colors", "set channels colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, FLAGS },
100     { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },
101         { "lin", "linear",         0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},
102         { "log", "logarithmic",    0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},
103     { NULL }
104 };
105
106 AVFILTER_DEFINE_CLASS(showwaves);
107
108 static av_cold void uninit(AVFilterContext *ctx)
109 {
110     ShowWavesContext *showwaves = ctx->priv;
111
112     av_frame_free(&showwaves->outpicref);
113     av_freep(&showwaves->buf_idy);
114     av_freep(&showwaves->fg);
115
116     if (showwaves->single_pic) {
117         struct frame_node *node = showwaves->audio_frames;
118         while (node) {
119             struct frame_node *tmp = node;
120
121             node = node->next;
122             av_frame_free(&tmp->frame);
123             av_freep(&tmp);
124         }
125         av_freep(&showwaves->sum);
126         showwaves->last_frame = NULL;
127     }
128 }
129
130 static int query_formats(AVFilterContext *ctx)
131 {
132     AVFilterFormats *formats = NULL;
133     AVFilterChannelLayouts *layouts = NULL;
134     AVFilterLink *inlink = ctx->inputs[0];
135     AVFilterLink *outlink = ctx->outputs[0];
136     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
137     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
138     int ret;
139
140     /* set input audio formats */
141     formats = ff_make_format_list(sample_fmts);
142     if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0)
143         return ret;
144
145     layouts = ff_all_channel_layouts();
146     if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0)
147         return ret;
148
149     formats = ff_all_samplerates();
150     if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
151         return ret;
152
153     /* set output video format */
154     formats = ff_make_format_list(pix_fmts);
155     if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
156         return ret;
157
158     return 0;
159 }
160
161 static int get_lin_h(int16_t sample, int height)
162 {
163     return height/2 - av_rescale(sample, height/2, INT16_MAX);
164 }
165
166 static int get_lin_h2(int16_t sample, int height)
167 {
168     return av_rescale(FFABS(sample), height, INT16_MAX);
169 }
170
171 static int get_log_h(int16_t sample, int height)
172 {
173     return height/2 - FFSIGN(sample) * (log10(1 + FFABS(sample)) * (height/2) / log10(1 + INT16_MAX));
174 }
175
176 static int get_log_h2(int16_t sample, int height)
177 {
178     return log10(1 + FFABS(sample)) * height / log10(1 + INT16_MAX);
179 }
180
181 static void draw_sample_point_rgba(uint8_t *buf, int height, int linesize,
182                                    int16_t *prev_y,
183                                    const uint8_t color[4], int h)
184 {
185     if (h >= 0 && h < height) {
186         buf[h * linesize + 0] += color[0];
187         buf[h * linesize + 1] += color[1];
188         buf[h * linesize + 2] += color[2];
189         buf[h * linesize + 3] += color[3];
190     }
191 }
192
193 static void draw_sample_line_rgba(uint8_t *buf, int height, int linesize,
194                                   int16_t *prev_y,
195                                   const uint8_t color[4], int h)
196 {
197     int k;
198     int start   = height/2;
199     int end     = av_clip(h, 0, height-1);
200     if (start > end)
201         FFSWAP(int16_t, start, end);
202     for (k = start; k < end; k++) {
203         buf[k * linesize + 0] += color[0];
204         buf[k * linesize + 1] += color[1];
205         buf[k * linesize + 2] += color[2];
206         buf[k * linesize + 3] += color[3];
207     }
208 }
209
210 static void draw_sample_p2p_rgba(uint8_t *buf, int height, int linesize,
211                                  int16_t *prev_y,
212                                  const uint8_t color[4], int h)
213 {
214     int k;
215     if (h >= 0 && h < height) {
216         buf[h * linesize + 0] += color[0];
217         buf[h * linesize + 1] += color[1];
218         buf[h * linesize + 2] += color[2];
219         buf[h * linesize + 3] += color[3];
220         if (*prev_y && h != *prev_y) {
221             int start = *prev_y;
222             int end = av_clip(h, 0, height-1);
223             if (start > end)
224                 FFSWAP(int16_t, start, end);
225             for (k = start + 1; k < end; k++) {
226                 buf[k * linesize + 0] += color[0];
227                 buf[k * linesize + 1] += color[1];
228                 buf[k * linesize + 2] += color[2];
229                 buf[k * linesize + 3] += color[3];
230             }
231         }
232     }
233     *prev_y = h;
234 }
235
236 static void draw_sample_cline_rgba(uint8_t *buf, int height, int linesize,
237                                    int16_t *prev_y,
238                                    const uint8_t color[4], int h)
239 {
240     int k;
241     const int start = (height - h) / 2;
242     const int end   = start + h;
243     for (k = start; k < end; k++) {
244         buf[k * linesize + 0] += color[0];
245         buf[k * linesize + 1] += color[1];
246         buf[k * linesize + 2] += color[2];
247         buf[k * linesize + 3] += color[3];
248     }
249 }
250
251 static void draw_sample_point_gray(uint8_t *buf, int height, int linesize,
252                                    int16_t *prev_y,
253                                    const uint8_t color[4], int h)
254 {
255     if (h >= 0 && h < height)
256         buf[h * linesize] += color[0];
257 }
258
259 static void draw_sample_line_gray(uint8_t *buf, int height, int linesize,
260                                   int16_t *prev_y,
261                                   const uint8_t color[4], int h)
262 {
263     int k;
264     int start   = height/2;
265     int end     = av_clip(h, 0, height-1);
266     if (start > end)
267         FFSWAP(int16_t, start, end);
268     for (k = start; k < end; k++)
269         buf[k * linesize] += color[0];
270 }
271
272 static void draw_sample_p2p_gray(uint8_t *buf, int height, int linesize,
273                                  int16_t *prev_y,
274                                  const uint8_t color[4], int h)
275 {
276     int k;
277     if (h >= 0 && h < height) {
278         buf[h * linesize] += color[0];
279         if (*prev_y && h != *prev_y) {
280             int start = *prev_y;
281             int end = av_clip(h, 0, height-1);
282             if (start > end)
283                 FFSWAP(int16_t, start, end);
284             for (k = start + 1; k < end; k++)
285                 buf[k * linesize] += color[0];
286         }
287     }
288     *prev_y = h;
289 }
290
291 static void draw_sample_cline_gray(uint8_t *buf, int height, int linesize,
292                                    int16_t *prev_y,
293                                    const uint8_t color[4], int h)
294 {
295     int k;
296     const int start = (height - h) / 2;
297     const int end   = start + h;
298     for (k = start; k < end; k++)
299         buf[k * linesize] += color[0];
300 }
301
302 static int config_output(AVFilterLink *outlink)
303 {
304     AVFilterContext *ctx = outlink->src;
305     AVFilterLink *inlink = ctx->inputs[0];
306     ShowWavesContext *showwaves = ctx->priv;
307     int nb_channels = inlink->channels;
308     char *colors, *saveptr = NULL;
309     uint8_t x;
310     int ch;
311
312     if (showwaves->single_pic)
313         showwaves->n = 1;
314
315     if (!showwaves->n)
316         showwaves->n = FFMAX(1, ((double)inlink->sample_rate / (showwaves->w * av_q2d(showwaves->rate))) + 0.5);
317
318     showwaves->buf_idx = 0;
319     if (!(showwaves->buf_idy = av_mallocz_array(nb_channels, sizeof(*showwaves->buf_idy)))) {
320         av_log(ctx, AV_LOG_ERROR, "Could not allocate showwaves buffer\n");
321         return AVERROR(ENOMEM);
322     }
323     outlink->w = showwaves->w;
324     outlink->h = showwaves->h;
325     outlink->sample_aspect_ratio = (AVRational){1,1};
326
327     outlink->frame_rate = av_div_q((AVRational){inlink->sample_rate,showwaves->n},
328                                    (AVRational){showwaves->w,1});
329
330     av_log(ctx, AV_LOG_VERBOSE, "s:%dx%d r:%f n:%d\n",
331            showwaves->w, showwaves->h, av_q2d(outlink->frame_rate), showwaves->n);
332
333     switch (outlink->format) {
334     case AV_PIX_FMT_GRAY8:
335         switch (showwaves->mode) {
336         case MODE_POINT:         showwaves->draw_sample = draw_sample_point_gray; break;
337         case MODE_LINE:          showwaves->draw_sample = draw_sample_line_gray;  break;
338         case MODE_P2P:           showwaves->draw_sample = draw_sample_p2p_gray;   break;
339         case MODE_CENTERED_LINE: showwaves->draw_sample = draw_sample_cline_gray; break;
340         default:
341             return AVERROR_BUG;
342         }
343         showwaves->pixstep = 1;
344         break;
345     case AV_PIX_FMT_RGBA:
346         switch (showwaves->mode) {
347         case MODE_POINT:         showwaves->draw_sample = draw_sample_point_rgba; break;
348         case MODE_LINE:          showwaves->draw_sample = draw_sample_line_rgba;  break;
349         case MODE_P2P:           showwaves->draw_sample = draw_sample_p2p_rgba;   break;
350         case MODE_CENTERED_LINE: showwaves->draw_sample = draw_sample_cline_rgba; break;
351         default:
352             return AVERROR_BUG;
353         }
354         showwaves->pixstep = 4;
355         break;
356     }
357
358     switch (showwaves->scale) {
359     case SCALE_LIN:
360         switch (showwaves->mode) {
361         case MODE_POINT:
362         case MODE_LINE:
363         case MODE_P2P:           showwaves->get_h = get_lin_h;  break;
364         case MODE_CENTERED_LINE: showwaves->get_h = get_lin_h2; break;
365         default:
366             return AVERROR_BUG;
367         }
368         break;
369     case SCALE_LOG:
370         switch (showwaves->mode) {
371         case MODE_POINT:
372         case MODE_LINE:
373         case MODE_P2P:           showwaves->get_h = get_log_h;  break;
374         case MODE_CENTERED_LINE: showwaves->get_h = get_log_h2; break;
375         default:
376             return AVERROR_BUG;
377         }
378         break;
379     }
380
381     showwaves->fg = av_malloc_array(nb_channels, 4 * sizeof(*showwaves->fg));
382     if (!showwaves->fg)
383         return AVERROR(ENOMEM);
384
385     colors = av_strdup(showwaves->colors);
386     if (!colors)
387         return AVERROR(ENOMEM);
388
389     /* multiplication factor, pre-computed to avoid in-loop divisions */
390     x = 255 / ((showwaves->split_channels ? 1 : nb_channels) * showwaves->n);
391     if (outlink->format == AV_PIX_FMT_RGBA) {
392         uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff };
393
394         for (ch = 0; ch < nb_channels; ch++) {
395             char *color;
396
397             color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr);
398             if (color)
399                 av_parse_color(fg, color, -1, ctx);
400             showwaves->fg[4*ch + 0] = fg[0] * x / 255.;
401             showwaves->fg[4*ch + 1] = fg[1] * x / 255.;
402             showwaves->fg[4*ch + 2] = fg[2] * x / 255.;
403             showwaves->fg[4*ch + 3] = fg[3] * x / 255.;
404         }
405     } else {
406         for (ch = 0; ch < nb_channels; ch++)
407             showwaves->fg[4 * ch + 0] = x;
408     }
409     av_free(colors);
410
411     return 0;
412 }
413
414 inline static int push_frame(AVFilterLink *outlink)
415 {
416     AVFilterContext *ctx = outlink->src;
417     AVFilterLink *inlink = ctx->inputs[0];
418     ShowWavesContext *showwaves = outlink->src->priv;
419     int nb_channels = inlink->channels;
420     int ret, i;
421
422     ret = ff_filter_frame(outlink, showwaves->outpicref);
423     showwaves->outpicref = NULL;
424     showwaves->buf_idx = 0;
425     for (i = 0; i < nb_channels; i++)
426         showwaves->buf_idy[i] = 0;
427     return ret;
428 }
429
430 static int push_single_pic(AVFilterLink *outlink)
431 {
432     AVFilterContext *ctx = outlink->src;
433     AVFilterLink *inlink = ctx->inputs[0];
434     ShowWavesContext *showwaves = ctx->priv;
435     int64_t n = 0, max_samples = showwaves->total_samples / outlink->w;
436     AVFrame *out = showwaves->outpicref;
437     struct frame_node *node;
438     const int nb_channels = inlink->channels;
439     const int ch_height = showwaves->split_channels ? outlink->h / nb_channels : outlink->h;
440     const int linesize = out->linesize[0];
441     const int pixstep = showwaves->pixstep;
442     int col = 0;
443     int64_t *sum = showwaves->sum;
444
445     if (max_samples == 0) {
446         av_log(ctx, AV_LOG_ERROR, "Too few samples\n");
447         return AVERROR(EINVAL);
448     }
449
450     av_log(ctx, AV_LOG_DEBUG, "Create frame averaging %"PRId64" samples per column\n", max_samples);
451
452     memset(sum, 0, nb_channels);
453
454     for (node = showwaves->audio_frames; node; node = node->next) {
455         int i;
456         const AVFrame *frame = node->frame;
457         const int16_t *p = (const int16_t *)frame->data[0];
458
459         for (i = 0; i < frame->nb_samples; i++) {
460             int ch;
461
462             for (ch = 0; ch < nb_channels; ch++)
463                 sum[ch] += abs(p[ch + i*nb_channels]) << 1;
464             if (n++ == max_samples) {
465                 for (ch = 0; ch < nb_channels; ch++) {
466                     int16_t sample = sum[ch] / max_samples;
467                     uint8_t *buf = out->data[0] + col * pixstep;
468                     int h;
469
470                     if (showwaves->split_channels)
471                         buf += ch*ch_height*linesize;
472                     av_assert0(col < outlink->w);
473                     h = showwaves->get_h(sample, ch_height);
474                     showwaves->draw_sample(buf, ch_height, linesize, &showwaves->buf_idy[ch], &showwaves->fg[ch * 4], h);
475                     sum[ch] = 0;
476                 }
477                 col++;
478                 n = 0;
479             }
480         }
481     }
482
483     return push_frame(outlink);
484 }
485
486
487 static int request_frame(AVFilterLink *outlink)
488 {
489     ShowWavesContext *showwaves = outlink->src->priv;
490     AVFilterLink *inlink = outlink->src->inputs[0];
491     int ret;
492
493     ret = ff_request_frame(inlink);
494     if (ret == AVERROR_EOF && showwaves->outpicref) {
495         if (showwaves->single_pic)
496             push_single_pic(outlink);
497         else
498             push_frame(outlink);
499     }
500
501     return ret;
502 }
503
504 static int alloc_out_frame(ShowWavesContext *showwaves, const int16_t *p,
505                            const AVFilterLink *inlink, AVFilterLink *outlink,
506                            const AVFrame *in)
507 {
508     if (!showwaves->outpicref) {
509         int j;
510         AVFrame *out = showwaves->outpicref =
511             ff_get_video_buffer(outlink, outlink->w, outlink->h);
512         if (!out)
513             return AVERROR(ENOMEM);
514         out->width  = outlink->w;
515         out->height = outlink->h;
516         out->pts = in->pts + av_rescale_q((p - (int16_t *)in->data[0]) / inlink->channels,
517                                           av_make_q(1, inlink->sample_rate),
518                                           outlink->time_base);
519         for (j = 0; j < outlink->h; j++)
520             memset(out->data[0] + j*out->linesize[0], 0, outlink->w * showwaves->pixstep);
521     }
522     return 0;
523 }
524
525 static av_cold int init(AVFilterContext *ctx)
526 {
527     ShowWavesContext *showwaves = ctx->priv;
528
529     if (!strcmp(ctx->filter->name, "showwavespic")) {
530         showwaves->single_pic = 1;
531         showwaves->mode = MODE_CENTERED_LINE;
532     }
533
534     return 0;
535 }
536
537 #if CONFIG_SHOWWAVES_FILTER
538
539 static int showwaves_filter_frame(AVFilterLink *inlink, AVFrame *insamples)
540 {
541     AVFilterContext *ctx = inlink->dst;
542     AVFilterLink *outlink = ctx->outputs[0];
543     ShowWavesContext *showwaves = ctx->priv;
544     const int nb_samples = insamples->nb_samples;
545     AVFrame *outpicref = showwaves->outpicref;
546     int16_t *p = (int16_t *)insamples->data[0];
547     int nb_channels = inlink->channels;
548     int i, j, ret = 0;
549     const int pixstep = showwaves->pixstep;
550     const int n = showwaves->n;
551     const int ch_height = showwaves->split_channels ? outlink->h / nb_channels : outlink->h;
552
553     /* draw data in the buffer */
554     for (i = 0; i < nb_samples; i++) {
555
556         ret = alloc_out_frame(showwaves, p, inlink, outlink, insamples);
557         if (ret < 0)
558             goto end;
559         outpicref = showwaves->outpicref;
560
561         for (j = 0; j < nb_channels; j++) {
562             uint8_t *buf = outpicref->data[0] + showwaves->buf_idx * pixstep;
563             const int linesize = outpicref->linesize[0];
564             int h;
565
566             if (showwaves->split_channels)
567                 buf += j*ch_height*linesize;
568             h = showwaves->get_h(*p++, ch_height);
569             showwaves->draw_sample(buf, ch_height, linesize,
570                                    &showwaves->buf_idy[j], &showwaves->fg[j * 4], h);
571         }
572
573         showwaves->sample_count_mod++;
574         if (showwaves->sample_count_mod == n) {
575             showwaves->sample_count_mod = 0;
576             showwaves->buf_idx++;
577         }
578         if (showwaves->buf_idx == showwaves->w)
579             if ((ret = push_frame(outlink)) < 0)
580                 break;
581         outpicref = showwaves->outpicref;
582     }
583
584 end:
585     av_frame_free(&insamples);
586     return ret;
587 }
588
589 static const AVFilterPad showwaves_inputs[] = {
590     {
591         .name         = "default",
592         .type         = AVMEDIA_TYPE_AUDIO,
593         .filter_frame = showwaves_filter_frame,
594     },
595     { NULL }
596 };
597
598 static const AVFilterPad showwaves_outputs[] = {
599     {
600         .name          = "default",
601         .type          = AVMEDIA_TYPE_VIDEO,
602         .config_props  = config_output,
603         .request_frame = request_frame,
604     },
605     { NULL }
606 };
607
608 AVFilter ff_avf_showwaves = {
609     .name          = "showwaves",
610     .description   = NULL_IF_CONFIG_SMALL("Convert input audio to a video output."),
611     .init          = init,
612     .uninit        = uninit,
613     .query_formats = query_formats,
614     .priv_size     = sizeof(ShowWavesContext),
615     .inputs        = showwaves_inputs,
616     .outputs       = showwaves_outputs,
617     .priv_class    = &showwaves_class,
618 };
619
620 #endif // CONFIG_SHOWWAVES_FILTER
621
622 #if CONFIG_SHOWWAVESPIC_FILTER
623
624 #define OFFSET(x) offsetof(ShowWavesContext, x)
625 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
626
627 static const AVOption showwavespic_options[] = {
628     { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
629     { "s",    "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "600x240"}, 0, 0, FLAGS },
630     { "split_channels", "draw channels separately", OFFSET(split_channels), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
631     { "colors", "set channels colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, FLAGS },
632     { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },
633         { "lin", "linear",         0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},
634         { "log", "logarithmic",    0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},
635     { NULL }
636 };
637
638 AVFILTER_DEFINE_CLASS(showwavespic);
639
640 static int showwavespic_config_input(AVFilterLink *inlink)
641 {
642     AVFilterContext *ctx = inlink->dst;
643     ShowWavesContext *showwaves = ctx->priv;
644
645     if (showwaves->single_pic) {
646         showwaves->sum = av_mallocz_array(inlink->channels, sizeof(*showwaves->sum));
647         if (!showwaves->sum)
648             return AVERROR(ENOMEM);
649     }
650
651     return 0;
652 }
653
654 static int showwavespic_filter_frame(AVFilterLink *inlink, AVFrame *insamples)
655 {
656     AVFilterContext *ctx = inlink->dst;
657     AVFilterLink *outlink = ctx->outputs[0];
658     ShowWavesContext *showwaves = ctx->priv;
659     int16_t *p = (int16_t *)insamples->data[0];
660     int ret = 0;
661
662     if (showwaves->single_pic) {
663         struct frame_node *f;
664
665         ret = alloc_out_frame(showwaves, p, inlink, outlink, insamples);
666         if (ret < 0)
667             goto end;
668
669         /* queue the audio frame */
670         f = av_malloc(sizeof(*f));
671         if (!f) {
672             ret = AVERROR(ENOMEM);
673             goto end;
674         }
675         f->frame = insamples;
676         f->next = NULL;
677         if (!showwaves->last_frame) {
678             showwaves->audio_frames =
679             showwaves->last_frame   = f;
680         } else {
681             showwaves->last_frame->next = f;
682             showwaves->last_frame = f;
683         }
684         showwaves->total_samples += insamples->nb_samples;
685
686         return 0;
687     }
688
689 end:
690     av_frame_free(&insamples);
691     return ret;
692 }
693
694 static const AVFilterPad showwavespic_inputs[] = {
695     {
696         .name         = "default",
697         .type         = AVMEDIA_TYPE_AUDIO,
698         .config_props = showwavespic_config_input,
699         .filter_frame = showwavespic_filter_frame,
700     },
701     { NULL }
702 };
703
704 static const AVFilterPad showwavespic_outputs[] = {
705     {
706         .name          = "default",
707         .type          = AVMEDIA_TYPE_VIDEO,
708         .config_props  = config_output,
709         .request_frame = request_frame,
710     },
711     { NULL }
712 };
713
714 AVFilter ff_avf_showwavespic = {
715     .name          = "showwavespic",
716     .description   = NULL_IF_CONFIG_SMALL("Convert input audio to a video output single picture."),
717     .init          = init,
718     .uninit        = uninit,
719     .query_formats = query_formats,
720     .priv_size     = sizeof(ShowWavesContext),
721     .inputs        = showwavespic_inputs,
722     .outputs       = showwavespic_outputs,
723     .priv_class    = &showwavespic_class,
724 };
725
726 #endif // CONFIG_SHOWWAVESPIC_FILTER