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                            gl_format format, GLsizei width,
 420                            GLsizei height, GLsizei depth)
 421 {
 422    struct st_context *st = st_context(ctx);
 423    struct st_texture_image *stImage = st_texture_image(texImage);
 424    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
 425    const GLuint level = texImage->Level;
 426
 427    DBG("%s\n", __FUNCTION__);
 428
 429    assert(width > 0);
 430    assert(height > 0);
 431    assert(depth > 0);
 432    assert(!stImage->TexData);
 433    assert(!stImage->pt); /* xxx this might be wrong */
 434
 435    /* Look if the parent texture object has space for this image */
 436    if (stObj->pt &&
 437        level <= stObj->pt->last_level &&
 438        st_texture_match_image(stObj->pt, texImage)) {
 439       /* this image will fit in the existing texture object's memory */
 440       pipe_resource_reference(&stImage->pt, stObj->pt);
 441       return GL_TRUE;
 442    }
 443
 444    /* The parent texture object does not have space for this image */
 445
 446    pipe_resource_reference(&stObj->pt, NULL);
 447    pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
 448
 449    if (!guess_and_alloc_texture(st, stObj, stImage)) {
 450       /* Probably out of memory.
 451        * Try flushing any pending rendering, then retry.
 452        */
 453       st_finish(st);
 454       if (!guess_and_alloc_texture(st, stObj, stImage)) {
 455          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
 456          return GL_FALSE;
 457       }
 458    }
 459
 460    if (stObj->pt &&
 461        st_texture_match_image(stObj->pt, texImage)) {
 462       /* The image will live in the object's mipmap memory */
 463       pipe_resource_reference(&stImage->pt, stObj->pt);
 464       assert(stImage->pt);
 465       return GL_TRUE;
 466    }
 467    else {
 468       /* Create a new, temporary texture/resource/buffer to hold this
 469        * one texture image.  Note that when we later access this image
 470        * (either for mapping or copying) we'll want to always specify
 471        * mipmap level=0, even if the image represents some other mipmap
 472        * level.
 473        */
 474       enum pipe_format format =
 475          st_mesa_format_to_pipe_format(texImage->TexFormat);
 476       GLuint bindings = default_bindings(st, format);
 477       GLuint ptWidth, ptHeight, ptDepth, ptLayers;
 478
 479       st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
 480                                       width, height, depth,
 481                                       &ptWidth, &ptHeight, &ptDepth, &ptLayers);
 482
 483       stImage->pt = st_texture_create(st,
 484                                       gl_target_to_pipe(stObj->base.Target),
 485                                       format,
 486                                       0, /* lastLevel */
 487                                       ptWidth,
 488                                       ptHeight,
 489                                       ptDepth,
 490                                       ptLayers,
 491                                       bindings);
 492       return stImage->pt != NULL;
 493    }
 494 }
 495
 496
 497 /**
 498  * Preparation prior to glTexImage.  Basically check the 'surface_based'
 499  * field and switch to a "normal" tex image if necessary.
 500  */
 501 static void
 502 prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage,
 503               GLint internalFormat,
 504               GLint width, GLint height, GLint depth, GLint border,
 505               GLenum format, GLenum type)
 506 {
 507    struct gl_texture_object *texObj = texImage->TexObject;
 508    struct st_texture_object *stObj = st_texture_object(texObj);
 509
 510    /* switch to "normal" */
 511    if (stObj->surface_based) {
 512       const GLenum target = texObj->Target;
 513       const GLuint level = texImage->Level;
 514       gl_format texFormat;
 515
 516       _mesa_clear_texture_object(ctx, texObj);
 517       pipe_resource_reference(&stObj->pt, NULL);
 518
 519       /* oops, need to init this image again */
 520       texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
 521                                               internalFormat, format, type);
 522
 523       _mesa_init_teximage_fields(ctx, texImage,
 524                                  width, height, depth, border,
 525                                  internalFormat, texFormat);
 526
 527       stObj->surface_based = GL_FALSE;
 528    }
 529 }
 530
 531
 532 static void
 533 st_TexImage(struct gl_context * ctx, GLuint dims,
 534             struct gl_texture_image *texImage,
 535             GLint internalFormat,
 536             GLint width, GLint height, GLint depth, GLint border,
 537             GLenum format, GLenum type, const void *pixels,
 538             const struct gl_pixelstore_attrib *unpack)
 539 {
 540    prep_teximage(ctx, texImage, internalFormat, width, height, depth, border,
 541                  format, type);
 542    _mesa_store_teximage(ctx, dims, texImage, internalFormat, width, height, depth,
 543                         border, format, type, pixels, unpack);
 544 }
 545
 546
 547 static void
 548 st_CompressedTexImage2D(struct gl_context *ctx,
 549                         struct gl_texture_image *texImage,
 550                         GLint internalFormat,
 551                         GLint width, GLint height, GLint border,
 552                         GLsizei imageSize, const GLvoid *data)
 553 {
 554    prep_teximage(ctx, texImage, internalFormat, width, 1, 1, border,
 555                  GL_NONE, GL_NONE);
 556    _mesa_store_compressed_teximage2d(ctx, texImage, internalFormat, width,
 557                                      height, border, imageSize, data);
 558 }
 559
 560
 561
 562 /**
 563  * glGetTexImage() helper: decompress a compressed texture by rendering
 564  * a textured quad.  Store the results in the user's buffer.
 565  */
 566 static void
 567 decompress_with_blit(struct gl_context * ctx,
 568                      GLenum format, GLenum type, GLvoid *pixels,
 569                      struct gl_texture_image *texImage)
 570 {
 571    struct st_context *st = st_context(ctx);
 572    struct pipe_context *pipe = st->pipe;
 573    struct st_texture_image *stImage = st_texture_image(texImage);
 574    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
 575    struct pipe_sampler_view *src_view;
 576    const GLuint width = texImage->Width;
 577    const GLuint height = texImage->Height;
 578    struct pipe_surface *dst_surface;
 579    struct pipe_resource *dst_texture;
 580    struct pipe_transfer *tex_xfer;
 581    unsigned bind = (PIPE_BIND_RENDER_TARGET | /* util_blit may choose to render */
 582                     PIPE_BIND_TRANSFER_READ);
 583
 584    /* create temp / dest surface */
 585    if (!util_create_rgba_surface(pipe, width, height, bind,
 586                                  &dst_texture, &dst_surface)) {
 587       _mesa_problem(ctx, "util_create_rgba_surface() failed "
 588                     "in decompress_with_blit()");
 589       return;
 590    }
 591
 592    /* Disable conditional rendering. */
 593    if (st->render_condition) {
 594       pipe->render_condition(pipe, NULL, 0);
 595    }
 596
 597    /* Create sampler view that limits fetches to the source mipmap level */
 598    {
 599       struct pipe_sampler_view sv_temp;
 600
 601       u_sampler_view_default_template(&sv_temp, stObj->pt, stObj->pt->format);
 602
 603       sv_temp.u.tex.first_level =
 604       sv_temp.u.tex.last_level = texImage->Level;
 605
 606       src_view = pipe->create_sampler_view(pipe, stObj->pt, &sv_temp);
 607       if (!src_view) {
 608          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
 609          return;
 610       }
 611    }
 612
 613    /* blit/render/decompress */
 614    util_blit_pixels_tex(st->blit,
 615                         src_view,      /* pipe_resource (src) */
 616                         0, 0,             /* src x0, y0 */
 617                         width, height,    /* src x1, y1 */
 618                         dst_surface,      /* pipe_surface (dst) */
 619                         0, 0,             /* dst x0, y0 */
 620                         width, height,    /* dst x1, y1 */
 621                         0.0,              /* z */
 622                         PIPE_TEX_MIPFILTER_NEAREST);
 623
 624    /* Restore conditional rendering state. */
 625    if (st->render_condition) {
 626       pipe->render_condition(pipe, st->render_condition,
 627                              st->condition_mode);
 628    }
 629
 630    /* map the dst_surface so we can read from it */
 631    tex_xfer = pipe_get_transfer(pipe,
 632                                 dst_texture, 0, 0,
 633                                 PIPE_TRANSFER_READ,
 634                                 0, 0, width, height);
 635
 636    pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
 637
 638    /* copy/pack data into user buffer */
 639    if (_mesa_format_matches_format_and_type(stImage->base.TexFormat,
 640                                             format, type,
 641                                             ctx->Pack.SwapBytes)) {
 642       /* memcpy */
 643       const uint bytesPerRow = width * util_format_get_blocksize(stImage->pt->format);
 644       ubyte *map = pipe_transfer_map(pipe, tex_xfer);
 645       GLuint row;
 646       for (row = 0; row < height; row++) {
 647          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
 648                                               height, format, type, row, 0);
 649          memcpy(dest, map, bytesPerRow);
 650          map += tex_xfer->stride;
 651       }
 652       pipe_transfer_unmap(pipe, tex_xfer);
 653    }
 654    else {
 655       /* format translation via floats */
 656       GLuint row;
 657       enum pipe_format pformat = util_format_linear(dst_texture->format);
 658       GLfloat *rgba;
 659
 660       rgba = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
 661       if (!rgba) {
 662          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage()");
 663          goto end;
 664       }
 665
 666       for (row = 0; row < height; row++) {
 667          const GLbitfield transferOps = 0x0; /* bypassed for glGetTexImage() */
 668          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
 669                                               height, format, type, row, 0);
 670
 671          if (ST_DEBUG & DEBUG_FALLBACK)
 672             debug_printf("%s: fallback format translation\n", __FUNCTION__);
 673
 674          /* get float[4] rgba row from surface */
 675          pipe_get_tile_rgba_format(pipe, tex_xfer, 0, row, width, 1,
 676                                    pformat, rgba);
 677
 678          _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
 679                                     type, dest, &ctx->Pack, transferOps);
 680       }
 681
 682       free(rgba);
 683    }
 684
 685 end:
 686    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 687
 688    pipe->transfer_destroy(pipe, tex_xfer);
 689
 690    /* destroy the temp / dest surface */
 691    util_destroy_rgba_surface(dst_texture, dst_surface);
 692
 693    pipe_sampler_view_release(pipe, &src_view);
 694 }
 695
 696
 697
 698 /**
 699  * Called via ctx->Driver.GetTexImage()
 700  */
 701 static void
 702 st_GetTexImage(struct gl_context * ctx,
 703                GLenum format, GLenum type, GLvoid * pixels,
 704                struct gl_texture_image *texImage)
 705 {
 706    struct st_texture_image *stImage = st_texture_image(texImage);
 707
 708    if (stImage->pt && util_format_is_s3tc(stImage->pt->format)) {
 709       /* Need to decompress the texture.
 710        * We'll do this by rendering a textured quad (which is hopefully
 711        * faster than using the fallback code in texcompress.c).
 712        * Note that we only expect RGBA formats (no Z/depth formats).
 713        */
 714       decompress_with_blit(ctx, format, type, pixels, texImage);
 715    }
 716    else {
 717       _mesa_get_teximage(ctx, format, type, pixels, texImage);
 718    }
 719 }
 720
 721
 722 /**
 723  * Do a CopyTexSubImage operation using a read transfer from the source,
 724  * a write transfer to the destination and get_tile()/put_tile() to access
 725  * the pixels/texels.
 726  *
 727  * Note: srcY=0=TOP of renderbuffer
 728  */
 729 static void
 730 fallback_copy_texsubimage(struct gl_context *ctx,
 731                           struct st_renderbuffer *strb,
 732                           struct st_texture_image *stImage,
 733                           GLenum baseFormat,
 734                           GLint destX, GLint destY, GLint destZ,
 735                           GLint srcX, GLint srcY,
 736                           GLsizei width, GLsizei height)
 737 {
 738    struct st_context *st = st_context(ctx);
 739    struct pipe_context *pipe = st->pipe;
 740    struct pipe_transfer *src_trans;
 741    GLvoid *texDest;
 742    enum pipe_transfer_usage transfer_usage;
 743
 744    if (ST_DEBUG & DEBUG_FALLBACK)
 745       debug_printf("%s: fallback processing\n", __FUNCTION__);
 746
 747    if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
 748       srcY = strb->Base.Height - srcY - height;
 749    }
 750
 751    src_trans = pipe_get_transfer(pipe,
 752                                  strb->texture,
 753                                  strb->rtt_level,
 754                                  strb->rtt_face + strb->rtt_slice,
 755                                  PIPE_TRANSFER_READ,
 756                                  srcX, srcY,
 757                                  width, height);
 758
 759    if ((baseFormat == GL_DEPTH_COMPONENT ||
 760         baseFormat == GL_DEPTH_STENCIL) &&
 761        util_format_is_depth_and_stencil(stImage->pt->format))
 762       transfer_usage = PIPE_TRANSFER_READ_WRITE;
 763    else
 764       transfer_usage = PIPE_TRANSFER_WRITE;
 765
 766    /* XXX this used to ignore destZ param */
 767    texDest = st_texture_image_map(st, stImage, destZ, transfer_usage,
 768                                   destX, destY, width, height);
 769
 770    if (baseFormat == GL_DEPTH_COMPONENT ||
 771        baseFormat == GL_DEPTH_STENCIL) {
 772       const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
 773                                      ctx->Pixel.DepthBias != 0.0F);
 774       GLint row, yStep;
 775       uint *data;
 776
 777       /* determine bottom-to-top vs. top-to-bottom order for src buffer */
 778       if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
 779          srcY = height - 1;
 780          yStep = -1;
 781       }
 782       else {
 783          srcY = 0;
 784          yStep = 1;
 785       }
 786
 787       data = (uint *) malloc(width * sizeof(uint));
 788
 789       if (data) {
 790          /* To avoid a large temp memory allocation, do copy row by row */
 791          for (row = 0; row < height; row++, srcY += yStep) {
 792             pipe_get_tile_z(pipe, src_trans, 0, srcY, width, 1, data);
 793             if (scaleOrBias) {
 794                _mesa_scale_and_bias_depth_uint(ctx, width, data);
 795             }
 796             pipe_put_tile_z(pipe, stImage->transfer, 0, row, width, 1, data);
 797          }
 798       }
 799       else {
 800          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
 801       }
 802
 803       free(data);
 804    }
 805    else {
 806       /* RGBA format */
 807       GLfloat *tempSrc =
 808          (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 809
 810       if (tempSrc && texDest) {
 811          const GLint dims = 2;
 812          const GLint dstRowStride = stImage->transfer->stride;
 813          struct gl_texture_image *texImage = &stImage->base;
 814          struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
 815
 816          if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
 817             unpack.Invert = GL_TRUE;
 818          }
 819
 820          /* get float/RGBA image from framebuffer */
 821          /* XXX this usually involves a lot of int/float conversion.
 822           * try to avoid that someday.
 823           */
 824          pipe_get_tile_rgba_format(pipe, src_trans, 0, 0, width, height,
 825                                    util_format_linear(strb->texture->format),
 826                                    tempSrc);
 827
 828          /* Store into texture memory.
 829           * Note that this does some special things such as pixel transfer
 830           * ops and format conversion.  In particular, if the dest tex format
 831           * is actually RGBA but the user created the texture as GL_RGB we
 832           * need to fill-in/override the alpha channel with 1.0.
 833           */
 834          _mesa_texstore(ctx, dims,
 835                         texImage->_BaseFormat,
 836                         texImage->TexFormat,
 837                         dstRowStride,
 838                         (GLubyte **) &texDest,
 839                         width, height, 1,
 840                         GL_RGBA, GL_FLOAT, tempSrc, /* src */
 841                         &unpack);
 842       }
 843       else {
 844          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
 845       }
 846
 847       if (tempSrc)
 848          free(tempSrc);
 849    }
 850
 851    st_texture_image_unmap(st, stImage);
 852    pipe->transfer_destroy(pipe, src_trans);
 853 }
 854
 855
 856
 857 /**
 858  * If the format of the src renderbuffer and the format of the dest
 859  * texture are compatible (in terms of blitting), return a TGSI writemask
 860  * to be used during the blit.
 861  * If the src/dest are incompatible, return 0.
 862  */
 863 static unsigned
 864 compatible_src_dst_formats(struct gl_context *ctx,
 865                            const struct gl_renderbuffer *src,
 866                            const struct gl_texture_image *dst)
 867 {
 868    /* Get logical base formats for the src and dest.
 869     * That is, use the user-requested formats and not the actual, device-
 870     * chosen formats.
 871     * For example, the user may have requested an A8 texture but the
 872     * driver may actually be using an RGBA texture format.  When we
 873     * copy/blit to that texture, we only want to copy the Alpha channel
 874     * and not the RGB channels.
 875     *
 876     * Similarly, when the src FBO was created an RGB format may have been
 877     * requested but the driver actually chose an RGBA format.  In that case,
 878     * we don't want to copy the undefined Alpha channel to the dest texture
 879     * (it should be 1.0).
 880     */
 881    const GLenum srcFormat = _mesa_base_fbo_format(ctx, src->InternalFormat);
 882    const GLenum dstFormat = _mesa_base_tex_format(ctx, dst->InternalFormat);
 883
 884    /**
 885     * XXX when we have red-only and red/green renderbuffers we'll need
 886     * to add more cases here (or implement a general-purpose routine that
 887     * queries the existance of the R,G,B,A channels in the src and dest).
 888     */
 889    if (srcFormat == dstFormat) {
 890       /* This is the same as matching_base_formats, which should
 891        * always pass, as it did previously.
 892        */
 893       return TGSI_WRITEMASK_XYZW;
 894    }
 895    else if (srcFormat == GL_RGB && dstFormat == GL_RGBA) {
 896       /* Make sure that A in the dest is 1.  The actual src format
 897        * may be RGBA and have undefined A values.
 898        */
 899       return TGSI_WRITEMASK_XYZ;
 900    }
 901    else if (srcFormat == GL_RGBA && dstFormat == GL_RGB) {
 902       /* Make sure that A in the dest is 1.  The actual dst format
 903        * may be RGBA and will need A=1 to provide proper alpha values
 904        * when sampled later.
 905        */
 906       return TGSI_WRITEMASK_XYZ;
 907    }
 908    else {
 909       if (ST_DEBUG & DEBUG_FALLBACK)
 910          debug_printf("%s failed for src %s, dst %s\n",
 911                       __FUNCTION__,
 912                       _mesa_lookup_enum_by_nr(srcFormat),
 913                       _mesa_lookup_enum_by_nr(dstFormat));
 914
 915       /* Otherwise fail.
 916        */
 917       return 0;
 918    }
 919 }
 920
 921
 922
 923 /**
 924  * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
 925  * Note that the region to copy has already been clipped so we know we
 926  * won't read from outside the source renderbuffer's bounds.
 927  *
 928  * Note: srcY=0=Bottom of renderbuffer (GL convention)
 929  */
 930 static void
 931 st_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
 932                    struct gl_texture_image *texImage,
 933                    GLint destX, GLint destY, GLint destZ,
 934                    struct gl_renderbuffer *rb,
 935                    GLint srcX, GLint srcY, GLsizei width, GLsizei height)
 936 {
 937    struct st_texture_image *stImage = st_texture_image(texImage);
 938    const GLenum texBaseFormat = texImage->_BaseFormat;
 939    struct gl_framebuffer *fb = ctx->ReadBuffer;
 940    struct st_renderbuffer *strb;
 941    struct st_context *st = st_context(ctx);
 942    struct pipe_context *pipe = st->pipe;
 943    struct pipe_screen *screen = pipe->screen;
 944    enum pipe_format dest_format, src_format;
 945    GLboolean matching_base_formats;
 946    GLuint format_writemask, sample_count;
 947    struct pipe_surface *dest_surface = NULL;
 948    GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
 949    struct pipe_surface surf_tmpl;
 950    unsigned int dst_usage;
 951    GLint srcY0, srcY1;
 952
 953    /* make sure finalize_textures has been called?
 954     */
 955    if (0) st_validate_state(st);
 956
 957    /* determine if copying depth or color data */
 958    if (texBaseFormat == GL_DEPTH_COMPONENT ||
 959        texBaseFormat == GL_DEPTH_STENCIL) {
 960       strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
 961    }
 962    else {
 963       /* texBaseFormat == GL_RGB, GL_RGBA, GL_ALPHA, etc */
 964       strb = st_renderbuffer(fb->_ColorReadBuffer);
 965    }
 966
 967    if (!strb || !strb->surface || !stImage->pt) {
 968       debug_printf("%s: null strb or stImage\n", __FUNCTION__);
 969       return;
 970    }
 971
 972    sample_count = strb->surface->texture->nr_samples;
 973    /* I believe this would be legal, presumably would need to do a resolve
 974       for color, and for depth/stencil spec says to just use one of the
 975       depth/stencil samples per pixel? Need some transfer clarifications. */
 976    assert(sample_count < 2);
 977
 978    assert(strb);
 979    assert(strb->surface);
 980    assert(stImage->pt);
 981
 982    src_format = strb->surface->format;
 983    dest_format = stImage->pt->format;
 984
 985    /*
 986     * Determine if the src framebuffer and dest texture have the same
 987     * base format.  We need this to detect a case such as the framebuffer
 988     * being GL_RGBA but the texture being GL_RGB.  If the actual hardware
 989     * texture format stores RGBA we need to set A=1 (overriding the
 990     * framebuffer's alpha values).  We can't do that with the blit or
 991     * textured-quad paths.
 992     */
 993    matching_base_formats =
 994       (_mesa_get_format_base_format(strb->Base.Format) ==
 995        _mesa_get_format_base_format(texImage->TexFormat));
 996
 997    if (ctx->_ImageTransferState) {
 998       goto fallback;
 999    }
1000
1001    if (matching_base_formats &&
1002        src_format == dest_format &&
1003        !do_flip) {
1004       /* use surface_copy() / blit */
1005       struct pipe_box src_box;
1006       u_box_2d_zslice(srcX, srcY, strb->surface->u.tex.first_layer,
1007                       width, height, &src_box);
1008
1009       /* for resource_copy_region(), y=0=top, always */
1010       pipe->resource_copy_region(pipe,
1011                                  /* dest */
1012                                  stImage->pt,
1013                                  stImage->base.Level,
1014                                  destX, destY, destZ + stImage->base.Face,
1015                                  /* src */
1016                                  strb->texture,
1017                                  strb->surface->u.tex.level,
1018                                  &src_box);
1019       return;
1020    }
1021
1022    if (texBaseFormat == GL_DEPTH_STENCIL) {
1023       goto fallback;
1024    }
1025
1026    if (texBaseFormat == GL_DEPTH_COMPONENT) {
1027       format_writemask = TGSI_WRITEMASK_XYZW;
1028       dst_usage = PIPE_BIND_DEPTH_STENCIL;
1029    }
1030    else {
1031       format_writemask = compatible_src_dst_formats(ctx, &strb->Base, texImage);
1032       dst_usage = PIPE_BIND_RENDER_TARGET;
1033    }
1034
1035    if (!format_writemask ||
1036        !screen->is_format_supported(screen, src_format,
1037                                     PIPE_TEXTURE_2D, sample_count,
1038                                     PIPE_BIND_SAMPLER_VIEW) ||
1039        !screen->is_format_supported(screen, dest_format,
1040                                     PIPE_TEXTURE_2D, 0,
1041                                     dst_usage)) {
1042       goto fallback;
1043    }
1044
1045    if (do_flip) {
1046       srcY1 = strb->Base.Height - srcY - height;
1047       srcY0 = srcY1 + height;
1048    }
1049    else {
1050       srcY0 = srcY;
1051       srcY1 = srcY0 + height;
1052    }
1053
1054    /* Disable conditional rendering. */
1055    if (st->render_condition) {
1056       pipe->render_condition(pipe, NULL, 0);
1057    }
1058
1059    memset(&surf_tmpl, 0, sizeof(surf_tmpl));
1060    surf_tmpl.format = util_format_linear(stImage->pt->format);
1061    surf_tmpl.usage = dst_usage;
1062    surf_tmpl.u.tex.level = stImage->base.Level;
1063    surf_tmpl.u.tex.first_layer = stImage->base.Face + destZ;
1064    surf_tmpl.u.tex.last_layer = stImage->base.Face + destZ;
1065
1066    dest_surface = pipe->create_surface(pipe, stImage->pt,
1067                                        &surf_tmpl);
1068    util_blit_pixels_writemask(st->blit,
1069                               strb->texture,
1070                               strb->surface->u.tex.level,
1071                               srcX, srcY0,
1072                               srcX + width, srcY1,
1073                               strb->surface->u.tex.first_layer,
1074                               dest_surface,
1075                               destX, destY,
1076                               destX + width, destY + height,
1077                               0.0, PIPE_TEX_MIPFILTER_NEAREST,
1078                               format_writemask);
1079    pipe_surface_reference(&dest_surface, NULL);
1080
1081    /* Restore conditional rendering state. */
1082    if (st->render_condition) {
1083       pipe->render_condition(pipe, st->render_condition,
1084                              st->condition_mode);
1085    }
1086
1087    return;
1088
1089 fallback:
1090    /* software fallback */
1091    fallback_copy_texsubimage(ctx,
1092                              strb, stImage, texBaseFormat,
1093                              destX, destY, destZ,
1094                              srcX, srcY, width, height);
1095 }
1096
1097
1098 /**
1099  * Copy image data from stImage into the texture object 'stObj' at level
1100  * 'dstLevel'.
1101  */
1102 static void
1103 copy_image_data_to_texture(struct st_context *st,
1104                            struct st_texture_object *stObj,
1105                            GLuint dstLevel,
1106                            struct st_texture_image *stImage)
1107 {
1108    /* debug checks */
1109    {
1110       const struct gl_texture_image *dstImage =
1111          stObj->base.Image[stImage->base.Face][dstLevel];
1112       assert(dstImage);
1113       assert(dstImage->Width == stImage->base.Width);
1114       assert(dstImage->Height == stImage->base.Height);
1115       assert(dstImage->Depth == stImage->base.Depth);
1116    }
1117
1118    if (stImage->pt) {
1119       /* Copy potentially with the blitter:
1120        */
1121       GLuint src_level;
1122       if (stImage->pt != stObj->pt)
1123          src_level = 0;
1124       else
1125          src_level = stImage->base.Level;
1126
1127       st_texture_image_copy(st->pipe,
1128                             stObj->pt, dstLevel,  /* dest texture, level */
1129                             stImage->pt, src_level, /* src texture, level */
1130                             stImage->base.Face);
1131
1132       pipe_resource_reference(&stImage->pt, NULL);
1133    }
1134    else if (stImage->TexData) {
1135       /* Copy from malloc'd memory */
1136       /* XXX this should be re-examined/tested with a compressed format */
1137       GLuint blockSize = util_format_get_blocksize(stObj->pt->format);
1138       GLuint srcRowStride = stImage->base.Width * blockSize;
1139       GLuint srcSliceStride = stImage->base.Height * srcRowStride;
1140       st_texture_image_data(st,
1141                             stObj->pt,
1142                             stImage->base.Face,
1143                             dstLevel,
1144                             stImage->TexData,
1145                             srcRowStride,
1146                             srcSliceStride);
1147       _mesa_align_free(stImage->TexData);
1148       stImage->TexData = NULL;
1149    }
1150
1151    pipe_resource_reference(&stImage->pt, stObj->pt);
1152 }
1153
1154
1155 /**
1156  * Called during state validation.  When this function is finished,
1157  * the texture object should be ready for rendering.
1158  * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
1159  */
1160 GLboolean
1161 st_finalize_texture(struct gl_context *ctx,
1162                     struct pipe_context *pipe,
1163                     struct gl_texture_object *tObj)
1164 {
1165    struct st_context *st = st_context(ctx);
1166    struct st_texture_object *stObj = st_texture_object(tObj);
1167    const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1168    GLuint face;
1169    struct st_texture_image *firstImage;
1170    enum pipe_format firstImageFormat;
1171    GLuint ptWidth, ptHeight, ptDepth, ptLayers;
1172
1173    if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
1174       /* The texture is complete and we know exactly how many mipmap levels
1175        * are present/needed.  This is conditional because we may be called
1176        * from the st_generate_mipmap() function when the texture object is
1177        * incomplete.  In that case, we'll have set stObj->lastLevel before
1178        * we get here.
1179        */
1180       if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
1181           stObj->base.Sampler.MinFilter == GL_NEAREST)
1182          stObj->lastLevel = stObj->base.BaseLevel;
1183       else
1184          stObj->lastLevel = stObj->base._MaxLevel;
1185    }
1186
1187    firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);
1188    assert(firstImage);
1189
1190    /* If both firstImage and stObj point to a texture which can contain
1191     * all active images, favour firstImage.  Note that because of the
1192     * completeness requirement, we know that the image dimensions
1193     * will match.
1194     */
1195    if (firstImage->pt &&
1196        firstImage->pt != stObj->pt &&
1197        (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) {
1198       pipe_resource_reference(&stObj->pt, firstImage->pt);
1199       pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1200    }
1201
1202    /* Find gallium format for the Mesa texture */
1203    firstImageFormat = st_mesa_format_to_pipe_format(firstImage->base.TexFormat);
1204
1205    /* Find size of level=0 Gallium mipmap image, plus number of texture layers */
1206    {
1207       GLuint width, height, depth;
1208       if (!guess_base_level_size(stObj->base.Target,
1209                                  firstImage->base.Width2,
1210                                  firstImage->base.Height2,
1211                                  firstImage->base.Depth2,
1212                                  firstImage->base.Level,
1213                                  &width, &height, &depth)) {
1214          width = stObj->width0;
1215          height = stObj->height0;
1216          depth = stObj->depth0;
1217       }
1218       /* convert GL dims to Gallium dims */
1219       st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth,
1220                                       &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1221    }
1222
1223    /* If we already have a gallium texture, check that it matches the texture
1224     * object's format, target, size, num_levels, etc.
1225     */
1226    if (stObj->pt) {
1227       if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
1228           !st_sampler_compat_formats(stObj->pt->format, firstImageFormat) ||
1229           stObj->pt->last_level < stObj->lastLevel ||
1230           stObj->pt->width0 != ptWidth ||
1231           stObj->pt->height0 != ptHeight ||
1232           stObj->pt->depth0 != ptDepth ||
1233           stObj->pt->array_size != ptLayers)
1234       {
1235          /* The gallium texture does not match the Mesa texture so delete the
1236           * gallium texture now.  We'll make a new one below.
1237           */
1238          pipe_resource_reference(&stObj->pt, NULL);
1239          pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1240          st->dirty.st |= ST_NEW_FRAMEBUFFER;
1241       }
1242    }
1243
1244    /* May need to create a new gallium texture:
1245     */
1246    if (!stObj->pt) {
1247       GLuint bindings = default_bindings(st, firstImageFormat);
1248
1249       stObj->pt = st_texture_create(st,
1250                                     gl_target_to_pipe(stObj->base.Target),
1251                                     firstImageFormat,
1252                                     stObj->lastLevel,
1253                                     ptWidth,
1254                                     ptHeight,
1255                                     ptDepth,
1256                                     ptLayers,
1257                                     bindings);
1258
1259       if (!stObj->pt) {
1260          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
1261          return GL_FALSE;
1262       }
1263    }
1264
1265    /* Pull in any images not in the object's texture:
1266     */
1267    for (face = 0; face < nr_faces; face++) {
1268       GLuint level;
1269       for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) {
1270          struct st_texture_image *stImage =
1271             st_texture_image(stObj->base.Image[face][level]);
1272
1273          /* Need to import images in main memory or held in other textures.
1274           */
1275          if (stImage && stObj->pt != stImage->pt) {
1276             if (level == 0 ||
1277                 (stImage->base.Width == u_minify(stObj->width0, level) &&
1278                  stImage->base.Height == u_minify(stObj->height0, level) &&
1279                  stImage->base.Depth == u_minify(stObj->depth0, level))) {
1280                /* src image fits expected dest mipmap level size */
1281                copy_image_data_to_texture(st, stObj, level, stImage);
1282             }
1283          }
1284       }
1285    }
1286
1287    return GL_TRUE;
1288 }
1289
1290
1291 /**
1292  * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory
1293  * for a whole mipmap stack.
1294  */
1295 static GLboolean
1296 st_AllocTextureStorage(struct gl_context *ctx,
1297                        struct gl_texture_object *texObj,
1298                        GLsizei levels, GLsizei width,
1299                        GLsizei height, GLsizei depth)
1300 {
1301    const GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1302    struct st_context *st = st_context(ctx);
1303    struct st_texture_object *stObj = st_texture_object(texObj);
1304    GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings;
1305    enum pipe_format fmt;
1306    GLint level;
1307
1308    assert(levels > 0);
1309
1310    /* Save the level=0 dimensions */
1311    stObj->width0 = width;
1312    stObj->height0 = height;
1313    stObj->depth0 = depth;
1314    stObj->lastLevel = levels - 1;
1315
1316    fmt = st_mesa_format_to_pipe_format(texObj->Image[0][0]->TexFormat);
1317
1318    bindings = default_bindings(st, fmt);
1319
1320    st_gl_texture_dims_to_pipe_dims(texObj->Target,
1321                                    width, height, depth,
1322                                    &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1323
1324    stObj->pt = st_texture_create(st,
1325                                  gl_target_to_pipe(texObj->Target),
1326                                  fmt,
1327                                  levels,
1328                                  ptWidth,
1329                                  ptHeight,
1330                                  ptDepth,
1331                                  ptLayers,
1332                                  bindings);
1333    if (!stObj->pt)
1334       return GL_FALSE;
1335
1336    /* Set image resource pointers */
1337    for (level = 0; level < levels; level++) {
1338       GLuint face;
1339       for (face = 0; face < numFaces; face++) {
1340          struct st_texture_image *stImage =
1341             st_texture_image(texObj->Image[face][level]);
1342          pipe_resource_reference(&stImage->pt, stObj->pt);
1343       }
1344    }
1345
1346    return GL_TRUE;
1347 }
1348
1349
1350
1351 void
1352 st_init_texture_functions(struct dd_function_table *functions)
1353 {
1354    functions->ChooseTextureFormat = st_ChooseTextureFormat;
1355    functions->TexImage = st_TexImage;
1356    functions->TexSubImage = _mesa_store_texsubimage;
1357    functions->CompressedTexSubImage1D = _mesa_store_compressed_texsubimage1d;
1358    functions->CompressedTexSubImage2D = _mesa_store_compressed_texsubimage2d;
1359    functions->CompressedTexSubImage3D = _mesa_store_compressed_texsubimage3d;
1360    functions->CopyTexSubImage = st_CopyTexSubImage;
1361    functions->GenerateMipmap = st_generate_mipmap;
1362
1363    functions->GetTexImage = st_GetTexImage;
1364
1365    /* compressed texture functions */
1366    functions->CompressedTexImage2D = st_CompressedTexImage2D;
1367    functions->GetCompressedTexImage = _mesa_get_compressed_teximage;
1368
1369    functions->NewTextureObject = st_NewTextureObject;
1370    functions->NewTextureImage = st_NewTextureImage;
1371    functions->DeleteTextureImage = st_DeleteTextureImage;
1372    functions->DeleteTexture = st_DeleteTextureObject;
1373    functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
1374    functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
1375    functions->MapTextureImage = st_MapTextureImage;
1376    functions->UnmapTextureImage = st_UnmapTextureImage;
1377
1378    /* XXX Temporary until we can query pipe's texture sizes */
1379    functions->TestProxyTexImage = _mesa_test_proxy_teximage;
1380
1381    functions->AllocTextureStorage = st_AllocTextureStorage;
1382 }