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 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 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 276 static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg) 277 { 278 return tpg->qual; 279 } 280 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 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 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 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 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 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 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 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 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 362 static inline u32 tpg_g_colorspace(const struct tpg_data *tpg) 363 { 364 return tpg->colorspace; 365 } 366 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 375 static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg) 376 { 377 return tpg->ycbcr_enc; 378 } 379 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 388 static inline u32 tpg_g_hsv_enc(const struct tpg_data *tpg) 389 { 390 return tpg->hsv_enc; 391 } 392 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 401 static inline u32 tpg_g_xfer_func(const struct tpg_data *tpg) 402 { 403 return tpg->xfer_func; 404 } 405 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 414 static inline u32 tpg_g_quantization(const struct tpg_data *tpg) 415 { 416 return tpg->quantization; 417 } 418 419 static inline unsigned tpg_g_buffers(const struct tpg_data *tpg) 420 { 421 return tpg->buffers; 422 } 423 424 static inline unsigned tpg_g_planes(const struct tpg_data *tpg) 425 { 426 return tpg->interleaved ? 1 : tpg->planes; 427 } 428 429 static inline bool tpg_g_interleaved(const struct tpg_data *tpg) 430 { 431 return tpg->interleaved; 432 } 433 434 static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane) 435 { 436 return tpg->twopixelsize[plane]; 437 } 438 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 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 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 457 static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane) 458 { 459 return tpg->bytesperline[plane]; 460 } 461 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 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 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 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 522 static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h) 523 { 524 tpg->buf_height = h; 525 } 526 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 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 539 static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg) 540 { 541 return tpg->perc_fill; 542 } 543 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 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 559 static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg) 560 { 561 return tpg->vid_aspect; 562 } 563 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 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 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 585 static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav) 586 { 587 tpg->insert_sav = insert_sav; 588 } 589 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 */ 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 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 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 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 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 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 646 static inline bool tpg_g_hflip(const struct tpg_data *tpg) 647 { 648 return tpg->hflip; 649 } 650 651 static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip) 652 { 653 tpg->vflip = vflip; 654 } 655 656 static inline bool tpg_g_vflip(const struct tpg_data *tpg) 657 { 658 return tpg->vflip; 659 } 660 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