src/mesa/state_tracker/st_cb_copyimage.c

   1 /*
   2  * Copyright 2015 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #include "state_tracker/st_context.h"
  26 #include "state_tracker/st_cb_bitmap.h"
  27 #include "state_tracker/st_cb_copyimage.h"
  28 #include "state_tracker/st_cb_fbo.h"
  29 #include "state_tracker/st_texture.h"
  30
  31 #include "util/u_box.h"
  32 #include "util/u_format.h"
  33 #include "util/u_inlines.h"
  34
  35
  36 /**
  37  * Return an equivalent canonical format without "X" channels.
  38  *
  39  * Copying between incompatible formats is easier when the format is
  40  * canonicalized, meaning that it is in a standard form.
  41  *
  42  * The returned format has the same component sizes and swizzles as
  43  * the source format, the type is changed to UINT or UNORM, depending on
  44  * which one has the most swizzle combinations in their group.
  45  *
  46  * If it's not an array format, return a memcpy-equivalent array format.
  47  *
  48  * The key feature is that swizzled versions of formats of the same
  49  * component size always return the same component type.
  50  *
  51  * X returns A.
  52  * Luminance, intensity, alpha, depth, stencil, and 8-bit and 16-bit packed
  53  * formats are not supported. (same as ARB_copy_image)
  54  */
  55 static enum pipe_format
  56 get_canonical_format(enum pipe_format format)
  57 {
  58    const struct util_format_description *desc =
  59       util_format_description(format);
  60
  61    /* Packed formats. Return the equivalent array format. */
  62    if (format == PIPE_FORMAT_R11G11B10_FLOAT ||
  63        format == PIPE_FORMAT_R9G9B9E5_FLOAT)
  64       return get_canonical_format(PIPE_FORMAT_R8G8B8A8_UINT);
  65
  66    if (desc->nr_channels == 4 &&
  67        desc->channel[0].size == 10 &&
  68        desc->channel[1].size == 10 &&
  69        desc->channel[2].size == 10 &&
  70        desc->channel[3].size == 2) {
  71       if (desc->swizzle[0] == PIPE_SWIZZLE_X &&
  72           desc->swizzle[1] == PIPE_SWIZZLE_Y &&
  73           desc->swizzle[2] == PIPE_SWIZZLE_Z)
  74          return get_canonical_format(PIPE_FORMAT_R8G8B8A8_UINT);
  75
  76       return PIPE_FORMAT_NONE;
  77    }
  78
  79 #define RETURN_FOR_SWIZZLE1(x, format) \
  80    if (desc->swizzle[0] == PIPE_SWIZZLE_##x) \
  81       return format
  82
  83 #define RETURN_FOR_SWIZZLE2(x, y, format) \
  84    if (desc->swizzle[0] == PIPE_SWIZZLE_##x && \
  85        desc->swizzle[1] == PIPE_SWIZZLE_##y) \
  86       return format
  87
  88 #define RETURN_FOR_SWIZZLE3(x, y, z, format) \
  89    if (desc->swizzle[0] == PIPE_SWIZZLE_##x && \
  90        desc->swizzle[1] == PIPE_SWIZZLE_##y && \
  91        desc->swizzle[2] == PIPE_SWIZZLE_##z) \
  92       return format
  93
  94 #define RETURN_FOR_SWIZZLE4(x, y, z, w, format) \
  95    if (desc->swizzle[0] == PIPE_SWIZZLE_##x && \
  96        desc->swizzle[1] == PIPE_SWIZZLE_##y && \
  97        desc->swizzle[2] == PIPE_SWIZZLE_##z && \
  98        desc->swizzle[3] == PIPE_SWIZZLE_##w) \
  99       return format
 100
 101    /* Array formats. */
 102    if (desc->is_array) {
 103       switch (desc->nr_channels) {
 104       case 1:
 105          switch (desc->channel[0].size) {
 106          case 8:
 107             RETURN_FOR_SWIZZLE1(X, PIPE_FORMAT_R8_UINT);
 108             break;
 109
 110          case 16:
 111             RETURN_FOR_SWIZZLE1(X, PIPE_FORMAT_R16_UINT);
 112             break;
 113
 114          case 32:
 115             RETURN_FOR_SWIZZLE1(X, PIPE_FORMAT_R32_UINT);
 116             break;
 117          }
 118          break;
 119
 120       case 2:
 121          switch (desc->channel[0].size) {
 122          case 8:
 123             /* All formats in each group must be of the same type.
 124              * We can't use UINT for R8G8 while using UNORM for G8R8.
 125              */
 126             RETURN_FOR_SWIZZLE2(X, Y, PIPE_FORMAT_R8G8_UNORM);
 127             RETURN_FOR_SWIZZLE2(Y, X, PIPE_FORMAT_G8R8_UNORM);
 128             break;
 129
 130          case 16:
 131             RETURN_FOR_SWIZZLE2(X, Y, PIPE_FORMAT_R16G16_UNORM);
 132             RETURN_FOR_SWIZZLE2(Y, X, PIPE_FORMAT_G16R16_UNORM);
 133             break;
 134
 135          case 32:
 136             RETURN_FOR_SWIZZLE2(X, Y, PIPE_FORMAT_R32G32_UINT);
 137             break;
 138          }
 139          break;
 140
 141       case 3:
 142          switch (desc->channel[0].size) {
 143          case 8:
 144             RETURN_FOR_SWIZZLE3(X, Y, Z, PIPE_FORMAT_R8G8B8_UINT);
 145             break;
 146
 147          case 16:
 148             RETURN_FOR_SWIZZLE3(X, Y, Z, PIPE_FORMAT_R16G16B16_UINT);
 149             break;
 150
 151          case 32:
 152             RETURN_FOR_SWIZZLE3(X, Y, Z, PIPE_FORMAT_R32G32B32_UINT);
 153             break;
 154          }
 155          break;
 156
 157       case 4:
 158          switch (desc->channel[0].size) {
 159          case 8:
 160             RETURN_FOR_SWIZZLE4(X, Y, Z, W, PIPE_FORMAT_R8G8B8A8_UNORM);
 161             RETURN_FOR_SWIZZLE4(X, Y, Z, 1, PIPE_FORMAT_R8G8B8A8_UNORM);
 162             RETURN_FOR_SWIZZLE4(Z, Y, X, W, PIPE_FORMAT_B8G8R8A8_UNORM);
 163             RETURN_FOR_SWIZZLE4(Z, Y, X, 1, PIPE_FORMAT_B8G8R8A8_UNORM);
 164             RETURN_FOR_SWIZZLE4(W, Z, Y, X, PIPE_FORMAT_A8B8G8R8_UNORM);
 165             RETURN_FOR_SWIZZLE4(W, Z, Y, 1, PIPE_FORMAT_A8B8G8R8_UNORM);
 166             RETURN_FOR_SWIZZLE4(Y, Z, W, X, PIPE_FORMAT_A8R8G8B8_UNORM);
 167             RETURN_FOR_SWIZZLE4(Y, Z, W, 1, PIPE_FORMAT_A8R8G8B8_UNORM);
 168             break;
 169
 170          case 16:
 171             RETURN_FOR_SWIZZLE4(X, Y, Z, W, PIPE_FORMAT_R16G16B16A16_UINT);
 172             RETURN_FOR_SWIZZLE4(X, Y, Z, 1, PIPE_FORMAT_R16G16B16A16_UINT);
 173             break;
 174
 175          case 32:
 176             RETURN_FOR_SWIZZLE4(X, Y, Z, W, PIPE_FORMAT_R32G32B32A32_UINT);
 177             RETURN_FOR_SWIZZLE4(X, Y, Z, 1, PIPE_FORMAT_R32G32B32A32_UINT);
 178             break;
 179          }
 180       }
 181
 182       assert(!"unknown array format");
 183       return PIPE_FORMAT_NONE;
 184    }
 185
 186    assert(!"unknown packed format");
 187    return PIPE_FORMAT_NONE;
 188 }
 189
 190 /**
 191  * Return true if the swizzle is XYZW in case of a 4-channel format,
 192  * XY in case of a 2-channel format, or X in case of a 1-channel format.
 193  */
 194 static bool
 195 has_identity_swizzle(const struct util_format_description *desc)
 196 {
 197    int i;
 198
 199    for (i = 0; i < desc->nr_channels; i++)
 200       if (desc->swizzle[i] != PIPE_SWIZZLE_X + i)
 201          return false;
 202
 203    return true;
 204 }
 205
 206 /**
 207  * Return a canonical format for the given bits and channel size.
 208  */
 209 static enum pipe_format
 210 canonical_format_from_bits(unsigned bits, unsigned channel_size)
 211 {
 212    switch (bits) {
 213    case 8:
 214       if (channel_size == 8)
 215          return get_canonical_format(PIPE_FORMAT_R8_UINT);
 216       break;
 217
 218    case 16:
 219       if (channel_size == 8)
 220          return get_canonical_format(PIPE_FORMAT_R8G8_UINT);
 221       if (channel_size == 16)
 222          return get_canonical_format(PIPE_FORMAT_R16_UINT);
 223       break;
 224
 225    case 32:
 226       if (channel_size == 8)
 227          return get_canonical_format(PIPE_FORMAT_R8G8B8A8_UINT);
 228       if (channel_size == 16)
 229          return get_canonical_format(PIPE_FORMAT_R16G16_UINT);
 230       if (channel_size == 32)
 231          return get_canonical_format(PIPE_FORMAT_R32_UINT);
 232       break;
 233
 234    case 64:
 235       if (channel_size == 16)
 236          return get_canonical_format(PIPE_FORMAT_R16G16B16A16_UINT);
 237       if (channel_size == 32)
 238          return get_canonical_format(PIPE_FORMAT_R32G32_UINT);
 239       break;
 240
 241    case 128:
 242       if (channel_size == 32)
 243          return get_canonical_format(PIPE_FORMAT_R32G32B32A32_UINT);
 244       break;
 245    }
 246
 247    assert(!"impossible format");
 248    return PIPE_FORMAT_NONE;
 249 }
 250
 251 static void
 252 blit(struct pipe_context *pipe,
 253      struct pipe_resource *dst,
 254      enum pipe_format dst_format,
 255      unsigned dst_level,
 256      unsigned dstx, unsigned dsty, unsigned dstz,
 257      struct pipe_resource *src,
 258      enum pipe_format src_format,
 259      unsigned src_level,
 260      const struct pipe_box *src_box)
 261 {
 262    struct pipe_blit_info blit = {{0}};
 263
 264    blit.src.resource = src;
 265    blit.dst.resource = dst;
 266    blit.src.format = src_format;
 267    blit.dst.format = dst_format;
 268    blit.src.level = src_level;
 269    blit.dst.level = dst_level;
 270    blit.src.box = *src_box;
 271    u_box_3d(dstx, dsty, dstz, src_box->width, src_box->height,
 272             src_box->depth, &blit.dst.box);
 273    blit.mask = PIPE_MASK_RGBA;
 274    blit.filter = PIPE_TEX_FILTER_NEAREST;
 275
 276    pipe->blit(pipe, &blit);
 277 }
 278
 279 static void
 280 swizzled_copy(struct pipe_context *pipe,
 281               struct pipe_resource *dst,
 282               unsigned dst_level,
 283               unsigned dstx, unsigned dsty, unsigned dstz,
 284               struct pipe_resource *src,
 285               unsigned src_level,
 286               const struct pipe_box *src_box)
 287 {
 288    const struct util_format_description *src_desc, *dst_desc;
 289    unsigned bits;
 290    enum pipe_format blit_src_format, blit_dst_format;
 291
 292    /* Get equivalent canonical formats. Those are always array formats and
 293     * copying between compatible canonical formats behaves either like
 294     * memcpy or like swizzled memcpy. The idea is that we won't have to care
 295     * about the channel type from this point on.
 296     * Only the swizzle and channel size.
 297     */
 298    blit_src_format = get_canonical_format(src->format);
 299    blit_dst_format = get_canonical_format(dst->format);
 300
 301    assert(blit_src_format != PIPE_FORMAT_NONE);
 302    assert(blit_dst_format != PIPE_FORMAT_NONE);
 303
 304    src_desc = util_format_description(blit_src_format);
 305    dst_desc = util_format_description(blit_dst_format);
 306
 307    assert(src_desc->block.bits == dst_desc->block.bits);
 308    bits = src_desc->block.bits;
 309
 310    if (dst_desc->channel[0].size == src_desc->channel[0].size) {
 311       /* Only the swizzle is different, which means we can just blit,
 312        * e.g. RGBA -> BGRA.
 313        */
 314    } else if (has_identity_swizzle(src_desc)) {
 315       /* Src is unswizzled and dst can be swizzled, so src is typecast
 316        * to an equivalent dst-compatible format.
 317        * e.g. R32 -> BGRA8 is realized as RGBA8 -> BGRA8
 318        */
 319       blit_src_format =
 320          canonical_format_from_bits(bits, dst_desc->channel[0].size);
 321    } else if (has_identity_swizzle(dst_desc)) {
 322       /* Dst is unswizzled and src can be swizzled, so dst is typecast
 323        * to an equivalent src-compatible format.
 324        * e.g. BGRA8 -> R32 is realized as BGRA8 -> RGBA8
 325        */
 326       blit_dst_format =
 327          canonical_format_from_bits(bits, src_desc->channel[0].size);
 328    } else {
 329       assert(!"This should have been handled by handle_complex_copy.");
 330       return;
 331    }
 332
 333    blit(pipe, dst, blit_dst_format, dst_level, dstx, dsty, dstz,
 334         src, blit_src_format, src_level, src_box);
 335 }
 336
 337 static bool
 338 same_size_and_swizzle(const struct util_format_description *d1,
 339                       const struct util_format_description *d2)
 340 {
 341    int i;
 342
 343    if (d1->layout != d2->layout ||
 344        d1->nr_channels != d2->nr_channels ||
 345        d1->is_array != d2->is_array)
 346       return false;
 347
 348    for (i = 0; i < d1->nr_channels; i++) {
 349       if (d1->channel[i].size != d2->channel[i].size)
 350          return false;
 351
 352       if (d1->swizzle[i] <= PIPE_SWIZZLE_W &&
 353           d2->swizzle[i] <= PIPE_SWIZZLE_W &&
 354           d1->swizzle[i] != d2->swizzle[i])
 355          return false;
 356    }
 357
 358    return true;
 359 }
 360
 361 static struct pipe_resource *
 362 create_texture(struct pipe_screen *screen, enum pipe_format format,
 363                unsigned nr_samples,
 364                unsigned width, unsigned height, unsigned depth)
 365 {
 366    struct pipe_resource templ;
 367
 368    memset(&templ, 0, sizeof(templ));
 369    templ.format = format;
 370    templ.width0 = width;
 371    templ.height0 = height;
 372    templ.depth0 = 1;
 373    templ.array_size = depth;
 374    templ.nr_samples = nr_samples;
 375    templ.usage = PIPE_USAGE_DEFAULT;
 376    templ.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
 377
 378    if (depth > 1)
 379       templ.target = PIPE_TEXTURE_2D_ARRAY;
 380    else
 381       templ.target = PIPE_TEXTURE_2D;
 382
 383    return screen->resource_create(screen, &templ);
 384 }
 385
 386 /**
 387  * Handle complex format conversions using 2 blits with a temporary texture
 388  * in between, e.g. blitting from B10G10R10A2 to G16R16.
 389  *
 390  * This example is implemented this way:
 391  * 1) First, blit from B10G10R10A2 to R10G10B10A2, which is canonical, so it
 392  *    can be reinterpreted as a different canonical format of the same bpp,
 393  *    such as R16G16. This blit only swaps R and B 10-bit components.
 394  * 2) Finally, blit the result, which is R10G10B10A2, as R16G16 to G16R16.
 395  *    This blit only swaps R and G 16-bit components.
 396  */
 397 static bool
 398 handle_complex_copy(struct pipe_context *pipe,
 399                     struct pipe_resource *dst,
 400                     unsigned dst_level,
 401                     unsigned dstx, unsigned dsty, unsigned dstz,
 402                     struct pipe_resource *src,
 403                     unsigned src_level,
 404                     const struct pipe_box *src_box,
 405                     enum pipe_format noncanon_format,
 406                     enum pipe_format canon_format)
 407 {
 408    struct pipe_box temp_box;
 409    struct pipe_resource *temp = NULL;
 410    const struct util_format_description *src_desc, *dst_desc;
 411    const struct util_format_description *canon_desc, *noncanon_desc;
 412    bool src_is_canon;
 413    bool src_is_noncanon;
 414    bool dst_is_canon;
 415    bool dst_is_noncanon;
 416
 417    src_desc = util_format_description(src->format);
 418    dst_desc = util_format_description(dst->format);
 419    canon_desc = util_format_description(canon_format);
 420    noncanon_desc = util_format_description(noncanon_format);
 421
 422    src_is_canon = same_size_and_swizzle(src_desc, canon_desc);
 423    dst_is_canon = same_size_and_swizzle(dst_desc, canon_desc);
 424    src_is_noncanon = same_size_and_swizzle(src_desc, noncanon_desc);
 425    dst_is_noncanon = same_size_and_swizzle(dst_desc, noncanon_desc);
 426
 427    if (src_is_noncanon) {
 428       /* Simple case - only types differ (e.g. UNORM and UINT). */
 429       if (dst_is_noncanon) {
 430          blit(pipe, dst, noncanon_format, dst_level, dstx, dsty, dstz, src,
 431               noncanon_format, src_level, src_box);
 432          return true;
 433       }
 434
 435       /* Simple case - only types and swizzles differ. */
 436       if (dst_is_canon) {
 437          blit(pipe, dst, canon_format, dst_level, dstx, dsty, dstz, src,
 438               noncanon_format, src_level, src_box);
 439          return true;
 440       }
 441
 442       /* Use the temporary texture. Src is converted to a canonical format,
 443        * then proceed the generic swizzled_copy.
 444        */
 445       temp = create_texture(pipe->screen, canon_format, src->nr_samples,
 446                             src_box->width,
 447                             src_box->height, src_box->depth);
 448
 449       u_box_3d(0, 0, 0, src_box->width, src_box->height, src_box->depth,
 450                &temp_box);
 451
 452       blit(pipe, temp, canon_format, 0, 0, 0, 0, src, noncanon_format,
 453            src_level, src_box);
 454       swizzled_copy(pipe, dst, dst_level, dstx, dsty, dstz, temp, 0,
 455                     &temp_box);
 456       pipe_resource_reference(&temp, NULL);
 457       return true;
 458    }
 459
 460    if (dst_is_noncanon) {
 461       /* Simple case - only types and swizzles differ. */
 462       if (src_is_canon) {
 463          blit(pipe, dst, noncanon_format, dst_level, dstx, dsty, dstz, src,
 464               canon_format, src_level, src_box);
 465          return true;
 466       }
 467
 468       /* Use the temporary texture. First, use the generic copy, but use
 469        * a canonical format in the destination. Then convert */
 470       temp = create_texture(pipe->screen, canon_format, dst->nr_samples,
 471                             src_box->width,
 472                             src_box->height, src_box->depth);
 473
 474       u_box_3d(0, 0, 0, src_box->width, src_box->height, src_box->depth,
 475                &temp_box);
 476
 477       swizzled_copy(pipe, temp, 0, 0, 0, 0, src, src_level, src_box);
 478       blit(pipe, dst, noncanon_format, dst_level, dstx, dsty, dstz, temp,
 479            canon_format, 0, &temp_box);
 480       pipe_resource_reference(&temp, NULL);
 481       return true;
 482    }
 483
 484    return false;
 485 }
 486
 487 static void
 488 copy_image(struct pipe_context *pipe,
 489            struct pipe_resource *dst,
 490            unsigned dst_level,
 491            unsigned dstx, unsigned dsty, unsigned dstz,
 492            struct pipe_resource *src,
 493            unsigned src_level,
 494            const struct pipe_box *src_box)
 495 {
 496    if (src->format == dst->format ||
 497        util_format_is_compressed(src->format) ||
 498        util_format_is_compressed(dst->format)) {
 499       pipe->resource_copy_region(pipe, dst, dst_level, dstx, dsty, dstz,
 500                                  src, src_level, src_box);
 501       return;
 502    }
 503
 504    /* Copying to/from B10G10R10*2 needs 2 blits with R10G10B10A2
 505     * as a temporary texture in between.
 506     */
 507    if (handle_complex_copy(pipe, dst, dst_level, dstx, dsty, dstz, src,
 508                            src_level, src_box, PIPE_FORMAT_B10G10R10A2_UINT,
 509                            PIPE_FORMAT_R10G10B10A2_UINT))
 510       return;
 511
 512    /* Copying to/from G8R8 needs 2 blits with R8G8 as a temporary texture
 513     * in between.
 514     */
 515    if (handle_complex_copy(pipe, dst, dst_level, dstx, dsty, dstz, src,
 516                            src_level, src_box, PIPE_FORMAT_G8R8_UNORM,
 517                            PIPE_FORMAT_R8G8_UNORM))
 518       return;
 519
 520    /* Copying to/from G16R16 needs 2 blits with R16G16 as a temporary texture
 521     * in between.
 522     */
 523    if (handle_complex_copy(pipe, dst, dst_level, dstx, dsty, dstz, src,
 524                            src_level, src_box, PIPE_FORMAT_G16R16_UNORM,
 525                            PIPE_FORMAT_R16G16_UNORM))
 526       return;
 527
 528    /* Only allow non-identity swizzling on RGBA8 formats. */
 529
 530    /* Simple copy, memcpy with swizzling, no format conversion. */
 531    swizzled_copy(pipe, dst, dst_level, dstx, dsty, dstz, src, src_level,
 532                  src_box);
 533 }
 534
 535 /* Note, the only allowable compressed format for this function is ETC */
 536 static void
 537 fallback_copy_image(struct st_context *st,
 538                     struct gl_texture_image *dst_image,
 539                     struct pipe_resource *dst_res,
 540                     int dst_x, int dst_y, int dst_z,
 541                     struct gl_texture_image *src_image,
 542                     struct pipe_resource *src_res,
 543                     int src_x, int src_y, int src_z,
 544                     int src_w, int src_h)
 545 {
 546    uint8_t *dst, *src;
 547    int dst_stride, src_stride;
 548    struct pipe_transfer *dst_transfer, *src_transfer;
 549    unsigned line_bytes;
 550
 551    bool dst_is_compressed = dst_image && _mesa_is_format_compressed(dst_image->TexFormat);
 552    bool src_is_compressed = src_image && _mesa_is_format_compressed(src_image->TexFormat);
 553
 554    unsigned dst_w = src_w;
 555    unsigned dst_h = src_h;
 556    unsigned lines = src_h;
 557
 558    if (src_is_compressed && !dst_is_compressed) {
 559       dst_w = DIV_ROUND_UP(dst_w, 4);
 560       dst_h = DIV_ROUND_UP(dst_h, 4);
 561    } else if (!src_is_compressed && dst_is_compressed) {
 562       dst_w *= 4;
 563       dst_h *= 4;
 564    }
 565    if (src_is_compressed) {
 566       lines = DIV_ROUND_UP(lines, 4);
 567    }
 568
 569    if (src_image)
 570       line_bytes = _mesa_format_row_stride(src_image->TexFormat, src_w);
 571    else
 572       line_bytes = _mesa_format_row_stride(dst_image->TexFormat, dst_w);
 573
 574    if (dst_image) {
 575       st->ctx->Driver.MapTextureImage(
 576             st->ctx, dst_image, dst_z,
 577             dst_x, dst_y, dst_w, dst_h,
 578             GL_MAP_WRITE_BIT, &dst, &dst_stride);
 579    } else {
 580       dst = pipe_transfer_map(st->pipe, dst_res, 0, dst_z,
 581                               PIPE_TRANSFER_WRITE,
 582                               dst_x, dst_y, dst_w, dst_h,
 583                               &dst_transfer);
 584       dst_stride = dst_transfer->stride;
 585    }
 586
 587    if (src_image) {
 588       st->ctx->Driver.MapTextureImage(
 589             st->ctx, src_image, src_z,
 590             src_x, src_y, src_w, src_h,
 591             GL_MAP_READ_BIT, &src, &src_stride);
 592    } else {
 593       src = pipe_transfer_map(st->pipe, src_res, 0, src_z,
 594                               PIPE_TRANSFER_READ,
 595                               src_x, src_y, src_w, src_h,
 596                               &src_transfer);
 597       src_stride = src_transfer->stride;
 598    }
 599
 600    for (int y = 0; y < lines; y++) {
 601       memcpy(dst, src, line_bytes);
 602       dst += dst_stride;
 603       src += src_stride;
 604    }
 605
 606    if (dst_image) {
 607       st->ctx->Driver.UnmapTextureImage(st->ctx, dst_image, dst_z);
 608    } else {
 609       pipe_transfer_unmap(st->pipe, dst_transfer);
 610    }
 611
 612    if (src_image) {
 613       st->ctx->Driver.UnmapTextureImage(st->ctx, src_image, src_z);
 614    } else {
 615       pipe_transfer_unmap(st->pipe, src_transfer);
 616    }
 617 }
 618
 619 static void
 620 st_CopyImageSubData(struct gl_context *ctx,
 621                     struct gl_texture_image *src_image,
 622                     struct gl_renderbuffer *src_renderbuffer,
 623                     int src_x, int src_y, int src_z,
 624                     struct gl_texture_image *dst_image,
 625                     struct gl_renderbuffer *dst_renderbuffer,
 626                     int dst_x, int dst_y, int dst_z,
 627                     int src_width, int src_height)
 628 {
 629    struct st_context *st = st_context(ctx);
 630    struct pipe_context *pipe = st->pipe;
 631    struct pipe_resource *src_res, *dst_res;
 632    struct pipe_box box;
 633    int src_level, dst_level;
 634    int orig_src_z = src_z, orig_dst_z = dst_z;
 635
 636    st_flush_bitmap_cache(st);
 637    st_invalidate_readpix_cache(st);
 638
 639    if (src_image) {
 640       struct st_texture_image *src = st_texture_image(src_image);
 641       src_res = src->pt;
 642       src_level = src_image->Level;
 643       src_z += src_image->Face;
 644       if (src_image->TexObject->Immutable) {
 645          src_level += src_image->TexObject->MinLevel;
 646          src_z += src_image->TexObject->MinLayer;
 647       }
 648    } else {
 649       struct st_renderbuffer *src = st_renderbuffer(src_renderbuffer);
 650       src_res = src->texture;
 651       src_level = 0;
 652    }
 653
 654    if (dst_image) {
 655       struct st_texture_image *dst = st_texture_image(dst_image);
 656       dst_res = dst->pt;
 657       dst_level = dst_image->Level;
 658       dst_z += dst_image->Face;
 659       if (dst_image->TexObject->Immutable) {
 660          dst_level += dst_image->TexObject->MinLevel;
 661          dst_z += dst_image->TexObject->MinLayer;
 662       }
 663    } else {
 664       struct st_renderbuffer *dst = st_renderbuffer(dst_renderbuffer);
 665       dst_res = dst->texture;
 666       dst_level = 0;
 667    }
 668
 669    u_box_2d_zslice(src_x, src_y, src_z, src_width, src_height, &box);
 670
 671    if ((src_image && st_compressed_format_fallback(st, src_image->TexFormat)) ||
 672        (dst_image && st_compressed_format_fallback(st, dst_image->TexFormat))) {
 673       fallback_copy_image(st, dst_image, dst_res, dst_x, dst_y, orig_dst_z,
 674                           src_image, src_res, src_x, src_y, orig_src_z,
 675                           src_width, src_height);
 676    } else {
 677       copy_image(pipe, dst_res, dst_level, dst_x, dst_y, dst_z,
 678                  src_res, src_level, &box);
 679    }
 680 }
 681
 682 void
 683 st_init_copy_image_functions(struct dd_function_table *functions)
 684 {
 685    functions->CopyImageSubData = st_CopyImageSubData;
 686 }