1 /* 2 * Copyright 2008 Tungsten Graphics 3 * Jakob Bornecrantz <jakob (at) tungstengraphics.com> 4 * Copyright 2008 Intel Corporation 5 * Jesse Barnes <jesse.barnes (at) intel.com> 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 23 * IN THE SOFTWARE. 24 */ 25 26 #include <assert.h> 27 #include <stdbool.h> 28 #include <stdint.h> 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include <time.h> 33 34 #include <drm_fourcc.h> 35 36 #if HAVE_CAIRO 37 #include <cairo.h> 38 #include <math.h> 39 #endif 40 41 #include "common.h" 42 #include "format.h" 43 #include "pattern.h" 44 45 struct color_rgba { 46 uint16_t red; 47 uint16_t green; 48 uint16_t blue; 49 uint16_t alpha; 50 }; 51 52 struct color_rgb24 { 53 unsigned int value:24; 54 } __attribute__((__packed__)); 55 56 struct color_yuv { 57 unsigned char y; 58 unsigned char u; 59 unsigned char v; 60 }; 61 62 #define MAKE_YUV_601_Y(r, g, b) \ 63 ((( 66 * (r) + 129 * (g) + 25 * (b) + 128) >> 8) + 16) 64 #define MAKE_YUV_601_U(r, g, b) \ 65 (((-38 * (r) - 74 * (g) + 112 * (b) + 128) >> 8) + 128) 66 #define MAKE_YUV_601_V(r, g, b) \ 67 (((112 * (r) - 94 * (g) - 18 * (b) + 128) >> 8) + 128) 68 69 #define MAKE_YUV_601(r, g, b) \ 70 { .y = MAKE_YUV_601_Y(r, g, b), \ 71 .u = MAKE_YUV_601_U(r, g, b), \ 72 .v = MAKE_YUV_601_V(r, g, b) } 73 74 static inline uint16_t swap16(uint16_t x) 75 { 76 return ((x & 0x00ffU) << 8) | ((x & 0xff00U) >> 8); 77 } 78 79 static inline uint32_t swap32(uint32_t x) 80 { 81 return ((x & 0x000000ffU) << 24) | 82 ((x & 0x0000ff00U) << 8) | 83 ((x & 0x00ff0000U) >> 8) | 84 ((x & 0xff000000U) >> 24); 85 } 86 87 #ifdef HAVE_BIG_ENDIAN 88 #define cpu_to_be16(x) (x) 89 #define cpu_to_le16(x) swap16(x) 90 #define cpu_to_le32(x) swap32(x) 91 #define fb_foreign_endian(format) (!((format) & DRM_FORMAT_BIG_ENDIAN)) 92 #else 93 #define cpu_to_be16(x) swap16(x) 94 #define cpu_to_le16(x) (x) 95 #define cpu_to_le32(x) (x) 96 #define fb_foreign_endian(format) ((format) & DRM_FORMAT_BIG_ENDIAN) 97 #endif 98 99 #define cpu_to_fb16(x) (fb_be ? cpu_to_be16(x) : cpu_to_le16(x)) 100 101 /* This function takes 8-bit color values */ 102 static inline uint32_t shiftcolor8(const struct util_color_component *comp, 103 uint32_t value) 104 { 105 value &= 0xff; 106 /* Fill the low bits with the high bits. */ 107 value = (value << 8) | value; 108 /* Shift down to remove unwanted low bits */ 109 value = value >> (16 - comp->length); 110 /* Shift back up to where the value should be */ 111 return value << comp->offset; 112 } 113 114 /* This function takes 10-bit color values */ 115 static inline uint32_t shiftcolor10(const struct util_color_component *comp, 116 uint32_t value) 117 { 118 value &= 0x3ff; 119 /* Fill the low bits with the high bits. */ 120 value = (value << 6) | (value >> 4); 121 /* Shift down to remove unwanted low bits */ 122 value = value >> (16 - comp->length); 123 /* Shift back up to where the value should be */ 124 return value << comp->offset; 125 } 126 127 /* This function takes 16-bit color values */ 128 static inline uint64_t shiftcolor16(const struct util_color_component *comp, 129 uint64_t value) 130 { 131 value &= 0xffff; 132 /* Shift down to remove unwanted low bits */ 133 value = value >> (16 - comp->length); 134 /* Shift back up to where the value should be */ 135 return value << comp->offset; 136 } 137 138 #define MAKE_RGBA10(rgb, r, g, b, a) \ 139 (shiftcolor10(&(rgb)->red, (r)) | \ 140 shiftcolor10(&(rgb)->green, (g)) | \ 141 shiftcolor10(&(rgb)->blue, (b)) | \ 142 shiftcolor10(&(rgb)->alpha, (a))) 143 144 #define MAKE_RGBA(rgb, r, g, b, a) \ 145 (shiftcolor8(&(rgb)->red, (r)) | \ 146 shiftcolor8(&(rgb)->green, (g)) | \ 147 shiftcolor8(&(rgb)->blue, (b)) | \ 148 shiftcolor8(&(rgb)->alpha, (a))) 149 150 #define MAKE_RGB24(rgb, r, g, b) \ 151 { .value = MAKE_RGBA(rgb, r, g, b, 0) } 152 153 154 /** 155 * Takes a uint16_t, divides by 65536, converts the infinite-precision 156 * result to fp16 with round-to-zero. 157 * 158 * Copied from mesa:src/util/half_float.c 159 */ 160 static uint16_t uint16_div_64k_to_half(uint16_t v) 161 { 162 /* Zero or subnormal. Set the mantissa to (v << 8) and return. */ 163 if (v < 4) 164 return v << 8; 165 166 /* Count the leading 0s in the uint16_t */ 167 int n = __builtin_clz(v) - 16; 168 169 /* Shift the mantissa up so bit 16 is the hidden 1 bit, 170 * mask it off, then shift back down to 10 bits 171 */ 172 int m = ( ((uint32_t)v << (n + 1)) & 0xffff ) >> 6; 173 174 /* (0{n} 1 X{15-n}) * 2^-16 175 * = 1.X * 2^(15-n-16) 176 * = 1.X * 2^(14-n - 15) 177 * which is the FP16 form with e = 14 - n 178 */ 179 int e = 14 - n; 180 181 return (e << 10) | m; 182 } 183 184 #define MAKE_RGBA8FP16(rgb, r, g, b, a) \ 185 (shiftcolor16(&(rgb)->red, uint16_div_64k_to_half((r) << 8)) | \ 186 shiftcolor16(&(rgb)->green, uint16_div_64k_to_half((g) << 8)) | \ 187 shiftcolor16(&(rgb)->blue, uint16_div_64k_to_half((b) << 8)) | \ 188 shiftcolor16(&(rgb)->alpha, uint16_div_64k_to_half((a) << 8))) 189 190 #define MAKE_RGBA10FP16(rgb, r, g, b, a) \ 191 (shiftcolor16(&(rgb)->red, uint16_div_64k_to_half((r) << 6)) | \ 192 shiftcolor16(&(rgb)->green, uint16_div_64k_to_half((g) << 6)) | \ 193 shiftcolor16(&(rgb)->blue, uint16_div_64k_to_half((b) << 6)) | \ 194 shiftcolor16(&(rgb)->alpha, uint16_div_64k_to_half((a) << 6))) 195 196 static void fill_smpte_yuv_planar(const struct util_yuv_info *yuv, 197 unsigned char *y_mem, unsigned char *u_mem, 198 unsigned char *v_mem, unsigned int width, 199 unsigned int height, unsigned int stride) 200 { 201 const struct color_yuv colors_top[] = { 202 MAKE_YUV_601(192, 192, 192), /* grey */ 203 MAKE_YUV_601(192, 192, 0), /* yellow */ 204 MAKE_YUV_601(0, 192, 192), /* cyan */ 205 MAKE_YUV_601(0, 192, 0), /* green */ 206 MAKE_YUV_601(192, 0, 192), /* magenta */ 207 MAKE_YUV_601(192, 0, 0), /* red */ 208 MAKE_YUV_601(0, 0, 192), /* blue */ 209 }; 210 const struct color_yuv colors_middle[] = { 211 MAKE_YUV_601(0, 0, 192), /* blue */ 212 MAKE_YUV_601(19, 19, 19), /* black */ 213 MAKE_YUV_601(192, 0, 192), /* magenta */ 214 MAKE_YUV_601(19, 19, 19), /* black */ 215 MAKE_YUV_601(0, 192, 192), /* cyan */ 216 MAKE_YUV_601(19, 19, 19), /* black */ 217 MAKE_YUV_601(192, 192, 192), /* grey */ 218 }; 219 const struct color_yuv colors_bottom[] = { 220 MAKE_YUV_601(0, 33, 76), /* in-phase */ 221 MAKE_YUV_601(255, 255, 255), /* super white */ 222 MAKE_YUV_601(50, 0, 106), /* quadrature */ 223 MAKE_YUV_601(19, 19, 19), /* black */ 224 MAKE_YUV_601(9, 9, 9), /* 3.5% */ 225 MAKE_YUV_601(19, 19, 19), /* 7.5% */ 226 MAKE_YUV_601(29, 29, 29), /* 11.5% */ 227 MAKE_YUV_601(19, 19, 19), /* black */ 228 }; 229 unsigned int cs = yuv->chroma_stride; 230 unsigned int xsub = yuv->xsub; 231 unsigned int ysub = yuv->ysub; 232 unsigned int x; 233 unsigned int y; 234 235 /* Luma */ 236 for (y = 0; y < height * 6 / 9; ++y) { 237 for (x = 0; x < width; ++x) 238 y_mem[x] = colors_top[x * 7 / width].y; 239 y_mem += stride; 240 } 241 242 for (; y < height * 7 / 9; ++y) { 243 for (x = 0; x < width; ++x) 244 y_mem[x] = colors_middle[x * 7 / width].y; 245 y_mem += stride; 246 } 247 248 for (; y < height; ++y) { 249 for (x = 0; x < width * 5 / 7; ++x) 250 y_mem[x] = colors_bottom[x * 4 / (width * 5 / 7)].y; 251 for (; x < width * 6 / 7; ++x) 252 y_mem[x] = colors_bottom[(x - width * 5 / 7) * 3 253 / (width / 7) + 4].y; 254 for (; x < width; ++x) 255 y_mem[x] = colors_bottom[7].y; 256 y_mem += stride; 257 } 258 259 /* Chroma */ 260 for (y = 0; y < height / ysub * 6 / 9; ++y) { 261 for (x = 0; x < width; x += xsub) { 262 u_mem[x*cs/xsub] = colors_top[x * 7 / width].u; 263 v_mem[x*cs/xsub] = colors_top[x * 7 / width].v; 264 } 265 u_mem += stride * cs / xsub; 266 v_mem += stride * cs / xsub; 267 } 268 269 for (; y < height / ysub * 7 / 9; ++y) { 270 for (x = 0; x < width; x += xsub) { 271 u_mem[x*cs/xsub] = colors_middle[x * 7 / width].u; 272 v_mem[x*cs/xsub] = colors_middle[x * 7 / width].v; 273 } 274 u_mem += stride * cs / xsub; 275 v_mem += stride * cs / xsub; 276 } 277 278 for (; y < height / ysub; ++y) { 279 for (x = 0; x < width * 5 / 7; x += xsub) { 280 u_mem[x*cs/xsub] = 281 colors_bottom[x * 4 / (width * 5 / 7)].u; 282 v_mem[x*cs/xsub] = 283 colors_bottom[x * 4 / (width * 5 / 7)].v; 284 } 285 for (; x < width * 6 / 7; x += xsub) { 286 u_mem[x*cs/xsub] = colors_bottom[(x - width * 5 / 7) * 287 3 / (width / 7) + 4].u; 288 v_mem[x*cs/xsub] = colors_bottom[(x - width * 5 / 7) * 289 3 / (width / 7) + 4].v; 290 } 291 for (; x < width; x += xsub) { 292 u_mem[x*cs/xsub] = colors_bottom[7].u; 293 v_mem[x*cs/xsub] = colors_bottom[7].v; 294 } 295 u_mem += stride * cs / xsub; 296 v_mem += stride * cs / xsub; 297 } 298 } 299 300 static void write_pixels_10bpp(unsigned char *mem, 301 unsigned short a, 302 unsigned short b, 303 unsigned short c, 304 unsigned short d) 305 { 306 mem[0] = (a & 0xff); 307 mem[1] = ((a >> 8) & 0x3) | ((b & 0x3f) << 2); 308 mem[2] = ((b >> 6) & 0xf) | ((c & 0xf) << 4); 309 mem[3] = ((c >> 4) & 0x3f) | ((d & 0x3) << 6); 310 mem[4] = ((d >> 2) & 0xff); 311 } 312 313 static void update_pixels_10bpp(unsigned char *mem, uint64_t val, uint64_t mask) 314 { 315 int i; 316 317 for (i = 0; i < 5; i++, mask >>= 8, val >>= 8) { 318 mem[i] &= ~(mask & 0xff); 319 mem[i] |= (mask & 0xff) & val; 320 } 321 } 322 323 static void fill_smpte_yuv_planar_10bpp(const struct util_yuv_info *yuv, 324 unsigned char *y_mem, 325 unsigned char *uv_mem, 326 unsigned int width, 327 unsigned int height, 328 unsigned int stride) 329 { 330 const struct color_yuv colors_top[] = { 331 MAKE_YUV_601(192, 192, 192), /* grey */ 332 MAKE_YUV_601(192, 192, 0), /* yellow */ 333 MAKE_YUV_601(0, 192, 192), /* cyan */ 334 MAKE_YUV_601(0, 192, 0), /* green */ 335 MAKE_YUV_601(192, 0, 192), /* magenta */ 336 MAKE_YUV_601(192, 0, 0), /* red */ 337 MAKE_YUV_601(0, 0, 192), /* blue */ 338 }; 339 const struct color_yuv colors_middle[] = { 340 MAKE_YUV_601(0, 0, 192), /* blue */ 341 MAKE_YUV_601(19, 19, 19), /* black */ 342 MAKE_YUV_601(192, 0, 192), /* magenta */ 343 MAKE_YUV_601(19, 19, 19), /* black */ 344 MAKE_YUV_601(0, 192, 192), /* cyan */ 345 MAKE_YUV_601(19, 19, 19), /* black */ 346 MAKE_YUV_601(192, 192, 192), /* grey */ 347 }; 348 const struct color_yuv colors_bottom[] = { 349 MAKE_YUV_601(0, 33, 76), /* in-phase */ 350 MAKE_YUV_601(255, 255, 255), /* super white */ 351 MAKE_YUV_601(50, 0, 106), /* quadrature */ 352 MAKE_YUV_601(19, 19, 19), /* black */ 353 MAKE_YUV_601(9, 9, 9), /* 3.5% */ 354 MAKE_YUV_601(19, 19, 19), /* 7.5% */ 355 MAKE_YUV_601(29, 29, 29), /* 11.5% */ 356 MAKE_YUV_601(19, 19, 19), /* black */ 357 }; 358 unsigned int cs = yuv->chroma_stride; 359 unsigned int xsub = yuv->xsub; 360 unsigned int ysub = yuv->ysub; 361 unsigned int xstep = cs * xsub; 362 unsigned int x; 363 unsigned int y; 364 365 /* Luma */ 366 for (y = 0; y < height * 6 / 9; ++y) { 367 for (x = 0; x < width; x += 4) 368 write_pixels_10bpp(&y_mem[(x * 5) / 4], 369 colors_top[(x+0) * 7 / width].y << 2, 370 colors_top[(x+1) * 7 / width].y << 2, 371 colors_top[(x+2) * 7 / width].y << 2, 372 colors_top[(x+3) * 7 / width].y << 2); 373 y_mem += stride; 374 } 375 376 for (; y < height * 7 / 9; ++y) { 377 for (x = 0; x < width; x += 4) 378 write_pixels_10bpp(&y_mem[(x * 5) / 4], 379 colors_middle[(x+0) * 7 / width].y << 2, 380 colors_middle[(x+1) * 7 / width].y << 2, 381 colors_middle[(x+2) * 7 / width].y << 2, 382 colors_middle[(x+3) * 7 / width].y << 2); 383 y_mem += stride; 384 } 385 386 for (; y < height; ++y) { 387 for (x = 0; x < width * 5 / 7; x += 4) 388 write_pixels_10bpp(&y_mem[(x * 5) / 4], 389 colors_bottom[(x+0) * 4 / (width * 5 / 7)].y << 2, 390 colors_bottom[(x+1) * 4 / (width * 5 / 7)].y << 2, 391 colors_bottom[(x+2) * 4 / (width * 5 / 7)].y << 2, 392 colors_bottom[(x+3) * 4 / (width * 5 / 7)].y << 2); 393 for (; x < width * 6 / 7; x += 4) 394 write_pixels_10bpp(&y_mem[(x * 5) / 4], 395 colors_bottom[((x+0) - width * 5 / 7) * 3 / (width / 7) + 4].y << 2, 396 colors_bottom[((x+1) - width * 5 / 7) * 3 / (width / 7) + 4].y << 2, 397 colors_bottom[((x+2) - width * 5 / 7) * 3 / (width / 7) + 4].y << 2, 398 colors_bottom[((x+3) - width * 5 / 7) * 3 / (width / 7) + 4].y << 2); 399 for (; x < width; x += 4) 400 write_pixels_10bpp(&y_mem[(x * 5) / 4], 401 colors_bottom[7].y << 2, 402 colors_bottom[7].y << 2, 403 colors_bottom[7].y << 2, 404 colors_bottom[7].y << 2); 405 y_mem += stride; 406 } 407 408 /* Chroma */ 409 for (y = 0; y < height * 6 / 9; y += ysub) { 410 for (x = 0; x < width; x += xstep) 411 write_pixels_10bpp(&uv_mem[(x * 5) / xstep], 412 colors_top[(x+0) * 7 / width].u << 2, 413 colors_top[(x+0) * 7 / width].v << 2, 414 colors_top[(x+xsub) * 7 / width].u << 2, 415 colors_top[(x+xsub) * 7 / width].v << 2); 416 uv_mem += stride * cs / xsub; 417 } 418 419 for (; y < height * 7 / 9; y += ysub) { 420 for (x = 0; x < width; x += xstep) 421 write_pixels_10bpp(&uv_mem[(x * 5) / xstep], 422 colors_middle[(x+0) * 7 / width].u << 2, 423 colors_middle[(x+0) * 7 / width].v << 2, 424 colors_middle[(x+xsub) * 7 / width].u << 2, 425 colors_middle[(x+xsub) * 7 / width].v << 2); 426 uv_mem += stride * cs / xsub; 427 } 428 429 for (; y < height; y += ysub) { 430 for (x = 0; x < width * 5 / 7; x += xstep) 431 write_pixels_10bpp(&uv_mem[(x * 5) / xstep], 432 colors_bottom[(x+0) * 4 / (width * 5 / 7)].u << 2, 433 colors_bottom[(x+0) * 4 / (width * 5 / 7)].v << 2, 434 colors_bottom[(x+xsub) * 4 / (width * 5 / 7)].u << 2, 435 colors_bottom[(x+xsub) * 4 / (width * 5 / 7)].v << 2); 436 for (; x < width * 6 / 7; x += xstep) 437 write_pixels_10bpp(&uv_mem[(x * 5) / xstep], 438 colors_bottom[((x+0) - width * 5 / 7) * 3 / (width / 7) + 4].u << 2, 439 colors_bottom[((x+0) - width * 5 / 7) * 3 / (width / 7) + 4].v << 2, 440 colors_bottom[((x+xsub) - width * 5 / 7) * 3 / (width / 7) + 4].u << 2, 441 colors_bottom[((x+xsub) - width * 5 / 7) * 3 / (width / 7) + 4].v << 2); 442 for (; x < width; x += xstep) 443 write_pixels_10bpp(&uv_mem[(x * 5) / xstep], 444 colors_bottom[7].u << 2, 445 colors_bottom[7].v << 2, 446 colors_bottom[7].u << 2, 447 colors_bottom[7].v << 2); 448 uv_mem += stride * cs / xsub; 449 } 450 } 451 452 static void fill_smpte_yuv_packed(const struct util_yuv_info *yuv, void *mem, 453 unsigned int width, unsigned int height, 454 unsigned int stride) 455 { 456 const struct color_yuv colors_top[] = { 457 MAKE_YUV_601(192, 192, 192), /* grey */ 458 MAKE_YUV_601(192, 192, 0), /* yellow */ 459 MAKE_YUV_601(0, 192, 192), /* cyan */ 460 MAKE_YUV_601(0, 192, 0), /* green */ 461 MAKE_YUV_601(192, 0, 192), /* magenta */ 462 MAKE_YUV_601(192, 0, 0), /* red */ 463 MAKE_YUV_601(0, 0, 192), /* blue */ 464 }; 465 const struct color_yuv colors_middle[] = { 466 MAKE_YUV_601(0, 0, 192), /* blue */ 467 MAKE_YUV_601(19, 19, 19), /* black */ 468 MAKE_YUV_601(192, 0, 192), /* magenta */ 469 MAKE_YUV_601(19, 19, 19), /* black */ 470 MAKE_YUV_601(0, 192, 192), /* cyan */ 471 MAKE_YUV_601(19, 19, 19), /* black */ 472 MAKE_YUV_601(192, 192, 192), /* grey */ 473 }; 474 const struct color_yuv colors_bottom[] = { 475 MAKE_YUV_601(0, 33, 76), /* in-phase */ 476 MAKE_YUV_601(255, 255, 255), /* super white */ 477 MAKE_YUV_601(50, 0, 106), /* quadrature */ 478 MAKE_YUV_601(19, 19, 19), /* black */ 479 MAKE_YUV_601(9, 9, 9), /* 3.5% */ 480 MAKE_YUV_601(19, 19, 19), /* 7.5% */ 481 MAKE_YUV_601(29, 29, 29), /* 11.5% */ 482 MAKE_YUV_601(19, 19, 19), /* black */ 483 }; 484 unsigned char *y_mem = (yuv->order & YUV_YC) ? mem : mem + 1; 485 unsigned char *c_mem = (yuv->order & YUV_CY) ? mem : mem + 1; 486 unsigned int u = (yuv->order & YUV_YCrCb) ? 2 : 0; 487 unsigned int v = (yuv->order & YUV_YCbCr) ? 2 : 0; 488 unsigned int x; 489 unsigned int y; 490 491 /* Luma */ 492 for (y = 0; y < height * 6 / 9; ++y) { 493 for (x = 0; x < width; ++x) 494 y_mem[2*x] = colors_top[x * 7 / width].y; 495 y_mem += stride; 496 } 497 498 for (; y < height * 7 / 9; ++y) { 499 for (x = 0; x < width; ++x) 500 y_mem[2*x] = colors_middle[x * 7 / width].y; 501 y_mem += stride; 502 } 503 504 for (; y < height; ++y) { 505 for (x = 0; x < width * 5 / 7; ++x) 506 y_mem[2*x] = colors_bottom[x * 4 / (width * 5 / 7)].y; 507 for (; x < width * 6 / 7; ++x) 508 y_mem[2*x] = colors_bottom[(x - width * 5 / 7) * 3 509 / (width / 7) + 4].y; 510 for (; x < width; ++x) 511 y_mem[2*x] = colors_bottom[7].y; 512 y_mem += stride; 513 } 514 515 /* Chroma */ 516 for (y = 0; y < height * 6 / 9; ++y) { 517 for (x = 0; x < width; x += 2) { 518 c_mem[2*x+u] = colors_top[x * 7 / width].u; 519 c_mem[2*x+v] = colors_top[x * 7 / width].v; 520 } 521 c_mem += stride; 522 } 523 524 for (; y < height * 7 / 9; ++y) { 525 for (x = 0; x < width; x += 2) { 526 c_mem[2*x+u] = colors_middle[x * 7 / width].u; 527 c_mem[2*x+v] = colors_middle[x * 7 / width].v; 528 } 529 c_mem += stride; 530 } 531 532 for (; y < height; ++y) { 533 for (x = 0; x < width * 5 / 7; x += 2) { 534 c_mem[2*x+u] = colors_bottom[x * 4 / (width * 5 / 7)].u; 535 c_mem[2*x+v] = colors_bottom[x * 4 / (width * 5 / 7)].v; 536 } 537 for (; x < width * 6 / 7; x += 2) { 538 c_mem[2*x+u] = colors_bottom[(x - width * 5 / 7) * 539 3 / (width / 7) + 4].u; 540 c_mem[2*x+v] = colors_bottom[(x - width * 5 / 7) * 541 3 / (width / 7) + 4].v; 542 } 543 for (; x < width; x += 2) { 544 c_mem[2*x+u] = colors_bottom[7].u; 545 c_mem[2*x+v] = colors_bottom[7].v; 546 } 547 c_mem += stride; 548 } 549 } 550 551 static void fill_smpte_rgb16(const struct util_rgb_info *rgb, void *mem, 552 unsigned int width, unsigned int height, 553 unsigned int stride, bool fb_be) 554 { 555 const uint16_t colors_top[] = { 556 MAKE_RGBA(rgb, 192, 192, 192, 255), /* grey */ 557 MAKE_RGBA(rgb, 192, 192, 0, 255), /* yellow */ 558 MAKE_RGBA(rgb, 0, 192, 192, 255), /* cyan */ 559 MAKE_RGBA(rgb, 0, 192, 0, 255), /* green */ 560 MAKE_RGBA(rgb, 192, 0, 192, 255), /* magenta */ 561 MAKE_RGBA(rgb, 192, 0, 0, 255), /* red */ 562 MAKE_RGBA(rgb, 0, 0, 192, 255), /* blue */ 563 }; 564 const uint16_t colors_middle[] = { 565 MAKE_RGBA(rgb, 0, 0, 192, 127), /* blue */ 566 MAKE_RGBA(rgb, 19, 19, 19, 127), /* black */ 567 MAKE_RGBA(rgb, 192, 0, 192, 127), /* magenta */ 568 MAKE_RGBA(rgb, 19, 19, 19, 127), /* black */ 569 MAKE_RGBA(rgb, 0, 192, 192, 127), /* cyan */ 570 MAKE_RGBA(rgb, 19, 19, 19, 127), /* black */ 571 MAKE_RGBA(rgb, 192, 192, 192, 127), /* grey */ 572 }; 573 const uint16_t colors_bottom[] = { 574 MAKE_RGBA(rgb, 0, 33, 76, 255), /* in-phase */ 575 MAKE_RGBA(rgb, 255, 255, 255, 255), /* super white */ 576 MAKE_RGBA(rgb, 50, 0, 106, 255), /* quadrature */ 577 MAKE_RGBA(rgb, 19, 19, 19, 255), /* black */ 578 MAKE_RGBA(rgb, 9, 9, 9, 255), /* 3.5% */ 579 MAKE_RGBA(rgb, 19, 19, 19, 255), /* 7.5% */ 580 MAKE_RGBA(rgb, 29, 29, 29, 255), /* 11.5% */ 581 MAKE_RGBA(rgb, 19, 19, 19, 255), /* black */ 582 }; 583 unsigned int x; 584 unsigned int y; 585 586 for (y = 0; y < height * 6 / 9; ++y) { 587 for (x = 0; x < width; ++x) 588 ((uint16_t *)mem)[x] = cpu_to_fb16(colors_top[x * 7 / width]); 589 mem += stride; 590 } 591 592 for (; y < height * 7 / 9; ++y) { 593 for (x = 0; x < width; ++x) 594 ((uint16_t *)mem)[x] = cpu_to_fb16(colors_middle[x * 7 / width]); 595 mem += stride; 596 } 597 598 for (; y < height; ++y) { 599 for (x = 0; x < width * 5 / 7; ++x) 600 ((uint16_t *)mem)[x] = 601 cpu_to_fb16(colors_bottom[x * 4 / (width * 5 / 7)]); 602 for (; x < width * 6 / 7; ++x) 603 ((uint16_t *)mem)[x] = 604 cpu_to_fb16(colors_bottom[(x - width * 5 / 7) * 3 605 / (width / 7) + 4]); 606 for (; x < width; ++x) 607 ((uint16_t *)mem)[x] = cpu_to_fb16(colors_bottom[7]); 608 mem += stride; 609 } 610 } 611 612 static void fill_smpte_rgb24(const struct util_rgb_info *rgb, void *mem, 613 unsigned int width, unsigned int height, 614 unsigned int stride) 615 { 616 const struct color_rgb24 colors_top[] = { 617 MAKE_RGB24(rgb, 192, 192, 192), /* grey */ 618 MAKE_RGB24(rgb, 192, 192, 0), /* yellow */ 619 MAKE_RGB24(rgb, 0, 192, 192), /* cyan */ 620 MAKE_RGB24(rgb, 0, 192, 0), /* green */ 621 MAKE_RGB24(rgb, 192, 0, 192), /* magenta */ 622 MAKE_RGB24(rgb, 192, 0, 0), /* red */ 623 MAKE_RGB24(rgb, 0, 0, 192), /* blue */ 624 }; 625 const struct color_rgb24 colors_middle[] = { 626 MAKE_RGB24(rgb, 0, 0, 192), /* blue */ 627 MAKE_RGB24(rgb, 19, 19, 19), /* black */ 628 MAKE_RGB24(rgb, 192, 0, 192), /* magenta */ 629 MAKE_RGB24(rgb, 19, 19, 19), /* black */ 630 MAKE_RGB24(rgb, 0, 192, 192), /* cyan */ 631 MAKE_RGB24(rgb, 19, 19, 19), /* black */ 632 MAKE_RGB24(rgb, 192, 192, 192), /* grey */ 633 }; 634 const struct color_rgb24 colors_bottom[] = { 635 MAKE_RGB24(rgb, 0, 33, 76), /* in-phase */ 636 MAKE_RGB24(rgb, 255, 255, 255), /* super white */ 637 MAKE_RGB24(rgb, 50, 0, 106), /* quadrature */ 638 MAKE_RGB24(rgb, 19, 19, 19), /* black */ 639 MAKE_RGB24(rgb, 9, 9, 9), /* 3.5% */ 640 MAKE_RGB24(rgb, 19, 19, 19), /* 7.5% */ 641 MAKE_RGB24(rgb, 29, 29, 29), /* 11.5% */ 642 MAKE_RGB24(rgb, 19, 19, 19), /* black */ 643 }; 644 unsigned int x; 645 unsigned int y; 646 647 for (y = 0; y < height * 6 / 9; ++y) { 648 for (x = 0; x < width; ++x) 649 ((struct color_rgb24 *)mem)[x] = 650 colors_top[x * 7 / width]; 651 mem += stride; 652 } 653 654 for (; y < height * 7 / 9; ++y) { 655 for (x = 0; x < width; ++x) 656 ((struct color_rgb24 *)mem)[x] = 657 colors_middle[x * 7 / width]; 658 mem += stride; 659 } 660 661 for (; y < height; ++y) { 662 for (x = 0; x < width * 5 / 7; ++x) 663 ((struct color_rgb24 *)mem)[x] = 664 colors_bottom[x * 4 / (width * 5 / 7)]; 665 for (; x < width * 6 / 7; ++x) 666 ((struct color_rgb24 *)mem)[x] = 667 colors_bottom[(x - width * 5 / 7) * 3 668 / (width / 7) + 4]; 669 for (; x < width; ++x) 670 ((struct color_rgb24 *)mem)[x] = colors_bottom[7]; 671 mem += stride; 672 } 673 } 674 675 static void fill_smpte_rgb32(const struct util_rgb_info *rgb, void *mem, 676 unsigned int width, unsigned int height, 677 unsigned int stride) 678 { 679 const uint32_t colors_top[] = { 680 MAKE_RGBA(rgb, 192, 192, 192, 255), /* grey */ 681 MAKE_RGBA(rgb, 192, 192, 0, 255), /* yellow */ 682 MAKE_RGBA(rgb, 0, 192, 192, 255), /* cyan */ 683 MAKE_RGBA(rgb, 0, 192, 0, 255), /* green */ 684 MAKE_RGBA(rgb, 192, 0, 192, 255), /* magenta */ 685 MAKE_RGBA(rgb, 192, 0, 0, 255), /* red */ 686 MAKE_RGBA(rgb, 0, 0, 192, 255), /* blue */ 687 }; 688 const uint32_t colors_middle[] = { 689 MAKE_RGBA(rgb, 0, 0, 192, 127), /* blue */ 690 MAKE_RGBA(rgb, 19, 19, 19, 127), /* black */ 691 MAKE_RGBA(rgb, 192, 0, 192, 127), /* magenta */ 692 MAKE_RGBA(rgb, 19, 19, 19, 127), /* black */ 693 MAKE_RGBA(rgb, 0, 192, 192, 127), /* cyan */ 694 MAKE_RGBA(rgb, 19, 19, 19, 127), /* black */ 695 MAKE_RGBA(rgb, 192, 192, 192, 127), /* grey */ 696 }; 697 const uint32_t colors_bottom[] = { 698 MAKE_RGBA(rgb, 0, 33, 76, 255), /* in-phase */ 699 MAKE_RGBA(rgb, 255, 255, 255, 255), /* super white */ 700 MAKE_RGBA(rgb, 50, 0, 106, 255), /* quadrature */ 701 MAKE_RGBA(rgb, 19, 19, 19, 255), /* black */ 702 MAKE_RGBA(rgb, 9, 9, 9, 255), /* 3.5% */ 703 MAKE_RGBA(rgb, 19, 19, 19, 255), /* 7.5% */ 704 MAKE_RGBA(rgb, 29, 29, 29, 255), /* 11.5% */ 705 MAKE_RGBA(rgb, 19, 19, 19, 255), /* black */ 706 }; 707 unsigned int x; 708 unsigned int y; 709 710 for (y = 0; y < height * 6 / 9; ++y) { 711 for (x = 0; x < width; ++x) 712 ((uint32_t *)mem)[x] = cpu_to_le32(colors_top[x * 7 / width]); 713 mem += stride; 714 } 715 716 for (; y < height * 7 / 9; ++y) { 717 for (x = 0; x < width; ++x) 718 ((uint32_t *)mem)[x] = cpu_to_le32(colors_middle[x * 7 / width]); 719 mem += stride; 720 } 721 722 for (; y < height; ++y) { 723 for (x = 0; x < width * 5 / 7; ++x) 724 ((uint32_t *)mem)[x] = 725 cpu_to_le32(colors_bottom[x * 4 / (width * 5 / 7)]); 726 for (; x < width * 6 / 7; ++x) 727 ((uint32_t *)mem)[x] = 728 cpu_to_le32(colors_bottom[(x - width * 5 / 7) * 3 729 / (width / 7) + 4]); 730 for (; x < width; ++x) 731 ((uint32_t *)mem)[x] = cpu_to_le32(colors_bottom[7]); 732 mem += stride; 733 } 734 } 735 736 static void fill_smpte_rgb16fp(const struct util_rgb_info *rgb, void *mem, 737 unsigned int width, unsigned int height, 738 unsigned int stride) 739 { 740 const uint64_t colors_top[] = { 741 MAKE_RGBA8FP16(rgb, 192, 192, 192, 255),/* grey */ 742 MAKE_RGBA8FP16(rgb, 192, 192, 0, 255), /* yellow */ 743 MAKE_RGBA8FP16(rgb, 0, 192, 192, 255), /* cyan */ 744 MAKE_RGBA8FP16(rgb, 0, 192, 0, 255), /* green */ 745 MAKE_RGBA8FP16(rgb, 192, 0, 192, 255), /* magenta */ 746 MAKE_RGBA8FP16(rgb, 192, 0, 0, 255), /* red */ 747 MAKE_RGBA8FP16(rgb, 0, 0, 192, 255), /* blue */ 748 }; 749 const uint64_t colors_middle[] = { 750 MAKE_RGBA8FP16(rgb, 0, 0, 192, 127), /* blue */ 751 MAKE_RGBA8FP16(rgb, 19, 19, 19, 127), /* black */ 752 MAKE_RGBA8FP16(rgb, 192, 0, 192, 127), /* magenta */ 753 MAKE_RGBA8FP16(rgb, 19, 19, 19, 127), /* black */ 754 MAKE_RGBA8FP16(rgb, 0, 192, 192, 127), /* cyan */ 755 MAKE_RGBA8FP16(rgb, 19, 19, 19, 127), /* black */ 756 MAKE_RGBA8FP16(rgb, 192, 192, 192, 127),/* grey */ 757 }; 758 const uint64_t colors_bottom[] = { 759 MAKE_RGBA8FP16(rgb, 0, 33, 76, 255), /* in-phase */ 760 MAKE_RGBA8FP16(rgb, 255, 255, 255, 255),/* super white */ 761 MAKE_RGBA8FP16(rgb, 50, 0, 106, 255), /* quadrature */ 762 MAKE_RGBA8FP16(rgb, 19, 19, 19, 255), /* black */ 763 MAKE_RGBA8FP16(rgb, 9, 9, 9, 255), /* 3.5% */ 764 MAKE_RGBA8FP16(rgb, 19, 19, 19, 255), /* 7.5% */ 765 MAKE_RGBA8FP16(rgb, 29, 29, 29, 255), /* 11.5% */ 766 MAKE_RGBA8FP16(rgb, 19, 19, 19, 255), /* black */ 767 }; 768 unsigned int x; 769 unsigned int y; 770 771 for (y = 0; y < height * 6 / 9; ++y) { 772 for (x = 0; x < width; ++x) 773 ((uint64_t *)mem)[x] = colors_top[x * 7 / width]; 774 mem += stride; 775 } 776 777 for (; y < height * 7 / 9; ++y) { 778 for (x = 0; x < width; ++x) 779 ((uint64_t *)mem)[x] = colors_middle[x * 7 / width]; 780 mem += stride; 781 } 782 783 for (; y < height; ++y) { 784 for (x = 0; x < width * 5 / 7; ++x) 785 ((uint64_t *)mem)[x] = 786 colors_bottom[x * 4 / (width * 5 / 7)]; 787 for (; x < width * 6 / 7; ++x) 788 ((uint64_t *)mem)[x] = 789 colors_bottom[(x - width * 5 / 7) * 3 790 / (width / 7) + 4]; 791 for (; x < width; ++x) 792 ((uint64_t *)mem)[x] = colors_bottom[7]; 793 mem += stride; 794 } 795 } 796 797 enum smpte_colors { 798 SMPTE_COLOR_GREY, 799 SMPTE_COLOR_YELLOW, 800 SMPTE_COLOR_CYAN, 801 SMPTE_COLOR_GREEN, 802 SMPTE_COLOR_MAGENTA, 803 SMPTE_COLOR_RED, 804 SMPTE_COLOR_BLUE, 805 SMPTE_COLOR_BLACK, 806 SMPTE_COLOR_IN_PHASE, 807 SMPTE_COLOR_SUPER_WHITE, 808 SMPTE_COLOR_QUADRATURE, 809 SMPTE_COLOR_3PC5, 810 SMPTE_COLOR_11PC5, 811 }; 812 813 static unsigned int smpte_top[7] = { 814 SMPTE_COLOR_GREY, 815 SMPTE_COLOR_YELLOW, 816 SMPTE_COLOR_CYAN, 817 SMPTE_COLOR_GREEN, 818 SMPTE_COLOR_MAGENTA, 819 SMPTE_COLOR_RED, 820 SMPTE_COLOR_BLUE, 821 }; 822 823 static unsigned int smpte_middle[7] = { 824 SMPTE_COLOR_BLUE, 825 SMPTE_COLOR_BLACK, 826 SMPTE_COLOR_MAGENTA, 827 SMPTE_COLOR_BLACK, 828 SMPTE_COLOR_CYAN, 829 SMPTE_COLOR_BLACK, 830 SMPTE_COLOR_GREY, 831 }; 832 833 static unsigned int smpte_bottom[8] = { 834 SMPTE_COLOR_IN_PHASE, 835 SMPTE_COLOR_SUPER_WHITE, 836 SMPTE_COLOR_QUADRATURE, 837 SMPTE_COLOR_BLACK, 838 SMPTE_COLOR_3PC5, 839 SMPTE_COLOR_BLACK, 840 SMPTE_COLOR_11PC5, 841 SMPTE_COLOR_BLACK, 842 }; 843 844 #define EXPAND_COLOR(r, g, b) { (r) * 0x101, (g) * 0x101, (b) * 0x101 } 845 846 static const struct drm_color_lut bw_color_lut[] = { 847 EXPAND_COLOR( 0, 0, 0), /* black */ 848 EXPAND_COLOR(255, 255, 255), /* white */ 849 }; 850 851 static const struct drm_color_lut pentile_color_lut[] = { 852 /* PenTile RG-GB */ 853 EXPAND_COLOR( 0, 0, 0), /* black */ 854 EXPAND_COLOR(255, 0, 0), /* red */ 855 EXPAND_COLOR( 0, 207, 0), /* green */ 856 EXPAND_COLOR( 0, 0, 255), /* blue */ 857 }; 858 859 static const struct drm_color_lut smpte_color_lut[] = { 860 [SMPTE_COLOR_GREY] = EXPAND_COLOR(192, 192, 192), 861 [SMPTE_COLOR_YELLOW] = EXPAND_COLOR(192, 192, 0), 862 [SMPTE_COLOR_CYAN] = EXPAND_COLOR( 0, 192, 192), 863 [SMPTE_COLOR_GREEN] = EXPAND_COLOR( 0, 192, 0), 864 [SMPTE_COLOR_MAGENTA] = EXPAND_COLOR(192, 0, 192), 865 [SMPTE_COLOR_RED] = EXPAND_COLOR(192, 0, 0), 866 [SMPTE_COLOR_BLUE] = EXPAND_COLOR( 0, 0, 192), 867 [SMPTE_COLOR_BLACK] = EXPAND_COLOR( 19, 19, 19), 868 [SMPTE_COLOR_IN_PHASE] = EXPAND_COLOR( 0, 33, 76), 869 [SMPTE_COLOR_SUPER_WHITE] = EXPAND_COLOR(255, 255, 255), 870 [SMPTE_COLOR_QUADRATURE] = EXPAND_COLOR( 50, 0, 106), 871 [SMPTE_COLOR_3PC5] = EXPAND_COLOR( 9, 9, 9), 872 [SMPTE_COLOR_11PC5] = EXPAND_COLOR( 29, 29, 29), 873 }; 874 875 #undef EXPAND_COLOR 876 877 /* 878 * Floyd-Steinberg dithering 879 */ 880 881 struct fsd { 882 unsigned int width; 883 unsigned int x; 884 unsigned int i; 885 int red; 886 int green; 887 int blue; 888 int error[]; 889 }; 890 891 static struct fsd *fsd_alloc(unsigned int width) 892 { 893 unsigned int n = 3 * (width + 1); 894 struct fsd *fsd = malloc(sizeof(*fsd) + n * sizeof(fsd->error[0])); 895 896 fsd->width = width; 897 fsd->x = 0; 898 fsd->i = 0; 899 memset(fsd->error, 0, n * sizeof(fsd->error[0])); 900 901 return fsd; 902 } 903 904 static inline int clamp(int val, int min, int max) 905 { 906 if (val < min) 907 return min; 908 if (val > max) 909 return max; 910 return val; 911 } 912 913 static void fsd_dither(struct fsd *fsd, struct drm_color_lut *color) 914 { 915 unsigned int i = fsd->i; 916 917 fsd->red = (int)color->red + (fsd->error[3 * i] + 8) / 16; 918 fsd->green = (int)color->green + (fsd->error[3 * i + 1] + 8) / 16; 919 fsd->blue = (int)color->blue + (fsd->error[3 * i + 2] + 8) / 16; 920 921 color->red = clamp(fsd->red, 0, 65535); 922 color->green = clamp(fsd->green, 0, 65535); 923 color->blue = clamp(fsd->blue, 0, 65535); 924 } 925 926 static void fsd_update(struct fsd *fsd, const struct drm_color_lut *actual) 927 { 928 int error_red = fsd->red - (int)actual->red; 929 int error_green = fsd->green - (int)actual->green; 930 int error_blue = fsd->blue - (int)actual->blue; 931 unsigned int width = fsd->width; 932 unsigned int i = fsd->i, j; 933 unsigned int n = width + 1; 934 935 /* Distribute errors over neighboring pixels */ 936 if (fsd->x == width - 1) { 937 /* Last pixel on this scanline */ 938 /* South East: initialize to zero */ 939 fsd->error[3 * i] = 0; 940 fsd->error[3 * i + 1] = 0; 941 fsd->error[3 * i + 2] = 0; 942 } else { 943 /* East: accumulate error */ 944 j = (i + 1) % n; 945 fsd->error[3 * j] += 7 * error_red; 946 fsd->error[3 * j + 1] += 7 * error_green; 947 fsd->error[3 * j + 2] += 7 * error_blue; 948 949 /* South East: initial error */ 950 fsd->error[3 * i] = error_red; 951 fsd->error[3 * i + 1] = error_green; 952 fsd->error[3 * i + 2] = error_blue; 953 } 954 /* South West: accumulate error */ 955 j = (i + width - 1) % n; 956 fsd->error[3 * j] += 3 * error_red; 957 fsd->error[3 * j + 1] += 3 * error_green; 958 fsd->error[3 * j + 2] += 3 * error_blue; 959 960 /* South: accumulate error */ 961 j = (i + width) % n; 962 fsd->error[3 * j] += 5 * error_red; 963 fsd->error[3 * j + 1] += 5 * error_green; 964 fsd->error[3 * j + 2] += 5 * error_blue; 965 966 fsd->x = (fsd->x + 1) % width; 967 fsd->i = (fsd->i + 1) % n; 968 } 969 970 static void write_pixel_1(uint8_t *mem, unsigned int x, unsigned int pixel) 971 { 972 unsigned int shift = 7 - (x & 7); 973 unsigned int mask = 1U << shift; 974 975 mem[x / 8] = (mem[x / 8] & ~mask) | ((pixel << shift) & mask); 976 } 977 978 static void write_color_1(struct fsd *fsd, uint8_t *mem, unsigned int x, 979 unsigned int index) 980 { 981 struct drm_color_lut color = smpte_color_lut[index]; 982 unsigned int pixel; 983 984 fsd_dither(fsd, &color); 985 986 /* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */ 987 if (3 * color.red + 6 * color.green + color.blue >= 10 * 32768) { 988 pixel = 1; 989 color.red = color.green = color.blue = 65535; 990 } else { 991 pixel = 0; 992 color.red = color.green = color.blue = 0; 993 } 994 995 fsd_update(fsd, &color); 996 997 write_pixel_1(mem, x, pixel); 998 } 999 1000 static void fill_smpte_c1(void *mem, unsigned int width, unsigned int height, 1001 unsigned int stride) 1002 { 1003 struct fsd *fsd = fsd_alloc(width); 1004 unsigned int x; 1005 unsigned int y; 1006 1007 for (y = 0; y < height * 6 / 9; ++y) { 1008 for (x = 0; x < width; ++x) 1009 write_color_1(fsd, mem, x, smpte_top[x * 7 / width]); 1010 mem += stride; 1011 } 1012 1013 for (; y < height * 7 / 9; ++y) { 1014 for (x = 0; x < width; ++x) 1015 write_color_1(fsd, mem, x, smpte_middle[x * 7 / width]); 1016 mem += stride; 1017 } 1018 1019 for (; y < height; ++y) { 1020 for (x = 0; x < width * 5 / 7; ++x) 1021 write_color_1(fsd, mem, x, 1022 smpte_bottom[x * 4 / (width * 5 / 7)]); 1023 for (; x < width * 6 / 7; ++x) 1024 write_color_1(fsd, mem, x, 1025 smpte_bottom[(x - width * 5 / 7) * 3 / 1026 (width / 7) + 4]); 1027 for (; x < width; ++x) 1028 write_color_1(fsd, mem, x, smpte_bottom[7]); 1029 mem += stride; 1030 } 1031 1032 free(fsd); 1033 } 1034 1035 static void write_pixel_2(uint8_t *mem, unsigned int x, unsigned int pixel) 1036 { 1037 unsigned int shift = 6 - 2 * (x & 3); 1038 unsigned int mask = 3U << shift; 1039 1040 mem[x / 4] = (mem[x / 4] & ~mask) | ((pixel << shift) & mask); 1041 } 1042 1043 static void write_color_2(struct fsd *fsd, uint8_t *mem, unsigned int stride, 1044 unsigned int x, unsigned int index) 1045 { 1046 struct drm_color_lut color = smpte_color_lut[index]; 1047 unsigned int r, g, b; 1048 1049 fsd_dither(fsd, &color); 1050 1051 if (color.red >= 32768) { 1052 r = 1; 1053 color.red = 65535; 1054 } else { 1055 r = 0; 1056 color.red = 0; 1057 } 1058 if (color.green >= 32768) { 1059 g = 2; 1060 color.green = 65535; 1061 } else { 1062 g = 0; 1063 color.green = 0; 1064 } 1065 if (color.blue >= 32768) { 1066 b = 3; 1067 color.blue = 65535; 1068 } else { 1069 b = 0; 1070 color.blue = 0; 1071 } 1072 1073 fsd_update(fsd, &color); 1074 1075 /* Use PenTile RG-GB */ 1076 write_pixel_2(mem, 2 * x, r); 1077 write_pixel_2(mem, 2 * x + 1, g); 1078 write_pixel_2(mem + stride, 2 * x, g); 1079 write_pixel_2(mem + stride, 2 * x + 1, b); 1080 } 1081 1082 static void fill_smpte_c2(void *mem, unsigned int width, unsigned int height, 1083 unsigned int stride) 1084 { 1085 struct fsd *fsd = fsd_alloc(width); 1086 unsigned int x; 1087 unsigned int y; 1088 1089 /* Half resolution for PenTile RG-GB */ 1090 width /= 2; 1091 height /= 2; 1092 1093 for (y = 0; y < height * 6 / 9; ++y) { 1094 for (x = 0; x < width; ++x) 1095 write_color_2(fsd, mem, stride, x, smpte_top[x * 7 / width]); 1096 mem += 2 * stride; 1097 } 1098 1099 for (; y < height * 7 / 9; ++y) { 1100 for (x = 0; x < width; ++x) 1101 write_color_2(fsd, mem, stride, x, smpte_middle[x * 7 / width]); 1102 mem += 2 * stride; 1103 } 1104 1105 for (; y < height; ++y) { 1106 for (x = 0; x < width * 5 / 7; ++x) 1107 write_color_2(fsd, mem, stride, x, 1108 smpte_bottom[x * 4 / (width * 5 / 7)]); 1109 for (; x < width * 6 / 7; ++x) 1110 write_color_2(fsd, mem, stride, x, 1111 smpte_bottom[(x - width * 5 / 7) * 3 / 1112 (width / 7) + 4]); 1113 for (; x < width; ++x) 1114 write_color_2(fsd, mem, stride, x, smpte_bottom[7]); 1115 mem += 2 * stride; 1116 } 1117 1118 free(fsd); 1119 } 1120 1121 static void write_pixel_4(uint8_t *mem, unsigned int x, unsigned int pixel) 1122 { 1123 if (x & 1) 1124 mem[x / 2] = (mem[x / 2] & 0xf0) | (pixel & 0x0f); 1125 else 1126 mem[x / 2] = (mem[x / 2] & 0x0f) | (pixel << 4); 1127 } 1128 1129 static void fill_smpte_c4(void *mem, unsigned int width, unsigned int height, 1130 unsigned int stride) 1131 { 1132 unsigned int x; 1133 unsigned int y; 1134 1135 for (y = 0; y < height * 6 / 9; ++y) { 1136 for (x = 0; x < width; ++x) 1137 write_pixel_4(mem, x, smpte_top[x * 7 / width]); 1138 mem += stride; 1139 } 1140 1141 for (; y < height * 7 / 9; ++y) { 1142 for (x = 0; x < width; ++x) 1143 write_pixel_4(mem, x, smpte_middle[x * 7 / width]); 1144 mem += stride; 1145 } 1146 1147 for (; y < height; ++y) { 1148 for (x = 0; x < width * 5 / 7; ++x) 1149 write_pixel_4(mem, x, 1150 smpte_bottom[x * 4 / (width * 5 / 7)]); 1151 for (; x < width * 6 / 7; ++x) 1152 write_pixel_4(mem, x, 1153 smpte_bottom[(x - width * 5 / 7) * 3 / 1154 (width / 7) + 4]); 1155 for (; x < width; ++x) 1156 write_pixel_4(mem, x, smpte_bottom[7]); 1157 mem += stride; 1158 } 1159 } 1160 1161 static void fill_smpte_c8(void *mem, unsigned int width, unsigned int height, 1162 unsigned int stride) 1163 { 1164 unsigned int x; 1165 unsigned int y; 1166 1167 for (y = 0; y < height * 6 / 9; ++y) { 1168 for (x = 0; x < width; ++x) 1169 ((uint8_t *)mem)[x] = smpte_top[x * 7 / width]; 1170 mem += stride; 1171 } 1172 1173 for (; y < height * 7 / 9; ++y) { 1174 for (x = 0; x < width; ++x) 1175 ((uint8_t *)mem)[x] = smpte_middle[x * 7 / width]; 1176 mem += stride; 1177 } 1178 1179 for (; y < height; ++y) { 1180 for (x = 0; x < width * 5 / 7; ++x) 1181 ((uint8_t *)mem)[x] = 1182 smpte_bottom[x * 4 / (width * 5 / 7)]; 1183 for (; x < width * 6 / 7; ++x) 1184 ((uint8_t *)mem)[x] = 1185 smpte_bottom[(x - width * 5 / 7) * 3 1186 / (width / 7) + 4]; 1187 for (; x < width; ++x) 1188 ((uint8_t *)mem)[x] = smpte_bottom[7]; 1189 mem += stride; 1190 } 1191 } 1192 1193 void util_smpte_fill_lut(unsigned int ncolors, struct drm_color_lut *lut) 1194 { 1195 if (ncolors < ARRAY_SIZE(bw_color_lut)) { 1196 printf("Error: lut too small: %u < %zu\n", ncolors, 1197 ARRAY_SIZE(bw_color_lut)); 1198 return; 1199 } 1200 memset(lut, 0, ncolors * sizeof(struct drm_color_lut)); 1201 1202 if (ncolors < ARRAY_SIZE(pentile_color_lut)) 1203 memcpy(lut, bw_color_lut, sizeof(bw_color_lut)); 1204 else if (ncolors < ARRAY_SIZE(smpte_color_lut)) 1205 memcpy(lut, pentile_color_lut, sizeof(pentile_color_lut)); 1206 else 1207 memcpy(lut, smpte_color_lut, sizeof(smpte_color_lut)); 1208 } 1209 1210 static void fill_smpte(const struct util_format_info *info, void *planes[3], 1211 unsigned int width, unsigned int height, 1212 unsigned int stride) 1213 { 1214 unsigned char *u, *v; 1215 1216 switch (info->format) { 1217 case DRM_FORMAT_C1: 1218 return fill_smpte_c1(planes[0], width, height, stride); 1219 case DRM_FORMAT_C2: 1220 return fill_smpte_c2(planes[0], width, height, stride); 1221 case DRM_FORMAT_C4: 1222 return fill_smpte_c4(planes[0], width, height, stride); 1223 case DRM_FORMAT_C8: 1224 return fill_smpte_c8(planes[0], width, height, stride); 1225 case DRM_FORMAT_UYVY: 1226 case DRM_FORMAT_VYUY: 1227 case DRM_FORMAT_YUYV: 1228 case DRM_FORMAT_YVYU: 1229 return fill_smpte_yuv_packed(&info->yuv, planes[0], width, 1230 height, stride); 1231 1232 case DRM_FORMAT_NV12: 1233 case DRM_FORMAT_NV21: 1234 case DRM_FORMAT_NV16: 1235 case DRM_FORMAT_NV61: 1236 case DRM_FORMAT_NV24: 1237 case DRM_FORMAT_NV42: 1238 u = info->yuv.order & YUV_YCbCr ? planes[1] : planes[1] + 1; 1239 v = info->yuv.order & YUV_YCrCb ? planes[1] : planes[1] + 1; 1240 return fill_smpte_yuv_planar(&info->yuv, planes[0], u, v, 1241 width, height, stride); 1242 1243 case DRM_FORMAT_NV15: 1244 case DRM_FORMAT_NV20: 1245 case DRM_FORMAT_NV30: 1246 return fill_smpte_yuv_planar_10bpp(&info->yuv, planes[0], 1247 planes[1], width, height, 1248 stride); 1249 1250 case DRM_FORMAT_YUV420: 1251 case DRM_FORMAT_YUV422: 1252 case DRM_FORMAT_YUV444: 1253 return fill_smpte_yuv_planar(&info->yuv, planes[0], planes[1], 1254 planes[2], width, height, stride); 1255 1256 case DRM_FORMAT_YVU420: 1257 case DRM_FORMAT_YVU422: 1258 case DRM_FORMAT_YVU444: 1259 return fill_smpte_yuv_planar(&info->yuv, planes[0], planes[2], 1260 planes[1], width, height, stride); 1261 1262 case DRM_FORMAT_ARGB4444: 1263 case DRM_FORMAT_XRGB4444: 1264 case DRM_FORMAT_ABGR4444: 1265 case DRM_FORMAT_XBGR4444: 1266 case DRM_FORMAT_RGBA4444: 1267 case DRM_FORMAT_RGBX4444: 1268 case DRM_FORMAT_BGRA4444: 1269 case DRM_FORMAT_BGRX4444: 1270 case DRM_FORMAT_RGB565: 1271 case DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN: 1272 case DRM_FORMAT_BGR565: 1273 case DRM_FORMAT_ARGB1555: 1274 case DRM_FORMAT_XRGB1555: 1275 case DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN: 1276 case DRM_FORMAT_ABGR1555: 1277 case DRM_FORMAT_XBGR1555: 1278 case DRM_FORMAT_RGBA5551: 1279 case DRM_FORMAT_RGBX5551: 1280 case DRM_FORMAT_BGRA5551: 1281 case DRM_FORMAT_BGRX5551: 1282 return fill_smpte_rgb16(&info->rgb, planes[0], 1283 width, height, stride, 1284 info->format & DRM_FORMAT_BIG_ENDIAN); 1285 1286 case DRM_FORMAT_BGR888: 1287 case DRM_FORMAT_RGB888: 1288 return fill_smpte_rgb24(&info->rgb, planes[0], 1289 width, height, stride); 1290 case DRM_FORMAT_ARGB8888: 1291 case DRM_FORMAT_XRGB8888: 1292 case DRM_FORMAT_ABGR8888: 1293 case DRM_FORMAT_XBGR8888: 1294 case DRM_FORMAT_RGBA8888: 1295 case DRM_FORMAT_RGBX8888: 1296 case DRM_FORMAT_BGRA8888: 1297 case DRM_FORMAT_BGRX8888: 1298 case DRM_FORMAT_ARGB2101010: 1299 case DRM_FORMAT_XRGB2101010: 1300 case DRM_FORMAT_ABGR2101010: 1301 case DRM_FORMAT_XBGR2101010: 1302 case DRM_FORMAT_RGBA1010102: 1303 case DRM_FORMAT_RGBX1010102: 1304 case DRM_FORMAT_BGRA1010102: 1305 case DRM_FORMAT_BGRX1010102: 1306 return fill_smpte_rgb32(&info->rgb, planes[0], 1307 width, height, stride); 1308 1309 case DRM_FORMAT_XRGB16161616F: 1310 case DRM_FORMAT_XBGR16161616F: 1311 case DRM_FORMAT_ARGB16161616F: 1312 case DRM_FORMAT_ABGR16161616F: 1313 return fill_smpte_rgb16fp(&info->rgb, planes[0], 1314 width, height, stride); 1315 } 1316 } 1317 1318 #if HAVE_CAIRO 1319 static void byteswap_buffer16(void *mem, unsigned int width, unsigned int height, 1320 unsigned int stride) 1321 { 1322 unsigned int x, y; 1323 1324 for (y = 0; y < height; ++y) { 1325 for (x = 0; x < width; ++x) 1326 ((uint16_t *)mem)[x] = swap16(((uint16_t *)mem)[x]); 1327 mem += stride; 1328 } 1329 } 1330 1331 static void byteswap_buffer32(void *mem, unsigned int width, unsigned int height, 1332 unsigned int stride) 1333 { 1334 unsigned int x, y; 1335 1336 for (y = 0; y < height; ++y) { 1337 for (x = 0; x < width; ++x) 1338 ((uint32_t *)mem)[x] = swap32(((uint32_t *)mem)[x]); 1339 mem += stride; 1340 } 1341 } 1342 #endif 1343 1344 static void make_pwetty(void *data, unsigned int width, unsigned int height, 1345 unsigned int stride, uint32_t format) 1346 { 1347 #if HAVE_CAIRO 1348 cairo_surface_t *surface; 1349 cairo_t *cr; 1350 cairo_format_t cairo_format; 1351 bool swap16 = false; 1352 bool swap32 = false; 1353 1354 /* we can ignore the order of R,G,B channels */ 1355 switch (format) { 1356 case DRM_FORMAT_XRGB8888: 1357 case DRM_FORMAT_ARGB8888: 1358 case DRM_FORMAT_XBGR8888: 1359 case DRM_FORMAT_ABGR8888: 1360 cairo_format = CAIRO_FORMAT_ARGB32; 1361 break; 1362 case DRM_FORMAT_RGB565: 1363 case DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN: 1364 case DRM_FORMAT_BGR565: 1365 cairo_format = CAIRO_FORMAT_RGB16_565; 1366 swap16 = fb_foreign_endian(format); 1367 break; 1368 #if CAIRO_VERSION_MAJOR > 1 || (CAIRO_VERSION_MAJOR == 1 && CAIRO_VERSION_MINOR >= 12) 1369 case DRM_FORMAT_ARGB2101010: 1370 case DRM_FORMAT_XRGB2101010: 1371 case DRM_FORMAT_ABGR2101010: 1372 case DRM_FORMAT_XBGR2101010: 1373 cairo_format = CAIRO_FORMAT_RGB30; 1374 swap32 = fb_foreign_endian(format); 1375 break; 1376 #endif 1377 default: 1378 return; 1379 } 1380 1381 /* Cairo uses native byte order, so we may have to byteswap before... */ 1382 if (swap16) 1383 byteswap_buffer16(data, width, height, stride); 1384 if (swap32) 1385 byteswap_buffer32(data, width, height, stride); 1386 1387 surface = cairo_image_surface_create_for_data(data, 1388 cairo_format, 1389 width, height, 1390 stride); 1391 cr = cairo_create(surface); 1392 cairo_surface_destroy(surface); 1393 1394 cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE); 1395 for (unsigned x = 0; x < width; x += 250) 1396 for (unsigned y = 0; y < height; y += 250) { 1397 char buf[64]; 1398 1399 cairo_move_to(cr, x, y - 20); 1400 cairo_line_to(cr, x, y + 20); 1401 cairo_move_to(cr, x - 20, y); 1402 cairo_line_to(cr, x + 20, y); 1403 cairo_new_sub_path(cr); 1404 cairo_arc(cr, x, y, 10, 0, M_PI * 2); 1405 cairo_set_line_width(cr, 4); 1406 cairo_set_source_rgb(cr, 0, 0, 0); 1407 cairo_stroke_preserve(cr); 1408 cairo_set_source_rgb(cr, 1, 1, 1); 1409 cairo_set_line_width(cr, 2); 1410 cairo_stroke(cr); 1411 1412 snprintf(buf, sizeof buf, "%d, %d", x, y); 1413 cairo_move_to(cr, x + 20, y + 20); 1414 cairo_text_path(cr, buf); 1415 cairo_set_source_rgb(cr, 0, 0, 0); 1416 cairo_stroke_preserve(cr); 1417 cairo_set_source_rgb(cr, 1, 1, 1); 1418 cairo_fill(cr); 1419 } 1420 1421 cairo_destroy(cr); 1422 1423 /* ... and after */ 1424 if (swap16) 1425 byteswap_buffer16(data, width, height, stride); 1426 if (swap32) 1427 byteswap_buffer32(data, width, height, stride); 1428 #endif 1429 } 1430 1431 static struct color_yuv make_tiles_yuv_color(unsigned int x, unsigned int y, 1432 unsigned int width) 1433 { 1434 div_t d = div(x+y, width); 1435 uint32_t rgb32 = 0x00130502 * (d.quot >> 6) 1436 + 0x000a1120 * (d.rem >> 6); 1437 struct color_yuv color = 1438 MAKE_YUV_601((rgb32 >> 16) & 0xff, (rgb32 >> 8) & 0xff, 1439 rgb32 & 0xff); 1440 return color; 1441 } 1442 1443 static void fill_tiles_yuv_planar(const struct util_format_info *info, 1444 unsigned char *y_mem, unsigned char *u_mem, 1445 unsigned char *v_mem, unsigned int width, 1446 unsigned int height, unsigned int stride) 1447 { 1448 const struct util_yuv_info *yuv = &info->yuv; 1449 unsigned int cs = yuv->chroma_stride; 1450 unsigned int xsub = yuv->xsub; 1451 unsigned int ysub = yuv->ysub; 1452 unsigned int x; 1453 unsigned int y; 1454 1455 for (y = 0; y < height; ++y) { 1456 for (x = 0; x < width; ++x) { 1457 struct color_yuv color = 1458 make_tiles_yuv_color(x, y, width); 1459 1460 y_mem[x] = color.y; 1461 u_mem[x/xsub*cs] = color.u; 1462 v_mem[x/xsub*cs] = color.v; 1463 } 1464 1465 y_mem += stride; 1466 if ((y + 1) % ysub == 0) { 1467 u_mem += stride * cs / xsub; 1468 v_mem += stride * cs / xsub; 1469 } 1470 } 1471 } 1472 1473 static void fill_tiles_yuv_planar_10bpp(const struct util_format_info *info, 1474 unsigned char *y_mem, 1475 unsigned char *uv_mem, 1476 unsigned int width, 1477 unsigned int height, 1478 unsigned int stride) 1479 { 1480 const struct util_yuv_info *yuv = &info->yuv; 1481 unsigned int cs = yuv->chroma_stride; 1482 unsigned int xsub = yuv->xsub; 1483 unsigned int ysub = yuv->ysub; 1484 unsigned int xstep = cs * xsub; 1485 unsigned int x; 1486 unsigned int y; 1487 1488 for (y = 0; y < height; ++y) { 1489 for (x = 0; x < width; x += 4) { 1490 struct color_yuv a = make_tiles_yuv_color(x+0, y, width); 1491 struct color_yuv b = make_tiles_yuv_color(x+1, y, width); 1492 struct color_yuv c = make_tiles_yuv_color(x+2, y, width); 1493 struct color_yuv d = make_tiles_yuv_color(x+3, y, width); 1494 1495 write_pixels_10bpp(&y_mem[(x * 5) / 4], 1496 a.y << 2, b.y << 2, c.y << 2, d.y << 2); 1497 } 1498 y_mem += stride; 1499 } 1500 for (y = 0; y < height; y += ysub) { 1501 for (x = 0; x < width; x += xstep) { 1502 struct color_yuv a = make_tiles_yuv_color(x+0, y, width); 1503 struct color_yuv b = make_tiles_yuv_color(x+xsub, y, width); 1504 1505 write_pixels_10bpp(&uv_mem[(x * 5) / xstep], 1506 a.u << 2, a.v << 2, b.u << 2, b.v << 2); 1507 } 1508 uv_mem += stride * cs / xsub; 1509 } 1510 } 1511 1512 static void fill_tiles_yuv_packed(const struct util_format_info *info, 1513 void *mem, unsigned int width, 1514 unsigned int height, unsigned int stride) 1515 { 1516 const struct util_yuv_info *yuv = &info->yuv; 1517 unsigned char *y_mem = (yuv->order & YUV_YC) ? mem : mem + 1; 1518 unsigned char *c_mem = (yuv->order & YUV_CY) ? mem : mem + 1; 1519 unsigned int u = (yuv->order & YUV_YCrCb) ? 2 : 0; 1520 unsigned int v = (yuv->order & YUV_YCbCr) ? 2 : 0; 1521 unsigned int x; 1522 unsigned int y; 1523 1524 for (y = 0; y < height; ++y) { 1525 for (x = 0; x < width; x += 2) { 1526 struct color_yuv color = 1527 make_tiles_yuv_color(x, y, width); 1528 1529 y_mem[2*x] = color.y; 1530 c_mem[2*x+u] = color.u; 1531 y_mem[2*x+2] = color.y; 1532 c_mem[2*x+v] = color.v; 1533 } 1534 1535 y_mem += stride; 1536 c_mem += stride; 1537 } 1538 } 1539 1540 static void fill_tiles_rgb16(const struct util_format_info *info, void *mem, 1541 unsigned int width, unsigned int height, 1542 unsigned int stride, bool fb_be) 1543 { 1544 const struct util_rgb_info *rgb = &info->rgb; 1545 void *mem_base = mem; 1546 unsigned int x, y; 1547 1548 for (y = 0; y < height; ++y) { 1549 for (x = 0; x < width; ++x) { 1550 div_t d = div(x+y, width); 1551 uint32_t rgb32 = 0x00130502 * (d.quot >> 6) 1552 + 0x000a1120 * (d.rem >> 6); 1553 uint16_t color = 1554 MAKE_RGBA(rgb, (rgb32 >> 16) & 0xff, 1555 (rgb32 >> 8) & 0xff, rgb32 & 0xff, 1556 255); 1557 1558 ((uint16_t *)mem)[x] = cpu_to_fb16(color); 1559 } 1560 mem += stride; 1561 } 1562 1563 make_pwetty(mem_base, width, height, stride, info->format); 1564 } 1565 1566 static void fill_tiles_rgb24(const struct util_format_info *info, void *mem, 1567 unsigned int width, unsigned int height, 1568 unsigned int stride) 1569 { 1570 const struct util_rgb_info *rgb = &info->rgb; 1571 unsigned int x, y; 1572 1573 for (y = 0; y < height; ++y) { 1574 for (x = 0; x < width; ++x) { 1575 div_t d = div(x+y, width); 1576 uint32_t rgb32 = 0x00130502 * (d.quot >> 6) 1577 + 0x000a1120 * (d.rem >> 6); 1578 struct color_rgb24 color = 1579 MAKE_RGB24(rgb, (rgb32 >> 16) & 0xff, 1580 (rgb32 >> 8) & 0xff, rgb32 & 0xff); 1581 1582 ((struct color_rgb24 *)mem)[x] = color; 1583 } 1584 mem += stride; 1585 } 1586 } 1587 1588 static void fill_tiles_rgb32(const struct util_format_info *info, void *mem, 1589 unsigned int width, unsigned int height, 1590 unsigned int stride) 1591 { 1592 const struct util_rgb_info *rgb = &info->rgb; 1593 void *mem_base = mem; 1594 unsigned int x, y; 1595 1596 for (y = 0; y < height; ++y) { 1597 for (x = 0; x < width; ++x) { 1598 div_t d = div(x+y, width); 1599 uint32_t rgb32 = 0x00130502 * (d.quot >> 6) 1600 + 0x000a1120 * (d.rem >> 6); 1601 uint32_t alpha = ((y < height/2) && (x < width/2)) ? 127 : 255; 1602 uint32_t color = 1603 MAKE_RGBA(rgb, (rgb32 >> 16) & 0xff, 1604 (rgb32 >> 8) & 0xff, rgb32 & 0xff, 1605 alpha); 1606 1607 ((uint32_t *)mem)[x] = cpu_to_le32(color); 1608 } 1609 mem += stride; 1610 } 1611 1612 make_pwetty(mem_base, width, height, stride, info->format); 1613 } 1614 1615 static void fill_tiles_rgb16fp(const struct util_format_info *info, void *mem, 1616 unsigned int width, unsigned int height, 1617 unsigned int stride) 1618 { 1619 const struct util_rgb_info *rgb = &info->rgb; 1620 unsigned int x, y; 1621 1622 /* TODO: Give this actual fp16 precision */ 1623 for (y = 0; y < height; ++y) { 1624 for (x = 0; x < width; ++x) { 1625 div_t d = div(x+y, width); 1626 uint32_t rgb32 = 0x00130502 * (d.quot >> 6) 1627 + 0x000a1120 * (d.rem >> 6); 1628 uint32_t alpha = ((y < height/2) && (x < width/2)) ? 127 : 255; 1629 uint64_t color = 1630 MAKE_RGBA8FP16(rgb, (rgb32 >> 16) & 0xff, 1631 (rgb32 >> 8) & 0xff, rgb32 & 0xff, 1632 alpha); 1633 1634 ((uint64_t *)mem)[x] = color; 1635 } 1636 mem += stride; 1637 } 1638 } 1639 1640 static void fill_tiles(const struct util_format_info *info, void *planes[3], 1641 unsigned int width, unsigned int height, 1642 unsigned int stride) 1643 { 1644 unsigned char *u, *v; 1645 1646 switch (info->format) { 1647 case DRM_FORMAT_UYVY: 1648 case DRM_FORMAT_VYUY: 1649 case DRM_FORMAT_YUYV: 1650 case DRM_FORMAT_YVYU: 1651 return fill_tiles_yuv_packed(info, planes[0], 1652 width, height, stride); 1653 1654 case DRM_FORMAT_NV12: 1655 case DRM_FORMAT_NV21: 1656 case DRM_FORMAT_NV16: 1657 case DRM_FORMAT_NV61: 1658 case DRM_FORMAT_NV24: 1659 case DRM_FORMAT_NV42: 1660 u = info->yuv.order & YUV_YCbCr ? planes[1] : planes[1] + 1; 1661 v = info->yuv.order & YUV_YCrCb ? planes[1] : planes[1] + 1; 1662 return fill_tiles_yuv_planar(info, planes[0], u, v, 1663 width, height, stride); 1664 1665 case DRM_FORMAT_NV15: 1666 case DRM_FORMAT_NV20: 1667 case DRM_FORMAT_NV30: 1668 return fill_tiles_yuv_planar_10bpp(info, planes[0], planes[1], 1669 width, height, stride); 1670 1671 case DRM_FORMAT_YUV420: 1672 case DRM_FORMAT_YUV422: 1673 case DRM_FORMAT_YUV444: 1674 return fill_tiles_yuv_planar(info, planes[0], planes[1], 1675 planes[2], width, height, stride); 1676 1677 case DRM_FORMAT_YVU420: 1678 case DRM_FORMAT_YVU422: 1679 case DRM_FORMAT_YVU444: 1680 return fill_tiles_yuv_planar(info, planes[0], planes[2], 1681 planes[1], width, height, stride); 1682 1683 case DRM_FORMAT_ARGB4444: 1684 case DRM_FORMAT_XRGB4444: 1685 case DRM_FORMAT_ABGR4444: 1686 case DRM_FORMAT_XBGR4444: 1687 case DRM_FORMAT_RGBA4444: 1688 case DRM_FORMAT_RGBX4444: 1689 case DRM_FORMAT_BGRA4444: 1690 case DRM_FORMAT_BGRX4444: 1691 case DRM_FORMAT_RGB565: 1692 case DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN: 1693 case DRM_FORMAT_BGR565: 1694 case DRM_FORMAT_ARGB1555: 1695 case DRM_FORMAT_XRGB1555: 1696 case DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN: 1697 case DRM_FORMAT_ABGR1555: 1698 case DRM_FORMAT_XBGR1555: 1699 case DRM_FORMAT_RGBA5551: 1700 case DRM_FORMAT_RGBX5551: 1701 case DRM_FORMAT_BGRA5551: 1702 case DRM_FORMAT_BGRX5551: 1703 return fill_tiles_rgb16(info, planes[0], 1704 width, height, stride, 1705 info->format & DRM_FORMAT_BIG_ENDIAN); 1706 1707 case DRM_FORMAT_BGR888: 1708 case DRM_FORMAT_RGB888: 1709 return fill_tiles_rgb24(info, planes[0], 1710 width, height, stride); 1711 case DRM_FORMAT_ARGB8888: 1712 case DRM_FORMAT_XRGB8888: 1713 case DRM_FORMAT_ABGR8888: 1714 case DRM_FORMAT_XBGR8888: 1715 case DRM_FORMAT_RGBA8888: 1716 case DRM_FORMAT_RGBX8888: 1717 case DRM_FORMAT_BGRA8888: 1718 case DRM_FORMAT_BGRX8888: 1719 case DRM_FORMAT_ARGB2101010: 1720 case DRM_FORMAT_XRGB2101010: 1721 case DRM_FORMAT_ABGR2101010: 1722 case DRM_FORMAT_XBGR2101010: 1723 case DRM_FORMAT_RGBA1010102: 1724 case DRM_FORMAT_RGBX1010102: 1725 case DRM_FORMAT_BGRA1010102: 1726 case DRM_FORMAT_BGRX1010102: 1727 return fill_tiles_rgb32(info, planes[0], 1728 width, height, stride); 1729 1730 case DRM_FORMAT_XRGB16161616F: 1731 case DRM_FORMAT_XBGR16161616F: 1732 case DRM_FORMAT_ARGB16161616F: 1733 case DRM_FORMAT_ABGR16161616F: 1734 return fill_tiles_rgb16fp(info, planes[0], 1735 width, height, stride); 1736 } 1737 } 1738 1739 static void fill_plain(const struct util_format_info *info, void *planes[3], 1740 unsigned int height, 1741 unsigned int stride) 1742 { 1743 switch (info->format) { 1744 case DRM_FORMAT_XRGB16161616F: 1745 case DRM_FORMAT_XBGR16161616F: 1746 case DRM_FORMAT_ARGB16161616F: 1747 case DRM_FORMAT_ABGR16161616F: 1748 /* 0x3838 = 0.5273 */ 1749 memset(planes[0], 0x38, stride * height); 1750 break; 1751 default: 1752 memset(planes[0], 0x77, stride * height); 1753 break; 1754 } 1755 } 1756 1757 static void fill_gradient_rgb32(const struct util_rgb_info *rgb, 1758 void *mem, 1759 unsigned int width, unsigned int height, 1760 unsigned int stride) 1761 { 1762 unsigned int i, j; 1763 1764 for (i = 0; i < height / 2; i++) { 1765 uint32_t *row = mem; 1766 1767 for (j = 0; j < width / 2; j++) { 1768 uint32_t value = MAKE_RGBA10(rgb, j & 0x3ff, j & 0x3ff, j & 0x3ff, 0); 1769 row[2*j] = row[2*j+1] = cpu_to_le32(value); 1770 } 1771 mem += stride; 1772 } 1773 1774 for (; i < height; i++) { 1775 uint32_t *row = mem; 1776 1777 for (j = 0; j < width / 2; j++) { 1778 uint32_t value = MAKE_RGBA10(rgb, j & 0x3fc, j & 0x3fc, j & 0x3fc, 0); 1779 row[2*j] = row[2*j+1] = cpu_to_le32(value); 1780 } 1781 mem += stride; 1782 } 1783 } 1784 1785 static void fill_gradient_rgb16fp(const struct util_rgb_info *rgb, 1786 void *mem, 1787 unsigned int width, unsigned int height, 1788 unsigned int stride) 1789 { 1790 unsigned int i, j; 1791 1792 for (i = 0; i < height / 2; i++) { 1793 uint64_t *row = mem; 1794 1795 for (j = 0; j < width / 2; j++) { 1796 uint64_t value = MAKE_RGBA10FP16(rgb, j & 0x3ff, j & 0x3ff, j & 0x3ff, 0); 1797 row[2*j] = row[2*j+1] = value; 1798 } 1799 mem += stride; 1800 } 1801 1802 for (; i < height; i++) { 1803 uint64_t *row = mem; 1804 1805 for (j = 0; j < width / 2; j++) { 1806 uint64_t value = MAKE_RGBA10FP16(rgb, j & 0x3fc, j & 0x3fc, j & 0x3fc, 0); 1807 row[2*j] = row[2*j+1] = value; 1808 } 1809 mem += stride; 1810 } 1811 } 1812 1813 /* The gradient pattern creates two horizontal gray gradients, split 1814 * into two halves. The top half has 10bpc precision, the bottom half 1815 * has 8bpc precision. When using with a 10bpc fb format, there are 3 1816 * possible outcomes: 1817 * 1818 * - Pixel data is encoded as 8bpc to the display, no dithering. This 1819 * would lead to the top and bottom halves looking identical. 1820 * 1821 * - Pixel data is encoded as 8bpc to the display, with dithering. This 1822 * would lead to there being a visible difference between the two halves, 1823 * but the top half would look a little speck-y due to the dithering. 1824 * 1825 * - Pixel data is encoded at 10bpc+ to the display (which implies 1826 * the display is able to show this level of depth). This should 1827 * lead to the top half being a very clean gradient, and visibly different 1828 * from the bottom half. 1829 * 1830 * Once we support additional fb formats, this approach could be extended 1831 * to distinguish even higher bpc precisions. 1832 * 1833 * Note that due to practical size considerations, for the screens 1834 * where this matters, the pattern actually emits stripes 2-pixels 1835 * wide for each gradient color. Otherwise the difference may be a bit 1836 * hard to notice. 1837 */ 1838 static void fill_gradient(const struct util_format_info *info, void *planes[3], 1839 unsigned int width, unsigned int height, 1840 unsigned int stride) 1841 { 1842 switch (info->format) { 1843 case DRM_FORMAT_ARGB8888: 1844 case DRM_FORMAT_XRGB8888: 1845 case DRM_FORMAT_ABGR8888: 1846 case DRM_FORMAT_XBGR8888: 1847 case DRM_FORMAT_RGBA8888: 1848 case DRM_FORMAT_RGBX8888: 1849 case DRM_FORMAT_BGRA8888: 1850 case DRM_FORMAT_BGRX8888: 1851 case DRM_FORMAT_ARGB2101010: 1852 case DRM_FORMAT_XRGB2101010: 1853 case DRM_FORMAT_ABGR2101010: 1854 case DRM_FORMAT_XBGR2101010: 1855 case DRM_FORMAT_RGBA1010102: 1856 case DRM_FORMAT_RGBX1010102: 1857 case DRM_FORMAT_BGRA1010102: 1858 case DRM_FORMAT_BGRX1010102: 1859 return fill_gradient_rgb32(&info->rgb, planes[0], 1860 width, height, stride); 1861 1862 case DRM_FORMAT_XRGB16161616F: 1863 case DRM_FORMAT_XBGR16161616F: 1864 case DRM_FORMAT_ARGB16161616F: 1865 case DRM_FORMAT_ABGR16161616F: 1866 return fill_gradient_rgb16fp(&info->rgb, planes[0], 1867 width, height, stride); 1868 } 1869 } 1870 1871 static struct color_rgba get_black_white_value(uint64_t index) 1872 { 1873 const struct color_rgba colors[] = { 1874 { .red = 0, .green = 0, .blue = 0, .alpha = 255 }, /* black */ 1875 { .red = 255, .green = 255, .blue = 255, .alpha = 255 }, /* white */ 1876 }; 1877 1878 return colors[index & 0x1]; 1879 } 1880 1881 static struct color_rgba get_noise_color_value() 1882 { 1883 struct color_rgba color = { 1884 .red = rand(), 1885 .green = rand(), 1886 .blue = rand(), 1887 .alpha = 255 1888 }; 1889 1890 return color; 1891 } 1892 1893 static struct color_rgba get_rgb_color(uint64_t index, 1894 enum util_fill_pattern pattern) 1895 { 1896 struct color_rgba color = { 1897 .red = 0, 1898 .green = 0, 1899 .blue = 0, 1900 .alpha = 0 1901 }; 1902 1903 switch (pattern) { 1904 case UTIL_PATTERN_NOISE: 1905 color = get_black_white_value(rand()); 1906 1907 case UTIL_PATTERN_NOISE_COLOR: 1908 color = get_noise_color_value(); 1909 1910 case UTIL_PATTERN_BLACK_WHITE: 1911 color = get_black_white_value(index); 1912 1913 default: 1914 break; 1915 } 1916 1917 return color; 1918 } 1919 1920 static void insert_value_yuv_packed(const struct util_format_info *info, 1921 void *planes[3], unsigned int stride, 1922 unsigned int x, unsigned int y, 1923 const struct color_rgba* color) 1924 { 1925 struct color_yuv val = MAKE_YUV_601(color->red, color->green, color->blue); 1926 const struct util_yuv_info *yuv = &info->yuv; 1927 unsigned char *y_mem = (yuv->order & YUV_YC) ? planes[0] : planes[0] + 1; 1928 unsigned char *c_mem = (yuv->order & YUV_CY) ? planes[0] : planes[0] + 1; 1929 unsigned int u = (yuv->order & YUV_YCrCb) ? 2 : 0; 1930 unsigned int v = (yuv->order & YUV_YCbCr) ? 2 : 0; 1931 1932 if (x & 0x1) 1933 return; 1934 1935 y_mem += stride * y; 1936 c_mem += stride * y; 1937 1938 y_mem[2*x] = val.y; 1939 c_mem[2*x+u] = val.u; 1940 y_mem[2*x+2] = val.y; 1941 c_mem[2*x+v] = val.v; 1942 } 1943 1944 static void insert_value_yuv_planar(const struct util_format_info *info, 1945 void *planes[3], unsigned int stride, 1946 unsigned int x, unsigned int y, 1947 const struct color_rgba* color) 1948 { 1949 struct color_yuv val = MAKE_YUV_601(color->red, color->green, color->blue); 1950 const struct util_yuv_info *yuv = &info->yuv; 1951 unsigned int cs = yuv->chroma_stride; 1952 unsigned int xsub = yuv->xsub; 1953 unsigned int ysub = yuv->ysub; 1954 unsigned int chroma_offset = (y + 1) / ysub; 1955 unsigned char *y_mem = planes[0] + (y * stride); 1956 unsigned char *u_mem = planes[1]; 1957 unsigned char *v_mem = planes[2]; 1958 1959 switch (info->format) { 1960 case DRM_FORMAT_NV42: 1961 u_mem = info->yuv.order & YUV_YCbCr ? planes[1] : planes[1] + 1; 1962 v_mem = info->yuv.order & YUV_YCrCb ? planes[1] : planes[1] + 1; 1963 break; 1964 case DRM_FORMAT_YVU420: 1965 u_mem = planes[2]; 1966 v_mem = planes[1]; 1967 break; 1968 case DRM_FORMAT_YUV420: 1969 default: 1970 break; 1971 } 1972 1973 u_mem += (chroma_offset * (stride * cs / xsub)); 1974 v_mem += (chroma_offset * (stride * cs / xsub)); 1975 1976 y_mem[x] = val.y; 1977 u_mem[x/xsub*cs] = val.u; 1978 v_mem[x/xsub*cs] = val.v; 1979 } 1980 1981 static inline bool is_power_of_two(unsigned long val) 1982 { 1983 return (val != 0) && ((val & (val - 1)) == 0); 1984 } 1985 1986 static bool check_yuv(const struct util_yuv_info *info) 1987 { 1988 if (__builtin_expect( 1989 is_power_of_two(info->xsub) && 1990 is_power_of_two(info->ysub) && 1991 is_power_of_two(info->chroma_stride), 1)) { 1992 return true; 1993 } 1994 1995 return false; 1996 } 1997 1998 static void insert_value_yuv_planar_10bpp(const struct util_format_info *info, 1999 void *planes[3], unsigned int stride, 2000 unsigned int x, unsigned int y, 2001 const struct color_rgba* color) 2002 { 2003 struct color_yuv val = MAKE_YUV_601(color->red, color->green, color->blue); 2004 const struct util_yuv_info *yuv = &info->yuv; 2005 unsigned int cs = yuv->chroma_stride; 2006 unsigned int xsub = yuv->xsub; 2007 unsigned int ysub = yuv->ysub; 2008 unsigned int xstep = cs * xsub; 2009 unsigned int ysub_mask = ysub - 1; 2010 unsigned int xsub_mask = xsub - 1; 2011 unsigned int xstep_mask = xstep - 1; 2012 unsigned char *y_mem = planes[0] + (y * stride); 2013 unsigned char *uv_mem = planes[1] + (y * (stride * cs / xsub)); 2014 unsigned int block_start = ((x & 0x3) * 5) / 4; 2015 unsigned int bit_start = (x & 0x3) * 10; 2016 2017 /* Plus two because val.y is only 8 bits */ 2018 update_pixels_10bpp(&y_mem[block_start], val.y << (bit_start + 2), 2019 0x3ff << bit_start); 2020 2021 /* This logic only works when xsub, ysub and chroma stride is power of two. */ 2022 assert(check_yuv(&info->yuv)); 2023 2024 if (y & ysub_mask) 2025 return; 2026 2027 if (x & xsub_mask) 2028 return; 2029 2030 block_start = ((x & ~xstep_mask) * 5) / xstep; 2031 bit_start = x & xstep_mask ? 0 : 20; 2032 2033 update_pixels_10bpp(&uv_mem[block_start], 2034 ((val.u << 2) | (val.v << 12)) << bit_start, 2035 0xfffff << bit_start); 2036 } 2037 2038 2039 static void insert_value_rgb32(const struct util_format_info *info, 2040 void *planes[3], unsigned int stride, 2041 unsigned int x, unsigned int y, 2042 const struct color_rgba* color) 2043 { 2044 uint32_t *row = planes[0] + (stride * y); 2045 uint32_t val = MAKE_RGBA10(&info->rgb, color->red, color->green, 2046 color->blue, color->alpha); 2047 2048 row[x] = val; 2049 } 2050 2051 static void insert_value_rgb16fp(const struct util_format_info *info, 2052 void *planes[3], unsigned int stride, 2053 unsigned int x, unsigned int y, 2054 const struct color_rgba* color) 2055 { 2056 uint64_t *row = planes[0] + (stride * y); 2057 uint64_t val = MAKE_RGBA10FP16(&info->rgb, color->red, color->green, 2058 color->blue, color->alpha); 2059 2060 row[x] = val; 2061 } 2062 2063 static void fill_simple_patterns(const struct util_format_info *info, 2064 void *planes[3], unsigned int width, 2065 unsigned int height, unsigned int stride, 2066 enum util_fill_pattern pattern) 2067 { 2068 void (*func_insert_value)(const struct util_format_info *info, 2069 void *planes[3], unsigned int stride, 2070 unsigned int x, unsigned int y, 2071 const struct color_rgba* color); 2072 int x, y; 2073 2074 switch (info->format) { 2075 case DRM_FORMAT_UYVY: 2076 case DRM_FORMAT_VYUY: 2077 case DRM_FORMAT_YUYV: 2078 case DRM_FORMAT_YVYU: 2079 func_insert_value = &insert_value_yuv_packed; 2080 break; 2081 case DRM_FORMAT_NV12: 2082 case DRM_FORMAT_NV21: 2083 case DRM_FORMAT_NV16: 2084 case DRM_FORMAT_NV61: 2085 case DRM_FORMAT_NV24: 2086 case DRM_FORMAT_NV42: 2087 case DRM_FORMAT_YUV420: 2088 case DRM_FORMAT_YVU420: 2089 func_insert_value = &insert_value_yuv_planar; 2090 break; 2091 case DRM_FORMAT_NV15: 2092 case DRM_FORMAT_NV20: 2093 case DRM_FORMAT_NV30: 2094 func_insert_value = &insert_value_yuv_planar_10bpp; 2095 break; 2096 case DRM_FORMAT_ARGB8888: 2097 case DRM_FORMAT_XRGB8888: 2098 case DRM_FORMAT_ABGR8888: 2099 case DRM_FORMAT_XBGR8888: 2100 case DRM_FORMAT_RGBA8888: 2101 case DRM_FORMAT_RGBX8888: 2102 case DRM_FORMAT_BGRA8888: 2103 case DRM_FORMAT_BGRX8888: 2104 case DRM_FORMAT_ARGB2101010: 2105 case DRM_FORMAT_XRGB2101010: 2106 case DRM_FORMAT_ABGR2101010: 2107 case DRM_FORMAT_XBGR2101010: 2108 case DRM_FORMAT_RGBA1010102: 2109 case DRM_FORMAT_RGBX1010102: 2110 case DRM_FORMAT_BGRA1010102: 2111 case DRM_FORMAT_BGRX1010102: 2112 func_insert_value = &insert_value_rgb32; 2113 break; 2114 case DRM_FORMAT_XRGB16161616F: 2115 case DRM_FORMAT_XBGR16161616F: 2116 case DRM_FORMAT_ARGB16161616F: 2117 case DRM_FORMAT_ABGR16161616F: 2118 func_insert_value = &insert_value_rgb16fp; 2119 break; 2120 default: 2121 return; 2122 } 2123 2124 for (y = 0; y < height; y++) { 2125 for (x = 0; x < width; x++) { 2126 struct color_rgba color = get_rgb_color((width * y) + x, pattern); 2127 (*func_insert_value)(info, planes, stride, x, y, &color); 2128 } 2129 } 2130 } 2131 2132 /* 2133 * util_fill_pattern - Fill a buffer with a test pattern 2134 * @format: Pixel format 2135 * @pattern: Test pattern 2136 * @planes: Array of buffers 2137 * @width: Width in pixels 2138 * @height: Height in pixels 2139 * @stride: Line stride (pitch) in bytes 2140 * @seed: Seed for noise patterns if zero a default time based seed will be used 2141 * 2142 * Fill the buffers with the test pattern specified by the pattern parameter. 2143 * Supported formats vary depending on the selected pattern. 2144 */ 2145 void util_fill_pattern(uint32_t format, enum util_fill_pattern pattern, 2146 void *planes[3], unsigned int width, 2147 unsigned int height, unsigned int stride, unsigned long seed) 2148 { 2149 const struct util_format_info *info; 2150 2151 info = util_format_info_find(format); 2152 if (info == NULL) 2153 return; 2154 2155 switch (pattern) { 2156 case UTIL_PATTERN_NOISE: 2157 case UTIL_PATTERN_NOISE_COLOR: 2158 if (!seed) 2159 seed = time(NULL); 2160 srand(seed); 2161 printf("Seed used for noise patterns %lu\n", seed); 2162 break; 2163 default: 2164 break; 2165 } 2166 2167 switch (pattern) { 2168 case UTIL_PATTERN_TILES: 2169 return fill_tiles(info, planes, width, height, stride); 2170 2171 case UTIL_PATTERN_SMPTE: 2172 return fill_smpte(info, planes, width, height, stride); 2173 2174 case UTIL_PATTERN_PLAIN: 2175 return fill_plain(info, planes, height, stride); 2176 2177 case UTIL_PATTERN_GRADIENT: 2178 return fill_gradient(info, planes, width, height, stride); 2179 2180 case UTIL_PATTERN_NOISE: 2181 case UTIL_PATTERN_NOISE_COLOR: 2182 case UTIL_PATTERN_BLACK_WHITE: 2183 return fill_simple_patterns(info, planes, width, height, stride, 2184 pattern); 2185 2186 default: 2187 printf("Error: unsupported test pattern %u.\n", pattern); 2188 break; 2189 } 2190 } 2191 2192 static const char *pattern_names[] = { 2193 [UTIL_PATTERN_TILES] = "tiles", 2194 [UTIL_PATTERN_SMPTE] = "smpte", 2195 [UTIL_PATTERN_PLAIN] = "plain", 2196 [UTIL_PATTERN_GRADIENT] = "gradient", 2197 [UTIL_PATTERN_NOISE] = "noise", 2198 [UTIL_PATTERN_NOISE_COLOR] = "noise-color", 2199 [UTIL_PATTERN_BLACK_WHITE] = "black-white", 2200 }; 2201 2202 enum util_fill_pattern util_pattern_enum(const char *name) 2203 { 2204 unsigned int i; 2205 2206 for (i = 0; i < ARRAY_SIZE(pattern_names); i++) 2207 if (!strcmp(pattern_names[i], name)) 2208 return (enum util_fill_pattern)i; 2209 2210 printf("Error: unsupported test pattern %s.\n", name); 2211 return UTIL_PATTERN_SMPTE; 2212 } 2213
Indexes created Fri Jul 31 00:23:59 UTC 2026