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 #if FEATURE_convolve
  31 #include "main/convolve.h"
  32 #endif
  33 #include "main/enums.h"
  34 #include "main/fbobject.h"
  35 #include "main/formats.h"
  36 #include "main/image.h"
  37 #include "main/imports.h"
  38 #include "main/macros.h"
  39 #include "main/mipmap.h"
  40 #include "main/texcompress.h"
  41 #include "main/texfetch.h"
  42 #include "main/texgetimage.h"
  43 #include "main/teximage.h"
  44 #include "main/texobj.h"
  45 #include "main/texstore.h"
  46
  47 #include "state_tracker/st_debug.h"
  48 #include "state_tracker/st_context.h"
  49 #include "state_tracker/st_cb_fbo.h"
  50 #include "state_tracker/st_cb_texture.h"
  51 #include "state_tracker/st_format.h"
  52 #include "state_tracker/st_public.h"
  53 #include "state_tracker/st_texture.h"
  54 #include "state_tracker/st_gen_mipmap.h"
  55 #include "state_tracker/st_inlines.h"
  56 #include "state_tracker/st_atom.h"
  57
  58 #include "pipe/p_context.h"
  59 #include "pipe/p_defines.h"
  60 #include "util/u_inlines.h"
  61 #include "pipe/p_shader_tokens.h"
  62 #include "util/u_tile.h"
  63 #include "util/u_blit.h"
  64 #include "util/u_format.h"
  65 #include "util/u_surface.h"
  66 #include "util/u_sampler.h"
  67 #include "util/u_math.h"
  68
  69
  70 #define DBG if (0) printf
  71
  72
  73 static enum pipe_texture_target
  74 gl_target_to_pipe(GLenum target)
  75 {
  76    switch (target) {
  77    case GL_TEXTURE_1D:
  78       return PIPE_TEXTURE_1D;
  79
  80    case GL_TEXTURE_2D:
  81    case GL_TEXTURE_RECTANGLE_NV:
  82       return PIPE_TEXTURE_2D;
  83
  84    case GL_TEXTURE_3D:
  85       return PIPE_TEXTURE_3D;
  86
  87    case GL_TEXTURE_CUBE_MAP_ARB:
  88       return PIPE_TEXTURE_CUBE;
  89
  90    default:
  91       assert(0);
  92       return 0;
  93    }
  94 }
  95
  96
  97 /** called via ctx->Driver.NewTextureImage() */
  98 static struct gl_texture_image *
  99 st_NewTextureImage(GLcontext * ctx)
 100 {
 101    DBG("%s\n", __FUNCTION__);
 102    (void) ctx;
 103    return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image);
 104 }
 105
 106
 107 /** called via ctx->Driver.NewTextureObject() */
 108 static struct gl_texture_object *
 109 st_NewTextureObject(GLcontext * ctx, GLuint name, GLenum target)
 110 {
 111    struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object);
 112
 113    DBG("%s\n", __FUNCTION__);
 114    _mesa_initialize_texture_object(&obj->base, name, target);
 115
 116    return &obj->base;
 117 }
 118
 119 /** called via ctx->Driver.DeleteTextureImage() */
 120 static void
 121 st_DeleteTextureObject(GLcontext *ctx,
 122                        struct gl_texture_object *texObj)
 123 {
 124    struct st_texture_object *stObj = st_texture_object(texObj);
 125    if (stObj->pt)
 126       pipe_resource_reference(&stObj->pt, NULL);
 127    if (stObj->sampler_view) {
 128       if (stObj->sampler_view->context != ctx->st->pipe) {
 129          /* Take "ownership" of this texture sampler view by setting
 130           * its context pointer to this context.  This avoids potential
 131           * crashes when the texture object is shared among contexts
 132           * and the original/owner context has already been destroyed.
 133           */
 134          stObj->sampler_view->context = ctx->st->pipe;
 135       }
 136       pipe_sampler_view_reference(&stObj->sampler_view, NULL);
 137    }
 138    _mesa_delete_texture_object(ctx, texObj);
 139 }
 140
 141
 142 /** called via ctx->Driver.FreeTexImageData() */
 143 static void
 144 st_FreeTextureImageData(GLcontext * ctx, struct gl_texture_image *texImage)
 145 {
 146    struct st_texture_image *stImage = st_texture_image(texImage);
 147
 148    DBG("%s\n", __FUNCTION__);
 149
 150    if (stImage->pt) {
 151       pipe_resource_reference(&stImage->pt, NULL);
 152    }
 153
 154    if (texImage->Data) {
 155       _mesa_align_free(texImage->Data);
 156       texImage->Data = NULL;
 157    }
 158 }
 159
 160
 161 /**
 162  * From linux kernel i386 header files, copes with odd sizes better
 163  * than COPY_DWORDS would:
 164  * XXX Put this in src/mesa/main/imports.h ???
 165  */
 166 #if defined(PIPE_CC_GCC) && defined(PIPE_ARCH_X86)
 167 static INLINE void *
 168 __memcpy(void *to, const void *from, size_t n)
 169 {
 170    int d0, d1, d2;
 171    __asm__ __volatile__("rep ; movsl\n\t"
 172                         "testb $2,%b4\n\t"
 173                         "je 1f\n\t"
 174                         "movsw\n"
 175                         "1:\ttestb $1,%b4\n\t"
 176                         "je 2f\n\t"
 177                         "movsb\n" "2:":"=&c"(d0), "=&D"(d1), "=&S"(d2)
 178                         :"0"(n / 4), "q"(n), "1"((long) to), "2"((long) from)
 179                         :"memory");
 180    return (to);
 181 }
 182 #else
 183 #define __memcpy(a,b,c) memcpy(a,b,c)
 184 #endif
 185
 186
 187 /**
 188  * The system memcpy (at least on ubuntu 5.10) has problems copying
 189  * to agp (writecombined) memory from a source which isn't 64-byte
 190  * aligned - there is a 4x performance falloff.
 191  *
 192  * The x86 __memcpy is immune to this but is slightly slower
 193  * (10%-ish) than the system memcpy.
 194  *
 195  * The sse_memcpy seems to have a slight cliff at 64/32 bytes, but
 196  * isn't much faster than x86_memcpy for agp copies.
 197  *
 198  * TODO: switch dynamically.
 199  */
 200 static void *
 201 do_memcpy(void *dest, const void *src, size_t n)
 202 {
 203    if ((((unsigned long) src) & 63) || (((unsigned long) dest) & 63)) {
 204       return __memcpy(dest, src, n);
 205    }
 206    else
 207       return memcpy(dest, src, n);
 208 }
 209
 210
 211 /**
 212  * Return default texture usage bitmask for the given texture format.
 213  */
 214 static GLuint
 215 default_usage(enum pipe_format fmt)
 216 {
 217    GLuint usage = PIPE_BIND_SAMPLER_VIEW;
 218    if (util_format_is_depth_or_stencil(fmt))
 219       usage |= PIPE_BIND_DEPTH_STENCIL;
 220    else
 221       usage |= PIPE_BIND_RENDER_TARGET;
 222    return usage;
 223 }
 224
 225
 226 /**
 227  * Allocate a pipe_resource object for the given st_texture_object using
 228  * the given st_texture_image to guess the mipmap size/levels.
 229  *
 230  * [comments...]
 231  * Otherwise, store it in memory if (Border != 0) or (any dimension ==
 232  * 1).
 233  *
 234  * Otherwise, if max_level >= level >= min_level, create texture with
 235  * space for images from min_level down to max_level.
 236  *
 237  * Otherwise, create texture with space for images from (level 0)..(1x1).
 238  * Consider pruning this texture at a validation if the saving is worth it.
 239  */
 240 static void
 241 guess_and_alloc_texture(struct st_context *st,
 242                         struct st_texture_object *stObj,
 243                         const struct st_texture_image *stImage)
 244 {
 245    GLuint firstLevel;
 246    GLuint lastLevel;
 247    GLuint width = stImage->base.Width2;  /* size w/out border */
 248    GLuint height = stImage->base.Height2;
 249    GLuint depth = stImage->base.Depth2;
 250    GLuint i, usage;
 251    enum pipe_format fmt;
 252
 253    DBG("%s\n", __FUNCTION__);
 254
 255    assert(!stObj->pt);
 256
 257    if (stObj->pt &&
 258        (GLint) stImage->level > stObj->base.BaseLevel &&
 259        (stImage->base.Width == 1 ||
 260         (stObj->base.Target != GL_TEXTURE_1D &&
 261          stImage->base.Height == 1) ||
 262         (stObj->base.Target == GL_TEXTURE_3D &&
 263          stImage->base.Depth == 1)))
 264       return;
 265
 266    /* If this image disrespects BaseLevel, allocate from level zero.
 267     * Usually BaseLevel == 0, so it's unlikely to happen.
 268     */
 269    if ((GLint) stImage->level < stObj->base.BaseLevel)
 270       firstLevel = 0;
 271    else
 272       firstLevel = stObj->base.BaseLevel;
 273
 274
 275    /* Figure out image dimensions at start level.
 276     */
 277    for (i = stImage->level; i > firstLevel; i--) {
 278       if (width != 1)
 279          width <<= 1;
 280       if (height != 1)
 281          height <<= 1;
 282       if (depth != 1)
 283          depth <<= 1;
 284    }
 285
 286    if (width == 0 || height == 0 || depth == 0) {
 287       /* no texture needed */
 288       return;
 289    }
 290
 291    /* Guess a reasonable value for lastLevel.  This is probably going
 292     * to be wrong fairly often and might mean that we have to look at
 293     * resizable buffers, or require that buffers implement lazy
 294     * pagetable arrangements.
 295     */
 296    if ((stObj->base.MinFilter == GL_NEAREST ||
 297         stObj->base.MinFilter == GL_LINEAR ||
 298         stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
 299         stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) &&
 300        !stObj->base.GenerateMipmap &&
 301        stImage->level == firstLevel) {
 302       /* only alloc space for a single mipmap level */
 303       lastLevel = firstLevel;
 304    }
 305    else {
 306       /* alloc space for a full mipmap */
 307       GLuint l2width = util_logbase2(width);
 308       GLuint l2height = util_logbase2(height);
 309       GLuint l2depth = util_logbase2(depth);
 310       lastLevel = firstLevel + MAX2(MAX2(l2width, l2height), l2depth);
 311    }
 312
 313    fmt = st_mesa_format_to_pipe_format(stImage->base.TexFormat);
 314
 315    usage = default_usage(fmt);
 316
 317    stObj->pt = st_texture_create(st,
 318                                  gl_target_to_pipe(stObj->base.Target),
 319                                  fmt,
 320                                  lastLevel,
 321                                  width,
 322                                  height,
 323                                  depth,
 324                                  usage);
 325
 326    stObj->pipe = st->pipe;
 327
 328    DBG("%s - success\n", __FUNCTION__);
 329 }
 330
 331
 332 /**
 333  * Adjust pixel unpack params and image dimensions to strip off the
 334  * texture border.
 335  * Gallium doesn't support texture borders.  They've seldem been used
 336  * and seldom been implemented correctly anyway.
 337  * \param unpackNew  returns the new pixel unpack parameters
 338  */
 339 static void
 340 strip_texture_border(GLint border,
 341                      GLint *width, GLint *height, GLint *depth,
 342                      const struct gl_pixelstore_attrib *unpack,
 343                      struct gl_pixelstore_attrib *unpackNew)
 344 {
 345    assert(border > 0);  /* sanity check */
 346
 347    *unpackNew = *unpack;
 348
 349    if (unpackNew->RowLength == 0)
 350       unpackNew->RowLength = *width;
 351
 352    if (depth && unpackNew->ImageHeight == 0)
 353       unpackNew->ImageHeight = *height;
 354
 355    unpackNew->SkipPixels += border;
 356    if (height)
 357       unpackNew->SkipRows += border;
 358    if (depth)
 359       unpackNew->SkipImages += border;
 360
 361    assert(*width >= 3);
 362    *width = *width - 2 * border;
 363    if (height && *height >= 3)
 364       *height = *height - 2 * border;
 365    if (depth && *depth >= 3)
 366       *depth = *depth - 2 * border;
 367 }
 368
 369
 370 /**
 371  * Try to do texture compression via rendering.  If the Gallium driver
 372  * can render into a compressed surface this will allow us to do texture
 373  * compression.
 374  * \return GL_TRUE for success, GL_FALSE for failure
 375  */
 376 static GLboolean
 377 compress_with_blit(GLcontext * ctx,
 378                    GLenum target, GLint level,
 379                    GLint xoffset, GLint yoffset, GLint zoffset,
 380                    GLint width, GLint height, GLint depth,
 381                    GLenum format, GLenum type, const void *pixels,
 382                    const struct gl_pixelstore_attrib *unpack,
 383                    struct gl_texture_image *texImage)
 384 {
 385    const GLuint dstImageOffsets[1] = {0};
 386    struct st_texture_image *stImage = st_texture_image(texImage);
 387    struct pipe_context *pipe = ctx->st->pipe;
 388    struct pipe_screen *screen = pipe->screen;
 389    gl_format mesa_format;
 390    struct pipe_resource templ;
 391    struct pipe_resource *src_tex;
 392    struct pipe_sampler_view view_templ;
 393    struct pipe_sampler_view *src_view;
 394    struct pipe_surface *dst_surface;
 395    struct pipe_transfer *tex_xfer;
 396    void *map;
 397
 398    if (!stImage->pt) {
 399       /* XXX: Can this happen? Should we assert? */
 400       return GL_FALSE;
 401    }
 402
 403    /* get destination surface (in the compressed texture) */
 404    dst_surface = screen->get_tex_surface(screen, stImage->pt,
 405                                          stImage->face, stImage->level, 0,
 406                                          PIPE_BIND_BLIT_DESTINATION);
 407    if (!dst_surface) {
 408       /* can't render into this format (or other problem) */
 409       return GL_FALSE;
 410    }
 411
 412    /* Choose format for the temporary RGBA texture image.
 413     */
 414    mesa_format = st_ChooseTextureFormat(ctx, GL_RGBA, format, type);
 415    assert(mesa_format);
 416    if (!mesa_format)
 417       return GL_FALSE;
 418
 419    /* Create the temporary source texture
 420     */
 421    memset(&templ, 0, sizeof(templ));
 422    templ.target = PIPE_TEXTURE_2D;
 423    templ.format = st_mesa_format_to_pipe_format(mesa_format);
 424    templ.width0 = width;
 425    templ.height0 = height;
 426    templ.depth0 = 1;
 427    templ.last_level = 0;
 428    templ._usage = PIPE_USAGE_DEFAULT;
 429    templ.bind = PIPE_BIND_SAMPLER_VIEW;
 430    src_tex = screen->resource_create(screen, &templ);
 431
 432    if (!src_tex)
 433       return GL_FALSE;
 434
 435    /* Put user's tex data into the temporary texture
 436     */
 437    tex_xfer = st_cond_flush_get_tex_transfer(st_context(ctx), src_tex,
 438                                              0, 0, 0, /* face, level are zero */
 439                                              PIPE_TRANSFER_WRITE,
 440                                              0, 0, width, height); /* x, y, w, h */
 441    map = pipe_transfer_map(pipe, tex_xfer);
 442
 443    _mesa_texstore(ctx, 2, GL_RGBA, mesa_format,
 444                   map,              /* dest ptr */
 445                   0, 0, 0,          /* dest x/y/z offset */
 446                   tex_xfer->stride, /* dest row stride (bytes) */
 447                   dstImageOffsets,  /* image offsets (for 3D only) */
 448                   width, height, 1, /* size */
 449                   format, type,     /* source format/type */
 450                   pixels,           /* source data */
 451                   unpack);          /* source data packing */
 452
 453    pipe_transfer_unmap(pipe, tex_xfer);
 454    pipe->transfer_destroy(pipe, tex_xfer);
 455
 456    /* Create temporary sampler view */
 457    u_sampler_view_default_template(&view_templ,
 458                                    src_tex,
 459                                    src_tex->format);
 460    src_view = pipe->create_sampler_view(pipe, src_tex, &view_templ);
 461
 462
 463    /* copy / compress image */
 464    util_blit_pixels_tex(ctx->st->blit,
 465                         src_view,         /* sampler view (src) */
 466                         0, 0,             /* src x0, y0 */
 467                         width, height,    /* src x1, y1 */
 468                         dst_surface,      /* pipe_surface (dst) */
 469                         xoffset, yoffset, /* dst x0, y0 */
 470                         xoffset + width,  /* dst x1 */
 471                         yoffset + height, /* dst y1 */
 472                         0.0,              /* z */
 473                         PIPE_TEX_MIPFILTER_NEAREST);
 474
 475    pipe_surface_reference(&dst_surface, NULL);
 476    pipe_resource_reference(&src_tex, NULL);
 477    pipe_sampler_view_reference(&src_view, NULL);
 478
 479    return GL_TRUE;
 480 }
 481
 482
 483 /**
 484  * Do glTexImage1/2/3D().
 485  */
 486 static void
 487 st_TexImage(GLcontext * ctx,
 488             GLint dims,
 489             GLenum target, GLint level,
 490             GLint internalFormat,
 491             GLint width, GLint height, GLint depth,
 492             GLint border,
 493             GLenum format, GLenum type, const void *pixels,
 494             const struct gl_pixelstore_attrib *unpack,
 495             struct gl_texture_object *texObj,
 496             struct gl_texture_image *texImage,
 497             GLsizei imageSize, GLboolean compressed_src)
 498 {
 499    struct pipe_screen *screen = ctx->st->pipe->screen;
 500    struct st_texture_object *stObj = st_texture_object(texObj);
 501    struct st_texture_image *stImage = st_texture_image(texImage);
 502    GLint postConvWidth, postConvHeight;
 503    GLint texelBytes, sizeInBytes;
 504    GLuint dstRowStride = 0;
 505    struct gl_pixelstore_attrib unpackNB;
 506    enum pipe_transfer_usage transfer_usage = 0;
 507
 508    DBG("%s target %s level %d %dx%dx%d border %d\n", __FUNCTION__,
 509        _mesa_lookup_enum_by_nr(target), level, width, height, depth, border);
 510
 511    /* switch to "normal" */
 512    if (stObj->surface_based) {
 513       _mesa_clear_texture_object(ctx, texObj);
 514       stObj->surface_based = GL_FALSE;
 515    }
 516
 517    /* gallium does not support texture borders, strip it off */
 518    if (border) {
 519       strip_texture_border(border, &width, &height, &depth, unpack, &unpackNB);
 520       unpack = &unpackNB;
 521       texImage->Width = width;
 522       texImage->Height = height;
 523       texImage->Depth = depth;
 524       texImage->Border = 0;
 525       border = 0;
 526    }
 527
 528    postConvWidth = width;
 529    postConvHeight = height;
 530
 531    stImage->face = _mesa_tex_target_to_face(target);
 532    stImage->level = level;
 533
 534 #if FEATURE_convolve
 535    if (ctx->_ImageTransferState & IMAGE_CONVOLUTION_BIT) {
 536       _mesa_adjust_image_for_convolution(ctx, dims, &postConvWidth,
 537                                          &postConvHeight);
 538    }
 539 #endif
 540
 541    _mesa_set_fetch_functions(texImage, dims);
 542
 543    if (_mesa_is_format_compressed(texImage->TexFormat)) {
 544       /* must be a compressed format */
 545       texelBytes = 0;
 546    }
 547    else {
 548       texelBytes = _mesa_get_format_bytes(texImage->TexFormat);
 549
 550       /* Minimum pitch of 32 bytes */
 551       if (postConvWidth * texelBytes < 32) {
 552          postConvWidth = 32 / texelBytes;
 553          texImage->RowStride = postConvWidth;
 554       }
 555
 556       /* we'll set RowStride elsewhere when the texture is a "mapped" state */
 557       /*assert(texImage->RowStride == postConvWidth);*/
 558    }
 559
 560    /* Release the reference to a potentially orphaned buffer.
 561     * Release any old malloced memory.
 562     */
 563    if (stImage->pt) {
 564       pipe_resource_reference(&stImage->pt, NULL);
 565       assert(!texImage->Data);
 566    }
 567    else if (texImage->Data) {
 568       _mesa_align_free(texImage->Data);
 569    }
 570
 571    /*
 572     * See if the new image is somehow incompatible with the existing
 573     * mipmap.  If so, free the old mipmap.
 574     */
 575    if (stObj->pt) {
 576       if (stObj->teximage_realloc ||
 577           level > (GLint) stObj->pt->last_level ||
 578           !st_texture_match_image(stObj->pt, &stImage->base,
 579                                   stImage->face, stImage->level)) {
 580          DBG("release it\n");
 581          pipe_resource_reference(&stObj->pt, NULL);
 582          assert(!stObj->pt);
 583          pipe_sampler_view_reference(&stObj->sampler_view, NULL);
 584          stObj->teximage_realloc = FALSE;
 585       }
 586    }
 587
 588    if (width == 0 || height == 0 || depth == 0) {
 589       /* stop after freeing old image */
 590       return;
 591    }
 592
 593    if (!stObj->pt) {
 594       guess_and_alloc_texture(ctx->st, stObj, stImage);
 595       if (!stObj->pt) {
 596          /* Probably out of memory.
 597           * Try flushing any pending rendering, then retry.
 598           */
 599          st_finish(ctx->st);
 600          guess_and_alloc_texture(ctx->st, stObj, stImage);
 601          if (!stObj->pt) {
 602             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
 603             return;
 604          }
 605       }
 606    }
 607
 608    assert(!stImage->pt);
 609
 610    if (stObj->pt &&
 611        st_texture_match_image(stObj->pt, &stImage->base,
 612                                  stImage->face, stImage->level)) {
 613
 614       pipe_resource_reference(&stImage->pt, stObj->pt);
 615       assert(stImage->pt);
 616    }
 617
 618    if (!stImage->pt)
 619       DBG("XXX: Image did not fit into texture - storing in local memory!\n");
 620
 621    /* st_CopyTexImage calls this function with pixels == NULL, with
 622     * the expectation that the texture will be set up but nothing
 623     * more will be done.  This is where those calls return:
 624     */
 625    if (compressed_src) {
 626       pixels = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, pixels,
 627                                                       unpack,
 628                                                       "glCompressedTexImage");
 629    }
 630    else {
 631       pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, 1,
 632                                            format, type,
 633                                            pixels, unpack, "glTexImage");
 634    }
 635
 636    /* Note: we can't check for pixels==NULL until after we've allocated
 637     * memory for the texture.
 638     */
 639
 640    /* See if we can do texture compression with a blit/render.
 641     */
 642    if (!compressed_src &&
 643        !ctx->Mesa_DXTn &&
 644        _mesa_is_format_compressed(texImage->TexFormat) &&
 645        screen->is_format_supported(screen,
 646                                    stImage->pt->format,
 647                                    stImage->pt->target,
 648                                    PIPE_BIND_RENDER_TARGET, 0)) {
 649       if (!pixels)
 650          goto done;
 651
 652       if (compress_with_blit(ctx, target, level, 0, 0, 0, width, height, depth,
 653                              format, type, pixels, unpack, texImage)) {
 654          goto done;
 655       }
 656    }
 657
 658    if (stImage->pt) {
 659       if (format == GL_DEPTH_COMPONENT &&
 660           util_format_is_depth_and_stencil(stImage->pt->format))
 661          transfer_usage = PIPE_TRANSFER_READ_WRITE;
 662       else
 663          transfer_usage = PIPE_TRANSFER_WRITE;
 664
 665       texImage->Data = st_texture_image_map(ctx->st, stImage, 0,
 666                                             transfer_usage, 0, 0,
 667                                             stImage->base.Width,
 668                                             stImage->base.Height);
 669       if(stImage->transfer)
 670          dstRowStride = stImage->transfer->stride;
 671    }
 672    else {
 673       /* Allocate regular memory and store the image there temporarily.   */
 674       if (_mesa_is_format_compressed(texImage->TexFormat)) {
 675          sizeInBytes = _mesa_format_image_size(texImage->TexFormat,
 676                                                texImage->Width,
 677                                                texImage->Height,
 678                                                texImage->Depth);
 679          dstRowStride = _mesa_format_row_stride(texImage->TexFormat, width);
 680          assert(dims != 3);
 681       }
 682       else {
 683          dstRowStride = postConvWidth * texelBytes;
 684          sizeInBytes = depth * dstRowStride * postConvHeight;
 685       }
 686
 687       texImage->Data = _mesa_align_malloc(sizeInBytes, 16);
 688    }
 689
 690    if (!texImage->Data) {
 691       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
 692       return;
 693    }
 694
 695    if (!pixels)
 696       goto done;
 697
 698    DBG("Upload image %dx%dx%d row_len %x pitch %x\n",
 699        width, height, depth, width * texelBytes, dstRowStride);
 700
 701    /* Copy data.  Would like to know when it's ok for us to eg. use
 702     * the blitter to copy.  Or, use the hardware to do the format
 703     * conversion and copy:
 704     */
 705    if (compressed_src) {
 706       const GLuint srcImageStride = _mesa_format_row_stride(texImage->TexFormat, width);
 707       if(dstRowStride == srcImageStride)
 708          memcpy(texImage->Data, pixels, imageSize);
 709       else
 710       {
 711          char *dst = texImage->Data;
 712          const char *src = pixels;
 713          GLuint i, bw, bh, lines;
 714          _mesa_get_format_block_size(texImage->TexFormat, &bw, &bh);
 715          lines = (height + bh - 1) / bh;
 716
 717          for(i = 0; i < lines; ++i)
 718          {
 719             memcpy(dst, src, srcImageStride);
 720             dst += dstRowStride;
 721             src += srcImageStride;
 722          }
 723       }
 724    }
 725    else {
 726       const GLuint srcImageStride =
 727          _mesa_image_image_stride(unpack, width, height, format, type);
 728       GLint i;
 729       const GLubyte *src = (const GLubyte *) pixels;
 730
 731       for (i = 0; i < depth; i++) {
 732          if (!_mesa_texstore(ctx, dims,
 733                              texImage->_BaseFormat,
 734                              texImage->TexFormat,
 735                              texImage->Data,
 736                              0, 0, 0, /* dstX/Y/Zoffset */
 737                              dstRowStride,
 738                              texImage->ImageOffsets,
 739                              width, height, 1,
 740                              format, type, src, unpack)) {
 741             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
 742          }
 743
 744          if (stImage->pt && i + 1 < depth) {
 745             /* unmap this slice */
 746             st_texture_image_unmap(ctx->st, stImage);
 747             /* map next slice of 3D texture */
 748             texImage->Data = st_texture_image_map(ctx->st, stImage, i + 1,
 749                                                   transfer_usage, 0, 0,
 750                                                   stImage->base.Width,
 751                                                   stImage->base.Height);
 752             src += srcImageStride;
 753          }
 754       }
 755    }
 756
 757 done:
 758    _mesa_unmap_teximage_pbo(ctx, unpack);
 759
 760    if (stImage->pt && texImage->Data) {
 761       st_texture_image_unmap(ctx->st, stImage);
 762       texImage->Data = NULL;
 763    }
 764 }
 765
 766
 767 static void
 768 st_TexImage3D(GLcontext * ctx,
 769               GLenum target, GLint level,
 770               GLint internalFormat,
 771               GLint width, GLint height, GLint depth,
 772               GLint border,
 773               GLenum format, GLenum type, const void *pixels,
 774               const struct gl_pixelstore_attrib *unpack,
 775               struct gl_texture_object *texObj,
 776               struct gl_texture_image *texImage)
 777 {
 778    st_TexImage(ctx, 3, target, level, internalFormat, width, height, depth,
 779                border, format, type, pixels, unpack, texObj, texImage,
 780                0, GL_FALSE);
 781 }
 782
 783
 784 static void
 785 st_TexImage2D(GLcontext * ctx,
 786               GLenum target, GLint level,
 787               GLint internalFormat,
 788               GLint width, GLint height, GLint border,
 789               GLenum format, GLenum type, const void *pixels,
 790               const struct gl_pixelstore_attrib *unpack,
 791               struct gl_texture_object *texObj,
 792               struct gl_texture_image *texImage)
 793 {
 794    st_TexImage(ctx, 2, target, level, internalFormat, width, height, 1, border,
 795                format, type, pixels, unpack, texObj, texImage, 0, GL_FALSE);
 796 }
 797
 798
 799 static void
 800 st_TexImage1D(GLcontext * ctx,
 801               GLenum target, GLint level,
 802               GLint internalFormat,
 803               GLint width, GLint border,
 804               GLenum format, GLenum type, const void *pixels,
 805               const struct gl_pixelstore_attrib *unpack,
 806               struct gl_texture_object *texObj,
 807               struct gl_texture_image *texImage)
 808 {
 809    st_TexImage(ctx, 1, target, level, internalFormat, width, 1, 1, border,
 810                format, type, pixels, unpack, texObj, texImage, 0, GL_FALSE);
 811 }
 812
 813
 814 static void
 815 st_CompressedTexImage2D(GLcontext *ctx, GLenum target, GLint level,
 816                         GLint internalFormat,
 817                         GLint width, GLint height, GLint border,
 818                         GLsizei imageSize, const GLvoid *data,
 819                         struct gl_texture_object *texObj,
 820                         struct gl_texture_image *texImage)
 821 {
 822    st_TexImage(ctx, 2, target, level, internalFormat, width, height, 1, border,
 823                0, 0, data, &ctx->Unpack, texObj, texImage, imageSize, GL_TRUE);
 824 }
 825
 826
 827
 828 /**
 829  * glGetTexImage() helper: decompress a compressed texture by rendering
 830  * a textured quad.  Store the results in the user's buffer.
 831  */
 832 static void
 833 decompress_with_blit(GLcontext * ctx, GLenum target, GLint level,
 834                      GLenum format, GLenum type, GLvoid *pixels,
 835                      struct gl_texture_object *texObj,
 836                      struct gl_texture_image *texImage)
 837 {
 838    struct pipe_context *pipe = ctx->st->pipe;
 839    struct pipe_screen *screen = pipe->screen;
 840    struct st_texture_image *stImage = st_texture_image(texImage);
 841    struct st_texture_object *stObj = st_texture_object(texObj);
 842    struct pipe_sampler_view *src_view = st_get_stobj_sampler_view(stObj);
 843    const GLuint width = texImage->Width;
 844    const GLuint height = texImage->Height;
 845    struct pipe_surface *dst_surface;
 846    struct pipe_resource *dst_texture;
 847    struct pipe_transfer *tex_xfer;
 848    unsigned bind = (PIPE_BIND_BLIT_DESTINATION |
 849                     PIPE_BIND_RENDER_TARGET | /* util_blit may choose to render */
 850                     PIPE_BIND_TRANSFER_READ);
 851
 852    /* create temp / dest surface */
 853    if (!util_create_rgba_surface(screen, width, height, bind,
 854                                  &dst_texture, &dst_surface)) {
 855       _mesa_problem(ctx, "util_create_rgba_surface() failed "
 856                     "in decompress_with_blit()");
 857       return;
 858    }
 859
 860    /* blit/render/decompress */
 861    util_blit_pixels_tex(ctx->st->blit,
 862                         src_view,      /* pipe_resource (src) */
 863                         0, 0,             /* src x0, y0 */
 864                         width, height,    /* src x1, y1 */
 865                         dst_surface,      /* pipe_surface (dst) */
 866                         0, 0,             /* dst x0, y0 */
 867                         width, height,    /* dst x1, y1 */
 868                         0.0,              /* z */
 869                         PIPE_TEX_MIPFILTER_NEAREST);
 870
 871    /* map the dst_surface so we can read from it */
 872    tex_xfer = st_cond_flush_get_tex_transfer(st_context(ctx),
 873                                              dst_texture, 0, 0, 0,
 874                                              PIPE_TRANSFER_READ,
 875                                              0, 0, width, height);
 876
 877    pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
 878
 879    /* copy/pack data into user buffer */
 880    if (st_equal_formats(stImage->pt->format, format, type)) {
 881       /* memcpy */
 882       const uint bytesPerRow = width * util_format_get_blocksize(stImage->pt->format);
 883       ubyte *map = pipe_transfer_map(pipe, tex_xfer);
 884       GLuint row;
 885       for (row = 0; row < height; row++) {
 886          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
 887                                               height, format, type, row, 0);
 888          memcpy(dest, map, bytesPerRow);
 889          map += tex_xfer->stride;
 890       }
 891       pipe_transfer_unmap(pipe, tex_xfer);
 892    }
 893    else {
 894       /* format translation via floats */
 895       GLuint row;
 896       for (row = 0; row < height; row++) {
 897          const GLbitfield transferOps = 0x0; /* bypassed for glGetTexImage() */
 898          GLfloat rgba[4 * MAX_WIDTH];
 899          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
 900                                               height, format, type, row, 0);
 901
 902          if (ST_DEBUG & DEBUG_FALLBACK)
 903             debug_printf("%s: fallback format translation\n", __FUNCTION__);
 904
 905          /* get float[4] rgba row from surface */
 906          pipe_get_tile_rgba(pipe, tex_xfer, 0, row, width, 1, rgba);
 907
 908          _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
 909                                     type, dest, &ctx->Pack, transferOps);
 910       }
 911    }
 912
 913    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 914
 915    pipe->transfer_destroy(pipe, tex_xfer);
 916
 917    /* destroy the temp / dest surface */
 918    util_destroy_rgba_surface(dst_texture, dst_surface);
 919 }
 920
 921
 922
 923 /**
 924  * Need to map texture image into memory before copying image data,
 925  * then unmap it.
 926  */
 927 static void
 928 st_get_tex_image(GLcontext * ctx, GLenum target, GLint level,
 929                  GLenum format, GLenum type, GLvoid * pixels,
 930                  struct gl_texture_object *texObj,
 931                  struct gl_texture_image *texImage, GLboolean compressed_dst)
 932 {
 933    struct st_texture_image *stImage = st_texture_image(texImage);
 934    const GLuint dstImageStride =
 935       _mesa_image_image_stride(&ctx->Pack, texImage->Width, texImage->Height,
 936                                format, type);
 937    GLuint depth, i;
 938    GLubyte *dest;
 939
 940    if (stImage->pt &&
 941        util_format_is_s3tc(stImage->pt->format) &&
 942        !compressed_dst) {
 943       /* Need to decompress the texture.
 944        * We'll do this by rendering a textured quad.
 945        * Note that we only expect RGBA formats (no Z/depth formats).
 946        */
 947       decompress_with_blit(ctx, target, level, format, type, pixels,
 948                            texObj, texImage);
 949       return;
 950    }
 951
 952    /* Map */
 953    if (stImage->pt) {
 954       /* Image is stored in hardware format in a buffer managed by the
 955        * kernel.  Need to explicitly map and unmap it.
 956        */
 957       unsigned face = _mesa_tex_target_to_face(target);
 958
 959       st_teximage_flush_before_map(ctx->st, stImage->pt, face, level,
 960                                    PIPE_TRANSFER_READ);
 961
 962       texImage->Data = st_texture_image_map(ctx->st, stImage, 0,
 963                                             PIPE_TRANSFER_READ, 0, 0,
 964                                             stImage->base.Width,
 965                                             stImage->base.Height);
 966       texImage->RowStride = stImage->transfer->stride / util_format_get_blocksize(stImage->pt->format);
 967    }
 968    else {
 969       /* Otherwise, the image should actually be stored in
 970        * texImage->Data.  This is pretty confusing for
 971        * everybody, I'd much prefer to separate the two functions of
 972        * texImage->Data - storage for texture images in main memory
 973        * and access (ie mappings) of images.  In other words, we'd
 974        * create a new texImage->Map field and leave Data simply for
 975        * storage.
 976        */
 977       assert(texImage->Data);
 978    }
 979
 980    depth = texImage->Depth;
 981    texImage->Depth = 1;
 982
 983    dest = (GLubyte *) pixels;
 984
 985    for (i = 0; i < depth; i++) {
 986       if (compressed_dst) {
 987          _mesa_get_compressed_teximage(ctx, target, level, dest,
 988                                        texObj, texImage);
 989       }
 990       else {
 991          _mesa_get_teximage(ctx, target, level, format, type, dest,
 992                             texObj, texImage);
 993       }
 994
 995       if (stImage->pt && i + 1 < depth) {
 996          /* unmap this slice */
 997          st_texture_image_unmap(ctx->st, stImage);
 998          /* map next slice of 3D texture */
 999          texImage->Data = st_texture_image_map(ctx->st, stImage, i + 1,
1000                                                PIPE_TRANSFER_READ, 0, 0,
1001                                                stImage->base.Width,
1002                                                stImage->base.Height);
1003          dest += dstImageStride;
1004       }
1005    }
1006
1007    texImage->Depth = depth;
1008
1009    /* Unmap */
1010    if (stImage->pt) {
1011       st_texture_image_unmap(ctx->st, stImage);
1012       texImage->Data = NULL;
1013    }
1014 }
1015
1016
1017 static void
1018 st_GetTexImage(GLcontext * ctx, GLenum target, GLint level,
1019                GLenum format, GLenum type, GLvoid * pixels,
1020                struct gl_texture_object *texObj,
1021                struct gl_texture_image *texImage)
1022 {
1023    st_get_tex_image(ctx, target, level, format, type, pixels, texObj, texImage,
1024                     GL_FALSE);
1025 }
1026
1027
1028 static void
1029 st_GetCompressedTexImage(GLcontext *ctx, GLenum target, GLint level,
1030                          GLvoid *pixels,
1031                          struct gl_texture_object *texObj,
1032                          struct gl_texture_image *texImage)
1033 {
1034    st_get_tex_image(ctx, target, level, 0, 0, pixels, texObj, texImage,
1035                     GL_TRUE);
1036 }
1037
1038
1039
1040 static void
1041 st_TexSubimage(GLcontext *ctx, GLint dims, GLenum target, GLint level,
1042                GLint xoffset, GLint yoffset, GLint zoffset,
1043                GLint width, GLint height, GLint depth,
1044                GLenum format, GLenum type, const void *pixels,
1045                const struct gl_pixelstore_attrib *packing,
1046                struct gl_texture_object *texObj,
1047                struct gl_texture_image *texImage)
1048 {
1049    struct pipe_screen *screen = ctx->st->pipe->screen;
1050    struct st_texture_image *stImage = st_texture_image(texImage);
1051    GLuint dstRowStride;
1052    const GLuint srcImageStride =
1053       _mesa_image_image_stride(packing, width, height, format, type);
1054    GLint i;
1055    const GLubyte *src;
1056    /* init to silence warning only: */
1057    enum pipe_transfer_usage transfer_usage = PIPE_TRANSFER_WRITE;
1058
1059    DBG("%s target %s level %d offset %d,%d %dx%d\n", __FUNCTION__,
1060        _mesa_lookup_enum_by_nr(target),
1061        level, xoffset, yoffset, width, height);
1062
1063    pixels =
1064       _mesa_validate_pbo_teximage(ctx, dims, width, height, depth, format,
1065                                   type, pixels, packing, "glTexSubImage2D");
1066    if (!pixels)
1067       return;
1068
1069    /* See if we can do texture compression with a blit/render.
1070     */
1071    if (!ctx->Mesa_DXTn &&
1072        _mesa_is_format_compressed(texImage->TexFormat) &&
1073        screen->is_format_supported(screen,
1074                                    stImage->pt->format,
1075                                    stImage->pt->target,
1076                                    PIPE_BIND_RENDER_TARGET, 0)) {
1077       if (compress_with_blit(ctx, target, level,
1078                              xoffset, yoffset, zoffset,
1079                              width, height, depth,
1080                              format, type, pixels, packing, texImage)) {
1081          goto done;
1082       }
1083    }
1084
1085    /* Map buffer if necessary.  Need to lock to prevent other contexts
1086     * from uploading the buffer under us.
1087     */
1088    if (stImage->pt) {
1089       unsigned face = _mesa_tex_target_to_face(target);
1090
1091       if (format == GL_DEPTH_COMPONENT &&
1092           util_format_is_depth_and_stencil(stImage->pt->format))
1093          transfer_usage = PIPE_TRANSFER_READ_WRITE;
1094       else
1095          transfer_usage = PIPE_TRANSFER_WRITE;
1096
1097       st_teximage_flush_before_map(ctx->st, stImage->pt, face, level,
1098                                    transfer_usage);
1099       texImage->Data = st_texture_image_map(ctx->st, stImage, zoffset,
1100                                             transfer_usage,
1101                                             xoffset, yoffset,
1102                                             width, height);
1103    }
1104
1105    if (!texImage->Data) {
1106       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
1107       goto done;
1108    }
1109
1110    src = (const GLubyte *) pixels;
1111    dstRowStride = stImage->transfer->stride;
1112
1113    for (i = 0; i < depth; i++) {
1114       if (!_mesa_texstore(ctx, dims, texImage->_BaseFormat,
1115                           texImage->TexFormat,
1116                           texImage->Data,
1117                           0, 0, 0,
1118                           dstRowStride,
1119                           texImage->ImageOffsets,
1120                           width, height, 1,
1121                           format, type, src, packing)) {
1122          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
1123       }
1124
1125       if (stImage->pt && i + 1 < depth) {
1126          /* unmap this slice */
1127          st_texture_image_unmap(ctx->st, stImage);
1128          /* map next slice of 3D texture */
1129          texImage->Data = st_texture_image_map(ctx->st, stImage,
1130                                                zoffset + i + 1,
1131                                                transfer_usage,
1132                                                xoffset, yoffset,
1133                                                width, height);
1134          src += srcImageStride;
1135       }
1136    }
1137
1138 done:
1139    _mesa_unmap_teximage_pbo(ctx, packing);
1140
1141    if (stImage->pt && texImage->Data) {
1142       st_texture_image_unmap(ctx->st, stImage);
1143       texImage->Data = NULL;
1144    }
1145 }
1146
1147
1148
1149 static void
1150 st_TexSubImage3D(GLcontext *ctx, GLenum target, GLint level,
1151                  GLint xoffset, GLint yoffset, GLint zoffset,
1152                  GLsizei width, GLsizei height, GLsizei depth,
1153                  GLenum format, GLenum type, const GLvoid *pixels,
1154                  const struct gl_pixelstore_attrib *packing,
1155                  struct gl_texture_object *texObj,
1156                  struct gl_texture_image *texImage)
1157 {
1158    st_TexSubimage(ctx, 3, target, level, xoffset, yoffset, zoffset,
1159                   width, height, depth, format, type,
1160                   pixels, packing, texObj, texImage);
1161 }
1162
1163
1164 static void
1165 st_TexSubImage2D(GLcontext *ctx, GLenum target, GLint level,
1166                  GLint xoffset, GLint yoffset,
1167                  GLsizei width, GLsizei height,
1168                  GLenum format, GLenum type, const GLvoid * pixels,
1169                  const struct gl_pixelstore_attrib *packing,
1170                  struct gl_texture_object *texObj,
1171                  struct gl_texture_image *texImage)
1172 {
1173    st_TexSubimage(ctx, 2, target, level, xoffset, yoffset, 0,
1174                   width, height, 1, format, type,
1175                   pixels, packing, texObj, texImage);
1176 }
1177
1178
1179 static void
1180 st_TexSubImage1D(GLcontext *ctx, GLenum target, GLint level,
1181                  GLint xoffset, GLsizei width, GLenum format, GLenum type,
1182                  const GLvoid * pixels,
1183                  const struct gl_pixelstore_attrib *packing,
1184                  struct gl_texture_object *texObj,
1185                  struct gl_texture_image *texImage)
1186 {
1187    st_TexSubimage(ctx, 1, target, level, xoffset, 0, 0, width, 1, 1,
1188                   format, type, pixels, packing, texObj, texImage);
1189 }
1190
1191
1192 static void
1193 st_CompressedTexSubImage1D(GLcontext *ctx, GLenum target, GLint level,
1194                            GLint xoffset, GLsizei width,
1195                            GLenum format,
1196                            GLsizei imageSize, const GLvoid *data,
1197                            struct gl_texture_object *texObj,
1198                            struct gl_texture_image *texImage)
1199 {
1200    assert(0);
1201 }
1202
1203
1204 static void
1205 st_CompressedTexSubImage2D(GLcontext *ctx, GLenum target, GLint level,
1206                            GLint xoffset, GLint yoffset,
1207                            GLsizei width, GLint height,
1208                            GLenum format,
1209                            GLsizei imageSize, const GLvoid *data,
1210                            struct gl_texture_object *texObj,
1211                            struct gl_texture_image *texImage)
1212 {
1213    struct st_texture_image *stImage = st_texture_image(texImage);
1214    int srcBlockStride;
1215    int dstBlockStride;
1216    int y;
1217    enum pipe_format pformat= stImage->pt->format;
1218
1219    if (stImage->pt) {
1220       unsigned face = _mesa_tex_target_to_face(target);
1221
1222       st_teximage_flush_before_map(ctx->st, stImage->pt, face, level,
1223                                    PIPE_TRANSFER_WRITE);
1224       texImage->Data = st_texture_image_map(ctx->st, stImage, 0,
1225                                             PIPE_TRANSFER_WRITE,
1226                                             xoffset, yoffset,
1227                                             width, height);
1228
1229       srcBlockStride = util_format_get_stride(pformat, width);
1230       dstBlockStride = stImage->transfer->stride;
1231    } else {
1232       assert(stImage->pt);
1233       /* TODO find good values for block and strides */
1234       /* TODO also adjust texImage->data for yoffset/xoffset */
1235       return;
1236    }
1237
1238    if (!texImage->Data) {
1239       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage");
1240       return;
1241    }
1242
1243    assert(xoffset % util_format_get_blockwidth(pformat) == 0);
1244    assert(yoffset % util_format_get_blockheight(pformat) == 0);
1245    assert(width % util_format_get_blockwidth(pformat) == 0);
1246    assert(height % util_format_get_blockheight(pformat) == 0);
1247
1248    for (y = 0; y < height; y += util_format_get_blockheight(pformat)) {
1249       /* don't need to adjust for xoffset and yoffset as st_texture_image_map does that */
1250       const char *src = (const char*)data + srcBlockStride * util_format_get_nblocksy(pformat, y);
1251       char *dst = (char*)texImage->Data + dstBlockStride * util_format_get_nblocksy(pformat, y);
1252       memcpy(dst, src, util_format_get_stride(pformat, width));
1253    }
1254
1255    if (stImage->pt) {
1256       st_texture_image_unmap(ctx->st, stImage);
1257       texImage->Data = NULL;
1258    }
1259 }
1260
1261
1262 static void
1263 st_CompressedTexSubImage3D(GLcontext *ctx, GLenum target, GLint level,
1264                            GLint xoffset, GLint yoffset, GLint zoffset,
1265                            GLsizei width, GLint height, GLint depth,
1266                            GLenum format,
1267                            GLsizei imageSize, const GLvoid *data,
1268                            struct gl_texture_object *texObj,
1269                            struct gl_texture_image *texImage)
1270 {
1271    assert(0);
1272 }
1273
1274
1275
1276 /**
1277  * Do a CopyTexSubImage operation using a read transfer from the source,
1278  * a write transfer to the destination and get_tile()/put_tile() to access
1279  * the pixels/texels.
1280  *
1281  * Note: srcY=0=TOP of renderbuffer
1282  */
1283 static void
1284 fallback_copy_texsubimage(GLcontext *ctx, GLenum target, GLint level,
1285                           struct st_renderbuffer *strb,
1286                           struct st_texture_image *stImage,
1287                           GLenum baseFormat,
1288                           GLint destX, GLint destY, GLint destZ,
1289                           GLint srcX, GLint srcY,
1290                           GLsizei width, GLsizei height)
1291 {
1292    struct pipe_context *pipe = ctx->st->pipe;
1293    struct pipe_transfer *src_trans;
1294    GLvoid *texDest;
1295    enum pipe_transfer_usage transfer_usage;
1296
1297    if (ST_DEBUG & DEBUG_FALLBACK)
1298       debug_printf("%s: fallback processing\n", __FUNCTION__);
1299
1300    assert(width <= MAX_WIDTH);
1301
1302    if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1303       srcY = strb->Base.Height - srcY - height;
1304    }
1305
1306    src_trans = st_cond_flush_get_tex_transfer( st_context(ctx),
1307                                                strb->texture,
1308                                                0, 0, 0,
1309                                                PIPE_TRANSFER_READ,
1310                                                srcX, srcY,
1311                                                width, height);
1312
1313    if ((baseFormat == GL_DEPTH_COMPONENT ||
1314         baseFormat == GL_DEPTH_STENCIL) &&
1315        util_format_is_depth_and_stencil(stImage->pt->format))
1316       transfer_usage = PIPE_TRANSFER_READ_WRITE;
1317    else
1318       transfer_usage = PIPE_TRANSFER_WRITE;
1319
1320    st_teximage_flush_before_map(ctx->st, stImage->pt, 0, 0,
1321                                 transfer_usage);
1322
1323    texDest = st_texture_image_map(ctx->st, stImage, 0, transfer_usage,
1324                                   destX, destY, width, height);
1325
1326    if (baseFormat == GL_DEPTH_COMPONENT ||
1327        baseFormat == GL_DEPTH_STENCIL) {
1328       const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
1329                                      ctx->Pixel.DepthBias != 0.0F);
1330       GLint row, yStep;
1331
1332       /* determine bottom-to-top vs. top-to-bottom order for src buffer */
1333       if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1334          srcY = height - 1;
1335          yStep = -1;
1336       }
1337       else {
1338          srcY = 0;
1339          yStep = 1;
1340       }
1341
1342       /* To avoid a large temp memory allocation, do copy row by row */
1343       for (row = 0; row < height; row++, srcY += yStep) {
1344          uint data[MAX_WIDTH];
1345          pipe_get_tile_z(pipe, src_trans, 0, srcY, width, 1, data);
1346          if (scaleOrBias) {
1347             _mesa_scale_and_bias_depth_uint(ctx, width, data);
1348          }
1349          pipe_put_tile_z(pipe, stImage->transfer, 0, row, width, 1, data);
1350       }
1351    }
1352    else {
1353       /* RGBA format */
1354       GLfloat *tempSrc =
1355          (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
1356
1357       if (tempSrc && texDest) {
1358          const GLint dims = 2;
1359          const GLint dstRowStride = stImage->transfer->stride;
1360          struct gl_texture_image *texImage = &stImage->base;
1361          struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
1362
1363          if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1364             unpack.Invert = GL_TRUE;
1365          }
1366
1367          /* get float/RGBA image from framebuffer */
1368          /* XXX this usually involves a lot of int/float conversion.
1369           * try to avoid that someday.
1370           */
1371          pipe_get_tile_rgba(pipe, src_trans, 0, 0, width, height, tempSrc);
1372
1373          /* Store into texture memory.
1374           * Note that this does some special things such as pixel transfer
1375           * ops and format conversion.  In particular, if the dest tex format
1376           * is actually RGBA but the user created the texture as GL_RGB we
1377           * need to fill-in/override the alpha channel with 1.0.
1378           */
1379          _mesa_texstore(ctx, dims,
1380                         texImage->_BaseFormat,
1381                         texImage->TexFormat,
1382                         texDest,
1383                         0, 0, 0,
1384                         dstRowStride,
1385                         texImage->ImageOffsets,
1386                         width, height, 1,
1387                         GL_RGBA, GL_FLOAT, tempSrc, /* src */
1388                         &unpack);
1389       }
1390       else {
1391          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
1392       }
1393
1394       if (tempSrc)
1395          free(tempSrc);
1396    }
1397
1398    st_texture_image_unmap(ctx->st, stImage);
1399    pipe->transfer_destroy(pipe, src_trans);
1400 }
1401
1402
1403
1404 /**
1405  * If the format of the src renderbuffer and the format of the dest
1406  * texture are compatible (in terms of blitting), return a TGSI writemask
1407  * to be used during the blit.
1408  * If the src/dest are incompatible, return 0.
1409  */
1410 static unsigned
1411 compatible_src_dst_formats(GLcontext *ctx,
1412                            const struct gl_renderbuffer *src,
1413                            const struct gl_texture_image *dst)
1414 {
1415    /* Get logical base formats for the src and dest.
1416     * That is, use the user-requested formats and not the actual, device-
1417     * chosen formats.
1418     * For example, the user may have requested an A8 texture but the
1419     * driver may actually be using an RGBA texture format.  When we
1420     * copy/blit to that texture, we only want to copy the Alpha channel
1421     * and not the RGB channels.
1422     *
1423     * Similarly, when the src FBO was created an RGB format may have been
1424     * requested but the driver actually chose an RGBA format.  In that case,
1425     * we don't want to copy the undefined Alpha channel to the dest texture
1426     * (it should be 1.0).
1427     */
1428    const GLenum srcFormat = _mesa_base_fbo_format(ctx, src->InternalFormat);
1429    const GLenum dstFormat = _mesa_base_tex_format(ctx, dst->InternalFormat);
1430
1431    /**
1432     * XXX when we have red-only and red/green renderbuffers we'll need
1433     * to add more cases here (or implement a general-purpose routine that
1434     * queries the existance of the R,G,B,A channels in the src and dest).
1435     */
1436    if (srcFormat == dstFormat) {
1437       /* This is the same as matching_base_formats, which should
1438        * always pass, as it did previously.
1439        */
1440       return TGSI_WRITEMASK_XYZW;
1441    }
1442    else if (srcFormat == GL_RGB && dstFormat == GL_RGBA) {
1443       /* Make sure that A in the dest is 1.  The actual src format
1444        * may be RGBA and have undefined A values.
1445        */
1446       return TGSI_WRITEMASK_XYZ;
1447    }
1448    else if (srcFormat == GL_RGBA && dstFormat == GL_RGB) {
1449       /* Make sure that A in the dest is 1.  The actual dst format
1450        * may be RGBA and will need A=1 to provide proper alpha values
1451        * when sampled later.
1452        */
1453       return TGSI_WRITEMASK_XYZ;
1454    }
1455    else {
1456       if (ST_DEBUG & DEBUG_FALLBACK)
1457          debug_printf("%s failed for src %s, dst %s\n",
1458                       __FUNCTION__,
1459                       _mesa_lookup_enum_by_nr(srcFormat),
1460                       _mesa_lookup_enum_by_nr(dstFormat));
1461
1462       /* Otherwise fail.
1463        */
1464       return 0;
1465    }
1466 }
1467
1468
1469
1470 /**
1471  * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
1472  * Note that the region to copy has already been clipped so we know we
1473  * won't read from outside the source renderbuffer's bounds.
1474  *
1475  * Note: srcY=0=Bottom of renderbuffer (GL convention)
1476  */
1477 static void
1478 st_copy_texsubimage(GLcontext *ctx,
1479                     GLenum target, GLint level,
1480                     GLint destX, GLint destY, GLint destZ,
1481                     GLint srcX, GLint srcY,
1482                     GLsizei width, GLsizei height)
1483 {
1484    struct gl_texture_unit *texUnit =
1485       &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1486    struct gl_texture_object *texObj =
1487       _mesa_select_tex_object(ctx, texUnit, target);
1488    struct gl_texture_image *texImage =
1489       _mesa_select_tex_image(ctx, texObj, target, level);
1490    struct st_texture_image *stImage = st_texture_image(texImage);
1491    const GLenum texBaseFormat = texImage->_BaseFormat;
1492    struct gl_framebuffer *fb = ctx->ReadBuffer;
1493    struct st_renderbuffer *strb;
1494    struct pipe_context *pipe = ctx->st->pipe;
1495    struct pipe_screen *screen = pipe->screen;
1496    enum pipe_format dest_format, src_format;
1497    GLboolean use_fallback = GL_TRUE;
1498    GLboolean matching_base_formats;
1499    GLuint format_writemask;
1500    struct pipe_surface *dest_surface = NULL;
1501    GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
1502
1503    /* any rendering in progress must flushed before we grab the fb image */
1504    st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
1505
1506    /* make sure finalize_textures has been called?
1507     */
1508    if (0) st_validate_state(ctx->st);
1509
1510    /* determine if copying depth or color data */
1511    if (texBaseFormat == GL_DEPTH_COMPONENT ||
1512        texBaseFormat == GL_DEPTH_STENCIL) {
1513       strb = st_renderbuffer(fb->_DepthBuffer);
1514    }
1515    else {
1516       /* texBaseFormat == GL_RGB, GL_RGBA, GL_ALPHA, etc */
1517       strb = st_renderbuffer(fb->_ColorReadBuffer);
1518    }
1519
1520    if (!strb || !strb->surface || !stImage->pt) {
1521       debug_printf("%s: null strb or stImage\n", __FUNCTION__);
1522       return;
1523    }
1524
1525    if (srcX < 0) {
1526       width -= -srcX;
1527       destX += -srcX;
1528       srcX = 0;
1529    }
1530
1531    if (srcY < 0) {
1532       height -= -srcY;
1533       destY += -srcY;
1534       srcY = 0;
1535    }
1536
1537    if (destX < 0) {
1538       width -= -destX;
1539       srcX += -destX;
1540       destX = 0;
1541    }
1542
1543    if (destY < 0) {
1544       height -= -destY;
1545       srcY += -destY;
1546       destY = 0;
1547    }
1548
1549    if (width < 0 || height < 0)
1550       return;
1551
1552
1553    assert(strb);
1554    assert(strb->surface);
1555    assert(stImage->pt);
1556
1557    src_format = strb->surface->format;
1558    dest_format = stImage->pt->format;
1559
1560    /*
1561     * Determine if the src framebuffer and dest texture have the same
1562     * base format.  We need this to detect a case such as the framebuffer
1563     * being GL_RGBA but the texture being GL_RGB.  If the actual hardware
1564     * texture format stores RGBA we need to set A=1 (overriding the
1565     * framebuffer's alpha values).  We can't do that with the blit or
1566     * textured-quad paths.
1567     */
1568    matching_base_formats =
1569       (_mesa_get_format_base_format(strb->Base.Format) ==
1570        _mesa_get_format_base_format(texImage->TexFormat));
1571    format_writemask = compatible_src_dst_formats(ctx, &strb->Base, texImage);
1572
1573    if (ctx->_ImageTransferState == 0x0) {
1574
1575       if (matching_base_formats &&
1576           src_format == dest_format &&
1577           !do_flip)
1578       {
1579          /* use surface_copy() / blit */
1580
1581          dest_surface = screen->get_tex_surface(screen, stImage->pt,
1582                                                 stImage->face, stImage->level,
1583                                                 destZ,
1584                                                 PIPE_BIND_BLIT_DESTINATION);
1585
1586          /* for surface_copy(), y=0=top, always */
1587          pipe->surface_copy(pipe,
1588                             /* dest */
1589                             dest_surface,
1590                             destX, destY,
1591                             /* src */
1592                             strb->surface,
1593                             srcX, srcY,
1594                             /* size */
1595                             width, height);
1596          use_fallback = GL_FALSE;
1597       }
1598       else if (format_writemask &&
1599                texBaseFormat != GL_DEPTH_COMPONENT &&
1600                texBaseFormat != GL_DEPTH_STENCIL &&
1601                screen->is_format_supported(screen, src_format,
1602                                            PIPE_TEXTURE_2D,
1603                                            PIPE_BIND_SAMPLER_VIEW,
1604                                            0) &&
1605                screen->is_format_supported(screen, dest_format,
1606                                            PIPE_TEXTURE_2D,
1607                                            PIPE_BIND_RENDER_TARGET,
1608                                            0)) {
1609          /* draw textured quad to do the copy */
1610          GLint srcY0, srcY1;
1611
1612          dest_surface = screen->get_tex_surface(screen, stImage->pt,
1613                                                 stImage->face, stImage->level,
1614                                                 destZ,
1615                                                 PIPE_BIND_BLIT_DESTINATION);
1616
1617          if (do_flip) {
1618             srcY1 = strb->Base.Height - srcY - height;
1619             srcY0 = srcY1 + height;
1620          }
1621          else {
1622             srcY0 = srcY;
1623             srcY1 = srcY0 + height;
1624          }
1625          util_blit_pixels_writemask(ctx->st->blit,
1626                                     strb->surface,
1627                                     st_renderbuffer_get_sampler_view(strb, pipe),
1628                                     srcX, srcY0,
1629                                     srcX + width, srcY1,
1630                                     dest_surface,
1631                                     destX, destY,
1632                                     destX + width, destY + height,
1633                                     0.0, PIPE_TEX_MIPFILTER_NEAREST,
1634                                     format_writemask);
1635          use_fallback = GL_FALSE;
1636       }
1637
1638       if (dest_surface)
1639          pipe_surface_reference(&dest_surface, NULL);
1640    }
1641
1642    if (use_fallback) {
1643       /* software fallback */
1644       fallback_copy_texsubimage(ctx, target, level,
1645                                 strb, stImage, texBaseFormat,
1646                                 destX, destY, destZ,
1647                                 srcX, srcY, width, height);
1648    }
1649 }
1650
1651
1652
1653 static void
1654 st_CopyTexImage1D(GLcontext * ctx, GLenum target, GLint level,
1655                   GLenum internalFormat,
1656                   GLint x, GLint y, GLsizei width, GLint border)
1657 {
1658    struct gl_texture_unit *texUnit =
1659       &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1660    struct gl_texture_object *texObj =
1661       _mesa_select_tex_object(ctx, texUnit, target);
1662    struct gl_texture_image *texImage =
1663       _mesa_select_tex_image(ctx, texObj, target, level);
1664
1665    /* Setup or redefine the texture object, texture and texture
1666     * image.  Don't populate yet.
1667     */
1668    ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
1669                           width, border,
1670                           GL_RGBA, CHAN_TYPE, NULL,
1671                           &ctx->DefaultPacking, texObj, texImage);
1672
1673    st_copy_texsubimage(ctx, target, level,
1674                        0, 0, 0,  /* destX,Y,Z */
1675                        x, y, width, 1);  /* src X, Y, size */
1676 }
1677
1678
1679 static void
1680 st_CopyTexImage2D(GLcontext * ctx, GLenum target, GLint level,
1681                   GLenum internalFormat,
1682                   GLint x, GLint y, GLsizei width, GLsizei height,
1683                   GLint border)
1684 {
1685    struct gl_texture_unit *texUnit =
1686       &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1687    struct gl_texture_object *texObj =
1688       _mesa_select_tex_object(ctx, texUnit, target);
1689    struct gl_texture_image *texImage =
1690       _mesa_select_tex_image(ctx, texObj, target, level);
1691
1692    /* Setup or redefine the texture object, texture and texture
1693     * image.  Don't populate yet.
1694     */
1695    ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
1696                           width, height, border,
1697                           GL_RGBA, CHAN_TYPE, NULL,
1698                           &ctx->DefaultPacking, texObj, texImage);
1699
1700    st_copy_texsubimage(ctx, target, level,
1701                        0, 0, 0,  /* destX,Y,Z */
1702                        x, y, width, height);  /* src X, Y, size */
1703 }
1704
1705
1706 static void
1707 st_CopyTexSubImage1D(GLcontext * ctx, GLenum target, GLint level,
1708                      GLint xoffset, GLint x, GLint y, GLsizei width)
1709 {
1710    const GLint yoffset = 0, zoffset = 0;
1711    const GLsizei height = 1;
1712    st_copy_texsubimage(ctx, target, level,
1713                        xoffset, yoffset, zoffset,  /* destX,Y,Z */
1714                        x, y, width, height);  /* src X, Y, size */
1715 }
1716
1717
1718 static void
1719 st_CopyTexSubImage2D(GLcontext * ctx, GLenum target, GLint level,
1720                      GLint xoffset, GLint yoffset,
1721                      GLint x, GLint y, GLsizei width, GLsizei height)
1722 {
1723    const GLint zoffset = 0;
1724    st_copy_texsubimage(ctx, target, level,
1725                        xoffset, yoffset, zoffset,  /* destX,Y,Z */
1726                        x, y, width, height);  /* src X, Y, size */
1727 }
1728
1729
1730 static void
1731 st_CopyTexSubImage3D(GLcontext * ctx, GLenum target, GLint level,
1732                      GLint xoffset, GLint yoffset, GLint zoffset,
1733                      GLint x, GLint y, GLsizei width, GLsizei height)
1734 {
1735    st_copy_texsubimage(ctx, target, level,
1736                        xoffset, yoffset, zoffset,  /* destX,Y,Z */
1737                        x, y, width, height);  /* src X, Y, size */
1738 }
1739
1740
1741 static void
1742 copy_image_data_to_texture(struct st_context *st,
1743                            struct st_texture_object *stObj,
1744                            GLuint dstLevel,
1745                            struct st_texture_image *stImage)
1746 {
1747    if (stImage->pt) {
1748       /* Copy potentially with the blitter:
1749        */
1750       st_texture_image_copy(st->pipe,
1751                             stObj->pt, dstLevel,  /* dest texture, level */
1752                             stImage->pt, /* src texture */
1753                             stImage->face);
1754
1755       pipe_resource_reference(&stImage->pt, NULL);
1756    }
1757    else if (stImage->base.Data) {
1758       /* More straightforward upload.
1759        */
1760       st_teximage_flush_before_map(st, stObj->pt, stImage->face, dstLevel,
1761                                    PIPE_TRANSFER_WRITE);
1762
1763       st_texture_image_data(st,
1764                             stObj->pt,
1765                             stImage->face,
1766                             dstLevel,
1767                             stImage->base.Data,
1768                             stImage->base.RowStride *
1769                             util_format_get_blocksize(stObj->pt->format),
1770                             stImage->base.RowStride *
1771                             stImage->base.Height *
1772                             util_format_get_blocksize(stObj->pt->format));
1773       _mesa_align_free(stImage->base.Data);
1774       stImage->base.Data = NULL;
1775    }
1776
1777    pipe_resource_reference(&stImage->pt, stObj->pt);
1778 }
1779
1780
1781 /**
1782  * Called during state validation.  When this function is finished,
1783  * the texture object should be ready for rendering.
1784  * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
1785  */
1786 GLboolean
1787 st_finalize_texture(GLcontext *ctx,
1788                     struct pipe_context *pipe,
1789                     struct gl_texture_object *tObj,
1790                     GLboolean *needFlush)
1791 {
1792    struct st_texture_object *stObj = st_texture_object(tObj);
1793    const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1794    GLuint blockSize, face;
1795    struct st_texture_image *firstImage;
1796
1797    *needFlush = GL_FALSE;
1798
1799    if (stObj->base._Complete) {
1800       /* The texture is complete and we know exactly how many mipmap levels
1801        * are present/needed.  This is conditional because we may be called
1802        * from the st_generate_mipmap() function when the texture object is
1803        * incomplete.  In that case, we'll have set stObj->lastLevel before
1804        * we get here.
1805        */
1806       if (stObj->base.MinFilter == GL_LINEAR ||
1807           stObj->base.MinFilter == GL_NEAREST)
1808          stObj->lastLevel = stObj->base.BaseLevel;
1809       else
1810          stObj->lastLevel = stObj->base._MaxLevel - stObj->base.BaseLevel;
1811    }
1812
1813    firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);
1814
1815    /* If both firstImage and stObj point to a texture which can contain
1816     * all active images, favour firstImage.  Note that because of the
1817     * completeness requirement, we know that the image dimensions
1818     * will match.
1819     */
1820    if (firstImage->pt &&
1821        firstImage->pt != stObj->pt &&
1822        firstImage->pt->last_level >= stObj->lastLevel) {
1823       pipe_resource_reference(&stObj->pt, firstImage->pt);
1824       pipe_sampler_view_reference(&stObj->sampler_view, NULL);
1825    }
1826
1827    /* bytes per pixel block (blocks are usually 1x1) */
1828    blockSize = _mesa_get_format_bytes(firstImage->base.TexFormat);
1829
1830    /* If we already have a gallium texture, check that it matches the texture
1831     * object's format, target, size, num_levels, etc.
1832     */
1833    if (stObj->pt) {
1834       const enum pipe_format fmt =
1835          st_mesa_format_to_pipe_format(firstImage->base.TexFormat);
1836       if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
1837           stObj->pt->format != fmt ||
1838           stObj->pt->last_level < stObj->lastLevel ||
1839           stObj->pt->width0 != firstImage->base.Width2 ||
1840           stObj->pt->height0 != firstImage->base.Height2 ||
1841           stObj->pt->depth0 != firstImage->base.Depth2)
1842       {
1843          pipe_resource_reference(&stObj->pt, NULL);
1844          pipe_sampler_view_reference(&stObj->sampler_view, NULL);
1845          ctx->st->dirty.st |= ST_NEW_FRAMEBUFFER;
1846       }
1847    }
1848
1849    /* May need to create a new gallium texture:
1850     */
1851    if (!stObj->pt) {
1852       const enum pipe_format fmt =
1853          st_mesa_format_to_pipe_format(firstImage->base.TexFormat);
1854       GLuint usage = default_usage(fmt);
1855
1856       stObj->pt = st_texture_create(ctx->st,
1857                                     gl_target_to_pipe(stObj->base.Target),
1858                                     fmt,
1859                                     stObj->lastLevel,
1860                                     firstImage->base.Width2,
1861                                     firstImage->base.Height2,
1862                                     firstImage->base.Depth2,
1863                                     usage);
1864
1865       if (!stObj->pt) {
1866          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
1867          return GL_FALSE;
1868       }
1869    }
1870
1871    /* Pull in any images not in the object's texture:
1872     */
1873    for (face = 0; face < nr_faces; face++) {
1874       GLuint level;
1875       for (level = 0; level <= stObj->lastLevel; level++) {
1876          struct st_texture_image *stImage =
1877             st_texture_image(stObj->base.Image[face][stObj->base.BaseLevel + level]);
1878
1879          /* Need to import images in main memory or held in other textures.
1880           */
1881          if (stImage && stObj->pt != stImage->pt) {
1882             copy_image_data_to_texture(ctx->st, stObj, level, stImage);
1883             *needFlush = GL_TRUE;
1884          }
1885       }
1886    }
1887
1888    return GL_TRUE;
1889 }
1890
1891
1892 /**
1893  * Returns pointer to a default/dummy texture.
1894  * This is typically used when the current shader has tex/sample instructions
1895  * but the user has not provided a (any) texture(s).
1896  */
1897 struct gl_texture_object *
1898 st_get_default_texture(struct st_context *st)
1899 {
1900    if (!st->default_texture) {
1901       static const GLenum target = GL_TEXTURE_2D;
1902       GLubyte pixels[16][16][4];
1903       struct gl_texture_object *texObj;
1904       struct gl_texture_image *texImg;
1905       GLuint i, j;
1906
1907       /* The ARB_fragment_program spec says (0,0,0,1) should be returned
1908        * when attempting to sample incomplete textures.
1909        */
1910       for (i = 0; i < 16; i++) {
1911          for (j = 0; j < 16; j++) {
1912             pixels[i][j][0] = 0;
1913             pixels[i][j][1] = 0;
1914             pixels[i][j][2] = 0;
1915             pixels[i][j][3] = 255;
1916          }
1917       }
1918
1919       texObj = st->ctx->Driver.NewTextureObject(st->ctx, 0, target);
1920
1921       texImg = _mesa_get_tex_image(st->ctx, texObj, target, 0);
1922
1923       _mesa_init_teximage_fields(st->ctx, target, texImg,
1924                                  16, 16, 1, 0,  /* w, h, d, border */
1925                                  GL_RGBA);
1926
1927       st_TexImage(st->ctx, 2, target,
1928                   0, GL_RGBA,    /* level, intformat */
1929                   16, 16, 1, 0,  /* w, h, d, border */
1930                   GL_RGBA, GL_UNSIGNED_BYTE, pixels,
1931                   &st->ctx->DefaultPacking,
1932                   texObj, texImg,
1933                   0, 0);
1934
1935       texObj->MinFilter = GL_NEAREST;
1936       texObj->MagFilter = GL_NEAREST;
1937       texObj->_Complete = GL_TRUE;
1938
1939       st->default_texture = texObj;
1940    }
1941    return st->default_texture;
1942 }
1943
1944
1945 void
1946 st_init_texture_functions(struct dd_function_table *functions)
1947 {
1948    functions->ChooseTextureFormat = st_ChooseTextureFormat;
1949    functions->TexImage1D = st_TexImage1D;
1950    functions->TexImage2D = st_TexImage2D;
1951    functions->TexImage3D = st_TexImage3D;
1952    functions->TexSubImage1D = st_TexSubImage1D;
1953    functions->TexSubImage2D = st_TexSubImage2D;
1954    functions->TexSubImage3D = st_TexSubImage3D;
1955    functions->CompressedTexSubImage1D = st_CompressedTexSubImage1D;
1956    functions->CompressedTexSubImage2D = st_CompressedTexSubImage2D;
1957    functions->CompressedTexSubImage3D = st_CompressedTexSubImage3D;
1958    functions->CopyTexImage1D = st_CopyTexImage1D;
1959    functions->CopyTexImage2D = st_CopyTexImage2D;
1960    functions->CopyTexSubImage1D = st_CopyTexSubImage1D;
1961    functions->CopyTexSubImage2D = st_CopyTexSubImage2D;
1962    functions->CopyTexSubImage3D = st_CopyTexSubImage3D;
1963    functions->GenerateMipmap = st_generate_mipmap;
1964
1965    functions->GetTexImage = st_GetTexImage;
1966
1967    /* compressed texture functions */
1968    functions->CompressedTexImage2D = st_CompressedTexImage2D;
1969    functions->GetCompressedTexImage = st_GetCompressedTexImage;
1970
1971    functions->NewTextureObject = st_NewTextureObject;
1972    functions->NewTextureImage = st_NewTextureImage;
1973    functions->DeleteTexture = st_DeleteTextureObject;
1974    functions->FreeTexImageData = st_FreeTextureImageData;
1975    functions->UpdateTexturePalette = 0;
1976
1977    functions->TextureMemCpy = do_memcpy;
1978
1979    /* XXX Temporary until we can query pipe's texture sizes */
1980    functions->TestProxyTexImage = _mesa_test_proxy_teximage;
1981 }