summaryrefslogtreecommitdiff
path: root/libavfilter/vf_vectorscope.c (plain)
blob: 987bc66bd49a04a20e1fb52c497ae779283927fd
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
32enum VectorscopeMode {
33 GRAY,
34 COLOR,
35 COLOR2,
36 COLOR3,
37 COLOR4,
38 COLOR5,
39 MODE_NB
40};
41
42typedef 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
79static 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
124AVFILTER_DEFINE_CLASS(vectorscope);
125
126static const enum AVPixelFormat out_yuv8_pix_fmts[] = {
127 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P,
128 AV_PIX_FMT_NONE
129};
130
131static const enum AVPixelFormat out_yuv9_pix_fmts[] = {
132 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUV444P9,
133 AV_PIX_FMT_NONE
134};
135
136static const enum AVPixelFormat out_yuv10_pix_fmts[] = {
137 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUV444P10,
138 AV_PIX_FMT_NONE
139};
140
141static const enum AVPixelFormat out_yuv12_pix_fmts[] = {
142 AV_PIX_FMT_YUV444P12,
143 AV_PIX_FMT_NONE
144};
145
146static const enum AVPixelFormat out_rgb8_pix_fmts[] = {
147 AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
148 AV_PIX_FMT_NONE
149};
150
151static const enum AVPixelFormat out_rgb9_pix_fmts[] = {
152 AV_PIX_FMT_GBRP9,
153 AV_PIX_FMT_NONE
154};
155
156static const enum AVPixelFormat out_rgb10_pix_fmts[] = {
157 AV_PIX_FMT_GBRP10,
158 AV_PIX_FMT_NONE
159};
160
161static const enum AVPixelFormat out_rgb12_pix_fmts[] = {
162 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
163 AV_PIX_FMT_NONE
164};
165
166static 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,
173 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
174 AV_PIX_FMT_NONE
175};
176
177static 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,
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
194static 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
253static 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
276static 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
297static 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
328static 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
348static 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
378static 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
389static 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
400static 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
598static 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
792const static char *positions_name[] = {
793 "R", "B", "Cy", "Yl", "G", "Mg",
794};
795
796const 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
850static 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
873static 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
896static void none_graticule(VectorscopeContext *s, AVFrame *out, int X, int Y, int D, int P)
897{
898}
899
900static 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
926static 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
952static 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
1020static 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
1086static 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
1146static 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
1204static 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 (av_frame_get_colorspace(in)) {
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
1247static 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
1323static 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
1331static 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
1341static const AVFilterPad outputs[] = {
1342 {
1343 .name = "default",
1344 .type = AVMEDIA_TYPE_VIDEO,
1345 .config_props = config_output,
1346 },
1347 { NULL }
1348};
1349
1350AVFilter 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};
1360
generated by cgit at 2024-05-17 04:12:29 (GMT)