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