drivers/media/platform/vivid/vivid-tpg.h

   1 /*
   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
  23 #include <linux/types.h>
  24 #include <linux/errno.h>
  25 #include <linux/random.h>
  26 #include <linux/slab.h>
  27 #include <linux/vmalloc.h>
  28 #include <linux/videodev2.h>
  29
  30 #include "vivid-tpg-colors.h"
  31
  32 enum 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,
  44         TPG_PAT_CHECKERS_2X2,
  45         TPG_PAT_CHECKERS_1X1,
  46         TPG_PAT_COLOR_CHECKERS_2X2,
  47         TPG_PAT_COLOR_CHECKERS_1X1,
  48         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
  59 extern const char * const tpg_pattern_strings[];
  60
  61 enum tpg_quality {
  62         TPG_QUAL_COLOR,
  63         TPG_QUAL_GRAY,
  64         TPG_QUAL_NOISE
  65 };
  66
  67 enum 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
  75 enum tpg_pixel_aspect {
  76         TPG_PIXEL_ASPECT_SQUARE,
  77         TPG_PIXEL_ASPECT_NTSC,
  78         TPG_PIXEL_ASPECT_PAL,
  79 };
  80
  81 enum 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
  91 extern const char * const tpg_aspect_strings[];
  92
  93 #define TPG_MAX_PLANES 3
  94 #define TPG_MAX_PAT_LINES 8
  95
  96 struct 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;
 104         bool                            field_alternate;
 105         /* 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;
 125         u32                             xfer_func;
 126         u32                             ycbcr_enc;
 127         /*
 128          * Stores the actual transfer function, i.e. will never be
 129          * V4L2_XFER_FUNC_DEFAULT.
 130          */
 131         u32                             real_xfer_func;
 132         /*
 133          * Stores the actual Y'CbCr encoding, i.e. will never be
 134          * V4L2_YCBCR_ENC_DEFAULT.
 135          */
 136         u32                             real_ycbcr_enc;
 137         u32                             quantization;
 138         /*
 139          * Stores the actual quantization, i.e. will never be
 140          * V4L2_QUANTIZATION_DEFAULT.
 141          */
 142         u32                             real_quantization;
 143         enum tpg_video_aspect           vid_aspect;
 144         enum tpg_pixel_aspect           pix_aspect;
 145         unsigned                        rgb_range;
 146         unsigned                        real_rgb_range;
 147         unsigned                        buffers;
 148         unsigned                        planes;
 149         bool                            interleaved;
 150         u8                              vdownsampling[TPG_MAX_PLANES];
 151         u8                              hdownsampling[TPG_MAX_PLANES];
 152         /*
 153          * horizontal positions must be ANDed with this value to enforce
 154          * correct boundaries for packed YUYV values.
 155          */
 156         unsigned                        hmask[TPG_MAX_PLANES];
 157         /* Used to store the colors in native format, either RGB or YUV */
 158         u8                              colors[TPG_COLOR_MAX][3];
 159         u8                              textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
 160         /* size in bytes for two pixels in each plane */
 161         unsigned                        twopixelsize[TPG_MAX_PLANES];
 162         unsigned                        bytesperline[TPG_MAX_PLANES];
 163
 164         /* Configuration */
 165         enum tpg_pattern                pattern;
 166         bool                            hflip;
 167         bool                            vflip;
 168         unsigned                        perc_fill;
 169         bool                            perc_fill_blank;
 170         bool                            show_border;
 171         bool                            show_square;
 172         bool                            insert_sav;
 173         bool                            insert_eav;
 174
 175         /* Test pattern movement */
 176         enum tpg_move_mode              mv_hor_mode;
 177         int                             mv_hor_count;
 178         int                             mv_hor_step;
 179         enum tpg_move_mode              mv_vert_mode;
 180         int                             mv_vert_count;
 181         int                             mv_vert_step;
 182
 183         bool                            recalc_colors;
 184         bool                            recalc_lines;
 185         bool                            recalc_square_border;
 186
 187         /* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
 188         unsigned                        max_line_width;
 189         u8                              *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
 190         u8                              *downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
 191         u8                              *random_line[TPG_MAX_PLANES];
 192         u8                              *contrast_line[TPG_MAX_PLANES];
 193         u8                              *black_line[TPG_MAX_PLANES];
 194 };
 195
 196 void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
 197 int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
 198 void tpg_free(struct tpg_data *tpg);
 199 void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
 200                        u32 field);
 201 void tpg_log_status(struct tpg_data *tpg);
 202
 203 void tpg_set_font(const u8 *f);
 204 void tpg_gen_text(const struct tpg_data *tpg,
 205                 u8 *basep[TPG_MAX_PLANES][2], int y, int x, char *text);
 206 void tpg_calc_text_basep(struct tpg_data *tpg,
 207                 u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
 208 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
 209 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
 210                            unsigned p, u8 *vbuf);
 211 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
 212                     unsigned p, u8 *vbuf);
 213 bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
 214 void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
 215                 const struct v4l2_rect *compose);
 216
 217 static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
 218 {
 219         if (tpg->pattern == pattern)
 220                 return;
 221         tpg->pattern = pattern;
 222         tpg->recalc_colors = true;
 223 }
 224
 225 static inline void tpg_s_quality(struct tpg_data *tpg,
 226                                     enum tpg_quality qual, unsigned qual_offset)
 227 {
 228         if (tpg->qual == qual && tpg->qual_offset == qual_offset)
 229                 return;
 230         tpg->qual = qual;
 231         tpg->qual_offset = qual_offset;
 232         tpg->recalc_colors = true;
 233 }
 234
 235 static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
 236 {
 237         return tpg->qual;
 238 }
 239
 240 static inline void tpg_s_alpha_component(struct tpg_data *tpg,
 241                                             u8 alpha_component)
 242 {
 243         if (tpg->alpha_component == alpha_component)
 244                 return;
 245         tpg->alpha_component = alpha_component;
 246         tpg->recalc_colors = true;
 247 }
 248
 249 static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
 250                                             bool red_only)
 251 {
 252         if (tpg->alpha_red_only == red_only)
 253                 return;
 254         tpg->alpha_red_only = red_only;
 255         tpg->recalc_colors = true;
 256 }
 257
 258 static inline void tpg_s_brightness(struct tpg_data *tpg,
 259                                         u8 brightness)
 260 {
 261         if (tpg->brightness == brightness)
 262                 return;
 263         tpg->brightness = brightness;
 264         tpg->recalc_colors = true;
 265 }
 266
 267 static inline void tpg_s_contrast(struct tpg_data *tpg,
 268                                         u8 contrast)
 269 {
 270         if (tpg->contrast == contrast)
 271                 return;
 272         tpg->contrast = contrast;
 273         tpg->recalc_colors = true;
 274 }
 275
 276 static inline void tpg_s_saturation(struct tpg_data *tpg,
 277                                         u8 saturation)
 278 {
 279         if (tpg->saturation == saturation)
 280                 return;
 281         tpg->saturation = saturation;
 282         tpg->recalc_colors = true;
 283 }
 284
 285 static inline void tpg_s_hue(struct tpg_data *tpg,
 286                                         s16 hue)
 287 {
 288         if (tpg->hue == hue)
 289                 return;
 290         tpg->hue = hue;
 291         tpg->recalc_colors = true;
 292 }
 293
 294 static inline void tpg_s_rgb_range(struct tpg_data *tpg,
 295                                         unsigned rgb_range)
 296 {
 297         if (tpg->rgb_range == rgb_range)
 298                 return;
 299         tpg->rgb_range = rgb_range;
 300         tpg->recalc_colors = true;
 301 }
 302
 303 static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
 304                                         unsigned rgb_range)
 305 {
 306         if (tpg->real_rgb_range == rgb_range)
 307                 return;
 308         tpg->real_rgb_range = rgb_range;
 309         tpg->recalc_colors = true;
 310 }
 311
 312 static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
 313 {
 314         if (tpg->colorspace == colorspace)
 315                 return;
 316         tpg->colorspace = colorspace;
 317         tpg->recalc_colors = true;
 318 }
 319
 320 static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
 321 {
 322         return tpg->colorspace;
 323 }
 324
 325 static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
 326 {
 327         if (tpg->ycbcr_enc == ycbcr_enc)
 328                 return;
 329         tpg->ycbcr_enc = ycbcr_enc;
 330         tpg->recalc_colors = true;
 331 }
 332
 333 static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
 334 {
 335         return tpg->ycbcr_enc;
 336 }
 337
 338 static inline void tpg_s_xfer_func(struct tpg_data *tpg, u32 xfer_func)
 339 {
 340         if (tpg->xfer_func == xfer_func)
 341                 return;
 342         tpg->xfer_func = xfer_func;
 343         tpg->recalc_colors = true;
 344 }
 345
 346 static inline u32 tpg_g_xfer_func(const struct tpg_data *tpg)
 347 {
 348         return tpg->xfer_func;
 349 }
 350
 351 static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
 352 {
 353         if (tpg->quantization == quantization)
 354                 return;
 355         tpg->quantization = quantization;
 356         tpg->recalc_colors = true;
 357 }
 358
 359 static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
 360 {
 361         return tpg->quantization;
 362 }
 363
 364 static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
 365 {
 366         return tpg->buffers;
 367 }
 368
 369 static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
 370 {
 371         return tpg->interleaved ? 1 : tpg->planes;
 372 }
 373
 374 static inline bool tpg_g_interleaved(const struct tpg_data *tpg)
 375 {
 376         return tpg->interleaved;
 377 }
 378
 379 static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
 380 {
 381         return tpg->twopixelsize[plane];
 382 }
 383
 384 static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
 385                                   unsigned plane, unsigned x)
 386 {
 387         return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
 388                 tpg->twopixelsize[plane] / 2;
 389 }
 390
 391 static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
 392 {
 393         return (x * tpg->scaled_width) / tpg->src_width;
 394 }
 395
 396 static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
 397                                       unsigned plane, unsigned x)
 398 {
 399         return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
 400 }
 401
 402 static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
 403 {
 404         return tpg->bytesperline[plane];
 405 }
 406
 407 static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
 408 {
 409         unsigned p;
 410
 411         if (tpg->buffers > 1) {
 412                 tpg->bytesperline[plane] = bpl;
 413                 return;
 414         }
 415
 416         for (p = 0; p < tpg_g_planes(tpg); p++) {
 417                 unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
 418
 419                 tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
 420         }
 421         if (tpg_g_interleaved(tpg))
 422                 tpg->bytesperline[1] = tpg->bytesperline[0];
 423 }
 424
 425
 426 static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
 427 {
 428         unsigned w = 0;
 429         unsigned p;
 430
 431         if (tpg->buffers > 1)
 432                 return tpg_g_bytesperline(tpg, plane);
 433         for (p = 0; p < tpg_g_planes(tpg); p++) {
 434                 unsigned plane_w = tpg_g_bytesperline(tpg, p);
 435
 436                 w += plane_w / tpg->vdownsampling[p];
 437         }
 438         return w;
 439 }
 440
 441 static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
 442                                            unsigned plane, unsigned bpl)
 443 {
 444         unsigned w = 0;
 445         unsigned p;
 446
 447         if (tpg->buffers > 1)
 448                 return bpl;
 449         for (p = 0; p < tpg_g_planes(tpg); p++) {
 450                 unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
 451
 452                 plane_w /= tpg->hdownsampling[p];
 453                 w += plane_w / tpg->vdownsampling[p];
 454         }
 455         return w;
 456 }
 457
 458 static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
 459 {
 460         if (plane >= tpg_g_planes(tpg))
 461                 return 0;
 462
 463         return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
 464                tpg->vdownsampling[plane];
 465 }
 466
 467 static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
 468 {
 469         tpg->buf_height = h;
 470 }
 471
 472 static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
 473 {
 474         tpg->field = field;
 475         tpg->field_alternate = alternate;
 476 }
 477
 478 static inline void tpg_s_perc_fill(struct tpg_data *tpg,
 479                                       unsigned perc_fill)
 480 {
 481         tpg->perc_fill = perc_fill;
 482 }
 483
 484 static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
 485 {
 486         return tpg->perc_fill;
 487 }
 488
 489 static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
 490                                          bool perc_fill_blank)
 491 {
 492         tpg->perc_fill_blank = perc_fill_blank;
 493 }
 494
 495 static inline void tpg_s_video_aspect(struct tpg_data *tpg,
 496                                         enum tpg_video_aspect vid_aspect)
 497 {
 498         if (tpg->vid_aspect == vid_aspect)
 499                 return;
 500         tpg->vid_aspect = vid_aspect;
 501         tpg->recalc_square_border = true;
 502 }
 503
 504 static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
 505 {
 506         return tpg->vid_aspect;
 507 }
 508
 509 static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
 510                                         enum tpg_pixel_aspect pix_aspect)
 511 {
 512         if (tpg->pix_aspect == pix_aspect)
 513                 return;
 514         tpg->pix_aspect = pix_aspect;
 515         tpg->recalc_square_border = true;
 516 }
 517
 518 static inline void tpg_s_show_border(struct tpg_data *tpg,
 519                                         bool show_border)
 520 {
 521         tpg->show_border = show_border;
 522 }
 523
 524 static inline void tpg_s_show_square(struct tpg_data *tpg,
 525                                         bool show_square)
 526 {
 527         tpg->show_square = show_square;
 528 }
 529
 530 static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
 531 {
 532         tpg->insert_sav = insert_sav;
 533 }
 534
 535 static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
 536 {
 537         tpg->insert_eav = insert_eav;
 538 }
 539
 540 void tpg_update_mv_step(struct tpg_data *tpg);
 541
 542 static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
 543                                 enum tpg_move_mode mv_hor_mode)
 544 {
 545         tpg->mv_hor_mode = mv_hor_mode;
 546         tpg_update_mv_step(tpg);
 547 }
 548
 549 static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
 550                                 enum tpg_move_mode mv_vert_mode)
 551 {
 552         tpg->mv_vert_mode = mv_vert_mode;
 553         tpg_update_mv_step(tpg);
 554 }
 555
 556 static inline void tpg_init_mv_count(struct tpg_data *tpg)
 557 {
 558         tpg->mv_hor_count = tpg->mv_vert_count = 0;
 559 }
 560
 561 static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
 562 {
 563         tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
 564         tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
 565 }
 566
 567 static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
 568 {
 569         if (tpg->hflip == hflip)
 570                 return;
 571         tpg->hflip = hflip;
 572         tpg_update_mv_step(tpg);
 573         tpg->recalc_lines = true;
 574 }
 575
 576 static inline bool tpg_g_hflip(const struct tpg_data *tpg)
 577 {
 578         return tpg->hflip;
 579 }
 580
 581 static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
 582 {
 583         tpg->vflip = vflip;
 584 }
 585
 586 static inline bool tpg_g_vflip(const struct tpg_data *tpg)
 587 {
 588         return tpg->vflip;
 589 }
 590
 591 static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
 592 {
 593         return tpg->pattern != TPG_PAT_NOISE &&
 594                tpg->mv_hor_mode == TPG_MOVE_NONE &&
 595                tpg->mv_vert_mode == TPG_MOVE_NONE;
 596 }
 597
 598 #endif