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