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
214 /* Test pattern movement */
215 enum tpg_move_mode mv_hor_mode;
216 int mv_hor_count;
217 int mv_hor_step;
218 enum tpg_move_mode mv_vert_mode;
219 int mv_vert_count;
220 int mv_vert_step;
221
222 bool recalc_colors;
223 bool recalc_lines;
224 bool recalc_square_border;
225
226 /* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
227 unsigned max_line_width;
228 u8 *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
229 u8 *downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
230 u8 *random_line[TPG_MAX_PLANES];
231 u8 *contrast_line[TPG_MAX_PLANES];
232 u8 *black_line[TPG_MAX_PLANES];
233 };
234
235 void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
236 int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
237 void tpg_free(struct tpg_data *tpg);
238 void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
239 u32 field);
240 void tpg_log_status(struct tpg_data *tpg);
241
242 void tpg_set_font(const u8 *f);
243 void tpg_gen_text(const struct tpg_data *tpg,
244 u8 *basep[TPG_MAX_PLANES][2], int y, int x, const char *text);
245 void tpg_calc_text_basep(struct tpg_data *tpg,
246 u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
247 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
248 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
249 unsigned p, u8 *vbuf);
250 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
251 unsigned p, u8 *vbuf);
252 bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
253 void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
254 const struct v4l2_rect *compose);
255 const char *tpg_g_color_order(const struct tpg_data *tpg);
256
tpg_s_pattern(struct tpg_data * tpg,enum tpg_pattern pattern)257 static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
258 {
259 if (tpg->pattern == pattern)
260 return;
261 tpg->pattern = pattern;
262 tpg->recalc_colors = true;
263 }
264
tpg_s_quality(struct tpg_data * tpg,enum tpg_quality qual,unsigned qual_offset)265 static inline void tpg_s_quality(struct tpg_data *tpg,
266 enum tpg_quality qual, unsigned qual_offset)
267 {
268 if (tpg->qual == qual && tpg->qual_offset == qual_offset)
269 return;
270 tpg->qual = qual;
271 tpg->qual_offset = qual_offset;
272 tpg->recalc_colors = true;
273 }
274
tpg_g_quality(const struct tpg_data * tpg)275 static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
276 {
277 return tpg->qual;
278 }
279
tpg_s_alpha_component(struct tpg_data * tpg,u8 alpha_component)280 static inline void tpg_s_alpha_component(struct tpg_data *tpg,
281 u8 alpha_component)
282 {
283 if (tpg->alpha_component == alpha_component)
284 return;
285 tpg->alpha_component = alpha_component;
286 tpg->recalc_colors = true;
287 }
288
tpg_s_alpha_mode(struct tpg_data * tpg,bool red_only)289 static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
290 bool red_only)
291 {
292 if (tpg->alpha_red_only == red_only)
293 return;
294 tpg->alpha_red_only = red_only;
295 tpg->recalc_colors = true;
296 }
297
tpg_s_brightness(struct tpg_data * tpg,u8 brightness)298 static inline void tpg_s_brightness(struct tpg_data *tpg,
299 u8 brightness)
300 {
301 if (tpg->brightness == brightness)
302 return;
303 tpg->brightness = brightness;
304 tpg->recalc_colors = true;
305 }
306
tpg_s_contrast(struct tpg_data * tpg,u8 contrast)307 static inline void tpg_s_contrast(struct tpg_data *tpg,
308 u8 contrast)
309 {
310 if (tpg->contrast == contrast)
311 return;
312 tpg->contrast = contrast;
313 tpg->recalc_colors = true;
314 }
315
tpg_s_saturation(struct tpg_data * tpg,u8 saturation)316 static inline void tpg_s_saturation(struct tpg_data *tpg,
317 u8 saturation)
318 {
319 if (tpg->saturation == saturation)
320 return;
321 tpg->saturation = saturation;
322 tpg->recalc_colors = true;
323 }
324
tpg_s_hue(struct tpg_data * tpg,s16 hue)325 static inline void tpg_s_hue(struct tpg_data *tpg,
326 s16 hue)
327 {
328 hue = clamp_t(s16, hue, -128, 128);
329 if (tpg->hue == hue)
330 return;
331 tpg->hue = hue;
332 tpg->recalc_colors = true;
333 }
334
tpg_s_rgb_range(struct tpg_data * tpg,unsigned rgb_range)335 static inline void tpg_s_rgb_range(struct tpg_data *tpg,
336 unsigned rgb_range)
337 {
338 if (tpg->rgb_range == rgb_range)
339 return;
340 tpg->rgb_range = rgb_range;
341 tpg->recalc_colors = true;
342 }
343
tpg_s_real_rgb_range(struct tpg_data * tpg,unsigned rgb_range)344 static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
345 unsigned rgb_range)
346 {
347 if (tpg->real_rgb_range == rgb_range)
348 return;
349 tpg->real_rgb_range = rgb_range;
350 tpg->recalc_colors = true;
351 }
352
tpg_s_colorspace(struct tpg_data * tpg,u32 colorspace)353 static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
354 {
355 if (tpg->colorspace == colorspace)
356 return;
357 tpg->colorspace = colorspace;
358 tpg->recalc_colors = true;
359 }
360
tpg_g_colorspace(const struct tpg_data * tpg)361 static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
362 {
363 return tpg->colorspace;
364 }
365
tpg_s_ycbcr_enc(struct tpg_data * tpg,u32 ycbcr_enc)366 static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
367 {
368 if (tpg->ycbcr_enc == ycbcr_enc)
369 return;
370 tpg->ycbcr_enc = ycbcr_enc;
371 tpg->recalc_colors = true;
372 }
373
tpg_g_ycbcr_enc(const struct tpg_data * tpg)374 static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
375 {
376 return tpg->ycbcr_enc;
377 }
378
tpg_s_hsv_enc(struct tpg_data * tpg,u32 hsv_enc)379 static inline void tpg_s_hsv_enc(struct tpg_data *tpg, u32 hsv_enc)
380 {
381 if (tpg->hsv_enc == hsv_enc)
382 return;
383 tpg->hsv_enc = hsv_enc;
384 tpg->recalc_colors = true;
385 }
386
tpg_g_hsv_enc(const struct tpg_data * tpg)387 static inline u32 tpg_g_hsv_enc(const struct tpg_data *tpg)
388 {
389 return tpg->hsv_enc;
390 }
391
tpg_s_xfer_func(struct tpg_data * tpg,u32 xfer_func)392 static inline void tpg_s_xfer_func(struct tpg_data *tpg, u32 xfer_func)
393 {
394 if (tpg->xfer_func == xfer_func)
395 return;
396 tpg->xfer_func = xfer_func;
397 tpg->recalc_colors = true;
398 }
399
tpg_g_xfer_func(const struct tpg_data * tpg)400 static inline u32 tpg_g_xfer_func(const struct tpg_data *tpg)
401 {
402 return tpg->xfer_func;
403 }
404
tpg_s_quantization(struct tpg_data * tpg,u32 quantization)405 static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
406 {
407 if (tpg->quantization == quantization)
408 return;
409 tpg->quantization = quantization;
410 tpg->recalc_colors = true;
411 }
412
tpg_g_quantization(const struct tpg_data * tpg)413 static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
414 {
415 return tpg->quantization;
416 }
417
tpg_g_buffers(const struct tpg_data * tpg)418 static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
419 {
420 return tpg->buffers;
421 }
422
tpg_g_planes(const struct tpg_data * tpg)423 static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
424 {
425 return tpg->interleaved ? 1 : tpg->planes;
426 }
427
tpg_g_interleaved(const struct tpg_data * tpg)428 static inline bool tpg_g_interleaved(const struct tpg_data *tpg)
429 {
430 return tpg->interleaved;
431 }
432
tpg_g_twopixelsize(const struct tpg_data * tpg,unsigned plane)433 static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
434 {
435 return tpg->twopixelsize[plane];
436 }
437
tpg_hdiv(const struct tpg_data * tpg,unsigned plane,unsigned x)438 static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
439 unsigned plane, unsigned x)
440 {
441 return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
442 tpg->twopixelsize[plane] / 2;
443 }
444
tpg_hscale(const struct tpg_data * tpg,unsigned x)445 static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
446 {
447 return (x * tpg->scaled_width) / tpg->src_width;
448 }
449
tpg_hscale_div(const struct tpg_data * tpg,unsigned plane,unsigned x)450 static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
451 unsigned plane, unsigned x)
452 {
453 return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
454 }
455
tpg_g_bytesperline(const struct tpg_data * tpg,unsigned plane)456 static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
457 {
458 return tpg->bytesperline[plane];
459 }
460
tpg_s_bytesperline(struct tpg_data * tpg,unsigned plane,unsigned bpl)461 static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
462 {
463 unsigned p;
464
465 if (tpg->buffers > 1) {
466 tpg->bytesperline[plane] = bpl;
467 return;
468 }
469
470 for (p = 0; p < tpg_g_planes(tpg); p++) {
471 unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
472
473 tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
474 }
475 if (tpg_g_interleaved(tpg))
476 tpg->bytesperline[1] = tpg->bytesperline[0];
477 }
478
479
tpg_g_line_width(const struct tpg_data * tpg,unsigned plane)480 static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
481 {
482 unsigned w = 0;
483 unsigned p;
484
485 if (tpg->buffers > 1)
486 return tpg_g_bytesperline(tpg, plane);
487 for (p = 0; p < tpg_g_planes(tpg); p++) {
488 unsigned plane_w = tpg_g_bytesperline(tpg, p);
489
490 w += plane_w / tpg->vdownsampling[p];
491 }
492 return w;
493 }
494
tpg_calc_line_width(const struct tpg_data * tpg,unsigned plane,unsigned bpl)495 static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
496 unsigned plane, unsigned bpl)
497 {
498 unsigned w = 0;
499 unsigned p;
500
501 if (tpg->buffers > 1)
502 return bpl;
503 for (p = 0; p < tpg_g_planes(tpg); p++) {
504 unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
505
506 plane_w /= tpg->hdownsampling[p];
507 w += plane_w / tpg->vdownsampling[p];
508 }
509 return w;
510 }
511
tpg_calc_plane_size(const struct tpg_data * tpg,unsigned plane)512 static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
513 {
514 if (plane >= tpg_g_planes(tpg))
515 return 0;
516
517 return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
518 tpg->vdownsampling[plane];
519 }
520
tpg_s_buf_height(struct tpg_data * tpg,unsigned h)521 static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
522 {
523 tpg->buf_height = h;
524 }
525
tpg_s_field(struct tpg_data * tpg,unsigned field,bool alternate)526 static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
527 {
528 tpg->field = field;
529 tpg->field_alternate = alternate;
530 }
531
tpg_s_perc_fill(struct tpg_data * tpg,unsigned perc_fill)532 static inline void tpg_s_perc_fill(struct tpg_data *tpg,
533 unsigned perc_fill)
534 {
535 tpg->perc_fill = perc_fill;
536 }
537
tpg_g_perc_fill(const struct tpg_data * tpg)538 static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
539 {
540 return tpg->perc_fill;
541 }
542
tpg_s_perc_fill_blank(struct tpg_data * tpg,bool perc_fill_blank)543 static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
544 bool perc_fill_blank)
545 {
546 tpg->perc_fill_blank = perc_fill_blank;
547 }
548
tpg_s_video_aspect(struct tpg_data * tpg,enum tpg_video_aspect vid_aspect)549 static inline void tpg_s_video_aspect(struct tpg_data *tpg,
550 enum tpg_video_aspect vid_aspect)
551 {
552 if (tpg->vid_aspect == vid_aspect)
553 return;
554 tpg->vid_aspect = vid_aspect;
555 tpg->recalc_square_border = true;
556 }
557
tpg_g_video_aspect(const struct tpg_data * tpg)558 static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
559 {
560 return tpg->vid_aspect;
561 }
562
tpg_s_pixel_aspect(struct tpg_data * tpg,enum tpg_pixel_aspect pix_aspect)563 static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
564 enum tpg_pixel_aspect pix_aspect)
565 {
566 if (tpg->pix_aspect == pix_aspect)
567 return;
568 tpg->pix_aspect = pix_aspect;
569 tpg->recalc_square_border = true;
570 }
571
tpg_s_show_border(struct tpg_data * tpg,bool show_border)572 static inline void tpg_s_show_border(struct tpg_data *tpg,
573 bool show_border)
574 {
575 tpg->show_border = show_border;
576 }
577
tpg_s_show_square(struct tpg_data * tpg,bool show_square)578 static inline void tpg_s_show_square(struct tpg_data *tpg,
579 bool show_square)
580 {
581 tpg->show_square = show_square;
582 }
583
tpg_s_insert_sav(struct tpg_data * tpg,bool insert_sav)584 static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
585 {
586 tpg->insert_sav = insert_sav;
587 }
588
tpg_s_insert_eav(struct tpg_data * tpg,bool insert_eav)589 static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
590 {
591 tpg->insert_eav = insert_eav;
592 }
593
594 void tpg_update_mv_step(struct tpg_data *tpg);
595
tpg_s_mv_hor_mode(struct tpg_data * tpg,enum tpg_move_mode mv_hor_mode)596 static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
597 enum tpg_move_mode mv_hor_mode)
598 {
599 tpg->mv_hor_mode = mv_hor_mode;
600 tpg_update_mv_step(tpg);
601 }
602
tpg_s_mv_vert_mode(struct tpg_data * tpg,enum tpg_move_mode mv_vert_mode)603 static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
604 enum tpg_move_mode mv_vert_mode)
605 {
606 tpg->mv_vert_mode = mv_vert_mode;
607 tpg_update_mv_step(tpg);
608 }
609
tpg_init_mv_count(struct tpg_data * tpg)610 static inline void tpg_init_mv_count(struct tpg_data *tpg)
611 {
612 tpg->mv_hor_count = tpg->mv_vert_count = 0;
613 }
614
tpg_update_mv_count(struct tpg_data * tpg,bool frame_is_field)615 static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
616 {
617 tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
618 tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
619 }
620
tpg_s_hflip(struct tpg_data * tpg,bool hflip)621 static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
622 {
623 if (tpg->hflip == hflip)
624 return;
625 tpg->hflip = hflip;
626 tpg_update_mv_step(tpg);
627 tpg->recalc_lines = true;
628 }
629
tpg_g_hflip(const struct tpg_data * tpg)630 static inline bool tpg_g_hflip(const struct tpg_data *tpg)
631 {
632 return tpg->hflip;
633 }
634
tpg_s_vflip(struct tpg_data * tpg,bool vflip)635 static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
636 {
637 tpg->vflip = vflip;
638 }
639
tpg_g_vflip(const struct tpg_data * tpg)640 static inline bool tpg_g_vflip(const struct tpg_data *tpg)
641 {
642 return tpg->vflip;
643 }
644
tpg_pattern_is_static(const struct tpg_data * tpg)645 static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
646 {
647 return tpg->pattern != TPG_PAT_NOISE &&
648 tpg->mv_hor_mode == TPG_MOVE_NONE &&
649 tpg->mv_vert_mode == TPG_MOVE_NONE;
650 }
651
652 #endif
653