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