lp_texture.c revision b43c182f19c6291c88420fa12714f952c2b461fb
1/************************************************************************** 2 * 3 * Copyright 2006 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 * Authors: 29 * Keith Whitwell <keith@tungstengraphics.com> 30 * Michel Dänzer <michel@tungstengraphics.com> 31 */ 32 33#include "pipe/p_context.h" 34#include "pipe/p_defines.h" 35#include "util/u_inlines.h" 36 37#include "util/u_format.h" 38#include "util/u_math.h" 39#include "util/u_memory.h" 40 41#include "lp_context.h" 42#include "lp_screen.h" 43#include "lp_texture.h" 44#include "lp_tile_size.h" 45#include "state_tracker/sw_winsys.h" 46 47 48/** 49 * Conventional allocation path for non-display textures: 50 * Simple, maximally packed layout. 51 */ 52static boolean 53llvmpipe_texture_layout(struct llvmpipe_screen *screen, 54 struct llvmpipe_texture *lpt) 55{ 56 struct pipe_texture *pt = &lpt->base; 57 unsigned level; 58 unsigned width = pt->width0; 59 unsigned height = pt->height0; 60 unsigned depth = pt->depth0; 61 unsigned buffer_size = 0; 62 63 for (level = 0; level <= pt->last_level; level++) { 64 unsigned nblocksx, nblocksy; 65 66 /* Allocate storage for whole quads. This is particularly important 67 * for depth surfaces, which are currently stored in a swizzled format. 68 */ 69 nblocksx = util_format_get_nblocksx(pt->format, align(width, TILE_SIZE)); 70 nblocksy = util_format_get_nblocksy(pt->format, align(height, TILE_SIZE)); 71 72 lpt->stride[level] = align(nblocksx * util_format_get_blocksize(pt->format), 16); 73 74 lpt->level_offset[level] = buffer_size; 75 76 buffer_size += (nblocksy * 77 ((pt->target == PIPE_TEXTURE_CUBE) ? 6 : depth) * 78 lpt->stride[level]); 79 80 width = u_minify(width, 1); 81 height = u_minify(height, 1); 82 depth = u_minify(depth, 1); 83 } 84 85 lpt->data = align_malloc(buffer_size, 16); 86 87 return lpt->data != NULL; 88} 89 90 91 92static boolean 93llvmpipe_displaytarget_layout(struct llvmpipe_screen *screen, 94 struct llvmpipe_texture *lpt) 95{ 96 struct sw_winsys *winsys = screen->winsys; 97 98 /* Round up the surface size to a multiple of the tile size to 99 * avoid tile clipping. 100 */ 101 unsigned width = align(lpt->base.width0, TILE_SIZE); 102 unsigned height = align(lpt->base.height0, TILE_SIZE); 103 104 lpt->dt = winsys->displaytarget_create(winsys, 105 lpt->base.format, 106 width, height, 107 16, 108 &lpt->stride[0] ); 109 110 return lpt->dt != NULL; 111} 112 113 114static struct pipe_texture * 115llvmpipe_texture_create(struct pipe_screen *_screen, 116 const struct pipe_texture *templat) 117{ 118 struct llvmpipe_screen *screen = llvmpipe_screen(_screen); 119 struct llvmpipe_texture *lpt = CALLOC_STRUCT(llvmpipe_texture); 120 if (!lpt) 121 return NULL; 122 123 lpt->base = *templat; 124 pipe_reference_init(&lpt->base.reference, 1); 125 lpt->base.screen = &screen->base; 126 127 if (lpt->base.tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET | 128 PIPE_TEXTURE_USAGE_SCANOUT | 129 PIPE_TEXTURE_USAGE_SHARED)) { 130 if (!llvmpipe_displaytarget_layout(screen, lpt)) 131 goto fail; 132 } 133 else { 134 if (!llvmpipe_texture_layout(screen, lpt)) 135 goto fail; 136 } 137 138 return &lpt->base; 139 140 fail: 141 FREE(lpt); 142 return NULL; 143} 144 145 146static void 147llvmpipe_texture_destroy(struct pipe_texture *pt) 148{ 149 struct llvmpipe_screen *screen = llvmpipe_screen(pt->screen); 150 struct llvmpipe_texture *lpt = llvmpipe_texture(pt); 151 152 if (lpt->dt) { 153 /* display target */ 154 struct sw_winsys *winsys = screen->winsys; 155 winsys->displaytarget_destroy(winsys, lpt->dt); 156 } 157 else { 158 /* regular texture */ 159 align_free(lpt->data); 160 } 161 162 FREE(lpt); 163} 164 165 166static struct pipe_surface * 167llvmpipe_get_tex_surface(struct pipe_screen *screen, 168 struct pipe_texture *pt, 169 unsigned face, unsigned level, unsigned zslice, 170 unsigned usage) 171{ 172 struct llvmpipe_texture *lpt = llvmpipe_texture(pt); 173 struct pipe_surface *ps; 174 175 assert(level <= pt->last_level); 176 177 ps = CALLOC_STRUCT(pipe_surface); 178 if (ps) { 179 pipe_reference_init(&ps->reference, 1); 180 pipe_texture_reference(&ps->texture, pt); 181 ps->format = pt->format; 182 ps->width = u_minify(pt->width0, level); 183 ps->height = u_minify(pt->height0, level); 184 ps->offset = lpt->level_offset[level]; 185 ps->usage = usage; 186 187 /* Because we are llvmpipe, anything that the state tracker 188 * thought was going to be done with the GPU will actually get 189 * done with the CPU. Let's adjust the flags to take that into 190 * account. 191 */ 192 if (ps->usage & PIPE_BUFFER_USAGE_GPU_WRITE) { 193 /* GPU_WRITE means "render" and that can involve reads (blending) */ 194 ps->usage |= PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_CPU_READ; 195 } 196 197 if (ps->usage & PIPE_BUFFER_USAGE_GPU_READ) 198 ps->usage |= PIPE_BUFFER_USAGE_CPU_READ; 199 200 if (ps->usage & (PIPE_BUFFER_USAGE_CPU_WRITE | 201 PIPE_BUFFER_USAGE_GPU_WRITE)) { 202 /* Mark the surface as dirty. */ 203 lpt->timestamp++; 204 llvmpipe_screen(screen)->timestamp++; 205 } 206 207 ps->face = face; 208 ps->level = level; 209 ps->zslice = zslice; 210 211 /* XXX shouldn't that rather be 212 tex_height = align(ps->height, 2); 213 to account for alignment done in llvmpipe_texture_layout ? 214 */ 215 if (pt->target == PIPE_TEXTURE_CUBE) { 216 unsigned tex_height = ps->height; 217 ps->offset += face * util_format_get_nblocksy(pt->format, tex_height) * lpt->stride[level]; 218 } 219 else if (pt->target == PIPE_TEXTURE_3D) { 220 unsigned tex_height = ps->height; 221 ps->offset += zslice * util_format_get_nblocksy(pt->format, tex_height) * lpt->stride[level]; 222 } 223 else { 224 assert(face == 0); 225 assert(zslice == 0); 226 } 227 } 228 return ps; 229} 230 231 232static void 233llvmpipe_tex_surface_destroy(struct pipe_surface *surf) 234{ 235 /* Effectively do the texture_update work here - if texture images 236 * needed post-processing to put them into hardware layout, this is 237 * where it would happen. For llvmpipe, nothing to do. 238 */ 239 assert(surf->texture); 240 pipe_texture_reference(&surf->texture, NULL); 241 FREE(surf); 242} 243 244 245static struct pipe_transfer * 246llvmpipe_get_tex_transfer(struct pipe_context *pipe, 247 struct pipe_texture *texture, 248 unsigned face, unsigned level, unsigned zslice, 249 enum pipe_transfer_usage usage, 250 unsigned x, unsigned y, unsigned w, unsigned h) 251{ 252 struct llvmpipe_texture *lptex = llvmpipe_texture(texture); 253 struct llvmpipe_transfer *lpt; 254 255 assert(texture); 256 assert(level <= texture->last_level); 257 258 lpt = CALLOC_STRUCT(llvmpipe_transfer); 259 if (lpt) { 260 struct pipe_transfer *pt = &lpt->base; 261 pipe_texture_reference(&pt->texture, texture); 262 pt->x = x; 263 pt->y = y; 264 pt->width = align(w, TILE_SIZE); 265 pt->height = align(h, TILE_SIZE); 266 pt->stride = lptex->stride[level]; 267 pt->usage = usage; 268 pt->face = face; 269 pt->level = level; 270 pt->zslice = zslice; 271 272 lpt->offset = lptex->level_offset[level]; 273 274 /* XXX shouldn't that rather be 275 tex_height = align(u_minify(texture->height0, level), 2) 276 to account for alignment done in llvmpipe_texture_layout ? 277 */ 278 if (texture->target == PIPE_TEXTURE_CUBE) { 279 unsigned tex_height = u_minify(texture->height0, level); 280 lpt->offset += face * util_format_get_nblocksy(texture->format, tex_height) * pt->stride; 281 } 282 else if (texture->target == PIPE_TEXTURE_3D) { 283 unsigned tex_height = u_minify(texture->height0, level); 284 lpt->offset += zslice * util_format_get_nblocksy(texture->format, tex_height) * pt->stride; 285 } 286 else { 287 assert(face == 0); 288 assert(zslice == 0); 289 } 290 return pt; 291 } 292 return NULL; 293} 294 295 296static void 297llvmpipe_tex_transfer_destroy(struct pipe_transfer *transfer) 298{ 299 /* Effectively do the texture_update work here - if texture images 300 * needed post-processing to put them into hardware layout, this is 301 * where it would happen. For llvmpipe, nothing to do. 302 */ 303 assert (transfer->texture); 304 pipe_texture_reference(&transfer->texture, NULL); 305 FREE(transfer); 306} 307 308 309static void * 310llvmpipe_transfer_map( struct pipe_context *pipe, 311 struct pipe_transfer *transfer ) 312{ 313 struct llvmpipe_screen *screen = llvmpipe_screen(pipe->screen); 314 ubyte *map, *xfer_map; 315 struct llvmpipe_texture *lpt; 316 enum pipe_format format; 317 318 assert(transfer->texture); 319 lpt = llvmpipe_texture(transfer->texture); 320 format = lpt->base.format; 321 322 if (lpt->dt) { 323 /* display target */ 324 struct sw_winsys *winsys = screen->winsys; 325 326 map = winsys->displaytarget_map(winsys, lpt->dt, 327 pipe_transfer_buffer_flags(transfer)); 328 if (map == NULL) 329 return NULL; 330 } 331 else { 332 /* regular texture */ 333 map = lpt->data; 334 } 335 336 /* May want to different things here depending on read/write nature 337 * of the map: 338 */ 339 if (transfer->texture && (transfer->usage & PIPE_TRANSFER_WRITE)) { 340 /* Do something to notify sharing contexts of a texture change. 341 */ 342 screen->timestamp++; 343 } 344 345 xfer_map = map + llvmpipe_transfer(transfer)->offset + 346 transfer->y / util_format_get_blockheight(format) * transfer->stride + 347 transfer->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format); 348 /*printf("map = %p xfer map = %p\n", map, xfer_map);*/ 349 return xfer_map; 350} 351 352 353static void 354llvmpipe_transfer_unmap(struct pipe_context *pipe, 355 struct pipe_transfer *transfer) 356{ 357 struct llvmpipe_screen *lp_screen = llvmpipe_screen(pipe->screen); 358 struct llvmpipe_texture *lpt; 359 360 assert(transfer->texture); 361 lpt = llvmpipe_texture(transfer->texture); 362 363 if (lpt->dt) { 364 /* display target */ 365 struct sw_winsys *winsys = lp_screen->winsys; 366 winsys->displaytarget_unmap(winsys, lpt->dt); 367 } 368} 369 370 371void 372llvmpipe_init_screen_texture_funcs(struct pipe_screen *screen) 373{ 374 screen->texture_create = llvmpipe_texture_create; 375 screen->texture_destroy = llvmpipe_texture_destroy; 376 377 screen->get_tex_surface = llvmpipe_get_tex_surface; 378 screen->tex_surface_destroy = llvmpipe_tex_surface_destroy; 379} 380 381 382void 383llvmpipe_init_context_texture_funcs(struct pipe_context *pipe) 384{ 385 pipe->get_tex_transfer = llvmpipe_get_tex_transfer; 386 pipe->tex_transfer_destroy = llvmpipe_tex_transfer_destroy; 387 pipe->transfer_map = llvmpipe_transfer_map; 388 pipe->transfer_unmap = llvmpipe_transfer_unmap; 389} 390