avfilter/vf_waveform: only use available components
[ffmpeg.git] / libavfilter / vf_waveform.c
1 /*
2  * Copyright (c) 2012-2015 Paul B Mahol
3  * Copyright (c) 2013 Marton Balint
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/parseutils.h"
25 #include "libavutil/pixdesc.h"
26 #include "avfilter.h"
27 #include "formats.h"
28 #include "internal.h"
29 #include "video.h"
30
31 enum FilterType {
32     LOWPASS,
33     FLAT,
34     AFLAT,
35     CHROMA,
36     ACHROMA,
37     COLOR,
38     NB_FILTERS
39 };
40
41 typedef struct WaveformContext {
42     const AVClass *class;
43     int            mode;
44     int            ncomp;
45     int            pcomp;
46     const uint8_t  *bg_color;
47     float          fintensity;
48     int            intensity;
49     int            mirror;
50     int            display;
51     int            envelope;
52     int            estart[4];
53     int            eend[4];
54     int            *emax[4][4];
55     int            *emin[4][4];
56     int            *peak;
57     int            filter;
58     int            bits;
59     int            max;
60     int            size;
61     void (*waveform)(struct WaveformContext *s, AVFrame *in, AVFrame *out,
62                      int component, int intensity, int offset, int column);
63     const AVPixFmtDescriptor *desc;
64 } WaveformContext;
65
66 #define OFFSET(x) offsetof(WaveformContext, x)
67 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
68
69 static const AVOption waveform_options[] = {
70     { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "mode" },
71     { "m",    "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "mode" },
72         { "row",    NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" },
73         { "column", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" },
74     { "intensity", "set intensity", OFFSET(fintensity), AV_OPT_TYPE_FLOAT, {.dbl=0.04}, 0, 1, FLAGS },
75     { "i",         "set intensity", OFFSET(fintensity), AV_OPT_TYPE_FLOAT, {.dbl=0.04}, 0, 1, FLAGS },
76     { "mirror", "set mirroring", OFFSET(mirror), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
77     { "r",      "set mirroring", OFFSET(mirror), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
78     { "display", "set display mode", OFFSET(display), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "display" },
79     { "d",       "set display mode", OFFSET(display), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "display" },
80         { "overlay", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "display" },
81         { "parade",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "display" },
82     { "components", "set components to display", OFFSET(pcomp), AV_OPT_TYPE_INT, {.i64=1}, 1, 15, FLAGS },
83     { "c",          "set components to display", OFFSET(pcomp), AV_OPT_TYPE_INT, {.i64=1}, 1, 15, FLAGS },
84     { "envelope", "set envelope to display", OFFSET(envelope), AV_OPT_TYPE_INT, {.i64=0}, 0, 3, FLAGS, "envelope" },
85     { "e",        "set envelope to display", OFFSET(envelope), AV_OPT_TYPE_INT, {.i64=0}, 0, 3, FLAGS, "envelope" },
86         { "none",         NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "envelope" },
87         { "instant",      NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "envelope" },
88         { "peak",         NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "envelope" },
89         { "peak+instant", NULL, 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, "envelope" },
90     { "filter", "set filter", OFFSET(filter), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_FILTERS-1, FLAGS, "filter" },
91     { "f",      "set filter", OFFSET(filter), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_FILTERS-1, FLAGS, "filter" },
92         { "lowpass", NULL, 0, AV_OPT_TYPE_CONST, {.i64=LOWPASS}, 0, 0, FLAGS, "filter" },
93         { "flat"   , NULL, 0, AV_OPT_TYPE_CONST, {.i64=FLAT},    0, 0, FLAGS, "filter" },
94         { "aflat"  , NULL, 0, AV_OPT_TYPE_CONST, {.i64=AFLAT},   0, 0, FLAGS, "filter" },
95         { "chroma",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=CHROMA},  0, 0, FLAGS, "filter" },
96         { "achroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ACHROMA}, 0, 0, FLAGS, "filter" },
97         { "color",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=COLOR},   0, 0, FLAGS, "filter" },
98     { NULL }
99 };
100
101 AVFILTER_DEFINE_CLASS(waveform);
102
103 static const enum AVPixelFormat lowpass_pix_fmts[] = {
104     AV_PIX_FMT_GBRP,     AV_PIX_FMT_GBRAP,
105     AV_PIX_FMT_GBRP9,    AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
106     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
107     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
108     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
109     AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
110     AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
111     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
112     AV_PIX_FMT_GRAY8,
113     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
114     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
115     AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
116     AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
117     AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV440P12,
118     AV_PIX_FMT_NONE
119 };
120
121 static const enum AVPixelFormat flat_pix_fmts[] = {
122     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
123 };
124
125 static const enum AVPixelFormat color_pix_fmts[] = {
126     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
127     AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
128     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
129     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
130     AV_PIX_FMT_YUV444P12,
131     AV_PIX_FMT_NONE
132 };
133
134 static int query_formats(AVFilterContext *ctx)
135 {
136     WaveformContext *s = ctx->priv;
137     AVFilterFormats *fmts_list;
138     const enum AVPixelFormat *pix_fmts;
139
140     switch (s->filter) {
141     case LOWPASS: pix_fmts = lowpass_pix_fmts; break;
142     case FLAT:
143     case AFLAT:
144     case CHROMA:
145     case ACHROMA: pix_fmts = flat_pix_fmts;    break;
146     case COLOR:   pix_fmts = color_pix_fmts;   break;
147     }
148
149     fmts_list = ff_make_format_list(pix_fmts);
150     if (!fmts_list)
151         return AVERROR(ENOMEM);
152     return ff_set_common_formats(ctx, fmts_list);
153 }
154
155 static void envelope_instant16(WaveformContext *s, AVFrame *out, int plane, int component)
156 {
157     const int dst_linesize = out->linesize[component] / 2;
158     const int bg = s->bg_color[component] * (s->max / 256);
159     const int limit = s->max - 1;
160     const int is_chroma = (component == 1 || component == 2);
161     const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
162     const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
163     const int dst_h = AV_CEIL_RSHIFT(out->height, shift_h);
164     const int dst_w = AV_CEIL_RSHIFT(out->width, shift_w);
165     const int start = s->estart[plane];
166     const int end = s->eend[plane];
167     uint16_t *dst;
168     int x, y;
169
170     if (s->mode) {
171         for (x = 0; x < dst_w; x++) {
172             for (y = start; y < end; y++) {
173                 dst = (uint16_t *)out->data[component] + y * dst_linesize + x;
174                 if (dst[0] != bg) {
175                     dst[0] = limit;
176                     break;
177                 }
178             }
179             for (y = end - 1; y >= start; y--) {
180                 dst = (uint16_t *)out->data[component] + y * dst_linesize + x;
181                 if (dst[0] != bg) {
182                     dst[0] = limit;
183                     break;
184                 }
185             }
186         }
187     } else {
188         for (y = 0; y < dst_h; y++) {
189             dst = (uint16_t *)out->data[component] + y * dst_linesize;
190             for (x = start; x < end; x++) {
191                 if (dst[x] != bg) {
192                     dst[x] = limit;
193                     break;
194                 }
195             }
196             for (x = end - 1; x >= start; x--) {
197                 if (dst[x] != bg) {
198                     dst[x] = limit;
199                     break;
200                 }
201             }
202         }
203     }
204 }
205
206 static void envelope_instant(WaveformContext *s, AVFrame *out, int plane, int component)
207 {
208     const int dst_linesize = out->linesize[component];
209     const uint8_t bg = s->bg_color[component];
210     const int is_chroma = (component == 1 || component == 2);
211     const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
212     const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
213     const int dst_h = AV_CEIL_RSHIFT(out->height, shift_h);
214     const int dst_w = AV_CEIL_RSHIFT(out->width, shift_w);
215     const int start = s->estart[plane];
216     const int end = s->eend[plane];
217     uint8_t *dst;
218     int x, y;
219
220     if (s->mode) {
221         for (x = 0; x < dst_w; x++) {
222             for (y = start; y < end; y++) {
223                 dst = out->data[component] + y * dst_linesize + x;
224                 if (dst[0] != bg) {
225                     dst[0] = 255;
226                     break;
227                 }
228             }
229             for (y = end - 1; y >= start; y--) {
230                 dst = out->data[component] + y * dst_linesize + x;
231                 if (dst[0] != bg) {
232                     dst[0] = 255;
233                     break;
234                 }
235             }
236         }
237     } else {
238         for (y = 0; y < dst_h; y++) {
239             dst = out->data[component] + y * dst_linesize;
240             for (x = start; x < end; x++) {
241                 if (dst[x] != bg) {
242                     dst[x] = 255;
243                     break;
244                 }
245             }
246             for (x = end - 1; x >= start; x--) {
247                 if (dst[x] != bg) {
248                     dst[x] = 255;
249                     break;
250                 }
251             }
252         }
253     }
254 }
255
256 static void envelope_peak16(WaveformContext *s, AVFrame *out, int plane, int component)
257 {
258     const int dst_linesize = out->linesize[component] / 2;
259     const int bg = s->bg_color[component] * (s->max / 256);
260     const int limit = s->max - 1;
261     const int is_chroma = (component == 1 || component == 2);
262     const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
263     const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
264     const int dst_h = AV_CEIL_RSHIFT(out->height, shift_h);
265     const int dst_w = AV_CEIL_RSHIFT(out->width, shift_w);
266     const int start = s->estart[plane];
267     const int end = s->eend[plane];
268     int *emax = s->emax[plane][component];
269     int *emin = s->emin[plane][component];
270     uint16_t *dst;
271     int x, y;
272
273     if (s->mode) {
274         for (x = 0; x < dst_w; x++) {
275             for (y = start; y < end && y < emin[x]; y++) {
276                 dst = (uint16_t *)out->data[component] + y * dst_linesize + x;
277                 if (dst[0] != bg) {
278                     emin[x] = y;
279                     break;
280                 }
281             }
282             for (y = end - 1; y >= start && y >= emax[x]; y--) {
283                 dst = (uint16_t *)out->data[component] + y * dst_linesize + x;
284                 if (dst[0] != bg) {
285                     emax[x] = y;
286                     break;
287                 }
288             }
289         }
290
291         if (s->envelope == 3)
292             envelope_instant16(s, out, plane, component);
293
294         for (x = 0; x < dst_w; x++) {
295             dst = (uint16_t *)out->data[component] + emin[x] * dst_linesize + x;
296             dst[0] = limit;
297             dst = (uint16_t *)out->data[component] + emax[x] * dst_linesize + x;
298             dst[0] = limit;
299         }
300     } else {
301         for (y = 0; y < dst_h; y++) {
302             dst = (uint16_t *)out->data[component] + y * dst_linesize;
303             for (x = start; x < end && x < emin[y]; x++) {
304                 if (dst[x] != bg) {
305                     emin[y] = x;
306                     break;
307                 }
308             }
309             for (x = end - 1; x >= start && x >= emax[y]; x--) {
310                 if (dst[x] != bg) {
311                     emax[y] = x;
312                     break;
313                 }
314             }
315         }
316
317         if (s->envelope == 3)
318             envelope_instant16(s, out, plane, component);
319
320         for (y = 0; y < dst_h; y++) {
321             dst = (uint16_t *)out->data[component] + y * dst_linesize + emin[y];
322             dst[0] = limit;
323             dst = (uint16_t *)out->data[component] + y * dst_linesize + emax[y];
324             dst[0] = limit;
325         }
326     }
327 }
328
329 static void envelope_peak(WaveformContext *s, AVFrame *out, int plane, int component)
330 {
331     const int dst_linesize = out->linesize[component];
332     const int bg = s->bg_color[component];
333     const int is_chroma = (component == 1 || component == 2);
334     const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
335     const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
336     const int dst_h = AV_CEIL_RSHIFT(out->height, shift_h);
337     const int dst_w = AV_CEIL_RSHIFT(out->width, shift_w);
338     const int start = s->estart[plane];
339     const int end = s->eend[plane];
340     int *emax = s->emax[plane][component];
341     int *emin = s->emin[plane][component];
342     uint8_t *dst;
343     int x, y;
344
345     if (s->mode) {
346         for (x = 0; x < dst_w; x++) {
347             for (y = start; y < end && y < emin[x]; y++) {
348                 dst = out->data[component] + y * dst_linesize + x;
349                 if (dst[0] != bg) {
350                     emin[x] = y;
351                     break;
352                 }
353             }
354             for (y = end - 1; y >= start && y >= emax[x]; y--) {
355                 dst = out->data[component] + y * dst_linesize + x;
356                 if (dst[0] != bg) {
357                     emax[x] = y;
358                     break;
359                 }
360             }
361         }
362
363         if (s->envelope == 3)
364             envelope_instant(s, out, plane, component);
365
366         for (x = 0; x < dst_w; x++) {
367             dst = out->data[component] + emin[x] * dst_linesize + x;
368             dst[0] = 255;
369             dst = out->data[component] + emax[x] * dst_linesize + x;
370             dst[0] = 255;
371         }
372     } else {
373         for (y = 0; y < dst_h; y++) {
374             dst = out->data[component] + y * dst_linesize;
375             for (x = start; x < end && x < emin[y]; x++) {
376                 if (dst[x] != bg) {
377                     emin[y] = x;
378                     break;
379                 }
380             }
381             for (x = end - 1; x >= start && x >= emax[y]; x--) {
382                 if (dst[x] != bg) {
383                     emax[y] = x;
384                     break;
385                 }
386             }
387         }
388
389         if (s->envelope == 3)
390             envelope_instant(s, out, plane, component);
391
392         for (y = 0; y < dst_h; y++) {
393             dst = out->data[component] + y * dst_linesize + emin[y];
394             dst[0] = 255;
395             dst = out->data[component] + y * dst_linesize + emax[y];
396             dst[0] = 255;
397         }
398     }
399 }
400
401 static void envelope16(WaveformContext *s, AVFrame *out, int plane, int component)
402 {
403     if (s->envelope == 0) {
404         return;
405     } else if (s->envelope == 1) {
406         envelope_instant16(s, out, plane, component);
407     } else {
408         envelope_peak16(s, out, plane, component);
409     }
410 }
411
412 static void envelope(WaveformContext *s, AVFrame *out, int plane, int component)
413 {
414     if (s->envelope == 0) {
415         return;
416     } else if (s->envelope == 1) {
417         envelope_instant(s, out, plane, component);
418     } else {
419         envelope_peak(s, out, plane, component);
420     }
421 }
422
423 static void update16(uint16_t *target, int max, int intensity, int limit)
424 {
425     if (*target <= max)
426         *target += intensity;
427     else
428         *target = limit;
429 }
430
431 static void update(uint8_t *target, int max, int intensity)
432 {
433     if (*target <= max)
434         *target += intensity;
435     else
436         *target = 255;
437 }
438
439 static void lowpass16(WaveformContext *s, AVFrame *in, AVFrame *out,
440                       int component, int intensity, int offset, int column)
441 {
442     const int plane = s->desc->comp[component].plane;
443     const int mirror = s->mirror;
444     const int is_chroma = (component == 1 || component == 2);
445     const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
446     const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
447     const int src_linesize = in->linesize[plane] / 2;
448     const int dst_linesize = out->linesize[plane] / 2;
449     const int dst_signed_linesize = dst_linesize * (mirror == 1 ? -1 : 1);
450     const int limit = s->max - 1;
451     const int max = limit - intensity;
452     const int src_h = AV_CEIL_RSHIFT(in->height, shift_h);
453     const int src_w = AV_CEIL_RSHIFT(in->width, shift_w);
454     const uint16_t *src_data = (const uint16_t *)in->data[plane];
455     uint16_t *dst_data = (uint16_t *)out->data[plane] + (column ? (offset >> shift_h) * dst_linesize : offset >> shift_w);
456     uint16_t * const dst_bottom_line = dst_data + dst_linesize * ((s->size >> shift_h) - 1);
457     uint16_t * const dst_line = (mirror ? dst_bottom_line : dst_data);
458     const uint16_t *p;
459     int y;
460
461     if (!column && mirror)
462         dst_data += s->size >> shift_w;
463
464     for (y = 0; y < src_h; y++) {
465         const uint16_t *src_data_end = src_data + src_w;
466         uint16_t *dst = dst_line;
467
468         for (p = src_data; p < src_data_end; p++) {
469             uint16_t *target;
470             int v = FFMIN(*p, limit);
471
472             if (column) {
473                 target = dst++ + dst_signed_linesize * (v >> shift_h);
474             } else {
475                 if (mirror)
476                     target = dst_data - (v >> shift_w) - 1;
477                 else
478                     target = dst_data + (v >> shift_w);
479             }
480             update16(target, max, intensity, limit);
481         }
482         src_data += src_linesize;
483         dst_data += dst_linesize;
484     }
485
486     envelope16(s, out, plane, plane);
487 }
488
489 static void lowpass(WaveformContext *s, AVFrame *in, AVFrame *out,
490                     int component, int intensity, int offset, int column)
491 {
492     const int plane = s->desc->comp[component].plane;
493     const int mirror = s->mirror;
494     const int is_chroma = (component == 1 || component == 2);
495     const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
496     const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
497     const int src_linesize = in->linesize[plane];
498     const int dst_linesize = out->linesize[plane];
499     const int dst_signed_linesize = dst_linesize * (mirror == 1 ? -1 : 1);
500     const int max = 255 - intensity;
501     const int src_h = AV_CEIL_RSHIFT(in->height, shift_h);
502     const int src_w = AV_CEIL_RSHIFT(in->width, shift_w);
503     const uint8_t *src_data = in->data[plane];
504     uint8_t *dst_data = out->data[plane] + (column ? (offset >> shift_h) * dst_linesize : offset >> shift_w);
505     uint8_t * const dst_bottom_line = dst_data + dst_linesize * ((s->size >> shift_h) - 1);
506     uint8_t * const dst_line = (mirror ? dst_bottom_line : dst_data);
507     const uint8_t *p;
508     int y;
509
510     if (!column && mirror)
511         dst_data += s->size >> shift_w;
512
513     for (y = 0; y < src_h; y++) {
514         const uint8_t *src_data_end = src_data + src_w;
515         uint8_t *dst = dst_line;
516
517         for (p = src_data; p < src_data_end; p++) {
518             uint8_t *target;
519             if (column) {
520                 target = dst++ + dst_signed_linesize * (*p >> shift_h);
521             } else {
522                 if (mirror)
523                     target = dst_data - (*p >> shift_w) - 1;
524                 else
525                     target = dst_data + (*p >> shift_w);
526             }
527             update(target, max, intensity);
528         }
529         src_data += src_linesize;
530         dst_data += dst_linesize;
531     }
532
533     envelope(s, out, plane, plane);
534 }
535
536 static void flat(WaveformContext *s, AVFrame *in, AVFrame *out,
537                  int component, int intensity, int offset, int column)
538 {
539     const int plane = s->desc->comp[component].plane;
540     const int mirror = s->mirror;
541     const int c0_linesize = in->linesize[ plane + 0 ];
542     const int c1_linesize = in->linesize[(plane + 1) % s->ncomp];
543     const int c2_linesize = in->linesize[(plane + 2) % s->ncomp];
544     const int d0_linesize = out->linesize[ plane + 0 ];
545     const int d1_linesize = out->linesize[(plane + 1) % s->ncomp];
546     const int max = 255 - intensity;
547     const int src_h = in->height;
548     const int src_w = in->width;
549     int x, y;
550
551     if (column) {
552         const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
553         const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
554
555         for (x = 0; x < src_w; x++) {
556             const uint8_t *c0_data = in->data[plane + 0];
557             const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
558             const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
559             uint8_t *d0_data = out->data[plane] + offset * d0_linesize;
560             uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;
561             uint8_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1);
562             uint8_t * const d0 = (mirror ? d0_bottom_line : d0_data);
563             uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);
564             uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data);
565
566             for (y = 0; y < src_h; y++) {
567                 const int c0 = c0_data[x] + 256;
568                 const int c1 = FFABS(c1_data[x] - 128) + FFABS(c2_data[x] - 128);
569                 uint8_t *target;
570
571                 target = d0 + x + d0_signed_linesize * c0;
572                 update(target, max, intensity);
573                 target = d1 + x + d1_signed_linesize * (c0 - c1);
574                 update(target, max, 1);
575                 target = d1 + x + d1_signed_linesize * (c0 + c1);
576                 update(target, max, 1);
577
578                 c0_data += c0_linesize;
579                 c1_data += c1_linesize;
580                 c2_data += c2_linesize;
581                 d0_data += d0_linesize;
582                 d1_data += d1_linesize;
583             }
584         }
585     } else {
586         const uint8_t *c0_data = in->data[plane];
587         const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
588         const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
589         uint8_t *d0_data = out->data[plane] + offset;
590         uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset;
591
592         if (mirror) {
593             d0_data += s->size - 1;
594             d1_data += s->size - 1;
595         }
596
597         for (y = 0; y < src_h; y++) {
598             for (x = 0; x < src_w; x++) {
599                 int c0 = c0_data[x] + 256;
600                 const int c1 = FFABS(c1_data[x] - 128) + FFABS(c2_data[x] - 128);
601                 uint8_t *target;
602
603                 if (mirror) {
604                     target = d0_data - c0;
605                     update(target, max, intensity);
606                     target = d1_data - (c0 - c1);
607                     update(target, max, 1);
608                     target = d1_data - (c0 + c1);
609                     update(target, max, 1);
610                 } else {
611                     target = d0_data + c0;
612                     update(target, max, intensity);
613                     target = d1_data + (c0 - c1);
614                     update(target, max, 1);
615                     target = d1_data + (c0 + c1);
616                     update(target, max, 1);
617                 }
618             }
619
620             c0_data += c0_linesize;
621             c1_data += c1_linesize;
622             c2_data += c2_linesize;
623             d0_data += d0_linesize;
624             d1_data += d1_linesize;
625         }
626     }
627
628     envelope(s, out, plane, plane);
629     envelope(s, out, plane, (plane + 1) % s->ncomp);
630 }
631
632 static void aflat(WaveformContext *s, AVFrame *in, AVFrame *out,
633                   int component, int intensity, int offset, int column)
634 {
635     const int plane = s->desc->comp[component].plane;
636     const int mirror = s->mirror;
637     const int c0_linesize = in->linesize[ plane + 0 ];
638     const int c1_linesize = in->linesize[(plane + 1) % s->ncomp];
639     const int c2_linesize = in->linesize[(plane + 2) % s->ncomp];
640     const int d0_linesize = out->linesize[ plane + 0 ];
641     const int d1_linesize = out->linesize[(plane + 1) % s->ncomp];
642     const int d2_linesize = out->linesize[(plane + 2) % s->ncomp];
643     const int max = 255 - intensity;
644     const int src_h = in->height;
645     const int src_w = in->width;
646     int x, y;
647
648     if (column) {
649         const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
650         const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
651         const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
652
653         for (x = 0; x < src_w; x++) {
654             const uint8_t *c0_data = in->data[plane + 0];
655             const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
656             const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
657             uint8_t *d0_data = out->data[plane] + offset * d0_linesize;
658             uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;
659             uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset * d2_linesize;
660             uint8_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1);
661             uint8_t * const d0 = (mirror ? d0_bottom_line : d0_data);
662             uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);
663             uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data);
664             uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1);
665             uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data);
666
667             for (y = 0; y < src_h; y++) {
668                 const int c0 = c0_data[x] + 128;
669                 const int c1 = c1_data[x] - 128;
670                 const int c2 = c2_data[x] - 128;
671                 uint8_t *target;
672
673                 target = d0 + x + d0_signed_linesize * c0;
674                 update(target, max, intensity);
675
676                 target = d1 + x + d1_signed_linesize * (c0 + c1);
677                 update(target, max, 1);
678
679                 target = d2 + x + d2_signed_linesize * (c0 + c2);
680                 update(target, max, 1);
681
682                 c0_data += c0_linesize;
683                 c1_data += c1_linesize;
684                 c2_data += c2_linesize;
685                 d0_data += d0_linesize;
686                 d1_data += d1_linesize;
687                 d2_data += d2_linesize;
688             }
689         }
690     } else {
691         const uint8_t *c0_data = in->data[plane];
692         const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
693         const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
694         uint8_t *d0_data = out->data[plane] + offset;
695         uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset;
696         uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset;
697
698         if (mirror) {
699             d0_data += s->size - 1;
700             d1_data += s->size - 1;
701             d2_data += s->size - 1;
702         }
703
704         for (y = 0; y < src_h; y++) {
705             for (x = 0; x < src_w; x++) {
706                 const int c0 = c0_data[x] + 128;
707                 const int c1 = c1_data[x] - 128;
708                 const int c2 = c2_data[x] - 128;
709                 uint8_t *target;
710
711                 if (mirror) {
712                     target = d0_data - c0;
713                     update(target, max, intensity);
714                     target = d1_data - (c0 + c1);
715                     update(target, max, 1);
716                     target = d2_data - (c0 + c2);
717                     update(target, max, 1);
718                 } else {
719                     target = d0_data + c0;
720                     update(target, max, intensity);
721                     target = d1_data + (c0 + c1);
722                     update(target, max, 1);
723                     target = d2_data + (c0 + c2);
724                     update(target, max, 1);
725                 }
726             }
727
728             c0_data += c0_linesize;
729             c1_data += c1_linesize;
730             c2_data += c2_linesize;
731             d0_data += d0_linesize;
732             d1_data += d1_linesize;
733             d2_data += d2_linesize;
734         }
735     }
736
737     envelope(s, out, plane, (plane + 0) % s->ncomp);
738     envelope(s, out, plane, (plane + 1) % s->ncomp);
739     envelope(s, out, plane, (plane + 2) % s->ncomp);
740 }
741
742 static void chroma(WaveformContext *s, AVFrame *in, AVFrame *out,
743                    int component, int intensity, int offset, int column)
744 {
745     const int plane = s->desc->comp[component].plane;
746     const int mirror = s->mirror;
747     const int c0_linesize = in->linesize[(plane + 1) % s->ncomp];
748     const int c1_linesize = in->linesize[(plane + 2) % s->ncomp];
749     const int dst_linesize = out->linesize[plane];
750     const int max = 255 - intensity;
751     const int src_h = in->height;
752     const int src_w = in->width;
753     int x, y;
754
755     if (column) {
756         const int dst_signed_linesize = dst_linesize * (mirror == 1 ? -1 : 1);
757
758         for (x = 0; x < src_w; x++) {
759             const uint8_t *c0_data = in->data[(plane + 1) % s->ncomp];
760             const uint8_t *c1_data = in->data[(plane + 2) % s->ncomp];
761             uint8_t *dst_data = out->data[plane] + offset * dst_linesize;
762             uint8_t * const dst_bottom_line = dst_data + dst_linesize * (s->size - 1);
763             uint8_t * const dst_line = (mirror ? dst_bottom_line : dst_data);
764             uint8_t *dst = dst_line;
765
766             for (y = 0; y < src_h; y++) {
767                 const int sum = FFABS(c0_data[x] - 128) + FFABS(c1_data[x] - 128);
768                 uint8_t *target;
769
770                 target = dst + x + dst_signed_linesize * (256 - sum);
771                 update(target, max, intensity);
772                 target = dst + x + dst_signed_linesize * (255 + sum);
773                 update(target, max, intensity);
774
775                 c0_data += c0_linesize;
776                 c1_data += c1_linesize;
777                 dst_data += dst_linesize;
778             }
779         }
780     } else {
781         const uint8_t *c0_data = in->data[(plane + 1) % s->ncomp];
782         const uint8_t *c1_data = in->data[(plane + 2) % s->ncomp];
783         uint8_t *dst_data = out->data[plane] + offset;
784
785         if (mirror)
786             dst_data += s->size - 1;
787         for (y = 0; y < src_h; y++) {
788             for (x = 0; x < src_w; x++) {
789                 const int sum = FFABS(c0_data[x] - 128) + FFABS(c1_data[x] - 128);
790                 uint8_t *target;
791
792                 if (mirror) {
793                     target = dst_data - (256 - sum);
794                     update(target, max, intensity);
795                     target = dst_data - (255 + sum);
796                     update(target, max, intensity);
797                 } else {
798                     target = dst_data + (256 - sum);
799                     update(target, max, intensity);
800                     target = dst_data + (255 + sum);
801                     update(target, max, intensity);
802                 }
803             }
804
805             c0_data += c0_linesize;
806             c1_data += c1_linesize;
807             dst_data += dst_linesize;
808         }
809     }
810
811     envelope(s, out, plane, (plane + 0) % s->ncomp);
812 }
813
814 static void achroma(WaveformContext *s, AVFrame *in, AVFrame *out,
815                     int component, int intensity, int offset, int column)
816 {
817     const int plane = s->desc->comp[component].plane;
818     const int mirror = s->mirror;
819     const int c1_linesize = in->linesize[(plane + 1) % s->ncomp];
820     const int c2_linesize = in->linesize[(plane + 2) % s->ncomp];
821     const int d1_linesize = out->linesize[(plane + 1) % s->ncomp];
822     const int d2_linesize = out->linesize[(plane + 2) % s->ncomp];
823     const int max = 255 - intensity;
824     const int src_h = in->height;
825     const int src_w = in->width;
826     int x, y;
827
828     if (column) {
829         const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
830         const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
831
832         for (x = 0; x < src_w; x++) {
833             const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
834             const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
835             uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;
836             uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset * d2_linesize;
837             uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);
838             uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data);
839             uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1);
840             uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data);
841
842             for (y = 0; y < src_h; y++) {
843                 const int c1 = c1_data[x] - 128;
844                 const int c2 = c2_data[x] - 128;
845                 uint8_t *target;
846
847                 target = d1 + x + d1_signed_linesize * (128 + c1);
848                 update(target, max, intensity);
849
850                 target = d2 + x + d2_signed_linesize * (128 + c2);
851                 update(target, max, intensity);
852
853                 c1_data += c1_linesize;
854                 c2_data += c2_linesize;
855                 d1_data += d1_linesize;
856                 d2_data += d2_linesize;
857             }
858         }
859     } else {
860         const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
861         const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
862         uint8_t *d0_data = out->data[plane] + offset;
863         uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset;
864         uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset;
865
866         if (mirror) {
867             d0_data += s->size - 1;
868             d1_data += s->size - 1;
869             d2_data += s->size - 1;
870         }
871
872         for (y = 0; y < src_h; y++) {
873             for (x = 0; x < src_w; x++) {
874                 const int c1 = c1_data[x] - 128;
875                 const int c2 = c2_data[x] - 128;
876                 uint8_t *target;
877
878                 if (mirror) {
879                     target = d1_data - (128 + c1);
880                     update(target, max, intensity);
881                     target = d2_data - (128 + c2);
882                     update(target, max, intensity);
883                 } else {
884                     target = d1_data + (128 + c1);
885                     update(target, max, intensity);
886                     target = d2_data + (128 + c2);
887                     update(target, max, intensity);
888                 }
889             }
890
891             c1_data += c1_linesize;
892             c2_data += c2_linesize;
893             d1_data += d1_linesize;
894             d2_data += d2_linesize;
895         }
896     }
897
898     envelope(s, out, plane, (plane + 1) % s->ncomp);
899     envelope(s, out, plane, (plane + 2) % s->ncomp);
900 }
901
902 static void color16(WaveformContext *s, AVFrame *in, AVFrame *out,
903                     int component, int intensity, int offset, int column)
904 {
905     const int plane = s->desc->comp[component].plane;
906     const int mirror = s->mirror;
907     const int limit = s->max - 1;
908     const uint16_t *c0_data = (const uint16_t *)in->data[plane + 0];
909     const uint16_t *c1_data = (const uint16_t *)in->data[(plane + 1) % s->ncomp];
910     const uint16_t *c2_data = (const uint16_t *)in->data[(plane + 2) % s->ncomp];
911     const int c0_linesize = in->linesize[ plane + 0 ] / 2;
912     const int c1_linesize = in->linesize[(plane + 1) % s->ncomp] / 2;
913     const int c2_linesize = in->linesize[(plane + 2) % s->ncomp] / 2;
914     const int d0_linesize = out->linesize[ plane + 0 ] / 2;
915     const int d1_linesize = out->linesize[(plane + 1) % s->ncomp] / 2;
916     const int d2_linesize = out->linesize[(plane + 2) % s->ncomp] / 2;
917     const int src_h = in->height;
918     const int src_w = in->width;
919     int x, y;
920
921     if (s->mode) {
922         const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
923         const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
924         const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
925         uint16_t *d0_data = (uint16_t *)out->data[plane] + offset * d0_linesize;
926         uint16_t *d1_data = (uint16_t *)out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;
927         uint16_t *d2_data = (uint16_t *)out->data[(plane + 2) % s->ncomp] + offset * d2_linesize;
928         uint16_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1);
929         uint16_t * const d0 = (mirror ? d0_bottom_line : d0_data);
930         uint16_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);
931         uint16_t * const d1 = (mirror ? d1_bottom_line : d1_data);
932         uint16_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1);
933         uint16_t * const d2 = (mirror ? d2_bottom_line : d2_data);
934
935         for (y = 0; y < src_h; y++) {
936             for (x = 0; x < src_w; x++) {
937                 const int c0 = FFMIN(c0_data[x], limit);
938                 const int c1 = c1_data[x];
939                 const int c2 = c2_data[x];
940
941                 *(d0 + d0_signed_linesize * c0 + x) = c0;
942                 *(d1 + d1_signed_linesize * c0 + x) = c1;
943                 *(d2 + d2_signed_linesize * c0 + x) = c2;
944             }
945
946             c0_data += c0_linesize;
947             c1_data += c1_linesize;
948             c2_data += c2_linesize;
949             d0_data += d0_linesize;
950             d1_data += d1_linesize;
951             d2_data += d2_linesize;
952         }
953     } else {
954         uint16_t *d0_data = (uint16_t *)out->data[plane] + offset;
955         uint16_t *d1_data = (uint16_t *)out->data[(plane + 1) % s->ncomp] + offset;
956         uint16_t *d2_data = (uint16_t *)out->data[(plane + 2) % s->ncomp] + offset;
957
958         if (mirror) {
959             d0_data += s->size - 1;
960             d1_data += s->size - 1;
961             d2_data += s->size - 1;
962         }
963
964         for (y = 0; y < src_h; y++) {
965             for (x = 0; x < src_w; x++) {
966                 const int c0 = FFMIN(c0_data[x], limit);
967                 const int c1 = c1_data[x];
968                 const int c2 = c2_data[x];
969
970                 if (mirror) {
971                     *(d0_data - c0) = c0;
972                     *(d1_data - c0) = c1;
973                     *(d2_data - c0) = c2;
974                 } else {
975                     *(d0_data + c0) = c0;
976                     *(d1_data + c0) = c1;
977                     *(d2_data + c0) = c2;
978                 }
979             }
980
981             c0_data += c0_linesize;
982             c1_data += c1_linesize;
983             c2_data += c2_linesize;
984             d0_data += d0_linesize;
985             d1_data += d1_linesize;
986             d2_data += d2_linesize;
987         }
988     }
989
990     envelope16(s, out, plane, plane);
991 }
992
993 static void color(WaveformContext *s, AVFrame *in, AVFrame *out,
994                   int component, int intensity, int offset, int column)
995 {
996     const int plane = s->desc->comp[component].plane;
997     const int mirror = s->mirror;
998     const uint8_t *c0_data = in->data[plane + 0];
999     const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];
1000     const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];
1001     const int c0_linesize = in->linesize[ plane + 0 ];
1002     const int c1_linesize = in->linesize[(plane + 1) % s->ncomp];
1003     const int c2_linesize = in->linesize[(plane + 2) % s->ncomp];
1004     const int d0_linesize = out->linesize[ plane + 0 ];
1005     const int d1_linesize = out->linesize[(plane + 1) % s->ncomp];
1006     const int d2_linesize = out->linesize[(plane + 2) % s->ncomp];
1007     const int src_h = in->height;
1008     const int src_w = in->width;
1009     int x, y;
1010
1011     if (s->mode) {
1012         const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1);
1013         const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);
1014         const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);
1015         uint8_t *d0_data = out->data[plane] + offset * d0_linesize;
1016         uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;
1017         uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset * d2_linesize;
1018         uint8_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1);
1019         uint8_t * const d0 = (mirror ? d0_bottom_line : d0_data);
1020         uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);
1021         uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data);
1022         uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1);
1023         uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data);
1024
1025         for (y = 0; y < src_h; y++) {
1026             for (x = 0; x < src_w; x++) {
1027                 const int c0 = c0_data[x];
1028                 const int c1 = c1_data[x];
1029                 const int c2 = c2_data[x];
1030
1031                 *(d0 + d0_signed_linesize * c0 + x) = c0;
1032                 *(d1 + d1_signed_linesize * c0 + x) = c1;
1033                 *(d2 + d2_signed_linesize * c0 + x) = c2;
1034             }
1035
1036             c0_data += c0_linesize;
1037             c1_data += c1_linesize;
1038             c2_data += c2_linesize;
1039             d0_data += d0_linesize;
1040             d1_data += d1_linesize;
1041             d2_data += d2_linesize;
1042         }
1043     } else {
1044         uint8_t *d0_data = out->data[plane] + offset;
1045         uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset;
1046         uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset;
1047
1048         if (mirror) {
1049             d0_data += s->size - 1;
1050             d1_data += s->size - 1;
1051             d2_data += s->size - 1;
1052         }
1053
1054         for (y = 0; y < src_h; y++) {
1055             for (x = 0; x < src_w; x++) {
1056                 const int c0 = c0_data[x];
1057                 const int c1 = c1_data[x];
1058                 const int c2 = c2_data[x];
1059
1060                 if (mirror) {
1061                     *(d0_data - c0) = c0;
1062                     *(d1_data - c0) = c1;
1063                     *(d2_data - c0) = c2;
1064                 } else {
1065                     *(d0_data + c0) = c0;
1066                     *(d1_data + c0) = c1;
1067                     *(d2_data + c0) = c2;
1068                 }
1069             }
1070
1071             c0_data += c0_linesize;
1072             c1_data += c1_linesize;
1073             c2_data += c2_linesize;
1074             d0_data += d0_linesize;
1075             d1_data += d1_linesize;
1076             d2_data += d2_linesize;
1077         }
1078     }
1079
1080     envelope(s, out, plane, plane);
1081 }
1082
1083 static const uint8_t black_yuva_color[4] = { 0, 127, 127, 255 };
1084 static const uint8_t black_gbrp_color[4] = { 0, 0, 0, 255 };
1085
1086 static int config_input(AVFilterLink *inlink)
1087 {
1088     AVFilterContext *ctx = inlink->dst;
1089     WaveformContext *s = ctx->priv;
1090
1091     s->desc  = av_pix_fmt_desc_get(inlink->format);
1092     s->ncomp = s->desc->nb_components;
1093     s->bits = s->desc->comp[0].depth;
1094     s->max = 1 << s->bits;
1095     s->intensity = s->fintensity * (s->max - 1);
1096
1097     switch (s->filter) {
1098     case LOWPASS:
1099             s->size = 256;
1100             s->waveform = s->bits > 8 ? lowpass16 : lowpass; break;
1101     case FLAT:
1102             s->size = 256 * 3;
1103             s->waveform = flat;    break;
1104     case AFLAT:
1105             s->size = 256 * 2;
1106             s->waveform = aflat;   break;
1107     case CHROMA:
1108             s->size = 256 * 2;
1109             s->waveform = chroma;  break;
1110     case ACHROMA:
1111             s->size = 256;
1112             s->waveform = achroma; break;
1113     case COLOR:
1114             s->size = 256;
1115             s->waveform = s->bits > 8 ?   color16 :   color; break;
1116     }
1117
1118     s->size = s->size << (s->bits - 8);
1119
1120     switch (inlink->format) {
1121     case AV_PIX_FMT_GBRAP:
1122     case AV_PIX_FMT_GBRP:
1123     case AV_PIX_FMT_GBRP9:
1124     case AV_PIX_FMT_GBRP10:
1125     case AV_PIX_FMT_GBRP12:
1126         s->bg_color = black_gbrp_color;
1127         break;
1128     default:
1129         s->bg_color = black_yuva_color;
1130     }
1131
1132     return 0;
1133 }
1134
1135 static int config_output(AVFilterLink *outlink)
1136 {
1137     AVFilterContext *ctx = outlink->src;
1138     AVFilterLink *inlink = ctx->inputs[0];
1139     WaveformContext *s = ctx->priv;
1140     int comp = 0, i, j = 0, k, p, size, shift;
1141
1142     for (i = 0; i < s->ncomp; i++) {
1143         if ((1 << i) & s->pcomp)
1144             comp++;
1145     }
1146
1147     av_freep(&s->peak);
1148
1149     if (s->mode) {
1150         outlink->h = s->size * FFMAX(comp * s->display, 1);
1151         size = inlink->w;
1152     } else {
1153         outlink->w = s->size * FFMAX(comp * s->display, 1);
1154         size = inlink->h;
1155     }
1156
1157     s->peak = av_malloc_array(size, 32 * sizeof(*s->peak));
1158     if (!s->peak)
1159         return AVERROR(ENOMEM);
1160
1161     for (p = 0; p < s->ncomp; p++) {
1162         const int is_chroma = (p == 1 || p == 2);
1163         const int shift_w = (is_chroma ? s->desc->log2_chroma_w : 0);
1164         const int shift_h = (is_chroma ? s->desc->log2_chroma_h : 0);
1165         const int plane = s->desc->comp[p].plane;
1166         int offset;
1167
1168         if (!((1 << p) & s->pcomp))
1169             continue;
1170
1171         shift = s->mode ? shift_h : shift_w;
1172
1173         for (k = 0; k < 4; k++) {
1174             s->emax[plane][k] = s->peak + size * (plane * 4 + k + 0);
1175             s->emin[plane][k] = s->peak + size * (plane * 4 + k + 16);
1176         }
1177
1178         offset = j++ * s->size * s->display;
1179         s->estart[plane] = offset >> shift;
1180         s->eend[plane]   = (offset + s->size - 1) >> shift;
1181         for (i = 0; i < size; i++) {
1182             for (k = 0; k < 4; k++) {
1183                 s->emax[plane][k][i] = s->estart[plane];
1184                 s->emin[plane][k][i] = s->eend[plane];
1185             }
1186         }
1187     }
1188
1189     outlink->sample_aspect_ratio = (AVRational){1,1};
1190
1191     return 0;
1192 }
1193
1194 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
1195 {
1196     AVFilterContext *ctx  = inlink->dst;
1197     WaveformContext *s    = ctx->priv;
1198     AVFilterLink *outlink = ctx->outputs[0];
1199     AVFrame *out;
1200     int i, j, k;
1201
1202     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
1203     if (!out) {
1204         av_frame_free(&in);
1205         return AVERROR(ENOMEM);
1206     }
1207     out->pts = in->pts;
1208
1209     for (k = 0; k < s->ncomp; k++) {
1210         const int is_chroma = (k == 1 || k == 2);
1211         const int dst_h = AV_CEIL_RSHIFT(outlink->h, (is_chroma ? s->desc->log2_chroma_h : 0));
1212         const int dst_w = AV_CEIL_RSHIFT(outlink->w, (is_chroma ? s->desc->log2_chroma_w : 0));
1213         if (s->bits <= 8) {
1214             for (i = 0; i < dst_h ; i++)
1215                 memset(out->data[s->desc->comp[k].plane] +
1216                        i * out->linesize[s->desc->comp[k].plane],
1217                        s->bg_color[k], dst_w);
1218         } else {
1219             const int mult = s->size / 256;
1220             uint16_t *dst = (uint16_t *)out->data[s->desc->comp[k].plane];
1221
1222             for (i = 0; i < dst_h ; i++) {
1223                 for (j = 0; j < dst_w; j++)
1224                     dst[j] = s->bg_color[k] * mult;
1225                 dst += out->linesize[s->desc->comp[k].plane] / 2;
1226             }
1227         }
1228     }
1229
1230     for (k = 0, i = 0; k < s->ncomp; k++) {
1231         if ((1 << k) & s->pcomp) {
1232             const int offset = i++ * s->size * s->display;
1233             s->waveform(s, in, out, k, s->intensity, offset, s->mode);
1234         }
1235     }
1236
1237     av_frame_free(&in);
1238     return ff_filter_frame(outlink, out);
1239 }
1240
1241 static av_cold void uninit(AVFilterContext *ctx)
1242 {
1243     WaveformContext *s = ctx->priv;
1244
1245     av_freep(&s->peak);
1246 }
1247
1248 static const AVFilterPad inputs[] = {
1249     {
1250         .name         = "default",
1251         .type         = AVMEDIA_TYPE_VIDEO,
1252         .filter_frame = filter_frame,
1253         .config_props = config_input,
1254     },
1255     { NULL }
1256 };
1257
1258 static const AVFilterPad outputs[] = {
1259     {
1260         .name         = "default",
1261         .type         = AVMEDIA_TYPE_VIDEO,
1262         .config_props = config_output,
1263     },
1264     { NULL }
1265 };
1266
1267 AVFilter ff_vf_waveform = {
1268     .name          = "waveform",
1269     .description   = NULL_IF_CONFIG_SMALL("Video waveform monitor."),
1270     .priv_size     = sizeof(WaveformContext),
1271     .priv_class    = &waveform_class,
1272     .query_formats = query_formats,
1273     .uninit        = uninit,
1274     .inputs        = inputs,
1275     .outputs       = outputs,
1276 };