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