st_texture.c revision 1a82d9648b3db780e58e4966924157542d148c58
1/************************************************************************** 2 * 3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * All Rights Reserved. 5 * 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: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 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 TUNGSTEN GRAPHICS 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. 25 * 26 **************************************************************************/ 27 28#include "st_context.h" 29#include "st_format.h" 30#include "st_texture.h" 31#include "enums.h" 32 33#undef Elements /* fix re-defined macro warning */ 34 35#include "pipe/p_state.h" 36#include "pipe/p_context.h" 37#include "pipe/p_defines.h" 38#include "pipe/p_inlines.h" 39#include "pipe/p_util.h" 40#include "pipe/p_inlines.h" 41 42 43#define DBG if(0) printf 44 45#if 0 46static GLenum 47target_to_target(GLenum target) 48{ 49 switch (target) { 50 case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB: 51 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB: 52 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB: 53 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB: 54 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB: 55 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB: 56 return GL_TEXTURE_CUBE_MAP_ARB; 57 default: 58 return target; 59 } 60} 61#endif 62 63 64/** 65 * Allocate a new pipe_texture object 66 * width0, height0, depth0 are the dimensions of the level 0 image 67 * (the highest resolution). last_level indicates how many mipmap levels 68 * to allocate storage for. For non-mipmapped textures, this will be zero. 69 */ 70struct pipe_texture * 71st_texture_create(struct st_context *st, 72 enum pipe_texture_target target, 73 enum pipe_format format, 74 GLuint last_level, 75 GLuint width0, 76 GLuint height0, 77 GLuint depth0, 78 GLuint compress_byte, 79 GLuint usage ) 80{ 81 struct pipe_texture pt, *newtex; 82 struct pipe_screen *screen = st->pipe->screen; 83 84 assert(target <= PIPE_TEXTURE_CUBE); 85 86 DBG("%s target %s format %s last_level %d\n", __FUNCTION__, 87 _mesa_lookup_enum_by_nr(target), 88 _mesa_lookup_enum_by_nr(format), last_level); 89 90 assert(format); 91 assert(screen->is_format_supported(screen, format, PIPE_TEXTURE)); 92 93 memset(&pt, 0, sizeof(pt)); 94 pt.target = target; 95 pt.format = format; 96 pt.last_level = last_level; 97 pt.width[0] = width0; 98 pt.height[0] = height0; 99 pt.depth[0] = depth0; 100 pt.compressed = compress_byte ? 1 : 0; 101 pt.cpp = pt.compressed ? compress_byte : st_sizeof_format(format); 102 pt.tex_usage = usage; 103 104 newtex = screen->texture_create(screen, &pt); 105 106 assert(!newtex || newtex->refcount == 1); 107 108 return newtex; 109} 110 111 112/** 113 * Check if a texture image be pulled into a unified mipmap texture. 114 * This mirrors the completeness test in a lot of ways. 115 * 116 * Not sure whether I want to pass gl_texture_image here. 117 */ 118GLboolean 119st_texture_match_image(const struct pipe_texture *pt, 120 const struct gl_texture_image *image, 121 GLuint face, GLuint level) 122{ 123 /* Images with borders are never pulled into mipmap textures. 124 */ 125 if (image->Border) 126 return GL_FALSE; 127 128 if (st_mesa_format_to_pipe_format(image->TexFormat->MesaFormat) != pt->format || 129 image->IsCompressed != pt->compressed) 130 return GL_FALSE; 131 132 /* Test image dimensions against the base level image adjusted for 133 * minification. This will also catch images not present in the 134 * texture, changed targets, etc. 135 */ 136 if (image->Width != pt->width[level] || 137 image->Height != pt->height[level] || 138 image->Depth != pt->depth[level]) 139 return GL_FALSE; 140 141 return GL_TRUE; 142} 143 144 145#if 000 146/* Although we use the image_offset[] array to store relative offsets 147 * to cube faces, Mesa doesn't know anything about this and expects 148 * each cube face to be treated as a separate image. 149 * 150 * These functions present that view to mesa: 151 */ 152const GLuint * 153st_texture_depth_offsets(struct pipe_texture *pt, GLuint level) 154{ 155 static const GLuint zero = 0; 156 157 if (pt->target != PIPE_TEXTURE_3D || pt->level[level].nr_images == 1) 158 return &zero; 159 else 160 return pt->level[level].image_offset; 161} 162 163 164/** 165 * Return the offset to the given mipmap texture image within the 166 * texture memory buffer, in bytes. 167 */ 168GLuint 169st_texture_image_offset(const struct pipe_texture * pt, 170 GLuint face, GLuint level) 171{ 172 if (pt->target == PIPE_TEXTURE_CUBE) 173 return (pt->level[level].level_offset + 174 pt->level[level].image_offset[face] * pt->cpp); 175 else 176 return pt->level[level].level_offset; 177} 178#endif 179 180 181/** 182 * Map a teximage in a mipmap texture. 183 * \param row_stride returns row stride in bytes 184 * \param image_stride returns image stride in bytes (for 3D textures). 185 * \return address of mapping 186 */ 187GLubyte * 188st_texture_image_map(struct st_context *st, struct st_texture_image *stImage, 189 GLuint zoffset, 190 GLuint flags ) 191{ 192 struct pipe_screen *screen = st->pipe->screen; 193 struct pipe_texture *pt = stImage->pt; 194 DBG("%s \n", __FUNCTION__); 195 196 stImage->surface = screen->get_tex_surface(screen, pt, stImage->face, 197 stImage->level, zoffset, 198 flags); 199 200 return screen->surface_map(screen, stImage->surface, flags); 201} 202 203 204void 205st_texture_image_unmap(struct st_context *st, 206 struct st_texture_image *stImage) 207{ 208 struct pipe_screen *screen = st->pipe->screen; 209 210 DBG("%s\n", __FUNCTION__); 211 212 screen->surface_unmap(screen, stImage->surface); 213 214 pipe_surface_reference(&stImage->surface, NULL); 215} 216 217 218 219/** 220 * Upload data to a rectangular sub-region. Lots of choices how to do this: 221 * 222 * - memcpy by span to current destination 223 * - upload data as new buffer and blit 224 * 225 * Currently always memcpy. 226 */ 227static void 228st_surface_data(struct pipe_context *pipe, 229 struct pipe_surface *dst, 230 unsigned dstx, unsigned dsty, 231 const void *src, unsigned src_pitch, 232 unsigned srcx, unsigned srcy, unsigned width, unsigned height) 233{ 234 struct pipe_screen *screen = pipe->screen; 235 void *map = screen->surface_map(screen, dst, PIPE_BUFFER_USAGE_CPU_WRITE); 236 237 pipe_copy_rect(map, 238 dst->cpp, 239 dst->pitch, 240 dstx, dsty, width, height, src, src_pitch, srcx, srcy); 241 242 screen->surface_unmap(screen, dst); 243} 244 245 246/* Upload data for a particular image. 247 */ 248void 249st_texture_image_data(struct pipe_context *pipe, 250 struct pipe_texture *dst, 251 GLuint face, 252 GLuint level, 253 void *src, 254 GLuint src_row_pitch, GLuint src_image_pitch) 255{ 256 struct pipe_screen *screen = pipe->screen; 257 GLuint depth = dst->depth[level]; 258 GLuint i; 259 GLuint height = 0; 260 const GLubyte *srcUB = src; 261 struct pipe_surface *dst_surface; 262 263 DBG("%s\n", __FUNCTION__); 264 for (i = 0; i < depth; i++) { 265 height = dst->height[level]; 266 if(dst->compressed) 267 height /= 4; 268 269 dst_surface = screen->get_tex_surface(screen, dst, face, level, i, 270 PIPE_BUFFER_USAGE_CPU_WRITE); 271 272 st_surface_data(pipe, dst_surface, 273 0, 0, /* dstx, dsty */ 274 srcUB, 275 src_row_pitch, 276 0, 0, /* source x, y */ 277 dst->width[level], height); /* width, height */ 278 279 screen->tex_surface_release(screen, &dst_surface); 280 281 srcUB += src_image_pitch * dst->cpp; 282 } 283} 284 285 286/* Copy mipmap image between textures 287 */ 288void 289st_texture_image_copy(struct pipe_context *pipe, 290 struct pipe_texture *dst, GLuint dstLevel, 291 struct pipe_texture *src, 292 GLuint face) 293{ 294 struct pipe_screen *screen = pipe->screen; 295 GLuint width = dst->width[dstLevel]; 296 GLuint height = dst->height[dstLevel]; 297 GLuint depth = dst->depth[dstLevel]; 298 struct pipe_surface *src_surface; 299 struct pipe_surface *dst_surface; 300 GLuint i; 301 302 /* XXX this is a hack */ 303 const GLuint copyHeight = dst->compressed ? height / 4 : height; 304 305 for (i = 0; i < depth; i++) { 306 GLuint srcLevel; 307 308 /* find src texture level of needed size */ 309 for (srcLevel = 0; srcLevel <= src->last_level; srcLevel++) { 310 if (src->width[srcLevel] == width && 311 src->height[srcLevel] == height) { 312 break; 313 } 314 } 315 assert(src->width[srcLevel] == width); 316 assert(src->height[srcLevel] == height); 317 318#if 0 319 { 320 src_surface = screen->get_tex_surface(screen, src, face, srcLevel, i, 321 PIPE_BUFFER_USAGE_CPU_READ); 322 ubyte *map = screen->surface_map(screen, src_surface, PIPE_BUFFER_USAGE_CPU_READ); 323 map += src_surface->width * src_surface->height * 4 / 2; 324 printf("%s center pixel: %d %d %d %d (pt %p[%d] -> %p[%d])\n", 325 __FUNCTION__, 326 map[0], map[1], map[2], map[3], 327 src, srcLevel, dst, dstLevel); 328 329 screen->surface_unmap(screen, src_surface); 330 pipe_surface_reference(&src_surface, NULL); 331 } 332#endif 333 334 dst_surface = screen->get_tex_surface(screen, dst, face, dstLevel, i, 335 PIPE_BUFFER_USAGE_GPU_WRITE); 336 337 src_surface = screen->get_tex_surface(screen, src, face, srcLevel, i, 338 PIPE_BUFFER_USAGE_GPU_READ); 339 340 pipe->surface_copy(pipe, 341 FALSE, 342 dst_surface, 343 0, 0, /* destX, Y */ 344 src_surface, 345 0, 0, /* srcX, Y */ 346 width, copyHeight); 347 348 screen->tex_surface_release(screen, &src_surface); 349 screen->tex_surface_release(screen, &dst_surface); 350 } 351} 352