reactos/dll/opengl/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
  42
  43 typedef void (*pack_ubyte_rgba_row_func)(GLuint n,
  44                                          const GLubyte src[][4], void *dst);
  45
  46 typedef void (*pack_float_rgba_row_func)(GLuint n,
  47                                          const GLfloat src[][4], void *dst);
  48
  49 /*
  50  * MESA_FORMAT_RGBA8888
  51  */
  52
  53 static void
  54 pack_ubyte_RGBA8888(const GLubyte src[4], void *dst)
  55 {
  56    GLuint *d = ((GLuint *) dst);
  57    *d = PACK_COLOR_8888(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
  58 }
  59
  60 static void
  61 pack_float_RGBA8888(const GLfloat src[4], void *dst)
  62 {
  63    GLubyte v[4];
  64    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  65    pack_ubyte_RGBA8888(v, dst);
  66 }
  67
  68 static void
  69 pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
  70 {
  71    GLuint *d = ((GLuint *) dst);
  72    GLuint i;
  73    for (i = 0; i < n; i++) {
  74       d[i] = PACK_COLOR_8888(src[i][RCOMP], src[i][GCOMP],
  75                              src[i][BCOMP], src[i][ACOMP]);
  76    }
  77 }
  78
  79 static void
  80 pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
  81 {
  82    GLuint *d = ((GLuint *) dst);
  83    GLuint i;
  84    for (i = 0; i < n; i++) {
  85       GLubyte v[4];
  86       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  87       pack_ubyte_RGBA8888(v, d + i);
  88    }
  89 }
  90
  91
  92
  93 /*
  94  * MESA_FORMAT_RGBA8888_REV
  95  */
  96
  97 static void
  98 pack_ubyte_RGBA8888_REV(const GLubyte src[4], void *dst)
  99 {
 100    GLuint *d = ((GLuint *) dst);
 101    *d = PACK_COLOR_8888(src[ACOMP], src[BCOMP], src[GCOMP], src[RCOMP]);
 102 }
 103
 104 static void
 105 pack_float_RGBA8888_REV(const GLfloat src[4], void *dst)
 106 {
 107    GLubyte v[4];
 108    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 109    pack_ubyte_RGBA8888_REV(v, dst);
 110 }
 111
 112 static void
 113 pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
 114 {
 115    GLuint *d = ((GLuint *) dst);
 116    GLuint i;
 117    for (i = 0; i < n; i++) {
 118       d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][BCOMP],
 119                              src[i][GCOMP], src[i][RCOMP]);
 120    }
 121 }
 122
 123 static void
 124 pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
 125 {
 126    GLuint *d = ((GLuint *) dst);
 127    GLuint i;
 128    for (i = 0; i < n; i++) {
 129       GLubyte v[4];
 130       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 131       pack_ubyte_RGBA8888_REV(v, d + i);
 132    }
 133 }
 134
 135
 136 /*
 137  * MESA_FORMAT_ARGB8888
 138  */
 139
 140 static void
 141 pack_ubyte_ARGB8888(const GLubyte src[4], void *dst)
 142 {
 143    GLuint *d = ((GLuint *) dst);
 144    *d = PACK_COLOR_8888(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 145 }
 146
 147 static void
 148 pack_float_ARGB8888(const GLfloat src[4], void *dst)
 149 {
 150    GLubyte v[4];
 151    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 152    pack_ubyte_ARGB8888(v, dst);
 153 }
 154
 155 static void
 156 pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
 157 {
 158    GLuint *d = ((GLuint *) dst);
 159    GLuint i;
 160    for (i = 0; i < n; i++) {
 161       d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][RCOMP],
 162                              src[i][GCOMP], src[i][BCOMP]);
 163    }
 164 }
 165
 166 static void
 167 pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
 168 {
 169    GLuint *d = ((GLuint *) dst);
 170    GLuint i;
 171    for (i = 0; i < n; i++) {
 172       GLubyte v[4];
 173       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 174       pack_ubyte_ARGB8888(v, d + i);
 175    }
 176 }
 177
 178
 179 /*
 180  * MESA_FORMAT_ARGB8888_REV
 181  */
 182
 183 static void
 184 pack_ubyte_ARGB8888_REV(const GLubyte src[4], void *dst)
 185 {
 186    GLuint *d = ((GLuint *) dst);
 187    *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
 188 }
 189
 190 static void
 191 pack_float_ARGB8888_REV(const GLfloat src[4], void *dst)
 192 {
 193    GLubyte v[4];
 194    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 195    pack_ubyte_ARGB8888_REV(v, dst);
 196 }
 197
 198 static void
 199 pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
 200 {
 201    GLuint *d = ((GLuint *) dst);
 202    GLuint i;
 203    for (i = 0; i < n; i++) {
 204       d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP],
 205                              src[i][RCOMP], src[i][ACOMP]);
 206    }
 207 }
 208
 209 static void
 210 pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
 211 {
 212    GLuint *d = ((GLuint *) dst);
 213    GLuint i;
 214    for (i = 0; i < n; i++) {
 215       GLubyte v[4];
 216       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 217       pack_ubyte_ARGB8888_REV(v, d + i);
 218    }
 219 }
 220
 221
 222 /*
 223  * MESA_FORMAT_XRGB8888
 224  */
 225
 226 static void
 227 pack_ubyte_XRGB8888(const GLubyte src[4], void *dst)
 228 {
 229    GLuint *d = ((GLuint *) dst);
 230    *d = PACK_COLOR_8888(0x0, src[RCOMP], src[GCOMP], src[BCOMP]);
 231 }
 232
 233 static void
 234 pack_float_XRGB8888(const GLfloat src[4], void *dst)
 235 {
 236    GLubyte v[4];
 237    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 238    pack_ubyte_XRGB8888(v, dst);
 239 }
 240
 241 static void
 242 pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
 243 {
 244    GLuint *d = ((GLuint *) dst);
 245    GLuint i;
 246    for (i = 0; i < n; i++) {
 247       d[i] = PACK_COLOR_8888(0, src[i][RCOMP], src[i][GCOMP], src[i][BCOMP]);
 248    }
 249 }
 250
 251 static void
 252 pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
 253 {
 254    GLuint *d = ((GLuint *) dst);
 255    GLuint i;
 256    for (i = 0; i < n; i++) {
 257       GLubyte v[4];
 258       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 259       pack_ubyte_XRGB8888(v, d + i);
 260    }
 261 }
 262
 263
 264 /*
 265  * MESA_FORMAT_XRGB8888_REV
 266  */
 267
 268 static void
 269 pack_ubyte_XRGB8888_REV(const GLubyte src[4], void *dst)
 270 {
 271    GLuint *d = ((GLuint *) dst);
 272    *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], 0);
 273 }
 274
 275 static void
 276 pack_float_XRGB8888_REV(const GLfloat src[4], void *dst)
 277 {
 278    GLubyte v[4];
 279    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 280    pack_ubyte_XRGB8888_REV(v, dst);
 281 }
 282
 283 static void
 284 pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
 285 {
 286    GLuint *d = ((GLuint *) dst);
 287    GLuint i;
 288    for (i = 0; i < n; i++) {
 289       d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP], src[i][RCOMP], 0);
 290    }
 291 }
 292
 293 static void
 294 pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
 295 {
 296    GLuint *d = ((GLuint *) dst);
 297    GLuint i;
 298    for (i = 0; i < n; i++) {
 299       GLubyte v[4];
 300       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 301       pack_ubyte_XRGB8888_REV(v, d + i);
 302    }
 303 }
 304
 305
 306 /*
 307  * MESA_FORMAT_RGB888
 308  */
 309
 310 static void
 311 pack_ubyte_RGB888(const GLubyte src[4], void *dst)
 312 {
 313    GLubyte *d = ((GLubyte *) dst);
 314    d[2] = src[RCOMP];
 315    d[1] = src[GCOMP];
 316    d[0] = src[BCOMP];
 317 }
 318
 319 static void
 320 pack_float_RGB888(const GLfloat src[4], void *dst)
 321 {
 322    GLubyte *d = ((GLubyte *) dst);
 323    UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[RCOMP]);
 324    UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
 325    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[BCOMP]);
 326 }
 327
 328 static void
 329 pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
 330 {
 331    GLubyte *d = ((GLubyte *) dst);
 332    GLuint i;
 333    for (i = 0; i < n; i++) {
 334       d[i*3+2] = src[i][RCOMP];
 335       d[i*3+1] = src[i][GCOMP];
 336       d[i*3+0] = src[i][BCOMP];
 337    }
 338 }
 339
 340 static void
 341 pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
 342 {
 343    GLubyte *d = ((GLubyte *) dst);
 344    GLuint i;
 345    for (i = 0; i < n; i++) {
 346       GLubyte v[4];
 347       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 348       d[i*3+2] = v[RCOMP];
 349       d[i*3+1] = v[GCOMP];
 350       d[i*3+0] = v[BCOMP];
 351    }
 352 }
 353
 354
 355 /*
 356  * MESA_FORMAT_BGR888
 357  */
 358
 359 static void
 360 pack_ubyte_BGR888(const GLubyte src[4], void *dst)
 361 {
 362    GLubyte *d = ((GLubyte *) dst);
 363    d[2] = src[BCOMP];
 364    d[1] = src[GCOMP];
 365    d[0] = src[RCOMP];
 366 }
 367
 368 static void
 369 pack_float_BGR888(const GLfloat src[4], void *dst)
 370 {
 371    GLubyte *d = ((GLubyte *) dst);
 372    UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[BCOMP]);
 373    UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
 374    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
 375 }
 376
 377 static void
 378 pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
 379 {
 380    GLubyte *d = ((GLubyte *) dst);
 381    GLuint i;
 382    for (i = 0; i < n; i++) {
 383       d[i*3+2] = src[i][BCOMP];
 384       d[i*3+1] = src[i][GCOMP];
 385       d[i*3+0] = src[i][RCOMP];
 386    }
 387 }
 388
 389 static void
 390 pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
 391 {
 392    GLubyte *d = ((GLubyte *) dst);
 393    GLuint i;
 394    for (i = 0; i < n; i++) {
 395       GLubyte v[4];
 396       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 397       d[i*3+2] = v[BCOMP];
 398       d[i*3+1] = v[GCOMP];
 399       d[i*3+0] = v[RCOMP];
 400    }
 401 }
 402
 403
 404 /*
 405  * MESA_FORMAT_RGB565
 406  */
 407
 408 static void
 409 pack_ubyte_RGB565(const GLubyte src[4], void *dst)
 410 {
 411    GLushort *d = ((GLushort *) dst);
 412    *d = PACK_COLOR_565(src[RCOMP], src[GCOMP], src[BCOMP]);
 413 }
 414
 415 static void
 416 pack_float_RGB565(const GLfloat src[4], void *dst)
 417 {
 418    GLubyte v[3];
 419    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 420    UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
 421    UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
 422    pack_ubyte_RGB565(v, dst);
 423 }
 424
 425 static void
 426 pack_row_ubyte_RGB565(GLuint n, const GLubyte src[][4], void *dst)
 427 {
 428    GLushort *d = ((GLushort *) dst);
 429    GLuint i;
 430    for (i = 0; i < n; i++) {
 431       pack_ubyte_RGB565(src[i], d + i);
 432    }
 433 }
 434
 435 static void
 436 pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
 437 {
 438    GLushort *d = ((GLushort *) dst);
 439    GLuint i;
 440    for (i = 0; i < n; i++) {
 441       GLubyte v[4];
 442       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 443       pack_ubyte_RGB565(v, d + i);
 444    }
 445 }
 446
 447
 448 /*
 449  * MESA_FORMAT_RGB565_REV
 450  */
 451
 452 static void
 453 pack_ubyte_RGB565_REV(const GLubyte src[4], void *dst)
 454 {
 455    GLushort *d = ((GLushort *) dst);
 456    *d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
 457 }
 458
 459 static void
 460 pack_float_RGB565_REV(const GLfloat src[4], void *dst)
 461 {
 462    GLushort *d = ((GLushort *) dst);
 463    GLubyte r, g, b;
 464    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
 465    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
 466    UNCLAMPED_FLOAT_TO_UBYTE(b, src[BCOMP]);
 467    *d = PACK_COLOR_565_REV(r, g, b);
 468 }
 469
 470 static void
 471 pack_row_ubyte_RGB565_REV(GLuint n, const GLubyte src[][4], void *dst)
 472 {
 473    GLushort *d = ((GLushort *) dst);
 474    GLuint i;
 475    for (i = 0; i < n; i++) {
 476       pack_ubyte_RGB565_REV(src[i], d + i);
 477    }
 478 }
 479
 480 static void
 481 pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
 482 {
 483    GLushort *d = ((GLushort *) dst);
 484    GLuint i;
 485    for (i = 0; i < n; i++) {
 486       GLubyte v[4];
 487       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
 488       pack_ubyte_RGB565_REV(v, d + i);
 489    }
 490 }
 491
 492
 493 /*
 494  * MESA_FORMAT_ARGB4444
 495  */
 496
 497 static void
 498 pack_ubyte_ARGB4444(const GLubyte src[4], void *dst)
 499 {
 500    GLushort *d = ((GLushort *) dst);
 501    *d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 502 }
 503
 504 static void
 505 pack_float_ARGB4444(const GLfloat src[4], void *dst)
 506 {
 507    GLubyte v[4];
 508    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 509    pack_ubyte_ARGB4444(v, dst);
 510 }
 511
 512 /* use fallback row packing functions */
 513
 514
 515 /*
 516  * MESA_FORMAT_ARGB4444_REV
 517  */
 518
 519 static void
 520 pack_ubyte_ARGB4444_REV(const GLubyte src[4], void *dst)
 521 {
 522    GLushort *d = ((GLushort *) dst);
 523    *d = PACK_COLOR_4444(src[GCOMP], src[BCOMP], src[ACOMP], src[RCOMP]);
 524 }
 525
 526 static void
 527 pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
 528 {
 529    GLubyte v[4];
 530    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 531    pack_ubyte_ARGB4444_REV(v, dst);
 532 }
 533
 534 /* use fallback row packing functions */
 535
 536
 537 /*
 538  * MESA_FORMAT_RGBA5551
 539  */
 540
 541 static void
 542 pack_ubyte_RGBA5551(const GLubyte src[4], void *dst)
 543 {
 544    GLushort *d = ((GLushort *) dst);
 545    *d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
 546 }
 547
 548 static void
 549 pack_float_RGBA5551(const GLfloat src[4], void *dst)
 550 {
 551    GLubyte v[4];
 552    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 553    pack_ubyte_RGBA5551(v, dst);
 554 }
 555
 556 /* use fallback row packing functions */
 557
 558
 559 /*
 560  * MESA_FORMAT_ARGB1555
 561  */
 562
 563 static void
 564 pack_ubyte_ARGB1555(const GLubyte src[4], void *dst)
 565 {
 566    GLushort *d = ((GLushort *) dst);
 567    *d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 568 }
 569
 570 static void
 571 pack_float_ARGB1555(const GLfloat src[4], void *dst)
 572 {
 573    GLubyte v[4];
 574    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 575    pack_ubyte_ARGB1555(v, dst);
 576 }
 577
 578
 579 /* MESA_FORMAT_ARGB1555_REV */
 580
 581 static void
 582 pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
 583 {
 584    GLushort *d = ((GLushort *) dst), tmp;
 585    tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
 586    *d = (tmp >> 8) | (tmp << 8);
 587 }
 588
 589 static void
 590 pack_float_ARGB1555_REV(const GLfloat src[4], void *dst)
 591 {
 592    GLubyte v[4];
 593    _mesa_unclamped_float_rgba_to_ubyte(v, src);
 594    pack_ubyte_ARGB1555_REV(v, dst);
 595 }
 596
 597
 598 /* MESA_FORMAT_AL44 */
 599
 600 static void
 601 pack_ubyte_AL44(const GLubyte src[4], void *dst)
 602 {
 603    GLubyte *d = ((GLubyte *) dst);
 604    *d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
 605 }
 606
 607 static void
 608 pack_float_AL44(const GLfloat src[4], void *dst)
 609 {
 610    GLubyte v[4];
 611    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 612    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
 613    pack_ubyte_AL44(v, dst);
 614 }
 615
 616
 617 /* MESA_FORMAT_AL88 */
 618
 619 static void
 620 pack_ubyte_AL88(const GLubyte src[4], void *dst)
 621 {
 622    GLushort *d = ((GLushort *) dst);
 623    *d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
 624 }
 625
 626 static void
 627 pack_float_AL88(const GLfloat src[4], void *dst)
 628 {
 629    GLubyte v[4];
 630    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 631    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
 632    pack_ubyte_AL88(v, dst);
 633 }
 634
 635
 636 /* MESA_FORMAT_AL88_REV */
 637
 638 static void
 639 pack_ubyte_AL88_REV(const GLubyte src[4], void *dst)
 640 {
 641    GLushort *d = ((GLushort *) dst);
 642    *d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
 643 }
 644
 645 static void
 646 pack_float_AL88_REV(const GLfloat src[4], void *dst)
 647 {
 648    GLubyte v[4];
 649    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 650    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
 651    pack_ubyte_AL88_REV(v, dst);
 652 }
 653
 654
 655 /* MESA_FORMAT_AL1616 */
 656
 657 static void
 658 pack_ubyte_AL1616(const GLubyte src[4], void *dst)
 659 {
 660    GLuint *d = ((GLuint *) dst);
 661    GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
 662    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
 663    *d = PACK_COLOR_1616(a, l);
 664 }
 665
 666 static void
 667 pack_float_AL1616(const GLfloat src[4], void *dst)
 668 {
 669    GLuint *d = ((GLuint *) dst);
 670    GLushort l, a;
 671    UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
 672    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
 673    *d = PACK_COLOR_1616(a, l);
 674 }
 675
 676
 677 /* MESA_FORMAT_AL1616_REV */
 678
 679 static void
 680 pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
 681 {
 682    GLuint *d = ((GLuint *) dst);
 683    GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
 684    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
 685    *d = PACK_COLOR_1616(l, a);
 686 }
 687
 688 static void
 689 pack_float_AL1616_REV(const GLfloat src[4], void *dst)
 690 {
 691    GLuint *d = ((GLuint *) dst);
 692    GLushort l, a;
 693    UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
 694    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
 695    *d = PACK_COLOR_1616(l, a);
 696 }
 697
 698
 699 /* MESA_FORMAT_RGB332 */
 700
 701 static void
 702 pack_ubyte_RGB332(const GLubyte src[4], void *dst)
 703 {
 704    GLubyte *d = ((GLubyte *) dst);
 705    *d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
 706 }
 707
 708 static void
 709 pack_float_RGB332(const GLfloat src[4], void *dst)
 710 {
 711    GLubyte v[4];
 712    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
 713    UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
 714    UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
 715    pack_ubyte_RGB332(v, dst);
 716 }
 717
 718
 719 /* MESA_FORMAT_A8 */
 720
 721 static void
 722 pack_ubyte_A8(const GLubyte src[4], void *dst)
 723 {
 724    GLubyte *d = ((GLubyte *) dst);
 725    *d = src[ACOMP];
 726 }
 727
 728 static void
 729 pack_float_A8(const GLfloat src[4], void *dst)
 730 {
 731    GLubyte *d = ((GLubyte *) dst);
 732    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
 733 }
 734
 735
 736 /* MESA_FORMAT_A16 */
 737
 738 static void
 739 pack_ubyte_A16(const GLubyte src[4], void *dst)
 740 {
 741    GLushort *d = ((GLushort *) dst);
 742    *d = UBYTE_TO_USHORT(src[ACOMP]);
 743 }
 744
 745 static void
 746 pack_float_A16(const GLfloat src[4], void *dst)
 747 {
 748    GLushort *d = ((GLushort *) dst);
 749    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
 750 }
 751
 752
 753 /* MESA_FORMAT_L8 */
 754
 755 static void
 756 pack_ubyte_L8(const GLubyte src[4], void *dst)
 757 {
 758    GLubyte *d = ((GLubyte *) dst);
 759    *d = src[RCOMP];
 760 }
 761
 762 static void
 763 pack_float_L8(const GLfloat src[4], void *dst)
 764 {
 765    GLubyte *d = ((GLubyte *) dst);
 766    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
 767 }
 768
 769
 770 /* MESA_FORMAT_L16 */
 771
 772 static void
 773 pack_ubyte_L16(const GLubyte src[4], void *dst)
 774 {
 775    GLushort *d = ((GLushort *) dst);
 776    *d = UBYTE_TO_USHORT(src[RCOMP]);
 777 }
 778
 779 static void
 780 pack_float_L16(const GLfloat src[4], void *dst)
 781 {
 782    GLushort *d = ((GLushort *) dst);
 783    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
 784 }
 785
 786
 787 /* MESA_FORMAT_YCBCR */
 788
 789 static void
 790 pack_ubyte_YCBCR(const GLubyte src[4], void *dst)
 791 {
 792    /* todo */
 793 }
 794
 795 static void
 796 pack_float_YCBCR(const GLfloat src[4], void *dst)
 797 {
 798    /* todo */
 799 }
 800
 801
 802 /* MESA_FORMAT_YCBCR_REV */
 803
 804 static void
 805 pack_ubyte_YCBCR_REV(const GLubyte src[4], void *dst)
 806 {
 807    /* todo */
 808 }
 809
 810 static void
 811 pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
 812 {
 813    /* todo */
 814 }
 815
 816
 817 /* MESA_FORMAT_RGBA_FLOAT32 */
 818
 819 static void
 820 pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
 821 {
 822    GLfloat *d = ((GLfloat *) dst);
 823    d[0] = UBYTE_TO_FLOAT(src[0]);
 824    d[1] = UBYTE_TO_FLOAT(src[1]);
 825    d[2] = UBYTE_TO_FLOAT(src[2]);
 826    d[3] = UBYTE_TO_FLOAT(src[3]);
 827 }
 828
 829 static void
 830 pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
 831 {
 832    GLfloat *d = ((GLfloat *) dst);
 833    d[0] = src[0];
 834    d[1] = src[1];
 835    d[2] = src[2];
 836    d[3] = src[3];
 837 }
 838
 839
 840 /* MESA_FORMAT_RGBA_FLOAT16 */
 841
 842 static void
 843 pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
 844 {
 845    GLhalfARB *d = ((GLhalfARB *) dst);
 846    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
 847    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
 848    d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
 849    d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
 850 }
 851
 852 static void
 853 pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
 854 {
 855    GLhalfARB *d = ((GLhalfARB *) dst);
 856    d[0] = _mesa_float_to_half(src[0]);
 857    d[1] = _mesa_float_to_half(src[1]);
 858    d[2] = _mesa_float_to_half(src[2]);
 859    d[3] = _mesa_float_to_half(src[3]);
 860 }
 861
 862
 863 /* MESA_FORMAT_RGB_FLOAT32 */
 864
 865 static void
 866 pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
 867 {
 868    GLfloat *d = ((GLfloat *) dst);
 869    d[0] = UBYTE_TO_FLOAT(src[0]);
 870    d[1] = UBYTE_TO_FLOAT(src[1]);
 871    d[2] = UBYTE_TO_FLOAT(src[2]);
 872 }
 873
 874 static void
 875 pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
 876 {
 877    GLfloat *d = ((GLfloat *) dst);
 878    d[0] = src[0];
 879    d[1] = src[1];
 880    d[2] = src[2];
 881 }
 882
 883
 884 /* MESA_FORMAT_RGB_FLOAT16 */
 885
 886 static void
 887 pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
 888 {
 889    GLhalfARB *d = ((GLhalfARB *) dst);
 890    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
 891    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
 892    d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
 893 }
 894
 895 static void
 896 pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
 897 {
 898    GLhalfARB *d = ((GLhalfARB *) dst);
 899    d[0] = _mesa_float_to_half(src[0]);
 900    d[1] = _mesa_float_to_half(src[1]);
 901    d[2] = _mesa_float_to_half(src[2]);
 902 }
 903
 904
 905 /* MESA_FORMAT_ALPHA_FLOAT32 */
 906
 907 static void
 908 pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
 909 {
 910    GLfloat *d = ((GLfloat *) dst);
 911    d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
 912 }
 913
 914 static void
 915 pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
 916 {
 917    GLfloat *d = ((GLfloat *) dst);
 918    d[0] = src[ACOMP];
 919 }
 920
 921
 922 /* MESA_FORMAT_ALPHA_FLOAT16 */
 923
 924 static void
 925 pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
 926 {
 927    GLhalfARB *d = ((GLhalfARB *) dst);
 928    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
 929 }
 930
 931 static void
 932 pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
 933 {
 934    GLhalfARB *d = ((GLhalfARB *) dst);
 935    d[0] = _mesa_float_to_half(src[ACOMP]);
 936 }
 937
 938
 939 /* MESA_FORMAT_LUMINANCE_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
 940
 941 static void
 942 pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
 943 {
 944    GLfloat *d = ((GLfloat *) dst);
 945    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
 946 }
 947
 948 static void
 949 pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
 950 {
 951    GLfloat *d = ((GLfloat *) dst);
 952    d[0] = src[RCOMP];
 953 }
 954
 955
 956 /* MESA_FORMAT_LUMINANCE_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
 957
 958 static void
 959 pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
 960 {
 961    GLhalfARB *d = ((GLhalfARB *) dst);
 962    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
 963 }
 964
 965 static void
 966 pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
 967 {
 968    GLhalfARB *d = ((GLhalfARB *) dst);
 969    d[0] = _mesa_float_to_half(src[RCOMP]);
 970 }
 971
 972
 973 /* MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 */
 974
 975 static void
 976 pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
 977 {
 978    GLfloat *d = ((GLfloat *) dst);
 979    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
 980    d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
 981 }
 982
 983 static void
 984 pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
 985 {
 986    GLfloat *d = ((GLfloat *) dst);
 987    d[0] = src[RCOMP];
 988    d[1] = src[ACOMP];
 989 }
 990
 991
 992 /* MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 */
 993
 994 static void
 995 pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
 996 {
 997    GLhalfARB *d = ((GLhalfARB *) dst);
 998    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
 999    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1000 }
1001
1002 static void
1003 pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1004 {
1005    GLhalfARB *d = ((GLhalfARB *) dst);
1006    d[0] = _mesa_float_to_half(src[RCOMP]);
1007    d[1] = _mesa_float_to_half(src[ACOMP]);
1008 }
1009
1010
1011 /* MESA_FORMAT_RGBA_16 */
1012
1013 static void
1014 pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
1015 {
1016    GLushort *d = ((GLushort *) dst);
1017    d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1018    d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1019    d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1020    d[3] = UBYTE_TO_USHORT(src[ACOMP]);
1021 }
1022
1023 static void
1024 pack_float_RGBA_16(const GLfloat src[4], void *dst)
1025 {
1026    GLushort *d = ((GLushort *) dst);
1027    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1028    UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1029    UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1030    UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
1031 }
1032
1033 /*
1034  * MESA_FORMAT_SIGNED_RGBA_16
1035  */
1036
1037 static void
1038 pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
1039 {
1040    GLshort *d = (GLshort *) dst;
1041    d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1042    d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1043    d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1044    d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1045 }
1046
1047
1048
1049 /**
1050  * Return a function that can pack a GLubyte rgba[4] color.
1051  */
1052 gl_pack_ubyte_rgba_func
1053 _mesa_get_pack_ubyte_rgba_function(gl_format format)
1054 {
1055    static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
1056    static GLboolean initialized = GL_FALSE;
1057
1058    if (!initialized) {
1059       memset(table, 0, sizeof(table));
1060
1061       table[MESA_FORMAT_NONE] = NULL;
1062
1063       table[MESA_FORMAT_RGBA8888] = pack_ubyte_RGBA8888;
1064       table[MESA_FORMAT_RGBA8888_REV] = pack_ubyte_RGBA8888_REV;
1065       table[MESA_FORMAT_ARGB8888] = pack_ubyte_ARGB8888;
1066       table[MESA_FORMAT_ARGB8888_REV] = pack_ubyte_ARGB8888_REV;
1067       table[MESA_FORMAT_RGBX8888] = pack_ubyte_RGBA8888; /* reused */
1068       table[MESA_FORMAT_RGBX8888_REV] = pack_ubyte_RGBA8888_REV; /* reused */
1069       table[MESA_FORMAT_XRGB8888] = pack_ubyte_XRGB8888;
1070       table[MESA_FORMAT_XRGB8888_REV] = pack_ubyte_XRGB8888_REV;
1071       table[MESA_FORMAT_RGB888] = pack_ubyte_RGB888;
1072       table[MESA_FORMAT_BGR888] = pack_ubyte_BGR888;
1073       table[MESA_FORMAT_RGB565] = pack_ubyte_RGB565;
1074       table[MESA_FORMAT_RGB565_REV] = pack_ubyte_RGB565_REV;
1075       table[MESA_FORMAT_ARGB4444] = pack_ubyte_ARGB4444;
1076       table[MESA_FORMAT_ARGB4444_REV] = pack_ubyte_ARGB4444_REV;
1077       table[MESA_FORMAT_RGBA5551] = pack_ubyte_RGBA5551;
1078       table[MESA_FORMAT_ARGB1555] = pack_ubyte_ARGB1555;
1079       table[MESA_FORMAT_ARGB1555_REV] = pack_ubyte_ARGB1555_REV;
1080       table[MESA_FORMAT_AL44] = pack_ubyte_AL44;
1081       table[MESA_FORMAT_AL88] = pack_ubyte_AL88;
1082       table[MESA_FORMAT_AL88_REV] = pack_ubyte_AL88_REV;
1083       table[MESA_FORMAT_AL1616] = pack_ubyte_AL1616;
1084       table[MESA_FORMAT_AL1616_REV] = pack_ubyte_AL1616_REV;
1085       table[MESA_FORMAT_RGB332] = pack_ubyte_RGB332;
1086       table[MESA_FORMAT_A8] = pack_ubyte_A8;
1087       table[MESA_FORMAT_A16] = pack_ubyte_A16;
1088       table[MESA_FORMAT_L8] = pack_ubyte_L8;
1089       table[MESA_FORMAT_L16] = pack_ubyte_L16;
1090       table[MESA_FORMAT_I8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
1091       table[MESA_FORMAT_I16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
1092       table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
1093       table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
1094
1095       /* should never convert RGBA to these formats */
1096       table[MESA_FORMAT_Z16] = NULL;
1097       table[MESA_FORMAT_X8_Z24] = NULL;
1098       table[MESA_FORMAT_Z24_X8] = NULL;
1099       table[MESA_FORMAT_Z32] = NULL;
1100       table[MESA_FORMAT_S8] = NULL;
1101
1102       table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
1103       table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
1104       table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
1105       table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
1106       table[MESA_FORMAT_ALPHA_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
1107       table[MESA_FORMAT_ALPHA_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
1108       table[MESA_FORMAT_LUMINANCE_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1109       table[MESA_FORMAT_LUMINANCE_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1110       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
1111       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
1112       table[MESA_FORMAT_INTENSITY_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1113       table[MESA_FORMAT_INTENSITY_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1114
1115       /* n/a */
1116       table[MESA_FORMAT_RGBA_INT8] = NULL; /* pack_ubyte_RGBA_INT8 */
1117       table[MESA_FORMAT_RGBA_INT16] = NULL; /* pack_ubyte_RGBA_INT16 */
1118       table[MESA_FORMAT_RGBA_INT32] = NULL; /* pack_ubyte_RGBA_INT32 */
1119       table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
1120       table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
1121       table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
1122
1123       table[MESA_FORMAT_RGBA_16] = pack_ubyte_RGBA_16;
1124
1125       table[MESA_FORMAT_SIGNED_RGBA_16] = NULL;
1126
1127
1128       table[MESA_FORMAT_RGBA_16] = pack_ubyte_RGBA_16;
1129
1130       initialized = GL_TRUE;
1131    }
1132
1133    return table[format];
1134 }
1135
1136
1137
1138 /**
1139  * Return a function that can pack a GLfloat rgba[4] color.
1140  */
1141 gl_pack_float_rgba_func
1142 _mesa_get_pack_float_rgba_function(gl_format format)
1143 {
1144    static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
1145    static GLboolean initialized = GL_FALSE;
1146
1147    if (!initialized) {
1148       memset(table, 0, sizeof(table));
1149
1150       table[MESA_FORMAT_NONE] = NULL;
1151
1152       table[MESA_FORMAT_RGBA8888] = pack_float_RGBA8888;
1153       table[MESA_FORMAT_RGBA8888_REV] = pack_float_RGBA8888_REV;
1154       table[MESA_FORMAT_ARGB8888] = pack_float_ARGB8888;
1155       table[MESA_FORMAT_ARGB8888_REV] = pack_float_ARGB8888_REV;
1156       table[MESA_FORMAT_RGBX8888] = pack_float_RGBA8888; /* reused */
1157       table[MESA_FORMAT_RGBX8888_REV] = pack_float_RGBA8888_REV; /* reused */
1158       table[MESA_FORMAT_XRGB8888] = pack_float_XRGB8888;
1159       table[MESA_FORMAT_XRGB8888_REV] = pack_float_XRGB8888_REV;
1160       table[MESA_FORMAT_RGB888] = pack_float_RGB888;
1161       table[MESA_FORMAT_BGR888] = pack_float_BGR888;
1162       table[MESA_FORMAT_RGB565] = pack_float_RGB565;
1163       table[MESA_FORMAT_RGB565_REV] = pack_float_RGB565_REV;
1164       table[MESA_FORMAT_ARGB4444] = pack_float_ARGB4444;
1165       table[MESA_FORMAT_ARGB4444_REV] = pack_float_ARGB4444_REV;
1166       table[MESA_FORMAT_RGBA5551] = pack_float_RGBA5551;
1167       table[MESA_FORMAT_ARGB1555] = pack_float_ARGB1555;
1168       table[MESA_FORMAT_ARGB1555_REV] = pack_float_ARGB1555_REV;
1169
1170       table[MESA_FORMAT_AL44] = pack_float_AL44;
1171       table[MESA_FORMAT_AL88] = pack_float_AL88;
1172       table[MESA_FORMAT_AL88_REV] = pack_float_AL88_REV;
1173       table[MESA_FORMAT_AL1616] = pack_float_AL1616;
1174       table[MESA_FORMAT_AL1616_REV] = pack_float_AL1616_REV;
1175       table[MESA_FORMAT_RGB332] = pack_float_RGB332;
1176       table[MESA_FORMAT_A8] = pack_float_A8;
1177       table[MESA_FORMAT_A16] = pack_float_A16;
1178       table[MESA_FORMAT_L8] = pack_float_L8;
1179       table[MESA_FORMAT_L16] = pack_float_L16;
1180       table[MESA_FORMAT_I8] = pack_float_L8; /* reuse pack_float_L8 */
1181       table[MESA_FORMAT_I16] = pack_float_L16; /* reuse pack_float_L16 */
1182       table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
1183       table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
1184
1185       /* should never convert RGBA to these formats */
1186       table[MESA_FORMAT_Z16] = NULL;
1187       table[MESA_FORMAT_X8_Z24] = NULL;
1188       table[MESA_FORMAT_Z24_X8] = NULL;
1189       table[MESA_FORMAT_Z32] = NULL;
1190       table[MESA_FORMAT_S8] = NULL;
1191
1192       table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
1193       table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
1194       table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
1195       table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
1196       table[MESA_FORMAT_ALPHA_FLOAT32] = pack_float_ALPHA_FLOAT32;
1197       table[MESA_FORMAT_ALPHA_FLOAT16] = pack_float_ALPHA_FLOAT16;
1198       table[MESA_FORMAT_LUMINANCE_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
1199       table[MESA_FORMAT_LUMINANCE_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
1200       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
1201       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
1202
1203       table[MESA_FORMAT_INTENSITY_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
1204       table[MESA_FORMAT_INTENSITY_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
1205
1206       /* n/a */
1207       table[MESA_FORMAT_RGBA_INT8] = NULL;
1208       table[MESA_FORMAT_RGBA_INT16] = NULL;
1209       table[MESA_FORMAT_RGBA_INT32] = NULL;
1210       table[MESA_FORMAT_RGBA_UINT8] = NULL;
1211       table[MESA_FORMAT_RGBA_UINT16] = NULL;
1212       table[MESA_FORMAT_RGBA_UINT32] = NULL;
1213
1214       table[MESA_FORMAT_RGBA_16] = pack_float_RGBA_16;
1215
1216       table[MESA_FORMAT_SIGNED_RGBA_16] = pack_float_SIGNED_RGBA_16;
1217
1218
1219       initialized = GL_TRUE;
1220    }
1221
1222    return table[format];
1223 }
1224
1225
1226
1227 static pack_float_rgba_row_func
1228 get_pack_float_rgba_row_function(gl_format format)
1229 {
1230    static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
1231    static GLboolean initialized = GL_FALSE;
1232
1233    if (!initialized) {
1234       /* We don't need a special row packing function for each format.
1235        * There's a generic fallback which uses a per-pixel packing function.
1236        */
1237       memset(table, 0, sizeof(table));
1238
1239       table[MESA_FORMAT_RGBA8888] = pack_row_float_RGBA8888;
1240       table[MESA_FORMAT_RGBA8888_REV] = pack_row_float_RGBA8888_REV;
1241       table[MESA_FORMAT_ARGB8888] = pack_row_float_ARGB8888;
1242       table[MESA_FORMAT_ARGB8888_REV] = pack_row_float_ARGB8888_REV;
1243       table[MESA_FORMAT_RGBX8888] = pack_row_float_RGBA8888; /* reused */
1244       table[MESA_FORMAT_RGBX8888_REV] = pack_row_float_RGBA8888_REV; /* reused */
1245       table[MESA_FORMAT_XRGB8888] = pack_row_float_XRGB8888;
1246       table[MESA_FORMAT_XRGB8888_REV] = pack_row_float_XRGB8888_REV;
1247       table[MESA_FORMAT_RGB888] = pack_row_float_RGB888;
1248       table[MESA_FORMAT_BGR888] = pack_row_float_BGR888;
1249       table[MESA_FORMAT_RGB565] = pack_row_float_RGB565;
1250       table[MESA_FORMAT_RGB565_REV] = pack_row_float_RGB565_REV;
1251
1252       initialized = GL_TRUE;
1253    }
1254
1255    return table[format];
1256 }
1257
1258
1259
1260 static pack_ubyte_rgba_row_func
1261 get_pack_ubyte_rgba_row_function(gl_format format)
1262 {
1263    static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
1264    static GLboolean initialized = GL_FALSE;
1265
1266    if (!initialized) {
1267       /* We don't need a special row packing function for each format.
1268        * There's a generic fallback which uses a per-pixel packing function.
1269        */
1270       memset(table, 0, sizeof(table));
1271
1272       table[MESA_FORMAT_RGBA8888] = pack_row_ubyte_RGBA8888;
1273       table[MESA_FORMAT_RGBA8888_REV] = pack_row_ubyte_RGBA8888_REV;
1274       table[MESA_FORMAT_ARGB8888] = pack_row_ubyte_ARGB8888;
1275       table[MESA_FORMAT_ARGB8888_REV] = pack_row_ubyte_ARGB8888_REV;
1276       table[MESA_FORMAT_RGBX8888] = pack_row_ubyte_RGBA8888; /* reused */
1277       table[MESA_FORMAT_RGBX8888_REV] = pack_row_ubyte_RGBA8888_REV; /* reused */
1278       table[MESA_FORMAT_XRGB8888] = pack_row_ubyte_XRGB8888;
1279       table[MESA_FORMAT_XRGB8888_REV] = pack_row_ubyte_XRGB8888_REV;
1280       table[MESA_FORMAT_RGB888] = pack_row_ubyte_RGB888;
1281       table[MESA_FORMAT_BGR888] = pack_row_ubyte_BGR888;
1282       table[MESA_FORMAT_RGB565] = pack_row_ubyte_RGB565;
1283       table[MESA_FORMAT_RGB565_REV] = pack_row_ubyte_RGB565_REV;
1284
1285       initialized = GL_TRUE;
1286    }
1287
1288    return table[format];
1289 }
1290
1291
1292
1293 /**
1294  * Pack a row of GLfloat rgba[4] values to the destination.
1295  */
1296 void
1297 _mesa_pack_float_rgba_row(gl_format format, GLuint n,
1298                           const GLfloat src[][4], void *dst)
1299 {
1300    pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
1301    if (packrow) {
1302       /* use "fast" function */
1303       packrow(n, src, dst);
1304    }
1305    else {
1306       /* slower fallback */
1307       gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
1308       GLuint dstStride = _mesa_get_format_bytes(format);
1309       GLubyte *dstPtr = (GLubyte *) dst;
1310       GLuint i;
1311
1312       assert(pack);
1313       if (!pack)
1314          return;
1315
1316       for (i = 0; i < n; i++) {
1317          pack(src[i], dstPtr);
1318          dstPtr += dstStride;
1319       }
1320    }
1321 }
1322
1323
1324 /**
1325  * Pack a row of GLubyte rgba[4] values to the destination.
1326  */
1327 void
1328 _mesa_pack_ubyte_rgba_row(gl_format format, GLuint n,
1329                           const GLubyte src[][4], void *dst)
1330 {
1331    pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
1332    if (packrow) {
1333       /* use "fast" function */
1334       packrow(n, src, dst);
1335    }
1336    else {
1337       /* slower fallback */
1338       gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
1339       const GLuint stride = _mesa_get_format_bytes(format);
1340       GLubyte *d = ((GLubyte *) dst);
1341       GLuint i;
1342
1343       assert(pack);
1344       if (!pack)
1345          return;
1346
1347       for (i = 0; i < n; i++) {
1348          pack(src[i], d);
1349          d += stride;
1350       }
1351    }
1352 }
1353
1354
1355 /**
1356  ** Pack float Z pixels
1357  **/
1358
1359 static void
1360 pack_float_z_Z24_S8(const GLfloat *src, void *dst)
1361 {
1362    /* don't disturb the stencil values */
1363    GLuint *d = ((GLuint *) dst);
1364    const GLdouble scale = (GLdouble) 0xffffff;
1365    GLuint s = *d & 0xff;
1366    GLuint z = (GLuint) (*src * scale);
1367    assert(z <= 0xffffff);
1368    *d = (z << 8) | s;
1369 }
1370
1371 static void
1372 pack_float_z_S8_Z24(const GLfloat *src, void *dst)
1373 {
1374    /* don't disturb the stencil values */
1375    GLuint *d = ((GLuint *) dst);
1376    const GLdouble scale = (GLdouble) 0xffffff;
1377    GLuint s = *d & 0xff000000;
1378    GLuint z = (GLuint) (*src * scale);
1379    assert(z <= 0xffffff);
1380    *d = s | z;
1381 }
1382
1383 static void
1384 pack_float_z_Z16(const GLfloat *src, void *dst)
1385 {
1386    GLushort *d = ((GLushort *) dst);
1387    const GLfloat scale = (GLfloat) 0xffff;
1388    *d = (GLushort) (*src * scale);
1389 }
1390
1391 static void
1392 pack_float_z_Z32(const GLfloat *src, void *dst)
1393 {
1394    GLuint *d = ((GLuint *) dst);
1395    const GLdouble scale = (GLdouble) 0xffffffff;
1396    *d = (GLuint) (*src * scale);
1397 }
1398
1399 gl_pack_float_z_func
1400 _mesa_get_pack_float_z_func(gl_format format)
1401 {
1402    switch (format) {
1403    case MESA_FORMAT_Z24_X8:
1404       return pack_float_z_Z24_S8;
1405    case MESA_FORMAT_X8_Z24:
1406       return pack_float_z_S8_Z24;
1407    case MESA_FORMAT_Z16:
1408       return pack_float_z_Z16;
1409    case MESA_FORMAT_Z32:
1410       return pack_float_z_Z32;
1411    default:
1412       _mesa_problem(NULL,
1413                     "unexpected format in _mesa_get_pack_float_z_func()");
1414       return NULL;
1415    }
1416 }
1417
1418
1419
1420 /**
1421  ** Pack uint Z pixels.  The incoming src value is always in
1422  ** the range [0, 2^32-1].
1423  **/
1424
1425 static void
1426 pack_uint_z_Z24_S8(const GLuint *src, void *dst)
1427 {
1428    /* don't disturb the stencil values */
1429    GLuint *d = ((GLuint *) dst);
1430    GLuint s = *d & 0xff;
1431    GLuint z = *src & 0xffffff00;
1432    *d = z | s;
1433 }
1434
1435 static void
1436 pack_uint_z_S8_Z24(const GLuint *src, void *dst)
1437 {
1438    /* don't disturb the stencil values */
1439    GLuint *d = ((GLuint *) dst);
1440    GLuint s = *d & 0xff000000;
1441    GLuint z = *src >> 8;
1442    *d = s | z;
1443 }
1444
1445 static void
1446 pack_uint_z_Z16(const GLuint *src, void *dst)
1447 {
1448    GLushort *d = ((GLushort *) dst);
1449    *d = *src >> 16;
1450 }
1451
1452 static void
1453 pack_uint_z_Z32(const GLuint *src, void *dst)
1454 {
1455    GLuint *d = ((GLuint *) dst);
1456    *d = *src;
1457 }
1458
1459 gl_pack_uint_z_func
1460 _mesa_get_pack_uint_z_func(gl_format format)
1461 {
1462    switch (format) {
1463    case MESA_FORMAT_Z24_X8:
1464       return pack_uint_z_Z24_S8;
1465    case MESA_FORMAT_X8_Z24:
1466       return pack_uint_z_S8_Z24;
1467    case MESA_FORMAT_Z16:
1468       return pack_uint_z_Z16;
1469    case MESA_FORMAT_Z32:
1470       return pack_uint_z_Z32;
1471    default:
1472       _mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
1473       return NULL;
1474    }
1475 }
1476
1477
1478 /**
1479  ** Pack ubyte stencil pixels
1480  **/
1481
1482 static void
1483 pack_ubyte_stencil_S8(const GLubyte *src, void *dst)
1484 {
1485    GLubyte *d = (GLubyte *) dst;
1486    *d = *src;
1487 }
1488
1489
1490 gl_pack_ubyte_stencil_func
1491 _mesa_get_pack_ubyte_stencil_func(gl_format format)
1492 {
1493    return pack_ubyte_stencil_S8;
1494 }
1495
1496
1497
1498 void
1499 _mesa_pack_float_z_row(gl_format format, GLuint n,
1500                        const GLfloat *src, void *dst)
1501 {
1502    switch (format) {
1503    case MESA_FORMAT_Z24_X8:
1504       {
1505          /* don't disturb the stencil values */
1506          GLuint *d = ((GLuint *) dst);
1507          const GLdouble scale = (GLdouble) 0xffffff;
1508          GLuint i;
1509          for (i = 0; i < n; i++) {
1510             GLuint s = d[i] & 0xff;
1511             GLuint z = (GLuint) (src[i] * scale);
1512             assert(z <= 0xffffff);
1513             d[i] = (z << 8) | s;
1514          }
1515       }
1516       break;
1517    case MESA_FORMAT_X8_Z24:
1518       {
1519          /* don't disturb the stencil values */
1520          GLuint *d = ((GLuint *) dst);
1521          const GLdouble scale = (GLdouble) 0xffffff;
1522          GLuint i;
1523          for (i = 0; i < n; i++) {
1524             GLuint s = d[i] & 0xff000000;
1525             GLuint z = (GLuint) (src[i] * scale);
1526             assert(z <= 0xffffff);
1527             d[i] = s | z;
1528          }
1529       }
1530       break;
1531    case MESA_FORMAT_Z16:
1532       {
1533          GLushort *d = ((GLushort *) dst);
1534          const GLfloat scale = (GLfloat) 0xffff;
1535          GLuint i;
1536          for (i = 0; i < n; i++) {
1537             d[i] = (GLushort) (src[i] * scale);
1538          }
1539       }
1540       break;
1541    case MESA_FORMAT_Z32:
1542       {
1543          GLuint *d = ((GLuint *) dst);
1544          const GLdouble scale = (GLdouble) 0xffffffff;
1545          GLuint i;
1546          for (i = 0; i < n; i++) {
1547             d[i] = (GLuint) (src[i] * scale);
1548          }
1549       }
1550       break;
1551    default:
1552       _mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
1553    }
1554 }
1555
1556
1557 /**
1558  * The incoming Z values are always in the range [0, 0xffffffff].
1559  */
1560 void
1561 _mesa_pack_uint_z_row(gl_format format, GLuint n,
1562                       const GLuint *src, void *dst)
1563 {
1564    switch (format) {
1565    case MESA_FORMAT_Z24_X8:
1566       {
1567          /* don't disturb the stencil values */
1568          GLuint *d = ((GLuint *) dst);
1569          GLuint i;
1570          for (i = 0; i < n; i++) {
1571             GLuint s = d[i] & 0xff;
1572             GLuint z = src[i] & 0xffffff00;
1573             d[i] = z | s;
1574          }
1575       }
1576       break;
1577    case MESA_FORMAT_X8_Z24:
1578       {
1579          /* don't disturb the stencil values */
1580          GLuint *d = ((GLuint *) dst);
1581          GLuint i;
1582          for (i = 0; i < n; i++) {
1583             GLuint s = d[i] & 0xff000000;
1584             GLuint z = src[i] >> 8;
1585             d[i] = s | z;
1586          }
1587       }
1588       break;
1589    case MESA_FORMAT_Z16:
1590       {
1591          GLushort *d = ((GLushort *) dst);
1592          GLuint i;
1593          for (i = 0; i < n; i++) {
1594             d[i] = src[i] >> 16;
1595          }
1596       }
1597       break;
1598    case MESA_FORMAT_Z32:
1599       memcpy(dst, src, n * sizeof(GLfloat));
1600       break;
1601    default:
1602       _mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
1603    }
1604 }
1605
1606
1607 void
1608 _mesa_pack_ubyte_stencil_row(gl_format format, GLuint n,
1609                              const GLubyte *src, void *dst)
1610 {
1611    memcpy(dst, src, n * sizeof(GLubyte));
1612 }
1613
1614
1615 /**
1616  * Convert a boolean color mask to a packed color where each channel of
1617  * the packed value at dst will be 0 or ~0 depending on the colorMask.
1618  */
1619 void
1620 _mesa_pack_colormask(gl_format format, const GLubyte colorMask[4], void *dst)
1621 {
1622    GLfloat maskColor[4];
1623
1624    switch (_mesa_get_format_datatype(format)) {
1625    case GL_UNSIGNED_NORMALIZED:
1626       /* simple: 1.0 will convert to ~0 in the right bit positions */
1627       maskColor[0] = colorMask[0] ? 1.0 : 0.0;
1628       maskColor[1] = colorMask[1] ? 1.0 : 0.0;
1629       maskColor[2] = colorMask[2] ? 1.0 : 0.0;
1630       maskColor[3] = colorMask[3] ? 1.0 : 0.0;
1631       _mesa_pack_float_rgba_row(format, 1,
1632                                 (const GLfloat (*)[4]) maskColor, dst);
1633       break;
1634    case GL_SIGNED_NORMALIZED:
1635    case GL_FLOAT:
1636       /* These formats are harder because it's hard to know the floating
1637        * point values that will convert to ~0 for each color channel's bits.
1638        * This solution just generates a non-zero value for each color channel
1639        * then fixes up the non-zero values to be ~0.
1640        * Note: we'll need to add special case code if we ever have to deal
1641        * with formats with unequal color channel sizes, like R11_G11_B10.
1642        * We issue a warning below for channel sizes other than 8,16,32.
1643        */
1644       {
1645          GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
1646          GLuint bytes = _mesa_get_format_bytes(format);
1647          GLuint i;
1648
1649          /* this should put non-zero values into the channels of dst */
1650          maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
1651          maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
1652          maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
1653          maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
1654          _mesa_pack_float_rgba_row(format, 1,
1655                                    (const GLfloat (*)[4]) maskColor, dst);
1656
1657          /* fix-up the dst channels by converting non-zero values to ~0 */
1658          if (bits == 8) {
1659             GLubyte *d = (GLubyte *) dst;
1660             for (i = 0; i < bytes; i++) {
1661                d[i] = d[i] ? 0xffff : 0x0;
1662             }
1663          }
1664          else if (bits == 16) {
1665             GLushort *d = (GLushort *) dst;
1666             for (i = 0; i < bytes / 2; i++) {
1667                d[i] = d[i] ? 0xffff : 0x0;
1668             }
1669          }
1670          else if (bits == 32) {
1671             GLuint *d = (GLuint *) dst;
1672             for (i = 0; i < bytes / 4; i++) {
1673                d[i] = d[i] ? 0xffffffffU : 0x0;
1674             }
1675          }
1676          else {
1677             _mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
1678             return;
1679          }
1680       }
1681       break;
1682    default:
1683       _mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
1684       return;
1685    }
1686 }