?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / media / common / v4l2-tpg / v4l2-tpg-core.c
blob2036b94269afef7cc39e2f265dea240fb9e6c735
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * v4l2-tpg-core.c - Test Pattern Generator
4 *
5 * Note: gen_twopix and tpg_gen_text are based on code from vivi.c. See the
6 * vivi.c source for the copyright information of those functions.
7 *
8 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
9 */
10
11 #include <linux/module.h>
12 #include <media/tpg/v4l2-tpg.h>
13
14 /* Must remain in sync with enum tpg_pattern */
15 const char * const tpg_pattern_strings[] = {
16 "75% Colorbar",
17 "100% Colorbar",
18 "CSC Colorbar",
19 "Horizontal 100% Colorbar",
20 "100% Color Squares",
21 "100% Black",
22 "100% White",
23 "100% Red",
24 "100% Green",
25 "100% Blue",
26 "16x16 Checkers",
27 "2x2 Checkers",
28 "1x1 Checkers",
29 "2x2 Red/Green Checkers",
30 "1x1 Red/Green Checkers",
31 "Alternating Hor Lines",
32 "Alternating Vert Lines",
33 "One Pixel Wide Cross",
34 "Two Pixels Wide Cross",
35 "Ten Pixels Wide Cross",
36 "Gray Ramp",
37 "Noise",
38 NULL
39 };
40 EXPORT_SYMBOL_GPL(tpg_pattern_strings);
41
42 /* Must remain in sync with enum tpg_aspect */
43 const char * const tpg_aspect_strings[] = {
44 "Source Width x Height",
45 "4x3",
46 "14x9",
47 "16x9",
48 "16x9 Anamorphic",
49 NULL
50 };
51 EXPORT_SYMBOL_GPL(tpg_aspect_strings);
52
53 /*
54 * Sine table: sin[0] = 127 * sin(-180 degrees)
55 * sin[128] = 127 * sin(0 degrees)
56 * sin[256] = 127 * sin(180 degrees)
57 */
58 static const s8 sin[257] = {
59 0, -4, -7, -11, -13, -18, -20, -22, -26, -29, -33, -35, -37, -41, -43, -48,
60 -50, -52, -56, -58, -62, -63, -65, -69, -71, -75, -76, -78, -82, -83, -87, -88,
61 -90, -93, -94, -97, -99, -101, -103, -104, -107, -108, -110, -111, -112, -114, -115, -117,
62 -118, -119, -120, -121, -122, -123, -123, -124, -125, -125, -126, -126, -127, -127, -127, -127,
63 -127, -127, -127, -127, -126, -126, -125, -125, -124, -124, -123, -122, -121, -120, -119, -118,
64 -117, -116, -114, -113, -111, -110, -109, -107, -105, -103, -101, -100, -97, -96, -93, -91,
65 -90, -87, -85, -82, -80, -76, -75, -73, -69, -67, -63, -62, -60, -56, -54, -50,
66 -48, -46, -41, -39, -35, -33, -31, -26, -24, -20, -18, -15, -11, -9, -4, -2,
67 0, 2, 4, 9, 11, 15, 18, 20, 24, 26, 31, 33, 35, 39, 41, 46,
68 48, 50, 54, 56, 60, 62, 64, 67, 69, 73, 75, 76, 80, 82, 85, 87,
69 90, 91, 93, 96, 97, 100, 101, 103, 105, 107, 109, 110, 111, 113, 114, 116,
70 117, 118, 119, 120, 121, 122, 123, 124, 124, 125, 125, 126, 126, 127, 127, 127,
71 127, 127, 127, 127, 127, 126, 126, 125, 125, 124, 123, 123, 122, 121, 120, 119,
72 118, 117, 115, 114, 112, 111, 110, 108, 107, 104, 103, 101, 99, 97, 94, 93,
73 90, 88, 87, 83, 82, 78, 76, 75, 71, 69, 65, 64, 62, 58, 56, 52,
74 50, 48, 43, 41, 37, 35, 33, 29, 26, 22, 20, 18, 13, 11, 7, 4,
75 0,
76 };
77
78 #define cos(idx) sin[((idx) + 64) % sizeof(sin)]
79
80 /* Global font descriptor */
81 static const u8 *font8x16;
82
83 void tpg_set_font(const u8 *f)
84 {
85 font8x16 = f;
86 }
87 EXPORT_SYMBOL_GPL(tpg_set_font);
88
89 void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h)
90 {
91 memset(tpg, 0, sizeof(*tpg));
92 tpg->scaled_width = tpg->src_width = w;
93 tpg->src_height = tpg->buf_height = h;
94 tpg->crop.width = tpg->compose.width = w;
95 tpg->crop.height = tpg->compose.height = h;
96 tpg->recalc_colors = true;
97 tpg->recalc_square_border = true;
98 tpg->brightness = 128;
99 tpg->contrast = 128;
100 tpg->saturation = 128;
101 tpg->hue = 0;
102 tpg->mv_hor_mode = TPG_MOVE_NONE;
103 tpg->mv_vert_mode = TPG_MOVE_NONE;
104 tpg->field = V4L2_FIELD_NONE;
105 tpg_s_fourcc(tpg, V4L2_PIX_FMT_RGB24);
106 tpg->colorspace = V4L2_COLORSPACE_SRGB;
107 tpg->perc_fill = 100;
108 tpg->hsv_enc = V4L2_HSV_ENC_180;
109 }
110 EXPORT_SYMBOL_GPL(tpg_init);
111
112 int tpg_alloc(struct tpg_data *tpg, unsigned max_w)
113 {
114 unsigned pat;
115 unsigned plane;
116
117 tpg->max_line_width = max_w;
118 for (pat = 0; pat < TPG_MAX_PAT_LINES; pat++) {
119 for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
120 unsigned pixelsz = plane ? 2 : 4;
121
122 tpg->lines[pat][plane] =
123 vzalloc(array3_size(max_w, 2, pixelsz));
124 if (!tpg->lines[pat][plane])
125 return -ENOMEM;
126 if (plane == 0)
127 continue;
128 tpg->downsampled_lines[pat][plane] =
129 vzalloc(array3_size(max_w, 2, pixelsz));
130 if (!tpg->downsampled_lines[pat][plane])
131 return -ENOMEM;
132 }
133 }
134 for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
135 unsigned pixelsz = plane ? 2 : 4;
136
137 tpg->contrast_line[plane] =
138 vzalloc(array_size(pixelsz, max_w));
139 if (!tpg->contrast_line[plane])
140 return -ENOMEM;
141 tpg->black_line[plane] =
142 vzalloc(array_size(pixelsz, max_w));
143 if (!tpg->black_line[plane])
144 return -ENOMEM;
145 tpg->random_line[plane] =
146 vzalloc(array3_size(max_w, 2, pixelsz));
147 if (!tpg->random_line[plane])
148 return -ENOMEM;
149 }
150 return 0;
151 }
152 EXPORT_SYMBOL_GPL(tpg_alloc);
153
154 void tpg_free(struct tpg_data *tpg)
155 {
156 unsigned pat;
157 unsigned plane;
158
159 for (pat = 0; pat < TPG_MAX_PAT_LINES; pat++)
160 for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
161 vfree(tpg->lines[pat][plane]);
162 tpg->lines[pat][plane] = NULL;
163 if (plane == 0)
164 continue;
165 vfree(tpg->downsampled_lines[pat][plane]);
166 tpg->downsampled_lines[pat][plane] = NULL;
167 }
168 for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
169 vfree(tpg->contrast_line[plane]);
170 vfree(tpg->black_line[plane]);
171 vfree(tpg->random_line[plane]);
172 tpg->contrast_line[plane] = NULL;
173 tpg->black_line[plane] = NULL;
174 tpg->random_line[plane] = NULL;
175 }
176 }
177 EXPORT_SYMBOL_GPL(tpg_free);
178
179 bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc)
180 {
181 tpg->fourcc = fourcc;
182 tpg->planes = 1;
183 tpg->buffers = 1;
184 tpg->recalc_colors = true;
185 tpg->interleaved = false;
186 tpg->vdownsampling[0] = 1;
187 tpg->hdownsampling[0] = 1;
188 tpg->hmask[0] = ~0;
189 tpg->hmask[1] = ~0;
190 tpg->hmask[2] = ~0;
191
192 switch (fourcc) {
193 case V4L2_PIX_FMT_SBGGR8:
194 case V4L2_PIX_FMT_SGBRG8:
195 case V4L2_PIX_FMT_SGRBG8:
196 case V4L2_PIX_FMT_SRGGB8:
197 case V4L2_PIX_FMT_SBGGR10:
198 case V4L2_PIX_FMT_SGBRG10:
199 case V4L2_PIX_FMT_SGRBG10:
200 case V4L2_PIX_FMT_SRGGB10:
201 case V4L2_PIX_FMT_SBGGR12:
202 case V4L2_PIX_FMT_SGBRG12:
203 case V4L2_PIX_FMT_SGRBG12:
204 case V4L2_PIX_FMT_SRGGB12:
205 tpg->interleaved = true;
206 tpg->vdownsampling[1] = 1;
207 tpg->hdownsampling[1] = 1;
208 tpg->planes = 2;
209 /* fall through */
210 case V4L2_PIX_FMT_RGB332:
211 case V4L2_PIX_FMT_RGB565:
212 case V4L2_PIX_FMT_RGB565X:
213 case V4L2_PIX_FMT_RGB444:
214 case V4L2_PIX_FMT_XRGB444:
215 case V4L2_PIX_FMT_ARGB444:
216 case V4L2_PIX_FMT_RGB555:
217 case V4L2_PIX_FMT_XRGB555:
218 case V4L2_PIX_FMT_ARGB555:
219 case V4L2_PIX_FMT_RGB555X:
220 case V4L2_PIX_FMT_XRGB555X:
221 case V4L2_PIX_FMT_ARGB555X:
222 case V4L2_PIX_FMT_BGR666:
223 case V4L2_PIX_FMT_RGB24:
224 case V4L2_PIX_FMT_BGR24:
225 case V4L2_PIX_FMT_RGB32:
226 case V4L2_PIX_FMT_BGR32:
227 case V4L2_PIX_FMT_XRGB32:
228 case V4L2_PIX_FMT_XBGR32:
229 case V4L2_PIX_FMT_ARGB32:
230 case V4L2_PIX_FMT_ABGR32:
231 tpg->color_enc = TGP_COLOR_ENC_RGB;
232 break;
233 case V4L2_PIX_FMT_GREY:
234 case V4L2_PIX_FMT_Y10:
235 case V4L2_PIX_FMT_Y12:
236 case V4L2_PIX_FMT_Y16:
237 case V4L2_PIX_FMT_Y16_BE:
238 tpg->color_enc = TGP_COLOR_ENC_LUMA;
239 break;
240 case V4L2_PIX_FMT_YUV444:
241 case V4L2_PIX_FMT_YUV555:
242 case V4L2_PIX_FMT_YUV565:
243 case V4L2_PIX_FMT_YUV32:
244 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
245 break;
246 case V4L2_PIX_FMT_YUV420M:
247 case V4L2_PIX_FMT_YVU420M:
248 tpg->buffers = 3;
249 /* fall through */
250 case V4L2_PIX_FMT_YUV420:
251 case V4L2_PIX_FMT_YVU420:
252 tpg->vdownsampling[1] = 2;
253 tpg->vdownsampling[2] = 2;
254 tpg->hdownsampling[1] = 2;
255 tpg->hdownsampling[2] = 2;
256 tpg->planes = 3;
257 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
258 break;
259 case V4L2_PIX_FMT_YUV422M:
260 case V4L2_PIX_FMT_YVU422M:
261 tpg->buffers = 3;
262 /* fall through */
263 case V4L2_PIX_FMT_YUV422P:
264 tpg->vdownsampling[1] = 1;
265 tpg->vdownsampling[2] = 1;
266 tpg->hdownsampling[1] = 2;
267 tpg->hdownsampling[2] = 2;
268 tpg->planes = 3;
269 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
270 break;
271 case V4L2_PIX_FMT_NV16M:
272 case V4L2_PIX_FMT_NV61M:
273 tpg->buffers = 2;
274 /* fall through */
275 case V4L2_PIX_FMT_NV16:
276 case V4L2_PIX_FMT_NV61:
277 tpg->vdownsampling[1] = 1;
278 tpg->hdownsampling[1] = 1;
279 tpg->hmask[1] = ~1;
280 tpg->planes = 2;
281 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
282 break;
283 case V4L2_PIX_FMT_NV12M:
284 case V4L2_PIX_FMT_NV21M:
285 tpg->buffers = 2;
286 /* fall through */
287 case V4L2_PIX_FMT_NV12:
288 case V4L2_PIX_FMT_NV21:
289 tpg->vdownsampling[1] = 2;
290 tpg->hdownsampling[1] = 1;
291 tpg->hmask[1] = ~1;
292 tpg->planes = 2;
293 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
294 break;
295 case V4L2_PIX_FMT_YUV444M:
296 case V4L2_PIX_FMT_YVU444M:
297 tpg->buffers = 3;
298 tpg->planes = 3;
299 tpg->vdownsampling[1] = 1;
300 tpg->vdownsampling[2] = 1;
301 tpg->hdownsampling[1] = 1;
302 tpg->hdownsampling[2] = 1;
303 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
304 break;
305 case V4L2_PIX_FMT_NV24:
306 case V4L2_PIX_FMT_NV42:
307 tpg->vdownsampling[1] = 1;
308 tpg->hdownsampling[1] = 1;
309 tpg->planes = 2;
310 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
311 break;
312 case V4L2_PIX_FMT_YUYV:
313 case V4L2_PIX_FMT_UYVY:
314 case V4L2_PIX_FMT_YVYU:
315 case V4L2_PIX_FMT_VYUY:
316 tpg->hmask[0] = ~1;
317 tpg->color_enc = TGP_COLOR_ENC_YCBCR;
318 break;
319 case V4L2_PIX_FMT_HSV24:
320 case V4L2_PIX_FMT_HSV32:
321 tpg->color_enc = TGP_COLOR_ENC_HSV;
322 break;
323 default:
324 return false;
325 }
326
327 switch (fourcc) {
328 case V4L2_PIX_FMT_GREY:
329 case V4L2_PIX_FMT_RGB332:
330 tpg->twopixelsize[0] = 2;
331 break;
332 case V4L2_PIX_FMT_RGB565:
333 case V4L2_PIX_FMT_RGB565X:
334 case V4L2_PIX_FMT_RGB444:
335 case V4L2_PIX_FMT_XRGB444:
336 case V4L2_PIX_FMT_ARGB444:
337 case V4L2_PIX_FMT_RGB555:
338 case V4L2_PIX_FMT_XRGB555:
339 case V4L2_PIX_FMT_ARGB555:
340 case V4L2_PIX_FMT_RGB555X:
341 case V4L2_PIX_FMT_XRGB555X:
342 case V4L2_PIX_FMT_ARGB555X:
343 case V4L2_PIX_FMT_YUYV:
344 case V4L2_PIX_FMT_UYVY:
345 case V4L2_PIX_FMT_YVYU:
346 case V4L2_PIX_FMT_VYUY:
347 case V4L2_PIX_FMT_YUV444:
348 case V4L2_PIX_FMT_YUV555:
349 case V4L2_PIX_FMT_YUV565:
350 case V4L2_PIX_FMT_Y10:
351 case V4L2_PIX_FMT_Y12:
352 case V4L2_PIX_FMT_Y16:
353 case V4L2_PIX_FMT_Y16_BE:
354 tpg->twopixelsize[0] = 2 * 2;
355 break;
356 case V4L2_PIX_FMT_RGB24:
357 case V4L2_PIX_FMT_BGR24:
358 case V4L2_PIX_FMT_HSV24:
359 tpg->twopixelsize[0] = 2 * 3;
360 break;
361 case V4L2_PIX_FMT_BGR666:
362 case V4L2_PIX_FMT_RGB32:
363 case V4L2_PIX_FMT_BGR32:
364 case V4L2_PIX_FMT_XRGB32:
365 case V4L2_PIX_FMT_XBGR32:
366 case V4L2_PIX_FMT_ARGB32:
367 case V4L2_PIX_FMT_ABGR32:
368 case V4L2_PIX_FMT_YUV32:
369 case V4L2_PIX_FMT_HSV32:
370 tpg->twopixelsize[0] = 2 * 4;
371 break;
372 case V4L2_PIX_FMT_NV12:
373 case V4L2_PIX_FMT_NV21:
374 case V4L2_PIX_FMT_NV12M:
375 case V4L2_PIX_FMT_NV21M:
376 case V4L2_PIX_FMT_NV16:
377 case V4L2_PIX_FMT_NV61:
378 case V4L2_PIX_FMT_NV16M:
379 case V4L2_PIX_FMT_NV61M:
380 case V4L2_PIX_FMT_SBGGR8:
381 case V4L2_PIX_FMT_SGBRG8:
382 case V4L2_PIX_FMT_SGRBG8:
383 case V4L2_PIX_FMT_SRGGB8:
384 tpg->twopixelsize[0] = 2;
385 tpg->twopixelsize[1] = 2;
386 break;
387 case V4L2_PIX_FMT_SRGGB10:
388 case V4L2_PIX_FMT_SGRBG10:
389 case V4L2_PIX_FMT_SGBRG10:
390 case V4L2_PIX_FMT_SBGGR10:
391 case V4L2_PIX_FMT_SRGGB12:
392 case V4L2_PIX_FMT_SGRBG12:
393 case V4L2_PIX_FMT_SGBRG12:
394 case V4L2_PIX_FMT_SBGGR12:
395 tpg->twopixelsize[0] = 4;
396 tpg->twopixelsize[1] = 4;
397 break;
398 case V4L2_PIX_FMT_YUV444M:
399 case V4L2_PIX_FMT_YVU444M:
400 case V4L2_PIX_FMT_YUV422M:
401 case V4L2_PIX_FMT_YVU422M:
402 case V4L2_PIX_FMT_YUV422P:
403 case V4L2_PIX_FMT_YUV420:
404 case V4L2_PIX_FMT_YVU420:
405 case V4L2_PIX_FMT_YUV420M:
406 case V4L2_PIX_FMT_YVU420M:
407 tpg->twopixelsize[0] = 2;
408 tpg->twopixelsize[1] = 2;
409 tpg->twopixelsize[2] = 2;
410 break;
411 case V4L2_PIX_FMT_NV24:
412 case V4L2_PIX_FMT_NV42:
413 tpg->twopixelsize[0] = 2;
414 tpg->twopixelsize[1] = 4;
415 break;
416 }
417 return true;
418 }
419 EXPORT_SYMBOL_GPL(tpg_s_fourcc);
420
421 void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
422 const struct v4l2_rect *compose)
423 {
424 tpg->crop = *crop;
425 tpg->compose = *compose;
426 tpg->scaled_width = (tpg->src_width * tpg->compose.width +
427 tpg->crop.width - 1) / tpg->crop.width;
428 tpg->scaled_width &= ~1;
429 if (tpg->scaled_width > tpg->max_line_width)
430 tpg->scaled_width = tpg->max_line_width;
431 if (tpg->scaled_width < 2)
432 tpg->scaled_width = 2;
433 tpg->recalc_lines = true;
434 }
435 EXPORT_SYMBOL_GPL(tpg_s_crop_compose);
436
437 void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
438 u32 field)
439 {
440 unsigned p;
441
442 tpg->src_width = width;
443 tpg->src_height = height;
444 tpg->field = field;
445 tpg->buf_height = height;
446 if (V4L2_FIELD_HAS_T_OR_B(field))
447 tpg->buf_height /= 2;
448 tpg->scaled_width = width;
449 tpg->crop.top = tpg->crop.left = 0;
450 tpg->crop.width = width;
451 tpg->crop.height = height;
452 tpg->compose.top = tpg->compose.left = 0;
453 tpg->compose.width = width;
454 tpg->compose.height = tpg->buf_height;
455 for (p = 0; p < tpg->planes; p++)
456 tpg->bytesperline[p] = (width * tpg->twopixelsize[p]) /
457 (2 * tpg->hdownsampling[p]);
458 tpg->recalc_square_border = true;
459 }
460 EXPORT_SYMBOL_GPL(tpg_reset_source);
461
462 static enum tpg_color tpg_get_textbg_color(struct tpg_data *tpg)
463 {
464 switch (tpg->pattern) {
465 case TPG_PAT_BLACK:
466 return TPG_COLOR_100_WHITE;
467 case TPG_PAT_CSC_COLORBAR:
468 return TPG_COLOR_CSC_BLACK;
469 default:
470 return TPG_COLOR_100_BLACK;
471 }
472 }
473
474 static enum tpg_color tpg_get_textfg_color(struct tpg_data *tpg)
475 {
476 switch (tpg->pattern) {
477 case TPG_PAT_75_COLORBAR:
478 case TPG_PAT_CSC_COLORBAR:
479 return TPG_COLOR_CSC_WHITE;
480 case TPG_PAT_BLACK:
481 return TPG_COLOR_100_BLACK;
482 default:
483 return TPG_COLOR_100_WHITE;
484 }
485 }
486
487 static inline int rec709_to_linear(int v)
488 {
489 v = clamp(v, 0, 0xff0);
490 return tpg_rec709_to_linear[v];
491 }
492
493 static inline int linear_to_rec709(int v)
494 {
495 v = clamp(v, 0, 0xff0);
496 return tpg_linear_to_rec709[v];
497 }
498
499 static void color_to_hsv(struct tpg_data *tpg, int r, int g, int b,
500 int *h, int *s, int *v)
501 {
502 int max_rgb, min_rgb, diff_rgb;
503 int aux;
504 int third;
505 int third_size;
506
507 r >>= 4;
508 g >>= 4;
509 b >>= 4;
510
511 /* Value */
512 max_rgb = max3(r, g, b);
513 *v = max_rgb;
514 if (!max_rgb) {
515 *h = 0;
516 *s = 0;
517 return;
518 }
519
520 /* Saturation */
521 min_rgb = min3(r, g, b);
522 diff_rgb = max_rgb - min_rgb;
523 aux = 255 * diff_rgb;
524 aux += max_rgb / 2;
525 aux /= max_rgb;
526 *s = aux;
527 if (!aux) {
528 *h = 0;
529 return;
530 }
531
532 third_size = (tpg->real_hsv_enc == V4L2_HSV_ENC_180) ? 60 : 85;
533
534 /* Hue */
535 if (max_rgb == r) {
536 aux = g - b;
537 third = 0;
538 } else if (max_rgb == g) {
539 aux = b - r;
540 third = third_size;
541 } else {
542 aux = r - g;
543 third = third_size * 2;
544 }
545
546 aux *= third_size / 2;
547 aux += diff_rgb / 2;
548 aux /= diff_rgb;
549 aux += third;
550
551 /* Clamp Hue */
552 if (tpg->real_hsv_enc == V4L2_HSV_ENC_180) {
553 if (aux < 0)
554 aux += 180;
555 else if (aux > 180)
556 aux -= 180;
557 } else {
558 aux = aux & 0xff;
559 }
560
561 *h = aux;
562 }
563
564 static void rgb2ycbcr(const int m[3][3], int r, int g, int b,
565 int y_offset, int *y, int *cb, int *cr)
566 {
567 *y = ((m[0][0] * r + m[0][1] * g + m[0][2] * b) >> 16) + (y_offset << 4);
568 *cb = ((m[1][0] * r + m[1][1] * g + m[1][2] * b) >> 16) + (128 << 4);
569 *cr = ((m[2][0] * r + m[2][1] * g + m[2][2] * b) >> 16) + (128 << 4);
570 }
571
572 static void color_to_ycbcr(struct tpg_data *tpg, int r, int g, int b,
573 int *y, int *cb, int *cr)
574 {
575 #define COEFF(v, r) ((int)(0.5 + (v) * (r) * 256.0))
576
577 static const int bt601[3][3] = {
578 { COEFF(0.299, 219), COEFF(0.587, 219), COEFF(0.114, 219) },
579 { COEFF(-0.1687, 224), COEFF(-0.3313, 224), COEFF(0.5, 224) },
580 { COEFF(0.5, 224), COEFF(-0.4187, 224), COEFF(-0.0813, 224) },
581 };
582 static const int bt601_full[3][3] = {
583 { COEFF(0.299, 255), COEFF(0.587, 255), COEFF(0.114, 255) },
584 { COEFF(-0.1687, 255), COEFF(-0.3313, 255), COEFF(0.5, 255) },
585 { COEFF(0.5, 255), COEFF(-0.4187, 255), COEFF(-0.0813, 255) },
586 };
587 static const int rec709[3][3] = {
588 { COEFF(0.2126, 219), COEFF(0.7152, 219), COEFF(0.0722, 219) },
589 { COEFF(-0.1146, 224), COEFF(-0.3854, 224), COEFF(0.5, 224) },
590 { COEFF(0.5, 224), COEFF(-0.4542, 224), COEFF(-0.0458, 224) },
591 };
592 static const int rec709_full[3][3] = {
593 { COEFF(0.2126, 255), COEFF(0.7152, 255), COEFF(0.0722, 255) },
594 { COEFF(-0.1146, 255), COEFF(-0.3854, 255), COEFF(0.5, 255) },
595 { COEFF(0.5, 255), COEFF(-0.4542, 255), COEFF(-0.0458, 255) },
596 };
597 static const int smpte240m[3][3] = {
598 { COEFF(0.212, 219), COEFF(0.701, 219), COEFF(0.087, 219) },
599 { COEFF(-0.116, 224), COEFF(-0.384, 224), COEFF(0.5, 224) },
600 { COEFF(0.5, 224), COEFF(-0.445, 224), COEFF(-0.055, 224) },
601 };
602 static const int smpte240m_full[3][3] = {
603 { COEFF(0.212, 255), COEFF(0.701, 255), COEFF(0.087, 255) },
604 { COEFF(-0.116, 255), COEFF(-0.384, 255), COEFF(0.5, 255) },
605 { COEFF(0.5, 255), COEFF(-0.445, 255), COEFF(-0.055, 255) },
606 };
607 static const int bt2020[3][3] = {
608 { COEFF(0.2627, 219), COEFF(0.6780, 219), COEFF(0.0593, 219) },
609 { COEFF(-0.1396, 224), COEFF(-0.3604, 224), COEFF(0.5, 224) },
610 { COEFF(0.5, 224), COEFF(-0.4598, 224), COEFF(-0.0402, 224) },
611 };
612 static const int bt2020_full[3][3] = {
613 { COEFF(0.2627, 255), COEFF(0.6780, 255), COEFF(0.0593, 255) },
614 { COEFF(-0.1396, 255), COEFF(-0.3604, 255), COEFF(0.5, 255) },
615 { COEFF(0.5, 255), COEFF(-0.4598, 255), COEFF(-0.0402, 255) },
616 };
617 static const int bt2020c[4] = {
618 COEFF(1.0 / 1.9404, 224), COEFF(1.0 / 1.5816, 224),
619 COEFF(1.0 / 1.7184, 224), COEFF(1.0 / 0.9936, 224),
620 };
621 static const int bt2020c_full[4] = {
622 COEFF(1.0 / 1.9404, 255), COEFF(1.0 / 1.5816, 255),
623 COEFF(1.0 / 1.7184, 255), COEFF(1.0 / 0.9936, 255),
624 };
625
626 bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
627 unsigned y_offset = full ? 0 : 16;
628 int lin_y, yc;
629
630 switch (tpg->real_ycbcr_enc) {
631 case V4L2_YCBCR_ENC_601:
632 rgb2ycbcr(full ? bt601_full : bt601, r, g, b, y_offset, y, cb, cr);
633 break;
634 case V4L2_YCBCR_ENC_XV601:
635 /* Ignore quantization range, there is only one possible
636 * Y'CbCr encoding. */
637 rgb2ycbcr(bt601, r, g, b, 16, y, cb, cr);
638 break;
639 case V4L2_YCBCR_ENC_XV709:
640 /* Ignore quantization range, there is only one possible
641 * Y'CbCr encoding. */
642 rgb2ycbcr(rec709, r, g, b, 16, y, cb, cr);
643 break;
644 case V4L2_YCBCR_ENC_BT2020:
645 rgb2ycbcr(full ? bt2020_full : bt2020, r, g, b, y_offset, y, cb, cr);
646 break;
647 case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
648 lin_y = (COEFF(0.2627, 255) * rec709_to_linear(r) +
649 COEFF(0.6780, 255) * rec709_to_linear(g) +
650 COEFF(0.0593, 255) * rec709_to_linear(b)) >> 16;
651 yc = linear_to_rec709(lin_y);
652 *y = full ? yc : (yc * 219) / 255 + (16 << 4);
653 if (b <= yc)
654 *cb = (((b - yc) * (full ? bt2020c_full[0] : bt2020c[0])) >> 16) + (128 << 4);
655 else
656 *cb = (((b - yc) * (full ? bt2020c_full[1] : bt2020c[1])) >> 16) + (128 << 4);
657 if (r <= yc)
658 *cr = (((r - yc) * (full ? bt2020c_full[2] : bt2020c[2])) >> 16) + (128 << 4);
659 else
660 *cr = (((r - yc) * (full ? bt2020c_full[3] : bt2020c[3])) >> 16) + (128 << 4);
661 break;
662 case V4L2_YCBCR_ENC_SMPTE240M:
663 rgb2ycbcr(full ? smpte240m_full : smpte240m, r, g, b, y_offset, y, cb, cr);
664 break;
665 case V4L2_YCBCR_ENC_709:
666 default:
667 rgb2ycbcr(full ? rec709_full : rec709, r, g, b, y_offset, y, cb, cr);
668 break;
669 }
670 }
671
672 static void ycbcr2rgb(const int m[3][3], int y, int cb, int cr,
673 int y_offset, int *r, int *g, int *b)
674 {
675 y -= y_offset << 4;
676 cb -= 128 << 4;
677 cr -= 128 << 4;
678 *r = m[0][0] * y + m[0][1] * cb + m[0][2] * cr;
679 *g = m[1][0] * y + m[1][1] * cb + m[1][2] * cr;
680 *b = m[2][0] * y + m[2][1] * cb + m[2][2] * cr;
681 *r = clamp(*r >> 12, 0, 0xff0);
682 *g = clamp(*g >> 12, 0, 0xff0);
683 *b = clamp(*b >> 12, 0, 0xff0);
684 }
685
686 static void ycbcr_to_color(struct tpg_data *tpg, int y, int cb, int cr,
687 int *r, int *g, int *b)
688 {
689 #undef COEFF
690 #define COEFF(v, r) ((int)(0.5 + (v) * ((255.0 * 255.0 * 16.0) / (r))))
691 static const int bt601[3][3] = {
692 { COEFF(1, 219), COEFF(0, 224), COEFF(1.4020, 224) },
693 { COEFF(1, 219), COEFF(-0.3441, 224), COEFF(-0.7141, 224) },
694 { COEFF(1, 219), COEFF(1.7720, 224), COEFF(0, 224) },
695 };
696 static const int bt601_full[3][3] = {
697 { COEFF(1, 255), COEFF(0, 255), COEFF(1.4020, 255) },
698 { COEFF(1, 255), COEFF(-0.3441, 255), COEFF(-0.7141, 255) },
699 { COEFF(1, 255), COEFF(1.7720, 255), COEFF(0, 255) },
700 };
701 static const int rec709[3][3] = {
702 { COEFF(1, 219), COEFF(0, 224), COEFF(1.5748, 224) },
703 { COEFF(1, 219), COEFF(-0.1873, 224), COEFF(-0.4681, 224) },
704 { COEFF(1, 219), COEFF(1.8556, 224), COEFF(0, 224) },
705 };
706 static const int rec709_full[3][3] = {
707 { COEFF(1, 255), COEFF(0, 255), COEFF(1.5748, 255) },
708 { COEFF(1, 255), COEFF(-0.1873, 255), COEFF(-0.4681, 255) },
709 { COEFF(1, 255), COEFF(1.8556, 255), COEFF(0, 255) },
710 };
711 static const int smpte240m[3][3] = {
712 { COEFF(1, 219), COEFF(0, 224), COEFF(1.5756, 224) },
713 { COEFF(1, 219), COEFF(-0.2253, 224), COEFF(-0.4767, 224) },
714 { COEFF(1, 219), COEFF(1.8270, 224), COEFF(0, 224) },
715 };
716 static const int smpte240m_full[3][3] = {
717 { COEFF(1, 255), COEFF(0, 255), COEFF(1.5756, 255) },
718 { COEFF(1, 255), COEFF(-0.2253, 255), COEFF(-0.4767, 255) },
719 { COEFF(1, 255), COEFF(1.8270, 255), COEFF(0, 255) },
720 };
721 static const int bt2020[3][3] = {
722 { COEFF(1, 219), COEFF(0, 224), COEFF(1.4746, 224) },
723 { COEFF(1, 219), COEFF(-0.1646, 224), COEFF(-0.5714, 224) },
724 { COEFF(1, 219), COEFF(1.8814, 224), COEFF(0, 224) },
725 };
726 static const int bt2020_full[3][3] = {
727 { COEFF(1, 255), COEFF(0, 255), COEFF(1.4746, 255) },
728 { COEFF(1, 255), COEFF(-0.1646, 255), COEFF(-0.5714, 255) },
729 { COEFF(1, 255), COEFF(1.8814, 255), COEFF(0, 255) },
730 };
731 static const int bt2020c[4] = {
732 COEFF(1.9404, 224), COEFF(1.5816, 224),
733 COEFF(1.7184, 224), COEFF(0.9936, 224),
734 };
735 static const int bt2020c_full[4] = {
736 COEFF(1.9404, 255), COEFF(1.5816, 255),
737 COEFF(1.7184, 255), COEFF(0.9936, 255),
738 };
739
740 bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
741 unsigned y_offset = full ? 0 : 16;
742 int y_fac = full ? COEFF(1.0, 255) : COEFF(1.0, 219);
743 int lin_r, lin_g, lin_b, lin_y;
744
745 switch (tpg->real_ycbcr_enc) {
746 case V4L2_YCBCR_ENC_601:
747 ycbcr2rgb(full ? bt601_full : bt601, y, cb, cr, y_offset, r, g, b);
748 break;
749 case V4L2_YCBCR_ENC_XV601:
750 /* Ignore quantization range, there is only one possible
751 * Y'CbCr encoding. */
752 ycbcr2rgb(bt601, y, cb, cr, 16, r, g, b);
753 break;
754 case V4L2_YCBCR_ENC_XV709:
755 /* Ignore quantization range, there is only one possible
756 * Y'CbCr encoding. */
757 ycbcr2rgb(rec709, y, cb, cr, 16, r, g, b);
758 break;
759 case V4L2_YCBCR_ENC_BT2020:
760 ycbcr2rgb(full ? bt2020_full : bt2020, y, cb, cr, y_offset, r, g, b);
761 break;
762 case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
763 y -= full ? 0 : 16 << 4;
764 cb -= 128 << 4;
765 cr -= 128 << 4;
766
767 if (cb <= 0)
768 *b = y_fac * y + (full ? bt2020c_full[0] : bt2020c[0]) * cb;
769 else
770 *b = y_fac * y + (full ? bt2020c_full[1] : bt2020c[1]) * cb;
771 *b = *b >> 12;
772 if (cr <= 0)
773 *r = y_fac * y + (full ? bt2020c_full[2] : bt2020c[2]) * cr;
774 else
775 *r = y_fac * y + (full ? bt2020c_full[3] : bt2020c[3]) * cr;
776 *r = *r >> 12;
777 lin_r = rec709_to_linear(*r);
778 lin_b = rec709_to_linear(*b);
779 lin_y = rec709_to_linear((y * 255) / (full ? 255 : 219));
780
781 lin_g = COEFF(1.0 / 0.6780, 255) * lin_y -
782 COEFF(0.2627 / 0.6780, 255) * lin_r -
783 COEFF(0.0593 / 0.6780, 255) * lin_b;
784 *g = linear_to_rec709(lin_g >> 12);
785 break;
786 case V4L2_YCBCR_ENC_SMPTE240M:
787 ycbcr2rgb(full ? smpte240m_full : smpte240m, y, cb, cr, y_offset, r, g, b);
788 break;
789 case V4L2_YCBCR_ENC_709:
790 default:
791 ycbcr2rgb(full ? rec709_full : rec709, y, cb, cr, y_offset, r, g, b);
792 break;
793 }
794 }
795
796 /* precalculate color bar values to speed up rendering */
797 static void precalculate_color(struct tpg_data *tpg, int k)
798 {
799 int col = k;
800 int r = tpg_colors[col].r;
801 int g = tpg_colors[col].g;
802 int b = tpg_colors[col].b;
803 int y, cb, cr;
804 bool ycbcr_valid = false;
805
806 if (k == TPG_COLOR_TEXTBG) {
807 col = tpg_get_textbg_color(tpg);
808
809 r = tpg_colors[col].r;
810 g = tpg_colors[col].g;
811 b = tpg_colors[col].b;
812 } else if (k == TPG_COLOR_TEXTFG) {
813 col = tpg_get_textfg_color(tpg);
814
815 r = tpg_colors[col].r;
816 g = tpg_colors[col].g;
817 b = tpg_colors[col].b;
818 } else if (tpg->pattern == TPG_PAT_NOISE) {
819 r = g = b = prandom_u32_max(256);
820 } else if (k == TPG_COLOR_RANDOM) {
821 r = g = b = tpg->qual_offset + prandom_u32_max(196);
822 } else if (k >= TPG_COLOR_RAMP) {
823 r = g = b = k - TPG_COLOR_RAMP;
824 }
825
826 if (tpg->pattern == TPG_PAT_CSC_COLORBAR && col <= TPG_COLOR_CSC_BLACK) {
827 r = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].r;
828 g = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].g;
829 b = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].b;
830 } else {
831 r <<= 4;
832 g <<= 4;
833 b <<= 4;
834 }
835
836 if (tpg->qual == TPG_QUAL_GRAY ||
837 tpg->color_enc == TGP_COLOR_ENC_LUMA) {
838 /* Rec. 709 Luma function */
839 /* (0.2126, 0.7152, 0.0722) * (255 * 256) */
840 r = g = b = (13879 * r + 46688 * g + 4713 * b) >> 16;
841 }
842
843 /*
844 * The assumption is that the RGB output is always full range,
845 * so only if the rgb_range overrides the 'real' rgb range do
846 * we need to convert the RGB values.
847 *
848 * Remember that r, g and b are still in the 0 - 0xff0 range.
849 */
850 if (tpg->real_rgb_range == V4L2_DV_RGB_RANGE_LIMITED &&
851 tpg->rgb_range == V4L2_DV_RGB_RANGE_FULL &&
852 tpg->color_enc == TGP_COLOR_ENC_RGB) {
853 /*
854 * Convert from full range (which is what r, g and b are)
855 * to limited range (which is the 'real' RGB range), which
856 * is then interpreted as full range.
857 */
858 r = (r * 219) / 255 + (16 << 4);
859 g = (g * 219) / 255 + (16 << 4);
860 b = (b * 219) / 255 + (16 << 4);
861 } else if (tpg->real_rgb_range != V4L2_DV_RGB_RANGE_LIMITED &&
862 tpg->rgb_range == V4L2_DV_RGB_RANGE_LIMITED &&
863 tpg->color_enc == TGP_COLOR_ENC_RGB) {
864
865 /*
866 * Clamp r, g and b to the limited range and convert to full
867 * range since that's what we deliver.
868 */
869 r = clamp(r, 16 << 4, 235 << 4);
870 g = clamp(g, 16 << 4, 235 << 4);
871 b = clamp(b, 16 << 4, 235 << 4);
872 r = (r - (16 << 4)) * 255 / 219;
873 g = (g - (16 << 4)) * 255 / 219;
874 b = (b - (16 << 4)) * 255 / 219;
875 }
876
877 if ((tpg->brightness != 128 || tpg->contrast != 128 ||
878 tpg->saturation != 128 || tpg->hue) &&
879 tpg->color_enc != TGP_COLOR_ENC_LUMA) {
880 /* Implement these operations */
881 int tmp_cb, tmp_cr;
882
883 /* First convert to YCbCr */
884
885 color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
886
887 y = (16 << 4) + ((y - (16 << 4)) * tpg->contrast) / 128;
888 y += (tpg->brightness << 4) - (128 << 4);
889
890 cb -= 128 << 4;
891 cr -= 128 << 4;
892 tmp_cb = (cb * cos(128 + tpg->hue)) / 127 + (cr * sin[128 + tpg->hue]) / 127;
893 tmp_cr = (cr * cos(128 + tpg->hue)) / 127 - (cb * sin[128 + tpg->hue]) / 127;
894
895 cb = (128 << 4) + (tmp_cb * tpg->contrast * tpg->saturation) / (128 * 128);
896 cr = (128 << 4) + (tmp_cr * tpg->contrast * tpg->saturation) / (128 * 128);
897 if (tpg->color_enc == TGP_COLOR_ENC_YCBCR)
898 ycbcr_valid = true;
899 else
900 ycbcr_to_color(tpg, y, cb, cr, &r, &g, &b);
901 } else if ((tpg->brightness != 128 || tpg->contrast != 128) &&
902 tpg->color_enc == TGP_COLOR_ENC_LUMA) {
903 r = (16 << 4) + ((r - (16 << 4)) * tpg->contrast) / 128;
904 r += (tpg->brightness << 4) - (128 << 4);
905 }
906
907 switch (tpg->color_enc) {
908 case TGP_COLOR_ENC_HSV:
909 {
910 int h, s, v;
911
912 color_to_hsv(tpg, r, g, b, &h, &s, &v);
913 tpg->colors[k][0] = h;
914 tpg->colors[k][1] = s;
915 tpg->colors[k][2] = v;
916 break;
917 }
918 case TGP_COLOR_ENC_YCBCR:
919 {
920 /* Convert to YCbCr */
921 if (!ycbcr_valid)
922 color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
923
924 y >>= 4;
925 cb >>= 4;
926 cr >>= 4;
927 /*
928 * XV601/709 use the header/footer margins to encode R', G'
929 * and B' values outside the range [0-1]. So do not clamp
930 * XV601/709 values.
931 */
932 if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE &&
933 tpg->real_ycbcr_enc != V4L2_YCBCR_ENC_XV601 &&
934 tpg->real_ycbcr_enc != V4L2_YCBCR_ENC_XV709) {
935 y = clamp(y, 16, 235);
936 cb = clamp(cb, 16, 240);
937 cr = clamp(cr, 16, 240);
938 } else {
939 y = clamp(y, 1, 254);
940 cb = clamp(cb, 1, 254);
941 cr = clamp(cr, 1, 254);
942 }
943 switch (tpg->fourcc) {
944 case V4L2_PIX_FMT_YUV444:
945 y >>= 4;
946 cb >>= 4;
947 cr >>= 4;
948 break;
949 case V4L2_PIX_FMT_YUV555:
950 y >>= 3;
951 cb >>= 3;
952 cr >>= 3;
953 break;
954 case V4L2_PIX_FMT_YUV565:
955 y >>= 3;
956 cb >>= 2;
957 cr >>= 3;
958 break;
959 }
960 tpg->colors[k][0] = y;
961 tpg->colors[k][1] = cb;
962 tpg->colors[k][2] = cr;
963 break;
964 }
965 case TGP_COLOR_ENC_LUMA:
966 {
967 tpg->colors[k][0] = r >> 4;
968 break;
969 }
970 case TGP_COLOR_ENC_RGB:
971 {
972 if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
973 r = (r * 219) / 255 + (16 << 4);
974 g = (g * 219) / 255 + (16 << 4);
975 b = (b * 219) / 255 + (16 << 4);
976 }
977 switch (tpg->fourcc) {
978 case V4L2_PIX_FMT_RGB332:
979 r >>= 9;
980 g >>= 9;
981 b >>= 10;
982 break;
983 case V4L2_PIX_FMT_RGB565:
984 case V4L2_PIX_FMT_RGB565X:
985 r >>= 7;
986 g >>= 6;
987 b >>= 7;
988 break;
989 case V4L2_PIX_FMT_RGB444:
990 case V4L2_PIX_FMT_XRGB444:
991 case V4L2_PIX_FMT_ARGB444:
992 r >>= 8;
993 g >>= 8;
994 b >>= 8;
995 break;
996 case V4L2_PIX_FMT_RGB555:
997 case V4L2_PIX_FMT_XRGB555:
998 case V4L2_PIX_FMT_ARGB555:
999 case V4L2_PIX_FMT_RGB555X:
1000 case V4L2_PIX_FMT_XRGB555X:
1001 case V4L2_PIX_FMT_ARGB555X:
1002 r >>= 7;
1003 g >>= 7;
1004 b >>= 7;
1005 break;
1006 case V4L2_PIX_FMT_BGR666:
1007 r >>= 6;
1008 g >>= 6;
1009 b >>= 6;
1010 break;
1011 default:
1012 r >>= 4;
1013 g >>= 4;
1014 b >>= 4;
1015 break;
1016 }
1017
1018 tpg->colors[k][0] = r;
1019 tpg->colors[k][1] = g;
1020 tpg->colors[k][2] = b;
1021 break;
1022 }
1023 }
1024 }
1025
1026 static void tpg_precalculate_colors(struct tpg_data *tpg)
1027 {
1028 int k;
1029
1030 for (k = 0; k < TPG_COLOR_MAX; k++)
1031 precalculate_color(tpg, k);
1032 }
1033
1034 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
1035 static void gen_twopix(struct tpg_data *tpg,
1036 u8 buf[TPG_MAX_PLANES][8], int color, bool odd)
1037 {
1038 unsigned offset = odd * tpg->twopixelsize[0] / 2;
1039 u8 alpha = tpg->alpha_component;
1040 u8 r_y_h, g_u_s, b_v;
1041
1042 if (tpg->alpha_red_only && color != TPG_COLOR_CSC_RED &&
1043 color != TPG_COLOR_100_RED &&
1044 color != TPG_COLOR_75_RED)
1045 alpha = 0;
1046 if (color == TPG_COLOR_RANDOM)
1047 precalculate_color(tpg, color);
1048 r_y_h = tpg->colors[color][0]; /* R or precalculated Y, H */
1049 g_u_s = tpg->colors[color][1]; /* G or precalculated U, V */
1050 b_v = tpg->colors[color][2]; /* B or precalculated V */
1051
1052 switch (tpg->fourcc) {
1053 case V4L2_PIX_FMT_GREY:
1054 buf[0][offset] = r_y_h;
1055 break;
1056 case V4L2_PIX_FMT_Y10:
1057 buf[0][offset] = (r_y_h << 2) & 0xff;
1058 buf[0][offset+1] = r_y_h >> 6;
1059 break;
1060 case V4L2_PIX_FMT_Y12:
1061 buf[0][offset] = (r_y_h << 4) & 0xff;
1062 buf[0][offset+1] = r_y_h >> 4;
1063 break;
1064 case V4L2_PIX_FMT_Y16:
1065 /*
1066 * Ideally both bytes should be set to r_y_h, but then you won't
1067 * be able to detect endian problems. So keep it 0 except for
1068 * the corner case where r_y_h is 0xff so white really will be
1069 * white (0xffff).
1070 */
1071 buf[0][offset] = r_y_h == 0xff ? r_y_h : 0;
1072 buf[0][offset+1] = r_y_h;
1073 break;
1074 case V4L2_PIX_FMT_Y16_BE:
1075 /* See comment for V4L2_PIX_FMT_Y16 above */
1076 buf[0][offset] = r_y_h;
1077 buf[0][offset+1] = r_y_h == 0xff ? r_y_h : 0;
1078 break;
1079 case V4L2_PIX_FMT_YUV422M:
1080 case V4L2_PIX_FMT_YUV422P:
1081 case V4L2_PIX_FMT_YUV420:
1082 case V4L2_PIX_FMT_YUV420M:
1083 buf[0][offset] = r_y_h;
1084 if (odd) {
1085 buf[1][0] = (buf[1][0] + g_u_s) / 2;
1086 buf[2][0] = (buf[2][0] + b_v) / 2;
1087 buf[1][1] = buf[1][0];
1088 buf[2][1] = buf[2][0];
1089 break;
1090 }
1091 buf[1][0] = g_u_s;
1092 buf[2][0] = b_v;
1093 break;
1094 case V4L2_PIX_FMT_YVU422M:
1095 case V4L2_PIX_FMT_YVU420:
1096 case V4L2_PIX_FMT_YVU420M:
1097 buf[0][offset] = r_y_h;
1098 if (odd) {
1099 buf[1][0] = (buf[1][0] + b_v) / 2;
1100 buf[2][0] = (buf[2][0] + g_u_s) / 2;
1101 buf[1][1] = buf[1][0];
1102 buf[2][1] = buf[2][0];
1103 break;
1104 }
1105 buf[1][0] = b_v;
1106 buf[2][0] = g_u_s;
1107 break;
1108
1109 case V4L2_PIX_FMT_NV12:
1110 case V4L2_PIX_FMT_NV12M:
1111 case V4L2_PIX_FMT_NV16:
1112 case V4L2_PIX_FMT_NV16M:
1113 buf[0][offset] = r_y_h;
1114 if (odd) {
1115 buf[1][0] = (buf[1][0] + g_u_s) / 2;
1116 buf[1][1] = (buf[1][1] + b_v) / 2;
1117 break;
1118 }
1119 buf[1][0] = g_u_s;
1120 buf[1][1] = b_v;
1121 break;
1122 case V4L2_PIX_FMT_NV21:
1123 case V4L2_PIX_FMT_NV21M:
1124 case V4L2_PIX_FMT_NV61:
1125 case V4L2_PIX_FMT_NV61M:
1126 buf[0][offset] = r_y_h;
1127 if (odd) {
1128 buf[1][0] = (buf[1][0] + b_v) / 2;
1129 buf[1][1] = (buf[1][1] + g_u_s) / 2;
1130 break;
1131 }
1132 buf[1][0] = b_v;
1133 buf[1][1] = g_u_s;
1134 break;
1135
1136 case V4L2_PIX_FMT_YUV444M:
1137 buf[0][offset] = r_y_h;
1138 buf[1][offset] = g_u_s;
1139 buf[2][offset] = b_v;
1140 break;
1141
1142 case V4L2_PIX_FMT_YVU444M:
1143 buf[0][offset] = r_y_h;
1144 buf[1][offset] = b_v;
1145 buf[2][offset] = g_u_s;
1146 break;
1147
1148 case V4L2_PIX_FMT_NV24:
1149 buf[0][offset] = r_y_h;
1150 buf[1][2 * offset] = g_u_s;
1151 buf[1][(2 * offset + 1) % 8] = b_v;
1152 break;
1153
1154 case V4L2_PIX_FMT_NV42:
1155 buf[0][offset] = r_y_h;
1156 buf[1][2 * offset] = b_v;
1157 buf[1][(2 * offset + 1) % 8] = g_u_s;
1158 break;
1159
1160 case V4L2_PIX_FMT_YUYV:
1161 buf[0][offset] = r_y_h;
1162 if (odd) {
1163 buf[0][1] = (buf[0][1] + g_u_s) / 2;
1164 buf[0][3] = (buf[0][3] + b_v) / 2;
1165 break;
1166 }
1167 buf[0][1] = g_u_s;
1168 buf[0][3] = b_v;
1169 break;
1170 case V4L2_PIX_FMT_UYVY:
1171 buf[0][offset + 1] = r_y_h;
1172 if (odd) {
1173 buf[0][0] = (buf[0][0] + g_u_s) / 2;
1174 buf[0][2] = (buf[0][2] + b_v) / 2;
1175 break;
1176 }
1177 buf[0][0] = g_u_s;
1178 buf[0][2] = b_v;
1179 break;
1180 case V4L2_PIX_FMT_YVYU:
1181 buf[0][offset] = r_y_h;
1182 if (odd) {
1183 buf[0][1] = (buf[0][1] + b_v) / 2;
1184 buf[0][3] = (buf[0][3] + g_u_s) / 2;
1185 break;
1186 }
1187 buf[0][1] = b_v;
1188 buf[0][3] = g_u_s;
1189 break;
1190 case V4L2_PIX_FMT_VYUY:
1191 buf[0][offset + 1] = r_y_h;
1192 if (odd) {
1193 buf[0][0] = (buf[0][0] + b_v) / 2;
1194 buf[0][2] = (buf[0][2] + g_u_s) / 2;
1195 break;
1196 }
1197 buf[0][0] = b_v;
1198 buf[0][2] = g_u_s;
1199 break;
1200 case V4L2_PIX_FMT_RGB332:
1201 buf[0][offset] = (r_y_h << 5) | (g_u_s << 2) | b_v;
1202 break;
1203 case V4L2_PIX_FMT_YUV565:
1204 case V4L2_PIX_FMT_RGB565:
1205 buf[0][offset] = (g_u_s << 5) | b_v;
1206 buf[0][offset + 1] = (r_y_h << 3) | (g_u_s >> 3);
1207 break;
1208 case V4L2_PIX_FMT_RGB565X:
1209 buf[0][offset] = (r_y_h << 3) | (g_u_s >> 3);
1210 buf[0][offset + 1] = (g_u_s << 5) | b_v;
1211 break;
1212 case V4L2_PIX_FMT_RGB444:
1213 case V4L2_PIX_FMT_XRGB444:
1214 alpha = 0;
1215 /* fall through */
1216 case V4L2_PIX_FMT_YUV444:
1217 case V4L2_PIX_FMT_ARGB444:
1218 buf[0][offset] = (g_u_s << 4) | b_v;
1219 buf[0][offset + 1] = (alpha & 0xf0) | r_y_h;
1220 break;
1221 case V4L2_PIX_FMT_RGB555:
1222 case V4L2_PIX_FMT_XRGB555:
1223 alpha = 0;
1224 /* fall through */
1225 case V4L2_PIX_FMT_YUV555:
1226 case V4L2_PIX_FMT_ARGB555:
1227 buf[0][offset] = (g_u_s << 5) | b_v;
1228 buf[0][offset + 1] = (alpha & 0x80) | (r_y_h << 2)
1229 | (g_u_s >> 3);
1230 break;
1231 case V4L2_PIX_FMT_RGB555X:
1232 case V4L2_PIX_FMT_XRGB555X:
1233 alpha = 0;
1234 /* fall through */
1235 case V4L2_PIX_FMT_ARGB555X:
1236 buf[0][offset] = (alpha & 0x80) | (r_y_h << 2) | (g_u_s >> 3);
1237 buf[0][offset + 1] = (g_u_s << 5) | b_v;
1238 break;
1239 case V4L2_PIX_FMT_RGB24:
1240 case V4L2_PIX_FMT_HSV24:
1241 buf[0][offset] = r_y_h;
1242 buf[0][offset + 1] = g_u_s;
1243 buf[0][offset + 2] = b_v;
1244 break;
1245 case V4L2_PIX_FMT_BGR24:
1246 buf[0][offset] = b_v;
1247 buf[0][offset + 1] = g_u_s;
1248 buf[0][offset + 2] = r_y_h;
1249 break;
1250 case V4L2_PIX_FMT_BGR666:
1251 buf[0][offset] = (b_v << 2) | (g_u_s >> 4);
1252 buf[0][offset + 1] = (g_u_s << 4) | (r_y_h >> 2);
1253 buf[0][offset + 2] = r_y_h << 6;
1254 buf[0][offset + 3] = 0;
1255 break;
1256 case V4L2_PIX_FMT_RGB32:
1257 case V4L2_PIX_FMT_XRGB32:
1258 case V4L2_PIX_FMT_HSV32:
1259 alpha = 0;
1260 /* fall through */
1261 case V4L2_PIX_FMT_YUV32:
1262 case V4L2_PIX_FMT_ARGB32:
1263 buf[0][offset] = alpha;
1264 buf[0][offset + 1] = r_y_h;
1265 buf[0][offset + 2] = g_u_s;
1266 buf[0][offset + 3] = b_v;
1267 break;
1268 case V4L2_PIX_FMT_BGR32:
1269 case V4L2_PIX_FMT_XBGR32:
1270 alpha = 0;
1271 /* fall through */
1272 case V4L2_PIX_FMT_ABGR32:
1273 buf[0][offset] = b_v;
1274 buf[0][offset + 1] = g_u_s;
1275 buf[0][offset + 2] = r_y_h;
1276 buf[0][offset + 3] = alpha;
1277 break;
1278 case V4L2_PIX_FMT_SBGGR8:
1279 buf[0][offset] = odd ? g_u_s : b_v;
1280 buf[1][offset] = odd ? r_y_h : g_u_s;
1281 break;
1282 case V4L2_PIX_FMT_SGBRG8:
1283 buf[0][offset] = odd ? b_v : g_u_s;
1284 buf[1][offset] = odd ? g_u_s : r_y_h;
1285 break;
1286 case V4L2_PIX_FMT_SGRBG8:
1287 buf[0][offset] = odd ? r_y_h : g_u_s;
1288 buf[1][offset] = odd ? g_u_s : b_v;
1289 break;
1290 case V4L2_PIX_FMT_SRGGB8:
1291 buf[0][offset] = odd ? g_u_s : r_y_h;
1292 buf[1][offset] = odd ? b_v : g_u_s;
1293 break;
1294 case V4L2_PIX_FMT_SBGGR10:
1295 buf[0][offset] = odd ? g_u_s << 2 : b_v << 2;
1296 buf[0][offset + 1] = odd ? g_u_s >> 6 : b_v >> 6;
1297 buf[1][offset] = odd ? r_y_h << 2 : g_u_s << 2;
1298 buf[1][offset + 1] = odd ? r_y_h >> 6 : g_u_s >> 6;
1299 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1300 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1301 break;
1302 case V4L2_PIX_FMT_SGBRG10:
1303 buf[0][offset] = odd ? b_v << 2 : g_u_s << 2;
1304 buf[0][offset + 1] = odd ? b_v >> 6 : g_u_s >> 6;
1305 buf[1][offset] = odd ? g_u_s << 2 : r_y_h << 2;
1306 buf[1][offset + 1] = odd ? g_u_s >> 6 : r_y_h >> 6;
1307 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1308 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1309 break;
1310 case V4L2_PIX_FMT_SGRBG10:
1311 buf[0][offset] = odd ? r_y_h << 2 : g_u_s << 2;
1312 buf[0][offset + 1] = odd ? r_y_h >> 6 : g_u_s >> 6;
1313 buf[1][offset] = odd ? g_u_s << 2 : b_v << 2;
1314 buf[1][offset + 1] = odd ? g_u_s >> 6 : b_v >> 6;
1315 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1316 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1317 break;
1318 case V4L2_PIX_FMT_SRGGB10:
1319 buf[0][offset] = odd ? g_u_s << 2 : r_y_h << 2;
1320 buf[0][offset + 1] = odd ? g_u_s >> 6 : r_y_h >> 6;
1321 buf[1][offset] = odd ? b_v << 2 : g_u_s << 2;
1322 buf[1][offset + 1] = odd ? b_v >> 6 : g_u_s >> 6;
1323 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1324 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1325 break;
1326 case V4L2_PIX_FMT_SBGGR12:
1327 buf[0][offset] = odd ? g_u_s << 4 : b_v << 4;
1328 buf[0][offset + 1] = odd ? g_u_s >> 4 : b_v >> 4;
1329 buf[1][offset] = odd ? r_y_h << 4 : g_u_s << 4;
1330 buf[1][offset + 1] = odd ? r_y_h >> 4 : g_u_s >> 4;
1331 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1332 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1333 break;
1334 case V4L2_PIX_FMT_SGBRG12:
1335 buf[0][offset] = odd ? b_v << 4 : g_u_s << 4;
1336 buf[0][offset + 1] = odd ? b_v >> 4 : g_u_s >> 4;
1337 buf[1][offset] = odd ? g_u_s << 4 : r_y_h << 4;
1338 buf[1][offset + 1] = odd ? g_u_s >> 4 : r_y_h >> 4;
1339 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1340 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1341 break;
1342 case V4L2_PIX_FMT_SGRBG12:
1343 buf[0][offset] = odd ? r_y_h << 4 : g_u_s << 4;
1344 buf[0][offset + 1] = odd ? r_y_h >> 4 : g_u_s >> 4;
1345 buf[1][offset] = odd ? g_u_s << 4 : b_v << 4;
1346 buf[1][offset + 1] = odd ? g_u_s >> 4 : b_v >> 4;
1347 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1348 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1349 break;
1350 case V4L2_PIX_FMT_SRGGB12:
1351 buf[0][offset] = odd ? g_u_s << 4 : r_y_h << 4;
1352 buf[0][offset + 1] = odd ? g_u_s >> 4 : r_y_h >> 4;
1353 buf[1][offset] = odd ? b_v << 4 : g_u_s << 4;
1354 buf[1][offset + 1] = odd ? b_v >> 4 : g_u_s >> 4;
1355 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1356 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1357 break;
1358 }
1359 }
1360
1361 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line)
1362 {
1363 switch (tpg->fourcc) {
1364 case V4L2_PIX_FMT_SBGGR8:
1365 case V4L2_PIX_FMT_SGBRG8:
1366 case V4L2_PIX_FMT_SGRBG8:
1367 case V4L2_PIX_FMT_SRGGB8:
1368 case V4L2_PIX_FMT_SBGGR10:
1369 case V4L2_PIX_FMT_SGBRG10:
1370 case V4L2_PIX_FMT_SGRBG10:
1371 case V4L2_PIX_FMT_SRGGB10:
1372 case V4L2_PIX_FMT_SBGGR12:
1373 case V4L2_PIX_FMT_SGBRG12:
1374 case V4L2_PIX_FMT_SGRBG12:
1375 case V4L2_PIX_FMT_SRGGB12:
1376 return buf_line & 1;
1377 default:
1378 return 0;
1379 }
1380 }
1381 EXPORT_SYMBOL_GPL(tpg_g_interleaved_plane);
1382
1383 /* Return how many pattern lines are used by the current pattern. */
1384 static unsigned tpg_get_pat_lines(const struct tpg_data *tpg)
1385 {
1386 switch (tpg->pattern) {
1387 case TPG_PAT_CHECKERS_16X16:
1388 case TPG_PAT_CHECKERS_2X2:
1389 case TPG_PAT_CHECKERS_1X1:
1390 case TPG_PAT_COLOR_CHECKERS_2X2:
1391 case TPG_PAT_COLOR_CHECKERS_1X1:
1392 case TPG_PAT_ALTERNATING_HLINES:
1393 case TPG_PAT_CROSS_1_PIXEL:
1394 case TPG_PAT_CROSS_2_PIXELS:
1395 case TPG_PAT_CROSS_10_PIXELS:
1396 return 2;
1397 case TPG_PAT_100_COLORSQUARES:
1398 case TPG_PAT_100_HCOLORBAR:
1399 return 8;
1400 default:
1401 return 1;
1402 }
1403 }
1404
1405 /* Which pattern line should be used for the given frame line. */
1406 static unsigned tpg_get_pat_line(const struct tpg_data *tpg, unsigned line)
1407 {
1408 switch (tpg->pattern) {
1409 case TPG_PAT_CHECKERS_16X16:
1410 return (line >> 4) & 1;
1411 case TPG_PAT_CHECKERS_1X1:
1412 case TPG_PAT_COLOR_CHECKERS_1X1:
1413 case TPG_PAT_ALTERNATING_HLINES:
1414 return line & 1;
1415 case TPG_PAT_CHECKERS_2X2:
1416 case TPG_PAT_COLOR_CHECKERS_2X2:
1417 return (line & 2) >> 1;
1418 case TPG_PAT_100_COLORSQUARES:
1419 case TPG_PAT_100_HCOLORBAR:
1420 return (line * 8) / tpg->src_height;
1421 case TPG_PAT_CROSS_1_PIXEL:
1422 return line == tpg->src_height / 2;
1423 case TPG_PAT_CROSS_2_PIXELS:
1424 return (line + 1) / 2 == tpg->src_height / 4;
1425 case TPG_PAT_CROSS_10_PIXELS:
1426 return (line + 10) / 20 == tpg->src_height / 40;
1427 default:
1428 return 0;
1429 }
1430 }
1431
1432 /*
1433 * Which color should be used for the given pattern line and X coordinate.
1434 * Note: x is in the range 0 to 2 * tpg->src_width.
1435 */
1436 static enum tpg_color tpg_get_color(const struct tpg_data *tpg,
1437 unsigned pat_line, unsigned x)
1438 {
1439 /* Maximum number of bars are TPG_COLOR_MAX - otherwise, the input print code
1440 should be modified */
1441 static const enum tpg_color bars[3][8] = {
1442 /* Standard ITU-R 75% color bar sequence */
1443 { TPG_COLOR_CSC_WHITE, TPG_COLOR_75_YELLOW,
1444 TPG_COLOR_75_CYAN, TPG_COLOR_75_GREEN,
1445 TPG_COLOR_75_MAGENTA, TPG_COLOR_75_RED,
1446 TPG_COLOR_75_BLUE, TPG_COLOR_100_BLACK, },
1447 /* Standard ITU-R 100% color bar sequence */
1448 { TPG_COLOR_100_WHITE, TPG_COLOR_100_YELLOW,
1449 TPG_COLOR_100_CYAN, TPG_COLOR_100_GREEN,
1450 TPG_COLOR_100_MAGENTA, TPG_COLOR_100_RED,
1451 TPG_COLOR_100_BLUE, TPG_COLOR_100_BLACK, },
1452 /* Color bar sequence suitable to test CSC */
1453 { TPG_COLOR_CSC_WHITE, TPG_COLOR_CSC_YELLOW,
1454 TPG_COLOR_CSC_CYAN, TPG_COLOR_CSC_GREEN,
1455 TPG_COLOR_CSC_MAGENTA, TPG_COLOR_CSC_RED,
1456 TPG_COLOR_CSC_BLUE, TPG_COLOR_CSC_BLACK, },
1457 };
1458
1459 switch (tpg->pattern) {
1460 case TPG_PAT_75_COLORBAR:
1461 case TPG_PAT_100_COLORBAR:
1462 case TPG_PAT_CSC_COLORBAR:
1463 return bars[tpg->pattern][((x * 8) / tpg->src_width) % 8];
1464 case TPG_PAT_100_COLORSQUARES:
1465 return bars[1][(pat_line + (x * 8) / tpg->src_width) % 8];
1466 case TPG_PAT_100_HCOLORBAR:
1467 return bars[1][pat_line];
1468 case TPG_PAT_BLACK:
1469 return TPG_COLOR_100_BLACK;
1470 case TPG_PAT_WHITE:
1471 return TPG_COLOR_100_WHITE;
1472 case TPG_PAT_RED:
1473 return TPG_COLOR_100_RED;
1474 case TPG_PAT_GREEN:
1475 return TPG_COLOR_100_GREEN;
1476 case TPG_PAT_BLUE:
1477 return TPG_COLOR_100_BLUE;
1478 case TPG_PAT_CHECKERS_16X16:
1479 return (((x >> 4) & 1) ^ (pat_line & 1)) ?
1480 TPG_COLOR_100_BLACK : TPG_COLOR_100_WHITE;
1481 case TPG_PAT_CHECKERS_1X1:
1482 return ((x & 1) ^ (pat_line & 1)) ?
1483 TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1484 case TPG_PAT_COLOR_CHECKERS_1X1:
1485 return ((x & 1) ^ (pat_line & 1)) ?
1486 TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1487 case TPG_PAT_CHECKERS_2X2:
1488 return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1489 TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1490 case TPG_PAT_COLOR_CHECKERS_2X2:
1491 return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1492 TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1493 case TPG_PAT_ALTERNATING_HLINES:
1494 return pat_line ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1495 case TPG_PAT_ALTERNATING_VLINES:
1496 return (x & 1) ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1497 case TPG_PAT_CROSS_1_PIXEL:
1498 if (pat_line || (x % tpg->src_width) == tpg->src_width / 2)
1499 return TPG_COLOR_100_BLACK;
1500 return TPG_COLOR_100_WHITE;
1501 case TPG_PAT_CROSS_2_PIXELS:
1502 if (pat_line || ((x % tpg->src_width) + 1) / 2 == tpg->src_width / 4)
1503 return TPG_COLOR_100_BLACK;
1504 return TPG_COLOR_100_WHITE;
1505 case TPG_PAT_CROSS_10_PIXELS:
1506 if (pat_line || ((x % tpg->src_width) + 10) / 20 == tpg->src_width / 40)
1507 return TPG_COLOR_100_BLACK;
1508 return TPG_COLOR_100_WHITE;
1509 case TPG_PAT_GRAY_RAMP:
1510 return TPG_COLOR_RAMP + ((x % tpg->src_width) * 256) / tpg->src_width;
1511 default:
1512 return TPG_COLOR_100_RED;
1513 }
1514 }
1515
1516 /*
1517 * Given the pixel aspect ratio and video aspect ratio calculate the
1518 * coordinates of a centered square and the coordinates of the border of
1519 * the active video area. The coordinates are relative to the source
1520 * frame rectangle.
1521 */
1522 static void tpg_calculate_square_border(struct tpg_data *tpg)
1523 {
1524 unsigned w = tpg->src_width;
1525 unsigned h = tpg->src_height;
1526 unsigned sq_w, sq_h;
1527
1528 sq_w = (w * 2 / 5) & ~1;
1529 if (((w - sq_w) / 2) & 1)
1530 sq_w += 2;
1531 sq_h = sq_w;
1532 tpg->square.width = sq_w;
1533 if (tpg->vid_aspect == TPG_VIDEO_ASPECT_16X9_ANAMORPHIC) {
1534 unsigned ana_sq_w = (sq_w / 4) * 3;
1535
1536 if (((w - ana_sq_w) / 2) & 1)
1537 ana_sq_w += 2;
1538 tpg->square.width = ana_sq_w;
1539 }
1540 tpg->square.left = (w - tpg->square.width) / 2;
1541 if (tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC)
1542 sq_h = sq_w * 10 / 11;
1543 else if (tpg->pix_aspect == TPG_PIXEL_ASPECT_PAL)
1544 sq_h = sq_w * 59 / 54;
1545 tpg->square.height = sq_h;
1546 tpg->square.top = (h - sq_h) / 2;
1547 tpg->border.left = 0;
1548 tpg->border.width = w;
1549 tpg->border.top = 0;
1550 tpg->border.height = h;
1551 switch (tpg->vid_aspect) {
1552 case TPG_VIDEO_ASPECT_4X3:
1553 if (tpg->pix_aspect)
1554 return;
1555 if (3 * w >= 4 * h) {
1556 tpg->border.width = ((4 * h) / 3) & ~1;
1557 if (((w - tpg->border.width) / 2) & ~1)
1558 tpg->border.width -= 2;
1559 tpg->border.left = (w - tpg->border.width) / 2;
1560 break;
1561 }
1562 tpg->border.height = ((3 * w) / 4) & ~1;
1563 tpg->border.top = (h - tpg->border.height) / 2;
1564 break;
1565 case TPG_VIDEO_ASPECT_14X9_CENTRE:
1566 if (tpg->pix_aspect) {
1567 tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 420 : 506;
1568 tpg->border.top = (h - tpg->border.height) / 2;
1569 break;
1570 }
1571 if (9 * w >= 14 * h) {
1572 tpg->border.width = ((14 * h) / 9) & ~1;
1573 if (((w - tpg->border.width) / 2) & ~1)
1574 tpg->border.width -= 2;
1575 tpg->border.left = (w - tpg->border.width) / 2;
1576 break;
1577 }
1578 tpg->border.height = ((9 * w) / 14) & ~1;
1579 tpg->border.top = (h - tpg->border.height) / 2;
1580 break;
1581 case TPG_VIDEO_ASPECT_16X9_CENTRE:
1582 if (tpg->pix_aspect) {
1583 tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 368 : 442;
1584 tpg->border.top = (h - tpg->border.height) / 2;
1585 break;
1586 }
1587 if (9 * w >= 16 * h) {
1588 tpg->border.width = ((16 * h) / 9) & ~1;
1589 if (((w - tpg->border.width) / 2) & ~1)
1590 tpg->border.width -= 2;
1591 tpg->border.left = (w - tpg->border.width) / 2;
1592 break;
1593 }
1594 tpg->border.height = ((9 * w) / 16) & ~1;
1595 tpg->border.top = (h - tpg->border.height) / 2;
1596 break;
1597 default:
1598 break;
1599 }
1600 }
1601
1602 static void tpg_precalculate_line(struct tpg_data *tpg)
1603 {
1604 enum tpg_color contrast;
1605 u8 pix[TPG_MAX_PLANES][8];
1606 unsigned pat;
1607 unsigned p;
1608 unsigned x;
1609
1610 switch (tpg->pattern) {
1611 case TPG_PAT_GREEN:
1612 contrast = TPG_COLOR_100_RED;
1613 break;
1614 case TPG_PAT_CSC_COLORBAR:
1615 contrast = TPG_COLOR_CSC_GREEN;
1616 break;
1617 default:
1618 contrast = TPG_COLOR_100_GREEN;
1619 break;
1620 }
1621
1622 for (pat = 0; pat < tpg_get_pat_lines(tpg); pat++) {
1623 /* Coarse scaling with Bresenham */
1624 unsigned int_part = tpg->src_width / tpg->scaled_width;
1625 unsigned fract_part = tpg->src_width % tpg->scaled_width;
1626 unsigned src_x = 0;
1627 unsigned error = 0;
1628
1629 for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1630 unsigned real_x = src_x;
1631 enum tpg_color color1, color2;
1632
1633 real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1634 color1 = tpg_get_color(tpg, pat, real_x);
1635
1636 src_x += int_part;
1637 error += fract_part;
1638 if (error >= tpg->scaled_width) {
1639 error -= tpg->scaled_width;
1640 src_x++;
1641 }
1642
1643 real_x = src_x;
1644 real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1645 color2 = tpg_get_color(tpg, pat, real_x);
1646
1647 src_x += int_part;
1648 error += fract_part;
1649 if (error >= tpg->scaled_width) {
1650 error -= tpg->scaled_width;
1651 src_x++;
1652 }
1653
1654 gen_twopix(tpg, pix, tpg->hflip ? color2 : color1, 0);
1655 gen_twopix(tpg, pix, tpg->hflip ? color1 : color2, 1);
1656 for (p = 0; p < tpg->planes; p++) {
1657 unsigned twopixsize = tpg->twopixelsize[p];
1658 unsigned hdiv = tpg->hdownsampling[p];
1659 u8 *pos = tpg->lines[pat][p] + tpg_hdiv(tpg, p, x);
1660
1661 memcpy(pos, pix[p], twopixsize / hdiv);
1662 }
1663 }
1664 }
1665
1666 if (tpg->vdownsampling[tpg->planes - 1] > 1) {
1667 unsigned pat_lines = tpg_get_pat_lines(tpg);
1668
1669 for (pat = 0; pat < pat_lines; pat++) {
1670 unsigned next_pat = (pat + 1) % pat_lines;
1671
1672 for (p = 1; p < tpg->planes; p++) {
1673 unsigned w = tpg_hdiv(tpg, p, tpg->scaled_width * 2);
1674 u8 *pos1 = tpg->lines[pat][p];
1675 u8 *pos2 = tpg->lines[next_pat][p];
1676 u8 *dest = tpg->downsampled_lines[pat][p];
1677
1678 for (x = 0; x < w; x++, pos1++, pos2++, dest++)
1679 *dest = ((u16)*pos1 + (u16)*pos2) / 2;
1680 }
1681 }
1682 }
1683
1684 gen_twopix(tpg, pix, contrast, 0);
1685 gen_twopix(tpg, pix, contrast, 1);
1686 for (p = 0; p < tpg->planes; p++) {
1687 unsigned twopixsize = tpg->twopixelsize[p];
1688 u8 *pos = tpg->contrast_line[p];
1689
1690 for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1691 memcpy(pos, pix[p], twopixsize);
1692 }
1693
1694 gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 0);
1695 gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 1);
1696 for (p = 0; p < tpg->planes; p++) {
1697 unsigned twopixsize = tpg->twopixelsize[p];
1698 u8 *pos = tpg->black_line[p];
1699
1700 for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1701 memcpy(pos, pix[p], twopixsize);
1702 }
1703
1704 for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1705 gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 0);
1706 gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 1);
1707 for (p = 0; p < tpg->planes; p++) {
1708 unsigned twopixsize = tpg->twopixelsize[p];
1709 u8 *pos = tpg->random_line[p] + x * twopixsize / 2;
1710
1711 memcpy(pos, pix[p], twopixsize);
1712 }
1713 }
1714
1715 gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 0);
1716 gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 1);
1717 gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 0);
1718 gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 1);
1719 }
1720
1721 /* need this to do rgb24 rendering */
1722 typedef struct { u16 __; u8 _; } __packed x24;
1723
1724 #define PRINTSTR(PIXTYPE) do { \
1725 unsigned vdiv = tpg->vdownsampling[p]; \
1726 unsigned hdiv = tpg->hdownsampling[p]; \
1727 int line; \
1728 PIXTYPE fg; \
1729 PIXTYPE bg; \
1730 memcpy(&fg, tpg->textfg[p], sizeof(PIXTYPE)); \
1731 memcpy(&bg, tpg->textbg[p], sizeof(PIXTYPE)); \
1732 \
1733 for (line = first; line < 16; line += vdiv * step) { \
1734 int l = tpg->vflip ? 15 - line : line; \
1735 PIXTYPE *pos = (PIXTYPE *)(basep[p][(line / vdiv) & 1] + \
1736 ((y * step + l) / (vdiv * div)) * tpg->bytesperline[p] + \
1737 (x / hdiv) * sizeof(PIXTYPE)); \
1738 unsigned s; \
1739 \
1740 for (s = 0; s < len; s++) { \
1741 u8 chr = font8x16[(u8)text[s] * 16 + line]; \
1742 \
1743 if (hdiv == 2 && tpg->hflip) { \
1744 pos[3] = (chr & (0x01 << 6) ? fg : bg); \
1745 pos[2] = (chr & (0x01 << 4) ? fg : bg); \
1746 pos[1] = (chr & (0x01 << 2) ? fg : bg); \
1747 pos[0] = (chr & (0x01 << 0) ? fg : bg); \
1748 } else if (hdiv == 2) { \
1749 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
1750 pos[1] = (chr & (0x01 << 5) ? fg : bg); \
1751 pos[2] = (chr & (0x01 << 3) ? fg : bg); \
1752 pos[3] = (chr & (0x01 << 1) ? fg : bg); \
1753 } else if (tpg->hflip) { \
1754 pos[7] = (chr & (0x01 << 7) ? fg : bg); \
1755 pos[6] = (chr & (0x01 << 6) ? fg : bg); \
1756 pos[5] = (chr & (0x01 << 5) ? fg : bg); \
1757 pos[4] = (chr & (0x01 << 4) ? fg : bg); \
1758 pos[3] = (chr & (0x01 << 3) ? fg : bg); \
1759 pos[2] = (chr & (0x01 << 2) ? fg : bg); \
1760 pos[1] = (chr & (0x01 << 1) ? fg : bg); \
1761 pos[0] = (chr & (0x01 << 0) ? fg : bg); \
1762 } else { \
1763 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
1764 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
1765 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
1766 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
1767 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
1768 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
1769 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
1770 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
1771 } \
1772 \
1773 pos += (tpg->hflip ? -8 : 8) / (int)hdiv; \
1774 } \
1775 } \
1776 } while (0)
1777
1778 static noinline void tpg_print_str_2(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1779 unsigned p, unsigned first, unsigned div, unsigned step,
1780 int y, int x, char *text, unsigned len)
1781 {
1782 PRINTSTR(u8);
1783 }
1784
1785 static noinline void tpg_print_str_4(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1786 unsigned p, unsigned first, unsigned div, unsigned step,
1787 int y, int x, char *text, unsigned len)
1788 {
1789 PRINTSTR(u16);
1790 }
1791
1792 static noinline void tpg_print_str_6(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1793 unsigned p, unsigned first, unsigned div, unsigned step,
1794 int y, int x, char *text, unsigned len)
1795 {
1796 PRINTSTR(x24);
1797 }
1798
1799 static noinline void tpg_print_str_8(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1800 unsigned p, unsigned first, unsigned div, unsigned step,
1801 int y, int x, char *text, unsigned len)
1802 {
1803 PRINTSTR(u32);
1804 }
1805
1806 void tpg_gen_text(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1807 int y, int x, char *text)
1808 {
1809 unsigned step = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
1810 unsigned div = step;
1811 unsigned first = 0;
1812 unsigned len = strlen(text);
1813 unsigned p;
1814
1815 if (font8x16 == NULL || basep == NULL)
1816 return;
1817
1818 /* Checks if it is possible to show string */
1819 if (y + 16 >= tpg->compose.height || x + 8 >= tpg->compose.width)
1820 return;
1821
1822 if (len > (tpg->compose.width - x) / 8)
1823 len = (tpg->compose.width - x) / 8;
1824 if (tpg->vflip)
1825 y = tpg->compose.height - y - 16;
1826 if (tpg->hflip)
1827 x = tpg->compose.width - x - 8;
1828 y += tpg->compose.top;
1829 x += tpg->compose.left;
1830 if (tpg->field == V4L2_FIELD_BOTTOM)
1831 first = 1;
1832 else if (tpg->field == V4L2_FIELD_SEQ_TB || tpg->field == V4L2_FIELD_SEQ_BT)
1833 div = 2;
1834
1835 for (p = 0; p < tpg->planes; p++) {
1836 /* Print text */
1837 switch (tpg->twopixelsize[p]) {
1838 case 2:
1839 tpg_print_str_2(tpg, basep, p, first, div, step, y, x,
1840 text, len);
1841 break;
1842 case 4:
1843 tpg_print_str_4(tpg, basep, p, first, div, step, y, x,
1844 text, len);
1845 break;
1846 case 6:
1847 tpg_print_str_6(tpg, basep, p, first, div, step, y, x,
1848 text, len);
1849 break;
1850 case 8:
1851 tpg_print_str_8(tpg, basep, p, first, div, step, y, x,
1852 text, len);
1853 break;
1854 }
1855 }
1856 }
1857 EXPORT_SYMBOL_GPL(tpg_gen_text);
1858
1859 void tpg_update_mv_step(struct tpg_data *tpg)
1860 {
1861 int factor = tpg->mv_hor_mode > TPG_MOVE_NONE ? -1 : 1;
1862
1863 if (tpg->hflip)
1864 factor = -factor;
1865 switch (tpg->mv_hor_mode) {
1866 case TPG_MOVE_NEG_FAST:
1867 case TPG_MOVE_POS_FAST:
1868 tpg->mv_hor_step = ((tpg->src_width + 319) / 320) * 4;
1869 break;
1870 case TPG_MOVE_NEG:
1871 case TPG_MOVE_POS:
1872 tpg->mv_hor_step = ((tpg->src_width + 639) / 640) * 4;
1873 break;
1874 case TPG_MOVE_NEG_SLOW:
1875 case TPG_MOVE_POS_SLOW:
1876 tpg->mv_hor_step = 2;
1877 break;
1878 case TPG_MOVE_NONE:
1879 tpg->mv_hor_step = 0;
1880 break;
1881 }
1882 if (factor < 0)
1883 tpg->mv_hor_step = tpg->src_width - tpg->mv_hor_step;
1884
1885 factor = tpg->mv_vert_mode > TPG_MOVE_NONE ? -1 : 1;
1886 switch (tpg->mv_vert_mode) {
1887 case TPG_MOVE_NEG_FAST:
1888 case TPG_MOVE_POS_FAST:
1889 tpg->mv_vert_step = ((tpg->src_width + 319) / 320) * 4;
1890 break;
1891 case TPG_MOVE_NEG:
1892 case TPG_MOVE_POS:
1893 tpg->mv_vert_step = ((tpg->src_width + 639) / 640) * 4;
1894 break;
1895 case TPG_MOVE_NEG_SLOW:
1896 case TPG_MOVE_POS_SLOW:
1897 tpg->mv_vert_step = 1;
1898 break;
1899 case TPG_MOVE_NONE:
1900 tpg->mv_vert_step = 0;
1901 break;
1902 }
1903 if (factor < 0)
1904 tpg->mv_vert_step = tpg->src_height - tpg->mv_vert_step;
1905 }
1906 EXPORT_SYMBOL_GPL(tpg_update_mv_step);
1907
1908 /* Map the line number relative to the crop rectangle to a frame line number */
1909 static unsigned tpg_calc_frameline(const struct tpg_data *tpg, unsigned src_y,
1910 unsigned field)
1911 {
1912 switch (field) {
1913 case V4L2_FIELD_TOP:
1914 return tpg->crop.top + src_y * 2;
1915 case V4L2_FIELD_BOTTOM:
1916 return tpg->crop.top + src_y * 2 + 1;
1917 default:
1918 return src_y + tpg->crop.top;
1919 }
1920 }
1921
1922 /*
1923 * Map the line number relative to the compose rectangle to a destination
1924 * buffer line number.
1925 */
1926 static unsigned tpg_calc_buffer_line(const struct tpg_data *tpg, unsigned y,
1927 unsigned field)
1928 {
1929 y += tpg->compose.top;
1930 switch (field) {
1931 case V4L2_FIELD_SEQ_TB:
1932 if (y & 1)
1933 return tpg->buf_height / 2 + y / 2;
1934 return y / 2;
1935 case V4L2_FIELD_SEQ_BT:
1936 if (y & 1)
1937 return y / 2;
1938 return tpg->buf_height / 2 + y / 2;
1939 default:
1940 return y;
1941 }
1942 }
1943
1944 static void tpg_recalc(struct tpg_data *tpg)
1945 {
1946 if (tpg->recalc_colors) {
1947 tpg->recalc_colors = false;
1948 tpg->recalc_lines = true;
1949 tpg->real_xfer_func = tpg->xfer_func;
1950 tpg->real_ycbcr_enc = tpg->ycbcr_enc;
1951 tpg->real_hsv_enc = tpg->hsv_enc;
1952 tpg->real_quantization = tpg->quantization;
1953
1954 if (tpg->xfer_func == V4L2_XFER_FUNC_DEFAULT)
1955 tpg->real_xfer_func =
1956 V4L2_MAP_XFER_FUNC_DEFAULT(tpg->colorspace);
1957
1958 if (tpg->ycbcr_enc == V4L2_YCBCR_ENC_DEFAULT)
1959 tpg->real_ycbcr_enc =
1960 V4L2_MAP_YCBCR_ENC_DEFAULT(tpg->colorspace);
1961
1962 if (tpg->quantization == V4L2_QUANTIZATION_DEFAULT)
1963 tpg->real_quantization =
1964 V4L2_MAP_QUANTIZATION_DEFAULT(
1965 tpg->color_enc != TGP_COLOR_ENC_YCBCR,
1966 tpg->colorspace, tpg->real_ycbcr_enc);
1967
1968 tpg_precalculate_colors(tpg);
1969 }
1970 if (tpg->recalc_square_border) {
1971 tpg->recalc_square_border = false;
1972 tpg_calculate_square_border(tpg);
1973 }
1974 if (tpg->recalc_lines) {
1975 tpg->recalc_lines = false;
1976 tpg_precalculate_line(tpg);
1977 }
1978 }
1979
1980 void tpg_calc_text_basep(struct tpg_data *tpg,
1981 u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf)
1982 {
1983 unsigned stride = tpg->bytesperline[p];
1984 unsigned h = tpg->buf_height;
1985
1986 tpg_recalc(tpg);
1987
1988 basep[p][0] = vbuf;
1989 basep[p][1] = vbuf;
1990 h /= tpg->vdownsampling[p];
1991 if (tpg->field == V4L2_FIELD_SEQ_TB)
1992 basep[p][1] += h * stride / 2;
1993 else if (tpg->field == V4L2_FIELD_SEQ_BT)
1994 basep[p][0] += h * stride / 2;
1995 if (p == 0 && tpg->interleaved)
1996 tpg_calc_text_basep(tpg, basep, 1, vbuf);
1997 }
1998 EXPORT_SYMBOL_GPL(tpg_calc_text_basep);
1999
2000 static int tpg_pattern_avg(const struct tpg_data *tpg,
2001 unsigned pat1, unsigned pat2)
2002 {
2003 unsigned pat_lines = tpg_get_pat_lines(tpg);
2004
2005 if (pat1 == (pat2 + 1) % pat_lines)
2006 return pat2;
2007 if (pat2 == (pat1 + 1) % pat_lines)
2008 return pat1;
2009 return -1;
2010 }
2011
2012 static const char *tpg_color_enc_str(enum tgp_color_enc
2013 color_enc)
2014 {
2015 switch (color_enc) {
2016 case TGP_COLOR_ENC_HSV:
2017 return "HSV";
2018 case TGP_COLOR_ENC_YCBCR:
2019 return "Y'CbCr";
2020 case TGP_COLOR_ENC_LUMA:
2021 return "Luma";
2022 case TGP_COLOR_ENC_RGB:
2023 default:
2024 return "R'G'B";
2025
2026 }
2027 }
2028
2029 void tpg_log_status(struct tpg_data *tpg)
2030 {
2031 pr_info("tpg source WxH: %ux%u (%s)\n",
2032 tpg->src_width, tpg->src_height,
2033 tpg_color_enc_str(tpg->color_enc));
2034 pr_info("tpg field: %u\n", tpg->field);
2035 pr_info("tpg crop: %ux%u@%dx%d\n", tpg->crop.width, tpg->crop.height,
2036 tpg->crop.left, tpg->crop.top);
2037 pr_info("tpg compose: %ux%u@%dx%d\n", tpg->compose.width, tpg->compose.height,
2038 tpg->compose.left, tpg->compose.top);
2039 pr_info("tpg colorspace: %d\n", tpg->colorspace);
2040 pr_info("tpg transfer function: %d/%d\n", tpg->xfer_func, tpg->real_xfer_func);
2041 pr_info("tpg Y'CbCr encoding: %d/%d\n", tpg->ycbcr_enc, tpg->real_ycbcr_enc);
2042 pr_info("tpg HSV encoding: %d/%d\n", tpg->hsv_enc, tpg->real_hsv_enc);
2043 pr_info("tpg quantization: %d/%d\n", tpg->quantization, tpg->real_quantization);
2044 pr_info("tpg RGB range: %d/%d\n", tpg->rgb_range, tpg->real_rgb_range);
2045 }
2046 EXPORT_SYMBOL_GPL(tpg_log_status);
2047
2048 /*
2049 * This struct contains common parameters used by both the drawing of the
2050 * test pattern and the drawing of the extras (borders, square, etc.)
2051 */
2052 struct tpg_draw_params {
2053 /* common data */
2054 bool is_tv;
2055 bool is_60hz;
2056 unsigned twopixsize;
2057 unsigned img_width;
2058 unsigned stride;
2059 unsigned hmax;
2060 unsigned frame_line;
2061 unsigned frame_line_next;
2062
2063 /* test pattern */
2064 unsigned mv_hor_old;
2065 unsigned mv_hor_new;
2066 unsigned mv_vert_old;
2067 unsigned mv_vert_new;
2068
2069 /* extras */
2070 unsigned wss_width;
2071 unsigned wss_random_offset;
2072 unsigned sav_eav_f;
2073 unsigned left_pillar_width;
2074 unsigned right_pillar_start;
2075 };
2076
2077 static void tpg_fill_params_pattern(const struct tpg_data *tpg, unsigned p,
2078 struct tpg_draw_params *params)
2079 {
2080 params->mv_hor_old =
2081 tpg_hscale_div(tpg, p, tpg->mv_hor_count % tpg->src_width);
2082 params->mv_hor_new =
2083 tpg_hscale_div(tpg, p, (tpg->mv_hor_count + tpg->mv_hor_step) %
2084 tpg->src_width);
2085 params->mv_vert_old = tpg->mv_vert_count % tpg->src_height;
2086 params->mv_vert_new =
2087 (tpg->mv_vert_count + tpg->mv_vert_step) % tpg->src_height;
2088 }
2089
2090 static void tpg_fill_params_extras(const struct tpg_data *tpg,
2091 unsigned p,
2092 struct tpg_draw_params *params)
2093 {
2094 unsigned left_pillar_width = 0;
2095 unsigned right_pillar_start = params->img_width;
2096
2097 params->wss_width = tpg->crop.left < tpg->src_width / 2 ?
2098 tpg->src_width / 2 - tpg->crop.left : 0;
2099 if (params->wss_width > tpg->crop.width)
2100 params->wss_width = tpg->crop.width;
2101 params->wss_width = tpg_hscale_div(tpg, p, params->wss_width);
2102 params->wss_random_offset =
2103 params->twopixsize * prandom_u32_max(tpg->src_width / 2);
2104
2105 if (tpg->crop.left < tpg->border.left) {
2106 left_pillar_width = tpg->border.left - tpg->crop.left;
2107 if (left_pillar_width > tpg->crop.width)
2108 left_pillar_width = tpg->crop.width;
2109 left_pillar_width = tpg_hscale_div(tpg, p, left_pillar_width);
2110 }
2111 params->left_pillar_width = left_pillar_width;
2112
2113 if (tpg->crop.left + tpg->crop.width >
2114 tpg->border.left + tpg->border.width) {
2115 right_pillar_start =
2116 tpg->border.left + tpg->border.width - tpg->crop.left;
2117 right_pillar_start =
2118 tpg_hscale_div(tpg, p, right_pillar_start);
2119 if (right_pillar_start > params->img_width)
2120 right_pillar_start = params->img_width;
2121 }
2122 params->right_pillar_start = right_pillar_start;
2123
2124 params->sav_eav_f = tpg->field ==
2125 (params->is_60hz ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
2126 }
2127
2128 static void tpg_fill_plane_extras(const struct tpg_data *tpg,
2129 const struct tpg_draw_params *params,
2130 unsigned p, unsigned h, u8 *vbuf)
2131 {
2132 unsigned twopixsize = params->twopixsize;
2133 unsigned img_width = params->img_width;
2134 unsigned frame_line = params->frame_line;
2135 const struct v4l2_rect *sq = &tpg->square;
2136 const struct v4l2_rect *b = &tpg->border;
2137 const struct v4l2_rect *c = &tpg->crop;
2138
2139 if (params->is_tv && !params->is_60hz &&
2140 frame_line == 0 && params->wss_width) {
2141 /*
2142 * Replace the first half of the top line of a 50 Hz frame
2143 * with random data to simulate a WSS signal.
2144 */
2145 u8 *wss = tpg->random_line[p] + params->wss_random_offset;
2146
2147 memcpy(vbuf, wss, params->wss_width);
2148 }
2149
2150 if (tpg->show_border && frame_line >= b->top &&
2151 frame_line < b->top + b->height) {
2152 unsigned bottom = b->top + b->height - 1;
2153 unsigned left = params->left_pillar_width;
2154 unsigned right = params->right_pillar_start;
2155
2156 if (frame_line == b->top || frame_line == b->top + 1 ||
2157 frame_line == bottom || frame_line == bottom - 1) {
2158 memcpy(vbuf + left, tpg->contrast_line[p],
2159 right - left);
2160 } else {
2161 if (b->left >= c->left &&
2162 b->left < c->left + c->width)
2163 memcpy(vbuf + left,
2164 tpg->contrast_line[p], twopixsize);
2165 if (b->left + b->width > c->left &&
2166 b->left + b->width <= c->left + c->width)
2167 memcpy(vbuf + right - twopixsize,
2168 tpg->contrast_line[p], twopixsize);
2169 }
2170 }
2171 if (tpg->qual != TPG_QUAL_NOISE && frame_line >= b->top &&
2172 frame_line < b->top + b->height) {
2173 memcpy(vbuf, tpg->black_line[p], params->left_pillar_width);
2174 memcpy(vbuf + params->right_pillar_start, tpg->black_line[p],
2175 img_width - params->right_pillar_start);
2176 }
2177 if (tpg->show_square && frame_line >= sq->top &&
2178 frame_line < sq->top + sq->height &&
2179 sq->left < c->left + c->width &&
2180 sq->left + sq->width >= c->left) {
2181 unsigned left = sq->left;
2182 unsigned width = sq->width;
2183
2184 if (c->left > left) {
2185 width -= c->left - left;
2186 left = c->left;
2187 }
2188 if (c->left + c->width < left + width)
2189 width -= left + width - c->left - c->width;
2190 left -= c->left;
2191 left = tpg_hscale_div(tpg, p, left);
2192 width = tpg_hscale_div(tpg, p, width);
2193 memcpy(vbuf + left, tpg->contrast_line[p], width);
2194 }
2195 if (tpg->insert_sav) {
2196 unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width / 3);
2197 u8 *p = vbuf + offset;
2198 unsigned vact = 0, hact = 0;
2199
2200 p[0] = 0xff;
2201 p[1] = 0;
2202 p[2] = 0;
2203 p[3] = 0x80 | (params->sav_eav_f << 6) |
2204 (vact << 5) | (hact << 4) |
2205 ((hact ^ vact) << 3) |
2206 ((hact ^ params->sav_eav_f) << 2) |
2207 ((params->sav_eav_f ^ vact) << 1) |
2208 (hact ^ vact ^ params->sav_eav_f);
2209 }
2210 if (tpg->insert_eav) {
2211 unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width * 2 / 3);
2212 u8 *p = vbuf + offset;
2213 unsigned vact = 0, hact = 1;
2214
2215 p[0] = 0xff;
2216 p[1] = 0;
2217 p[2] = 0;
2218 p[3] = 0x80 | (params->sav_eav_f << 6) |
2219 (vact << 5) | (hact << 4) |
2220 ((hact ^ vact) << 3) |
2221 ((hact ^ params->sav_eav_f) << 2) |
2222 ((params->sav_eav_f ^ vact) << 1) |
2223 (hact ^ vact ^ params->sav_eav_f);
2224 }
2225 }
2226
2227 static void tpg_fill_plane_pattern(const struct tpg_data *tpg,
2228 const struct tpg_draw_params *params,
2229 unsigned p, unsigned h, u8 *vbuf)
2230 {
2231 unsigned twopixsize = params->twopixsize;
2232 unsigned img_width = params->img_width;
2233 unsigned mv_hor_old = params->mv_hor_old;
2234 unsigned mv_hor_new = params->mv_hor_new;
2235 unsigned mv_vert_old = params->mv_vert_old;
2236 unsigned mv_vert_new = params->mv_vert_new;
2237 unsigned frame_line = params->frame_line;
2238 unsigned frame_line_next = params->frame_line_next;
2239 unsigned line_offset = tpg_hscale_div(tpg, p, tpg->crop.left);
2240 bool even;
2241 bool fill_blank = false;
2242 unsigned pat_line_old;
2243 unsigned pat_line_new;
2244 u8 *linestart_older;
2245 u8 *linestart_newer;
2246 u8 *linestart_top;
2247 u8 *linestart_bottom;
2248
2249 even = !(frame_line & 1);
2250
2251 if (h >= params->hmax) {
2252 if (params->hmax == tpg->compose.height)
2253 return;
2254 if (!tpg->perc_fill_blank)
2255 return;
2256 fill_blank = true;
2257 }
2258
2259 if (tpg->vflip) {
2260 frame_line = tpg->src_height - frame_line - 1;
2261 frame_line_next = tpg->src_height - frame_line_next - 1;
2262 }
2263
2264 if (fill_blank) {
2265 linestart_older = tpg->contrast_line[p];
2266 linestart_newer = tpg->contrast_line[p];
2267 } else if (tpg->qual != TPG_QUAL_NOISE &&
2268 (frame_line < tpg->border.top ||
2269 frame_line >= tpg->border.top + tpg->border.height)) {
2270 linestart_older = tpg->black_line[p];
2271 linestart_newer = tpg->black_line[p];
2272 } else if (tpg->pattern == TPG_PAT_NOISE || tpg->qual == TPG_QUAL_NOISE) {
2273 linestart_older = tpg->random_line[p] +
2274 twopixsize * prandom_u32_max(tpg->src_width / 2);
2275 linestart_newer = tpg->random_line[p] +
2276 twopixsize * prandom_u32_max(tpg->src_width / 2);
2277 } else {
2278 unsigned frame_line_old =
2279 (frame_line + mv_vert_old) % tpg->src_height;
2280 unsigned frame_line_new =
2281 (frame_line + mv_vert_new) % tpg->src_height;
2282 unsigned pat_line_next_old;
2283 unsigned pat_line_next_new;
2284
2285 pat_line_old = tpg_get_pat_line(tpg, frame_line_old);
2286 pat_line_new = tpg_get_pat_line(tpg, frame_line_new);
2287 linestart_older = tpg->lines[pat_line_old][p] + mv_hor_old;
2288 linestart_newer = tpg->lines[pat_line_new][p] + mv_hor_new;
2289
2290 if (tpg->vdownsampling[p] > 1 && frame_line != frame_line_next) {
2291 int avg_pat;
2292
2293 /*
2294 * Now decide whether we need to use downsampled_lines[].
2295 * That's necessary if the two lines use different patterns.
2296 */
2297 pat_line_next_old = tpg_get_pat_line(tpg,
2298 (frame_line_next + mv_vert_old) % tpg->src_height);
2299 pat_line_next_new = tpg_get_pat_line(tpg,
2300 (frame_line_next + mv_vert_new) % tpg->src_height);
2301
2302 switch (tpg->field) {
2303 case V4L2_FIELD_INTERLACED:
2304 case V4L2_FIELD_INTERLACED_BT:
2305 case V4L2_FIELD_INTERLACED_TB:
2306 avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_new);
2307 if (avg_pat < 0)
2308 break;
2309 linestart_older = tpg->downsampled_lines[avg_pat][p] + mv_hor_old;
2310 linestart_newer = linestart_older;
2311 break;
2312 case V4L2_FIELD_NONE:
2313 case V4L2_FIELD_TOP:
2314 case V4L2_FIELD_BOTTOM:
2315 case V4L2_FIELD_SEQ_BT:
2316 case V4L2_FIELD_SEQ_TB:
2317 avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_next_old);
2318 if (avg_pat >= 0)
2319 linestart_older = tpg->downsampled_lines[avg_pat][p] +
2320 mv_hor_old;
2321 avg_pat = tpg_pattern_avg(tpg, pat_line_new, pat_line_next_new);
2322 if (avg_pat >= 0)
2323 linestart_newer = tpg->downsampled_lines[avg_pat][p] +
2324 mv_hor_new;
2325 break;
2326 }
2327 }
2328 linestart_older += line_offset;
2329 linestart_newer += line_offset;
2330 }
2331 if (tpg->field_alternate) {
2332 linestart_top = linestart_bottom = linestart_older;
2333 } else if (params->is_60hz) {
2334 linestart_top = linestart_newer;
2335 linestart_bottom = linestart_older;
2336 } else {
2337 linestart_top = linestart_older;
2338 linestart_bottom = linestart_newer;
2339 }
2340
2341 switch (tpg->field) {
2342 case V4L2_FIELD_INTERLACED:
2343 case V4L2_FIELD_INTERLACED_TB:
2344 case V4L2_FIELD_SEQ_TB:
2345 case V4L2_FIELD_SEQ_BT:
2346 if (even)
2347 memcpy(vbuf, linestart_top, img_width);
2348 else
2349 memcpy(vbuf, linestart_bottom, img_width);
2350 break;
2351 case V4L2_FIELD_INTERLACED_BT:
2352 if (even)
2353 memcpy(vbuf, linestart_bottom, img_width);
2354 else
2355 memcpy(vbuf, linestart_top, img_width);
2356 break;
2357 case V4L2_FIELD_TOP:
2358 memcpy(vbuf, linestart_top, img_width);
2359 break;
2360 case V4L2_FIELD_BOTTOM:
2361 memcpy(vbuf, linestart_bottom, img_width);
2362 break;
2363 case V4L2_FIELD_NONE:
2364 default:
2365 memcpy(vbuf, linestart_older, img_width);
2366 break;
2367 }
2368 }
2369
2370 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
2371 unsigned p, u8 *vbuf)
2372 {
2373 struct tpg_draw_params params;
2374 unsigned factor = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
2375
2376 /* Coarse scaling with Bresenham */
2377 unsigned int_part = (tpg->crop.height / factor) / tpg->compose.height;
2378 unsigned fract_part = (tpg->crop.height / factor) % tpg->compose.height;
2379 unsigned src_y = 0;
2380 unsigned error = 0;
2381 unsigned h;
2382
2383 tpg_recalc(tpg);
2384
2385 params.is_tv = std;
2386 params.is_60hz = std & V4L2_STD_525_60;
2387 params.twopixsize = tpg->twopixelsize[p];
2388 params.img_width = tpg_hdiv(tpg, p, tpg->compose.width);
2389 params.stride = tpg->bytesperline[p];
2390 params.hmax = (tpg->compose.height * tpg->perc_fill) / 100;
2391
2392 tpg_fill_params_pattern(tpg, p, &params);
2393 tpg_fill_params_extras(tpg, p, &params);
2394
2395 vbuf += tpg_hdiv(tpg, p, tpg->compose.left);
2396
2397 for (h = 0; h < tpg->compose.height; h++) {
2398 unsigned buf_line;
2399
2400 params.frame_line = tpg_calc_frameline(tpg, src_y, tpg->field);
2401 params.frame_line_next = params.frame_line;
2402 buf_line = tpg_calc_buffer_line(tpg, h, tpg->field);
2403 src_y += int_part;
2404 error += fract_part;
2405 if (error >= tpg->compose.height) {
2406 error -= tpg->compose.height;
2407 src_y++;
2408 }
2409
2410 /*
2411 * For line-interleaved formats determine the 'plane'
2412 * based on the buffer line.
2413 */
2414 if (tpg_g_interleaved(tpg))
2415 p = tpg_g_interleaved_plane(tpg, buf_line);
2416
2417 if (tpg->vdownsampling[p] > 1) {
2418 /*
2419 * When doing vertical downsampling the field setting
2420 * matters: for SEQ_BT/TB we downsample each field
2421 * separately (i.e. lines 0+2 are combined, as are
2422 * lines 1+3), for the other field settings we combine
2423 * odd and even lines. Doing that for SEQ_BT/TB would
2424 * be really weird.
2425 */
2426 if (tpg->field == V4L2_FIELD_SEQ_BT ||
2427 tpg->field == V4L2_FIELD_SEQ_TB) {
2428 unsigned next_src_y = src_y;
2429
2430 if ((h & 3) >= 2)
2431 continue;
2432 next_src_y += int_part;
2433 if (error + fract_part >= tpg->compose.height)
2434 next_src_y++;
2435 params.frame_line_next =
2436 tpg_calc_frameline(tpg, next_src_y, tpg->field);
2437 } else {
2438 if (h & 1)
2439 continue;
2440 params.frame_line_next =
2441 tpg_calc_frameline(tpg, src_y, tpg->field);
2442 }
2443
2444 buf_line /= tpg->vdownsampling[p];
2445 }
2446 tpg_fill_plane_pattern(tpg, &params, p, h,
2447 vbuf + buf_line * params.stride);
2448 tpg_fill_plane_extras(tpg, &params, p, h,
2449 vbuf + buf_line * params.stride);
2450 }
2451 }
2452 EXPORT_SYMBOL_GPL(tpg_fill_plane_buffer);
2453
2454 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8 *vbuf)
2455 {
2456 unsigned offset = 0;
2457 unsigned i;
2458
2459 if (tpg->buffers > 1) {
2460 tpg_fill_plane_buffer(tpg, std, p, vbuf);
2461 return;
2462 }
2463
2464 for (i = 0; i < tpg_g_planes(tpg); i++) {
2465 tpg_fill_plane_buffer(tpg, std, i, vbuf + offset);
2466 offset += tpg_calc_plane_size(tpg, i);
2467 }
2468 }
2469 EXPORT_SYMBOL_GPL(tpg_fillbuffer);
2470
2471 MODULE_DESCRIPTION("V4L2 Test Pattern Generator");
2472 MODULE_AUTHOR("Hans Verkuil");
2473 MODULE_LICENSE("GPL");
Linux with added FPC-III support