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 <stdio.h> 29 #include "main/bufferobj.h" 30 #include "main/enums.h" 31 #include "main/fbobject.h" 32 #include "main/formats.h" 33 #include "main/format_utils.h" 34 #include "main/glformats.h" 35 #include "main/image.h" 36 #include "main/imports.h" 37 #include "main/macros.h" 38 #include "main/mipmap.h" 39 #include "main/pack.h" 40 #include "main/pbo.h" 41 #include "main/pixeltransfer.h" 42 #include "main/texcompress.h" 43 #include "main/texcompress_etc.h" 44 #include "main/texgetimage.h" 45 #include "main/teximage.h" 46 #include "main/texobj.h" 47 #include "main/texstore.h" 48 49 #include "state_tracker/st_debug.h" 50 #include "state_tracker/st_context.h" 51 #include "state_tracker/st_cb_bitmap.h" 52 #include "state_tracker/st_cb_fbo.h" 53 #include "state_tracker/st_cb_flush.h" 54 #include "state_tracker/st_cb_texture.h" 55 #include "state_tracker/st_cb_bufferobjects.h" 56 #include "state_tracker/st_format.h" 57 #include "state_tracker/st_pbo.h" 58 #include "state_tracker/st_texture.h" 59 #include "state_tracker/st_gen_mipmap.h" 60 #include "state_tracker/st_atom.h" 61 #include "state_tracker/st_sampler_view.h" 62 63 #include "pipe/p_context.h" 64 #include "pipe/p_defines.h" 65 #include "util/u_inlines.h" 66 #include "util/u_upload_mgr.h" 67 #include "pipe/p_shader_tokens.h" 68 #include "util/u_tile.h" 69 #include "util/u_format.h" 70 #include "util/u_surface.h" 71 #include "util/u_sampler.h" 72 #include "util/u_math.h" 73 #include "util/u_box.h" 74 #include "util/u_simple_shaders.h" 75 #include "cso_cache/cso_context.h" 76 #include "tgsi/tgsi_ureg.h" 77 78 #define DBG if (0) printf 79 80 81 enum pipe_texture_target 82 gl_target_to_pipe(GLenum target) 83 { 84 switch (target) { 85 case GL_TEXTURE_1D: 86 case GL_PROXY_TEXTURE_1D: 87 return PIPE_TEXTURE_1D; 88 case GL_TEXTURE_2D: 89 case GL_PROXY_TEXTURE_2D: 90 case GL_TEXTURE_EXTERNAL_OES: 91 case GL_TEXTURE_2D_MULTISAMPLE: 92 case GL_PROXY_TEXTURE_2D_MULTISAMPLE: 93 return PIPE_TEXTURE_2D; 94 case GL_TEXTURE_RECTANGLE_NV: 95 case GL_PROXY_TEXTURE_RECTANGLE_NV: 96 return PIPE_TEXTURE_RECT; 97 case GL_TEXTURE_3D: 98 case GL_PROXY_TEXTURE_3D: 99 return PIPE_TEXTURE_3D; 100 case GL_TEXTURE_CUBE_MAP_ARB: 101 case GL_PROXY_TEXTURE_CUBE_MAP_ARB: 102 case GL_TEXTURE_CUBE_MAP_POSITIVE_X: 103 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: 104 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: 105 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: 106 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: 107 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: 108 return PIPE_TEXTURE_CUBE; 109 case GL_TEXTURE_1D_ARRAY_EXT: 110 case GL_PROXY_TEXTURE_1D_ARRAY_EXT: 111 return PIPE_TEXTURE_1D_ARRAY; 112 case GL_TEXTURE_2D_ARRAY_EXT: 113 case GL_PROXY_TEXTURE_2D_ARRAY_EXT: 114 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: 115 case GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY: 116 return PIPE_TEXTURE_2D_ARRAY; 117 case GL_TEXTURE_BUFFER: 118 return PIPE_BUFFER; 119 case GL_TEXTURE_CUBE_MAP_ARRAY: 120 case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY: 121 return PIPE_TEXTURE_CUBE_ARRAY; 122 default: 123 assert(0); 124 return 0; 125 } 126 } 127 128 129 /** called via ctx->Driver.NewTextureImage() */ 130 static struct gl_texture_image * 131 st_NewTextureImage(struct gl_context * ctx) 132 { 133 DBG("%s\n", __func__); 134 (void) ctx; 135 return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image); 136 } 137 138 139 /** called via ctx->Driver.DeleteTextureImage() */ 140 static void 141 st_DeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img) 142 { 143 /* nothing special (yet) for st_texture_image */ 144 _mesa_delete_texture_image(ctx, img); 145 } 146 147 148 /** called via ctx->Driver.NewTextureObject() */ 149 static struct gl_texture_object * 150 st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) 151 { 152 struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object); 153 154 DBG("%s\n", __func__); 155 _mesa_initialize_texture_object(ctx, &obj->base, name, target); 156 157 return &obj->base; 158 } 159 160 /** called via ctx->Driver.DeleteTextureObject() */ 161 static void 162 st_DeleteTextureObject(struct gl_context *ctx, 163 struct gl_texture_object *texObj) 164 { 165 struct st_context *st = st_context(ctx); 166 struct st_texture_object *stObj = st_texture_object(texObj); 167 168 pipe_resource_reference(&stObj->pt, NULL); 169 st_texture_release_all_sampler_views(st, stObj); 170 st_texture_free_sampler_views(stObj); 171 _mesa_delete_texture_object(ctx, texObj); 172 } 173 174 175 /** called via ctx->Driver.FreeTextureImageBuffer() */ 176 static void 177 st_FreeTextureImageBuffer(struct gl_context *ctx, 178 struct gl_texture_image *texImage) 179 { 180 struct st_context *st = st_context(ctx); 181 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 182 struct st_texture_image *stImage = st_texture_image(texImage); 183 184 DBG("%s\n", __func__); 185 186 if (stImage->pt) { 187 pipe_resource_reference(&stImage->pt, NULL); 188 } 189 190 free(stImage->transfer); 191 stImage->transfer = NULL; 192 stImage->num_transfers = 0; 193 194 if (stImage->etc_data) { 195 free(stImage->etc_data); 196 stImage->etc_data = NULL; 197 } 198 199 /* if the texture image is being deallocated, the structure of the 200 * texture is changing so we'll likely need a new sampler view. 201 */ 202 st_texture_release_all_sampler_views(st, stObj); 203 } 204 205 bool 206 st_etc_fallback(struct st_context *st, struct gl_texture_image *texImage) 207 { 208 return (_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) || 209 (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1); 210 } 211 212 static void 213 etc_fallback_allocate(struct st_context *st, struct st_texture_image *stImage) 214 { 215 struct gl_texture_image *texImage = &stImage->base; 216 217 if (!st_etc_fallback(st, texImage)) 218 return; 219 220 if (stImage->etc_data) 221 free(stImage->etc_data); 222 223 unsigned data_size = _mesa_format_image_size(texImage->TexFormat, 224 texImage->Width2, 225 texImage->Height2, 226 texImage->Depth2); 227 228 stImage->etc_data = 229 malloc(data_size * _mesa_num_tex_faces(texImage->TexObject->Target)); 230 } 231 232 /** called via ctx->Driver.MapTextureImage() */ 233 static void 234 st_MapTextureImage(struct gl_context *ctx, 235 struct gl_texture_image *texImage, 236 GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h, 237 GLbitfield mode, 238 GLubyte **mapOut, GLint *rowStrideOut) 239 { 240 struct st_context *st = st_context(ctx); 241 struct st_texture_image *stImage = st_texture_image(texImage); 242 unsigned pipeMode; 243 GLubyte *map; 244 struct pipe_transfer *transfer; 245 246 pipeMode = 0x0; 247 if (mode & GL_MAP_READ_BIT) 248 pipeMode |= PIPE_TRANSFER_READ; 249 if (mode & GL_MAP_WRITE_BIT) 250 pipeMode |= PIPE_TRANSFER_WRITE; 251 if (mode & GL_MAP_INVALIDATE_RANGE_BIT) 252 pipeMode |= PIPE_TRANSFER_DISCARD_RANGE; 253 254 map = st_texture_image_map(st, stImage, pipeMode, x, y, slice, w, h, 1, 255 &transfer); 256 if (map) { 257 if (st_etc_fallback(st, texImage)) { 258 /* ETC isn't supported by all gallium drivers, where it's represented 259 * by uncompressed formats. We store the compressed data (as it's 260 * needed for image copies in OES_copy_image), and decompress as 261 * necessary in Unmap. 262 * 263 * Note: all ETC1/ETC2 formats have 4x4 block sizes. 264 */ 265 unsigned z = transfer->box.z; 266 struct st_texture_image_transfer *itransfer = &stImage->transfer[z]; 267 268 unsigned bytes = _mesa_get_format_bytes(texImage->TexFormat); 269 unsigned stride = *rowStrideOut = itransfer->temp_stride = 270 _mesa_format_row_stride(texImage->TexFormat, texImage->Width2); 271 *mapOut = itransfer->temp_data = 272 stImage->etc_data + ((x / 4) * bytes + (y / 4) * stride) + 273 z * stride * texImage->Height2 / 4; 274 itransfer->map = map; 275 } 276 else { 277 /* supported mapping */ 278 *mapOut = map; 279 *rowStrideOut = transfer->stride; 280 } 281 } 282 else { 283 *mapOut = NULL; 284 *rowStrideOut = 0; 285 } 286 } 287 288 289 /** called via ctx->Driver.UnmapTextureImage() */ 290 static void 291 st_UnmapTextureImage(struct gl_context *ctx, 292 struct gl_texture_image *texImage, 293 GLuint slice) 294 { 295 struct st_context *st = st_context(ctx); 296 struct st_texture_image *stImage = st_texture_image(texImage); 297 298 if (st_etc_fallback(st, texImage)) { 299 /* Decompress the ETC texture to the mapped one. */ 300 unsigned z = slice + stImage->base.Face; 301 struct st_texture_image_transfer *itransfer = &stImage->transfer[z]; 302 struct pipe_transfer *transfer = itransfer->transfer; 303 304 assert(z == transfer->box.z); 305 306 if (transfer->usage & PIPE_TRANSFER_WRITE) { 307 if (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8) { 308 _mesa_etc1_unpack_rgba8888(itransfer->map, transfer->stride, 309 itransfer->temp_data, 310 itransfer->temp_stride, 311 transfer->box.width, transfer->box.height); 312 } 313 else { 314 _mesa_unpack_etc2_format(itransfer->map, transfer->stride, 315 itransfer->temp_data, itransfer->temp_stride, 316 transfer->box.width, transfer->box.height, 317 texImage->TexFormat); 318 } 319 } 320 321 itransfer->temp_data = NULL; 322 itransfer->temp_stride = 0; 323 itransfer->map = 0; 324 } 325 326 st_texture_image_unmap(st, stImage, slice); 327 } 328 329 330 /** 331 * Return default texture resource binding bitmask for the given format. 332 */ 333 static GLuint 334 default_bindings(struct st_context *st, enum pipe_format format) 335 { 336 struct pipe_screen *screen = st->pipe->screen; 337 const unsigned target = PIPE_TEXTURE_2D; 338 unsigned bindings; 339 340 if (util_format_is_depth_or_stencil(format)) 341 bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DEPTH_STENCIL; 342 else 343 bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET; 344 345 if (screen->is_format_supported(screen, format, target, 0, bindings)) 346 return bindings; 347 else { 348 /* Try non-sRGB. */ 349 format = util_format_linear(format); 350 351 if (screen->is_format_supported(screen, format, target, 0, bindings)) 352 return bindings; 353 else 354 return PIPE_BIND_SAMPLER_VIEW; 355 } 356 } 357 358 359 /** 360 * Given the size of a mipmap image, try to compute the size of the level=0 361 * mipmap image. 362 * 363 * Note that this isn't always accurate for odd-sized, non-POW textures. 364 * For example, if level=1 and width=40 then the level=0 width may be 80 or 81. 365 * 366 * \return GL_TRUE for success, GL_FALSE for failure 367 */ 368 static GLboolean 369 guess_base_level_size(GLenum target, 370 GLuint width, GLuint height, GLuint depth, GLuint level, 371 GLuint *width0, GLuint *height0, GLuint *depth0) 372 { 373 assert(width >= 1); 374 assert(height >= 1); 375 assert(depth >= 1); 376 377 if (level > 0) { 378 /* Guess the size of the base level. 379 * Depending on the image's size, we can't always make a guess here. 380 */ 381 switch (target) { 382 case GL_TEXTURE_1D: 383 case GL_TEXTURE_1D_ARRAY: 384 width <<= level; 385 break; 386 387 case GL_TEXTURE_2D: 388 case GL_TEXTURE_2D_ARRAY: 389 /* We can't make a good guess here, because the base level dimensions 390 * can be non-square. 391 */ 392 if (width == 1 || height == 1) { 393 return GL_FALSE; 394 } 395 width <<= level; 396 height <<= level; 397 break; 398 399 case GL_TEXTURE_CUBE_MAP: 400 case GL_TEXTURE_CUBE_MAP_ARRAY: 401 width <<= level; 402 height <<= level; 403 break; 404 405 case GL_TEXTURE_3D: 406 /* We can't make a good guess here, because the base level dimensions 407 * can be non-cube. 408 */ 409 if (width == 1 || height == 1 || depth == 1) { 410 return GL_FALSE; 411 } 412 width <<= level; 413 height <<= level; 414 depth <<= level; 415 break; 416 417 case GL_TEXTURE_RECTANGLE: 418 break; 419 420 default: 421 assert(0); 422 } 423 } 424 425 *width0 = width; 426 *height0 = height; 427 *depth0 = depth; 428 429 return GL_TRUE; 430 } 431 432 433 /** 434 * Try to determine whether we should allocate memory for a full texture 435 * mipmap. The problem is when we get a glTexImage(level=0) call, we 436 * can't immediately know if other mipmap levels are coming next. Here 437 * we try to guess whether to allocate memory for a mipmap or just the 438 * 0th level. 439 * 440 * If we guess incorrectly here we'll later reallocate the right amount of 441 * memory either in st_AllocTextureImageBuffer() or st_finalize_texture(). 442 * 443 * \param stObj the texture object we're going to allocate memory for. 444 * \param stImage describes the incoming image which we need to store. 445 */ 446 static boolean 447 allocate_full_mipmap(const struct st_texture_object *stObj, 448 const struct st_texture_image *stImage) 449 { 450 switch (stObj->base.Target) { 451 case GL_TEXTURE_RECTANGLE_NV: 452 case GL_TEXTURE_BUFFER: 453 case GL_TEXTURE_EXTERNAL_OES: 454 case GL_TEXTURE_2D_MULTISAMPLE: 455 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: 456 /* these texture types cannot be mipmapped */ 457 return FALSE; 458 } 459 460 if (stImage->base.Level > 0 || stObj->base.GenerateMipmap) 461 return TRUE; 462 463 if (stImage->base._BaseFormat == GL_DEPTH_COMPONENT || 464 stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) 465 /* depth/stencil textures are seldom mipmapped */ 466 return FALSE; 467 468 if (stObj->base.BaseLevel == 0 && stObj->base.MaxLevel == 0) 469 return FALSE; 470 471 if (stObj->base.Sampler.MinFilter == GL_NEAREST || 472 stObj->base.Sampler.MinFilter == GL_LINEAR) 473 /* not a mipmap minification filter */ 474 return FALSE; 475 476 if (stObj->base.Target == GL_TEXTURE_3D) 477 /* 3D textures are seldom mipmapped */ 478 return FALSE; 479 480 return TRUE; 481 } 482 483 484 /** 485 * Try to allocate a pipe_resource object for the given st_texture_object. 486 * 487 * We use the given st_texture_image as a clue to determine the size of the 488 * mipmap image at level=0. 489 * 490 * \return GL_TRUE for success, GL_FALSE if out of memory. 491 */ 492 static GLboolean 493 guess_and_alloc_texture(struct st_context *st, 494 struct st_texture_object *stObj, 495 const struct st_texture_image *stImage) 496 { 497 const struct gl_texture_image *firstImage; 498 GLuint lastLevel, width, height, depth; 499 GLuint bindings; 500 GLuint ptWidth, ptHeight, ptDepth, ptLayers; 501 enum pipe_format fmt; 502 bool guessed_box = false; 503 504 DBG("%s\n", __func__); 505 506 assert(!stObj->pt); 507 508 /* If a base level image with compatible size exists, use that as our guess. 509 */ 510 firstImage = _mesa_base_tex_image(&stObj->base); 511 if (firstImage && 512 firstImage->Width2 > 0 && 513 firstImage->Height2 > 0 && 514 firstImage->Depth2 > 0 && 515 guess_base_level_size(stObj->base.Target, 516 firstImage->Width2, 517 firstImage->Height2, 518 firstImage->Depth2, 519 firstImage->Level, 520 &width, &height, &depth)) { 521 if (stImage->base.Width2 == u_minify(width, stImage->base.Level) && 522 stImage->base.Height2 == u_minify(height, stImage->base.Level) && 523 stImage->base.Depth2 == u_minify(depth, stImage->base.Level)) 524 guessed_box = true; 525 } 526 527 if (!guessed_box) 528 guessed_box = guess_base_level_size(stObj->base.Target, 529 stImage->base.Width2, 530 stImage->base.Height2, 531 stImage->base.Depth2, 532 stImage->base.Level, 533 &width, &height, &depth); 534 535 if (!guessed_box) { 536 /* we can't determine the image size at level=0 */ 537 /* this is not an out of memory error */ 538 return GL_TRUE; 539 } 540 541 /* At this point, (width x height x depth) is the expected size of 542 * the level=0 mipmap image. 543 */ 544 545 /* Guess a reasonable value for lastLevel. With OpenGL we have no 546 * idea how many mipmap levels will be in a texture until we start 547 * to render with it. Make an educated guess here but be prepared 548 * to re-allocating a texture buffer with space for more (or fewer) 549 * mipmap levels later. 550 */ 551 if (allocate_full_mipmap(stObj, stImage)) { 552 /* alloc space for a full mipmap */ 553 lastLevel = _mesa_get_tex_max_num_levels(stObj->base.Target, 554 width, height, depth) - 1; 555 } 556 else { 557 /* only alloc space for a single mipmap level */ 558 lastLevel = 0; 559 } 560 561 fmt = st_mesa_format_to_pipe_format(st, stImage->base.TexFormat); 562 563 bindings = default_bindings(st, fmt); 564 565 st_gl_texture_dims_to_pipe_dims(stObj->base.Target, 566 width, height, depth, 567 &ptWidth, &ptHeight, &ptDepth, &ptLayers); 568 569 stObj->pt = st_texture_create(st, 570 gl_target_to_pipe(stObj->base.Target), 571 fmt, 572 lastLevel, 573 ptWidth, 574 ptHeight, 575 ptDepth, 576 ptLayers, 0, 577 bindings); 578 579 stObj->lastLevel = lastLevel; 580 581 DBG("%s returning %d\n", __func__, (stObj->pt != NULL)); 582 583 return stObj->pt != NULL; 584 } 585 586 587 /** 588 * Called via ctx->Driver.AllocTextureImageBuffer(). 589 * If the texture object/buffer already has space for the indicated image, 590 * we're done. Otherwise, allocate memory for the new texture image. 591 */ 592 static GLboolean 593 st_AllocTextureImageBuffer(struct gl_context *ctx, 594 struct gl_texture_image *texImage) 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 const GLuint level = texImage->Level; 600 GLuint width = texImage->Width; 601 GLuint height = texImage->Height; 602 GLuint depth = texImage->Depth; 603 604 DBG("%s\n", __func__); 605 606 assert(!stImage->pt); /* xxx this might be wrong */ 607 608 etc_fallback_allocate(st, stImage); 609 610 /* Look if the parent texture object has space for this image */ 611 if (stObj->pt && 612 level <= stObj->pt->last_level && 613 st_texture_match_image(st, stObj->pt, texImage)) { 614 /* this image will fit in the existing texture object's memory */ 615 pipe_resource_reference(&stImage->pt, stObj->pt); 616 return GL_TRUE; 617 } 618 619 /* The parent texture object does not have space for this image */ 620 621 pipe_resource_reference(&stObj->pt, NULL); 622 st_texture_release_all_sampler_views(st, stObj); 623 624 if (!guess_and_alloc_texture(st, stObj, stImage)) { 625 /* Probably out of memory. 626 * Try flushing any pending rendering, then retry. 627 */ 628 st_finish(st); 629 if (!guess_and_alloc_texture(st, stObj, stImage)) { 630 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); 631 return GL_FALSE; 632 } 633 } 634 635 if (stObj->pt && 636 st_texture_match_image(st, stObj->pt, texImage)) { 637 /* The image will live in the object's mipmap memory */ 638 pipe_resource_reference(&stImage->pt, stObj->pt); 639 assert(stImage->pt); 640 return GL_TRUE; 641 } 642 else { 643 /* Create a new, temporary texture/resource/buffer to hold this 644 * one texture image. Note that when we later access this image 645 * (either for mapping or copying) we'll want to always specify 646 * mipmap level=0, even if the image represents some other mipmap 647 * level. 648 */ 649 enum pipe_format format = 650 st_mesa_format_to_pipe_format(st, texImage->TexFormat); 651 GLuint bindings = default_bindings(st, format); 652 GLuint ptWidth, ptHeight, ptDepth, ptLayers; 653 654 st_gl_texture_dims_to_pipe_dims(stObj->base.Target, 655 width, height, depth, 656 &ptWidth, &ptHeight, &ptDepth, &ptLayers); 657 658 stImage->pt = st_texture_create(st, 659 gl_target_to_pipe(stObj->base.Target), 660 format, 661 0, /* lastLevel */ 662 ptWidth, 663 ptHeight, 664 ptDepth, 665 ptLayers, 0, 666 bindings); 667 return stImage->pt != NULL; 668 } 669 } 670 671 672 /** 673 * Preparation prior to glTexImage. Basically check the 'surface_based' 674 * field and switch to a "normal" tex image if necessary. 675 */ 676 static void 677 prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage, 678 GLenum format, GLenum type) 679 { 680 struct gl_texture_object *texObj = texImage->TexObject; 681 struct st_texture_object *stObj = st_texture_object(texObj); 682 683 /* switch to "normal" */ 684 if (stObj->surface_based) { 685 const GLenum target = texObj->Target; 686 const GLuint level = texImage->Level; 687 mesa_format texFormat; 688 689 _mesa_clear_texture_object(ctx, texObj); 690 pipe_resource_reference(&stObj->pt, NULL); 691 692 /* oops, need to init this image again */ 693 texFormat = _mesa_choose_texture_format(ctx, texObj, target, level, 694 texImage->InternalFormat, format, 695 type); 696 697 _mesa_init_teximage_fields(ctx, texImage, 698 texImage->Width, texImage->Height, 699 texImage->Depth, texImage->Border, 700 texImage->InternalFormat, texFormat); 701 702 stObj->surface_based = GL_FALSE; 703 } 704 } 705 706 707 /** 708 * Return a writemask for the gallium blit. The parameters can be base 709 * formats or "format" from glDrawPixels/glTexImage/glGetTexImage. 710 */ 711 unsigned 712 st_get_blit_mask(GLenum srcFormat, GLenum dstFormat) 713 { 714 switch (dstFormat) { 715 case GL_DEPTH_STENCIL: 716 switch (srcFormat) { 717 case GL_DEPTH_STENCIL: 718 return PIPE_MASK_ZS; 719 case GL_DEPTH_COMPONENT: 720 return PIPE_MASK_Z; 721 case GL_STENCIL_INDEX: 722 return PIPE_MASK_S; 723 default: 724 assert(0); 725 return 0; 726 } 727 728 case GL_DEPTH_COMPONENT: 729 switch (srcFormat) { 730 case GL_DEPTH_STENCIL: 731 case GL_DEPTH_COMPONENT: 732 return PIPE_MASK_Z; 733 default: 734 assert(0); 735 return 0; 736 } 737 738 case GL_STENCIL_INDEX: 739 switch (srcFormat) { 740 case GL_STENCIL_INDEX: 741 return PIPE_MASK_S; 742 default: 743 assert(0); 744 return 0; 745 } 746 747 default: 748 return PIPE_MASK_RGBA; 749 } 750 } 751 752 /** 753 * Converts format to a format with the same components, types 754 * and sizes, but with the components in RGBA order. 755 */ 756 static enum pipe_format 757 unswizzle_format(enum pipe_format format) 758 { 759 switch (format) 760 { 761 case PIPE_FORMAT_B8G8R8A8_UNORM: 762 case PIPE_FORMAT_A8R8G8B8_UNORM: 763 case PIPE_FORMAT_A8B8G8R8_UNORM: 764 return PIPE_FORMAT_R8G8B8A8_UNORM; 765 766 case PIPE_FORMAT_B10G10R10A2_UNORM: 767 return PIPE_FORMAT_R10G10B10A2_UNORM; 768 769 case PIPE_FORMAT_B10G10R10A2_SNORM: 770 return PIPE_FORMAT_R10G10B10A2_SNORM; 771 772 case PIPE_FORMAT_B10G10R10A2_UINT: 773 return PIPE_FORMAT_R10G10B10A2_UINT; 774 775 default: 776 return format; 777 } 778 } 779 780 /** 781 * Converts PIPE_FORMAT_A* to PIPE_FORMAT_R*. 782 */ 783 static enum pipe_format 784 alpha_to_red(enum pipe_format format) 785 { 786 switch (format) 787 { 788 case PIPE_FORMAT_A8_UNORM: 789 return PIPE_FORMAT_R8_UNORM; 790 case PIPE_FORMAT_A8_SNORM: 791 return PIPE_FORMAT_R8_SNORM; 792 case PIPE_FORMAT_A8_UINT: 793 return PIPE_FORMAT_R8_UINT; 794 case PIPE_FORMAT_A8_SINT: 795 return PIPE_FORMAT_R8_SINT; 796 797 case PIPE_FORMAT_A16_UNORM: 798 return PIPE_FORMAT_R16_UNORM; 799 case PIPE_FORMAT_A16_SNORM: 800 return PIPE_FORMAT_R16_SNORM; 801 case PIPE_FORMAT_A16_UINT: 802 return PIPE_FORMAT_R16_UINT; 803 case PIPE_FORMAT_A16_SINT: 804 return PIPE_FORMAT_R16_SINT; 805 case PIPE_FORMAT_A16_FLOAT: 806 return PIPE_FORMAT_R16_FLOAT; 807 808 case PIPE_FORMAT_A32_UINT: 809 return PIPE_FORMAT_R32_UINT; 810 case PIPE_FORMAT_A32_SINT: 811 return PIPE_FORMAT_R32_SINT; 812 case PIPE_FORMAT_A32_FLOAT: 813 return PIPE_FORMAT_R32_FLOAT; 814 815 default: 816 return format; 817 } 818 } 819 820 /** 821 * Converts PIPE_FORMAT_R*A* to PIPE_FORMAT_R*G*. 822 */ 823 static enum pipe_format 824 red_alpha_to_red_green(enum pipe_format format) 825 { 826 switch (format) 827 { 828 case PIPE_FORMAT_R8A8_UNORM: 829 return PIPE_FORMAT_R8G8_UNORM; 830 case PIPE_FORMAT_R8A8_SNORM: 831 return PIPE_FORMAT_R8G8_SNORM; 832 case PIPE_FORMAT_R8A8_UINT: 833 return PIPE_FORMAT_R8G8_UINT; 834 case PIPE_FORMAT_R8A8_SINT: 835 return PIPE_FORMAT_R8G8_SINT; 836 837 case PIPE_FORMAT_R16A16_UNORM: 838 return PIPE_FORMAT_R16G16_UNORM; 839 case PIPE_FORMAT_R16A16_SNORM: 840 return PIPE_FORMAT_R16G16_SNORM; 841 case PIPE_FORMAT_R16A16_UINT: 842 return PIPE_FORMAT_R16G16_UINT; 843 case PIPE_FORMAT_R16A16_SINT: 844 return PIPE_FORMAT_R16G16_SINT; 845 case PIPE_FORMAT_R16A16_FLOAT: 846 return PIPE_FORMAT_R16G16_FLOAT; 847 848 case PIPE_FORMAT_R32A32_UINT: 849 return PIPE_FORMAT_R32G32_UINT; 850 case PIPE_FORMAT_R32A32_SINT: 851 return PIPE_FORMAT_R32G32_SINT; 852 case PIPE_FORMAT_R32A32_FLOAT: 853 return PIPE_FORMAT_R32G32_FLOAT; 854 855 default: 856 return format; 857 } 858 } 859 860 /** 861 * Converts PIPE_FORMAT_L*A* to PIPE_FORMAT_R*G*. 862 */ 863 static enum pipe_format 864 luminance_alpha_to_red_green(enum pipe_format format) 865 { 866 switch (format) 867 { 868 case PIPE_FORMAT_L8A8_UNORM: 869 return PIPE_FORMAT_R8G8_UNORM; 870 case PIPE_FORMAT_L8A8_SNORM: 871 return PIPE_FORMAT_R8G8_SNORM; 872 case PIPE_FORMAT_L8A8_UINT: 873 return PIPE_FORMAT_R8G8_UINT; 874 case PIPE_FORMAT_L8A8_SINT: 875 return PIPE_FORMAT_R8G8_SINT; 876 877 case PIPE_FORMAT_L16A16_UNORM: 878 return PIPE_FORMAT_R16G16_UNORM; 879 case PIPE_FORMAT_L16A16_SNORM: 880 return PIPE_FORMAT_R16G16_SNORM; 881 case PIPE_FORMAT_L16A16_UINT: 882 return PIPE_FORMAT_R16G16_UINT; 883 case PIPE_FORMAT_L16A16_SINT: 884 return PIPE_FORMAT_R16G16_SINT; 885 case PIPE_FORMAT_L16A16_FLOAT: 886 return PIPE_FORMAT_R16G16_FLOAT; 887 888 case PIPE_FORMAT_L32A32_UINT: 889 return PIPE_FORMAT_R32G32_UINT; 890 case PIPE_FORMAT_L32A32_SINT: 891 return PIPE_FORMAT_R32G32_SINT; 892 case PIPE_FORMAT_L32A32_FLOAT: 893 return PIPE_FORMAT_R32G32_FLOAT; 894 895 default: 896 return format; 897 } 898 } 899 900 /** 901 * Returns true if format is a PIPE_FORMAT_A* format, and false otherwise. 902 */ 903 static bool 904 format_is_alpha(enum pipe_format format) 905 { 906 const struct util_format_description *desc = util_format_description(format); 907 908 if (desc->nr_channels == 1 && 909 desc->swizzle[0] == PIPE_SWIZZLE_0 && 910 desc->swizzle[1] == PIPE_SWIZZLE_0 && 911 desc->swizzle[2] == PIPE_SWIZZLE_0 && 912 desc->swizzle[3] == PIPE_SWIZZLE_X) 913 return true; 914 915 return false; 916 } 917 918 /** 919 * Returns true if format is a PIPE_FORMAT_R* format, and false otherwise. 920 */ 921 static bool 922 format_is_red(enum pipe_format format) 923 { 924 const struct util_format_description *desc = util_format_description(format); 925 926 if (desc->nr_channels == 1 && 927 desc->swizzle[0] == PIPE_SWIZZLE_X && 928 desc->swizzle[1] == PIPE_SWIZZLE_0 && 929 desc->swizzle[2] == PIPE_SWIZZLE_0 && 930 desc->swizzle[3] == PIPE_SWIZZLE_1) 931 return true; 932 933 return false; 934 } 935 936 937 /** 938 * Returns true if format is a PIPE_FORMAT_L* format, and false otherwise. 939 */ 940 static bool 941 format_is_luminance(enum pipe_format format) 942 { 943 const struct util_format_description *desc = util_format_description(format); 944 945 if (desc->nr_channels == 1 && 946 desc->swizzle[0] == PIPE_SWIZZLE_X && 947 desc->swizzle[1] == PIPE_SWIZZLE_X && 948 desc->swizzle[2] == PIPE_SWIZZLE_X && 949 desc->swizzle[3] == PIPE_SWIZZLE_1) 950 return true; 951 952 return false; 953 } 954 955 /** 956 * Returns true if format is a PIPE_FORMAT_R*A* format, and false otherwise. 957 */ 958 static bool 959 format_is_red_alpha(enum pipe_format format) 960 { 961 const struct util_format_description *desc = util_format_description(format); 962 963 if (desc->nr_channels == 2 && 964 desc->swizzle[0] == PIPE_SWIZZLE_X && 965 desc->swizzle[1] == PIPE_SWIZZLE_0 && 966 desc->swizzle[2] == PIPE_SWIZZLE_0 && 967 desc->swizzle[3] == PIPE_SWIZZLE_Y) 968 return true; 969 970 return false; 971 } 972 973 static bool 974 format_is_swizzled_rgba(enum pipe_format format) 975 { 976 const struct util_format_description *desc = util_format_description(format); 977 978 if ((desc->swizzle[0] == TGSI_SWIZZLE_X || desc->swizzle[0] == PIPE_SWIZZLE_0) && 979 (desc->swizzle[1] == TGSI_SWIZZLE_Y || desc->swizzle[1] == PIPE_SWIZZLE_0) && 980 (desc->swizzle[2] == TGSI_SWIZZLE_Z || desc->swizzle[2] == PIPE_SWIZZLE_0) && 981 (desc->swizzle[3] == TGSI_SWIZZLE_W || desc->swizzle[3] == PIPE_SWIZZLE_1)) 982 return false; 983 984 return true; 985 } 986 987 struct format_table 988 { 989 unsigned char swizzle[4]; 990 enum pipe_format format; 991 }; 992 993 static const struct format_table table_8888_unorm[] = { 994 { { 0, 1, 2, 3 }, PIPE_FORMAT_R8G8B8A8_UNORM }, 995 { { 2, 1, 0, 3 }, PIPE_FORMAT_B8G8R8A8_UNORM }, 996 { { 3, 0, 1, 2 }, PIPE_FORMAT_A8R8G8B8_UNORM }, 997 { { 3, 2, 1, 0 }, PIPE_FORMAT_A8B8G8R8_UNORM } 998 }; 999 1000 static const struct format_table table_1010102_unorm[] = { 1001 { { 0, 1, 2, 3 }, PIPE_FORMAT_R10G10B10A2_UNORM }, 1002 { { 2, 1, 0, 3 }, PIPE_FORMAT_B10G10R10A2_UNORM } 1003 }; 1004 1005 static const struct format_table table_1010102_snorm[] = { 1006 { { 0, 1, 2, 3 }, PIPE_FORMAT_R10G10B10A2_SNORM }, 1007 { { 2, 1, 0, 3 }, PIPE_FORMAT_B10G10R10A2_SNORM } 1008 }; 1009 1010 static const struct format_table table_1010102_uint[] = { 1011 { { 0, 1, 2, 3 }, PIPE_FORMAT_R10G10B10A2_UINT }, 1012 { { 2, 1, 0, 3 }, PIPE_FORMAT_B10G10R10A2_UINT } 1013 }; 1014 1015 static enum pipe_format 1016 swizzle_format(enum pipe_format format, const int * const swizzle) 1017 { 1018 unsigned i; 1019 1020 switch (format) { 1021 case PIPE_FORMAT_R8G8B8A8_UNORM: 1022 case PIPE_FORMAT_B8G8R8A8_UNORM: 1023 case PIPE_FORMAT_A8R8G8B8_UNORM: 1024 case PIPE_FORMAT_A8B8G8R8_UNORM: 1025 for (i = 0; i < ARRAY_SIZE(table_8888_unorm); i++) { 1026 if (swizzle[0] == table_8888_unorm[i].swizzle[0] && 1027 swizzle[1] == table_8888_unorm[i].swizzle[1] && 1028 swizzle[2] == table_8888_unorm[i].swizzle[2] && 1029 swizzle[3] == table_8888_unorm[i].swizzle[3]) 1030 return table_8888_unorm[i].format; 1031 } 1032 break; 1033 1034 case PIPE_FORMAT_R10G10B10A2_UNORM: 1035 case PIPE_FORMAT_B10G10R10A2_UNORM: 1036 for (i = 0; i < ARRAY_SIZE(table_1010102_unorm); i++) { 1037 if (swizzle[0] == table_1010102_unorm[i].swizzle[0] && 1038 swizzle[1] == table_1010102_unorm[i].swizzle[1] && 1039 swizzle[2] == table_1010102_unorm[i].swizzle[2] && 1040 swizzle[3] == table_1010102_unorm[i].swizzle[3]) 1041 return table_1010102_unorm[i].format; 1042 } 1043 break; 1044 1045 case PIPE_FORMAT_R10G10B10A2_SNORM: 1046 case PIPE_FORMAT_B10G10R10A2_SNORM: 1047 for (i = 0; i < ARRAY_SIZE(table_1010102_snorm); i++) { 1048 if (swizzle[0] == table_1010102_snorm[i].swizzle[0] && 1049 swizzle[1] == table_1010102_snorm[i].swizzle[1] && 1050 swizzle[2] == table_1010102_snorm[i].swizzle[2] && 1051 swizzle[3] == table_1010102_snorm[i].swizzle[3]) 1052 return table_1010102_snorm[i].format; 1053 } 1054 break; 1055 1056 case PIPE_FORMAT_R10G10B10A2_UINT: 1057 case PIPE_FORMAT_B10G10R10A2_UINT: 1058 for (i = 0; i < ARRAY_SIZE(table_1010102_uint); i++) { 1059 if (swizzle[0] == table_1010102_uint[i].swizzle[0] && 1060 swizzle[1] == table_1010102_uint[i].swizzle[1] && 1061 swizzle[2] == table_1010102_uint[i].swizzle[2] && 1062 swizzle[3] == table_1010102_uint[i].swizzle[3]) 1063 return table_1010102_uint[i].format; 1064 } 1065 break; 1066 1067 default: 1068 break; 1069 } 1070 1071 return PIPE_FORMAT_NONE; 1072 } 1073 1074 static bool 1075 reinterpret_formats(enum pipe_format *src_format, enum pipe_format *dst_format) 1076 { 1077 enum pipe_format src = *src_format; 1078 enum pipe_format dst = *dst_format; 1079 1080 /* Note: dst_format has already been transformed from luminance/intensity 1081 * to red when this function is called. The source format will never 1082 * be an intensity format, because GL_INTENSITY is not a legal value 1083 * for the format parameter in glTex(Sub)Image(). */ 1084 1085 if (format_is_alpha(src)) { 1086 if (!format_is_alpha(dst)) 1087 return false; 1088 1089 src = alpha_to_red(src); 1090 dst = alpha_to_red(dst); 1091 } else if (format_is_luminance(src)) { 1092 if (!format_is_red(dst) && !format_is_red_alpha(dst)) 1093 return false; 1094 1095 src = util_format_luminance_to_red(src); 1096 } else if (util_format_is_luminance_alpha(src)) { 1097 src = luminance_alpha_to_red_green(src); 1098 1099 if (format_is_red_alpha(dst)) { 1100 dst = red_alpha_to_red_green(dst); 1101 } else if (!format_is_red(dst)) 1102 return false; 1103 } else if (format_is_swizzled_rgba(src)) { 1104 const struct util_format_description *src_desc = util_format_description(src); 1105 const struct util_format_description *dst_desc = util_format_description(dst); 1106 int swizzle[4]; 1107 unsigned i; 1108 1109 /* Make sure the format is an RGBA and not an RGBX format */ 1110 if (src_desc->nr_channels != 4 || src_desc->swizzle[3] == PIPE_SWIZZLE_1) 1111 return false; 1112 1113 if (dst_desc->nr_channels != 4 || dst_desc->swizzle[3] == PIPE_SWIZZLE_1) 1114 return false; 1115 1116 for (i = 0; i < 4; i++) 1117 swizzle[i] = dst_desc->swizzle[src_desc->swizzle[i]]; 1118 1119 dst = swizzle_format(dst, swizzle); 1120 if (dst == PIPE_FORMAT_NONE) 1121 return false; 1122 1123 src = unswizzle_format(src); 1124 } 1125 1126 *src_format = src; 1127 *dst_format = dst; 1128 return true; 1129 } 1130 1131 static bool 1132 try_pbo_upload_common(struct gl_context *ctx, 1133 struct pipe_surface *surface, 1134 const struct st_pbo_addresses *addr, 1135 enum pipe_format src_format) 1136 { 1137 struct st_context *st = st_context(ctx); 1138 struct cso_context *cso = st->cso_context; 1139 struct pipe_context *pipe = st->pipe; 1140 bool success = false; 1141 void *fs; 1142 1143 fs = st_pbo_get_upload_fs(st, src_format, surface->format); 1144 if (!fs) 1145 return false; 1146 1147 cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS | 1148 CSO_BIT_FRAGMENT_SAMPLERS | 1149 CSO_BIT_VERTEX_ELEMENTS | 1150 CSO_BIT_AUX_VERTEX_BUFFER_SLOT | 1151 CSO_BIT_FRAMEBUFFER | 1152 CSO_BIT_VIEWPORT | 1153 CSO_BIT_BLEND | 1154 CSO_BIT_DEPTH_STENCIL_ALPHA | 1155 CSO_BIT_RASTERIZER | 1156 CSO_BIT_STREAM_OUTPUTS | 1157 CSO_BIT_PAUSE_QUERIES | 1158 CSO_BIT_SAMPLE_MASK | 1159 CSO_BIT_MIN_SAMPLES | 1160 CSO_BIT_RENDER_CONDITION | 1161 CSO_BITS_ALL_SHADERS)); 1162 cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT); 1163 1164 cso_set_sample_mask(cso, ~0); 1165 cso_set_min_samples(cso, 1); 1166 cso_set_render_condition(cso, NULL, FALSE, 0); 1167 1168 /* Set up the sampler_view */ 1169 { 1170 struct pipe_sampler_view templ; 1171 struct pipe_sampler_view *sampler_view; 1172 struct pipe_sampler_state sampler = {0}; 1173 const struct pipe_sampler_state *samplers[1] = {&sampler}; 1174 1175 memset(&templ, 0, sizeof(templ)); 1176 templ.target = PIPE_BUFFER; 1177 templ.format = src_format; 1178 templ.u.buf.offset = addr->first_element * addr->bytes_per_pixel; 1179 templ.u.buf.size = (addr->last_element - addr->first_element + 1) * 1180 addr->bytes_per_pixel; 1181 templ.swizzle_r = PIPE_SWIZZLE_X; 1182 templ.swizzle_g = PIPE_SWIZZLE_Y; 1183 templ.swizzle_b = PIPE_SWIZZLE_Z; 1184 templ.swizzle_a = PIPE_SWIZZLE_W; 1185 1186 sampler_view = pipe->create_sampler_view(pipe, addr->buffer, &templ); 1187 if (sampler_view == NULL) 1188 goto fail; 1189 1190 cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view); 1191 1192 pipe_sampler_view_reference(&sampler_view, NULL); 1193 1194 cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers); 1195 } 1196 1197 /* Framebuffer_state */ 1198 { 1199 struct pipe_framebuffer_state fb; 1200 memset(&fb, 0, sizeof(fb)); 1201 fb.width = surface->width; 1202 fb.height = surface->height; 1203 fb.nr_cbufs = 1; 1204 pipe_surface_reference(&fb.cbufs[0], surface); 1205 1206 cso_set_framebuffer(cso, &fb); 1207 1208 pipe_surface_reference(&fb.cbufs[0], NULL); 1209 } 1210 1211 cso_set_viewport_dims(cso, surface->width, surface->height, FALSE); 1212 1213 /* Blend state */ 1214 cso_set_blend(cso, &st->pbo.upload_blend); 1215 1216 /* Depth/stencil/alpha state */ 1217 { 1218 struct pipe_depth_stencil_alpha_state dsa; 1219 memset(&dsa, 0, sizeof(dsa)); 1220 cso_set_depth_stencil_alpha(cso, &dsa); 1221 } 1222 1223 /* Set up the fragment shader */ 1224 cso_set_fragment_shader_handle(cso, fs); 1225 1226 success = st_pbo_draw(st, addr, surface->width, surface->height); 1227 1228 fail: 1229 cso_restore_state(cso); 1230 cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT); 1231 1232 return success; 1233 } 1234 1235 static bool 1236 try_pbo_upload(struct gl_context *ctx, GLuint dims, 1237 struct gl_texture_image *texImage, 1238 GLenum format, GLenum type, 1239 enum pipe_format dst_format, 1240 GLint xoffset, GLint yoffset, GLint zoffset, 1241 GLint width, GLint height, GLint depth, 1242 const void *pixels, 1243 const struct gl_pixelstore_attrib *unpack) 1244 { 1245 struct st_context *st = st_context(ctx); 1246 struct st_texture_image *stImage = st_texture_image(texImage); 1247 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1248 struct pipe_resource *texture = stImage->pt; 1249 struct pipe_context *pipe = st->pipe; 1250 struct pipe_screen *screen = pipe->screen; 1251 struct pipe_surface *surface = NULL; 1252 struct st_pbo_addresses addr; 1253 enum pipe_format src_format; 1254 const struct util_format_description *desc; 1255 GLenum gl_target = texImage->TexObject->Target; 1256 bool success; 1257 1258 if (!st->pbo.upload_enabled) 1259 return false; 1260 1261 /* From now on, we need the gallium representation of dimensions. */ 1262 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1263 depth = height; 1264 height = 1; 1265 zoffset = yoffset; 1266 yoffset = 0; 1267 } 1268 1269 if (depth != 1 && !st->pbo.layers) 1270 return false; 1271 1272 /* Choose the source format. Initially, we do so without checking driver 1273 * support at all because of the remapping we later perform and because 1274 * at least the Radeon driver actually supports some formats for texture 1275 * buffers which it doesn't support for regular textures. */ 1276 src_format = st_choose_matching_format(st, 0, format, type, unpack->SwapBytes); 1277 if (!src_format) { 1278 return false; 1279 } 1280 1281 src_format = util_format_linear(src_format); 1282 desc = util_format_description(src_format); 1283 1284 if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) 1285 return false; 1286 1287 if (desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB) 1288 return false; 1289 1290 if (st->pbo.rgba_only) { 1291 enum pipe_format orig_dst_format = dst_format; 1292 1293 if (!reinterpret_formats(&src_format, &dst_format)) { 1294 return false; 1295 } 1296 1297 if (dst_format != orig_dst_format && 1298 !screen->is_format_supported(screen, dst_format, PIPE_TEXTURE_2D, 0, 1299 PIPE_BIND_RENDER_TARGET)) { 1300 return false; 1301 } 1302 } 1303 1304 if (!src_format || 1305 !screen->is_format_supported(screen, src_format, PIPE_BUFFER, 0, 1306 PIPE_BIND_SAMPLER_VIEW)) { 1307 return false; 1308 } 1309 1310 /* Compute buffer addresses */ 1311 addr.xoffset = xoffset; 1312 addr.yoffset = yoffset; 1313 addr.width = width; 1314 addr.height = height; 1315 addr.depth = depth; 1316 addr.bytes_per_pixel = desc->block.bits / 8; 1317 1318 if (!st_pbo_addresses_pixelstore(st, gl_target, dims == 3, unpack, pixels, 1319 &addr)) 1320 return false; 1321 1322 /* Set up the surface */ 1323 { 1324 unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; 1325 unsigned max_layer = util_max_layer(texture, level); 1326 1327 zoffset += texImage->Face + texImage->TexObject->MinLayer; 1328 1329 struct pipe_surface templ; 1330 memset(&templ, 0, sizeof(templ)); 1331 templ.format = dst_format; 1332 templ.u.tex.level = level; 1333 templ.u.tex.first_layer = MIN2(zoffset, max_layer); 1334 templ.u.tex.last_layer = MIN2(zoffset + depth - 1, max_layer); 1335 1336 surface = pipe->create_surface(pipe, texture, &templ); 1337 if (!surface) 1338 return false; 1339 } 1340 1341 success = try_pbo_upload_common(ctx, surface, &addr, src_format); 1342 1343 pipe_surface_reference(&surface, NULL); 1344 1345 return success; 1346 } 1347 1348 static void 1349 st_TexSubImage(struct gl_context *ctx, GLuint dims, 1350 struct gl_texture_image *texImage, 1351 GLint xoffset, GLint yoffset, GLint zoffset, 1352 GLint width, GLint height, GLint depth, 1353 GLenum format, GLenum type, const void *pixels, 1354 const struct gl_pixelstore_attrib *unpack) 1355 { 1356 struct st_context *st = st_context(ctx); 1357 struct st_texture_image *stImage = st_texture_image(texImage); 1358 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1359 struct pipe_context *pipe = st->pipe; 1360 struct pipe_screen *screen = pipe->screen; 1361 struct pipe_resource *dst = stImage->pt; 1362 struct pipe_resource *src = NULL; 1363 struct pipe_resource src_templ; 1364 struct pipe_transfer *transfer; 1365 struct pipe_blit_info blit; 1366 enum pipe_format src_format, dst_format; 1367 mesa_format mesa_src_format; 1368 GLenum gl_target = texImage->TexObject->Target; 1369 unsigned bind; 1370 GLubyte *map; 1371 unsigned dstz = texImage->Face + texImage->TexObject->MinLayer; 1372 unsigned dst_level = 0; 1373 1374 st_flush_bitmap_cache(st); 1375 st_invalidate_readpix_cache(st); 1376 1377 if (stObj->pt == stImage->pt) 1378 dst_level = texImage->TexObject->MinLevel + texImage->Level; 1379 1380 assert(!_mesa_is_format_etc2(texImage->TexFormat) && 1381 texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); 1382 1383 if (!dst) 1384 goto fallback; 1385 1386 /* Try texture_subdata, which should be the fastest memcpy path. */ 1387 if (pixels && 1388 !_mesa_is_bufferobj(unpack->BufferObj) && 1389 _mesa_texstore_can_use_memcpy(ctx, texImage->_BaseFormat, 1390 texImage->TexFormat, format, type, 1391 unpack)) { 1392 struct pipe_box box; 1393 unsigned stride, layer_stride; 1394 void *data; 1395 1396 stride = _mesa_image_row_stride(unpack, width, format, type); 1397 layer_stride = _mesa_image_image_stride(unpack, width, height, format, 1398 type); 1399 data = _mesa_image_address(dims, unpack, pixels, width, height, format, 1400 type, 0, 0, 0); 1401 1402 /* Convert to Gallium coordinates. */ 1403 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1404 zoffset = yoffset; 1405 yoffset = 0; 1406 depth = height; 1407 height = 1; 1408 layer_stride = stride; 1409 } 1410 1411 u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box); 1412 pipe->texture_subdata(pipe, dst, dst_level, 0, 1413 &box, data, stride, layer_stride); 1414 return; 1415 } 1416 1417 if (!st->prefer_blit_based_texture_transfer) { 1418 goto fallback; 1419 } 1420 1421 /* XXX Fallback for depth-stencil formats due to an incomplete stencil 1422 * blit implementation in some drivers. */ 1423 if (format == GL_DEPTH_STENCIL) { 1424 goto fallback; 1425 } 1426 1427 /* If the base internal format and the texture format don't match, 1428 * we can't use blit-based TexSubImage. */ 1429 if (texImage->_BaseFormat != 1430 _mesa_get_format_base_format(texImage->TexFormat)) { 1431 goto fallback; 1432 } 1433 1434 1435 /* See if the destination format is supported. */ 1436 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) 1437 bind = PIPE_BIND_DEPTH_STENCIL; 1438 else 1439 bind = PIPE_BIND_RENDER_TARGET; 1440 1441 /* For luminance and intensity, only the red channel is stored 1442 * in the destination. */ 1443 dst_format = util_format_linear(dst->format); 1444 dst_format = util_format_luminance_to_red(dst_format); 1445 dst_format = util_format_intensity_to_red(dst_format); 1446 1447 if (!dst_format || 1448 !screen->is_format_supported(screen, dst_format, dst->target, 1449 dst->nr_samples, bind)) { 1450 goto fallback; 1451 } 1452 1453 if (_mesa_is_bufferobj(unpack->BufferObj)) { 1454 if (try_pbo_upload(ctx, dims, texImage, format, type, dst_format, 1455 xoffset, yoffset, zoffset, 1456 width, height, depth, pixels, unpack)) 1457 return; 1458 } 1459 1460 /* See if the texture format already matches the format and type, 1461 * in which case the memcpy-based fast path will likely be used and 1462 * we don't have to blit. */ 1463 if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, 1464 type, unpack->SwapBytes, NULL)) { 1465 goto fallback; 1466 } 1467 1468 /* Choose the source format. */ 1469 src_format = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW, 1470 format, type, unpack->SwapBytes); 1471 if (!src_format) { 1472 goto fallback; 1473 } 1474 1475 mesa_src_format = st_pipe_format_to_mesa_format(src_format); 1476 1477 /* There is no reason to do this if we cannot use memcpy for the temporary 1478 * source texture at least. This also takes transfer ops into account, 1479 * etc. */ 1480 if (!_mesa_texstore_can_use_memcpy(ctx, 1481 _mesa_get_format_base_format(mesa_src_format), 1482 mesa_src_format, format, type, unpack)) { 1483 goto fallback; 1484 } 1485 1486 /* TexSubImage only sets a single cubemap face. */ 1487 if (gl_target == GL_TEXTURE_CUBE_MAP) { 1488 gl_target = GL_TEXTURE_2D; 1489 } 1490 /* TexSubImage can specify subsets of cube map array faces 1491 * so we need to upload via 2D array instead */ 1492 if (gl_target == GL_TEXTURE_CUBE_MAP_ARRAY) { 1493 gl_target = GL_TEXTURE_2D_ARRAY; 1494 } 1495 1496 /* Initialize the source texture description. */ 1497 memset(&src_templ, 0, sizeof(src_templ)); 1498 src_templ.target = gl_target_to_pipe(gl_target); 1499 src_templ.format = src_format; 1500 src_templ.bind = PIPE_BIND_SAMPLER_VIEW; 1501 src_templ.usage = PIPE_USAGE_STAGING; 1502 1503 st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, 1504 &src_templ.width0, &src_templ.height0, 1505 &src_templ.depth0, &src_templ.array_size); 1506 1507 /* Check for NPOT texture support. */ 1508 if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) && 1509 (!util_is_power_of_two(src_templ.width0) || 1510 !util_is_power_of_two(src_templ.height0) || 1511 !util_is_power_of_two(src_templ.depth0))) { 1512 goto fallback; 1513 } 1514 1515 /* Create the source texture. */ 1516 src = screen->resource_create(screen, &src_templ); 1517 if (!src) { 1518 goto fallback; 1519 } 1520 1521 /* Map source pixels. */ 1522 pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth, 1523 format, type, pixels, unpack, 1524 "glTexSubImage"); 1525 if (!pixels) { 1526 /* This is a GL error. */ 1527 pipe_resource_reference(&src, NULL); 1528 return; 1529 } 1530 1531 /* From now on, we need the gallium representation of dimensions. */ 1532 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1533 zoffset = yoffset; 1534 yoffset = 0; 1535 depth = height; 1536 height = 1; 1537 } 1538 1539 map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0, 1540 width, height, depth, &transfer); 1541 if (!map) { 1542 _mesa_unmap_teximage_pbo(ctx, unpack); 1543 pipe_resource_reference(&src, NULL); 1544 goto fallback; 1545 } 1546 1547 /* Upload pixels (just memcpy). */ 1548 { 1549 const uint bytesPerRow = width * util_format_get_blocksize(src_format); 1550 GLuint row, slice; 1551 1552 for (slice = 0; slice < (unsigned) depth; slice++) { 1553 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1554 /* 1D array textures. 1555 * We need to convert gallium coords to GL coords. 1556 */ 1557 void *src = _mesa_image_address2d(unpack, pixels, 1558 width, depth, format, 1559 type, slice, 0); 1560 memcpy(map, src, bytesPerRow); 1561 } 1562 else { 1563 ubyte *slice_map = map; 1564 1565 for (row = 0; row < (unsigned) height; row++) { 1566 void *src = _mesa_image_address(dims, unpack, pixels, 1567 width, height, format, 1568 type, slice, row, 0); 1569 memcpy(slice_map, src, bytesPerRow); 1570 slice_map += transfer->stride; 1571 } 1572 } 1573 map += transfer->layer_stride; 1574 } 1575 } 1576 1577 pipe_transfer_unmap(pipe, transfer); 1578 _mesa_unmap_teximage_pbo(ctx, unpack); 1579 1580 /* Blit. */ 1581 memset(&blit, 0, sizeof(blit)); 1582 blit.src.resource = src; 1583 blit.src.level = 0; 1584 blit.src.format = src_format; 1585 blit.dst.resource = dst; 1586 blit.dst.level = dst_level; 1587 blit.dst.format = dst_format; 1588 blit.src.box.x = blit.src.box.y = blit.src.box.z = 0; 1589 blit.dst.box.x = xoffset; 1590 blit.dst.box.y = yoffset; 1591 blit.dst.box.z = zoffset + dstz; 1592 blit.src.box.width = blit.dst.box.width = width; 1593 blit.src.box.height = blit.dst.box.height = height; 1594 blit.src.box.depth = blit.dst.box.depth = depth; 1595 blit.mask = st_get_blit_mask(format, texImage->_BaseFormat); 1596 blit.filter = PIPE_TEX_FILTER_NEAREST; 1597 blit.scissor_enable = FALSE; 1598 1599 st->pipe->blit(st->pipe, &blit); 1600 1601 pipe_resource_reference(&src, NULL); 1602 return; 1603 1604 fallback: 1605 _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset, 1606 width, height, depth, format, type, pixels, 1607 unpack); 1608 } 1609 1610 static void 1611 st_TexImage(struct gl_context * ctx, GLuint dims, 1612 struct gl_texture_image *texImage, 1613 GLenum format, GLenum type, const void *pixels, 1614 const struct gl_pixelstore_attrib *unpack) 1615 { 1616 assert(dims == 1 || dims == 2 || dims == 3); 1617 1618 prep_teximage(ctx, texImage, format, type); 1619 1620 if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0) 1621 return; 1622 1623 /* allocate storage for texture data */ 1624 if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) { 1625 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims); 1626 return; 1627 } 1628 1629 st_TexSubImage(ctx, dims, texImage, 0, 0, 0, 1630 texImage->Width, texImage->Height, texImage->Depth, 1631 format, type, pixels, unpack); 1632 } 1633 1634 1635 static void 1636 st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims, 1637 struct gl_texture_image *texImage, 1638 GLint x, GLint y, GLint z, 1639 GLsizei w, GLsizei h, GLsizei d, 1640 GLenum format, GLsizei imageSize, const void *data) 1641 { 1642 struct st_context *st = st_context(ctx); 1643 struct st_texture_image *stImage = st_texture_image(texImage); 1644 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1645 struct pipe_resource *texture = stImage->pt; 1646 struct pipe_context *pipe = st->pipe; 1647 struct pipe_screen *screen = pipe->screen; 1648 struct pipe_resource *dst = stImage->pt; 1649 struct pipe_surface *surface = NULL; 1650 struct compressed_pixelstore store; 1651 struct st_pbo_addresses addr; 1652 enum pipe_format copy_format; 1653 unsigned bw, bh; 1654 intptr_t buf_offset; 1655 bool success = false; 1656 1657 /* Check basic pre-conditions for PBO upload */ 1658 if (!st->prefer_blit_based_texture_transfer) { 1659 goto fallback; 1660 } 1661 1662 if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj)) 1663 goto fallback; 1664 1665 if (st_etc_fallback(st, texImage)) { 1666 /* ETC isn't supported and is represented by uncompressed formats. */ 1667 goto fallback; 1668 } 1669 1670 if (!dst) { 1671 goto fallback; 1672 } 1673 1674 if (!st->pbo.upload_enabled || 1675 !screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) { 1676 goto fallback; 1677 } 1678 1679 /* Choose the pipe format for the upload. */ 1680 addr.bytes_per_pixel = util_format_get_blocksize(dst->format); 1681 bw = util_format_get_blockwidth(dst->format); 1682 bh = util_format_get_blockheight(dst->format); 1683 1684 switch (addr.bytes_per_pixel) { 1685 case 8: 1686 copy_format = PIPE_FORMAT_R16G16B16A16_UINT; 1687 break; 1688 case 16: 1689 copy_format = PIPE_FORMAT_R32G32B32A32_UINT; 1690 break; 1691 default: 1692 goto fallback; 1693 } 1694 1695 if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0, 1696 PIPE_BIND_SAMPLER_VIEW)) { 1697 goto fallback; 1698 } 1699 1700 if (!screen->is_format_supported(screen, copy_format, dst->target, 1701 dst->nr_samples, PIPE_BIND_RENDER_TARGET)) { 1702 goto fallback; 1703 } 1704 1705 /* Interpret the pixelstore settings. */ 1706 _mesa_compute_compressed_pixelstore(dims, texImage->TexFormat, w, h, d, 1707 &ctx->Unpack, &store); 1708 assert(store.CopyBytesPerRow % addr.bytes_per_pixel == 0); 1709 assert(store.SkipBytes % addr.bytes_per_pixel == 0); 1710 1711 /* Compute the offset into the buffer */ 1712 buf_offset = (intptr_t)data + store.SkipBytes; 1713 1714 if (buf_offset % addr.bytes_per_pixel) { 1715 goto fallback; 1716 } 1717 1718 buf_offset = buf_offset / addr.bytes_per_pixel; 1719 1720 addr.xoffset = x / bw; 1721 addr.yoffset = y / bh; 1722 addr.width = store.CopyBytesPerRow / addr.bytes_per_pixel; 1723 addr.height = store.CopyRowsPerSlice; 1724 addr.depth = d; 1725 addr.pixels_per_row = store.TotalBytesPerRow / addr.bytes_per_pixel; 1726 addr.image_height = store.TotalRowsPerSlice; 1727 1728 if (!st_pbo_addresses_setup(st, st_buffer_object(ctx->Unpack.BufferObj)->buffer, 1729 buf_offset, &addr)) 1730 goto fallback; 1731 1732 /* Set up the surface. */ 1733 { 1734 unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; 1735 unsigned max_layer = util_max_layer(texture, level); 1736 1737 z += texImage->Face + texImage->TexObject->MinLayer; 1738 1739 struct pipe_surface templ; 1740 memset(&templ, 0, sizeof(templ)); 1741 templ.format = copy_format; 1742 templ.u.tex.level = level; 1743 templ.u.tex.first_layer = MIN2(z, max_layer); 1744 templ.u.tex.last_layer = MIN2(z + d - 1, max_layer); 1745 1746 surface = pipe->create_surface(pipe, texture, &templ); 1747 if (!surface) 1748 goto fallback; 1749 } 1750 1751 success = try_pbo_upload_common(ctx, surface, &addr, copy_format); 1752 1753 pipe_surface_reference(&surface, NULL); 1754 1755 if (success) 1756 return; 1757 1758 fallback: 1759 _mesa_store_compressed_texsubimage(ctx, dims, texImage, 1760 x, y, z, w, h, d, 1761 format, imageSize, data); 1762 } 1763 1764 static void 1765 st_CompressedTexImage(struct gl_context *ctx, GLuint dims, 1766 struct gl_texture_image *texImage, 1767 GLsizei imageSize, const void *data) 1768 { 1769 prep_teximage(ctx, texImage, GL_NONE, GL_NONE); 1770 1771 /* only 2D and 3D compressed images are supported at this time */ 1772 if (dims == 1) { 1773 _mesa_problem(ctx, "Unexpected glCompressedTexImage1D call"); 1774 return; 1775 } 1776 1777 /* This is pretty simple, because unlike the general texstore path we don't 1778 * have to worry about the usual image unpacking or image transfer 1779 * operations. 1780 */ 1781 assert(texImage); 1782 assert(texImage->Width > 0); 1783 assert(texImage->Height > 0); 1784 assert(texImage->Depth > 0); 1785 1786 /* allocate storage for texture data */ 1787 if (!st_AllocTextureImageBuffer(ctx, texImage)) { 1788 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims); 1789 return; 1790 } 1791 1792 st_CompressedTexSubImage(ctx, dims, texImage, 1793 0, 0, 0, 1794 texImage->Width, texImage->Height, texImage->Depth, 1795 texImage->TexFormat, 1796 imageSize, data); 1797 } 1798 1799 1800 1801 1802 /** 1803 * Called via ctx->Driver.GetTexSubImage() 1804 * 1805 * This uses a blit to copy the texture to a texture format which matches 1806 * the format and type combo and then a fast read-back is done using memcpy. 1807 * We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is 1808 * a format which matches the swizzling. 1809 * 1810 * If such a format isn't available, it falls back to _mesa_GetTexImage_sw. 1811 * 1812 * NOTE: Drivers usually do a blit to convert between tiled and linear 1813 * texture layouts during texture uploads/downloads, so the blit 1814 * we do here should be free in such cases. 1815 */ 1816 static void 1817 st_GetTexSubImage(struct gl_context * ctx, 1818 GLint xoffset, GLint yoffset, GLint zoffset, 1819 GLsizei width, GLsizei height, GLint depth, 1820 GLenum format, GLenum type, void * pixels, 1821 struct gl_texture_image *texImage) 1822 { 1823 struct st_context *st = st_context(ctx); 1824 struct pipe_context *pipe = st->pipe; 1825 struct pipe_screen *screen = pipe->screen; 1826 struct st_texture_image *stImage = st_texture_image(texImage); 1827 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1828 struct pipe_resource *src = stObj->pt; 1829 struct pipe_resource *dst = NULL; 1830 struct pipe_resource dst_templ; 1831 enum pipe_format dst_format, src_format; 1832 mesa_format mesa_format; 1833 GLenum gl_target = texImage->TexObject->Target; 1834 enum pipe_texture_target pipe_target; 1835 unsigned dims; 1836 struct pipe_blit_info blit; 1837 unsigned bind; 1838 struct pipe_transfer *tex_xfer; 1839 ubyte *map = NULL; 1840 boolean done = FALSE; 1841 1842 assert(!_mesa_is_format_etc2(texImage->TexFormat) && 1843 texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); 1844 1845 st_flush_bitmap_cache(st); 1846 1847 if (!st->prefer_blit_based_texture_transfer && 1848 !_mesa_is_format_compressed(texImage->TexFormat)) { 1849 /* Try to avoid the fallback if we're doing texture decompression here */ 1850 goto fallback; 1851 } 1852 1853 /* Handle non-finalized textures. */ 1854 if (!stImage->pt || stImage->pt != stObj->pt || !src) { 1855 goto fallback; 1856 } 1857 1858 /* XXX Fallback to _mesa_GetTexImage_sw for depth-stencil formats 1859 * due to an incomplete stencil blit implementation in some drivers. */ 1860 if (format == GL_DEPTH_STENCIL || format == GL_STENCIL_INDEX) { 1861 goto fallback; 1862 } 1863 1864 /* If the base internal format and the texture format don't match, we have 1865 * to fall back to _mesa_GetTexImage_sw. */ 1866 if (texImage->_BaseFormat != 1867 _mesa_get_format_base_format(texImage->TexFormat)) { 1868 goto fallback; 1869 } 1870 1871 /* See if the texture format already matches the format and type, 1872 * in which case the memcpy-based fast path will be used. */ 1873 if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, 1874 type, ctx->Pack.SwapBytes, NULL)) { 1875 goto fallback; 1876 } 1877 1878 /* Convert the source format to what is expected by GetTexImage 1879 * and see if it's supported. 1880 * 1881 * This only applies to glGetTexImage: 1882 * - Luminance must be returned as (L,0,0,1). 1883 * - Luminance alpha must be returned as (L,0,0,A). 1884 * - Intensity must be returned as (I,0,0,1) 1885 */ 1886 if (stObj->surface_based) 1887 src_format = util_format_linear(stObj->surface_format); 1888 else 1889 src_format = util_format_linear(src->format); 1890 src_format = util_format_luminance_to_red(src_format); 1891 src_format = util_format_intensity_to_red(src_format); 1892 1893 if (!src_format || 1894 !screen->is_format_supported(screen, src_format, src->target, 1895 src->nr_samples, 1896 PIPE_BIND_SAMPLER_VIEW)) { 1897 goto fallback; 1898 } 1899 1900 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) 1901 bind = PIPE_BIND_DEPTH_STENCIL; 1902 else 1903 bind = PIPE_BIND_RENDER_TARGET; 1904 1905 /* GetTexImage only returns a single face for cubemaps. */ 1906 if (gl_target == GL_TEXTURE_CUBE_MAP) { 1907 gl_target = GL_TEXTURE_2D; 1908 } 1909 pipe_target = gl_target_to_pipe(gl_target); 1910 1911 /* Choose the destination format by finding the best match 1912 * for the format+type combo. */ 1913 dst_format = st_choose_matching_format(st, bind, format, type, 1914 ctx->Pack.SwapBytes); 1915 1916 if (dst_format == PIPE_FORMAT_NONE) { 1917 GLenum dst_glformat; 1918 1919 /* Fall back to _mesa_GetTexImage_sw except for compressed formats, 1920 * where decompression with a blit is always preferred. */ 1921 if (!util_format_is_compressed(src->format)) { 1922 goto fallback; 1923 } 1924 1925 /* Set the appropriate format for the decompressed texture. 1926 * Luminance and sRGB formats shouldn't appear here.*/ 1927 switch (src_format) { 1928 case PIPE_FORMAT_DXT1_RGB: 1929 case PIPE_FORMAT_DXT1_RGBA: 1930 case PIPE_FORMAT_DXT3_RGBA: 1931 case PIPE_FORMAT_DXT5_RGBA: 1932 case PIPE_FORMAT_RGTC1_UNORM: 1933 case PIPE_FORMAT_RGTC2_UNORM: 1934 case PIPE_FORMAT_ETC1_RGB8: 1935 case PIPE_FORMAT_BPTC_RGBA_UNORM: 1936 dst_glformat = GL_RGBA8; 1937 break; 1938 case PIPE_FORMAT_RGTC1_SNORM: 1939 case PIPE_FORMAT_RGTC2_SNORM: 1940 if (!ctx->Extensions.EXT_texture_snorm) 1941 goto fallback; 1942 dst_glformat = GL_RGBA8_SNORM; 1943 break; 1944 case PIPE_FORMAT_BPTC_RGB_FLOAT: 1945 case PIPE_FORMAT_BPTC_RGB_UFLOAT: 1946 if (!ctx->Extensions.ARB_texture_float) 1947 goto fallback; 1948 dst_glformat = GL_RGBA32F; 1949 break; 1950 default: 1951 assert(0); 1952 goto fallback; 1953 } 1954 1955 dst_format = st_choose_format(st, dst_glformat, format, type, 1956 pipe_target, 0, bind, FALSE); 1957 1958 if (dst_format == PIPE_FORMAT_NONE) { 1959 /* unable to get an rgba format!?! */ 1960 goto fallback; 1961 } 1962 } 1963 1964 /* create the destination texture of size (width X height X depth) */ 1965 memset(&dst_templ, 0, sizeof(dst_templ)); 1966 dst_templ.target = pipe_target; 1967 dst_templ.format = dst_format; 1968 dst_templ.bind = bind; 1969 dst_templ.usage = PIPE_USAGE_STAGING; 1970 1971 st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, 1972 &dst_templ.width0, &dst_templ.height0, 1973 &dst_templ.depth0, &dst_templ.array_size); 1974 1975 dst = screen->resource_create(screen, &dst_templ); 1976 if (!dst) { 1977 goto fallback; 1978 } 1979 1980 /* From now on, we need the gallium representation of dimensions. */ 1981 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1982 zoffset = yoffset; 1983 yoffset = 0; 1984 depth = height; 1985 height = 1; 1986 } 1987 1988 assert(texImage->Face == 0 || 1989 texImage->TexObject->MinLayer == 0 || 1990 zoffset == 0); 1991 1992 memset(&blit, 0, sizeof(blit)); 1993 blit.src.resource = src; 1994 blit.src.level = texImage->Level + texImage->TexObject->MinLevel; 1995 blit.src.format = src_format; 1996 blit.dst.resource = dst; 1997 blit.dst.level = 0; 1998 blit.dst.format = dst->format; 1999 blit.src.box.x = xoffset; 2000 blit.dst.box.x = 0; 2001 blit.src.box.y = yoffset; 2002 blit.dst.box.y = 0; 2003 blit.src.box.z = texImage->Face + texImage->TexObject->MinLayer + zoffset; 2004 blit.dst.box.z = 0; 2005 blit.src.box.width = blit.dst.box.width = width; 2006 blit.src.box.height = blit.dst.box.height = height; 2007 blit.src.box.depth = blit.dst.box.depth = depth; 2008 blit.mask = st_get_blit_mask(texImage->_BaseFormat, format); 2009 blit.filter = PIPE_TEX_FILTER_NEAREST; 2010 blit.scissor_enable = FALSE; 2011 2012 /* blit/render/decompress */ 2013 st->pipe->blit(st->pipe, &blit); 2014 2015 pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels); 2016 2017 map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ, 2018 0, 0, 0, width, height, depth, &tex_xfer); 2019 if (!map) { 2020 goto end; 2021 } 2022 2023 mesa_format = st_pipe_format_to_mesa_format(dst_format); 2024 dims = _mesa_get_texture_dimensions(gl_target); 2025 2026 /* copy/pack data into user buffer */ 2027 if (_mesa_format_matches_format_and_type(mesa_format, format, type, 2028 ctx->Pack.SwapBytes, NULL)) { 2029 /* memcpy */ 2030 const uint bytesPerRow = width * util_format_get_blocksize(dst_format); 2031 GLuint row, slice; 2032 2033 for (slice = 0; slice < depth; slice++) { 2034 ubyte *slice_map = map; 2035 2036 for (row = 0; row < height; row++) { 2037 void *dest = _mesa_image_address(dims, &ctx->Pack, pixels, 2038 width, height, format, type, 2039 slice, row, 0); 2040 2041 memcpy(dest, slice_map, bytesPerRow); 2042 2043 slice_map += tex_xfer->stride; 2044 } 2045 2046 map += tex_xfer->layer_stride; 2047 } 2048 } 2049 else { 2050 /* format translation via floats */ 2051 GLuint slice; 2052 GLfloat *rgba; 2053 uint32_t dstMesaFormat; 2054 int dstStride, srcStride; 2055 2056 assert(util_format_is_compressed(src->format)); 2057 2058 rgba = malloc(width * height * 4 * sizeof(GLfloat)); 2059 if (!rgba) { 2060 goto end; 2061 } 2062 2063 if (ST_DEBUG & DEBUG_FALLBACK) 2064 debug_printf("%s: fallback format translation\n", __func__); 2065 2066 dstMesaFormat = _mesa_format_from_format_and_type(format, type); 2067 dstStride = _mesa_image_row_stride(&ctx->Pack, width, format, type); 2068 srcStride = 4 * width * sizeof(GLfloat); 2069 for (slice = 0; slice < depth; slice++) { 2070 void *dest = _mesa_image_address(dims, &ctx->Pack, pixels, 2071 width, height, format, type, 2072 slice, 0, 0); 2073 2074 /* get float[4] rgba row from surface */ 2075 pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, height, 2076 dst_format, rgba); 2077 2078 _mesa_format_convert(dest, dstMesaFormat, dstStride, 2079 rgba, RGBA32_FLOAT, srcStride, 2080 width, height, NULL); 2081 2082 /* Handle byte swapping if required */ 2083 if (ctx->Pack.SwapBytes) { 2084 _mesa_swap_bytes_2d_image(format, type, &ctx->Pack, 2085 width, height, dest, dest); 2086 } 2087 2088 map += tex_xfer->layer_stride; 2089 } 2090 2091 free(rgba); 2092 } 2093 done = TRUE; 2094 2095 end: 2096 if (map) 2097 pipe_transfer_unmap(pipe, tex_xfer); 2098 2099 _mesa_unmap_pbo_dest(ctx, &ctx->Pack); 2100 pipe_resource_reference(&dst, NULL); 2101 2102 fallback: 2103 if (!done) { 2104 _mesa_GetTexSubImage_sw(ctx, xoffset, yoffset, zoffset, 2105 width, height, depth, 2106 format, type, pixels, texImage); 2107 } 2108 } 2109 2110 2111 /** 2112 * Do a CopyTexSubImage operation using a read transfer from the source, 2113 * a write transfer to the destination and get_tile()/put_tile() to access 2114 * the pixels/texels. 2115 * 2116 * Note: srcY=0=TOP of renderbuffer 2117 */ 2118 static void 2119 fallback_copy_texsubimage(struct gl_context *ctx, 2120 struct st_renderbuffer *strb, 2121 struct st_texture_image *stImage, 2122 GLenum baseFormat, 2123 GLint destX, GLint destY, GLint slice, 2124 GLint srcX, GLint srcY, 2125 GLsizei width, GLsizei height) 2126 { 2127 struct st_context *st = st_context(ctx); 2128 struct pipe_context *pipe = st->pipe; 2129 struct pipe_transfer *src_trans; 2130 GLubyte *texDest; 2131 enum pipe_transfer_usage transfer_usage; 2132 void *map; 2133 unsigned dst_width = width; 2134 unsigned dst_height = height; 2135 unsigned dst_depth = 1; 2136 struct pipe_transfer *transfer; 2137 2138 if (ST_DEBUG & DEBUG_FALLBACK) 2139 debug_printf("%s: fallback processing\n", __func__); 2140 2141 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { 2142 srcY = strb->Base.Height - srcY - height; 2143 } 2144 2145 map = pipe_transfer_map(pipe, 2146 strb->texture, 2147 strb->surface->u.tex.level, 2148 strb->surface->u.tex.first_layer, 2149 PIPE_TRANSFER_READ, 2150 srcX, srcY, 2151 width, height, &src_trans); 2152 2153 if ((baseFormat == GL_DEPTH_COMPONENT || 2154 baseFormat == GL_DEPTH_STENCIL) && 2155 util_format_is_depth_and_stencil(stImage->pt->format)) 2156 transfer_usage = PIPE_TRANSFER_READ_WRITE; 2157 else 2158 transfer_usage = PIPE_TRANSFER_WRITE; 2159 2160 texDest = st_texture_image_map(st, stImage, transfer_usage, 2161 destX, destY, slice, 2162 dst_width, dst_height, dst_depth, 2163 &transfer); 2164 2165 if (baseFormat == GL_DEPTH_COMPONENT || 2166 baseFormat == GL_DEPTH_STENCIL) { 2167 const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F || 2168 ctx->Pixel.DepthBias != 0.0F); 2169 GLint row, yStep; 2170 uint *data; 2171 2172 /* determine bottom-to-top vs. top-to-bottom order for src buffer */ 2173 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { 2174 srcY = height - 1; 2175 yStep = -1; 2176 } 2177 else { 2178 srcY = 0; 2179 yStep = 1; 2180 } 2181 2182 data = malloc(width * sizeof(uint)); 2183 2184 if (data) { 2185 /* To avoid a large temp memory allocation, do copy row by row */ 2186 for (row = 0; row < height; row++, srcY += yStep) { 2187 pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data); 2188 if (scaleOrBias) { 2189 _mesa_scale_and_bias_depth_uint(ctx, width, data); 2190 } 2191 2192 if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { 2193 pipe_put_tile_z(transfer, texDest + row*transfer->layer_stride, 2194 0, 0, width, 1, data); 2195 } 2196 else { 2197 pipe_put_tile_z(transfer, texDest, 0, row, width, 1, data); 2198 } 2199 } 2200 } 2201 else { 2202 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()"); 2203 } 2204 2205 free(data); 2206 } 2207 else { 2208 /* RGBA format */ 2209 GLfloat *tempSrc = 2210 malloc(width * height * 4 * sizeof(GLfloat)); 2211 2212 if (tempSrc && texDest) { 2213 const GLint dims = 2; 2214 GLint dstRowStride; 2215 struct gl_texture_image *texImage = &stImage->base; 2216 struct gl_pixelstore_attrib unpack = ctx->DefaultPacking; 2217 2218 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { 2219 unpack.Invert = GL_TRUE; 2220 } 2221 2222 if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { 2223 dstRowStride = transfer->layer_stride; 2224 } 2225 else { 2226 dstRowStride = transfer->stride; 2227 } 2228 2229 /* get float/RGBA image from framebuffer */ 2230 /* XXX this usually involves a lot of int/float conversion. 2231 * try to avoid that someday. 2232 */ 2233 pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height, 2234 util_format_linear(strb->texture->format), 2235 tempSrc); 2236 2237 /* Store into texture memory. 2238 * Note that this does some special things such as pixel transfer 2239 * ops and format conversion. In particular, if the dest tex format 2240 * is actually RGBA but the user created the texture as GL_RGB we 2241 * need to fill-in/override the alpha channel with 1.0. 2242 */ 2243 _mesa_texstore(ctx, dims, 2244 texImage->_BaseFormat, 2245 texImage->TexFormat, 2246 dstRowStride, 2247 &texDest, 2248 width, height, 1, 2249 GL_RGBA, GL_FLOAT, tempSrc, /* src */ 2250 &unpack); 2251 } 2252 else { 2253 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage"); 2254 } 2255 2256 free(tempSrc); 2257 } 2258 2259 st_texture_image_unmap(st, stImage, slice); 2260 pipe->transfer_unmap(pipe, src_trans); 2261 } 2262 2263 2264 /** 2265 * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible. 2266 * Note that the region to copy has already been clipped so we know we 2267 * won't read from outside the source renderbuffer's bounds. 2268 * 2269 * Note: srcY=0=Bottom of renderbuffer (GL convention) 2270 */ 2271 static void 2272 st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, 2273 struct gl_texture_image *texImage, 2274 GLint destX, GLint destY, GLint slice, 2275 struct gl_renderbuffer *rb, 2276 GLint srcX, GLint srcY, GLsizei width, GLsizei height) 2277 { 2278 struct st_texture_image *stImage = st_texture_image(texImage); 2279 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 2280 struct st_renderbuffer *strb = st_renderbuffer(rb); 2281 struct st_context *st = st_context(ctx); 2282 struct pipe_context *pipe = st->pipe; 2283 struct pipe_screen *screen = pipe->screen; 2284 struct pipe_blit_info blit; 2285 enum pipe_format dst_format; 2286 GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP); 2287 unsigned bind; 2288 GLint srcY0, srcY1; 2289 2290 st_flush_bitmap_cache(st); 2291 st_invalidate_readpix_cache(st); 2292 2293 assert(!_mesa_is_format_etc2(texImage->TexFormat) && 2294 texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); 2295 2296 if (!strb || !strb->surface || !stImage->pt) { 2297 debug_printf("%s: null strb or stImage\n", __func__); 2298 return; 2299 } 2300 2301 if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat, 2302 texImage->TexFormat)) { 2303 goto fallback; 2304 } 2305 2306 /* The base internal format must match the mesa format, so make sure 2307 * e.g. an RGB internal format is really allocated as RGB and not as RGBA. 2308 */ 2309 if (texImage->_BaseFormat != 2310 _mesa_get_format_base_format(texImage->TexFormat) || 2311 rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) { 2312 goto fallback; 2313 } 2314 2315 /* Choose the destination format to match the TexImage behavior. */ 2316 dst_format = util_format_linear(stImage->pt->format); 2317 dst_format = util_format_luminance_to_red(dst_format); 2318 dst_format = util_format_intensity_to_red(dst_format); 2319 2320 /* See if the destination format is supported. */ 2321 if (texImage->_BaseFormat == GL_DEPTH_STENCIL || 2322 texImage->_BaseFormat == GL_DEPTH_COMPONENT) { 2323 bind = PIPE_BIND_DEPTH_STENCIL; 2324 } 2325 else { 2326 bind = PIPE_BIND_RENDER_TARGET; 2327 } 2328 2329 if (!dst_format || 2330 !screen->is_format_supported(screen, dst_format, stImage->pt->target, 2331 stImage->pt->nr_samples, bind)) { 2332 goto fallback; 2333 } 2334 2335 /* Y flipping for the main framebuffer. */ 2336 if (do_flip) { 2337 srcY1 = strb->Base.Height - srcY - height; 2338 srcY0 = srcY1 + height; 2339 } 2340 else { 2341 srcY0 = srcY; 2342 srcY1 = srcY0 + height; 2343 } 2344 2345 /* Blit the texture. 2346 * This supports flipping, format conversions, and downsampling. 2347 */ 2348 memset(&blit, 0, sizeof(blit)); 2349 blit.src.resource = strb->texture; 2350 blit.src.format = util_format_linear(strb->surface->format); 2351 blit.src.level = strb->surface->u.tex.level; 2352 blit.src.box.x = srcX; 2353 blit.src.box.y = srcY0; 2354 blit.src.box.z = strb->surface->u.tex.first_layer; 2355 blit.src.box.width = width; 2356 blit.src.box.height = srcY1 - srcY0; 2357 blit.src.box.depth = 1; 2358 blit.dst.resource = stImage->pt; 2359 blit.dst.format = dst_format; 2360 blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level + texImage->TexObject->MinLevel; 2361 blit.dst.box.x = destX; 2362 blit.dst.box.y = destY; 2363 blit.dst.box.z = stImage->base.Face + slice + texImage->TexObject->MinLayer; 2364 blit.dst.box.width = width; 2365 blit.dst.box.height = height; 2366 blit.dst.box.depth = 1; 2367 blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat); 2368 blit.filter = PIPE_TEX_FILTER_NEAREST; 2369 pipe->blit(pipe, &blit); 2370 return; 2371 2372 fallback: 2373 /* software fallback */ 2374 fallback_copy_texsubimage(ctx, 2375 strb, stImage, texImage->_BaseFormat, 2376 destX, destY, slice, 2377 srcX, srcY, width, height); 2378 } 2379 2380 2381 /** 2382 * Copy image data from stImage into the texture object 'stObj' at level 2383 * 'dstLevel'. 2384 */ 2385 static void 2386 copy_image_data_to_texture(struct st_context *st, 2387 struct st_texture_object *stObj, 2388 GLuint dstLevel, 2389 struct st_texture_image *stImage) 2390 { 2391 /* debug checks */ 2392 { 2393 const struct gl_texture_image *dstImage = 2394 stObj->base.Image[stImage->base.Face][dstLevel]; 2395 assert(dstImage); 2396 assert(dstImage->Width == stImage->base.Width); 2397 assert(dstImage->Height == stImage->base.Height); 2398 assert(dstImage->Depth == stImage->base.Depth); 2399 } 2400 2401 if (stImage->pt) { 2402 /* Copy potentially with the blitter: 2403 */ 2404 GLuint src_level; 2405 if (stImage->pt->last_level == 0) 2406 src_level = 0; 2407 else 2408 src_level = stImage->base.Level; 2409 2410 assert(src_level <= stImage->pt->last_level); 2411 assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width); 2412 assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY || 2413 u_minify(stImage->pt->height0, src_level) == stImage->base.Height); 2414 assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY || 2415 stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY || 2416 u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth); 2417 2418 st_texture_image_copy(st->pipe, 2419 stObj->pt, dstLevel, /* dest texture, level */ 2420 stImage->pt, src_level, /* src texture, level */ 2421 stImage->base.Face); 2422 2423 pipe_resource_reference(&stImage->pt, NULL); 2424 } 2425 pipe_resource_reference(&stImage->pt, stObj->pt); 2426 } 2427 2428 2429 /** 2430 * Called during state validation. When this function is finished, 2431 * the texture object should be ready for rendering. 2432 * \return GL_TRUE for success, GL_FALSE for failure (out of mem) 2433 */ 2434 GLboolean 2435 st_finalize_texture(struct gl_context *ctx, 2436 struct pipe_context *pipe, 2437 struct gl_texture_object *tObj, 2438 GLuint cubeMapFace) 2439 { 2440 struct st_context *st = st_context(ctx); 2441 struct st_texture_object *stObj = st_texture_object(tObj); 2442 const GLuint nr_faces = _mesa_num_tex_faces(stObj->base.Target); 2443 GLuint face; 2444 const struct st_texture_image *firstImage; 2445 enum pipe_format firstImageFormat; 2446 GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples; 2447 2448 if (tObj->Immutable) 2449 return GL_TRUE; 2450 2451 if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) { 2452 /* The texture is complete and we know exactly how many mipmap levels 2453 * are present/needed. This is conditional because we may be called 2454 * from the st_generate_mipmap() function when the texture object is 2455 * incomplete. In that case, we'll have set stObj->lastLevel before 2456 * we get here. 2457 */ 2458 if (stObj->base.Sampler.MinFilter == GL_LINEAR || 2459 stObj->base.Sampler.MinFilter == GL_NEAREST) 2460 stObj->lastLevel = stObj->base.BaseLevel; 2461 else 2462 stObj->lastLevel = stObj->base._MaxLevel; 2463 } 2464 2465 if (tObj->Target == GL_TEXTURE_BUFFER) { 2466 struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject); 2467 2468 if (!st_obj) { 2469 pipe_resource_reference(&stObj->pt, NULL); 2470 st_texture_release_all_sampler_views(st, stObj); 2471 return GL_TRUE; 2472 } 2473 2474 if (st_obj->buffer != stObj->pt) { 2475 pipe_resource_reference(&stObj->pt, st_obj->buffer); 2476 st_texture_release_all_sampler_views(st, stObj); 2477 } 2478 return GL_TRUE; 2479 2480 } 2481 2482 firstImage = st_texture_image_const(stObj->base.Image[cubeMapFace][stObj->base.BaseLevel]); 2483 assert(firstImage); 2484 2485 /* If both firstImage and stObj point to a texture which can contain 2486 * all active images, favour firstImage. Note that because of the 2487 * completeness requirement, we know that the image dimensions 2488 * will match. 2489 */ 2490 if (firstImage->pt && 2491 firstImage->pt != stObj->pt && 2492 (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) { 2493 pipe_resource_reference(&stObj->pt, firstImage->pt); 2494 st_texture_release_all_sampler_views(st, stObj); 2495 } 2496 2497 /* If this texture comes from a window system, there is nothing else to do. */ 2498 if (stObj->surface_based) { 2499 return GL_TRUE; 2500 } 2501 2502 /* Find gallium format for the Mesa texture */ 2503 firstImageFormat = 2504 st_mesa_format_to_pipe_format(st, firstImage->base.TexFormat); 2505 2506 /* Find size of level=0 Gallium mipmap image, plus number of texture layers */ 2507 { 2508 GLuint width, height, depth; 2509 2510 st_gl_texture_dims_to_pipe_dims(stObj->base.Target, 2511 firstImage->base.Width2, 2512 firstImage->base.Height2, 2513 firstImage->base.Depth2, 2514 &width, &height, &depth, &ptLayers); 2515 2516 /* If we previously allocated a pipe texture and its sizes are 2517 * compatible, use them. 2518 */ 2519 if (stObj->pt && 2520 u_minify(stObj->pt->width0, firstImage->base.Level) == width && 2521 u_minify(stObj->pt->height0, firstImage->base.Level) == height && 2522 u_minify(stObj->pt->depth0, firstImage->base.Level) == depth) { 2523 ptWidth = stObj->pt->width0; 2524 ptHeight = stObj->pt->height0; 2525 ptDepth = stObj->pt->depth0; 2526 } else { 2527 /* Otherwise, compute a new level=0 size that is compatible with the 2528 * base level image. 2529 */ 2530 ptWidth = width > 1 ? width << firstImage->base.Level : 1; 2531 ptHeight = height > 1 ? height << firstImage->base.Level : 1; 2532 ptDepth = depth > 1 ? depth << firstImage->base.Level : 1; 2533 2534 /* If the base level image is 1x1x1, we still need to ensure that the 2535 * resulting pipe texture ends up with the required number of levels 2536 * in total. 2537 */ 2538 if (ptWidth == 1 && ptHeight == 1 && ptDepth == 1) { 2539 ptWidth <<= firstImage->base.Level; 2540 2541 if (stObj->base.Target == GL_TEXTURE_CUBE_MAP || 2542 stObj->base.Target == GL_TEXTURE_CUBE_MAP_ARRAY) 2543 ptHeight = ptWidth; 2544 } 2545 } 2546 2547 ptNumSamples = firstImage->base.NumSamples; 2548 } 2549 2550 /* If we already have a gallium texture, check that it matches the texture 2551 * object's format, target, size, num_levels, etc. 2552 */ 2553 if (stObj->pt) { 2554 if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) || 2555 stObj->pt->format != firstImageFormat || 2556 stObj->pt->last_level < stObj->lastLevel || 2557 stObj->pt->width0 != ptWidth || 2558 stObj->pt->height0 != ptHeight || 2559 stObj->pt->depth0 != ptDepth || 2560 stObj->pt->nr_samples != ptNumSamples || 2561 stObj->pt->array_size != ptLayers) 2562 { 2563 /* The gallium texture does not match the Mesa texture so delete the 2564 * gallium texture now. We'll make a new one below. 2565 */ 2566 pipe_resource_reference(&stObj->pt, NULL); 2567 st_texture_release_all_sampler_views(st, stObj); 2568 st->dirty |= ST_NEW_FRAMEBUFFER; 2569 } 2570 } 2571 2572 /* May need to create a new gallium texture: 2573 */ 2574 if (!stObj->pt) { 2575 GLuint bindings = default_bindings(st, firstImageFormat); 2576 2577 stObj->pt = st_texture_create(st, 2578 gl_target_to_pipe(stObj->base.Target), 2579 firstImageFormat, 2580 stObj->lastLevel, 2581 ptWidth, 2582 ptHeight, 2583 ptDepth, 2584 ptLayers, ptNumSamples, 2585 bindings); 2586 2587 if (!stObj->pt) { 2588 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); 2589 return GL_FALSE; 2590 } 2591 } 2592 2593 /* Pull in any images not in the object's texture: 2594 */ 2595 for (face = 0; face < nr_faces; face++) { 2596 GLuint level; 2597 for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) { 2598 struct st_texture_image *stImage = 2599 st_texture_image(stObj->base.Image[face][level]); 2600 2601 /* Need to import images in main memory or held in other textures. 2602 */ 2603 if (stImage && stObj->pt != stImage->pt) { 2604 GLuint height; 2605 GLuint depth; 2606 2607 if (stObj->base.Target != GL_TEXTURE_1D_ARRAY) 2608 height = u_minify(ptHeight, level); 2609 else 2610 height = ptLayers; 2611 2612 if (stObj->base.Target == GL_TEXTURE_3D) 2613 depth = u_minify(ptDepth, level); 2614 else if (stObj->base.Target == GL_TEXTURE_CUBE_MAP) 2615 depth = 1; 2616 else 2617 depth = ptLayers; 2618 2619 if (level == 0 || 2620 (stImage->base.Width == u_minify(ptWidth, level) && 2621 stImage->base.Height == height && 2622 stImage->base.Depth == depth)) { 2623 /* src image fits expected dest mipmap level size */ 2624 copy_image_data_to_texture(st, stObj, level, stImage); 2625 } 2626 } 2627 } 2628 } 2629 2630 return GL_TRUE; 2631 } 2632 2633 2634 /** 2635 * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory 2636 * for a whole mipmap stack. 2637 */ 2638 static GLboolean 2639 st_AllocTextureStorage(struct gl_context *ctx, 2640 struct gl_texture_object *texObj, 2641 GLsizei levels, GLsizei width, 2642 GLsizei height, GLsizei depth) 2643 { 2644 const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); 2645 struct gl_texture_image *texImage = texObj->Image[0][0]; 2646 struct st_context *st = st_context(ctx); 2647 struct st_texture_object *stObj = st_texture_object(texObj); 2648 struct pipe_screen *screen = st->pipe->screen; 2649 GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings; 2650 enum pipe_format fmt; 2651 GLint level; 2652 GLuint num_samples = texImage->NumSamples; 2653 2654 assert(levels > 0); 2655 2656 stObj->lastLevel = levels - 1; 2657 2658 fmt = st_mesa_format_to_pipe_format(st, texImage->TexFormat); 2659 2660 bindings = default_bindings(st, fmt); 2661 2662 /* Raise the sample count if the requested one is unsupported. */ 2663 if (num_samples > 1) { 2664 boolean found = FALSE; 2665 2666 for (; num_samples <= ctx->Const.MaxSamples; num_samples++) { 2667 if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, 2668 num_samples, 2669 PIPE_BIND_SAMPLER_VIEW)) { 2670 /* Update the sample count in gl_texture_image as well. */ 2671 texImage->NumSamples = num_samples; 2672 found = TRUE; 2673 break; 2674 } 2675 } 2676 2677 if (!found) { 2678 return GL_FALSE; 2679 } 2680 } 2681 2682 st_gl_texture_dims_to_pipe_dims(texObj->Target, 2683 width, height, depth, 2684 &ptWidth, &ptHeight, &ptDepth, &ptLayers); 2685 2686 stObj->pt = st_texture_create(st, 2687 gl_target_to_pipe(texObj->Target), 2688 fmt, 2689 levels - 1, 2690 ptWidth, 2691 ptHeight, 2692 ptDepth, 2693 ptLayers, num_samples, 2694 bindings); 2695 if (!stObj->pt) 2696 return GL_FALSE; 2697 2698 /* Set image resource pointers */ 2699 for (level = 0; level < levels; level++) { 2700 GLuint face; 2701 for (face = 0; face < numFaces; face++) { 2702 struct st_texture_image *stImage = 2703 st_texture_image(texObj->Image[face][level]); 2704 pipe_resource_reference(&stImage->pt, stObj->pt); 2705 2706 etc_fallback_allocate(st, stImage); 2707 } 2708 } 2709 2710 return GL_TRUE; 2711 } 2712 2713 2714 static GLboolean 2715 st_TestProxyTexImage(struct gl_context *ctx, GLenum target, 2716 GLuint numLevels, GLint level, 2717 mesa_format format, GLuint numSamples, 2718 GLint width, GLint height, GLint depth) 2719 { 2720 struct st_context *st = st_context(ctx); 2721 struct pipe_context *pipe = st->pipe; 2722 2723 if (width == 0 || height == 0 || depth == 0) { 2724 /* zero-sized images are legal, and always fit! */ 2725 return GL_TRUE; 2726 } 2727 2728 if (pipe->screen->can_create_resource) { 2729 /* Ask the gallium driver if the texture is too large */ 2730 struct gl_texture_object *texObj = 2731 _mesa_get_current_tex_object(ctx, target); 2732 struct pipe_resource pt; 2733 2734 /* Setup the pipe_resource object 2735 */ 2736 memset(&pt, 0, sizeof(pt)); 2737 2738 pt.target = gl_target_to_pipe(target); 2739 pt.format = st_mesa_format_to_pipe_format(st, format); 2740 pt.nr_samples = numSamples; 2741 2742 st_gl_texture_dims_to_pipe_dims(target, 2743 width, height, depth, 2744 &pt.width0, &pt.height0, 2745 &pt.depth0, &pt.array_size); 2746 2747 if (numLevels > 0) { 2748 /* For immutable textures we know the final number of mip levels */ 2749 pt.last_level = numLevels - 1; 2750 } 2751 else if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR || 2752 texObj->Sampler.MinFilter == GL_NEAREST)) { 2753 /* assume just one mipmap level */ 2754 pt.last_level = 0; 2755 } 2756 else { 2757 /* assume a full set of mipmaps */ 2758 pt.last_level = _mesa_logbase2(MAX3(width, height, depth)); 2759 } 2760 2761 return pipe->screen->can_create_resource(pipe->screen, &pt); 2762 } 2763 else { 2764 /* Use core Mesa fallback */ 2765 return _mesa_test_proxy_teximage(ctx, target, numLevels, level, format, 2766 numSamples, width, height, depth); 2767 } 2768 } 2769 2770 static GLboolean 2771 st_TextureView(struct gl_context *ctx, 2772 struct gl_texture_object *texObj, 2773 struct gl_texture_object *origTexObj) 2774 { 2775 struct st_context *st = st_context(ctx); 2776 struct st_texture_object *orig = st_texture_object(origTexObj); 2777 struct st_texture_object *tex = st_texture_object(texObj); 2778 struct gl_texture_image *image = texObj->Image[0][0]; 2779 2780 const int numFaces = _mesa_num_tex_faces(texObj->Target); 2781 const int numLevels = texObj->NumLevels; 2782 2783 int face; 2784 int level; 2785 2786 pipe_resource_reference(&tex->pt, orig->pt); 2787 2788 /* Set image resource pointers */ 2789 for (level = 0; level < numLevels; level++) { 2790 for (face = 0; face < numFaces; face++) { 2791 struct st_texture_image *stImage = 2792 st_texture_image(texObj->Image[face][level]); 2793 pipe_resource_reference(&stImage->pt, tex->pt); 2794 } 2795 } 2796 2797 tex->surface_based = GL_TRUE; 2798 tex->surface_format = 2799 st_mesa_format_to_pipe_format(st_context(ctx), image->TexFormat); 2800 2801 tex->lastLevel = numLevels - 1; 2802 2803 /* free texture sampler views. They need to be recreated when we 2804 * change the texture view parameters. 2805 */ 2806 st_texture_release_all_sampler_views(st, tex); 2807 2808 return GL_TRUE; 2809 } 2810 2811 static void 2812 st_ClearTexSubImage(struct gl_context *ctx, 2813 struct gl_texture_image *texImage, 2814 GLint xoffset, GLint yoffset, GLint zoffset, 2815 GLsizei width, GLsizei height, GLsizei depth, 2816 const void *clearValue) 2817 { 2818 static const char zeros[16] = {0}; 2819 struct st_texture_image *stImage = st_texture_image(texImage); 2820 struct pipe_resource *pt = stImage->pt; 2821 struct st_context *st = st_context(ctx); 2822 struct pipe_context *pipe = st->pipe; 2823 unsigned level = texImage->Level; 2824 struct pipe_box box; 2825 2826 if (!pt) 2827 return; 2828 2829 st_flush_bitmap_cache(st); 2830 st_invalidate_readpix_cache(st); 2831 2832 u_box_3d(xoffset, yoffset, zoffset + texImage->Face, 2833 width, height, depth, &box); 2834 if (texImage->TexObject->Immutable) { 2835 level += texImage->TexObject->MinLevel; 2836 box.z += texImage->TexObject->MinLayer; 2837 } 2838 2839 pipe->clear_texture(pipe, pt, level, &box, clearValue ? clearValue : zeros); 2840 } 2841 2842 2843 /** 2844 * Called via the glTexParam*() function, but only when some texture object 2845 * state has actually changed. 2846 */ 2847 static void 2848 st_TexParameter(struct gl_context *ctx, 2849 struct gl_texture_object *texObj, GLenum pname) 2850 { 2851 struct st_context *st = st_context(ctx); 2852 struct st_texture_object *stObj = st_texture_object(texObj); 2853 2854 switch (pname) { 2855 case GL_TEXTURE_BASE_LEVEL: 2856 case GL_TEXTURE_MAX_LEVEL: 2857 case GL_DEPTH_TEXTURE_MODE: 2858 case GL_DEPTH_STENCIL_TEXTURE_MODE: 2859 case GL_TEXTURE_SRGB_DECODE_EXT: 2860 case GL_TEXTURE_SWIZZLE_R: 2861 case GL_TEXTURE_SWIZZLE_G: 2862 case GL_TEXTURE_SWIZZLE_B: 2863 case GL_TEXTURE_SWIZZLE_A: 2864 case GL_TEXTURE_SWIZZLE_RGBA: 2865 case GL_TEXTURE_BUFFER_SIZE: 2866 case GL_TEXTURE_BUFFER_OFFSET: 2867 /* changing any of these texture parameters means we must create 2868 * new sampler views. 2869 */ 2870 st_texture_release_all_sampler_views(st, stObj); 2871 break; 2872 default: 2873 ; /* nothing */ 2874 } 2875 } 2876 2877 2878 void 2879 st_init_texture_functions(struct dd_function_table *functions) 2880 { 2881 functions->ChooseTextureFormat = st_ChooseTextureFormat; 2882 functions->QueryInternalFormat = st_QueryInternalFormat; 2883 functions->TexImage = st_TexImage; 2884 functions->TexSubImage = st_TexSubImage; 2885 functions->CompressedTexSubImage = st_CompressedTexSubImage; 2886 functions->CopyTexSubImage = st_CopyTexSubImage; 2887 functions->GenerateMipmap = st_generate_mipmap; 2888 2889 functions->GetTexSubImage = st_GetTexSubImage; 2890 2891 /* compressed texture functions */ 2892 functions->CompressedTexImage = st_CompressedTexImage; 2893 functions->GetCompressedTexSubImage = _mesa_GetCompressedTexSubImage_sw; 2894 2895 functions->NewTextureObject = st_NewTextureObject; 2896 functions->NewTextureImage = st_NewTextureImage; 2897 functions->DeleteTextureImage = st_DeleteTextureImage; 2898 functions->DeleteTexture = st_DeleteTextureObject; 2899 functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer; 2900 functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer; 2901 functions->MapTextureImage = st_MapTextureImage; 2902 functions->UnmapTextureImage = st_UnmapTextureImage; 2903 2904 /* XXX Temporary until we can query pipe's texture sizes */ 2905 functions->TestProxyTexImage = st_TestProxyTexImage; 2906 2907 functions->AllocTextureStorage = st_AllocTextureStorage; 2908 functions->TextureView = st_TextureView; 2909 functions->ClearTexSubImage = st_ClearTexSubImage; 2910 2911 functions->TexParameter = st_TexParameter; 2912 } 2913
