1/************************************************************************** 2 * 3 * Copyright 2010 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 18 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 19 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 20 * USE OR OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * The above copyright notice and this permission notice (including the 23 * next paragraph) shall be included in all copies or substantial portions 24 * of the Software. 25 * 26 **************************************************************************/ 27 28 29/** 30 * @file 31 * YUV and RGB subsampled formats conversion. 32 * 33 * @author Jose Fonseca <jfonseca@vmware.com> 34 */ 35 36 37#include "util/u_debug.h" 38#include "util/u_format_yuv.h" 39 40 41void 42util_format_r8g8_b8g8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride, 43 const uint8_t *src_row, unsigned src_stride, 44 unsigned width, unsigned height) 45{ 46 unsigned x, y; 47 48 for (y = 0; y < height; y += 1) { 49 float *dst = dst_row; 50 const uint32_t *src = (const uint32_t *)src_row; 51 uint32_t value; 52 float r, g0, g1, b; 53 54 for (x = 0; x + 1 < width; x += 2) { 55 value = util_cpu_to_le32(*src++); 56 57 r = ubyte_to_float((value >> 0) & 0xff); 58 g0 = ubyte_to_float((value >> 8) & 0xff); 59 b = ubyte_to_float((value >> 16) & 0xff); 60 g1 = ubyte_to_float((value >> 24) & 0xff); 61 62 dst[0] = r; /* r */ 63 dst[1] = g0; /* g */ 64 dst[2] = b; /* b */ 65 dst[3] = 1.0f; /* a */ 66 dst += 4; 67 68 dst[0] = r; /* r */ 69 dst[1] = g1; /* g */ 70 dst[2] = b; /* b */ 71 dst[3] = 1.0f; /* a */ 72 dst += 4; 73 } 74 75 if (x < width) { 76 value = util_cpu_to_le32(*src); 77 78 r = ubyte_to_float((value >> 0) & 0xff); 79 g0 = ubyte_to_float((value >> 8) & 0xff); 80 b = ubyte_to_float((value >> 16) & 0xff); 81 g1 = ubyte_to_float((value >> 24) & 0xff); 82 83 dst[0] = r; /* r */ 84 dst[1] = g0; /* g */ 85 dst[2] = b; /* b */ 86 dst[3] = 1.0f; /* a */ 87 } 88 89 src_row += src_stride/sizeof(*src_row); 90 dst_row += dst_stride/sizeof(*dst_row); 91 } 92} 93 94 95void 96util_format_r8g8_b8g8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 97 const uint8_t *src_row, unsigned src_stride, 98 unsigned width, unsigned height) 99{ 100 unsigned x, y; 101 102 for (y = 0; y < height; y += 1) { 103 uint8_t *dst = dst_row; 104 const uint32_t *src = (const uint32_t *)src_row; 105 uint32_t value; 106 uint8_t r, g0, g1, b; 107 108 for (x = 0; x + 1 < width; x += 2) { 109 value = util_cpu_to_le32(*src++); 110 111 r = (value >> 0) & 0xff; 112 g0 = (value >> 8) & 0xff; 113 b = (value >> 16) & 0xff; 114 g1 = (value >> 24) & 0xff; 115 116 dst[0] = r; /* r */ 117 dst[1] = g0; /* g */ 118 dst[2] = b; /* b */ 119 dst[3] = 0xff; /* a */ 120 dst += 4; 121 122 dst[0] = r; /* r */ 123 dst[1] = g1; /* g */ 124 dst[2] = b; /* b */ 125 dst[3] = 0xff; /* a */ 126 dst += 4; 127 } 128 129 if (x < width) { 130 value = util_cpu_to_le32(*src); 131 132 r = (value >> 0) & 0xff; 133 g0 = (value >> 8) & 0xff; 134 b = (value >> 16) & 0xff; 135 g1 = (value >> 24) & 0xff; 136 137 dst[0] = r; /* r */ 138 dst[1] = g0; /* g */ 139 dst[2] = b; /* b */ 140 dst[3] = 0xff; /* a */ 141 } 142 143 src_row += src_stride/sizeof(*src_row); 144 dst_row += dst_stride/sizeof(*dst_row); 145 } 146} 147 148 149void 150util_format_r8g8_b8g8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 151 const float *src_row, unsigned src_stride, 152 unsigned width, unsigned height) 153{ 154 unsigned x, y; 155 156 for (y = 0; y < height; y += 1) { 157 const float *src = src_row; 158 uint32_t *dst = (uint32_t *)dst_row; 159 float r, g0, g1, b; 160 uint32_t value; 161 162 for (x = 0; x + 1 < width; x += 2) { 163 r = 0.5f*(src[0] + src[4]); 164 g0 = src[1]; 165 g1 = src[5]; 166 b = 0.5f*(src[2] + src[6]); 167 168 value = float_to_ubyte(r); 169 value |= float_to_ubyte(g0) << 8; 170 value |= float_to_ubyte(b) << 16; 171 value |= float_to_ubyte(g1) << 24; 172 173 *dst++ = util_le32_to_cpu(value); 174 175 src += 8; 176 } 177 178 if (x < width) { 179 r = src[0]; 180 g0 = src[1]; 181 g1 = 0; 182 b = src[2]; 183 184 value = float_to_ubyte(r); 185 value |= float_to_ubyte(g0) << 8; 186 value |= float_to_ubyte(b) << 16; 187 value |= float_to_ubyte(g1) << 24; 188 189 *dst = util_le32_to_cpu(value); 190 } 191 192 dst_row += dst_stride/sizeof(*dst_row); 193 src_row += src_stride/sizeof(*src_row); 194 } 195} 196 197 198void 199util_format_r8g8_b8g8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 200 const uint8_t *src_row, unsigned src_stride, 201 unsigned width, unsigned height) 202{ 203 unsigned x, y; 204 205 for (y = 0; y < height; y += 1) { 206 const uint8_t *src = src_row; 207 uint32_t *dst = (uint32_t *)dst_row; 208 uint32_t r, g0, g1, b; 209 uint32_t value; 210 211 for (x = 0; x + 1 < width; x += 2) { 212 r = (src[0] + src[4] + 1) >> 1; 213 g0 = src[1]; 214 g1 = src[5]; 215 b = (src[2] + src[6] + 1) >> 1; 216 217 value = r; 218 value |= g0 << 8; 219 value |= b << 16; 220 value |= g1 << 24; 221 222 *dst++ = util_le32_to_cpu(value); 223 224 src += 8; 225 } 226 227 if (x < width) { 228 r = src[0]; 229 g0 = src[1]; 230 g1 = 0; 231 b = src[2]; 232 233 value = r; 234 value |= g0 << 8; 235 value |= b << 16; 236 value |= g1 << 24; 237 238 *dst = util_le32_to_cpu(value); 239 } 240 241 dst_row += dst_stride/sizeof(*dst_row); 242 src_row += src_stride/sizeof(*src_row); 243 } 244} 245 246 247void 248util_format_r8g8_b8g8_unorm_fetch_rgba_float(float *dst, const uint8_t *src, 249 unsigned i, unsigned j) 250{ 251 assert(i < 2); 252 assert(j < 1); 253 254 dst[0] = ubyte_to_float(src[0]); /* r */ 255 dst[1] = ubyte_to_float(src[1 + 2*i]); /* g */ 256 dst[2] = ubyte_to_float(src[2]); /* b */ 257 dst[3] = 1.0f; /* a */ 258} 259 260 261void 262util_format_g8r8_g8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride, 263 const uint8_t *src_row, unsigned src_stride, 264 unsigned width, unsigned height) 265{ 266 unsigned x, y; 267 268 for (y = 0; y < height; y += 1) { 269 float *dst = dst_row; 270 const uint32_t *src = (const uint32_t *)src_row; 271 uint32_t value; 272 float r, g0, g1, b; 273 274 for (x = 0; x + 1 < width; x += 2) { 275 value = util_cpu_to_le32(*src++); 276 277 g0 = ubyte_to_float((value >> 0) & 0xff); 278 r = ubyte_to_float((value >> 8) & 0xff); 279 g1 = ubyte_to_float((value >> 16) & 0xff); 280 b = ubyte_to_float((value >> 24) & 0xff); 281 282 dst[0] = r; /* r */ 283 dst[1] = g0; /* g */ 284 dst[2] = b; /* b */ 285 dst[3] = 1.0f; /* a */ 286 dst += 4; 287 288 dst[0] = r; /* r */ 289 dst[1] = g1; /* g */ 290 dst[2] = b; /* b */ 291 dst[3] = 1.0f; /* a */ 292 dst += 4; 293 } 294 295 if (x < width) { 296 value = util_cpu_to_le32(*src); 297 298 g0 = ubyte_to_float((value >> 0) & 0xff); 299 r = ubyte_to_float((value >> 8) & 0xff); 300 g1 = ubyte_to_float((value >> 16) & 0xff); 301 b = ubyte_to_float((value >> 24) & 0xff); 302 303 dst[0] = r; /* r */ 304 dst[1] = g0; /* g */ 305 dst[2] = b; /* b */ 306 dst[3] = 1.0f; /* a */ 307 } 308 309 src_row += src_stride/sizeof(*src_row); 310 dst_row += dst_stride/sizeof(*dst_row); 311 } 312} 313 314 315void 316util_format_g8r8_g8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 317 const uint8_t *src_row, unsigned src_stride, 318 unsigned width, unsigned height) 319{ 320 unsigned x, y; 321 322 for (y = 0; y < height; y += 1) { 323 uint8_t *dst = dst_row; 324 const uint32_t *src = (const uint32_t *)src_row; 325 uint32_t value; 326 uint8_t r, g0, g1, b; 327 328 for (x = 0; x + 1 < width; x += 2) { 329 value = util_cpu_to_le32(*src++); 330 331 g0 = (value >> 0) & 0xff; 332 r = (value >> 8) & 0xff; 333 g1 = (value >> 16) & 0xff; 334 b = (value >> 24) & 0xff; 335 336 dst[0] = r; /* r */ 337 dst[1] = g0; /* g */ 338 dst[2] = b; /* b */ 339 dst[3] = 0xff; /* a */ 340 dst += 4; 341 342 dst[0] = r; /* r */ 343 dst[1] = g1; /* g */ 344 dst[2] = b; /* b */ 345 dst[3] = 0xff; /* a */ 346 dst += 4; 347 } 348 349 if (x < width) { 350 value = util_cpu_to_le32(*src); 351 352 g0 = (value >> 0) & 0xff; 353 r = (value >> 8) & 0xff; 354 g1 = (value >> 16) & 0xff; 355 b = (value >> 24) & 0xff; 356 357 dst[0] = r; /* r */ 358 dst[1] = g0; /* g */ 359 dst[2] = b; /* b */ 360 dst[3] = 0xff; /* a */ 361 } 362 363 src_row += src_stride/sizeof(*src_row); 364 dst_row += dst_stride/sizeof(*dst_row); 365 } 366} 367 368 369void 370util_format_g8r8_g8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 371 const float *src_row, unsigned src_stride, 372 unsigned width, unsigned height) 373{ 374 unsigned x, y; 375 376 for (y = 0; y < height; y += 1) { 377 const float *src = src_row; 378 uint32_t *dst = (uint32_t *)dst_row; 379 float r, g0, g1, b; 380 uint32_t value; 381 382 for (x = 0; x + 1 < width; x += 2) { 383 r = 0.5f*(src[0] + src[4]); 384 g0 = src[1]; 385 g1 = src[5]; 386 b = 0.5f*(src[2] + src[6]); 387 388 value = float_to_ubyte(g0); 389 value |= float_to_ubyte(r) << 8; 390 value |= float_to_ubyte(g1) << 16; 391 value |= float_to_ubyte(b) << 24; 392 393 *dst++ = util_le32_to_cpu(value); 394 395 src += 8; 396 } 397 398 if (x < width) { 399 r = src[0]; 400 g0 = src[1]; 401 g1 = 0; 402 b = src[2]; 403 404 value = float_to_ubyte(g0); 405 value |= float_to_ubyte(r) << 8; 406 value |= float_to_ubyte(g1) << 16; 407 value |= float_to_ubyte(b) << 24; 408 409 *dst = util_le32_to_cpu(value); 410 } 411 412 dst_row += dst_stride/sizeof(*dst_row); 413 src_row += src_stride/sizeof(*src_row); 414 } 415} 416 417 418void 419util_format_g8r8_g8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 420 const uint8_t *src_row, unsigned src_stride, 421 unsigned width, unsigned height) 422{ 423 unsigned x, y; 424 425 for (y = 0; y < height; y += 1) { 426 const uint8_t *src = src_row; 427 uint32_t *dst = (uint32_t *)dst_row; 428 uint32_t r, g0, g1, b; 429 uint32_t value; 430 431 for (x = 0; x + 1 < width; x += 2) { 432 r = (src[0] + src[4] + 1) >> 1; 433 g0 = src[1]; 434 g1 = src[5]; 435 b = (src[2] + src[6] + 1) >> 1; 436 437 value = g0; 438 value |= r << 8; 439 value |= g1 << 16; 440 value |= b << 24; 441 442 *dst++ = util_le32_to_cpu(value); 443 444 src += 8; 445 } 446 447 if (x < width) { 448 r = src[0]; 449 g0 = src[1]; 450 g1 = 0; 451 b = src[2]; 452 453 value = g0; 454 value |= r << 8; 455 value |= g1 << 16; 456 value |= b << 24; 457 458 *dst = util_le32_to_cpu(value); 459 } 460 461 dst_row += dst_stride/sizeof(*dst_row); 462 src_row += src_stride/sizeof(*src_row); 463 } 464} 465 466 467void 468util_format_g8r8_g8b8_unorm_fetch_rgba_float(float *dst, const uint8_t *src, 469 unsigned i, unsigned j) 470{ 471 assert(i < 2); 472 assert(j < 1); 473 474 dst[0] = ubyte_to_float(src[1]); /* r */ 475 dst[1] = ubyte_to_float(src[0 + 2*i]); /* g */ 476 dst[2] = ubyte_to_float(src[3]); /* b */ 477 dst[3] = 1.0f; /* a */ 478} 479 480 481void 482util_format_uyvy_unpack_rgba_float(float *dst_row, unsigned dst_stride, 483 const uint8_t *src_row, unsigned src_stride, 484 unsigned width, unsigned height) 485{ 486 unsigned x, y; 487 488 for (y = 0; y < height; y += 1) { 489 float *dst = dst_row; 490 const uint32_t *src = (const uint32_t *)src_row; 491 uint32_t value; 492 uint8_t y0, y1, u, v; 493 494 for (x = 0; x + 1 < width; x += 2) { 495 value = util_cpu_to_le32(*src++); 496 497 u = (value >> 0) & 0xff; 498 y0 = (value >> 8) & 0xff; 499 v = (value >> 16) & 0xff; 500 y1 = (value >> 24) & 0xff; 501 502 util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]); 503 dst[3] = 1.0f; /* a */ 504 dst += 4; 505 506 util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]); 507 dst[3] = 1.0f; /* a */ 508 dst += 4; 509 } 510 511 if (x < width) { 512 value = util_cpu_to_le32(*src); 513 514 u = (value >> 0) & 0xff; 515 y0 = (value >> 8) & 0xff; 516 v = (value >> 16) & 0xff; 517 y1 = (value >> 24) & 0xff; 518 519 util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]); 520 dst[3] = 1.0f; /* a */ 521 } 522 523 src_row += src_stride/sizeof(*src_row); 524 dst_row += dst_stride/sizeof(*dst_row); 525 } 526} 527 528 529void 530util_format_uyvy_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 531 const uint8_t *src_row, unsigned src_stride, 532 unsigned width, unsigned height) 533{ 534 unsigned x, y; 535 536 for (y = 0; y < height; y += 1) { 537 uint8_t *dst = dst_row; 538 const uint32_t *src = (const uint32_t *)src_row; 539 uint32_t value; 540 uint8_t y0, y1, u, v; 541 542 for (x = 0; x + 1 < width; x += 2) { 543 value = util_cpu_to_le32(*src++); 544 545 u = (value >> 0) & 0xff; 546 y0 = (value >> 8) & 0xff; 547 v = (value >> 16) & 0xff; 548 y1 = (value >> 24) & 0xff; 549 550 util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]); 551 dst[3] = 0xff; /* a */ 552 dst += 4; 553 554 util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]); 555 dst[3] = 0xff; /* a */ 556 dst += 4; 557 } 558 559 if (x < width) { 560 value = util_cpu_to_le32(*src); 561 562 u = (value >> 0) & 0xff; 563 y0 = (value >> 8) & 0xff; 564 v = (value >> 16) & 0xff; 565 y1 = (value >> 24) & 0xff; 566 567 util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]); 568 dst[3] = 0xff; /* a */ 569 } 570 571 src_row += src_stride/sizeof(*src_row); 572 dst_row += dst_stride/sizeof(*dst_row); 573 } 574} 575 576 577void 578util_format_uyvy_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 579 const float *src_row, unsigned src_stride, 580 unsigned width, unsigned height) 581{ 582 unsigned x, y; 583 584 for (y = 0; y < height; y += 1) { 585 const float *src = src_row; 586 uint32_t *dst = (uint32_t *)dst_row; 587 uint8_t y0, y1, u, v; 588 uint32_t value; 589 590 for (x = 0; x + 1 < width; x += 2) { 591 uint8_t y0, y1, u0, u1, v0, v1, u, v; 592 593 util_format_rgb_float_to_yuv(src[0], src[1], src[2], 594 &y0, &u0, &v0); 595 util_format_rgb_float_to_yuv(src[4], src[5], src[6], 596 &y1, &u1, &v1); 597 598 u = (u0 + u1 + 1) >> 1; 599 v = (v0 + v1 + 1) >> 1; 600 601 value = u; 602 value |= y0 << 8; 603 value |= v << 16; 604 value |= y1 << 24; 605 606 *dst++ = util_le32_to_cpu(value); 607 608 src += 8; 609 } 610 611 if (x < width) { 612 util_format_rgb_float_to_yuv(src[0], src[1], src[2], 613 &y0, &u, &v); 614 y1 = 0; 615 616 value = u; 617 value |= y0 << 8; 618 value |= v << 16; 619 value |= y1 << 24; 620 621 *dst = util_le32_to_cpu(value); 622 } 623 624 dst_row += dst_stride/sizeof(*dst_row); 625 src_row += src_stride/sizeof(*src_row); 626 } 627} 628 629 630void 631util_format_uyvy_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 632 const uint8_t *src_row, unsigned src_stride, 633 unsigned width, unsigned height) 634{ 635 unsigned x, y; 636 637 for (y = 0; y < height; y += 1) { 638 const uint8_t *src = src_row; 639 uint32_t *dst = (uint32_t *)dst_row; 640 uint8_t y0, y1, u, v; 641 uint32_t value; 642 643 for (x = 0; x + 1 < width; x += 2) { 644 uint8_t y0, y1, u0, u1, v0, v1, u, v; 645 646 util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2], 647 &y0, &u0, &v0); 648 util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6], 649 &y1, &u1, &v1); 650 651 u = (u0 + u1 + 1) >> 1; 652 v = (v0 + v1 + 1) >> 1; 653 654 value = u; 655 value |= y0 << 8; 656 value |= v << 16; 657 value |= y1 << 24; 658 659 *dst++ = util_le32_to_cpu(value); 660 661 src += 8; 662 } 663 664 if (x < width) { 665 util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2], 666 &y0, &u, &v); 667 y1 = 0; 668 669 value = u; 670 value |= y0 << 8; 671 value |= v << 16; 672 value |= y1 << 24; 673 674 *dst = util_le32_to_cpu(value); 675 } 676 677 dst_row += dst_stride/sizeof(*dst_row); 678 src_row += src_stride/sizeof(*src_row); 679 } 680} 681 682 683void 684util_format_uyvy_fetch_rgba_float(float *dst, const uint8_t *src, 685 unsigned i, unsigned j) 686{ 687 uint8_t y, u, v; 688 689 assert(i < 2); 690 assert(j < 1); 691 692 y = src[1 + i*2]; 693 u = src[0]; 694 v = src[2]; 695 696 util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]); 697 698 dst[3] = 1.0f; 699} 700 701 702void 703util_format_yuyv_unpack_rgba_float(float *dst_row, unsigned dst_stride, 704 const uint8_t *src_row, unsigned src_stride, 705 unsigned width, unsigned height) 706{ 707 unsigned x, y; 708 709 for (y = 0; y < height; y += 1) { 710 float *dst = dst_row; 711 const uint32_t *src = (const uint32_t *)src_row; 712 uint32_t value; 713 uint8_t y0, y1, u, v; 714 715 for (x = 0; x + 1 < width; x += 2) { 716 value = util_cpu_to_le32(*src++); 717 718 y0 = (value >> 0) & 0xff; 719 u = (value >> 8) & 0xff; 720 y1 = (value >> 16) & 0xff; 721 v = (value >> 24) & 0xff; 722 723 util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]); 724 dst[3] = 1.0f; /* a */ 725 dst += 4; 726 727 util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]); 728 dst[3] = 1.0f; /* a */ 729 dst += 4; 730 } 731 732 if (x < width) { 733 value = util_cpu_to_le32(*src); 734 735 y0 = (value >> 0) & 0xff; 736 u = (value >> 8) & 0xff; 737 y1 = (value >> 16) & 0xff; 738 v = (value >> 24) & 0xff; 739 740 util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]); 741 dst[3] = 1.0f; /* a */ 742 } 743 744 src_row += src_stride/sizeof(*src_row); 745 dst_row += dst_stride/sizeof(*dst_row); 746 } 747} 748 749 750void 751util_format_yuyv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 752 const uint8_t *src_row, unsigned src_stride, 753 unsigned width, unsigned height) 754{ 755 unsigned x, y; 756 757 for (y = 0; y < height; y += 1) { 758 uint8_t *dst = dst_row; 759 const uint32_t *src = (const uint32_t *)src_row; 760 uint32_t value; 761 uint8_t y0, y1, u, v; 762 763 for (x = 0; x + 1 < width; x += 2) { 764 value = util_cpu_to_le32(*src++); 765 766 y0 = (value >> 0) & 0xff; 767 u = (value >> 8) & 0xff; 768 y1 = (value >> 16) & 0xff; 769 v = (value >> 24) & 0xff; 770 771 util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]); 772 dst[3] = 0xff; /* a */ 773 dst += 4; 774 775 util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]); 776 dst[3] = 0xff; /* a */ 777 dst += 4; 778 } 779 780 if (x < width) { 781 value = util_cpu_to_le32(*src); 782 783 y0 = (value >> 0) & 0xff; 784 u = (value >> 8) & 0xff; 785 y1 = (value >> 16) & 0xff; 786 v = (value >> 24) & 0xff; 787 788 util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]); 789 dst[3] = 0xff; /* a */ 790 } 791 792 src_row += src_stride/sizeof(*src_row); 793 dst_row += dst_stride/sizeof(*dst_row); 794 } 795} 796 797 798void 799util_format_yuyv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 800 const float *src_row, unsigned src_stride, 801 unsigned width, unsigned height) 802{ 803 unsigned x, y; 804 805 for (y = 0; y < height; y += 1) { 806 const float *src = src_row; 807 uint32_t *dst = (uint32_t *)dst_row; 808 uint8_t y0, y1, u, v; 809 uint32_t value; 810 811 for (x = 0; x + 1 < width; x += 2) { 812 uint8_t y0, y1, u0, u1, v0, v1, u, v; 813 814 util_format_rgb_float_to_yuv(src[0], src[1], src[2], 815 &y0, &u0, &v0); 816 util_format_rgb_float_to_yuv(src[4], src[5], src[6], 817 &y1, &u1, &v1); 818 819 u = (u0 + u1 + 1) >> 1; 820 v = (v0 + v1 + 1) >> 1; 821 822 value = y0; 823 value |= u << 8; 824 value |= y1 << 16; 825 value |= v << 24; 826 827 *dst++ = util_le32_to_cpu(value); 828 829 src += 8; 830 } 831 832 if (x < width) { 833 util_format_rgb_float_to_yuv(src[0], src[1], src[2], 834 &y0, &u, &v); 835 y1 = 0; 836 837 value = y0; 838 value |= u << 8; 839 value |= y1 << 16; 840 value |= v << 24; 841 842 *dst = util_le32_to_cpu(value); 843 } 844 845 dst_row += dst_stride/sizeof(*dst_row); 846 src_row += src_stride/sizeof(*src_row); 847 } 848} 849 850 851void 852util_format_yuyv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 853 const uint8_t *src_row, unsigned src_stride, 854 unsigned width, unsigned height) 855{ 856 unsigned x, y; 857 858 for (y = 0; y < height; y += 1) { 859 const uint8_t *src = src_row; 860 uint32_t *dst = (uint32_t *)dst_row; 861 uint8_t y0, y1, u, v; 862 uint32_t value; 863 864 for (x = 0; x + 1 < width; x += 2) { 865 uint8_t y0, y1, u0, u1, v0, v1, u, v; 866 867 util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2], 868 &y0, &u0, &v0); 869 util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6], 870 &y1, &u1, &v1); 871 872 u = (u0 + u1 + 1) >> 1; 873 v = (v0 + v1 + 1) >> 1; 874 875 value = y0; 876 value |= u << 8; 877 value |= y1 << 16; 878 value |= v << 24; 879 880 *dst++ = util_le32_to_cpu(value); 881 882 src += 8; 883 } 884 885 if (x < width) { 886 util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2], 887 &y0, &u, &v); 888 y1 = 0; 889 890 value = y0; 891 value |= u << 8; 892 value |= y1 << 16; 893 value |= v << 24; 894 895 *dst = util_le32_to_cpu(value); 896 } 897 898 dst_row += dst_stride/sizeof(*dst_row); 899 src_row += src_stride/sizeof(*src_row); 900 } 901} 902 903 904void 905util_format_yuyv_fetch_rgba_float(float *dst, const uint8_t *src, 906 unsigned i, unsigned j) 907{ 908 uint8_t y, u, v; 909 910 assert(i < 2); 911 assert(j < 1); 912 913 y = src[0 + i*2]; 914 u = src[1]; 915 v = src[3]; 916 917 util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]); 918 919 dst[3] = 1.0f; 920} 921 922/* XXX: Stubbed for now */ 923void 924util_format_yv12_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 925 const uint8_t *src_row, unsigned src_stride, 926 unsigned width, unsigned height) {} 927void 928util_format_yv12_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 929 const uint8_t *src_row, unsigned src_stride, 930 unsigned width, unsigned height) {} 931void 932util_format_yv12_unpack_rgba_float(float *dst_row, unsigned dst_stride, 933 const uint8_t *src_row, unsigned src_stride, 934 unsigned width, unsigned height) {} 935void 936util_format_yv12_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 937 const float *src_row, unsigned src_stride, 938 unsigned width, unsigned height) {} 939void 940util_format_yv12_fetch_rgba_float(float *dst, const uint8_t *src, 941 unsigned i, unsigned j) {} 942void 943util_format_yv16_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 944 const uint8_t *src_row, unsigned src_stride, 945 unsigned width, unsigned height) {} 946void 947util_format_yv16_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 948 const uint8_t *src_row, unsigned src_stride, 949 unsigned width, unsigned height) {} 950void 951util_format_yv16_unpack_rgba_float(float *dst_row, unsigned dst_stride, 952 const uint8_t *src_row, unsigned src_stride, 953 unsigned width, unsigned height) {} 954void 955util_format_yv16_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 956 const float *src_row, unsigned src_stride, 957 unsigned width, unsigned height) {} 958void 959util_format_yv16_fetch_rgba_float(float *dst, const uint8_t *src, 960 unsigned i, unsigned j) {} 961void 962util_format_iyuv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 963 const uint8_t *src_row, unsigned src_stride, 964 unsigned width, unsigned height) {} 965void 966util_format_iyuv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 967 const uint8_t *src_row, unsigned src_stride, 968 unsigned width, unsigned height) {} 969void 970util_format_iyuv_unpack_rgba_float(float *dst_row, unsigned dst_stride, 971 const uint8_t *src_row, unsigned src_stride, 972 unsigned width, unsigned height) {} 973void 974util_format_iyuv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 975 const float *src_row, unsigned src_stride, 976 unsigned width, unsigned height) {} 977void 978util_format_iyuv_fetch_rgba_float(float *dst, const uint8_t *src, 979 unsigned i, unsigned j) {} 980void 981util_format_nv12_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 982 const uint8_t *src_row, unsigned src_stride, 983 unsigned width, unsigned height) {} 984void 985util_format_nv12_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 986 const uint8_t *src_row, unsigned src_stride, 987 unsigned width, unsigned height) {} 988void 989util_format_nv12_unpack_rgba_float(float *dst_row, unsigned dst_stride, 990 const uint8_t *src_row, unsigned src_stride, 991 unsigned width, unsigned height) {} 992void 993util_format_nv12_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 994 const float *src_row, unsigned src_stride, 995 unsigned width, unsigned height) {} 996void 997util_format_nv12_fetch_rgba_float(float *dst, const uint8_t *src, 998 unsigned i, unsigned j) {} 999void 1000util_format_nv21_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 1001 const uint8_t *src_row, unsigned src_stride, 1002 unsigned width, unsigned height) {} 1003void 1004util_format_nv21_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 1005 const uint8_t *src_row, unsigned src_stride, 1006 unsigned width, unsigned height) {} 1007void 1008util_format_nv21_unpack_rgba_float(float *dst_row, unsigned dst_stride, 1009 const uint8_t *src_row, unsigned src_stride, 1010 unsigned width, unsigned height) {} 1011void 1012util_format_nv21_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 1013 const float *src_row, unsigned src_stride, 1014 unsigned width, unsigned height) {} 1015void 1016util_format_nv21_fetch_rgba_float(float *dst, const uint8_t *src, 1017 unsigned i, unsigned j) {} 1018 1019void 1020util_format_r8g8_r8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride, 1021 const uint8_t *src_row, unsigned src_stride, 1022 unsigned width, unsigned height) {} 1023 1024void 1025util_format_r8g8_r8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 1026 const uint8_t *src_row, unsigned src_stride, 1027 unsigned width, unsigned height) {} 1028 1029void 1030util_format_r8g8_r8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 1031 const float *src_row, unsigned src_stride, 1032 unsigned width, unsigned height) {} 1033 1034void 1035util_format_r8g8_r8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 1036 const uint8_t *src_row, unsigned src_stride, 1037 unsigned width, unsigned height) {} 1038 1039void 1040util_format_r8g8_r8b8_unorm_fetch_rgba_float(float *dst, const uint8_t *src, 1041 unsigned i, unsigned j) {} 1042 1043void 1044util_format_g8r8_b8r8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride, 1045 const uint8_t *src_row, unsigned src_stride, 1046 unsigned width, unsigned height) {} 1047 1048void 1049util_format_g8r8_b8r8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 1050 const uint8_t *src_row, unsigned src_stride, 1051 unsigned width, unsigned height) {} 1052 1053void 1054util_format_g8r8_b8r8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, 1055 const float *src_row, unsigned src_stride, 1056 unsigned width, unsigned height) {} 1057 1058void 1059util_format_g8r8_b8r8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, 1060 const uint8_t *src_row, unsigned src_stride, 1061 unsigned width, unsigned height) {} 1062 1063void 1064util_format_g8r8_b8r8_unorm_fetch_rgba_float(float *dst, const uint8_t *src, 1065 unsigned i, unsigned j) {} 1066