1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
28 #include "main/bufferobj.h"
29 #include "main/enums.h"
30 #include "main/fbobject.h"
31 #include "main/formats.h"
32 #include "main/image.h"
33 #include "main/imports.h"
34 #include "main/macros.h"
35 #include "main/mipmap.h"
36 #include "main/pack.h"
38 #include "main/pixeltransfer.h"
39 #include "main/texcompress.h"
40 #include "main/texgetimage.h"
41 #include "main/teximage.h"
42 #include "main/texobj.h"
43 #include "main/texstore.h"
45 #include "state_tracker/st_debug.h"
46 #include "state_tracker/st_context.h"
47 #include "state_tracker/st_cb_fbo.h"
48 #include "state_tracker/st_cb_flush.h"
49 #include "state_tracker/st_cb_texture.h"
50 #include "state_tracker/st_cb_bufferobjects.h"
51 #include "state_tracker/st_format.h"
52 #include "state_tracker/st_texture.h"
53 #include "state_tracker/st_gen_mipmap.h"
54 #include "state_tracker/st_atom.h"
56 #include "pipe/p_context.h"
57 #include "pipe/p_defines.h"
58 #include "util/u_inlines.h"
59 #include "pipe/p_shader_tokens.h"
60 #include "util/u_tile.h"
61 #include "util/u_format.h"
62 #include "util/u_surface.h"
63 #include "util/u_sampler.h"
64 #include "util/u_math.h"
65 #include "util/u_box.h"
67 #define DBG if (0) printf
70 enum pipe_texture_target
71 gl_target_to_pipe(GLenum target)
75 case GL_PROXY_TEXTURE_1D:
76 return PIPE_TEXTURE_1D;
78 case GL_PROXY_TEXTURE_2D:
79 case GL_TEXTURE_EXTERNAL_OES:
80 case GL_TEXTURE_2D_MULTISAMPLE:
81 case GL_PROXY_TEXTURE_2D_MULTISAMPLE:
82 return PIPE_TEXTURE_2D;
83 case GL_TEXTURE_RECTANGLE_NV:
84 case GL_PROXY_TEXTURE_RECTANGLE_NV:
85 return PIPE_TEXTURE_RECT;
87 case GL_PROXY_TEXTURE_3D:
88 return PIPE_TEXTURE_3D;
89 case GL_TEXTURE_CUBE_MAP_ARB:
90 case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
91 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
92 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
93 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
94 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
95 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
96 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
97 return PIPE_TEXTURE_CUBE;
98 case GL_TEXTURE_1D_ARRAY_EXT:
99 case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
100 return PIPE_TEXTURE_1D_ARRAY;
101 case GL_TEXTURE_2D_ARRAY_EXT:
102 case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
103 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
104 case GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY:
105 return PIPE_TEXTURE_2D_ARRAY;
106 case GL_TEXTURE_BUFFER:
108 case GL_TEXTURE_CUBE_MAP_ARRAY:
109 case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY:
110 return PIPE_TEXTURE_CUBE_ARRAY;
118 /** called via ctx->Driver.NewTextureImage() */
119 static struct gl_texture_image *
120 st_NewTextureImage(struct gl_context * ctx)
122 DBG("%s\n", __FUNCTION__);
124 return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image);
128 /** called via ctx->Driver.DeleteTextureImage() */
130 st_DeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img)
132 /* nothing special (yet) for st_texture_image */
133 _mesa_delete_texture_image(ctx, img);
137 /** called via ctx->Driver.NewTextureObject() */
138 static struct gl_texture_object *
139 st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target)
141 struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object);
143 DBG("%s\n", __FUNCTION__);
144 _mesa_initialize_texture_object(ctx, &obj->base, name, target);
149 /** called via ctx->Driver.DeleteTextureObject() */
151 st_DeleteTextureObject(struct gl_context *ctx,
152 struct gl_texture_object *texObj)
154 struct st_context *st = st_context(ctx);
155 struct st_texture_object *stObj = st_texture_object(texObj);
157 pipe_resource_reference(&stObj->pt, NULL);
158 if (stObj->sampler_view) {
159 pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
161 _mesa_delete_texture_object(ctx, texObj);
165 /** called via ctx->Driver.FreeTextureImageBuffer() */
167 st_FreeTextureImageBuffer(struct gl_context *ctx,
168 struct gl_texture_image *texImage)
170 struct st_texture_image *stImage = st_texture_image(texImage);
172 DBG("%s\n", __FUNCTION__);
175 pipe_resource_reference(&stImage->pt, NULL);
178 _mesa_align_free(stImage->TexData);
179 stImage->TexData = NULL;
183 /** called via ctx->Driver.MapTextureImage() */
185 st_MapTextureImage(struct gl_context *ctx,
186 struct gl_texture_image *texImage,
187 GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h,
189 GLubyte **mapOut, GLint *rowStrideOut)
191 struct st_context *st = st_context(ctx);
192 struct st_texture_image *stImage = st_texture_image(texImage);
197 if (mode & GL_MAP_READ_BIT)
198 pipeMode |= PIPE_TRANSFER_READ;
199 if (mode & GL_MAP_WRITE_BIT)
200 pipeMode |= PIPE_TRANSFER_WRITE;
201 if (mode & GL_MAP_INVALIDATE_RANGE_BIT)
202 pipeMode |= PIPE_TRANSFER_DISCARD_RANGE;
204 map = st_texture_image_map(st, stImage, pipeMode, x, y, slice, w, h, 1);
207 *rowStrideOut = stImage->transfer->stride;
216 /** called via ctx->Driver.UnmapTextureImage() */
218 st_UnmapTextureImage(struct gl_context *ctx,
219 struct gl_texture_image *texImage,
222 struct st_context *st = st_context(ctx);
223 struct st_texture_image *stImage = st_texture_image(texImage);
224 st_texture_image_unmap(st, stImage);
229 * Return default texture resource binding bitmask for the given format.
232 default_bindings(struct st_context *st, enum pipe_format format)
234 struct pipe_screen *screen = st->pipe->screen;
235 const unsigned target = PIPE_TEXTURE_2D;
238 if (util_format_is_depth_or_stencil(format))
239 bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DEPTH_STENCIL;
241 bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
243 if (screen->is_format_supported(screen, format, target, 0, bindings))
247 format = util_format_linear(format);
249 if (screen->is_format_supported(screen, format, target, 0, bindings))
252 return PIPE_BIND_SAMPLER_VIEW;
258 * Given the size of a mipmap image, try to compute the size of the level=0
261 * Note that this isn't always accurate for odd-sized, non-POW textures.
262 * For example, if level=1 and width=40 then the level=0 width may be 80 or 81.
264 * \return GL_TRUE for success, GL_FALSE for failure
267 guess_base_level_size(GLenum target,
268 GLuint width, GLuint height, GLuint depth, GLuint level,
269 GLuint *width0, GLuint *height0, GLuint *depth0)
276 /* Guess the size of the base level.
277 * Depending on the image's size, we can't always make a guess here.
281 case GL_TEXTURE_1D_ARRAY:
286 case GL_TEXTURE_2D_ARRAY:
287 /* We can't make a good guess here, because the base level dimensions
290 if (width == 1 || height == 1) {
297 case GL_TEXTURE_CUBE_MAP:
298 case GL_TEXTURE_CUBE_MAP_ARRAY:
304 /* We can't make a good guess here, because the base level dimensions
307 if (width == 1 || height == 1 || depth == 1) {
315 case GL_TEXTURE_RECTANGLE:
332 * Try to allocate a pipe_resource object for the given st_texture_object.
334 * We use the given st_texture_image as a clue to determine the size of the
335 * mipmap image at level=0.
337 * \return GL_TRUE for success, GL_FALSE if out of memory.
340 guess_and_alloc_texture(struct st_context *st,
341 struct st_texture_object *stObj,
342 const struct st_texture_image *stImage)
344 GLuint lastLevel, width, height, depth;
346 GLuint ptWidth, ptHeight, ptDepth, ptLayers;
347 enum pipe_format fmt;
349 DBG("%s\n", __FUNCTION__);
353 if (!guess_base_level_size(stObj->base.Target,
354 stImage->base.Width2,
355 stImage->base.Height2,
356 stImage->base.Depth2,
358 &width, &height, &depth)) {
359 /* we can't determine the image size at level=0 */
360 stObj->width0 = stObj->height0 = stObj->depth0 = 0;
361 /* this is not an out of memory error */
365 /* At this point, (width x height x depth) is the expected size of
366 * the level=0 mipmap image.
369 /* Guess a reasonable value for lastLevel. With OpenGL we have no
370 * idea how many mipmap levels will be in a texture until we start
371 * to render with it. Make an educated guess here but be prepared
372 * to re-allocating a texture buffer with space for more (or fewer)
373 * mipmap levels later.
375 if ((stObj->base.Sampler.MinFilter == GL_NEAREST ||
376 stObj->base.Sampler.MinFilter == GL_LINEAR ||
377 (stObj->base.BaseLevel == 0 &&
378 stObj->base.MaxLevel == 0) ||
379 stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
380 stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) &&
381 !stObj->base.GenerateMipmap &&
382 stImage->base.Level == 0) {
383 /* only alloc space for a single mipmap level */
387 /* alloc space for a full mipmap */
388 lastLevel = _mesa_get_tex_max_num_levels(stObj->base.Target,
389 width, height, depth) - 1;
392 /* Save the level=0 dimensions */
393 stObj->width0 = width;
394 stObj->height0 = height;
395 stObj->depth0 = depth;
397 fmt = st_mesa_format_to_pipe_format(stImage->base.TexFormat);
399 bindings = default_bindings(st, fmt);
401 st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
402 width, height, depth,
403 &ptWidth, &ptHeight, &ptDepth, &ptLayers);
405 stObj->pt = st_texture_create(st,
406 gl_target_to_pipe(stObj->base.Target),
415 stObj->lastLevel = lastLevel;
417 DBG("%s returning %d\n", __FUNCTION__, (stObj->pt != NULL));
419 return stObj->pt != NULL;
424 * Called via ctx->Driver.AllocTextureImageBuffer().
425 * If the texture object/buffer already has space for the indicated image,
426 * we're done. Otherwise, allocate memory for the new texture image.
429 st_AllocTextureImageBuffer(struct gl_context *ctx,
430 struct gl_texture_image *texImage)
432 struct st_context *st = st_context(ctx);
433 struct st_texture_image *stImage = st_texture_image(texImage);
434 struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
435 const GLuint level = texImage->Level;
436 GLuint width = texImage->Width;
437 GLuint height = texImage->Height;
438 GLuint depth = texImage->Depth;
440 DBG("%s\n", __FUNCTION__);
442 assert(!stImage->TexData);
443 assert(!stImage->pt); /* xxx this might be wrong */
445 /* Look if the parent texture object has space for this image */
447 level <= stObj->pt->last_level &&
448 st_texture_match_image(stObj->pt, texImage)) {
449 /* this image will fit in the existing texture object's memory */
450 pipe_resource_reference(&stImage->pt, stObj->pt);
454 /* The parent texture object does not have space for this image */
456 pipe_resource_reference(&stObj->pt, NULL);
457 pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
459 if (!guess_and_alloc_texture(st, stObj, stImage)) {
460 /* Probably out of memory.
461 * Try flushing any pending rendering, then retry.
464 if (!guess_and_alloc_texture(st, stObj, stImage)) {
465 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
471 st_texture_match_image(stObj->pt, texImage)) {
472 /* The image will live in the object's mipmap memory */
473 pipe_resource_reference(&stImage->pt, stObj->pt);
478 /* Create a new, temporary texture/resource/buffer to hold this
479 * one texture image. Note that when we later access this image
480 * (either for mapping or copying) we'll want to always specify
481 * mipmap level=0, even if the image represents some other mipmap
484 enum pipe_format format =
485 st_mesa_format_to_pipe_format(texImage->TexFormat);
486 GLuint bindings = default_bindings(st, format);
487 GLuint ptWidth, ptHeight, ptDepth, ptLayers;
489 st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
490 width, height, depth,
491 &ptWidth, &ptHeight, &ptDepth, &ptLayers);
493 stImage->pt = st_texture_create(st,
494 gl_target_to_pipe(stObj->base.Target),
502 return stImage->pt != NULL;
508 * Preparation prior to glTexImage. Basically check the 'surface_based'
509 * field and switch to a "normal" tex image if necessary.
512 prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage,
513 GLenum format, GLenum type)
515 struct gl_texture_object *texObj = texImage->TexObject;
516 struct st_texture_object *stObj = st_texture_object(texObj);
518 /* switch to "normal" */
519 if (stObj->surface_based) {
520 const GLenum target = texObj->Target;
521 const GLuint level = texImage->Level;
522 mesa_format texFormat;
524 _mesa_clear_texture_object(ctx, texObj);
525 pipe_resource_reference(&stObj->pt, NULL);
527 /* oops, need to init this image again */
528 texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
529 texImage->InternalFormat, format,
532 _mesa_init_teximage_fields(ctx, texImage,
533 texImage->Width, texImage->Height,
534 texImage->Depth, texImage->Border,
535 texImage->InternalFormat, texFormat);
537 stObj->surface_based = GL_FALSE;
543 * Return a writemask for the gallium blit. The parameters can be base
544 * formats or "format" from glDrawPixels/glTexImage/glGetTexImage.
547 st_get_blit_mask(GLenum srcFormat, GLenum dstFormat)
550 case GL_DEPTH_STENCIL:
552 case GL_DEPTH_STENCIL:
554 case GL_DEPTH_COMPONENT:
556 case GL_STENCIL_INDEX:
563 case GL_DEPTH_COMPONENT:
565 case GL_DEPTH_STENCIL:
566 case GL_DEPTH_COMPONENT:
573 case GL_STENCIL_INDEX:
575 case GL_STENCIL_INDEX:
583 return PIPE_MASK_RGBA;
589 st_TexSubImage(struct gl_context *ctx, GLuint dims,
590 struct gl_texture_image *texImage,
591 GLint xoffset, GLint yoffset, GLint zoffset,
592 GLint width, GLint height, GLint depth,
593 GLenum format, GLenum type, const void *pixels,
594 const struct gl_pixelstore_attrib *unpack)
596 struct st_context *st = st_context(ctx);
597 struct st_texture_image *stImage = st_texture_image(texImage);
598 struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
599 struct pipe_context *pipe = st->pipe;
600 struct pipe_screen *screen = pipe->screen;
601 struct pipe_resource *dst = stImage->pt;
602 struct pipe_resource *src = NULL;
603 struct pipe_resource src_templ;
604 struct pipe_transfer *transfer;
605 struct pipe_blit_info blit;
606 enum pipe_format src_format, dst_format;
607 mesa_format mesa_src_format;
608 GLenum gl_target = texImage->TexObject->Target;
612 if (!st->prefer_blit_based_texture_transfer) {
620 /* XXX Fallback for depth-stencil formats due to an incomplete stencil
621 * blit implementation in some drivers. */
622 if (format == GL_DEPTH_STENCIL) {
626 /* If the base internal format and the texture format don't match,
627 * we can't use blit-based TexSubImage. */
628 if (texImage->_BaseFormat !=
629 _mesa_get_format_base_format(texImage->TexFormat)) {
633 /* See if the texture format already matches the format and type,
634 * in which case the memcpy-based fast path will likely be used and
635 * we don't have to blit. */
636 if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
637 type, unpack->SwapBytes)) {
641 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
642 bind = PIPE_BIND_DEPTH_STENCIL;
644 bind = PIPE_BIND_RENDER_TARGET;
646 /* See if the destination format is supported.
647 * For luminance and intensity, only the red channel is stored there. */
648 dst_format = util_format_linear(dst->format);
649 dst_format = util_format_luminance_to_red(dst_format);
650 dst_format = util_format_intensity_to_red(dst_format);
653 !screen->is_format_supported(screen, dst_format, dst->target,
654 dst->nr_samples, bind)) {
658 /* Choose the source format. */
659 src_format = st_choose_matching_format(screen, PIPE_BIND_SAMPLER_VIEW,
660 format, type, unpack->SwapBytes);
665 mesa_src_format = st_pipe_format_to_mesa_format(src_format);
667 /* There is no reason to do this if we cannot use memcpy for the temporary
668 * source texture at least. This also takes transfer ops into account,
670 if (!_mesa_texstore_can_use_memcpy(ctx,
671 _mesa_get_format_base_format(mesa_src_format),
672 mesa_src_format, format, type, unpack)) {
676 /* TexSubImage only sets a single cubemap face. */
677 if (gl_target == GL_TEXTURE_CUBE_MAP) {
678 gl_target = GL_TEXTURE_2D;
681 /* Initialize the source texture description. */
682 memset(&src_templ, 0, sizeof(src_templ));
683 src_templ.target = gl_target_to_pipe(gl_target);
684 src_templ.format = src_format;
685 src_templ.bind = PIPE_BIND_SAMPLER_VIEW;
686 src_templ.usage = PIPE_USAGE_STAGING;
688 st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
689 &src_templ.width0, &src_templ.height0,
690 &src_templ.depth0, &src_templ.array_size);
692 /* Check for NPOT texture support. */
693 if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
694 (!util_is_power_of_two(src_templ.width0) ||
695 !util_is_power_of_two(src_templ.height0) ||
696 !util_is_power_of_two(src_templ.depth0))) {
700 /* Create the source texture. */
701 src = screen->resource_create(screen, &src_templ);
706 /* Map source pixels. */
707 pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
708 format, type, pixels, unpack,
711 /* This is a GL error. */
712 pipe_resource_reference(&src, NULL);
716 /* From now on, we need the gallium representation of dimensions. */
717 if (gl_target == GL_TEXTURE_1D_ARRAY) {
722 map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0,
723 width, height, depth, &transfer);
725 _mesa_unmap_teximage_pbo(ctx, unpack);
726 pipe_resource_reference(&src, NULL);
730 /* Upload pixels (just memcpy). */
732 const uint bytesPerRow = width * util_format_get_blocksize(src_format);
735 for (slice = 0; slice < (unsigned) depth; slice++) {
736 if (gl_target == GL_TEXTURE_1D_ARRAY) {
737 /* 1D array textures.
738 * We need to convert gallium coords to GL coords.
740 GLvoid *src = _mesa_image_address3d(unpack, pixels,
741 width, depth, format,
743 memcpy(map, src, bytesPerRow);
746 ubyte *slice_map = map;
748 for (row = 0; row < (unsigned) height; row++) {
749 GLvoid *src = _mesa_image_address3d(unpack, pixels,
750 width, height, format,
751 type, slice, row, 0);
752 memcpy(slice_map, src, bytesPerRow);
753 slice_map += transfer->stride;
756 map += transfer->layer_stride;
760 pipe_transfer_unmap(pipe, transfer);
761 _mesa_unmap_teximage_pbo(ctx, unpack);
764 blit.src.resource = src;
766 blit.src.format = src_format;
767 blit.dst.resource = dst;
768 blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level;
769 blit.dst.format = dst_format;
770 blit.src.box.x = blit.src.box.y = blit.src.box.z = 0;
771 blit.dst.box.x = xoffset;
772 blit.dst.box.y = yoffset;
773 blit.dst.box.z = zoffset + texImage->Face;
774 blit.src.box.width = blit.dst.box.width = width;
775 blit.src.box.height = blit.dst.box.height = height;
776 blit.src.box.depth = blit.dst.box.depth = depth;
777 blit.mask = st_get_blit_mask(format, texImage->_BaseFormat);
778 blit.filter = PIPE_TEX_FILTER_NEAREST;
779 blit.scissor_enable = FALSE;
781 st->pipe->blit(st->pipe, &blit);
783 pipe_resource_reference(&src, NULL);
787 _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset,
788 width, height, depth, format, type, pixels,
793 st_TexImage(struct gl_context * ctx, GLuint dims,
794 struct gl_texture_image *texImage,
795 GLenum format, GLenum type, const void *pixels,
796 const struct gl_pixelstore_attrib *unpack)
798 assert(dims == 1 || dims == 2 || dims == 3);
800 prep_teximage(ctx, texImage, format, type);
802 if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
805 /* allocate storage for texture data */
806 if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
807 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
811 st_TexSubImage(ctx, dims, texImage, 0, 0, 0,
812 texImage->Width, texImage->Height, texImage->Depth,
813 format, type, pixels, unpack);
818 st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
819 struct gl_texture_image *texImage,
820 GLsizei imageSize, const GLvoid *data)
822 prep_teximage(ctx, texImage, GL_NONE, GL_NONE);
823 _mesa_store_compressed_teximage(ctx, dims, texImage, imageSize, data);
830 * Called via ctx->Driver.GetTexImage()
832 * This uses a blit to copy the texture to a texture format which matches
833 * the format and type combo and then a fast read-back is done using memcpy.
834 * We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is
835 * a format which matches the swizzling.
837 * If such a format isn't available, it falls back to _mesa_get_teximage.
839 * NOTE: Drivers usually do a blit to convert between tiled and linear
840 * texture layouts during texture uploads/downloads, so the blit
841 * we do here should be free in such cases.
844 st_GetTexImage(struct gl_context * ctx,
845 GLenum format, GLenum type, GLvoid * pixels,
846 struct gl_texture_image *texImage)
848 struct st_context *st = st_context(ctx);
849 struct pipe_context *pipe = st->pipe;
850 struct pipe_screen *screen = pipe->screen;
851 GLuint width = texImage->Width;
852 GLuint height = texImage->Height;
853 GLuint depth = texImage->Depth;
854 struct st_texture_image *stImage = st_texture_image(texImage);
855 struct pipe_resource *src = st_texture_object(texImage->TexObject)->pt;
856 struct pipe_resource *dst = NULL;
857 struct pipe_resource dst_templ;
858 enum pipe_format dst_format, src_format;
859 mesa_format mesa_format;
860 GLenum gl_target = texImage->TexObject->Target;
861 enum pipe_texture_target pipe_target;
862 struct pipe_blit_info blit;
863 unsigned bind = PIPE_BIND_TRANSFER_READ;
864 struct pipe_transfer *tex_xfer;
866 boolean done = FALSE;
868 if (!st->prefer_blit_based_texture_transfer &&
869 !_mesa_is_format_compressed(texImage->TexFormat)) {
870 /* Try to avoid the fallback if we're doing texture decompression here */
874 if (!stImage->pt || !src) {
878 /* XXX Fallback to _mesa_get_teximage for depth-stencil formats
879 * due to an incomplete stencil blit implementation in some drivers. */
880 if (format == GL_DEPTH_STENCIL) {
884 /* If the base internal format and the texture format don't match, we have
885 * to fall back to _mesa_get_teximage. */
886 if (texImage->_BaseFormat !=
887 _mesa_get_format_base_format(texImage->TexFormat)) {
891 /* See if the texture format already matches the format and type,
892 * in which case the memcpy-based fast path will be used. */
893 if (_mesa_format_matches_format_and_type(texImage->TexFormat, format,
894 type, ctx->Pack.SwapBytes)) {
898 /* Convert the source format to what is expected by GetTexImage
899 * and see if it's supported.
901 * This only applies to glGetTexImage:
902 * - Luminance must be returned as (L,0,0,1).
903 * - Luminance alpha must be returned as (L,0,0,A).
904 * - Intensity must be returned as (I,0,0,1)
906 src_format = util_format_linear(src->format);
907 src_format = util_format_luminance_to_red(src_format);
908 src_format = util_format_intensity_to_red(src_format);
911 !screen->is_format_supported(screen, src_format, src->target,
913 PIPE_BIND_SAMPLER_VIEW)) {
917 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)
918 bind |= PIPE_BIND_DEPTH_STENCIL;
920 bind |= PIPE_BIND_RENDER_TARGET;
922 /* GetTexImage only returns a single face for cubemaps. */
923 if (gl_target == GL_TEXTURE_CUBE_MAP) {
924 gl_target = GL_TEXTURE_2D;
926 pipe_target = gl_target_to_pipe(gl_target);
928 /* Choose the destination format by finding the best match
929 * for the format+type combo. */
930 dst_format = st_choose_matching_format(screen, bind, format, type,
931 ctx->Pack.SwapBytes);
933 if (dst_format == PIPE_FORMAT_NONE) {
936 /* Fall back to _mesa_get_teximage except for compressed formats,
937 * where decompression with a blit is always preferred. */
938 if (!util_format_is_compressed(src->format)) {
942 /* Set the appropriate format for the decompressed texture.
943 * Luminance and sRGB formats shouldn't appear here.*/
944 switch (src_format) {
945 case PIPE_FORMAT_DXT1_RGB:
946 case PIPE_FORMAT_DXT1_RGBA:
947 case PIPE_FORMAT_DXT3_RGBA:
948 case PIPE_FORMAT_DXT5_RGBA:
949 case PIPE_FORMAT_RGTC1_UNORM:
950 case PIPE_FORMAT_RGTC2_UNORM:
951 case PIPE_FORMAT_ETC1_RGB8:
952 dst_glformat = GL_RGBA8;
954 case PIPE_FORMAT_RGTC1_SNORM:
955 case PIPE_FORMAT_RGTC2_SNORM:
956 if (!ctx->Extensions.EXT_texture_snorm)
958 dst_glformat = GL_RGBA8_SNORM;
960 /* TODO: for BPTC_*FLOAT, set RGBA32F and check for ARB_texture_float */
966 dst_format = st_choose_format(st, dst_glformat, format, type,
967 pipe_target, 0, bind, FALSE);
969 if (dst_format == PIPE_FORMAT_NONE) {
970 /* unable to get an rgba format!?! */
975 /* create the destination texture */
976 memset(&dst_templ, 0, sizeof(dst_templ));
977 dst_templ.target = pipe_target;
978 dst_templ.format = dst_format;
979 dst_templ.bind = bind;
980 dst_templ.usage = PIPE_USAGE_STAGING;
982 st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth,
983 &dst_templ.width0, &dst_templ.height0,
984 &dst_templ.depth0, &dst_templ.array_size);
986 dst = screen->resource_create(screen, &dst_templ);
991 /* From now on, we need the gallium representation of dimensions. */
992 if (gl_target == GL_TEXTURE_1D_ARRAY) {
997 blit.src.resource = src;
998 blit.src.level = texImage->Level;
999 blit.src.format = src_format;
1000 blit.dst.resource = dst;
1002 blit.dst.format = dst->format;
1003 blit.src.box.x = blit.dst.box.x = 0;
1004 blit.src.box.y = blit.dst.box.y = 0;
1005 blit.src.box.z = texImage->Face;
1007 blit.src.box.width = blit.dst.box.width = width;
1008 blit.src.box.height = blit.dst.box.height = height;
1009 blit.src.box.depth = blit.dst.box.depth = depth;
1010 blit.mask = st_get_blit_mask(texImage->_BaseFormat, format);
1011 blit.filter = PIPE_TEX_FILTER_NEAREST;
1012 blit.scissor_enable = FALSE;
1014 /* blit/render/decompress */
1015 st->pipe->blit(st->pipe, &blit);
1017 pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels);
1019 map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ,
1020 0, 0, 0, width, height, depth, &tex_xfer);
1025 mesa_format = st_pipe_format_to_mesa_format(dst_format);
1027 /* copy/pack data into user buffer */
1028 if (_mesa_format_matches_format_and_type(mesa_format, format, type,
1029 ctx->Pack.SwapBytes)) {
1031 const uint bytesPerRow = width * util_format_get_blocksize(dst_format);
1034 for (slice = 0; slice < depth; slice++) {
1035 if (gl_target == GL_TEXTURE_1D_ARRAY) {
1036 /* 1D array textures.
1037 * We need to convert gallium coords to GL coords.
1039 GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1040 width, depth, format,
1042 memcpy(dest, map, bytesPerRow);
1045 ubyte *slice_map = map;
1047 for (row = 0; row < height; row++) {
1048 GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1049 width, height, format,
1050 type, slice, row, 0);
1051 memcpy(dest, slice_map, bytesPerRow);
1052 slice_map += tex_xfer->stride;
1055 map += tex_xfer->layer_stride;
1059 /* format translation via floats */
1063 assert(util_format_is_compressed(src->format));
1065 rgba = malloc(width * 4 * sizeof(GLfloat));
1070 if (ST_DEBUG & DEBUG_FALLBACK)
1071 debug_printf("%s: fallback format translation\n", __FUNCTION__);
1073 for (slice = 0; slice < depth; slice++) {
1074 if (gl_target == GL_TEXTURE_1D_ARRAY) {
1075 /* 1D array textures.
1076 * We need to convert gallium coords to GL coords.
1078 GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1079 width, depth, format,
1082 /* get float[4] rgba row from surface */
1083 pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1,
1086 _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
1087 type, dest, &ctx->Pack, 0);
1090 for (row = 0; row < height; row++) {
1091 GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels,
1092 width, height, format,
1093 type, slice, row, 0);
1095 /* get float[4] rgba row from surface */
1096 pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1,
1099 _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format,
1100 type, dest, &ctx->Pack, 0);
1103 map += tex_xfer->layer_stride;
1112 pipe_transfer_unmap(pipe, tex_xfer);
1114 _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
1115 pipe_resource_reference(&dst, NULL);
1119 _mesa_get_teximage(ctx, format, type, pixels, texImage);
1125 * Do a CopyTexSubImage operation using a read transfer from the source,
1126 * a write transfer to the destination and get_tile()/put_tile() to access
1127 * the pixels/texels.
1129 * Note: srcY=0=TOP of renderbuffer
1132 fallback_copy_texsubimage(struct gl_context *ctx,
1133 struct st_renderbuffer *strb,
1134 struct st_texture_image *stImage,
1136 GLint destX, GLint destY, GLint slice,
1137 GLint srcX, GLint srcY,
1138 GLsizei width, GLsizei height)
1140 struct st_context *st = st_context(ctx);
1141 struct pipe_context *pipe = st->pipe;
1142 struct pipe_transfer *src_trans;
1144 enum pipe_transfer_usage transfer_usage;
1146 unsigned dst_width = width;
1147 unsigned dst_height = height;
1148 unsigned dst_depth = 1;
1150 if (ST_DEBUG & DEBUG_FALLBACK)
1151 debug_printf("%s: fallback processing\n", __FUNCTION__);
1153 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1154 srcY = strb->Base.Height - srcY - height;
1157 map = pipe_transfer_map(pipe,
1159 strb->surface->u.tex.level,
1160 strb->surface->u.tex.first_layer,
1163 width, height, &src_trans);
1165 if ((baseFormat == GL_DEPTH_COMPONENT ||
1166 baseFormat == GL_DEPTH_STENCIL) &&
1167 util_format_is_depth_and_stencil(stImage->pt->format))
1168 transfer_usage = PIPE_TRANSFER_READ_WRITE;
1170 transfer_usage = PIPE_TRANSFER_WRITE;
1172 texDest = st_texture_image_map(st, stImage, transfer_usage,
1173 destX, destY, slice,
1174 dst_width, dst_height, dst_depth);
1176 if (baseFormat == GL_DEPTH_COMPONENT ||
1177 baseFormat == GL_DEPTH_STENCIL) {
1178 const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
1179 ctx->Pixel.DepthBias != 0.0F);
1183 /* determine bottom-to-top vs. top-to-bottom order for src buffer */
1184 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1193 data = malloc(width * sizeof(uint));
1196 /* To avoid a large temp memory allocation, do copy row by row */
1197 for (row = 0; row < height; row++, srcY += yStep) {
1198 pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data);
1200 _mesa_scale_and_bias_depth_uint(ctx, width, data);
1203 if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
1204 pipe_put_tile_z(stImage->transfer,
1205 texDest + row*stImage->transfer->layer_stride,
1206 0, 0, width, 1, data);
1209 pipe_put_tile_z(stImage->transfer, texDest, 0, row, width, 1,
1215 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
1223 malloc(width * height * 4 * sizeof(GLfloat));
1225 if (tempSrc && texDest) {
1226 const GLint dims = 2;
1228 struct gl_texture_image *texImage = &stImage->base;
1229 struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
1231 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
1232 unpack.Invert = GL_TRUE;
1235 if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) {
1236 dstRowStride = stImage->transfer->layer_stride;
1239 dstRowStride = stImage->transfer->stride;
1242 /* get float/RGBA image from framebuffer */
1243 /* XXX this usually involves a lot of int/float conversion.
1244 * try to avoid that someday.
1246 pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height,
1247 util_format_linear(strb->texture->format),
1250 /* Store into texture memory.
1251 * Note that this does some special things such as pixel transfer
1252 * ops and format conversion. In particular, if the dest tex format
1253 * is actually RGBA but the user created the texture as GL_RGB we
1254 * need to fill-in/override the alpha channel with 1.0.
1256 _mesa_texstore(ctx, dims,
1257 texImage->_BaseFormat,
1258 texImage->TexFormat,
1262 GL_RGBA, GL_FLOAT, tempSrc, /* src */
1266 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
1272 st_texture_image_unmap(st, stImage);
1273 pipe->transfer_unmap(pipe, src_trans);
1278 * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
1279 * Note that the region to copy has already been clipped so we know we
1280 * won't read from outside the source renderbuffer's bounds.
1282 * Note: srcY=0=Bottom of renderbuffer (GL convention)
1285 st_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
1286 struct gl_texture_image *texImage,
1287 GLint destX, GLint destY, GLint slice,
1288 struct gl_renderbuffer *rb,
1289 GLint srcX, GLint srcY, GLsizei width, GLsizei height)
1291 struct st_texture_image *stImage = st_texture_image(texImage);
1292 struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
1293 struct st_renderbuffer *strb = st_renderbuffer(rb);
1294 struct st_context *st = st_context(ctx);
1295 struct pipe_context *pipe = st->pipe;
1296 struct pipe_screen *screen = pipe->screen;
1297 struct pipe_blit_info blit;
1298 enum pipe_format dst_format;
1299 GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
1303 if (!strb || !strb->surface || !stImage->pt) {
1304 debug_printf("%s: null strb or stImage\n", __FUNCTION__);
1308 if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat,
1309 texImage->TexFormat)) {
1313 /* The base internal format must match the mesa format, so make sure
1314 * e.g. an RGB internal format is really allocated as RGB and not as RGBA.
1316 if (texImage->_BaseFormat !=
1317 _mesa_get_format_base_format(texImage->TexFormat) ||
1318 rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) {
1322 /* Choose the destination format to match the TexImage behavior. */
1323 dst_format = util_format_linear(stImage->pt->format);
1324 dst_format = util_format_luminance_to_red(dst_format);
1325 dst_format = util_format_intensity_to_red(dst_format);
1327 /* See if the destination format is supported. */
1328 if (texImage->_BaseFormat == GL_DEPTH_STENCIL ||
1329 texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
1330 bind = PIPE_BIND_DEPTH_STENCIL;
1333 bind = PIPE_BIND_RENDER_TARGET;
1337 !screen->is_format_supported(screen, dst_format, stImage->pt->target,
1338 stImage->pt->nr_samples, bind)) {
1342 /* Y flipping for the main framebuffer. */
1344 srcY1 = strb->Base.Height - srcY - height;
1345 srcY0 = srcY1 + height;
1349 srcY1 = srcY0 + height;
1352 /* Blit the texture.
1353 * This supports flipping, format conversions, and downsampling.
1355 memset(&blit, 0, sizeof(blit));
1356 blit.src.resource = strb->texture;
1357 blit.src.format = util_format_linear(strb->surface->format);
1358 blit.src.level = strb->surface->u.tex.level;
1359 blit.src.box.x = srcX;
1360 blit.src.box.y = srcY0;
1361 blit.src.box.z = strb->surface->u.tex.first_layer;
1362 blit.src.box.width = width;
1363 blit.src.box.height = srcY1 - srcY0;
1364 blit.src.box.depth = 1;
1365 blit.dst.resource = stImage->pt;
1366 blit.dst.format = dst_format;
1367 blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level;
1368 blit.dst.box.x = destX;
1369 blit.dst.box.y = destY;
1370 blit.dst.box.z = stImage->base.Face + slice;
1371 blit.dst.box.width = width;
1372 blit.dst.box.height = height;
1373 blit.dst.box.depth = 1;
1374 blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat);
1375 blit.filter = PIPE_TEX_FILTER_NEAREST;
1376 pipe->blit(pipe, &blit);
1380 /* software fallback */
1381 fallback_copy_texsubimage(ctx,
1382 strb, stImage, texImage->_BaseFormat,
1383 destX, destY, slice,
1384 srcX, srcY, width, height);
1389 * Copy image data from stImage into the texture object 'stObj' at level
1393 copy_image_data_to_texture(struct st_context *st,
1394 struct st_texture_object *stObj,
1396 struct st_texture_image *stImage)
1400 const struct gl_texture_image *dstImage =
1401 stObj->base.Image[stImage->base.Face][dstLevel];
1403 assert(dstImage->Width == stImage->base.Width);
1404 assert(dstImage->Height == stImage->base.Height);
1405 assert(dstImage->Depth == stImage->base.Depth);
1409 /* Copy potentially with the blitter:
1412 if (stImage->pt->last_level == 0)
1415 src_level = stImage->base.Level;
1417 assert(src_level <= stImage->pt->last_level);
1418 assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width);
1419 assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY ||
1420 u_minify(stImage->pt->height0, src_level) == stImage->base.Height);
1421 assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY ||
1422 stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY ||
1423 u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth);
1425 st_texture_image_copy(st->pipe,
1426 stObj->pt, dstLevel, /* dest texture, level */
1427 stImage->pt, src_level, /* src texture, level */
1428 stImage->base.Face);
1430 pipe_resource_reference(&stImage->pt, NULL);
1432 else if (stImage->TexData) {
1433 /* Copy from malloc'd memory */
1434 /* XXX this should be re-examined/tested with a compressed format */
1435 GLuint blockSize = util_format_get_blocksize(stObj->pt->format);
1436 GLuint srcRowStride = stImage->base.Width * blockSize;
1437 GLuint srcSliceStride = stImage->base.Height * srcRowStride;
1438 st_texture_image_data(st,
1445 _mesa_align_free(stImage->TexData);
1446 stImage->TexData = NULL;
1449 pipe_resource_reference(&stImage->pt, stObj->pt);
1454 * Called during state validation. When this function is finished,
1455 * the texture object should be ready for rendering.
1456 * \return GL_TRUE for success, GL_FALSE for failure (out of mem)
1459 st_finalize_texture(struct gl_context *ctx,
1460 struct pipe_context *pipe,
1461 struct gl_texture_object *tObj)
1463 struct st_context *st = st_context(ctx);
1464 struct st_texture_object *stObj = st_texture_object(tObj);
1465 const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
1467 struct st_texture_image *firstImage;
1468 enum pipe_format firstImageFormat;
1469 GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples;
1471 if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
1472 /* The texture is complete and we know exactly how many mipmap levels
1473 * are present/needed. This is conditional because we may be called
1474 * from the st_generate_mipmap() function when the texture object is
1475 * incomplete. In that case, we'll have set stObj->lastLevel before
1478 if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
1479 stObj->base.Sampler.MinFilter == GL_NEAREST)
1480 stObj->lastLevel = stObj->base.BaseLevel;
1482 stObj->lastLevel = stObj->base._MaxLevel;
1485 if (tObj->Target == GL_TEXTURE_BUFFER) {
1486 struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject);
1489 pipe_resource_reference(&stObj->pt, NULL);
1490 pipe_sampler_view_reference(&stObj->sampler_view, NULL);
1494 if (st_obj->buffer != stObj->pt) {
1495 pipe_resource_reference(&stObj->pt, st_obj->buffer);
1496 pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1497 stObj->width0 = stObj->pt->width0 / _mesa_get_format_bytes(tObj->_BufferObjectFormat);
1505 firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);
1508 /* If both firstImage and stObj point to a texture which can contain
1509 * all active images, favour firstImage. Note that because of the
1510 * completeness requirement, we know that the image dimensions
1513 if (firstImage->pt &&
1514 firstImage->pt != stObj->pt &&
1515 (!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) {
1516 pipe_resource_reference(&stObj->pt, firstImage->pt);
1517 pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1520 /* If this texture comes from a window system, there is nothing else to do. */
1521 if (stObj->surface_based) {
1525 /* Find gallium format for the Mesa texture */
1526 firstImageFormat = st_mesa_format_to_pipe_format(firstImage->base.TexFormat);
1528 /* Find size of level=0 Gallium mipmap image, plus number of texture layers */
1530 GLuint width, height, depth;
1531 if (!guess_base_level_size(stObj->base.Target,
1532 firstImage->base.Width2,
1533 firstImage->base.Height2,
1534 firstImage->base.Depth2,
1535 firstImage->base.Level,
1536 &width, &height, &depth)) {
1537 width = stObj->width0;
1538 height = stObj->height0;
1539 depth = stObj->depth0;
1541 /* convert GL dims to Gallium dims */
1542 st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth,
1543 &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1544 ptNumSamples = firstImage->base.NumSamples;
1547 /* If we already have a gallium texture, check that it matches the texture
1548 * object's format, target, size, num_levels, etc.
1551 if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
1552 stObj->pt->format != firstImageFormat ||
1553 stObj->pt->last_level < stObj->lastLevel ||
1554 stObj->pt->width0 != ptWidth ||
1555 stObj->pt->height0 != ptHeight ||
1556 stObj->pt->depth0 != ptDepth ||
1557 stObj->pt->nr_samples != ptNumSamples ||
1558 stObj->pt->array_size != ptLayers)
1560 /* The gallium texture does not match the Mesa texture so delete the
1561 * gallium texture now. We'll make a new one below.
1563 pipe_resource_reference(&stObj->pt, NULL);
1564 pipe_sampler_view_release(st->pipe, &stObj->sampler_view);
1565 st->dirty.st |= ST_NEW_FRAMEBUFFER;
1569 /* May need to create a new gallium texture:
1572 GLuint bindings = default_bindings(st, firstImageFormat);
1574 stObj->pt = st_texture_create(st,
1575 gl_target_to_pipe(stObj->base.Target),
1581 ptLayers, ptNumSamples,
1585 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
1590 /* Pull in any images not in the object's texture:
1592 for (face = 0; face < nr_faces; face++) {
1594 for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) {
1595 struct st_texture_image *stImage =
1596 st_texture_image(stObj->base.Image[face][level]);
1598 /* Need to import images in main memory or held in other textures.
1600 if (stImage && stObj->pt != stImage->pt) {
1602 (stImage->base.Width == u_minify(stObj->width0, level) &&
1603 stImage->base.Height == u_minify(stObj->height0, level) &&
1604 stImage->base.Depth == u_minify(stObj->depth0, level))) {
1605 /* src image fits expected dest mipmap level size */
1606 copy_image_data_to_texture(st, stObj, level, stImage);
1617 * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory
1618 * for a whole mipmap stack.
1621 st_AllocTextureStorage(struct gl_context *ctx,
1622 struct gl_texture_object *texObj,
1623 GLsizei levels, GLsizei width,
1624 GLsizei height, GLsizei depth)
1626 const GLuint numFaces = _mesa_num_tex_faces(texObj->Target);
1627 struct gl_texture_image *texImage = texObj->Image[0][0];
1628 struct st_context *st = st_context(ctx);
1629 struct st_texture_object *stObj = st_texture_object(texObj);
1630 struct pipe_screen *screen = st->pipe->screen;
1631 GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings;
1632 enum pipe_format fmt;
1634 GLuint num_samples = texImage->NumSamples;
1638 /* Save the level=0 dimensions */
1639 stObj->width0 = width;
1640 stObj->height0 = height;
1641 stObj->depth0 = depth;
1642 stObj->lastLevel = levels - 1;
1644 fmt = st_mesa_format_to_pipe_format(texImage->TexFormat);
1646 bindings = default_bindings(st, fmt);
1648 /* Raise the sample count if the requested one is unsupported. */
1649 if (num_samples > 1) {
1650 boolean found = FALSE;
1652 for (; num_samples <= ctx->Const.MaxSamples; num_samples++) {
1653 if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D,
1655 PIPE_BIND_SAMPLER_VIEW)) {
1656 /* Update the sample count in gl_texture_image as well. */
1657 texImage->NumSamples = num_samples;
1668 st_gl_texture_dims_to_pipe_dims(texObj->Target,
1669 width, height, depth,
1670 &ptWidth, &ptHeight, &ptDepth, &ptLayers);
1672 stObj->pt = st_texture_create(st,
1673 gl_target_to_pipe(texObj->Target),
1679 ptLayers, num_samples,
1684 /* Set image resource pointers */
1685 for (level = 0; level < levels; level++) {
1687 for (face = 0; face < numFaces; face++) {
1688 struct st_texture_image *stImage =
1689 st_texture_image(texObj->Image[face][level]);
1690 pipe_resource_reference(&stImage->pt, stObj->pt);
1699 st_TestProxyTexImage(struct gl_context *ctx, GLenum target,
1700 GLint level, mesa_format format,
1701 GLint width, GLint height,
1702 GLint depth, GLint border)
1704 struct st_context *st = st_context(ctx);
1705 struct pipe_context *pipe = st->pipe;
1707 if (width == 0 || height == 0 || depth == 0) {
1708 /* zero-sized images are legal, and always fit! */
1712 if (pipe->screen->can_create_resource) {
1713 /* Ask the gallium driver if the texture is too large */
1714 struct gl_texture_object *texObj =
1715 _mesa_get_current_tex_object(ctx, target);
1716 struct pipe_resource pt;
1718 /* Setup the pipe_resource object
1720 memset(&pt, 0, sizeof(pt));
1722 pt.target = gl_target_to_pipe(target);
1723 pt.format = st_mesa_format_to_pipe_format(format);
1725 st_gl_texture_dims_to_pipe_dims(target,
1726 width, height, depth,
1727 &pt.width0, &pt.height0,
1728 &pt.depth0, &pt.array_size);
1730 if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR ||
1731 texObj->Sampler.MinFilter == GL_NEAREST)) {
1732 /* assume just one mipmap level */
1736 /* assume a full set of mipmaps */
1737 pt.last_level = _mesa_logbase2(MAX3(width, height, depth));
1740 return pipe->screen->can_create_resource(pipe->screen, &pt);
1743 /* Use core Mesa fallback */
1744 return _mesa_test_proxy_teximage(ctx, target, level, format,
1745 width, height, depth, border);
1751 st_init_texture_functions(struct dd_function_table *functions)
1753 functions->ChooseTextureFormat = st_ChooseTextureFormat;
1754 functions->QuerySamplesForFormat = st_QuerySamplesForFormat;
1755 functions->TexImage = st_TexImage;
1756 functions->TexSubImage = st_TexSubImage;
1757 functions->CompressedTexSubImage = _mesa_store_compressed_texsubimage;
1758 functions->CopyTexSubImage = st_CopyTexSubImage;
1759 functions->GenerateMipmap = st_generate_mipmap;
1761 functions->GetTexImage = st_GetTexImage;
1763 /* compressed texture functions */
1764 functions->CompressedTexImage = st_CompressedTexImage;
1765 functions->GetCompressedTexImage = _mesa_get_compressed_teximage;
1767 functions->NewTextureObject = st_NewTextureObject;
1768 functions->NewTextureImage = st_NewTextureImage;
1769 functions->DeleteTextureImage = st_DeleteTextureImage;
1770 functions->DeleteTexture = st_DeleteTextureObject;
1771 functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
1772 functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
1773 functions->MapTextureImage = st_MapTextureImage;
1774 functions->UnmapTextureImage = st_UnmapTextureImage;
1776 /* XXX Temporary until we can query pipe's texture sizes */
1777 functions->TestProxyTexImage = st_TestProxyTexImage;
1779 functions->AllocTextureStorage = st_AllocTextureStorage;