src/mesa/state_tracker/st_cb_texture.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 VMware, Inc.
   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 VMWARE 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/bufferobj.h"
  29 #include "main/enums.h"
  30 #include "main/fbobject.h"
  31 #include "main/formats.h"
  32 #include "main/image.h"
  33 #include "main/imports.h"
  34 #include "main/macros.h"
  35 #include "main/mipmap.h"
  36 #include "main/pack.h"
  37 #include "main/pbo.h"
  38 #include "main/pixeltransfer.h"
  39 #include "main/texcompress.h"
  40 #include "main/texgetimage.h"
  41 #include "main/teximage.h"
  42 #include "main/texobj.h"
  43 #include "main/texstore.h"
  44
  45 #include "state_tracker/st_debug.h"
  46 #include "state_tracker/st_context.h"
  47 #include "state_tracker/st_cb_fbo.h"
  48 #include "state_tracker/st_cb_flush.h"
  49 #include "state_tracker/st_cb_texture.h"
  50 #include "state_tracker/st_cb_bufferobjects.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_format.h"
  62 #include "util/u_surface.h"
  63 #include "util/u_sampler.h"
  64 #include "util/u_math.h"
  65 #include "util/u_box.h"
  66
  67 #define DBG if (0) printf
  68
  69
  70 enum pipe_texture_target
  71 gl_target_to_pipe(GLenum target)
  72 {
  73    switch (target) {
  74    case GL_TEXTURE_1D:
  75    case GL_PROXY_TEXTURE_1D:
  76       return PIPE_TEXTURE_1D;
  77    case GL_TEXTURE_2D:
  78    case GL_PROXY_TEXTURE_2D:
  79    case GL_TEXTURE_EXTERNAL_OES:
  80    case GL_TEXTURE_2D_MULTISAMPLE:
  81    case GL_PROXY_TEXTURE_2D_MULTISAMPLE:
  82       return PIPE_TEXTURE_2D;
  83    case GL_TEXTURE_RECTANGLE_NV:
  84    case GL_PROXY_TEXTURE_RECTANGLE_NV:
  85       return PIPE_TEXTURE_RECT;
  86    case GL_TEXTURE_3D:
  87    case GL_PROXY_TEXTURE_3D:
  88       return PIPE_TEXTURE_3D;
  89    case GL_TEXTURE_CUBE_MAP_ARB:
  90    case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
  91    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
  92    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
  93    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
  94    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
  95    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
  96    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
  97       return PIPE_TEXTURE_CUBE;
  98    case GL_TEXTURE_1D_ARRAY_EXT:
  99    case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
 100       return PIPE_TEXTURE_1D_ARRAY;
 101    case GL_TEXTURE_2D_ARRAY_EXT:
 102    case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
 103    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
 104    case GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY:
 105       return PIPE_TEXTURE_2D_ARRAY;
 106    case GL_TEXTURE_BUFFER:
 107       return PIPE_BUFFER;
 108    case GL_TEXTURE_CUBE_MAP_ARRAY:
 109    case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY:
 110       return PIPE_TEXTURE_CUBE_ARRAY;
 111    default:
 112       assert(0);
 113       return 0;
 114    }
 115 }
 116
 117
 118 /** called via ctx->Driver.NewTextureImage() */
 119 static struct gl_texture_image *
 120 st_NewTextureImage(struct gl_context * ctx)
 121 {
 122    DBG("%s\n", __FUNCTION__);
 123    (void) ctx;
 124    return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image);
 125 }
 126
 127
 128 /** called via ctx->Driver.DeleteTextureImage() */
 129 static void
 130 st_DeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img)
 131 {
 132    /* nothing special (yet) for st_texture_image */
 133    _mesa_delete_texture_image(ctx, img);
 134 }
 135
 136
 137 /** called via ctx->Driver.NewTextureObject() */
 138 static struct gl_texture_object *
 139 st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target)
 140 {
 141    struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object);
 142
 143    DBG("%s\n", __FUNCTION__);
 144    _mesa_initialize_texture_object(ctx, &obj->base, name, target);
 145
 146    return &obj->base;
 147 }
 148
 149 /** called via ctx->Driver.DeleteTextureObject() */
 150 static void
 151 st_DeleteTextureObject(struct gl_context *ctx,
 152                        struct gl_texture_object *texObj)
 153 {
 154    struct st_context *st = st_context(ctx);
 155    struct st_texture_object *stObj = st_texture_object(texObj);
 156    if (stObj->pt)
 157       pipe_resource_reference(&stObj->pt, NULL);
 158    if (stObj->sampler_view) {
 159       pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
 160    }
 161    _mesa_delete_texture_object(ctx, texObj);
 162 }
 163
 164
 165 /** called via ctx->Driver.FreeTextureImageBuffer() */
 166 static void
 167 st_FreeTextureImageBuffer(struct gl_context *ctx,
 168                           struct gl_texture_image *texImage)
 169 {
 170    struct st_texture_image *stImage = st_texture_image(texImage);
 171
 172    DBG("%s\n", __FUNCTION__);
 173
 174    if (stImage->pt) {
 175       pipe_resource_reference(&stImage->pt, NULL);
 176    }
 177
 178    _mesa_align_free(stImage->TexData);
 179    stImage->TexData = NULL;
 180 }
 181
 182
 183 /** called via ctx->Driver.MapTextureImage() */
 184 static void
 185 st_MapTextureImage(struct gl_context *ctx,
 186                    struct gl_texture_image *texImage,
 187                    GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h,
 188                    GLbitfield mode,
 189                    GLubyte **mapOut, GLint *rowStrideOut)
 190 {
 191    struct st_context *st = st_context(ctx);
 192    struct st_texture_image *stImage = st_texture_image(texImage);
 193    unsigned pipeMode;
 194    GLubyte *map;
 195
 196    pipeMode = 0x0;
 197    if (mode & GL_MAP_READ_BIT)
 198       pipeMode |= PIPE_TRANSFER_READ;
 199    if (mode & GL_MAP_WRITE_BIT)
 200       pipeMode |= PIPE_TRANSFER_WRITE;
 201    if (mode & GL_MAP_INVALIDATE_RANGE_BIT)
 202       pipeMode |= PIPE_TRANSFER_DISCARD_RANGE;
 203
 204    map = st_texture_image_map(st, stImage, pipeMode, x, y, slice, w, h, 1);
 205    if (map) {
 206       *mapOut = map;
 207       *rowStrideOut = stImage->transfer->stride;
 208    }
 209    else {
 210       *mapOut = NULL;
 211       *rowStrideOut = 0;
 212    }
 213 }
 214
 215
 216 /** called via ctx->Driver.UnmapTextureImage() */
 217 static void
 218 st_UnmapTextureImage(struct gl_context *ctx,
 219                      struct gl_texture_image *texImage,
 220                      GLuint slice)
 221 {
 222    struct st_context *st = st_context(ctx);
 223    struct st_texture_image *stImage  = st_texture_image(texImage);
 224    st_texture_image_unmap(st, stImage);
 225 }
 226
 227
 228 /**
 229  * Return default texture resource binding bitmask for the given format.
 230  */
 231 static GLuint
 232 default_bindings(struct st_context *st, enum pipe_format format)
 233 {
 234    struct pipe_screen *screen = st->pipe->screen;
 235    const unsigned target = PIPE_TEXTURE_2D;
 236    unsigned bindings;
 237
 238    if (util_format_is_depth_or_stencil(format))
 239       bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DEPTH_STENCIL;
 240    else
 241       bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
 242
 243    if (screen->is_format_supported(screen, format, target, 0, bindings))
 244       return bindings;
 245    else {
 246       /* Try non-sRGB. */
 247       format = util_format_linear(format);
 248
 249       if (screen->is_format_supported(screen, format, target, 0, bindings))
 250          return bindings;
 251       else
 252          return PIPE_BIND_SAMPLER_VIEW;
 253    }
 254 }
 255
 256
 257 /**
 258  * Given the size of a mipmap image, try to compute the size of the level=0
 259  * mipmap image.
 260  *
 261  * Note that this isn't always accurate for odd-sized, non-POW textures.
 262  * For example, if level=1 and width=40 then the level=0 width may be 80 or 81.
 263  *
 264  * \return GL_TRUE for success, GL_FALSE for failure
 265  */
 266 static GLboolean
 267 guess_base_level_size(GLenum target,
 268                       GLuint width, GLuint height, GLuint depth, GLuint level,
 269                       GLuint *width0, GLuint *height0, GLuint *depth0)
 270 {
 271    assert(width >= 1);
 272    assert(height >= 1);
 273    assert(depth >= 1);
 274
 275    if (level > 0) {
 276       /* Guess the size of the base level.
 277        * Depending on the image's size, we can't always make a guess here.
 278        */
 279       switch (target) {
 280       case GL_TEXTURE_1D:
 281       case GL_TEXTURE_1D_ARRAY:
 282          width <<= level;
 283          break;
 284
 285       case GL_TEXTURE_2D:
 286       case GL_TEXTURE_2D_ARRAY:
 287          /* We can't make a good guess here, because the base level dimensions
 288           * can be non-square.
 289           */
 290          if (width == 1 || height == 1) {
 291             return GL_FALSE;
 292          }
 293          width <<= level;
 294          height <<= level;
 295          break;
 296
 297       case GL_TEXTURE_CUBE_MAP:
 298       case GL_TEXTURE_CUBE_MAP_ARRAY:
 299          width <<= level;
 300          height <<= level;
 301          break;
 302
 303       case GL_TEXTURE_3D:
 304          /* We can't make a good guess here, because the base level dimensions
 305           * can be non-cube.
 306           */
 307          if (width == 1 || height == 1 || depth == 1) {
 308             return GL_FALSE;
 309          }
 310          width <<= level;
 311          height <<= level;
 312          depth <<= level;
 313          break;
 314
 315       case GL_TEXTURE_RECTANGLE:
 316          break;
 317
 318       default:
 319          assert(0);
 320       }
 321    }
 322
 323    *width0 = width;
 324    *height0 = height;
 325    *depth0 = depth;
 326
 327    return GL_TRUE;
 328 }
 329
 330
 331 /**
 332  * Try to allocate a pipe_resource object for the given st_texture_object.
 333  *
 334  * We use the given st_texture_image as a clue to determine the size of the
 335  * mipmap image at level=0.
 336  *
 337  * \return GL_TRUE for success, GL_FALSE if out of memory.
 338  */
 339 static GLboolean
 340 guess_and_alloc_texture(struct st_context *st,
 341                         struct st_texture_object *stObj,
 342                         const struct st_texture_image *stImage)
 343 {
 344    GLuint lastLevel, width, height, depth;
 345    GLuint bindings;
 346    GLuint ptWidth, ptHeight, ptDepth, ptLayers;
 347    enum pipe_format fmt;
 348
 349    DBG("%s\n", __FUNCTION__);
 350
 351    assert(!stObj->pt);
 352
 353    if (!guess_base_level_size(stObj->base.Target,
 354                               stImage->base.Width2,
 355                               stImage->base.Height2,
 356                               stImage->base.Depth2,
 357                               stImage->base.Level,
 358                               &width, &height, &depth)) {
 359       /* we can't determine the image size at level=0 */
 360       stObj->width0 = stObj->height0 = stObj->depth0 = 0;
 361       /* this is not an out of memory error */
 362       return GL_TRUE;
 363    }
 364
 365    /* At this point, (width x height x depth) is the expected size of
 366     * the level=0 mipmap image.
 367     */
 368
 369    /* Guess a reasonable value for lastLevel.  With OpenGL we have no
 370     * idea how many mipmap levels will be in a texture until we start
 371     * to render with it.  Make an educated guess here but be prepared
 372     * to re-allocating a texture buffer with space for more (or fewer)
 373     * mipmap levels later.
 374     */
 375    if ((stObj->base.Sampler.MinFilter == GL_NEAREST ||
 376         stObj->base.Sampler.MinFilter == GL_LINEAR ||
 377         (stObj->base.BaseLevel == 0 &&
 378          stObj->base.MaxLevel == 0) ||
 379         stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
 380         stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) &&
 381        !stObj->base.GenerateMipmap &&
 382        stImage->base.Level == 0) {
 383       /* only alloc space for a single mipmap level */
 384       lastLevel = 0;
 385    }
 386    else {
 387       /* alloc space for a full mipmap */
 388       lastLevel = _mesa_get_tex_max_num_levels(stObj->base.Target,
 389                                                width, height, depth) - 1;
 390    }
 391
 392    /* Save the level=0 dimensions */
 393    stObj->width0 = width;
 394    stObj->height0 = height;
 395    stObj->depth0 = depth;
 396
 397    fmt = st_mesa_format_to_pipe_format(stImage->base.TexFormat);
 398
 399    bindings = default_bindings(st, fmt);
 400
 401    st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
 402                                    width, height, depth,
 403                                    &ptWidth, &ptHeight, &ptDepth, &ptLayers);
 404
 405    stObj->pt = st_texture_create(st,
 406                                  gl_target_to_pipe(stObj->base.Target),
 407                                  fmt,
 408                                  lastLevel,
 409                                  ptWidth,
 410                                  ptHeight,
 411                                  ptDepth,
 412                                  ptLayers, 0,
 413                                  bindings);
 414
 415    stObj->lastLevel = lastLevel;
 416
 417    DBG("%s returning %d\n", __FUNCTION__, (stObj->pt != NULL));
 418
 419    return stObj->pt != NULL;
 420 }
 421
 422
 423 /**
 424  * Called via ctx->Driver.AllocTextureImageBuffer().
 425  * If the texture object/buffer already has space for the indicated image,
 426  * we're done.  Otherwise, allocate memory for the new texture image.
 427  */
 428 static GLboolean
 429 st_AllocTextureImageBuffer(struct gl_context *ctx,
 430                            struct gl_texture_image *texImage)
 431 {
 432    struct st_context *st = st_context(ctx);
 433    struct st_texture_image *stImage = st_texture_image(texImage);
 434    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
 435    const GLuint level = texImage->Level;
 436    GLuint width = texImage->Width;
 437    GLuint height = texImage->Height;
 438    GLuint depth = texImage->Depth;
 439
 440    DBG("%s\n", __FUNCTION__);
 441
 442    assert(!stImage->TexData);
 443    assert(!stImage->pt); /* xxx this might be wrong */
 444
 445    /* Look if the parent texture object has space for this image */
 446    if (stObj->pt &&
 447        level <= stObj->pt->last_level &&
 448        st_texture_match_image(stObj->pt, texImage)) {
 449       /* this image will fit in the existing texture object's memory */
 450       pipe_resource_reference(&stImage->pt, stObj->pt);
 451       return GL_TRUE;
 452    }
 453
 454    /* The parent texture object does not have space for this image */
 455
 456    pipe_resource_reference(&stObj->pt, NULL);
 457    pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
 458
 459    if (!guess_and_alloc_texture(st, stObj, stImage)) {
 460       /* Probably out of memory.
 461        * Try flushing any pending rendering, then retry.
 462        */
 463       st_finish(st);
 464       if (!guess_and_alloc_texture(st, stObj, stImage)) {
 465          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
 466          return GL_FALSE;
 467       }
 468    }
 469
 470    if (stObj->pt &&
 471        st_texture_match_image(stObj->pt, texImage)) {
 472       /* The image will live in the object's mipmap memory */
 473       pipe_resource_reference(&stImage->pt, stObj->pt);
 474       assert(stImage->pt);
 475       return GL_TRUE;
 476    }
 477    else {
 478       /* Create a new, temporary texture/resource/buffer to hold this
 479        * one texture image.  Note that when we later access this image
 480        * (either for mapping or copying) we'll want to always specify
 481        * mipmap level=0, even if the image represents some other mipmap
 482        * level.
 483        */
 484       enum pipe_format format =
 485          st_mesa_format_to_pipe_format(texImage->TexFormat);
 486       GLuint bindings = default_bindings(st, format);
 487       GLuint ptWidth, ptHeight, ptDepth, ptLayers;
 488
 489       st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
 490                                       width, height, depth,
 491                                       &ptWidth, &ptHeight, &ptDepth, &ptLayers);
 492
 493       stImage->pt = st_texture_create(st,
 494                                       gl_target_to_pipe(stObj->base.Target),
 495                                       format,
 496                                       0, /* lastLevel */
 497                                       ptWidth,
 498                                       ptHeight,
 499                                       ptDepth,
 500                                       ptLayers, 0,
 501                                       bindings);
 502       return stImage->pt != NULL;
 503    }
 504 }
 505
 506
 507 /**
 508  * Preparation prior to glTexImage.  Basically check the 'surface_based'
 509  * field and switch to a "normal" tex image if necessary.
 510  */
 511 static void
 512 prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage,
 513               GLenum format, GLenum type)
 514 {
 515    struct gl_texture_object *texObj = texImage->TexObject;
 516    struct st_texture_object *stObj = st_texture_object(texObj);
 517
 518    /* switch to "normal" */
 519    if (stObj->surface_based) {
 520       const GLenum target = texObj->Target;
 521       const GLuint level = texImage->Level;
 522       mesa_format texFormat;
 523
 524       _mesa_clear_texture_object(ctx, texObj);
 525       pipe_resource_reference(&stObj->pt, NULL);
 526
 527       /* oops, need to init this image again */
 528       texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
 529                                               texImage->InternalFormat, format,
 530                                               type);
 531
 532       _mesa_init_teximage_fields(ctx, texImage,
 533                                  texImage->Width, texImage->Height,
 534                                  texImage->Depth, texImage->Border,
 535                                  texImage->InternalFormat, texFormat);
 536
 537       stObj->surface_based = GL_FALSE;
 538    }
 539 }
 540
 541
 542 /**
 543  * Return a writemask for the gallium blit. The parameters can be base
 544  * formats or "format" from glDrawPixels/glTexImage/glGetTexImage.
 545  */
 546 unsigned
 547 st_get_blit_mask(GLenum srcFormat, GLenum dstFormat)
 548 {
 549    switch (dstFormat) {
 550    case GL_DEPTH_STENCIL:
 551       switch (srcFormat) {
 552       case GL_DEPTH_STENCIL:
 553          return PIPE_MASK_ZS;
 554       case GL_DEPTH_COMPONENT:
 555          return PIPE_MASK_Z;
 556       case GL_STENCIL_INDEX:
 557          return PIPE_MASK_S;
 558       default:
 559          assert(0);
 560          return 0;
 561       }
 562
 563    case GL_DEPTH_COMPONENT:
 564       switch (srcFormat) {
 565       case GL_DEPTH_STENCIL:
 566       case GL_DEPTH_COMPONENT:
 567          return PIPE_MASK_Z;
 568       default:
 569          assert(0);
 570          return 0;
 571       }
 572
 573    case GL_STENCIL_INDEX:
 574       switch (srcFormat) {
 575       case GL_STENCIL_INDEX:
 576          return PIPE_MASK_S;
 577       default:
 578          assert(0);
 579          return 0;
 580       }
 581
 582    default:
 583       return PIPE_MASK_RGBA;
 584    }
 585 }
 586
 587
 588 static void
 589 st_TexSubImage(struct gl_context *ctx, GLuint dims,
 590                struct gl_texture_image *texImage,
 591                GLint xoffset, GLint yoffset, GLint zoffset,
 592                GLint width, GLint height, GLint depth,
 593                GLenum format, GLenum type, const void *pixels,
 594                const struct gl_pixelstore_attrib *unpack)
 595 {
 596    struct st_context *st = st_context(ctx);
 597    struct st_texture_image *stImage = st_texture_image(texImage);
 598    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
 599    struct pipe_context *pipe = st->pipe;
 600    struct pipe_screen *screen = pipe->screen;
 601    struct pipe_resource *dst = stImage->pt;
 602    struct pipe_resource *src = NULL;
 603    struct pipe_resource src_templ;
 604    struct pipe_transfer *transfer;
 605    struct pipe_blit_info blit;
 606    enum pipe_format src_format, dst_format;
 607    mesa_format mesa_src_format;
 608    GLenum gl_target = texImage->TexObject->Target;
 609    unsigned bind;
 610    GLubyte *map;
 611
 612    if (!st->prefer_blit_based_texture_transfer) {
 613       goto fallback;
 614    }
 615
 616    if (!dst) {
 617       goto fallback;
 618    }
 619
 620    /* XXX Fallback for depth-stencil formats due to an incomplete stencil
 621     * blit implementation in some drivers. */
 622    if (format == GL_DEPTH_STENCIL) {
 623       goto fallback;
 624    }
 625
 626    /* If the base internal format and the texture format don't match,
 627     * we can't use blit-based TexSubImage. */
 628    if (texImage->_BaseFormat !=
 629        _mesa_get_format_base_format(texImage->TexFormat)) {
 630       goto fallback;
 631    }
 632
 633    /* See if the texture format already matches the format and type,
 634     * in which case the memcpy-based fast path will likely be used and
 635     * we don't have to blit. */
 636    if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
 637                                             type, unpack->SwapBytes)) {
 638       goto fallback;
 639    }
 640
 641    if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
 642       bind = PIPE_BIND_DEPTH_STENCIL;
 643    else
 644       bind = PIPE_BIND_RENDER_TARGET;
 645
 646    /* See if the destination format is supported.
 647     * For luminance and intensity, only the red channel is stored there. */
 648    dst_format = util_format_linear(dst->format);
 649    dst_format = util_format_luminance_to_red(dst_format);
 650    dst_format = util_format_intensity_to_red(dst_format);
 651
 652    if (!dst_format ||
 653        !screen->is_format_supported(screen, dst_format, dst->target,
 654                                     dst->nr_samples, bind)) {
 655       goto fallback;
 656    }
 657
 658    /* Choose the source format. */
 659    src_format = st_choose_matching_format(screen, PIPE_BIND_SAMPLER_VIEW,
 660                                           format, type, unpack->SwapBytes);
 661    if (!src_format) {
 662       goto fallback;
 663    }
 664
 665    mesa_src_format = st_pipe_format_to_mesa_format(src_format);
 666
 667    /* There is no reason to do this if we cannot use memcpy for the temporary
 668     * source texture at least. This also takes transfer ops into account,
 669     * etc. */
 670    if (!_mesa_texstore_can_use_memcpy(ctx,
 671                              _mesa_get_format_base_format(mesa_src_format),
 672                              mesa_src_format, format, type, unpack)) {
 673       goto fallback;
 674    }
 675
 676    /* TexSubImage only sets a single cubemap face. */
 677    if (gl_target == GL_TEXTURE_CUBE_MAP) {
 678       gl_target = GL_TEXTURE_2D;
 679    }
 680
 681    /* Initialize the source texture description. */
 682    memset(&src_templ, 0, sizeof(src_templ));
 683    src_templ.target = gl_target_to_pipe(gl_target);
 684    src_templ.format = src_format;
 685    src_templ.bind = PIPE_BIND_SAMPLER_VIEW;
 686    src_templ.usage = PIPE_USAGE_STAGING;
 687
 688    st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
 689                                    &src_templ.width0, &src_templ.height0,
 690                                    &src_templ.depth0, &src_templ.array_size);
 691
 692    /* Check for NPOT texture support. */
 693    if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
 694        (!util_is_power_of_two(src_templ.width0) ||
 695         !util_is_power_of_two(src_templ.height0) ||
 696         !util_is_power_of_two(src_templ.depth0))) {
 697       goto fallback;
 698    }
 699
 700    /* Create the source texture. */
 701    src = screen->resource_create(screen, &src_templ);
 702    if (!src) {
 703       goto fallback;
 704    }
 705
 706    /* Map source pixels. */
 707    pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
 708                                         format, type, pixels, unpack,
 709                                         "glTexSubImage");
 710    if (!pixels) {
 711       /* This is a GL error. */
 712       pipe_resource_reference(&src, NULL);
 713       return;
 714    }
 715
 716    /* From now on, we need the gallium representation of dimensions. */
 717    if (gl_target == GL_TEXTURE_1D_ARRAY) {
 718       depth = height;
 719       height = 1;
 720    }
 721
 722    map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0,
 723                               width, height, depth, &transfer);
 724    if (!map) {
 725       _mesa_unmap_teximage_pbo(ctx, unpack);
 726       pipe_resource_reference(&src, NULL);
 727       goto fallback;
 728    }
 729
 730    /* Upload pixels (just memcpy). */
 731    {
 732       const uint bytesPerRow = width * util_format_get_blocksize(src_format);
 733       GLuint row, slice;
 734
 735       for (slice = 0; slice < (unsigned) depth; slice++) {
 736          if (gl_target == GL_TEXTURE_1D_ARRAY) {
 737             /* 1D array textures.
 738              * We need to convert gallium coords to GL coords.
 739              */
 740             GLvoid *src = _mesa_image_address3d(unpack, pixels,
 741                                                 width, depth, format,
 742                                                 type, 0, slice, 0);
 743             memcpy(map, src, bytesPerRow);
 744          }
 745          else {
 746             ubyte *slice_map = map;
 747
 748             for (row = 0; row < (unsigned) height; row++) {
 749                GLvoid *src = _mesa_image_address3d(unpack, pixels,
 750                                                    width, height, format,
 751                                                    type, slice, row, 0);
 752                memcpy(slice_map, src, bytesPerRow);
 753                slice_map += transfer->stride;
 754             }
 755          }
 756          map += transfer->layer_stride;
 757       }
 758    }
 759
 760    pipe_transfer_unmap(pipe, transfer);
 761    _mesa_unmap_teximage_pbo(ctx, unpack);
 762
 763    /* Blit. */
 764    blit.src.resource = src;
 765    blit.src.level = 0;
 766    blit.src.format = src_format;
 767    blit.dst.resource = dst;
 768    blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level;
 769    blit.dst.format = dst_format;
 770    blit.src.box.x = blit.src.box.y = blit.src.box.z = 0;
 771    blit.dst.box.x = xoffset;
 772    blit.dst.box.y = yoffset;
 773    blit.dst.box.z = zoffset + texImage->Face;
 774    blit.src.box.width = blit.dst.box.width = width;
 775    blit.src.box.height = blit.dst.box.height = height;
 776    blit.src.box.depth = blit.dst.box.depth = depth;
 777    blit.mask = st_get_blit_mask(format, texImage->_BaseFormat);
 778    blit.filter = PIPE_TEX_FILTER_NEAREST;
 779    blit.scissor_enable = FALSE;
 780
 781    st->pipe->blit(st->pipe, &blit);
 782
 783    pipe_resource_reference(&src, NULL);
 784    return;
 785
 786 fallback:
 787    _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset,
 788                            width, height, depth, format, type, pixels,
 789                            unpack);
 790 }
 791
 792 static void
 793 st_TexImage(struct gl_context * ctx, GLuint dims,
 794             struct gl_texture_image *texImage,
 795             GLenum format, GLenum type, const void *pixels,
 796             const struct gl_pixelstore_attrib *unpack)
 797 {
 798    assert(dims == 1 || dims == 2 || dims == 3);
 799
 800    prep_teximage(ctx, texImage, format, type);
 801
 802    if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
 803       return;
 804
 805    /* allocate storage for texture data */
 806    if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
 807       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
 808       return;
 809    }
 810
 811    st_TexSubImage(ctx, dims, texImage, 0, 0, 0,
 812                   texImage->Width, texImage->Height, texImage->Depth,
 813                   format, type, pixels, unpack);
 814 }
 815
 816
 817 static void
 818 st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
 819                       struct gl_texture_image *texImage,
 820                       GLsizei imageSize, const GLvoid *data)
 821 {
 822    prep_teximage(ctx, texImage, GL_NONE, GL_NONE);
 823    _mesa_store_compressed_teximage(ctx, dims, texImage, imageSize, data);
 824 }
 825
 826
 827
 828
 829 /**
 830  * Called via ctx->Driver.GetTexImage()
 831  *
 832  * This uses a blit to copy the texture to a texture format which matches
 833  * the format and type combo and then a fast read-back is done using memcpy.
 834  * We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is
 835  * a format which matches the swizzling.
 836  *
 837  * If such a format isn't available, it falls back to _mesa_get_teximage.
 838  *
 839  * NOTE: Drivers usually do a blit to convert between tiled and linear
 840  *       texture layouts during texture uploads/downloads, so the blit
 841  *       we do here should be free in such cases.
 842  */
 843 static void
 844 st_GetTexImage(struct gl_context * ctx,
 845                GLenum format, GLenum type, GLvoid * pixels,
 846                struct gl_texture_image *texImage)
 847 {
 848    struct st_context *st = st_context(ctx);
 849    struct pipe_context *pipe = st->pipe;
 850    struct pipe_screen *screen = pipe->screen;
 851    GLuint width = texImage->Width;
 852    GLuint height = texImage->Height;
 853    GLuint depth = texImage->Depth;
 854    struct st_texture_image *stImage = st_texture_image(texImage);
 855    struct pipe_resource *src = st_texture_object(texImage->TexObject)->pt;
 856    struct pipe_resource *dst = NULL;
 857    struct pipe_resource dst_templ;
 858    enum pipe_format dst_format, src_format;
 859    mesa_format mesa_format;
 860    GLenum gl_target = texImage->TexObject->Target;
 861    enum pipe_texture_target pipe_target;
 862    struct pipe_blit_info blit;
 863    unsigned bind = PIPE_BIND_TRANSFER_READ;
 864    struct pipe_transfer *tex_xfer;
 865    ubyte *map = NULL;
 866    boolean done = FALSE;
 867
 868    if (!st->prefer_blit_based_texture_transfer &&
 869        !_mesa_is_format_compressed(texImage->TexFormat)) {
 870       /* Try to avoid the fallback if we're doing texture decompression here */
 871       goto fallback;
 872    }
 873
 874    if (!stImage->pt || !src) {
 875       goto fallback;
 876    }
 877
 878    /* XXX Fallback to _mesa_get_teximage for depth-stencil formats
 879     * due to an incomplete stencil blit implementation in some drivers. */
 880    if (format == GL_DEPTH_STENCIL) {
 881       goto fallback;
 882    }
 883
 884    /* If the base internal format and the texture format don't match, we have
 885     * to fall back to _mesa_get_teximage. */
 886    if (texImage->_BaseFormat !=
 887        _mesa_get_format_base_format(texImage->TexFormat)) {
 888       goto fallback;
 889    }
 890
 891    /* See if the texture format already matches the format and type,
 892     * in which case the memcpy-based fast path will be used. */
 893    if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
 894                                             type, ctx->Pack.SwapBytes)) {
 895       goto fallback;
 896    }
 897
 898    /* Convert the source format to what is expected by GetTexImage
 899     * and see if it's supported.
 900     *
 901     * This only applies to glGetTexImage:
 902     * - Luminance must be returned as (L,0,0,1).
 903     * - Luminance alpha must be returned as (L,0,0,A).
 904     * - Intensity must be returned as (I,0,0,1)
 905     */
 906    src_format = util_format_linear(src->format);
 907    src_format = util_format_luminance_to_red(src_format);
 908    src_format = util_format_intensity_to_red(src_format);
 909
 910    if (!src_format ||
 911        !screen->is_format_supported(screen, src_format, src->target,
 912                                     src->nr_samples,
 913                                     PIPE_BIND_SAMPLER_VIEW)) {
 914       goto fallback;
 915    }
 916
 917    if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
 918       bind |= PIPE_BIND_DEPTH_STENCIL;
 919    else
 920       bind |= PIPE_BIND_RENDER_TARGET;
 921
 922    /* GetTexImage only returns a single face for cubemaps. */
 923    if (gl_target == GL_TEXTURE_CUBE_MAP) {
 924       gl_target = GL_TEXTURE_2D;
 925    }
 926    pipe_target = gl_target_to_pipe(gl_target);
 927
 928    /* Choose the destination format by finding the best match
 929     * for the format+type combo. */
 930    dst_format = st_choose_matching_format(screen, bind, format, type,
 931                                           ctx->Pack.SwapBytes);
 932
 933    if (dst_format == PIPE_FORMAT_NONE) {
 934       GLenum dst_glformat;
 935
 936       /* Fall back to _mesa_get_teximage except for compressed formats,
 937        * where decompression with a blit is always preferred. */
 938       if (!util_format_is_compressed(src->format)) {
 939          goto fallback;
 940       }
 941
 942       /* Set the appropriate format for the decompressed texture.
 943        * Luminance and sRGB formats shouldn't appear here.*/
 944       switch (src_format) {
 945       case PIPE_FORMAT_DXT1_RGB:
 946       case PIPE_FORMAT_DXT1_RGBA:
 947       case PIPE_FORMAT_DXT3_RGBA:
 948       case PIPE_FORMAT_DXT5_RGBA:
 949       case PIPE_FORMAT_RGTC1_UNORM:
 950       case PIPE_FORMAT_RGTC2_UNORM:
 951       case PIPE_FORMAT_ETC1_RGB8:
 952          dst_glformat = GL_RGBA8;
 953          break;
 954       case PIPE_FORMAT_RGTC1_SNORM:
 955       case PIPE_FORMAT_RGTC2_SNORM:
 956          if (!ctx->Extensions.EXT_texture_snorm)
 957             goto fallback;
 958          dst_glformat = GL_RGBA8_SNORM;
 959          break;
 960       /* TODO: for BPTC_*FLOAT, set RGBA32F and check for ARB_texture_float */
 961       default:
 962          assert(0);
 963          goto fallback;
 964       }
 965
 966       dst_format = st_choose_format(st, dst_glformat, format, type,
 967                                     pipe_target, 0, bind, FALSE);
 968
 969       if (dst_format == PIPE_FORMAT_NONE) {
 970          /* unable to get an rgba format!?! */
 971          goto fallback;
 972       }
 973    }
 974
 975    /* create the destination texture */
 976    memset(&dst_templ, 0, sizeof(dst_templ));
 977    dst_templ.target = pipe_target;
 978    dst_templ.format = dst_format;
 979    dst_templ.bind = bind;
 980    dst_templ.usage = PIPE_USAGE_STAGING;
 981
 982    st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
 983                                    &dst_templ.width0, &dst_templ.height0,
 984                                    &dst_templ.depth0, &dst_templ.array_size);
 985
 986    dst = screen->resource_create(screen, &dst_templ);
 987    if (!dst) {
 988       goto fallback;
 989    }
 990
 991    /* From now on, we need the gallium representation of dimensions. */
 992    if (gl_target == GL_TEXTURE_1D_ARRAY) {
 993       depth = height;
 994       height = 1;
 995    }
 996
 997    blit.src.resource = src;
 998    blit.src.level = texImage->Level;
 999    blit.src.format = src_format;
1000    blit.dst.resource = dst;
1001    blit.dst.level = 0;
1002    blit.dst.format = dst->format;
1003    blit.src.box.x = blit.dst.box.x = 0;
1004    blit.src.box.y = blit.dst.box.y = 0;
1005    blit.src.box.z = texImage->Face;
1006    blit.dst.box.z = 0;
1007    blit.src.box.width = blit.dst.box.width = width;
1008    blit.src.box.height = blit.dst.box.height = height;
1009    blit.src.box.depth = blit.dst.box.depth = depth;
1010    blit.mask = st_get_blit_mask(texImage->_BaseFormat, format);
1011    blit.filter = PIPE_TEX_FILTER_NEAREST;
1012    blit.scissor_enable = FALSE;
1013
1014    /* blit/render/decompress */
1015    st->pipe->blit(st->pipe, &blit);
1016
1017    pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
1018
1019    map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ,
1020                               0, 0, 0, width, height, depth, &tex_xfer);
1021    if (!map) {
1022       goto end;
1023    }
1024
1025    mesa_format = st_pipe_format_to_mesa_format(dst_format);
1026
1027    /* copy/pack data into user buffer */
1028    if (_mesa_format_matches_format_and_type(mesa_format, format, type,
1029                                             ctx->Pack.SwapBytes)) {
1030       /* memcpy */
1031       const uint bytesPerRow = width * util_format_get_blocksize(dst_format);
1032       GLuint row, slice;
1033
1034       for (slice = 0; slice < depth; slice++) {
1035          if (gl_target == GL_TEXTURE_1D_ARRAY) {
1036             /* 1D array textures.
1037              * We need to convert gallium coords to GL coords.
1038              */
1039             GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1040                                                  width, depth, format,
1041                                                  type, 0, slice, 0);
1042             memcpy(dest, map, bytesPerRow);
1043          }
1044          else {
1045             ubyte *slice_map = map;
1046
1047             for (row = 0; row < height; row++) {
1048                GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1049                                                     width, height, format,
1050                                                     type, slice, row, 0);
1051                memcpy(dest, slice_map, bytesPerRow);
1052                slice_map += tex_xfer->stride;
1053             }
1054          }
1055          map += tex_xfer->layer_stride;
1056       }
1057    }
1058    else {
1059       /* format translation via floats */
1060       GLuint row, slice;
1061       GLfloat *rgba;
1062
1063       assert(util_format_is_compressed(src->format));
1064
1065       rgba = malloc(width * 4 * sizeof(GLfloat));
1066       if (!rgba) {
1067          goto end;
1068       }
1069
1070       if (ST_DEBUG & DEBUG_FALLBACK)
1071          debug_printf("%s: fallback format translation\n", __FUNCTION__);
1072
1073       for (slice = 0; slice < depth; slice++) {
1074          if (gl_target == GL_TEXTURE_1D_ARRAY) {
1075             /* 1D array textures.
1076              * We need to convert gallium coords to GL coords.
1077              */
1078             GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1079                                                  width, depth, format,
1080                                                  type, 0, slice, 0);
1081
1082             /* get float[4] rgba row from surface */
1083             pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1,
1084                                       dst_format, rgba);
1085
1086             _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
1087                                        type, dest, &ctx->Pack, 0);
1088          }
1089          else {
1090             for (row = 0; row < height; row++) {
1091                GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1092                                                     width, height, format,
1093                                                     type, slice, row, 0);
1094
1095                /* get float[4] rgba row from surface */
1096                pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1,
1097                                          dst_format, rgba);
1098
1099                _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
1100                                           type, dest, &ctx->Pack, 0);
1101             }
1102          }
1103          map += tex_xfer->layer_stride;
1104       }
1105
1106       free(rgba);
1107    }
1108    done = TRUE;
1109
1110 end:
1111    if (map)
1112       pipe_transfer_unmap(pipe, tex_xfer);
1113
1114    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
1115    pipe_resource_reference(&dst, NULL);
1116
1117 fallback:
1118    if (!done) {
1119       _mesa_get_teximage(ctx, format, type, pixels, texImage);
1120    }
1121 }
1122
1123
1124 /**
1125  * Do a CopyTexSubImage operation using a read transfer from the source,
1126  * a write transfer to the destination and get_tile()/put_tile() to access
1127  * the pixels/texels.
1128  *
1129  * Note: srcY=0=TOP of renderbuffer
1130  */
1131 static void
1132 fallback_copy_texsubimage(struct gl_context *ctx,
1133                           struct st_renderbuffer *strb,
1134                           struct st_texture_image *stImage,
1135                           GLenum baseFormat,
1136                           GLint destX, GLint destY, GLint slice,
1137                           GLint srcX, GLint srcY,
1138                           GLsizei width, GLsizei height)
1139 {
1140    struct st_context *st = st_context(ctx);
1141    struct pipe_context *pipe = st->pipe;
1142    struct pipe_transfer *src_trans;
1143    GLubyte *texDest;
1144    enum pipe_transfer_usage transfer_usage;
1145    void *map;
1146    unsigned dst_width = width;
1147    unsigned dst_height = height;
1148    unsigned dst_depth = 1;
1149
1150    if (ST_DEBUG & DEBUG_FALLBACK)
1151       debug_printf("%s: fallback processing\n", __FUNCTION__);
1152
1153    if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1154       srcY = strb->Base.Height - srcY - height;
1155    }
1156
1157    map = pipe_transfer_map(pipe,
1158                            strb->texture,
1159                            strb->surface->u.tex.level,
1160                            strb->surface->u.tex.first_layer,
1161                            PIPE_TRANSFER_READ,
1162                            srcX, srcY,
1163                            width, height, &src_trans);
1164
1165    if ((baseFormat == GL_DEPTH_COMPONENT ||
1166         baseFormat == GL_DEPTH_STENCIL) &&
1167        util_format_is_depth_and_stencil(stImage->pt->format))
1168       transfer_usage = PIPE_TRANSFER_READ_WRITE;
1169    else
1170       transfer_usage = PIPE_TRANSFER_WRITE;
1171
1172    texDest = st_texture_image_map(st, stImage, transfer_usage,
1173                                   destX, destY, slice,
1174                                   dst_width, dst_height, dst_depth);
1175
1176    if (baseFormat == GL_DEPTH_COMPONENT ||
1177        baseFormat == GL_DEPTH_STENCIL) {
1178       const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
1179                                      ctx->Pixel.DepthBias != 0.0F);
1180       GLint row, yStep;
1181       uint *data;
1182
1183       /* determine bottom-to-top vs. top-to-bottom order for src buffer */
1184       if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1185          srcY = height - 1;
1186          yStep = -1;
1187       }
1188       else {
1189          srcY = 0;
1190          yStep = 1;
1191       }
1192
1193       data = malloc(width * sizeof(uint));
1194
1195       if (data) {
1196          /* To avoid a large temp memory allocation, do copy row by row */
1197          for (row = 0; row < height; row++, srcY += yStep) {
1198             pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data);
1199             if (scaleOrBias) {
1200                _mesa_scale_and_bias_depth_uint(ctx, width, data);
1201             }
1202
1203             if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
1204                pipe_put_tile_z(stImage->transfer,
1205                                texDest + row*stImage->transfer->layer_stride,
1206                                0, 0, width, 1, data);
1207             }
1208             else {
1209                pipe_put_tile_z(stImage->transfer, texDest, 0, row, width, 1,
1210                                data);
1211             }
1212          }
1213       }
1214       else {
1215          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
1216       }
1217
1218       free(data);
1219    }
1220    else {
1221       /* RGBA format */
1222       GLfloat *tempSrc =
1223          malloc(width * height * 4 * sizeof(GLfloat));
1224
1225       if (tempSrc && texDest) {
1226          const GLint dims = 2;
1227          GLint dstRowStride;
1228          struct gl_texture_image *texImage = &stImage->base;
1229          struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
1230
1231          if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1232             unpack.Invert = GL_TRUE;
1233          }
1234
1235          if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
1236             dstRowStride = stImage->transfer->layer_stride;
1237          }
1238          else {
1239             dstRowStride = stImage->transfer->stride;
1240          }
1241
1242          /* get float/RGBA image from framebuffer */
1243          /* XXX this usually involves a lot of int/float conversion.
1244           * try to avoid that someday.
1245           */
1246          pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height,
1247                                    util_format_linear(strb->texture->format),
1248                                    tempSrc);
1249
1250          /* Store into texture memory.
1251           * Note that this does some special things such as pixel transfer
1252           * ops and format conversion.  In particular, if the dest tex format
1253           * is actually RGBA but the user created the texture as GL_RGB we
1254           * need to fill-in/override the alpha channel with 1.0.
1255           */
1256          _mesa_texstore(ctx, dims,
1257                         texImage->_BaseFormat,
1258                         texImage->TexFormat,
1259                         dstRowStride,
1260                         &texDest,
1261                         width, height, 1,
1262                         GL_RGBA, GL_FLOAT, tempSrc, /* src */
1263                         &unpack);
1264       }
1265       else {
1266          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
1267       }
1268
1269       free(tempSrc);
1270    }
1271
1272    st_texture_image_unmap(st, stImage);
1273    pipe->transfer_unmap(pipe, src_trans);
1274 }
1275
1276
1277 /**
1278  * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
1279  * Note that the region to copy has already been clipped so we know we
1280  * won't read from outside the source renderbuffer's bounds.
1281  *
1282  * Note: srcY=0=Bottom of renderbuffer (GL convention)
1283  */
1284 static void
1285 st_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
1286                    struct gl_texture_image *texImage,
1287                    GLint destX, GLint destY, GLint slice,
1288                    struct gl_renderbuffer *rb,
1289                    GLint srcX, GLint srcY, GLsizei width, GLsizei height)
1290 {
1291    struct st_texture_image *stImage = st_texture_image(texImage);
1292    struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1293    struct st_renderbuffer *strb = st_renderbuffer(rb);
1294    struct st_context *st = st_context(ctx);
1295    struct pipe_context *pipe = st->pipe;
1296    struct pipe_screen *screen = pipe->screen;
1297    struct pipe_blit_info blit;
1298    enum pipe_format dst_format;
1299    GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
1300    unsigned bind;
1301    GLint srcY0, srcY1;
1302
1303    if (!strb || !strb->surface || !stImage->pt) {
1304       debug_printf("%s: null strb or stImage\n", __FUNCTION__);
1305       return;
1306    }
1307
1308    if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat,
1309                                          texImage->TexFormat)) {
1310       goto fallback;
1311    }
1312
1313    /* The base internal format must match the mesa format, so make sure
1314     * e.g. an RGB internal format is really allocated as RGB and not as RGBA.
1315     */
1316    if (texImage->_BaseFormat !=
1317        _mesa_get_format_base_format(texImage->TexFormat) ||
1318        rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) {
1319       goto fallback;
1320    }
1321
1322    /* Choose the destination format to match the TexImage behavior. */
1323    dst_format = util_format_linear(stImage->pt->format);
1324    dst_format = util_format_luminance_to_red(dst_format);
1325    dst_format = util_format_intensity_to_red(dst_format);
1326
1327    /* See if the destination format is supported. */
1328    if (texImage->_BaseFormat == GL_DEPTH_STENCIL ||
1329        texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
1330       bind = PIPE_BIND_DEPTH_STENCIL;
1331    }
1332    else {
1333       bind = PIPE_BIND_RENDER_TARGET;
1334    }
1335
1336    if (!dst_format ||
1337        !screen->is_format_supported(screen, dst_format, stImage->pt->target,
1338                                     stImage->pt->nr_samples, bind)) {
1339       goto fallback;
1340    }
1341
1342    /* Y flipping for the main framebuffer. */
1343    if (do_flip) {
1344       srcY1 = strb->Base.Height - srcY - height;
1345       srcY0 = srcY1 + height;
1346    }
1347    else {
1348       srcY0 = srcY;
1349       srcY1 = srcY0 + height;
1350    }
1351
1352    /* Blit the texture.
1353     * This supports flipping, format conversions, and downsampling.
1354     */
1355    memset(&blit, 0, sizeof(blit));
1356    blit.src.resource = strb->texture;
1357    blit.src.format = util_format_linear(strb->surface->format);
1358    blit.src.level = strb->surface->u.tex.level;
1359    blit.src.box.x = srcX;
1360    blit.src.box.y = srcY0;
1361    blit.src.box.z = strb->surface->u.tex.first_layer;
1362    blit.src.box.width = width;
1363    blit.src.box.height = srcY1 - srcY0;
1364    blit.src.box.depth = 1;
1365    blit.dst.resource = stImage->pt;
1366    blit.dst.format = dst_format;
1367    blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level;
1368    blit.dst.box.x = destX;
1369    blit.dst.box.y = destY;
1370    blit.dst.box.z = stImage->base.Face + slice;
1371    blit.dst.box.width = width;
1372    blit.dst.box.height = height;
1373    blit.dst.box.depth = 1;
1374    blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat);
1375    blit.filter = PIPE_TEX_FILTER_NEAREST;
1376    pipe->blit(pipe, &blit);
1377    return;
1378
1379 fallback:
1380    /* software fallback */
1381    fallback_copy_texsubimage(ctx,
1382                              strb, stImage, texImage->_BaseFormat,
1383                              destX, destY, slice,
1384                              srcX, srcY, width, height);
1385 }
1386
1387
1388 /**
1389  * Copy image data from stImage into the texture object 'stObj' at level
1390  * 'dstLevel'.
1391  */
1392 static void
1393 copy_image_data_to_texture(struct st_context *st,
1394                            struct st_texture_object *stObj,
1395                            GLuint dstLevel,
1396                            struct st_texture_image *stImage)
1397 {
1398    /* debug checks */
1399    {
1400       const struct gl_texture_image *dstImage =
1401          stObj->base.Image[stImage->base.Face][dstLevel];
1402       assert(dstImage);
1403       assert(dstImage->Width == stImage->base.Width);
1404       assert(dstImage->Height == stImage->base.Height);
1405       assert(dstImage->Depth == stImage->base.Depth);
1406    }
1407
1408    if (stImage->pt) {
1409       /* Copy potentially with the blitter:
1410        */
1411       GLuint src_level;
1412       if (stImage->pt->last_level == 0)
1413          src_level = 0;
1414       else
1415          src_level = stImage->base.Level;
1416
1417       assert(src_level <= stImage->pt->last_level);
1418       assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width);
1419       assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY ||
1420              u_minify(stImage->pt->height0, src_level) == stImage->base.Height);
1421       assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY ||
1422              stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY ||
1423              u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth);
1424
1425       st_texture_image_copy(st->pipe,
1426                             stObj->pt, dstLevel,  /* dest texture, level */
1427                             stImage->pt, src_level, /* src texture, level */
1428                             stImage->base.Face);
1429
1430       pipe_resource_reference(&stImage->pt, NULL);
1431    }
1432    else if (stImage->TexData) {
1433       /* Copy from malloc'd memory */
1434       /* XXX this should be re-examined/tested with a compressed format */
1435       GLuint blockSize = util_format_get_blocksize(stObj->pt->format);
1436       GLuint srcRowStride = stImage->base.Width * blockSize;
1437       GLuint srcSliceStride = stImage->base.Height * srcRowStride;
1438       st_texture_image_data(st,
1439                             stObj->pt,
1440                             stImage->base.Face,
1441                             dstLevel,
1442                             stImage->TexData,
1443                             srcRowStride,
1444                             srcSliceStride);
1445       _mesa_align_free(stImage->TexData);
1446       stImage->TexData = NULL;
1447    }
1448
1449    pipe_resource_reference(&stImage->pt, stObj->pt);
1450 }
1451
1452
1453 /**
1454  * Called during state validation.  When this function is finished,
1455  * the texture object should be ready for rendering.
1456  * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
1457  */
1458 GLboolean
1459 st_finalize_texture(struct gl_context *ctx,
1460                     struct pipe_context *pipe,
1461                     struct gl_texture_object *tObj)
1462 {
1463    struct st_context *st = st_context(ctx);
1464    struct st_texture_object *stObj = st_texture_object(tObj);
1465    const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1466    GLuint face;
1467    struct st_texture_image *firstImage;
1468    enum pipe_format firstImageFormat;
1469    GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples;
1470
1471    if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
1472       /* The texture is complete and we know exactly how many mipmap levels
1473        * are present/needed.  This is conditional because we may be called
1474        * from the st_generate_mipmap() function when the texture object is
1475        * incomplete.  In that case, we'll have set stObj->lastLevel before
1476        * we get here.
1477        */
1478       if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
1479           stObj->base.Sampler.MinFilter == GL_NEAREST)
1480          stObj->lastLevel = stObj->base.BaseLevel;
1481       else
1482          stObj->lastLevel = stObj->base._MaxLevel;
1483    }
1484
1485    if (tObj->Target == GL_TEXTURE_BUFFER) {
1486       struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject);
1487
1488       if (!st_obj) {
1489          pipe_resource_reference(&stObj->pt, NULL);
1490          pipe_sampler_view_reference(&stObj->sampler_view, NULL);
1491          return GL_TRUE;
1492       }
1493
1494       if (st_obj->buffer != stObj->pt) {
1495          pipe_resource_reference(&stObj->pt, st_obj->buffer);
1496          pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1497          stObj->width0 = stObj->pt->width0 / _mesa_get_format_bytes(tObj->_BufferObjectFormat);
1498          stObj->height0 = 1;
1499          stObj->depth0 = 1;
1500       }
1501       return GL_TRUE;
1502
1503    }
1504
1505    firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);
1506    assert(firstImage);
1507
1508    /* If both firstImage and stObj point to a texture which can contain
1509     * all active images, favour firstImage.  Note that because of the
1510     * completeness requirement, we know that the image dimensions
1511     * will match.
1512     */
1513    if (firstImage->pt &&
1514        firstImage->pt != stObj->pt &&
1515        (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) {
1516       pipe_resource_reference(&stObj->pt, firstImage->pt);
1517       pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1518    }
1519
1520    /* If this texture comes from a window system, there is nothing else to do. */
1521    if (stObj->surface_based) {
1522       return GL_TRUE;
1523    }
1524
1525    /* Find gallium format for the Mesa texture */
1526    firstImageFormat = st_mesa_format_to_pipe_format(firstImage->base.TexFormat);
1527
1528    /* Find size of level=0 Gallium mipmap image, plus number of texture layers */
1529    {
1530       GLuint width, height, depth;
1531       if (!guess_base_level_size(stObj->base.Target,
1532                                  firstImage->base.Width2,
1533                                  firstImage->base.Height2,
1534                                  firstImage->base.Depth2,
1535                                  firstImage->base.Level,
1536                                  &width, &height, &depth)) {
1537          width = stObj->width0;
1538          height = stObj->height0;
1539          depth = stObj->depth0;
1540       }
1541       /* convert GL dims to Gallium dims */
1542       st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth,
1543                                       &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1544       ptNumSamples = firstImage->base.NumSamples;
1545    }
1546
1547    /* If we already have a gallium texture, check that it matches the texture
1548     * object's format, target, size, num_levels, etc.
1549     */
1550    if (stObj->pt) {
1551       if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
1552           stObj->pt->format != firstImageFormat ||
1553           stObj->pt->last_level < stObj->lastLevel ||
1554           stObj->pt->width0 != ptWidth ||
1555           stObj->pt->height0 != ptHeight ||
1556           stObj->pt->depth0 != ptDepth ||
1557           stObj->pt->nr_samples != ptNumSamples ||
1558           stObj->pt->array_size != ptLayers)
1559       {
1560          /* The gallium texture does not match the Mesa texture so delete the
1561           * gallium texture now.  We'll make a new one below.
1562           */
1563          pipe_resource_reference(&stObj->pt, NULL);
1564          pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1565          st->dirty.st |= ST_NEW_FRAMEBUFFER;
1566       }
1567    }
1568
1569    /* May need to create a new gallium texture:
1570     */
1571    if (!stObj->pt) {
1572       GLuint bindings = default_bindings(st, firstImageFormat);
1573
1574       stObj->pt = st_texture_create(st,
1575                                     gl_target_to_pipe(stObj->base.Target),
1576                                     firstImageFormat,
1577                                     stObj->lastLevel,
1578                                     ptWidth,
1579                                     ptHeight,
1580                                     ptDepth,
1581                                     ptLayers, ptNumSamples,
1582                                     bindings);
1583
1584       if (!stObj->pt) {
1585          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
1586          return GL_FALSE;
1587       }
1588    }
1589
1590    /* Pull in any images not in the object's texture:
1591     */
1592    for (face = 0; face < nr_faces; face++) {
1593       GLuint level;
1594       for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) {
1595          struct st_texture_image *stImage =
1596             st_texture_image(stObj->base.Image[face][level]);
1597
1598          /* Need to import images in main memory or held in other textures.
1599           */
1600          if (stImage && stObj->pt != stImage->pt) {
1601             if (level == 0 ||
1602                 (stImage->base.Width == u_minify(stObj->width0, level) &&
1603                  stImage->base.Height == u_minify(stObj->height0, level) &&
1604                  stImage->base.Depth == u_minify(stObj->depth0, level))) {
1605                /* src image fits expected dest mipmap level size */
1606                copy_image_data_to_texture(st, stObj, level, stImage);
1607             }
1608          }
1609       }
1610    }
1611
1612    return GL_TRUE;
1613 }
1614
1615
1616 /**
1617  * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory
1618  * for a whole mipmap stack.
1619  */
1620 static GLboolean
1621 st_AllocTextureStorage(struct gl_context *ctx,
1622                        struct gl_texture_object *texObj,
1623                        GLsizei levels, GLsizei width,
1624                        GLsizei height, GLsizei depth)
1625 {
1626    const GLuint numFaces = _mesa_num_tex_faces(texObj->Target);
1627    struct gl_texture_image *texImage = texObj->Image[0][0];
1628    struct st_context *st = st_context(ctx);
1629    struct st_texture_object *stObj = st_texture_object(texObj);
1630    struct pipe_screen *screen = st->pipe->screen;
1631    GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings;
1632    enum pipe_format fmt;
1633    GLint level;
1634    GLuint num_samples = texImage->NumSamples;
1635
1636    assert(levels > 0);
1637
1638    /* Save the level=0 dimensions */
1639    stObj->width0 = width;
1640    stObj->height0 = height;
1641    stObj->depth0 = depth;
1642    stObj->lastLevel = levels - 1;
1643
1644    fmt = st_mesa_format_to_pipe_format(texImage->TexFormat);
1645
1646    bindings = default_bindings(st, fmt);
1647
1648    /* Raise the sample count if the requested one is unsupported. */
1649    if (num_samples > 1) {
1650       boolean found = FALSE;
1651
1652       for (; num_samples <= ctx->Const.MaxSamples; num_samples++) {
1653          if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D,
1654                                          num_samples,
1655                                          PIPE_BIND_SAMPLER_VIEW)) {
1656             /* Update the sample count in gl_texture_image as well. */
1657             texImage->NumSamples = num_samples;
1658             found = TRUE;
1659             break;
1660          }
1661       }
1662
1663       if (!found) {
1664          return GL_FALSE;
1665       }
1666    }
1667
1668    st_gl_texture_dims_to_pipe_dims(texObj->Target,
1669                                    width, height, depth,
1670                                    &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1671
1672    stObj->pt = st_texture_create(st,
1673                                  gl_target_to_pipe(texObj->Target),
1674                                  fmt,
1675                                  levels - 1,
1676                                  ptWidth,
1677                                  ptHeight,
1678                                  ptDepth,
1679                                  ptLayers, num_samples,
1680                                  bindings);
1681    if (!stObj->pt)
1682       return GL_FALSE;
1683
1684    /* Set image resource pointers */
1685    for (level = 0; level < levels; level++) {
1686       GLuint face;
1687       for (face = 0; face < numFaces; face++) {
1688          struct st_texture_image *stImage =
1689             st_texture_image(texObj->Image[face][level]);
1690          pipe_resource_reference(&stImage->pt, stObj->pt);
1691       }
1692    }
1693
1694    return GL_TRUE;
1695 }
1696
1697
1698 static GLboolean
1699 st_TestProxyTexImage(struct gl_context *ctx, GLenum target,
1700                      GLint level, mesa_format format,
1701                      GLint width, GLint height,
1702                      GLint depth, GLint border)
1703 {
1704    struct st_context *st = st_context(ctx);
1705    struct pipe_context *pipe = st->pipe;
1706
1707    if (width == 0 || height == 0 || depth == 0) {
1708       /* zero-sized images are legal, and always fit! */
1709       return GL_TRUE;
1710    }
1711
1712    if (pipe->screen->can_create_resource) {
1713       /* Ask the gallium driver if the texture is too large */
1714       struct gl_texture_object *texObj =
1715          _mesa_get_current_tex_object(ctx, target);
1716       struct pipe_resource pt;
1717
1718       /* Setup the pipe_resource object
1719        */
1720       memset(&pt, 0, sizeof(pt));
1721
1722       pt.target = gl_target_to_pipe(target);
1723       pt.format = st_mesa_format_to_pipe_format(format);
1724
1725       st_gl_texture_dims_to_pipe_dims(target,
1726                                       width, height, depth,
1727                                       &pt.width0, &pt.height0,
1728                                       &pt.depth0, &pt.array_size);
1729
1730       if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR ||
1731                          texObj->Sampler.MinFilter == GL_NEAREST)) {
1732          /* assume just one mipmap level */
1733          pt.last_level = 0;
1734       }
1735       else {
1736          /* assume a full set of mipmaps */
1737          pt.last_level = _mesa_logbase2(MAX3(width, height, depth));
1738       }
1739
1740       return pipe->screen->can_create_resource(pipe->screen, &pt);
1741    }
1742    else {
1743       /* Use core Mesa fallback */
1744       return _mesa_test_proxy_teximage(ctx, target, level, format,
1745                                        width, height, depth, border);
1746    }
1747 }
1748
1749
1750 void
1751 st_init_texture_functions(struct dd_function_table *functions)
1752 {
1753    functions->ChooseTextureFormat = st_ChooseTextureFormat;
1754    functions->QuerySamplesForFormat = st_QuerySamplesForFormat;
1755    functions->TexImage = st_TexImage;
1756    functions->TexSubImage = st_TexSubImage;
1757    functions->CompressedTexSubImage = _mesa_store_compressed_texsubimage;
1758    functions->CopyTexSubImage = st_CopyTexSubImage;
1759    functions->GenerateMipmap = st_generate_mipmap;
1760
1761    functions->GetTexImage = st_GetTexImage;
1762
1763    /* compressed texture functions */
1764    functions->CompressedTexImage = st_CompressedTexImage;
1765    functions->GetCompressedTexImage = _mesa_get_compressed_teximage;
1766
1767    functions->NewTextureObject = st_NewTextureObject;
1768    functions->NewTextureImage = st_NewTextureImage;
1769    functions->DeleteTextureImage = st_DeleteTextureImage;
1770    functions->DeleteTexture = st_DeleteTextureObject;
1771    functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
1772    functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
1773    functions->MapTextureImage = st_MapTextureImage;
1774    functions->UnmapTextureImage = st_UnmapTextureImage;
1775
1776    /* XXX Temporary until we can query pipe's texture sizes */
1777    functions->TestProxyTexImage = st_TestProxyTexImage;
1778
1779    functions->AllocTextureStorage = st_AllocTextureStorage;
1780 }