intel_tex.c revision 82691574b6fc5a66290cbab88010caa8bc00c1dd
1#include "swrast/swrast.h" 2#include "main/renderbuffer.h" 3#include "main/texobj.h" 4#include "main/teximage.h" 5#include "main/mipmap.h" 6#include "drivers/common/meta.h" 7#include "intel_context.h" 8#include "intel_mipmap_tree.h" 9#include "intel_tex.h" 10 11#define FILE_DEBUG_FLAG DEBUG_TEXTURE 12 13static struct gl_texture_image * 14intelNewTextureImage(struct gl_context * ctx) 15{ 16 DBG("%s\n", __FUNCTION__); 17 (void) ctx; 18 return (struct gl_texture_image *) CALLOC_STRUCT(intel_texture_image); 19} 20 21static void 22intelDeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img) 23{ 24 /* nothing special (yet) for intel_texture_image */ 25 _mesa_delete_texture_image(ctx, img); 26} 27 28 29static struct gl_texture_object * 30intelNewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) 31{ 32 struct intel_texture_object *obj = CALLOC_STRUCT(intel_texture_object); 33 34 (void) ctx; 35 36 DBG("%s\n", __FUNCTION__); 37 _mesa_initialize_texture_object(&obj->base, name, target); 38 39 return &obj->base; 40} 41 42static void 43intelDeleteTextureObject(struct gl_context *ctx, 44 struct gl_texture_object *texObj) 45{ 46 struct intel_texture_object *intelObj = intel_texture_object(texObj); 47 48 intel_miptree_release(&intelObj->mt); 49 _mesa_delete_texture_object(ctx, texObj); 50} 51 52static GLboolean 53intel_alloc_texture_image_buffer(struct gl_context *ctx, 54 struct gl_texture_image *image, 55 gl_format format, GLsizei width, 56 GLsizei height, GLsizei depth) 57{ 58 struct intel_context *intel = intel_context(ctx); 59 struct intel_texture_image *intel_image = intel_texture_image(image); 60 struct gl_texture_object *texobj = image->TexObject; 61 struct intel_texture_object *intel_texobj = intel_texture_object(texobj); 62 63 /* Because the driver uses AllocTextureImageBuffer() internally, it may end 64 * up mismatched with FreeTextureImageBuffer(), but that is safe to call 65 * multiple times. 66 */ 67 ctx->Driver.FreeTextureImageBuffer(ctx, image); 68 69 if (intel->must_use_separate_stencil 70 && image->TexFormat == MESA_FORMAT_S8_Z24) { 71 intel_tex_image_s8z24_create_renderbuffers(intel, intel_image); 72 } 73 74 if (intel_texobj->mt && 75 intel_miptree_match_image(intel_texobj->mt, image)) { 76 intel_miptree_reference(&intel_image->mt, intel_texobj->mt); 77 DBG("%s: alloc obj %p level %d %dx%dx%d using object's miptree %p\n", 78 __FUNCTION__, texobj, image->Level, 79 width, height, depth, intel_texobj->mt); 80 return true; 81 } else if (image->Border == 0) { 82 intel_image->mt = intel_miptree_create_for_teximage(intel, intel_texobj, 83 intel_image, 84 false); 85 86 /* Even if the object currently has a mipmap tree associated 87 * with it, this one is a more likely candidate to represent the 88 * whole object since our level didn't fit what was there 89 * before, and any lower levels would fit into our miptree. 90 */ 91 intel_miptree_reference(&intel_texobj->mt, intel_image->mt); 92 93 DBG("%s: alloc obj %p level %d %dx%dx%d using new miptree %p\n", 94 __FUNCTION__, texobj, image->Level, 95 width, height, depth, intel_image->mt); 96 return true; 97 } 98 99 DBG("%s: alloc obj %p level %d %dx%dx%d using swrast\n", 100 __FUNCTION__, texobj, image->Level, width, height, depth); 101 102 return _swrast_alloc_texture_image_buffer(ctx, image, format, 103 width, height, depth); 104} 105 106static void 107intel_free_texture_image_buffer(struct gl_context * ctx, 108 struct gl_texture_image *texImage) 109{ 110 struct intel_texture_image *intelImage = intel_texture_image(texImage); 111 112 DBG("%s\n", __FUNCTION__); 113 114 intel_miptree_release(&intelImage->mt); 115 116 if (texImage->Data) { 117 _mesa_free_texmemory(texImage->Data); 118 texImage->Data = NULL; 119 } 120 121 _mesa_reference_renderbuffer(&intelImage->depth_rb, NULL); 122 _mesa_reference_renderbuffer(&intelImage->stencil_rb, NULL); 123} 124 125/** 126 * Map texture memory/buffer into user space. 127 * Note: the region of interest parameters are ignored here. 128 * \param mapOut returns start of mapping of region of interest 129 * \param rowStrideOut returns row stride in bytes 130 */ 131static void 132intel_map_texture_image(struct gl_context *ctx, 133 struct gl_texture_image *tex_image, 134 GLuint slice, 135 GLuint x, GLuint y, GLuint w, GLuint h, 136 GLbitfield mode, 137 GLubyte **map, 138 GLint *stride) 139{ 140 struct intel_context *intel = intel_context(ctx); 141 struct intel_texture_image *intel_image = intel_texture_image(tex_image); 142 struct intel_mipmap_tree *mt = intel_image->mt; 143 unsigned int bw, bh; 144 145 /* Check that our caller wasn't confused about how to map a 1D texture. */ 146 assert(tex_image->TexObject->Target != GL_TEXTURE_1D_ARRAY || 147 h == 1); 148 149 if (intel_image->stencil_rb) { 150 /* 151 * The texture has packed depth/stencil format, but uses separate 152 * stencil. The texture's embedded stencil buffer contains the real 153 * stencil data, so copy that into the miptree. 154 */ 155 intel_tex_image_s8z24_gather(intel, intel_image); 156 } 157 158 /* For compressed formats, the stride is the number of bytes per 159 * row of blocks. intel_miptree_get_image_offset() already does 160 * the divide. 161 */ 162 _mesa_get_format_block_size(tex_image->TexFormat, &bw, &bh); 163 assert(y % bh == 0); 164 y /= bh; 165 166 if (likely(mt)) { 167 void *base = intel_region_map(intel, mt->region); 168 unsigned int image_x, image_y; 169 170 intel_miptree_get_image_offset(mt, tex_image->Level, tex_image->Face, 171 slice, &image_x, &image_y); 172 x += image_x; 173 y += image_y; 174 175 *stride = mt->region->pitch * mt->cpp; 176 *map = base + y * *stride + x * mt->cpp; 177 178 DBG("%s: %d,%d %dx%d from mt %p %d,%d = %p/%d\n", __FUNCTION__, 179 x - image_x, y - image_y, w, h, 180 mt, x, y, *map, *stride); 181 } else { 182 /* texture data is in malloc'd memory */ 183 GLuint width = tex_image->Width; 184 GLuint height = ALIGN(tex_image->Height, bh) / bh; 185 GLuint texelSize = _mesa_get_format_bytes(tex_image->TexFormat); 186 187 assert(map); 188 189 *stride = _mesa_format_row_stride(tex_image->TexFormat, width); 190 *map = tex_image->Data + (slice * height + y) * *stride + x * texelSize; 191 192 DBG("%s: %d,%d %dx%d from data %p = %p/%d\n", __FUNCTION__, 193 x, y, w, h, 194 tex_image->Data, *map, *stride); 195 } 196} 197 198static void 199intel_unmap_texture_image(struct gl_context *ctx, 200 struct gl_texture_image *tex_image, GLuint slice) 201{ 202 struct intel_context *intel = intel_context(ctx); 203 struct intel_texture_image *intel_image = intel_texture_image(tex_image); 204 205 if (intel_image->mt) 206 intel_region_unmap(intel, intel_image->mt->region); 207 208 if (intel_image->stencil_rb) { 209 /* 210 * The texture has packed depth/stencil format, but uses separate 211 * stencil. The texture's embedded stencil buffer contains the real 212 * stencil data, so copy that into the miptree. 213 */ 214 intel_tex_image_s8z24_scatter(intel, intel_image); 215 } 216} 217 218/** 219 * Called via ctx->Driver.GenerateMipmap() 220 * This is basically a wrapper for _mesa_meta_GenerateMipmap() which checks 221 * if we'll be using software mipmap generation. In that case, we need to 222 * map/unmap the base level texture image. 223 */ 224static void 225intelGenerateMipmap(struct gl_context *ctx, GLenum target, 226 struct gl_texture_object *texObj) 227{ 228 if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, texObj)) { 229 fallback_debug("%s - fallback to swrast\n", __FUNCTION__); 230 231 _mesa_generate_mipmap(ctx, target, texObj); 232 } 233 else { 234 _mesa_meta_GenerateMipmap(ctx, target, texObj); 235 } 236} 237 238 239void 240intelInitTextureFuncs(struct dd_function_table *functions) 241{ 242 functions->GenerateMipmap = intelGenerateMipmap; 243 244 functions->NewTextureObject = intelNewTextureObject; 245 functions->NewTextureImage = intelNewTextureImage; 246 functions->DeleteTextureImage = intelDeleteTextureImage; 247 functions->DeleteTexture = intelDeleteTextureObject; 248 functions->AllocTextureImageBuffer = intel_alloc_texture_image_buffer; 249 functions->FreeTextureImageBuffer = intel_free_texture_image_buffer; 250 functions->MapTextureImage = intel_map_texture_image; 251 functions->UnmapTextureImage = intel_unmap_texture_image; 252} 253