blob: 82ce9bfa86049eaa2bc4017acac00e2fe0067e62 [file] [log] [blame]
Hans Verkuil63881df2014-08-25 08:02:14 -03001/*
2 * vivid-tpg.h - Test Pattern Generator
3 *
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17 * SOFTWARE.
18 */
19
20#ifndef _VIVID_TPG_H_
21#define _VIVID_TPG_H_
22
Hans Verkuil63881df2014-08-25 08:02:14 -030023#include <linux/types.h>
24#include <linux/errno.h>
25#include <linux/random.h>
26#include <linux/slab.h>
Hans Verkuil5754d0d2014-09-03 04:29:00 -030027#include <linux/vmalloc.h>
Hans Verkuil63881df2014-08-25 08:02:14 -030028#include <linux/videodev2.h>
29
30#include "vivid-tpg-colors.h"
31
32enum tpg_pattern {
33 TPG_PAT_75_COLORBAR,
34 TPG_PAT_100_COLORBAR,
35 TPG_PAT_CSC_COLORBAR,
36 TPG_PAT_100_HCOLORBAR,
37 TPG_PAT_100_COLORSQUARES,
38 TPG_PAT_BLACK,
39 TPG_PAT_WHITE,
40 TPG_PAT_RED,
41 TPG_PAT_GREEN,
42 TPG_PAT_BLUE,
43 TPG_PAT_CHECKERS_16X16,
Hans Verkuil1a05d312015-03-07 12:49:57 -030044 TPG_PAT_CHECKERS_2X2,
Hans Verkuil63881df2014-08-25 08:02:14 -030045 TPG_PAT_CHECKERS_1X1,
Hans Verkuil1a05d312015-03-07 12:49:57 -030046 TPG_PAT_COLOR_CHECKERS_2X2,
47 TPG_PAT_COLOR_CHECKERS_1X1,
Hans Verkuil63881df2014-08-25 08:02:14 -030048 TPG_PAT_ALTERNATING_HLINES,
49 TPG_PAT_ALTERNATING_VLINES,
50 TPG_PAT_CROSS_1_PIXEL,
51 TPG_PAT_CROSS_2_PIXELS,
52 TPG_PAT_CROSS_10_PIXELS,
53 TPG_PAT_GRAY_RAMP,
54
55 /* Must be the last pattern */
56 TPG_PAT_NOISE,
57};
58
59extern const char * const tpg_pattern_strings[];
60
61enum tpg_quality {
62 TPG_QUAL_COLOR,
63 TPG_QUAL_GRAY,
64 TPG_QUAL_NOISE
65};
66
67enum tpg_video_aspect {
68 TPG_VIDEO_ASPECT_IMAGE,
69 TPG_VIDEO_ASPECT_4X3,
70 TPG_VIDEO_ASPECT_14X9_CENTRE,
71 TPG_VIDEO_ASPECT_16X9_CENTRE,
72 TPG_VIDEO_ASPECT_16X9_ANAMORPHIC,
73};
74
75enum tpg_pixel_aspect {
76 TPG_PIXEL_ASPECT_SQUARE,
77 TPG_PIXEL_ASPECT_NTSC,
78 TPG_PIXEL_ASPECT_PAL,
79};
80
81enum tpg_move_mode {
82 TPG_MOVE_NEG_FAST,
83 TPG_MOVE_NEG,
84 TPG_MOVE_NEG_SLOW,
85 TPG_MOVE_NONE,
86 TPG_MOVE_POS_SLOW,
87 TPG_MOVE_POS,
88 TPG_MOVE_POS_FAST,
89};
90
91extern const char * const tpg_aspect_strings[];
92
Hans Verkuilba01f672015-03-07 13:57:27 -030093#define TPG_MAX_PLANES 3
Hans Verkuil63881df2014-08-25 08:02:14 -030094#define TPG_MAX_PAT_LINES 8
95
96struct tpg_data {
97 /* Source frame size */
98 unsigned src_width, src_height;
99 /* Buffer height */
100 unsigned buf_height;
101 /* Scaled output frame size */
102 unsigned scaled_width;
103 u32 field;
Hans Verkuil43047f62015-03-07 12:38:42 -0300104 bool field_alternate;
Hans Verkuil63881df2014-08-25 08:02:14 -0300105 /* crop coordinates are frame-based */
106 struct v4l2_rect crop;
107 /* compose coordinates are format-based */
108 struct v4l2_rect compose;
109 /* border and square coordinates are frame-based */
110 struct v4l2_rect border;
111 struct v4l2_rect square;
112
113 /* Color-related fields */
114 enum tpg_quality qual;
115 unsigned qual_offset;
116 u8 alpha_component;
117 bool alpha_red_only;
118 u8 brightness;
119 u8 contrast;
120 u8 saturation;
121 s16 hue;
122 u32 fourcc;
123 bool is_yuv;
124 u32 colorspace;
Hans Verkuil481b97a2014-11-17 10:14:32 -0300125 u32 ycbcr_enc;
126 /*
127 * Stores the actual Y'CbCr encoding, i.e. will never be
128 * V4L2_YCBCR_ENC_DEFAULT.
129 */
130 u32 real_ycbcr_enc;
131 u32 quantization;
132 /*
133 * Stores the actual quantization, i.e. will never be
134 * V4L2_QUANTIZATION_DEFAULT.
135 */
136 u32 real_quantization;
Hans Verkuil63881df2014-08-25 08:02:14 -0300137 enum tpg_video_aspect vid_aspect;
138 enum tpg_pixel_aspect pix_aspect;
139 unsigned rgb_range;
140 unsigned real_rgb_range;
Hans Verkuil06d1f0c2015-03-07 13:01:53 -0300141 unsigned buffers;
Hans Verkuil63881df2014-08-25 08:02:14 -0300142 unsigned planes;
Hans Verkuilba01f672015-03-07 13:57:27 -0300143 u8 vdownsampling[TPG_MAX_PLANES];
144 u8 hdownsampling[TPG_MAX_PLANES];
Hans Verkuil9991def2015-03-08 05:53:10 -0300145 /*
146 * horizontal positions must be ANDed with this value to enforce
147 * correct boundaries for packed YUYV values.
148 */
149 unsigned hmask[TPG_MAX_PLANES];
Hans Verkuil63881df2014-08-25 08:02:14 -0300150 /* Used to store the colors in native format, either RGB or YUV */
151 u8 colors[TPG_COLOR_MAX][3];
152 u8 textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
153 /* size in bytes for two pixels in each plane */
154 unsigned twopixelsize[TPG_MAX_PLANES];
155 unsigned bytesperline[TPG_MAX_PLANES];
156
157 /* Configuration */
158 enum tpg_pattern pattern;
159 bool hflip;
160 bool vflip;
161 unsigned perc_fill;
162 bool perc_fill_blank;
163 bool show_border;
164 bool show_square;
165 bool insert_sav;
166 bool insert_eav;
167
168 /* Test pattern movement */
169 enum tpg_move_mode mv_hor_mode;
170 int mv_hor_count;
171 int mv_hor_step;
172 enum tpg_move_mode mv_vert_mode;
173 int mv_vert_count;
174 int mv_vert_step;
175
176 bool recalc_colors;
177 bool recalc_lines;
178 bool recalc_square_border;
179
180 /* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
181 unsigned max_line_width;
182 u8 *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
Hans Verkuil5d7c5392015-03-07 14:06:43 -0300183 u8 *downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
Hans Verkuil63881df2014-08-25 08:02:14 -0300184 u8 *random_line[TPG_MAX_PLANES];
185 u8 *contrast_line[TPG_MAX_PLANES];
186 u8 *black_line[TPG_MAX_PLANES];
187};
188
189void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
190int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
191void tpg_free(struct tpg_data *tpg);
192void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
193 u32 field);
194
195void tpg_set_font(const u8 *f);
Hans Verkuildfff0482015-03-09 11:04:02 -0300196void tpg_gen_text(const struct tpg_data *tpg,
Hans Verkuil63881df2014-08-25 08:02:14 -0300197 u8 *basep[TPG_MAX_PLANES][2], int y, int x, char *text);
198void tpg_calc_text_basep(struct tpg_data *tpg,
199 u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
Hans Verkuildfff0482015-03-09 11:04:02 -0300200void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
201 unsigned p, u8 *vbuf);
202void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
203 unsigned p, u8 *vbuf);
Hans Verkuil63881df2014-08-25 08:02:14 -0300204bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
205void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
206 const struct v4l2_rect *compose);
207
208static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
209{
210 if (tpg->pattern == pattern)
211 return;
212 tpg->pattern = pattern;
213 tpg->recalc_colors = true;
214}
215
216static inline void tpg_s_quality(struct tpg_data *tpg,
217 enum tpg_quality qual, unsigned qual_offset)
218{
219 if (tpg->qual == qual && tpg->qual_offset == qual_offset)
220 return;
221 tpg->qual = qual;
222 tpg->qual_offset = qual_offset;
223 tpg->recalc_colors = true;
224}
225
226static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
227{
228 return tpg->qual;
229}
230
231static inline void tpg_s_alpha_component(struct tpg_data *tpg,
232 u8 alpha_component)
233{
234 if (tpg->alpha_component == alpha_component)
235 return;
236 tpg->alpha_component = alpha_component;
237 tpg->recalc_colors = true;
238}
239
240static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
241 bool red_only)
242{
243 if (tpg->alpha_red_only == red_only)
244 return;
245 tpg->alpha_red_only = red_only;
246 tpg->recalc_colors = true;
247}
248
249static inline void tpg_s_brightness(struct tpg_data *tpg,
250 u8 brightness)
251{
252 if (tpg->brightness == brightness)
253 return;
254 tpg->brightness = brightness;
255 tpg->recalc_colors = true;
256}
257
258static inline void tpg_s_contrast(struct tpg_data *tpg,
259 u8 contrast)
260{
261 if (tpg->contrast == contrast)
262 return;
263 tpg->contrast = contrast;
264 tpg->recalc_colors = true;
265}
266
267static inline void tpg_s_saturation(struct tpg_data *tpg,
268 u8 saturation)
269{
270 if (tpg->saturation == saturation)
271 return;
272 tpg->saturation = saturation;
273 tpg->recalc_colors = true;
274}
275
276static inline void tpg_s_hue(struct tpg_data *tpg,
277 s16 hue)
278{
279 if (tpg->hue == hue)
280 return;
281 tpg->hue = hue;
282 tpg->recalc_colors = true;
283}
284
285static inline void tpg_s_rgb_range(struct tpg_data *tpg,
286 unsigned rgb_range)
287{
288 if (tpg->rgb_range == rgb_range)
289 return;
290 tpg->rgb_range = rgb_range;
291 tpg->recalc_colors = true;
292}
293
294static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
295 unsigned rgb_range)
296{
297 if (tpg->real_rgb_range == rgb_range)
298 return;
299 tpg->real_rgb_range = rgb_range;
300 tpg->recalc_colors = true;
301}
302
303static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
304{
305 if (tpg->colorspace == colorspace)
306 return;
307 tpg->colorspace = colorspace;
308 tpg->recalc_colors = true;
309}
310
311static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
312{
313 return tpg->colorspace;
314}
315
Hans Verkuil481b97a2014-11-17 10:14:32 -0300316static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
317{
318 if (tpg->ycbcr_enc == ycbcr_enc)
319 return;
320 tpg->ycbcr_enc = ycbcr_enc;
321 tpg->recalc_colors = true;
322}
323
324static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
325{
326 return tpg->ycbcr_enc;
327}
328
329static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
330{
331 if (tpg->quantization == quantization)
332 return;
333 tpg->quantization = quantization;
334 tpg->recalc_colors = true;
335}
336
337static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
338{
339 return tpg->quantization;
340}
341
Hans Verkuil06d1f0c2015-03-07 13:01:53 -0300342static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
343{
344 return tpg->buffers;
345}
346
Hans Verkuil63881df2014-08-25 08:02:14 -0300347static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
348{
349 return tpg->planes;
350}
351
352static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
353{
354 return tpg->twopixelsize[plane];
355}
356
Hans Verkuil9991def2015-03-08 05:53:10 -0300357static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
358 unsigned plane, unsigned x)
359{
360 return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
361 tpg->twopixelsize[plane] / 2;
362}
363
364static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
365{
366 return (x * tpg->scaled_width) / tpg->src_width;
367}
368
369static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
370 unsigned plane, unsigned x)
371{
372 return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
373}
374
Hans Verkuil63881df2014-08-25 08:02:14 -0300375static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
376{
377 return tpg->bytesperline[plane];
378}
379
380static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
381{
Hans Verkuil4db22042015-03-07 13:39:01 -0300382 unsigned p;
383
384 if (tpg->buffers > 1) {
385 tpg->bytesperline[plane] = bpl;
386 return;
387 }
388
389 for (p = 0; p < tpg->planes; p++) {
390 unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
391
Hans Verkuilba01f672015-03-07 13:57:27 -0300392 tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
Hans Verkuil4db22042015-03-07 13:39:01 -0300393 }
394}
395
Hans Verkuilba01f672015-03-07 13:57:27 -0300396
Hans Verkuil4db22042015-03-07 13:39:01 -0300397static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
398{
399 unsigned w = 0;
400 unsigned p;
401
402 if (tpg->buffers > 1)
403 return tpg_g_bytesperline(tpg, plane);
404 for (p = 0; p < tpg->planes; p++) {
405 unsigned plane_w = tpg_g_bytesperline(tpg, p);
406
Hans Verkuilba01f672015-03-07 13:57:27 -0300407 w += plane_w / tpg->vdownsampling[p];
Hans Verkuil4db22042015-03-07 13:39:01 -0300408 }
409 return w;
410}
411
412static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
413 unsigned plane, unsigned bpl)
414{
415 unsigned w = 0;
416 unsigned p;
417
418 if (tpg->buffers > 1)
419 return bpl;
420 for (p = 0; p < tpg->planes; p++) {
421 unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
422
Hans Verkuilba01f672015-03-07 13:57:27 -0300423 plane_w /= tpg->hdownsampling[p];
424 w += plane_w / tpg->vdownsampling[p];
Hans Verkuil4db22042015-03-07 13:39:01 -0300425 }
426 return w;
427}
428
429static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
430{
431 if (plane >= tpg->planes)
432 return 0;
433
Hans Verkuilba01f672015-03-07 13:57:27 -0300434 return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
435 tpg->vdownsampling[plane];
Hans Verkuil63881df2014-08-25 08:02:14 -0300436}
437
438static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
439{
440 tpg->buf_height = h;
441}
442
Hans Verkuil43047f62015-03-07 12:38:42 -0300443static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
Hans Verkuil63881df2014-08-25 08:02:14 -0300444{
445 tpg->field = field;
Hans Verkuil43047f62015-03-07 12:38:42 -0300446 tpg->field_alternate = alternate;
Hans Verkuil63881df2014-08-25 08:02:14 -0300447}
448
449static inline void tpg_s_perc_fill(struct tpg_data *tpg,
450 unsigned perc_fill)
451{
452 tpg->perc_fill = perc_fill;
453}
454
455static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
456{
457 return tpg->perc_fill;
458}
459
460static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
461 bool perc_fill_blank)
462{
463 tpg->perc_fill_blank = perc_fill_blank;
464}
465
466static inline void tpg_s_video_aspect(struct tpg_data *tpg,
467 enum tpg_video_aspect vid_aspect)
468{
469 if (tpg->vid_aspect == vid_aspect)
470 return;
471 tpg->vid_aspect = vid_aspect;
472 tpg->recalc_square_border = true;
473}
474
475static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
476{
477 return tpg->vid_aspect;
478}
479
480static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
481 enum tpg_pixel_aspect pix_aspect)
482{
483 if (tpg->pix_aspect == pix_aspect)
484 return;
485 tpg->pix_aspect = pix_aspect;
486 tpg->recalc_square_border = true;
487}
488
489static inline void tpg_s_show_border(struct tpg_data *tpg,
490 bool show_border)
491{
492 tpg->show_border = show_border;
493}
494
495static inline void tpg_s_show_square(struct tpg_data *tpg,
496 bool show_square)
497{
498 tpg->show_square = show_square;
499}
500
501static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
502{
503 tpg->insert_sav = insert_sav;
504}
505
506static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
507{
508 tpg->insert_eav = insert_eav;
509}
510
511void tpg_update_mv_step(struct tpg_data *tpg);
512
513static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
514 enum tpg_move_mode mv_hor_mode)
515{
516 tpg->mv_hor_mode = mv_hor_mode;
517 tpg_update_mv_step(tpg);
518}
519
520static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
521 enum tpg_move_mode mv_vert_mode)
522{
523 tpg->mv_vert_mode = mv_vert_mode;
524 tpg_update_mv_step(tpg);
525}
526
527static inline void tpg_init_mv_count(struct tpg_data *tpg)
528{
529 tpg->mv_hor_count = tpg->mv_vert_count = 0;
530}
531
532static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
533{
534 tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
535 tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
536}
537
538static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
539{
540 if (tpg->hflip == hflip)
541 return;
542 tpg->hflip = hflip;
543 tpg_update_mv_step(tpg);
544 tpg->recalc_lines = true;
545}
546
547static inline bool tpg_g_hflip(const struct tpg_data *tpg)
548{
549 return tpg->hflip;
550}
551
552static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
553{
554 tpg->vflip = vflip;
555}
556
557static inline bool tpg_g_vflip(const struct tpg_data *tpg)
558{
559 return tpg->vflip;
560}
561
562static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
563{
564 return tpg->pattern != TPG_PAT_NOISE &&
565 tpg->mv_hor_mode == TPG_MOVE_NONE &&
566 tpg->mv_vert_mode == TPG_MOVE_NONE;
567}
568
569#endif