st_cb_texture.c revision a710c21ac200fc1c80a6209862e837f0a75f4cc5
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 81enum pipe_texture_target 82gl_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() */ 130static struct gl_texture_image * 131st_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() */ 140static void 141st_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() */ 149static struct gl_texture_object * 150st_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() */ 161static void 162st_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() */ 176static void 177st_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 205bool 206st_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 212static void 213etc_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() */ 233static void 234st_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() */ 290static void 291st_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 */ 333static GLuint 334default_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 */ 368static GLboolean 369guess_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 */ 446static boolean 447allocate_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 */ 492static GLboolean 493guess_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 */ 592static GLboolean 593st_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 */ 676static void 677prep_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 */ 711unsigned 712st_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 */ 756static enum pipe_format 757unswizzle_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 */ 783static enum pipe_format 784alpha_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 */ 823static enum pipe_format 824red_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 */ 863static enum pipe_format 864luminance_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 */ 903static bool 904format_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 */ 921static bool 922format_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 */ 940static bool 941format_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 */ 958static bool 959format_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 973static bool 974format_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 987struct format_table 988{ 989 unsigned char swizzle[4]; 990 enum pipe_format format; 991}; 992 993static 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 1000static 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 1005static 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 1010static 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 1015static enum pipe_format 1016swizzle_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 1074static bool 1075reinterpret_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 1131static bool 1132try_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 1142 /* Create fragment shader */ 1143 if (!st->pbo.upload_fs) { 1144 st->pbo.upload_fs = st_pbo_create_upload_fs(st); 1145 if (!st->pbo.upload_fs) 1146 return false; 1147 } 1148 1149 cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS | 1150 CSO_BIT_FRAGMENT_SAMPLERS | 1151 CSO_BIT_VERTEX_ELEMENTS | 1152 CSO_BIT_AUX_VERTEX_BUFFER_SLOT | 1153 CSO_BIT_FRAMEBUFFER | 1154 CSO_BIT_VIEWPORT | 1155 CSO_BIT_BLEND | 1156 CSO_BIT_DEPTH_STENCIL_ALPHA | 1157 CSO_BIT_RASTERIZER | 1158 CSO_BIT_STREAM_OUTPUTS | 1159 CSO_BIT_PAUSE_QUERIES | 1160 CSO_BITS_ALL_SHADERS)); 1161 cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT); 1162 1163 1164 /* Set up the sampler_view */ 1165 { 1166 struct pipe_sampler_view templ; 1167 struct pipe_sampler_view *sampler_view; 1168 struct pipe_sampler_state sampler = {0}; 1169 const struct pipe_sampler_state *samplers[1] = {&sampler}; 1170 1171 memset(&templ, 0, sizeof(templ)); 1172 templ.target = PIPE_BUFFER; 1173 templ.format = src_format; 1174 templ.u.buf.offset = addr->first_element * addr->bytes_per_pixel; 1175 templ.u.buf.size = (addr->last_element - addr->first_element + 1) * 1176 addr->bytes_per_pixel; 1177 templ.swizzle_r = PIPE_SWIZZLE_X; 1178 templ.swizzle_g = PIPE_SWIZZLE_Y; 1179 templ.swizzle_b = PIPE_SWIZZLE_Z; 1180 templ.swizzle_a = PIPE_SWIZZLE_W; 1181 1182 sampler_view = pipe->create_sampler_view(pipe, addr->buffer, &templ); 1183 if (sampler_view == NULL) 1184 goto fail; 1185 1186 cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view); 1187 1188 pipe_sampler_view_reference(&sampler_view, NULL); 1189 1190 cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers); 1191 } 1192 1193 /* Framebuffer_state */ 1194 { 1195 struct pipe_framebuffer_state fb; 1196 memset(&fb, 0, sizeof(fb)); 1197 fb.width = surface->width; 1198 fb.height = surface->height; 1199 fb.nr_cbufs = 1; 1200 pipe_surface_reference(&fb.cbufs[0], surface); 1201 1202 cso_set_framebuffer(cso, &fb); 1203 1204 pipe_surface_reference(&fb.cbufs[0], NULL); 1205 } 1206 1207 cso_set_viewport_dims(cso, surface->width, surface->height, FALSE); 1208 1209 /* Blend state */ 1210 cso_set_blend(cso, &st->pbo.upload_blend); 1211 1212 /* Depth/stencil/alpha state */ 1213 { 1214 struct pipe_depth_stencil_alpha_state dsa; 1215 memset(&dsa, 0, sizeof(dsa)); 1216 cso_set_depth_stencil_alpha(cso, &dsa); 1217 } 1218 1219 /* Set up the fragment shader */ 1220 cso_set_fragment_shader_handle(cso, st->pbo.upload_fs); 1221 1222 success = st_pbo_draw(st, addr, surface->width, surface->height); 1223 1224fail: 1225 cso_restore_state(cso); 1226 cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT); 1227 1228 return success; 1229} 1230 1231static bool 1232try_pbo_upload(struct gl_context *ctx, GLuint dims, 1233 struct gl_texture_image *texImage, 1234 GLenum format, GLenum type, 1235 enum pipe_format dst_format, 1236 GLint xoffset, GLint yoffset, GLint zoffset, 1237 GLint width, GLint height, GLint depth, 1238 const void *pixels, 1239 const struct gl_pixelstore_attrib *unpack) 1240{ 1241 struct st_context *st = st_context(ctx); 1242 struct st_texture_image *stImage = st_texture_image(texImage); 1243 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1244 struct pipe_resource *texture = stImage->pt; 1245 struct pipe_context *pipe = st->pipe; 1246 struct pipe_screen *screen = pipe->screen; 1247 struct pipe_surface *surface = NULL; 1248 struct st_pbo_addresses addr; 1249 enum pipe_format src_format; 1250 const struct util_format_description *desc; 1251 GLenum gl_target = texImage->TexObject->Target; 1252 bool success; 1253 1254 if (!st->pbo.upload_enabled) 1255 return false; 1256 1257 /* From now on, we need the gallium representation of dimensions. */ 1258 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1259 depth = height; 1260 height = 1; 1261 zoffset = yoffset; 1262 yoffset = 0; 1263 } 1264 1265 if (depth != 1 && !st->pbo.layers) 1266 return false; 1267 1268 /* Choose the source format. Initially, we do so without checking driver 1269 * support at all because of the remapping we later perform and because 1270 * at least the Radeon driver actually supports some formats for texture 1271 * buffers which it doesn't support for regular textures. */ 1272 src_format = st_choose_matching_format(st, 0, format, type, unpack->SwapBytes); 1273 if (!src_format) { 1274 return false; 1275 } 1276 1277 src_format = util_format_linear(src_format); 1278 desc = util_format_description(src_format); 1279 1280 if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) 1281 return false; 1282 1283 if (desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB) 1284 return false; 1285 1286 if (st->pbo.rgba_only) { 1287 enum pipe_format orig_dst_format = dst_format; 1288 1289 if (!reinterpret_formats(&src_format, &dst_format)) { 1290 return false; 1291 } 1292 1293 if (dst_format != orig_dst_format && 1294 !screen->is_format_supported(screen, dst_format, PIPE_TEXTURE_2D, 0, 1295 PIPE_BIND_RENDER_TARGET)) { 1296 return false; 1297 } 1298 } 1299 1300 if (!src_format || 1301 !screen->is_format_supported(screen, src_format, PIPE_BUFFER, 0, 1302 PIPE_BIND_SAMPLER_VIEW)) { 1303 return false; 1304 } 1305 1306 /* Compute buffer addresses */ 1307 addr.xoffset = xoffset; 1308 addr.yoffset = yoffset; 1309 addr.width = width; 1310 addr.height = height; 1311 addr.depth = depth; 1312 addr.bytes_per_pixel = desc->block.bits / 8; 1313 1314 if (!st_pbo_addresses_pixelstore(st, gl_target, dims == 3, unpack, pixels, 1315 &addr)) 1316 return false; 1317 1318 /* Set up the surface */ 1319 { 1320 unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; 1321 unsigned max_layer = util_max_layer(texture, level); 1322 1323 zoffset += texImage->Face + texImage->TexObject->MinLayer; 1324 1325 struct pipe_surface templ; 1326 memset(&templ, 0, sizeof(templ)); 1327 templ.format = dst_format; 1328 templ.u.tex.level = level; 1329 templ.u.tex.first_layer = MIN2(zoffset, max_layer); 1330 templ.u.tex.last_layer = MIN2(zoffset + depth - 1, max_layer); 1331 1332 surface = pipe->create_surface(pipe, texture, &templ); 1333 if (!surface) 1334 return false; 1335 } 1336 1337 success = try_pbo_upload_common(ctx, surface, &addr, src_format); 1338 1339 pipe_surface_reference(&surface, NULL); 1340 1341 return success; 1342} 1343 1344static void 1345st_TexSubImage(struct gl_context *ctx, GLuint dims, 1346 struct gl_texture_image *texImage, 1347 GLint xoffset, GLint yoffset, GLint zoffset, 1348 GLint width, GLint height, GLint depth, 1349 GLenum format, GLenum type, const void *pixels, 1350 const struct gl_pixelstore_attrib *unpack) 1351{ 1352 struct st_context *st = st_context(ctx); 1353 struct st_texture_image *stImage = st_texture_image(texImage); 1354 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1355 struct pipe_context *pipe = st->pipe; 1356 struct pipe_screen *screen = pipe->screen; 1357 struct pipe_resource *dst = stImage->pt; 1358 struct pipe_resource *src = NULL; 1359 struct pipe_resource src_templ; 1360 struct pipe_transfer *transfer; 1361 struct pipe_blit_info blit; 1362 enum pipe_format src_format, dst_format; 1363 mesa_format mesa_src_format; 1364 GLenum gl_target = texImage->TexObject->Target; 1365 unsigned bind; 1366 GLubyte *map; 1367 unsigned dstz = texImage->Face + texImage->TexObject->MinLayer; 1368 unsigned dst_level = 0; 1369 1370 st_flush_bitmap_cache(st); 1371 st_invalidate_readpix_cache(st); 1372 1373 if (stObj->pt == stImage->pt) 1374 dst_level = texImage->TexObject->MinLevel + texImage->Level; 1375 1376 assert(!_mesa_is_format_etc2(texImage->TexFormat) && 1377 texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); 1378 1379 if (!dst) 1380 goto fallback; 1381 1382 /* Try texture_subdata, which should be the fastest memcpy path. */ 1383 if (pixels && 1384 !_mesa_is_bufferobj(unpack->BufferObj) && 1385 _mesa_texstore_can_use_memcpy(ctx, texImage->_BaseFormat, 1386 texImage->TexFormat, format, type, 1387 unpack)) { 1388 struct pipe_box box; 1389 unsigned stride, layer_stride; 1390 void *data; 1391 1392 stride = _mesa_image_row_stride(unpack, width, format, type); 1393 layer_stride = _mesa_image_image_stride(unpack, width, height, format, 1394 type); 1395 data = _mesa_image_address(dims, unpack, pixels, width, height, format, 1396 type, 0, 0, 0); 1397 1398 /* Convert to Gallium coordinates. */ 1399 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1400 zoffset = yoffset; 1401 yoffset = 0; 1402 depth = height; 1403 height = 1; 1404 layer_stride = stride; 1405 } 1406 1407 u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box); 1408 pipe->texture_subdata(pipe, dst, dst_level, 0, 1409 &box, data, stride, layer_stride); 1410 return; 1411 } 1412 1413 if (!st->prefer_blit_based_texture_transfer) { 1414 goto fallback; 1415 } 1416 1417 /* XXX Fallback for depth-stencil formats due to an incomplete stencil 1418 * blit implementation in some drivers. */ 1419 if (format == GL_DEPTH_STENCIL) { 1420 goto fallback; 1421 } 1422 1423 /* If the base internal format and the texture format don't match, 1424 * we can't use blit-based TexSubImage. */ 1425 if (texImage->_BaseFormat != 1426 _mesa_get_format_base_format(texImage->TexFormat)) { 1427 goto fallback; 1428 } 1429 1430 1431 /* See if the destination format is supported. */ 1432 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) 1433 bind = PIPE_BIND_DEPTH_STENCIL; 1434 else 1435 bind = PIPE_BIND_RENDER_TARGET; 1436 1437 /* For luminance and intensity, only the red channel is stored 1438 * in the destination. */ 1439 dst_format = util_format_linear(dst->format); 1440 dst_format = util_format_luminance_to_red(dst_format); 1441 dst_format = util_format_intensity_to_red(dst_format); 1442 1443 if (!dst_format || 1444 !screen->is_format_supported(screen, dst_format, dst->target, 1445 dst->nr_samples, bind)) { 1446 goto fallback; 1447 } 1448 1449 if (_mesa_is_bufferobj(unpack->BufferObj)) { 1450 if (try_pbo_upload(ctx, dims, texImage, format, type, dst_format, 1451 xoffset, yoffset, zoffset, 1452 width, height, depth, pixels, unpack)) 1453 return; 1454 } 1455 1456 /* See if the texture format already matches the format and type, 1457 * in which case the memcpy-based fast path will likely be used and 1458 * we don't have to blit. */ 1459 if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, 1460 type, unpack->SwapBytes, NULL)) { 1461 goto fallback; 1462 } 1463 1464 /* Choose the source format. */ 1465 src_format = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW, 1466 format, type, unpack->SwapBytes); 1467 if (!src_format) { 1468 goto fallback; 1469 } 1470 1471 mesa_src_format = st_pipe_format_to_mesa_format(src_format); 1472 1473 /* There is no reason to do this if we cannot use memcpy for the temporary 1474 * source texture at least. This also takes transfer ops into account, 1475 * etc. */ 1476 if (!_mesa_texstore_can_use_memcpy(ctx, 1477 _mesa_get_format_base_format(mesa_src_format), 1478 mesa_src_format, format, type, unpack)) { 1479 goto fallback; 1480 } 1481 1482 /* TexSubImage only sets a single cubemap face. */ 1483 if (gl_target == GL_TEXTURE_CUBE_MAP) { 1484 gl_target = GL_TEXTURE_2D; 1485 } 1486 /* TexSubImage can specify subsets of cube map array faces 1487 * so we need to upload via 2D array instead */ 1488 if (gl_target == GL_TEXTURE_CUBE_MAP_ARRAY) { 1489 gl_target = GL_TEXTURE_2D_ARRAY; 1490 } 1491 1492 /* Initialize the source texture description. */ 1493 memset(&src_templ, 0, sizeof(src_templ)); 1494 src_templ.target = gl_target_to_pipe(gl_target); 1495 src_templ.format = src_format; 1496 src_templ.bind = PIPE_BIND_SAMPLER_VIEW; 1497 src_templ.usage = PIPE_USAGE_STAGING; 1498 1499 st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, 1500 &src_templ.width0, &src_templ.height0, 1501 &src_templ.depth0, &src_templ.array_size); 1502 1503 /* Check for NPOT texture support. */ 1504 if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) && 1505 (!util_is_power_of_two(src_templ.width0) || 1506 !util_is_power_of_two(src_templ.height0) || 1507 !util_is_power_of_two(src_templ.depth0))) { 1508 goto fallback; 1509 } 1510 1511 /* Create the source texture. */ 1512 src = screen->resource_create(screen, &src_templ); 1513 if (!src) { 1514 goto fallback; 1515 } 1516 1517 /* Map source pixels. */ 1518 pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth, 1519 format, type, pixels, unpack, 1520 "glTexSubImage"); 1521 if (!pixels) { 1522 /* This is a GL error. */ 1523 pipe_resource_reference(&src, NULL); 1524 return; 1525 } 1526 1527 /* From now on, we need the gallium representation of dimensions. */ 1528 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1529 zoffset = yoffset; 1530 yoffset = 0; 1531 depth = height; 1532 height = 1; 1533 } 1534 1535 map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0, 1536 width, height, depth, &transfer); 1537 if (!map) { 1538 _mesa_unmap_teximage_pbo(ctx, unpack); 1539 pipe_resource_reference(&src, NULL); 1540 goto fallback; 1541 } 1542 1543 /* Upload pixels (just memcpy). */ 1544 { 1545 const uint bytesPerRow = width * util_format_get_blocksize(src_format); 1546 GLuint row, slice; 1547 1548 for (slice = 0; slice < (unsigned) depth; slice++) { 1549 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1550 /* 1D array textures. 1551 * We need to convert gallium coords to GL coords. 1552 */ 1553 void *src = _mesa_image_address2d(unpack, pixels, 1554 width, depth, format, 1555 type, slice, 0); 1556 memcpy(map, src, bytesPerRow); 1557 } 1558 else { 1559 ubyte *slice_map = map; 1560 1561 for (row = 0; row < (unsigned) height; row++) { 1562 void *src = _mesa_image_address(dims, unpack, pixels, 1563 width, height, format, 1564 type, slice, row, 0); 1565 memcpy(slice_map, src, bytesPerRow); 1566 slice_map += transfer->stride; 1567 } 1568 } 1569 map += transfer->layer_stride; 1570 } 1571 } 1572 1573 pipe_transfer_unmap(pipe, transfer); 1574 _mesa_unmap_teximage_pbo(ctx, unpack); 1575 1576 /* Blit. */ 1577 memset(&blit, 0, sizeof(blit)); 1578 blit.src.resource = src; 1579 blit.src.level = 0; 1580 blit.src.format = src_format; 1581 blit.dst.resource = dst; 1582 blit.dst.level = dst_level; 1583 blit.dst.format = dst_format; 1584 blit.src.box.x = blit.src.box.y = blit.src.box.z = 0; 1585 blit.dst.box.x = xoffset; 1586 blit.dst.box.y = yoffset; 1587 blit.dst.box.z = zoffset + dstz; 1588 blit.src.box.width = blit.dst.box.width = width; 1589 blit.src.box.height = blit.dst.box.height = height; 1590 blit.src.box.depth = blit.dst.box.depth = depth; 1591 blit.mask = st_get_blit_mask(format, texImage->_BaseFormat); 1592 blit.filter = PIPE_TEX_FILTER_NEAREST; 1593 blit.scissor_enable = FALSE; 1594 1595 st->pipe->blit(st->pipe, &blit); 1596 1597 pipe_resource_reference(&src, NULL); 1598 return; 1599 1600fallback: 1601 _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset, 1602 width, height, depth, format, type, pixels, 1603 unpack); 1604} 1605 1606static void 1607st_TexImage(struct gl_context * ctx, GLuint dims, 1608 struct gl_texture_image *texImage, 1609 GLenum format, GLenum type, const void *pixels, 1610 const struct gl_pixelstore_attrib *unpack) 1611{ 1612 assert(dims == 1 || dims == 2 || dims == 3); 1613 1614 prep_teximage(ctx, texImage, format, type); 1615 1616 if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0) 1617 return; 1618 1619 /* allocate storage for texture data */ 1620 if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) { 1621 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims); 1622 return; 1623 } 1624 1625 st_TexSubImage(ctx, dims, texImage, 0, 0, 0, 1626 texImage->Width, texImage->Height, texImage->Depth, 1627 format, type, pixels, unpack); 1628} 1629 1630 1631static void 1632st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims, 1633 struct gl_texture_image *texImage, 1634 GLint x, GLint y, GLint z, 1635 GLsizei w, GLsizei h, GLsizei d, 1636 GLenum format, GLsizei imageSize, const void *data) 1637{ 1638 struct st_context *st = st_context(ctx); 1639 struct st_texture_image *stImage = st_texture_image(texImage); 1640 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1641 struct pipe_resource *texture = stImage->pt; 1642 struct pipe_context *pipe = st->pipe; 1643 struct pipe_screen *screen = pipe->screen; 1644 struct pipe_resource *dst = stImage->pt; 1645 struct pipe_surface *surface = NULL; 1646 struct compressed_pixelstore store; 1647 struct st_pbo_addresses addr; 1648 enum pipe_format copy_format; 1649 unsigned bw, bh; 1650 intptr_t buf_offset; 1651 bool success = false; 1652 1653 /* Check basic pre-conditions for PBO upload */ 1654 if (!st->prefer_blit_based_texture_transfer) { 1655 goto fallback; 1656 } 1657 1658 if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj)) 1659 goto fallback; 1660 1661 if (st_etc_fallback(st, texImage)) { 1662 /* ETC isn't supported and is represented by uncompressed formats. */ 1663 goto fallback; 1664 } 1665 1666 if (!dst) { 1667 goto fallback; 1668 } 1669 1670 if (!st->pbo.upload_enabled || 1671 !screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) { 1672 goto fallback; 1673 } 1674 1675 /* Choose the pipe format for the upload. */ 1676 addr.bytes_per_pixel = util_format_get_blocksize(dst->format); 1677 bw = util_format_get_blockwidth(dst->format); 1678 bh = util_format_get_blockheight(dst->format); 1679 1680 switch (addr.bytes_per_pixel) { 1681 case 8: 1682 copy_format = PIPE_FORMAT_R16G16B16A16_UINT; 1683 break; 1684 case 16: 1685 copy_format = PIPE_FORMAT_R32G32B32A32_UINT; 1686 break; 1687 default: 1688 goto fallback; 1689 } 1690 1691 if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0, 1692 PIPE_BIND_SAMPLER_VIEW)) { 1693 goto fallback; 1694 } 1695 1696 if (!screen->is_format_supported(screen, copy_format, dst->target, 1697 dst->nr_samples, PIPE_BIND_RENDER_TARGET)) { 1698 goto fallback; 1699 } 1700 1701 /* Interpret the pixelstore settings. */ 1702 _mesa_compute_compressed_pixelstore(dims, texImage->TexFormat, w, h, d, 1703 &ctx->Unpack, &store); 1704 assert(store.CopyBytesPerRow % addr.bytes_per_pixel == 0); 1705 assert(store.SkipBytes % addr.bytes_per_pixel == 0); 1706 1707 /* Compute the offset into the buffer */ 1708 buf_offset = (intptr_t)data + store.SkipBytes; 1709 1710 if (buf_offset % addr.bytes_per_pixel) { 1711 goto fallback; 1712 } 1713 1714 buf_offset = buf_offset / addr.bytes_per_pixel; 1715 1716 addr.xoffset = x / bw; 1717 addr.yoffset = y / bh; 1718 addr.width = store.CopyBytesPerRow / addr.bytes_per_pixel; 1719 addr.height = store.CopyRowsPerSlice; 1720 addr.depth = d; 1721 addr.pixels_per_row = store.TotalBytesPerRow / addr.bytes_per_pixel; 1722 addr.image_height = store.TotalRowsPerSlice; 1723 1724 if (!st_pbo_addresses_setup(st, st_buffer_object(ctx->Unpack.BufferObj)->buffer, 1725 buf_offset, &addr)) 1726 goto fallback; 1727 1728 /* Set up the surface. */ 1729 { 1730 unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; 1731 unsigned max_layer = util_max_layer(texture, level); 1732 1733 z += texImage->Face + texImage->TexObject->MinLayer; 1734 1735 struct pipe_surface templ; 1736 memset(&templ, 0, sizeof(templ)); 1737 templ.format = copy_format; 1738 templ.u.tex.level = level; 1739 templ.u.tex.first_layer = MIN2(z, max_layer); 1740 templ.u.tex.last_layer = MIN2(z + d - 1, max_layer); 1741 1742 surface = pipe->create_surface(pipe, texture, &templ); 1743 if (!surface) 1744 goto fallback; 1745 } 1746 1747 success = try_pbo_upload_common(ctx, surface, &addr, copy_format); 1748 1749 pipe_surface_reference(&surface, NULL); 1750 1751 if (success) 1752 return; 1753 1754fallback: 1755 _mesa_store_compressed_texsubimage(ctx, dims, texImage, 1756 x, y, z, w, h, d, 1757 format, imageSize, data); 1758} 1759 1760static void 1761st_CompressedTexImage(struct gl_context *ctx, GLuint dims, 1762 struct gl_texture_image *texImage, 1763 GLsizei imageSize, const void *data) 1764{ 1765 prep_teximage(ctx, texImage, GL_NONE, GL_NONE); 1766 1767 /* only 2D and 3D compressed images are supported at this time */ 1768 if (dims == 1) { 1769 _mesa_problem(ctx, "Unexpected glCompressedTexImage1D call"); 1770 return; 1771 } 1772 1773 /* This is pretty simple, because unlike the general texstore path we don't 1774 * have to worry about the usual image unpacking or image transfer 1775 * operations. 1776 */ 1777 assert(texImage); 1778 assert(texImage->Width > 0); 1779 assert(texImage->Height > 0); 1780 assert(texImage->Depth > 0); 1781 1782 /* allocate storage for texture data */ 1783 if (!st_AllocTextureImageBuffer(ctx, texImage)) { 1784 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims); 1785 return; 1786 } 1787 1788 st_CompressedTexSubImage(ctx, dims, texImage, 1789 0, 0, 0, 1790 texImage->Width, texImage->Height, texImage->Depth, 1791 texImage->TexFormat, 1792 imageSize, data); 1793} 1794 1795 1796 1797 1798/** 1799 * Called via ctx->Driver.GetTexSubImage() 1800 * 1801 * This uses a blit to copy the texture to a texture format which matches 1802 * the format and type combo and then a fast read-back is done using memcpy. 1803 * We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is 1804 * a format which matches the swizzling. 1805 * 1806 * If such a format isn't available, it falls back to _mesa_GetTexImage_sw. 1807 * 1808 * NOTE: Drivers usually do a blit to convert between tiled and linear 1809 * texture layouts during texture uploads/downloads, so the blit 1810 * we do here should be free in such cases. 1811 */ 1812static void 1813st_GetTexSubImage(struct gl_context * ctx, 1814 GLint xoffset, GLint yoffset, GLint zoffset, 1815 GLsizei width, GLsizei height, GLint depth, 1816 GLenum format, GLenum type, void * pixels, 1817 struct gl_texture_image *texImage) 1818{ 1819 struct st_context *st = st_context(ctx); 1820 struct pipe_context *pipe = st->pipe; 1821 struct pipe_screen *screen = pipe->screen; 1822 struct st_texture_image *stImage = st_texture_image(texImage); 1823 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 1824 struct pipe_resource *src = stObj->pt; 1825 struct pipe_resource *dst = NULL; 1826 struct pipe_resource dst_templ; 1827 enum pipe_format dst_format, src_format; 1828 mesa_format mesa_format; 1829 GLenum gl_target = texImage->TexObject->Target; 1830 enum pipe_texture_target pipe_target; 1831 struct pipe_blit_info blit; 1832 unsigned bind; 1833 struct pipe_transfer *tex_xfer; 1834 ubyte *map = NULL; 1835 boolean done = FALSE; 1836 1837 assert(!_mesa_is_format_etc2(texImage->TexFormat) && 1838 texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); 1839 1840 st_flush_bitmap_cache(st); 1841 1842 if (!st->prefer_blit_based_texture_transfer && 1843 !_mesa_is_format_compressed(texImage->TexFormat)) { 1844 /* Try to avoid the fallback if we're doing texture decompression here */ 1845 goto fallback; 1846 } 1847 1848 /* Handle non-finalized textures. */ 1849 if (!stImage->pt || stImage->pt != stObj->pt || !src) { 1850 goto fallback; 1851 } 1852 1853 /* XXX Fallback to _mesa_GetTexImage_sw for depth-stencil formats 1854 * due to an incomplete stencil blit implementation in some drivers. */ 1855 if (format == GL_DEPTH_STENCIL || format == GL_STENCIL_INDEX) { 1856 goto fallback; 1857 } 1858 1859 /* If the base internal format and the texture format don't match, we have 1860 * to fall back to _mesa_GetTexImage_sw. */ 1861 if (texImage->_BaseFormat != 1862 _mesa_get_format_base_format(texImage->TexFormat)) { 1863 goto fallback; 1864 } 1865 1866 /* See if the texture format already matches the format and type, 1867 * in which case the memcpy-based fast path will be used. */ 1868 if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, 1869 type, ctx->Pack.SwapBytes, NULL)) { 1870 goto fallback; 1871 } 1872 1873 /* Convert the source format to what is expected by GetTexImage 1874 * and see if it's supported. 1875 * 1876 * This only applies to glGetTexImage: 1877 * - Luminance must be returned as (L,0,0,1). 1878 * - Luminance alpha must be returned as (L,0,0,A). 1879 * - Intensity must be returned as (I,0,0,1) 1880 */ 1881 if (stObj->surface_based) 1882 src_format = util_format_linear(stObj->surface_format); 1883 else 1884 src_format = util_format_linear(src->format); 1885 src_format = util_format_luminance_to_red(src_format); 1886 src_format = util_format_intensity_to_red(src_format); 1887 1888 if (!src_format || 1889 !screen->is_format_supported(screen, src_format, src->target, 1890 src->nr_samples, 1891 PIPE_BIND_SAMPLER_VIEW)) { 1892 goto fallback; 1893 } 1894 1895 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) 1896 bind = PIPE_BIND_DEPTH_STENCIL; 1897 else 1898 bind = PIPE_BIND_RENDER_TARGET; 1899 1900 /* GetTexImage only returns a single face for cubemaps. */ 1901 if (gl_target == GL_TEXTURE_CUBE_MAP) { 1902 gl_target = GL_TEXTURE_2D; 1903 } 1904 pipe_target = gl_target_to_pipe(gl_target); 1905 1906 /* Choose the destination format by finding the best match 1907 * for the format+type combo. */ 1908 dst_format = st_choose_matching_format(st, bind, format, type, 1909 ctx->Pack.SwapBytes); 1910 1911 if (dst_format == PIPE_FORMAT_NONE) { 1912 GLenum dst_glformat; 1913 1914 /* Fall back to _mesa_GetTexImage_sw except for compressed formats, 1915 * where decompression with a blit is always preferred. */ 1916 if (!util_format_is_compressed(src->format)) { 1917 goto fallback; 1918 } 1919 1920 /* Set the appropriate format for the decompressed texture. 1921 * Luminance and sRGB formats shouldn't appear here.*/ 1922 switch (src_format) { 1923 case PIPE_FORMAT_DXT1_RGB: 1924 case PIPE_FORMAT_DXT1_RGBA: 1925 case PIPE_FORMAT_DXT3_RGBA: 1926 case PIPE_FORMAT_DXT5_RGBA: 1927 case PIPE_FORMAT_RGTC1_UNORM: 1928 case PIPE_FORMAT_RGTC2_UNORM: 1929 case PIPE_FORMAT_ETC1_RGB8: 1930 case PIPE_FORMAT_BPTC_RGBA_UNORM: 1931 dst_glformat = GL_RGBA8; 1932 break; 1933 case PIPE_FORMAT_RGTC1_SNORM: 1934 case PIPE_FORMAT_RGTC2_SNORM: 1935 if (!ctx->Extensions.EXT_texture_snorm) 1936 goto fallback; 1937 dst_glformat = GL_RGBA8_SNORM; 1938 break; 1939 case PIPE_FORMAT_BPTC_RGB_FLOAT: 1940 case PIPE_FORMAT_BPTC_RGB_UFLOAT: 1941 if (!ctx->Extensions.ARB_texture_float) 1942 goto fallback; 1943 dst_glformat = GL_RGBA32F; 1944 break; 1945 default: 1946 assert(0); 1947 goto fallback; 1948 } 1949 1950 dst_format = st_choose_format(st, dst_glformat, format, type, 1951 pipe_target, 0, bind, FALSE); 1952 1953 if (dst_format == PIPE_FORMAT_NONE) { 1954 /* unable to get an rgba format!?! */ 1955 goto fallback; 1956 } 1957 } 1958 1959 /* create the destination texture of size (width X height X depth) */ 1960 memset(&dst_templ, 0, sizeof(dst_templ)); 1961 dst_templ.target = pipe_target; 1962 dst_templ.format = dst_format; 1963 dst_templ.bind = bind; 1964 dst_templ.usage = PIPE_USAGE_STAGING; 1965 1966 st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, 1967 &dst_templ.width0, &dst_templ.height0, 1968 &dst_templ.depth0, &dst_templ.array_size); 1969 1970 dst = screen->resource_create(screen, &dst_templ); 1971 if (!dst) { 1972 goto fallback; 1973 } 1974 1975 /* From now on, we need the gallium representation of dimensions. */ 1976 if (gl_target == GL_TEXTURE_1D_ARRAY) { 1977 zoffset = yoffset; 1978 yoffset = 0; 1979 depth = height; 1980 height = 1; 1981 } 1982 1983 assert(texImage->Face == 0 || 1984 texImage->TexObject->MinLayer == 0 || 1985 zoffset == 0); 1986 1987 memset(&blit, 0, sizeof(blit)); 1988 blit.src.resource = src; 1989 blit.src.level = texImage->Level + texImage->TexObject->MinLevel; 1990 blit.src.format = src_format; 1991 blit.dst.resource = dst; 1992 blit.dst.level = 0; 1993 blit.dst.format = dst->format; 1994 blit.src.box.x = xoffset; 1995 blit.dst.box.x = 0; 1996 blit.src.box.y = yoffset; 1997 blit.dst.box.y = 0; 1998 blit.src.box.z = texImage->Face + texImage->TexObject->MinLayer + zoffset; 1999 blit.dst.box.z = 0; 2000 blit.src.box.width = blit.dst.box.width = width; 2001 blit.src.box.height = blit.dst.box.height = height; 2002 blit.src.box.depth = blit.dst.box.depth = depth; 2003 blit.mask = st_get_blit_mask(texImage->_BaseFormat, format); 2004 blit.filter = PIPE_TEX_FILTER_NEAREST; 2005 blit.scissor_enable = FALSE; 2006 2007 /* blit/render/decompress */ 2008 st->pipe->blit(st->pipe, &blit); 2009 2010 pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels); 2011 2012 map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ, 2013 0, 0, 0, width, height, depth, &tex_xfer); 2014 if (!map) { 2015 goto end; 2016 } 2017 2018 mesa_format = st_pipe_format_to_mesa_format(dst_format); 2019 2020 /* copy/pack data into user buffer */ 2021 if (_mesa_format_matches_format_and_type(mesa_format, format, type, 2022 ctx->Pack.SwapBytes, NULL)) { 2023 /* memcpy */ 2024 const uint bytesPerRow = width * util_format_get_blocksize(dst_format); 2025 GLuint row, slice; 2026 2027 for (slice = 0; slice < depth; slice++) { 2028 if (gl_target == GL_TEXTURE_1D_ARRAY) { 2029 /* 1D array textures. 2030 * We need to convert gallium coords to GL coords. 2031 */ 2032 void *dest = _mesa_image_address3d(&ctx->Pack, pixels, 2033 width, depth, format, 2034 type, 0, slice, 0); 2035 memcpy(dest, map, bytesPerRow); 2036 } 2037 else { 2038 ubyte *slice_map = map; 2039 2040 for (row = 0; row < height; row++) { 2041 void *dest = _mesa_image_address3d(&ctx->Pack, pixels, 2042 width, height, format, 2043 type, slice, row, 0); 2044 memcpy(dest, slice_map, bytesPerRow); 2045 slice_map += tex_xfer->stride; 2046 } 2047 } 2048 map += tex_xfer->layer_stride; 2049 } 2050 } 2051 else { 2052 /* format translation via floats */ 2053 GLuint row, slice; 2054 GLfloat *rgba; 2055 uint32_t dstMesaFormat; 2056 int dstStride, srcStride; 2057 2058 assert(util_format_is_compressed(src->format)); 2059 2060 rgba = malloc(width * 4 * sizeof(GLfloat)); 2061 if (!rgba) { 2062 goto end; 2063 } 2064 2065 if (ST_DEBUG & DEBUG_FALLBACK) 2066 debug_printf("%s: fallback format translation\n", __func__); 2067 2068 dstMesaFormat = _mesa_format_from_format_and_type(format, type); 2069 dstStride = _mesa_image_row_stride(&ctx->Pack, width, format, type); 2070 srcStride = 4 * width * sizeof(GLfloat); 2071 for (slice = 0; slice < depth; slice++) { 2072 if (gl_target == GL_TEXTURE_1D_ARRAY) { 2073 /* 1D array textures. 2074 * We need to convert gallium coords to GL coords. 2075 */ 2076 void *dest = _mesa_image_address3d(&ctx->Pack, pixels, 2077 width, depth, format, 2078 type, 0, slice, 0); 2079 2080 /* get float[4] rgba row from surface */ 2081 pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1, 2082 dst_format, rgba); 2083 2084 _mesa_format_convert(dest, dstMesaFormat, dstStride, 2085 rgba, RGBA32_FLOAT, srcStride, 2086 width, 1, NULL); 2087 } 2088 else { 2089 for (row = 0; row < height; row++) { 2090 void *dest = _mesa_image_address3d(&ctx->Pack, pixels, 2091 width, height, format, 2092 type, slice, row, 0); 2093 2094 /* get float[4] rgba row from surface */ 2095 pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1, 2096 dst_format, rgba); 2097 2098 _mesa_format_convert(dest, dstMesaFormat, dstStride, 2099 rgba, RGBA32_FLOAT, srcStride, 2100 width, 1, NULL); 2101 } 2102 } 2103 map += tex_xfer->layer_stride; 2104 } 2105 2106 free(rgba); 2107 } 2108 done = TRUE; 2109 2110end: 2111 if (map) 2112 pipe_transfer_unmap(pipe, tex_xfer); 2113 2114 _mesa_unmap_pbo_dest(ctx, &ctx->Pack); 2115 pipe_resource_reference(&dst, NULL); 2116 2117fallback: 2118 if (!done) { 2119 _mesa_GetTexSubImage_sw(ctx, xoffset, yoffset, zoffset, 2120 width, height, depth, 2121 format, type, pixels, texImage); 2122 } 2123} 2124 2125 2126/** 2127 * Do a CopyTexSubImage operation using a read transfer from the source, 2128 * a write transfer to the destination and get_tile()/put_tile() to access 2129 * the pixels/texels. 2130 * 2131 * Note: srcY=0=TOP of renderbuffer 2132 */ 2133static void 2134fallback_copy_texsubimage(struct gl_context *ctx, 2135 struct st_renderbuffer *strb, 2136 struct st_texture_image *stImage, 2137 GLenum baseFormat, 2138 GLint destX, GLint destY, GLint slice, 2139 GLint srcX, GLint srcY, 2140 GLsizei width, GLsizei height) 2141{ 2142 struct st_context *st = st_context(ctx); 2143 struct pipe_context *pipe = st->pipe; 2144 struct pipe_transfer *src_trans; 2145 GLubyte *texDest; 2146 enum pipe_transfer_usage transfer_usage; 2147 void *map; 2148 unsigned dst_width = width; 2149 unsigned dst_height = height; 2150 unsigned dst_depth = 1; 2151 struct pipe_transfer *transfer; 2152 2153 if (ST_DEBUG & DEBUG_FALLBACK) 2154 debug_printf("%s: fallback processing\n", __func__); 2155 2156 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { 2157 srcY = strb->Base.Height - srcY - height; 2158 } 2159 2160 map = pipe_transfer_map(pipe, 2161 strb->texture, 2162 strb->surface->u.tex.level, 2163 strb->surface->u.tex.first_layer, 2164 PIPE_TRANSFER_READ, 2165 srcX, srcY, 2166 width, height, &src_trans); 2167 2168 if ((baseFormat == GL_DEPTH_COMPONENT || 2169 baseFormat == GL_DEPTH_STENCIL) && 2170 util_format_is_depth_and_stencil(stImage->pt->format)) 2171 transfer_usage = PIPE_TRANSFER_READ_WRITE; 2172 else 2173 transfer_usage = PIPE_TRANSFER_WRITE; 2174 2175 texDest = st_texture_image_map(st, stImage, transfer_usage, 2176 destX, destY, slice, 2177 dst_width, dst_height, dst_depth, 2178 &transfer); 2179 2180 if (baseFormat == GL_DEPTH_COMPONENT || 2181 baseFormat == GL_DEPTH_STENCIL) { 2182 const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F || 2183 ctx->Pixel.DepthBias != 0.0F); 2184 GLint row, yStep; 2185 uint *data; 2186 2187 /* determine bottom-to-top vs. top-to-bottom order for src buffer */ 2188 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { 2189 srcY = height - 1; 2190 yStep = -1; 2191 } 2192 else { 2193 srcY = 0; 2194 yStep = 1; 2195 } 2196 2197 data = malloc(width * sizeof(uint)); 2198 2199 if (data) { 2200 /* To avoid a large temp memory allocation, do copy row by row */ 2201 for (row = 0; row < height; row++, srcY += yStep) { 2202 pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data); 2203 if (scaleOrBias) { 2204 _mesa_scale_and_bias_depth_uint(ctx, width, data); 2205 } 2206 2207 if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { 2208 pipe_put_tile_z(transfer, texDest + row*transfer->layer_stride, 2209 0, 0, width, 1, data); 2210 } 2211 else { 2212 pipe_put_tile_z(transfer, texDest, 0, row, width, 1, data); 2213 } 2214 } 2215 } 2216 else { 2217 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()"); 2218 } 2219 2220 free(data); 2221 } 2222 else { 2223 /* RGBA format */ 2224 GLfloat *tempSrc = 2225 malloc(width * height * 4 * sizeof(GLfloat)); 2226 2227 if (tempSrc && texDest) { 2228 const GLint dims = 2; 2229 GLint dstRowStride; 2230 struct gl_texture_image *texImage = &stImage->base; 2231 struct gl_pixelstore_attrib unpack = ctx->DefaultPacking; 2232 2233 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { 2234 unpack.Invert = GL_TRUE; 2235 } 2236 2237 if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { 2238 dstRowStride = transfer->layer_stride; 2239 } 2240 else { 2241 dstRowStride = transfer->stride; 2242 } 2243 2244 /* get float/RGBA image from framebuffer */ 2245 /* XXX this usually involves a lot of int/float conversion. 2246 * try to avoid that someday. 2247 */ 2248 pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height, 2249 util_format_linear(strb->texture->format), 2250 tempSrc); 2251 2252 /* Store into texture memory. 2253 * Note that this does some special things such as pixel transfer 2254 * ops and format conversion. In particular, if the dest tex format 2255 * is actually RGBA but the user created the texture as GL_RGB we 2256 * need to fill-in/override the alpha channel with 1.0. 2257 */ 2258 _mesa_texstore(ctx, dims, 2259 texImage->_BaseFormat, 2260 texImage->TexFormat, 2261 dstRowStride, 2262 &texDest, 2263 width, height, 1, 2264 GL_RGBA, GL_FLOAT, tempSrc, /* src */ 2265 &unpack); 2266 } 2267 else { 2268 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage"); 2269 } 2270 2271 free(tempSrc); 2272 } 2273 2274 st_texture_image_unmap(st, stImage, slice); 2275 pipe->transfer_unmap(pipe, src_trans); 2276} 2277 2278 2279/** 2280 * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible. 2281 * Note that the region to copy has already been clipped so we know we 2282 * won't read from outside the source renderbuffer's bounds. 2283 * 2284 * Note: srcY=0=Bottom of renderbuffer (GL convention) 2285 */ 2286static void 2287st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, 2288 struct gl_texture_image *texImage, 2289 GLint destX, GLint destY, GLint slice, 2290 struct gl_renderbuffer *rb, 2291 GLint srcX, GLint srcY, GLsizei width, GLsizei height) 2292{ 2293 struct st_texture_image *stImage = st_texture_image(texImage); 2294 struct st_texture_object *stObj = st_texture_object(texImage->TexObject); 2295 struct st_renderbuffer *strb = st_renderbuffer(rb); 2296 struct st_context *st = st_context(ctx); 2297 struct pipe_context *pipe = st->pipe; 2298 struct pipe_screen *screen = pipe->screen; 2299 struct pipe_blit_info blit; 2300 enum pipe_format dst_format; 2301 GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP); 2302 unsigned bind; 2303 GLint srcY0, srcY1; 2304 2305 st_flush_bitmap_cache(st); 2306 st_invalidate_readpix_cache(st); 2307 2308 assert(!_mesa_is_format_etc2(texImage->TexFormat) && 2309 texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); 2310 2311 if (!strb || !strb->surface || !stImage->pt) { 2312 debug_printf("%s: null strb or stImage\n", __func__); 2313 return; 2314 } 2315 2316 if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat, 2317 texImage->TexFormat)) { 2318 goto fallback; 2319 } 2320 2321 /* The base internal format must match the mesa format, so make sure 2322 * e.g. an RGB internal format is really allocated as RGB and not as RGBA. 2323 */ 2324 if (texImage->_BaseFormat != 2325 _mesa_get_format_base_format(texImage->TexFormat) || 2326 rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) { 2327 goto fallback; 2328 } 2329 2330 /* Choose the destination format to match the TexImage behavior. */ 2331 dst_format = util_format_linear(stImage->pt->format); 2332 dst_format = util_format_luminance_to_red(dst_format); 2333 dst_format = util_format_intensity_to_red(dst_format); 2334 2335 /* See if the destination format is supported. */ 2336 if (texImage->_BaseFormat == GL_DEPTH_STENCIL || 2337 texImage->_BaseFormat == GL_DEPTH_COMPONENT) { 2338 bind = PIPE_BIND_DEPTH_STENCIL; 2339 } 2340 else { 2341 bind = PIPE_BIND_RENDER_TARGET; 2342 } 2343 2344 if (!dst_format || 2345 !screen->is_format_supported(screen, dst_format, stImage->pt->target, 2346 stImage->pt->nr_samples, bind)) { 2347 goto fallback; 2348 } 2349 2350 /* Y flipping for the main framebuffer. */ 2351 if (do_flip) { 2352 srcY1 = strb->Base.Height - srcY - height; 2353 srcY0 = srcY1 + height; 2354 } 2355 else { 2356 srcY0 = srcY; 2357 srcY1 = srcY0 + height; 2358 } 2359 2360 /* Blit the texture. 2361 * This supports flipping, format conversions, and downsampling. 2362 */ 2363 memset(&blit, 0, sizeof(blit)); 2364 blit.src.resource = strb->texture; 2365 blit.src.format = util_format_linear(strb->surface->format); 2366 blit.src.level = strb->surface->u.tex.level; 2367 blit.src.box.x = srcX; 2368 blit.src.box.y = srcY0; 2369 blit.src.box.z = strb->surface->u.tex.first_layer; 2370 blit.src.box.width = width; 2371 blit.src.box.height = srcY1 - srcY0; 2372 blit.src.box.depth = 1; 2373 blit.dst.resource = stImage->pt; 2374 blit.dst.format = dst_format; 2375 blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level + texImage->TexObject->MinLevel; 2376 blit.dst.box.x = destX; 2377 blit.dst.box.y = destY; 2378 blit.dst.box.z = stImage->base.Face + slice + texImage->TexObject->MinLayer; 2379 blit.dst.box.width = width; 2380 blit.dst.box.height = height; 2381 blit.dst.box.depth = 1; 2382 blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat); 2383 blit.filter = PIPE_TEX_FILTER_NEAREST; 2384 pipe->blit(pipe, &blit); 2385 return; 2386 2387fallback: 2388 /* software fallback */ 2389 fallback_copy_texsubimage(ctx, 2390 strb, stImage, texImage->_BaseFormat, 2391 destX, destY, slice, 2392 srcX, srcY, width, height); 2393} 2394 2395 2396/** 2397 * Copy image data from stImage into the texture object 'stObj' at level 2398 * 'dstLevel'. 2399 */ 2400static void 2401copy_image_data_to_texture(struct st_context *st, 2402 struct st_texture_object *stObj, 2403 GLuint dstLevel, 2404 struct st_texture_image *stImage) 2405{ 2406 /* debug checks */ 2407 { 2408 const struct gl_texture_image *dstImage = 2409 stObj->base.Image[stImage->base.Face][dstLevel]; 2410 assert(dstImage); 2411 assert(dstImage->Width == stImage->base.Width); 2412 assert(dstImage->Height == stImage->base.Height); 2413 assert(dstImage->Depth == stImage->base.Depth); 2414 } 2415 2416 if (stImage->pt) { 2417 /* Copy potentially with the blitter: 2418 */ 2419 GLuint src_level; 2420 if (stImage->pt->last_level == 0) 2421 src_level = 0; 2422 else 2423 src_level = stImage->base.Level; 2424 2425 assert(src_level <= stImage->pt->last_level); 2426 assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width); 2427 assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY || 2428 u_minify(stImage->pt->height0, src_level) == stImage->base.Height); 2429 assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY || 2430 stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY || 2431 u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth); 2432 2433 st_texture_image_copy(st->pipe, 2434 stObj->pt, dstLevel, /* dest texture, level */ 2435 stImage->pt, src_level, /* src texture, level */ 2436 stImage->base.Face); 2437 2438 pipe_resource_reference(&stImage->pt, NULL); 2439 } 2440 pipe_resource_reference(&stImage->pt, stObj->pt); 2441} 2442 2443 2444/** 2445 * Called during state validation. When this function is finished, 2446 * the texture object should be ready for rendering. 2447 * \return GL_TRUE for success, GL_FALSE for failure (out of mem) 2448 */ 2449GLboolean 2450st_finalize_texture(struct gl_context *ctx, 2451 struct pipe_context *pipe, 2452 struct gl_texture_object *tObj) 2453{ 2454 struct st_context *st = st_context(ctx); 2455 struct st_texture_object *stObj = st_texture_object(tObj); 2456 const GLuint nr_faces = _mesa_num_tex_faces(stObj->base.Target); 2457 GLuint face; 2458 const struct st_texture_image *firstImage; 2459 enum pipe_format firstImageFormat; 2460 GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples; 2461 2462 if (tObj->Immutable) 2463 return GL_TRUE; 2464 2465 if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) { 2466 /* The texture is complete and we know exactly how many mipmap levels 2467 * are present/needed. This is conditional because we may be called 2468 * from the st_generate_mipmap() function when the texture object is 2469 * incomplete. In that case, we'll have set stObj->lastLevel before 2470 * we get here. 2471 */ 2472 if (stObj->base.Sampler.MinFilter == GL_LINEAR || 2473 stObj->base.Sampler.MinFilter == GL_NEAREST) 2474 stObj->lastLevel = stObj->base.BaseLevel; 2475 else 2476 stObj->lastLevel = stObj->base._MaxLevel; 2477 } 2478 2479 if (tObj->Target == GL_TEXTURE_BUFFER) { 2480 struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject); 2481 2482 if (!st_obj) { 2483 pipe_resource_reference(&stObj->pt, NULL); 2484 st_texture_release_all_sampler_views(st, stObj); 2485 return GL_TRUE; 2486 } 2487 2488 if (st_obj->buffer != stObj->pt) { 2489 pipe_resource_reference(&stObj->pt, st_obj->buffer); 2490 st_texture_release_all_sampler_views(st, stObj); 2491 } 2492 return GL_TRUE; 2493 2494 } 2495 2496 firstImage = st_texture_image_const(_mesa_base_tex_image(&stObj->base)); 2497 assert(firstImage); 2498 2499 /* If both firstImage and stObj point to a texture which can contain 2500 * all active images, favour firstImage. Note that because of the 2501 * completeness requirement, we know that the image dimensions 2502 * will match. 2503 */ 2504 if (firstImage->pt && 2505 firstImage->pt != stObj->pt && 2506 (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) { 2507 pipe_resource_reference(&stObj->pt, firstImage->pt); 2508 st_texture_release_all_sampler_views(st, stObj); 2509 } 2510 2511 /* If this texture comes from a window system, there is nothing else to do. */ 2512 if (stObj->surface_based) { 2513 return GL_TRUE; 2514 } 2515 2516 /* Find gallium format for the Mesa texture */ 2517 firstImageFormat = 2518 st_mesa_format_to_pipe_format(st, firstImage->base.TexFormat); 2519 2520 /* Find size of level=0 Gallium mipmap image, plus number of texture layers */ 2521 { 2522 GLuint width, height, depth; 2523 2524 st_gl_texture_dims_to_pipe_dims(stObj->base.Target, 2525 firstImage->base.Width2, 2526 firstImage->base.Height2, 2527 firstImage->base.Depth2, 2528 &width, &height, &depth, &ptLayers); 2529 2530 /* If we previously allocated a pipe texture and its sizes are 2531 * compatible, use them. 2532 */ 2533 if (stObj->pt && 2534 u_minify(stObj->pt->width0, firstImage->base.Level) == width && 2535 u_minify(stObj->pt->height0, firstImage->base.Level) == height && 2536 u_minify(stObj->pt->depth0, firstImage->base.Level) == depth) { 2537 ptWidth = stObj->pt->width0; 2538 ptHeight = stObj->pt->height0; 2539 ptDepth = stObj->pt->depth0; 2540 } else { 2541 /* Otherwise, compute a new level=0 size that is compatible with the 2542 * base level image. 2543 */ 2544 ptWidth = width > 1 ? width << firstImage->base.Level : 1; 2545 ptHeight = height > 1 ? height << firstImage->base.Level : 1; 2546 ptDepth = depth > 1 ? depth << firstImage->base.Level : 1; 2547 2548 /* If the base level image is 1x1x1, we still need to ensure that the 2549 * resulting pipe texture ends up with the required number of levels 2550 * in total. 2551 */ 2552 if (ptWidth == 1 && ptHeight == 1 && ptDepth == 1) { 2553 ptWidth <<= firstImage->base.Level; 2554 2555 if (stObj->base.Target == GL_TEXTURE_CUBE_MAP || 2556 stObj->base.Target == GL_TEXTURE_CUBE_MAP_ARRAY) 2557 ptHeight = ptWidth; 2558 } 2559 } 2560 2561 ptNumSamples = firstImage->base.NumSamples; 2562 } 2563 2564 /* If we already have a gallium texture, check that it matches the texture 2565 * object's format, target, size, num_levels, etc. 2566 */ 2567 if (stObj->pt) { 2568 if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) || 2569 stObj->pt->format != firstImageFormat || 2570 stObj->pt->last_level < stObj->lastLevel || 2571 stObj->pt->width0 != ptWidth || 2572 stObj->pt->height0 != ptHeight || 2573 stObj->pt->depth0 != ptDepth || 2574 stObj->pt->nr_samples != ptNumSamples || 2575 stObj->pt->array_size != ptLayers) 2576 { 2577 /* The gallium texture does not match the Mesa texture so delete the 2578 * gallium texture now. We'll make a new one below. 2579 */ 2580 pipe_resource_reference(&stObj->pt, NULL); 2581 st_texture_release_all_sampler_views(st, stObj); 2582 st->dirty |= ST_NEW_FRAMEBUFFER; 2583 } 2584 } 2585 2586 /* May need to create a new gallium texture: 2587 */ 2588 if (!stObj->pt) { 2589 GLuint bindings = default_bindings(st, firstImageFormat); 2590 2591 stObj->pt = st_texture_create(st, 2592 gl_target_to_pipe(stObj->base.Target), 2593 firstImageFormat, 2594 stObj->lastLevel, 2595 ptWidth, 2596 ptHeight, 2597 ptDepth, 2598 ptLayers, ptNumSamples, 2599 bindings); 2600 2601 if (!stObj->pt) { 2602 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); 2603 return GL_FALSE; 2604 } 2605 } 2606 2607 /* Pull in any images not in the object's texture: 2608 */ 2609 for (face = 0; face < nr_faces; face++) { 2610 GLuint level; 2611 for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) { 2612 struct st_texture_image *stImage = 2613 st_texture_image(stObj->base.Image[face][level]); 2614 2615 /* Need to import images in main memory or held in other textures. 2616 */ 2617 if (stImage && stObj->pt != stImage->pt) { 2618 GLuint height; 2619 GLuint depth; 2620 2621 if (stObj->base.Target != GL_TEXTURE_1D_ARRAY) 2622 height = u_minify(ptHeight, level); 2623 else 2624 height = ptLayers; 2625 2626 if (stObj->base.Target == GL_TEXTURE_3D) 2627 depth = u_minify(ptDepth, level); 2628 else if (stObj->base.Target == GL_TEXTURE_CUBE_MAP) 2629 depth = 1; 2630 else 2631 depth = ptLayers; 2632 2633 if (level == 0 || 2634 (stImage->base.Width == u_minify(ptWidth, level) && 2635 stImage->base.Height == height && 2636 stImage->base.Depth == depth)) { 2637 /* src image fits expected dest mipmap level size */ 2638 copy_image_data_to_texture(st, stObj, level, stImage); 2639 } 2640 } 2641 } 2642 } 2643 2644 return GL_TRUE; 2645} 2646 2647 2648/** 2649 * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory 2650 * for a whole mipmap stack. 2651 */ 2652static GLboolean 2653st_AllocTextureStorage(struct gl_context *ctx, 2654 struct gl_texture_object *texObj, 2655 GLsizei levels, GLsizei width, 2656 GLsizei height, GLsizei depth) 2657{ 2658 const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); 2659 struct gl_texture_image *texImage = texObj->Image[0][0]; 2660 struct st_context *st = st_context(ctx); 2661 struct st_texture_object *stObj = st_texture_object(texObj); 2662 struct pipe_screen *screen = st->pipe->screen; 2663 GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings; 2664 enum pipe_format fmt; 2665 GLint level; 2666 GLuint num_samples = texImage->NumSamples; 2667 2668 assert(levels > 0); 2669 2670 stObj->lastLevel = levels - 1; 2671 2672 fmt = st_mesa_format_to_pipe_format(st, texImage->TexFormat); 2673 2674 bindings = default_bindings(st, fmt); 2675 2676 /* Raise the sample count if the requested one is unsupported. */ 2677 if (num_samples > 1) { 2678 boolean found = FALSE; 2679 2680 for (; num_samples <= ctx->Const.MaxSamples; num_samples++) { 2681 if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, 2682 num_samples, 2683 PIPE_BIND_SAMPLER_VIEW)) { 2684 /* Update the sample count in gl_texture_image as well. */ 2685 texImage->NumSamples = num_samples; 2686 found = TRUE; 2687 break; 2688 } 2689 } 2690 2691 if (!found) { 2692 return GL_FALSE; 2693 } 2694 } 2695 2696 st_gl_texture_dims_to_pipe_dims(texObj->Target, 2697 width, height, depth, 2698 &ptWidth, &ptHeight, &ptDepth, &ptLayers); 2699 2700 stObj->pt = st_texture_create(st, 2701 gl_target_to_pipe(texObj->Target), 2702 fmt, 2703 levels - 1, 2704 ptWidth, 2705 ptHeight, 2706 ptDepth, 2707 ptLayers, num_samples, 2708 bindings); 2709 if (!stObj->pt) 2710 return GL_FALSE; 2711 2712 /* Set image resource pointers */ 2713 for (level = 0; level < levels; level++) { 2714 GLuint face; 2715 for (face = 0; face < numFaces; face++) { 2716 struct st_texture_image *stImage = 2717 st_texture_image(texObj->Image[face][level]); 2718 pipe_resource_reference(&stImage->pt, stObj->pt); 2719 2720 etc_fallback_allocate(st, stImage); 2721 } 2722 } 2723 2724 return GL_TRUE; 2725} 2726 2727 2728static GLboolean 2729st_TestProxyTexImage(struct gl_context *ctx, GLenum target, 2730 GLuint numLevels, GLint level, 2731 mesa_format format, GLuint numSamples, 2732 GLint width, GLint height, GLint depth) 2733{ 2734 struct st_context *st = st_context(ctx); 2735 struct pipe_context *pipe = st->pipe; 2736 2737 if (width == 0 || height == 0 || depth == 0) { 2738 /* zero-sized images are legal, and always fit! */ 2739 return GL_TRUE; 2740 } 2741 2742 if (pipe->screen->can_create_resource) { 2743 /* Ask the gallium driver if the texture is too large */ 2744 struct gl_texture_object *texObj = 2745 _mesa_get_current_tex_object(ctx, target); 2746 struct pipe_resource pt; 2747 2748 /* Setup the pipe_resource object 2749 */ 2750 memset(&pt, 0, sizeof(pt)); 2751 2752 pt.target = gl_target_to_pipe(target); 2753 pt.format = st_mesa_format_to_pipe_format(st, format); 2754 pt.nr_samples = numSamples; 2755 2756 st_gl_texture_dims_to_pipe_dims(target, 2757 width, height, depth, 2758 &pt.width0, &pt.height0, 2759 &pt.depth0, &pt.array_size); 2760 2761 if (numLevels > 0) { 2762 /* For immutable textures we know the final number of mip levels */ 2763 pt.last_level = numLevels - 1; 2764 } 2765 else if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR || 2766 texObj->Sampler.MinFilter == GL_NEAREST)) { 2767 /* assume just one mipmap level */ 2768 pt.last_level = 0; 2769 } 2770 else { 2771 /* assume a full set of mipmaps */ 2772 pt.last_level = _mesa_logbase2(MAX3(width, height, depth)); 2773 } 2774 2775 return pipe->screen->can_create_resource(pipe->screen, &pt); 2776 } 2777 else { 2778 /* Use core Mesa fallback */ 2779 return _mesa_test_proxy_teximage(ctx, target, numLevels, level, format, 2780 numSamples, width, height, depth); 2781 } 2782} 2783 2784static GLboolean 2785st_TextureView(struct gl_context *ctx, 2786 struct gl_texture_object *texObj, 2787 struct gl_texture_object *origTexObj) 2788{ 2789 struct st_context *st = st_context(ctx); 2790 struct st_texture_object *orig = st_texture_object(origTexObj); 2791 struct st_texture_object *tex = st_texture_object(texObj); 2792 struct gl_texture_image *image = texObj->Image[0][0]; 2793 2794 const int numFaces = _mesa_num_tex_faces(texObj->Target); 2795 const int numLevels = texObj->NumLevels; 2796 2797 int face; 2798 int level; 2799 2800 pipe_resource_reference(&tex->pt, orig->pt); 2801 2802 /* Set image resource pointers */ 2803 for (level = 0; level < numLevels; level++) { 2804 for (face = 0; face < numFaces; face++) { 2805 struct st_texture_image *stImage = 2806 st_texture_image(texObj->Image[face][level]); 2807 pipe_resource_reference(&stImage->pt, tex->pt); 2808 } 2809 } 2810 2811 tex->surface_based = GL_TRUE; 2812 tex->surface_format = 2813 st_mesa_format_to_pipe_format(st_context(ctx), image->TexFormat); 2814 2815 tex->lastLevel = numLevels - 1; 2816 2817 /* free texture sampler views. They need to be recreated when we 2818 * change the texture view parameters. 2819 */ 2820 st_texture_release_all_sampler_views(st, tex); 2821 2822 return GL_TRUE; 2823} 2824 2825static void 2826st_ClearTexSubImage(struct gl_context *ctx, 2827 struct gl_texture_image *texImage, 2828 GLint xoffset, GLint yoffset, GLint zoffset, 2829 GLsizei width, GLsizei height, GLsizei depth, 2830 const void *clearValue) 2831{ 2832 static const char zeros[16] = {0}; 2833 struct st_texture_image *stImage = st_texture_image(texImage); 2834 struct pipe_resource *pt = stImage->pt; 2835 struct st_context *st = st_context(ctx); 2836 struct pipe_context *pipe = st->pipe; 2837 unsigned level = texImage->Level; 2838 struct pipe_box box; 2839 2840 if (!pt) 2841 return; 2842 2843 st_flush_bitmap_cache(st); 2844 st_invalidate_readpix_cache(st); 2845 2846 u_box_3d(xoffset, yoffset, zoffset + texImage->Face, 2847 width, height, depth, &box); 2848 if (texImage->TexObject->Immutable) { 2849 level += texImage->TexObject->MinLevel; 2850 box.z += texImage->TexObject->MinLayer; 2851 } 2852 2853 pipe->clear_texture(pipe, pt, level, &box, clearValue ? clearValue : zeros); 2854} 2855 2856 2857/** 2858 * Called via the glTexParam*() function, but only when some texture object 2859 * state has actually changed. 2860 */ 2861static void 2862st_TexParameter(struct gl_context *ctx, 2863 struct gl_texture_object *texObj, GLenum pname) 2864{ 2865 struct st_context *st = st_context(ctx); 2866 struct st_texture_object *stObj = st_texture_object(texObj); 2867 2868 switch (pname) { 2869 case GL_TEXTURE_BASE_LEVEL: 2870 case GL_TEXTURE_MAX_LEVEL: 2871 case GL_DEPTH_TEXTURE_MODE: 2872 case GL_DEPTH_STENCIL_TEXTURE_MODE: 2873 case GL_TEXTURE_SRGB_DECODE_EXT: 2874 case GL_TEXTURE_SWIZZLE_R: 2875 case GL_TEXTURE_SWIZZLE_G: 2876 case GL_TEXTURE_SWIZZLE_B: 2877 case GL_TEXTURE_SWIZZLE_A: 2878 case GL_TEXTURE_SWIZZLE_RGBA: 2879 case GL_TEXTURE_BUFFER_SIZE: 2880 case GL_TEXTURE_BUFFER_OFFSET: 2881 /* changing any of these texture parameters means we must create 2882 * new sampler views. 2883 */ 2884 st_texture_release_all_sampler_views(st, stObj); 2885 break; 2886 default: 2887 ; /* nothing */ 2888 } 2889} 2890 2891 2892void 2893st_init_texture_functions(struct dd_function_table *functions) 2894{ 2895 functions->ChooseTextureFormat = st_ChooseTextureFormat; 2896 functions->QueryInternalFormat = st_QueryInternalFormat; 2897 functions->TexImage = st_TexImage; 2898 functions->TexSubImage = st_TexSubImage; 2899 functions->CompressedTexSubImage = st_CompressedTexSubImage; 2900 functions->CopyTexSubImage = st_CopyTexSubImage; 2901 functions->GenerateMipmap = st_generate_mipmap; 2902 2903 functions->GetTexSubImage = st_GetTexSubImage; 2904 2905 /* compressed texture functions */ 2906 functions->CompressedTexImage = st_CompressedTexImage; 2907 functions->GetCompressedTexSubImage = _mesa_GetCompressedTexSubImage_sw; 2908 2909 functions->NewTextureObject = st_NewTextureObject; 2910 functions->NewTextureImage = st_NewTextureImage; 2911 functions->DeleteTextureImage = st_DeleteTextureImage; 2912 functions->DeleteTexture = st_DeleteTextureObject; 2913 functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer; 2914 functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer; 2915 functions->MapTextureImage = st_MapTextureImage; 2916 functions->UnmapTextureImage = st_UnmapTextureImage; 2917 2918 /* XXX Temporary until we can query pipe's texture sizes */ 2919 functions->TestProxyTexImage = st_TestProxyTexImage; 2920 2921 functions->AllocTextureStorage = st_AllocTextureStorage; 2922 functions->TextureView = st_TextureView; 2923 functions->ClearTexSubImage = st_ClearTexSubImage; 2924 2925 functions->TexParameter = st_TexParameter; 2926} 2927