X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fi965%2Fintel_tex.c;h=7ce2ceb9a2f7f72e555d34a5ccd5adccaa7284d3;hb=8c47ccb13a198f4d38c772df1de457de34dde23e;hp=fdb40aeffc4fda931da68fc27372b136bd3a3e79;hpb=1c7f75e45ed68e1d6bddcd01a61709f8f52d4d55;p=mesa.git diff --git a/src/mesa/drivers/dri/i965/intel_tex.c b/src/mesa/drivers/dri/i965/intel_tex.c index fdb40aeffc4..7ce2ceb9a2f 100644 --- a/src/mesa/drivers/dri/i965/intel_tex.c +++ b/src/mesa/drivers/dri/i965/intel_tex.c @@ -5,6 +5,8 @@ #include "main/mipmap.h" #include "drivers/common/meta.h" #include "brw_context.h" +#include "brw_defines.h" +#include "intel_buffer_objects.h" #include "intel_mipmap_tree.h" #include "intel_tex.h" #include "intel_fbo.h" @@ -14,7 +16,7 @@ static struct gl_texture_image * intelNewTextureImage(struct gl_context * ctx) { - DBG("%s\n", __FUNCTION__); + DBG("%s\n", __func__); (void) ctx; return (struct gl_texture_image *) CALLOC_STRUCT(intel_texture_image); } @@ -34,7 +36,7 @@ intelNewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) (void) ctx; - DBG("%s\n", __FUNCTION__); + DBG("%s\n", __func__); if (obj == NULL) return NULL; @@ -46,7 +48,7 @@ intelNewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) return &obj->base; } -static void +static void intelDeleteTextureObject(struct gl_context *ctx, struct gl_texture_object *texObj) { @@ -69,7 +71,7 @@ intel_alloc_texture_image_buffer(struct gl_context *ctx, /* Quantize sample count */ if (image->NumSamples) { - image->NumSamples = intel_quantize_num_samples(brw->intelScreen, image->NumSamples); + image->NumSamples = intel_quantize_num_samples(brw->screen, image->NumSamples); if (!image->NumSamples) return false; } @@ -87,12 +89,14 @@ intel_alloc_texture_image_buffer(struct gl_context *ctx, intel_miptree_match_image(intel_texobj->mt, image)) { intel_miptree_reference(&intel_image->mt, intel_texobj->mt); DBG("%s: alloc obj %p level %d %dx%dx%d using object's miptree %p\n", - __FUNCTION__, texobj, image->Level, + __func__, texobj, image->Level, image->Width, image->Height, image->Depth, intel_texobj->mt); } else { intel_image->mt = intel_miptree_create_for_teximage(brw, intel_texobj, intel_image, - false); + 1 /* samples */); + if (!intel_image->mt) + return false; /* Even if the object currently has a mipmap tree associated * with it, this one is a more likely candidate to represent the @@ -102,7 +106,7 @@ intel_alloc_texture_image_buffer(struct gl_context *ctx, intel_miptree_reference(&intel_texobj->mt, intel_image->mt); DBG("%s: alloc obj %p level %d %dx%dx%d using new miptree %p\n", - __FUNCTION__, texobj, image->Level, + __func__, texobj, image->Level, image->Width, image->Height, image->Depth, intel_image->mt); } @@ -114,7 +118,7 @@ intel_alloc_texture_image_buffer(struct gl_context *ctx, /** * ctx->Driver.AllocTextureStorage() handler. * - * Compare this to _mesa_alloc_texture_storage, which would call into + * Compare this to _mesa_AllocTextureStorage_sw, which would call into * intel_alloc_texture_image_buffer() above. */ static GLboolean @@ -126,7 +130,7 @@ intel_alloc_texture_storage(struct gl_context *ctx, struct brw_context *brw = brw_context(ctx); struct intel_texture_object *intel_texobj = intel_texture_object(texobj); struct gl_texture_image *first_image = texobj->Image[0][0]; - int num_samples = intel_quantize_num_samples(brw->intelScreen, + int num_samples = intel_quantize_num_samples(brw->screen, first_image->NumSamples); const int numFaces = _mesa_num_tex_faces(texobj->Target); int face; @@ -139,14 +143,18 @@ intel_alloc_texture_storage(struct gl_context *ctx, !intel_miptree_match_image(intel_texobj->mt, first_image) || intel_texobj->mt->last_level != levels - 1) { intel_miptree_release(&intel_texobj->mt); + + intel_get_image_dims(first_image, &width, &height, &depth); intel_texobj->mt = intel_miptree_create(brw, texobj->Target, first_image->TexFormat, 0, levels - 1, width, height, depth, - false, /* expect_accelerated */ - num_samples, - INTEL_MIPTREE_TILING_ANY); + MAX2(num_samples, 1), + MIPTREE_LAYOUT_TILING_ANY); + if (intel_texobj->mt == NULL) { + return false; + } } for (face = 0; face < numFaces; face++) { @@ -168,6 +176,7 @@ intel_alloc_texture_storage(struct gl_context *ctx, intel_texobj->needs_validate = false; intel_texobj->validated_first_level = 0; intel_texobj->validated_last_level = levels - 1; + intel_texobj->_Format = intel_texobj->mt->format; return true; } @@ -179,7 +188,7 @@ intel_free_texture_image_buffer(struct gl_context * ctx, { struct intel_texture_image *intelImage = intel_texture_image(texImage); - DBG("%s\n", __FUNCTION__); + DBG("%s\n", __func__); intel_miptree_release(&intelImage->mt); @@ -200,11 +209,12 @@ intel_map_texture_image(struct gl_context *ctx, GLuint x, GLuint y, GLuint w, GLuint h, GLbitfield mode, GLubyte **map, - GLint *stride) + GLint *out_stride) { struct brw_context *brw = brw_context(ctx); struct intel_texture_image *intel_image = intel_texture_image(tex_image); struct intel_mipmap_tree *mt = intel_image->mt; + ptrdiff_t stride; /* Our texture data is always stored in a miptree. */ assert(mt); @@ -219,8 +229,13 @@ intel_map_texture_image(struct gl_context *ctx, if (tex_image->TexObject->Target == GL_TEXTURE_CUBE_MAP) slice = tex_image->Face; - intel_miptree_map(brw, mt, tex_image->Level, slice, x, y, w, h, mode, - (void **)map, stride); + intel_miptree_map(brw, mt, + tex_image->Level + tex_image->TexObject->MinLevel, + slice + tex_image->TexObject->MinLayer, + x, y, w, h, mode, + (void **)map, &stride); + + *out_stride = stride; } static void @@ -234,7 +249,136 @@ intel_unmap_texture_image(struct gl_context *ctx, if (tex_image->TexObject->Target == GL_TEXTURE_CUBE_MAP) slice = tex_image->Face; - intel_miptree_unmap(brw, mt, tex_image->Level, slice); + intel_miptree_unmap(brw, mt, + tex_image->Level + tex_image->TexObject->MinLevel, + slice + tex_image->TexObject->MinLayer); +} + +static GLboolean +intel_texture_view(struct gl_context *ctx, + struct gl_texture_object *texObj, + struct gl_texture_object *origTexObj) +{ + struct brw_context *brw = brw_context(ctx); + struct intel_texture_object *intel_tex = intel_texture_object(texObj); + struct intel_texture_object *intel_orig_tex = intel_texture_object(origTexObj); + + assert(intel_orig_tex->mt); + intel_miptree_reference(&intel_tex->mt, intel_orig_tex->mt); + + /* Since we can only make views of immutable-format textures, + * we can assume that everything is in origTexObj's miptree. + * + * Mesa core has already made us a copy of all the teximage objects, + * except it hasn't copied our mt pointers, etc. + */ + const int numFaces = _mesa_num_tex_faces(texObj->Target); + const int numLevels = texObj->NumLevels; + + int face; + int level; + + for (face = 0; face < numFaces; face++) { + for (level = 0; level < numLevels; level++) { + struct gl_texture_image *image = texObj->Image[face][level]; + struct intel_texture_image *intel_image = intel_texture_image(image); + + intel_miptree_reference(&intel_image->mt, intel_orig_tex->mt); + } + } + + /* The miptree is in a validated state, so no need to check later. */ + intel_tex->needs_validate = false; + intel_tex->validated_first_level = 0; + intel_tex->validated_last_level = numLevels - 1; + + /* Set the validated texture format, with the same adjustments that + * would have been applied to determine the underlying texture's + * mt->format. + */ + intel_tex->_Format = intel_depth_format_for_depthstencil_format( + intel_lower_compressed_format(brw, texObj->Image[0][0]->TexFormat)); + + return GL_TRUE; +} + +static bool +intel_set_texture_storage_for_buffer_object(struct gl_context *ctx, + struct gl_texture_object *tex_obj, + struct gl_buffer_object *buffer_obj, + uint32_t buffer_offset, + uint32_t row_stride, + bool read_only) +{ + struct brw_context *brw = brw_context(ctx); + struct intel_texture_object *intel_texobj = intel_texture_object(tex_obj); + struct gl_texture_image *image = tex_obj->Image[0][0]; + struct intel_texture_image *intel_image = intel_texture_image(image); + struct intel_buffer_object *intel_buffer_obj = intel_buffer_object(buffer_obj); + + if (!read_only) { + /* Renderbuffers have the restriction that the buffer offset and + * surface pitch must be a multiple of the element size. If it's + * not, we have to fail and fall back to software. + */ + int cpp = _mesa_get_format_bytes(image->TexFormat); + if (buffer_offset % cpp || row_stride % cpp) { + perf_debug("Bad PBO alignment; fallback to CPU mapping\n"); + return false; + } + + if (!brw->mesa_format_supports_render[image->TexFormat]) { + perf_debug("Non-renderable PBO format; fallback to CPU mapping\n"); + return false; + } + } + + assert(intel_texobj->mt == NULL); + + struct brw_bo *bo = intel_bufferobj_buffer(brw, intel_buffer_obj, + buffer_offset, + row_stride * image->Height, + !read_only); + intel_texobj->mt = + intel_miptree_create_for_bo(brw, bo, + image->TexFormat, + buffer_offset, + image->Width, image->Height, image->Depth, + row_stride, + 0); + if (!intel_texobj->mt) + return false; + + if (!_swrast_init_texture_image(image)) + return false; + + intel_miptree_reference(&intel_image->mt, intel_texobj->mt); + + /* The miptree is in a validated state, so no need to check later. */ + intel_texobj->needs_validate = false; + intel_texobj->validated_first_level = 0; + intel_texobj->validated_last_level = 0; + intel_texobj->_Format = intel_texobj->mt->format; + + return true; +} + +static void +intel_texture_barrier(struct gl_context *ctx) +{ + struct brw_context *brw = brw_context(ctx); + + if (brw->gen >= 6) { + brw_emit_pipe_control_flush(brw, + PIPE_CONTROL_DEPTH_CACHE_FLUSH | + PIPE_CONTROL_RENDER_TARGET_FLUSH | + PIPE_CONTROL_CS_STALL); + + brw_emit_pipe_control_flush(brw, + PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE); + } else { + brw_emit_mi_flush(brw); + } } void @@ -249,4 +393,8 @@ intelInitTextureFuncs(struct dd_function_table *functions) functions->AllocTextureStorage = intel_alloc_texture_storage; functions->MapTextureImage = intel_map_texture_image; functions->UnmapTextureImage = intel_unmap_texture_image; + functions->TextureView = intel_texture_view; + functions->SetTextureStorageForBufferObject = + intel_set_texture_storage_for_buffer_object; + functions->TextureBarrier = intel_texture_barrier; }