src/mesa/main/texstore.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.5
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  * Copyright (c) 2008-2009  VMware, Inc.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /*
  27  * Authors:
  28  *   Brian Paul
  29  */
  30
  31 /**
  32  * The GL texture image functions in teximage.c basically just do
  33  * error checking and data structure allocation.  They in turn call
  34  * device driver functions which actually copy/convert/store the user's
  35  * texture image data.
  36  *
  37  * However, most device drivers will be able to use the fallback functions
  38  * in this file.  That is, most drivers will have the following bit of
  39  * code:
  40  *   ctx->Driver.TexImage = _mesa_store_teximage;
  41  *   ctx->Driver.TexSubImage = _mesa_store_texsubimage;
  42  *   etc...
  43  *
  44  * Texture image processing is actually kind of complicated.  We have to do:
  45  *    Format/type conversions
  46  *    pixel unpacking
  47  *    pixel transfer (scale, bais, lookup, etc)
  48  *
  49  * These functions can handle most everything, including processing full
  50  * images and sub-images.
  51  */
  52
  53
  54 #include "glheader.h"
  55 #include "bufferobj.h"
  56 #include "colormac.h"
  57 #include "format_pack.h"
  58 #include "image.h"
  59 #include "macros.h"
  60 #include "mipmap.h"
  61 #include "mfeatures.h"
  62 #include "mtypes.h"
  63 #include "pack.h"
  64 #include "pbo.h"
  65 #include "imports.h"
  66 #include "texcompress.h"
  67 #include "texcompress_fxt1.h"
  68 #include "texcompress_rgtc.h"
  69 #include "texcompress_s3tc.h"
  70 #include "texcompress_etc.h"
  71 #include "teximage.h"
  72 #include "texstore.h"
  73 #include "enums.h"
  74 #include "glformats.h"
  75 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
  76 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
  77
  78
  79 enum {
  80    ZERO = 4,
  81    ONE = 5
  82 };
  83
  84
  85 /**
  86  * Texture image storage function.
  87  */
  88 typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);
  89
  90
  91 /**
  92  * Return GL_TRUE if the given image format is one that be converted
  93  * to another format by swizzling.
  94  */
  95 static GLboolean
  96 can_swizzle(GLenum logicalBaseFormat)
  97 {
  98    switch (logicalBaseFormat) {
  99    case GL_RGBA:
 100    case GL_RGB:
 101    case GL_LUMINANCE_ALPHA:
 102    case GL_INTENSITY:
 103    case GL_ALPHA:
 104    case GL_LUMINANCE:
 105    case GL_RED:
 106    case GL_GREEN:
 107    case GL_BLUE:
 108    case GL_BGR:
 109    case GL_BGRA:
 110    case GL_ABGR_EXT:
 111    case GL_RG:
 112       return GL_TRUE;
 113    default:
 114       return GL_FALSE;
 115    }
 116 }
 117
 118
 119
 120 enum {
 121    IDX_LUMINANCE = 0,
 122    IDX_ALPHA,
 123    IDX_INTENSITY,
 124    IDX_LUMINANCE_ALPHA,
 125    IDX_RGB,
 126    IDX_RGBA,
 127    IDX_RED,
 128    IDX_GREEN,
 129    IDX_BLUE,
 130    IDX_BGR,
 131    IDX_BGRA,
 132    IDX_ABGR,
 133    IDX_RG,
 134    MAX_IDX
 135 };
 136
 137 #define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)
 138 #define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)
 139 #define MAP3(x,y,z)   MAP4(x, y, z, ZERO)
 140 #define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
 141
 142
 143 static const struct {
 144    GLubyte format_idx;
 145    GLubyte to_rgba[6];
 146    GLubyte from_rgba[6];
 147 } mappings[MAX_IDX] =
 148 {
 149    {
 150       IDX_LUMINANCE,
 151       MAP4(0,0,0,ONE),
 152       MAP1(0)
 153    },
 154
 155    {
 156       IDX_ALPHA,
 157       MAP4(ZERO, ZERO, ZERO, 0),
 158       MAP1(3)
 159    },
 160
 161    {
 162       IDX_INTENSITY,
 163       MAP4(0, 0, 0, 0),
 164       MAP1(0),
 165    },
 166
 167    {
 168       IDX_LUMINANCE_ALPHA,
 169       MAP4(0,0,0,1),
 170       MAP2(0,3)
 171    },
 172
 173    {
 174       IDX_RGB,
 175       MAP4(0,1,2,ONE),
 176       MAP3(0,1,2)
 177    },
 178
 179    {
 180       IDX_RGBA,
 181       MAP4(0,1,2,3),
 182       MAP4(0,1,2,3),
 183    },
 184
 185    {
 186       IDX_RED,
 187       MAP4(0, ZERO, ZERO, ONE),
 188       MAP1(0),
 189    },
 190
 191    {
 192       IDX_GREEN,
 193       MAP4(ZERO, 0, ZERO, ONE),
 194       MAP1(1),
 195    },
 196
 197    {
 198       IDX_BLUE,
 199       MAP4(ZERO, ZERO, 0, ONE),
 200       MAP1(2),
 201    },
 202
 203    {
 204       IDX_BGR,
 205       MAP4(2,1,0,ONE),
 206       MAP3(2,1,0)
 207    },
 208
 209    {
 210       IDX_BGRA,
 211       MAP4(2,1,0,3),
 212       MAP4(2,1,0,3)
 213    },
 214
 215    {
 216       IDX_ABGR,
 217       MAP4(3,2,1,0),
 218       MAP4(3,2,1,0)
 219    },
 220
 221    {
 222       IDX_RG,
 223       MAP4(0, 1, ZERO, ONE),
 224       MAP2(0, 1)
 225    },
 226 };
 227
 228
 229
 230 /**
 231  * Convert a GL image format enum to an IDX_* value (see above).
 232  */
 233 static int
 234 get_map_idx(GLenum value)
 235 {
 236    switch (value) {
 237    case GL_LUMINANCE: return IDX_LUMINANCE;
 238    case GL_ALPHA: return IDX_ALPHA;
 239    case GL_INTENSITY: return IDX_INTENSITY;
 240    case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;
 241    case GL_RGB: return IDX_RGB;
 242    case GL_RGBA: return IDX_RGBA;
 243    case GL_RED: return IDX_RED;
 244    case GL_GREEN: return IDX_GREEN;
 245    case GL_BLUE: return IDX_BLUE;
 246    case GL_BGR: return IDX_BGR;
 247    case GL_BGRA: return IDX_BGRA;
 248    case GL_ABGR_EXT: return IDX_ABGR;
 249    case GL_RG: return IDX_RG;
 250    default:
 251       _mesa_problem(NULL, "Unexpected inFormat");
 252       return 0;
 253    }
 254 }
 255
 256
 257 /**
 258  * When promoting texture formats (see below) we need to compute the
 259  * mapping of dest components back to source components.
 260  * This function does that.
 261  * \param inFormat  the incoming format of the texture
 262  * \param outFormat  the final texture format
 263  * \return map[6]  a full 6-component map
 264  */
 265 static void
 266 compute_component_mapping(GLenum inFormat, GLenum outFormat,
 267                           GLubyte *map)
 268 {
 269    const int inFmt = get_map_idx(inFormat);
 270    const int outFmt = get_map_idx(outFormat);
 271    const GLubyte *in2rgba = mappings[inFmt].to_rgba;
 272    const GLubyte *rgba2out = mappings[outFmt].from_rgba;
 273    int i;
 274
 275    for (i = 0; i < 4; i++)
 276       map[i] = in2rgba[rgba2out[i]];
 277
 278    map[ZERO] = ZERO;
 279    map[ONE] = ONE;
 280
 281 #if 0
 282    printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
 283           inFormat, _mesa_lookup_enum_by_nr(inFormat),
 284           outFormat, _mesa_lookup_enum_by_nr(outFormat),
 285           map[0],
 286           map[1],
 287           map[2],
 288           map[3],
 289           map[4],
 290           map[5]);
 291 #endif
 292 }
 293
 294
 295 /**
 296  * Make a temporary (color) texture image with GLfloat components.
 297  * Apply all needed pixel unpacking and pixel transfer operations.
 298  * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
 299  * Suppose the user specifies GL_LUMINANCE as the internal texture format
 300  * but the graphics hardware doesn't support luminance textures.  So, we might
 301  * use an RGB hardware format instead.
 302  * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
 303  *
 304  * \param ctx  the rendering context
 305  * \param dims  image dimensions: 1, 2 or 3
 306  * \param logicalBaseFormat  basic texture derived from the user's
 307  *    internal texture format value
 308  * \param textureBaseFormat  the actual basic format of the texture
 309  * \param srcWidth  source image width
 310  * \param srcHeight  source image height
 311  * \param srcDepth  source image depth
 312  * \param srcFormat  source image format
 313  * \param srcType  source image type
 314  * \param srcAddr  source image address
 315  * \param srcPacking  source image pixel packing
 316  * \return resulting image with format = textureBaseFormat and type = GLfloat.
 317  */
 318 GLfloat *
 319 _mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
 320                             GLenum logicalBaseFormat,
 321                             GLenum textureBaseFormat,
 322                             GLint srcWidth, GLint srcHeight, GLint srcDepth,
 323                             GLenum srcFormat, GLenum srcType,
 324                             const GLvoid *srcAddr,
 325                             const struct gl_pixelstore_attrib *srcPacking,
 326                             GLbitfield transferOps)
 327 {
 328    GLfloat *tempImage;
 329    const GLint components = _mesa_components_in_format(logicalBaseFormat);
 330    const GLint srcStride =
 331       _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
 332    GLfloat *dst;
 333    GLint img, row;
 334
 335    ASSERT(dims >= 1 && dims <= 3);
 336
 337    ASSERT(logicalBaseFormat == GL_RGBA ||
 338           logicalBaseFormat == GL_RGB ||
 339           logicalBaseFormat == GL_RG ||
 340           logicalBaseFormat == GL_RED ||
 341           logicalBaseFormat == GL_LUMINANCE_ALPHA ||
 342           logicalBaseFormat == GL_LUMINANCE ||
 343           logicalBaseFormat == GL_ALPHA ||
 344           logicalBaseFormat == GL_INTENSITY ||
 345           logicalBaseFormat == GL_DEPTH_COMPONENT);
 346
 347    ASSERT(textureBaseFormat == GL_RGBA ||
 348           textureBaseFormat == GL_RGB ||
 349           textureBaseFormat == GL_RG ||
 350           textureBaseFormat == GL_RED ||
 351           textureBaseFormat == GL_LUMINANCE_ALPHA ||
 352           textureBaseFormat == GL_LUMINANCE ||
 353           textureBaseFormat == GL_ALPHA ||
 354           textureBaseFormat == GL_INTENSITY ||
 355           textureBaseFormat == GL_DEPTH_COMPONENT);
 356
 357    tempImage = malloc(srcWidth * srcHeight * srcDepth
 358                                   * components * sizeof(GLfloat));
 359    if (!tempImage)
 360       return NULL;
 361
 362    dst = tempImage;
 363    for (img = 0; img < srcDepth; img++) {
 364       const GLubyte *src
 365          = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
 366                                                  srcWidth, srcHeight,
 367                                                  srcFormat, srcType,
 368                                                  img, 0, 0);
 369       for (row = 0; row < srcHeight; row++) {
 370          _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,
 371                                        dst, srcFormat, srcType, src,
 372                                        srcPacking, transferOps);
 373          dst += srcWidth * components;
 374          src += srcStride;
 375       }
 376    }
 377
 378    if (logicalBaseFormat != textureBaseFormat) {
 379       /* more work */
 380       GLint texComponents = _mesa_components_in_format(textureBaseFormat);
 381       GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
 382       GLfloat *newImage;
 383       GLint i, n;
 384       GLubyte map[6];
 385
 386       /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
 387       ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
 388              textureBaseFormat == GL_LUMINANCE_ALPHA);
 389
 390       /* The actual texture format should have at least as many components
 391        * as the logical texture format.
 392        */
 393       ASSERT(texComponents >= logComponents);
 394
 395       newImage = malloc(srcWidth * srcHeight * srcDepth
 396                                           * texComponents * sizeof(GLfloat));
 397       if (!newImage) {
 398          free(tempImage);
 399          return NULL;
 400       }
 401
 402       compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
 403
 404       n = srcWidth * srcHeight * srcDepth;
 405       for (i = 0; i < n; i++) {
 406          GLint k;
 407          for (k = 0; k < texComponents; k++) {
 408             GLint j = map[k];
 409             if (j == ZERO)
 410                newImage[i * texComponents + k] = 0.0F;
 411             else if (j == ONE)
 412                newImage[i * texComponents + k] = 1.0F;
 413             else
 414                newImage[i * texComponents + k] = tempImage[i * logComponents + j];
 415          }
 416       }
 417
 418       free(tempImage);
 419       tempImage = newImage;
 420    }
 421
 422    return tempImage;
 423 }
 424
 425
 426 /**
 427  * Make temporary image with uint pixel values.  Used for unsigned
 428  * integer-valued textures.
 429  */
 430 static GLuint *
 431 make_temp_uint_image(struct gl_context *ctx, GLuint dims,
 432                      GLenum logicalBaseFormat,
 433                      GLenum textureBaseFormat,
 434                      GLint srcWidth, GLint srcHeight, GLint srcDepth,
 435                      GLenum srcFormat, GLenum srcType,
 436                      const GLvoid *srcAddr,
 437                      const struct gl_pixelstore_attrib *srcPacking)
 438 {
 439    GLuint *tempImage;
 440    const GLint components = _mesa_components_in_format(logicalBaseFormat);
 441    const GLint srcStride =
 442       _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
 443    GLuint *dst;
 444    GLint img, row;
 445
 446    ASSERT(dims >= 1 && dims <= 3);
 447
 448    ASSERT(logicalBaseFormat == GL_RGBA ||
 449           logicalBaseFormat == GL_RGB ||
 450           logicalBaseFormat == GL_RG ||
 451           logicalBaseFormat == GL_RED ||
 452           logicalBaseFormat == GL_LUMINANCE_ALPHA ||
 453           logicalBaseFormat == GL_LUMINANCE ||
 454           logicalBaseFormat == GL_INTENSITY ||
 455           logicalBaseFormat == GL_ALPHA);
 456
 457    ASSERT(textureBaseFormat == GL_RGBA ||
 458           textureBaseFormat == GL_RGB ||
 459           textureBaseFormat == GL_RG ||
 460           textureBaseFormat == GL_RED ||
 461           textureBaseFormat == GL_LUMINANCE_ALPHA ||
 462           textureBaseFormat == GL_LUMINANCE ||
 463           textureBaseFormat == GL_INTENSITY ||
 464           textureBaseFormat == GL_ALPHA);
 465
 466    tempImage = malloc(srcWidth * srcHeight * srcDepth
 467                                  * components * sizeof(GLuint));
 468    if (!tempImage)
 469       return NULL;
 470
 471    dst = tempImage;
 472    for (img = 0; img < srcDepth; img++) {
 473       const GLubyte *src
 474          = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
 475                                                  srcWidth, srcHeight,
 476                                                  srcFormat, srcType,
 477                                                  img, 0, 0);
 478       for (row = 0; row < srcHeight; row++) {
 479          _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,
 480                                       dst, srcFormat, srcType, src,
 481                                       srcPacking);
 482          dst += srcWidth * components;
 483          src += srcStride;
 484       }
 485    }
 486
 487    if (logicalBaseFormat != textureBaseFormat) {
 488       /* more work */
 489       GLint texComponents = _mesa_components_in_format(textureBaseFormat);
 490       GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
 491       GLuint *newImage;
 492       GLint i, n;
 493       GLubyte map[6];
 494
 495       /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
 496       ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
 497              textureBaseFormat == GL_LUMINANCE_ALPHA);
 498
 499       /* The actual texture format should have at least as many components
 500        * as the logical texture format.
 501        */
 502       ASSERT(texComponents >= logComponents);
 503
 504       newImage = malloc(srcWidth * srcHeight * srcDepth
 505                                    * texComponents * sizeof(GLuint));
 506       if (!newImage) {
 507          free(tempImage);
 508          return NULL;
 509       }
 510
 511       compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
 512
 513       n = srcWidth * srcHeight * srcDepth;
 514       for (i = 0; i < n; i++) {
 515          GLint k;
 516          for (k = 0; k < texComponents; k++) {
 517             GLint j = map[k];
 518             if (j == ZERO)
 519                newImage[i * texComponents + k] = 0;
 520             else if (j == ONE)
 521                newImage[i * texComponents + k] = 1;
 522             else
 523                newImage[i * texComponents + k] = tempImage[i * logComponents + j];
 524          }
 525       }
 526
 527       free(tempImage);
 528       tempImage = newImage;
 529    }
 530
 531    return tempImage;
 532 }
 533
 534
 535
 536 /**
 537  * Make a temporary (color) texture image with GLubyte components.
 538  * Apply all needed pixel unpacking and pixel transfer operations.
 539  * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
 540  * Suppose the user specifies GL_LUMINANCE as the internal texture format
 541  * but the graphics hardware doesn't support luminance textures.  So, we might
 542  * use an RGB hardware format instead.
 543  * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
 544  *
 545  * \param ctx  the rendering context
 546  * \param dims  image dimensions: 1, 2 or 3
 547  * \param logicalBaseFormat  basic texture derived from the user's
 548  *    internal texture format value
 549  * \param textureBaseFormat  the actual basic format of the texture
 550  * \param srcWidth  source image width
 551  * \param srcHeight  source image height
 552  * \param srcDepth  source image depth
 553  * \param srcFormat  source image format
 554  * \param srcType  source image type
 555  * \param srcAddr  source image address
 556  * \param srcPacking  source image pixel packing
 557  * \return resulting image with format = textureBaseFormat and type = GLubyte.
 558  */
 559 GLubyte *
 560 _mesa_make_temp_ubyte_image(struct gl_context *ctx, GLuint dims,
 561                             GLenum logicalBaseFormat,
 562                             GLenum textureBaseFormat,
 563                             GLint srcWidth, GLint srcHeight, GLint srcDepth,
 564                             GLenum srcFormat, GLenum srcType,
 565                             const GLvoid *srcAddr,
 566                             const struct gl_pixelstore_attrib *srcPacking)
 567 {
 568    GLuint transferOps = ctx->_ImageTransferState;
 569    const GLint components = _mesa_components_in_format(logicalBaseFormat);
 570    GLint img, row;
 571    GLubyte *tempImage, *dst;
 572
 573    ASSERT(dims >= 1 && dims <= 3);
 574
 575    ASSERT(logicalBaseFormat == GL_RGBA ||
 576           logicalBaseFormat == GL_RGB ||
 577           logicalBaseFormat == GL_RG ||
 578           logicalBaseFormat == GL_RED ||
 579           logicalBaseFormat == GL_LUMINANCE_ALPHA ||
 580           logicalBaseFormat == GL_LUMINANCE ||
 581           logicalBaseFormat == GL_ALPHA ||
 582           logicalBaseFormat == GL_INTENSITY);
 583
 584    ASSERT(textureBaseFormat == GL_RGBA ||
 585           textureBaseFormat == GL_RGB ||
 586           textureBaseFormat == GL_RG ||
 587           textureBaseFormat == GL_RED ||
 588           textureBaseFormat == GL_LUMINANCE_ALPHA ||
 589           textureBaseFormat == GL_LUMINANCE ||
 590           textureBaseFormat == GL_ALPHA ||
 591           textureBaseFormat == GL_INTENSITY);
 592
 593    /* unpack and transfer the source image */
 594    tempImage = malloc(srcWidth * srcHeight * srcDepth
 595                                        * components * sizeof(GLubyte));
 596    if (!tempImage) {
 597       return NULL;
 598    }
 599
 600    dst = tempImage;
 601    for (img = 0; img < srcDepth; img++) {
 602       const GLint srcStride =
 603          _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
 604       const GLubyte *src =
 605          (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
 606                                                srcWidth, srcHeight,
 607                                                srcFormat, srcType,
 608                                                img, 0, 0);
 609       for (row = 0; row < srcHeight; row++) {
 610          _mesa_unpack_color_span_ubyte(ctx, srcWidth, logicalBaseFormat, dst,
 611                                        srcFormat, srcType, src, srcPacking,
 612                                        transferOps);
 613          dst += srcWidth * components;
 614          src += srcStride;
 615       }
 616    }
 617
 618    if (logicalBaseFormat != textureBaseFormat) {
 619       /* one more conversion step */
 620       GLint texComponents = _mesa_components_in_format(textureBaseFormat);
 621       GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
 622       GLubyte *newImage;
 623       GLint i, n;
 624       GLubyte map[6];
 625
 626       /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
 627       ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
 628              textureBaseFormat == GL_LUMINANCE_ALPHA);
 629
 630       /* The actual texture format should have at least as many components
 631        * as the logical texture format.
 632        */
 633       ASSERT(texComponents >= logComponents);
 634
 635       newImage = malloc(srcWidth * srcHeight * srcDepth
 636                                          * texComponents * sizeof(GLubyte));
 637       if (!newImage) {
 638          free(tempImage);
 639          return NULL;
 640       }
 641
 642       compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
 643
 644       n = srcWidth * srcHeight * srcDepth;
 645       for (i = 0; i < n; i++) {
 646          GLint k;
 647          for (k = 0; k < texComponents; k++) {
 648             GLint j = map[k];
 649             if (j == ZERO)
 650                newImage[i * texComponents + k] = 0;
 651             else if (j == ONE)
 652                newImage[i * texComponents + k] = 255;
 653             else
 654                newImage[i * texComponents + k] = tempImage[i * logComponents + j];
 655          }
 656       }
 657
 658       free(tempImage);
 659       tempImage = newImage;
 660    }
 661
 662    return tempImage;
 663 }
 664
 665
 666 /**
 667  * Copy GLubyte pixels from <src> to <dst> with swizzling.
 668  * \param dst  destination pixels
 669  * \param dstComponents  number of color components in destination pixels
 670  * \param src  source pixels
 671  * \param srcComponents  number of color components in source pixels
 672  * \param map  the swizzle mapping.  map[X] says where to find the X component
 673  *             in the source image's pixels.  For example, if the source image
 674  *             is GL_BGRA and X = red, map[0] yields 2.
 675  * \param count  number of pixels to copy/swizzle.
 676  */
 677 static void
 678 swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src,
 679              GLuint srcComponents, const GLubyte *map, GLuint count)
 680 {
 681 #define SWZ_CPY(dst, src, count, dstComps, srcComps) \
 682    do {                                              \
 683       GLuint i;                                      \
 684       for (i = 0; i < count; i++) {                  \
 685          GLuint j;                                   \
 686          if (srcComps == 4) {                        \
 687             COPY_4UBV(tmp, src);                     \
 688          }                                           \
 689          else {                                      \
 690             for (j = 0; j < srcComps; j++) {         \
 691                tmp[j] = src[j];                      \
 692             }                                        \
 693          }                                           \
 694          src += srcComps;                            \
 695          for (j = 0; j < dstComps; j++) {            \
 696             dst[j] = tmp[map[j]];                    \
 697          }                                           \
 698          dst += dstComps;                            \
 699       }                                              \
 700    } while (0)
 701
 702    GLubyte tmp[6];
 703
 704    tmp[ZERO] = 0x0;
 705    tmp[ONE] = 0xff;
 706
 707    ASSERT(srcComponents <= 4);
 708    ASSERT(dstComponents <= 4);
 709
 710    switch (dstComponents) {
 711    case 4:
 712       switch (srcComponents) {
 713       case 4:
 714          SWZ_CPY(dst, src, count, 4, 4);
 715          break;
 716       case 3:
 717          SWZ_CPY(dst, src, count, 4, 3);
 718          break;
 719       case 2:
 720          SWZ_CPY(dst, src, count, 4, 2);
 721          break;
 722       case 1:
 723          SWZ_CPY(dst, src, count, 4, 1);
 724          break;
 725       default:
 726          ;
 727       }
 728       break;
 729    case 3:
 730       switch (srcComponents) {
 731       case 4:
 732          SWZ_CPY(dst, src, count, 3, 4);
 733          break;
 734       case 3:
 735          SWZ_CPY(dst, src, count, 3, 3);
 736          break;
 737       case 2:
 738          SWZ_CPY(dst, src, count, 3, 2);
 739          break;
 740       case 1:
 741          SWZ_CPY(dst, src, count, 3, 1);
 742          break;
 743       default:
 744          ;
 745       }
 746       break;
 747    case 2:
 748       switch (srcComponents) {
 749       case 4:
 750          SWZ_CPY(dst, src, count, 2, 4);
 751          break;
 752       case 3:
 753          SWZ_CPY(dst, src, count, 2, 3);
 754          break;
 755       case 2:
 756          SWZ_CPY(dst, src, count, 2, 2);
 757          break;
 758       case 1:
 759          SWZ_CPY(dst, src, count, 2, 1);
 760          break;
 761       default:
 762          ;
 763       }
 764       break;
 765    case 1:
 766       switch (srcComponents) {
 767       case 4:
 768          SWZ_CPY(dst, src, count, 1, 4);
 769          break;
 770       case 3:
 771          SWZ_CPY(dst, src, count, 1, 3);
 772          break;
 773       case 2:
 774          SWZ_CPY(dst, src, count, 1, 2);
 775          break;
 776       case 1:
 777          SWZ_CPY(dst, src, count, 1, 1);
 778          break;
 779       default:
 780          ;
 781       }
 782       break;
 783    default:
 784       ;
 785    }
 786 #undef SWZ_CPY
 787 }
 788
 789
 790
 791 static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };
 792 static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };
 793
 794
 795 /**
 796  * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
 797  * mapping array depending on endianness.
 798  */
 799 static const GLubyte *
 800 type_mapping( GLenum srcType )
 801 {
 802    switch (srcType) {
 803    case GL_BYTE:
 804    case GL_UNSIGNED_BYTE:
 805       return map_identity;
 806    case GL_UNSIGNED_INT_8_8_8_8:
 807       return _mesa_little_endian() ? map_3210 : map_identity;
 808    case GL_UNSIGNED_INT_8_8_8_8_REV:
 809       return _mesa_little_endian() ? map_identity : map_3210;
 810    default:
 811       return NULL;
 812    }
 813 }
 814
 815
 816 /**
 817  * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
 818  * mapping array depending on pixelstore byte swapping state.
 819  */
 820 static const GLubyte *
 821 byteswap_mapping( GLboolean swapBytes,
 822                   GLenum srcType )
 823 {
 824    if (!swapBytes)
 825       return map_identity;
 826
 827    switch (srcType) {
 828    case GL_BYTE:
 829    case GL_UNSIGNED_BYTE:
 830       return map_identity;
 831    case GL_UNSIGNED_INT_8_8_8_8:
 832    case GL_UNSIGNED_INT_8_8_8_8_REV:
 833       return map_3210;
 834    default:
 835       return NULL;
 836    }
 837 }
 838
 839
 840
 841 /**
 842  * Transfer a GLubyte texture image with component swizzling.
 843  */
 844 static void
 845 _mesa_swizzle_ubyte_image(struct gl_context *ctx,
 846                           GLuint dimensions,
 847                           GLenum srcFormat,
 848                           GLenum srcType,
 849
 850                           GLenum baseInternalFormat,
 851
 852                           const GLubyte *rgba2dst,
 853                           GLuint dstComponents,
 854
 855                           GLint dstRowStride,
 856                           GLubyte **dstSlices,
 857
 858                           GLint srcWidth, GLint srcHeight, GLint srcDepth,
 859                           const GLvoid *srcAddr,
 860                           const struct gl_pixelstore_attrib *srcPacking )
 861 {
 862    GLint srcComponents = _mesa_components_in_format(srcFormat);
 863    const GLubyte *srctype2ubyte, *swap;
 864    GLubyte map[4], src2base[6], base2rgba[6];
 865    GLint i;
 866    const GLint srcRowStride =
 867       _mesa_image_row_stride(srcPacking, srcWidth,
 868                              srcFormat, GL_UNSIGNED_BYTE);
 869    const GLint srcImageStride
 870       = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,
 871                                  GL_UNSIGNED_BYTE);
 872    const GLubyte *srcImage
 873       = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,
 874                                               srcWidth, srcHeight, srcFormat,
 875                                               GL_UNSIGNED_BYTE, 0, 0, 0);
 876
 877    (void) ctx;
 878
 879    /* Translate from src->baseInternal->GL_RGBA->dst.  This will
 880     * correctly deal with RGBA->RGB->RGBA conversions where the final
 881     * A value must be 0xff regardless of the incoming alpha values.
 882     */
 883    compute_component_mapping(srcFormat, baseInternalFormat, src2base);
 884    compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);
 885    swap = byteswap_mapping(srcPacking->SwapBytes, srcType);
 886    srctype2ubyte = type_mapping(srcType);
 887
 888
 889    for (i = 0; i < 4; i++)
 890       map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];
 891
 892 /*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */
 893
 894    if (srcComponents == dstComponents &&
 895        srcRowStride == dstRowStride &&
 896        srcRowStride == srcWidth * srcComponents &&
 897        dimensions < 3) {
 898       /* 1 and 2D images only */
 899       GLubyte *dstImage = dstSlices[0];
 900       swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map,
 901                    srcWidth * srcHeight);
 902    }
 903    else {
 904       GLint img, row;
 905       for (img = 0; img < srcDepth; img++) {
 906          const GLubyte *srcRow = srcImage;
 907          GLubyte *dstRow = dstSlices[img];
 908          for (row = 0; row < srcHeight; row++) {
 909             swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);
 910             dstRow += dstRowStride;
 911             srcRow += srcRowStride;
 912          }
 913          srcImage += srcImageStride;
 914       }
 915    }
 916 }
 917
 918
 919 /**
 920  * Teximage storage routine for when a simple memcpy will do.
 921  * No pixel transfer operations or special texel encodings allowed.
 922  * 1D, 2D and 3D images supported.
 923  */
 924 static void
 925 memcpy_texture(struct gl_context *ctx,
 926                GLuint dimensions,
 927                gl_format dstFormat,
 928                GLint dstRowStride,
 929                GLubyte **dstSlices,
 930                GLint srcWidth, GLint srcHeight, GLint srcDepth,
 931                GLenum srcFormat, GLenum srcType,
 932                const GLvoid *srcAddr,
 933                const struct gl_pixelstore_attrib *srcPacking)
 934 {
 935    const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
 936                                                      srcFormat, srcType);
 937    const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
 938                                       srcWidth, srcHeight, srcFormat, srcType);
 939    const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,
 940         srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
 941    const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
 942    const GLint bytesPerRow = srcWidth * texelBytes;
 943
 944    if (dstRowStride == srcRowStride &&
 945        dstRowStride == bytesPerRow) {
 946       /* memcpy image by image */
 947       GLint img;
 948       for (img = 0; img < srcDepth; img++) {
 949          GLubyte *dstImage = dstSlices[img];
 950          memcpy(dstImage, srcImage, bytesPerRow * srcHeight);
 951          srcImage += srcImageStride;
 952       }
 953    }
 954    else {
 955       /* memcpy row by row */
 956       GLint img, row;
 957       for (img = 0; img < srcDepth; img++) {
 958          const GLubyte *srcRow = srcImage;
 959          GLubyte *dstRow = dstSlices[img];
 960          for (row = 0; row < srcHeight; row++) {
 961             memcpy(dstRow, srcRow, bytesPerRow);
 962             dstRow += dstRowStride;
 963             srcRow += srcRowStride;
 964          }
 965          srcImage += srcImageStride;
 966       }
 967    }
 968 }
 969
 970
 971 /**
 972  * General-case function for storing a color texture images with
 973  * components that can be represented with ubytes.  Example destination
 974  * texture formats are MESA_FORMAT_ARGB888, ARGB4444, RGB565.
 975  */
 976 static GLboolean
 977 store_ubyte_texture(TEXSTORE_PARAMS)
 978 {
 979    const GLint srcRowStride = srcWidth * 4 * sizeof(GLubyte);
 980    GLubyte *tempImage, *src;
 981    GLint img;
 982
 983    tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
 984                                            baseInternalFormat,
 985                                            GL_RGBA,
 986                                            srcWidth, srcHeight, srcDepth,
 987                                            srcFormat, srcType, srcAddr,
 988                                            srcPacking);
 989    if (!tempImage)
 990       return GL_FALSE;
 991
 992    src = tempImage;
 993    for (img = 0; img < srcDepth; img++) {
 994       _mesa_pack_ubyte_rgba_rect(dstFormat, srcWidth, srcHeight,
 995                                  src, srcRowStride,
 996                                  dstSlices[img], dstRowStride);
 997       src += srcHeight * srcRowStride;
 998    }
 999    free(tempImage);
1000
1001    return GL_TRUE;
1002 }
1003
1004
1005
1006
1007 /**
1008  * Store a 32-bit integer or float depth component texture image.
1009  */
1010 static GLboolean
1011 _mesa_texstore_z32(TEXSTORE_PARAMS)
1012 {
1013    const GLuint depthScale = 0xffffffff;
1014    GLenum dstType;
1015    (void) dims;
1016    ASSERT(dstFormat == MESA_FORMAT_Z32 ||
1017           dstFormat == MESA_FORMAT_Z32_FLOAT);
1018    ASSERT(_mesa_get_format_bytes(dstFormat) == sizeof(GLuint));
1019
1020    if (dstFormat == MESA_FORMAT_Z32)
1021       dstType = GL_UNSIGNED_INT;
1022    else
1023       dstType = GL_FLOAT;
1024
1025    if (ctx->Pixel.DepthScale == 1.0f &&
1026        ctx->Pixel.DepthBias == 0.0f &&
1027        !srcPacking->SwapBytes &&
1028        baseInternalFormat == GL_DEPTH_COMPONENT &&
1029        srcFormat == GL_DEPTH_COMPONENT &&
1030        srcType == dstType) {
1031       /* simple memcpy path */
1032       memcpy_texture(ctx, dims,
1033                      dstFormat,
1034                      dstRowStride, dstSlices,
1035                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1036                      srcAddr, srcPacking);
1037    }
1038    else {
1039       /* general path */
1040       GLint img, row;
1041       for (img = 0; img < srcDepth; img++) {
1042          GLubyte *dstRow = dstSlices[img];
1043          for (row = 0; row < srcHeight; row++) {
1044             const GLvoid *src = _mesa_image_address(dims, srcPacking,
1045                 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
1046             _mesa_unpack_depth_span(ctx, srcWidth,
1047                                     dstType, dstRow,
1048                                     depthScale, srcType, src, srcPacking);
1049             dstRow += dstRowStride;
1050          }
1051       }
1052    }
1053    return GL_TRUE;
1054 }
1055
1056
1057 /**
1058  * Store a 24-bit integer depth component texture image.
1059  */
1060 static GLboolean
1061 _mesa_texstore_x8_z24(TEXSTORE_PARAMS)
1062 {
1063    const GLuint depthScale = 0xffffff;
1064
1065    (void) dims;
1066    ASSERT(dstFormat == MESA_FORMAT_X8_Z24);
1067
1068    {
1069       /* general path */
1070       GLint img, row;
1071       for (img = 0; img < srcDepth; img++) {
1072          GLubyte *dstRow = dstSlices[img];
1073          for (row = 0; row < srcHeight; row++) {
1074             const GLvoid *src = _mesa_image_address(dims, srcPacking,
1075                 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
1076             _mesa_unpack_depth_span(ctx, srcWidth,
1077                                     GL_UNSIGNED_INT, (GLuint *) dstRow,
1078                                     depthScale, srcType, src, srcPacking);
1079             dstRow += dstRowStride;
1080          }
1081       }
1082    }
1083    return GL_TRUE;
1084 }
1085
1086
1087 /**
1088  * Store a 24-bit integer depth component texture image.
1089  */
1090 static GLboolean
1091 _mesa_texstore_z24_x8(TEXSTORE_PARAMS)
1092 {
1093    const GLuint depthScale = 0xffffff;
1094
1095    (void) dims;
1096    ASSERT(dstFormat == MESA_FORMAT_Z24_X8);
1097
1098    {
1099       /* general path */
1100       GLint img, row;
1101       for (img = 0; img < srcDepth; img++) {
1102          GLubyte *dstRow = dstSlices[img];
1103          for (row = 0; row < srcHeight; row++) {
1104             const GLvoid *src = _mesa_image_address(dims, srcPacking,
1105                 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
1106             GLuint *dst = (GLuint *) dstRow;
1107             GLint i;
1108             _mesa_unpack_depth_span(ctx, srcWidth,
1109                                     GL_UNSIGNED_INT, dst,
1110                                     depthScale, srcType, src, srcPacking);
1111             for (i = 0; i < srcWidth; i++)
1112                dst[i] <<= 8;
1113             dstRow += dstRowStride;
1114          }
1115       }
1116    }
1117    return GL_TRUE;
1118 }
1119
1120
1121 /**
1122  * Store a 16-bit integer depth component texture image.
1123  */
1124 static GLboolean
1125 _mesa_texstore_z16(TEXSTORE_PARAMS)
1126 {
1127    const GLuint depthScale = 0xffff;
1128    (void) dims;
1129    ASSERT(dstFormat == MESA_FORMAT_Z16);
1130    ASSERT(_mesa_get_format_bytes(dstFormat) == sizeof(GLushort));
1131
1132    if (ctx->Pixel.DepthScale == 1.0f &&
1133        ctx->Pixel.DepthBias == 0.0f &&
1134        !srcPacking->SwapBytes &&
1135        baseInternalFormat == GL_DEPTH_COMPONENT &&
1136        srcFormat == GL_DEPTH_COMPONENT &&
1137        srcType == GL_UNSIGNED_SHORT) {
1138       /* simple memcpy path */
1139       memcpy_texture(ctx, dims,
1140                      dstFormat,
1141                      dstRowStride, dstSlices,
1142                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1143                      srcAddr, srcPacking);
1144    }
1145    else {
1146       /* general path */
1147       GLint img, row;
1148       for (img = 0; img < srcDepth; img++) {
1149          GLubyte *dstRow = dstSlices[img];
1150          for (row = 0; row < srcHeight; row++) {
1151             const GLvoid *src = _mesa_image_address(dims, srcPacking,
1152                 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
1153             GLushort *dst16 = (GLushort *) dstRow;
1154             _mesa_unpack_depth_span(ctx, srcWidth,
1155                                     GL_UNSIGNED_SHORT, dst16, depthScale,
1156                                     srcType, src, srcPacking);
1157             dstRow += dstRowStride;
1158          }
1159       }
1160    }
1161    return GL_TRUE;
1162 }
1163
1164
1165 /**
1166  * Store an rgb565 or rgb565_rev texture image.
1167  */
1168 static GLboolean
1169 _mesa_texstore_rgb565(TEXSTORE_PARAMS)
1170 {
1171    ASSERT(dstFormat == MESA_FORMAT_RGB565 ||
1172           dstFormat == MESA_FORMAT_RGB565_REV);
1173    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
1174
1175    if (!ctx->_ImageTransferState &&
1176        baseInternalFormat == GL_RGB &&
1177        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1178                                             srcPacking->SwapBytes)) {
1179       /* simple memcpy path */
1180       memcpy_texture(ctx, dims,
1181                      dstFormat,
1182                      dstRowStride, dstSlices,
1183                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1184                      srcAddr, srcPacking);
1185    }
1186    else if (!ctx->_ImageTransferState &&
1187             !srcPacking->SwapBytes &&
1188             baseInternalFormat == GL_RGB &&
1189             srcFormat == GL_RGB &&
1190             srcType == GL_UNSIGNED_BYTE &&
1191             dims == 2) {
1192       /* do optimized tex store */
1193       const GLint srcRowStride =
1194          _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
1195       const GLubyte *src = (const GLubyte *)
1196          _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
1197                              srcFormat, srcType, 0, 0, 0);
1198       GLubyte *dst = dstSlices[0];
1199       GLint row, col;
1200       for (row = 0; row < srcHeight; row++) {
1201          const GLubyte *srcUB = (const GLubyte *) src;
1202          GLushort *dstUS = (GLushort *) dst;
1203          /* check for byteswapped format */
1204          if (dstFormat == MESA_FORMAT_RGB565) {
1205             for (col = 0; col < srcWidth; col++) {
1206                dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );
1207                srcUB += 3;
1208             }
1209          }
1210          else {
1211             for (col = 0; col < srcWidth; col++) {
1212                dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );
1213                srcUB += 3;
1214             }
1215          }
1216          dst += dstRowStride;
1217          src += srcRowStride;
1218       }
1219    }
1220    else {
1221       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1222                                  dstFormat, dstRowStride, dstSlices,
1223                                  srcWidth, srcHeight, srcDepth,
1224                                  srcFormat, srcType, srcAddr, srcPacking);
1225    }
1226    return GL_TRUE;
1227 }
1228
1229
1230 /**
1231  * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.
1232  */
1233 static GLboolean
1234 _mesa_texstore_rgba8888(TEXSTORE_PARAMS)
1235 {
1236    const GLboolean littleEndian = _mesa_little_endian();
1237
1238    ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||
1239           dstFormat == MESA_FORMAT_RGBA8888_REV ||
1240           dstFormat == MESA_FORMAT_RGBX8888 ||
1241           dstFormat == MESA_FORMAT_RGBX8888_REV);
1242    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
1243
1244    if (!ctx->_ImageTransferState &&
1245        baseInternalFormat == GL_RGBA &&
1246        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1247                                             srcPacking->SwapBytes)) {
1248       /* simple memcpy path */
1249       memcpy_texture(ctx, dims,
1250                      dstFormat,
1251                      dstRowStride, dstSlices,
1252                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1253                      srcAddr, srcPacking);
1254    }
1255    else if (!ctx->_ImageTransferState &&
1256             (srcType == GL_UNSIGNED_BYTE ||
1257              srcType == GL_UNSIGNED_INT_8_8_8_8 ||
1258              srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
1259             can_swizzle(baseInternalFormat) &&
1260             can_swizzle(srcFormat)) {
1261
1262       GLubyte dstmap[4];
1263
1264       /* dstmap - how to swizzle from RGBA to dst format:
1265        */
1266       if ((littleEndian && (dstFormat == MESA_FORMAT_RGBA8888 ||
1267                             dstFormat == MESA_FORMAT_RGBX8888)) ||
1268           (!littleEndian && (dstFormat == MESA_FORMAT_RGBA8888_REV ||
1269                              dstFormat == MESA_FORMAT_RGBX8888_REV))) {
1270          dstmap[3] = 0;
1271          dstmap[2] = 1;
1272          dstmap[1] = 2;
1273          dstmap[0] = 3;
1274       }
1275       else {
1276          dstmap[3] = 3;
1277          dstmap[2] = 2;
1278          dstmap[1] = 1;
1279          dstmap[0] = 0;
1280       }
1281
1282       _mesa_swizzle_ubyte_image(ctx, dims,
1283                                 srcFormat,
1284                                 srcType,
1285                                 baseInternalFormat,
1286                                 dstmap, 4,
1287                                 dstRowStride, dstSlices,
1288                                 srcWidth, srcHeight, srcDepth, srcAddr,
1289                                 srcPacking);
1290    }
1291    else {
1292       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1293                                  dstFormat, dstRowStride, dstSlices,
1294                                  srcWidth, srcHeight, srcDepth,
1295                                  srcFormat, srcType, srcAddr, srcPacking);
1296    }
1297    return GL_TRUE;
1298 }
1299
1300
1301 static GLboolean
1302 _mesa_texstore_argb8888(TEXSTORE_PARAMS)
1303 {
1304    const GLboolean littleEndian = _mesa_little_endian();
1305
1306    ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||
1307           dstFormat == MESA_FORMAT_ARGB8888_REV ||
1308           dstFormat == MESA_FORMAT_XRGB8888 ||
1309           dstFormat == MESA_FORMAT_XRGB8888_REV );
1310    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
1311
1312    if (!ctx->_ImageTransferState &&
1313        baseInternalFormat == GL_RGBA &&
1314        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1315                                             srcPacking->SwapBytes)) {
1316       /* simple memcpy path (big endian) */
1317       memcpy_texture(ctx, dims,
1318                      dstFormat,
1319                      dstRowStride, dstSlices,
1320                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1321                      srcAddr, srcPacking);
1322    }
1323    else if (!ctx->_ImageTransferState &&
1324             !srcPacking->SwapBytes &&
1325             (dstFormat == MESA_FORMAT_ARGB8888 ||
1326              dstFormat == MESA_FORMAT_XRGB8888) &&
1327             srcFormat == GL_RGB &&
1328             (baseInternalFormat == GL_RGBA ||
1329              baseInternalFormat == GL_RGB) &&
1330             srcType == GL_UNSIGNED_BYTE) {
1331       int img, row, col;
1332       for (img = 0; img < srcDepth; img++) {
1333          const GLint srcRowStride =
1334             _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
1335          GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
1336                   srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
1337          GLubyte *dstRow = dstSlices[img];
1338          for (row = 0; row < srcHeight; row++) {
1339             GLuint *d4 = (GLuint *) dstRow;
1340             for (col = 0; col < srcWidth; col++) {
1341                d4[col] = PACK_COLOR_8888(0xff,
1342                                          srcRow[col * 3 + RCOMP],
1343                                          srcRow[col * 3 + GCOMP],
1344                                          srcRow[col * 3 + BCOMP]);
1345             }
1346             dstRow += dstRowStride;
1347             srcRow += srcRowStride;
1348          }
1349       }
1350    }
1351    else if (!ctx->_ImageTransferState &&
1352             !srcPacking->SwapBytes &&
1353             dstFormat == MESA_FORMAT_ARGB8888 &&
1354             srcFormat == GL_LUMINANCE_ALPHA &&
1355             baseInternalFormat == GL_RGBA &&
1356             srcType == GL_UNSIGNED_BYTE) {
1357       /* special case of storing LA -> ARGB8888 */
1358       int img, row, col;
1359       const GLint srcRowStride =
1360          _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
1361       for (img = 0; img < srcDepth; img++) {
1362          const GLubyte *srcRow = (const GLubyte *)
1363             _mesa_image_address(dims, srcPacking, srcAddr, srcWidth,
1364                                 srcHeight, srcFormat, srcType, img, 0, 0);
1365          GLubyte *dstRow = dstSlices[img];
1366          for (row = 0; row < srcHeight; row++) {
1367             GLuint *d4 = (GLuint *) dstRow;
1368             for (col = 0; col < srcWidth; col++) {
1369                GLubyte l = srcRow[col * 2 + 0], a = srcRow[col * 2 + 1];
1370                d4[col] = PACK_COLOR_8888(a, l, l, l);
1371             }
1372             dstRow += dstRowStride;
1373             srcRow += srcRowStride;
1374          }
1375       }
1376    }
1377    else if (!ctx->_ImageTransferState &&
1378             !srcPacking->SwapBytes &&
1379             dstFormat == MESA_FORMAT_ARGB8888 &&
1380             srcFormat == GL_RGBA &&
1381             baseInternalFormat == GL_RGBA &&
1382             srcType == GL_UNSIGNED_BYTE) {
1383       /* same as above case, but src data has alpha too */
1384       GLint img, row, col;
1385       /* For some reason, streaming copies to write-combined regions
1386        * are extremely sensitive to the characteristics of how the
1387        * source data is retrieved.  By reordering the source reads to
1388        * be in-order, the speed of this operation increases by half.
1389        * Strangely the same isn't required for the RGB path, above.
1390        */
1391       for (img = 0; img < srcDepth; img++) {
1392          const GLint srcRowStride =
1393             _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
1394          GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
1395                   srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
1396          GLubyte *dstRow = dstSlices[img];
1397          for (row = 0; row < srcHeight; row++) {
1398             GLuint *d4 = (GLuint *) dstRow;
1399             for (col = 0; col < srcWidth; col++) {
1400                d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],
1401                                          srcRow[col * 4 + RCOMP],
1402                                          srcRow[col * 4 + GCOMP],
1403                                          srcRow[col * 4 + BCOMP]);
1404             }
1405             dstRow += dstRowStride;
1406             srcRow += srcRowStride;
1407          }
1408       }
1409    }
1410    else if (!ctx->_ImageTransferState &&
1411             (srcType == GL_UNSIGNED_BYTE ||
1412              srcType == GL_UNSIGNED_INT_8_8_8_8 ||
1413              srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
1414             can_swizzle(baseInternalFormat) &&
1415             can_swizzle(srcFormat)) {
1416
1417       GLubyte dstmap[4];
1418
1419       /* dstmap - how to swizzle from RGBA to dst format:
1420        */
1421       if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
1422           (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||
1423           (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
1424           (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {
1425          dstmap[3] = 3;         /* alpha */
1426          dstmap[2] = 0;         /* red */
1427          dstmap[1] = 1;         /* green */
1428          dstmap[0] = 2;         /* blue */
1429       }
1430       else {
1431          assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
1432                 (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
1433                 (littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||
1434                 (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));
1435          dstmap[3] = 2;
1436          dstmap[2] = 1;
1437          dstmap[1] = 0;
1438          dstmap[0] = 3;
1439       }
1440
1441       _mesa_swizzle_ubyte_image(ctx, dims,
1442                                 srcFormat,
1443                                 srcType,
1444                                 baseInternalFormat,
1445                                 dstmap, 4,
1446                                 dstRowStride,
1447                                 dstSlices,
1448                                 srcWidth, srcHeight, srcDepth, srcAddr,
1449                                 srcPacking);
1450    }
1451    else {
1452       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1453                                  dstFormat, dstRowStride, dstSlices,
1454                                  srcWidth, srcHeight, srcDepth,
1455                                  srcFormat, srcType, srcAddr, srcPacking);
1456    }
1457    return GL_TRUE;
1458 }
1459
1460
1461 static GLboolean
1462 _mesa_texstore_rgb888(TEXSTORE_PARAMS)
1463 {
1464    ASSERT(dstFormat == MESA_FORMAT_RGB888);
1465    ASSERT(_mesa_get_format_bytes(dstFormat) == 3);
1466
1467    if (!ctx->_ImageTransferState &&
1468        baseInternalFormat == GL_RGB &&
1469        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1470                                             srcPacking->SwapBytes)) {
1471       /* simple memcpy path */
1472       memcpy_texture(ctx, dims,
1473                      dstFormat,
1474                      dstRowStride, dstSlices,
1475                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1476                      srcAddr, srcPacking);
1477    }
1478    else if (!ctx->_ImageTransferState &&
1479             !srcPacking->SwapBytes &&
1480             srcFormat == GL_RGBA &&
1481             srcType == GL_UNSIGNED_BYTE) {
1482       /* extract RGB from RGBA */
1483       GLint img, row, col;
1484       for (img = 0; img < srcDepth; img++) {
1485          const GLint srcRowStride =
1486             _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
1487          GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
1488                   srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
1489          GLubyte *dstRow = dstSlices[img];
1490          for (row = 0; row < srcHeight; row++) {
1491             for (col = 0; col < srcWidth; col++) {
1492                dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];
1493                dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
1494                dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];
1495             }
1496             dstRow += dstRowStride;
1497             srcRow += srcRowStride;
1498          }
1499       }
1500    }
1501    else if (!ctx->_ImageTransferState &&
1502             srcType == GL_UNSIGNED_BYTE &&
1503             can_swizzle(baseInternalFormat) &&
1504             can_swizzle(srcFormat)) {
1505
1506       GLubyte dstmap[4];
1507
1508       /* dstmap - how to swizzle from RGBA to dst format:
1509        */
1510       dstmap[0] = 2;
1511       dstmap[1] = 1;
1512       dstmap[2] = 0;
1513       dstmap[3] = ONE;          /* ? */
1514
1515       _mesa_swizzle_ubyte_image(ctx, dims,
1516                                 srcFormat,
1517                                 srcType,
1518                                 baseInternalFormat,
1519                                 dstmap, 3,
1520                                 dstRowStride, dstSlices,
1521                                 srcWidth, srcHeight, srcDepth, srcAddr,
1522                                 srcPacking);
1523    }
1524    else {
1525       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1526                                  dstFormat, dstRowStride, dstSlices,
1527                                  srcWidth, srcHeight, srcDepth,
1528                                  srcFormat, srcType, srcAddr, srcPacking);
1529    }
1530    return GL_TRUE;
1531 }
1532
1533
1534 static GLboolean
1535 _mesa_texstore_bgr888(TEXSTORE_PARAMS)
1536 {
1537    ASSERT(dstFormat == MESA_FORMAT_BGR888);
1538    ASSERT(_mesa_get_format_bytes(dstFormat) == 3);
1539
1540    if (!ctx->_ImageTransferState &&
1541        baseInternalFormat == GL_RGB &&
1542        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1543                                             srcPacking->SwapBytes)) {
1544       /* simple memcpy path */
1545       memcpy_texture(ctx, dims,
1546                      dstFormat,
1547                      dstRowStride, dstSlices,
1548                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1549                      srcAddr, srcPacking);
1550    }
1551    else if (!ctx->_ImageTransferState &&
1552             !srcPacking->SwapBytes &&
1553             srcFormat == GL_RGBA &&
1554             srcType == GL_UNSIGNED_BYTE) {
1555       /* extract BGR from RGBA */
1556       int img, row, col;
1557       for (img = 0; img < srcDepth; img++) {
1558          const GLint srcRowStride =
1559             _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
1560          GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
1561                   srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
1562          GLubyte *dstRow = dstSlices[img];
1563          for (row = 0; row < srcHeight; row++) {
1564             for (col = 0; col < srcWidth; col++) {
1565                dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];
1566                dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
1567                dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];
1568             }
1569             dstRow += dstRowStride;
1570             srcRow += srcRowStride;
1571          }
1572       }
1573    }
1574    else if (!ctx->_ImageTransferState &&
1575             srcType == GL_UNSIGNED_BYTE &&
1576             can_swizzle(baseInternalFormat) &&
1577             can_swizzle(srcFormat)) {
1578
1579       GLubyte dstmap[4];
1580
1581       /* dstmap - how to swizzle from RGBA to dst format:
1582        */
1583       dstmap[0] = 0;
1584       dstmap[1] = 1;
1585       dstmap[2] = 2;
1586       dstmap[3] = ONE;          /* ? */
1587
1588       _mesa_swizzle_ubyte_image(ctx, dims,
1589                                 srcFormat,
1590                                 srcType,
1591                                 baseInternalFormat,
1592                                 dstmap, 3,
1593                                 dstRowStride, dstSlices,
1594                                 srcWidth, srcHeight, srcDepth, srcAddr,
1595                                 srcPacking);
1596    }
1597    else {
1598       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1599                                  dstFormat, dstRowStride, dstSlices,
1600                                  srcWidth, srcHeight, srcDepth,
1601                                  srcFormat, srcType, srcAddr, srcPacking);
1602    }
1603    return GL_TRUE;
1604 }
1605
1606
1607 static GLboolean
1608 _mesa_texstore_argb4444(TEXSTORE_PARAMS)
1609 {
1610    ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||
1611           dstFormat == MESA_FORMAT_ARGB4444_REV);
1612    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
1613
1614    if (!ctx->_ImageTransferState &&
1615        baseInternalFormat == GL_RGBA &&
1616        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1617                                             srcPacking->SwapBytes)) {
1618       /* simple memcpy path */
1619       memcpy_texture(ctx, dims,
1620                      dstFormat,
1621                      dstRowStride, dstSlices,
1622                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1623                      srcAddr, srcPacking);
1624    }
1625    else {
1626       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1627                                  dstFormat, dstRowStride, dstSlices,
1628                                  srcWidth, srcHeight, srcDepth,
1629                                  srcFormat, srcType, srcAddr, srcPacking);
1630    }
1631    return GL_TRUE;
1632 }
1633
1634 static GLboolean
1635 _mesa_texstore_rgba5551(TEXSTORE_PARAMS)
1636 {
1637    ASSERT(dstFormat == MESA_FORMAT_RGBA5551);
1638    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
1639
1640    if (!ctx->_ImageTransferState &&
1641        baseInternalFormat == GL_RGBA &&
1642        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1643                                             srcPacking->SwapBytes)) {
1644       /* simple memcpy path */
1645       memcpy_texture(ctx, dims,
1646                      dstFormat,
1647                      dstRowStride, dstSlices,
1648                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1649                      srcAddr, srcPacking);
1650    }
1651    else {
1652       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1653                                  dstFormat, dstRowStride, dstSlices,
1654                                  srcWidth, srcHeight, srcDepth,
1655                                  srcFormat, srcType, srcAddr, srcPacking);
1656    }
1657    return GL_TRUE;
1658 }
1659
1660 static GLboolean
1661 _mesa_texstore_argb1555(TEXSTORE_PARAMS)
1662 {
1663    ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||
1664           dstFormat == MESA_FORMAT_ARGB1555_REV);
1665    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
1666
1667    if (!ctx->_ImageTransferState &&
1668        baseInternalFormat == GL_RGBA &&
1669        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1670                                             srcPacking->SwapBytes)) {
1671       /* simple memcpy path */
1672       memcpy_texture(ctx, dims,
1673                      dstFormat,
1674                      dstRowStride, dstSlices,
1675                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1676                      srcAddr, srcPacking);
1677    }
1678    else {
1679       return store_ubyte_texture(ctx, dims, baseInternalFormat,
1680                                  dstFormat, dstRowStride, dstSlices,
1681                                  srcWidth, srcHeight, srcDepth,
1682                                  srcFormat, srcType, srcAddr, srcPacking);
1683    }
1684    return GL_TRUE;
1685 }
1686
1687
1688 static GLboolean
1689 _mesa_texstore_argb2101010(TEXSTORE_PARAMS)
1690 {
1691    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
1692
1693    ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);
1694    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
1695
1696    if (!ctx->_ImageTransferState &&
1697        baseInternalFormat == GL_RGBA &&
1698        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
1699                                             srcPacking->SwapBytes)) {
1700       /* simple memcpy path */
1701       memcpy_texture(ctx, dims,
1702                      dstFormat,
1703                      dstRowStride, dstSlices,
1704                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1705                      srcAddr, srcPacking);
1706    }
1707    else {
1708       /* general path */
1709       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
1710                                                  baseInternalFormat,
1711                                                  baseFormat,
1712                                                  srcWidth, srcHeight, srcDepth,
1713                                                  srcFormat, srcType, srcAddr,
1714                                                  srcPacking,
1715                                                  ctx->_ImageTransferState);
1716       const GLfloat *src = tempImage;
1717       GLint img, row, col;
1718       if (!tempImage)
1719          return GL_FALSE;
1720       for (img = 0; img < srcDepth; img++) {
1721          GLubyte *dstRow = dstSlices[img];
1722          if (baseInternalFormat == GL_RGBA) {
1723             for (row = 0; row < srcHeight; row++) {
1724                GLuint *dstUI = (GLuint *) dstRow;
1725                for (col = 0; col < srcWidth; col++) {
1726                   GLushort a,r,g,b;
1727
1728                   UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1729                   UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1730                   UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1731                   UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1732                   dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);
1733                   src += 4;
1734                }
1735                dstRow += dstRowStride;
1736             }
1737          } else if (baseInternalFormat == GL_RGB) {
1738             for (row = 0; row < srcHeight; row++) {
1739                GLuint *dstUI = (GLuint *) dstRow;
1740                for (col = 0; col < srcWidth; col++) {
1741                   GLushort r,g,b;
1742
1743                   UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1744                   UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1745                   UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1746                   dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);
1747                   src += 4;
1748                }
1749                dstRow += dstRowStride;
1750             }
1751          } else {
1752             ASSERT(0);
1753          }
1754       }
1755       free((void *) tempImage);
1756    }
1757    return GL_TRUE;
1758 }
1759
1760
1761 /**
1762  * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.
1763  */
1764 static GLboolean
1765 _mesa_texstore_unorm44(TEXSTORE_PARAMS)
1766 {
1767    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
1768
1769    ASSERT(dstFormat == MESA_FORMAT_AL44);
1770    ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
1771
1772    {
1773       /* general path */
1774       const GLubyte *tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
1775                                                  baseInternalFormat,
1776                                                  baseFormat,
1777                                                  srcWidth, srcHeight, srcDepth,
1778                                                  srcFormat, srcType, srcAddr,
1779                                                  srcPacking);
1780       const GLubyte *src = tempImage;
1781       GLint img, row, col;
1782       if (!tempImage)
1783          return GL_FALSE;
1784       for (img = 0; img < srcDepth; img++) {
1785          GLubyte *dstRow = dstSlices[img];
1786          for (row = 0; row < srcHeight; row++) {
1787             GLubyte *dstUS = (GLubyte *) dstRow;
1788             for (col = 0; col < srcWidth; col++) {
1789                /* src[0] is luminance, src[1] is alpha */
1790                dstUS[col] = PACK_COLOR_44( src[1],
1791                                            src[0] );
1792                src += 2;
1793             }
1794             dstRow += dstRowStride;
1795          }
1796       }
1797       free((void *) tempImage);
1798    }
1799    return GL_TRUE;
1800 }
1801
1802
1803 /**
1804  * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.
1805  */
1806 static GLboolean
1807 _mesa_texstore_unorm88(TEXSTORE_PARAMS)
1808 {
1809    const GLboolean littleEndian = _mesa_little_endian();
1810    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
1811
1812    ASSERT(dstFormat == MESA_FORMAT_AL88 ||
1813           dstFormat == MESA_FORMAT_AL88_REV ||
1814           dstFormat == MESA_FORMAT_GR88 ||
1815           dstFormat == MESA_FORMAT_RG88);
1816    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
1817
1818    if (!ctx->_ImageTransferState &&
1819        !srcPacking->SwapBytes &&
1820        ((dstFormat == MESA_FORMAT_AL88 &&
1821          baseInternalFormat == GL_LUMINANCE_ALPHA &&
1822          srcFormat == GL_LUMINANCE_ALPHA) ||
1823         (dstFormat == MESA_FORMAT_GR88 &&
1824          baseInternalFormat == srcFormat)) &&
1825        srcType == GL_UNSIGNED_BYTE &&
1826        littleEndian) {
1827       /* simple memcpy path */
1828       memcpy_texture(ctx, dims,
1829                      dstFormat,
1830                      dstRowStride, dstSlices,
1831                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1832                      srcAddr, srcPacking);
1833    }
1834    else if (!ctx->_ImageTransferState &&
1835             littleEndian &&
1836             srcType == GL_UNSIGNED_BYTE &&
1837             can_swizzle(baseInternalFormat) &&
1838             can_swizzle(srcFormat)) {
1839       GLubyte dstmap[4];
1840
1841       /* dstmap - how to swizzle from RGBA to dst format:
1842        */
1843       if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {
1844          if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||
1845              (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {
1846             dstmap[0] = 0;
1847             dstmap[1] = 3;
1848          }
1849          else {
1850             dstmap[0] = 3;
1851             dstmap[1] = 0;
1852          }
1853       }
1854       else {
1855          if ((littleEndian && dstFormat == MESA_FORMAT_GR88) ||
1856              (!littleEndian && dstFormat == MESA_FORMAT_RG88)) {
1857             dstmap[0] = 0;
1858             dstmap[1] = 1;
1859          }
1860          else {
1861             dstmap[0] = 1;
1862             dstmap[1] = 0;
1863          }
1864       }
1865       dstmap[2] = ZERO;         /* ? */
1866       dstmap[3] = ONE;          /* ? */
1867
1868       _mesa_swizzle_ubyte_image(ctx, dims,
1869                                 srcFormat,
1870                                 srcType,
1871                                 baseInternalFormat,
1872                                 dstmap, 2,
1873                                 dstRowStride, dstSlices,
1874                                 srcWidth, srcHeight, srcDepth, srcAddr,
1875                                 srcPacking);
1876    }
1877    else {
1878       /* general path */
1879       const GLubyte *tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
1880                                                  baseInternalFormat,
1881                                                  baseFormat,
1882                                                  srcWidth, srcHeight, srcDepth,
1883                                                  srcFormat, srcType, srcAddr,
1884                                                  srcPacking);
1885       const GLubyte *src = tempImage;
1886       GLint img, row, col;
1887       if (!tempImage)
1888          return GL_FALSE;
1889       for (img = 0; img < srcDepth; img++) {
1890          GLubyte *dstRow = dstSlices[img];
1891          for (row = 0; row < srcHeight; row++) {
1892             GLushort *dstUS = (GLushort *) dstRow;
1893             if (dstFormat == MESA_FORMAT_AL88 ||
1894                 dstFormat == MESA_FORMAT_GR88) {
1895                for (col = 0; col < srcWidth; col++) {
1896                   /* src[0] is luminance (or R), src[1] is alpha (or G) */
1897                  dstUS[col] = PACK_COLOR_88( src[1],
1898                                              src[0] );
1899                  src += 2;
1900                }
1901             }
1902             else {
1903                for (col = 0; col < srcWidth; col++) {
1904                   /* src[0] is luminance (or R), src[1] is alpha (or G) */
1905                  dstUS[col] = PACK_COLOR_88_REV( src[1],
1906                                                  src[0] );
1907                  src += 2;
1908                }
1909             }
1910             dstRow += dstRowStride;
1911          }
1912       }
1913       free((void *) tempImage);
1914    }
1915    return GL_TRUE;
1916 }
1917
1918
1919 /**
1920  * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.
1921  */
1922 static GLboolean
1923 _mesa_texstore_unorm1616(TEXSTORE_PARAMS)
1924 {
1925    const GLboolean littleEndian = _mesa_little_endian();
1926    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
1927
1928    ASSERT(dstFormat == MESA_FORMAT_AL1616 ||
1929           dstFormat == MESA_FORMAT_AL1616_REV ||
1930           dstFormat == MESA_FORMAT_RG1616 ||
1931           dstFormat == MESA_FORMAT_RG1616_REV);
1932    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
1933
1934    if (!ctx->_ImageTransferState &&
1935        !srcPacking->SwapBytes &&
1936        ((dstFormat == MESA_FORMAT_AL1616 &&
1937          baseInternalFormat == GL_LUMINANCE_ALPHA &&
1938          srcFormat == GL_LUMINANCE_ALPHA) ||
1939         (dstFormat == MESA_FORMAT_RG1616 &&
1940          baseInternalFormat == srcFormat)) &&
1941        srcType == GL_UNSIGNED_SHORT &&
1942        littleEndian) {
1943       /* simple memcpy path */
1944       memcpy_texture(ctx, dims,
1945                      dstFormat,
1946                      dstRowStride, dstSlices,
1947                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
1948                      srcAddr, srcPacking);
1949    }
1950    else {
1951       /* general path */
1952       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
1953                                                  baseInternalFormat,
1954                                                  baseFormat,
1955                                                  srcWidth, srcHeight, srcDepth,
1956                                                  srcFormat, srcType, srcAddr,
1957                                                  srcPacking,
1958                                                  ctx->_ImageTransferState);
1959       const GLfloat *src = tempImage;
1960       GLint img, row, col;
1961       if (!tempImage)
1962          return GL_FALSE;
1963       for (img = 0; img < srcDepth; img++) {
1964          GLubyte *dstRow = dstSlices[img];
1965          for (row = 0; row < srcHeight; row++) {
1966             GLuint *dstUI = (GLuint *) dstRow;
1967             if (dstFormat == MESA_FORMAT_AL1616 ||
1968                 dstFormat == MESA_FORMAT_RG1616) {
1969                for (col = 0; col < srcWidth; col++) {
1970                   GLushort l, a;
1971
1972                   UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
1973                   UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
1974                   dstUI[col] = PACK_COLOR_1616(a, l);
1975                   src += 2;
1976                }
1977             }
1978             else {
1979                for (col = 0; col < srcWidth; col++) {
1980                   GLushort l, a;
1981
1982                   UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
1983                   UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
1984                   dstUI[col] = PACK_COLOR_1616_REV(a, l);
1985                   src += 2;
1986                }
1987             }
1988             dstRow += dstRowStride;
1989          }
1990       }
1991       free((void *) tempImage);
1992    }
1993    return GL_TRUE;
1994 }
1995
1996
1997 /* Texstore for R16, A16, L16, I16. */
1998 static GLboolean
1999 _mesa_texstore_unorm16(TEXSTORE_PARAMS)
2000 {
2001    const GLboolean littleEndian = _mesa_little_endian();
2002    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2003
2004    ASSERT(dstFormat == MESA_FORMAT_R16 ||
2005           dstFormat == MESA_FORMAT_A16 ||
2006           dstFormat == MESA_FORMAT_L16 ||
2007           dstFormat == MESA_FORMAT_I16);
2008    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
2009
2010    if (!ctx->_ImageTransferState &&
2011        !srcPacking->SwapBytes &&
2012        baseInternalFormat == srcFormat &&
2013        srcType == GL_UNSIGNED_SHORT &&
2014        littleEndian) {
2015       /* simple memcpy path */
2016       memcpy_texture(ctx, dims,
2017                      dstFormat,
2018                      dstRowStride, dstSlices,
2019                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2020                      srcAddr, srcPacking);
2021    }
2022    else {
2023       /* general path */
2024       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2025                                                  baseInternalFormat,
2026                                                  baseFormat,
2027                                                  srcWidth, srcHeight, srcDepth,
2028                                                  srcFormat, srcType, srcAddr,
2029                                                  srcPacking,
2030                                                  ctx->_ImageTransferState);
2031       const GLfloat *src = tempImage;
2032       GLint img, row, col;
2033       if (!tempImage)
2034          return GL_FALSE;
2035       for (img = 0; img < srcDepth; img++) {
2036          GLubyte *dstRow = dstSlices[img];
2037          for (row = 0; row < srcHeight; row++) {
2038             GLushort *dstUS = (GLushort *) dstRow;
2039             for (col = 0; col < srcWidth; col++) {
2040                GLushort r;
2041
2042                UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
2043                dstUS[col] = r;
2044                src += 1;
2045             }
2046             dstRow += dstRowStride;
2047          }
2048       }
2049       free((void *) tempImage);
2050    }
2051    return GL_TRUE;
2052 }
2053
2054
2055 static GLboolean
2056 _mesa_texstore_rgba_16(TEXSTORE_PARAMS)
2057 {
2058    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2059
2060    ASSERT(dstFormat == MESA_FORMAT_RGBA_16);
2061    ASSERT(_mesa_get_format_bytes(dstFormat) == 8);
2062
2063    if (!ctx->_ImageTransferState &&
2064        !srcPacking->SwapBytes &&
2065        baseInternalFormat == GL_RGBA &&
2066        srcFormat == GL_RGBA &&
2067        srcType == GL_UNSIGNED_SHORT) {
2068       /* simple memcpy path */
2069       memcpy_texture(ctx, dims,
2070                      dstFormat,
2071                      dstRowStride, dstSlices,
2072                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2073                      srcAddr, srcPacking);
2074    }
2075    else {
2076       /* general path */
2077       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2078                                                  baseInternalFormat,
2079                                                  baseFormat,
2080                                                  srcWidth, srcHeight, srcDepth,
2081                                                  srcFormat, srcType, srcAddr,
2082                                                  srcPacking,
2083                                                  ctx->_ImageTransferState);
2084       const GLfloat *src = tempImage;
2085       GLint img, row, col;
2086       if (!tempImage)
2087          return GL_FALSE;
2088       for (img = 0; img < srcDepth; img++) {
2089          GLubyte *dstRow = dstSlices[img];
2090          for (row = 0; row < srcHeight; row++) {
2091             GLushort *dstUS = (GLushort *) dstRow;
2092             for (col = 0; col < srcWidth; col++) {
2093                GLushort r, g, b, a;
2094
2095                UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
2096                UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);
2097                UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);
2098                UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);
2099                dstUS[col*4+0] = r;
2100                dstUS[col*4+1] = g;
2101                dstUS[col*4+2] = b;
2102                dstUS[col*4+3] = a;
2103                src += 4;
2104             }
2105             dstRow += dstRowStride;
2106          }
2107       }
2108       free((void *) tempImage);
2109    }
2110    return GL_TRUE;
2111 }
2112
2113
2114 static GLboolean
2115 _mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)
2116 {
2117    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2118
2119    ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||
2120           dstFormat == MESA_FORMAT_SIGNED_RGBA_16);
2121
2122    if (!ctx->_ImageTransferState &&
2123        !srcPacking->SwapBytes &&
2124        baseInternalFormat == GL_RGBA &&
2125        dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&
2126        srcFormat == GL_RGBA &&
2127        srcType == GL_SHORT) {
2128       /* simple memcpy path */
2129       memcpy_texture(ctx, dims,
2130                      dstFormat,
2131                      dstRowStride, dstSlices,
2132                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2133                      srcAddr, srcPacking);
2134    }
2135    else {
2136       /* general path */
2137       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2138                                                  baseInternalFormat,
2139                                                  baseFormat,
2140                                                  srcWidth, srcHeight, srcDepth,
2141                                                  srcFormat, srcType, srcAddr,
2142                                                  srcPacking,
2143                                                  ctx->_ImageTransferState);
2144       const GLfloat *src = tempImage;
2145       const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;
2146       GLint img, row, col;
2147
2148       if (!tempImage)
2149          return GL_FALSE;
2150
2151       /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,
2152        * 3 or 4 components/pixel here.
2153        */
2154       for (img = 0; img < srcDepth; img++) {
2155          GLubyte *dstRow = dstSlices[img];
2156          for (row = 0; row < srcHeight; row++) {
2157             GLshort *dstRowS = (GLshort *) dstRow;
2158             if (dstFormat == MESA_FORMAT_SIGNED_RGBA_16) {
2159                for (col = 0; col < srcWidth; col++) {
2160                   GLuint c;
2161                   for (c = 0; c < comps; c++) {
2162                      GLshort p;
2163                      UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);
2164                      dstRowS[col * comps + c] = p;
2165                   }
2166                }
2167                dstRow += dstRowStride;
2168                src += 4 * srcWidth;
2169             } else {
2170                for (col = 0; col < srcWidth; col++) {
2171                   GLuint c;
2172                   for (c = 0; c < comps; c++) {
2173                      GLshort p;
2174                      UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 3 + c]);
2175                      dstRowS[col * comps + c] = p;
2176                   }
2177                }
2178                dstRow += dstRowStride;
2179                src += 3 * srcWidth;
2180             }
2181          }
2182       }
2183       free((void *) tempImage);
2184    }
2185    return GL_TRUE;
2186 }
2187
2188
2189 static GLboolean
2190 _mesa_texstore_rgb332(TEXSTORE_PARAMS)
2191 {
2192    ASSERT(dstFormat == MESA_FORMAT_RGB332);
2193    ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
2194
2195    if (!ctx->_ImageTransferState &&
2196        baseInternalFormat == GL_RGB &&
2197        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
2198                                             srcPacking->SwapBytes)) {
2199       /* simple memcpy path */
2200       memcpy_texture(ctx, dims,
2201                      dstFormat,
2202                      dstRowStride, dstSlices,
2203                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2204                      srcAddr, srcPacking);
2205    }
2206    else {
2207       return store_ubyte_texture(ctx, dims, baseInternalFormat,
2208                                  dstFormat, dstRowStride, dstSlices,
2209                                  srcWidth, srcHeight, srcDepth,
2210                                  srcFormat, srcType, srcAddr, srcPacking);
2211    }
2212    return GL_TRUE;
2213 }
2214
2215
2216 /**
2217  * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.
2218  */
2219 static GLboolean
2220 _mesa_texstore_unorm8(TEXSTORE_PARAMS)
2221 {
2222    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2223
2224    ASSERT(dstFormat == MESA_FORMAT_A8 ||
2225           dstFormat == MESA_FORMAT_L8 ||
2226           dstFormat == MESA_FORMAT_I8 ||
2227           dstFormat == MESA_FORMAT_R8);
2228    ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
2229
2230    if (!ctx->_ImageTransferState &&
2231        !srcPacking->SwapBytes &&
2232        baseInternalFormat == srcFormat &&
2233        srcType == GL_UNSIGNED_BYTE) {
2234       /* simple memcpy path */
2235       memcpy_texture(ctx, dims,
2236                      dstFormat,
2237                      dstRowStride, dstSlices,
2238                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2239                      srcAddr, srcPacking);
2240    }
2241    else if (!ctx->_ImageTransferState &&
2242             srcType == GL_UNSIGNED_BYTE &&
2243             can_swizzle(baseInternalFormat) &&
2244             can_swizzle(srcFormat)) {
2245       GLubyte dstmap[4];
2246
2247       /* dstmap - how to swizzle from RGBA to dst format:
2248        */
2249       if (dstFormat == MESA_FORMAT_A8) {
2250          dstmap[0] = 3;
2251       }
2252       else {
2253          dstmap[0] = 0;
2254       }
2255       dstmap[1] = ZERO;         /* ? */
2256       dstmap[2] = ZERO;         /* ? */
2257       dstmap[3] = ONE;          /* ? */
2258
2259       _mesa_swizzle_ubyte_image(ctx, dims,
2260                                 srcFormat,
2261                                 srcType,
2262                                 baseInternalFormat,
2263                                 dstmap, 1,
2264                                 dstRowStride, dstSlices,
2265                                 srcWidth, srcHeight, srcDepth, srcAddr,
2266                                 srcPacking);
2267    }
2268    else {
2269       /* general path */
2270       const GLubyte *tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
2271                                                  baseInternalFormat,
2272                                                  baseFormat,
2273                                                  srcWidth, srcHeight, srcDepth,
2274                                                  srcFormat, srcType, srcAddr,
2275                                                  srcPacking);
2276       const GLubyte *src = tempImage;
2277       GLint img, row, col;
2278       if (!tempImage)
2279          return GL_FALSE;
2280       for (img = 0; img < srcDepth; img++) {
2281          GLubyte *dstRow = dstSlices[img];
2282          for (row = 0; row < srcHeight; row++) {
2283             for (col = 0; col < srcWidth; col++) {
2284                dstRow[col] = src[col];
2285             }
2286             dstRow += dstRowStride;
2287             src += srcWidth;
2288          }
2289       }
2290       free((void *) tempImage);
2291    }
2292    return GL_TRUE;
2293 }
2294
2295
2296
2297 /**
2298  * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
2299  */
2300 static GLboolean
2301 _mesa_texstore_ycbcr(TEXSTORE_PARAMS)
2302 {
2303    const GLboolean littleEndian = _mesa_little_endian();
2304
2305    (void) ctx; (void) dims; (void) baseInternalFormat;
2306
2307    ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||
2308           (dstFormat == MESA_FORMAT_YCBCR_REV));
2309    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
2310    ASSERT(ctx->Extensions.MESA_ycbcr_texture);
2311    ASSERT(srcFormat == GL_YCBCR_MESA);
2312    ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||
2313           (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));
2314    ASSERT(baseInternalFormat == GL_YCBCR_MESA);
2315
2316    /* always just memcpy since no pixel transfer ops apply */
2317    memcpy_texture(ctx, dims,
2318                   dstFormat,
2319                   dstRowStride, dstSlices,
2320                   srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2321                   srcAddr, srcPacking);
2322
2323    /* Check if we need byte swapping */
2324    /* XXX the logic here _might_ be wrong */
2325    if (srcPacking->SwapBytes ^
2326        (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^
2327        (dstFormat == MESA_FORMAT_YCBCR_REV) ^
2328        !littleEndian) {
2329       GLint img, row;
2330       for (img = 0; img < srcDepth; img++) {
2331          GLubyte *dstRow = dstSlices[img];
2332          for (row = 0; row < srcHeight; row++) {
2333             _mesa_swap2((GLushort *) dstRow, srcWidth);
2334             dstRow += dstRowStride;
2335          }
2336       }
2337    }
2338    return GL_TRUE;
2339 }
2340
2341 static GLboolean
2342 _mesa_texstore_dudv8(TEXSTORE_PARAMS)
2343 {
2344    const GLboolean littleEndian = _mesa_little_endian();
2345    const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
2346
2347    ASSERT(dstFormat == MESA_FORMAT_DUDV8);
2348    ASSERT(texelBytes == 2);
2349    ASSERT(ctx->Extensions.ATI_envmap_bumpmap);
2350    ASSERT((srcFormat == GL_DU8DV8_ATI) ||
2351           (srcFormat == GL_DUDV_ATI));
2352    ASSERT(baseInternalFormat == GL_DUDV_ATI);
2353
2354    if (!srcPacking->SwapBytes && srcType == GL_BYTE &&
2355        littleEndian) {
2356       /* simple memcpy path */
2357       memcpy_texture(ctx, dims,
2358                      dstFormat,
2359                      dstRowStride, dstSlices,
2360                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2361                      srcAddr, srcPacking);
2362    }
2363    else if (srcType == GL_BYTE) {
2364       GLubyte dstmap[4];
2365
2366       /* dstmap - how to swizzle from RGBA to dst format:
2367        */
2368       if (littleEndian) {
2369          dstmap[0] = 0;
2370          dstmap[1] = 3;
2371       }
2372       else {
2373          dstmap[0] = 3;
2374          dstmap[1] = 0;
2375       }
2376       dstmap[2] = ZERO;         /* ? */
2377       dstmap[3] = ONE;          /* ? */
2378
2379       _mesa_swizzle_ubyte_image(ctx, dims,
2380                                 GL_LUMINANCE_ALPHA, /* hack */
2381                                 GL_UNSIGNED_BYTE, /* hack */
2382                                 GL_LUMINANCE_ALPHA, /* hack */
2383                                 dstmap, 2,
2384                                 dstRowStride, dstSlices,
2385                                 srcWidth, srcHeight, srcDepth, srcAddr,
2386                                 srcPacking);
2387    }
2388    else {
2389       /* general path - note this is defined for 2d textures only */
2390       const GLint components = _mesa_components_in_format(baseInternalFormat);
2391       const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,
2392                                                      srcFormat, srcType);
2393       GLbyte *tempImage, *dst, *src;
2394       GLint row;
2395
2396       tempImage = malloc(srcWidth * srcHeight * srcDepth
2397                                           * components * sizeof(GLbyte));
2398       if (!tempImage)
2399          return GL_FALSE;
2400
2401       src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,
2402                                            srcWidth, srcHeight,
2403                                            srcFormat, srcType,
2404                                            0, 0, 0);
2405
2406       dst = tempImage;
2407       for (row = 0; row < srcHeight; row++) {
2408          _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,
2409                                      dst, srcFormat, srcType, src,
2410                                      srcPacking, 0);
2411          dst += srcWidth * components;
2412          src += srcStride;
2413       }
2414
2415       src = tempImage;
2416       dst = (GLbyte *) dstSlices[0];
2417       for (row = 0; row < srcHeight; row++) {
2418          memcpy(dst, src, srcWidth * texelBytes);
2419          dst += dstRowStride;
2420          src += srcWidth * texelBytes;
2421       }
2422       free((void *) tempImage);
2423    }
2424    return GL_TRUE;
2425 }
2426
2427
2428 /**
2429  * Store a texture in a signed normalized 8-bit format.
2430  */
2431 static GLboolean
2432 _mesa_texstore_snorm8(TEXSTORE_PARAMS)
2433 {
2434    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2435
2436    ASSERT(dstFormat == MESA_FORMAT_SIGNED_A8 ||
2437           dstFormat == MESA_FORMAT_SIGNED_L8 ||
2438           dstFormat == MESA_FORMAT_SIGNED_I8 ||
2439           dstFormat == MESA_FORMAT_SIGNED_R8);
2440    ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
2441
2442    if (!ctx->_ImageTransferState &&
2443        !srcPacking->SwapBytes &&
2444        baseInternalFormat == srcFormat &&
2445        srcType == GL_BYTE) {
2446       /* simple memcpy path */
2447       memcpy_texture(ctx, dims,
2448                      dstFormat,
2449                      dstRowStride, dstSlices,
2450                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2451                      srcAddr, srcPacking);
2452    }
2453    else {
2454       /* general path */
2455       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2456                                                  baseInternalFormat,
2457                                                  baseFormat,
2458                                                  srcWidth, srcHeight, srcDepth,
2459                                                  srcFormat, srcType, srcAddr,
2460                                                  srcPacking,
2461                                                  ctx->_ImageTransferState);
2462       const GLfloat *src = tempImage;
2463       GLint img, row, col;
2464       if (!tempImage)
2465          return GL_FALSE;
2466       for (img = 0; img < srcDepth; img++) {
2467          GLbyte *dstRow = (GLbyte *) dstSlices[img];
2468          for (row = 0; row < srcHeight; row++) {
2469             for (col = 0; col < srcWidth; col++) {
2470                dstRow[col] = FLOAT_TO_BYTE_TEX(src[col]);
2471             }
2472             dstRow += dstRowStride;
2473             src += srcWidth;
2474          }
2475       }
2476       free((void *) tempImage);
2477    }
2478    return GL_TRUE;
2479 }
2480
2481
2482 /**
2483  * Store a texture in a signed normalized two-channel 16-bit format.
2484  */
2485 static GLboolean
2486 _mesa_texstore_snorm88(TEXSTORE_PARAMS)
2487 {
2488    const GLboolean littleEndian = _mesa_little_endian();
2489    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2490
2491    ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL88 ||
2492           dstFormat == MESA_FORMAT_SIGNED_RG88_REV);
2493    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
2494
2495    if (!ctx->_ImageTransferState &&
2496        !srcPacking->SwapBytes &&
2497        baseInternalFormat == srcFormat &&
2498        srcType == GL_BYTE &&
2499        littleEndian) {
2500       /* simple memcpy path */
2501       memcpy_texture(ctx, dims,
2502                      dstFormat,
2503                      dstRowStride, dstSlices,
2504                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2505                      srcAddr, srcPacking);
2506    }
2507    else {
2508       /* general path */
2509       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2510                                                  baseInternalFormat,
2511                                                  baseFormat,
2512                                                  srcWidth, srcHeight, srcDepth,
2513                                                  srcFormat, srcType, srcAddr,
2514                                                  srcPacking,
2515                                                  ctx->_ImageTransferState);
2516       const GLfloat *src = tempImage;
2517       GLint img, row, col;
2518       if (!tempImage)
2519          return GL_FALSE;
2520       for (img = 0; img < srcDepth; img++) {
2521          GLbyte *dstRow = (GLbyte *) dstSlices[img];
2522          for (row = 0; row < srcHeight; row++) {
2523             GLbyte *dst = dstRow;
2524             for (col = 0; col < srcWidth; col++) {
2525                dst[0] = FLOAT_TO_BYTE_TEX(src[0]);
2526                dst[1] = FLOAT_TO_BYTE_TEX(src[1]);
2527                src += 2;
2528                dst += 2;
2529             }
2530             dstRow += dstRowStride;
2531          }
2532       }
2533       free((void *) tempImage);
2534    }
2535    return GL_TRUE;
2536 }
2537
2538 /* Texstore for signed R16, A16, L16, I16. */
2539 static GLboolean
2540 _mesa_texstore_snorm16(TEXSTORE_PARAMS)
2541 {
2542    const GLboolean littleEndian = _mesa_little_endian();
2543    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2544
2545    ASSERT(dstFormat == MESA_FORMAT_SIGNED_R16 ||
2546           dstFormat == MESA_FORMAT_SIGNED_A16 ||
2547           dstFormat == MESA_FORMAT_SIGNED_L16 ||
2548           dstFormat == MESA_FORMAT_SIGNED_I16);
2549    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
2550
2551    if (!ctx->_ImageTransferState &&
2552        !srcPacking->SwapBytes &&
2553        baseInternalFormat == srcFormat &&
2554        srcType == GL_SHORT &&
2555        littleEndian) {
2556       /* simple memcpy path */
2557       memcpy_texture(ctx, dims,
2558                      dstFormat,
2559                      dstRowStride, dstSlices,
2560                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2561                      srcAddr, srcPacking);
2562    }
2563    else {
2564       /* general path */
2565       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2566                                                  baseInternalFormat,
2567                                                  baseFormat,
2568                                                  srcWidth, srcHeight, srcDepth,
2569                                                  srcFormat, srcType, srcAddr,
2570                                                  srcPacking,
2571                                                  ctx->_ImageTransferState);
2572       const GLfloat *src = tempImage;
2573       GLint img, row, col;
2574       if (!tempImage)
2575          return GL_FALSE;
2576       for (img = 0; img < srcDepth; img++) {
2577          GLubyte *dstRow = dstSlices[img];
2578          for (row = 0; row < srcHeight; row++) {
2579             GLshort *dstUS = (GLshort *) dstRow;
2580             for (col = 0; col < srcWidth; col++) {
2581                GLushort r;
2582
2583                UNCLAMPED_FLOAT_TO_SHORT(r, src[0]);
2584                dstUS[col] = r;
2585                src += 1;
2586             }
2587             dstRow += dstRowStride;
2588          }
2589       }
2590       free((void *) tempImage);
2591    }
2592    return GL_TRUE;
2593 }
2594
2595 /**
2596  * Do texstore for 2-channel, 16-bit/channel, signed normalized formats.
2597  */
2598 static GLboolean
2599 _mesa_texstore_snorm1616(TEXSTORE_PARAMS)
2600 {
2601    const GLboolean littleEndian = _mesa_little_endian();
2602    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2603
2604    ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL1616 ||
2605           dstFormat == MESA_FORMAT_SIGNED_GR1616);
2606    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
2607
2608    if (!ctx->_ImageTransferState &&
2609        !srcPacking->SwapBytes &&
2610        baseInternalFormat == srcFormat &&
2611        srcType == GL_SHORT &&
2612        littleEndian) {
2613       /* simple memcpy path */
2614       memcpy_texture(ctx, dims,
2615                      dstFormat,
2616                      dstRowStride, dstSlices,
2617                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2618                      srcAddr, srcPacking);
2619    }
2620    else {
2621       /* general path */
2622       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2623                                                  baseInternalFormat,
2624                                                  baseFormat,
2625                                                  srcWidth, srcHeight, srcDepth,
2626                                                  srcFormat, srcType, srcAddr,
2627                                                  srcPacking,
2628                                                  ctx->_ImageTransferState);
2629       const GLfloat *src = tempImage;
2630       GLint img, row, col;
2631       if (!tempImage)
2632          return GL_FALSE;
2633       for (img = 0; img < srcDepth; img++) {
2634          GLubyte *dstRow = dstSlices[img];
2635          for (row = 0; row < srcHeight; row++) {
2636             GLshort *dst = (GLshort *) dstRow;
2637             for (col = 0; col < srcWidth; col++) {
2638                GLushort l, a;
2639
2640                UNCLAMPED_FLOAT_TO_SHORT(l, src[0]);
2641                UNCLAMPED_FLOAT_TO_SHORT(a, src[1]);
2642                dst[0] = l;
2643                dst[1] = a;
2644                src += 2;
2645                dst += 2;
2646             }
2647             dstRow += dstRowStride;
2648          }
2649       }
2650       free((void *) tempImage);
2651    }
2652    return GL_TRUE;
2653 }
2654
2655 /**
2656  * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.
2657  */
2658 static GLboolean
2659 _mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)
2660 {
2661    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2662
2663    ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);
2664    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
2665
2666    {
2667       /* general path */
2668       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2669                                                  baseInternalFormat,
2670                                                  baseFormat,
2671                                                  srcWidth, srcHeight, srcDepth,
2672                                                  srcFormat, srcType, srcAddr,
2673                                                  srcPacking,
2674                                                  ctx->_ImageTransferState);
2675       const GLfloat *srcRow = tempImage;
2676       GLint img, row, col;
2677       if (!tempImage)
2678          return GL_FALSE;
2679       for (img = 0; img < srcDepth; img++) {
2680          GLbyte *dstRow = (GLbyte *) dstSlices[img];
2681          for (row = 0; row < srcHeight; row++) {
2682             GLbyte *dst = dstRow;
2683             for (col = 0; col < srcWidth; col++) {
2684                dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
2685                dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
2686                dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
2687                dst[0] = 127;
2688                srcRow += 3;
2689                dst += 4;
2690             }
2691             dstRow += dstRowStride;
2692          }
2693       }
2694       free((void *) tempImage);
2695    }
2696    return GL_TRUE;
2697 }
2698
2699
2700
2701 /**
2702  * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or
2703  * MESA_FORMAT_SIGNED_RGBA8888_REV
2704  */
2705 static GLboolean
2706 _mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)
2707 {
2708    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
2709
2710    ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||
2711           dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);
2712    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
2713
2714    if (!ctx->_ImageTransferState &&
2715        baseInternalFormat == GL_RGBA &&
2716        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
2717                                             srcPacking->SwapBytes)) {
2718        /* simple memcpy path */
2719       memcpy_texture(ctx, dims,
2720                      dstFormat,
2721                      dstRowStride, dstSlices,
2722                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2723                      srcAddr, srcPacking);
2724    }
2725    else {
2726       /* general path */
2727       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
2728                                                  baseInternalFormat,
2729                                                  baseFormat,
2730                                                  srcWidth, srcHeight, srcDepth,
2731                                                  srcFormat, srcType, srcAddr,
2732                                                  srcPacking,
2733                                                  ctx->_ImageTransferState);
2734       const GLfloat *srcRow = tempImage;
2735       GLint img, row, col;
2736       if (!tempImage)
2737          return GL_FALSE;
2738       for (img = 0; img < srcDepth; img++) {
2739          GLbyte *dstRow = (GLbyte *) dstSlices[img];
2740          for (row = 0; row < srcHeight; row++) {
2741             GLbyte *dst = dstRow;
2742             if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {
2743                for (col = 0; col < srcWidth; col++) {
2744                   dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
2745                   dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
2746                   dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
2747                   dst[0] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);
2748                   srcRow += 4;
2749                   dst += 4;
2750                }
2751             }
2752             else {
2753                for (col = 0; col < srcWidth; col++) {
2754                   dst[0] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
2755                   dst[1] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
2756                   dst[2] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
2757                   dst[3] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);
2758                   srcRow += 4;
2759                   dst += 4;
2760                }
2761             }
2762             dstRow += dstRowStride;
2763          }
2764       }
2765       free((void *) tempImage);
2766    }
2767    return GL_TRUE;
2768 }
2769
2770
2771 /**
2772  * Store a combined depth/stencil texture image.
2773  */
2774 static GLboolean
2775 _mesa_texstore_z24_s8(TEXSTORE_PARAMS)
2776 {
2777    const GLuint depthScale = 0xffffff;
2778    const GLint srcRowStride
2779       = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
2780    GLint img, row;
2781
2782    ASSERT(dstFormat == MESA_FORMAT_Z24_S8);
2783    ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||
2784           srcFormat == GL_DEPTH_COMPONENT ||
2785           srcFormat == GL_STENCIL_INDEX);
2786    ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
2787
2788    if (srcFormat == GL_DEPTH_STENCIL && ctx->Pixel.DepthScale == 1.0f &&
2789        ctx->Pixel.DepthBias == 0.0f &&
2790        !srcPacking->SwapBytes) {
2791       /* simple path */
2792       memcpy_texture(ctx, dims,
2793                      dstFormat,
2794                      dstRowStride, dstSlices,
2795                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2796                      srcAddr, srcPacking);
2797    }
2798    else if (srcFormat == GL_DEPTH_COMPONENT ||
2799             srcFormat == GL_STENCIL_INDEX) {
2800       GLuint *depth = malloc(srcWidth * sizeof(GLuint));
2801       GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
2802
2803       if (!depth || !stencil) {
2804          free(depth);
2805          free(stencil);
2806          return GL_FALSE;
2807       }
2808
2809       /* In case we only upload depth we need to preserve the stencil */
2810       for (img = 0; img < srcDepth; img++) {
2811          GLuint *dstRow = (GLuint *) dstSlices[img];
2812          const GLubyte *src
2813             = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
2814                   srcWidth, srcHeight,
2815                   srcFormat, srcType,
2816                   img, 0, 0);
2817          for (row = 0; row < srcHeight; row++) {
2818             GLint i;
2819             GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
2820
2821             if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
2822                keepstencil = GL_TRUE;
2823             }
2824             else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
2825                keepdepth = GL_TRUE;
2826             }
2827
2828             if (keepdepth == GL_FALSE)
2829                /* the 24 depth bits will be in the low position: */
2830                _mesa_unpack_depth_span(ctx, srcWidth,
2831                                        GL_UNSIGNED_INT, /* dst type */
2832                                        keepstencil ? depth : dstRow, /* dst addr */
2833                                        depthScale,
2834                                        srcType, src, srcPacking);
2835
2836             if (keepstencil == GL_FALSE)
2837                /* get the 8-bit stencil values */
2838                _mesa_unpack_stencil_span(ctx, srcWidth,
2839                                          GL_UNSIGNED_BYTE, /* dst type */
2840                                          stencil, /* dst addr */
2841                                          srcType, src, srcPacking,
2842                                          ctx->_ImageTransferState);
2843
2844             for (i = 0; i < srcWidth; i++) {
2845                if (keepstencil)
2846                   dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);
2847                else
2848                   dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);
2849             }
2850
2851             src += srcRowStride;
2852             dstRow += dstRowStride / sizeof(GLuint);
2853          }
2854       }
2855
2856       free(depth);
2857       free(stencil);
2858    }
2859    return GL_TRUE;
2860 }
2861
2862
2863 /**
2864  * Store a combined depth/stencil texture image.
2865  */
2866 static GLboolean
2867 _mesa_texstore_s8_z24(TEXSTORE_PARAMS)
2868 {
2869    const GLuint depthScale = 0xffffff;
2870    const GLint srcRowStride
2871       = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
2872    GLint img, row;
2873    GLuint *depth;
2874    GLubyte *stencil;
2875
2876    ASSERT(dstFormat == MESA_FORMAT_S8_Z24);
2877    ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||
2878           srcFormat == GL_DEPTH_COMPONENT ||
2879           srcFormat == GL_STENCIL_INDEX);
2880    ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||
2881           srcType == GL_UNSIGNED_INT_24_8_EXT);
2882
2883    depth = malloc(srcWidth * sizeof(GLuint));
2884    stencil = malloc(srcWidth * sizeof(GLubyte));
2885
2886    if (!depth || !stencil) {
2887       free(depth);
2888       free(stencil);
2889       return GL_FALSE;
2890    }
2891
2892    for (img = 0; img < srcDepth; img++) {
2893       GLuint *dstRow = (GLuint *) dstSlices[img];
2894       const GLubyte *src
2895          = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
2896                                                 srcWidth, srcHeight,
2897                                                 srcFormat, srcType,
2898                                                 img, 0, 0);
2899       for (row = 0; row < srcHeight; row++) {
2900          GLint i;
2901          GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
2902
2903          if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
2904             keepstencil = GL_TRUE;
2905          }
2906          else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
2907             keepdepth = GL_TRUE;
2908          }
2909
2910          if (keepdepth == GL_FALSE)
2911             /* the 24 depth bits will be in the low position: */
2912             _mesa_unpack_depth_span(ctx, srcWidth,
2913                                     GL_UNSIGNED_INT, /* dst type */
2914                                     keepstencil ? depth : dstRow, /* dst addr */
2915                                     depthScale,
2916                                     srcType, src, srcPacking);
2917
2918          if (keepstencil == GL_FALSE)
2919             /* get the 8-bit stencil values */
2920             _mesa_unpack_stencil_span(ctx, srcWidth,
2921                                       GL_UNSIGNED_BYTE, /* dst type */
2922                                       stencil, /* dst addr */
2923                                       srcType, src, srcPacking,
2924                                       ctx->_ImageTransferState);
2925
2926          /* merge stencil values into depth values */
2927          for (i = 0; i < srcWidth; i++) {
2928             if (keepstencil)
2929                dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);
2930             else
2931                dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);
2932
2933          }
2934          src += srcRowStride;
2935          dstRow += dstRowStride / sizeof(GLuint);
2936       }
2937    }
2938
2939    free(depth);
2940    free(stencil);
2941
2942    return GL_TRUE;
2943 }
2944
2945
2946 /**
2947  * Store simple 8-bit/value stencil texture data.
2948  */
2949 static GLboolean
2950 _mesa_texstore_s8(TEXSTORE_PARAMS)
2951 {
2952    ASSERT(dstFormat == MESA_FORMAT_S8);
2953    ASSERT(srcFormat == GL_STENCIL_INDEX);
2954
2955    if (!ctx->_ImageTransferState &&
2956        !srcPacking->SwapBytes &&
2957        baseInternalFormat == srcFormat &&
2958        srcType == GL_UNSIGNED_BYTE) {
2959       /* simple memcpy path */
2960       memcpy_texture(ctx, dims,
2961                      dstFormat,
2962                      dstRowStride, dstSlices,
2963                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
2964                      srcAddr, srcPacking);
2965    }
2966    else {
2967       const GLint srcRowStride
2968          = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
2969       GLint img, row;
2970       GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
2971
2972       if (!stencil)
2973          return GL_FALSE;
2974
2975       for (img = 0; img < srcDepth; img++) {
2976          GLubyte *dstRow = dstSlices[img];
2977          const GLubyte *src
2978             = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
2979                                                    srcWidth, srcHeight,
2980                                                    srcFormat, srcType,
2981                                                    img, 0, 0);
2982          for (row = 0; row < srcHeight; row++) {
2983             GLint i;
2984
2985             /* get the 8-bit stencil values */
2986             _mesa_unpack_stencil_span(ctx, srcWidth,
2987                                       GL_UNSIGNED_BYTE, /* dst type */
2988                                       stencil, /* dst addr */
2989                                       srcType, src, srcPacking,
2990                                       ctx->_ImageTransferState);
2991             /* merge stencil values into depth values */
2992             for (i = 0; i < srcWidth; i++)
2993                dstRow[i] = stencil[i];
2994
2995             src += srcRowStride;
2996             dstRow += dstRowStride / sizeof(GLubyte);
2997          }
2998       }
2999
3000       free(stencil);
3001    }
3002
3003    return GL_TRUE;
3004 }
3005
3006
3007 /**
3008  * Store an image in any of the formats:
3009  *   _mesa_texformat_rgba_float32
3010  *   _mesa_texformat_rgb_float32
3011  *   _mesa_texformat_alpha_float32
3012  *   _mesa_texformat_luminance_float32
3013  *   _mesa_texformat_luminance_alpha_float32
3014  *   _mesa_texformat_intensity_float32
3015  */
3016 static GLboolean
3017 _mesa_texstore_rgba_float32(TEXSTORE_PARAMS)
3018 {
3019    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3020    const GLint components = _mesa_components_in_format(baseFormat);
3021
3022    ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||
3023           dstFormat == MESA_FORMAT_RGB_FLOAT32 ||
3024           dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||
3025           dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||
3026           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||
3027           dstFormat == MESA_FORMAT_INTENSITY_FLOAT32 ||
3028           dstFormat == MESA_FORMAT_R_FLOAT32 ||
3029           dstFormat == MESA_FORMAT_RG_FLOAT32);
3030    ASSERT(baseInternalFormat == GL_RGBA ||
3031           baseInternalFormat == GL_RGB ||
3032           baseInternalFormat == GL_ALPHA ||
3033           baseInternalFormat == GL_LUMINANCE ||
3034           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3035           baseInternalFormat == GL_INTENSITY ||
3036           baseInternalFormat == GL_RED ||
3037           baseInternalFormat == GL_RG);
3038    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLfloat));
3039
3040    if (!ctx->_ImageTransferState &&
3041        !srcPacking->SwapBytes &&
3042        baseInternalFormat == srcFormat &&
3043        baseInternalFormat == baseFormat &&
3044        srcType == GL_FLOAT) {
3045       /* simple memcpy path */
3046       memcpy_texture(ctx, dims,
3047                      dstFormat,
3048                      dstRowStride, dstSlices,
3049                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3050                      srcAddr, srcPacking);
3051    }
3052    else {
3053       /* general path */
3054       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
3055                                                  baseInternalFormat,
3056                                                  baseFormat,
3057                                                  srcWidth, srcHeight, srcDepth,
3058                                                  srcFormat, srcType, srcAddr,
3059                                                  srcPacking,
3060                                                  ctx->_ImageTransferState);
3061       const GLfloat *srcRow = tempImage;
3062       GLint bytesPerRow;
3063       GLint img, row;
3064       if (!tempImage)
3065          return GL_FALSE;
3066       bytesPerRow = srcWidth * components * sizeof(GLfloat);
3067       for (img = 0; img < srcDepth; img++) {
3068          GLubyte *dstRow = dstSlices[img];
3069          for (row = 0; row < srcHeight; row++) {
3070             memcpy(dstRow, srcRow, bytesPerRow);
3071             dstRow += dstRowStride;
3072             srcRow += srcWidth * components;
3073          }
3074       }
3075
3076       free((void *) tempImage);
3077    }
3078    return GL_TRUE;
3079 }
3080
3081
3082
3083 /**
3084  * As above, but store 16-bit floats.
3085  */
3086 static GLboolean
3087 _mesa_texstore_rgba_float16(TEXSTORE_PARAMS)
3088 {
3089    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3090    const GLint components = _mesa_components_in_format(baseFormat);
3091
3092    ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||
3093           dstFormat == MESA_FORMAT_RGB_FLOAT16 ||
3094           dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||
3095           dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||
3096           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||
3097           dstFormat == MESA_FORMAT_INTENSITY_FLOAT16 ||
3098           dstFormat == MESA_FORMAT_R_FLOAT16 ||
3099           dstFormat == MESA_FORMAT_RG_FLOAT16);
3100    ASSERT(baseInternalFormat == GL_RGBA ||
3101           baseInternalFormat == GL_RGB ||
3102           baseInternalFormat == GL_ALPHA ||
3103           baseInternalFormat == GL_LUMINANCE ||
3104           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3105           baseInternalFormat == GL_INTENSITY ||
3106           baseInternalFormat == GL_RED ||
3107           baseInternalFormat == GL_RG);
3108    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLhalfARB));
3109
3110    if (!ctx->_ImageTransferState &&
3111        !srcPacking->SwapBytes &&
3112        baseInternalFormat == srcFormat &&
3113        baseInternalFormat == baseFormat &&
3114        srcType == GL_HALF_FLOAT_ARB) {
3115       /* simple memcpy path */
3116       memcpy_texture(ctx, dims,
3117                      dstFormat,
3118                      dstRowStride, dstSlices,
3119                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3120                      srcAddr, srcPacking);
3121    }
3122    else {
3123       /* general path */
3124       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
3125                                                  baseInternalFormat,
3126                                                  baseFormat,
3127                                                  srcWidth, srcHeight, srcDepth,
3128                                                  srcFormat, srcType, srcAddr,
3129                                                  srcPacking,
3130                                                  ctx->_ImageTransferState);
3131       const GLfloat *src = tempImage;
3132       GLint img, row;
3133       if (!tempImage)
3134          return GL_FALSE;
3135       for (img = 0; img < srcDepth; img++) {
3136          GLubyte *dstRow = dstSlices[img];
3137          for (row = 0; row < srcHeight; row++) {
3138             GLhalfARB *dstTexel = (GLhalfARB *) dstRow;
3139             GLint i;
3140             for (i = 0; i < srcWidth * components; i++) {
3141                dstTexel[i] = _mesa_float_to_half(src[i]);
3142             }
3143             dstRow += dstRowStride;
3144             src += srcWidth * components;
3145          }
3146       }
3147
3148       free((void *) tempImage);
3149    }
3150    return GL_TRUE;
3151 }
3152
3153
3154 /* non-normalized, signed int8 */
3155 static GLboolean
3156 _mesa_texstore_rgba_int8(TEXSTORE_PARAMS)
3157 {
3158    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3159    const GLint components = _mesa_components_in_format(baseFormat);
3160
3161    ASSERT(dstFormat == MESA_FORMAT_R_INT8 ||
3162           dstFormat == MESA_FORMAT_RG_INT8 ||
3163           dstFormat == MESA_FORMAT_RGB_INT8 ||
3164           dstFormat == MESA_FORMAT_RGBA_INT8 ||
3165           dstFormat == MESA_FORMAT_ALPHA_INT8 ||
3166           dstFormat == MESA_FORMAT_INTENSITY_INT8 ||
3167           dstFormat == MESA_FORMAT_LUMINANCE_INT8 ||
3168           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_INT8);
3169    ASSERT(baseInternalFormat == GL_RGBA ||
3170           baseInternalFormat == GL_RGB ||
3171           baseInternalFormat == GL_RG ||
3172           baseInternalFormat == GL_RED ||
3173           baseInternalFormat == GL_ALPHA ||
3174           baseInternalFormat == GL_LUMINANCE ||
3175           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3176           baseInternalFormat == GL_INTENSITY);
3177    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLbyte));
3178
3179    /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
3180     * to integer formats.
3181     */
3182    if (!srcPacking->SwapBytes &&
3183        baseInternalFormat == srcFormat &&
3184        srcType == GL_BYTE) {
3185       /* simple memcpy path */
3186       memcpy_texture(ctx, dims,
3187                      dstFormat,
3188                      dstRowStride, dstSlices,
3189                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3190                      srcAddr, srcPacking);
3191    }
3192    else {
3193       /* general path */
3194       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
3195                                                      baseInternalFormat,
3196                                                      baseFormat,
3197                                                      srcWidth, srcHeight, srcDepth,
3198                                                      srcFormat, srcType,
3199                                                      srcAddr,
3200                                                      srcPacking);
3201       const GLuint *src = tempImage;
3202       GLint img, row;
3203       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3204       if (!tempImage)
3205          return GL_FALSE;
3206       for (img = 0; img < srcDepth; img++) {
3207          GLubyte *dstRow = dstSlices[img];
3208          for (row = 0; row < srcHeight; row++) {
3209             GLbyte *dstTexel = (GLbyte *) dstRow;
3210             GLint i;
3211             if (is_unsigned) {
3212                for (i = 0; i < srcWidth * components; i++) {
3213                   dstTexel[i] = (GLbyte) MIN2(src[i], 0x7f);
3214                }
3215             } else {
3216                for (i = 0; i < srcWidth * components; i++) {
3217                   dstTexel[i] = (GLbyte) CLAMP((GLint) src[i], -0x80, 0x7f);
3218                }
3219             }
3220             dstRow += dstRowStride;
3221             src += srcWidth * components;
3222          }
3223       }
3224
3225       free((void *) tempImage);
3226    }
3227    return GL_TRUE;
3228 }
3229
3230
3231 /* non-normalized, signed int16 */
3232 static GLboolean
3233 _mesa_texstore_rgba_int16(TEXSTORE_PARAMS)
3234 {
3235    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3236    const GLint components = _mesa_components_in_format(baseFormat);
3237
3238    ASSERT(dstFormat == MESA_FORMAT_R_INT16 ||
3239           dstFormat == MESA_FORMAT_RG_INT16 ||
3240           dstFormat == MESA_FORMAT_RGB_INT16 ||
3241           dstFormat == MESA_FORMAT_RGBA_INT16 ||
3242           dstFormat == MESA_FORMAT_ALPHA_INT16 ||
3243           dstFormat == MESA_FORMAT_LUMINANCE_INT16 ||
3244           dstFormat == MESA_FORMAT_INTENSITY_INT16 ||
3245           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_INT16);
3246    ASSERT(baseInternalFormat == GL_RGBA ||
3247           baseInternalFormat == GL_RGB ||
3248           baseInternalFormat == GL_RG ||
3249           baseInternalFormat == GL_RED ||
3250           baseInternalFormat == GL_ALPHA ||
3251           baseInternalFormat == GL_LUMINANCE ||
3252           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3253           baseInternalFormat == GL_INTENSITY);
3254    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLshort));
3255
3256    /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
3257     * to integer formats.
3258     */
3259    if (!srcPacking->SwapBytes &&
3260        baseInternalFormat == srcFormat &&
3261        srcType == GL_SHORT) {
3262       /* simple memcpy path */
3263       memcpy_texture(ctx, dims,
3264                      dstFormat,
3265                      dstRowStride, dstSlices,
3266                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3267                      srcAddr, srcPacking);
3268    }
3269    else {
3270       /* general path */
3271       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
3272                                                      baseInternalFormat,
3273                                                      baseFormat,
3274                                                      srcWidth, srcHeight, srcDepth,
3275                                                      srcFormat, srcType,
3276                                                      srcAddr,
3277                                                      srcPacking);
3278       const GLuint *src = tempImage;
3279       GLint img, row;
3280       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3281       if (!tempImage)
3282          return GL_FALSE;
3283       for (img = 0; img < srcDepth; img++) {
3284          GLubyte *dstRow = dstSlices[img];
3285          for (row = 0; row < srcHeight; row++) {
3286             GLshort *dstTexel = (GLshort *) dstRow;
3287             GLint i;
3288             if (is_unsigned) {
3289                for (i = 0; i < srcWidth * components; i++) {
3290                   dstTexel[i] = (GLshort) MIN2(src[i], 0x7fff);
3291                }
3292             } else {
3293                for (i = 0; i < srcWidth * components; i++) {
3294                   dstTexel[i] = (GLshort)CLAMP((GLint) src[i], -0x8000, 0x7fff);
3295                }
3296             }
3297             dstRow += dstRowStride;
3298             src += srcWidth * components;
3299          }
3300       }
3301
3302       free((void *) tempImage);
3303    }
3304    return GL_TRUE;
3305 }
3306
3307
3308 /* non-normalized, signed int32 */
3309 static GLboolean
3310 _mesa_texstore_rgba_int32(TEXSTORE_PARAMS)
3311 {
3312    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3313    const GLint components = _mesa_components_in_format(baseFormat);
3314
3315    ASSERT(dstFormat == MESA_FORMAT_R_INT32 ||
3316           dstFormat == MESA_FORMAT_RG_INT32 ||
3317           dstFormat == MESA_FORMAT_RGB_INT32 ||
3318           dstFormat == MESA_FORMAT_RGBA_INT32 ||
3319           dstFormat == MESA_FORMAT_ALPHA_INT32 ||
3320           dstFormat == MESA_FORMAT_INTENSITY_INT32 ||
3321           dstFormat == MESA_FORMAT_LUMINANCE_INT32 ||
3322           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_INT32);
3323    ASSERT(baseInternalFormat == GL_RGBA ||
3324           baseInternalFormat == GL_RGB ||
3325           baseInternalFormat == GL_RG ||
3326           baseInternalFormat == GL_RED ||
3327           baseInternalFormat == GL_ALPHA ||
3328           baseInternalFormat == GL_LUMINANCE ||
3329           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3330           baseInternalFormat == GL_INTENSITY);
3331    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLint));
3332
3333    /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
3334     * to integer formats.
3335     */
3336    if (!srcPacking->SwapBytes &&
3337        baseInternalFormat == srcFormat &&
3338        srcType == GL_INT) {
3339       /* simple memcpy path */
3340       memcpy_texture(ctx, dims,
3341                      dstFormat,
3342                      dstRowStride, dstSlices,
3343                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3344                      srcAddr, srcPacking);
3345    }
3346    else {
3347       /* general path */
3348       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
3349                                                      baseInternalFormat,
3350                                                      baseFormat,
3351                                                      srcWidth, srcHeight, srcDepth,
3352                                                      srcFormat, srcType,
3353                                                      srcAddr,
3354                                                      srcPacking);
3355       const GLuint *src = tempImage;
3356       GLint img, row;
3357       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3358       if (!tempImage)
3359          return GL_FALSE;
3360       for (img = 0; img < srcDepth; img++) {
3361          GLubyte *dstRow = dstSlices[img];
3362          for (row = 0; row < srcHeight; row++) {
3363             GLint *dstTexel = (GLint *) dstRow;
3364             GLint i;
3365             if (is_unsigned) {
3366                for (i = 0; i < srcWidth * components; i++) {
3367                   dstTexel[i] = (GLint) MIN2(src[i], 0x7fffffff);
3368                }
3369             } else {
3370                for (i = 0; i < srcWidth * components; i++) {
3371                   dstTexel[i] = (GLint) src[i];
3372                }
3373             }
3374             dstRow += dstRowStride;
3375             src += srcWidth * components;
3376          }
3377       }
3378
3379       free((void *) tempImage);
3380    }
3381    return GL_TRUE;
3382 }
3383
3384
3385 /* non-normalized, unsigned int8 */
3386 static GLboolean
3387 _mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)
3388 {
3389    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3390    const GLint components = _mesa_components_in_format(baseFormat);
3391
3392    ASSERT(dstFormat == MESA_FORMAT_R_UINT8 ||
3393           dstFormat == MESA_FORMAT_RG_UINT8 ||
3394           dstFormat == MESA_FORMAT_RGB_UINT8 ||
3395           dstFormat == MESA_FORMAT_RGBA_UINT8 ||
3396           dstFormat == MESA_FORMAT_ALPHA_UINT8 ||
3397           dstFormat == MESA_FORMAT_INTENSITY_UINT8 ||
3398           dstFormat == MESA_FORMAT_LUMINANCE_UINT8 ||
3399           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_UINT8);
3400    ASSERT(baseInternalFormat == GL_RGBA ||
3401           baseInternalFormat == GL_RGB ||
3402           baseInternalFormat == GL_RG ||
3403           baseInternalFormat == GL_RED ||
3404           baseInternalFormat == GL_ALPHA ||
3405           baseInternalFormat == GL_LUMINANCE ||
3406           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3407           baseInternalFormat == GL_INTENSITY);
3408    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLubyte));
3409
3410    /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
3411     * to integer formats.
3412     */
3413    if (!srcPacking->SwapBytes &&
3414        baseInternalFormat == srcFormat &&
3415        srcType == GL_UNSIGNED_BYTE) {
3416       /* simple memcpy path */
3417       memcpy_texture(ctx, dims,
3418                      dstFormat,
3419                      dstRowStride, dstSlices,
3420                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3421                      srcAddr, srcPacking);
3422    }
3423    else {
3424       /* general path */
3425       const GLuint *tempImage =
3426          make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
3427                               srcWidth, srcHeight, srcDepth,
3428                               srcFormat, srcType, srcAddr, srcPacking);
3429       const GLuint *src = tempImage;
3430       GLint img, row;
3431       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3432       if (!tempImage)
3433          return GL_FALSE;
3434       for (img = 0; img < srcDepth; img++) {
3435          GLubyte *dstRow = dstSlices[img];
3436          for (row = 0; row < srcHeight; row++) {
3437             GLubyte *dstTexel = (GLubyte *) dstRow;
3438             GLint i;
3439             if (is_unsigned) {
3440                for (i = 0; i < srcWidth * components; i++) {
3441                   dstTexel[i] = (GLubyte) MIN2(src[i], 0xff);
3442                }
3443             } else {
3444                for (i = 0; i < srcWidth * components; i++) {
3445                   dstTexel[i] = (GLubyte) CLAMP((GLint) src[i], 0, 0xff);
3446                }
3447             }
3448             dstRow += dstRowStride;
3449             src += srcWidth * components;
3450          }
3451       }
3452
3453       free((void *) tempImage);
3454    }
3455    return GL_TRUE;
3456 }
3457
3458
3459 /* non-normalized, unsigned int16 */
3460 static GLboolean
3461 _mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)
3462 {
3463    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3464    const GLint components = _mesa_components_in_format(baseFormat);
3465
3466    ASSERT(dstFormat == MESA_FORMAT_R_UINT16 ||
3467           dstFormat == MESA_FORMAT_RG_UINT16 ||
3468           dstFormat == MESA_FORMAT_RGB_UINT16 ||
3469           dstFormat == MESA_FORMAT_RGBA_UINT16 ||
3470           dstFormat == MESA_FORMAT_ALPHA_UINT16 ||
3471           dstFormat == MESA_FORMAT_INTENSITY_UINT16 ||
3472           dstFormat == MESA_FORMAT_LUMINANCE_UINT16 ||
3473           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_UINT16);
3474    ASSERT(baseInternalFormat == GL_RGBA ||
3475           baseInternalFormat == GL_RGB ||
3476           baseInternalFormat == GL_RG ||
3477           baseInternalFormat == GL_RED ||
3478           baseInternalFormat == GL_ALPHA ||
3479           baseInternalFormat == GL_LUMINANCE ||
3480           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3481           baseInternalFormat == GL_INTENSITY);
3482    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLushort));
3483
3484    /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
3485     * to integer formats.
3486     */
3487    if (!srcPacking->SwapBytes &&
3488        baseInternalFormat == srcFormat &&
3489        srcType == GL_UNSIGNED_SHORT) {
3490       /* simple memcpy path */
3491       memcpy_texture(ctx, dims,
3492                      dstFormat,
3493                      dstRowStride, dstSlices,
3494                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3495                      srcAddr, srcPacking);
3496    }
3497    else {
3498       /* general path */
3499       const GLuint *tempImage =
3500          make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
3501                               srcWidth, srcHeight, srcDepth,
3502                               srcFormat, srcType, srcAddr, srcPacking);
3503       const GLuint *src = tempImage;
3504       GLint img, row;
3505       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3506       if (!tempImage)
3507          return GL_FALSE;
3508       for (img = 0; img < srcDepth; img++) {
3509          GLubyte *dstRow = dstSlices[img];
3510          for (row = 0; row < srcHeight; row++) {
3511             GLushort *dstTexel = (GLushort *) dstRow;
3512             GLint i;
3513             if (is_unsigned) {
3514                for (i = 0; i < srcWidth * components; i++) {
3515                   dstTexel[i] = (GLushort) MIN2(src[i], 0xffff);
3516               }
3517             } else {
3518                for (i = 0; i < srcWidth * components; i++) {
3519                   dstTexel[i] = (GLushort) CLAMP((GLint) src[i], 0, 0xffff);
3520                }
3521             }
3522             dstRow += dstRowStride;
3523             src += srcWidth * components;
3524          }
3525       }
3526
3527       free((void *) tempImage);
3528    }
3529    return GL_TRUE;
3530 }
3531
3532
3533 /* non-normalized, unsigned int32 */
3534 static GLboolean
3535 _mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)
3536 {
3537    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3538    const GLint components = _mesa_components_in_format(baseFormat);
3539
3540    ASSERT(dstFormat == MESA_FORMAT_R_UINT32 ||
3541           dstFormat == MESA_FORMAT_RG_UINT32 ||
3542           dstFormat == MESA_FORMAT_RGB_UINT32 ||
3543           dstFormat == MESA_FORMAT_RGBA_UINT32 ||
3544           dstFormat == MESA_FORMAT_ALPHA_UINT32 ||
3545           dstFormat == MESA_FORMAT_INTENSITY_UINT32 ||
3546           dstFormat == MESA_FORMAT_LUMINANCE_UINT32 ||
3547           dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_UINT32);
3548    ASSERT(baseInternalFormat == GL_RGBA ||
3549           baseInternalFormat == GL_RGB ||
3550           baseInternalFormat == GL_RG ||
3551           baseInternalFormat == GL_RED ||
3552           baseInternalFormat == GL_ALPHA ||
3553           baseInternalFormat == GL_LUMINANCE ||
3554           baseInternalFormat == GL_LUMINANCE_ALPHA ||
3555           baseInternalFormat == GL_INTENSITY);
3556    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLuint));
3557
3558    /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
3559     * to integer formats.
3560     */
3561    if (!srcPacking->SwapBytes &&
3562        baseInternalFormat == srcFormat &&
3563        srcType == GL_UNSIGNED_INT) {
3564       /* simple memcpy path */
3565       memcpy_texture(ctx, dims,
3566                      dstFormat,
3567                      dstRowStride, dstSlices,
3568                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3569                      srcAddr, srcPacking);
3570    }
3571    else {
3572       /* general path */
3573       const GLuint *tempImage =
3574          make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
3575                               srcWidth, srcHeight, srcDepth,
3576                               srcFormat, srcType, srcAddr, srcPacking);
3577       const GLuint *src = tempImage;
3578       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3579       GLint img, row;
3580       if (!tempImage)
3581          return GL_FALSE;
3582       for (img = 0; img < srcDepth; img++) {
3583          GLubyte *dstRow = dstSlices[img];
3584          for (row = 0; row < srcHeight; row++) {
3585             GLuint *dstTexel = (GLuint *) dstRow;
3586             GLint i;
3587             if (is_unsigned) {
3588                for (i = 0; i < srcWidth * components; i++) {
3589                   dstTexel[i] = src[i];
3590                }
3591             } else {
3592                for (i = 0; i < srcWidth * components; i++) {
3593                   dstTexel[i] = MAX2((GLint) src[i], 0);
3594                }
3595             }
3596             dstRow += dstRowStride;
3597             src += srcWidth * components;
3598          }
3599       }
3600
3601       free((void *) tempImage);
3602    }
3603    return GL_TRUE;
3604 }
3605
3606
3607 static GLboolean
3608 _mesa_texstore_srgb8(TEXSTORE_PARAMS)
3609 {
3610    gl_format newDstFormat;
3611    GLboolean k;
3612
3613    ASSERT(dstFormat == MESA_FORMAT_SRGB8);
3614
3615    /* reuse normal rgb texstore code */
3616    newDstFormat = MESA_FORMAT_RGB888;
3617
3618    k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,
3619                              newDstFormat,
3620                              dstRowStride, dstSlices,
3621                              srcWidth, srcHeight, srcDepth,
3622                              srcFormat, srcType,
3623                              srcAddr, srcPacking);
3624    return k;
3625 }
3626
3627
3628 static GLboolean
3629 _mesa_texstore_srgba8(TEXSTORE_PARAMS)
3630 {
3631    gl_format newDstFormat;
3632    GLboolean k;
3633
3634    ASSERT(dstFormat == MESA_FORMAT_SRGBA8);
3635
3636    /* reuse normal rgba texstore code */
3637    newDstFormat = MESA_FORMAT_RGBA8888;
3638    k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,
3639                                newDstFormat,
3640                                dstRowStride, dstSlices,
3641                                srcWidth, srcHeight, srcDepth,
3642                                srcFormat, srcType,
3643                                srcAddr, srcPacking);
3644    return k;
3645 }
3646
3647
3648 static GLboolean
3649 _mesa_texstore_sargb8(TEXSTORE_PARAMS)
3650 {
3651    gl_format newDstFormat;
3652    GLboolean k;
3653
3654    ASSERT(dstFormat == MESA_FORMAT_SARGB8);
3655
3656    /* reuse normal rgba texstore code */
3657    newDstFormat = MESA_FORMAT_ARGB8888;
3658
3659    k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,
3660                                newDstFormat,
3661                                dstRowStride, dstSlices,
3662                                srcWidth, srcHeight, srcDepth,
3663                                srcFormat, srcType,
3664                                srcAddr, srcPacking);
3665    return k;
3666 }
3667
3668
3669 static GLboolean
3670 _mesa_texstore_sl8(TEXSTORE_PARAMS)
3671 {
3672    gl_format newDstFormat;
3673    GLboolean k;
3674
3675    ASSERT(dstFormat == MESA_FORMAT_SL8);
3676
3677    newDstFormat = MESA_FORMAT_L8;
3678
3679    /* _mesa_textore_a8 handles luminance8 too */
3680    k = _mesa_texstore_unorm8(ctx, dims, baseInternalFormat,
3681                              newDstFormat,
3682                              dstRowStride, dstSlices,
3683                              srcWidth, srcHeight, srcDepth,
3684                              srcFormat, srcType,
3685                              srcAddr, srcPacking);
3686    return k;
3687 }
3688
3689
3690 static GLboolean
3691 _mesa_texstore_sla8(TEXSTORE_PARAMS)
3692 {
3693    gl_format newDstFormat;
3694    GLboolean k;
3695
3696    ASSERT(dstFormat == MESA_FORMAT_SLA8);
3697
3698    /* reuse normal luminance/alpha texstore code */
3699    newDstFormat = MESA_FORMAT_AL88;
3700
3701    k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,
3702                               newDstFormat,
3703                               dstRowStride, dstSlices,
3704                               srcWidth, srcHeight, srcDepth,
3705                               srcFormat, srcType,
3706                               srcAddr, srcPacking);
3707    return k;
3708 }
3709
3710 static GLboolean
3711 _mesa_texstore_rgb9_e5(TEXSTORE_PARAMS)
3712 {
3713    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3714
3715    ASSERT(dstFormat == MESA_FORMAT_RGB9_E5_FLOAT);
3716    ASSERT(baseInternalFormat == GL_RGB);
3717
3718    if (!ctx->_ImageTransferState &&
3719        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
3720                                             srcPacking->SwapBytes)) {
3721       /* simple memcpy path */
3722       memcpy_texture(ctx, dims,
3723                      dstFormat,
3724                      dstRowStride, dstSlices,
3725                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3726                      srcAddr, srcPacking);
3727    }
3728    else {
3729       /* general path */
3730       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
3731                                                  baseInternalFormat,
3732                                                  baseFormat,
3733                                                  srcWidth, srcHeight, srcDepth,
3734                                                  srcFormat, srcType, srcAddr,
3735                                                  srcPacking,
3736                                                  ctx->_ImageTransferState);
3737       const GLfloat *srcRow = tempImage;
3738       GLint img, row, col;
3739       if (!tempImage)
3740          return GL_FALSE;
3741       for (img = 0; img < srcDepth; img++) {
3742          GLubyte *dstRow = dstSlices[img];
3743          for (row = 0; row < srcHeight; row++) {
3744             GLuint *dstUI = (GLuint*)dstRow;
3745             for (col = 0; col < srcWidth; col++) {
3746                dstUI[col] = float3_to_rgb9e5(&srcRow[col * 3]);
3747             }
3748             dstRow += dstRowStride;
3749             srcRow += srcWidth * 3;
3750          }
3751       }
3752
3753       free((void *) tempImage);
3754    }
3755    return GL_TRUE;
3756 }
3757
3758 static GLboolean
3759 _mesa_texstore_r11_g11_b10f(TEXSTORE_PARAMS)
3760 {
3761    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3762
3763    ASSERT(dstFormat == MESA_FORMAT_R11_G11_B10_FLOAT);
3764    ASSERT(baseInternalFormat == GL_RGB);
3765
3766    if (!ctx->_ImageTransferState &&
3767        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
3768                                             srcPacking->SwapBytes)) {
3769       /* simple memcpy path */
3770       memcpy_texture(ctx, dims,
3771                      dstFormat,
3772                      dstRowStride, dstSlices,
3773                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3774                      srcAddr, srcPacking);
3775    }
3776    else {
3777       /* general path */
3778       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
3779                                                  baseInternalFormat,
3780                                                  baseFormat,
3781                                                  srcWidth, srcHeight, srcDepth,
3782                                                  srcFormat, srcType, srcAddr,
3783                                                  srcPacking,
3784                                                  ctx->_ImageTransferState);
3785       const GLfloat *srcRow = tempImage;
3786       GLint img, row, col;
3787       if (!tempImage)
3788          return GL_FALSE;
3789       for (img = 0; img < srcDepth; img++) {
3790          GLubyte *dstRow = dstSlices[img];
3791          for (row = 0; row < srcHeight; row++) {
3792             GLuint *dstUI = (GLuint*)dstRow;
3793             for (col = 0; col < srcWidth; col++) {
3794                dstUI[col] = float3_to_r11g11b10f(&srcRow[col * 3]);
3795             }
3796             dstRow += dstRowStride;
3797             srcRow += srcWidth * 3;
3798          }
3799       }
3800
3801       free((void *) tempImage);
3802    }
3803    return GL_TRUE;
3804 }
3805
3806
3807 static GLboolean
3808 _mesa_texstore_z32f_x24s8(TEXSTORE_PARAMS)
3809 {
3810    ASSERT(dstFormat == MESA_FORMAT_Z32_FLOAT_X24S8);
3811    ASSERT(srcFormat == GL_DEPTH_STENCIL ||
3812           srcFormat == GL_DEPTH_COMPONENT ||
3813           srcFormat == GL_STENCIL_INDEX);
3814    ASSERT(srcFormat != GL_DEPTH_STENCIL ||
3815           srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
3816
3817    if (srcFormat == GL_DEPTH_STENCIL &&
3818        ctx->Pixel.DepthScale == 1.0f &&
3819        ctx->Pixel.DepthBias == 0.0f &&
3820        !srcPacking->SwapBytes) {
3821       /* simple path */
3822       memcpy_texture(ctx, dims,
3823                      dstFormat,
3824                      dstRowStride, dstSlices,
3825                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3826                      srcAddr, srcPacking);
3827    }
3828    else if (srcFormat == GL_DEPTH_COMPONENT ||
3829             srcFormat == GL_STENCIL_INDEX) {
3830       GLint img, row;
3831       const GLint srcRowStride
3832          = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
3833          / sizeof(uint64_t);
3834
3835       /* In case we only upload depth we need to preserve the stencil */
3836       for (img = 0; img < srcDepth; img++) {
3837          uint64_t *dstRow = (uint64_t *) dstSlices[img];
3838          const uint64_t *src
3839             = (const uint64_t *) _mesa_image_address(dims, srcPacking, srcAddr,
3840                   srcWidth, srcHeight,
3841                   srcFormat, srcType,
3842                   img, 0, 0);
3843          for (row = 0; row < srcHeight; row++) {
3844             /* The unpack functions with:
3845              *    dstType = GL_FLOAT_32_UNSIGNED_INT_24_8_REV
3846              * only write their own dword, so the other dword (stencil
3847              * or depth) is preserved. */
3848             if (srcFormat != GL_STENCIL_INDEX)
3849                _mesa_unpack_depth_span(ctx, srcWidth,
3850                                        GL_FLOAT_32_UNSIGNED_INT_24_8_REV, /* dst type */
3851                                        dstRow, /* dst addr */
3852                                        ~0U, srcType, src, srcPacking);
3853
3854             if (srcFormat != GL_DEPTH_COMPONENT)
3855                _mesa_unpack_stencil_span(ctx, srcWidth,
3856                                          GL_FLOAT_32_UNSIGNED_INT_24_8_REV, /* dst type */
3857                                          dstRow, /* dst addr */
3858                                          srcType, src, srcPacking,
3859                                          ctx->_ImageTransferState);
3860
3861             src += srcRowStride;
3862             dstRow += dstRowStride / sizeof(uint64_t);
3863          }
3864       }
3865    }
3866    return GL_TRUE;
3867 }
3868
3869 static GLboolean
3870 _mesa_texstore_argb2101010_uint(TEXSTORE_PARAMS)
3871 {
3872    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3873
3874    ASSERT(dstFormat == MESA_FORMAT_ARGB2101010_UINT);
3875    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
3876
3877    if (baseInternalFormat == GL_RGBA &&
3878        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
3879                                             srcPacking->SwapBytes)) {
3880       /* simple memcpy path */
3881       memcpy_texture(ctx, dims,
3882                      dstFormat,
3883                      dstRowStride, dstSlices,
3884                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3885                      srcAddr, srcPacking);
3886    }
3887    else {
3888       /* general path */
3889       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
3890                                                      baseInternalFormat,
3891                                                      baseFormat,
3892                                                      srcWidth, srcHeight,
3893                                                      srcDepth, srcFormat,
3894                                                      srcType, srcAddr,
3895                                                      srcPacking);
3896       const GLuint *src = tempImage;
3897       GLint img, row, col;
3898       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3899       if (!tempImage)
3900          return GL_FALSE;
3901       for (img = 0; img < srcDepth; img++) {
3902          GLubyte *dstRow = dstSlices[img];
3903
3904          for (row = 0; row < srcHeight; row++) {
3905             GLuint *dstUI = (GLuint *) dstRow;
3906             if (is_unsigned) {
3907                for (col = 0; col < srcWidth; col++) {
3908                   GLushort a,r,g,b;
3909                   r = MIN2(src[RCOMP], 0x3ff);
3910                   g = MIN2(src[GCOMP], 0x3ff);
3911                   b = MIN2(src[BCOMP], 0x3ff);
3912                   a = MIN2(src[ACOMP], 0x003);
3913                   dstUI[col] = (a << 30) | (r << 20) | (g << 10) | (b);
3914                   src += 4;
3915                }
3916             } else {
3917                for (col = 0; col < srcWidth; col++) {
3918                   GLushort a,r,g,b;
3919                   r = CLAMP((GLint) src[RCOMP], 0, 0x3ff);
3920                   g = CLAMP((GLint) src[GCOMP], 0, 0x3ff);
3921                   b = CLAMP((GLint) src[BCOMP], 0, 0x3ff);
3922                   a = CLAMP((GLint) src[ACOMP], 0, 0x003);
3923                   dstUI[col] = (a << 30) | (r << 20) | (g << 10) | (b);
3924                   src += 4;
3925                }
3926             }
3927             dstRow += dstRowStride;
3928          }
3929       }
3930       free((void *) tempImage);
3931    }
3932    return GL_TRUE;
3933 }
3934
3935 static GLboolean
3936 _mesa_texstore_abgr2101010_uint(TEXSTORE_PARAMS)
3937 {
3938    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
3939
3940    ASSERT(dstFormat == MESA_FORMAT_ABGR2101010_UINT);
3941    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
3942
3943    if (baseInternalFormat == GL_RGBA &&
3944        _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
3945                                             srcPacking->SwapBytes)) {
3946       /* simple memcpy path */
3947       memcpy_texture(ctx, dims,
3948                      dstFormat,
3949                      dstRowStride, dstSlices,
3950                      srcWidth, srcHeight, srcDepth, srcFormat, srcType,
3951                      srcAddr, srcPacking);
3952    }
3953    else {
3954       /* general path */
3955       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
3956                                                      baseInternalFormat,
3957                                                      baseFormat,
3958                                                      srcWidth, srcHeight,
3959                                                      srcDepth, srcFormat,
3960                                                      srcType, srcAddr,
3961                                                      srcPacking);
3962       const GLuint *src = tempImage;
3963       GLint img, row, col;
3964       GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
3965       if (!tempImage)
3966          return GL_FALSE;
3967       for (img = 0; img < srcDepth; img++) {
3968          GLubyte *dstRow = dstSlices[img];
3969
3970          for (row = 0; row < srcHeight; row++) {
3971             GLuint *dstUI = (GLuint *) dstRow;
3972             if (is_unsigned) {
3973                for (col = 0; col < srcWidth; col++) {
3974                   GLushort a,r,g,b;
3975                   r = MIN2(src[RCOMP], 0x3ff);
3976                   g = MIN2(src[GCOMP], 0x3ff);
3977                   b = MIN2(src[BCOMP], 0x3ff);
3978                   a = MIN2(src[ACOMP], 0x003);
3979                   dstUI[col] = (a << 30) | (b << 20) | (g << 10) | (r);
3980                   src += 4;
3981                }
3982             } else {
3983                for (col = 0; col < srcWidth; col++) {
3984                   GLushort a,r,g,b;
3985                   r = CLAMP((GLint) src[RCOMP], 0, 0x3ff);
3986                   g = CLAMP((GLint) src[GCOMP], 0, 0x3ff);
3987                   b = CLAMP((GLint) src[BCOMP], 0, 0x3ff);
3988                   a = CLAMP((GLint) src[ACOMP], 0, 0x003);
3989                   dstUI[col] = (a << 30) | (b << 20) | (g << 10) | (r);
3990                   src += 4;
3991                }
3992             }
3993             dstRow += dstRowStride;
3994          }
3995       }
3996       free((void *) tempImage);
3997    }
3998    return GL_TRUE;
3999 }
4000
4001 static GLboolean
4002 _mesa_texstore_null(TEXSTORE_PARAMS)
4003 {
4004    (void) ctx; (void) dims;
4005    (void) baseInternalFormat;
4006    (void) dstFormat;
4007    (void) dstRowStride; (void) dstSlices,
4008    (void) srcWidth; (void) srcHeight; (void) srcDepth;
4009    (void) srcFormat; (void) srcType;
4010    (void) srcAddr;
4011    (void) srcPacking;
4012
4013    /* should never happen */
4014    _mesa_problem(NULL, "_mesa_texstore_null() is called");
4015    return GL_FALSE;
4016 }
4017
4018
4019 /**
4020  * Return the StoreTexImageFunc pointer to store an image in the given format.
4021  */
4022 static StoreTexImageFunc
4023 _mesa_get_texstore_func(gl_format format)
4024 {
4025    static StoreTexImageFunc table[MESA_FORMAT_COUNT];
4026    static GLboolean initialized = GL_FALSE;
4027
4028    if (!initialized) {
4029       table[MESA_FORMAT_NONE] = _mesa_texstore_null;
4030
4031       table[MESA_FORMAT_RGBA8888] = _mesa_texstore_rgba8888;
4032       table[MESA_FORMAT_RGBA8888_REV] = _mesa_texstore_rgba8888;
4033       table[MESA_FORMAT_ARGB8888] = _mesa_texstore_argb8888;
4034       table[MESA_FORMAT_ARGB8888_REV] = _mesa_texstore_argb8888;
4035       table[MESA_FORMAT_RGBX8888] = _mesa_texstore_rgba8888;
4036       table[MESA_FORMAT_RGBX8888_REV] = _mesa_texstore_rgba8888;
4037       table[MESA_FORMAT_XRGB8888] = _mesa_texstore_argb8888;
4038       table[MESA_FORMAT_XRGB8888_REV] = _mesa_texstore_argb8888;
4039       table[MESA_FORMAT_RGB888] = _mesa_texstore_rgb888;
4040       table[MESA_FORMAT_BGR888] = _mesa_texstore_bgr888;
4041       table[MESA_FORMAT_RGB565] = _mesa_texstore_rgb565;
4042       table[MESA_FORMAT_RGB565_REV] = _mesa_texstore_rgb565;
4043       table[MESA_FORMAT_ARGB4444] = _mesa_texstore_argb4444;
4044       table[MESA_FORMAT_ARGB4444_REV] = _mesa_texstore_argb4444;
4045       table[MESA_FORMAT_RGBA5551] = _mesa_texstore_rgba5551;
4046       table[MESA_FORMAT_ARGB1555] = _mesa_texstore_argb1555;
4047       table[MESA_FORMAT_ARGB1555_REV] = _mesa_texstore_argb1555;
4048       table[MESA_FORMAT_AL44] = _mesa_texstore_unorm44;
4049       table[MESA_FORMAT_AL88] = _mesa_texstore_unorm88;
4050       table[MESA_FORMAT_AL88_REV] = _mesa_texstore_unorm88;
4051       table[MESA_FORMAT_AL1616] = _mesa_texstore_unorm1616;
4052       table[MESA_FORMAT_AL1616_REV] = _mesa_texstore_unorm1616;
4053       table[MESA_FORMAT_RGB332] = _mesa_texstore_rgb332;
4054       table[MESA_FORMAT_A8] = _mesa_texstore_unorm8;
4055       table[MESA_FORMAT_A16] = _mesa_texstore_unorm16;
4056       table[MESA_FORMAT_L8] = _mesa_texstore_unorm8;
4057       table[MESA_FORMAT_L16] = _mesa_texstore_unorm16;
4058       table[MESA_FORMAT_I8] = _mesa_texstore_unorm8;
4059       table[MESA_FORMAT_I16] = _mesa_texstore_unorm16;
4060       table[MESA_FORMAT_YCBCR] = _mesa_texstore_ycbcr;
4061       table[MESA_FORMAT_YCBCR_REV] = _mesa_texstore_ycbcr;
4062       table[MESA_FORMAT_R8] = _mesa_texstore_unorm8;
4063       table[MESA_FORMAT_GR88] = _mesa_texstore_unorm88;
4064       table[MESA_FORMAT_RG88] = _mesa_texstore_unorm88;
4065       table[MESA_FORMAT_R16] = _mesa_texstore_unorm16;
4066       table[MESA_FORMAT_RG1616] = _mesa_texstore_unorm1616;
4067       table[MESA_FORMAT_RG1616_REV] = _mesa_texstore_unorm1616;
4068       table[MESA_FORMAT_ARGB2101010] = _mesa_texstore_argb2101010;
4069       table[MESA_FORMAT_Z24_S8] = _mesa_texstore_z24_s8;
4070       table[MESA_FORMAT_S8_Z24] = _mesa_texstore_s8_z24;
4071       table[MESA_FORMAT_Z16] = _mesa_texstore_z16;
4072       table[MESA_FORMAT_X8_Z24] = _mesa_texstore_x8_z24;
4073       table[MESA_FORMAT_Z24_X8] = _mesa_texstore_z24_x8;
4074       table[MESA_FORMAT_Z32] = _mesa_texstore_z32;
4075       table[MESA_FORMAT_S8] = _mesa_texstore_s8;
4076       table[MESA_FORMAT_SRGB8] = _mesa_texstore_srgb8;
4077       table[MESA_FORMAT_SRGBA8] = _mesa_texstore_srgba8;
4078       table[MESA_FORMAT_SARGB8] = _mesa_texstore_sargb8;
4079       table[MESA_FORMAT_SL8] = _mesa_texstore_sl8;
4080       table[MESA_FORMAT_SLA8] = _mesa_texstore_sla8;
4081       table[MESA_FORMAT_SRGB_DXT1] = _mesa_texstore_rgb_dxt1;
4082       table[MESA_FORMAT_SRGBA_DXT1] = _mesa_texstore_rgba_dxt1;
4083       table[MESA_FORMAT_SRGBA_DXT3] = _mesa_texstore_rgba_dxt3;
4084       table[MESA_FORMAT_SRGBA_DXT5] = _mesa_texstore_rgba_dxt5;
4085       table[MESA_FORMAT_RGB_FXT1] = _mesa_texstore_rgb_fxt1;
4086       table[MESA_FORMAT_RGBA_FXT1] = _mesa_texstore_rgba_fxt1;
4087       table[MESA_FORMAT_RGB_DXT1] = _mesa_texstore_rgb_dxt1;
4088       table[MESA_FORMAT_RGBA_DXT1] = _mesa_texstore_rgba_dxt1;
4089       table[MESA_FORMAT_RGBA_DXT3] = _mesa_texstore_rgba_dxt3;
4090       table[MESA_FORMAT_RGBA_DXT5] = _mesa_texstore_rgba_dxt5;
4091       table[MESA_FORMAT_RGBA_FLOAT32] = _mesa_texstore_rgba_float32;
4092       table[MESA_FORMAT_RGBA_FLOAT16] = _mesa_texstore_rgba_float16;
4093       table[MESA_FORMAT_RGB_FLOAT32] = _mesa_texstore_rgba_float32;
4094       table[MESA_FORMAT_RGB_FLOAT16] = _mesa_texstore_rgba_float16;
4095       table[MESA_FORMAT_ALPHA_FLOAT32] = _mesa_texstore_rgba_float32;
4096       table[MESA_FORMAT_ALPHA_FLOAT16] = _mesa_texstore_rgba_float16;
4097       table[MESA_FORMAT_LUMINANCE_FLOAT32] = _mesa_texstore_rgba_float32;
4098       table[MESA_FORMAT_LUMINANCE_FLOAT16] = _mesa_texstore_rgba_float16;
4099       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = _mesa_texstore_rgba_float32;
4100       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = _mesa_texstore_rgba_float16;
4101       table[MESA_FORMAT_INTENSITY_FLOAT32] = _mesa_texstore_rgba_float32;
4102       table[MESA_FORMAT_INTENSITY_FLOAT16] = _mesa_texstore_rgba_float16;
4103       table[MESA_FORMAT_R_FLOAT32] = _mesa_texstore_rgba_float32;
4104       table[MESA_FORMAT_R_FLOAT16] = _mesa_texstore_rgba_float16;
4105       table[MESA_FORMAT_RG_FLOAT32] = _mesa_texstore_rgba_float32;
4106       table[MESA_FORMAT_RG_FLOAT16] = _mesa_texstore_rgba_float16;
4107       table[MESA_FORMAT_DUDV8] = _mesa_texstore_dudv8;
4108       table[MESA_FORMAT_SIGNED_R8] = _mesa_texstore_snorm8;
4109       table[MESA_FORMAT_SIGNED_RG88_REV] = _mesa_texstore_snorm88;
4110       table[MESA_FORMAT_SIGNED_RGBX8888] = _mesa_texstore_signed_rgbx8888;
4111       table[MESA_FORMAT_SIGNED_RGBA8888] = _mesa_texstore_signed_rgba8888;
4112       table[MESA_FORMAT_SIGNED_RGBA8888_REV] = _mesa_texstore_signed_rgba8888;
4113       table[MESA_FORMAT_SIGNED_R16] = _mesa_texstore_snorm16;
4114       table[MESA_FORMAT_SIGNED_GR1616] = _mesa_texstore_snorm1616;
4115       table[MESA_FORMAT_SIGNED_RGB_16] = _mesa_texstore_signed_rgba_16;
4116       table[MESA_FORMAT_SIGNED_RGBA_16] = _mesa_texstore_signed_rgba_16;
4117       table[MESA_FORMAT_RGBA_16] = _mesa_texstore_rgba_16;
4118       table[MESA_FORMAT_RED_RGTC1] = _mesa_texstore_red_rgtc1;
4119       table[MESA_FORMAT_SIGNED_RED_RGTC1] = _mesa_texstore_signed_red_rgtc1;
4120       table[MESA_FORMAT_RG_RGTC2] = _mesa_texstore_rg_rgtc2;
4121       table[MESA_FORMAT_SIGNED_RG_RGTC2] = _mesa_texstore_signed_rg_rgtc2;
4122       table[MESA_FORMAT_L_LATC1] = _mesa_texstore_red_rgtc1;
4123       table[MESA_FORMAT_SIGNED_L_LATC1] = _mesa_texstore_signed_red_rgtc1;
4124       table[MESA_FORMAT_LA_LATC2] = _mesa_texstore_rg_rgtc2;
4125       table[MESA_FORMAT_SIGNED_LA_LATC2] = _mesa_texstore_signed_rg_rgtc2;
4126       table[MESA_FORMAT_ETC1_RGB8] = _mesa_texstore_etc1_rgb8;
4127       table[MESA_FORMAT_ETC2_RGB8] = _mesa_texstore_etc2_rgb8;
4128       /* table[MESA_FORMAT_ETC2_SRGB8] = _mesa_texstore_etc2_srgb8; -- not implemented yet */
4129       /* table[MESA_FORMAT_ETC2_RGBA8_EAC] = _mesa_texstore_etc2_rgba8_eac; -- not implemented yet */
4130       /* table[MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC] = _mesa_texstore_etc2_srgb8_alpha8_eac; -- not implemented yet */
4131       /* table[MESA_FORMAT_ETC2_R11_EAC] = _mesa_texstore_etc2_r11_eac; -- not implemented yet */
4132       /* table[MESA_FORMAT_ETC2_RG11_EAC] = _mesa_texstore_etc2_rg11_eac; -- not implemented yet */
4133       /* table[MESA_FORMAT_ETC2_SIGNED_R11_EAC] = _mesa_texstore_etc2_signed_r11_eac; -- not implemented yet */
4134       /* table[MESA_FORMAT_ETC2_SIGNED_RG11_EAC] = _mesa_texstore_etc2_signed_rg11_eac; -- not implemented yet */
4135       /* table[MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1] =
4136          _mesa_texstore_etc2_rgb8_punchthrough_alpha1; -- not implemented yet */
4137       /* table[MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1] =
4138          _mesa_texstore_etc2_srgb8_punchthrough_alpha1; -- not implemented yet */
4139       table[MESA_FORMAT_SIGNED_A8] = _mesa_texstore_snorm8;
4140       table[MESA_FORMAT_SIGNED_L8] = _mesa_texstore_snorm8;
4141       table[MESA_FORMAT_SIGNED_AL88] = _mesa_texstore_snorm88;
4142       table[MESA_FORMAT_SIGNED_I8] = _mesa_texstore_snorm8;
4143       table[MESA_FORMAT_SIGNED_A16] = _mesa_texstore_snorm16;
4144       table[MESA_FORMAT_SIGNED_L16] = _mesa_texstore_snorm16;
4145       table[MESA_FORMAT_SIGNED_AL1616] = _mesa_texstore_snorm1616;
4146       table[MESA_FORMAT_SIGNED_I16] = _mesa_texstore_snorm16;
4147       table[MESA_FORMAT_RGB9_E5_FLOAT] = _mesa_texstore_rgb9_e5;
4148       table[MESA_FORMAT_R11_G11_B10_FLOAT] = _mesa_texstore_r11_g11_b10f;
4149       table[MESA_FORMAT_Z32_FLOAT] = _mesa_texstore_z32;
4150       table[MESA_FORMAT_Z32_FLOAT_X24S8] = _mesa_texstore_z32f_x24s8;
4151
4152       table[MESA_FORMAT_ALPHA_UINT8] = _mesa_texstore_rgba_uint8;
4153       table[MESA_FORMAT_ALPHA_UINT16] = _mesa_texstore_rgba_uint16;
4154       table[MESA_FORMAT_ALPHA_UINT32] = _mesa_texstore_rgba_uint32;
4155       table[MESA_FORMAT_ALPHA_INT8] = _mesa_texstore_rgba_int8;
4156       table[MESA_FORMAT_ALPHA_INT16] = _mesa_texstore_rgba_int16;
4157       table[MESA_FORMAT_ALPHA_INT32] = _mesa_texstore_rgba_int32;
4158
4159       table[MESA_FORMAT_INTENSITY_UINT8] = _mesa_texstore_rgba_uint8;
4160       table[MESA_FORMAT_INTENSITY_UINT16] = _mesa_texstore_rgba_uint16;
4161       table[MESA_FORMAT_INTENSITY_UINT32] = _mesa_texstore_rgba_uint32;
4162       table[MESA_FORMAT_INTENSITY_INT8] = _mesa_texstore_rgba_int8;
4163       table[MESA_FORMAT_INTENSITY_INT16] = _mesa_texstore_rgba_int16;
4164       table[MESA_FORMAT_INTENSITY_INT32] = _mesa_texstore_rgba_int32;
4165
4166       table[MESA_FORMAT_LUMINANCE_UINT8] = _mesa_texstore_rgba_uint8;
4167       table[MESA_FORMAT_LUMINANCE_UINT16] = _mesa_texstore_rgba_uint16;
4168       table[MESA_FORMAT_LUMINANCE_UINT32] = _mesa_texstore_rgba_uint32;
4169       table[MESA_FORMAT_LUMINANCE_INT8] = _mesa_texstore_rgba_int8;
4170       table[MESA_FORMAT_LUMINANCE_INT16] = _mesa_texstore_rgba_int16;
4171       table[MESA_FORMAT_LUMINANCE_INT32] = _mesa_texstore_rgba_int32;
4172
4173       table[MESA_FORMAT_LUMINANCE_ALPHA_UINT8] = _mesa_texstore_rgba_uint8;
4174       table[MESA_FORMAT_LUMINANCE_ALPHA_UINT16] = _mesa_texstore_rgba_uint16;
4175       table[MESA_FORMAT_LUMINANCE_ALPHA_UINT32] = _mesa_texstore_rgba_uint32;
4176       table[MESA_FORMAT_LUMINANCE_ALPHA_INT8] = _mesa_texstore_rgba_int8;
4177       table[MESA_FORMAT_LUMINANCE_ALPHA_INT16] = _mesa_texstore_rgba_int16;
4178       table[MESA_FORMAT_LUMINANCE_ALPHA_INT32] = _mesa_texstore_rgba_int32;
4179
4180       table[MESA_FORMAT_R_INT8] = _mesa_texstore_rgba_int8;
4181       table[MESA_FORMAT_RG_INT8] = _mesa_texstore_rgba_int8;
4182       table[MESA_FORMAT_RGB_INT8] = _mesa_texstore_rgba_int8;
4183       table[MESA_FORMAT_RGBA_INT8] = _mesa_texstore_rgba_int8;
4184       table[MESA_FORMAT_R_INT16] = _mesa_texstore_rgba_int16;
4185       table[MESA_FORMAT_RG_INT16] = _mesa_texstore_rgba_int16;
4186       table[MESA_FORMAT_RGB_INT16] = _mesa_texstore_rgba_int16;
4187       table[MESA_FORMAT_RGBA_INT16] = _mesa_texstore_rgba_int16;
4188       table[MESA_FORMAT_R_INT32] = _mesa_texstore_rgba_int32;
4189       table[MESA_FORMAT_RG_INT32] = _mesa_texstore_rgba_int32;
4190       table[MESA_FORMAT_RGB_INT32] = _mesa_texstore_rgba_int32;
4191       table[MESA_FORMAT_RGBA_INT32] = _mesa_texstore_rgba_int32;
4192
4193       table[MESA_FORMAT_R_UINT8] = _mesa_texstore_rgba_uint8;
4194       table[MESA_FORMAT_RG_UINT8] = _mesa_texstore_rgba_uint8;
4195       table[MESA_FORMAT_RGB_UINT8] = _mesa_texstore_rgba_uint8;
4196       table[MESA_FORMAT_RGBA_UINT8] = _mesa_texstore_rgba_uint8;
4197       table[MESA_FORMAT_R_UINT16] = _mesa_texstore_rgba_uint16;
4198       table[MESA_FORMAT_RG_UINT16] = _mesa_texstore_rgba_uint16;
4199       table[MESA_FORMAT_RGB_UINT16] = _mesa_texstore_rgba_uint16;
4200       table[MESA_FORMAT_RGBA_UINT16] = _mesa_texstore_rgba_uint16;
4201       table[MESA_FORMAT_R_UINT32] = _mesa_texstore_rgba_uint32;
4202       table[MESA_FORMAT_RG_UINT32] = _mesa_texstore_rgba_uint32;
4203       table[MESA_FORMAT_RGB_UINT32] = _mesa_texstore_rgba_uint32;
4204       table[MESA_FORMAT_RGBA_UINT32] = _mesa_texstore_rgba_uint32;
4205
4206       table[MESA_FORMAT_ARGB2101010_UINT] = _mesa_texstore_argb2101010_uint;
4207       table[MESA_FORMAT_ABGR2101010_UINT] = _mesa_texstore_abgr2101010_uint;
4208       initialized = GL_TRUE;
4209    }
4210
4211    ASSERT(table[format]);
4212    return table[format];
4213 }
4214
4215
4216 /**
4217  * Store user data into texture memory.
4218  * Called via glTex[Sub]Image1/2/3D()
4219  */
4220 GLboolean
4221 _mesa_texstore(TEXSTORE_PARAMS)
4222 {
4223    StoreTexImageFunc storeImage;
4224    GLboolean success;
4225
4226    storeImage = _mesa_get_texstore_func(dstFormat);
4227
4228    success = storeImage(ctx, dims, baseInternalFormat,
4229                         dstFormat,
4230                         dstRowStride, dstSlices,
4231                         srcWidth, srcHeight, srcDepth,
4232                         srcFormat, srcType, srcAddr, srcPacking);
4233    return success;
4234 }
4235
4236
4237 /**
4238  * Normally, we'll only _write_ texel data to a texture when we map it.
4239  * But if the user is providing depth or stencil values and the texture
4240  * image is a combined depth/stencil format, we'll actually read from
4241  * the texture buffer too (in order to insert the depth or stencil values.
4242  * \param userFormat  the user-provided image format
4243  * \param texFormat  the destination texture format
4244  */
4245 static GLbitfield
4246 get_read_write_mode(GLenum userFormat, gl_format texFormat)
4247 {
4248    if ((userFormat == GL_STENCIL_INDEX || userFormat == GL_DEPTH_COMPONENT)
4249        && _mesa_get_format_base_format(texFormat) == GL_DEPTH_STENCIL)
4250       return GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
4251    else
4252       return GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
4253 }
4254
4255
4256 /**
4257  * Helper function for storing 1D, 2D, 3D whole and subimages into texture
4258  * memory.
4259  * The source of the image data may be user memory or a PBO.  In the later
4260  * case, we'll map the PBO, copy from it, then unmap it.
4261  */
4262 static void
4263 store_texsubimage(struct gl_context *ctx,
4264                   struct gl_texture_image *texImage,
4265                   GLint xoffset, GLint yoffset, GLint zoffset,
4266                   GLint width, GLint height, GLint depth,
4267                   GLenum format, GLenum type, const GLvoid *pixels,
4268                   const struct gl_pixelstore_attrib *packing,
4269                   const char *caller)
4270
4271 {
4272    const GLbitfield mapMode = get_read_write_mode(format, texImage->TexFormat);
4273    const GLenum target = texImage->TexObject->Target;
4274    GLboolean success = GL_FALSE;
4275    GLuint dims, slice, numSlices = 1, sliceOffset = 0;
4276    GLint srcImageStride = 0;
4277    const GLubyte *src;
4278
4279    assert(xoffset + width <= texImage->Width);
4280    assert(yoffset + height <= texImage->Height);
4281    assert(zoffset + depth <= texImage->Depth);
4282
4283    switch (target) {
4284    case GL_TEXTURE_1D:
4285       dims = 1;
4286       break;
4287    case GL_TEXTURE_2D_ARRAY:
4288    case GL_TEXTURE_CUBE_MAP_ARRAY:
4289    case GL_TEXTURE_3D:
4290       dims = 3;
4291       break;
4292    default:
4293       dims = 2;
4294    }
4295
4296    /* get pointer to src pixels (may be in a pbo which we'll map here) */
4297    src = (const GLubyte *)
4298       _mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
4299                                   format, type, pixels, packing, caller);
4300    if (!src)
4301       return;
4302
4303    /* compute slice info (and do some sanity checks) */
4304    switch (target) {
4305    case GL_TEXTURE_2D:
4306    case GL_TEXTURE_RECTANGLE:
4307    case GL_TEXTURE_CUBE_MAP:
4308       /* one image slice, nothing special needs to be done */
4309       break;
4310    case GL_TEXTURE_1D:
4311       assert(height == 1);
4312       assert(depth == 1);
4313       assert(yoffset == 0);
4314       assert(zoffset == 0);
4315       break;
4316    case GL_TEXTURE_1D_ARRAY:
4317       assert(depth == 1);
4318       assert(zoffset == 0);
4319       numSlices = height;
4320       sliceOffset = yoffset;
4321       height = 1;
4322       yoffset = 0;
4323       srcImageStride = _mesa_image_row_stride(packing, width, format, type);
4324       break;
4325    case GL_TEXTURE_2D_ARRAY:
4326       numSlices = depth;
4327       sliceOffset = zoffset;
4328       depth = 1;
4329       zoffset = 0;
4330       srcImageStride = _mesa_image_image_stride(packing, width, height,
4331                                                 format, type);
4332       break;
4333    case GL_TEXTURE_3D:
4334       /* we'll store 3D images as a series of slices */
4335       numSlices = depth;
4336       sliceOffset = zoffset;
4337       srcImageStride = _mesa_image_image_stride(packing, width, height,
4338                                                 format, type);
4339       break;
4340    case GL_TEXTURE_CUBE_MAP_ARRAY:
4341       numSlices = depth;
4342       sliceOffset = zoffset;
4343       srcImageStride = _mesa_image_image_stride(packing, width, height,
4344                                                 format, type);
4345       break;
4346    default:
4347       _mesa_warning(ctx, "Unexpected target 0x%x in store_texsubimage()", target);
4348       return;
4349    }
4350
4351    assert(numSlices == 1 || srcImageStride != 0);
4352
4353    for (slice = 0; slice < numSlices; slice++) {
4354       GLubyte *dstMap;
4355       GLint dstRowStride;
4356
4357       ctx->Driver.MapTextureImage(ctx, texImage,
4358                                   slice + sliceOffset,
4359                                   xoffset, yoffset, width, height,
4360                                   mapMode, &dstMap, &dstRowStride);
4361       if (dstMap) {
4362          /* Note: we're only storing a 2D (or 1D) slice at a time but we need
4363           * to pass the right 'dims' value so that GL_UNPACK_SKIP_IMAGES is
4364           * used for 3D images.
4365           */
4366          success = _mesa_texstore(ctx, dims, texImage->_BaseFormat,
4367                                   texImage->TexFormat,
4368                                   dstRowStride,
4369                                   &dstMap,
4370                                   width, height, 1,  /* w, h, d */
4371                                   format, type, src, packing);
4372
4373          ctx->Driver.UnmapTextureImage(ctx, texImage, slice + sliceOffset);
4374       }
4375
4376       src += srcImageStride;
4377
4378       if (!success)
4379          break;
4380    }
4381
4382    if (!success)
4383       _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
4384
4385    _mesa_unmap_teximage_pbo(ctx, packing);
4386 }
4387
4388
4389
4390 /**
4391  * Fallback code for ctx->Driver.TexImage().
4392  * Basically, allocate storage for the texture image, then copy the
4393  * user's image into it.
4394  */
4395 void
4396 _mesa_store_teximage(struct gl_context *ctx,
4397                      GLuint dims,
4398                      struct gl_texture_image *texImage,
4399                      GLenum format, GLenum type, const GLvoid *pixels,
4400                      const struct gl_pixelstore_attrib *packing)
4401 {
4402    assert(dims == 1 || dims == 2 || dims == 3);
4403
4404    if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
4405       return;
4406
4407    /* allocate storage for texture data */
4408    if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
4409       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
4410       return;
4411    }
4412
4413    store_texsubimage(ctx, texImage,
4414                      0, 0, 0, texImage->Width, texImage->Height, texImage->Depth,
4415                      format, type, pixels, packing, "glTexImage");
4416 }
4417
4418
4419 /*
4420  * Fallback for Driver.TexSubImage().
4421  */
4422 void
4423 _mesa_store_texsubimage(struct gl_context *ctx, GLuint dims,
4424                         struct gl_texture_image *texImage,
4425                         GLint xoffset, GLint yoffset, GLint zoffset,
4426                         GLint width, GLint height, GLint depth,
4427                         GLenum format, GLenum type, const void *pixels,
4428                         const struct gl_pixelstore_attrib *packing)
4429 {
4430    store_texsubimage(ctx, texImage,
4431                      xoffset, yoffset, zoffset, width, height, depth,
4432                      format, type, pixels, packing, "glTexSubImage");
4433 }
4434
4435
4436 /**
4437  * Fallback for Driver.CompressedTexImage()
4438  */
4439 void
4440 _mesa_store_compressed_teximage(struct gl_context *ctx, GLuint dims,
4441                                 struct gl_texture_image *texImage,
4442                                 GLsizei imageSize, const GLvoid *data)
4443 {
4444    /* only 2D compressed images are supported at this time */
4445    if (dims != 2) {
4446       _mesa_problem(ctx, "Unexpected glCompressedTexImage1D/3D call");
4447       return;
4448    }
4449
4450    /* This is pretty simple, because unlike the general texstore path we don't
4451     * have to worry about the usual image unpacking or image transfer
4452     * operations.
4453     */
4454    ASSERT(texImage);
4455    ASSERT(texImage->Width > 0);
4456    ASSERT(texImage->Height > 0);
4457    ASSERT(texImage->Depth == 1);
4458
4459    /* allocate storage for texture data */
4460    if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
4461       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
4462       return;
4463    }
4464
4465    _mesa_store_compressed_texsubimage(ctx, dims, texImage,
4466                                       0, 0, 0,
4467                                       texImage->Width, texImage->Height, texImage->Depth,
4468                                       texImage->TexFormat,
4469                                       imageSize, data);
4470 }
4471
4472
4473 /**
4474  * Fallback for Driver.CompressedTexSubImage()
4475  */
4476 void
4477 _mesa_store_compressed_texsubimage(struct gl_context *ctx, GLuint dims,
4478                                    struct gl_texture_image *texImage,
4479                                    GLint xoffset, GLint yoffset, GLint zoffset,
4480                                    GLsizei width, GLsizei height, GLsizei depth,
4481                                    GLenum format,
4482                                    GLsizei imageSize, const GLvoid *data)
4483 {
4484    GLint bytesPerRow, dstRowStride, srcRowStride;
4485    GLint i, rows;
4486    GLubyte *dstMap;
4487    const GLubyte *src;
4488    const gl_format texFormat = texImage->TexFormat;
4489    GLuint bw, bh;
4490
4491    if (dims != 2) {
4492       _mesa_problem(ctx, "Unexpected 1D/3D compressed texsubimage call");
4493       return;
4494    }
4495
4496    _mesa_get_format_block_size(texFormat, &bw, &bh);
4497
4498    /* get pointer to src pixels (may be in a pbo which we'll map here) */
4499    data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
4500                                                  &ctx->Unpack,
4501                                                  "glCompressedTexSubImage2D");
4502    if (!data)
4503       return;
4504
4505    srcRowStride = _mesa_format_row_stride(texFormat, width);
4506    src = (const GLubyte *) data;
4507
4508    /* Map dest texture buffer */
4509    ctx->Driver.MapTextureImage(ctx, texImage, 0,
4510                                xoffset, yoffset, width, height,
4511                                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
4512                                &dstMap, &dstRowStride);
4513
4514    if (dstMap) {
4515       bytesPerRow = srcRowStride;  /* bytes per row of blocks */
4516       rows = (height + bh - 1) / bh;  /* rows in blocks */
4517
4518       /* copy rows of blocks */
4519       for (i = 0; i < rows; i++) {
4520          memcpy(dstMap, src, bytesPerRow);
4521          dstMap += dstRowStride;
4522          src += srcRowStride;
4523       }
4524
4525       ctx->Driver.UnmapTextureImage(ctx, texImage, 0);
4526    }
4527    else {
4528       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2D");
4529    }
4530
4531    _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
4532 }