vf_paletteuse: Add error checking to apply_palette
[ffmpeg.git] / libavfilter / vf_vectorscope.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/avassert.h"
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/parseutils.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/xga_font_data.h"
27 #include "avfilter.h"
28 #include "formats.h"
29 #include "internal.h"
30 #include "video.h"
31
32 enum VectorscopeMode {
33     GRAY,
34     COLOR,
35     COLOR2,
36     COLOR3,
37     COLOR4,
38     COLOR5,
39     MODE_NB
40 };
41
42 typedef struct VectorscopeContext {
43     const AVClass *class;
44     int mode;
45     int intensity;
46     float fintensity;
47     uint16_t bg_color[4];
48     int planewidth[4];
49     int planeheight[4];
50     int hsub, vsub;
51     int x, y, pd;
52     int is_yuv;
53     int size;
54     int depth;
55     int mult;
56     int envelope;
57     int graticule;
58     float opacity;
59     float bgopacity;
60     float lthreshold;
61     float hthreshold;
62     int tmin;
63     int tmax;
64     int flags;
65     int colorspace;
66     int cs;
67     uint8_t *peak_memory;
68     uint8_t **peak;
69
70     void (*vectorscope)(struct VectorscopeContext *s,
71                         AVFrame *in, AVFrame *out, int pd);
72     void (*graticulef)(struct VectorscopeContext *s, AVFrame *out,
73                        int X, int Y, int D, int P);
74 } VectorscopeContext;
75
76 #define OFFSET(x) offsetof(VectorscopeContext, x)
77 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
78
79 static const AVOption vectorscope_options[] = {
80     { "mode", "set vectorscope mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, MODE_NB-1, FLAGS, "mode"},
81     { "m",    "set vectorscope mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, MODE_NB-1, FLAGS, "mode"},
82     {   "gray",   0, 0, AV_OPT_TYPE_CONST, {.i64=GRAY},   0, 0, FLAGS, "mode" },
83     {   "color",  0, 0, AV_OPT_TYPE_CONST, {.i64=COLOR},  0, 0, FLAGS, "mode" },
84     {   "color2", 0, 0, AV_OPT_TYPE_CONST, {.i64=COLOR2}, 0, 0, FLAGS, "mode" },
85     {   "color3", 0, 0, AV_OPT_TYPE_CONST, {.i64=COLOR3}, 0, 0, FLAGS, "mode" },
86     {   "color4", 0, 0, AV_OPT_TYPE_CONST, {.i64=COLOR4}, 0, 0, FLAGS, "mode" },
87     {   "color5", 0, 0, AV_OPT_TYPE_CONST, {.i64=COLOR5}, 0, 0, FLAGS, "mode" },
88     { "x", "set color component on X axis", OFFSET(x), AV_OPT_TYPE_INT, {.i64=1}, 0, 2, FLAGS},
89     { "y", "set color component on Y axis", OFFSET(y), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS},
90     { "intensity", "set intensity", OFFSET(fintensity), AV_OPT_TYPE_FLOAT, {.dbl=0.004}, 0, 1, FLAGS},
91     { "i",         "set intensity", OFFSET(fintensity), AV_OPT_TYPE_FLOAT, {.dbl=0.004}, 0, 1, FLAGS},
92     { "envelope",  "set envelope", OFFSET(envelope), AV_OPT_TYPE_INT, {.i64=0}, 0, 3, FLAGS, "envelope"},
93     { "e",         "set envelope", OFFSET(envelope), AV_OPT_TYPE_INT, {.i64=0}, 0, 3, FLAGS, "envelope"},
94     {   "none",         0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "envelope" },
95     {   "instant",      0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "envelope" },
96     {   "peak",         0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "envelope" },
97     {   "peak+instant", 0, 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, "envelope" },
98     { "graticule", "set graticule", OFFSET(graticule), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, "graticule"},
99     { "g",         "set graticule", OFFSET(graticule), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, "graticule"},
100     {   "none",         0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "graticule" },
101     {   "green",        0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "graticule" },
102     {   "color",        0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "graticule" },
103     { "opacity", "set graticule opacity", OFFSET(opacity), AV_OPT_TYPE_FLOAT, {.dbl=0.75}, 0, 1, FLAGS},
104     { "o",       "set graticule opacity", OFFSET(opacity), AV_OPT_TYPE_FLOAT, {.dbl=0.75}, 0, 1, FLAGS},
105     { "flags", "set graticule flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64=4}, 0, 7, FLAGS, "flags"},
106     { "f",     "set graticule flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64=4}, 0, 7, FLAGS, "flags"},
107     {   "white", "draw white point", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "flags" },
108     {   "black", "draw black point", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "flags" },
109     {   "name",  "draw point name",  0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, FLAGS, "flags" },
110     { "bgopacity", "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.3}, 0, 1, FLAGS},
111     { "b",         "set background opacity", OFFSET(bgopacity), AV_OPT_TYPE_FLOAT, {.dbl=0.3}, 0, 1, FLAGS},
112     { "lthreshold", "set low threshold",  OFFSET(lthreshold), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, FLAGS},
113     { "l",          "set low threshold",  OFFSET(lthreshold), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, FLAGS},
114     { "hthreshold", "set high threshold", OFFSET(hthreshold), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, FLAGS},
115     { "h",          "set high threshold", OFFSET(hthreshold), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, FLAGS},
116     { "colorspace", "set colorspace", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, "colorspace"},
117     { "c",          "set colorspace", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, "colorspace"},
118     {   "auto",       0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "colorspace" },
119     {   "601",        0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "colorspace" },
120     {   "709",        0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "colorspace" },
121     { NULL }
122 };
123
124 AVFILTER_DEFINE_CLASS(vectorscope);
125
126 static const enum AVPixelFormat out_yuv8_pix_fmts[] = {
127     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P,
128     AV_PIX_FMT_NONE
129 };
130
131 static const enum AVPixelFormat out_yuv9_pix_fmts[] = {
132     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUV444P9,
133     AV_PIX_FMT_NONE
134 };
135
136 static const enum AVPixelFormat out_yuv10_pix_fmts[] = {
137     AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUV444P10,
138     AV_PIX_FMT_NONE
139 };
140
141 static const enum AVPixelFormat out_yuv12_pix_fmts[] = {
142     AV_PIX_FMT_YUV444P12,
143     AV_PIX_FMT_NONE
144 };
145
146 static const enum AVPixelFormat out_rgb8_pix_fmts[] = {
147     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
148     AV_PIX_FMT_NONE
149 };
150
151 static const enum AVPixelFormat out_rgb9_pix_fmts[] = {
152     AV_PIX_FMT_GBRP9,
153     AV_PIX_FMT_NONE
154 };
155
156 static const enum AVPixelFormat out_rgb10_pix_fmts[] = {
157     AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
158     AV_PIX_FMT_NONE
159 };
160
161 static const enum AVPixelFormat out_rgb12_pix_fmts[] = {
162     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
163     AV_PIX_FMT_NONE
164 };
165
166 static const enum AVPixelFormat in1_pix_fmts[] = {
167     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
168     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
169     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10,
170     AV_PIX_FMT_YUV444P12,
171     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
172     AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
173     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
174     AV_PIX_FMT_NONE
175 };
176
177 static const enum AVPixelFormat in2_pix_fmts[] = {
178     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
179     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
180     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
181     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUVJ411P,
182     AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUV410P,
183     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
184     AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
185     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
186     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
187     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
188     AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
189     AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
190     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
191     AV_PIX_FMT_NONE
192 };
193
194 static int query_formats(AVFilterContext *ctx)
195 {
196     VectorscopeContext *s = ctx->priv;
197     const enum AVPixelFormat *out_pix_fmts;
198     const AVPixFmtDescriptor *desc;
199     AVFilterFormats *avff;
200     int depth, rgb, i, ret;
201
202     if (!ctx->inputs[0]->in_formats ||
203         !ctx->inputs[0]->in_formats->nb_formats) {
204         return AVERROR(EAGAIN);
205     }
206
207     if (!ctx->inputs[0]->out_formats) {
208         const enum AVPixelFormat *in_pix_fmts;
209
210         if ((s->x == 1 && s->y == 2) || (s->x == 2 && s->y == 1))
211             in_pix_fmts = in2_pix_fmts;
212         else
213             in_pix_fmts = in1_pix_fmts;
214         if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0)
215             return ret;
216     }
217
218     avff = ctx->inputs[0]->in_formats;
219     desc = av_pix_fmt_desc_get(avff->formats[0]);
220     rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
221     depth = desc->comp[0].depth;
222     for (i = 1; i < avff->nb_formats; i++) {
223         desc = av_pix_fmt_desc_get(avff->formats[i]);
224         if (rgb != (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
225             depth != desc->comp[0].depth)
226             return AVERROR(EAGAIN);
227     }
228
229     if (rgb && depth == 8)
230         out_pix_fmts = out_rgb8_pix_fmts;
231     else if (rgb && depth == 9)
232         out_pix_fmts = out_rgb9_pix_fmts;
233     else if (rgb && depth == 10)
234         out_pix_fmts = out_rgb10_pix_fmts;
235     else if (rgb && depth == 12)
236         out_pix_fmts = out_rgb12_pix_fmts;
237     else if (depth == 8)
238         out_pix_fmts = out_yuv8_pix_fmts;
239     else if (depth == 9)
240         out_pix_fmts = out_yuv9_pix_fmts;
241     else if (depth == 10)
242         out_pix_fmts = out_yuv10_pix_fmts;
243     else if (depth == 12)
244         out_pix_fmts = out_yuv12_pix_fmts;
245     else
246         return AVERROR(EAGAIN);
247     if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
248         return ret;
249
250     return 0;
251 }
252
253 static int config_output(AVFilterLink *outlink)
254 {
255     VectorscopeContext *s = outlink->src->priv;
256     int i;
257
258     s->intensity = s->fintensity * (s->size - 1);
259     outlink->h = outlink->w = s->size;
260     outlink->sample_aspect_ratio = (AVRational){1,1};
261
262     s->peak_memory = av_calloc(s->size, s->size);
263     if (!s->peak_memory)
264         return AVERROR(ENOMEM);
265
266     s->peak = av_calloc(s->size, sizeof(*s->peak));
267     if (!s->peak)
268         return AVERROR(ENOMEM);
269
270     for (i = 0; i < s->size; i++)
271         s->peak[i] = s->peak_memory + s->size * i;
272
273     return 0;
274 }
275
276 static void envelope_instant16(VectorscopeContext *s, AVFrame *out)
277 {
278     const int dlinesize = out->linesize[0] / 2;
279     uint16_t *dpd = s->mode == COLOR || !s->is_yuv ? (uint16_t *)out->data[s->pd] : (uint16_t *)out->data[0];
280     const int max = s->size - 1;
281     int i, j;
282
283     for (i = 0; i < out->height; i++) {
284         for (j = 0; j < out->width; j++) {
285             const int pos = i * dlinesize + j;
286             const int poa = (i - 1) * dlinesize + j;
287             const int pob = (i + 1) * dlinesize + j;
288
289             if (dpd[pos] && (((!j || !dpd[pos - 1]) || ((j == (out->width - 1)) || !dpd[pos + 1]))
290                          || ((!i || !dpd[poa]) || ((i == (out->height - 1)) || !dpd[pob])))) {
291                 dpd[pos] = max;
292             }
293         }
294     }
295 }
296
297 static void envelope_peak16(VectorscopeContext *s, AVFrame *out)
298 {
299     const int dlinesize = out->linesize[0] / 2;
300     uint16_t *dpd = s->mode == COLOR || !s->is_yuv ? (uint16_t *)out->data[s->pd] : (uint16_t *)out->data[0];
301     const int max = s->size - 1;
302     int i, j;
303
304     for (i = 0; i < out->height; i++) {
305         for (j = 0; j < out->width; j++) {
306             const int pos = i * dlinesize + j;
307
308             if (dpd[pos])
309                 s->peak[i][j] = 1;
310         }
311     }
312
313     if (s->envelope == 3)
314         envelope_instant16(s, out);
315
316     for (i = 0; i < out->height; i++) {
317         for (j = 0; j < out->width; j++) {
318             const int pos = i * dlinesize + j;
319
320             if (s->peak[i][j] && (((!j || !s->peak[i][j-1]) || ((j == (out->width - 1)) || !s->peak[i][j + 1]))
321                               || ((!i || !s->peak[i-1][j]) || ((i == (out->height - 1)) || !s->peak[i + 1][j])))) {
322                 dpd[pos] = max;
323             }
324         }
325     }
326 }
327
328 static void envelope_instant(VectorscopeContext *s, AVFrame *out)
329 {
330     const int dlinesize = out->linesize[0];
331     uint8_t *dpd = s->mode == COLOR || !s->is_yuv ? out->data[s->pd] : out->data[0];
332     int i, j;
333
334     for (i = 0; i < out->height; i++) {
335         for (j = 0; j < out->width; j++) {
336             const int pos = i * dlinesize + j;
337             const int poa = (i - 1) * dlinesize + j;
338             const int pob = (i + 1) * dlinesize + j;
339
340             if (dpd[pos] && (((!j || !dpd[pos - 1]) || ((j == (out->width - 1)) || !dpd[pos + 1]))
341                          || ((!i || !dpd[poa]) || ((i == (out->height - 1)) || !dpd[pob])))) {
342                 dpd[pos] = 255;
343             }
344         }
345     }
346 }
347
348 static void envelope_peak(VectorscopeContext *s, AVFrame *out)
349 {
350     const int dlinesize = out->linesize[0];
351     uint8_t *dpd = s->mode == COLOR || !s->is_yuv ? out->data[s->pd] : out->data[0];
352     int i, j;
353
354     for (i = 0; i < out->height; i++) {
355         for (j = 0; j < out->width; j++) {
356             const int pos = i * dlinesize + j;
357
358             if (dpd[pos])
359                 s->peak[i][j] = 1;
360         }
361     }
362
363     if (s->envelope == 3)
364         envelope_instant(s, out);
365
366     for (i = 0; i < out->height; i++) {
367         for (j = 0; j < out->width; j++) {
368             const int pos = i * dlinesize + j;
369
370             if (s->peak[i][j] && (((!j || !s->peak[i][j-1]) || ((j == (out->width - 1)) || !s->peak[i][j + 1]))
371                               || ((!i || !s->peak[i-1][j]) || ((i == (out->height - 1)) || !s->peak[i + 1][j])))) {
372                 dpd[pos] = 255;
373             }
374         }
375     }
376 }
377
378 static void envelope16(VectorscopeContext *s, AVFrame *out)
379 {
380     if (!s->envelope) {
381         return;
382     } else if (s->envelope == 1) {
383         envelope_instant16(s, out);
384     } else {
385         envelope_peak16(s, out);
386     }
387 }
388
389 static void envelope(VectorscopeContext *s, AVFrame *out)
390 {
391     if (!s->envelope) {
392         return;
393     } else if (s->envelope == 1) {
394         envelope_instant(s, out);
395     } else {
396         envelope_peak(s, out);
397     }
398 }
399
400 static void vectorscope16(VectorscopeContext *s, AVFrame *in, AVFrame *out, int pd)
401 {
402     const uint16_t * const *src = (const uint16_t * const *)in->data;
403     const int slinesizex = in->linesize[s->x] / 2;
404     const int slinesizey = in->linesize[s->y] / 2;
405     const int slinesized = in->linesize[pd] / 2;
406     const int dlinesize = out->linesize[0] / 2;
407     const int intensity = s->intensity;
408     const int px = s->x, py = s->y;
409     const int h = s->planeheight[py];
410     const int w = s->planewidth[px];
411     const uint16_t *spx = src[px];
412     const uint16_t *spy = src[py];
413     const uint16_t *spd = src[pd];
414     const int hsub = s->hsub;
415     const int vsub = s->vsub;
416     uint16_t **dst = (uint16_t **)out->data;
417     uint16_t *dpx = dst[px];
418     uint16_t *dpy = dst[py];
419     uint16_t *dpd = dst[pd];
420     const int max = s->size - 1;
421     const int mid = s->size / 2;
422     const int tmin = s->tmin;
423     const int tmax = s->tmax;
424     int i, j, k;
425
426     for (k = 0; k < 4 && dst[k]; k++) {
427         for (i = 0; i < out->height ; i++)
428             for (j = 0; j < out->width; j++)
429                 AV_WN16(out->data[k] + i * out->linesize[k] + j * 2,
430                         (s->mode == COLOR || s->mode == COLOR5) && k == s->pd ? 0 : s->bg_color[k]);
431     }
432
433     switch (s->mode) {
434     case COLOR:
435     case COLOR5:
436     case GRAY:
437         if (s->is_yuv) {
438             for (i = 0; i < h; i++) {
439                 const int iwx = i * slinesizex;
440                 const int iwy = i * slinesizey;
441                 const int iwd = i * slinesized;
442                 for (j = 0; j < w; j++) {
443                     const int x = FFMIN(spx[iwx + j], max);
444                     const int y = FFMIN(spy[iwy + j], max);
445                     const int z = spd[iwd + j];
446                     const int pos = y * dlinesize + x;
447
448                     if (z < tmin || z > tmax)
449                         continue;
450
451                     dpd[pos] = FFMIN(dpd[pos] + intensity, max);
452                 }
453             }
454         } else {
455             for (i = 0; i < h; i++) {
456                 const int iwx = i * slinesizex;
457                 const int iwy = i * slinesizey;
458                 const int iwd = i * slinesized;
459                 for (j = 0; j < w; j++) {
460                     const int x = FFMIN(spx[iwx + j], max);
461                     const int y = FFMIN(spy[iwy + j], max);
462                     const int z = spd[iwd + j];
463                     const int pos = y * dlinesize + x;
464
465                     if (z < tmin || z > tmax)
466                         continue;
467
468                     dst[0][pos] = FFMIN(dst[0][pos] + intensity, max);
469                     dst[1][pos] = FFMIN(dst[1][pos] + intensity, max);
470                     dst[2][pos] = FFMIN(dst[2][pos] + intensity, max);
471                 }
472             }
473         }
474         break;
475     case COLOR2:
476         if (s->is_yuv) {
477             for (i = 0; i < h; i++) {
478                 const int iw1 = i * slinesizex;
479                 const int iw2 = i * slinesizey;
480                 const int iwd = i * slinesized;
481                 for (j = 0; j < w; j++) {
482                     const int x = FFMIN(spx[iw1 + j], max);
483                     const int y = FFMIN(spy[iw2 + j], max);
484                     const int z = spd[iwd + j];
485                     const int pos = y * dlinesize + x;
486
487                     if (z < tmin || z > tmax)
488                         continue;
489
490                     if (!dpd[pos])
491                         dpd[pos] = FFABS(mid - x) + FFABS(mid - y);
492                     dpx[pos] = x;
493                     dpy[pos] = y;
494                 }
495             }
496         } else {
497             for (i = 0; i < h; i++) {
498                 const int iw1 = i * slinesizex;
499                 const int iw2 = i * slinesizey;
500                 const int iwd = i * slinesized;
501                 for (j = 0; j < w; j++) {
502                     const int x = FFMIN(spx[iw1 + j], max);
503                     const int y = FFMIN(spy[iw2 + j], max);
504                     const int z = spd[iwd + j];
505                     const int pos = y * dlinesize + x;
506
507                     if (z < tmin || z > tmax)
508                         continue;
509
510                     if (!dpd[pos])
511                         dpd[pos] = FFMIN(x + y, max);
512                     dpx[pos] = x;
513                     dpy[pos] = y;
514                 }
515             }
516         }
517         break;
518     case COLOR3:
519         for (i = 0; i < h; i++) {
520             const int iw1 = i * slinesizex;
521             const int iw2 = i * slinesizey;
522             const int iwd = i * slinesized;
523             for (j = 0; j < w; j++) {
524                 const int x = FFMIN(spx[iw1 + j], max);
525                 const int y = FFMIN(spy[iw2 + j], max);
526                 const int z = spd[iwd + j];
527                 const int pos = y * dlinesize + x;
528
529                 if (z < tmin || z > tmax)
530                     continue;
531
532                 dpd[pos] = FFMIN(max, dpd[pos] + intensity);
533                 dpx[pos] = x;
534                 dpy[pos] = y;
535             }
536         }
537         break;
538     case COLOR4:
539         for (i = 0; i < in->height; i++) {
540             const int iwx = (i >> vsub) * slinesizex;
541             const int iwy = (i >> vsub) * slinesizey;
542             const int iwd = i * slinesized;
543             for (j = 0; j < in->width; j++) {
544                 const int x = FFMIN(spx[iwx + (j >> hsub)], max);
545                 const int y = FFMIN(spy[iwy + (j >> hsub)], max);
546                 const int z = spd[iwd + j];
547                 const int pos = y * dlinesize + x;
548
549                 if (z < tmin || z > tmax)
550                     continue;
551
552                 dpd[pos] = FFMAX(z, dpd[pos]);
553                 dpx[pos] = x;
554                 dpy[pos] = y;
555             }
556         }
557         break;
558     default:
559         av_assert0(0);
560     }
561
562     envelope16(s, out);
563
564     if (dst[3]) {
565         for (i = 0; i < out->height; i++) {
566             for (j = 0; j < out->width; j++) {
567                 int pos = i * dlinesize + j;
568
569                 if (dpd[pos])
570                     dst[3][pos] = max;
571             }
572         }
573     }
574
575     if (s->mode == COLOR) {
576         for (i = 0; i < out->height; i++) {
577             for (j = 0; j < out->width; j++) {
578                 if (!dpd[i * dlinesize + j]) {
579                     dpx[i * dlinesize + j] = j;
580                     dpy[i * dlinesize + j] = i;
581                     dpd[i * dlinesize + j] = mid;
582                 }
583             }
584         }
585     } else if (s->mode == COLOR5) {
586         for (i = 0; i < out->height; i++) {
587             for (j = 0; j < out->width; j++) {
588                 if (!dpd[i * dlinesize + j]) {
589                     dpx[i * dlinesize + j] = j;
590                     dpy[i * dlinesize + j] = i;
591                     dpd[i * dlinesize + j] = mid * M_SQRT2 - hypot(i - mid, j - mid);
592                 }
593             }
594         }
595     }
596 }
597
598 static void vectorscope8(VectorscopeContext *s, AVFrame *in, AVFrame *out, int pd)
599 {
600     const uint8_t * const *src = (const uint8_t * const *)in->data;
601     const int slinesizex = in->linesize[s->x];
602     const int slinesizey = in->linesize[s->y];
603     const int slinesized = in->linesize[pd];
604     const int dlinesize = out->linesize[0];
605     const int intensity = s->intensity;
606     const int px = s->x, py = s->y;
607     const int h = s->planeheight[py];
608     const int w = s->planewidth[px];
609     const uint8_t *spx = src[px];
610     const uint8_t *spy = src[py];
611     const uint8_t *spd = src[pd];
612     const int hsub = s->hsub;
613     const int vsub = s->vsub;
614     uint8_t **dst = out->data;
615     uint8_t *dpx = dst[px];
616     uint8_t *dpy = dst[py];
617     uint8_t *dpd = dst[pd];
618     const int tmin = s->tmin;
619     const int tmax = s->tmax;
620     int i, j, k;
621
622     for (k = 0; k < 4 && dst[k]; k++)
623         for (i = 0; i < out->height ; i++)
624             memset(dst[k] + i * out->linesize[k],
625                    (s->mode == COLOR || s->mode == COLOR5) && k == s->pd ? 0 : s->bg_color[k], out->width);
626
627     switch (s->mode) {
628     case COLOR5:
629     case COLOR:
630     case GRAY:
631         if (s->is_yuv) {
632             for (i = 0; i < h; i++) {
633                 const int iwx = i * slinesizex;
634                 const int iwy = i * slinesizey;
635                 const int iwd = i * slinesized;
636                 for (j = 0; j < w; j++) {
637                     const int x = spx[iwx + j];
638                     const int y = spy[iwy + j];
639                     const int z = spd[iwd + j];
640                     const int pos = y * dlinesize + x;
641
642                     if (z < tmin || z > tmax)
643                         continue;
644
645                     dpd[pos] = FFMIN(dpd[pos] + intensity, 255);
646                 }
647             }
648         } else {
649             for (i = 0; i < h; i++) {
650                 const int iwx = i * slinesizex;
651                 const int iwy = i * slinesizey;
652                 const int iwd = i * slinesized;
653                 for (j = 0; j < w; j++) {
654                     const int x = spx[iwx + j];
655                     const int y = spy[iwy + j];
656                     const int z = spd[iwd + j];
657                     const int pos = y * dlinesize + x;
658
659                     if (z < tmin || z > tmax)
660                         continue;
661
662                     dst[0][pos] = FFMIN(dst[0][pos] + intensity, 255);
663                     dst[1][pos] = FFMIN(dst[1][pos] + intensity, 255);
664                     dst[2][pos] = FFMIN(dst[2][pos] + intensity, 255);
665                 }
666             }
667         }
668         break;
669     case COLOR2:
670         if (s->is_yuv) {
671             for (i = 0; i < h; i++) {
672                 const int iw1 = i * slinesizex;
673                 const int iw2 = i * slinesizey;
674                 const int iwd = i * slinesized;
675                 for (j = 0; j < w; j++) {
676                     const int x = spx[iw1 + j];
677                     const int y = spy[iw2 + j];
678                     const int z = spd[iwd + j];
679                     const int pos = y * dlinesize + x;
680
681                     if (z < tmin || z > tmax)
682                         continue;
683
684                     if (!dpd[pos])
685                         dpd[pos] = FFABS(128 - x) + FFABS(128 - y);
686                     dpx[pos] = x;
687                     dpy[pos] = y;
688                 }
689             }
690         } else {
691             for (i = 0; i < h; i++) {
692                 const int iw1 = i * slinesizex;
693                 const int iw2 = i * slinesizey;
694                 const int iwd = i * slinesized;
695                 for (j = 0; j < w; j++) {
696                     const int x = spx[iw1 + j];
697                     const int y = spy[iw2 + j];
698                     const int z = spd[iwd + j];
699                     const int pos = y * dlinesize + x;
700
701                     if (z < tmin || z > tmax)
702                         continue;
703
704                     if (!dpd[pos])
705                         dpd[pos] = FFMIN(x + y, 255);
706                     dpx[pos] = x;
707                     dpy[pos] = y;
708                 }
709             }
710         }
711         break;
712     case COLOR3:
713         for (i = 0; i < h; i++) {
714             const int iw1 = i * slinesizex;
715             const int iw2 = i * slinesizey;
716             const int iwd = i * slinesized;
717             for (j = 0; j < w; j++) {
718                 const int x = spx[iw1 + j];
719                 const int y = spy[iw2 + j];
720                 const int z = spd[iwd + j];
721                 const int pos = y * dlinesize + x;
722
723                 if (z < tmin || z > tmax)
724                     continue;
725
726                 dpd[pos] = FFMIN(255, dpd[pos] + intensity);
727                 dpx[pos] = x;
728                 dpy[pos] = y;
729             }
730         }
731         break;
732     case COLOR4:
733         for (i = 0; i < in->height; i++) {
734             const int iwx = (i >> vsub) * slinesizex;
735             const int iwy = (i >> vsub) * slinesizey;
736             const int iwd = i * slinesized;
737             for (j = 0; j < in->width; j++) {
738                 const int x = spx[iwx + (j >> hsub)];
739                 const int y = spy[iwy + (j >> hsub)];
740                 const int z = spd[iwd + j];
741                 const int pos = y * dlinesize + x;
742
743                 if (z < tmin || z > tmax)
744                     continue;
745
746                 dpd[pos] = FFMAX(z, dpd[pos]);
747                 dpx[pos] = x;
748                 dpy[pos] = y;
749             }
750         }
751         break;
752     default:
753         av_assert0(0);
754     }
755
756     envelope(s, out);
757
758     if (dst[3]) {
759         for (i = 0; i < out->height; i++) {
760             for (j = 0; j < out->width; j++) {
761                 int pos = i * dlinesize + j;
762
763                 if (dpd[pos])
764                     dst[3][pos] = 255;
765             }
766         }
767     }
768
769     if (s->mode == COLOR) {
770         for (i = 0; i < out->height; i++) {
771             for (j = 0; j < out->width; j++) {
772                 if (!dpd[i * out->linesize[pd] + j]) {
773                     dpx[i * out->linesize[px] + j] = j;
774                     dpy[i * out->linesize[py] + j] = i;
775                     dpd[i * out->linesize[pd] + j] = 128;
776                 }
777             }
778         }
779     } else if (s->mode == COLOR5) {
780         for (i = 0; i < out->height; i++) {
781             for (j = 0; j < out->width; j++) {
782                 if (!dpd[i * out->linesize[pd] + j]) {
783                     dpx[i * out->linesize[px] + j] = j;
784                     dpy[i * out->linesize[py] + j] = i;
785                     dpd[i * out->linesize[pd] + j] = 128 * M_SQRT2 - hypot(i - 128, j - 128);
786                 }
787             }
788         }
789     }
790 }
791
792 const static char *positions_name[] = {
793     "R", "B", "Cy", "Yl", "G", "Mg",
794 };
795
796 const static uint16_t positions[][14][3] = {
797   {
798     {  81,  90, 240 }, {  41, 240, 110 }, { 170, 166,  16 },
799     { 210,  16, 146 }, { 145,  54,  34 }, { 106, 202, 222 },
800     { 162,  44, 142 }, { 131, 156,  44 }, { 112,  72,  58 },
801     {  84, 184, 198 }, {  65, 100, 212 }, {  35, 212, 114 },
802     { 235, 128, 128 }, { 16, 128, 128 } },
803   { {  63, 102, 240 }, {  32, 240, 118 }, { 188, 154,  16 },
804     { 219,  16, 138 }, { 173,  42,  26 }, {  78, 214, 230 },
805     {  28, 212, 120 }, {  51, 109, 212 }, {  63, 193, 204 },
806     { 133,  63,  52 }, { 145, 147,  44 }, { 168,  44, 136 },
807     { 235, 128, 128 }, { 16, 128, 128 } },
808   { {  81*2,  90*2, 240*2 }, {  41*2, 240*2, 110*2 }, { 170*2, 166*2,  16*2 },
809     { 210*2,  16*2, 146*2 }, { 145*2,  54*2,  34*2 }, { 106*2, 202*2, 222*2 },
810     { 162*2,  44*2, 142*2 }, { 131*2, 156*2,  44*2 }, { 112*2,  72*2,  58*2 },
811     {  84*2, 184*2, 198*2 }, {  65*2, 100*2, 212*2 }, {  35*2, 212*2, 114*2 },
812     { 470, 256, 256 }, { 32, 256, 256 } },
813   { {  63*2, 102*2, 240*2 }, {  32*2, 240*2, 118*2 }, { 188*2, 154*2,  16*2 },
814     { 219*2,  16*2, 138*2 }, { 173*2,  42*2,  26*2 }, {  78*2, 214*2, 230*2 },
815     {  28*2, 212*2, 120*2 }, {  51*2, 109*2, 212*2 }, {  63*2, 193*2, 204*2 },
816     { 133*2,  63*2,  52*2 }, { 145*2, 147*2,  44*2 }, { 168*2,  44*2, 136*2 },
817     { 470, 256, 256 }, { 32, 256, 256 } },
818   { {  81*4,  90*4, 240*4 }, {  41*4, 240*4, 110*4 }, { 170*4, 166*4,  16*4 },
819     { 210*4,  16*4, 146*4 }, { 145*4,  54*4,  34*4 }, { 106*4, 202*4, 222*4 },
820     { 162*4,  44*4, 142*4 }, { 131*4, 156*4,  44*4 }, { 112*4,  72*4,  58*4 },
821     {  84*4, 184*4, 198*4 }, {  65*4, 100*4, 212*4 }, {  35*4, 212*4, 114*4 },
822     { 940, 512, 512 }, { 64, 512, 512 } },
823   { {  63*4, 102*4, 240*4 }, {  32*4, 240*4, 118*4 }, { 188*4, 154*4,  16*4 },
824     { 219*4,  16*4, 138*4 }, { 173*4,  42*4,  26*4 }, {  78*4, 214*4, 230*4 },
825     {  28*4, 212*4, 120*4 }, {  51*4, 109*4, 212*4 }, {  63*4, 193*4, 204*4 },
826     { 133*4,  63*4,  52*4 }, { 145*4, 147*4,  44*4 }, { 168*4,  44*4, 136*4 },
827     { 940, 512, 512 }, { 64, 512, 512 } },
828   { {  81*8,  90*4, 240*8 }, {  41*8, 240*8, 110*8 }, { 170*8, 166*8,  16*8 },
829     { 210*8,  16*4, 146*8 }, { 145*8,  54*8,  34*8 }, { 106*8, 202*8, 222*8 },
830     { 162*8,  44*4, 142*8 }, { 131*8, 156*8,  44*8 }, { 112*8,  72*8,  58*8 },
831     {  84*8, 184*4, 198*8 }, {  65*8, 100*8, 212*8 }, {  35*8, 212*8, 114*8 },
832     { 1880, 1024, 1024 }, { 128, 1024, 1024 } },
833   { {  63*8, 102*8, 240*8 }, {  32*8, 240*8, 118*8 }, { 188*8, 154*8,  16*8 },
834     { 219*8,  16*8, 138*8 }, { 173*8,  42*8,  26*8 }, {  78*8, 214*8, 230*8 },
835     {  28*8, 212*8, 120*8 }, {  51*8, 109*8, 212*8 }, {  63*8, 193*8, 204*8 },
836     { 133*8,  63*8,  52*8 }, { 145*8, 147*8,  44*8 }, { 168*8,  44*8, 136*8 },
837     { 1880, 1024, 1024 }, { 128, 1024, 1024 } },
838   { {  81*16,  90*16, 240*16 }, {  41*16, 240*16, 110*16 }, { 170*16, 166*16,  16*16 },
839     { 210*16,  16*16, 146*16 }, { 145*16,  54*16,  34*16 }, { 106*16, 202*16, 222*16 },
840     { 162*16,  44*16, 142*16 }, { 131*16, 156*16,  44*16 }, { 112*16,  72*16,  58*16 },
841     {  84*16, 184*16, 198*16 }, {  65*16, 100*16, 212*16 }, {  35*16, 212*16, 114*16 },
842     { 3760, 2048, 2048 }, { 256, 2048, 2048 } },
843   { {  63*16, 102*16, 240*16 }, {  32*16, 240*16, 118*16 }, { 188*16, 154*16,  16*16 },
844     { 219*16,  16*16, 138*16 }, { 173*16,  42*16,  26*16 }, {  78*16, 214*16, 230*16 },
845     {  28*16, 212*16, 120*16 }, {  51*16, 109*16, 212*16 }, {  63*16, 193*16, 204*16 },
846     { 133*16,  63*16,  52*16 }, { 145*16, 147*16,  44*16 }, { 168*16,  44*16, 136*16 },
847     { 3760, 2048, 2048 }, { 256, 2048, 2048 } },
848 };
849
850 static void draw_dots(uint8_t *dst, int L, int v, float o)
851 {
852     const float f = 1. - o;
853     const float V = o * v;
854     int l = L * 2;
855
856     dst[ l - 3] = dst[ l - 3] * f + V;
857     dst[ l + 3] = dst[ l + 3] * f + V;
858     dst[-l - 3] = dst[-l - 3] * f + V;
859     dst[-l + 3] = dst[-l + 3] * f + V;
860
861     l += L;
862
863     dst[ l - 3] = dst[ l - 3] * f + V;
864     dst[ l + 3] = dst[ l + 3] * f + V;
865     dst[ l - 2] = dst[ l - 2] * f + V;
866     dst[ l + 2] = dst[ l + 2] * f + V;
867     dst[-l - 3] = dst[-l - 3] * f + V;
868     dst[-l + 3] = dst[-l + 3] * f + V;
869     dst[-l - 2] = dst[-l - 2] * f + V;
870     dst[-l + 2] = dst[-l + 2] * f + V;
871 }
872
873 static void draw_dots16(uint16_t *dst, int L, int v, float o)
874 {
875     const float f = 1. - o;
876     const float V = o * v;
877     int l = L * 2;
878
879     dst[ l - 3] = dst[ l - 3] * f + V;
880     dst[ l + 3] = dst[ l + 3] * f + V;
881     dst[-l - 3] = dst[-l - 3] * f + V;
882     dst[-l + 3] = dst[-l + 3] * f + V;
883
884     l += L;
885
886     dst[ l - 3] = dst[ l - 3] * f + V;
887     dst[ l + 3] = dst[ l + 3] * f + V;
888     dst[ l - 2] = dst[ l - 2] * f + V;
889     dst[ l + 2] = dst[ l + 2] * f + V;
890     dst[-l - 3] = dst[-l - 3] * f + V;
891     dst[-l + 3] = dst[-l + 3] * f + V;
892     dst[-l - 2] = dst[-l - 2] * f + V;
893     dst[-l + 2] = dst[-l + 2] * f + V;
894 }
895
896 static void none_graticule(VectorscopeContext *s, AVFrame *out, int X, int Y, int D, int P)
897 {
898 }
899
900 static void draw_htext(AVFrame *out, int x, int y, float o1, float o2, const char *txt, const uint8_t color[4])
901 {
902     const uint8_t *font;
903     int font_height;
904     int i, plane;
905
906     font = avpriv_cga_font,   font_height =  8;
907
908     for (plane = 0; plane < 4 && out->data[plane]; plane++) {
909         for (i = 0; txt[i]; i++) {
910             int char_y, mask;
911             int v = color[plane];
912
913             uint8_t *p = out->data[plane] + y * out->linesize[plane] + (x + i * 8);
914             for (char_y = font_height - 1; char_y >= 0; char_y--) {
915                 for (mask = 0x80; mask; mask >>= 1) {
916                     if (font[txt[i] * font_height + char_y] & mask)
917                         p[0] = p[0] * o2 + v * o1;
918                     p++;
919                 }
920                 p += out->linesize[plane] - 8;
921             }
922         }
923     }
924 }
925
926 static void draw_htext16(AVFrame *out, int x, int y, float o1, float o2, const char *txt, const uint16_t color[4])
927 {
928     const uint8_t *font;
929     int font_height;
930     int i, plane;
931
932     font = avpriv_cga_font,   font_height =  8;
933
934     for (plane = 0; plane < 4 && out->data[plane]; plane++) {
935         for (i = 0; txt[i]; i++) {
936             int char_y, mask;
937             int v = color[plane];
938
939             uint16_t *p = (uint16_t *)(out->data[plane] + y * out->linesize[plane]) + (x + i * 8);
940             for (char_y = font_height - 1; char_y >= 0; char_y--) {
941                 for (mask = 0x80; mask; mask >>= 1) {
942                     if (font[txt[i] * font_height + char_y] & mask)
943                         p[0] = p[0] * o2 + v * o1;
944                     p++;
945                 }
946                 p += out->linesize[plane] / 2 - 8;
947             }
948         }
949     }
950 }
951
952 static void color_graticule16(VectorscopeContext *s, AVFrame *out, int X, int Y, int D, int P)
953 {
954     const int max = s->size - 1;
955     const float o = s->opacity;
956     int i;
957
958     for (i = 0; i < 12; i++) {
959         int x = positions[P][i][X];
960         int y = positions[P][i][Y];
961         int d = positions[P][i][D];
962
963         draw_dots16((uint16_t *)(out->data[D] + y * out->linesize[D] + x * 2), out->linesize[D] / 2, d, o);
964         draw_dots16((uint16_t *)(out->data[X] + y * out->linesize[X] + x * 2), out->linesize[X] / 2, x, o);
965         draw_dots16((uint16_t *)(out->data[Y] + y * out->linesize[Y] + x * 2), out->linesize[Y] / 2, y, o);
966         if (out->data[3])
967             draw_dots16((uint16_t *)(out->data[3] + y * out->linesize[3] + x * 2), out->linesize[3] / 2, max, o);
968     }
969
970     if (s->flags & 1) {
971         int x = positions[P][12][X];
972         int y = positions[P][12][Y];
973         int d = positions[P][12][D];
974
975         draw_dots16((uint16_t *)(out->data[D] + y * out->linesize[D] + x * 2), out->linesize[D] / 2, d, o);
976         draw_dots16((uint16_t *)(out->data[X] + y * out->linesize[X] + x * 2), out->linesize[X] / 2, x, o);
977         draw_dots16((uint16_t *)(out->data[Y] + y * out->linesize[Y] + x * 2), out->linesize[Y] / 2, y, o);
978         if (out->data[3])
979             draw_dots16((uint16_t *)(out->data[3] + y * out->linesize[3] + x * 2), out->linesize[3] / 2, max, o);
980     }
981
982     if (s->flags & 2) {
983         int x = positions[P][13][X];
984         int y = positions[P][13][Y];
985         int d = positions[P][13][D];
986
987         draw_dots16((uint16_t *)(out->data[D] + y * out->linesize[D] + x * 2), out->linesize[D] / 2, d, o);
988         draw_dots16((uint16_t *)(out->data[X] + y * out->linesize[X] + x * 2), out->linesize[X] / 2, x, o);
989         draw_dots16((uint16_t *)(out->data[Y] + y * out->linesize[Y] + x * 2), out->linesize[Y] / 2, y, o);
990         if (out->data[3])
991             draw_dots16((uint16_t *)(out->data[3] + y * out->linesize[3] + x * 2), out->linesize[3] / 2, max, o);
992     }
993
994     for (i = 0; i < 6 && s->flags & 4; i++) {
995         uint16_t color[4] = { 0, 0, 0, 0 };
996         int x = positions[P][i][X];
997         int y = positions[P][i][Y];
998         int d = positions[P][i][D];
999
1000         color[D] = d;
1001         color[X] = x;
1002         color[Y] = y;
1003         color[3] = max;
1004
1005         if (x > max / 2)
1006             x += 8;
1007         else
1008             x -= 14;
1009         if (y > max / 2)
1010             y += 8;
1011         else
1012             y -= 14;
1013
1014         x = av_clip(x, 0, out->width - 9);
1015         y = av_clip(y, 0, out->height - 9);
1016         draw_htext16(out, x, y, o, 1. - o, positions_name[i], color);
1017     }
1018 }
1019
1020 static void color_graticule(VectorscopeContext *s, AVFrame *out, int X, int Y, int D, int P)
1021 {
1022     const float o = s->opacity;
1023     int i;
1024
1025     for (i = 0; i < 12; i++) {
1026         int x = positions[P][i][X];
1027         int y = positions[P][i][Y];
1028         int d = positions[P][i][D];
1029
1030         draw_dots(out->data[D] + y * out->linesize[D] + x, out->linesize[D], d, o);
1031         draw_dots(out->data[X] + y * out->linesize[X] + x, out->linesize[X], x, o);
1032         draw_dots(out->data[Y] + y * out->linesize[Y] + x, out->linesize[Y], y, o);
1033         if (out->data[3])
1034             draw_dots(out->data[3] + y * out->linesize[3] + x, out->linesize[3], 255, o);
1035     }
1036
1037     if (s->flags & 1) {
1038         int x = positions[P][12][X];
1039         int y = positions[P][12][Y];
1040         int d = positions[P][12][D];
1041
1042         draw_dots(out->data[D] + y * out->linesize[D] + x, out->linesize[D], d, o);
1043         draw_dots(out->data[X] + y * out->linesize[X] + x, out->linesize[X], x, o);
1044         draw_dots(out->data[Y] + y * out->linesize[Y] + x, out->linesize[Y], y, o);
1045         if (out->data[3])
1046             draw_dots(out->data[3] + y * out->linesize[3] + x, out->linesize[3], 255, o);
1047     }
1048
1049     if (s->flags & 2) {
1050         int x = positions[P][13][X];
1051         int y = positions[P][13][Y];
1052         int d = positions[P][12][D];
1053
1054         draw_dots(out->data[D] + y * out->linesize[D] + x, out->linesize[D], d, o);
1055         draw_dots(out->data[X] + y * out->linesize[X] + x, out->linesize[X], x, o);
1056         draw_dots(out->data[Y] + y * out->linesize[Y] + x, out->linesize[Y], y, o);
1057         if (out->data[3])
1058             draw_dots(out->data[3] + y * out->linesize[3] + x, out->linesize[3], 255, o);
1059     }
1060
1061     for (i = 0; i < 6 && s->flags & 4; i++) {
1062         uint8_t color[4] = { 0, 0, 0, 255 };
1063         int x = positions[P][i][X];
1064         int y = positions[P][i][Y];
1065         int d = positions[P][i][D];
1066
1067         color[D] = d;
1068         color[X] = x;
1069         color[Y] = y;
1070
1071         if (x > 128)
1072             x += 8;
1073         else
1074             x -= 14;
1075         if (y > 128)
1076             y += 8;
1077         else
1078             y -= 14;
1079
1080         x = av_clip(x, 0, out->width - 9);
1081         y = av_clip(y, 0, out->height - 9);
1082         draw_htext(out, x, y, o, 1. - o, positions_name[i], color);
1083     }
1084 }
1085
1086 static void green_graticule16(VectorscopeContext *s, AVFrame *out, int X, int Y, int D, int P)
1087 {
1088     const int max = s->size - 1;
1089     const float o = s->opacity;
1090     const int m = s->mult;
1091     int i;
1092
1093     for (i = 0; i < 12; i++) {
1094         int x = positions[P][i][X];
1095         int y = positions[P][i][Y];
1096
1097         draw_dots16((uint16_t *)(out->data[0] + y * out->linesize[0] + x * 2), out->linesize[0] / 2, 128 * m, o);
1098         draw_dots16((uint16_t *)(out->data[1] + y * out->linesize[1] + x * 2), out->linesize[1] / 2, 0, o);
1099         draw_dots16((uint16_t *)(out->data[2] + y * out->linesize[2] + x * 2), out->linesize[2] / 2, 0, o);
1100         if (out->data[3])
1101             draw_dots16((uint16_t *)(out->data[3] + y * out->linesize[3] + x * 2), out->linesize[3] / 2, max, o);
1102     }
1103
1104     if (s->flags & 1) {
1105         int x = positions[P][12][X];
1106         int y = positions[P][12][Y];
1107
1108         draw_dots16((uint16_t *)(out->data[0] + y * out->linesize[0] + x * 2), out->linesize[0] / 2, 128 * m, o);
1109         draw_dots16((uint16_t *)(out->data[1] + y * out->linesize[1] + x * 2), out->linesize[1] / 2, 0, o);
1110         draw_dots16((uint16_t *)(out->data[2] + y * out->linesize[2] + x * 2), out->linesize[2] / 2, 0, o);
1111         if (out->data[3])
1112             draw_dots16((uint16_t *)(out->data[3] + y * out->linesize[3] + x * 2), out->linesize[3] / 2, max, o);
1113     }
1114
1115     if (s->flags & 2) {
1116         int x = positions[P][13][X];
1117         int y = positions[P][13][Y];
1118
1119         draw_dots16((uint16_t *)(out->data[0] + y * out->linesize[0] + x * 2), out->linesize[0] / 2, 128 * m, o);
1120         draw_dots16((uint16_t *)(out->data[1] + y * out->linesize[1] + x * 2), out->linesize[1] / 2, 0, o);
1121         draw_dots16((uint16_t *)(out->data[2] + y * out->linesize[2] + x * 2), out->linesize[2] / 2, 0, o);
1122         if (out->data[3])
1123             draw_dots16((uint16_t *)(out->data[3] + y * out->linesize[3] + x * 2), out->linesize[3] / 2, max, o);
1124     }
1125
1126     for (i = 0; i < 6 && s->flags & 4; i++) {
1127         const uint16_t color[4] = { 128 * m, 0, 0, max };
1128         int x = positions[P][i][X];
1129         int y = positions[P][i][Y];
1130
1131         if (x > max / 2)
1132             x += 8;
1133         else
1134             x -= 14;
1135         if (y > max / 2)
1136             y += 8;
1137         else
1138             y -= 14;
1139
1140         x = av_clip(x, 0, out->width - 9);
1141         y = av_clip(y, 0, out->height - 9);
1142         draw_htext16(out, x, y, o, 1. - o, positions_name[i], color);
1143     }
1144 }
1145
1146 static void green_graticule(VectorscopeContext *s, AVFrame *out, int X, int Y, int D, int P)
1147 {
1148     const float o = s->opacity;
1149     int i;
1150
1151     for (i = 0; i < 12; i++) {
1152         int x = positions[P][i][X];
1153         int y = positions[P][i][Y];
1154
1155         draw_dots(out->data[0] + y * out->linesize[0] + x, out->linesize[0], 128, o);
1156         draw_dots(out->data[1] + y * out->linesize[1] + x, out->linesize[1], 0, o);
1157         draw_dots(out->data[2] + y * out->linesize[2] + x, out->linesize[2], 0, o);
1158         if (out->data[3])
1159             draw_dots(out->data[3] + y * out->linesize[3] + x, out->linesize[3], 255, o);
1160     }
1161
1162     if (s->flags & 1) {
1163         int x = positions[P][12][X];
1164         int y = positions[P][12][Y];
1165
1166         draw_dots(out->data[0] + y * out->linesize[0] + x, out->linesize[0], 128, o);
1167         draw_dots(out->data[1] + y * out->linesize[1] + x, out->linesize[1], 0, o);
1168         draw_dots(out->data[2] + y * out->linesize[2] + x, out->linesize[2], 0, o);
1169         if (out->data[3])
1170             draw_dots(out->data[3] + y * out->linesize[3] + x, out->linesize[3], 255, o);
1171     }
1172
1173     if (s->flags & 2) {
1174         int x = positions[P][13][X];
1175         int y = positions[P][13][Y];
1176
1177         draw_dots(out->data[0] + y * out->linesize[0] + x, out->linesize[0], 128, o);
1178         draw_dots(out->data[1] + y * out->linesize[1] + x, out->linesize[1], 0, o);
1179         draw_dots(out->data[2] + y * out->linesize[2] + x, out->linesize[2], 0, o);
1180         if (out->data[3])
1181             draw_dots(out->data[3] + y * out->linesize[3] + x, out->linesize[3], 255, o);
1182     }
1183
1184     for (i = 0; i < 6 && s->flags & 4; i++) {
1185         const uint8_t color[4] = { 128, 0, 0, 255 };
1186         int x = positions[P][i][X];
1187         int y = positions[P][i][Y];
1188
1189         if (x > 128)
1190             x += 8;
1191         else
1192             x -= 14;
1193         if (y > 128)
1194             y += 8;
1195         else
1196             y -= 14;
1197
1198         x = av_clip(x, 0, out->width - 9);
1199         y = av_clip(y, 0, out->height - 9);
1200         draw_htext(out, x, y, o, 1. - o, positions_name[i], color);
1201     }
1202 }
1203
1204 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
1205 {
1206     AVFilterContext *ctx  = inlink->dst;
1207     VectorscopeContext *s = ctx->priv;
1208     AVFilterLink *outlink = ctx->outputs[0];
1209     AVFrame *out;
1210     int plane;
1211
1212     if (s->colorspace) {
1213         s->cs = (s->depth - 8) * 2 + s->colorspace - 1;
1214     } else {
1215         switch (in->colorspace) {
1216         case AVCOL_SPC_SMPTE170M:
1217         case AVCOL_SPC_BT470BG:
1218             s->cs = (s->depth - 8) * 2 + 0;
1219             break;
1220         case AVCOL_SPC_BT709:
1221         default:
1222             s->cs = (s->depth - 8) * 2 + 1;
1223         }
1224     }
1225
1226     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
1227     if (!out) {
1228         av_frame_free(&in);
1229         return AVERROR(ENOMEM);
1230     }
1231     av_frame_copy_props(out, in);
1232
1233     s->vectorscope(s, in, out, s->pd);
1234     s->graticulef(s, out, s->x, s->y, s->pd, s->cs);
1235
1236     for (plane = 0; plane < 4; plane++) {
1237         if (out->data[plane]) {
1238             out->data[plane]    += (s->size - 1) * out->linesize[plane];
1239             out->linesize[plane] = -out->linesize[plane];
1240         }
1241     }
1242
1243     av_frame_free(&in);
1244     return ff_filter_frame(outlink, out);
1245 }
1246
1247 static int config_input(AVFilterLink *inlink)
1248 {
1249     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
1250     AVFilterContext *ctx = inlink->dst;
1251     VectorscopeContext *s = ctx->priv;
1252
1253     s->is_yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB);
1254     s->size = 1 << desc->comp[0].depth;
1255     s->mult = s->size / 256;
1256     s->depth = desc->comp[0].depth;
1257     s->tmin = s->lthreshold * (s->size - 1);
1258     s->tmax = s->hthreshold * (s->size - 1);
1259
1260     if (s->tmin > s->tmax) {
1261         av_log(ctx, AV_LOG_ERROR, "low threshold should be less than high threshold\n");
1262         return AVERROR(EINVAL);
1263     }
1264
1265     if (s->mode == GRAY && s->is_yuv)
1266         s->pd = 0;
1267     else {
1268         if ((s->x == 1 && s->y == 2) || (s->x == 2 && s->y == 1))
1269             s->pd = 0;
1270         else if ((s->x == 0 && s->y == 2) || (s->x == 2 && s->y == 0))
1271             s->pd = 1;
1272         else if ((s->x == 0 && s->y == 1) || (s->x == 1 && s->y == 0))
1273             s->pd = 2;
1274     }
1275
1276     if (s->size == 256)
1277         s->vectorscope = vectorscope8;
1278     else
1279         s->vectorscope = vectorscope16;
1280
1281     s->graticulef = none_graticule;
1282
1283     if (s->is_yuv && s->size == 256) {
1284         if (s->graticule == 1)
1285             s->graticulef = green_graticule;
1286         else if (s->graticule == 2)
1287             s->graticulef = color_graticule;
1288     } else if (s->is_yuv) {
1289         if (s->graticule == 1)
1290             s->graticulef = green_graticule16;
1291         else if (s->graticule == 2)
1292             s->graticulef = color_graticule16;
1293     }
1294
1295     s->bg_color[3] = s->bgopacity * (s->size - 1);
1296
1297     switch (inlink->format) {
1298     case AV_PIX_FMT_GBRP12:
1299     case AV_PIX_FMT_GBRP10:
1300     case AV_PIX_FMT_GBRP9:
1301     case AV_PIX_FMT_GBRAP:
1302     case AV_PIX_FMT_GBRP:
1303         s->bg_color[0] = 0;
1304         s->bg_color[1] = 0;
1305         s->bg_color[2] = 0;
1306         break;
1307     default:
1308         s->bg_color[0] = 0;
1309         s->bg_color[1] = s->size / 2 - 1;
1310         s->bg_color[2] = s->size / 2 - 1;
1311     }
1312
1313     s->hsub = desc->log2_chroma_w;
1314     s->vsub = desc->log2_chroma_h;
1315     s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
1316     s->planeheight[0] = s->planeheight[3] = inlink->h;
1317     s->planewidth[1]  = s->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
1318     s->planewidth[0]  = s->planewidth[3]  = inlink->w;
1319
1320     return 0;
1321 }
1322
1323 static av_cold void uninit(AVFilterContext *ctx)
1324 {
1325     VectorscopeContext *s = ctx->priv;
1326
1327     av_freep(&s->peak);
1328     av_freep(&s->peak_memory);
1329 }
1330
1331 static const AVFilterPad inputs[] = {
1332     {
1333         .name         = "default",
1334         .type         = AVMEDIA_TYPE_VIDEO,
1335         .filter_frame = filter_frame,
1336         .config_props = config_input,
1337     },
1338     { NULL }
1339 };
1340
1341 static const AVFilterPad outputs[] = {
1342     {
1343         .name         = "default",
1344         .type         = AVMEDIA_TYPE_VIDEO,
1345         .config_props = config_output,
1346     },
1347     { NULL }
1348 };
1349
1350 AVFilter ff_vf_vectorscope = {
1351     .name          = "vectorscope",
1352     .description   = NULL_IF_CONFIG_SMALL("Video vectorscope."),
1353     .priv_size     = sizeof(VectorscopeContext),
1354     .priv_class    = &vectorscope_class,
1355     .query_formats = query_formats,
1356     .uninit        = uninit,
1357     .inputs        = inputs,
1358     .outputs       = outputs,
1359 };