X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_texture.c;h=d92a48a5fcfeb2752dc0f365fce0c008469cd4f3;hb=500b0735c0caa293d22fb3728cb76d267a016834;hp=9798321d4bc4d848765ab4f1797da2e18f9b50b2;hpb=f0ecd36ef8e10c087738c92cf62bad3815366963;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c index 9798321d4bc..d92a48a5fcf 100644 --- a/src/mesa/state_tracker/st_cb_texture.c +++ b/src/mesa/state_tracker/st_cb_texture.c @@ -1,8 +1,8 @@ /************************************************************************** - * + * * Copyright 2007 VMware, Inc. * All Rights Reserved. - * + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including @@ -10,11 +10,11 @@ * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. @@ -22,24 +22,26 @@ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * + * **************************************************************************/ #include #include "main/bufferobj.h" #include "main/enums.h" +#include "main/errors.h" #include "main/fbobject.h" #include "main/formats.h" #include "main/format_utils.h" #include "main/glformats.h" #include "main/image.h" -#include "main/imports.h" + #include "main/macros.h" #include "main/mipmap.h" #include "main/pack.h" #include "main/pbo.h" #include "main/pixeltransfer.h" #include "main/texcompress.h" +#include "main/texcompress_astc.h" #include "main/texcompress_etc.h" #include "main/texgetimage.h" #include "main/teximage.h" @@ -53,12 +55,14 @@ #include "state_tracker/st_cb_flush.h" #include "state_tracker/st_cb_texture.h" #include "state_tracker/st_cb_bufferobjects.h" +#include "state_tracker/st_cb_memoryobjects.h" #include "state_tracker/st_format.h" #include "state_tracker/st_pbo.h" #include "state_tracker/st_texture.h" #include "state_tracker/st_gen_mipmap.h" #include "state_tracker/st_atom.h" #include "state_tracker/st_sampler_view.h" +#include "state_tracker/st_util.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" @@ -66,7 +70,7 @@ #include "util/u_upload_mgr.h" #include "pipe/p_shader_tokens.h" #include "util/u_tile.h" -#include "util/u_format.h" +#include "util/format/u_format.h" #include "util/u_surface.h" #include "util/u_sampler.h" #include "util/u_math.h" @@ -150,17 +154,35 @@ static struct gl_texture_object * st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) { struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object); + if (!obj) + return NULL; + + obj->level_override = -1; + obj->layer_override = -1; + + /* Pre-allocate a sampler views container to save a branch in the + * fast path. + */ + obj->sampler_views = calloc(1, sizeof(struct st_sampler_views) + + sizeof(struct st_sampler_view)); + if (!obj->sampler_views) { + free(obj); + return NULL; + } + obj->sampler_views->max = 1; DBG("%s\n", __func__); _mesa_initialize_texture_object(ctx, &obj->base, name, target); + simple_mtx_init(&obj->validate_mutex, mtx_plain); obj->needs_validation = true; return &obj->base; } + /** called via ctx->Driver.DeleteTextureObject() */ -static void +static void st_DeleteTextureObject(struct gl_context *ctx, struct gl_texture_object *texObj) { @@ -168,11 +190,27 @@ st_DeleteTextureObject(struct gl_context *ctx, struct st_texture_object *stObj = st_texture_object(texObj); pipe_resource_reference(&stObj->pt, NULL); - st_texture_release_all_sampler_views(st, stObj); - st_texture_free_sampler_views(stObj); + st_delete_texture_sampler_views(st, stObj); + simple_mtx_destroy(&stObj->validate_mutex); _mesa_delete_texture_object(ctx, texObj); } +/** + * Called via ctx->Driver.TextureRemovedFromShared() + * When texture is removed from ctx->Shared->TexObjects we lose + * the ability to clean up views on context destruction, which may + * lead to dangling pointers to destroyed contexts. + * Release the views to prevent this. + */ +static void +st_TextureReleaseAllSamplerViews(struct gl_context *ctx, + struct gl_texture_object *texObj) +{ + struct st_context *st = st_context(ctx); + struct st_texture_object *stObj = st_texture_object(texObj); + + st_texture_release_all_sampler_views(st, stObj); +} /** called via ctx->Driver.FreeTextureImageBuffer() */ static void @@ -193,9 +231,11 @@ st_FreeTextureImageBuffer(struct gl_context *ctx, stImage->transfer = NULL; stImage->num_transfers = 0; - if (stImage->etc_data) { - free(stImage->etc_data); - stImage->etc_data = NULL; + if (stImage->compressed_data && + pipe_reference(&stImage->compressed_data->reference, NULL)) { + free(stImage->compressed_data->ptr); + free(stImage->compressed_data); + stImage->compressed_data = NULL; } /* if the texture image is being deallocated, the structure of the @@ -205,32 +245,61 @@ st_FreeTextureImageBuffer(struct gl_context *ctx, } bool -st_etc_fallback(struct st_context *st, struct gl_texture_image *texImage) +st_astc_format_fallback(const struct st_context *st, mesa_format format) { - return (_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) || - (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1); + if (!_mesa_is_format_astc_2d(format)) + return false; + + if (format == MESA_FORMAT_RGBA_ASTC_5x5 || + format == MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5) + return !st->has_astc_5x5_ldr; + + return !st->has_astc_2d_ldr; } +bool +st_compressed_format_fallback(struct st_context *st, mesa_format format) +{ + if (format == MESA_FORMAT_ETC1_RGB8) + return !st->has_etc1; + + if (_mesa_is_format_etc2(format)) + return !st->has_etc2; + + if (st_astc_format_fallback(st, format)) + return true; + + return false; +} + + static void -etc_fallback_allocate(struct st_context *st, struct st_texture_image *stImage) +compressed_tex_fallback_allocate(struct st_context *st, + struct st_texture_image *stImage) { struct gl_texture_image *texImage = &stImage->base; - if (!st_etc_fallback(st, texImage)) + if (!st_compressed_format_fallback(st, texImage->TexFormat)) return; - if (stImage->etc_data) - free(stImage->etc_data); + if (stImage->compressed_data && + pipe_reference(&stImage->compressed_data->reference, NULL)) { + free(stImage->compressed_data->ptr); + free(stImage->compressed_data); + } unsigned data_size = _mesa_format_image_size(texImage->TexFormat, texImage->Width2, texImage->Height2, texImage->Depth2); - stImage->etc_data = + stImage->compressed_data = ST_CALLOC_STRUCT(st_compressed_data); + stImage->compressed_data->ptr = malloc(data_size * _mesa_num_tex_faces(texImage->TexObject->Target)); + pipe_reference_init(&stImage->compressed_data->reference, 1); } + /** called via ctx->Driver.MapTextureImage() */ static void st_MapTextureImage(struct gl_context *ctx, @@ -241,38 +310,44 @@ st_MapTextureImage(struct gl_context *ctx, { struct st_context *st = st_context(ctx); struct st_texture_image *stImage = st_texture_image(texImage); - unsigned pipeMode; GLubyte *map; struct pipe_transfer *transfer; - pipeMode = 0x0; - if (mode & GL_MAP_READ_BIT) - pipeMode |= PIPE_TRANSFER_READ; - if (mode & GL_MAP_WRITE_BIT) - pipeMode |= PIPE_TRANSFER_WRITE; - if (mode & GL_MAP_INVALIDATE_RANGE_BIT) - pipeMode |= PIPE_TRANSFER_DISCARD_RANGE; + /* Check for unexpected flags */ + assert((mode & ~(GL_MAP_READ_BIT | + GL_MAP_WRITE_BIT | + GL_MAP_INVALIDATE_RANGE_BIT)) == 0); - map = st_texture_image_map(st, stImage, pipeMode, x, y, slice, w, h, 1, + const enum pipe_transfer_usage transfer_flags = + st_access_flags_to_transfer_flags(mode, false); + + map = st_texture_image_map(st, stImage, transfer_flags, x, y, slice, w, h, 1, &transfer); if (map) { - if (st_etc_fallback(st, texImage)) { - /* ETC isn't supported by all gallium drivers, where it's represented - * by uncompressed formats. We store the compressed data (as it's - * needed for image copies in OES_copy_image), and decompress as - * necessary in Unmap. + if (st_compressed_format_fallback(st, texImage->TexFormat)) { + /* Some compressed formats don't have to be supported by drivers, + * and st/mesa transparently handles decompression on upload (Unmap), + * so that drivers don't see the compressed formats. * - * Note: all ETC1/ETC2 formats have 4x4 block sizes. + * We store the compressed data (it's needed for glGetCompressedTex- + * Image and image copies in OES_copy_image). */ unsigned z = transfer->box.z; struct st_texture_image_transfer *itransfer = &stImage->transfer[z]; - unsigned bytes = _mesa_get_format_bytes(texImage->TexFormat); + unsigned blk_w, blk_h; + _mesa_get_format_block_size(texImage->TexFormat, &blk_w, &blk_h); + + unsigned y_blocks = DIV_ROUND_UP(texImage->Height2, blk_h); unsigned stride = *rowStrideOut = itransfer->temp_stride = _mesa_format_row_stride(texImage->TexFormat, texImage->Width2); + unsigned block_size = _mesa_get_format_bytes(texImage->TexFormat); + + assert(stImage->compressed_data); *mapOut = itransfer->temp_data = - stImage->etc_data + ((x / 4) * bytes + (y / 4) * stride) + - z * stride * texImage->Height2 / 4; + stImage->compressed_data->ptr + + (z * y_blocks + (y / blk_h)) * stride + + (x / blk_w) * block_size; itransfer->map = map; } else { @@ -297,8 +372,9 @@ st_UnmapTextureImage(struct gl_context *ctx, struct st_context *st = st_context(ctx); struct st_texture_image *stImage = st_texture_image(texImage); - if (st_etc_fallback(st, texImage)) { - /* Decompress the ETC texture to the mapped one. */ + if (st_compressed_format_fallback(st, texImage->TexFormat)) { + /* Decompress the compressed image on upload if the driver doesn't + * support the compressed format. */ unsigned z = slice + stImage->base.Face; struct st_texture_image_transfer *itransfer = &stImage->transfer[z]; struct pipe_transfer *transfer = itransfer->transfer; @@ -310,13 +386,24 @@ st_UnmapTextureImage(struct gl_context *ctx, _mesa_etc1_unpack_rgba8888(itransfer->map, transfer->stride, itransfer->temp_data, itransfer->temp_stride, - transfer->box.width, transfer->box.height); - } - else { + transfer->box.width, + transfer->box.height); + } else if (_mesa_is_format_etc2(texImage->TexFormat)) { + bool bgra = stImage->pt->format == PIPE_FORMAT_B8G8R8A8_SRGB; _mesa_unpack_etc2_format(itransfer->map, transfer->stride, - itransfer->temp_data, itransfer->temp_stride, + itransfer->temp_data, + itransfer->temp_stride, + transfer->box.width, transfer->box.height, + texImage->TexFormat, + bgra); + } else if (_mesa_is_format_astc_2d(texImage->TexFormat)) { + _mesa_unpack_astc_2d_ldr(itransfer->map, transfer->stride, + itransfer->temp_data, + itransfer->temp_stride, transfer->box.width, transfer->box.height, texImage->TexFormat); + } else { + unreachable("unexpected format for a compressed format fallback"); } } @@ -344,13 +431,13 @@ default_bindings(struct st_context *st, enum pipe_format format) else bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET; - if (screen->is_format_supported(screen, format, target, 0, bindings)) + if (screen->is_format_supported(screen, format, target, 0, 0, bindings)) return bindings; else { /* Try non-sRGB. */ format = util_format_linear(format); - if (screen->is_format_supported(screen, format, target, 0, bindings)) + if (screen->is_format_supported(screen, format, target, 0, 0, bindings)) return bindings; else return PIPE_BIND_SAMPLER_VIEW; @@ -371,7 +458,7 @@ static GLboolean guess_base_level_size(GLenum target, GLuint width, GLuint height, GLuint depth, GLuint level, GLuint *width0, GLuint *height0, GLuint *depth0) -{ +{ assert(width >= 1); assert(height >= 1); assert(depth >= 1); @@ -462,6 +549,17 @@ allocate_full_mipmap(const struct st_texture_object *stObj, if (stImage->base.Level > 0 || stObj->base.GenerateMipmap) return TRUE; + /* If the application has explicitly called glTextureParameter to set + * GL_TEXTURE_MAX_LEVEL, such that (max - base) > 0, then they're trying + * to communicate that they will have multiple miplevels. + * + * Core Mesa will initialize MaxLevel to value much larger than + * MAX_TEXTURE_LEVELS, so we check that to see if it's been set at all. + */ + if (stObj->base.MaxLevel < MAX_TEXTURE_LEVELS && + stObj->base.MaxLevel - stObj->base.BaseLevel > 0) + return TRUE; + if (stImage->base._BaseFormat == GL_DEPTH_COMPONENT || stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) /* depth/stencil textures are seldom mipmapped */ @@ -475,6 +573,18 @@ allocate_full_mipmap(const struct st_texture_object *stObj, /* not a mipmap minification filter */ return FALSE; + /* If the following sequence of GL calls is used: + * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, ... + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + * + * we would needlessly allocate a mipmapped texture, because the initial + * MinFilter is GL_NEAREST_MIPMAP_LINEAR. Catch this case and don't + * allocate a mipmapped texture by default. This may cause texture + * reallocation later, but GL_NEAREST_MIPMAP_LINEAR is pretty rare. + */ + if (stObj->base.Sampler.MinFilter == GL_NEAREST_MIPMAP_LINEAR) + return FALSE; + if (stObj->base.Target == GL_TEXTURE_3D) /* 3D textures are seldom mipmapped */ return FALSE; @@ -493,8 +603,8 @@ allocate_full_mipmap(const struct st_texture_object *stObj, */ static GLboolean guess_and_alloc_texture(struct st_context *st, - struct st_texture_object *stObj, - const struct st_texture_image *stImage) + struct st_texture_object *stObj, + const struct st_texture_image *stImage) { const struct gl_texture_image *firstImage; GLuint lastLevel, width, height, depth; @@ -599,7 +709,6 @@ st_AllocTextureImageBuffer(struct gl_context *ctx, struct st_context *st = st_context(ctx); struct st_texture_image *stImage = st_texture_image(texImage); struct st_texture_object *stObj = st_texture_object(texImage->TexObject); - const GLuint level = texImage->Level; GLuint width = texImage->Width; GLuint height = texImage->Height; GLuint depth = texImage->Depth; @@ -610,30 +719,35 @@ st_AllocTextureImageBuffer(struct gl_context *ctx, stObj->needs_validation = true; - etc_fallback_allocate(st, stImage); + compressed_tex_fallback_allocate(st, stImage); + const bool allowAllocateToStObj = !stObj->pt || + stObj->pt->last_level == 0 || + texImage->Level == 0; - /* Look if the parent texture object has space for this image */ - if (stObj->pt && - level <= stObj->pt->last_level && - st_texture_match_image(st, stObj->pt, texImage)) { - /* this image will fit in the existing texture object's memory */ - pipe_resource_reference(&stImage->pt, stObj->pt); - return GL_TRUE; - } + if (allowAllocateToStObj) { + /* Look if the parent texture object has space for this image */ + if (stObj->pt && + st_texture_match_image(st, stObj->pt, texImage)) { + /* this image will fit in the existing texture object's memory */ + pipe_resource_reference(&stImage->pt, stObj->pt); + assert(stImage->pt); + return GL_TRUE; + } - /* The parent texture object does not have space for this image */ + /* The parent texture object does not have space for this image */ - pipe_resource_reference(&stObj->pt, NULL); - st_texture_release_all_sampler_views(st, stObj); + pipe_resource_reference(&stObj->pt, NULL); + st_texture_release_all_sampler_views(st, stObj); - if (!guess_and_alloc_texture(st, stObj, stImage)) { - /* Probably out of memory. - * Try flushing any pending rendering, then retry. - */ - st_finish(st); if (!guess_and_alloc_texture(st, stObj, stImage)) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); - return GL_FALSE; + /* Probably out of memory. + * Try flushing any pending rendering, then retry. + */ + st_finish(st); + if (!guess_and_alloc_texture(st, stObj, stImage)) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); + return GL_FALSE; + } } } @@ -692,7 +806,10 @@ prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage, const GLuint level = texImage->Level; mesa_format texFormat; - _mesa_clear_texture_object(ctx, texObj); + assert(!st_texture_image(texImage)->pt); + _mesa_clear_texture_object(ctx, texObj, texImage); + stObj->layer_override = -1; + stObj->level_override = -1; pipe_resource_reference(&stObj->pt, NULL); /* oops, need to init this image again */ @@ -743,6 +860,7 @@ st_get_blit_mask(GLenum srcFormat, GLenum dstFormat) case GL_STENCIL_INDEX: switch (srcFormat) { + case GL_DEPTH_STENCIL: case GL_STENCIL_INDEX: return PIPE_MASK_S; default: @@ -783,6 +901,7 @@ unswizzle_format(enum pipe_format format) } } + /** * Converts PIPE_FORMAT_A* to PIPE_FORMAT_R*. */ @@ -823,6 +942,7 @@ alpha_to_red(enum pipe_format format) } } + /** * Converts PIPE_FORMAT_R*A* to PIPE_FORMAT_R*G*. */ @@ -863,6 +983,7 @@ red_alpha_to_red_green(enum pipe_format format) } } + /** * Converts PIPE_FORMAT_L*A* to PIPE_FORMAT_R*G*. */ @@ -903,6 +1024,7 @@ luminance_alpha_to_red_green(enum pipe_format format) } } + /** * Returns true if format is a PIPE_FORMAT_A* format, and false otherwise. */ @@ -921,6 +1043,7 @@ format_is_alpha(enum pipe_format format) return false; } + /** * Returns true if format is a PIPE_FORMAT_R* format, and false otherwise. */ @@ -976,6 +1099,7 @@ format_is_red_alpha(enum pipe_format format) return false; } + static bool format_is_swizzled_rgba(enum pipe_format format) { @@ -990,6 +1114,7 @@ format_is_swizzled_rgba(enum pipe_format format) return true; } + struct format_table { unsigned char swizzle[4]; @@ -1151,7 +1276,6 @@ try_pbo_upload_common(struct gl_context *ctx, return false; cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS | - CSO_BIT_FRAGMENT_SAMPLERS | CSO_BIT_VERTEX_ELEMENTS | CSO_BIT_AUX_VERTEX_BUFFER_SLOT | CSO_BIT_FRAMEBUFFER | @@ -1160,7 +1284,7 @@ try_pbo_upload_common(struct gl_context *ctx, CSO_BIT_DEPTH_STENCIL_ALPHA | CSO_BIT_RASTERIZER | CSO_BIT_STREAM_OUTPUTS | - CSO_BIT_PAUSE_QUERIES | + (st->active_queries ? CSO_BIT_PAUSE_QUERIES : 0) | CSO_BIT_SAMPLE_MASK | CSO_BIT_MIN_SAMPLES | CSO_BIT_RENDER_CONDITION | @@ -1175,8 +1299,6 @@ try_pbo_upload_common(struct gl_context *ctx, { struct pipe_sampler_view templ; struct pipe_sampler_view *sampler_view; - struct pipe_sampler_state sampler = {0}; - const struct pipe_sampler_state *samplers[1] = {&sampler}; memset(&templ, 0, sizeof(templ)); templ.target = PIPE_BUFFER; @@ -1196,8 +1318,6 @@ try_pbo_upload_common(struct gl_context *ctx, cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view); pipe_sampler_view_reference(&sampler_view, NULL); - - cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers); } /* Framebuffer_state */ @@ -1207,11 +1327,9 @@ try_pbo_upload_common(struct gl_context *ctx, fb.width = surface->width; fb.height = surface->height; fb.nr_cbufs = 1; - pipe_surface_reference(&fb.cbufs[0], surface); + fb.cbufs[0] = surface; cso_set_framebuffer(cso, &fb); - - pipe_surface_reference(&fb.cbufs[0], NULL); } cso_set_viewport_dims(cso, surface->width, surface->height, FALSE); @@ -1238,6 +1356,7 @@ fail: return success; } + static bool try_pbo_upload(struct gl_context *ctx, GLuint dims, struct gl_texture_image *texImage, @@ -1279,7 +1398,8 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims, * support at all because of the remapping we later perform and because * at least the Radeon driver actually supports some formats for texture * buffers which it doesn't support for regular textures. */ - src_format = st_choose_matching_format(st, 0, format, type, unpack->SwapBytes); + src_format = st_choose_matching_format(st, 0, format, type, + unpack->SwapBytes); if (!src_format) { return false; } @@ -1302,13 +1422,13 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims, if (dst_format != orig_dst_format && !screen->is_format_supported(screen, dst_format, PIPE_TEXTURE_2D, 0, - PIPE_BIND_RENDER_TARGET)) { + 0, PIPE_BIND_RENDER_TARGET)) { return false; } } if (!src_format || - !screen->is_format_supported(screen, src_format, PIPE_BUFFER, 0, + !screen->is_format_supported(screen, src_format, PIPE_BUFFER, 0, 0, PIPE_BIND_SAMPLER_VIEW)) { return false; } @@ -1327,7 +1447,8 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims, /* Set up the surface */ { - unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; + unsigned level = stObj->pt != stImage->pt + ? 0 : texImage->TexObject->MinLevel + texImage->Level; unsigned max_layer = util_max_layer(texture, level); zoffset += texImage->Face + texImage->TexObject->MinLayer; @@ -1351,6 +1472,7 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims, return success; } + static void st_TexSubImage(struct gl_context *ctx, GLuint dims, struct gl_texture_image *texImage, @@ -1376,6 +1498,7 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, GLubyte *map; unsigned dstz = texImage->Face + texImage->TexObject->MinLayer; unsigned dst_level = 0; + bool throttled = false; st_flush_bitmap_cache(st); st_invalidate_readpix_cache(st); @@ -1384,6 +1507,7 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, dst_level = texImage->TexObject->MinLevel + texImage->Level; assert(!_mesa_is_format_etc2(texImage->TexFormat) && + !_mesa_is_format_astc_2d(texImage->TexFormat) && texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); if (!dst) @@ -1391,7 +1515,7 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, /* Try texture_subdata, which should be the fastest memcpy path. */ if (pixels && - !_mesa_is_bufferobj(unpack->BufferObj) && + !unpack->BufferObj && _mesa_texstore_can_use_memcpy(ctx, texImage->_BaseFormat, texImage->TexFormat, format, type, unpack)) { @@ -1414,6 +1538,10 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, layer_stride = stride; } + util_throttle_memory_usage(pipe, &st->throttle, + (uint64_t) width * height * depth * + util_format_get_blocksize(dst->format)); + u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box); pipe->texture_subdata(pipe, dst, dst_level, 0, &box, data, stride, layer_stride); @@ -1452,11 +1580,12 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, if (!dst_format || !screen->is_format_supported(screen, dst_format, dst->target, - dst->nr_samples, bind)) { + dst->nr_samples, dst->nr_storage_samples, + bind)) { goto fallback; } - if (_mesa_is_bufferobj(unpack->BufferObj)) { + if (unpack->BufferObj) { if (try_pbo_upload(ctx, dims, texImage, format, type, dst_format, xoffset, yoffset, zoffset, width, height, depth, pixels, unpack)) @@ -1512,12 +1641,17 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, /* Check for NPOT texture support. */ if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) && - (!util_is_power_of_two(src_templ.width0) || - !util_is_power_of_two(src_templ.height0) || - !util_is_power_of_two(src_templ.depth0))) { + (!util_is_power_of_two_or_zero(src_templ.width0) || + !util_is_power_of_two_or_zero(src_templ.height0) || + !util_is_power_of_two_or_zero(src_templ.depth0))) { goto fallback; } + util_throttle_memory_usage(pipe, &st->throttle, + (uint64_t) width * height * depth * + util_format_get_blocksize(src_templ.format)); + throttled = true; + /* Create the source texture. */ src = screen->resource_create(screen, &src_templ); if (!src) { @@ -1608,11 +1742,17 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims, return; fallback: + if (!throttled) { + util_throttle_memory_usage(pipe, &st->throttle, + (uint64_t) width * height * depth * + _mesa_get_format_bytes(texImage->TexFormat)); + } _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels, unpack); } + static void st_TexImage(struct gl_context * ctx, GLuint dims, struct gl_texture_image *texImage, @@ -1665,13 +1805,11 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims, goto fallback; } - if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj)) + if (!ctx->Unpack.BufferObj) goto fallback; - if (st_etc_fallback(st, texImage)) { - /* ETC isn't supported and is represented by uncompressed formats. */ + if (st_compressed_format_fallback(st, texImage->TexFormat)) goto fallback; - } if (!dst) { goto fallback; @@ -1698,13 +1836,14 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims, goto fallback; } - if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0, + if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0, 0, PIPE_BIND_SAMPLER_VIEW)) { goto fallback; } if (!screen->is_format_supported(screen, copy_format, dst->target, - dst->nr_samples, PIPE_BIND_RENDER_TARGET)) { + dst->nr_samples, dst->nr_storage_samples, + PIPE_BIND_RENDER_TARGET)) { goto fallback; } @@ -1731,13 +1870,15 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims, addr.pixels_per_row = store.TotalBytesPerRow / addr.bytes_per_pixel; addr.image_height = store.TotalRowsPerSlice; - if (!st_pbo_addresses_setup(st, st_buffer_object(ctx->Unpack.BufferObj)->buffer, + if (!st_pbo_addresses_setup(st, + st_buffer_object(ctx->Unpack.BufferObj)->buffer, buf_offset, &addr)) goto fallback; /* Set up the surface. */ { - unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; + unsigned level = stObj->pt != stImage->pt + ? 0 : texImage->TexObject->MinLevel + texImage->Level; unsigned max_layer = util_max_layer(texture, level); z += texImage->Face + texImage->TexObject->MinLayer; @@ -1767,6 +1908,7 @@ fallback: format, imageSize, data); } + static void st_CompressedTexImage(struct gl_context *ctx, GLuint dims, struct gl_texture_image *texImage, @@ -1803,8 +1945,6 @@ st_CompressedTexImage(struct gl_context *ctx, GLuint dims, } - - /** * Called via ctx->Driver.GetTexSubImage() * @@ -1846,6 +1986,7 @@ st_GetTexSubImage(struct gl_context * ctx, boolean done = FALSE; assert(!_mesa_is_format_etc2(texImage->TexFormat) && + !_mesa_is_format_astc_2d(texImage->TexFormat) && texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); st_flush_bitmap_cache(st); @@ -1898,7 +2039,7 @@ st_GetTexSubImage(struct gl_context * ctx, if (!src_format || !screen->is_format_supported(screen, src_format, src->target, - src->nr_samples, + src->nr_samples, src->nr_storage_samples, PIPE_BIND_SAMPLER_VIEW)) { goto fallback; } @@ -1917,7 +2058,7 @@ st_GetTexSubImage(struct gl_context * ctx, /* Choose the destination format by finding the best match * for the format+type combo. */ dst_format = st_choose_matching_format(st, bind, format, type, - ctx->Pack.SwapBytes); + ctx->Pack.SwapBytes); if (dst_format == PIPE_FORMAT_NONE) { GLenum dst_glformat; @@ -1938,7 +2079,26 @@ st_GetTexSubImage(struct gl_context * ctx, case PIPE_FORMAT_RGTC1_UNORM: case PIPE_FORMAT_RGTC2_UNORM: case PIPE_FORMAT_ETC1_RGB8: + case PIPE_FORMAT_ETC2_RGB8: + case PIPE_FORMAT_ETC2_RGB8A1: + case PIPE_FORMAT_ETC2_RGBA8: + case PIPE_FORMAT_ASTC_4x4: + case PIPE_FORMAT_ASTC_5x4: + case PIPE_FORMAT_ASTC_5x5: + case PIPE_FORMAT_ASTC_6x5: + case PIPE_FORMAT_ASTC_6x6: + case PIPE_FORMAT_ASTC_8x5: + case PIPE_FORMAT_ASTC_8x6: + case PIPE_FORMAT_ASTC_8x8: + case PIPE_FORMAT_ASTC_10x5: + case PIPE_FORMAT_ASTC_10x6: + case PIPE_FORMAT_ASTC_10x8: + case PIPE_FORMAT_ASTC_10x10: + case PIPE_FORMAT_ASTC_12x10: + case PIPE_FORMAT_ASTC_12x12: case PIPE_FORMAT_BPTC_RGBA_UNORM: + case PIPE_FORMAT_FXT1_RGB: + case PIPE_FORMAT_FXT1_RGBA: dst_glformat = GL_RGBA8; break; case PIPE_FORMAT_RGTC1_SNORM: @@ -1953,13 +2113,38 @@ st_GetTexSubImage(struct gl_context * ctx, goto fallback; dst_glformat = GL_RGBA32F; break; + case PIPE_FORMAT_ETC2_R11_UNORM: + if (!screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, + pipe_target, 0, 0, bind)) + goto fallback; + dst_glformat = GL_R16; + break; + case PIPE_FORMAT_ETC2_R11_SNORM: + if (!screen->is_format_supported(screen, PIPE_FORMAT_R16_SNORM, + pipe_target, 0, 0, bind)) + goto fallback; + dst_glformat = GL_R16_SNORM; + break; + case PIPE_FORMAT_ETC2_RG11_UNORM: + if (!screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, + pipe_target, 0, 0, bind)) + goto fallback; + dst_glformat = GL_RG16; + break; + case PIPE_FORMAT_ETC2_RG11_SNORM: + if (!screen->is_format_supported(screen, PIPE_FORMAT_R16G16_SNORM, + pipe_target, 0, 0, bind)) + goto fallback; + dst_glformat = GL_RG16_SNORM; + break; default: assert(0); goto fallback; } dst_format = st_choose_format(st, dst_glformat, format, type, - pipe_target, 0, bind, FALSE); + pipe_target, 0, 0, bind, + false, false); if (dst_format == PIPE_FORMAT_NONE) { /* unable to get an rgba format!?! */ @@ -2078,8 +2263,8 @@ st_GetTexSubImage(struct gl_context * ctx, slice, 0, 0); /* get float[4] rgba row from surface */ - pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, height, - dst_format, rgba); + pipe_get_tile_rgba(tex_xfer, map, 0, 0, width, height, dst_format, + rgba); _mesa_format_convert(dest, dstMesaFormat, dstStride, rgba, RGBA32_FLOAT, srcStride, @@ -2155,6 +2340,10 @@ fallback_copy_texsubimage(struct gl_context *ctx, PIPE_TRANSFER_READ, srcX, srcY, width, height, &src_trans); + if (!map) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()"); + return; + } if ((baseFormat == GL_DEPTH_COMPONENT || baseFormat == GL_DEPTH_STENCIL) && @@ -2167,6 +2356,10 @@ fallback_copy_texsubimage(struct gl_context *ctx, destX, destY, slice, dst_width, dst_height, dst_depth, &transfer); + if (!texDest) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()"); + goto err; + } if (baseFormat == GL_DEPTH_COMPONENT || baseFormat == GL_DEPTH_STENCIL) { @@ -2188,20 +2381,19 @@ fallback_copy_texsubimage(struct gl_context *ctx, data = malloc(width * sizeof(uint)); if (data) { + unsigned dst_stride = (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY ? + transfer->layer_stride : transfer->stride); /* To avoid a large temp memory allocation, do copy row by row */ for (row = 0; row < height; row++, srcY += yStep) { - pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data); + util_format_unpack_z_32unorm(strb->texture->format, + data, (uint8_t *)map + src_trans->stride * srcY, + width); if (scaleOrBias) { _mesa_scale_and_bias_depth_uint(ctx, width, data); } - if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { - pipe_put_tile_z(transfer, texDest + row*transfer->layer_stride, - 0, 0, width, 1, data); - } - else { - pipe_put_tile_z(transfer, texDest, 0, row, width, 1, data); - } + util_format_pack_z_32unorm(stImage->pt->format, + texDest + row * dst_stride, data, width); } } else { @@ -2215,7 +2407,7 @@ fallback_copy_texsubimage(struct gl_context *ctx, GLfloat *tempSrc = malloc(width * height * 4 * sizeof(GLfloat)); - if (tempSrc && texDest) { + if (tempSrc) { const GLint dims = 2; GLint dstRowStride; struct gl_texture_image *texImage = &stImage->base; @@ -2236,9 +2428,9 @@ fallback_copy_texsubimage(struct gl_context *ctx, /* XXX this usually involves a lot of int/float conversion. * try to avoid that someday. */ - pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height, - util_format_linear(strb->texture->format), - tempSrc); + pipe_get_tile_rgba(src_trans, map, 0, 0, width, height, + util_format_linear(strb->texture->format), + tempSrc); /* Store into texture memory. * Note that this does some special things such as pixel transfer @@ -2247,8 +2439,8 @@ fallback_copy_texsubimage(struct gl_context *ctx, * need to fill-in/override the alpha channel with 1.0. */ _mesa_texstore(ctx, dims, - texImage->_BaseFormat, - texImage->TexFormat, + texImage->_BaseFormat, + texImage->TexFormat, dstRowStride, &texDest, width, height, 1, @@ -2263,10 +2455,38 @@ fallback_copy_texsubimage(struct gl_context *ctx, } st_texture_image_unmap(st, stImage, slice); +err: pipe->transfer_unmap(pipe, src_trans); } +static bool +st_can_copyteximage_using_blit(const struct gl_texture_image *texImage, + const struct gl_renderbuffer *rb) +{ + GLenum tex_baseformat = _mesa_get_format_base_format(texImage->TexFormat); + + /* We don't blit to a teximage where the GL base format doesn't match the + * texture's chosen format, except in the case of a GL_RGB texture + * represented with GL_RGBA (where the alpha channel is just being + * dropped). + */ + if (texImage->_BaseFormat != tex_baseformat && + ((texImage->_BaseFormat != GL_RGB || tex_baseformat != GL_RGBA))) { + return false; + } + + /* We can't blit from a RB where the GL base format doesn't match the RB's + * chosen format (for example, GL RGB or ALPHA with rb->Format of an RGBA + * type, because the other channels will be undefined). + */ + if (rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) + return false; + + return true; +} + + /** * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible. * Note that the region to copy has already been clipped so we know we @@ -2297,6 +2517,7 @@ st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, st_invalidate_readpix_cache(st); assert(!_mesa_is_format_etc2(texImage->TexFormat) && + !_mesa_is_format_astc_2d(texImage->TexFormat) && texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); if (!strb || !strb->surface || !stImage->pt) { @@ -2309,12 +2530,7 @@ st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, goto fallback; } - /* The base internal format must match the mesa format, so make sure - * e.g. an RGB internal format is really allocated as RGB and not as RGBA. - */ - if (texImage->_BaseFormat != - _mesa_get_format_base_format(texImage->TexFormat) || - rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) { + if (!st_can_copyteximage_using_blit(texImage, rb)) { goto fallback; } @@ -2334,7 +2550,8 @@ st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, if (!dst_format || !screen->is_format_supported(screen, dst_format, stImage->pt->target, - stImage->pt->nr_samples, bind)) { + stImage->pt->nr_samples, + stImage->pt->nr_storage_samples, bind)) { goto fallback; } @@ -2363,7 +2580,8 @@ st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, blit.src.box.depth = 1; blit.dst.resource = stImage->pt; blit.dst.format = dst_format; - blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level + texImage->TexObject->MinLevel; + blit.dst.level = stObj->pt != stImage->pt + ? 0 : texImage->Level + texImage->TexObject->MinLevel; blit.dst.box.x = destX; blit.dst.box.y = destY; blit.dst.box.z = stImage->base.Face + slice + texImage->TexObject->MinLayer; @@ -2390,13 +2608,13 @@ fallback: */ static void copy_image_data_to_texture(struct st_context *st, - struct st_texture_object *stObj, + struct st_texture_object *stObj, GLuint dstLevel, - struct st_texture_image *stImage) + struct st_texture_image *stImage) { /* debug checks */ { - const struct gl_texture_image *dstImage = + ASSERTED const struct gl_texture_image *dstImage = stObj->base.Image[stImage->base.Face][dstLevel]; assert(dstImage); assert(dstImage->Width == stImage->base.Width); @@ -2439,9 +2657,9 @@ copy_image_data_to_texture(struct st_context *st, */ GLboolean st_finalize_texture(struct gl_context *ctx, - struct pipe_context *pipe, - struct gl_texture_object *tObj, - GLuint cubeMapFace) + struct pipe_context *pipe, + struct gl_texture_object *tObj, + GLuint cubeMapFace) { struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(tObj); @@ -2455,22 +2673,10 @@ st_finalize_texture(struct gl_context *ctx, if (tObj->Immutable) return GL_TRUE; - if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) { - /* The texture is complete and we know exactly how many mipmap levels - * are present/needed. This is conditional because we may be called - * from the st_generate_mipmap() function when the texture object is - * incomplete. In that case, we'll have set stObj->lastLevel before - * we get here. - */ - if (stObj->base.Sampler.MinFilter == GL_LINEAR || - stObj->base.Sampler.MinFilter == GL_NEAREST) - stObj->lastLevel = stObj->base.BaseLevel; - else - stObj->lastLevel = stObj->base._MaxLevel; - } - - firstImage = st_texture_image_const(stObj->base.Image[cubeMapFace][stObj->base.BaseLevel]); - assert(firstImage); + if (tObj->_MipmapComplete) + stObj->lastLevel = stObj->base._MaxLevel; + else if (tObj->_BaseComplete) + stObj->lastLevel = stObj->base.BaseLevel; /* Skip the loop over images in the common case of no images having * changed. But if the GL_BASE_LEVEL or GL_MAX_LEVEL change to something we @@ -2482,6 +2688,15 @@ st_finalize_texture(struct gl_context *ctx, return GL_TRUE; } + /* If this texture comes from a window system, there is nothing else to do. */ + if (stObj->surface_based) { + return GL_TRUE; + } + + firstImage = st_texture_image_const(stObj->base.Image[cubeMapFace] + [stObj->base.BaseLevel]); + assert(firstImage); + /* If both firstImage and stObj point to a texture which can contain * all active images, favour firstImage. Note that because of the * completeness requirement, we know that the image dimensions @@ -2494,11 +2709,6 @@ st_finalize_texture(struct gl_context *ctx, st_texture_release_all_sampler_views(st, stObj); } - /* If this texture comes from a window system, there is nothing else to do. */ - if (stObj->surface_based) { - return GL_TRUE; - } - /* Find gallium format for the Mesa texture */ firstImageFormat = st_mesa_format_to_pipe_format(st, firstImage->base.TexFormat); @@ -2543,6 +2753,18 @@ st_finalize_texture(struct gl_context *ctx, stObj->base.Target == GL_TEXTURE_CUBE_MAP_ARRAY) ptHeight = ptWidth; } + + /* At this point, the texture may be incomplete (mismatched cube + * face sizes, for example). If that's the case, give up, but + * don't return GL_FALSE as that would raise an incorrect + * GL_OUT_OF_MEMORY error. See Piglit fbo-incomplete-texture-03 test. + */ + if (!stObj->base._BaseComplete) { + _mesa_test_texobj_completeness(ctx, &stObj->base); + if (!stObj->base._BaseComplete) { + return TRUE; + } + } } ptNumSamples = firstImage->base.NumSamples; @@ -2637,19 +2859,86 @@ st_finalize_texture(struct gl_context *ctx, /** - * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory - * for a whole mipmap stack. + * Allocate a new pipe_resource object + * width0, height0, depth0 are the dimensions of the level 0 image + * (the highest resolution). last_level indicates how many mipmap levels + * to allocate storage for. For non-mipmapped textures, this will be zero. + */ +static struct pipe_resource * +st_texture_create_from_memory(struct st_context *st, + struct st_memory_object *memObj, + GLuint64 offset, + enum pipe_texture_target target, + enum pipe_format format, + GLuint last_level, + GLuint width0, + GLuint height0, + GLuint depth0, + GLuint layers, + GLuint nr_samples, + GLuint bind) +{ + struct pipe_resource pt, *newtex; + struct pipe_screen *screen = st->pipe->screen; + + assert(target < PIPE_MAX_TEXTURE_TYPES); + assert(width0 > 0); + assert(height0 > 0); + assert(depth0 > 0); + if (target == PIPE_TEXTURE_CUBE) + assert(layers == 6); + + DBG("%s target %d format %s last_level %d\n", __func__, + (int) target, util_format_name(format), last_level); + + assert(format); + assert(screen->is_format_supported(screen, format, target, 0, 0, + PIPE_BIND_SAMPLER_VIEW)); + + memset(&pt, 0, sizeof(pt)); + pt.target = target; + pt.format = format; + pt.last_level = last_level; + pt.width0 = width0; + pt.height0 = height0; + pt.depth0 = depth0; + pt.array_size = layers; + pt.usage = PIPE_USAGE_DEFAULT; + pt.bind = bind; + /* only set this for OpenGL textures, not renderbuffers */ + pt.flags = PIPE_RESOURCE_FLAG_TEXTURING_MORE_LIKELY; + if (memObj->TextureTiling == GL_LINEAR_TILING_EXT) + pt.bind |= PIPE_BIND_LINEAR; + + pt.nr_samples = nr_samples; + pt.nr_storage_samples = nr_samples; + + newtex = screen->resource_from_memobj(screen, &pt, memObj->memory, offset); + + assert(!newtex || pipe_is_referenced(&newtex->reference)); + + return newtex; +} + + +/** + * Allocate texture memory for a whole mipmap stack. + * Note: for multisample textures if the requested sample count is not + * supported, we search for the next higher supported sample count. */ static GLboolean -st_AllocTextureStorage(struct gl_context *ctx, - struct gl_texture_object *texObj, - GLsizei levels, GLsizei width, - GLsizei height, GLsizei depth) +st_texture_storage(struct gl_context *ctx, + struct gl_texture_object *texObj, + GLsizei levels, GLsizei width, + GLsizei height, GLsizei depth, + struct gl_memory_object *memObj, + GLuint64 offset) { const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); struct gl_texture_image *texImage = texObj->Image[0][0]; struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(texObj); + struct st_memory_object *smObj = st_memory_object(memObj); struct pipe_screen *screen = st->pipe->screen; unsigned ptWidth, bindings; uint16_t ptHeight, ptDepth, ptLayers; @@ -2665,13 +2954,27 @@ st_AllocTextureStorage(struct gl_context *ctx, bindings = default_bindings(st, fmt); - /* Raise the sample count if the requested one is unsupported. */ - if (num_samples > 1) { + if (smObj) { + smObj->TextureTiling = texObj->TextureTiling; + bindings |= PIPE_BIND_SHARED; + } + + if (num_samples > 0) { + /* Find msaa sample count which is actually supported. For example, + * if the user requests 1x but only 4x or 8x msaa is supported, we'll + * choose 4x here. + */ + enum pipe_texture_target ptarget = gl_target_to_pipe(texObj->Target); boolean found = FALSE; + if (ctx->Const.MaxSamples > 1 && num_samples == 1) { + /* don't try num_samples = 1 with drivers that support real msaa */ + num_samples = 2; + } + for (; num_samples <= ctx->Const.MaxSamples; num_samples++) { - if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, - num_samples, + if (screen->is_format_supported(screen, fmt, ptarget, + num_samples, num_samples, PIPE_BIND_SAMPLER_VIEW)) { /* Update the sample count in gl_texture_image as well. */ texImage->NumSamples = num_samples; @@ -2689,15 +2992,31 @@ st_AllocTextureStorage(struct gl_context *ctx, width, height, depth, &ptWidth, &ptHeight, &ptDepth, &ptLayers); - stObj->pt = st_texture_create(st, - gl_target_to_pipe(texObj->Target), - fmt, - levels - 1, - ptWidth, - ptHeight, - ptDepth, - ptLayers, num_samples, - bindings); + if (smObj) { + stObj->pt = st_texture_create_from_memory(st, + smObj, + offset, + gl_target_to_pipe(texObj->Target), + fmt, + levels - 1, + ptWidth, + ptHeight, + ptDepth, + ptLayers, num_samples, + bindings); + } + else { + stObj->pt = st_texture_create(st, + gl_target_to_pipe(texObj->Target), + fmt, + levels - 1, + ptWidth, + ptHeight, + ptDepth, + ptLayers, num_samples, + bindings); + } + if (!stObj->pt) return GL_FALSE; @@ -2709,7 +3028,7 @@ st_AllocTextureStorage(struct gl_context *ctx, st_texture_image(texObj->Image[face][level]); pipe_resource_reference(&stImage->pt, stObj->pt); - etc_fallback_allocate(st, stImage); + compressed_tex_fallback_allocate(st, stImage); } } @@ -2721,6 +3040,21 @@ st_AllocTextureStorage(struct gl_context *ctx, return GL_TRUE; } +/** + * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory + * for a whole mipmap stack. + */ +static GLboolean +st_AllocTextureStorage(struct gl_context *ctx, + struct gl_texture_object *texObj, + GLsizei levels, GLsizei width, + GLsizei height, GLsizei depth) +{ + return st_texture_storage(ctx, texObj, levels, + width, height, depth, + NULL, 0); +} + static GLboolean st_TestProxyTexImage(struct gl_context *ctx, GLenum target, @@ -2749,6 +3083,7 @@ st_TestProxyTexImage(struct gl_context *ctx, GLenum target, pt.target = gl_target_to_pipe(target); pt.format = st_mesa_format_to_pipe_format(st, format); pt.nr_samples = numSamples; + pt.nr_storage_samples = numSamples; st_gl_texture_dims_to_pipe_dims(target, width, height, depth, @@ -2766,7 +3101,7 @@ st_TestProxyTexImage(struct gl_context *ctx, GLenum target, } else { /* assume a full set of mipmaps */ - pt.last_level = _mesa_logbase2(MAX3(width, height, depth)); + pt.last_level = util_logbase2(MAX3(width, height, depth)); } return pipe->screen->can_create_resource(pipe->screen, &pt); @@ -2801,7 +3136,15 @@ st_TextureView(struct gl_context *ctx, for (face = 0; face < numFaces; face++) { struct st_texture_image *stImage = st_texture_image(texObj->Image[face][level]); + struct st_texture_image *origImage = + st_texture_image(origTexObj->Image[face][level]); pipe_resource_reference(&stImage->pt, tex->pt); + if (origImage && + origImage->compressed_data) { + pipe_reference(NULL, + &origImage->compressed_data->reference); + stImage->compressed_data = origImage->compressed_data; + } } } @@ -2824,6 +3167,42 @@ st_TextureView(struct gl_context *ctx, return GL_TRUE; } + +/** + * Find the mipmap level in 'pt' which matches the level described by + * 'texImage'. + */ +static unsigned +find_mipmap_level(const struct gl_texture_image *texImage, + const struct pipe_resource *pt) +{ + const GLenum target = texImage->TexObject->Target; + GLint texWidth = texImage->Width; + GLint texHeight = texImage->Height; + GLint texDepth = texImage->Depth; + unsigned level, w; + uint16_t h, d, layers; + + st_gl_texture_dims_to_pipe_dims(target, texWidth, texHeight, texDepth, + &w, &h, &d, &layers); + + for (level = 0; level <= pt->last_level; level++) { + if (u_minify(pt->width0, level) == w && + u_minify(pt->height0, level) == h && + u_minify(pt->depth0, level) == d) { + return level; + } + } + + /* If we get here, there must be some sort of inconsistency between + * the Mesa texture object/images and the gallium resource. + */ + debug_printf("Inconsistent textures in find_mipmap_level()\n"); + + return texImage->Level; +} + + static void st_ClearTexSubImage(struct gl_context *ctx, struct gl_texture_image *texImage, @@ -2832,11 +3211,12 @@ st_ClearTexSubImage(struct gl_context *ctx, const void *clearValue) { static const char zeros[16] = {0}; + struct gl_texture_object *texObj = texImage->TexObject; struct st_texture_image *stImage = st_texture_image(texImage); struct pipe_resource *pt = stImage->pt; struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; - unsigned level = texImage->Level; + unsigned level; struct pipe_box box; if (!pt) @@ -2847,11 +3227,26 @@ st_ClearTexSubImage(struct gl_context *ctx, u_box_3d(xoffset, yoffset, zoffset + texImage->Face, width, height, depth, &box); - if (texImage->TexObject->Immutable) { - level += texImage->TexObject->MinLevel; - box.z += texImage->TexObject->MinLayer; + if (texObj->Immutable) { + /* The texture object has to be consistent (no "loose", per-image + * gallium resources). If this texture is a view into another + * texture, we have to apply the MinLevel/Layer offsets. If this is + * not a texture view, the offsets will be zero. + */ + assert(stImage->pt == st_texture_object(texObj)->pt); + level = texImage->Level + texObj->MinLevel; + box.z += texObj->MinLayer; + } + else { + /* Texture level sizes may be inconsistent. We my have "loose", + * per-image gallium resources. The texImage->Level may not match + * the gallium resource texture level. + */ + level = find_mipmap_level(texImage, pt); } + assert(level <= pt->last_level); + pipe->clear_texture(pipe, pt, level, &box, clearValue ? clearValue : zeros); } @@ -2890,6 +3285,18 @@ st_TexParameter(struct gl_context *ctx, } } +static GLboolean +st_SetTextureStorageForMemoryObject(struct gl_context *ctx, + struct gl_texture_object *texObj, + struct gl_memory_object *memObj, + GLsizei levels, GLsizei width, + GLsizei height, GLsizei depth, + GLuint64 offset) +{ + return st_texture_storage(ctx, texObj, levels, + width, height, depth, + memObj, offset); +} static GLuint64 st_NewTextureHandle(struct gl_context *ctx, struct gl_texture_object *texObj, @@ -2905,8 +3312,10 @@ st_NewTextureHandle(struct gl_context *ctx, struct gl_texture_object *texObj, if (!st_finalize_texture(ctx, pipe, texObj, 0)) return 0; - st_convert_sampler(st, texObj, sampObj, &sampler); - view = st_get_texture_sampler_view_from_stobj(st, stObj, sampObj, 0); + st_convert_sampler(st, texObj, sampObj, 0, &sampler); + + /* TODO: Clarify the interaction of ARB_bindless_texture and EXT_texture_sRGB_decode */ + view = st_get_texture_sampler_view_from_stobj(st, stObj, sampObj, 0, true); } else { view = st_get_buffer_sampler_view_from_stobj(st, stObj); } @@ -2943,7 +3352,7 @@ st_NewImageHandle(struct gl_context *ctx, struct gl_image_unit *imgObj) struct pipe_context *pipe = st->pipe; struct pipe_image_view image; - st_convert_image(st, imgObj, &image); + st_convert_image(st, imgObj, &image, GL_READ_WRITE); return pipe->create_image_handle(pipe, &image); } @@ -2985,12 +3394,12 @@ st_init_texture_functions(struct dd_function_table *functions) /* compressed texture functions */ functions->CompressedTexImage = st_CompressedTexImage; - functions->GetCompressedTexSubImage = _mesa_GetCompressedTexSubImage_sw; functions->NewTextureObject = st_NewTextureObject; functions->NewTextureImage = st_NewTextureImage; functions->DeleteTextureImage = st_DeleteTextureImage; functions->DeleteTexture = st_DeleteTextureObject; + functions->TextureRemovedFromShared = st_TextureReleaseAllSamplerViews; functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer; functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer; functions->MapTextureImage = st_MapTextureImage; @@ -3012,4 +3421,7 @@ st_init_texture_functions(struct dd_function_table *functions) functions->NewImageHandle = st_NewImageHandle; functions->DeleteImageHandle = st_DeleteImageHandle; functions->MakeImageHandleResident = st_MakeImageHandleResident; + + /* external object functions */ + functions->SetTextureStorageForMemoryObject = st_SetTextureStorageForMemoryObject; }