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