FFmpeg coverage

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