X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsoftpipe%2Fsp_texture.c;h=e1ea5df24ca420a1dbe836cf8a9ae597c855c2dc;hb=525921ed51176255474c73adacfc6801a7bf2783;hp=7aa85559b236d0d3a8dfa6f79782b8e0a5752c53;hpb=a8ea1dacc63ac567498049e5756c247b9fec6cd9;p=mesa.git diff --git a/src/gallium/drivers/softpipe/sp_texture.c b/src/gallium/drivers/softpipe/sp_texture.c index 7aa85559b23..e1ea5df24ca 100644 --- a/src/gallium/drivers/softpipe/sp_texture.c +++ b/src/gallium/drivers/softpipe/sp_texture.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2006 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -18,7 +18,7 @@ * 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. @@ -26,8 +26,8 @@ **************************************************************************/ /* * Authors: - * Keith Whitwell - * Michel Dänzer + * Keith Whitwell + * Michel Dänzer */ #include "pipe/p_defines.h" @@ -52,32 +52,73 @@ */ static boolean softpipe_resource_layout(struct pipe_screen *screen, - struct softpipe_resource *spr) + struct softpipe_resource *spr, + boolean allocate) { struct pipe_resource *pt = &spr->base; unsigned level; unsigned width = pt->width0; unsigned height = pt->height0; unsigned depth = pt->depth0; - unsigned buffer_size = 0; + uint64_t buffer_size = 0; for (level = 0; level <= pt->last_level; level++) { + unsigned slices, nblocksy; + + nblocksy = util_format_get_nblocksy(pt->format, height); + + if (pt->target == PIPE_TEXTURE_CUBE) + assert(pt->array_size == 6); + + if (pt->target == PIPE_TEXTURE_3D) + slices = depth; + else + slices = pt->array_size; + spr->stride[level] = util_format_get_stride(pt->format, width); spr->level_offset[level] = buffer_size; - buffer_size += (util_format_get_nblocksy(pt->format, height) * - ((pt->target == PIPE_TEXTURE_CUBE) ? 6 : depth) * - spr->stride[level]); + /* if row_stride * height > SP_MAX_TEXTURE_SIZE */ + if ((uint64_t)spr->stride[level] * nblocksy > SP_MAX_TEXTURE_SIZE) { + /* image too large */ + return FALSE; + } + + spr->img_stride[level] = spr->stride[level] * nblocksy; + + buffer_size += (uint64_t) spr->img_stride[level] * slices; width = u_minify(width, 1); height = u_minify(height, 1); depth = u_minify(depth, 1); } - spr->data = align_malloc(buffer_size, 16); + if (buffer_size > SP_MAX_TEXTURE_SIZE) + return FALSE; + + if (allocate) { + spr->data = align_malloc(buffer_size, 64); + return spr->data != NULL; + } + else { + return TRUE; + } +} + - return spr->data != NULL; +/** + * Check the size of the texture specified by 'res'. + * \return TRUE if OK, FALSE if too large. + */ +static boolean +softpipe_can_create_resource(struct pipe_screen *screen, + const struct pipe_resource *res) +{ + struct softpipe_resource spr; + memset(&spr, 0, sizeof(spr)); + spr.base = *res; + return softpipe_resource_layout(screen, &spr, FALSE); } @@ -97,7 +138,7 @@ softpipe_displaytarget_layout(struct pipe_screen *screen, spr->base.format, spr->base.width0, spr->base.height0, - 16, + 64, &spr->stride[0] ); return spr->dt != NULL; @@ -132,7 +173,7 @@ softpipe_resource_create(struct pipe_screen *screen, goto fail; } else { - if (!softpipe_resource_layout(screen, spr)) + if (!softpipe_resource_layout(screen, spr, TRUE)) goto fail; } @@ -220,24 +261,11 @@ softpipe_resource_get_handle(struct pipe_screen *screen, */ static unsigned sp_get_tex_image_offset(const struct softpipe_resource *spr, - unsigned level, unsigned face, unsigned zslice) + unsigned level, unsigned layer) { - const unsigned hgt = u_minify(spr->base.height0, level); - const unsigned nblocksy = util_format_get_nblocksy(spr->base.format, hgt); unsigned offset = spr->level_offset[level]; - if (spr->base.target == PIPE_TEXTURE_CUBE) { - assert(zslice == 0); - offset += face * nblocksy * spr->stride[level]; - } - else if (spr->base.target == PIPE_TEXTURE_3D) { - assert(face == 0); - offset += zslice * nblocksy * spr->stride[level]; - } - else { - assert(face == 0); - assert(zslice == 0); - } + offset += layer * spr->img_stride[level]; return offset; } @@ -247,39 +275,49 @@ sp_get_tex_image_offset(const struct softpipe_resource *spr, * Get a pipe_surface "view" into a texture resource. */ static struct pipe_surface * -softpipe_get_tex_surface(struct pipe_screen *screen, - struct pipe_resource *pt, - unsigned face, unsigned level, unsigned zslice, - unsigned usage) +softpipe_create_surface(struct pipe_context *pipe, + struct pipe_resource *pt, + const struct pipe_surface *surf_tmpl) { - struct softpipe_resource *spr = softpipe_resource(pt); struct pipe_surface *ps; - assert(level <= pt->last_level); - ps = CALLOC_STRUCT(pipe_surface); if (ps) { pipe_reference_init(&ps->reference, 1); pipe_resource_reference(&ps->texture, pt); - ps->format = pt->format; - ps->width = u_minify(pt->width0, level); - ps->height = u_minify(pt->height0, level); - ps->offset = sp_get_tex_image_offset(spr, level, face, zslice); - ps->usage = usage; - - ps->face = face; - ps->level = level; - ps->zslice = zslice; + ps->context = pipe; + ps->format = surf_tmpl->format; + if (pt->target != PIPE_BUFFER) { + assert(surf_tmpl->u.tex.level <= pt->last_level); + ps->width = u_minify(pt->width0, surf_tmpl->u.tex.level); + ps->height = u_minify(pt->height0, surf_tmpl->u.tex.level); + ps->u.tex.level = surf_tmpl->u.tex.level; + ps->u.tex.first_layer = surf_tmpl->u.tex.first_layer; + ps->u.tex.last_layer = surf_tmpl->u.tex.last_layer; + if (ps->u.tex.first_layer != ps->u.tex.last_layer) { + debug_printf("creating surface with multiple layers, rendering to first layer only\n"); + } + } + else { + /* setting width as number of elements should get us correct renderbuffer width */ + ps->width = surf_tmpl->u.buf.last_element - surf_tmpl->u.buf.first_element + 1; + ps->height = pt->height0; + ps->u.buf.first_element = surf_tmpl->u.buf.first_element; + ps->u.buf.last_element = surf_tmpl->u.buf.last_element; + assert(ps->u.buf.first_element <= ps->u.buf.last_element); + assert(ps->u.buf.last_element < ps->width); + } } return ps; } /** - * Free a pipe_surface which was created with softpipe_get_tex_surface(). + * Free a pipe_surface which was created with softpipe_create_surface(). */ static void -softpipe_tex_surface_destroy(struct pipe_surface *surf) +softpipe_surface_destroy(struct pipe_context *pipe, + struct pipe_surface *surf) { /* Effectively do the texture_update work here - if texture images * needed post-processing to put them into hardware layout, this is @@ -296,27 +334,48 @@ softpipe_tex_surface_destroy(struct pipe_surface *surf) * a resource object. * \param pipe rendering context * \param resource the resource to transfer in/out of - * \param sr indicates cube face or 3D texture slice + * \param level which mipmap level * \param usage bitmask of PIPE_TRANSFER_x flags * \param box the 1D/2D/3D region of interest */ -static struct pipe_transfer * -softpipe_get_transfer(struct pipe_context *pipe, - struct pipe_resource *resource, - struct pipe_subresource sr, - unsigned usage, - const struct pipe_box *box) +static void * +softpipe_transfer_map(struct pipe_context *pipe, + struct pipe_resource *resource, + unsigned level, + unsigned usage, + const struct pipe_box *box, + struct pipe_transfer **transfer) { + struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys; struct softpipe_resource *spr = softpipe_resource(resource); struct softpipe_transfer *spt; + struct pipe_transfer *pt; + enum pipe_format format = resource->format; + uint8_t *map; assert(resource); - assert(sr.level <= resource->last_level); + assert(level <= resource->last_level); /* make sure the requested region is in the image bounds */ - assert(box->x + box->width <= u_minify(resource->width0, sr.level)); - assert(box->y + box->height <= u_minify(resource->height0, sr.level)); - assert(box->z + box->depth <= u_minify(resource->depth0, sr.level)); + assert(box->x + box->width <= (int) u_minify(resource->width0, level)); + if (resource->target == PIPE_TEXTURE_1D_ARRAY) { + assert(box->y + box->height <= (int) resource->array_size); + } + else { + assert(box->y + box->height <= (int) u_minify(resource->height0, level)); + if (resource->target == PIPE_TEXTURE_2D_ARRAY) { + assert(box->z + box->depth <= (int) resource->array_size); + } + else if (resource->target == PIPE_TEXTURE_CUBE) { + assert(box->z < 6); + } + else if (resource->target == PIPE_TEXTURE_CUBE_ARRAY) { + assert(box->z <= (int) resource->array_size); + } + else { + assert(box->z + box->depth <= (int) u_minify(resource->depth0, level)); + } + } /* * Transfers, like other pipe operations, must happen in order, so flush the @@ -326,7 +385,7 @@ softpipe_get_transfer(struct pipe_context *pipe, boolean read_only = !(usage & PIPE_TRANSFER_WRITE); boolean do_not_block = !!(usage & PIPE_TRANSFER_DONTBLOCK); if (!softpipe_flush_resource(pipe, resource, - sr.face, sr.level, + level, box->depth > 1 ? -1 : box->z, 0, /* flush_flags */ read_only, TRUE, /* cpu_access */ @@ -340,65 +399,41 @@ softpipe_get_transfer(struct pipe_context *pipe, } spt = CALLOC_STRUCT(softpipe_transfer); - if (spt) { - struct pipe_transfer *pt = &spt->base; - enum pipe_format format = resource->format; - pipe_resource_reference(&pt->resource, resource); - pt->sr = sr; - pt->usage = usage; - pt->box = *box; - pt->stride = spr->stride[sr.level]; - - spt->offset = sp_get_tex_image_offset(spr, sr.level, sr.face, box->z); - - spt->offset += - box->y / util_format_get_blockheight(format) * spt->base.stride + - box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format); - - return pt; - } - return NULL; -} + if (!spt) + return NULL; + pt = &spt->base; -/** - * Free a pipe_transfer object which was created with - * softpipe_get_transfer(). - */ -static void -softpipe_transfer_destroy(struct pipe_context *pipe, - struct pipe_transfer *transfer) -{ - pipe_resource_reference(&transfer->resource, NULL); - FREE(transfer); -} + pipe_resource_reference(&pt->resource, resource); + pt->level = level; + pt->usage = usage; + pt->box = *box; + pt->stride = spr->stride[level]; + pt->layer_stride = spr->img_stride[level]; + spt->offset = sp_get_tex_image_offset(spr, level, box->z); + + spt->offset += + box->y / util_format_get_blockheight(format) * spt->base.stride + + box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format); -/** - * Create memory mapping for given pipe_transfer object. - */ -static void * -softpipe_transfer_map(struct pipe_context *pipe, - struct pipe_transfer *transfer) -{ - struct softpipe_transfer *spt = softpipe_transfer(transfer); - struct softpipe_resource *spr = softpipe_resource(transfer->resource); - struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys; - uint8_t *map; - /* resources backed by display target treated specially: */ if (spr->dt) { - map = winsys->displaytarget_map(winsys, spr->dt, transfer->usage); + map = winsys->displaytarget_map(winsys, spr->dt, usage); } else { map = spr->data; } - if (map == NULL) + if (map == NULL) { + pipe_resource_reference(&pt->resource, NULL); + FREE(spt); return NULL; - else - return map + spt->offset; + } + + *transfer = pt; + return map + spt->offset; } @@ -424,12 +459,15 @@ softpipe_transfer_unmap(struct pipe_context *pipe, /* Mark the texture as dirty to expire the tile caches. */ spr->timestamp++; } + + pipe_resource_reference(&transfer->resource, NULL); + FREE(transfer); } /** * Create buffer which wraps user-space data. */ -static struct pipe_resource * +struct pipe_resource * softpipe_user_buffer_create(struct pipe_screen *screen, void *ptr, unsigned bytes, @@ -450,6 +488,7 @@ softpipe_user_buffer_create(struct pipe_screen *screen, spr->base.width0 = bytes; spr->base.height0 = 1; spr->base.depth0 = 1; + spr->base.array_size = 1; spr->userBuffer = TRUE; spr->data = ptr; @@ -460,13 +499,14 @@ softpipe_user_buffer_create(struct pipe_screen *screen, void softpipe_init_texture_funcs(struct pipe_context *pipe) { - pipe->get_transfer = softpipe_get_transfer; - pipe->transfer_destroy = softpipe_transfer_destroy; pipe->transfer_map = softpipe_transfer_map; pipe->transfer_unmap = softpipe_transfer_unmap; pipe->transfer_flush_region = u_default_transfer_flush_region; pipe->transfer_inline_write = u_default_transfer_inline_write; + + pipe->create_surface = softpipe_create_surface; + pipe->surface_destroy = softpipe_surface_destroy; } @@ -477,8 +517,5 @@ softpipe_init_screen_texture_funcs(struct pipe_screen *screen) screen->resource_destroy = softpipe_resource_destroy; screen->resource_from_handle = softpipe_resource_from_handle; screen->resource_get_handle = softpipe_resource_get_handle; - screen->user_buffer_create = softpipe_user_buffer_create; - - screen->get_tex_surface = softpipe_get_tex_surface; - screen->tex_surface_destroy = softpipe_tex_surface_destroy; + screen->can_create_resource = softpipe_can_create_resource; }