drivers/media/common/v4l2-tpg/v4l2-tpg-core.c

   1 /*
   2  * v4l2-tpg-core.c - Test Pattern Generator
   3  *
   4  * Note: gen_twopix and tpg_gen_text are based on code from vivi.c. See the
   5  * vivi.c source for the copyright information of those functions.
   6  *
   7  * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   8  *
   9  * This program is free software; you may redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; version 2 of the License.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  14  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  15  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  16  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  17  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  18  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include <linux/module.h>
  24 #include <media/v4l2-tpg.h>
  25
  26 /* Must remain in sync with enum tpg_pattern */
  27 const char * const tpg_pattern_strings[] = {
  28         "75% Colorbar",
  29         "100% Colorbar",
  30         "CSC Colorbar",
  31         "Horizontal 100% Colorbar",
  32         "100% Color Squares",
  33         "100% Black",
  34         "100% White",
  35         "100% Red",
  36         "100% Green",
  37         "100% Blue",
  38         "16x16 Checkers",
  39         "2x2 Checkers",
  40         "1x1 Checkers",
  41         "2x2 Red/Green Checkers",
  42         "1x1 Red/Green Checkers",
  43         "Alternating Hor Lines",
  44         "Alternating Vert Lines",
  45         "One Pixel Wide Cross",
  46         "Two Pixels Wide Cross",
  47         "Ten Pixels Wide Cross",
  48         "Gray Ramp",
  49         "Noise",
  50         NULL
  51 };
  52 EXPORT_SYMBOL_GPL(tpg_pattern_strings);
  53
  54 /* Must remain in sync with enum tpg_aspect */
  55 const char * const tpg_aspect_strings[] = {
  56         "Source Width x Height",
  57         "4x3",
  58         "14x9",
  59         "16x9",
  60         "16x9 Anamorphic",
  61         NULL
  62 };
  63 EXPORT_SYMBOL_GPL(tpg_aspect_strings);
  64
  65 /*
  66  * Sine table: sin[0] = 127 * sin(-180 degrees)
  67  *             sin[128] = 127 * sin(0 degrees)
  68  *             sin[256] = 127 * sin(180 degrees)
  69  */
  70 static const s8 sin[257] = {
  71            0,   -4,   -7,  -11,  -13,  -18,  -20,  -22,  -26,  -29,  -33,  -35,  -37,  -41,  -43,  -48,
  72          -50,  -52,  -56,  -58,  -62,  -63,  -65,  -69,  -71,  -75,  -76,  -78,  -82,  -83,  -87,  -88,
  73          -90,  -93,  -94,  -97,  -99, -101, -103, -104, -107, -108, -110, -111, -112, -114, -115, -117,
  74         -118, -119, -120, -121, -122, -123, -123, -124, -125, -125, -126, -126, -127, -127, -127, -127,
  75         -127, -127, -127, -127, -126, -126, -125, -125, -124, -124, -123, -122, -121, -120, -119, -118,
  76         -117, -116, -114, -113, -111, -110, -109, -107, -105, -103, -101, -100,  -97,  -96,  -93,  -91,
  77          -90,  -87,  -85,  -82,  -80,  -76,  -75,  -73,  -69,  -67,  -63,  -62,  -60,  -56,  -54,  -50,
  78          -48,  -46,  -41,  -39,  -35,  -33,  -31,  -26,  -24,  -20,  -18,  -15,  -11,   -9,   -4,   -2,
  79            0,    2,    4,    9,   11,   15,   18,   20,   24,   26,   31,   33,   35,   39,   41,   46,
  80           48,   50,   54,   56,   60,   62,   64,   67,   69,   73,   75,   76,   80,   82,   85,   87,
  81           90,   91,   93,   96,   97,  100,  101,  103,  105,  107,  109,  110,  111,  113,  114,  116,
  82          117,  118,  119,  120,  121,  122,  123,  124,  124,  125,  125,  126,  126,  127,  127,  127,
  83          127,  127,  127,  127,  127,  126,  126,  125,  125,  124,  123,  123,  122,  121,  120,  119,
  84          118,  117,  115,  114,  112,  111,  110,  108,  107,  104,  103,  101,   99,   97,   94,   93,
  85           90,   88,   87,   83,   82,   78,   76,   75,   71,   69,   65,   64,   62,   58,   56,   52,
  86           50,   48,   43,   41,   37,   35,   33,   29,   26,   22,   20,   18,   13,   11,    7,    4,
  87            0,
  88 };
  89
  90 #define cos(idx) sin[((idx) + 64) % sizeof(sin)]
  91
  92 /* Global font descriptor */
  93 static const u8 *font8x16;
  94
  95 void tpg_set_font(const u8 *f)
  96 {
  97         font8x16 = f;
  98 }
  99 EXPORT_SYMBOL_GPL(tpg_set_font);
 100
 101 void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h)
 102 {
 103         memset(tpg, 0, sizeof(*tpg));
 104         tpg->scaled_width = tpg->src_width = w;
 105         tpg->src_height = tpg->buf_height = h;
 106         tpg->crop.width = tpg->compose.width = w;
 107         tpg->crop.height = tpg->compose.height = h;
 108         tpg->recalc_colors = true;
 109         tpg->recalc_square_border = true;
 110         tpg->brightness = 128;
 111         tpg->contrast = 128;
 112         tpg->saturation = 128;
 113         tpg->hue = 0;
 114         tpg->mv_hor_mode = TPG_MOVE_NONE;
 115         tpg->mv_vert_mode = TPG_MOVE_NONE;
 116         tpg->field = V4L2_FIELD_NONE;
 117         tpg_s_fourcc(tpg, V4L2_PIX_FMT_RGB24);
 118         tpg->colorspace = V4L2_COLORSPACE_SRGB;
 119         tpg->perc_fill = 100;
 120 }
 121 EXPORT_SYMBOL_GPL(tpg_init);
 122
 123 int tpg_alloc(struct tpg_data *tpg, unsigned max_w)
 124 {
 125         unsigned pat;
 126         unsigned plane;
 127
 128         tpg->max_line_width = max_w;
 129         for (pat = 0; pat < TPG_MAX_PAT_LINES; pat++) {
 130                 for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
 131                         unsigned pixelsz = plane ? 2 : 4;
 132
 133                         tpg->lines[pat][plane] = vzalloc(max_w * 2 * pixelsz);
 134                         if (!tpg->lines[pat][plane])
 135                                 return -ENOMEM;
 136                         if (plane == 0)
 137                                 continue;
 138                         tpg->downsampled_lines[pat][plane] = vzalloc(max_w * 2 * pixelsz);
 139                         if (!tpg->downsampled_lines[pat][plane])
 140                                 return -ENOMEM;
 141                 }
 142         }
 143         for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
 144                 unsigned pixelsz = plane ? 2 : 4;
 145
 146                 tpg->contrast_line[plane] = vzalloc(max_w * pixelsz);
 147                 if (!tpg->contrast_line[plane])
 148                         return -ENOMEM;
 149                 tpg->black_line[plane] = vzalloc(max_w * pixelsz);
 150                 if (!tpg->black_line[plane])
 151                         return -ENOMEM;
 152                 tpg->random_line[plane] = vzalloc(max_w * 2 * pixelsz);
 153                 if (!tpg->random_line[plane])
 154                         return -ENOMEM;
 155         }
 156         return 0;
 157 }
 158 EXPORT_SYMBOL_GPL(tpg_alloc);
 159
 160 void tpg_free(struct tpg_data *tpg)
 161 {
 162         unsigned pat;
 163         unsigned plane;
 164
 165         for (pat = 0; pat < TPG_MAX_PAT_LINES; pat++)
 166                 for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
 167                         vfree(tpg->lines[pat][plane]);
 168                         tpg->lines[pat][plane] = NULL;
 169                         if (plane == 0)
 170                                 continue;
 171                         vfree(tpg->downsampled_lines[pat][plane]);
 172                         tpg->downsampled_lines[pat][plane] = NULL;
 173                 }
 174         for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
 175                 vfree(tpg->contrast_line[plane]);
 176                 vfree(tpg->black_line[plane]);
 177                 vfree(tpg->random_line[plane]);
 178                 tpg->contrast_line[plane] = NULL;
 179                 tpg->black_line[plane] = NULL;
 180                 tpg->random_line[plane] = NULL;
 181         }
 182 }
 183 EXPORT_SYMBOL_GPL(tpg_free);
 184
 185 bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc)
 186 {
 187         tpg->fourcc = fourcc;
 188         tpg->planes = 1;
 189         tpg->buffers = 1;
 190         tpg->recalc_colors = true;
 191         tpg->interleaved = false;
 192         tpg->vdownsampling[0] = 1;
 193         tpg->hdownsampling[0] = 1;
 194         tpg->hmask[0] = ~0;
 195         tpg->hmask[1] = ~0;
 196         tpg->hmask[2] = ~0;
 197
 198         switch (fourcc) {
 199         case V4L2_PIX_FMT_SBGGR8:
 200         case V4L2_PIX_FMT_SGBRG8:
 201         case V4L2_PIX_FMT_SGRBG8:
 202         case V4L2_PIX_FMT_SRGGB8:
 203         case V4L2_PIX_FMT_SBGGR10:
 204         case V4L2_PIX_FMT_SGBRG10:
 205         case V4L2_PIX_FMT_SGRBG10:
 206         case V4L2_PIX_FMT_SRGGB10:
 207         case V4L2_PIX_FMT_SBGGR12:
 208         case V4L2_PIX_FMT_SGBRG12:
 209         case V4L2_PIX_FMT_SGRBG12:
 210         case V4L2_PIX_FMT_SRGGB12:
 211                 tpg->interleaved = true;
 212                 tpg->vdownsampling[1] = 1;
 213                 tpg->hdownsampling[1] = 1;
 214                 tpg->planes = 2;
 215                 /* fall through */
 216         case V4L2_PIX_FMT_RGB332:
 217         case V4L2_PIX_FMT_RGB565:
 218         case V4L2_PIX_FMT_RGB565X:
 219         case V4L2_PIX_FMT_RGB444:
 220         case V4L2_PIX_FMT_XRGB444:
 221         case V4L2_PIX_FMT_ARGB444:
 222         case V4L2_PIX_FMT_RGB555:
 223         case V4L2_PIX_FMT_XRGB555:
 224         case V4L2_PIX_FMT_ARGB555:
 225         case V4L2_PIX_FMT_RGB555X:
 226         case V4L2_PIX_FMT_XRGB555X:
 227         case V4L2_PIX_FMT_ARGB555X:
 228         case V4L2_PIX_FMT_BGR666:
 229         case V4L2_PIX_FMT_RGB24:
 230         case V4L2_PIX_FMT_BGR24:
 231         case V4L2_PIX_FMT_RGB32:
 232         case V4L2_PIX_FMT_BGR32:
 233         case V4L2_PIX_FMT_XRGB32:
 234         case V4L2_PIX_FMT_XBGR32:
 235         case V4L2_PIX_FMT_ARGB32:
 236         case V4L2_PIX_FMT_ABGR32:
 237         case V4L2_PIX_FMT_GREY:
 238         case V4L2_PIX_FMT_Y16:
 239         case V4L2_PIX_FMT_Y16_BE:
 240                 tpg->is_yuv = false;
 241                 break;
 242         case V4L2_PIX_FMT_YUV444:
 243         case V4L2_PIX_FMT_YUV555:
 244         case V4L2_PIX_FMT_YUV565:
 245         case V4L2_PIX_FMT_YUV32:
 246                 tpg->is_yuv = true;
 247                 break;
 248         case V4L2_PIX_FMT_YUV420M:
 249         case V4L2_PIX_FMT_YVU420M:
 250                 tpg->buffers = 3;
 251                 /* fall through */
 252         case V4L2_PIX_FMT_YUV420:
 253         case V4L2_PIX_FMT_YVU420:
 254                 tpg->vdownsampling[1] = 2;
 255                 tpg->vdownsampling[2] = 2;
 256                 tpg->hdownsampling[1] = 2;
 257                 tpg->hdownsampling[2] = 2;
 258                 tpg->planes = 3;
 259                 tpg->is_yuv = true;
 260                 break;
 261         case V4L2_PIX_FMT_YUV422M:
 262         case V4L2_PIX_FMT_YVU422M:
 263                 tpg->buffers = 3;
 264                 /* fall through */
 265         case V4L2_PIX_FMT_YUV422P:
 266                 tpg->vdownsampling[1] = 1;
 267                 tpg->vdownsampling[2] = 1;
 268                 tpg->hdownsampling[1] = 2;
 269                 tpg->hdownsampling[2] = 2;
 270                 tpg->planes = 3;
 271                 tpg->is_yuv = true;
 272                 break;
 273         case V4L2_PIX_FMT_NV16M:
 274         case V4L2_PIX_FMT_NV61M:
 275                 tpg->buffers = 2;
 276                 /* fall through */
 277         case V4L2_PIX_FMT_NV16:
 278         case V4L2_PIX_FMT_NV61:
 279                 tpg->vdownsampling[1] = 1;
 280                 tpg->hdownsampling[1] = 1;
 281                 tpg->hmask[1] = ~1;
 282                 tpg->planes = 2;
 283                 tpg->is_yuv = true;
 284                 break;
 285         case V4L2_PIX_FMT_NV12M:
 286         case V4L2_PIX_FMT_NV21M:
 287                 tpg->buffers = 2;
 288                 /* fall through */
 289         case V4L2_PIX_FMT_NV12:
 290         case V4L2_PIX_FMT_NV21:
 291                 tpg->vdownsampling[1] = 2;
 292                 tpg->hdownsampling[1] = 1;
 293                 tpg->hmask[1] = ~1;
 294                 tpg->planes = 2;
 295                 tpg->is_yuv = true;
 296                 break;
 297         case V4L2_PIX_FMT_YUV444M:
 298         case V4L2_PIX_FMT_YVU444M:
 299                 tpg->buffers = 3;
 300                 tpg->planes = 3;
 301                 tpg->vdownsampling[1] = 1;
 302                 tpg->vdownsampling[2] = 1;
 303                 tpg->hdownsampling[1] = 1;
 304                 tpg->hdownsampling[2] = 1;
 305                 tpg->is_yuv = true;
 306                 break;
 307         case V4L2_PIX_FMT_NV24:
 308         case V4L2_PIX_FMT_NV42:
 309                 tpg->vdownsampling[1] = 1;
 310                 tpg->hdownsampling[1] = 1;
 311                 tpg->planes = 2;
 312                 tpg->is_yuv = true;
 313                 break;
 314         case V4L2_PIX_FMT_YUYV:
 315         case V4L2_PIX_FMT_UYVY:
 316         case V4L2_PIX_FMT_YVYU:
 317         case V4L2_PIX_FMT_VYUY:
 318                 tpg->hmask[0] = ~1;
 319                 tpg->is_yuv = true;
 320                 break;
 321         default:
 322                 return false;
 323         }
 324
 325         switch (fourcc) {
 326         case V4L2_PIX_FMT_GREY:
 327         case V4L2_PIX_FMT_RGB332:
 328                 tpg->twopixelsize[0] = 2;
 329                 break;
 330         case V4L2_PIX_FMT_RGB565:
 331         case V4L2_PIX_FMT_RGB565X:
 332         case V4L2_PIX_FMT_RGB444:
 333         case V4L2_PIX_FMT_XRGB444:
 334         case V4L2_PIX_FMT_ARGB444:
 335         case V4L2_PIX_FMT_RGB555:
 336         case V4L2_PIX_FMT_XRGB555:
 337         case V4L2_PIX_FMT_ARGB555:
 338         case V4L2_PIX_FMT_RGB555X:
 339         case V4L2_PIX_FMT_XRGB555X:
 340         case V4L2_PIX_FMT_ARGB555X:
 341         case V4L2_PIX_FMT_YUYV:
 342         case V4L2_PIX_FMT_UYVY:
 343         case V4L2_PIX_FMT_YVYU:
 344         case V4L2_PIX_FMT_VYUY:
 345         case V4L2_PIX_FMT_YUV444:
 346         case V4L2_PIX_FMT_YUV555:
 347         case V4L2_PIX_FMT_YUV565:
 348         case V4L2_PIX_FMT_Y16:
 349         case V4L2_PIX_FMT_Y16_BE:
 350                 tpg->twopixelsize[0] = 2 * 2;
 351                 break;
 352         case V4L2_PIX_FMT_RGB24:
 353         case V4L2_PIX_FMT_BGR24:
 354                 tpg->twopixelsize[0] = 2 * 3;
 355                 break;
 356         case V4L2_PIX_FMT_BGR666:
 357         case V4L2_PIX_FMT_RGB32:
 358         case V4L2_PIX_FMT_BGR32:
 359         case V4L2_PIX_FMT_XRGB32:
 360         case V4L2_PIX_FMT_XBGR32:
 361         case V4L2_PIX_FMT_ARGB32:
 362         case V4L2_PIX_FMT_ABGR32:
 363         case V4L2_PIX_FMT_YUV32:
 364                 tpg->twopixelsize[0] = 2 * 4;
 365                 break;
 366         case V4L2_PIX_FMT_NV12:
 367         case V4L2_PIX_FMT_NV21:
 368         case V4L2_PIX_FMT_NV12M:
 369         case V4L2_PIX_FMT_NV21M:
 370         case V4L2_PIX_FMT_NV16:
 371         case V4L2_PIX_FMT_NV61:
 372         case V4L2_PIX_FMT_NV16M:
 373         case V4L2_PIX_FMT_NV61M:
 374         case V4L2_PIX_FMT_SBGGR8:
 375         case V4L2_PIX_FMT_SGBRG8:
 376         case V4L2_PIX_FMT_SGRBG8:
 377         case V4L2_PIX_FMT_SRGGB8:
 378                 tpg->twopixelsize[0] = 2;
 379                 tpg->twopixelsize[1] = 2;
 380                 break;
 381         case V4L2_PIX_FMT_SRGGB10:
 382         case V4L2_PIX_FMT_SGRBG10:
 383         case V4L2_PIX_FMT_SGBRG10:
 384         case V4L2_PIX_FMT_SBGGR10:
 385         case V4L2_PIX_FMT_SRGGB12:
 386         case V4L2_PIX_FMT_SGRBG12:
 387         case V4L2_PIX_FMT_SGBRG12:
 388         case V4L2_PIX_FMT_SBGGR12:
 389                 tpg->twopixelsize[0] = 4;
 390                 tpg->twopixelsize[1] = 4;
 391                 break;
 392         case V4L2_PIX_FMT_YUV444M:
 393         case V4L2_PIX_FMT_YVU444M:
 394         case V4L2_PIX_FMT_YUV422M:
 395         case V4L2_PIX_FMT_YVU422M:
 396         case V4L2_PIX_FMT_YUV422P:
 397         case V4L2_PIX_FMT_YUV420:
 398         case V4L2_PIX_FMT_YVU420:
 399         case V4L2_PIX_FMT_YUV420M:
 400         case V4L2_PIX_FMT_YVU420M:
 401                 tpg->twopixelsize[0] = 2;
 402                 tpg->twopixelsize[1] = 2;
 403                 tpg->twopixelsize[2] = 2;
 404                 break;
 405         case V4L2_PIX_FMT_NV24:
 406         case V4L2_PIX_FMT_NV42:
 407                 tpg->twopixelsize[0] = 2;
 408                 tpg->twopixelsize[1] = 4;
 409                 break;
 410         }
 411         return true;
 412 }
 413 EXPORT_SYMBOL_GPL(tpg_s_fourcc);
 414
 415 void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
 416                 const struct v4l2_rect *compose)
 417 {
 418         tpg->crop = *crop;
 419         tpg->compose = *compose;
 420         tpg->scaled_width = (tpg->src_width * tpg->compose.width +
 421                                  tpg->crop.width - 1) / tpg->crop.width;
 422         tpg->scaled_width &= ~1;
 423         if (tpg->scaled_width > tpg->max_line_width)
 424                 tpg->scaled_width = tpg->max_line_width;
 425         if (tpg->scaled_width < 2)
 426                 tpg->scaled_width = 2;
 427         tpg->recalc_lines = true;
 428 }
 429 EXPORT_SYMBOL_GPL(tpg_s_crop_compose);
 430
 431 void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
 432                        u32 field)
 433 {
 434         unsigned p;
 435
 436         tpg->src_width = width;
 437         tpg->src_height = height;
 438         tpg->field = field;
 439         tpg->buf_height = height;
 440         if (V4L2_FIELD_HAS_T_OR_B(field))
 441                 tpg->buf_height /= 2;
 442         tpg->scaled_width = width;
 443         tpg->crop.top = tpg->crop.left = 0;
 444         tpg->crop.width = width;
 445         tpg->crop.height = height;
 446         tpg->compose.top = tpg->compose.left = 0;
 447         tpg->compose.width = width;
 448         tpg->compose.height = tpg->buf_height;
 449         for (p = 0; p < tpg->planes; p++)
 450                 tpg->bytesperline[p] = (width * tpg->twopixelsize[p]) /
 451                                        (2 * tpg->hdownsampling[p]);
 452         tpg->recalc_square_border = true;
 453 }
 454 EXPORT_SYMBOL_GPL(tpg_reset_source);
 455
 456 static enum tpg_color tpg_get_textbg_color(struct tpg_data *tpg)
 457 {
 458         switch (tpg->pattern) {
 459         case TPG_PAT_BLACK:
 460                 return TPG_COLOR_100_WHITE;
 461         case TPG_PAT_CSC_COLORBAR:
 462                 return TPG_COLOR_CSC_BLACK;
 463         default:
 464                 return TPG_COLOR_100_BLACK;
 465         }
 466 }
 467
 468 static enum tpg_color tpg_get_textfg_color(struct tpg_data *tpg)
 469 {
 470         switch (tpg->pattern) {
 471         case TPG_PAT_75_COLORBAR:
 472         case TPG_PAT_CSC_COLORBAR:
 473                 return TPG_COLOR_CSC_WHITE;
 474         case TPG_PAT_BLACK:
 475                 return TPG_COLOR_100_BLACK;
 476         default:
 477                 return TPG_COLOR_100_WHITE;
 478         }
 479 }
 480
 481 static inline int rec709_to_linear(int v)
 482 {
 483         v = clamp(v, 0, 0xff0);
 484         return tpg_rec709_to_linear[v];
 485 }
 486
 487 static inline int linear_to_rec709(int v)
 488 {
 489         v = clamp(v, 0, 0xff0);
 490         return tpg_linear_to_rec709[v];
 491 }
 492
 493 static void rgb2ycbcr(const int m[3][3], int r, int g, int b,
 494                         int y_offset, int *y, int *cb, int *cr)
 495 {
 496         *y  = ((m[0][0] * r + m[0][1] * g + m[0][2] * b) >> 16) + (y_offset << 4);
 497         *cb = ((m[1][0] * r + m[1][1] * g + m[1][2] * b) >> 16) + (128 << 4);
 498         *cr = ((m[2][0] * r + m[2][1] * g + m[2][2] * b) >> 16) + (128 << 4);
 499 }
 500
 501 static void color_to_ycbcr(struct tpg_data *tpg, int r, int g, int b,
 502                            int *y, int *cb, int *cr)
 503 {
 504 #define COEFF(v, r) ((int)(0.5 + (v) * (r) * 256.0))
 505
 506         static const int bt601[3][3] = {
 507                 { COEFF(0.299, 219),   COEFF(0.587, 219),   COEFF(0.114, 219)   },
 508                 { COEFF(-0.1687, 224), COEFF(-0.3313, 224), COEFF(0.5, 224)     },
 509                 { COEFF(0.5, 224),     COEFF(-0.4187, 224), COEFF(-0.0813, 224) },
 510         };
 511         static const int bt601_full[3][3] = {
 512                 { COEFF(0.299, 255),   COEFF(0.587, 255),   COEFF(0.114, 255)   },
 513                 { COEFF(-0.1687, 255), COEFF(-0.3313, 255), COEFF(0.5, 255)     },
 514                 { COEFF(0.5, 255),     COEFF(-0.4187, 255), COEFF(-0.0813, 255) },
 515         };
 516         static const int rec709[3][3] = {
 517                 { COEFF(0.2126, 219),  COEFF(0.7152, 219),  COEFF(0.0722, 219)  },
 518                 { COEFF(-0.1146, 224), COEFF(-0.3854, 224), COEFF(0.5, 224)     },
 519                 { COEFF(0.5, 224),     COEFF(-0.4542, 224), COEFF(-0.0458, 224) },
 520         };
 521         static const int rec709_full[3][3] = {
 522                 { COEFF(0.2126, 255),  COEFF(0.7152, 255),  COEFF(0.0722, 255)  },
 523                 { COEFF(-0.1146, 255), COEFF(-0.3854, 255), COEFF(0.5, 255)     },
 524                 { COEFF(0.5, 255),     COEFF(-0.4542, 255), COEFF(-0.0458, 255) },
 525         };
 526         static const int smpte240m[3][3] = {
 527                 { COEFF(0.212, 219),  COEFF(0.701, 219),  COEFF(0.087, 219)  },
 528                 { COEFF(-0.116, 224), COEFF(-0.384, 224), COEFF(0.5, 224)    },
 529                 { COEFF(0.5, 224),    COEFF(-0.445, 224), COEFF(-0.055, 224) },
 530         };
 531         static const int smpte240m_full[3][3] = {
 532                 { COEFF(0.212, 255),  COEFF(0.701, 255),  COEFF(0.087, 255)  },
 533                 { COEFF(-0.116, 255), COEFF(-0.384, 255), COEFF(0.5, 255)    },
 534                 { COEFF(0.5, 255),    COEFF(-0.445, 255), COEFF(-0.055, 255) },
 535         };
 536         static const int bt2020[3][3] = {
 537                 { COEFF(0.2627, 219),  COEFF(0.6780, 219),  COEFF(0.0593, 219)  },
 538                 { COEFF(-0.1396, 224), COEFF(-0.3604, 224), COEFF(0.5, 224)     },
 539                 { COEFF(0.5, 224),     COEFF(-0.4598, 224), COEFF(-0.0402, 224) },
 540         };
 541         static const int bt2020_full[3][3] = {
 542                 { COEFF(0.2627, 255),  COEFF(0.6780, 255),  COEFF(0.0593, 255)  },
 543                 { COEFF(-0.1396, 255), COEFF(-0.3604, 255), COEFF(0.5, 255)     },
 544                 { COEFF(0.5, 255),     COEFF(-0.4698, 255), COEFF(-0.0402, 255) },
 545         };
 546         static const int bt2020c[4] = {
 547                 COEFF(1.0 / 1.9404, 224), COEFF(1.0 / 1.5816, 224),
 548                 COEFF(1.0 / 1.7184, 224), COEFF(1.0 / 0.9936, 224),
 549         };
 550         static const int bt2020c_full[4] = {
 551                 COEFF(1.0 / 1.9404, 255), COEFF(1.0 / 1.5816, 255),
 552                 COEFF(1.0 / 1.7184, 255), COEFF(1.0 / 0.9936, 255),
 553         };
 554
 555         bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
 556         unsigned y_offset = full ? 0 : 16;
 557         int lin_y, yc;
 558
 559         switch (tpg->real_ycbcr_enc) {
 560         case V4L2_YCBCR_ENC_601:
 561                 rgb2ycbcr(full ? bt601_full : bt601, r, g, b, y_offset, y, cb, cr);
 562                 break;
 563         case V4L2_YCBCR_ENC_XV601:
 564                 /* Ignore quantization range, there is only one possible
 565                  * Y'CbCr encoding. */
 566                 rgb2ycbcr(bt601, r, g, b, 16, y, cb, cr);
 567                 break;
 568         case V4L2_YCBCR_ENC_XV709:
 569                 /* Ignore quantization range, there is only one possible
 570                  * Y'CbCr encoding. */
 571                 rgb2ycbcr(rec709, r, g, b, 16, y, cb, cr);
 572                 break;
 573         case V4L2_YCBCR_ENC_BT2020:
 574                 rgb2ycbcr(full ? bt2020_full : bt2020, r, g, b, y_offset, y, cb, cr);
 575                 break;
 576         case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
 577                 lin_y = (COEFF(0.2627, 255) * rec709_to_linear(r) +
 578                          COEFF(0.6780, 255) * rec709_to_linear(g) +
 579                          COEFF(0.0593, 255) * rec709_to_linear(b)) >> 16;
 580                 yc = linear_to_rec709(lin_y);
 581                 *y = full ? yc : (yc * 219) / 255 + (16 << 4);
 582                 if (b <= yc)
 583                         *cb = (((b - yc) * (full ? bt2020c_full[0] : bt2020c[0])) >> 16) + (128 << 4);
 584                 else
 585                         *cb = (((b - yc) * (full ? bt2020c_full[1] : bt2020c[1])) >> 16) + (128 << 4);
 586                 if (r <= yc)
 587                         *cr = (((r - yc) * (full ? bt2020c_full[2] : bt2020c[2])) >> 16) + (128 << 4);
 588                 else
 589                         *cr = (((r - yc) * (full ? bt2020c_full[3] : bt2020c[3])) >> 16) + (128 << 4);
 590                 break;
 591         case V4L2_YCBCR_ENC_SMPTE240M:
 592                 rgb2ycbcr(full ? smpte240m_full : smpte240m, r, g, b, y_offset, y, cb, cr);
 593                 break;
 594         case V4L2_YCBCR_ENC_709:
 595         default:
 596                 rgb2ycbcr(full ? rec709_full : rec709, r, g, b, y_offset, y, cb, cr);
 597                 break;
 598         }
 599 }
 600
 601 static void ycbcr2rgb(const int m[3][3], int y, int cb, int cr,
 602                         int y_offset, int *r, int *g, int *b)
 603 {
 604         y -= y_offset << 4;
 605         cb -= 128 << 4;
 606         cr -= 128 << 4;
 607         *r = m[0][0] * y + m[0][1] * cb + m[0][2] * cr;
 608         *g = m[1][0] * y + m[1][1] * cb + m[1][2] * cr;
 609         *b = m[2][0] * y + m[2][1] * cb + m[2][2] * cr;
 610         *r = clamp(*r >> 12, 0, 0xff0);
 611         *g = clamp(*g >> 12, 0, 0xff0);
 612         *b = clamp(*b >> 12, 0, 0xff0);
 613 }
 614
 615 static void ycbcr_to_color(struct tpg_data *tpg, int y, int cb, int cr,
 616                            int *r, int *g, int *b)
 617 {
 618 #undef COEFF
 619 #define COEFF(v, r) ((int)(0.5 + (v) * ((255.0 * 255.0 * 16.0) / (r))))
 620         static const int bt601[3][3] = {
 621                 { COEFF(1, 219), COEFF(0, 224),       COEFF(1.4020, 224)  },
 622                 { COEFF(1, 219), COEFF(-0.3441, 224), COEFF(-0.7141, 224) },
 623                 { COEFF(1, 219), COEFF(1.7720, 224),  COEFF(0, 224)       },
 624         };
 625         static const int bt601_full[3][3] = {
 626                 { COEFF(1, 255), COEFF(0, 255),       COEFF(1.4020, 255)  },
 627                 { COEFF(1, 255), COEFF(-0.3441, 255), COEFF(-0.7141, 255) },
 628                 { COEFF(1, 255), COEFF(1.7720, 255),  COEFF(0, 255)       },
 629         };
 630         static const int rec709[3][3] = {
 631                 { COEFF(1, 219), COEFF(0, 224),       COEFF(1.5748, 224)  },
 632                 { COEFF(1, 219), COEFF(-0.1873, 224), COEFF(-0.4681, 224) },
 633                 { COEFF(1, 219), COEFF(1.8556, 224),  COEFF(0, 224)       },
 634         };
 635         static const int rec709_full[3][3] = {
 636                 { COEFF(1, 255), COEFF(0, 255),       COEFF(1.5748, 255)  },
 637                 { COEFF(1, 255), COEFF(-0.1873, 255), COEFF(-0.4681, 255) },
 638                 { COEFF(1, 255), COEFF(1.8556, 255),  COEFF(0, 255)       },
 639         };
 640         static const int smpte240m[3][3] = {
 641                 { COEFF(1, 219), COEFF(0, 224),       COEFF(1.5756, 224)  },
 642                 { COEFF(1, 219), COEFF(-0.2253, 224), COEFF(-0.4767, 224) },
 643                 { COEFF(1, 219), COEFF(1.8270, 224),  COEFF(0, 224)       },
 644         };
 645         static const int smpte240m_full[3][3] = {
 646                 { COEFF(1, 255), COEFF(0, 255),       COEFF(1.5756, 255)  },
 647                 { COEFF(1, 255), COEFF(-0.2253, 255), COEFF(-0.4767, 255) },
 648                 { COEFF(1, 255), COEFF(1.8270, 255),  COEFF(0, 255)       },
 649         };
 650         static const int bt2020[3][3] = {
 651                 { COEFF(1, 219), COEFF(0, 224),       COEFF(1.4746, 224)  },
 652                 { COEFF(1, 219), COEFF(-0.1646, 224), COEFF(-0.5714, 224) },
 653                 { COEFF(1, 219), COEFF(1.8814, 224),  COEFF(0, 224)       },
 654         };
 655         static const int bt2020_full[3][3] = {
 656                 { COEFF(1, 255), COEFF(0, 255),       COEFF(1.4746, 255)  },
 657                 { COEFF(1, 255), COEFF(-0.1646, 255), COEFF(-0.5714, 255) },
 658                 { COEFF(1, 255), COEFF(1.8814, 255),  COEFF(0, 255)       },
 659         };
 660         static const int bt2020c[4] = {
 661                 COEFF(1.9404, 224), COEFF(1.5816, 224),
 662                 COEFF(1.7184, 224), COEFF(0.9936, 224),
 663         };
 664         static const int bt2020c_full[4] = {
 665                 COEFF(1.9404, 255), COEFF(1.5816, 255),
 666                 COEFF(1.7184, 255), COEFF(0.9936, 255),
 667         };
 668
 669         bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
 670         unsigned y_offset = full ? 0 : 16;
 671         int y_fac = full ? COEFF(1.0, 255) : COEFF(1.0, 219);
 672         int lin_r, lin_g, lin_b, lin_y;
 673
 674         switch (tpg->real_ycbcr_enc) {
 675         case V4L2_YCBCR_ENC_601:
 676                 ycbcr2rgb(full ? bt601_full : bt601, y, cb, cr, y_offset, r, g, b);
 677                 break;
 678         case V4L2_YCBCR_ENC_XV601:
 679                 /* Ignore quantization range, there is only one possible
 680                  * Y'CbCr encoding. */
 681                 ycbcr2rgb(bt601, y, cb, cr, 16, r, g, b);
 682                 break;
 683         case V4L2_YCBCR_ENC_XV709:
 684                 /* Ignore quantization range, there is only one possible
 685                  * Y'CbCr encoding. */
 686                 ycbcr2rgb(rec709, y, cb, cr, 16, r, g, b);
 687                 break;
 688         case V4L2_YCBCR_ENC_BT2020:
 689                 ycbcr2rgb(full ? bt2020_full : bt2020, y, cb, cr, y_offset, r, g, b);
 690                 break;
 691         case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
 692                 y -= full ? 0 : 16 << 4;
 693                 cb -= 128 << 4;
 694                 cr -= 128 << 4;
 695
 696                 if (cb <= 0)
 697                         *b = y_fac * y + (full ? bt2020c_full[0] : bt2020c[0]) * cb;
 698                 else
 699                         *b = y_fac * y + (full ? bt2020c_full[1] : bt2020c[1]) * cb;
 700                 *b = *b >> 12;
 701                 if (cr <= 0)
 702                         *r = y_fac * y + (full ? bt2020c_full[2] : bt2020c[2]) * cr;
 703                 else
 704                         *r = y_fac * y + (full ? bt2020c_full[3] : bt2020c[3]) * cr;
 705                 *r = *r >> 12;
 706                 lin_r = rec709_to_linear(*r);
 707                 lin_b = rec709_to_linear(*b);
 708                 lin_y = rec709_to_linear((y * 255) / (full ? 255 : 219));
 709
 710                 lin_g = COEFF(1.0 / 0.6780, 255) * lin_y -
 711                         COEFF(0.2627 / 0.6780, 255) * lin_r -
 712                         COEFF(0.0593 / 0.6780, 255) * lin_b;
 713                 *g = linear_to_rec709(lin_g >> 12);
 714                 break;
 715         case V4L2_YCBCR_ENC_SMPTE240M:
 716                 ycbcr2rgb(full ? smpte240m_full : smpte240m, y, cb, cr, y_offset, r, g, b);
 717                 break;
 718         case V4L2_YCBCR_ENC_709:
 719         default:
 720                 ycbcr2rgb(full ? rec709_full : rec709, y, cb, cr, y_offset, r, g, b);
 721                 break;
 722         }
 723 }
 724
 725 /* precalculate color bar values to speed up rendering */
 726 static void precalculate_color(struct tpg_data *tpg, int k)
 727 {
 728         int col = k;
 729         int r = tpg_colors[col].r;
 730         int g = tpg_colors[col].g;
 731         int b = tpg_colors[col].b;
 732
 733         if (k == TPG_COLOR_TEXTBG) {
 734                 col = tpg_get_textbg_color(tpg);
 735
 736                 r = tpg_colors[col].r;
 737                 g = tpg_colors[col].g;
 738                 b = tpg_colors[col].b;
 739         } else if (k == TPG_COLOR_TEXTFG) {
 740                 col = tpg_get_textfg_color(tpg);
 741
 742                 r = tpg_colors[col].r;
 743                 g = tpg_colors[col].g;
 744                 b = tpg_colors[col].b;
 745         } else if (tpg->pattern == TPG_PAT_NOISE) {
 746                 r = g = b = prandom_u32_max(256);
 747         } else if (k == TPG_COLOR_RANDOM) {
 748                 r = g = b = tpg->qual_offset + prandom_u32_max(196);
 749         } else if (k >= TPG_COLOR_RAMP) {
 750                 r = g = b = k - TPG_COLOR_RAMP;
 751         }
 752
 753         if (tpg->pattern == TPG_PAT_CSC_COLORBAR && col <= TPG_COLOR_CSC_BLACK) {
 754                 r = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].r;
 755                 g = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].g;
 756                 b = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].b;
 757         } else {
 758                 r <<= 4;
 759                 g <<= 4;
 760                 b <<= 4;
 761         }
 762         if (tpg->qual == TPG_QUAL_GRAY || tpg->fourcc == V4L2_PIX_FMT_GREY ||
 763             tpg->fourcc == V4L2_PIX_FMT_Y16 ||
 764             tpg->fourcc == V4L2_PIX_FMT_Y16_BE) {
 765                 /* Rec. 709 Luma function */
 766                 /* (0.2126, 0.7152, 0.0722) * (255 * 256) */
 767                 r = g = b = (13879 * r + 46688 * g + 4713 * b) >> 16;
 768         }
 769
 770         /*
 771          * The assumption is that the RGB output is always full range,
 772          * so only if the rgb_range overrides the 'real' rgb range do
 773          * we need to convert the RGB values.
 774          *
 775          * Remember that r, g and b are still in the 0 - 0xff0 range.
 776          */
 777         if (tpg->real_rgb_range == V4L2_DV_RGB_RANGE_LIMITED &&
 778             tpg->rgb_range == V4L2_DV_RGB_RANGE_FULL && !tpg->is_yuv) {
 779                 /*
 780                  * Convert from full range (which is what r, g and b are)
 781                  * to limited range (which is the 'real' RGB range), which
 782                  * is then interpreted as full range.
 783                  */
 784                 r = (r * 219) / 255 + (16 << 4);
 785                 g = (g * 219) / 255 + (16 << 4);
 786                 b = (b * 219) / 255 + (16 << 4);
 787         } else if (tpg->real_rgb_range != V4L2_DV_RGB_RANGE_LIMITED &&
 788                    tpg->rgb_range == V4L2_DV_RGB_RANGE_LIMITED && !tpg->is_yuv) {
 789                 /*
 790                  * Clamp r, g and b to the limited range and convert to full
 791                  * range since that's what we deliver.
 792                  */
 793                 r = clamp(r, 16 << 4, 235 << 4);
 794                 g = clamp(g, 16 << 4, 235 << 4);
 795                 b = clamp(b, 16 << 4, 235 << 4);
 796                 r = (r - (16 << 4)) * 255 / 219;
 797                 g = (g - (16 << 4)) * 255 / 219;
 798                 b = (b - (16 << 4)) * 255 / 219;
 799         }
 800
 801         if (tpg->brightness != 128 || tpg->contrast != 128 ||
 802             tpg->saturation != 128 || tpg->hue) {
 803                 /* Implement these operations */
 804                 int y, cb, cr;
 805                 int tmp_cb, tmp_cr;
 806
 807                 /* First convert to YCbCr */
 808
 809                 color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
 810
 811                 y = (16 << 4) + ((y - (16 << 4)) * tpg->contrast) / 128;
 812                 y += (tpg->brightness << 4) - (128 << 4);
 813
 814                 cb -= 128 << 4;
 815                 cr -= 128 << 4;
 816                 tmp_cb = (cb * cos(128 + tpg->hue)) / 127 + (cr * sin[128 + tpg->hue]) / 127;
 817                 tmp_cr = (cr * cos(128 + tpg->hue)) / 127 - (cb * sin[128 + tpg->hue]) / 127;
 818
 819                 cb = (128 << 4) + (tmp_cb * tpg->contrast * tpg->saturation) / (128 * 128);
 820                 cr = (128 << 4) + (tmp_cr * tpg->contrast * tpg->saturation) / (128 * 128);
 821                 if (tpg->is_yuv) {
 822                         tpg->colors[k][0] = clamp(y >> 4, 1, 254);
 823                         tpg->colors[k][1] = clamp(cb >> 4, 1, 254);
 824                         tpg->colors[k][2] = clamp(cr >> 4, 1, 254);
 825                         return;
 826                 }
 827                 ycbcr_to_color(tpg, y, cb, cr, &r, &g, &b);
 828         }
 829
 830         if (tpg->is_yuv) {
 831                 /* Convert to YCbCr */
 832                 int y, cb, cr;
 833
 834                 color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
 835
 836                 if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
 837                         y = clamp(y, 16 << 4, 235 << 4);
 838                         cb = clamp(cb, 16 << 4, 240 << 4);
 839                         cr = clamp(cr, 16 << 4, 240 << 4);
 840                 }
 841                 y = clamp(y >> 4, 1, 254);
 842                 cb = clamp(cb >> 4, 1, 254);
 843                 cr = clamp(cr >> 4, 1, 254);
 844                 switch (tpg->fourcc) {
 845                 case V4L2_PIX_FMT_YUV444:
 846                         y >>= 4;
 847                         cb >>= 4;
 848                         cr >>= 4;
 849                         break;
 850                 case V4L2_PIX_FMT_YUV555:
 851                         y >>= 3;
 852                         cb >>= 3;
 853                         cr >>= 3;
 854                         break;
 855                 case V4L2_PIX_FMT_YUV565:
 856                         y >>= 3;
 857                         cb >>= 2;
 858                         cr >>= 3;
 859                         break;
 860                 }
 861                 tpg->colors[k][0] = y;
 862                 tpg->colors[k][1] = cb;
 863                 tpg->colors[k][2] = cr;
 864         } else {
 865                 if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
 866                         r = (r * 219) / 255 + (16 << 4);
 867                         g = (g * 219) / 255 + (16 << 4);
 868                         b = (b * 219) / 255 + (16 << 4);
 869                 }
 870                 switch (tpg->fourcc) {
 871                 case V4L2_PIX_FMT_RGB332:
 872                         r >>= 9;
 873                         g >>= 9;
 874                         b >>= 10;
 875                         break;
 876                 case V4L2_PIX_FMT_RGB565:
 877                 case V4L2_PIX_FMT_RGB565X:
 878                         r >>= 7;
 879                         g >>= 6;
 880                         b >>= 7;
 881                         break;
 882                 case V4L2_PIX_FMT_RGB444:
 883                 case V4L2_PIX_FMT_XRGB444:
 884                 case V4L2_PIX_FMT_ARGB444:
 885                         r >>= 8;
 886                         g >>= 8;
 887                         b >>= 8;
 888                         break;
 889                 case V4L2_PIX_FMT_RGB555:
 890                 case V4L2_PIX_FMT_XRGB555:
 891                 case V4L2_PIX_FMT_ARGB555:
 892                 case V4L2_PIX_FMT_RGB555X:
 893                 case V4L2_PIX_FMT_XRGB555X:
 894                 case V4L2_PIX_FMT_ARGB555X:
 895                         r >>= 7;
 896                         g >>= 7;
 897                         b >>= 7;
 898                         break;
 899                 case V4L2_PIX_FMT_BGR666:
 900                         r >>= 6;
 901                         g >>= 6;
 902                         b >>= 6;
 903                         break;
 904                 default:
 905                         r >>= 4;
 906                         g >>= 4;
 907                         b >>= 4;
 908                         break;
 909                 }
 910
 911                 tpg->colors[k][0] = r;
 912                 tpg->colors[k][1] = g;
 913                 tpg->colors[k][2] = b;
 914         }
 915 }
 916
 917 static void tpg_precalculate_colors(struct tpg_data *tpg)
 918 {
 919         int k;
 920
 921         for (k = 0; k < TPG_COLOR_MAX; k++)
 922                 precalculate_color(tpg, k);
 923 }
 924
 925 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
 926 static void gen_twopix(struct tpg_data *tpg,
 927                 u8 buf[TPG_MAX_PLANES][8], int color, bool odd)
 928 {
 929         unsigned offset = odd * tpg->twopixelsize[0] / 2;
 930         u8 alpha = tpg->alpha_component;
 931         u8 r_y, g_u, b_v;
 932
 933         if (tpg->alpha_red_only && color != TPG_COLOR_CSC_RED &&
 934                                    color != TPG_COLOR_100_RED &&
 935                                    color != TPG_COLOR_75_RED)
 936                 alpha = 0;
 937         if (color == TPG_COLOR_RANDOM)
 938                 precalculate_color(tpg, color);
 939         r_y = tpg->colors[color][0]; /* R or precalculated Y */
 940         g_u = tpg->colors[color][1]; /* G or precalculated U */
 941         b_v = tpg->colors[color][2]; /* B or precalculated V */
 942
 943         switch (tpg->fourcc) {
 944         case V4L2_PIX_FMT_GREY:
 945                 buf[0][offset] = r_y;
 946                 break;
 947         case V4L2_PIX_FMT_Y16:
 948                 /*
 949                  * Ideally both bytes should be set to r_y, but then you won't
 950                  * be able to detect endian problems. So keep it 0 except for
 951                  * the corner case where r_y is 0xff so white really will be
 952                  * white (0xffff).
 953                  */
 954                 buf[0][offset] = r_y == 0xff ? r_y : 0;
 955                 buf[0][offset+1] = r_y;
 956                 break;
 957         case V4L2_PIX_FMT_Y16_BE:
 958                 /* See comment for V4L2_PIX_FMT_Y16 above */
 959                 buf[0][offset] = r_y;
 960                 buf[0][offset+1] = r_y == 0xff ? r_y : 0;
 961                 break;
 962         case V4L2_PIX_FMT_YUV422M:
 963         case V4L2_PIX_FMT_YUV422P:
 964         case V4L2_PIX_FMT_YUV420:
 965         case V4L2_PIX_FMT_YUV420M:
 966                 buf[0][offset] = r_y;
 967                 if (odd) {
 968                         buf[1][0] = (buf[1][0] + g_u) / 2;
 969                         buf[2][0] = (buf[2][0] + b_v) / 2;
 970                         buf[1][1] = buf[1][0];
 971                         buf[2][1] = buf[2][0];
 972                         break;
 973                 }
 974                 buf[1][0] = g_u;
 975                 buf[2][0] = b_v;
 976                 break;
 977         case V4L2_PIX_FMT_YVU422M:
 978         case V4L2_PIX_FMT_YVU420:
 979         case V4L2_PIX_FMT_YVU420M:
 980                 buf[0][offset] = r_y;
 981                 if (odd) {
 982                         buf[1][0] = (buf[1][0] + b_v) / 2;
 983                         buf[2][0] = (buf[2][0] + g_u) / 2;
 984                         buf[1][1] = buf[1][0];
 985                         buf[2][1] = buf[2][0];
 986                         break;
 987                 }
 988                 buf[1][0] = b_v;
 989                 buf[2][0] = g_u;
 990                 break;
 991
 992         case V4L2_PIX_FMT_NV12:
 993         case V4L2_PIX_FMT_NV12M:
 994         case V4L2_PIX_FMT_NV16:
 995         case V4L2_PIX_FMT_NV16M:
 996                 buf[0][offset] = r_y;
 997                 if (odd) {
 998                         buf[1][0] = (buf[1][0] + g_u) / 2;
 999                         buf[1][1] = (buf[1][1] + b_v) / 2;
1000                         break;
1001                 }
1002                 buf[1][0] = g_u;
1003                 buf[1][1] = b_v;
1004                 break;
1005         case V4L2_PIX_FMT_NV21:
1006         case V4L2_PIX_FMT_NV21M:
1007         case V4L2_PIX_FMT_NV61:
1008         case V4L2_PIX_FMT_NV61M:
1009                 buf[0][offset] = r_y;
1010                 if (odd) {
1011                         buf[1][0] = (buf[1][0] + b_v) / 2;
1012                         buf[1][1] = (buf[1][1] + g_u) / 2;
1013                         break;
1014                 }
1015                 buf[1][0] = b_v;
1016                 buf[1][1] = g_u;
1017                 break;
1018
1019         case V4L2_PIX_FMT_YUV444M:
1020                 buf[0][offset] = r_y;
1021                 buf[1][offset] = g_u;
1022                 buf[2][offset] = b_v;
1023                 break;
1024
1025         case V4L2_PIX_FMT_YVU444M:
1026                 buf[0][offset] = r_y;
1027                 buf[1][offset] = b_v;
1028                 buf[2][offset] = g_u;
1029                 break;
1030
1031         case V4L2_PIX_FMT_NV24:
1032                 buf[0][offset] = r_y;
1033                 buf[1][2 * offset] = g_u;
1034                 buf[1][2 * offset + 1] = b_v;
1035                 break;
1036
1037         case V4L2_PIX_FMT_NV42:
1038                 buf[0][offset] = r_y;
1039                 buf[1][2 * offset] = b_v;
1040                 buf[1][2 * offset + 1] = g_u;
1041                 break;
1042
1043         case V4L2_PIX_FMT_YUYV:
1044                 buf[0][offset] = r_y;
1045                 if (odd) {
1046                         buf[0][1] = (buf[0][1] + g_u) / 2;
1047                         buf[0][3] = (buf[0][3] + b_v) / 2;
1048                         break;
1049                 }
1050                 buf[0][1] = g_u;
1051                 buf[0][3] = b_v;
1052                 break;
1053         case V4L2_PIX_FMT_UYVY:
1054                 buf[0][offset + 1] = r_y;
1055                 if (odd) {
1056                         buf[0][0] = (buf[0][0] + g_u) / 2;
1057                         buf[0][2] = (buf[0][2] + b_v) / 2;
1058                         break;
1059                 }
1060                 buf[0][0] = g_u;
1061                 buf[0][2] = b_v;
1062                 break;
1063         case V4L2_PIX_FMT_YVYU:
1064                 buf[0][offset] = r_y;
1065                 if (odd) {
1066                         buf[0][1] = (buf[0][1] + b_v) / 2;
1067                         buf[0][3] = (buf[0][3] + g_u) / 2;
1068                         break;
1069                 }
1070                 buf[0][1] = b_v;
1071                 buf[0][3] = g_u;
1072                 break;
1073         case V4L2_PIX_FMT_VYUY:
1074                 buf[0][offset + 1] = r_y;
1075                 if (odd) {
1076                         buf[0][0] = (buf[0][0] + b_v) / 2;
1077                         buf[0][2] = (buf[0][2] + g_u) / 2;
1078                         break;
1079                 }
1080                 buf[0][0] = b_v;
1081                 buf[0][2] = g_u;
1082                 break;
1083         case V4L2_PIX_FMT_RGB332:
1084                 buf[0][offset] = (r_y << 5) | (g_u << 2) | b_v;
1085                 break;
1086         case V4L2_PIX_FMT_YUV565:
1087         case V4L2_PIX_FMT_RGB565:
1088                 buf[0][offset] = (g_u << 5) | b_v;
1089                 buf[0][offset + 1] = (r_y << 3) | (g_u >> 3);
1090                 break;
1091         case V4L2_PIX_FMT_RGB565X:
1092                 buf[0][offset] = (r_y << 3) | (g_u >> 3);
1093                 buf[0][offset + 1] = (g_u << 5) | b_v;
1094                 break;
1095         case V4L2_PIX_FMT_RGB444:
1096         case V4L2_PIX_FMT_XRGB444:
1097                 alpha = 0;
1098                 /* fall through */
1099         case V4L2_PIX_FMT_YUV444:
1100         case V4L2_PIX_FMT_ARGB444:
1101                 buf[0][offset] = (g_u << 4) | b_v;
1102                 buf[0][offset + 1] = (alpha & 0xf0) | r_y;
1103                 break;
1104         case V4L2_PIX_FMT_RGB555:
1105         case V4L2_PIX_FMT_XRGB555:
1106                 alpha = 0;
1107                 /* fall through */
1108         case V4L2_PIX_FMT_YUV555:
1109         case V4L2_PIX_FMT_ARGB555:
1110                 buf[0][offset] = (g_u << 5) | b_v;
1111                 buf[0][offset + 1] = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
1112                 break;
1113         case V4L2_PIX_FMT_RGB555X:
1114         case V4L2_PIX_FMT_XRGB555X:
1115                 alpha = 0;
1116                 /* fall through */
1117         case V4L2_PIX_FMT_ARGB555X:
1118                 buf[0][offset] = (alpha & 0x80) | (r_y << 2) | (g_u >> 3);
1119                 buf[0][offset + 1] = (g_u << 5) | b_v;
1120                 break;
1121         case V4L2_PIX_FMT_RGB24:
1122                 buf[0][offset] = r_y;
1123                 buf[0][offset + 1] = g_u;
1124                 buf[0][offset + 2] = b_v;
1125                 break;
1126         case V4L2_PIX_FMT_BGR24:
1127                 buf[0][offset] = b_v;
1128                 buf[0][offset + 1] = g_u;
1129                 buf[0][offset + 2] = r_y;
1130                 break;
1131         case V4L2_PIX_FMT_BGR666:
1132                 buf[0][offset] = (b_v << 2) | (g_u >> 4);
1133                 buf[0][offset + 1] = (g_u << 4) | (r_y >> 2);
1134                 buf[0][offset + 2] = r_y << 6;
1135                 buf[0][offset + 3] = 0;
1136                 break;
1137         case V4L2_PIX_FMT_RGB32:
1138         case V4L2_PIX_FMT_XRGB32:
1139                 alpha = 0;
1140                 /* fall through */
1141         case V4L2_PIX_FMT_YUV32:
1142         case V4L2_PIX_FMT_ARGB32:
1143                 buf[0][offset] = alpha;
1144                 buf[0][offset + 1] = r_y;
1145                 buf[0][offset + 2] = g_u;
1146                 buf[0][offset + 3] = b_v;
1147                 break;
1148         case V4L2_PIX_FMT_BGR32:
1149         case V4L2_PIX_FMT_XBGR32:
1150                 alpha = 0;
1151                 /* fall through */
1152         case V4L2_PIX_FMT_ABGR32:
1153                 buf[0][offset] = b_v;
1154                 buf[0][offset + 1] = g_u;
1155                 buf[0][offset + 2] = r_y;
1156                 buf[0][offset + 3] = alpha;
1157                 break;
1158         case V4L2_PIX_FMT_SBGGR8:
1159                 buf[0][offset] = odd ? g_u : b_v;
1160                 buf[1][offset] = odd ? r_y : g_u;
1161                 break;
1162         case V4L2_PIX_FMT_SGBRG8:
1163                 buf[0][offset] = odd ? b_v : g_u;
1164                 buf[1][offset] = odd ? g_u : r_y;
1165                 break;
1166         case V4L2_PIX_FMT_SGRBG8:
1167                 buf[0][offset] = odd ? r_y : g_u;
1168                 buf[1][offset] = odd ? g_u : b_v;
1169                 break;
1170         case V4L2_PIX_FMT_SRGGB8:
1171                 buf[0][offset] = odd ? g_u : r_y;
1172                 buf[1][offset] = odd ? b_v : g_u;
1173                 break;
1174         case V4L2_PIX_FMT_SBGGR10:
1175                 buf[0][offset] = odd ? g_u << 2 : b_v << 2;
1176                 buf[0][offset + 1] = odd ? g_u >> 6 : b_v >> 6;
1177                 buf[1][offset] = odd ? r_y << 2 : g_u << 2;
1178                 buf[1][offset + 1] = odd ? r_y >> 6 : g_u >> 6;
1179                 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1180                 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1181                 break;
1182         case V4L2_PIX_FMT_SGBRG10:
1183                 buf[0][offset] = odd ? b_v << 2 : g_u << 2;
1184                 buf[0][offset + 1] = odd ? b_v >> 6 : g_u >> 6;
1185                 buf[1][offset] = odd ? g_u << 2 : r_y << 2;
1186                 buf[1][offset + 1] = odd ? g_u >> 6 : r_y >> 6;
1187                 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1188                 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1189                 break;
1190         case V4L2_PIX_FMT_SGRBG10:
1191                 buf[0][offset] = odd ? r_y << 2 : g_u << 2;
1192                 buf[0][offset + 1] = odd ? r_y >> 6 : g_u >> 6;
1193                 buf[1][offset] = odd ? g_u << 2 : b_v << 2;
1194                 buf[1][offset + 1] = odd ? g_u >> 6 : b_v >> 6;
1195                 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1196                 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1197                 break;
1198         case V4L2_PIX_FMT_SRGGB10:
1199                 buf[0][offset] = odd ? g_u << 2 : r_y << 2;
1200                 buf[0][offset + 1] = odd ? g_u >> 6 : r_y >> 6;
1201                 buf[1][offset] = odd ? b_v << 2 : g_u << 2;
1202                 buf[1][offset + 1] = odd ? b_v >> 6 : g_u >> 6;
1203                 buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1204                 buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1205                 break;
1206         case V4L2_PIX_FMT_SBGGR12:
1207                 buf[0][offset] = odd ? g_u << 4 : b_v << 4;
1208                 buf[0][offset + 1] = odd ? g_u >> 4 : b_v >> 4;
1209                 buf[1][offset] = odd ? r_y << 4 : g_u << 4;
1210                 buf[1][offset + 1] = odd ? r_y >> 4 : g_u >> 4;
1211                 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1212                 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1213                 break;
1214         case V4L2_PIX_FMT_SGBRG12:
1215                 buf[0][offset] = odd ? b_v << 4 : g_u << 4;
1216                 buf[0][offset + 1] = odd ? b_v >> 4 : g_u >> 4;
1217                 buf[1][offset] = odd ? g_u << 4 : r_y << 4;
1218                 buf[1][offset + 1] = odd ? g_u >> 4 : r_y >> 4;
1219                 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1220                 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1221                 break;
1222         case V4L2_PIX_FMT_SGRBG12:
1223                 buf[0][offset] = odd ? r_y << 4 : g_u << 4;
1224                 buf[0][offset + 1] = odd ? r_y >> 4 : g_u >> 4;
1225                 buf[1][offset] = odd ? g_u << 4 : b_v << 4;
1226                 buf[1][offset + 1] = odd ? g_u >> 4 : b_v >> 4;
1227                 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1228                 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1229                 break;
1230         case V4L2_PIX_FMT_SRGGB12:
1231                 buf[0][offset] = odd ? g_u << 4 : r_y << 4;
1232                 buf[0][offset + 1] = odd ? g_u >> 4 : r_y >> 4;
1233                 buf[1][offset] = odd ? b_v << 4 : g_u << 4;
1234                 buf[1][offset + 1] = odd ? b_v >> 4 : g_u >> 4;
1235                 buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1236                 buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1237                 break;
1238         }
1239 }
1240
1241 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line)
1242 {
1243         switch (tpg->fourcc) {
1244         case V4L2_PIX_FMT_SBGGR8:
1245         case V4L2_PIX_FMT_SGBRG8:
1246         case V4L2_PIX_FMT_SGRBG8:
1247         case V4L2_PIX_FMT_SRGGB8:
1248         case V4L2_PIX_FMT_SBGGR10:
1249         case V4L2_PIX_FMT_SGBRG10:
1250         case V4L2_PIX_FMT_SGRBG10:
1251         case V4L2_PIX_FMT_SRGGB10:
1252         case V4L2_PIX_FMT_SBGGR12:
1253         case V4L2_PIX_FMT_SGBRG12:
1254         case V4L2_PIX_FMT_SGRBG12:
1255         case V4L2_PIX_FMT_SRGGB12:
1256                 return buf_line & 1;
1257         default:
1258                 return 0;
1259         }
1260 }
1261 EXPORT_SYMBOL_GPL(tpg_g_interleaved_plane);
1262
1263 /* Return how many pattern lines are used by the current pattern. */
1264 static unsigned tpg_get_pat_lines(const struct tpg_data *tpg)
1265 {
1266         switch (tpg->pattern) {
1267         case TPG_PAT_CHECKERS_16X16:
1268         case TPG_PAT_CHECKERS_2X2:
1269         case TPG_PAT_CHECKERS_1X1:
1270         case TPG_PAT_COLOR_CHECKERS_2X2:
1271         case TPG_PAT_COLOR_CHECKERS_1X1:
1272         case TPG_PAT_ALTERNATING_HLINES:
1273         case TPG_PAT_CROSS_1_PIXEL:
1274         case TPG_PAT_CROSS_2_PIXELS:
1275         case TPG_PAT_CROSS_10_PIXELS:
1276                 return 2;
1277         case TPG_PAT_100_COLORSQUARES:
1278         case TPG_PAT_100_HCOLORBAR:
1279                 return 8;
1280         default:
1281                 return 1;
1282         }
1283 }
1284
1285 /* Which pattern line should be used for the given frame line. */
1286 static unsigned tpg_get_pat_line(const struct tpg_data *tpg, unsigned line)
1287 {
1288         switch (tpg->pattern) {
1289         case TPG_PAT_CHECKERS_16X16:
1290                 return (line >> 4) & 1;
1291         case TPG_PAT_CHECKERS_1X1:
1292         case TPG_PAT_COLOR_CHECKERS_1X1:
1293         case TPG_PAT_ALTERNATING_HLINES:
1294                 return line & 1;
1295         case TPG_PAT_CHECKERS_2X2:
1296         case TPG_PAT_COLOR_CHECKERS_2X2:
1297                 return (line & 2) >> 1;
1298         case TPG_PAT_100_COLORSQUARES:
1299         case TPG_PAT_100_HCOLORBAR:
1300                 return (line * 8) / tpg->src_height;
1301         case TPG_PAT_CROSS_1_PIXEL:
1302                 return line == tpg->src_height / 2;
1303         case TPG_PAT_CROSS_2_PIXELS:
1304                 return (line + 1) / 2 == tpg->src_height / 4;
1305         case TPG_PAT_CROSS_10_PIXELS:
1306                 return (line + 10) / 20 == tpg->src_height / 40;
1307         default:
1308                 return 0;
1309         }
1310 }
1311
1312 /*
1313  * Which color should be used for the given pattern line and X coordinate.
1314  * Note: x is in the range 0 to 2 * tpg->src_width.
1315  */
1316 static enum tpg_color tpg_get_color(const struct tpg_data *tpg,
1317                                     unsigned pat_line, unsigned x)
1318 {
1319         /* Maximum number of bars are TPG_COLOR_MAX - otherwise, the input print code
1320            should be modified */
1321         static const enum tpg_color bars[3][8] = {
1322                 /* Standard ITU-R 75% color bar sequence */
1323                 { TPG_COLOR_CSC_WHITE,   TPG_COLOR_75_YELLOW,
1324                   TPG_COLOR_75_CYAN,     TPG_COLOR_75_GREEN,
1325                   TPG_COLOR_75_MAGENTA,  TPG_COLOR_75_RED,
1326                   TPG_COLOR_75_BLUE,     TPG_COLOR_100_BLACK, },
1327                 /* Standard ITU-R 100% color bar sequence */
1328                 { TPG_COLOR_100_WHITE,   TPG_COLOR_100_YELLOW,
1329                   TPG_COLOR_100_CYAN,    TPG_COLOR_100_GREEN,
1330                   TPG_COLOR_100_MAGENTA, TPG_COLOR_100_RED,
1331                   TPG_COLOR_100_BLUE,    TPG_COLOR_100_BLACK, },
1332                 /* Color bar sequence suitable to test CSC */
1333                 { TPG_COLOR_CSC_WHITE,   TPG_COLOR_CSC_YELLOW,
1334                   TPG_COLOR_CSC_CYAN,    TPG_COLOR_CSC_GREEN,
1335                   TPG_COLOR_CSC_MAGENTA, TPG_COLOR_CSC_RED,
1336                   TPG_COLOR_CSC_BLUE,    TPG_COLOR_CSC_BLACK, },
1337         };
1338
1339         switch (tpg->pattern) {
1340         case TPG_PAT_75_COLORBAR:
1341         case TPG_PAT_100_COLORBAR:
1342         case TPG_PAT_CSC_COLORBAR:
1343                 return bars[tpg->pattern][((x * 8) / tpg->src_width) % 8];
1344         case TPG_PAT_100_COLORSQUARES:
1345                 return bars[1][(pat_line + (x * 8) / tpg->src_width) % 8];
1346         case TPG_PAT_100_HCOLORBAR:
1347                 return bars[1][pat_line];
1348         case TPG_PAT_BLACK:
1349                 return TPG_COLOR_100_BLACK;
1350         case TPG_PAT_WHITE:
1351                 return TPG_COLOR_100_WHITE;
1352         case TPG_PAT_RED:
1353                 return TPG_COLOR_100_RED;
1354         case TPG_PAT_GREEN:
1355                 return TPG_COLOR_100_GREEN;
1356         case TPG_PAT_BLUE:
1357                 return TPG_COLOR_100_BLUE;
1358         case TPG_PAT_CHECKERS_16X16:
1359                 return (((x >> 4) & 1) ^ (pat_line & 1)) ?
1360                         TPG_COLOR_100_BLACK : TPG_COLOR_100_WHITE;
1361         case TPG_PAT_CHECKERS_1X1:
1362                 return ((x & 1) ^ (pat_line & 1)) ?
1363                         TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1364         case TPG_PAT_COLOR_CHECKERS_1X1:
1365                 return ((x & 1) ^ (pat_line & 1)) ?
1366                         TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1367         case TPG_PAT_CHECKERS_2X2:
1368                 return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1369                         TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1370         case TPG_PAT_COLOR_CHECKERS_2X2:
1371                 return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1372                         TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1373         case TPG_PAT_ALTERNATING_HLINES:
1374                 return pat_line ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1375         case TPG_PAT_ALTERNATING_VLINES:
1376                 return (x & 1) ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1377         case TPG_PAT_CROSS_1_PIXEL:
1378                 if (pat_line || (x % tpg->src_width) == tpg->src_width / 2)
1379                         return TPG_COLOR_100_BLACK;
1380                 return TPG_COLOR_100_WHITE;
1381         case TPG_PAT_CROSS_2_PIXELS:
1382                 if (pat_line || ((x % tpg->src_width) + 1) / 2 == tpg->src_width / 4)
1383                         return TPG_COLOR_100_BLACK;
1384                 return TPG_COLOR_100_WHITE;
1385         case TPG_PAT_CROSS_10_PIXELS:
1386                 if (pat_line || ((x % tpg->src_width) + 10) / 20 == tpg->src_width / 40)
1387                         return TPG_COLOR_100_BLACK;
1388                 return TPG_COLOR_100_WHITE;
1389         case TPG_PAT_GRAY_RAMP:
1390                 return TPG_COLOR_RAMP + ((x % tpg->src_width) * 256) / tpg->src_width;
1391         default:
1392                 return TPG_COLOR_100_RED;
1393         }
1394 }
1395
1396 /*
1397  * Given the pixel aspect ratio and video aspect ratio calculate the
1398  * coordinates of a centered square and the coordinates of the border of
1399  * the active video area. The coordinates are relative to the source
1400  * frame rectangle.
1401  */
1402 static void tpg_calculate_square_border(struct tpg_data *tpg)
1403 {
1404         unsigned w = tpg->src_width;
1405         unsigned h = tpg->src_height;
1406         unsigned sq_w, sq_h;
1407
1408         sq_w = (w * 2 / 5) & ~1;
1409         if (((w - sq_w) / 2) & 1)
1410                 sq_w += 2;
1411         sq_h = sq_w;
1412         tpg->square.width = sq_w;
1413         if (tpg->vid_aspect == TPG_VIDEO_ASPECT_16X9_ANAMORPHIC) {
1414                 unsigned ana_sq_w = (sq_w / 4) * 3;
1415
1416                 if (((w - ana_sq_w) / 2) & 1)
1417                         ana_sq_w += 2;
1418                 tpg->square.width = ana_sq_w;
1419         }
1420         tpg->square.left = (w - tpg->square.width) / 2;
1421         if (tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC)
1422                 sq_h = sq_w * 10 / 11;
1423         else if (tpg->pix_aspect == TPG_PIXEL_ASPECT_PAL)
1424                 sq_h = sq_w * 59 / 54;
1425         tpg->square.height = sq_h;
1426         tpg->square.top = (h - sq_h) / 2;
1427         tpg->border.left = 0;
1428         tpg->border.width = w;
1429         tpg->border.top = 0;
1430         tpg->border.height = h;
1431         switch (tpg->vid_aspect) {
1432         case TPG_VIDEO_ASPECT_4X3:
1433                 if (tpg->pix_aspect)
1434                         return;
1435                 if (3 * w >= 4 * h) {
1436                         tpg->border.width = ((4 * h) / 3) & ~1;
1437                         if (((w - tpg->border.width) / 2) & ~1)
1438                                 tpg->border.width -= 2;
1439                         tpg->border.left = (w - tpg->border.width) / 2;
1440                         break;
1441                 }
1442                 tpg->border.height = ((3 * w) / 4) & ~1;
1443                 tpg->border.top = (h - tpg->border.height) / 2;
1444                 break;
1445         case TPG_VIDEO_ASPECT_14X9_CENTRE:
1446                 if (tpg->pix_aspect) {
1447                         tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 420 : 506;
1448                         tpg->border.top = (h - tpg->border.height) / 2;
1449                         break;
1450                 }
1451                 if (9 * w >= 14 * h) {
1452                         tpg->border.width = ((14 * h) / 9) & ~1;
1453                         if (((w - tpg->border.width) / 2) & ~1)
1454                                 tpg->border.width -= 2;
1455                         tpg->border.left = (w - tpg->border.width) / 2;
1456                         break;
1457                 }
1458                 tpg->border.height = ((9 * w) / 14) & ~1;
1459                 tpg->border.top = (h - tpg->border.height) / 2;
1460                 break;
1461         case TPG_VIDEO_ASPECT_16X9_CENTRE:
1462                 if (tpg->pix_aspect) {
1463                         tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 368 : 442;
1464                         tpg->border.top = (h - tpg->border.height) / 2;
1465                         break;
1466                 }
1467                 if (9 * w >= 16 * h) {
1468                         tpg->border.width = ((16 * h) / 9) & ~1;
1469                         if (((w - tpg->border.width) / 2) & ~1)
1470                                 tpg->border.width -= 2;
1471                         tpg->border.left = (w - tpg->border.width) / 2;
1472                         break;
1473                 }
1474                 tpg->border.height = ((9 * w) / 16) & ~1;
1475                 tpg->border.top = (h - tpg->border.height) / 2;
1476                 break;
1477         default:
1478                 break;
1479         }
1480 }
1481
1482 static void tpg_precalculate_line(struct tpg_data *tpg)
1483 {
1484         enum tpg_color contrast;
1485         u8 pix[TPG_MAX_PLANES][8];
1486         unsigned pat;
1487         unsigned p;
1488         unsigned x;
1489
1490         switch (tpg->pattern) {
1491         case TPG_PAT_GREEN:
1492                 contrast = TPG_COLOR_100_RED;
1493                 break;
1494         case TPG_PAT_CSC_COLORBAR:
1495                 contrast = TPG_COLOR_CSC_GREEN;
1496                 break;
1497         default:
1498                 contrast = TPG_COLOR_100_GREEN;
1499                 break;
1500         }
1501
1502         for (pat = 0; pat < tpg_get_pat_lines(tpg); pat++) {
1503                 /* Coarse scaling with Bresenham */
1504                 unsigned int_part = tpg->src_width / tpg->scaled_width;
1505                 unsigned fract_part = tpg->src_width % tpg->scaled_width;
1506                 unsigned src_x = 0;
1507                 unsigned error = 0;
1508
1509                 for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1510                         unsigned real_x = src_x;
1511                         enum tpg_color color1, color2;
1512
1513                         real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1514                         color1 = tpg_get_color(tpg, pat, real_x);
1515
1516                         src_x += int_part;
1517                         error += fract_part;
1518                         if (error >= tpg->scaled_width) {
1519                                 error -= tpg->scaled_width;
1520                                 src_x++;
1521                         }
1522
1523                         real_x = src_x;
1524                         real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1525                         color2 = tpg_get_color(tpg, pat, real_x);
1526
1527                         src_x += int_part;
1528                         error += fract_part;
1529                         if (error >= tpg->scaled_width) {
1530                                 error -= tpg->scaled_width;
1531                                 src_x++;
1532                         }
1533
1534                         gen_twopix(tpg, pix, tpg->hflip ? color2 : color1, 0);
1535                         gen_twopix(tpg, pix, tpg->hflip ? color1 : color2, 1);
1536                         for (p = 0; p < tpg->planes; p++) {
1537                                 unsigned twopixsize = tpg->twopixelsize[p];
1538                                 unsigned hdiv = tpg->hdownsampling[p];
1539                                 u8 *pos = tpg->lines[pat][p] + tpg_hdiv(tpg, p, x);
1540
1541                                 memcpy(pos, pix[p], twopixsize / hdiv);
1542                         }
1543                 }
1544         }
1545
1546         if (tpg->vdownsampling[tpg->planes - 1] > 1) {
1547                 unsigned pat_lines = tpg_get_pat_lines(tpg);
1548
1549                 for (pat = 0; pat < pat_lines; pat++) {
1550                         unsigned next_pat = (pat + 1) % pat_lines;
1551
1552                         for (p = 1; p < tpg->planes; p++) {
1553                                 unsigned w = tpg_hdiv(tpg, p, tpg->scaled_width * 2);
1554                                 u8 *pos1 = tpg->lines[pat][p];
1555                                 u8 *pos2 = tpg->lines[next_pat][p];
1556                                 u8 *dest = tpg->downsampled_lines[pat][p];
1557
1558                                 for (x = 0; x < w; x++, pos1++, pos2++, dest++)
1559                                         *dest = ((u16)*pos1 + (u16)*pos2) / 2;
1560                         }
1561                 }
1562         }
1563
1564         gen_twopix(tpg, pix, contrast, 0);
1565         gen_twopix(tpg, pix, contrast, 1);
1566         for (p = 0; p < tpg->planes; p++) {
1567                 unsigned twopixsize = tpg->twopixelsize[p];
1568                 u8 *pos = tpg->contrast_line[p];
1569
1570                 for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1571                         memcpy(pos, pix[p], twopixsize);
1572         }
1573
1574         gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 0);
1575         gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 1);
1576         for (p = 0; p < tpg->planes; p++) {
1577                 unsigned twopixsize = tpg->twopixelsize[p];
1578                 u8 *pos = tpg->black_line[p];
1579
1580                 for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1581                         memcpy(pos, pix[p], twopixsize);
1582         }
1583
1584         for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1585                 gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 0);
1586                 gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 1);
1587                 for (p = 0; p < tpg->planes; p++) {
1588                         unsigned twopixsize = tpg->twopixelsize[p];
1589                         u8 *pos = tpg->random_line[p] + x * twopixsize / 2;
1590
1591                         memcpy(pos, pix[p], twopixsize);
1592                 }
1593         }
1594
1595         gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 0);
1596         gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 1);
1597         gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 0);
1598         gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 1);
1599 }
1600
1601 /* need this to do rgb24 rendering */
1602 typedef struct { u16 __; u8 _; } __packed x24;
1603
1604 #define PRINTSTR(PIXTYPE) do {  \
1605         unsigned vdiv = tpg->vdownsampling[p]; \
1606         unsigned hdiv = tpg->hdownsampling[p]; \
1607         int line;       \
1608         PIXTYPE fg;     \
1609         PIXTYPE bg;     \
1610         memcpy(&fg, tpg->textfg[p], sizeof(PIXTYPE));   \
1611         memcpy(&bg, tpg->textbg[p], sizeof(PIXTYPE));   \
1612         \
1613         for (line = first; line < 16; line += vdiv * step) {    \
1614                 int l = tpg->vflip ? 15 - line : line; \
1615                 PIXTYPE *pos = (PIXTYPE *)(basep[p][(line / vdiv) & 1] + \
1616                                ((y * step + l) / (vdiv * div)) * tpg->bytesperline[p] + \
1617                                (x / hdiv) * sizeof(PIXTYPE));   \
1618                 unsigned s;     \
1619         \
1620                 for (s = 0; s < len; s++) {     \
1621                         u8 chr = font8x16[text[s] * 16 + line]; \
1622         \
1623                         if (hdiv == 2 && tpg->hflip) { \
1624                                 pos[3] = (chr & (0x01 << 6) ? fg : bg); \
1625                                 pos[2] = (chr & (0x01 << 4) ? fg : bg); \
1626                                 pos[1] = (chr & (0x01 << 2) ? fg : bg); \
1627                                 pos[0] = (chr & (0x01 << 0) ? fg : bg); \
1628                         } else if (hdiv == 2) { \
1629                                 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
1630                                 pos[1] = (chr & (0x01 << 5) ? fg : bg); \
1631                                 pos[2] = (chr & (0x01 << 3) ? fg : bg); \
1632                                 pos[3] = (chr & (0x01 << 1) ? fg : bg); \
1633                         } else if (tpg->hflip) { \
1634                                 pos[7] = (chr & (0x01 << 7) ? fg : bg); \
1635                                 pos[6] = (chr & (0x01 << 6) ? fg : bg); \
1636                                 pos[5] = (chr & (0x01 << 5) ? fg : bg); \
1637                                 pos[4] = (chr & (0x01 << 4) ? fg : bg); \
1638                                 pos[3] = (chr & (0x01 << 3) ? fg : bg); \
1639                                 pos[2] = (chr & (0x01 << 2) ? fg : bg); \
1640                                 pos[1] = (chr & (0x01 << 1) ? fg : bg); \
1641                                 pos[0] = (chr & (0x01 << 0) ? fg : bg); \
1642                         } else { \
1643                                 pos[0] = (chr & (0x01 << 7) ? fg : bg); \
1644                                 pos[1] = (chr & (0x01 << 6) ? fg : bg); \
1645                                 pos[2] = (chr & (0x01 << 5) ? fg : bg); \
1646                                 pos[3] = (chr & (0x01 << 4) ? fg : bg); \
1647                                 pos[4] = (chr & (0x01 << 3) ? fg : bg); \
1648                                 pos[5] = (chr & (0x01 << 2) ? fg : bg); \
1649                                 pos[6] = (chr & (0x01 << 1) ? fg : bg); \
1650                                 pos[7] = (chr & (0x01 << 0) ? fg : bg); \
1651                         } \
1652         \
1653                         pos += (tpg->hflip ? -8 : 8) / hdiv;    \
1654                 }       \
1655         }       \
1656 } while (0)
1657
1658 static noinline void tpg_print_str_2(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1659                         unsigned p, unsigned first, unsigned div, unsigned step,
1660                         int y, int x, char *text, unsigned len)
1661 {
1662         PRINTSTR(u8);
1663 }
1664
1665 static noinline void tpg_print_str_4(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1666                         unsigned p, unsigned first, unsigned div, unsigned step,
1667                         int y, int x, char *text, unsigned len)
1668 {
1669         PRINTSTR(u16);
1670 }
1671
1672 static noinline void tpg_print_str_6(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1673                         unsigned p, unsigned first, unsigned div, unsigned step,
1674                         int y, int x, char *text, unsigned len)
1675 {
1676         PRINTSTR(x24);
1677 }
1678
1679 static noinline void tpg_print_str_8(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1680                         unsigned p, unsigned first, unsigned div, unsigned step,
1681                         int y, int x, char *text, unsigned len)
1682 {
1683         PRINTSTR(u32);
1684 }
1685
1686 void tpg_gen_text(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1687                   int y, int x, char *text)
1688 {
1689         unsigned step = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
1690         unsigned div = step;
1691         unsigned first = 0;
1692         unsigned len = strlen(text);
1693         unsigned p;
1694
1695         if (font8x16 == NULL || basep == NULL)
1696                 return;
1697
1698         /* Checks if it is possible to show string */
1699         if (y + 16 >= tpg->compose.height || x + 8 >= tpg->compose.width)
1700                 return;
1701
1702         if (len > (tpg->compose.width - x) / 8)
1703                 len = (tpg->compose.width - x) / 8;
1704         if (tpg->vflip)
1705                 y = tpg->compose.height - y - 16;
1706         if (tpg->hflip)
1707                 x = tpg->compose.width - x - 8;
1708         y += tpg->compose.top;
1709         x += tpg->compose.left;
1710         if (tpg->field == V4L2_FIELD_BOTTOM)
1711                 first = 1;
1712         else if (tpg->field == V4L2_FIELD_SEQ_TB || tpg->field == V4L2_FIELD_SEQ_BT)
1713                 div = 2;
1714
1715         for (p = 0; p < tpg->planes; p++) {
1716                 /* Print text */
1717                 switch (tpg->twopixelsize[p]) {
1718                 case 2:
1719                         tpg_print_str_2(tpg, basep, p, first, div, step, y, x,
1720                                         text, len);
1721                         break;
1722                 case 4:
1723                         tpg_print_str_4(tpg, basep, p, first, div, step, y, x,
1724                                         text, len);
1725                         break;
1726                 case 6:
1727                         tpg_print_str_6(tpg, basep, p, first, div, step, y, x,
1728                                         text, len);
1729                         break;
1730                 case 8:
1731                         tpg_print_str_8(tpg, basep, p, first, div, step, y, x,
1732                                         text, len);
1733                         break;
1734                 }
1735         }
1736 }
1737 EXPORT_SYMBOL_GPL(tpg_gen_text);
1738
1739 void tpg_update_mv_step(struct tpg_data *tpg)
1740 {
1741         int factor = tpg->mv_hor_mode > TPG_MOVE_NONE ? -1 : 1;
1742
1743         if (tpg->hflip)
1744                 factor = -factor;
1745         switch (tpg->mv_hor_mode) {
1746         case TPG_MOVE_NEG_FAST:
1747         case TPG_MOVE_POS_FAST:
1748                 tpg->mv_hor_step = ((tpg->src_width + 319) / 320) * 4;
1749                 break;
1750         case TPG_MOVE_NEG:
1751         case TPG_MOVE_POS:
1752                 tpg->mv_hor_step = ((tpg->src_width + 639) / 640) * 4;
1753                 break;
1754         case TPG_MOVE_NEG_SLOW:
1755         case TPG_MOVE_POS_SLOW:
1756                 tpg->mv_hor_step = 2;
1757                 break;
1758         case TPG_MOVE_NONE:
1759                 tpg->mv_hor_step = 0;
1760                 break;
1761         }
1762         if (factor < 0)
1763                 tpg->mv_hor_step = tpg->src_width - tpg->mv_hor_step;
1764
1765         factor = tpg->mv_vert_mode > TPG_MOVE_NONE ? -1 : 1;
1766         switch (tpg->mv_vert_mode) {
1767         case TPG_MOVE_NEG_FAST:
1768         case TPG_MOVE_POS_FAST:
1769                 tpg->mv_vert_step = ((tpg->src_width + 319) / 320) * 4;
1770                 break;
1771         case TPG_MOVE_NEG:
1772         case TPG_MOVE_POS:
1773                 tpg->mv_vert_step = ((tpg->src_width + 639) / 640) * 4;
1774                 break;
1775         case TPG_MOVE_NEG_SLOW:
1776         case TPG_MOVE_POS_SLOW:
1777                 tpg->mv_vert_step = 1;
1778                 break;
1779         case TPG_MOVE_NONE:
1780                 tpg->mv_vert_step = 0;
1781                 break;
1782         }
1783         if (factor < 0)
1784                 tpg->mv_vert_step = tpg->src_height - tpg->mv_vert_step;
1785 }
1786 EXPORT_SYMBOL_GPL(tpg_update_mv_step);
1787
1788 /* Map the line number relative to the crop rectangle to a frame line number */
1789 static unsigned tpg_calc_frameline(const struct tpg_data *tpg, unsigned src_y,
1790                                     unsigned field)
1791 {
1792         switch (field) {
1793         case V4L2_FIELD_TOP:
1794                 return tpg->crop.top + src_y * 2;
1795         case V4L2_FIELD_BOTTOM:
1796                 return tpg->crop.top + src_y * 2 + 1;
1797         default:
1798                 return src_y + tpg->crop.top;
1799         }
1800 }
1801
1802 /*
1803  * Map the line number relative to the compose rectangle to a destination
1804  * buffer line number.
1805  */
1806 static unsigned tpg_calc_buffer_line(const struct tpg_data *tpg, unsigned y,
1807                                     unsigned field)
1808 {
1809         y += tpg->compose.top;
1810         switch (field) {
1811         case V4L2_FIELD_SEQ_TB:
1812                 if (y & 1)
1813                         return tpg->buf_height / 2 + y / 2;
1814                 return y / 2;
1815         case V4L2_FIELD_SEQ_BT:
1816                 if (y & 1)
1817                         return y / 2;
1818                 return tpg->buf_height / 2 + y / 2;
1819         default:
1820                 return y;
1821         }
1822 }
1823
1824 static void tpg_recalc(struct tpg_data *tpg)
1825 {
1826         if (tpg->recalc_colors) {
1827                 tpg->recalc_colors = false;
1828                 tpg->recalc_lines = true;
1829                 tpg->real_xfer_func = tpg->xfer_func;
1830                 tpg->real_ycbcr_enc = tpg->ycbcr_enc;
1831                 tpg->real_quantization = tpg->quantization;
1832
1833                 if (tpg->xfer_func == V4L2_XFER_FUNC_DEFAULT)
1834                         tpg->real_xfer_func =
1835                                 V4L2_MAP_XFER_FUNC_DEFAULT(tpg->colorspace);
1836
1837                 if (tpg->ycbcr_enc == V4L2_YCBCR_ENC_DEFAULT)
1838                         tpg->real_ycbcr_enc =
1839                                 V4L2_MAP_YCBCR_ENC_DEFAULT(tpg->colorspace);
1840
1841                 if (tpg->quantization == V4L2_QUANTIZATION_DEFAULT)
1842                         tpg->real_quantization =
1843                                 V4L2_MAP_QUANTIZATION_DEFAULT(!tpg->is_yuv,
1844                                         tpg->colorspace, tpg->real_ycbcr_enc);
1845
1846                 tpg_precalculate_colors(tpg);
1847         }
1848         if (tpg->recalc_square_border) {
1849                 tpg->recalc_square_border = false;
1850                 tpg_calculate_square_border(tpg);
1851         }
1852         if (tpg->recalc_lines) {
1853                 tpg->recalc_lines = false;
1854                 tpg_precalculate_line(tpg);
1855         }
1856 }
1857
1858 void tpg_calc_text_basep(struct tpg_data *tpg,
1859                 u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf)
1860 {
1861         unsigned stride = tpg->bytesperline[p];
1862         unsigned h = tpg->buf_height;
1863
1864         tpg_recalc(tpg);
1865
1866         basep[p][0] = vbuf;
1867         basep[p][1] = vbuf;
1868         h /= tpg->vdownsampling[p];
1869         if (tpg->field == V4L2_FIELD_SEQ_TB)
1870                 basep[p][1] += h * stride / 2;
1871         else if (tpg->field == V4L2_FIELD_SEQ_BT)
1872                 basep[p][0] += h * stride / 2;
1873         if (p == 0 && tpg->interleaved)
1874                 tpg_calc_text_basep(tpg, basep, 1, vbuf);
1875 }
1876 EXPORT_SYMBOL_GPL(tpg_calc_text_basep);
1877
1878 static int tpg_pattern_avg(const struct tpg_data *tpg,
1879                            unsigned pat1, unsigned pat2)
1880 {
1881         unsigned pat_lines = tpg_get_pat_lines(tpg);
1882
1883         if (pat1 == (pat2 + 1) % pat_lines)
1884                 return pat2;
1885         if (pat2 == (pat1 + 1) % pat_lines)
1886                 return pat1;
1887         return -1;
1888 }
1889
1890 void tpg_log_status(struct tpg_data *tpg)
1891 {
1892         pr_info("tpg source WxH: %ux%u (%s)\n",
1893                         tpg->src_width, tpg->src_height,
1894                         tpg->is_yuv ? "YCbCr" : "RGB");
1895         pr_info("tpg field: %u\n", tpg->field);
1896         pr_info("tpg crop: %ux%u@%dx%d\n", tpg->crop.width, tpg->crop.height,
1897                         tpg->crop.left, tpg->crop.top);
1898         pr_info("tpg compose: %ux%u@%dx%d\n", tpg->compose.width, tpg->compose.height,
1899                         tpg->compose.left, tpg->compose.top);
1900         pr_info("tpg colorspace: %d\n", tpg->colorspace);
1901         pr_info("tpg transfer function: %d/%d\n", tpg->xfer_func, tpg->real_xfer_func);
1902         pr_info("tpg Y'CbCr encoding: %d/%d\n", tpg->ycbcr_enc, tpg->real_ycbcr_enc);
1903         pr_info("tpg quantization: %d/%d\n", tpg->quantization, tpg->real_quantization);
1904         pr_info("tpg RGB range: %d/%d\n", tpg->rgb_range, tpg->real_rgb_range);
1905 }
1906 EXPORT_SYMBOL_GPL(tpg_log_status);
1907
1908 /*
1909  * This struct contains common parameters used by both the drawing of the
1910  * test pattern and the drawing of the extras (borders, square, etc.)
1911  */
1912 struct tpg_draw_params {
1913         /* common data */
1914         bool is_tv;
1915         bool is_60hz;
1916         unsigned twopixsize;
1917         unsigned img_width;
1918         unsigned stride;
1919         unsigned hmax;
1920         unsigned frame_line;
1921         unsigned frame_line_next;
1922
1923         /* test pattern */
1924         unsigned mv_hor_old;
1925         unsigned mv_hor_new;
1926         unsigned mv_vert_old;
1927         unsigned mv_vert_new;
1928
1929         /* extras */
1930         unsigned wss_width;
1931         unsigned wss_random_offset;
1932         unsigned sav_eav_f;
1933         unsigned left_pillar_width;
1934         unsigned right_pillar_start;
1935 };
1936
1937 static void tpg_fill_params_pattern(const struct tpg_data *tpg, unsigned p,
1938                                     struct tpg_draw_params *params)
1939 {
1940         params->mv_hor_old =
1941                 tpg_hscale_div(tpg, p, tpg->mv_hor_count % tpg->src_width);
1942         params->mv_hor_new =
1943                 tpg_hscale_div(tpg, p, (tpg->mv_hor_count + tpg->mv_hor_step) %
1944                                tpg->src_width);
1945         params->mv_vert_old = tpg->mv_vert_count % tpg->src_height;
1946         params->mv_vert_new =
1947                 (tpg->mv_vert_count + tpg->mv_vert_step) % tpg->src_height;
1948 }
1949
1950 static void tpg_fill_params_extras(const struct tpg_data *tpg,
1951                                    unsigned p,
1952                                    struct tpg_draw_params *params)
1953 {
1954         unsigned left_pillar_width = 0;
1955         unsigned right_pillar_start = params->img_width;
1956
1957         params->wss_width = tpg->crop.left < tpg->src_width / 2 ?
1958                 tpg->src_width / 2 - tpg->crop.left : 0;
1959         if (params->wss_width > tpg->crop.width)
1960                 params->wss_width = tpg->crop.width;
1961         params->wss_width = tpg_hscale_div(tpg, p, params->wss_width);
1962         params->wss_random_offset =
1963                 params->twopixsize * prandom_u32_max(tpg->src_width / 2);
1964
1965         if (tpg->crop.left < tpg->border.left) {
1966                 left_pillar_width = tpg->border.left - tpg->crop.left;
1967                 if (left_pillar_width > tpg->crop.width)
1968                         left_pillar_width = tpg->crop.width;
1969                 left_pillar_width = tpg_hscale_div(tpg, p, left_pillar_width);
1970         }
1971         params->left_pillar_width = left_pillar_width;
1972
1973         if (tpg->crop.left + tpg->crop.width >
1974             tpg->border.left + tpg->border.width) {
1975                 right_pillar_start =
1976                         tpg->border.left + tpg->border.width - tpg->crop.left;
1977                 right_pillar_start =
1978                         tpg_hscale_div(tpg, p, right_pillar_start);
1979                 if (right_pillar_start > params->img_width)
1980                         right_pillar_start = params->img_width;
1981         }
1982         params->right_pillar_start = right_pillar_start;
1983
1984         params->sav_eav_f = tpg->field ==
1985                         (params->is_60hz ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1986 }
1987
1988 static void tpg_fill_plane_extras(const struct tpg_data *tpg,
1989                                   const struct tpg_draw_params *params,
1990                                   unsigned p, unsigned h, u8 *vbuf)
1991 {
1992         unsigned twopixsize = params->twopixsize;
1993         unsigned img_width = params->img_width;
1994         unsigned frame_line = params->frame_line;
1995         const struct v4l2_rect *sq = &tpg->square;
1996         const struct v4l2_rect *b = &tpg->border;
1997         const struct v4l2_rect *c = &tpg->crop;
1998
1999         if (params->is_tv && !params->is_60hz &&
2000             frame_line == 0 && params->wss_width) {
2001                 /*
2002                  * Replace the first half of the top line of a 50 Hz frame
2003                  * with random data to simulate a WSS signal.
2004                  */
2005                 u8 *wss = tpg->random_line[p] + params->wss_random_offset;
2006
2007                 memcpy(vbuf, wss, params->wss_width);
2008         }
2009
2010         if (tpg->show_border && frame_line >= b->top &&
2011             frame_line < b->top + b->height) {
2012                 unsigned bottom = b->top + b->height - 1;
2013                 unsigned left = params->left_pillar_width;
2014                 unsigned right = params->right_pillar_start;
2015
2016                 if (frame_line == b->top || frame_line == b->top + 1 ||
2017                     frame_line == bottom || frame_line == bottom - 1) {
2018                         memcpy(vbuf + left, tpg->contrast_line[p],
2019                                         right - left);
2020                 } else {
2021                         if (b->left >= c->left &&
2022                             b->left < c->left + c->width)
2023                                 memcpy(vbuf + left,
2024                                         tpg->contrast_line[p], twopixsize);
2025                         if (b->left + b->width > c->left &&
2026                             b->left + b->width <= c->left + c->width)
2027                                 memcpy(vbuf + right - twopixsize,
2028                                         tpg->contrast_line[p], twopixsize);
2029                 }
2030         }
2031         if (tpg->qual != TPG_QUAL_NOISE && frame_line >= b->top &&
2032             frame_line < b->top + b->height) {
2033                 memcpy(vbuf, tpg->black_line[p], params->left_pillar_width);
2034                 memcpy(vbuf + params->right_pillar_start, tpg->black_line[p],
2035                        img_width - params->right_pillar_start);
2036         }
2037         if (tpg->show_square && frame_line >= sq->top &&
2038             frame_line < sq->top + sq->height &&
2039             sq->left < c->left + c->width &&
2040             sq->left + sq->width >= c->left) {
2041                 unsigned left = sq->left;
2042                 unsigned width = sq->width;
2043
2044                 if (c->left > left) {
2045                         width -= c->left - left;
2046                         left = c->left;
2047                 }
2048                 if (c->left + c->width < left + width)
2049                         width -= left + width - c->left - c->width;
2050                 left -= c->left;
2051                 left = tpg_hscale_div(tpg, p, left);
2052                 width = tpg_hscale_div(tpg, p, width);
2053                 memcpy(vbuf + left, tpg->contrast_line[p], width);
2054         }
2055         if (tpg->insert_sav) {
2056                 unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width / 3);
2057                 u8 *p = vbuf + offset;
2058                 unsigned vact = 0, hact = 0;
2059
2060                 p[0] = 0xff;
2061                 p[1] = 0;
2062                 p[2] = 0;
2063                 p[3] = 0x80 | (params->sav_eav_f << 6) |
2064                         (vact << 5) | (hact << 4) |
2065                         ((hact ^ vact) << 3) |
2066                         ((hact ^ params->sav_eav_f) << 2) |
2067                         ((params->sav_eav_f ^ vact) << 1) |
2068                         (hact ^ vact ^ params->sav_eav_f);
2069         }
2070         if (tpg->insert_eav) {
2071                 unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width * 2 / 3);
2072                 u8 *p = vbuf + offset;
2073                 unsigned vact = 0, hact = 1;
2074
2075                 p[0] = 0xff;
2076                 p[1] = 0;
2077                 p[2] = 0;
2078                 p[3] = 0x80 | (params->sav_eav_f << 6) |
2079                         (vact << 5) | (hact << 4) |
2080                         ((hact ^ vact) << 3) |
2081                         ((hact ^ params->sav_eav_f) << 2) |
2082                         ((params->sav_eav_f ^ vact) << 1) |
2083                         (hact ^ vact ^ params->sav_eav_f);
2084         }
2085 }
2086
2087 static void tpg_fill_plane_pattern(const struct tpg_data *tpg,
2088                                    const struct tpg_draw_params *params,
2089                                    unsigned p, unsigned h, u8 *vbuf)
2090 {
2091         unsigned twopixsize = params->twopixsize;
2092         unsigned img_width = params->img_width;
2093         unsigned mv_hor_old = params->mv_hor_old;
2094         unsigned mv_hor_new = params->mv_hor_new;
2095         unsigned mv_vert_old = params->mv_vert_old;
2096         unsigned mv_vert_new = params->mv_vert_new;
2097         unsigned frame_line = params->frame_line;
2098         unsigned frame_line_next = params->frame_line_next;
2099         unsigned line_offset = tpg_hscale_div(tpg, p, tpg->crop.left);
2100         bool even;
2101         bool fill_blank = false;
2102         unsigned pat_line_old;
2103         unsigned pat_line_new;
2104         u8 *linestart_older;
2105         u8 *linestart_newer;
2106         u8 *linestart_top;
2107         u8 *linestart_bottom;
2108
2109         even = !(frame_line & 1);
2110
2111         if (h >= params->hmax) {
2112                 if (params->hmax == tpg->compose.height)
2113                         return;
2114                 if (!tpg->perc_fill_blank)
2115                         return;
2116                 fill_blank = true;
2117         }
2118
2119         if (tpg->vflip) {
2120                 frame_line = tpg->src_height - frame_line - 1;
2121                 frame_line_next = tpg->src_height - frame_line_next - 1;
2122         }
2123
2124         if (fill_blank) {
2125                 linestart_older = tpg->contrast_line[p];
2126                 linestart_newer = tpg->contrast_line[p];
2127         } else if (tpg->qual != TPG_QUAL_NOISE &&
2128                    (frame_line < tpg->border.top ||
2129                     frame_line >= tpg->border.top + tpg->border.height)) {
2130                 linestart_older = tpg->black_line[p];
2131                 linestart_newer = tpg->black_line[p];
2132         } else if (tpg->pattern == TPG_PAT_NOISE || tpg->qual == TPG_QUAL_NOISE) {
2133                 linestart_older = tpg->random_line[p] +
2134                                   twopixsize * prandom_u32_max(tpg->src_width / 2);
2135                 linestart_newer = tpg->random_line[p] +
2136                                   twopixsize * prandom_u32_max(tpg->src_width / 2);
2137         } else {
2138                 unsigned frame_line_old =
2139                         (frame_line + mv_vert_old) % tpg->src_height;
2140                 unsigned frame_line_new =
2141                         (frame_line + mv_vert_new) % tpg->src_height;
2142                 unsigned pat_line_next_old;
2143                 unsigned pat_line_next_new;
2144
2145                 pat_line_old = tpg_get_pat_line(tpg, frame_line_old);
2146                 pat_line_new = tpg_get_pat_line(tpg, frame_line_new);
2147                 linestart_older = tpg->lines[pat_line_old][p] + mv_hor_old;
2148                 linestart_newer = tpg->lines[pat_line_new][p] + mv_hor_new;
2149
2150                 if (tpg->vdownsampling[p] > 1 && frame_line != frame_line_next) {
2151                         int avg_pat;
2152
2153                         /*
2154                          * Now decide whether we need to use downsampled_lines[].
2155                          * That's necessary if the two lines use different patterns.
2156                          */
2157                         pat_line_next_old = tpg_get_pat_line(tpg,
2158                                         (frame_line_next + mv_vert_old) % tpg->src_height);
2159                         pat_line_next_new = tpg_get_pat_line(tpg,
2160                                         (frame_line_next + mv_vert_new) % tpg->src_height);
2161
2162                         switch (tpg->field) {
2163                         case V4L2_FIELD_INTERLACED:
2164                         case V4L2_FIELD_INTERLACED_BT:
2165                         case V4L2_FIELD_INTERLACED_TB:
2166                                 avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_new);
2167                                 if (avg_pat < 0)
2168                                         break;
2169                                 linestart_older = tpg->downsampled_lines[avg_pat][p] + mv_hor_old;
2170                                 linestart_newer = linestart_older;
2171                                 break;
2172                         case V4L2_FIELD_NONE:
2173                         case V4L2_FIELD_TOP:
2174                         case V4L2_FIELD_BOTTOM:
2175                         case V4L2_FIELD_SEQ_BT:
2176                         case V4L2_FIELD_SEQ_TB:
2177                                 avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_next_old);
2178                                 if (avg_pat >= 0)
2179                                         linestart_older = tpg->downsampled_lines[avg_pat][p] +
2180                                                 mv_hor_old;
2181                                 avg_pat = tpg_pattern_avg(tpg, pat_line_new, pat_line_next_new);
2182                                 if (avg_pat >= 0)
2183                                         linestart_newer = tpg->downsampled_lines[avg_pat][p] +
2184                                                 mv_hor_new;
2185                                 break;
2186                         }
2187                 }
2188                 linestart_older += line_offset;
2189                 linestart_newer += line_offset;
2190         }
2191         if (tpg->field_alternate) {
2192                 linestart_top = linestart_bottom = linestart_older;
2193         } else if (params->is_60hz) {
2194                 linestart_top = linestart_newer;
2195                 linestart_bottom = linestart_older;
2196         } else {
2197                 linestart_top = linestart_older;
2198                 linestart_bottom = linestart_newer;
2199         }
2200
2201         switch (tpg->field) {
2202         case V4L2_FIELD_INTERLACED:
2203         case V4L2_FIELD_INTERLACED_TB:
2204         case V4L2_FIELD_SEQ_TB:
2205         case V4L2_FIELD_SEQ_BT:
2206                 if (even)
2207                         memcpy(vbuf, linestart_top, img_width);
2208                 else
2209                         memcpy(vbuf, linestart_bottom, img_width);
2210                 break;
2211         case V4L2_FIELD_INTERLACED_BT:
2212                 if (even)
2213                         memcpy(vbuf, linestart_bottom, img_width);
2214                 else
2215                         memcpy(vbuf, linestart_top, img_width);
2216                 break;
2217         case V4L2_FIELD_TOP:
2218                 memcpy(vbuf, linestart_top, img_width);
2219                 break;
2220         case V4L2_FIELD_BOTTOM:
2221                 memcpy(vbuf, linestart_bottom, img_width);
2222                 break;
2223         case V4L2_FIELD_NONE:
2224         default:
2225                 memcpy(vbuf, linestart_older, img_width);
2226                 break;
2227         }
2228 }
2229
2230 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
2231                            unsigned p, u8 *vbuf)
2232 {
2233         struct tpg_draw_params params;
2234         unsigned factor = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
2235
2236         /* Coarse scaling with Bresenham */
2237         unsigned int_part = (tpg->crop.height / factor) / tpg->compose.height;
2238         unsigned fract_part = (tpg->crop.height / factor) % tpg->compose.height;
2239         unsigned src_y = 0;
2240         unsigned error = 0;
2241         unsigned h;
2242
2243         tpg_recalc(tpg);
2244
2245         params.is_tv = std;
2246         params.is_60hz = std & V4L2_STD_525_60;
2247         params.twopixsize = tpg->twopixelsize[p];
2248         params.img_width = tpg_hdiv(tpg, p, tpg->compose.width);
2249         params.stride = tpg->bytesperline[p];
2250         params.hmax = (tpg->compose.height * tpg->perc_fill) / 100;
2251
2252         tpg_fill_params_pattern(tpg, p, &params);
2253         tpg_fill_params_extras(tpg, p, &params);
2254
2255         vbuf += tpg_hdiv(tpg, p, tpg->compose.left);
2256
2257         for (h = 0; h < tpg->compose.height; h++) {
2258                 unsigned buf_line;
2259
2260                 params.frame_line = tpg_calc_frameline(tpg, src_y, tpg->field);
2261                 params.frame_line_next = params.frame_line;
2262                 buf_line = tpg_calc_buffer_line(tpg, h, tpg->field);
2263                 src_y += int_part;
2264                 error += fract_part;
2265                 if (error >= tpg->compose.height) {
2266                         error -= tpg->compose.height;
2267                         src_y++;
2268                 }
2269
2270                 /*
2271                  * For line-interleaved formats determine the 'plane'
2272                  * based on the buffer line.
2273                  */
2274                 if (tpg_g_interleaved(tpg))
2275                         p = tpg_g_interleaved_plane(tpg, buf_line);
2276
2277                 if (tpg->vdownsampling[p] > 1) {
2278                         /*
2279                          * When doing vertical downsampling the field setting
2280                          * matters: for SEQ_BT/TB we downsample each field
2281                          * separately (i.e. lines 0+2 are combined, as are
2282                          * lines 1+3), for the other field settings we combine
2283                          * odd and even lines. Doing that for SEQ_BT/TB would
2284                          * be really weird.
2285                          */
2286                         if (tpg->field == V4L2_FIELD_SEQ_BT ||
2287                             tpg->field == V4L2_FIELD_SEQ_TB) {
2288                                 unsigned next_src_y = src_y;
2289
2290                                 if ((h & 3) >= 2)
2291                                         continue;
2292                                 next_src_y += int_part;
2293                                 if (error + fract_part >= tpg->compose.height)
2294                                         next_src_y++;
2295                                 params.frame_line_next =
2296                                         tpg_calc_frameline(tpg, next_src_y, tpg->field);
2297                         } else {
2298                                 if (h & 1)
2299                                         continue;
2300                                 params.frame_line_next =
2301                                         tpg_calc_frameline(tpg, src_y, tpg->field);
2302                         }
2303
2304                         buf_line /= tpg->vdownsampling[p];
2305                 }
2306                 tpg_fill_plane_pattern(tpg, &params, p, h,
2307                                 vbuf + buf_line * params.stride);
2308                 tpg_fill_plane_extras(tpg, &params, p, h,
2309                                 vbuf + buf_line * params.stride);
2310         }
2311 }
2312 EXPORT_SYMBOL_GPL(tpg_fill_plane_buffer);
2313
2314 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8 *vbuf)
2315 {
2316         unsigned offset = 0;
2317         unsigned i;
2318
2319         if (tpg->buffers > 1) {
2320                 tpg_fill_plane_buffer(tpg, std, p, vbuf);
2321                 return;
2322         }
2323
2324         for (i = 0; i < tpg_g_planes(tpg); i++) {
2325                 tpg_fill_plane_buffer(tpg, std, i, vbuf + offset);
2326                 offset += tpg_calc_plane_size(tpg, i);
2327         }
2328 }
2329 EXPORT_SYMBOL_GPL(tpg_fillbuffer);
2330
2331 MODULE_DESCRIPTION("V4L2 Test Pattern Generator");
2332 MODULE_AUTHOR("Hans Verkuil");
2333 MODULE_LICENSE("GPL");