src/mesa/main/format_pack.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (c) 2011 VMware, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /**
  27  * Color, depth, stencil packing functions.
  28  * Used to pack basic color, depth and stencil formats to specific
  29  * hardware formats.
  30  *
  31  * There are both per-pixel and per-row packing functions:
  32  * - The former will be used by swrast to write values to the color, depth,
  33  *   stencil buffers when drawing points, lines and masked spans.
  34  * - The later will be used for image-oriented functions like glDrawPixels,
  35  *   glAccum, and glTexImage.
  36  */
  37
  38
  39 #include "colormac.h"
  40 #include "format_pack.h"
  41 #include "macros.h"
  42 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
  43 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
  44
  45
  46 /** Helper struct for MESA_FORMAT_Z32_FLOAT_S8X24_UINT */
  47 struct z32f_x24s8
  48 {
  49    float z;
  50    uint32_t x24s8;
  51 };
  52
  53
  54 typedef void (*pack_ubyte_rgba_row_func)(GLuint n,
  55                                          const GLubyte src[][4], void *dst);
  56
  57 typedef void (*pack_float_rgba_row_func)(GLuint n,
  58                                          const GLfloat src[][4], void *dst);
  59
  60
  61
  62 static inline GLfloat
  63 linear_to_srgb(GLfloat cl)
  64 {
  65    if (cl < 0.0f)
  66       return 0.0f;
  67    else if (cl < 0.0031308f)
  68       return 12.92f * cl;
  69    else if (cl < 1.0f)
  70       return 1.055f * powf(cl, 0.41666f) - 0.055f;
  71    else
  72       return 1.0f;
  73 }
  74
  75
  76 static inline GLubyte
  77 linear_float_to_srgb_ubyte(GLfloat cl)
  78 {
  79    GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl));
  80    return res;
  81 }
  82
  83
  84 static inline GLubyte
  85 linear_ubyte_to_srgb_ubyte(GLubyte cl)
  86 {
  87    GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl / 255.0f));
  88    return res;
  89 }
  90
  91
  92
  93
  94 /*
  95  * MESA_FORMAT_A8B8G8R8_UNORM
  96  */
  97
  98 static void
  99 pack_ubyte_RGBA8888(const GLubyte src[4], void *dst)
 100 {
 101    GLuint *d = ((GLuint *) dst);
 102    *d = PACK_COLOR_8888(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
 103 }
 104
 105 static void
 106 pack_float_RGBA8888(const GLfloat src[4], void *dst)
 107 {
 108    GLubyte v[4];
 109    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 110    pack_ubyte_RGBA8888(v, dst);
 111 }
 112
 113 static void
 114 pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
 115 {
 116    GLuint *d = ((GLuint *) dst);
 117    GLuint i;
 118    for (i = 0; i < n; i++) {
 119       d[i] = PACK_COLOR_8888(src[i][RCOMP], src[i][GCOMP],
 120                              src[i][BCOMP], src[i][ACOMP]);
 121    }
 122 }
 123
 124 static void
 125 pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
 126 {
 127    GLuint *d = ((GLuint *) dst);
 128    GLuint i;
 129    for (i = 0; i < n; i++) {
 130       GLubyte v[4];
 131       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 132       pack_ubyte_RGBA8888(v, d + i);
 133    }
 134 }
 135
 136
 137
 138 /*
 139  * MESA_FORMAT_R8G8B8A8_UNORM
 140  */
 141
 142 static void
 143 pack_ubyte_RGBA8888_REV(const GLubyte src[4], void *dst)
 144 {
 145    GLuint *d = ((GLuint *) dst);
 146    *d = PACK_COLOR_8888(src[ACOMP], src[BCOMP], src[GCOMP], src[RCOMP]);
 147 }
 148
 149 static void
 150 pack_float_RGBA8888_REV(const GLfloat src[4], void *dst)
 151 {
 152    GLubyte v[4];
 153    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 154    pack_ubyte_RGBA8888_REV(v, dst);
 155 }
 156
 157 static void
 158 pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
 159 {
 160    GLuint *d = ((GLuint *) dst);
 161    GLuint i;
 162    for (i = 0; i < n; i++) {
 163       d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][BCOMP],
 164                              src[i][GCOMP], src[i][RCOMP]);
 165    }
 166 }
 167
 168 static void
 169 pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
 170 {
 171    GLuint *d = ((GLuint *) dst);
 172    GLuint i;
 173    for (i = 0; i < n; i++) {
 174       GLubyte v[4];
 175       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 176       pack_ubyte_RGBA8888_REV(v, d + i);
 177    }
 178 }
 179
 180
 181 /*
 182  * MESA_FORMAT_B8G8R8A8_UNORM
 183  */
 184
 185 static void
 186 pack_ubyte_ARGB8888(const GLubyte src[4], void *dst)
 187 {
 188    GLuint *d = ((GLuint *) dst);
 189    *d = PACK_COLOR_8888(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 190 }
 191
 192 static void
 193 pack_float_ARGB8888(const GLfloat src[4], void *dst)
 194 {
 195    GLubyte v[4];
 196    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 197    pack_ubyte_ARGB8888(v, dst);
 198 }
 199
 200 static void
 201 pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
 202 {
 203    GLuint *d = ((GLuint *) dst);
 204    GLuint i;
 205    for (i = 0; i < n; i++) {
 206       d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][RCOMP],
 207                              src[i][GCOMP], src[i][BCOMP]);
 208    }
 209 }
 210
 211 static void
 212 pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
 213 {
 214    GLuint *d = ((GLuint *) dst);
 215    GLuint i;
 216    for (i = 0; i < n; i++) {
 217       GLubyte v[4];
 218       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 219       pack_ubyte_ARGB8888(v, d + i);
 220    }
 221 }
 222
 223
 224 /*
 225  * MESA_FORMAT_A8R8G8B8_UNORM
 226  */
 227
 228 static void
 229 pack_ubyte_ARGB8888_REV(const GLubyte src[4], void *dst)
 230 {
 231    GLuint *d = ((GLuint *) dst);
 232    *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
 233 }
 234
 235 static void
 236 pack_float_ARGB8888_REV(const GLfloat src[4], void *dst)
 237 {
 238    GLubyte v[4];
 239    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 240    pack_ubyte_ARGB8888_REV(v, dst);
 241 }
 242
 243 static void
 244 pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
 245 {
 246    GLuint *d = ((GLuint *) dst);
 247    GLuint i;
 248    for (i = 0; i < n; i++) {
 249       d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP],
 250                              src[i][RCOMP], src[i][ACOMP]);
 251    }
 252 }
 253
 254 static void
 255 pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
 256 {
 257    GLuint *d = ((GLuint *) dst);
 258    GLuint i;
 259    for (i = 0; i < n; i++) {
 260       GLubyte v[4];
 261       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 262       pack_ubyte_ARGB8888_REV(v, d + i);
 263    }
 264 }
 265
 266
 267 /*
 268  * MESA_FORMAT_B8G8R8X8_UNORM
 269  */
 270
 271 static void
 272 pack_ubyte_XRGB8888(const GLubyte src[4], void *dst)
 273 {
 274    GLuint *d = ((GLuint *) dst);
 275    *d = PACK_COLOR_8888(0x0, src[RCOMP], src[GCOMP], src[BCOMP]);
 276 }
 277
 278 static void
 279 pack_float_XRGB8888(const GLfloat src[4], void *dst)
 280 {
 281    GLubyte v[4];
 282    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 283    pack_ubyte_XRGB8888(v, dst);
 284 }
 285
 286 static void
 287 pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
 288 {
 289    GLuint *d = ((GLuint *) dst);
 290    GLuint i;
 291    for (i = 0; i < n; i++) {
 292       d[i] = PACK_COLOR_8888(0, src[i][RCOMP], src[i][GCOMP], src[i][BCOMP]);
 293    }
 294 }
 295
 296 static void
 297 pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
 298 {
 299    GLuint *d = ((GLuint *) dst);
 300    GLuint i;
 301    for (i = 0; i < n; i++) {
 302       GLubyte v[4];
 303       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 304       pack_ubyte_XRGB8888(v, d + i);
 305    }
 306 }
 307
 308
 309 /*
 310  * MESA_FORMAT_X8R8G8B8_UNORM
 311  */
 312
 313 static void
 314 pack_ubyte_XRGB8888_REV(const GLubyte src[4], void *dst)
 315 {
 316    GLuint *d = ((GLuint *) dst);
 317    *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], 0);
 318 }
 319
 320 static void
 321 pack_float_XRGB8888_REV(const GLfloat src[4], void *dst)
 322 {
 323    GLubyte v[4];
 324    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 325    pack_ubyte_XRGB8888_REV(v, dst);
 326 }
 327
 328 static void
 329 pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
 330 {
 331    GLuint *d = ((GLuint *) dst);
 332    GLuint i;
 333    for (i = 0; i < n; i++) {
 334       d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP], src[i][RCOMP], 0);
 335    }
 336 }
 337
 338 static void
 339 pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
 340 {
 341    GLuint *d = ((GLuint *) dst);
 342    GLuint i;
 343    for (i = 0; i < n; i++) {
 344       GLubyte v[4];
 345       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 346       pack_ubyte_XRGB8888_REV(v, d + i);
 347    }
 348 }
 349
 350
 351 /*
 352  * MESA_FORMAT_BGR_UNORM8
 353  */
 354
 355 static void
 356 pack_ubyte_RGB888(const GLubyte src[4], void *dst)
 357 {
 358    GLubyte *d = ((GLubyte *) dst);
 359    d[2] = src[RCOMP];
 360    d[1] = src[GCOMP];
 361    d[0] = src[BCOMP];
 362 }
 363
 364 static void
 365 pack_float_RGB888(const GLfloat src[4], void *dst)
 366 {
 367    GLubyte *d = ((GLubyte *) dst);
 368    UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[RCOMP]);
 369    UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
 370    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[BCOMP]);
 371 }
 372
 373 static void
 374 pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
 375 {
 376    GLubyte *d = ((GLubyte *) dst);
 377    GLuint i;
 378    for (i = 0; i < n; i++) {
 379       d[i*3+2] = src[i][RCOMP];
 380       d[i*3+1] = src[i][GCOMP];
 381       d[i*3+0] = src[i][BCOMP];
 382    }
 383 }
 384
 385 static void
 386 pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
 387 {
 388    GLubyte *d = ((GLubyte *) dst);
 389    GLuint i;
 390    for (i = 0; i < n; i++) {
 391       GLubyte v[4];
 392       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 393       d[i*3+2] = v[RCOMP];
 394       d[i*3+1] = v[GCOMP];
 395       d[i*3+0] = v[BCOMP];
 396    }
 397 }
 398
 399
 400 /*
 401  * MESA_FORMAT_RGB_UNORM8
 402  */
 403
 404 static void
 405 pack_ubyte_BGR888(const GLubyte src[4], void *dst)
 406 {
 407    GLubyte *d = ((GLubyte *) dst);
 408    d[2] = src[BCOMP];
 409    d[1] = src[GCOMP];
 410    d[0] = src[RCOMP];
 411 }
 412
 413 static void
 414 pack_float_BGR888(const GLfloat src[4], void *dst)
 415 {
 416    GLubyte *d = ((GLubyte *) dst);
 417    UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[BCOMP]);
 418    UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
 419    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
 420 }
 421
 422 static void
 423 pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
 424 {
 425    GLubyte *d = ((GLubyte *) dst);
 426    GLuint i;
 427    for (i = 0; i < n; i++) {
 428       d[i*3+2] = src[i][BCOMP];
 429       d[i*3+1] = src[i][GCOMP];
 430       d[i*3+0] = src[i][RCOMP];
 431    }
 432 }
 433
 434 static void
 435 pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
 436 {
 437    GLubyte *d = ((GLubyte *) dst);
 438    GLuint i;
 439    for (i = 0; i < n; i++) {
 440       GLubyte v[4];
 441       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 442       d[i*3+2] = v[BCOMP];
 443       d[i*3+1] = v[GCOMP];
 444       d[i*3+0] = v[RCOMP];
 445    }
 446 }
 447
 448
 449 /*
 450  * MESA_FORMAT_B5G6R5_UNORM
 451  */
 452
 453 static void
 454 pack_ubyte_RGB565(const GLubyte src[4], void *dst)
 455 {
 456    GLushort *d = ((GLushort *) dst);
 457    *d = PACK_COLOR_565(src[RCOMP], src[GCOMP], src[BCOMP]);
 458 }
 459
 460 static void
 461 pack_float_RGB565(const GLfloat src[4], void *dst)
 462 {
 463    GLubyte v[3];
 464    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 465    UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
 466    UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
 467    pack_ubyte_RGB565(v, dst);
 468 }
 469
 470 static void
 471 pack_row_ubyte_RGB565(GLuint n, const GLubyte src[][4], void *dst)
 472 {
 473    GLushort *d = ((GLushort *) dst);
 474    GLuint i;
 475    for (i = 0; i < n; i++) {
 476       pack_ubyte_RGB565(src[i], d + i);
 477    }
 478 }
 479
 480 static void
 481 pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
 482 {
 483    GLushort *d = ((GLushort *) dst);
 484    GLuint i;
 485    for (i = 0; i < n; i++) {
 486       GLubyte v[4];
 487       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 488       pack_ubyte_RGB565(v, d + i);
 489    }
 490 }
 491
 492
 493 /*
 494  * MESA_FORMAT_R5G6B5_UNORM
 495  * Warning: these functions do not match the current Mesa definition
 496  * of MESA_FORMAT_R5G6B5_UNORM.
 497  */
 498
 499 static void
 500 pack_ubyte_RGB565_REV(const GLubyte src[4], void *dst)
 501 {
 502    GLushort *d = ((GLushort *) dst);
 503    *d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
 504 }
 505
 506 static void
 507 pack_float_RGB565_REV(const GLfloat src[4], void *dst)
 508 {
 509    GLushort *d = ((GLushort *) dst);
 510    GLubyte r, g, b;
 511    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
 512    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
 513    UNCLAMPED_FLOAT_TO_UBYTE(b, src[BCOMP]);
 514    *d = PACK_COLOR_565_REV(r, g, b);
 515 }
 516
 517 static void
 518 pack_row_ubyte_RGB565_REV(GLuint n, const GLubyte src[][4], void *dst)
 519 {
 520    GLushort *d = ((GLushort *) dst);
 521    GLuint i;
 522    for (i = 0; i < n; i++) {
 523       pack_ubyte_RGB565_REV(src[i], d + i);
 524    }
 525 }
 526
 527 static void
 528 pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
 529 {
 530    GLushort *d = ((GLushort *) dst);
 531    GLuint i;
 532    for (i = 0; i < n; i++) {
 533       GLubyte v[4];
 534       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 535       pack_ubyte_RGB565_REV(v, d + i);
 536    }
 537 }
 538
 539
 540 /*
 541  * MESA_FORMAT_B4G4R4A4_UNORM
 542  */
 543
 544 static void
 545 pack_ubyte_ARGB4444(const GLubyte src[4], void *dst)
 546 {
 547    GLushort *d = ((GLushort *) dst);
 548    *d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 549 }
 550
 551 static void
 552 pack_float_ARGB4444(const GLfloat src[4], void *dst)
 553 {
 554    GLubyte v[4];
 555    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 556    pack_ubyte_ARGB4444(v, dst);
 557 }
 558
 559 /* use fallback row packing functions */
 560
 561
 562 /*
 563  * MESA_FORMAT_A4R4G4B4_UNORM
 564  */
 565
 566 static void
 567 pack_ubyte_ARGB4444_REV(const GLubyte src[4], void *dst)
 568 {
 569    GLushort *d = ((GLushort *) dst);
 570    *d = PACK_COLOR_4444(src[GCOMP], src[BCOMP], src[ACOMP], src[RCOMP]);
 571 }
 572
 573 static void
 574 pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
 575 {
 576    GLubyte v[4];
 577    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 578    pack_ubyte_ARGB4444_REV(v, dst);
 579 }
 580
 581 /* use fallback row packing functions */
 582
 583
 584 /*
 585  * MESA_FORMAT_A1B5G5R5_UNORM
 586  */
 587
 588 static void
 589 pack_ubyte_RGBA5551(const GLubyte src[4], void *dst)
 590 {
 591    GLushort *d = ((GLushort *) dst);
 592    *d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
 593 }
 594
 595 static void
 596 pack_float_RGBA5551(const GLfloat src[4], void *dst)
 597 {
 598    GLubyte v[4];
 599    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 600    pack_ubyte_RGBA5551(v, dst);
 601 }
 602
 603 /* use fallback row packing functions */
 604
 605
 606 /*
 607  * MESA_FORMAT_B5G5R5A1_UNORM
 608  */
 609
 610 static void
 611 pack_ubyte_ARGB1555(const GLubyte src[4], void *dst)
 612 {
 613    GLushort *d = ((GLushort *) dst);
 614    *d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 615 }
 616
 617 static void
 618 pack_float_ARGB1555(const GLfloat src[4], void *dst)
 619 {
 620    GLubyte v[4];
 621    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 622    pack_ubyte_ARGB1555(v, dst);
 623 }
 624
 625
 626 /* MESA_FORMAT_A1R5G5B5_UNORM
 627  * Warning: these functions do not match the current Mesa definition
 628  * of MESA_FORMAT_A1R5G5B5_UNORM.
 629  */
 630
 631 static void
 632 pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
 633 {
 634    GLushort *d = ((GLushort *) dst), tmp;
 635    tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 636    *d = (tmp >> 8) | (tmp << 8);
 637 }
 638
 639 static void
 640 pack_float_ARGB1555_REV(const GLfloat src[4], void *dst)
 641 {
 642    GLubyte v[4];
 643    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 644    pack_ubyte_ARGB1555_REV(v, dst);
 645 }
 646
 647
 648 /* MESA_FORMAT_L4A4_UNORM */
 649
 650 static void
 651 pack_ubyte_AL44(const GLubyte src[4], void *dst)
 652 {
 653    GLubyte *d = ((GLubyte *) dst);
 654    *d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
 655 }
 656
 657 static void
 658 pack_float_AL44(const GLfloat src[4], void *dst)
 659 {
 660    GLubyte v[4];
 661    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 662    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
 663    pack_ubyte_AL44(v, dst);
 664 }
 665
 666
 667 /* MESA_FORMAT_L8A8_UNORM */
 668
 669 static void
 670 pack_ubyte_AL88(const GLubyte src[4], void *dst)
 671 {
 672    GLushort *d = ((GLushort *) dst);
 673    *d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
 674 }
 675
 676 static void
 677 pack_float_AL88(const GLfloat src[4], void *dst)
 678 {
 679    GLubyte v[4];
 680    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 681    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
 682    pack_ubyte_AL88(v, dst);
 683 }
 684
 685
 686 /* MESA_FORMAT_A8L8_UNORM */
 687
 688 static void
 689 pack_ubyte_AL88_REV(const GLubyte src[4], void *dst)
 690 {
 691    GLushort *d = ((GLushort *) dst);
 692    *d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
 693 }
 694
 695 static void
 696 pack_float_AL88_REV(const GLfloat src[4], void *dst)
 697 {
 698    GLubyte v[4];
 699    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 700    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
 701    pack_ubyte_AL88_REV(v, dst);
 702 }
 703
 704
 705 /* MESA_FORMAT_L16A16_UNORM */
 706
 707 static void
 708 pack_ubyte_AL1616(const GLubyte src[4], void *dst)
 709 {
 710    GLuint *d = ((GLuint *) dst);
 711    GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
 712    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
 713    *d = PACK_COLOR_1616(a, l);
 714 }
 715
 716 static void
 717 pack_float_AL1616(const GLfloat src[4], void *dst)
 718 {
 719    GLuint *d = ((GLuint *) dst);
 720    GLushort l, a;
 721    UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
 722    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
 723    *d = PACK_COLOR_1616(a, l);
 724 }
 725
 726
 727 /* MESA_FORMAT_A16L16_UNORM */
 728
 729 static void
 730 pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
 731 {
 732    GLuint *d = ((GLuint *) dst);
 733    GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
 734    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
 735    *d = PACK_COLOR_1616(l, a);
 736 }
 737
 738 static void
 739 pack_float_AL1616_REV(const GLfloat src[4], void *dst)
 740 {
 741    GLuint *d = ((GLuint *) dst);
 742    GLushort l, a;
 743    UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
 744    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
 745    *d = PACK_COLOR_1616(l, a);
 746 }
 747
 748
 749 /* MESA_FORMAT_B2G3R3_UNORM */
 750
 751 static void
 752 pack_ubyte_RGB332(const GLubyte src[4], void *dst)
 753 {
 754    GLubyte *d = ((GLubyte *) dst);
 755    *d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
 756 }
 757
 758 static void
 759 pack_float_RGB332(const GLfloat src[4], void *dst)
 760 {
 761    GLubyte v[4];
 762    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 763    UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
 764    UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
 765    pack_ubyte_RGB332(v, dst);
 766 }
 767
 768
 769 /* MESA_FORMAT_A_UNORM8 */
 770
 771 static void
 772 pack_ubyte_A8(const GLubyte src[4], void *dst)
 773 {
 774    GLubyte *d = ((GLubyte *) dst);
 775    *d = src[ACOMP];
 776 }
 777
 778 static void
 779 pack_float_A8(const GLfloat src[4], void *dst)
 780 {
 781    GLubyte *d = ((GLubyte *) dst);
 782    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
 783 }
 784
 785
 786 /* MESA_FORMAT_A_UNORM16 */
 787
 788 static void
 789 pack_ubyte_A16(const GLubyte src[4], void *dst)
 790 {
 791    GLushort *d = ((GLushort *) dst);
 792    *d = UBYTE_TO_USHORT(src[ACOMP]);
 793 }
 794
 795 static void
 796 pack_float_A16(const GLfloat src[4], void *dst)
 797 {
 798    GLushort *d = ((GLushort *) dst);
 799    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
 800 }
 801
 802
 803 /* MESA_FORMAT_L_UNORM8 */
 804
 805 static void
 806 pack_ubyte_L8(const GLubyte src[4], void *dst)
 807 {
 808    GLubyte *d = ((GLubyte *) dst);
 809    *d = src[RCOMP];
 810 }
 811
 812 static void
 813 pack_float_L8(const GLfloat src[4], void *dst)
 814 {
 815    GLubyte *d = ((GLubyte *) dst);
 816    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
 817 }
 818
 819
 820 /* MESA_FORMAT_L_UNORM16 */
 821
 822 static void
 823 pack_ubyte_L16(const GLubyte src[4], void *dst)
 824 {
 825    GLushort *d = ((GLushort *) dst);
 826    *d = UBYTE_TO_USHORT(src[RCOMP]);
 827 }
 828
 829 static void
 830 pack_float_L16(const GLfloat src[4], void *dst)
 831 {
 832    GLushort *d = ((GLushort *) dst);
 833    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
 834 }
 835
 836
 837 /* MESA_FORMAT_YCBCR */
 838
 839 static void
 840 pack_ubyte_YCBCR(const GLubyte src[4], void *dst)
 841 {
 842    /* todo */
 843 }
 844
 845 static void
 846 pack_float_YCBCR(const GLfloat src[4], void *dst)
 847 {
 848    /* todo */
 849 }
 850
 851
 852 /* MESA_FORMAT_YCBCR_REV */
 853
 854 static void
 855 pack_ubyte_YCBCR_REV(const GLubyte src[4], void *dst)
 856 {
 857    /* todo */
 858 }
 859
 860 static void
 861 pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
 862 {
 863    /* todo */
 864 }
 865
 866
 867 /* MESA_FORMAT_R_UNORM8 */
 868
 869 static void
 870 pack_ubyte_R8(const GLubyte src[4], void *dst)
 871 {
 872    GLubyte *d = ((GLubyte *) dst);
 873    *d = src[RCOMP];
 874 }
 875
 876 static void
 877 pack_float_R8(const GLfloat src[4], void *dst)
 878 {
 879    GLubyte *d = ((GLubyte *) dst);
 880    GLubyte r;
 881    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
 882    d[0] = r;
 883 }
 884
 885
 886 /* MESA_FORMAT_R8G8_UNORM */
 887
 888 static void
 889 pack_ubyte_GR88(const GLubyte src[4], void *dst)
 890 {
 891    GLubyte *d = ((GLubyte *) dst);
 892    *d = PACK_COLOR_88(src[GCOMP], src[RCOMP]);
 893 }
 894
 895 static void
 896 pack_float_GR88(const GLfloat src[4], void *dst)
 897 {
 898    GLushort *d = ((GLushort *) dst);
 899    GLubyte r, g;
 900    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
 901    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
 902    *d = PACK_COLOR_88(g, r);
 903 }
 904
 905
 906 /* MESA_FORMAT_G8R8_UNORM */
 907
 908 static void
 909 pack_ubyte_RG88(const GLubyte src[4], void *dst)
 910 {
 911    GLubyte *d = ((GLubyte *) dst);
 912    *d = PACK_COLOR_88(src[RCOMP], src[GCOMP]);
 913 }
 914
 915 static void
 916 pack_float_RG88(const GLfloat src[4], void *dst)
 917 {
 918    GLushort *d = ((GLushort *) dst);
 919    GLubyte r, g;
 920    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
 921    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
 922    *d = PACK_COLOR_88(r, g);
 923 }
 924
 925
 926 /* MESA_FORMAT_R_UNORM16 */
 927
 928 static void
 929 pack_ubyte_R16(const GLubyte src[4], void *dst)
 930 {
 931    GLushort *d = ((GLushort *) dst);
 932    *d = UBYTE_TO_USHORT(src[RCOMP]);
 933 }
 934
 935 static void
 936 pack_float_R16(const GLfloat src[4], void *dst)
 937 {
 938    GLushort *d = ((GLushort *) dst);
 939    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
 940 }
 941
 942
 943 /* MESA_FORMAT_R16G16_UNORM */
 944
 945 static void
 946 pack_ubyte_GR1616(const GLubyte src[4], void *dst)
 947 {
 948    GLuint *d = ((GLuint *) dst);
 949    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
 950    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
 951    *d = PACK_COLOR_1616(g, r);
 952 }
 953
 954 static void
 955 pack_float_GR1616(const GLfloat src[4], void *dst)
 956 {
 957    GLuint *d = ((GLuint *) dst);
 958    GLushort r, g;
 959    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
 960    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
 961    *d = PACK_COLOR_1616(g, r);
 962 }
 963
 964
 965 /* MESA_FORMAT_G16R16_UNORM */
 966
 967 static void
 968 pack_ubyte_RG1616(const GLubyte src[4], void *dst)
 969 {
 970    GLuint *d = ((GLuint *) dst);
 971    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
 972    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
 973    *d = PACK_COLOR_1616(r, g);
 974 }
 975
 976
 977 static void
 978 pack_float_RG1616(const GLfloat src[4], void *dst)
 979 {
 980    GLuint *d = ((GLuint *) dst);
 981    GLushort r, g;
 982    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
 983    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
 984    *d = PACK_COLOR_1616(r, g);
 985 }
 986
 987
 988 /* MESA_FORMAT_B10G10R10A2_UNORM */
 989
 990 static void
 991 pack_ubyte_ARGB2101010(const GLubyte src[4], void *dst)
 992 {
 993    GLuint *d = ((GLuint *) dst);
 994    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
 995    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
 996    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
 997    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
 998    *d = PACK_COLOR_2101010_US(a, r, g, b);
 999 }
1000
1001 static void
1002 pack_float_ARGB2101010(const GLfloat src[4], void *dst)
1003 {
1004    GLuint *d = ((GLuint *) dst);
1005    GLushort r, g, b, a;
1006    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1007    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1008    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1009    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1010    *d = PACK_COLOR_2101010_US(a, r, g, b);
1011 }
1012
1013
1014 /* MESA_FORMAT_R10G10B10A2_UINT */
1015
1016 static void
1017 pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst)
1018 {
1019    GLuint *d = ((GLuint *) dst);
1020    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1021    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1022    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1023    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1024    *d = PACK_COLOR_2101010_US(a, b, g, r);
1025 }
1026
1027 static void
1028 pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst)
1029 {
1030    GLuint *d = ((GLuint *) dst);
1031    GLushort r, g, b, a;
1032    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1033    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1034    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1035    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1036    *d = PACK_COLOR_2101010_US(a, b, g, r);
1037 }
1038
1039
1040 /* MESA_FORMAT_BGR_SRGB8 */
1041
1042 static void
1043 pack_ubyte_SRGB8(const GLubyte src[4], void *dst)
1044 {
1045    GLubyte *d = ((GLubyte *) dst);
1046    d[2] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1047    d[1] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1048    d[0] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1049 }
1050
1051 static void
1052 pack_float_SRGB8(const GLfloat src[4], void *dst)
1053 {
1054    GLubyte *d = ((GLubyte *) dst);
1055    d[2] = linear_float_to_srgb_ubyte(src[RCOMP]);
1056    d[1] = linear_float_to_srgb_ubyte(src[GCOMP]);
1057    d[0] = linear_float_to_srgb_ubyte(src[BCOMP]);
1058 }
1059
1060
1061 /* MESA_FORMAT_A8B8G8R8_SRGB */
1062
1063 static void
1064 pack_ubyte_SRGBA8(const GLubyte src[4], void *dst)
1065 {
1066    GLuint *d = ((GLuint *) dst);
1067    GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1068    GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1069    GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1070    *d = PACK_COLOR_8888(r, g, b, src[ACOMP]);
1071 }
1072
1073 static void
1074 pack_float_SRGBA8(const GLfloat src[4], void *dst)
1075 {
1076    GLuint *d = ((GLuint *) dst);
1077    GLubyte r, g, b, a;
1078    r = linear_float_to_srgb_ubyte(src[RCOMP]);
1079    g = linear_float_to_srgb_ubyte(src[GCOMP]);
1080    b = linear_float_to_srgb_ubyte(src[BCOMP]);
1081    UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1082    *d = PACK_COLOR_8888(r, g, b, a);
1083 }
1084
1085
1086 /* MESA_FORMAT_B8G8R8A8_SRGB */
1087
1088 static void
1089 pack_ubyte_SARGB8(const GLubyte src[4], void *dst)
1090 {
1091    GLuint *d = ((GLuint *) dst);
1092    GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1093    GLubyte g = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1094    GLubyte b = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1095    *d = PACK_COLOR_8888(src[ACOMP], r, g, b);
1096 }
1097
1098 static void
1099 pack_float_SARGB8(const GLfloat src[4], void *dst)
1100 {
1101    GLuint *d = ((GLuint *) dst);
1102    GLubyte r, g, b, a;
1103    r = linear_float_to_srgb_ubyte(src[RCOMP]);
1104    g = linear_float_to_srgb_ubyte(src[GCOMP]);
1105    b = linear_float_to_srgb_ubyte(src[BCOMP]);
1106    UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1107    *d = PACK_COLOR_8888(a, r, g, b);
1108 }
1109
1110
1111 /* MESA_FORMAT_L_SRGB8 */
1112
1113 static void
1114 pack_ubyte_SL8(const GLubyte src[4], void *dst)
1115 {
1116    GLubyte *d = ((GLubyte *) dst);
1117    *d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1118 }
1119
1120 static void
1121 pack_float_SL8(const GLfloat src[4], void *dst)
1122 {
1123    GLubyte *d = ((GLubyte *) dst);
1124    GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
1125    *d = l;
1126 }
1127
1128
1129 /* MESA_FORMAT_L8A8_SRGB */
1130
1131 static void
1132 pack_ubyte_SLA8(const GLubyte src[4], void *dst)
1133 {
1134    GLushort *d = ((GLushort *) dst);
1135    GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1136    *d = PACK_COLOR_88(src[ACOMP], l);
1137 }
1138
1139 static void
1140 pack_float_SLA8(const GLfloat src[4], void *dst)
1141 {
1142    GLushort *d = ((GLushort *) dst);
1143    GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
1144    CLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1145    *d = PACK_COLOR_88(a, l);
1146 }
1147
1148
1149 /* MESA_FORMAT_RGBA_FLOAT32 */
1150
1151 static void
1152 pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
1153 {
1154    GLfloat *d = ((GLfloat *) dst);
1155    d[0] = UBYTE_TO_FLOAT(src[0]);
1156    d[1] = UBYTE_TO_FLOAT(src[1]);
1157    d[2] = UBYTE_TO_FLOAT(src[2]);
1158    d[3] = UBYTE_TO_FLOAT(src[3]);
1159 }
1160
1161 static void
1162 pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
1163 {
1164    GLfloat *d = ((GLfloat *) dst);
1165    d[0] = src[0];
1166    d[1] = src[1];
1167    d[2] = src[2];
1168    d[3] = src[3];
1169 }
1170
1171
1172 /* MESA_FORMAT_RGBA_FLOAT16 */
1173
1174 static void
1175 pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
1176 {
1177    GLhalfARB *d = ((GLhalfARB *) dst);
1178    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1179    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1180    d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1181    d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
1182 }
1183
1184 static void
1185 pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
1186 {
1187    GLhalfARB *d = ((GLhalfARB *) dst);
1188    d[0] = _mesa_float_to_half(src[0]);
1189    d[1] = _mesa_float_to_half(src[1]);
1190    d[2] = _mesa_float_to_half(src[2]);
1191    d[3] = _mesa_float_to_half(src[3]);
1192 }
1193
1194
1195 /* MESA_FORMAT_RGB_FLOAT32 */
1196
1197 static void
1198 pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
1199 {
1200    GLfloat *d = ((GLfloat *) dst);
1201    d[0] = UBYTE_TO_FLOAT(src[0]);
1202    d[1] = UBYTE_TO_FLOAT(src[1]);
1203    d[2] = UBYTE_TO_FLOAT(src[2]);
1204 }
1205
1206 static void
1207 pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
1208 {
1209    GLfloat *d = ((GLfloat *) dst);
1210    d[0] = src[0];
1211    d[1] = src[1];
1212    d[2] = src[2];
1213 }
1214
1215
1216 /* MESA_FORMAT_RGB_FLOAT16 */
1217
1218 static void
1219 pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
1220 {
1221    GLhalfARB *d = ((GLhalfARB *) dst);
1222    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1223    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1224    d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1225 }
1226
1227 static void
1228 pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
1229 {
1230    GLhalfARB *d = ((GLhalfARB *) dst);
1231    d[0] = _mesa_float_to_half(src[0]);
1232    d[1] = _mesa_float_to_half(src[1]);
1233    d[2] = _mesa_float_to_half(src[2]);
1234 }
1235
1236
1237 /* MESA_FORMAT_A_FLOAT32 */
1238
1239 static void
1240 pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
1241 {
1242    GLfloat *d = ((GLfloat *) dst);
1243    d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
1244 }
1245
1246 static void
1247 pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
1248 {
1249    GLfloat *d = ((GLfloat *) dst);
1250    d[0] = src[ACOMP];
1251 }
1252
1253
1254 /* MESA_FORMAT_A_FLOAT16 */
1255
1256 static void
1257 pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
1258 {
1259    GLhalfARB *d = ((GLhalfARB *) dst);
1260    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1261 }
1262
1263 static void
1264 pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1265 {
1266    GLhalfARB *d = ((GLhalfARB *) dst);
1267    d[0] = _mesa_float_to_half(src[ACOMP]);
1268 }
1269
1270
1271 /* MESA_FORMAT_L_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
1272
1273 static void
1274 pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
1275 {
1276    GLfloat *d = ((GLfloat *) dst);
1277    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1278 }
1279
1280 static void
1281 pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
1282 {
1283    GLfloat *d = ((GLfloat *) dst);
1284    d[0] = src[RCOMP];
1285 }
1286
1287
1288 /* MESA_FORMAT_L_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
1289
1290 static void
1291 pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
1292 {
1293    GLhalfARB *d = ((GLhalfARB *) dst);
1294    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1295 }
1296
1297 static void
1298 pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
1299 {
1300    GLhalfARB *d = ((GLhalfARB *) dst);
1301    d[0] = _mesa_float_to_half(src[RCOMP]);
1302 }
1303
1304
1305 /* MESA_FORMAT_LA_FLOAT32 */
1306
1307 static void
1308 pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
1309 {
1310    GLfloat *d = ((GLfloat *) dst);
1311    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1312    d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
1313 }
1314
1315 static void
1316 pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
1317 {
1318    GLfloat *d = ((GLfloat *) dst);
1319    d[0] = src[RCOMP];
1320    d[1] = src[ACOMP];
1321 }
1322
1323
1324 /* MESA_FORMAT_LA_FLOAT16 */
1325
1326 static void
1327 pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
1328 {
1329    GLhalfARB *d = ((GLhalfARB *) dst);
1330    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1331    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1332 }
1333
1334 static void
1335 pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1336 {
1337    GLhalfARB *d = ((GLhalfARB *) dst);
1338    d[0] = _mesa_float_to_half(src[RCOMP]);
1339    d[1] = _mesa_float_to_half(src[ACOMP]);
1340 }
1341
1342
1343 /* MESA_FORMAT_RG_FLOAT32 */
1344
1345 static void
1346 pack_ubyte_RG_FLOAT32(const GLubyte src[4], void *dst)
1347 {
1348    GLfloat *d = ((GLfloat *) dst);
1349    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1350    d[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1351 }
1352
1353 static void
1354 pack_float_RG_FLOAT32(const GLfloat src[4], void *dst)
1355 {
1356    GLfloat *d = ((GLfloat *) dst);
1357    d[0] = src[RCOMP];
1358    d[1] = src[GCOMP];
1359 }
1360
1361
1362 /* MESA_FORMAT_RG_FLOAT16 */
1363
1364 static void
1365 pack_ubyte_RG_FLOAT16(const GLubyte src[4], void *dst)
1366 {
1367    GLhalfARB *d = ((GLhalfARB *) dst);
1368    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1369    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[GCOMP]));
1370 }
1371
1372 static void
1373 pack_float_RG_FLOAT16(const GLfloat src[4], void *dst)
1374 {
1375    GLhalfARB *d = ((GLhalfARB *) dst);
1376    d[0] = _mesa_float_to_half(src[RCOMP]);
1377    d[1] = _mesa_float_to_half(src[GCOMP]);
1378 }
1379
1380
1381 /* MESA_FORMAT_DUDV8 */
1382
1383 static void
1384 pack_ubyte_DUDV8(const GLubyte src[4], void *dst)
1385 {
1386    /* XXX is this ever used? */
1387    GLushort *d = ((GLushort *) dst);
1388    *d = PACK_COLOR_88(src[0], src[1]);
1389 }
1390
1391 static void
1392 pack_float_DUDV8(const GLfloat src[4], void *dst)
1393 {
1394    GLushort *d = ((GLushort *) dst);
1395    GLbyte du, dv;
1396    du = FLOAT_TO_BYTE(CLAMP(src[0], 0.0F, 1.0F));
1397    dv = FLOAT_TO_BYTE(CLAMP(src[1], 0.0F, 1.0F));
1398    *d = PACK_COLOR_88(du, dv);
1399 }
1400
1401
1402 /* MESA_FORMAT_RGBA_UNORM16 */
1403
1404 static void
1405 pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
1406 {
1407    GLushort *d = ((GLushort *) dst);
1408    d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1409    d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1410    d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1411    d[3] = UBYTE_TO_USHORT(src[ACOMP]);
1412 }
1413
1414 static void
1415 pack_float_RGBA_16(const GLfloat src[4], void *dst)
1416 {
1417    GLushort *d = ((GLushort *) dst);
1418    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1419    UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1420    UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1421    UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
1422 }
1423
1424
1425
1426 /*
1427  * MESA_FORMAT_R_SNORM8
1428  */
1429
1430 static void
1431 pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
1432 {
1433    GLbyte *d = (GLbyte *) dst;
1434    *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1435 }
1436
1437
1438 /*
1439  * MESA_FORMAT_R8G8_SNORM
1440  */
1441
1442 static void
1443 pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
1444 {
1445    GLushort *d = (GLushort *) dst;
1446    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1447    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1448    *d = (g << 8) | r;
1449 }
1450
1451
1452 /*
1453  * MESA_FORMAT_X8B8G8R8_SNORM
1454  */
1455
1456 static void
1457 pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
1458 {
1459    GLuint *d = (GLuint *) dst;
1460    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1461    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1462    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1463    GLbyte a = 127;
1464    *d = PACK_COLOR_8888(r, g, b, a);
1465 }
1466
1467
1468 /*
1469  * MESA_FORMAT_A8B8G8R8_SNORM
1470  */
1471
1472 static void
1473 pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
1474 {
1475    GLuint *d = (GLuint *) dst;
1476    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1477    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1478    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1479    GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1480    *d = PACK_COLOR_8888(r, g, b, a);
1481 }
1482
1483
1484 /*
1485  * MESA_FORMAT_R8G8B8A8_SNORM
1486  */
1487
1488 static void
1489 pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
1490 {
1491    GLuint *d = (GLuint *) dst;
1492    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1493    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1494    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1495    GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1496    *d = PACK_COLOR_8888(a, b, g, r);
1497 }
1498
1499
1500 /*
1501  * MESA_FORMAT_R_SNORM16
1502  */
1503
1504 static void
1505 pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
1506 {
1507    GLshort *d = (GLshort *) dst;
1508    *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1509 }
1510
1511
1512 /*
1513  * MESA_FORMAT_R16G16_SNORM
1514  */
1515
1516 static void
1517 pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
1518 {
1519    GLuint *d = (GLuint *) dst;
1520    GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1521    GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1522    *d = (g << 16) | (r & 0xffff);
1523 }
1524
1525
1526 /*
1527  * MESA_FORMAT_RGB_SNORM16
1528  */
1529
1530 static void
1531 pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
1532 {
1533    GLshort *d = (GLshort *) dst;
1534    d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1535    d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1536    d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1537 }
1538
1539
1540 /*
1541  * MESA_FORMAT_RGBA_SNORM16
1542  */
1543
1544 static void
1545 pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
1546 {
1547    GLshort *d = (GLshort *) dst;
1548    d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1549    d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1550    d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1551    d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1552 }
1553
1554
1555 /*
1556  * MESA_FORMAT_A_SNORM8
1557  */
1558
1559 static void
1560 pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
1561 {
1562    GLbyte *d = (GLbyte *) dst;
1563    *d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1564 }
1565
1566
1567 /*
1568  * MESA_FORMAT_L_SNORM8
1569  */
1570
1571 static void
1572 pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
1573 {
1574    GLbyte *d = (GLbyte *) dst;
1575    *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1576 }
1577
1578
1579 /*
1580  * MESA_FORMAT_L8A8_SNORM
1581  */
1582
1583 static void
1584 pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
1585 {
1586    GLushort *d = (GLushort *) dst;
1587    GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1588    GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1589    *d = (a << 8) | l;
1590 }
1591
1592
1593 /*
1594  * MESA_FORMAT_A_SNORM16
1595  */
1596
1597 static void
1598 pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
1599 {
1600    GLshort *d = (GLshort *) dst;
1601    *d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1602 }
1603
1604
1605 /*
1606  * MESA_FORMAT_L_SNORM16
1607  */
1608
1609 static void
1610 pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
1611 {
1612    GLshort *d = (GLshort *) dst;
1613    *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1614 }
1615
1616
1617 /*
1618  * MESA_FORMAT_LA_SNORM16
1619  */
1620
1621 static void
1622 pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
1623 {
1624    GLuint *d = (GLuint *) dst;
1625    GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1626    GLshort a = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1627    *d = PACK_COLOR_1616(a, l);
1628 }
1629
1630
1631 /*
1632  * MESA_FORMAT_R9G9B9E5_FLOAT;
1633  */
1634
1635 static void
1636 pack_float_RGB9_E5_FLOAT(const GLfloat src[4], void *dst)
1637 {
1638    GLuint *d = (GLuint *) dst;
1639    *d = float3_to_rgb9e5(src);
1640 }
1641
1642 static void
1643 pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
1644 {
1645    GLuint *d = (GLuint *) dst;
1646    GLfloat rgb[3];
1647    rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1648    rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1649    rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1650    *d = float3_to_rgb9e5(rgb);
1651 }
1652
1653
1654
1655 /*
1656  * MESA_FORMAT_R11G11B10_FLOAT;
1657  */
1658
1659 static void
1660 pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
1661 {
1662    GLuint *d = (GLuint *) dst;
1663    GLfloat rgb[3];
1664    rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1665    rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1666    rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1667    *d = float3_to_r11g11b10f(rgb);
1668 }
1669
1670 static void
1671 pack_float_R11_G11_B10_FLOAT(const GLfloat src[4], void *dst)
1672 {
1673    GLuint *d = (GLuint *) dst;
1674    *d = float3_to_r11g11b10f(src);
1675 }
1676
1677
1678 /*
1679  * MESA_FORMAT_B4G4R4X4_UNORM
1680  */
1681
1682 static void
1683 pack_ubyte_XRGB4444_UNORM(const GLubyte src[4], void *dst)
1684 {
1685    GLushort *d = ((GLushort *) dst);
1686    *d = PACK_COLOR_4444(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1687 }
1688
1689 static void
1690 pack_float_XRGB4444_UNORM(const GLfloat src[4], void *dst)
1691 {
1692    GLubyte v[4];
1693    _mesa_unclamped_float_rgba_to_ubyte(v, src);
1694    pack_ubyte_XRGB4444_UNORM(v, dst);
1695 }
1696
1697
1698 /*
1699  * MESA_FORMAT_B5G5R5X1_UNORM
1700  */
1701
1702 static void
1703 pack_ubyte_XRGB1555_UNORM(const GLubyte src[4], void *dst)
1704 {
1705    GLushort *d = ((GLushort *) dst);
1706    *d = PACK_COLOR_1555(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1707 }
1708
1709 static void
1710 pack_float_XRGB1555_UNORM(const GLfloat src[4], void *dst)
1711 {
1712    GLubyte v[4];
1713    _mesa_unclamped_float_rgba_to_ubyte(v, src);
1714    pack_ubyte_XRGB1555_UNORM(v, dst);
1715 }
1716
1717
1718 /*
1719  * MESA_FORMAT_R8G8B8X8_SNORM
1720  */
1721
1722 static void
1723 pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
1724 {
1725    GLuint *d = (GLuint *) dst;
1726    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1727    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1728    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1729    *d = PACK_COLOR_8888(127, b, g, r);
1730 }
1731
1732
1733 /*
1734  * MESA_FORMAT_R8G8B8X8_SRGB
1735  */
1736
1737 static void
1738 pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
1739 {
1740    GLuint *d = (GLuint *) dst;
1741    GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1742    GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1743    GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1744    *d = PACK_COLOR_8888(127, b, g, r);
1745 }
1746
1747
1748 /* MESA_FORMAT_B10G10R10X2_UNORM */
1749
1750 static void
1751 pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
1752 {
1753    GLuint *d = ((GLuint *) dst);
1754    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1755    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1756    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1757    *d = PACK_COLOR_2101010_US(3, r, g, b);
1758 }
1759
1760 static void
1761 pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
1762 {
1763    GLuint *d = ((GLuint *) dst);
1764    GLushort r, g, b;
1765    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1766    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1767    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1768    *d = PACK_COLOR_2101010_US(3, r, g, b);
1769 }
1770
1771
1772 /* MESA_FORMAT_RGBX_UNORM16 */
1773
1774 static void
1775 pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
1776 {
1777    GLushort *d = ((GLushort *) dst);
1778    d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1779    d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1780    d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1781    d[3] = 65535;
1782 }
1783
1784 static void
1785 pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
1786 {
1787    GLushort *d = ((GLushort *) dst);
1788    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1789    UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1790    UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1791    d[3] = 65535;
1792 }
1793
1794
1795 /* MESA_FORMAT_RGBX_SNORM16 */
1796
1797 static void
1798 pack_float_XBGR16161616_SNORM(const GLfloat src[4], void *dst)
1799 {
1800    GLushort *d = ((GLushort *) dst);
1801    UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
1802    UNCLAMPED_FLOAT_TO_SHORT(d[1], src[GCOMP]);
1803    UNCLAMPED_FLOAT_TO_SHORT(d[2], src[BCOMP]);
1804    d[3] = 32767;
1805 }
1806
1807
1808 /* MESA_FORMAT_RGBX_FLOAT16 */
1809
1810 static void
1811 pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
1812 {
1813    GLushort *d = ((GLushort *) dst);
1814    d[0] = _mesa_float_to_half(src[RCOMP]);
1815    d[1] = _mesa_float_to_half(src[GCOMP]);
1816    d[2] = _mesa_float_to_half(src[BCOMP]);
1817    d[3] = _mesa_float_to_half(1.0);
1818 }
1819
1820 /* MESA_FORMAT_RGBX_FLOAT32 */
1821
1822 static void
1823 pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
1824 {
1825    GLfloat *d = ((GLfloat *) dst);
1826    d[0] = src[RCOMP];
1827    d[1] = src[GCOMP];
1828    d[2] = src[BCOMP];
1829    d[3] = 1.0;
1830 }
1831
1832 /* MESA_FORMAT_R10G10B10A2_UNORM */
1833
1834 static void
1835 pack_ubyte_ABGR2101010(const GLubyte src[4], void *dst)
1836 {
1837    GLuint *d = ((GLuint *) dst);
1838    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1839    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1840    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1841    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1842    *d = PACK_COLOR_2101010_US(a, b, g, r);
1843 }
1844
1845 static void
1846 pack_float_ABGR2101010(const GLfloat src[4], void *dst)
1847 {
1848    GLuint *d = ((GLuint *) dst);
1849    GLushort r, g, b, a;
1850    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1851    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1852    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1853    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1854    *d = PACK_COLOR_2101010_US(a, b, g, r);
1855 }
1856
1857 /*
1858  * MESA_FORMAT_G8R8_SNORM
1859  */
1860
1861 static void
1862 pack_float_SIGNED_RG88(const GLfloat src[4], void *dst)
1863 {
1864    GLushort *d = (GLushort *) dst;
1865    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1866    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1867    *d = (r << 8) | (g & 0xff);
1868 }
1869
1870 /*
1871  * MESA_FORMAT_G16R16_SNORM
1872  */
1873
1874 static void
1875 pack_float_SIGNED_RG1616(const GLfloat src[4], void *dst)
1876 {
1877    GLuint *d = (GLuint *) dst;
1878    GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1879    GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1880    *d = (r << 16) | (g & 0xffff);
1881 }
1882
1883 /**
1884  * Return a function that can pack a GLubyte rgba[4] color.
1885  */
1886 gl_pack_ubyte_rgba_func
1887 _mesa_get_pack_ubyte_rgba_function(mesa_format format)
1888 {
1889    static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
1890    static GLboolean initialized = GL_FALSE;
1891
1892    if (!initialized) {
1893       memset(table, 0, sizeof(table));
1894
1895       table[MESA_FORMAT_NONE] = NULL;
1896
1897       table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_ubyte_RGBA8888;
1898       table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_ubyte_RGBA8888_REV;
1899       table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_ubyte_ARGB8888;
1900       table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_ubyte_ARGB8888_REV;
1901       table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_ubyte_RGBA8888; /* reused */
1902       table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_ubyte_RGBA8888_REV; /* reused */
1903       table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_ubyte_XRGB8888;
1904       table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_ubyte_XRGB8888_REV;
1905       table[MESA_FORMAT_BGR_UNORM8] = pack_ubyte_RGB888;
1906       table[MESA_FORMAT_RGB_UNORM8] = pack_ubyte_BGR888;
1907       table[MESA_FORMAT_B5G6R5_UNORM] = pack_ubyte_RGB565;
1908       table[MESA_FORMAT_R5G6B5_UNORM] = pack_ubyte_RGB565_REV;
1909       table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_ubyte_ARGB4444;
1910       table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_ubyte_ARGB4444_REV;
1911       table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_ubyte_RGBA5551;
1912       table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_ubyte_ARGB1555;
1913       table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_ubyte_ARGB1555_REV;
1914       table[MESA_FORMAT_L4A4_UNORM] = pack_ubyte_AL44;
1915       table[MESA_FORMAT_L8A8_UNORM] = pack_ubyte_AL88;
1916       table[MESA_FORMAT_A8L8_UNORM] = pack_ubyte_AL88_REV;
1917       table[MESA_FORMAT_L16A16_UNORM] = pack_ubyte_AL1616;
1918       table[MESA_FORMAT_A16L16_UNORM] = pack_ubyte_AL1616_REV;
1919       table[MESA_FORMAT_B2G3R3_UNORM] = pack_ubyte_RGB332;
1920       table[MESA_FORMAT_A_UNORM8] = pack_ubyte_A8;
1921       table[MESA_FORMAT_A_UNORM16] = pack_ubyte_A16;
1922       table[MESA_FORMAT_L_UNORM8] = pack_ubyte_L8;
1923       table[MESA_FORMAT_L_UNORM16] = pack_ubyte_L16;
1924       table[MESA_FORMAT_I_UNORM8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
1925       table[MESA_FORMAT_I_UNORM16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
1926       table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
1927       table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
1928       table[MESA_FORMAT_R_UNORM8] = pack_ubyte_R8;
1929       table[MESA_FORMAT_R8G8_UNORM] = pack_ubyte_GR88;
1930       table[MESA_FORMAT_G8R8_UNORM] = pack_ubyte_RG88;
1931       table[MESA_FORMAT_R_UNORM16] = pack_ubyte_R16;
1932       table[MESA_FORMAT_R16G16_UNORM] = pack_ubyte_GR1616;
1933       table[MESA_FORMAT_G16R16_UNORM] = pack_ubyte_RG1616;
1934       table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_ubyte_ARGB2101010;
1935       table[MESA_FORMAT_R10G10B10A2_UINT] = pack_ubyte_ABGR2101010_UINT;
1936
1937       /* should never convert RGBA to these formats */
1938       table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
1939       table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
1940       table[MESA_FORMAT_Z_UNORM16] = NULL;
1941       table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
1942       table[MESA_FORMAT_X8Z24_UNORM] = NULL;
1943       table[MESA_FORMAT_Z_UNORM32] = NULL;
1944       table[MESA_FORMAT_S_UINT8] = NULL;
1945
1946       /* sRGB */
1947       table[MESA_FORMAT_BGR_SRGB8] = pack_ubyte_SRGB8;
1948       table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_ubyte_SRGBA8;
1949       table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_ubyte_SARGB8;
1950       table[MESA_FORMAT_L_SRGB8] = pack_ubyte_SL8;
1951       table[MESA_FORMAT_L8A8_SRGB] = pack_ubyte_SLA8;
1952       /* n/a */
1953       table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
1954       table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
1955       table[MESA_FORMAT_SRGBA_DXT3] = NULL; /* pack_ubyte_SRGBA_DXT3; */
1956       table[MESA_FORMAT_SRGBA_DXT5] = NULL; /* pack_ubyte_SRGBA_DXT5; */
1957
1958       table[MESA_FORMAT_RGB_FXT1] = NULL; /* pack_ubyte_RGB_FXT1; */
1959       table[MESA_FORMAT_RGBA_FXT1] = NULL; /* pack_ubyte_RGBA_FXT1; */
1960       table[MESA_FORMAT_RGB_DXT1] = NULL; /* pack_ubyte_RGB_DXT1; */
1961       table[MESA_FORMAT_RGBA_DXT1] = NULL; /* pack_ubyte_RGBA_DXT1; */
1962       table[MESA_FORMAT_RGBA_DXT3] = NULL; /* pack_ubyte_RGBA_DXT3; */
1963       table[MESA_FORMAT_RGBA_DXT5] = NULL; /* pack_ubyte_RGBA_DXT5; */
1964
1965       table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
1966       table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
1967       table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
1968       table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
1969       table[MESA_FORMAT_A_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
1970       table[MESA_FORMAT_A_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
1971       table[MESA_FORMAT_L_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1972       table[MESA_FORMAT_L_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1973       table[MESA_FORMAT_LA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
1974       table[MESA_FORMAT_LA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
1975       table[MESA_FORMAT_I_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1976       table[MESA_FORMAT_I_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1977       table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1978       table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1979       table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
1980       table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
1981
1982       /* n/a */
1983       table[MESA_FORMAT_RGBA_SINT8] = NULL; /* pack_ubyte_RGBA_INT8 */
1984       table[MESA_FORMAT_RGBA_SINT16] = NULL; /* pack_ubyte_RGBA_INT16 */
1985       table[MESA_FORMAT_RGBA_SINT32] = NULL; /* pack_ubyte_RGBA_INT32 */
1986       table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
1987       table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
1988       table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
1989
1990       table[MESA_FORMAT_DUDV8] = pack_ubyte_DUDV8;
1991
1992       table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
1993
1994       /* n/a */
1995       table[MESA_FORMAT_R_SNORM8] = NULL;
1996       table[MESA_FORMAT_R8G8_SNORM] = NULL;
1997       table[MESA_FORMAT_X8B8G8R8_SNORM] = NULL;
1998       table[MESA_FORMAT_A8B8G8R8_SNORM] = NULL;
1999       table[MESA_FORMAT_R8G8B8A8_SNORM] = NULL;
2000       table[MESA_FORMAT_R_SNORM16] = NULL;
2001       table[MESA_FORMAT_R16G16_SNORM] = NULL;
2002       table[MESA_FORMAT_RGB_SNORM16] = NULL;
2003       table[MESA_FORMAT_RGBA_SNORM16] = NULL;
2004       table[MESA_FORMAT_A_SNORM8] = NULL;
2005       table[MESA_FORMAT_L_SNORM8] = NULL;
2006       table[MESA_FORMAT_L8A8_SNORM] = NULL;
2007       table[MESA_FORMAT_I_SNORM8] = NULL;
2008       table[MESA_FORMAT_A_SNORM16] = NULL;
2009       table[MESA_FORMAT_L_SNORM16] = NULL;
2010       table[MESA_FORMAT_LA_SNORM16] = NULL;
2011       table[MESA_FORMAT_I_SNORM16] = NULL;
2012
2013
2014       table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2015
2016       table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_ubyte_RGB9_E5_FLOAT;
2017       table[MESA_FORMAT_R11G11B10_FLOAT] = pack_ubyte_R11_G11_B10_FLOAT;
2018
2019       table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_ubyte_XRGB4444_UNORM;
2020       table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_ubyte_XRGB1555_UNORM;
2021       table[MESA_FORMAT_R8G8B8X8_SNORM] = NULL;
2022       table[MESA_FORMAT_R8G8B8X8_SRGB] = NULL;
2023       table[MESA_FORMAT_RGBX_UINT8] = NULL;
2024       table[MESA_FORMAT_RGBX_SINT8] = NULL;
2025       table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_ubyte_XRGB2101010_UNORM;
2026       table[MESA_FORMAT_RGBX_UNORM16] = pack_ubyte_XBGR16161616_UNORM;
2027       table[MESA_FORMAT_RGBX_SNORM16] = NULL;
2028       table[MESA_FORMAT_RGBX_FLOAT16] = NULL;
2029       table[MESA_FORMAT_RGBX_UINT16] = NULL;
2030       table[MESA_FORMAT_RGBX_SINT16] = NULL;
2031       table[MESA_FORMAT_RGBX_FLOAT32] = NULL;
2032       table[MESA_FORMAT_RGBX_UINT32] = NULL;
2033       table[MESA_FORMAT_RGBX_SINT32] = NULL;
2034
2035       table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_ubyte_ABGR2101010;
2036
2037       initialized = GL_TRUE;
2038    }
2039
2040    return table[format];
2041 }
2042
2043
2044
2045 /**
2046  * Return a function that can pack a GLfloat rgba[4] color.
2047  */
2048 gl_pack_float_rgba_func
2049 _mesa_get_pack_float_rgba_function(mesa_format format)
2050 {
2051    static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
2052    static GLboolean initialized = GL_FALSE;
2053
2054    if (!initialized) {
2055       memset(table, 0, sizeof(table));
2056
2057       table[MESA_FORMAT_NONE] = NULL;
2058
2059       table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_float_RGBA8888;
2060       table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_float_RGBA8888_REV;
2061       table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_float_ARGB8888;
2062       table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_float_ARGB8888_REV;
2063       table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_float_RGBA8888; /* reused */
2064       table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_float_RGBA8888_REV; /* reused */
2065       table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_float_XRGB8888;
2066       table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_float_XRGB8888_REV;
2067       table[MESA_FORMAT_BGR_UNORM8] = pack_float_RGB888;
2068       table[MESA_FORMAT_RGB_UNORM8] = pack_float_BGR888;
2069       table[MESA_FORMAT_B5G6R5_UNORM] = pack_float_RGB565;
2070       table[MESA_FORMAT_R5G6B5_UNORM] = pack_float_RGB565_REV;
2071       table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_float_ARGB4444;
2072       table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_float_ARGB4444_REV;
2073       table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_float_RGBA5551;
2074       table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_float_ARGB1555;
2075       table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_float_ARGB1555_REV;
2076
2077       table[MESA_FORMAT_L4A4_UNORM] = pack_float_AL44;
2078       table[MESA_FORMAT_L8A8_UNORM] = pack_float_AL88;
2079       table[MESA_FORMAT_A8L8_UNORM] = pack_float_AL88_REV;
2080       table[MESA_FORMAT_L16A16_UNORM] = pack_float_AL1616;
2081       table[MESA_FORMAT_A16L16_UNORM] = pack_float_AL1616_REV;
2082       table[MESA_FORMAT_B2G3R3_UNORM] = pack_float_RGB332;
2083       table[MESA_FORMAT_A_UNORM8] = pack_float_A8;
2084       table[MESA_FORMAT_A_UNORM16] = pack_float_A16;
2085       table[MESA_FORMAT_L_UNORM8] = pack_float_L8;
2086       table[MESA_FORMAT_L_UNORM16] = pack_float_L16;
2087       table[MESA_FORMAT_I_UNORM8] = pack_float_L8; /* reuse pack_float_L8 */
2088       table[MESA_FORMAT_I_UNORM16] = pack_float_L16; /* reuse pack_float_L16 */
2089       table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
2090       table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
2091       table[MESA_FORMAT_R_UNORM8] = pack_float_R8;
2092       table[MESA_FORMAT_R8G8_UNORM] = pack_float_GR88;
2093       table[MESA_FORMAT_G8R8_UNORM] = pack_float_RG88;
2094       table[MESA_FORMAT_R_UNORM16] = pack_float_R16;
2095       table[MESA_FORMAT_R16G16_UNORM] = pack_float_GR1616;
2096       table[MESA_FORMAT_G16R16_UNORM] = pack_float_RG1616;
2097       table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_float_ARGB2101010;
2098       table[MESA_FORMAT_R10G10B10A2_UINT] = pack_float_ABGR2101010_UINT;
2099
2100       /* should never convert RGBA to these formats */
2101       table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
2102       table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
2103       table[MESA_FORMAT_Z_UNORM16] = NULL;
2104       table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
2105       table[MESA_FORMAT_X8Z24_UNORM] = NULL;
2106       table[MESA_FORMAT_Z_UNORM32] = NULL;
2107       table[MESA_FORMAT_S_UINT8] = NULL;
2108
2109       table[MESA_FORMAT_BGR_SRGB8] = pack_float_SRGB8;
2110       table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_float_SRGBA8;
2111       table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_float_SARGB8;
2112       table[MESA_FORMAT_L_SRGB8] = pack_float_SL8;
2113       table[MESA_FORMAT_L8A8_SRGB] = pack_float_SLA8;
2114
2115       /* n/a */
2116       table[MESA_FORMAT_SRGB_DXT1] = NULL;
2117       table[MESA_FORMAT_SRGBA_DXT1] = NULL;
2118       table[MESA_FORMAT_SRGBA_DXT3] = NULL;
2119       table[MESA_FORMAT_SRGBA_DXT5] = NULL;
2120
2121       table[MESA_FORMAT_RGB_FXT1] = NULL;
2122       table[MESA_FORMAT_RGBA_FXT1] = NULL;
2123       table[MESA_FORMAT_RGB_DXT1] = NULL;
2124       table[MESA_FORMAT_RGBA_DXT1] = NULL;
2125       table[MESA_FORMAT_RGBA_DXT3] = NULL;
2126       table[MESA_FORMAT_RGBA_DXT5] = NULL;
2127
2128       table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
2129       table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
2130       table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
2131       table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
2132       table[MESA_FORMAT_A_FLOAT32] = pack_float_ALPHA_FLOAT32;
2133       table[MESA_FORMAT_A_FLOAT16] = pack_float_ALPHA_FLOAT16;
2134       table[MESA_FORMAT_L_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2135       table[MESA_FORMAT_L_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2136       table[MESA_FORMAT_LA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
2137       table[MESA_FORMAT_LA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
2138
2139       table[MESA_FORMAT_I_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2140       table[MESA_FORMAT_I_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2141       table[MESA_FORMAT_R_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2142       table[MESA_FORMAT_R_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2143       table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
2144       table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
2145
2146       /* n/a */
2147       table[MESA_FORMAT_RGBA_SINT8] = NULL;
2148       table[MESA_FORMAT_RGBA_SINT16] = NULL;
2149       table[MESA_FORMAT_RGBA_SINT32] = NULL;
2150       table[MESA_FORMAT_RGBA_UINT8] = NULL;
2151       table[MESA_FORMAT_RGBA_UINT16] = NULL;
2152       table[MESA_FORMAT_RGBA_UINT32] = NULL;
2153
2154       table[MESA_FORMAT_DUDV8] = pack_float_DUDV8;
2155
2156       table[MESA_FORMAT_RGBA_UNORM16] = pack_float_RGBA_16;
2157
2158       table[MESA_FORMAT_R_SNORM8] = pack_float_SIGNED_R8;
2159       table[MESA_FORMAT_R8G8_SNORM] = pack_float_SIGNED_RG88_REV;
2160       table[MESA_FORMAT_X8B8G8R8_SNORM] = pack_float_SIGNED_RGBX8888;
2161       table[MESA_FORMAT_A8B8G8R8_SNORM] = pack_float_SIGNED_RGBA8888;
2162       table[MESA_FORMAT_R8G8B8A8_SNORM] = pack_float_SIGNED_RGBA8888_REV;
2163       table[MESA_FORMAT_R_SNORM16] = pack_float_SIGNED_R16;
2164       table[MESA_FORMAT_R16G16_SNORM] = pack_float_SIGNED_GR1616;
2165       table[MESA_FORMAT_RGB_SNORM16] = pack_float_SIGNED_RGB_16;
2166       table[MESA_FORMAT_RGBA_SNORM16] = pack_float_SIGNED_RGBA_16;
2167       table[MESA_FORMAT_A_SNORM8] = pack_float_SIGNED_A8;
2168       table[MESA_FORMAT_L_SNORM8] = pack_float_SIGNED_L8;
2169       table[MESA_FORMAT_L8A8_SNORM] = pack_float_SIGNED_AL88;
2170       table[MESA_FORMAT_I_SNORM8] = pack_float_SIGNED_L8; /* reused */
2171       table[MESA_FORMAT_A_SNORM16] = pack_float_SIGNED_A16;
2172       table[MESA_FORMAT_L_SNORM16] = pack_float_SIGNED_L16;
2173       table[MESA_FORMAT_LA_SNORM16] = pack_float_SIGNED_AL1616;
2174       table[MESA_FORMAT_I_SNORM16] = pack_float_SIGNED_L16; /* reused */
2175
2176       table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_float_RGB9_E5_FLOAT;
2177       table[MESA_FORMAT_R11G11B10_FLOAT] = pack_float_R11_G11_B10_FLOAT;
2178
2179       table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_float_XRGB4444_UNORM;
2180       table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_float_XRGB1555_UNORM;
2181       table[MESA_FORMAT_R8G8B8X8_SNORM] = pack_float_XBGR8888_SNORM;
2182       table[MESA_FORMAT_R8G8B8X8_SRGB] = pack_float_XBGR8888_SRGB;
2183       table[MESA_FORMAT_RGBX_UINT8] = NULL;
2184       table[MESA_FORMAT_RGBX_SINT8] = NULL;
2185       table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_float_XRGB2101010_UNORM;
2186       table[MESA_FORMAT_RGBX_UNORM16] = pack_float_XBGR16161616_UNORM;
2187       table[MESA_FORMAT_RGBX_SNORM16] = pack_float_XBGR16161616_SNORM;
2188       table[MESA_FORMAT_RGBX_FLOAT16] = pack_float_XBGR16161616_FLOAT;
2189       table[MESA_FORMAT_RGBX_UINT16] = NULL;
2190       table[MESA_FORMAT_RGBX_SINT16] = NULL;
2191       table[MESA_FORMAT_RGBX_FLOAT32] = pack_float_XBGR32323232_FLOAT;
2192       table[MESA_FORMAT_RGBX_UINT32] = NULL;
2193       table[MESA_FORMAT_RGBX_SINT32] = NULL;
2194
2195       table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_float_ABGR2101010;
2196
2197       table[MESA_FORMAT_G8R8_SNORM] = pack_float_SIGNED_RG88;
2198       table[MESA_FORMAT_G16R16_SNORM] = pack_float_SIGNED_RG1616;
2199
2200       initialized = GL_TRUE;
2201    }
2202
2203    return table[format];
2204 }
2205
2206
2207
2208 static pack_float_rgba_row_func
2209 get_pack_float_rgba_row_function(mesa_format format)
2210 {
2211    static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
2212    static GLboolean initialized = GL_FALSE;
2213
2214    if (!initialized) {
2215       /* We don't need a special row packing function for each format.
2216        * There's a generic fallback which uses a per-pixel packing function.
2217        */
2218       memset(table, 0, sizeof(table));
2219
2220       table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_float_RGBA8888;
2221       table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_float_RGBA8888_REV;
2222       table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_float_ARGB8888;
2223       table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_float_ARGB8888_REV;
2224       table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_float_RGBA8888; /* reused */
2225       table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_float_RGBA8888_REV; /* reused */
2226       table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_float_XRGB8888;
2227       table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_float_XRGB8888_REV;
2228       table[MESA_FORMAT_BGR_UNORM8] = pack_row_float_RGB888;
2229       table[MESA_FORMAT_RGB_UNORM8] = pack_row_float_BGR888;
2230       table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_float_RGB565;
2231       table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_float_RGB565_REV;
2232
2233       initialized = GL_TRUE;
2234    }
2235
2236    return table[format];
2237 }
2238
2239
2240
2241 static pack_ubyte_rgba_row_func
2242 get_pack_ubyte_rgba_row_function(mesa_format format)
2243 {
2244    static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
2245    static GLboolean initialized = GL_FALSE;
2246
2247    if (!initialized) {
2248       /* We don't need a special row packing function for each format.
2249        * There's a generic fallback which uses a per-pixel packing function.
2250        */
2251       memset(table, 0, sizeof(table));
2252
2253       table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888;
2254       table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_ubyte_RGBA8888_REV;
2255       table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_ubyte_ARGB8888;
2256       table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_ubyte_ARGB8888_REV;
2257       table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888; /* reused */
2258       table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_ubyte_RGBA8888_REV; /* reused */
2259       table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_ubyte_XRGB8888;
2260       table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_ubyte_XRGB8888_REV;
2261       table[MESA_FORMAT_BGR_UNORM8] = pack_row_ubyte_RGB888;
2262       table[MESA_FORMAT_RGB_UNORM8] = pack_row_ubyte_BGR888;
2263       table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_ubyte_RGB565;
2264       table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_ubyte_RGB565_REV;
2265
2266       initialized = GL_TRUE;
2267    }
2268
2269    return table[format];
2270 }
2271
2272
2273
2274 /**
2275  * Pack a row of GLfloat rgba[4] values to the destination.
2276  */
2277 void
2278 _mesa_pack_float_rgba_row(mesa_format format, GLuint n,
2279                           const GLfloat src[][4], void *dst)
2280 {
2281    pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
2282    if (packrow) {
2283       /* use "fast" function */
2284       packrow(n, src, dst);
2285    }
2286    else {
2287       /* slower fallback */
2288       gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
2289       GLuint dstStride = _mesa_get_format_bytes(format);
2290       GLubyte *dstPtr = (GLubyte *) dst;
2291       GLuint i;
2292
2293       assert(pack);
2294       if (!pack)
2295          return;
2296
2297       for (i = 0; i < n; i++) {
2298          pack(src[i], dstPtr);
2299          dstPtr += dstStride;
2300       }
2301    }
2302 }
2303
2304
2305 /**
2306  * Pack a row of GLubyte rgba[4] values to the destination.
2307  */
2308 void
2309 _mesa_pack_ubyte_rgba_row(mesa_format format, GLuint n,
2310                           const GLubyte src[][4], void *dst)
2311 {
2312    pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2313    if (packrow) {
2314       /* use "fast" function */
2315       packrow(n, src, dst);
2316    }
2317    else {
2318       /* slower fallback */
2319       gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
2320       const GLuint stride = _mesa_get_format_bytes(format);
2321       GLubyte *d = ((GLubyte *) dst);
2322       GLuint i;
2323
2324       assert(pack);
2325       if (!pack)
2326          return;
2327
2328       for (i = 0; i < n; i++) {
2329          pack(src[i], d);
2330          d += stride;
2331       }
2332    }
2333 }
2334
2335
2336 /**
2337  * Pack a 2D image of ubyte RGBA pixels in the given format.
2338  * \param srcRowStride  source image row stride in bytes
2339  * \param dstRowStride  destination image row stride in bytes
2340  */
2341 void
2342 _mesa_pack_ubyte_rgba_rect(mesa_format format, GLuint width, GLuint height,
2343                            const GLubyte *src, GLint srcRowStride,
2344                            void *dst, GLint dstRowStride)
2345 {
2346    pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2347    GLubyte *dstUB = (GLubyte *) dst;
2348    GLuint i;
2349
2350    if (packrow) {
2351       if (srcRowStride == width * 4 * sizeof(GLubyte) &&
2352           dstRowStride == _mesa_format_row_stride(format, width)) {
2353          /* do whole image at once */
2354          packrow(width * height, (const GLubyte (*)[4]) src, dst);
2355       }
2356       else {
2357          /* row by row */
2358          for (i = 0; i < height; i++) {
2359             packrow(width, (const GLubyte (*)[4]) src, dstUB);
2360             src += srcRowStride;
2361             dstUB += dstRowStride;
2362          }
2363       }
2364    }
2365    else {
2366       /* slower fallback */
2367       for (i = 0; i < height; i++) {
2368          _mesa_pack_ubyte_rgba_row(format, width,
2369                                    (const GLubyte (*)[4]) src, dstUB);
2370          src += srcRowStride;
2371          dstUB += dstRowStride;
2372       }
2373    }
2374 }
2375
2376
2377
2378 /**
2379  ** Pack float Z pixels
2380  **/
2381
2382 static void
2383 pack_float_z_Z24_S8(const GLfloat *src, void *dst)
2384 {
2385    /* don't disturb the stencil values */
2386    GLuint *d = ((GLuint *) dst);
2387    const GLdouble scale = (GLdouble) 0xffffff;
2388    GLuint s = *d & 0xff;
2389    GLuint z = (GLuint) (*src * scale);
2390    assert(z <= 0xffffff);
2391    *d = (z << 8) | s;
2392 }
2393
2394 static void
2395 pack_float_z_S8_Z24(const GLfloat *src, void *dst)
2396 {
2397    /* don't disturb the stencil values */
2398    GLuint *d = ((GLuint *) dst);
2399    const GLdouble scale = (GLdouble) 0xffffff;
2400    GLuint s = *d & 0xff000000;
2401    GLuint z = (GLuint) (*src * scale);
2402    assert(z <= 0xffffff);
2403    *d = s | z;
2404 }
2405
2406 static void
2407 pack_float_z_Z16(const GLfloat *src, void *dst)
2408 {
2409    GLushort *d = ((GLushort *) dst);
2410    const GLfloat scale = (GLfloat) 0xffff;
2411    *d = (GLushort) (*src * scale);
2412 }
2413
2414 static void
2415 pack_float_z_Z32(const GLfloat *src, void *dst)
2416 {
2417    GLuint *d = ((GLuint *) dst);
2418    const GLdouble scale = (GLdouble) 0xffffffff;
2419    *d = (GLuint) (*src * scale);
2420 }
2421
2422 static void
2423 pack_float_z_Z32_FLOAT(const GLfloat *src, void *dst)
2424 {
2425    GLfloat *d = (GLfloat *) dst;
2426    *d = *src;
2427 }
2428
2429 gl_pack_float_z_func
2430 _mesa_get_pack_float_z_func(mesa_format format)
2431 {
2432    switch (format) {
2433    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2434    case MESA_FORMAT_X8Z24_UNORM:
2435       return pack_float_z_Z24_S8;
2436    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2437    case MESA_FORMAT_Z24_UNORM_X8_UINT:
2438       return pack_float_z_S8_Z24;
2439    case MESA_FORMAT_Z_UNORM16:
2440       return pack_float_z_Z16;
2441    case MESA_FORMAT_Z_UNORM32:
2442       return pack_float_z_Z32;
2443    case MESA_FORMAT_Z_FLOAT32:
2444    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2445       return pack_float_z_Z32_FLOAT;
2446    default:
2447       _mesa_problem(NULL,
2448                     "unexpected format in _mesa_get_pack_float_z_func()");
2449       return NULL;
2450    }
2451 }
2452
2453
2454
2455 /**
2456  ** Pack uint Z pixels.  The incoming src value is always in
2457  ** the range [0, 2^32-1].
2458  **/
2459
2460 static void
2461 pack_uint_z_Z24_S8(const GLuint *src, void *dst)
2462 {
2463    /* don't disturb the stencil values */
2464    GLuint *d = ((GLuint *) dst);
2465    GLuint s = *d & 0xff;
2466    GLuint z = *src & 0xffffff00;
2467    *d = z | s;
2468 }
2469
2470 static void
2471 pack_uint_z_S8_Z24(const GLuint *src, void *dst)
2472 {
2473    /* don't disturb the stencil values */
2474    GLuint *d = ((GLuint *) dst);
2475    GLuint s = *d & 0xff000000;
2476    GLuint z = *src >> 8;
2477    *d = s | z;
2478 }
2479
2480 static void
2481 pack_uint_z_Z16(const GLuint *src, void *dst)
2482 {
2483    GLushort *d = ((GLushort *) dst);
2484    *d = *src >> 16;
2485 }
2486
2487 static void
2488 pack_uint_z_Z32(const GLuint *src, void *dst)
2489 {
2490    GLuint *d = ((GLuint *) dst);
2491    *d = *src;
2492 }
2493
2494 static void
2495 pack_uint_z_Z32_FLOAT(const GLuint *src, void *dst)
2496 {
2497    GLuint *d = ((GLuint *) dst);
2498    const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2499    *d = (GLuint) (*src * scale);
2500    assert(*d >= 0.0f);
2501    assert(*d <= 1.0f);
2502 }
2503
2504 static void
2505 pack_uint_z_Z32_FLOAT_X24S8(const GLuint *src, void *dst)
2506 {
2507    GLfloat *d = ((GLfloat *) dst);
2508    const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2509    *d = (GLfloat) (*src * scale);
2510    assert(*d >= 0.0f);
2511    assert(*d <= 1.0f);
2512 }
2513
2514 gl_pack_uint_z_func
2515 _mesa_get_pack_uint_z_func(mesa_format format)
2516 {
2517    switch (format) {
2518    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2519    case MESA_FORMAT_X8Z24_UNORM:
2520       return pack_uint_z_Z24_S8;
2521    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2522    case MESA_FORMAT_Z24_UNORM_X8_UINT:
2523       return pack_uint_z_S8_Z24;
2524    case MESA_FORMAT_Z_UNORM16:
2525       return pack_uint_z_Z16;
2526    case MESA_FORMAT_Z_UNORM32:
2527       return pack_uint_z_Z32;
2528    case MESA_FORMAT_Z_FLOAT32:
2529       return pack_uint_z_Z32_FLOAT;
2530    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2531       return pack_uint_z_Z32_FLOAT_X24S8;
2532    default:
2533       _mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
2534       return NULL;
2535    }
2536 }
2537
2538
2539 /**
2540  ** Pack ubyte stencil pixels
2541  **/
2542
2543 static void
2544 pack_ubyte_stencil_Z24_S8(const GLubyte *src, void *dst)
2545 {
2546    /* don't disturb the Z values */
2547    GLuint *d = ((GLuint *) dst);
2548    GLuint s = *src;
2549    GLuint z = *d & 0xffffff00;
2550    *d = z | s;
2551 }
2552
2553 static void
2554 pack_ubyte_stencil_S8_Z24(const GLubyte *src, void *dst)
2555 {
2556    /* don't disturb the Z values */
2557    GLuint *d = ((GLuint *) dst);
2558    GLuint s = *src << 24;
2559    GLuint z = *d & 0xffffff;
2560    *d = s | z;
2561 }
2562
2563 static void
2564 pack_ubyte_stencil_S8(const GLubyte *src, void *dst)
2565 {
2566    GLubyte *d = (GLubyte *) dst;
2567    *d = *src;
2568 }
2569
2570 static void
2571 pack_ubyte_stencil_Z32_FLOAT_X24S8(const GLubyte *src, void *dst)
2572 {
2573    GLfloat *d = ((GLfloat *) dst);
2574    d[1] = *src;
2575 }
2576
2577
2578 gl_pack_ubyte_stencil_func
2579 _mesa_get_pack_ubyte_stencil_func(mesa_format format)
2580 {
2581    switch (format) {
2582    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2583       return pack_ubyte_stencil_Z24_S8;
2584    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2585       return pack_ubyte_stencil_S8_Z24;
2586    case MESA_FORMAT_S_UINT8:
2587       return pack_ubyte_stencil_S8;
2588    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2589       return pack_ubyte_stencil_Z32_FLOAT_X24S8;
2590    default:
2591       _mesa_problem(NULL,
2592                     "unexpected format in _mesa_pack_ubyte_stencil_func()");
2593       return NULL;
2594    }
2595 }
2596
2597
2598
2599 void
2600 _mesa_pack_float_z_row(mesa_format format, GLuint n,
2601                        const GLfloat *src, void *dst)
2602 {
2603    switch (format) {
2604    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2605    case MESA_FORMAT_X8Z24_UNORM:
2606       {
2607          /* don't disturb the stencil values */
2608          GLuint *d = ((GLuint *) dst);
2609          const GLdouble scale = (GLdouble) 0xffffff;
2610          GLuint i;
2611          for (i = 0; i < n; i++) {
2612             GLuint s = d[i] & 0xff;
2613             GLuint z = (GLuint) (src[i] * scale);
2614             assert(z <= 0xffffff);
2615             d[i] = (z << 8) | s;
2616          }
2617       }
2618       break;
2619    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2620    case MESA_FORMAT_Z24_UNORM_X8_UINT:
2621       {
2622          /* don't disturb the stencil values */
2623          GLuint *d = ((GLuint *) dst);
2624          const GLdouble scale = (GLdouble) 0xffffff;
2625          GLuint i;
2626          for (i = 0; i < n; i++) {
2627             GLuint s = d[i] & 0xff000000;
2628             GLuint z = (GLuint) (src[i] * scale);
2629             assert(z <= 0xffffff);
2630             d[i] = s | z;
2631          }
2632       }
2633       break;
2634    case MESA_FORMAT_Z_UNORM16:
2635       {
2636          GLushort *d = ((GLushort *) dst);
2637          const GLfloat scale = (GLfloat) 0xffff;
2638          GLuint i;
2639          for (i = 0; i < n; i++) {
2640             d[i] = (GLushort) (src[i] * scale);
2641          }
2642       }
2643       break;
2644    case MESA_FORMAT_Z_UNORM32:
2645       {
2646          GLuint *d = ((GLuint *) dst);
2647          const GLdouble scale = (GLdouble) 0xffffffff;
2648          GLuint i;
2649          for (i = 0; i < n; i++) {
2650             d[i] = (GLuint) (src[i] * scale);
2651          }
2652       }
2653       break;
2654    case MESA_FORMAT_Z_FLOAT32:
2655       memcpy(dst, src, n * sizeof(GLfloat));
2656       break;
2657    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2658       {
2659          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2660          GLuint i;
2661          for (i = 0; i < n; i++) {
2662             d[i].z = src[i];
2663          }
2664       }
2665       break;
2666    default:
2667       _mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
2668    }
2669 }
2670
2671
2672 /**
2673  * The incoming Z values are always in the range [0, 0xffffffff].
2674  */
2675 void
2676 _mesa_pack_uint_z_row(mesa_format format, GLuint n,
2677                       const GLuint *src, void *dst)
2678 {
2679    switch (format) {
2680    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2681    case MESA_FORMAT_X8Z24_UNORM:
2682       {
2683          /* don't disturb the stencil values */
2684          GLuint *d = ((GLuint *) dst);
2685          GLuint i;
2686          for (i = 0; i < n; i++) {
2687             GLuint s = d[i] & 0xff;
2688             GLuint z = src[i] & 0xffffff00;
2689             d[i] = z | s;
2690          }
2691       }
2692       break;
2693    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2694    case MESA_FORMAT_Z24_UNORM_X8_UINT:
2695       {
2696          /* don't disturb the stencil values */
2697          GLuint *d = ((GLuint *) dst);
2698          GLuint i;
2699          for (i = 0; i < n; i++) {
2700             GLuint s = d[i] & 0xff000000;
2701             GLuint z = src[i] >> 8;
2702             d[i] = s | z;
2703          }
2704       }
2705       break;
2706    case MESA_FORMAT_Z_UNORM16:
2707       {
2708          GLushort *d = ((GLushort *) dst);
2709          GLuint i;
2710          for (i = 0; i < n; i++) {
2711             d[i] = src[i] >> 16;
2712          }
2713       }
2714       break;
2715    case MESA_FORMAT_Z_UNORM32:
2716       memcpy(dst, src, n * sizeof(GLfloat));
2717       break;
2718    case MESA_FORMAT_Z_FLOAT32:
2719       {
2720          GLuint *d = ((GLuint *) dst);
2721          const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2722          GLuint i;
2723          for (i = 0; i < n; i++) {
2724             d[i] = (GLuint) (src[i] * scale);
2725             assert(d[i] >= 0.0f);
2726             assert(d[i] <= 1.0f);
2727          }
2728       }
2729       break;
2730    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2731       {
2732          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2733          const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2734          GLuint i;
2735          for (i = 0; i < n; i++) {
2736             d[i].z = (GLfloat) (src[i] * scale);
2737             assert(d[i].z >= 0.0f);
2738             assert(d[i].z <= 1.0f);
2739          }
2740       }
2741       break;
2742    default:
2743       _mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
2744    }
2745 }
2746
2747
2748 void
2749 _mesa_pack_ubyte_stencil_row(mesa_format format, GLuint n,
2750                              const GLubyte *src, void *dst)
2751 {
2752    switch (format) {
2753    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2754       {
2755          /* don't disturb the Z values */
2756          GLuint *d = ((GLuint *) dst);
2757          GLuint i;
2758          for (i = 0; i < n; i++) {
2759             GLuint s = src[i];
2760             GLuint z = d[i] & 0xffffff00;
2761             d[i] = z | s;
2762          }
2763       }
2764       break;
2765    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2766       {
2767          /* don't disturb the Z values */
2768          GLuint *d = ((GLuint *) dst);
2769          GLuint i;
2770          for (i = 0; i < n; i++) {
2771             GLuint s = src[i] << 24;
2772             GLuint z = d[i] & 0xffffff;
2773             d[i] = s | z;
2774          }
2775       }
2776       break;
2777    case MESA_FORMAT_S_UINT8:
2778       memcpy(dst, src, n * sizeof(GLubyte));
2779       break;
2780    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2781       {
2782          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2783          GLuint i;
2784          for (i = 0; i < n; i++) {
2785             d[i].x24s8 = src[i];
2786          }
2787       }
2788       break;
2789    default:
2790       _mesa_problem(NULL, "unexpected format in _mesa_pack_ubyte_stencil_row()");
2791    }
2792 }
2793
2794
2795 /**
2796  * Incoming Z/stencil values are always in uint_24_8 format.
2797  */
2798 void
2799 _mesa_pack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
2800                                        const GLuint *src, void *dst)
2801 {
2802    switch (format) {
2803    case MESA_FORMAT_S8_UINT_Z24_UNORM:
2804       memcpy(dst, src, n * sizeof(GLuint));
2805       break;
2806    case MESA_FORMAT_Z24_UNORM_S8_UINT:
2807       {
2808          GLuint *d = ((GLuint *) dst);
2809          GLuint i;
2810          for (i = 0; i < n; i++) {
2811             GLuint s = src[i] << 24;
2812             GLuint z = src[i] >> 8;
2813             d[i] = s | z;
2814          }
2815       }
2816       break;
2817    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2818       {
2819          const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
2820          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2821          GLuint i;
2822          for (i = 0; i < n; i++) {
2823             GLfloat z = (GLfloat) ((src[i] >> 8) * scale);
2824             d[i].z = z;
2825             d[i].x24s8 = src[i];
2826          }
2827       }
2828       break;
2829    default:
2830       _mesa_problem(NULL, "bad format %s in _mesa_pack_ubyte_s_row",
2831                     _mesa_get_format_name(format));
2832       return;
2833    }
2834 }
2835
2836
2837
2838 /**
2839  * Convert a boolean color mask to a packed color where each channel of
2840  * the packed value at dst will be 0 or ~0 depending on the colorMask.
2841  */
2842 void
2843 _mesa_pack_colormask(mesa_format format, const GLubyte colorMask[4], void *dst)
2844 {
2845    GLfloat maskColor[4];
2846
2847    switch (_mesa_get_format_datatype(format)) {
2848    case GL_UNSIGNED_NORMALIZED:
2849       /* simple: 1.0 will convert to ~0 in the right bit positions */
2850       maskColor[0] = colorMask[0] ? 1.0f : 0.0f;
2851       maskColor[1] = colorMask[1] ? 1.0f : 0.0f;
2852       maskColor[2] = colorMask[2] ? 1.0f : 0.0f;
2853       maskColor[3] = colorMask[3] ? 1.0f : 0.0f;
2854       _mesa_pack_float_rgba_row(format, 1,
2855                                 (const GLfloat (*)[4]) maskColor, dst);
2856       break;
2857    case GL_SIGNED_NORMALIZED:
2858    case GL_FLOAT:
2859       /* These formats are harder because it's hard to know the floating
2860        * point values that will convert to ~0 for each color channel's bits.
2861        * This solution just generates a non-zero value for each color channel
2862        * then fixes up the non-zero values to be ~0.
2863        * Note: we'll need to add special case code if we ever have to deal
2864        * with formats with unequal color channel sizes, like R11_G11_B10.
2865        * We issue a warning below for channel sizes other than 8,16,32.
2866        */
2867       {
2868          GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
2869          GLuint bytes = _mesa_get_format_bytes(format);
2870          GLuint i;
2871
2872          /* this should put non-zero values into the channels of dst */
2873          maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
2874          maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
2875          maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
2876          maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
2877          _mesa_pack_float_rgba_row(format, 1,
2878                                    (const GLfloat (*)[4]) maskColor, dst);
2879
2880          /* fix-up the dst channels by converting non-zero values to ~0 */
2881          if (bits == 8) {
2882             GLubyte *d = (GLubyte *) dst;
2883             for (i = 0; i < bytes; i++) {
2884                d[i] = d[i] ? 0xff : 0x0;
2885             }
2886          }
2887          else if (bits == 16) {
2888             GLushort *d = (GLushort *) dst;
2889             for (i = 0; i < bytes / 2; i++) {
2890                d[i] = d[i] ? 0xffff : 0x0;
2891             }
2892          }
2893          else if (bits == 32) {
2894             GLuint *d = (GLuint *) dst;
2895             for (i = 0; i < bytes / 4; i++) {
2896                d[i] = d[i] ? 0xffffffffU : 0x0;
2897             }
2898          }
2899          else {
2900             _mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
2901             return;
2902          }
2903       }
2904       break;
2905    default:
2906       _mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
2907       return;
2908    }
2909 }