?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sh_eth: fix EESIPR values for SH77{34|63}
[linux/fpc-iii.git] / drivers / media / common / v4l2-tpg / v4l2-tpg-core.c
blobe47b46e2d26ca7dd4a86f387422a19d8484701cf
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.4698, 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 if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
931 y = clamp(y, 16, 235);
932 cb = clamp(cb, 16, 240);
933 cr = clamp(cr, 16, 240);
934 } else {
935 y = clamp(y, 1, 254);
936 cb = clamp(cb, 1, 254);
937 cr = clamp(cr, 1, 254);
938 }
939 switch (tpg->fourcc) {
940 case V4L2_PIX_FMT_YUV444:
941 y >>= 4;
942 cb >>= 4;
943 cr >>= 4;
944 break;
945 case V4L2_PIX_FMT_YUV555:
946 y >>= 3;
947 cb >>= 3;
948 cr >>= 3;
949 break;
950 case V4L2_PIX_FMT_YUV565:
951 y >>= 3;
952 cb >>= 2;
953 cr >>= 3;
954 break;
955 }
956 tpg->colors[k][0] = y;
957 tpg->colors[k][1] = cb;
958 tpg->colors[k][2] = cr;
959 break;
960 }
961 case TGP_COLOR_ENC_LUMA:
962 {
963 tpg->colors[k][0] = r >> 4;
964 break;
965 }
966 case TGP_COLOR_ENC_RGB:
967 {
968 if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
969 r = (r * 219) / 255 + (16 << 4);
970 g = (g * 219) / 255 + (16 << 4);
971 b = (b * 219) / 255 + (16 << 4);
972 }
973 switch (tpg->fourcc) {
974 case V4L2_PIX_FMT_RGB332:
975 r >>= 9;
976 g >>= 9;
977 b >>= 10;
978 break;
979 case V4L2_PIX_FMT_RGB565:
980 case V4L2_PIX_FMT_RGB565X:
981 r >>= 7;
982 g >>= 6;
983 b >>= 7;
984 break;
985 case V4L2_PIX_FMT_RGB444:
986 case V4L2_PIX_FMT_XRGB444:
987 case V4L2_PIX_FMT_ARGB444:
988 r >>= 8;
989 g >>= 8;
990 b >>= 8;
991 break;
992 case V4L2_PIX_FMT_RGB555:
993 case V4L2_PIX_FMT_XRGB555:
994 case V4L2_PIX_FMT_ARGB555:
995 case V4L2_PIX_FMT_RGB555X:
996 case V4L2_PIX_FMT_XRGB555X:
997 case V4L2_PIX_FMT_ARGB555X:
998 r >>= 7;
999 g >>= 7;
1000 b >>= 7;
1001 break;
1002 case V4L2_PIX_FMT_BGR666:
1003 r >>= 6;
1004 g >>= 6;
1005 b >>= 6;
1006 break;
1007 default:
1008 r >>= 4;
1009 g >>= 4;
1010 b >>= 4;
1011 break;
1012 }
1013
1014 tpg->colors[k][0] = r;
1015 tpg->colors[k][1] = g;
1016 tpg->colors[k][2] = b;
1017 break;
1018 }
1019 }
1020 }
1021
1022 static void tpg_precalculate_colors(struct tpg_data *tpg)
1023 {
1024 int k;
1025
1026 for (k = 0; k < TPG_COLOR_MAX; k++)
1027 precalculate_color(tpg, k);
1028 }
1029
1030 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
1031 static void gen_twopix(struct tpg_data *tpg,
1032 u8 buf[TPG_MAX_PLANES][8], int color, bool odd)
1033 {
1034 unsigned offset = odd * tpg->twopixelsize[0] / 2;
1035 u8 alpha = tpg->alpha_component;
1036 u8 r_y_h, g_u_s, b_v;
1037
1038 if (tpg->alpha_red_only && color != TPG_COLOR_CSC_RED &&
1039 color != TPG_COLOR_100_RED &&
1040 color != TPG_COLOR_75_RED)
1041 alpha = 0;
1042 if (color == TPG_COLOR_RANDOM)
1043 precalculate_color(tpg, color);
1044 r_y_h = tpg->colors[color][0]; /* R or precalculated Y, H */
1045 g_u_s = tpg->colors[color][1]; /* G or precalculated U, V */
1046 b_v = tpg->colors[color][2]; /* B or precalculated V */
1047
1048 switch (tpg->fourcc) {
1049 case V4L2_PIX_FMT_GREY:
1050 buf[0][offset] = r_y_h;
1051 break;
1052 case V4L2_PIX_FMT_Y16:
1053 /*
1054 * Ideally both bytes should be set to r_y_h, but then you won't
1055 * be able to detect endian problems. So keep it 0 except for
1056 * the corner case where r_y_h is 0xff so white really will be
1057 * white (0xffff).
1058 */
1059 buf[0][offset] = r_y_h == 0xff ? r_y_h : 0;
1060 buf[0][offset+1] = r_y_h;
1061 break;
1062 case V4L2_PIX_FMT_Y16_BE:
1063 /* See comment for V4L2_PIX_FMT_Y16 above */
1064 buf[0][offset] = r_y_h;
1065 buf[0][offset+1] = r_y_h == 0xff ? r_y_h : 0;
1066 break;
1067 case V4L2_PIX_FMT_YUV422M:
1068 case V4L2_PIX_FMT_YUV422P:
1069 case V4L2_PIX_FMT_YUV420:
1070 case V4L2_PIX_FMT_YUV420M:
1071 buf[0][offset] = r_y_h;
1072 if (odd) {
1073 buf[1][0] = (buf[1][0] + g_u_s) / 2;
1074 buf[2][0] = (buf[2][0] + b_v) / 2;
1075 buf[1][1] = buf[1][0];
1076 buf[2][1] = buf[2][0];
1077 break;
1078 }
1079 buf[1][0] = g_u_s;
1080 buf[2][0] = b_v;
1081 break;
1082 case V4L2_PIX_FMT_YVU422M:
1083 case V4L2_PIX_FMT_YVU420:
1084 case V4L2_PIX_FMT_YVU420M:
1085 buf[0][offset] = r_y_h;
1086 if (odd) {
1087 buf[1][0] = (buf[1][0] + b_v) / 2;
1088 buf[2][0] = (buf[2][0] + g_u_s) / 2;
1089 buf[1][1] = buf[1][0];
1090 buf[2][1] = buf[2][0];
1091 break;
1092 }
1093 buf[1][0] = b_v;
1094 buf[2][0] = g_u_s;
1095 break;
1096
1097 case V4L2_PIX_FMT_NV12:
1098 case V4L2_PIX_FMT_NV12M:
1099 case V4L2_PIX_FMT_NV16:
1100 case V4L2_PIX_FMT_NV16M:
1101 buf[0][offset] = r_y_h;
1102 if (odd) {
1103 buf[1][0] = (buf[1][0] + g_u_s) / 2;
1104 buf[1][1] = (buf[1][1] + b_v) / 2;
1105 break;
1106 }
1107 buf[1][0] = g_u_s;
1108 buf[1][1] = b_v;
1109 break;
1110 case V4L2_PIX_FMT_NV21:
1111 case V4L2_PIX_FMT_NV21M:
1112 case V4L2_PIX_FMT_NV61:
1113 case V4L2_PIX_FMT_NV61M:
1114 buf[0][offset] = r_y_h;
1115 if (odd) {
1116 buf[1][0] = (buf[1][0] + b_v) / 2;
1117 buf[1][1] = (buf[1][1] + g_u_s) / 2;
1118 break;
1119 }
1120 buf[1][0] = b_v;
1121 buf[1][1] = g_u_s;
1122 break;
1123
1124 case V4L2_PIX_FMT_YUV444M:
1125 buf[0][offset] = r_y_h;
1126 buf[1][offset] = g_u_s;
1127 buf[2][offset] = b_v;
1128 break;
1129
1130 case V4L2_PIX_FMT_YVU444M:
1131 buf[0][offset] = r_y_h;
1132 buf[1][offset] = b_v;
1133 buf[2][offset] = g_u_s;
1134 break;
1135
1136 case V4L2_PIX_FMT_NV24:
1137 buf[0][offset] = r_y_h;
1138 buf[1][2 * offset] = g_u_s;
1139 buf[1][2 * offset + 1] = b_v;
1140 break;
1141
1142 case V4L2_PIX_FMT_NV42:
1143 buf[0][offset] = r_y_h;
1144 buf[1][2 * offset] = b_v;
1145 buf[1][2 * offset + 1] = g_u_s;
1146 break;
1147
1148 case V4L2_PIX_FMT_YUYV:
1149 buf[0][offset] = r_y_h;
1150 if (odd) {
1151 buf[0][1] = (buf[0][1] + g_u_s) / 2;
1152 buf[0][3] = (buf[0][3] + b_v) / 2;
1153 break;
1154 }
1155 buf[0][1] = g_u_s;
1156 buf[0][3] = b_v;
1157 break;
1158 case V4L2_PIX_FMT_UYVY:
1159 buf[0][offset + 1] = r_y_h;
1160 if (odd) {
1161 buf[0][0] = (buf[0][0] + g_u_s) / 2;
1162 buf[0][2] = (buf[0][2] + b_v) / 2;
1163 break;
1164 }
1165 buf[0][0] = g_u_s;
1166 buf[0][2] = b_v;
1167 break;
1168 case V4L2_PIX_FMT_YVYU:
1169 buf[0][offset] = r_y_h;
1170 if (odd) {
1171 buf[0][1] = (buf[0][1] + b_v) / 2;
1172 buf[0][3] = (buf[0][3] + g_u_s) / 2;
1173 break;
1174 }
1175 buf[0][1] = b_v;
1176 buf[0][3] = g_u_s;
1177 break;
1178 case V4L2_PIX_FMT_VYUY:
1179 buf[0][offset + 1] = r_y_h;
1180 if (odd) {
1181 buf[0][0] = (buf[0][0] + b_v) / 2;
1182 buf[0][2] = (buf[0][2] + g_u_s) / 2;
1183 break;
1184 }
1185 buf[0][0] = b_v;
1186 buf[0][2] = g_u_s;
1187 break;
1188 case V4L2_PIX_FMT_RGB332:
1189 buf[0][offset] = (r_y_h << 5) | (g_u_s << 2) | b_v;
1190 break;
1191 case V4L2_PIX_FMT_YUV565:
1192 case V4L2_PIX_FMT_RGB565:
1193 buf[0][offset] = (g_u_s << 5) | b_v;
1194 buf[0][offset + 1] = (r_y_h << 3) | (g_u_s >> 3);
1195 break;
1196 case V4L2_PIX_FMT_RGB565X:
1197 buf[0][offset] = (r_y_h << 3) | (g_u_s >> 3);
1198 buf[0][offset + 1] = (g_u_s << 5) | b_v;
1199 break;
1200 case V4L2_PIX_FMT_RGB444:
1201 case V4L2_PIX_FMT_XRGB444:
1202 alpha = 0;
1203 /* fall through */
1204 case V4L2_PIX_FMT_YUV444:
1205 case V4L2_PIX_FMT_ARGB444:
1206 buf[0][offset] = (g_u_s << 4) | b_v;
1207 buf[0][offset + 1] = (alpha & 0xf0) | r_y_h;
1208 break;
1209 case V4L2_PIX_FMT_RGB555:
1210 case V4L2_PIX_FMT_XRGB555:
1211 alpha = 0;
1212 /* fall through */
1213 case V4L2_PIX_FMT_YUV555:
1214 case V4L2_PIX_FMT_ARGB555:
1215 buf[0][offset] = (g_u_s << 5) | b_v;
1216 buf[0][offset + 1] = (alpha & 0x80) | (r_y_h << 2)
1217 | (g_u_s >> 3);
1218 break;
1219 case V4L2_PIX_FMT_RGB555X:
1220 case V4L2_PIX_FMT_XRGB555X:
1221 alpha = 0;
1222 /* fall through */
1223 case V4L2_PIX_FMT_ARGB555X:
1224 buf[0][offset] = (alpha & 0x80) | (r_y_h << 2) | (g_u_s >> 3);
1225 buf[0][offset + 1] = (g_u_s << 5) | b_v;
1226 break;
1227 case V4L2_PIX_FMT_RGB24:
1228 case V4L2_PIX_FMT_HSV24:
1229 buf[0][offset] = r_y_h;
1230 buf[0][offset + 1] = g_u_s;
1231 buf[0][offset + 2] = b_v;
1232 break;
1233 case V4L2_PIX_FMT_BGR24:
1234 buf[0][offset] = b_v;
1235 buf[0][offset + 1] = g_u_s;
1236 buf[0][offset + 2] = r_y_h;
1237 break;
1238 case V4L2_PIX_FMT_BGR666:
1239 buf[0][offset] = (b_v << 2) | (g_u_s >> 4);
1240 buf[0][offset + 1] = (g_u_s << 4) | (r_y_h >> 2);
1241 buf[0][offset + 2] = r_y_h << 6;
1242 buf[0][offset + 3] = 0;
1243 break;
1244 case V4L2_PIX_FMT_RGB32:
1245 case V4L2_PIX_FMT_XRGB32:
1246 case V4L2_PIX_FMT_HSV32:
1247 alpha = 0;
1248 /* fall through */
1249 case V4L2_PIX_FMT_YUV32:
1250 case V4L2_PIX_FMT_ARGB32:
1251 buf[0][offset] = alpha;
1252 buf[0][offset + 1] = r_y_h;
1253 buf[0][offset + 2] = g_u_s;
1254 buf[0][offset + 3] = b_v;
1255 break;
1256 case V4L2_PIX_FMT_BGR32:
1257 case V4L2_PIX_FMT_XBGR32:
1258 alpha = 0;
1259 /* fall through */
1260 case V4L2_PIX_FMT_ABGR32:
1261 buf[0][offset] = b_v;
1262 buf[0][offset + 1] = g_u_s;
1263 buf[0][offset + 2] = r_y_h;
1264 buf[0][offset + 3] = alpha;
1265 break;
1266 case V4L2_PIX_FMT_SBGGR8:
1267 buf[0][offset] = odd ? g_u_s : b_v;
1268 buf[1][offset] = odd ? r_y_h : g_u_s;
1269 break;
1270 case V4L2_PIX_FMT_SGBRG8:
1271 buf[0][offset] = odd ? b_v : g_u_s;
1272 buf[1][offset] = odd ? g_u_s : r_y_h;
1273 break;
1274 case V4L2_PIX_FMT_SGRBG8:
1275 buf[0][offset] = odd ? r_y_h : g_u_s;
1276 buf[1][offset] = odd ? g_u_s : b_v;
1277 break;
1278 case V4L2_PIX_FMT_SRGGB8:
1279 buf[0][offset] = odd ? g_u_s : r_y_h;
1280 buf[1][offset] = odd ? b_v : g_u_s;
1281 break;
1282 case V4L2_PIX_FMT_SBGGR10:
1283 buf[0][offset] = odd ? g_u_s << 2 : b_v << 2;
1284 buf[0][offset + 1] = odd ? g_u_s >> 6 : b_v >> 6;
1285 buf[1][offset] = odd ? r_y_h << 2 : g_u_s << 2;
1286 buf[1][offset + 1] = odd ? r_y_h >> 6 : g_u_s >> 6;
1287 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1288 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1289 break;
1290 case V4L2_PIX_FMT_SGBRG10:
1291 buf[0][offset] = odd ? b_v << 2 : g_u_s << 2;
1292 buf[0][offset + 1] = odd ? b_v >> 6 : g_u_s >> 6;
1293 buf[1][offset] = odd ? g_u_s << 2 : r_y_h << 2;
1294 buf[1][offset + 1] = odd ? g_u_s >> 6 : r_y_h >> 6;
1295 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1296 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1297 break;
1298 case V4L2_PIX_FMT_SGRBG10:
1299 buf[0][offset] = odd ? r_y_h << 2 : g_u_s << 2;
1300 buf[0][offset + 1] = odd ? r_y_h >> 6 : g_u_s >> 6;
1301 buf[1][offset] = odd ? g_u_s << 2 : b_v << 2;
1302 buf[1][offset + 1] = odd ? g_u_s >> 6 : b_v >> 6;
1303 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1304 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1305 break;
1306 case V4L2_PIX_FMT_SRGGB10:
1307 buf[0][offset] = odd ? g_u_s << 2 : r_y_h << 2;
1308 buf[0][offset + 1] = odd ? g_u_s >> 6 : r_y_h >> 6;
1309 buf[1][offset] = odd ? b_v << 2 : g_u_s << 2;
1310 buf[1][offset + 1] = odd ? b_v >> 6 : g_u_s >> 6;
1311 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1312 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1313 break;
1314 case V4L2_PIX_FMT_SBGGR12:
1315 buf[0][offset] = odd ? g_u_s << 4 : b_v << 4;
1316 buf[0][offset + 1] = odd ? g_u_s >> 4 : b_v >> 4;
1317 buf[1][offset] = odd ? r_y_h << 4 : g_u_s << 4;
1318 buf[1][offset + 1] = odd ? r_y_h >> 4 : g_u_s >> 4;
1319 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1320 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1321 break;
1322 case V4L2_PIX_FMT_SGBRG12:
1323 buf[0][offset] = odd ? b_v << 4 : g_u_s << 4;
1324 buf[0][offset + 1] = odd ? b_v >> 4 : g_u_s >> 4;
1325 buf[1][offset] = odd ? g_u_s << 4 : r_y_h << 4;
1326 buf[1][offset + 1] = odd ? g_u_s >> 4 : r_y_h >> 4;
1327 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1328 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1329 break;
1330 case V4L2_PIX_FMT_SGRBG12:
1331 buf[0][offset] = odd ? r_y_h << 4 : g_u_s << 4;
1332 buf[0][offset + 1] = odd ? r_y_h >> 4 : g_u_s >> 4;
1333 buf[1][offset] = odd ? g_u_s << 4 : b_v << 4;
1334 buf[1][offset + 1] = odd ? g_u_s >> 4 : b_v >> 4;
1335 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1336 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1337 break;
1338 case V4L2_PIX_FMT_SRGGB12:
1339 buf[0][offset] = odd ? g_u_s << 4 : r_y_h << 4;
1340 buf[0][offset + 1] = odd ? g_u_s >> 4 : r_y_h >> 4;
1341 buf[1][offset] = odd ? b_v << 4 : g_u_s << 4;
1342 buf[1][offset + 1] = odd ? b_v >> 4 : g_u_s >> 4;
1343 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1344 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1345 break;
1346 }
1347 }
1348
1349 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line)
1350 {
1351 switch (tpg->fourcc) {
1352 case V4L2_PIX_FMT_SBGGR8:
1353 case V4L2_PIX_FMT_SGBRG8:
1354 case V4L2_PIX_FMT_SGRBG8:
1355 case V4L2_PIX_FMT_SRGGB8:
1356 case V4L2_PIX_FMT_SBGGR10:
1357 case V4L2_PIX_FMT_SGBRG10:
1358 case V4L2_PIX_FMT_SGRBG10:
1359 case V4L2_PIX_FMT_SRGGB10:
1360 case V4L2_PIX_FMT_SBGGR12:
1361 case V4L2_PIX_FMT_SGBRG12:
1362 case V4L2_PIX_FMT_SGRBG12:
1363 case V4L2_PIX_FMT_SRGGB12:
1364 return buf_line & 1;
1365 default:
1366 return 0;
1367 }
1368 }
1369 EXPORT_SYMBOL_GPL(tpg_g_interleaved_plane);
1370
1371 /* Return how many pattern lines are used by the current pattern. */
1372 static unsigned tpg_get_pat_lines(const struct tpg_data *tpg)
1373 {
1374 switch (tpg->pattern) {
1375 case TPG_PAT_CHECKERS_16X16:
1376 case TPG_PAT_CHECKERS_2X2:
1377 case TPG_PAT_CHECKERS_1X1:
1378 case TPG_PAT_COLOR_CHECKERS_2X2:
1379 case TPG_PAT_COLOR_CHECKERS_1X1:
1380 case TPG_PAT_ALTERNATING_HLINES:
1381 case TPG_PAT_CROSS_1_PIXEL:
1382 case TPG_PAT_CROSS_2_PIXELS:
1383 case TPG_PAT_CROSS_10_PIXELS:
1384 return 2;
1385 case TPG_PAT_100_COLORSQUARES:
1386 case TPG_PAT_100_HCOLORBAR:
1387 return 8;
1388 default:
1389 return 1;
1390 }
1391 }
1392
1393 /* Which pattern line should be used for the given frame line. */
1394 static unsigned tpg_get_pat_line(const struct tpg_data *tpg, unsigned line)
1395 {
1396 switch (tpg->pattern) {
1397 case TPG_PAT_CHECKERS_16X16:
1398 return (line >> 4) & 1;
1399 case TPG_PAT_CHECKERS_1X1:
1400 case TPG_PAT_COLOR_CHECKERS_1X1:
1401 case TPG_PAT_ALTERNATING_HLINES:
1402 return line & 1;
1403 case TPG_PAT_CHECKERS_2X2:
1404 case TPG_PAT_COLOR_CHECKERS_2X2:
1405 return (line & 2) >> 1;
1406 case TPG_PAT_100_COLORSQUARES:
1407 case TPG_PAT_100_HCOLORBAR:
1408 return (line * 8) / tpg->src_height;
1409 case TPG_PAT_CROSS_1_PIXEL:
1410 return line == tpg->src_height / 2;
1411 case TPG_PAT_CROSS_2_PIXELS:
1412 return (line + 1) / 2 == tpg->src_height / 4;
1413 case TPG_PAT_CROSS_10_PIXELS:
1414 return (line + 10) / 20 == tpg->src_height / 40;
1415 default:
1416 return 0;
1417 }
1418 }
1419
1420 /*
1421 * Which color should be used for the given pattern line and X coordinate.
1422 * Note: x is in the range 0 to 2 * tpg->src_width.
1423 */
1424 static enum tpg_color tpg_get_color(const struct tpg_data *tpg,
1425 unsigned pat_line, unsigned x)
1426 {
1427 /* Maximum number of bars are TPG_COLOR_MAX - otherwise, the input print code
1428 should be modified */
1429 static const enum tpg_color bars[3][8] = {
1430 /* Standard ITU-R 75% color bar sequence */
1431 { TPG_COLOR_CSC_WHITE, TPG_COLOR_75_YELLOW,
1432 TPG_COLOR_75_CYAN, TPG_COLOR_75_GREEN,
1433 TPG_COLOR_75_MAGENTA, TPG_COLOR_75_RED,
1434 TPG_COLOR_75_BLUE, TPG_COLOR_100_BLACK, },
1435 /* Standard ITU-R 100% color bar sequence */
1436 { TPG_COLOR_100_WHITE, TPG_COLOR_100_YELLOW,
1437 TPG_COLOR_100_CYAN, TPG_COLOR_100_GREEN,
1438 TPG_COLOR_100_MAGENTA, TPG_COLOR_100_RED,
1439 TPG_COLOR_100_BLUE, TPG_COLOR_100_BLACK, },
1440 /* Color bar sequence suitable to test CSC */
1441 { TPG_COLOR_CSC_WHITE, TPG_COLOR_CSC_YELLOW,
1442 TPG_COLOR_CSC_CYAN, TPG_COLOR_CSC_GREEN,
1443 TPG_COLOR_CSC_MAGENTA, TPG_COLOR_CSC_RED,
1444 TPG_COLOR_CSC_BLUE, TPG_COLOR_CSC_BLACK, },
1445 };
1446
1447 switch (tpg->pattern) {
1448 case TPG_PAT_75_COLORBAR:
1449 case TPG_PAT_100_COLORBAR:
1450 case TPG_PAT_CSC_COLORBAR:
1451 return bars[tpg->pattern][((x * 8) / tpg->src_width) % 8];
1452 case TPG_PAT_100_COLORSQUARES:
1453 return bars[1][(pat_line + (x * 8) / tpg->src_width) % 8];
1454 case TPG_PAT_100_HCOLORBAR:
1455 return bars[1][pat_line];
1456 case TPG_PAT_BLACK:
1457 return TPG_COLOR_100_BLACK;
1458 case TPG_PAT_WHITE:
1459 return TPG_COLOR_100_WHITE;
1460 case TPG_PAT_RED:
1461 return TPG_COLOR_100_RED;
1462 case TPG_PAT_GREEN:
1463 return TPG_COLOR_100_GREEN;
1464 case TPG_PAT_BLUE:
1465 return TPG_COLOR_100_BLUE;
1466 case TPG_PAT_CHECKERS_16X16:
1467 return (((x >> 4) & 1) ^ (pat_line & 1)) ?
1468 TPG_COLOR_100_BLACK : TPG_COLOR_100_WHITE;
1469 case TPG_PAT_CHECKERS_1X1:
1470 return ((x & 1) ^ (pat_line & 1)) ?
1471 TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1472 case TPG_PAT_COLOR_CHECKERS_1X1:
1473 return ((x & 1) ^ (pat_line & 1)) ?
1474 TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1475 case TPG_PAT_CHECKERS_2X2:
1476 return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1477 TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1478 case TPG_PAT_COLOR_CHECKERS_2X2:
1479 return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1480 TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1481 case TPG_PAT_ALTERNATING_HLINES:
1482 return pat_line ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1483 case TPG_PAT_ALTERNATING_VLINES:
1484 return (x & 1) ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1485 case TPG_PAT_CROSS_1_PIXEL:
1486 if (pat_line || (x % tpg->src_width) == tpg->src_width / 2)
1487 return TPG_COLOR_100_BLACK;
1488 return TPG_COLOR_100_WHITE;
1489 case TPG_PAT_CROSS_2_PIXELS:
1490 if (pat_line || ((x % tpg->src_width) + 1) / 2 == tpg->src_width / 4)
1491 return TPG_COLOR_100_BLACK;
1492 return TPG_COLOR_100_WHITE;
1493 case TPG_PAT_CROSS_10_PIXELS:
1494 if (pat_line || ((x % tpg->src_width) + 10) / 20 == tpg->src_width / 40)
1495 return TPG_COLOR_100_BLACK;
1496 return TPG_COLOR_100_WHITE;
1497 case TPG_PAT_GRAY_RAMP:
1498 return TPG_COLOR_RAMP + ((x % tpg->src_width) * 256) / tpg->src_width;
1499 default:
1500 return TPG_COLOR_100_RED;
1501 }
1502 }
1503
1504 /*
1505 * Given the pixel aspect ratio and video aspect ratio calculate the
1506 * coordinates of a centered square and the coordinates of the border of
1507 * the active video area. The coordinates are relative to the source
1508 * frame rectangle.
1509 */
1510 static void tpg_calculate_square_border(struct tpg_data *tpg)
1511 {
1512 unsigned w = tpg->src_width;
1513 unsigned h = tpg->src_height;
1514 unsigned sq_w, sq_h;
1515
1516 sq_w = (w * 2 / 5) & ~1;
1517 if (((w - sq_w) / 2) & 1)
1518 sq_w += 2;
1519 sq_h = sq_w;
1520 tpg->square.width = sq_w;
1521 if (tpg->vid_aspect == TPG_VIDEO_ASPECT_16X9_ANAMORPHIC) {
1522 unsigned ana_sq_w = (sq_w / 4) * 3;
1523
1524 if (((w - ana_sq_w) / 2) & 1)
1525 ana_sq_w += 2;
1526 tpg->square.width = ana_sq_w;
1527 }
1528 tpg->square.left = (w - tpg->square.width) / 2;
1529 if (tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC)
1530 sq_h = sq_w * 10 / 11;
1531 else if (tpg->pix_aspect == TPG_PIXEL_ASPECT_PAL)
1532 sq_h = sq_w * 59 / 54;
1533 tpg->square.height = sq_h;
1534 tpg->square.top = (h - sq_h) / 2;
1535 tpg->border.left = 0;
1536 tpg->border.width = w;
1537 tpg->border.top = 0;
1538 tpg->border.height = h;
1539 switch (tpg->vid_aspect) {
1540 case TPG_VIDEO_ASPECT_4X3:
1541 if (tpg->pix_aspect)
1542 return;
1543 if (3 * w >= 4 * h) {
1544 tpg->border.width = ((4 * h) / 3) & ~1;
1545 if (((w - tpg->border.width) / 2) & ~1)
1546 tpg->border.width -= 2;
1547 tpg->border.left = (w - tpg->border.width) / 2;
1548 break;
1549 }
1550 tpg->border.height = ((3 * w) / 4) & ~1;
1551 tpg->border.top = (h - tpg->border.height) / 2;
1552 break;
1553 case TPG_VIDEO_ASPECT_14X9_CENTRE:
1554 if (tpg->pix_aspect) {
1555 tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 420 : 506;
1556 tpg->border.top = (h - tpg->border.height) / 2;
1557 break;
1558 }
1559 if (9 * w >= 14 * h) {
1560 tpg->border.width = ((14 * h) / 9) & ~1;
1561 if (((w - tpg->border.width) / 2) & ~1)
1562 tpg->border.width -= 2;
1563 tpg->border.left = (w - tpg->border.width) / 2;
1564 break;
1565 }
1566 tpg->border.height = ((9 * w) / 14) & ~1;
1567 tpg->border.top = (h - tpg->border.height) / 2;
1568 break;
1569 case TPG_VIDEO_ASPECT_16X9_CENTRE:
1570 if (tpg->pix_aspect) {
1571 tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 368 : 442;
1572 tpg->border.top = (h - tpg->border.height) / 2;
1573 break;
1574 }
1575 if (9 * w >= 16 * h) {
1576 tpg->border.width = ((16 * h) / 9) & ~1;
1577 if (((w - tpg->border.width) / 2) & ~1)
1578 tpg->border.width -= 2;
1579 tpg->border.left = (w - tpg->border.width) / 2;
1580 break;
1581 }
1582 tpg->border.height = ((9 * w) / 16) & ~1;
1583 tpg->border.top = (h - tpg->border.height) / 2;
1584 break;
1585 default:
1586 break;
1587 }
1588 }
1589
1590 static void tpg_precalculate_line(struct tpg_data *tpg)
1591 {
1592 enum tpg_color contrast;
1593 u8 pix[TPG_MAX_PLANES][8];
1594 unsigned pat;
1595 unsigned p;
1596 unsigned x;
1597
1598 switch (tpg->pattern) {
1599 case TPG_PAT_GREEN:
1600 contrast = TPG_COLOR_100_RED;
1601 break;
1602 case TPG_PAT_CSC_COLORBAR:
1603 contrast = TPG_COLOR_CSC_GREEN;
1604 break;
1605 default:
1606 contrast = TPG_COLOR_100_GREEN;
1607 break;
1608 }
1609
1610 for (pat = 0; pat < tpg_get_pat_lines(tpg); pat++) {
1611 /* Coarse scaling with Bresenham */
1612 unsigned int_part = tpg->src_width / tpg->scaled_width;
1613 unsigned fract_part = tpg->src_width % tpg->scaled_width;
1614 unsigned src_x = 0;
1615 unsigned error = 0;
1616
1617 for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1618 unsigned real_x = src_x;
1619 enum tpg_color color1, color2;
1620
1621 real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1622 color1 = tpg_get_color(tpg, pat, real_x);
1623
1624 src_x += int_part;
1625 error += fract_part;
1626 if (error >= tpg->scaled_width) {
1627 error -= tpg->scaled_width;
1628 src_x++;
1629 }
1630
1631 real_x = src_x;
1632 real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1633 color2 = tpg_get_color(tpg, pat, real_x);
1634
1635 src_x += int_part;
1636 error += fract_part;
1637 if (error >= tpg->scaled_width) {
1638 error -= tpg->scaled_width;
1639 src_x++;
1640 }
1641
1642 gen_twopix(tpg, pix, tpg->hflip ? color2 : color1, 0);
1643 gen_twopix(tpg, pix, tpg->hflip ? color1 : color2, 1);
1644 for (p = 0; p < tpg->planes; p++) {
1645 unsigned twopixsize = tpg->twopixelsize[p];
1646 unsigned hdiv = tpg->hdownsampling[p];
1647 u8 *pos = tpg->lines[pat][p] + tpg_hdiv(tpg, p, x);
1648
1649 memcpy(pos, pix[p], twopixsize / hdiv);
1650 }
1651 }
1652 }
1653
1654 if (tpg->vdownsampling[tpg->planes - 1] > 1) {
1655 unsigned pat_lines = tpg_get_pat_lines(tpg);
1656
1657 for (pat = 0; pat < pat_lines; pat++) {
1658 unsigned next_pat = (pat + 1) % pat_lines;
1659
1660 for (p = 1; p < tpg->planes; p++) {
1661 unsigned w = tpg_hdiv(tpg, p, tpg->scaled_width * 2);
1662 u8 *pos1 = tpg->lines[pat][p];
1663 u8 *pos2 = tpg->lines[next_pat][p];
1664 u8 *dest = tpg->downsampled_lines[pat][p];
1665
1666 for (x = 0; x < w; x++, pos1++, pos2++, dest++)
1667 *dest = ((u16)*pos1 + (u16)*pos2) / 2;
1668 }
1669 }
1670 }
1671
1672 gen_twopix(tpg, pix, contrast, 0);
1673 gen_twopix(tpg, pix, contrast, 1);
1674 for (p = 0; p < tpg->planes; p++) {
1675 unsigned twopixsize = tpg->twopixelsize[p];
1676 u8 *pos = tpg->contrast_line[p];
1677
1678 for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1679 memcpy(pos, pix[p], twopixsize);
1680 }
1681
1682 gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 0);
1683 gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 1);
1684 for (p = 0; p < tpg->planes; p++) {
1685 unsigned twopixsize = tpg->twopixelsize[p];
1686 u8 *pos = tpg->black_line[p];
1687
1688 for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1689 memcpy(pos, pix[p], twopixsize);
1690 }
1691
1692 for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1693 gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 0);
1694 gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 1);
1695 for (p = 0; p < tpg->planes; p++) {
1696 unsigned twopixsize = tpg->twopixelsize[p];
1697 u8 *pos = tpg->random_line[p] + x * twopixsize / 2;
1698
1699 memcpy(pos, pix[p], twopixsize);
1700 }
1701 }
1702
1703 gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 0);
1704 gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 1);
1705 gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 0);
1706 gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 1);
1707 }
1708
1709 /* need this to do rgb24 rendering */
1710 typedef struct { u16 __; u8 _; } __packed x24;
1711
1712 #define PRINTSTR(PIXTYPE) do { \
1713 unsigned vdiv = tpg->vdownsampling[p]; \
1714 unsigned hdiv = tpg->hdownsampling[p]; \
1715 int line; \
1716 PIXTYPE fg; \
1717 PIXTYPE bg; \
1718 memcpy(&fg, tpg->textfg[p], sizeof(PIXTYPE)); \
1719 memcpy(&bg, tpg->textbg[p], sizeof(PIXTYPE)); \
1720 \
1721 for (line = first; line < 16; line += vdiv * step) { \
1722 int l = tpg->vflip ? 15 - line : line; \
1723 PIXTYPE *pos = (PIXTYPE *)(basep[p][(line / vdiv) & 1] + \
1724 ((y * step + l) / (vdiv * div)) * tpg->bytesperline[p] + \
1725 (x / hdiv) * sizeof(PIXTYPE)); \
1726 unsigned s; \
1727 \
1728 for (s = 0; s < len; s++) { \
1729 u8 chr = font8x16[text[s] * 16 + line]; \
1730 \
1731 if (hdiv == 2 && tpg->hflip) { \
1732 pos[3] = (chr & (0x01 << 6) ? fg : bg); \
1733 pos[2] = (chr & (0x01 << 4) ? fg : bg); \
1734 pos[1] = (chr & (0x01 << 2) ? fg : bg); \
1735 pos[0] = (chr & (0x01 << 0) ? fg : bg); \
1736 } else if (hdiv == 2) { \
1737 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
1738 pos[1] = (chr & (0x01 << 5) ? fg : bg); \
1739 pos[2] = (chr & (0x01 << 3) ? fg : bg); \
1740 pos[3] = (chr & (0x01 << 1) ? fg : bg); \
1741 } else if (tpg->hflip) { \
1742 pos[7] = (chr & (0x01 << 7) ? fg : bg); \
1743 pos[6] = (chr & (0x01 << 6) ? fg : bg); \
1744 pos[5] = (chr & (0x01 << 5) ? fg : bg); \
1745 pos[4] = (chr & (0x01 << 4) ? fg : bg); \
1746 pos[3] = (chr & (0x01 << 3) ? fg : bg); \
1747 pos[2] = (chr & (0x01 << 2) ? fg : bg); \
1748 pos[1] = (chr & (0x01 << 1) ? fg : bg); \
1749 pos[0] = (chr & (0x01 << 0) ? fg : bg); \
1750 } else { \
1751 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
1752 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
1753 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
1754 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
1755 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
1756 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
1757 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
1758 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
1759 } \
1760 \
1761 pos += (tpg->hflip ? -8 : 8) / hdiv; \
1762 } \
1763 } \
1764 } while (0)
1765
1766 static noinline void tpg_print_str_2(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1767 unsigned p, unsigned first, unsigned div, unsigned step,
1768 int y, int x, char *text, unsigned len)
1769 {
1770 PRINTSTR(u8);
1771 }
1772
1773 static noinline void tpg_print_str_4(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(u16);
1778 }
1779
1780 static noinline void tpg_print_str_6(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(x24);
1785 }
1786
1787 static noinline void tpg_print_str_8(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(u32);
1792 }
1793
1794 void tpg_gen_text(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1795 int y, int x, char *text)
1796 {
1797 unsigned step = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
1798 unsigned div = step;
1799 unsigned first = 0;
1800 unsigned len = strlen(text);
1801 unsigned p;
1802
1803 if (font8x16 == NULL || basep == NULL)
1804 return;
1805
1806 /* Checks if it is possible to show string */
1807 if (y + 16 >= tpg->compose.height || x + 8 >= tpg->compose.width)
1808 return;
1809
1810 if (len > (tpg->compose.width - x) / 8)
1811 len = (tpg->compose.width - x) / 8;
1812 if (tpg->vflip)
1813 y = tpg->compose.height - y - 16;
1814 if (tpg->hflip)
1815 x = tpg->compose.width - x - 8;
1816 y += tpg->compose.top;
1817 x += tpg->compose.left;
1818 if (tpg->field == V4L2_FIELD_BOTTOM)
1819 first = 1;
1820 else if (tpg->field == V4L2_FIELD_SEQ_TB || tpg->field == V4L2_FIELD_SEQ_BT)
1821 div = 2;
1822
1823 for (p = 0; p < tpg->planes; p++) {
1824 /* Print text */
1825 switch (tpg->twopixelsize[p]) {
1826 case 2:
1827 tpg_print_str_2(tpg, basep, p, first, div, step, y, x,
1828 text, len);
1829 break;
1830 case 4:
1831 tpg_print_str_4(tpg, basep, p, first, div, step, y, x,
1832 text, len);
1833 break;
1834 case 6:
1835 tpg_print_str_6(tpg, basep, p, first, div, step, y, x,
1836 text, len);
1837 break;
1838 case 8:
1839 tpg_print_str_8(tpg, basep, p, first, div, step, y, x,
1840 text, len);
1841 break;
1842 }
1843 }
1844 }
1845 EXPORT_SYMBOL_GPL(tpg_gen_text);
1846
1847 void tpg_update_mv_step(struct tpg_data *tpg)
1848 {
1849 int factor = tpg->mv_hor_mode > TPG_MOVE_NONE ? -1 : 1;
1850
1851 if (tpg->hflip)
1852 factor = -factor;
1853 switch (tpg->mv_hor_mode) {
1854 case TPG_MOVE_NEG_FAST:
1855 case TPG_MOVE_POS_FAST:
1856 tpg->mv_hor_step = ((tpg->src_width + 319) / 320) * 4;
1857 break;
1858 case TPG_MOVE_NEG:
1859 case TPG_MOVE_POS:
1860 tpg->mv_hor_step = ((tpg->src_width + 639) / 640) * 4;
1861 break;
1862 case TPG_MOVE_NEG_SLOW:
1863 case TPG_MOVE_POS_SLOW:
1864 tpg->mv_hor_step = 2;
1865 break;
1866 case TPG_MOVE_NONE:
1867 tpg->mv_hor_step = 0;
1868 break;
1869 }
1870 if (factor < 0)
1871 tpg->mv_hor_step = tpg->src_width - tpg->mv_hor_step;
1872
1873 factor = tpg->mv_vert_mode > TPG_MOVE_NONE ? -1 : 1;
1874 switch (tpg->mv_vert_mode) {
1875 case TPG_MOVE_NEG_FAST:
1876 case TPG_MOVE_POS_FAST:
1877 tpg->mv_vert_step = ((tpg->src_width + 319) / 320) * 4;
1878 break;
1879 case TPG_MOVE_NEG:
1880 case TPG_MOVE_POS:
1881 tpg->mv_vert_step = ((tpg->src_width + 639) / 640) * 4;
1882 break;
1883 case TPG_MOVE_NEG_SLOW:
1884 case TPG_MOVE_POS_SLOW:
1885 tpg->mv_vert_step = 1;
1886 break;
1887 case TPG_MOVE_NONE:
1888 tpg->mv_vert_step = 0;
1889 break;
1890 }
1891 if (factor < 0)
1892 tpg->mv_vert_step = tpg->src_height - tpg->mv_vert_step;
1893 }
1894 EXPORT_SYMBOL_GPL(tpg_update_mv_step);
1895
1896 /* Map the line number relative to the crop rectangle to a frame line number */
1897 static unsigned tpg_calc_frameline(const struct tpg_data *tpg, unsigned src_y,
1898 unsigned field)
1899 {
1900 switch (field) {
1901 case V4L2_FIELD_TOP:
1902 return tpg->crop.top + src_y * 2;
1903 case V4L2_FIELD_BOTTOM:
1904 return tpg->crop.top + src_y * 2 + 1;
1905 default:
1906 return src_y + tpg->crop.top;
1907 }
1908 }
1909
1910 /*
1911 * Map the line number relative to the compose rectangle to a destination
1912 * buffer line number.
1913 */
1914 static unsigned tpg_calc_buffer_line(const struct tpg_data *tpg, unsigned y,
1915 unsigned field)
1916 {
1917 y += tpg->compose.top;
1918 switch (field) {
1919 case V4L2_FIELD_SEQ_TB:
1920 if (y & 1)
1921 return tpg->buf_height / 2 + y / 2;
1922 return y / 2;
1923 case V4L2_FIELD_SEQ_BT:
1924 if (y & 1)
1925 return y / 2;
1926 return tpg->buf_height / 2 + y / 2;
1927 default:
1928 return y;
1929 }
1930 }
1931
1932 static void tpg_recalc(struct tpg_data *tpg)
1933 {
1934 if (tpg->recalc_colors) {
1935 tpg->recalc_colors = false;
1936 tpg->recalc_lines = true;
1937 tpg->real_xfer_func = tpg->xfer_func;
1938 tpg->real_ycbcr_enc = tpg->ycbcr_enc;
1939 tpg->real_hsv_enc = tpg->hsv_enc;
1940 tpg->real_quantization = tpg->quantization;
1941
1942 if (tpg->xfer_func == V4L2_XFER_FUNC_DEFAULT)
1943 tpg->real_xfer_func =
1944 V4L2_MAP_XFER_FUNC_DEFAULT(tpg->colorspace);
1945
1946 if (tpg->ycbcr_enc == V4L2_YCBCR_ENC_DEFAULT)
1947 tpg->real_ycbcr_enc =
1948 V4L2_MAP_YCBCR_ENC_DEFAULT(tpg->colorspace);
1949
1950 if (tpg->quantization == V4L2_QUANTIZATION_DEFAULT)
1951 tpg->real_quantization =
1952 V4L2_MAP_QUANTIZATION_DEFAULT(
1953 tpg->color_enc != TGP_COLOR_ENC_YCBCR,
1954 tpg->colorspace, tpg->real_ycbcr_enc);
1955
1956 tpg_precalculate_colors(tpg);
1957 }
1958 if (tpg->recalc_square_border) {
1959 tpg->recalc_square_border = false;
1960 tpg_calculate_square_border(tpg);
1961 }
1962 if (tpg->recalc_lines) {
1963 tpg->recalc_lines = false;
1964 tpg_precalculate_line(tpg);
1965 }
1966 }
1967
1968 void tpg_calc_text_basep(struct tpg_data *tpg,
1969 u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf)
1970 {
1971 unsigned stride = tpg->bytesperline[p];
1972 unsigned h = tpg->buf_height;
1973
1974 tpg_recalc(tpg);
1975
1976 basep[p][0] = vbuf;
1977 basep[p][1] = vbuf;
1978 h /= tpg->vdownsampling[p];
1979 if (tpg->field == V4L2_FIELD_SEQ_TB)
1980 basep[p][1] += h * stride / 2;
1981 else if (tpg->field == V4L2_FIELD_SEQ_BT)
1982 basep[p][0] += h * stride / 2;
1983 if (p == 0 && tpg->interleaved)
1984 tpg_calc_text_basep(tpg, basep, 1, vbuf);
1985 }
1986 EXPORT_SYMBOL_GPL(tpg_calc_text_basep);
1987
1988 static int tpg_pattern_avg(const struct tpg_data *tpg,
1989 unsigned pat1, unsigned pat2)
1990 {
1991 unsigned pat_lines = tpg_get_pat_lines(tpg);
1992
1993 if (pat1 == (pat2 + 1) % pat_lines)
1994 return pat2;
1995 if (pat2 == (pat1 + 1) % pat_lines)
1996 return pat1;
1997 return -1;
1998 }
1999
2000 static const char *tpg_color_enc_str(enum tgp_color_enc
2001 color_enc)
2002 {
2003 switch (color_enc) {
2004 case TGP_COLOR_ENC_HSV:
2005 return "HSV";
2006 case TGP_COLOR_ENC_YCBCR:
2007 return "Y'CbCr";
2008 case TGP_COLOR_ENC_LUMA:
2009 return "Luma";
2010 case TGP_COLOR_ENC_RGB:
2011 default:
2012 return "R'G'B";
2013
2014 }
2015 }
2016
2017 void tpg_log_status(struct tpg_data *tpg)
2018 {
2019 pr_info("tpg source WxH: %ux%u (%s)\n",
2020 tpg->src_width, tpg->src_height,
2021 tpg_color_enc_str(tpg->color_enc));
2022 pr_info("tpg field: %u\n", tpg->field);
2023 pr_info("tpg crop: %ux%u@%dx%d\n", tpg->crop.width, tpg->crop.height,
2024 tpg->crop.left, tpg->crop.top);
2025 pr_info("tpg compose: %ux%u@%dx%d\n", tpg->compose.width, tpg->compose.height,
2026 tpg->compose.left, tpg->compose.top);
2027 pr_info("tpg colorspace: %d\n", tpg->colorspace);
2028 pr_info("tpg transfer function: %d/%d\n", tpg->xfer_func, tpg->real_xfer_func);
2029 pr_info("tpg Y'CbCr encoding: %d/%d\n", tpg->ycbcr_enc, tpg->real_ycbcr_enc);
2030 pr_info("tpg HSV encoding: %d/%d\n", tpg->hsv_enc, tpg->real_hsv_enc);
2031 pr_info("tpg quantization: %d/%d\n", tpg->quantization, tpg->real_quantization);
2032 pr_info("tpg RGB range: %d/%d\n", tpg->rgb_range, tpg->real_rgb_range);
2033 }
2034 EXPORT_SYMBOL_GPL(tpg_log_status);
2035
2036 /*
2037 * This struct contains common parameters used by both the drawing of the
2038 * test pattern and the drawing of the extras (borders, square, etc.)
2039 */
2040 struct tpg_draw_params {
2041 /* common data */
2042 bool is_tv;
2043 bool is_60hz;
2044 unsigned twopixsize;
2045 unsigned img_width;
2046 unsigned stride;
2047 unsigned hmax;
2048 unsigned frame_line;
2049 unsigned frame_line_next;
2050
2051 /* test pattern */
2052 unsigned mv_hor_old;
2053 unsigned mv_hor_new;
2054 unsigned mv_vert_old;
2055 unsigned mv_vert_new;
2056
2057 /* extras */
2058 unsigned wss_width;
2059 unsigned wss_random_offset;
2060 unsigned sav_eav_f;
2061 unsigned left_pillar_width;
2062 unsigned right_pillar_start;
2063 };
2064
2065 static void tpg_fill_params_pattern(const struct tpg_data *tpg, unsigned p,
2066 struct tpg_draw_params *params)
2067 {
2068 params->mv_hor_old =
2069 tpg_hscale_div(tpg, p, tpg->mv_hor_count % tpg->src_width);
2070 params->mv_hor_new =
2071 tpg_hscale_div(tpg, p, (tpg->mv_hor_count + tpg->mv_hor_step) %
2072 tpg->src_width);
2073 params->mv_vert_old = tpg->mv_vert_count % tpg->src_height;
2074 params->mv_vert_new =
2075 (tpg->mv_vert_count + tpg->mv_vert_step) % tpg->src_height;
2076 }
2077
2078 static void tpg_fill_params_extras(const struct tpg_data *tpg,
2079 unsigned p,
2080 struct tpg_draw_params *params)
2081 {
2082 unsigned left_pillar_width = 0;
2083 unsigned right_pillar_start = params->img_width;
2084
2085 params->wss_width = tpg->crop.left < tpg->src_width / 2 ?
2086 tpg->src_width / 2 - tpg->crop.left : 0;
2087 if (params->wss_width > tpg->crop.width)
2088 params->wss_width = tpg->crop.width;
2089 params->wss_width = tpg_hscale_div(tpg, p, params->wss_width);
2090 params->wss_random_offset =
2091 params->twopixsize * prandom_u32_max(tpg->src_width / 2);
2092
2093 if (tpg->crop.left < tpg->border.left) {
2094 left_pillar_width = tpg->border.left - tpg->crop.left;
2095 if (left_pillar_width > tpg->crop.width)
2096 left_pillar_width = tpg->crop.width;
2097 left_pillar_width = tpg_hscale_div(tpg, p, left_pillar_width);
2098 }
2099 params->left_pillar_width = left_pillar_width;
2100
2101 if (tpg->crop.left + tpg->crop.width >
2102 tpg->border.left + tpg->border.width) {
2103 right_pillar_start =
2104 tpg->border.left + tpg->border.width - tpg->crop.left;
2105 right_pillar_start =
2106 tpg_hscale_div(tpg, p, right_pillar_start);
2107 if (right_pillar_start > params->img_width)
2108 right_pillar_start = params->img_width;
2109 }
2110 params->right_pillar_start = right_pillar_start;
2111
2112 params->sav_eav_f = tpg->field ==
2113 (params->is_60hz ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
2114 }
2115
2116 static void tpg_fill_plane_extras(const struct tpg_data *tpg,
2117 const struct tpg_draw_params *params,
2118 unsigned p, unsigned h, u8 *vbuf)
2119 {
2120 unsigned twopixsize = params->twopixsize;
2121 unsigned img_width = params->img_width;
2122 unsigned frame_line = params->frame_line;
2123 const struct v4l2_rect *sq = &tpg->square;
2124 const struct v4l2_rect *b = &tpg->border;
2125 const struct v4l2_rect *c = &tpg->crop;
2126
2127 if (params->is_tv && !params->is_60hz &&
2128 frame_line == 0 && params->wss_width) {
2129 /*
2130 * Replace the first half of the top line of a 50 Hz frame
2131 * with random data to simulate a WSS signal.
2132 */
2133 u8 *wss = tpg->random_line[p] + params->wss_random_offset;
2134
2135 memcpy(vbuf, wss, params->wss_width);
2136 }
2137
2138 if (tpg->show_border && frame_line >= b->top &&
2139 frame_line < b->top + b->height) {
2140 unsigned bottom = b->top + b->height - 1;
2141 unsigned left = params->left_pillar_width;
2142 unsigned right = params->right_pillar_start;
2143
2144 if (frame_line == b->top || frame_line == b->top + 1 ||
2145 frame_line == bottom || frame_line == bottom - 1) {
2146 memcpy(vbuf + left, tpg->contrast_line[p],
2147 right - left);
2148 } else {
2149 if (b->left >= c->left &&
2150 b->left < c->left + c->width)
2151 memcpy(vbuf + left,
2152 tpg->contrast_line[p], twopixsize);
2153 if (b->left + b->width > c->left &&
2154 b->left + b->width <= c->left + c->width)
2155 memcpy(vbuf + right - twopixsize,
2156 tpg->contrast_line[p], twopixsize);
2157 }
2158 }
2159 if (tpg->qual != TPG_QUAL_NOISE && frame_line >= b->top &&
2160 frame_line < b->top + b->height) {
2161 memcpy(vbuf, tpg->black_line[p], params->left_pillar_width);
2162 memcpy(vbuf + params->right_pillar_start, tpg->black_line[p],
2163 img_width - params->right_pillar_start);
2164 }
2165 if (tpg->show_square && frame_line >= sq->top &&
2166 frame_line < sq->top + sq->height &&
2167 sq->left < c->left + c->width &&
2168 sq->left + sq->width >= c->left) {
2169 unsigned left = sq->left;
2170 unsigned width = sq->width;
2171
2172 if (c->left > left) {
2173 width -= c->left - left;
2174 left = c->left;
2175 }
2176 if (c->left + c->width < left + width)
2177 width -= left + width - c->left - c->width;
2178 left -= c->left;
2179 left = tpg_hscale_div(tpg, p, left);
2180 width = tpg_hscale_div(tpg, p, width);
2181 memcpy(vbuf + left, tpg->contrast_line[p], width);
2182 }
2183 if (tpg->insert_sav) {
2184 unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width / 3);
2185 u8 *p = vbuf + offset;
2186 unsigned vact = 0, hact = 0;
2187
2188 p[0] = 0xff;
2189 p[1] = 0;
2190 p[2] = 0;
2191 p[3] = 0x80 | (params->sav_eav_f << 6) |
2192 (vact << 5) | (hact << 4) |
2193 ((hact ^ vact) << 3) |
2194 ((hact ^ params->sav_eav_f) << 2) |
2195 ((params->sav_eav_f ^ vact) << 1) |
2196 (hact ^ vact ^ params->sav_eav_f);
2197 }
2198 if (tpg->insert_eav) {
2199 unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width * 2 / 3);
2200 u8 *p = vbuf + offset;
2201 unsigned vact = 0, hact = 1;
2202
2203 p[0] = 0xff;
2204 p[1] = 0;
2205 p[2] = 0;
2206 p[3] = 0x80 | (params->sav_eav_f << 6) |
2207 (vact << 5) | (hact << 4) |
2208 ((hact ^ vact) << 3) |
2209 ((hact ^ params->sav_eav_f) << 2) |
2210 ((params->sav_eav_f ^ vact) << 1) |
2211 (hact ^ vact ^ params->sav_eav_f);
2212 }
2213 }
2214
2215 static void tpg_fill_plane_pattern(const struct tpg_data *tpg,
2216 const struct tpg_draw_params *params,
2217 unsigned p, unsigned h, u8 *vbuf)
2218 {
2219 unsigned twopixsize = params->twopixsize;
2220 unsigned img_width = params->img_width;
2221 unsigned mv_hor_old = params->mv_hor_old;
2222 unsigned mv_hor_new = params->mv_hor_new;
2223 unsigned mv_vert_old = params->mv_vert_old;
2224 unsigned mv_vert_new = params->mv_vert_new;
2225 unsigned frame_line = params->frame_line;
2226 unsigned frame_line_next = params->frame_line_next;
2227 unsigned line_offset = tpg_hscale_div(tpg, p, tpg->crop.left);
2228 bool even;
2229 bool fill_blank = false;
2230 unsigned pat_line_old;
2231 unsigned pat_line_new;
2232 u8 *linestart_older;
2233 u8 *linestart_newer;
2234 u8 *linestart_top;
2235 u8 *linestart_bottom;
2236
2237 even = !(frame_line & 1);
2238
2239 if (h >= params->hmax) {
2240 if (params->hmax == tpg->compose.height)
2241 return;
2242 if (!tpg->perc_fill_blank)
2243 return;
2244 fill_blank = true;
2245 }
2246
2247 if (tpg->vflip) {
2248 frame_line = tpg->src_height - frame_line - 1;
2249 frame_line_next = tpg->src_height - frame_line_next - 1;
2250 }
2251
2252 if (fill_blank) {
2253 linestart_older = tpg->contrast_line[p];
2254 linestart_newer = tpg->contrast_line[p];
2255 } else if (tpg->qual != TPG_QUAL_NOISE &&
2256 (frame_line < tpg->border.top ||
2257 frame_line >= tpg->border.top + tpg->border.height)) {
2258 linestart_older = tpg->black_line[p];
2259 linestart_newer = tpg->black_line[p];
2260 } else if (tpg->pattern == TPG_PAT_NOISE || tpg->qual == TPG_QUAL_NOISE) {
2261 linestart_older = tpg->random_line[p] +
2262 twopixsize * prandom_u32_max(tpg->src_width / 2);
2263 linestart_newer = tpg->random_line[p] +
2264 twopixsize * prandom_u32_max(tpg->src_width / 2);
2265 } else {
2266 unsigned frame_line_old =
2267 (frame_line + mv_vert_old) % tpg->src_height;
2268 unsigned frame_line_new =
2269 (frame_line + mv_vert_new) % tpg->src_height;
2270 unsigned pat_line_next_old;
2271 unsigned pat_line_next_new;
2272
2273 pat_line_old = tpg_get_pat_line(tpg, frame_line_old);
2274 pat_line_new = tpg_get_pat_line(tpg, frame_line_new);
2275 linestart_older = tpg->lines[pat_line_old][p] + mv_hor_old;
2276 linestart_newer = tpg->lines[pat_line_new][p] + mv_hor_new;
2277
2278 if (tpg->vdownsampling[p] > 1 && frame_line != frame_line_next) {
2279 int avg_pat;
2280
2281 /*
2282 * Now decide whether we need to use downsampled_lines[].
2283 * That's necessary if the two lines use different patterns.
2284 */
2285 pat_line_next_old = tpg_get_pat_line(tpg,
2286 (frame_line_next + mv_vert_old) % tpg->src_height);
2287 pat_line_next_new = tpg_get_pat_line(tpg,
2288 (frame_line_next + mv_vert_new) % tpg->src_height);
2289
2290 switch (tpg->field) {
2291 case V4L2_FIELD_INTERLACED:
2292 case V4L2_FIELD_INTERLACED_BT:
2293 case V4L2_FIELD_INTERLACED_TB:
2294 avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_new);
2295 if (avg_pat < 0)
2296 break;
2297 linestart_older = tpg->downsampled_lines[avg_pat][p] + mv_hor_old;
2298 linestart_newer = linestart_older;
2299 break;
2300 case V4L2_FIELD_NONE:
2301 case V4L2_FIELD_TOP:
2302 case V4L2_FIELD_BOTTOM:
2303 case V4L2_FIELD_SEQ_BT:
2304 case V4L2_FIELD_SEQ_TB:
2305 avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_next_old);
2306 if (avg_pat >= 0)
2307 linestart_older = tpg->downsampled_lines[avg_pat][p] +
2308 mv_hor_old;
2309 avg_pat = tpg_pattern_avg(tpg, pat_line_new, pat_line_next_new);
2310 if (avg_pat >= 0)
2311 linestart_newer = tpg->downsampled_lines[avg_pat][p] +
2312 mv_hor_new;
2313 break;
2314 }
2315 }
2316 linestart_older += line_offset;
2317 linestart_newer += line_offset;
2318 }
2319 if (tpg->field_alternate) {
2320 linestart_top = linestart_bottom = linestart_older;
2321 } else if (params->is_60hz) {
2322 linestart_top = linestart_newer;
2323 linestart_bottom = linestart_older;
2324 } else {
2325 linestart_top = linestart_older;
2326 linestart_bottom = linestart_newer;
2327 }
2328
2329 switch (tpg->field) {
2330 case V4L2_FIELD_INTERLACED:
2331 case V4L2_FIELD_INTERLACED_TB:
2332 case V4L2_FIELD_SEQ_TB:
2333 case V4L2_FIELD_SEQ_BT:
2334 if (even)
2335 memcpy(vbuf, linestart_top, img_width);
2336 else
2337 memcpy(vbuf, linestart_bottom, img_width);
2338 break;
2339 case V4L2_FIELD_INTERLACED_BT:
2340 if (even)
2341 memcpy(vbuf, linestart_bottom, img_width);
2342 else
2343 memcpy(vbuf, linestart_top, img_width);
2344 break;
2345 case V4L2_FIELD_TOP:
2346 memcpy(vbuf, linestart_top, img_width);
2347 break;
2348 case V4L2_FIELD_BOTTOM:
2349 memcpy(vbuf, linestart_bottom, img_width);
2350 break;
2351 case V4L2_FIELD_NONE:
2352 default:
2353 memcpy(vbuf, linestart_older, img_width);
2354 break;
2355 }
2356 }
2357
2358 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
2359 unsigned p, u8 *vbuf)
2360 {
2361 struct tpg_draw_params params;
2362 unsigned factor = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
2363
2364 /* Coarse scaling with Bresenham */
2365 unsigned int_part = (tpg->crop.height / factor) / tpg->compose.height;
2366 unsigned fract_part = (tpg->crop.height / factor) % tpg->compose.height;
2367 unsigned src_y = 0;
2368 unsigned error = 0;
2369 unsigned h;
2370
2371 tpg_recalc(tpg);
2372
2373 params.is_tv = std;
2374 params.is_60hz = std & V4L2_STD_525_60;
2375 params.twopixsize = tpg->twopixelsize[p];
2376 params.img_width = tpg_hdiv(tpg, p, tpg->compose.width);
2377 params.stride = tpg->bytesperline[p];
2378 params.hmax = (tpg->compose.height * tpg->perc_fill) / 100;
2379
2380 tpg_fill_params_pattern(tpg, p, &params);
2381 tpg_fill_params_extras(tpg, p, &params);
2382
2383 vbuf += tpg_hdiv(tpg, p, tpg->compose.left);
2384
2385 for (h = 0; h < tpg->compose.height; h++) {
2386 unsigned buf_line;
2387
2388 params.frame_line = tpg_calc_frameline(tpg, src_y, tpg->field);
2389 params.frame_line_next = params.frame_line;
2390 buf_line = tpg_calc_buffer_line(tpg, h, tpg->field);
2391 src_y += int_part;
2392 error += fract_part;
2393 if (error >= tpg->compose.height) {
2394 error -= tpg->compose.height;
2395 src_y++;
2396 }
2397
2398 /*
2399 * For line-interleaved formats determine the 'plane'
2400 * based on the buffer line.
2401 */
2402 if (tpg_g_interleaved(tpg))
2403 p = tpg_g_interleaved_plane(tpg, buf_line);
2404
2405 if (tpg->vdownsampling[p] > 1) {
2406 /*
2407 * When doing vertical downsampling the field setting
2408 * matters: for SEQ_BT/TB we downsample each field
2409 * separately (i.e. lines 0+2 are combined, as are
2410 * lines 1+3), for the other field settings we combine
2411 * odd and even lines. Doing that for SEQ_BT/TB would
2412 * be really weird.
2413 */
2414 if (tpg->field == V4L2_FIELD_SEQ_BT ||
2415 tpg->field == V4L2_FIELD_SEQ_TB) {
2416 unsigned next_src_y = src_y;
2417
2418 if ((h & 3) >= 2)
2419 continue;
2420 next_src_y += int_part;
2421 if (error + fract_part >= tpg->compose.height)
2422 next_src_y++;
2423 params.frame_line_next =
2424 tpg_calc_frameline(tpg, next_src_y, tpg->field);
2425 } else {
2426 if (h & 1)
2427 continue;
2428 params.frame_line_next =
2429 tpg_calc_frameline(tpg, src_y, tpg->field);
2430 }
2431
2432 buf_line /= tpg->vdownsampling[p];
2433 }
2434 tpg_fill_plane_pattern(tpg, &params, p, h,
2435 vbuf + buf_line * params.stride);
2436 tpg_fill_plane_extras(tpg, &params, p, h,
2437 vbuf + buf_line * params.stride);
2438 }
2439 }
2440 EXPORT_SYMBOL_GPL(tpg_fill_plane_buffer);
2441
2442 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8 *vbuf)
2443 {
2444 unsigned offset = 0;
2445 unsigned i;
2446
2447 if (tpg->buffers > 1) {
2448 tpg_fill_plane_buffer(tpg, std, p, vbuf);
2449 return;
2450 }
2451
2452 for (i = 0; i < tpg_g_planes(tpg); i++) {
2453 tpg_fill_plane_buffer(tpg, std, i, vbuf + offset);
2454 offset += tpg_calc_plane_size(tpg, i);
2455 }
2456 }
2457 EXPORT_SYMBOL_GPL(tpg_fillbuffer);
2458
2459 MODULE_DESCRIPTION("V4L2 Test Pattern Generator");
2460 MODULE_AUTHOR("Hans Verkuil");
2461 MODULE_LICENSE("GPL");
Linux with added FPC-III support