X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_gen_mipmap.c;h=90b0b2d97450ca29bc339ec80fff05686277b466;hb=500b0735c0caa293d22fb3728cb76d267a016834;hp=5b7a96203793cf850c5869891b0f4514baee4477;hpb=ccd13da0fc1f1813b55fc0d2181a6cb0d3b42b0d;p=mesa.git diff --git a/src/mesa/state_tracker/st_gen_mipmap.c b/src/mesa/state_tracker/st_gen_mipmap.c index 5b7a9620379..90b0b2d9745 100644 --- a/src/mesa/state_tracker/st_gen_mipmap.c +++ b/src/mesa/state_tracker/st_gen_mipmap.c @@ -1,8 +1,8 @@ /************************************************************************** - * - * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. + * + * Copyright 2008 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,295 +10,142 @@ * 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. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * 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 "main/imports.h" -#include "main/macros.h" +#include "main/errors.h" + #include "main/mipmap.h" #include "main/teximage.h" -#include "main/texformat.h" - -#include "shader/prog_instruction.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" #include "util/u_inlines.h" -#include "util/u_format.h" +#include "util/format/u_format.h" #include "util/u_gen_mipmap.h" -#include "util/u_math.h" - -#include "cso_cache/cso_cache.h" -#include "cso_cache/cso_context.h" #include "st_debug.h" #include "st_context.h" -#include "st_gen_mipmap.h" #include "st_texture.h" +#include "st_util.h" +#include "st_gen_mipmap.h" +#include "st_cb_bitmap.h" #include "st_cb_texture.h" -#include "st_inlines.h" /** - * one-time init for generate mipmap - * XXX Note: there may be other times we need no-op/simple state like this. - * In that case, some code refactoring would be good. + * Called via ctx->Driver.GenerateMipmap(). */ void -st_init_generate_mipmap(struct st_context *st) -{ - st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context); -} - - -void -st_destroy_generate_mipmap(struct st_context *st) -{ - util_destroy_gen_mipmap(st->gen_mipmap); - st->gen_mipmap = NULL; -} - - -/** - * Generate mipmap levels using hardware rendering. - * \return TRUE if successful, FALSE if not possible - */ -static boolean -st_render_mipmap(struct st_context *st, - GLenum target, - struct st_texture_object *stObj, - uint baseLevel, uint lastLevel) -{ - struct pipe_context *pipe = st->pipe; - struct pipe_screen *screen = pipe->screen; - struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe); - const uint face = _mesa_tex_target_to_face(target); - - assert(target != GL_TEXTURE_3D); /* not done yet */ - - /* check if we can render in the texture's format */ - if (!screen->is_format_supported(screen, psv->format, psv->texture->target, - PIPE_BIND_RENDER_TARGET, 0)) { - return FALSE; - } - - util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel, - PIPE_TEX_FILTER_LINEAR); - - return TRUE; -} - - -static void -fallback_generate_mipmap(GLcontext *ctx, GLenum target, - struct gl_texture_object *texObj) -{ - struct pipe_context *pipe = ctx->st->pipe; - struct pipe_resource *pt = st_get_texobj_resource(texObj); - const uint baseLevel = texObj->BaseLevel; - const uint lastLevel = pt->last_level; - const uint face = _mesa_tex_target_to_face(target), zslice = 0; - uint dstLevel; - GLenum datatype; - GLuint comps; - - if (ST_DEBUG & DEBUG_FALLBACK) - debug_printf("%s: fallback processing\n", __FUNCTION__); - - assert(target != GL_TEXTURE_3D); /* not done yet */ - - _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat, - &datatype, &comps); - - for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) { - const uint srcLevel = dstLevel - 1; - struct pipe_transfer *srcTrans, *dstTrans; - const ubyte *srcData; - ubyte *dstData; - int srcStride, dstStride; - - srcTrans = st_cond_flush_get_tex_transfer(st_context(ctx), pt, face, - srcLevel, zslice, - PIPE_TRANSFER_READ, 0, 0, - u_minify(pt->width0, srcLevel), - u_minify(pt->height0, srcLevel)); - - dstTrans = st_cond_flush_get_tex_transfer(st_context(ctx), pt, face, - dstLevel, zslice, - PIPE_TRANSFER_WRITE, 0, 0, - u_minify(pt->width0, dstLevel), - u_minify(pt->height0, dstLevel)); - - srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans); - dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans); - - srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format); - dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format); - - _mesa_generate_mipmap_level(target, datatype, comps, - 0 /*border*/, - u_minify(pt->width0, srcLevel), - u_minify(pt->height0, srcLevel), - u_minify(pt->depth0, srcLevel), - srcData, - srcStride, /* stride in texels */ - u_minify(pt->width0, dstLevel), - u_minify(pt->height0, dstLevel), - u_minify(pt->depth0, dstLevel), - dstData, - dstStride); /* stride in texels */ - - pipe_transfer_unmap(pipe, srcTrans); - pipe_transfer_unmap(pipe, dstTrans); - - pipe->transfer_destroy(pipe, srcTrans); - pipe->transfer_destroy(pipe, dstTrans); - } -} - - -/** - * Compute the expected number of mipmap levels in the texture given - * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/ - * GL_TEXTURE_MAX_LEVEL settings. This will tell us how many mipmap - * level should be generated. - */ -static GLuint -compute_num_levels(GLcontext *ctx, - struct gl_texture_object *texObj, - GLenum target) -{ - if (target == GL_TEXTURE_RECTANGLE_ARB) { - return 1; - } - else { - const GLuint maxLevels = texObj->MaxLevel - texObj->BaseLevel + 1; - const struct gl_texture_image *baseImage = - _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel); - GLuint size, numLevels; - - size = MAX2(baseImage->Width2, baseImage->Height2); - size = MAX2(size, baseImage->Depth2); - - numLevels = 0; - - while (size > 0) { - numLevels++; - size >>= 1; - } - - numLevels = MIN2(numLevels, maxLevels); - - return numLevels; - } -} - - -void -st_generate_mipmap(GLcontext *ctx, GLenum target, +st_generate_mipmap(struct gl_context *ctx, GLenum target, struct gl_texture_object *texObj) { - struct st_context *st = ctx->st; + struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(texObj); struct pipe_resource *pt = st_get_texobj_resource(texObj); - const uint baseLevel = texObj->BaseLevel; - uint lastLevel; - uint dstLevel; + uint baseLevel = texObj->BaseLevel; + enum pipe_format format; + uint lastLevel, first_layer, last_layer; if (!pt) return; - /* find expected last mipmap level */ - lastLevel = compute_num_levels(ctx, texObj, target) - 1; + if (texObj->Immutable) + baseLevel += texObj->MinLevel; + + /* not sure if this ultimately actually should work, + but we're not supporting multisampled textures yet. */ + assert(pt->nr_samples < 2); + + /* find expected last mipmap level to generate*/ + lastLevel = _mesa_compute_num_levels(ctx, texObj, target) - 1; + + if (texObj->Immutable) + lastLevel += texObj->MinLevel; if (lastLevel == 0) return; - if (pt->last_level < lastLevel) { - /* The current gallium texture doesn't have space for all the - * mipmap levels we need to generate. So allocate a new texture. - */ - struct pipe_resource *oldTex = stObj->pt; - GLboolean needFlush; + st_flush_bitmap_cache(st); + st_invalidate_readpix_cache(st); - /* create new texture with space for more levels */ - stObj->pt = st_texture_create(st, - oldTex->target, - oldTex->format, - lastLevel, - oldTex->width0, - oldTex->height0, - oldTex->depth0, - oldTex->bind); + /* The texture isn't in a "complete" state yet so set the expected + * lastLevel here, since it won't get done in st_finalize_texture(). + */ + stObj->lastLevel = lastLevel; - /* The texture isn't in a "complete" state yet so set the expected - * lastLevel here, since it won't get done in st_finalize_texture(). - */ - stObj->lastLevel = lastLevel; + if (!texObj->Immutable) { + const GLboolean genSave = texObj->GenerateMipmap; - /* This will copy the old texture's base image into the new texture - * which we just allocated. + /* Temporarily set GenerateMipmap to true so that allocate_full_mipmap() + * makes the right decision about full mipmap allocation. */ - st_finalize_texture(ctx, st->pipe, texObj, &needFlush); - - /* release the old tex (will likely be freed too) */ - pipe_resource_reference(&oldTex, NULL); - pipe_sampler_view_reference(&stObj->sampler_view, NULL); + texObj->GenerateMipmap = GL_TRUE; - pt = stObj->pt; - } + _mesa_prepare_mipmap_levels(ctx, texObj, baseLevel, lastLevel); - assert(lastLevel <= pt->last_level); + texObj->GenerateMipmap = genSave; - /* Recall that the Mesa BaseLevel image is stored in the gallium - * texture's level[0] position. So pass baseLevel=0 here. - */ - if (!st_render_mipmap(st, target, stObj, 0, lastLevel)) { - fallback_generate_mipmap(ctx, target, texObj); + /* At this point, memory for all the texture levels has been + * allocated. However, the base level image may be in one resource + * while the subsequent/smaller levels may be in another resource. + * Finalizing the texture will copy the base images from the former + * resource to the latter. + * + * After this, we'll have all mipmap levels in one resource. + */ + st_finalize_texture(ctx, st->pipe, texObj, 0); } - /* Fill in the Mesa gl_texture_image fields */ - for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) { - const uint srcLevel = dstLevel - 1; - const struct gl_texture_image *srcImage - = _mesa_get_tex_image(ctx, texObj, target, srcLevel); - struct gl_texture_image *dstImage; - struct st_texture_image *stImage; - uint dstWidth = u_minify(pt->width0, dstLevel); - uint dstHeight = u_minify(pt->height0, dstLevel); - uint dstDepth = u_minify(pt->depth0, dstLevel); - uint border = srcImage->Border; + pt = stObj->pt; + if (!pt) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "mipmap generation"); + return; + } - dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel); - if (!dstImage) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps"); - return; - } + assert(pt->last_level >= lastLevel); - /* Free old image data */ - if (dstImage->Data) - ctx->Driver.FreeTexImageData(ctx, dstImage); + if (pt->target == PIPE_TEXTURE_CUBE) { + first_layer = last_layer = _mesa_tex_target_to_face(target); + } + else { + first_layer = 0; + last_layer = util_max_layer(pt, baseLevel); + } - /* initialize new image */ - _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight, - dstDepth, border, srcImage->InternalFormat); + if (stObj->surface_based) + format = stObj->surface_format; + else + format = pt->format; - dstImage->TexFormat = srcImage->TexFormat; + if (texObj->Sampler.sRGBDecode == GL_SKIP_DECODE_EXT) + format = util_format_linear(format); - stImage = (struct st_texture_image *) dstImage; - pipe_resource_reference(&stImage->pt, pt); + /* First see if the driver supports hardware mipmap generation, + * if not then generate the mipmap by rendering/texturing. + * If that fails, use the software fallback. + */ + if (!st->pipe->screen->get_param(st->pipe->screen, + PIPE_CAP_GENERATE_MIPMAP) || + !st->pipe->generate_mipmap(st->pipe, pt, format, baseLevel, + lastLevel, first_layer, last_layer)) { + + if (!util_gen_mipmap(st->pipe, pt, format, baseLevel, lastLevel, + first_layer, last_layer, PIPE_TEX_FILTER_LINEAR)) { + _mesa_generate_mipmap(ctx, target, texObj); + } } }