src/mesa/state_tracker/st_cb_texture.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * 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
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "main/mfeatures.h"
  29 #include "main/bufferobj.h"
  30 #include "main/enums.h"
  31 #include "main/fbobject.h"
  32 #include "main/formats.h"
  33 #include "main/image.h"
  34 #include "main/imports.h"
  35 #include "main/macros.h"
  36 #include "main/mipmap.h"
  37 #include "main/pack.h"
  38 #include "main/pbo.h"
  39 #include "main/pixeltransfer.h"
  40 #include "main/texcompress.h"
  41 #include "main/texgetimage.h"
  42 #include "main/teximage.h"
  43 #include "main/texobj.h"
  44 #include "main/texstore.h"
  45
  46 #include "state_tracker/st_debug.h"
  47 #include "state_tracker/st_context.h"
  48 #include "state_tracker/st_cb_fbo.h"
  49 #include "state_tracker/st_cb_flush.h"
  50 #include "state_tracker/st_cb_texture.h"
  51 #include "state_tracker/st_format.h"
  52 #include "state_tracker/st_texture.h"
  53 #include "state_tracker/st_gen_mipmap.h"
  54 #include "state_tracker/st_atom.h"
  55
  56 #include "pipe/p_context.h"
  57 #include "pipe/p_defines.h"
  58 #include "util/u_inlines.h"
  59 #include "pipe/p_shader_tokens.h"
  60 #include "util/u_tile.h"
  61 #include "util/u_blit.h"
  62 #include "util/u_format.h"
  63 #include "util/u_surface.h"
  64 #include "util/u_sampler.h"
  65 #include "util/u_math.h"
  66 #include "util/u_box.h"
  67
  68 #define DBG if (0) printf
  69
  70
  71 static enum pipe_texture_target
  72 gl_target_to_pipe(GLenum target)
  73 {
  74    switch (target) {
  75    case GL_TEXTURE_1D:
  76       return PIPE_TEXTURE_1D;
  77    case GL_TEXTURE_2D:
  78    case GL_TEXTURE_EXTERNAL_OES:
  79       return PIPE_TEXTURE_2D;
  80    case GL_TEXTURE_RECTANGLE_NV:
  81       return PIPE_TEXTURE_RECT;
  82    case GL_TEXTURE_3D:
  83       return PIPE_TEXTURE_3D;
  84    case GL_TEXTURE_CUBE_MAP_ARB:
  85       return PIPE_TEXTURE_CUBE;
  86    case GL_TEXTURE_1D_ARRAY_EXT:
  87       return PIPE_TEXTURE_1D_ARRAY;
  88    case GL_TEXTURE_2D_ARRAY_EXT:
  89       return PIPE_TEXTURE_2D_ARRAY;
  90    case GL_TEXTURE_BUFFER:
  91       return PIPE_BUFFER;
  92    default:
  93       assert(0);
  94       return 0;
  95    }
  96 }
  97
  98
  99 /** called via ctx->Driver.NewTextureImage() */
 100 static struct gl_texture_image *
 101 st_NewTextureImage(struct gl_context * ctx)
 102 {
 103    DBG("%s\n", __FUNCTION__);
 104    (void) ctx;
 105    return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image);
 106 }
 107
 108
 109 /** called via ctx->Driver.DeleteTextureImage() */
 110 static void
 111 st_DeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img)
 112 {
 113    /* nothing special (yet) for st_texture_image */
 114    _mesa_delete_texture_image(ctx, img);
 115 }
 116
 117
 118 /** called via ctx->Driver.NewTextureObject() */
 119 static struct gl_texture_object *
 120 st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target)
 121 {
 122    struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object);
 123
 124    DBG("%s\n", __FUNCTION__);
 125    _mesa_initialize_texture_object(&obj->base, name, target);
 126
 127    return &obj->base;
 128 }
 129
 130 /** called via ctx->Driver.DeleteTextureObject() */
 131 static void
 132 st_DeleteTextureObject(struct gl_context *ctx,
 133                        struct gl_texture_object *texObj)
 134 {
 135    struct st_context *st = st_context(ctx);
 136    struct st_texture_object *stObj = st_texture_object(texObj);
 137    if (stObj->pt)
 138       pipe_resource_reference(&stObj->pt, NULL);
 139    if (stObj->sampler_view) {
 140       pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
 141    }
 142    _mesa_delete_texture_object(ctx, texObj);
 143 }
 144
 145
 146 /** called via ctx->Driver.FreeTextureImageBuffer() */
 147 static void
 148 st_FreeTextureImageBuffer(struct gl_context *ctx,
 149                           struct gl_texture_image *texImage)
 150 {
 151    struct st_texture_image *stImage = st_texture_image(texImage);
 152
 153    DBG("%s\n", __FUNCTION__);
 154
 155    if (stImage->pt) {
 156       pipe_resource_reference(&stImage->pt, NULL);
 157    }
 158
 159    if (stImage->TexData) {
 160       _mesa_align_free(stImage->TexData);
 161       stImage->TexData = NULL;
 162    }
 163 }
 164
 165
 166 /** called via ctx->Driver.MapTextureImage() */
 167 static void
 168 st_MapTextureImage(struct gl_context *ctx,
 169                    struct gl_texture_image *texImage,
 170                    GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h,
 171                    GLbitfield mode,
 172                    GLubyte **mapOut, GLint *rowStrideOut)
 173 {
 174    struct st_context *st = st_context(ctx);
 175    struct st_texture_image *stImage = st_texture_image(texImage);
 176    unsigned pipeMode;
 177    GLubyte *map;
 178
 179    pipeMode = 0x0;
 180    if (mode & GL_MAP_READ_BIT)
 181       pipeMode |= PIPE_TRANSFER_READ;
 182    if (mode & GL_MAP_WRITE_BIT)
 183       pipeMode |= PIPE_TRANSFER_WRITE;
 184    if (mode & GL_MAP_INVALIDATE_RANGE_BIT)
 185       pipeMode |= PIPE_TRANSFER_DISCARD_RANGE;
 186
 187    map = st_texture_image_map(st, stImage, slice, pipeMode, x, y, w, h);
 188    if (map) {
 189       *mapOut = map;
 190       *rowStrideOut = stImage->transfer->stride;
 191    }
 192    else {
 193       *mapOut = NULL;
 194       *rowStrideOut = 0;
 195    }
 196 }
 197
 198
 199 /** called via ctx->Driver.UnmapTextureImage() */
 200 static void
 201 st_UnmapTextureImage(struct gl_context *ctx,
 202                      struct gl_texture_image *texImage,
 203                      GLuint slice)
 204 {
 205    struct st_context *st = st_context(ctx);
 206    struct st_texture_image *stImage  = st_texture_image(texImage);
 207    st_texture_image_unmap(st, stImage);
 208 }
 209
 210
 211 /**
 212  * Return default texture resource binding bitmask for the given format.
 213  */
 214 static GLuint
 215 default_bindings(struct st_context *st, enum pipe_format format)
 216 {
 217    struct pipe_screen *screen = st->pipe->screen;
 218    const unsigned target = PIPE_TEXTURE_2D;
 219    unsigned bindings;
 220
 221    if (util_format_is_depth_or_stencil(format))
 222       bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DEPTH_STENCIL;
 223    else
 224       bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
 225
 226    if (screen->is_format_supported(screen, format, target, 0, bindings))
 227       return bindings;
 228    else {
 229       /* Try non-sRGB. */
 230       format = util_format_linear(format);
 231
 232       if (screen->is_format_supported(screen, format, target, 0, bindings))
 233          return bindings;
 234       else
 235          return PIPE_BIND_SAMPLER_VIEW;
 236    }
 237 }
 238
 239
 240 /** Return number of image dimensions (1, 2 or 3) for a texture target. */
 241 static GLuint
 242 get_texture_dims(GLenum target)
 243 {
 244    switch (target) {
 245    case GL_TEXTURE_1D:
 246    case GL_TEXTURE_1D_ARRAY_EXT:
 247    case GL_TEXTURE_BUFFER:
 248       return 1;
 249    case GL_TEXTURE_2D:
 250    case GL_TEXTURE_CUBE_MAP_ARB:
 251    case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
 252    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
 253    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
 254    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
 255    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
 256    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
 257    case GL_TEXTURE_RECTANGLE_NV:
 258    case GL_TEXTURE_2D_ARRAY_EXT:
 259    case GL_TEXTURE_EXTERNAL_OES:
 260       return 2;
 261    case GL_TEXTURE_3D:
 262       return 3;
 263    default:
 264       assert(0 && "invalid texture target in get_texture_dims()");
 265       return 1;
 266    }
 267 }
 268
 269
 270 /**
 271  * Given the size of a mipmap image, try to compute the size of the level=0
 272  * mipmap image.
 273  *
 274  * Note that this isn't always accurate for odd-sized, non-POW textures.
 275  * For example, if level=1 and width=40 then the level=0 width may be 80 or 81.
 276  *
 277  * \return GL_TRUE for success, GL_FALSE for failure
 278  */
 279 static GLboolean
 280 guess_base_level_size(GLenum target,
 281                       GLuint width, GLuint height, GLuint depth, GLuint level,
 282                       GLuint *width0, GLuint *height0, GLuint *depth0)
 283 {
 284    const GLuint dims = get_texture_dims(target);
 285
 286    assert(width >= 1);
 287    assert(height >= 1);
 288    assert(depth >= 1);
 289
 290    if (level > 0) {
 291       /* Depending on the image's size, we can't always make a guess here */
 292       if ((dims >= 1 && width == 1) ||
 293           (dims >= 2 && height == 1) ||
 294           (dims >= 3 && depth == 1)) {
 295          /* we can't determine the image size at level=0 */
 296          return GL_FALSE;
 297       }
 298
 299       /* grow the image size until we hit level = 0 */
 300       while (level > 0) {
 301          if (width > 1)
 302             width <<= 1;
 303          if (height > 1)
 304             height <<= 1;
 305          if (depth > 1)
 306             depth <<= 1;
 307          level--;
 308       }
 309    }
 310
 311    *width0 = width;
 312    *height0 = height;
 313    *depth0 = depth;
 314
 315    return GL_TRUE;
 316 }
 317
 318
 319 /**
 320  * Try to allocate a pipe_resource object for the given st_texture_object.
 321  *
 322  * We use the given st_texture_image as a clue to determine the size of the
 323  * mipmap image at level=0.
 324  *
 325  * \return GL_TRUE for success, GL_FALSE if out of memory.
 326  */
 327 static GLboolean
 328 guess_and_alloc_texture(struct st_context *st,
 329                         struct st_texture_object *stObj,
 330                         const struct st_texture_image *stImage)
 331 {
 332    GLuint lastLevel, width, height, depth;
 333    GLuint bindings;
 334    GLuint ptWidth, ptHeight, ptDepth, ptLayers;
 335    enum pipe_format fmt;
 336
 337    DBG("%s\n", __FUNCTION__);
 338
 339    assert(!stObj->pt);
 340
 341    if (!guess_base_level_size(stObj->base.Target,
 342                               stImage->base.Width2,
 343                               stImage->base.Height2,
 344                               stImage->base.Depth2,
 345                               stImage->base.Level,
 346                               &width, &height, &depth)) {
 347       /* we can't determine the image size at level=0 */
 348       stObj->width0 = stObj->height0 = stObj->depth0 = 0;
 349       /* this is not an out of memory error */
 350       return GL_TRUE;
 351    }
 352
 353    /* At this point, (width x height x depth) is the expected size of
 354     * the level=0 mipmap image.
 355     */
 356
 357    /* Guess a reasonable value for lastLevel.  With OpenGL we have no
 358     * idea how many mipmap levels will be in a texture until we start
 359     * to render with it.  Make an educated guess here but be prepared
 360     * to re-allocating a texture buffer with space for more (or fewer)
 361     * mipmap levels later.
 362     */
 363    if ((stObj->base.Sampler.MinFilter == GL_NEAREST ||
 364         stObj->base.Sampler.MinFilter == GL_LINEAR ||
 365         stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
 366         stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) &&
 367        !stObj->base.GenerateMipmap &&
 368        stImage->base.Level == 0) {
 369       /* only alloc space for a single mipmap level */
 370       lastLevel = 0;
 371    }
 372    else {
 373       /* alloc space for a full mipmap */
 374       GLuint l2width = util_logbase2(width);
 375       GLuint l2height = util_logbase2(height);
 376       GLuint l2depth = util_logbase2(depth);
 377       lastLevel = MAX2(MAX2(l2width, l2height), l2depth);
 378    }
 379
 380    /* Save the level=0 dimensions */
 381    stObj->width0 = width;
 382    stObj->height0 = height;
 383    stObj->depth0 = depth;
 384
 385    fmt = st_mesa_format_to_pipe_format(stImage->base.TexFormat);
 386
 387    bindings = default_bindings(st, fmt);
 388
 389    st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
 390                                    width, height, depth,
 391                                    &ptWidth, &ptHeight, &ptDepth, &ptLayers);
 392
 393    stObj->pt = st_texture_create(st,
 394                                  gl_target_to_pipe(stObj->base.Target),
 395                                  fmt,
 396                                  lastLevel,
 397                                  ptWidth,
 398                                  ptHeight,
 399                                  ptDepth,
 400                                  ptLayers,
 401                                  bindings);
 402
 403    stObj->lastLevel = lastLevel;
 404
 405    DBG("%s returning %d\n", __FUNCTION__, (stObj->pt != NULL));
 406
 407    return stObj->pt != NULL;
 408 }
 409
 410
 411 /**
 412  * Called via ctx->Driver.AllocTextureImageBuffer().
 413  * If the texture object/buffer already has space for the indicated image,
 414  * we're done.  Otherwise, allocate memory for the new texture image.
 415  */
 416 static GLboolean
 417 st_AllocTextureImageBuffer(struct gl_context *ctx,
 418                            struct gl_texture_image *texImage)
 419 {
 420    struct st_context *st = st_context(ctx);
 421    struct st_texture_image *stImage = st_texture_image(texImage);
 422    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
 423    const GLuint level = texImage->Level;
 424    GLuint width = texImage->Width;
 425    GLuint height = texImage->Height;
 426    GLuint depth = texImage->Depth;
 427
 428    DBG("%s\n", __FUNCTION__);
 429
 430    assert(!stImage->TexData);
 431    assert(!stImage->pt); /* xxx this might be wrong */
 432
 433    /* Look if the parent texture object has space for this image */
 434    if (stObj->pt &&
 435        level <= stObj->pt->last_level &&
 436        st_texture_match_image(stObj->pt, texImage)) {
 437       /* this image will fit in the existing texture object's memory */
 438       pipe_resource_reference(&stImage->pt, stObj->pt);
 439       return GL_TRUE;
 440    }
 441
 442    /* The parent texture object does not have space for this image */
 443
 444    pipe_resource_reference(&stObj->pt, NULL);
 445    pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
 446
 447    if (!guess_and_alloc_texture(st, stObj, stImage)) {
 448       /* Probably out of memory.
 449        * Try flushing any pending rendering, then retry.
 450        */
 451       st_finish(st);
 452       if (!guess_and_alloc_texture(st, stObj, stImage)) {
 453          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
 454          return GL_FALSE;
 455       }
 456    }
 457
 458    if (stObj->pt &&
 459        st_texture_match_image(stObj->pt, texImage)) {
 460       /* The image will live in the object's mipmap memory */
 461       pipe_resource_reference(&stImage->pt, stObj->pt);
 462       assert(stImage->pt);
 463       return GL_TRUE;
 464    }
 465    else {
 466       /* Create a new, temporary texture/resource/buffer to hold this
 467        * one texture image.  Note that when we later access this image
 468        * (either for mapping or copying) we'll want to always specify
 469        * mipmap level=0, even if the image represents some other mipmap
 470        * level.
 471        */
 472       enum pipe_format format =
 473          st_mesa_format_to_pipe_format(texImage->TexFormat);
 474       GLuint bindings = default_bindings(st, format);
 475       GLuint ptWidth, ptHeight, ptDepth, ptLayers;
 476
 477       st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
 478                                       width, height, depth,
 479                                       &ptWidth, &ptHeight, &ptDepth, &ptLayers);
 480
 481       stImage->pt = st_texture_create(st,
 482                                       gl_target_to_pipe(stObj->base.Target),
 483                                       format,
 484                                       0, /* lastLevel */
 485                                       ptWidth,
 486                                       ptHeight,
 487                                       ptDepth,
 488                                       ptLayers,
 489                                       bindings);
 490       return stImage->pt != NULL;
 491    }
 492 }
 493
 494
 495 /**
 496  * Preparation prior to glTexImage.  Basically check the 'surface_based'
 497  * field and switch to a "normal" tex image if necessary.
 498  */
 499 static void
 500 prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage,
 501               GLenum format, GLenum type)
 502 {
 503    struct gl_texture_object *texObj = texImage->TexObject;
 504    struct st_texture_object *stObj = st_texture_object(texObj);
 505
 506    /* switch to "normal" */
 507    if (stObj->surface_based) {
 508       const GLenum target = texObj->Target;
 509       const GLuint level = texImage->Level;
 510       gl_format texFormat;
 511
 512       _mesa_clear_texture_object(ctx, texObj);
 513       pipe_resource_reference(&stObj->pt, NULL);
 514
 515       /* oops, need to init this image again */
 516       texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
 517                                               texImage->InternalFormat, format,
 518                                               type);
 519
 520       _mesa_init_teximage_fields(ctx, texImage,
 521                                  texImage->Width, texImage->Height,
 522                                  texImage->Depth, texImage->Border,
 523                                  texImage->InternalFormat, texFormat);
 524
 525       stObj->surface_based = GL_FALSE;
 526    }
 527 }
 528
 529
 530 static void
 531 st_TexImage(struct gl_context * ctx, GLuint dims,
 532             struct gl_texture_image *texImage,
 533             GLenum format, GLenum type, const void *pixels,
 534             const struct gl_pixelstore_attrib *unpack)
 535 {
 536    prep_teximage(ctx, texImage, format, type);
 537    _mesa_store_teximage(ctx, dims, texImage, format, type, pixels, unpack);
 538 }
 539
 540
 541 static void
 542 st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
 543                       struct gl_texture_image *texImage,
 544                       GLint internalFormat,
 545                       GLint width, GLint height, GLint border, GLint depth,
 546                       GLsizei imageSize, const GLvoid *data)
 547 {
 548    prep_teximage(ctx, texImage, GL_NONE, GL_NONE);
 549    _mesa_store_compressed_teximage(ctx, dims, texImage, internalFormat, width,
 550                                    height, depth, border, imageSize, data);
 551 }
 552
 553
 554
 555 /**
 556  * glGetTexImage() helper: decompress a compressed texture by rendering
 557  * a textured quad.  Store the results in the user's buffer.
 558  */
 559 static void
 560 decompress_with_blit(struct gl_context * ctx,
 561                      GLenum format, GLenum type, GLvoid *pixels,
 562                      struct gl_texture_image *texImage)
 563 {
 564    struct st_context *st = st_context(ctx);
 565    struct pipe_context *pipe = st->pipe;
 566    struct st_texture_image *stImage = st_texture_image(texImage);
 567    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
 568    struct pipe_sampler_view *src_view;
 569    const GLuint width = texImage->Width;
 570    const GLuint height = texImage->Height;
 571    struct pipe_surface *dst_surface;
 572    struct pipe_resource *dst_texture;
 573    struct pipe_transfer *tex_xfer;
 574    unsigned bind = (PIPE_BIND_RENDER_TARGET | /* util_blit may choose to render */
 575                     PIPE_BIND_TRANSFER_READ);
 576
 577    /* create temp / dest surface */
 578    if (!util_create_rgba_surface(pipe, width, height, bind,
 579                                  &dst_texture, &dst_surface)) {
 580       _mesa_problem(ctx, "util_create_rgba_surface() failed "
 581                     "in decompress_with_blit()");
 582       return;
 583    }
 584
 585    /* Disable conditional rendering. */
 586    if (st->render_condition) {
 587       pipe->render_condition(pipe, NULL, 0);
 588    }
 589
 590    /* Create sampler view that limits fetches to the source mipmap level */
 591    {
 592       struct pipe_sampler_view sv_temp;
 593
 594       u_sampler_view_default_template(&sv_temp, stObj->pt, stObj->pt->format);
 595
 596       sv_temp.format = util_format_linear(sv_temp.format);
 597       sv_temp.u.tex.first_level =
 598       sv_temp.u.tex.last_level = texImage->Level;
 599
 600       src_view = pipe->create_sampler_view(pipe, stObj->pt, &sv_temp);
 601       if (!src_view) {
 602          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
 603          return;
 604       }
 605    }
 606
 607    /* blit/render/decompress */
 608    util_blit_pixels_tex(st->blit,
 609                         src_view,      /* pipe_resource (src) */
 610                         0, 0,             /* src x0, y0 */
 611                         width, height,    /* src x1, y1 */
 612                         dst_surface,      /* pipe_surface (dst) */
 613                         0, 0,             /* dst x0, y0 */
 614                         width, height,    /* dst x1, y1 */
 615                         0.0,              /* z */
 616                         PIPE_TEX_MIPFILTER_NEAREST);
 617
 618    /* Restore conditional rendering state. */
 619    if (st->render_condition) {
 620       pipe->render_condition(pipe, st->render_condition,
 621                              st->condition_mode);
 622    }
 623
 624    /* map the dst_surface so we can read from it */
 625    tex_xfer = pipe_get_transfer(pipe,
 626                                 dst_texture, 0, 0,
 627                                 PIPE_TRANSFER_READ,
 628                                 0, 0, width, height);
 629
 630    pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
 631
 632    /* copy/pack data into user buffer */
 633    if (_mesa_format_matches_format_and_type(stImage->base.TexFormat,
 634                                             format, type,
 635                                             ctx->Pack.SwapBytes)) {
 636       /* memcpy */
 637       const uint bytesPerRow = width * util_format_get_blocksize(stImage->pt->format);
 638       ubyte *map = pipe_transfer_map(pipe, tex_xfer);
 639       GLuint row;
 640       for (row = 0; row < height; row++) {
 641          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
 642                                               height, format, type, row, 0);
 643          memcpy(dest, map, bytesPerRow);
 644          map += tex_xfer->stride;
 645       }
 646       pipe_transfer_unmap(pipe, tex_xfer);
 647    }
 648    else {
 649       /* format translation via floats */
 650       GLuint row;
 651       enum pipe_format pformat = util_format_linear(dst_texture->format);
 652       GLfloat *rgba;
 653
 654       rgba = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
 655       if (!rgba) {
 656          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage()");
 657          goto end;
 658       }
 659
 660       for (row = 0; row < height; row++) {
 661          const GLbitfield transferOps = 0x0; /* bypassed for glGetTexImage() */
 662          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
 663                                               height, format, type, row, 0);
 664
 665          if (ST_DEBUG & DEBUG_FALLBACK)
 666             debug_printf("%s: fallback format translation\n", __FUNCTION__);
 667
 668          /* get float[4] rgba row from surface */
 669          pipe_get_tile_rgba_format(pipe, tex_xfer, 0, row, width, 1,
 670                                    pformat, rgba);
 671
 672          _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
 673                                     type, dest, &ctx->Pack, transferOps);
 674       }
 675
 676       free(rgba);
 677    }
 678
 679 end:
 680    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 681
 682    pipe->transfer_destroy(pipe, tex_xfer);
 683
 684    /* destroy the temp / dest surface */
 685    util_destroy_rgba_surface(dst_texture, dst_surface);
 686
 687    pipe_sampler_view_release(pipe, &src_view);
 688 }
 689
 690
 691
 692 /**
 693  * Called via ctx->Driver.GetTexImage()
 694  */
 695 static void
 696 st_GetTexImage(struct gl_context * ctx,
 697                GLenum format, GLenum type, GLvoid * pixels,
 698                struct gl_texture_image *texImage)
 699 {
 700    struct st_texture_image *stImage = st_texture_image(texImage);
 701
 702    if (stImage->pt && util_format_is_s3tc(stImage->pt->format)) {
 703       /* Need to decompress the texture.
 704        * We'll do this by rendering a textured quad (which is hopefully
 705        * faster than using the fallback code in texcompress.c).
 706        * Note that we only expect RGBA formats (no Z/depth formats).
 707        */
 708       decompress_with_blit(ctx, format, type, pixels, texImage);
 709    }
 710    else {
 711       _mesa_get_teximage(ctx, format, type, pixels, texImage);
 712    }
 713 }
 714
 715
 716 /**
 717  * Do a CopyTexSubImage operation using a read transfer from the source,
 718  * a write transfer to the destination and get_tile()/put_tile() to access
 719  * the pixels/texels.
 720  *
 721  * Note: srcY=0=TOP of renderbuffer
 722  */
 723 static void
 724 fallback_copy_texsubimage(struct gl_context *ctx,
 725                           struct st_renderbuffer *strb,
 726                           struct st_texture_image *stImage,
 727                           GLenum baseFormat,
 728                           GLint destX, GLint destY, GLint destZ,
 729                           GLint srcX, GLint srcY,
 730                           GLsizei width, GLsizei height)
 731 {
 732    struct st_context *st = st_context(ctx);
 733    struct pipe_context *pipe = st->pipe;
 734    struct pipe_transfer *src_trans;
 735    GLvoid *texDest;
 736    enum pipe_transfer_usage transfer_usage;
 737
 738    if (ST_DEBUG & DEBUG_FALLBACK)
 739       debug_printf("%s: fallback processing\n", __FUNCTION__);
 740
 741    if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
 742       srcY = strb->Base.Height - srcY - height;
 743    }
 744
 745    src_trans = pipe_get_transfer(pipe,
 746                                  strb->texture,
 747                                  strb->rtt_level,
 748                                  strb->rtt_face + strb->rtt_slice,
 749                                  PIPE_TRANSFER_READ,
 750                                  srcX, srcY,
 751                                  width, height);
 752
 753    if ((baseFormat == GL_DEPTH_COMPONENT ||
 754         baseFormat == GL_DEPTH_STENCIL) &&
 755        util_format_is_depth_and_stencil(stImage->pt->format))
 756       transfer_usage = PIPE_TRANSFER_READ_WRITE;
 757    else
 758       transfer_usage = PIPE_TRANSFER_WRITE;
 759
 760    /* XXX this used to ignore destZ param */
 761    texDest = st_texture_image_map(st, stImage, destZ, transfer_usage,
 762                                   destX, destY, width, height);
 763
 764    if (baseFormat == GL_DEPTH_COMPONENT ||
 765        baseFormat == GL_DEPTH_STENCIL) {
 766       const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
 767                                      ctx->Pixel.DepthBias != 0.0F);
 768       GLint row, yStep;
 769       uint *data;
 770
 771       /* determine bottom-to-top vs. top-to-bottom order for src buffer */
 772       if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
 773          srcY = height - 1;
 774          yStep = -1;
 775       }
 776       else {
 777          srcY = 0;
 778          yStep = 1;
 779       }
 780
 781       data = (uint *) malloc(width * sizeof(uint));
 782
 783       if (data) {
 784          /* To avoid a large temp memory allocation, do copy row by row */
 785          for (row = 0; row < height; row++, srcY += yStep) {
 786             pipe_get_tile_z(pipe, src_trans, 0, srcY, width, 1, data);
 787             if (scaleOrBias) {
 788                _mesa_scale_and_bias_depth_uint(ctx, width, data);
 789             }
 790             pipe_put_tile_z(pipe, stImage->transfer, 0, row, width, 1, data);
 791          }
 792       }
 793       else {
 794          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
 795       }
 796
 797       free(data);
 798    }
 799    else {
 800       /* RGBA format */
 801       GLfloat *tempSrc =
 802          (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 803
 804       if (tempSrc && texDest) {
 805          const GLint dims = 2;
 806          const GLint dstRowStride = stImage->transfer->stride;
 807          struct gl_texture_image *texImage = &stImage->base;
 808          struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
 809
 810          if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
 811             unpack.Invert = GL_TRUE;
 812          }
 813
 814          /* get float/RGBA image from framebuffer */
 815          /* XXX this usually involves a lot of int/float conversion.
 816           * try to avoid that someday.
 817           */
 818          pipe_get_tile_rgba_format(pipe, src_trans, 0, 0, width, height,
 819                                    util_format_linear(strb->texture->format),
 820                                    tempSrc);
 821
 822          /* Store into texture memory.
 823           * Note that this does some special things such as pixel transfer
 824           * ops and format conversion.  In particular, if the dest tex format
 825           * is actually RGBA but the user created the texture as GL_RGB we
 826           * need to fill-in/override the alpha channel with 1.0.
 827           */
 828          _mesa_texstore(ctx, dims,
 829                         texImage->_BaseFormat,
 830                         texImage->TexFormat,
 831                         dstRowStride,
 832                         (GLubyte **) &texDest,
 833                         width, height, 1,
 834                         GL_RGBA, GL_FLOAT, tempSrc, /* src */
 835                         &unpack);
 836       }
 837       else {
 838          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
 839       }
 840
 841       if (tempSrc)
 842          free(tempSrc);
 843    }
 844
 845    st_texture_image_unmap(st, stImage);
 846    pipe->transfer_destroy(pipe, src_trans);
 847 }
 848
 849
 850
 851 /**
 852  * If the format of the src renderbuffer and the format of the dest
 853  * texture are compatible (in terms of blitting), return a TGSI writemask
 854  * to be used during the blit.
 855  * If the src/dest are incompatible, return 0.
 856  */
 857 static unsigned
 858 compatible_src_dst_formats(struct gl_context *ctx,
 859                            const struct gl_renderbuffer *src,
 860                            const struct gl_texture_image *dst)
 861 {
 862    /* Get logical base formats for the src and dest.
 863     * That is, use the user-requested formats and not the actual, device-
 864     * chosen formats.
 865     * For example, the user may have requested an A8 texture but the
 866     * driver may actually be using an RGBA texture format.  When we
 867     * copy/blit to that texture, we only want to copy the Alpha channel
 868     * and not the RGB channels.
 869     *
 870     * Similarly, when the src FBO was created an RGB format may have been
 871     * requested but the driver actually chose an RGBA format.  In that case,
 872     * we don't want to copy the undefined Alpha channel to the dest texture
 873     * (it should be 1.0).
 874     */
 875    const GLenum srcFormat = _mesa_base_fbo_format(ctx, src->InternalFormat);
 876    const GLenum dstFormat = _mesa_base_tex_format(ctx, dst->InternalFormat);
 877
 878    /**
 879     * XXX when we have red-only and red/green renderbuffers we'll need
 880     * to add more cases here (or implement a general-purpose routine that
 881     * queries the existance of the R,G,B,A channels in the src and dest).
 882     */
 883    if (srcFormat == dstFormat) {
 884       /* This is the same as matching_base_formats, which should
 885        * always pass, as it did previously.
 886        */
 887       return TGSI_WRITEMASK_XYZW;
 888    }
 889    else if (srcFormat == GL_RGB && dstFormat == GL_RGBA) {
 890       /* Make sure that A in the dest is 1.  The actual src format
 891        * may be RGBA and have undefined A values.
 892        */
 893       return TGSI_WRITEMASK_XYZ;
 894    }
 895    else if (srcFormat == GL_RGBA && dstFormat == GL_RGB) {
 896       /* Make sure that A in the dest is 1.  The actual dst format
 897        * may be RGBA and will need A=1 to provide proper alpha values
 898        * when sampled later.
 899        */
 900       return TGSI_WRITEMASK_XYZ;
 901    }
 902    else {
 903       if (ST_DEBUG & DEBUG_FALLBACK)
 904          debug_printf("%s failed for src %s, dst %s\n",
 905                       __FUNCTION__,
 906                       _mesa_lookup_enum_by_nr(srcFormat),
 907                       _mesa_lookup_enum_by_nr(dstFormat));
 908
 909       /* Otherwise fail.
 910        */
 911       return 0;
 912    }
 913 }
 914
 915
 916
 917 /**
 918  * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
 919  * Note that the region to copy has already been clipped so we know we
 920  * won't read from outside the source renderbuffer's bounds.
 921  *
 922  * Note: srcY=0=Bottom of renderbuffer (GL convention)
 923  */
 924 static void
 925 st_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
 926                    struct gl_texture_image *texImage,
 927                    GLint destX, GLint destY, GLint destZ,
 928                    struct gl_renderbuffer *rb,
 929                    GLint srcX, GLint srcY, GLsizei width, GLsizei height)
 930 {
 931    struct st_texture_image *stImage = st_texture_image(texImage);
 932    const GLenum texBaseFormat = texImage->_BaseFormat;
 933    struct gl_framebuffer *fb = ctx->ReadBuffer;
 934    struct st_renderbuffer *strb;
 935    struct st_context *st = st_context(ctx);
 936    struct pipe_context *pipe = st->pipe;
 937    struct pipe_screen *screen = pipe->screen;
 938    enum pipe_format dest_format, src_format;
 939    GLboolean matching_base_formats;
 940    GLuint color_writemask, zs_writemask, sample_count;
 941    struct pipe_surface *dest_surface = NULL;
 942    GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
 943    struct pipe_surface surf_tmpl;
 944    unsigned int dst_usage;
 945    GLint srcY0, srcY1;
 946
 947    /* make sure finalize_textures has been called?
 948     */
 949    if (0) st_validate_state(st);
 950
 951    /* determine if copying depth or color data */
 952    if (texBaseFormat == GL_DEPTH_COMPONENT ||
 953        texBaseFormat == GL_DEPTH_STENCIL) {
 954       strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
 955    }
 956    else {
 957       /* texBaseFormat == GL_RGB, GL_RGBA, GL_ALPHA, etc */
 958       strb = st_renderbuffer(fb->_ColorReadBuffer);
 959    }
 960
 961    if (!strb || !strb->surface || !stImage->pt) {
 962       debug_printf("%s: null strb or stImage\n", __FUNCTION__);
 963       return;
 964    }
 965
 966    sample_count = strb->surface->texture->nr_samples;
 967    /* I believe this would be legal, presumably would need to do a resolve
 968       for color, and for depth/stencil spec says to just use one of the
 969       depth/stencil samples per pixel? Need some transfer clarifications. */
 970    assert(sample_count < 2);
 971
 972    assert(strb);
 973    assert(strb->surface);
 974    assert(stImage->pt);
 975
 976    src_format = strb->surface->format;
 977    dest_format = stImage->pt->format;
 978
 979    /*
 980     * Determine if the src framebuffer and dest texture have the same
 981     * base format.  We need this to detect a case such as the framebuffer
 982     * being GL_RGBA but the texture being GL_RGB.  If the actual hardware
 983     * texture format stores RGBA we need to set A=1 (overriding the
 984     * framebuffer's alpha values).  We can't do that with the blit or
 985     * textured-quad paths.
 986     */
 987    matching_base_formats =
 988       (_mesa_get_format_base_format(strb->Base.Format) ==
 989        _mesa_get_format_base_format(texImage->TexFormat));
 990
 991    if (ctx->_ImageTransferState) {
 992       goto fallback;
 993    }
 994
 995    if (matching_base_formats &&
 996        src_format == dest_format &&
 997        !do_flip) {
 998       /* use surface_copy() / blit */
 999       struct pipe_box src_box;
1000       unsigned dstLevel;
1001
1002       u_box_2d_zslice(srcX, srcY, strb->surface->u.tex.first_layer,
1003                       width, height, &src_box);
1004
1005       /* If stImage->pt is an independent image (not a pointer into a full
1006        * mipmap) stImage->pt.last_level will be zero and we need to use that
1007        * as the dest level.
1008        */
1009       dstLevel = MIN2(stImage->base.Level, stImage->pt->last_level);
1010
1011       /* for resource_copy_region(), y=0=top, always */
1012       pipe->resource_copy_region(pipe,
1013                                  /* dest */
1014                                  stImage->pt,
1015                                  dstLevel,
1016                                  destX, destY, destZ + stImage->base.Face,
1017                                  /* src */
1018                                  strb->texture,
1019                                  strb->surface->u.tex.level,
1020                                  &src_box);
1021       return;
1022    }
1023
1024    if (texBaseFormat == GL_DEPTH_STENCIL) {
1025       goto fallback;
1026    }
1027
1028    if (texBaseFormat == GL_DEPTH_COMPONENT) {
1029       color_writemask = 0;
1030       zs_writemask = BLIT_WRITEMASK_Z;
1031       dst_usage = PIPE_BIND_DEPTH_STENCIL;
1032    }
1033    else {
1034       color_writemask = compatible_src_dst_formats(ctx, &strb->Base, texImage);
1035       zs_writemask = 0;
1036       dst_usage = PIPE_BIND_RENDER_TARGET;
1037    }
1038
1039    if ((!color_writemask && !zs_writemask) ||
1040        !screen->is_format_supported(screen, src_format,
1041                                     PIPE_TEXTURE_2D, sample_count,
1042                                     PIPE_BIND_SAMPLER_VIEW) ||
1043        !screen->is_format_supported(screen, dest_format,
1044                                     PIPE_TEXTURE_2D, 0,
1045                                     dst_usage)) {
1046       goto fallback;
1047    }
1048
1049    if (do_flip) {
1050       srcY1 = strb->Base.Height - srcY - height;
1051       srcY0 = srcY1 + height;
1052    }
1053    else {
1054       srcY0 = srcY;
1055       srcY1 = srcY0 + height;
1056    }
1057
1058    /* Disable conditional rendering. */
1059    if (st->render_condition) {
1060       pipe->render_condition(pipe, NULL, 0);
1061    }
1062
1063    memset(&surf_tmpl, 0, sizeof(surf_tmpl));
1064    surf_tmpl.format = util_format_linear(stImage->pt->format);
1065    surf_tmpl.usage = dst_usage;
1066    surf_tmpl.u.tex.level = stImage->base.Level;
1067    surf_tmpl.u.tex.first_layer = stImage->base.Face + destZ;
1068    surf_tmpl.u.tex.last_layer = stImage->base.Face + destZ;
1069
1070    dest_surface = pipe->create_surface(pipe, stImage->pt,
1071                                        &surf_tmpl);
1072    util_blit_pixels(st->blit,
1073                     strb->texture,
1074                     strb->surface->u.tex.level,
1075                     srcX, srcY0,
1076                     srcX + width, srcY1,
1077                     strb->surface->u.tex.first_layer,
1078                     dest_surface,
1079                     destX, destY,
1080                     destX + width, destY + height,
1081                     0.0, PIPE_TEX_MIPFILTER_NEAREST,
1082                     color_writemask, zs_writemask);
1083    pipe_surface_reference(&dest_surface, NULL);
1084
1085    /* Restore conditional rendering state. */
1086    if (st->render_condition) {
1087       pipe->render_condition(pipe, st->render_condition,
1088                              st->condition_mode);
1089    }
1090
1091    return;
1092
1093 fallback:
1094    /* software fallback */
1095    fallback_copy_texsubimage(ctx,
1096                              strb, stImage, texBaseFormat,
1097                              destX, destY, destZ,
1098                              srcX, srcY, width, height);
1099 }
1100
1101
1102 /**
1103  * Copy image data from stImage into the texture object 'stObj' at level
1104  * 'dstLevel'.
1105  */
1106 static void
1107 copy_image_data_to_texture(struct st_context *st,
1108                            struct st_texture_object *stObj,
1109                            GLuint dstLevel,
1110                            struct st_texture_image *stImage)
1111 {
1112    /* debug checks */
1113    {
1114       const struct gl_texture_image *dstImage =
1115          stObj->base.Image[stImage->base.Face][dstLevel];
1116       assert(dstImage);
1117       assert(dstImage->Width == stImage->base.Width);
1118       assert(dstImage->Height == stImage->base.Height);
1119       assert(dstImage->Depth == stImage->base.Depth);
1120    }
1121
1122    if (stImage->pt) {
1123       /* Copy potentially with the blitter:
1124        */
1125       GLuint src_level;
1126       if (stImage->pt != stObj->pt)
1127          src_level = 0;
1128       else
1129          src_level = stImage->base.Level;
1130
1131       st_texture_image_copy(st->pipe,
1132                             stObj->pt, dstLevel,  /* dest texture, level */
1133                             stImage->pt, src_level, /* src texture, level */
1134                             stImage->base.Face);
1135
1136       pipe_resource_reference(&stImage->pt, NULL);
1137    }
1138    else if (stImage->TexData) {
1139       /* Copy from malloc'd memory */
1140       /* XXX this should be re-examined/tested with a compressed format */
1141       GLuint blockSize = util_format_get_blocksize(stObj->pt->format);
1142       GLuint srcRowStride = stImage->base.Width * blockSize;
1143       GLuint srcSliceStride = stImage->base.Height * srcRowStride;
1144       st_texture_image_data(st,
1145                             stObj->pt,
1146                             stImage->base.Face,
1147                             dstLevel,
1148                             stImage->TexData,
1149                             srcRowStride,
1150                             srcSliceStride);
1151       _mesa_align_free(stImage->TexData);
1152       stImage->TexData = NULL;
1153    }
1154
1155    pipe_resource_reference(&stImage->pt, stObj->pt);
1156 }
1157
1158
1159 /**
1160  * Called during state validation.  When this function is finished,
1161  * the texture object should be ready for rendering.
1162  * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
1163  */
1164 GLboolean
1165 st_finalize_texture(struct gl_context *ctx,
1166                     struct pipe_context *pipe,
1167                     struct gl_texture_object *tObj)
1168 {
1169    struct st_context *st = st_context(ctx);
1170    struct st_texture_object *stObj = st_texture_object(tObj);
1171    const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1172    GLuint face;
1173    struct st_texture_image *firstImage;
1174    enum pipe_format firstImageFormat;
1175    GLuint ptWidth, ptHeight, ptDepth, ptLayers;
1176
1177    if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
1178       /* The texture is complete and we know exactly how many mipmap levels
1179        * are present/needed.  This is conditional because we may be called
1180        * from the st_generate_mipmap() function when the texture object is
1181        * incomplete.  In that case, we'll have set stObj->lastLevel before
1182        * we get here.
1183        */
1184       if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
1185           stObj->base.Sampler.MinFilter == GL_NEAREST)
1186          stObj->lastLevel = stObj->base.BaseLevel;
1187       else
1188          stObj->lastLevel = stObj->base._MaxLevel;
1189    }
1190
1191    firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);
1192    assert(firstImage);
1193
1194    /* If both firstImage and stObj point to a texture which can contain
1195     * all active images, favour firstImage.  Note that because of the
1196     * completeness requirement, we know that the image dimensions
1197     * will match.
1198     */
1199    if (firstImage->pt &&
1200        firstImage->pt != stObj->pt &&
1201        (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) {
1202       pipe_resource_reference(&stObj->pt, firstImage->pt);
1203       pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1204    }
1205
1206    /* Find gallium format for the Mesa texture */
1207    firstImageFormat = st_mesa_format_to_pipe_format(firstImage->base.TexFormat);
1208
1209    /* Find size of level=0 Gallium mipmap image, plus number of texture layers */
1210    {
1211       GLuint width, height, depth;
1212       if (!guess_base_level_size(stObj->base.Target,
1213                                  firstImage->base.Width2,
1214                                  firstImage->base.Height2,
1215                                  firstImage->base.Depth2,
1216                                  firstImage->base.Level,
1217                                  &width, &height, &depth)) {
1218          width = stObj->width0;
1219          height = stObj->height0;
1220          depth = stObj->depth0;
1221       }
1222       /* convert GL dims to Gallium dims */
1223       st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth,
1224                                       &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1225    }
1226
1227    /* If we already have a gallium texture, check that it matches the texture
1228     * object's format, target, size, num_levels, etc.
1229     */
1230    if (stObj->pt) {
1231       if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
1232           !st_sampler_compat_formats(stObj->pt->format, firstImageFormat) ||
1233           stObj->pt->last_level < stObj->lastLevel ||
1234           stObj->pt->width0 != ptWidth ||
1235           stObj->pt->height0 != ptHeight ||
1236           stObj->pt->depth0 != ptDepth ||
1237           stObj->pt->array_size != ptLayers)
1238       {
1239          /* The gallium texture does not match the Mesa texture so delete the
1240           * gallium texture now.  We'll make a new one below.
1241           */
1242          pipe_resource_reference(&stObj->pt, NULL);
1243          pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1244          st->dirty.st |= ST_NEW_FRAMEBUFFER;
1245       }
1246    }
1247
1248    /* May need to create a new gallium texture:
1249     */
1250    if (!stObj->pt) {
1251       GLuint bindings = default_bindings(st, firstImageFormat);
1252
1253       stObj->pt = st_texture_create(st,
1254                                     gl_target_to_pipe(stObj->base.Target),
1255                                     firstImageFormat,
1256                                     stObj->lastLevel,
1257                                     ptWidth,
1258                                     ptHeight,
1259                                     ptDepth,
1260                                     ptLayers,
1261                                     bindings);
1262
1263       if (!stObj->pt) {
1264          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
1265          return GL_FALSE;
1266       }
1267    }
1268
1269    /* Pull in any images not in the object's texture:
1270     */
1271    for (face = 0; face < nr_faces; face++) {
1272       GLuint level;
1273       for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) {
1274          struct st_texture_image *stImage =
1275             st_texture_image(stObj->base.Image[face][level]);
1276
1277          /* Need to import images in main memory or held in other textures.
1278           */
1279          if (stImage && stObj->pt != stImage->pt) {
1280             if (level == 0 ||
1281                 (stImage->base.Width == u_minify(stObj->width0, level) &&
1282                  stImage->base.Height == u_minify(stObj->height0, level) &&
1283                  stImage->base.Depth == u_minify(stObj->depth0, level))) {
1284                /* src image fits expected dest mipmap level size */
1285                copy_image_data_to_texture(st, stObj, level, stImage);
1286             }
1287          }
1288       }
1289    }
1290
1291    return GL_TRUE;
1292 }
1293
1294
1295 /**
1296  * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory
1297  * for a whole mipmap stack.
1298  */
1299 static GLboolean
1300 st_AllocTextureStorage(struct gl_context *ctx,
1301                        struct gl_texture_object *texObj,
1302                        GLsizei levels, GLsizei width,
1303                        GLsizei height, GLsizei depth)
1304 {
1305    const GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1306    struct st_context *st = st_context(ctx);
1307    struct st_texture_object *stObj = st_texture_object(texObj);
1308    GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings;
1309    enum pipe_format fmt;
1310    GLint level;
1311
1312    assert(levels > 0);
1313
1314    /* Save the level=0 dimensions */
1315    stObj->width0 = width;
1316    stObj->height0 = height;
1317    stObj->depth0 = depth;
1318    stObj->lastLevel = levels - 1;
1319
1320    fmt = st_mesa_format_to_pipe_format(texObj->Image[0][0]->TexFormat);
1321
1322    bindings = default_bindings(st, fmt);
1323
1324    st_gl_texture_dims_to_pipe_dims(texObj->Target,
1325                                    width, height, depth,
1326                                    &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1327
1328    stObj->pt = st_texture_create(st,
1329                                  gl_target_to_pipe(texObj->Target),
1330                                  fmt,
1331                                  levels,
1332                                  ptWidth,
1333                                  ptHeight,
1334                                  ptDepth,
1335                                  ptLayers,
1336                                  bindings);
1337    if (!stObj->pt)
1338       return GL_FALSE;
1339
1340    /* Set image resource pointers */
1341    for (level = 0; level < levels; level++) {
1342       GLuint face;
1343       for (face = 0; face < numFaces; face++) {
1344          struct st_texture_image *stImage =
1345             st_texture_image(texObj->Image[face][level]);
1346          pipe_resource_reference(&stImage->pt, stObj->pt);
1347       }
1348    }
1349
1350    return GL_TRUE;
1351 }
1352
1353
1354
1355 void
1356 st_init_texture_functions(struct dd_function_table *functions)
1357 {
1358    functions->ChooseTextureFormat = st_ChooseTextureFormat;
1359    functions->TexImage = st_TexImage;
1360    functions->TexSubImage = _mesa_store_texsubimage;
1361    functions->CompressedTexSubImage = _mesa_store_compressed_texsubimage;
1362    functions->CopyTexSubImage = st_CopyTexSubImage;
1363    functions->GenerateMipmap = st_generate_mipmap;
1364
1365    functions->GetTexImage = st_GetTexImage;
1366
1367    /* compressed texture functions */
1368    functions->CompressedTexImage = st_CompressedTexImage;
1369    functions->GetCompressedTexImage = _mesa_get_compressed_teximage;
1370
1371    functions->NewTextureObject = st_NewTextureObject;
1372    functions->NewTextureImage = st_NewTextureImage;
1373    functions->DeleteTextureImage = st_DeleteTextureImage;
1374    functions->DeleteTexture = st_DeleteTextureObject;
1375    functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
1376    functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
1377    functions->MapTextureImage = st_MapTextureImage;
1378    functions->UnmapTextureImage = st_UnmapTextureImage;
1379
1380    /* XXX Temporary until we can query pipe's texture sizes */
1381    functions->TestProxyTexImage = _mesa_test_proxy_teximage;
1382
1383    functions->AllocTextureStorage = st_AllocTextureStorage;
1384 }