xref: /openbmc/linux/include/media/tpg/v4l2-tpg.h (revision 5a531791)
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * v4l2-tpg.h - Test Pattern Generator
4  *
5  * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6  */
7 
8 #ifndef _V4L2_TPG_H_
9 #define _V4L2_TPG_H_
10 
11 #include <linux/types.h>
12 #include <linux/errno.h>
13 #include <linux/random.h>
14 #include <linux/slab.h>
15 #include <linux/vmalloc.h>
16 #include <linux/videodev2.h>
17 
18 struct tpg_rbg_color8 {
19 	unsigned char r, g, b;
20 };
21 
22 struct tpg_rbg_color16 {
23 	__u16 r, g, b;
24 };
25 
26 enum tpg_color {
27 	TPG_COLOR_CSC_WHITE,
28 	TPG_COLOR_CSC_YELLOW,
29 	TPG_COLOR_CSC_CYAN,
30 	TPG_COLOR_CSC_GREEN,
31 	TPG_COLOR_CSC_MAGENTA,
32 	TPG_COLOR_CSC_RED,
33 	TPG_COLOR_CSC_BLUE,
34 	TPG_COLOR_CSC_BLACK,
35 	TPG_COLOR_75_YELLOW,
36 	TPG_COLOR_75_CYAN,
37 	TPG_COLOR_75_GREEN,
38 	TPG_COLOR_75_MAGENTA,
39 	TPG_COLOR_75_RED,
40 	TPG_COLOR_75_BLUE,
41 	TPG_COLOR_100_WHITE,
42 	TPG_COLOR_100_YELLOW,
43 	TPG_COLOR_100_CYAN,
44 	TPG_COLOR_100_GREEN,
45 	TPG_COLOR_100_MAGENTA,
46 	TPG_COLOR_100_RED,
47 	TPG_COLOR_100_BLUE,
48 	TPG_COLOR_100_BLACK,
49 	TPG_COLOR_TEXTFG,
50 	TPG_COLOR_TEXTBG,
51 	TPG_COLOR_RANDOM,
52 	TPG_COLOR_RAMP,
53 	TPG_COLOR_MAX = TPG_COLOR_RAMP + 256
54 };
55 
56 extern const struct tpg_rbg_color8 tpg_colors[TPG_COLOR_MAX];
57 extern const unsigned short tpg_rec709_to_linear[255 * 16 + 1];
58 extern const unsigned short tpg_linear_to_rec709[255 * 16 + 1];
59 extern const struct tpg_rbg_color16 tpg_csc_colors[V4L2_COLORSPACE_DCI_P3 + 1]
60 					  [V4L2_XFER_FUNC_SMPTE2084 + 1]
61 					  [TPG_COLOR_CSC_BLACK + 1];
62 enum tpg_pattern {
63 	TPG_PAT_75_COLORBAR,
64 	TPG_PAT_100_COLORBAR,
65 	TPG_PAT_CSC_COLORBAR,
66 	TPG_PAT_100_HCOLORBAR,
67 	TPG_PAT_100_COLORSQUARES,
68 	TPG_PAT_BLACK,
69 	TPG_PAT_WHITE,
70 	TPG_PAT_RED,
71 	TPG_PAT_GREEN,
72 	TPG_PAT_BLUE,
73 	TPG_PAT_CHECKERS_16X16,
74 	TPG_PAT_CHECKERS_2X2,
75 	TPG_PAT_CHECKERS_1X1,
76 	TPG_PAT_COLOR_CHECKERS_2X2,
77 	TPG_PAT_COLOR_CHECKERS_1X1,
78 	TPG_PAT_ALTERNATING_HLINES,
79 	TPG_PAT_ALTERNATING_VLINES,
80 	TPG_PAT_CROSS_1_PIXEL,
81 	TPG_PAT_CROSS_2_PIXELS,
82 	TPG_PAT_CROSS_10_PIXELS,
83 	TPG_PAT_GRAY_RAMP,
84 
85 	/* Must be the last pattern */
86 	TPG_PAT_NOISE,
87 };
88 
89 extern const char * const tpg_pattern_strings[];
90 
91 enum tpg_quality {
92 	TPG_QUAL_COLOR,
93 	TPG_QUAL_GRAY,
94 	TPG_QUAL_NOISE
95 };
96 
97 enum tpg_video_aspect {
98 	TPG_VIDEO_ASPECT_IMAGE,
99 	TPG_VIDEO_ASPECT_4X3,
100 	TPG_VIDEO_ASPECT_14X9_CENTRE,
101 	TPG_VIDEO_ASPECT_16X9_CENTRE,
102 	TPG_VIDEO_ASPECT_16X9_ANAMORPHIC,
103 };
104 
105 enum tpg_pixel_aspect {
106 	TPG_PIXEL_ASPECT_SQUARE,
107 	TPG_PIXEL_ASPECT_NTSC,
108 	TPG_PIXEL_ASPECT_PAL,
109 };
110 
111 enum tpg_move_mode {
112 	TPG_MOVE_NEG_FAST,
113 	TPG_MOVE_NEG,
114 	TPG_MOVE_NEG_SLOW,
115 	TPG_MOVE_NONE,
116 	TPG_MOVE_POS_SLOW,
117 	TPG_MOVE_POS,
118 	TPG_MOVE_POS_FAST,
119 };
120 
121 enum tgp_color_enc {
122 	TGP_COLOR_ENC_RGB,
123 	TGP_COLOR_ENC_YCBCR,
124 	TGP_COLOR_ENC_HSV,
125 	TGP_COLOR_ENC_LUMA,
126 };
127 
128 extern const char * const tpg_aspect_strings[];
129 
130 #define TPG_MAX_PLANES 3
131 #define TPG_MAX_PAT_LINES 8
132 
133 struct tpg_data {
134 	/* Source frame size */
135 	unsigned			src_width, src_height;
136 	/* Buffer height */
137 	unsigned			buf_height;
138 	/* Scaled output frame size */
139 	unsigned			scaled_width;
140 	u32				field;
141 	bool				field_alternate;
142 	/* crop coordinates are frame-based */
143 	struct v4l2_rect		crop;
144 	/* compose coordinates are format-based */
145 	struct v4l2_rect		compose;
146 	/* border and square coordinates are frame-based */
147 	struct v4l2_rect		border;
148 	struct v4l2_rect		square;
149 
150 	/* Color-related fields */
151 	enum tpg_quality		qual;
152 	unsigned			qual_offset;
153 	u8				alpha_component;
154 	bool				alpha_red_only;
155 	u8				brightness;
156 	u8				contrast;
157 	u8				saturation;
158 	s16				hue;
159 	u32				fourcc;
160 	enum tgp_color_enc		color_enc;
161 	u32				colorspace;
162 	u32				xfer_func;
163 	u32				ycbcr_enc;
164 	u32				hsv_enc;
165 	/*
166 	 * Stores the actual transfer function, i.e. will never be
167 	 * V4L2_XFER_FUNC_DEFAULT.
168 	 */
169 	u32				real_xfer_func;
170 	/*
171 	 * Stores the actual Y'CbCr encoding, i.e. will never be
172 	 * V4L2_YCBCR_ENC_DEFAULT.
173 	 */
174 	u32				real_hsv_enc;
175 	u32				real_ycbcr_enc;
176 	u32				quantization;
177 	/*
178 	 * Stores the actual quantization, i.e. will never be
179 	 * V4L2_QUANTIZATION_DEFAULT.
180 	 */
181 	u32				real_quantization;
182 	enum tpg_video_aspect		vid_aspect;
183 	enum tpg_pixel_aspect		pix_aspect;
184 	unsigned			rgb_range;
185 	unsigned			real_rgb_range;
186 	unsigned			buffers;
187 	unsigned			planes;
188 	bool				interleaved;
189 	u8				vdownsampling[TPG_MAX_PLANES];
190 	u8				hdownsampling[TPG_MAX_PLANES];
191 	/*
192 	 * horizontal positions must be ANDed with this value to enforce
193 	 * correct boundaries for packed YUYV values.
194 	 */
195 	unsigned			hmask[TPG_MAX_PLANES];
196 	/* Used to store the colors in native format, either RGB or YUV */
197 	u8				colors[TPG_COLOR_MAX][3];
198 	u8				textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
199 	/* size in bytes for two pixels in each plane */
200 	unsigned			twopixelsize[TPG_MAX_PLANES];
201 	unsigned			bytesperline[TPG_MAX_PLANES];
202 
203 	/* Configuration */
204 	enum tpg_pattern		pattern;
205 	bool				hflip;
206 	bool				vflip;
207 	unsigned			perc_fill;
208 	bool				perc_fill_blank;
209 	bool				show_border;
210 	bool				show_square;
211 	bool				insert_sav;
212 	bool				insert_eav;
213 	bool				insert_hdmi_video_guard_band;
214 
215 	/* Test pattern movement */
216 	enum tpg_move_mode		mv_hor_mode;
217 	int				mv_hor_count;
218 	int				mv_hor_step;
219 	enum tpg_move_mode		mv_vert_mode;
220 	int				mv_vert_count;
221 	int				mv_vert_step;
222 
223 	bool				recalc_colors;
224 	bool				recalc_lines;
225 	bool				recalc_square_border;
226 
227 	/* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
228 	unsigned			max_line_width;
229 	u8				*lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
230 	u8				*downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
231 	u8				*random_line[TPG_MAX_PLANES];
232 	u8				*contrast_line[TPG_MAX_PLANES];
233 	u8				*black_line[TPG_MAX_PLANES];
234 };
235 
236 void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
237 int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
238 void tpg_free(struct tpg_data *tpg);
239 void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
240 		       u32 field);
241 void tpg_log_status(struct tpg_data *tpg);
242 
243 void tpg_set_font(const u8 *f);
244 void tpg_gen_text(const struct tpg_data *tpg,
245 		u8 *basep[TPG_MAX_PLANES][2], int y, int x, const char *text);
246 void tpg_calc_text_basep(struct tpg_data *tpg,
247 		u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
248 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
249 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
250 			   unsigned p, u8 *vbuf);
251 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
252 		    unsigned p, u8 *vbuf);
253 bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
254 void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
255 		const struct v4l2_rect *compose);
256 const char *tpg_g_color_order(const struct tpg_data *tpg);
257 
tpg_s_pattern(struct tpg_data * tpg,enum tpg_pattern pattern)258 static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
259 {
260 	if (tpg->pattern == pattern)
261 		return;
262 	tpg->pattern = pattern;
263 	tpg->recalc_colors = true;
264 }
265 
tpg_s_quality(struct tpg_data * tpg,enum tpg_quality qual,unsigned qual_offset)266 static inline void tpg_s_quality(struct tpg_data *tpg,
267 				    enum tpg_quality qual, unsigned qual_offset)
268 {
269 	if (tpg->qual == qual && tpg->qual_offset == qual_offset)
270 		return;
271 	tpg->qual = qual;
272 	tpg->qual_offset = qual_offset;
273 	tpg->recalc_colors = true;
274 }
275 
tpg_g_quality(const struct tpg_data * tpg)276 static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
277 {
278 	return tpg->qual;
279 }
280 
tpg_s_alpha_component(struct tpg_data * tpg,u8 alpha_component)281 static inline void tpg_s_alpha_component(struct tpg_data *tpg,
282 					    u8 alpha_component)
283 {
284 	if (tpg->alpha_component == alpha_component)
285 		return;
286 	tpg->alpha_component = alpha_component;
287 	tpg->recalc_colors = true;
288 }
289 
tpg_s_alpha_mode(struct tpg_data * tpg,bool red_only)290 static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
291 					    bool red_only)
292 {
293 	if (tpg->alpha_red_only == red_only)
294 		return;
295 	tpg->alpha_red_only = red_only;
296 	tpg->recalc_colors = true;
297 }
298 
tpg_s_brightness(struct tpg_data * tpg,u8 brightness)299 static inline void tpg_s_brightness(struct tpg_data *tpg,
300 					u8 brightness)
301 {
302 	if (tpg->brightness == brightness)
303 		return;
304 	tpg->brightness = brightness;
305 	tpg->recalc_colors = true;
306 }
307 
tpg_s_contrast(struct tpg_data * tpg,u8 contrast)308 static inline void tpg_s_contrast(struct tpg_data *tpg,
309 					u8 contrast)
310 {
311 	if (tpg->contrast == contrast)
312 		return;
313 	tpg->contrast = contrast;
314 	tpg->recalc_colors = true;
315 }
316 
tpg_s_saturation(struct tpg_data * tpg,u8 saturation)317 static inline void tpg_s_saturation(struct tpg_data *tpg,
318 					u8 saturation)
319 {
320 	if (tpg->saturation == saturation)
321 		return;
322 	tpg->saturation = saturation;
323 	tpg->recalc_colors = true;
324 }
325 
tpg_s_hue(struct tpg_data * tpg,s16 hue)326 static inline void tpg_s_hue(struct tpg_data *tpg,
327 					s16 hue)
328 {
329 	hue = clamp_t(s16, hue, -128, 128);
330 	if (tpg->hue == hue)
331 		return;
332 	tpg->hue = hue;
333 	tpg->recalc_colors = true;
334 }
335 
tpg_s_rgb_range(struct tpg_data * tpg,unsigned rgb_range)336 static inline void tpg_s_rgb_range(struct tpg_data *tpg,
337 					unsigned rgb_range)
338 {
339 	if (tpg->rgb_range == rgb_range)
340 		return;
341 	tpg->rgb_range = rgb_range;
342 	tpg->recalc_colors = true;
343 }
344 
tpg_s_real_rgb_range(struct tpg_data * tpg,unsigned rgb_range)345 static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
346 					unsigned rgb_range)
347 {
348 	if (tpg->real_rgb_range == rgb_range)
349 		return;
350 	tpg->real_rgb_range = rgb_range;
351 	tpg->recalc_colors = true;
352 }
353 
tpg_s_colorspace(struct tpg_data * tpg,u32 colorspace)354 static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
355 {
356 	if (tpg->colorspace == colorspace)
357 		return;
358 	tpg->colorspace = colorspace;
359 	tpg->recalc_colors = true;
360 }
361 
tpg_g_colorspace(const struct tpg_data * tpg)362 static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
363 {
364 	return tpg->colorspace;
365 }
366 
tpg_s_ycbcr_enc(struct tpg_data * tpg,u32 ycbcr_enc)367 static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
368 {
369 	if (tpg->ycbcr_enc == ycbcr_enc)
370 		return;
371 	tpg->ycbcr_enc = ycbcr_enc;
372 	tpg->recalc_colors = true;
373 }
374 
tpg_g_ycbcr_enc(const struct tpg_data * tpg)375 static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
376 {
377 	return tpg->ycbcr_enc;
378 }
379 
tpg_s_hsv_enc(struct tpg_data * tpg,u32 hsv_enc)380 static inline void tpg_s_hsv_enc(struct tpg_data *tpg, u32 hsv_enc)
381 {
382 	if (tpg->hsv_enc == hsv_enc)
383 		return;
384 	tpg->hsv_enc = hsv_enc;
385 	tpg->recalc_colors = true;
386 }
387 
tpg_g_hsv_enc(const struct tpg_data * tpg)388 static inline u32 tpg_g_hsv_enc(const struct tpg_data *tpg)
389 {
390 	return tpg->hsv_enc;
391 }
392 
tpg_s_xfer_func(struct tpg_data * tpg,u32 xfer_func)393 static inline void tpg_s_xfer_func(struct tpg_data *tpg, u32 xfer_func)
394 {
395 	if (tpg->xfer_func == xfer_func)
396 		return;
397 	tpg->xfer_func = xfer_func;
398 	tpg->recalc_colors = true;
399 }
400 
tpg_g_xfer_func(const struct tpg_data * tpg)401 static inline u32 tpg_g_xfer_func(const struct tpg_data *tpg)
402 {
403 	return tpg->xfer_func;
404 }
405 
tpg_s_quantization(struct tpg_data * tpg,u32 quantization)406 static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
407 {
408 	if (tpg->quantization == quantization)
409 		return;
410 	tpg->quantization = quantization;
411 	tpg->recalc_colors = true;
412 }
413 
tpg_g_quantization(const struct tpg_data * tpg)414 static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
415 {
416 	return tpg->quantization;
417 }
418 
tpg_g_buffers(const struct tpg_data * tpg)419 static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
420 {
421 	return tpg->buffers;
422 }
423 
tpg_g_planes(const struct tpg_data * tpg)424 static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
425 {
426 	return tpg->interleaved ? 1 : tpg->planes;
427 }
428 
tpg_g_interleaved(const struct tpg_data * tpg)429 static inline bool tpg_g_interleaved(const struct tpg_data *tpg)
430 {
431 	return tpg->interleaved;
432 }
433 
tpg_g_twopixelsize(const struct tpg_data * tpg,unsigned plane)434 static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
435 {
436 	return tpg->twopixelsize[plane];
437 }
438 
tpg_hdiv(const struct tpg_data * tpg,unsigned plane,unsigned x)439 static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
440 				  unsigned plane, unsigned x)
441 {
442 	return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
443 		tpg->twopixelsize[plane] / 2;
444 }
445 
tpg_hscale(const struct tpg_data * tpg,unsigned x)446 static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
447 {
448 	return (x * tpg->scaled_width) / tpg->src_width;
449 }
450 
tpg_hscale_div(const struct tpg_data * tpg,unsigned plane,unsigned x)451 static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
452 				      unsigned plane, unsigned x)
453 {
454 	return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
455 }
456 
tpg_g_bytesperline(const struct tpg_data * tpg,unsigned plane)457 static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
458 {
459 	return tpg->bytesperline[plane];
460 }
461 
tpg_s_bytesperline(struct tpg_data * tpg,unsigned plane,unsigned bpl)462 static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
463 {
464 	unsigned p;
465 
466 	if (tpg->buffers > 1) {
467 		tpg->bytesperline[plane] = bpl;
468 		return;
469 	}
470 
471 	for (p = 0; p < tpg_g_planes(tpg); p++) {
472 		unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
473 
474 		tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
475 	}
476 	if (tpg_g_interleaved(tpg))
477 		tpg->bytesperline[1] = tpg->bytesperline[0];
478 }
479 
480 
tpg_g_line_width(const struct tpg_data * tpg,unsigned plane)481 static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
482 {
483 	unsigned w = 0;
484 	unsigned p;
485 
486 	if (tpg->buffers > 1)
487 		return tpg_g_bytesperline(tpg, plane);
488 	for (p = 0; p < tpg_g_planes(tpg); p++) {
489 		unsigned plane_w = tpg_g_bytesperline(tpg, p);
490 
491 		w += plane_w / tpg->vdownsampling[p];
492 	}
493 	return w;
494 }
495 
tpg_calc_line_width(const struct tpg_data * tpg,unsigned plane,unsigned bpl)496 static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
497 					   unsigned plane, unsigned bpl)
498 {
499 	unsigned w = 0;
500 	unsigned p;
501 
502 	if (tpg->buffers > 1)
503 		return bpl;
504 	for (p = 0; p < tpg_g_planes(tpg); p++) {
505 		unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
506 
507 		plane_w /= tpg->hdownsampling[p];
508 		w += plane_w / tpg->vdownsampling[p];
509 	}
510 	return w;
511 }
512 
tpg_calc_plane_size(const struct tpg_data * tpg,unsigned plane)513 static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
514 {
515 	if (plane >= tpg_g_planes(tpg))
516 		return 0;
517 
518 	return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
519 	       tpg->vdownsampling[plane];
520 }
521 
tpg_s_buf_height(struct tpg_data * tpg,unsigned h)522 static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
523 {
524 	tpg->buf_height = h;
525 }
526 
tpg_s_field(struct tpg_data * tpg,unsigned field,bool alternate)527 static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
528 {
529 	tpg->field = field;
530 	tpg->field_alternate = alternate;
531 }
532 
tpg_s_perc_fill(struct tpg_data * tpg,unsigned perc_fill)533 static inline void tpg_s_perc_fill(struct tpg_data *tpg,
534 				      unsigned perc_fill)
535 {
536 	tpg->perc_fill = perc_fill;
537 }
538 
tpg_g_perc_fill(const struct tpg_data * tpg)539 static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
540 {
541 	return tpg->perc_fill;
542 }
543 
tpg_s_perc_fill_blank(struct tpg_data * tpg,bool perc_fill_blank)544 static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
545 					 bool perc_fill_blank)
546 {
547 	tpg->perc_fill_blank = perc_fill_blank;
548 }
549 
tpg_s_video_aspect(struct tpg_data * tpg,enum tpg_video_aspect vid_aspect)550 static inline void tpg_s_video_aspect(struct tpg_data *tpg,
551 					enum tpg_video_aspect vid_aspect)
552 {
553 	if (tpg->vid_aspect == vid_aspect)
554 		return;
555 	tpg->vid_aspect = vid_aspect;
556 	tpg->recalc_square_border = true;
557 }
558 
tpg_g_video_aspect(const struct tpg_data * tpg)559 static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
560 {
561 	return tpg->vid_aspect;
562 }
563 
tpg_s_pixel_aspect(struct tpg_data * tpg,enum tpg_pixel_aspect pix_aspect)564 static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
565 					enum tpg_pixel_aspect pix_aspect)
566 {
567 	if (tpg->pix_aspect == pix_aspect)
568 		return;
569 	tpg->pix_aspect = pix_aspect;
570 	tpg->recalc_square_border = true;
571 }
572 
tpg_s_show_border(struct tpg_data * tpg,bool show_border)573 static inline void tpg_s_show_border(struct tpg_data *tpg,
574 					bool show_border)
575 {
576 	tpg->show_border = show_border;
577 }
578 
tpg_s_show_square(struct tpg_data * tpg,bool show_square)579 static inline void tpg_s_show_square(struct tpg_data *tpg,
580 					bool show_square)
581 {
582 	tpg->show_square = show_square;
583 }
584 
tpg_s_insert_sav(struct tpg_data * tpg,bool insert_sav)585 static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
586 {
587 	tpg->insert_sav = insert_sav;
588 }
589 
tpg_s_insert_eav(struct tpg_data * tpg,bool insert_eav)590 static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
591 {
592 	tpg->insert_eav = insert_eav;
593 }
594 
595 /*
596  * This inserts 4 pixels of the RGB color 0xab55ab at the left hand side of the
597  * image. This is only done for 3 or 4 byte RGB pixel formats. This pixel value
598  * equals the Video Guard Band value as defined by HDMI (see section 5.2.2.1
599  * in the HDMI 1.3 Specification) that preceeds the first actual pixel. If the
600  * HDMI receiver doesn't handle this correctly, then it might keep skipping
601  * these Video Guard Band patterns and end up with a shorter video line. So this
602  * is a nice pattern to test with.
603  */
tpg_s_insert_hdmi_video_guard_band(struct tpg_data * tpg,bool insert_hdmi_video_guard_band)604 static inline void tpg_s_insert_hdmi_video_guard_band(struct tpg_data *tpg,
605 						      bool insert_hdmi_video_guard_band)
606 {
607 	tpg->insert_hdmi_video_guard_band = insert_hdmi_video_guard_band;
608 }
609 
610 void tpg_update_mv_step(struct tpg_data *tpg);
611 
tpg_s_mv_hor_mode(struct tpg_data * tpg,enum tpg_move_mode mv_hor_mode)612 static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
613 				enum tpg_move_mode mv_hor_mode)
614 {
615 	tpg->mv_hor_mode = mv_hor_mode;
616 	tpg_update_mv_step(tpg);
617 }
618 
tpg_s_mv_vert_mode(struct tpg_data * tpg,enum tpg_move_mode mv_vert_mode)619 static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
620 				enum tpg_move_mode mv_vert_mode)
621 {
622 	tpg->mv_vert_mode = mv_vert_mode;
623 	tpg_update_mv_step(tpg);
624 }
625 
tpg_init_mv_count(struct tpg_data * tpg)626 static inline void tpg_init_mv_count(struct tpg_data *tpg)
627 {
628 	tpg->mv_hor_count = tpg->mv_vert_count = 0;
629 }
630 
tpg_update_mv_count(struct tpg_data * tpg,bool frame_is_field)631 static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
632 {
633 	tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
634 	tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
635 }
636 
tpg_s_hflip(struct tpg_data * tpg,bool hflip)637 static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
638 {
639 	if (tpg->hflip == hflip)
640 		return;
641 	tpg->hflip = hflip;
642 	tpg_update_mv_step(tpg);
643 	tpg->recalc_lines = true;
644 }
645 
tpg_g_hflip(const struct tpg_data * tpg)646 static inline bool tpg_g_hflip(const struct tpg_data *tpg)
647 {
648 	return tpg->hflip;
649 }
650 
tpg_s_vflip(struct tpg_data * tpg,bool vflip)651 static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
652 {
653 	tpg->vflip = vflip;
654 }
655 
tpg_g_vflip(const struct tpg_data * tpg)656 static inline bool tpg_g_vflip(const struct tpg_data *tpg)
657 {
658 	return tpg->vflip;
659 }
660 
tpg_pattern_is_static(const struct tpg_data * tpg)661 static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
662 {
663 	return tpg->pattern != TPG_PAT_NOISE &&
664 	       tpg->mv_hor_mode == TPG_MOVE_NONE &&
665 	       tpg->mv_vert_mode == TPG_MOVE_NONE;
666 }
667 
668 #endif
669