/**************************************************************************
*
- * 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
* 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.
**************************************************************************/
/*
* Authors:
- * Keith Whitwell <keith@tungstengraphics.com>
- * Michel Dänzer <michel@tungstengraphics.com>
+ * Keith Whitwell <keithw@vmware.com>
+ * Michel Dänzer <daenzer@vmware.com>
*/
#include "pipe/p_defines.h"
#include "util/u_inlines.h"
-#include "util/u_format.h"
+#include "util/format/u_format.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "util/u_transfer.h"
+#include "util/u_surface.h"
#include "sp_context.h"
+#include "sp_flush.h"
#include "sp_texture.h"
#include "sp_screen.h"
-#include "state_tracker/sw_winsys.h"
+#include "frontend/sw_winsys.h"
/**
*/
static boolean
softpipe_resource_layout(struct pipe_screen *screen,
- struct softpipe_resource * spt)
+ struct softpipe_resource *spr,
+ boolean allocate)
{
- struct pipe_resource *pt = &spt->base;
+ 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++) {
- spt->stride[level] = util_format_get_stride(pt->format, width);
+ unsigned slices, nblocksy;
- spt->level_offset[level] = buffer_size;
+ nblocksy = util_format_get_nblocksy(pt->format, height);
- buffer_size += (util_format_get_nblocksy(pt->format, height) *
- ((pt->target == PIPE_TEXTURE_CUBE) ? 6 : depth) *
- spt->stride[level]);
+ 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;
+
+ /* 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);
}
- spt->data = align_malloc(buffer_size, 16);
+ if (buffer_size > SP_MAX_TEXTURE_SIZE)
+ return FALSE;
- return spt->data != NULL;
+ if (allocate) {
+ spr->data = align_malloc(buffer_size, 64);
+ return spr->data != NULL;
+ }
+ else {
+ return TRUE;
+ }
+}
+
+
+/**
+ * Check the size of the texture specified by 'res'.
+ * \return TRUE if OK, FALSE if too large.
+ */
+static bool
+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);
}
*/
static boolean
softpipe_displaytarget_layout(struct pipe_screen *screen,
- struct softpipe_resource * spt)
+ struct softpipe_resource *spr,
+ const void *map_front_private)
{
struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
/* Round up the surface size to a multiple of the tile size?
*/
- spt->dt = winsys->displaytarget_create(winsys,
- spt->base.bind,
- spt->base.format,
- spt->base.width0,
- spt->base.height0,
- 16,
- &spt->stride[0] );
-
- return spt->dt != NULL;
+ spr->dt = winsys->displaytarget_create(winsys,
+ spr->base.bind,
+ spr->base.format,
+ spr->base.width0,
+ spr->base.height0,
+ 64,
+ map_front_private,
+ &spr->stride[0] );
+
+ return spr->dt != NULL;
}
* Create new pipe_resource given the template information.
*/
static struct pipe_resource *
-softpipe_resource_create(struct pipe_screen *screen,
- const struct pipe_resource *templat)
+softpipe_resource_create_front(struct pipe_screen *screen,
+ const struct pipe_resource *templat,
+ const void *map_front_private)
{
- struct softpipe_resource *spt = CALLOC_STRUCT(softpipe_resource);
- if (!spt)
+ struct softpipe_resource *spr = CALLOC_STRUCT(softpipe_resource);
+ if (!spr)
return NULL;
assert(templat->format != PIPE_FORMAT_NONE);
- spt->base = *templat;
- pipe_reference_init(&spt->base.reference, 1);
- spt->base.screen = screen;
+ spr->base = *templat;
+ pipe_reference_init(&spr->base.reference, 1);
+ spr->base.screen = screen;
- spt->pot = (util_is_power_of_two(templat->width0) &&
- util_is_power_of_two(templat->height0) &&
- util_is_power_of_two(templat->depth0));
+ spr->pot = (util_is_power_of_two_or_zero(templat->width0) &&
+ util_is_power_of_two_or_zero(templat->height0) &&
+ util_is_power_of_two_or_zero(templat->depth0));
- if (spt->base.bind & (PIPE_BIND_DISPLAY_TARGET |
+ if (spr->base.bind & (PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SCANOUT |
PIPE_BIND_SHARED)) {
- if (!softpipe_displaytarget_layout(screen, spt))
+ if (!softpipe_displaytarget_layout(screen, spr, map_front_private))
goto fail;
}
else {
- if (!softpipe_resource_layout(screen, spt))
+ if (!softpipe_resource_layout(screen, spr, TRUE))
goto fail;
}
- return &spt->base;
+ return &spr->base;
fail:
- FREE(spt);
+ FREE(spr);
return NULL;
}
+static struct pipe_resource *
+softpipe_resource_create(struct pipe_screen *screen,
+ const struct pipe_resource *templat)
+{
+ return softpipe_resource_create_front(screen, templat, NULL);
+}
static void
softpipe_resource_destroy(struct pipe_screen *pscreen,
struct pipe_resource *pt)
{
struct softpipe_screen *screen = softpipe_screen(pscreen);
- struct softpipe_resource *spt = softpipe_resource(pt);
+ struct softpipe_resource *spr = softpipe_resource(pt);
- if (spt->dt) {
+ if (spr->dt) {
/* display target */
struct sw_winsys *winsys = screen->winsys;
- winsys->displaytarget_destroy(winsys, spt->dt);
+ winsys->displaytarget_destroy(winsys, spr->dt);
}
- else if (!spt->userBuffer) {
+ else if (!spr->userBuffer) {
/* regular texture */
- align_free(spt->data);
+ align_free(spr->data);
}
- FREE(spt);
+ FREE(spr);
}
static struct pipe_resource *
softpipe_resource_from_handle(struct pipe_screen *screen,
- const struct pipe_resource *templat,
- struct winsys_handle *whandle)
+ const struct pipe_resource *templat,
+ struct winsys_handle *whandle,
+ unsigned usage)
{
struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
- struct softpipe_resource *spt = CALLOC_STRUCT(softpipe_resource);
- if (!spt)
+ struct softpipe_resource *spr = CALLOC_STRUCT(softpipe_resource);
+ if (!spr)
return NULL;
- spt->base = *templat;
- pipe_reference_init(&spt->base.reference, 1);
- spt->base.screen = screen;
+ spr->base = *templat;
+ pipe_reference_init(&spr->base.reference, 1);
+ spr->base.screen = screen;
- spt->pot = (util_is_power_of_two(templat->width0) &&
- util_is_power_of_two(templat->height0) &&
- util_is_power_of_two(templat->depth0));
+ spr->pot = (util_is_power_of_two_or_zero(templat->width0) &&
+ util_is_power_of_two_or_zero(templat->height0) &&
+ util_is_power_of_two_or_zero(templat->depth0));
- spt->dt = winsys->displaytarget_from_handle(winsys,
+ spr->dt = winsys->displaytarget_from_handle(winsys,
templat,
whandle,
- &spt->stride[0]);
- if (!spt->dt)
+ &spr->stride[0]);
+ if (!spr->dt)
goto fail;
- return &spt->base;
+ return &spr->base;
fail:
- FREE(spt);
+ FREE(spr);
return NULL;
}
-static boolean
+static bool
softpipe_resource_get_handle(struct pipe_screen *screen,
- struct pipe_resource *pt,
- struct winsys_handle *whandle)
+ struct pipe_context *ctx,
+ struct pipe_resource *pt,
+ struct winsys_handle *whandle,
+ unsigned usage)
{
struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
- struct softpipe_resource *spt = softpipe_resource(pt);
+ struct softpipe_resource *spr = softpipe_resource(pt);
- assert(spt->dt);
- if (!spt->dt)
- return FALSE;
+ assert(spr->dt);
+ if (!spr->dt)
+ return false;
+
+ return winsys->displaytarget_get_handle(winsys, spr->dt, whandle);
+}
+
+
+/**
+ * Helper function to compute offset (in bytes) for a particular
+ * texture level/face/slice from the start of the buffer.
+ */
+unsigned
+softpipe_get_tex_image_offset(const struct softpipe_resource *spr,
+ unsigned level, unsigned layer)
+{
+ unsigned offset = spr->level_offset[level];
+
+ offset += layer * spr->img_stride[level];
- return winsys->displaytarget_get_handle(winsys, spt->dt, whandle);
+ return offset;
}
/**
- * Get a pipe_surface "view" into a texture.
+ * 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 *spt = 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 = spt->level_offset[level];
- ps->usage = usage;
-
- ps->face = face;
- ps->level = level;
- ps->zslice = zslice;
-
- if (pt->target == PIPE_TEXTURE_CUBE) {
- ps->offset += face * util_format_get_nblocksy(pt->format, u_minify(pt->height0, level)) *
- spt->stride[level];
- }
- else if (pt->target == PIPE_TEXTURE_3D) {
- ps->offset += zslice * util_format_get_nblocksy(pt->format, u_minify(pt->height0, level)) *
- spt->stride[level];
+ 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 {
- assert(face == 0);
- assert(zslice == 0);
+ /* 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
/**
* Geta pipe_transfer object which is used for moving data in/out of
- * a texture object.
- * \param face one of PIPE_TEX_FACE_x or 0
- * \param level texture mipmap level
- * \param zslice 2D slice of a 3D texture
- * \param usage one of PIPE_TRANSFER_READ/WRITE/READ_WRITE
- * \param x X position of region to read/write
- * \param y Y position of region to read/write
- * \param width width of region to read/write
- * \param height height of region to read/write
+ * a resource object.
+ * \param pipe rendering context
+ * \param resource the resource to transfer in/out of
+ * \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 softpipe_resource *sptex = softpipe_resource(resource);
+ 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));
-
- spt = CALLOC_STRUCT(softpipe_transfer);
- if (spt) {
- struct pipe_transfer *pt = &spt->base;
- enum pipe_format format = resource->format;
- int nblocksy = util_format_get_nblocksy(resource->format,
- u_minify(resource->height0, sr.level));
- pipe_resource_reference(&pt->resource, resource);
- pt->sr = sr;
- pt->usage = usage;
- pt->box = *box;
- pt->stride = sptex->stride[sr.level];
-
- spt->offset = sptex->level_offset[sr.level];
-
- if (resource->target == PIPE_TEXTURE_CUBE) {
- spt->offset += sr.face * nblocksy * pt->stride;
+ 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_3D) {
- spt->offset += box->z * nblocksy * pt->stride;
+ else if (resource->target == PIPE_TEXTURE_CUBE_ARRAY) {
+ assert(box->z <= (int) resource->array_size);
}
else {
- assert(sr.face == 0);
- assert(box->z == 0);
+ assert(box->z + box->depth <= (int) u_minify(resource->depth0, level));
}
-
- 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;
+ /*
+ * Transfers, like other pipe operations, must happen in order, so flush the
+ * context if necessary.
+ */
+ if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
+ boolean read_only = !(usage & PIPE_TRANSFER_WRITE);
+ boolean do_not_block = !!(usage & PIPE_TRANSFER_DONTBLOCK);
+ if (!softpipe_flush_resource(pipe, resource,
+ level, box->depth > 1 ? -1 : box->z,
+ 0, /* flush_flags */
+ read_only,
+ TRUE, /* cpu_access */
+ do_not_block)) {
+ /*
+ * It would have blocked, but state tracker requested no to.
+ */
+ assert(do_not_block);
+ return NULL;
+ }
}
- return NULL;
-}
+ spt = CALLOC_STRUCT(softpipe_transfer);
+ if (!spt)
+ return NULL;
-/**
- * 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);
-}
+ pt = &spt->base;
+ 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 = softpipe_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 *sp_transfer = softpipe_transfer(transfer);
- struct softpipe_resource *sp_resource = softpipe_resource(transfer->resource);
- struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys;
- uint8_t *map;
-
/* resources backed by display target treated specially:
*/
- if (sp_resource->dt) {
- map = winsys->displaytarget_map(winsys,
- sp_resource->dt,
- transfer->usage);
+ if (spr->dt) {
+ map = winsys->displaytarget_map(winsys, spr->dt, usage);
}
else {
- map = sp_resource->data;
+ map = spr->data;
}
- if (map == NULL)
+ if (!map) {
+ pipe_resource_reference(&pt->resource, NULL);
+ FREE(spt);
return NULL;
- else
- return map + sp_transfer->offset;
+ }
+
+ *transfer = pt;
+ return map + spt->offset;
}
softpipe_transfer_unmap(struct pipe_context *pipe,
struct pipe_transfer *transfer)
{
- struct softpipe_resource *spt;
+ struct softpipe_resource *spr;
assert(transfer->resource);
- spt = softpipe_resource(transfer->resource);
+ spr = softpipe_resource(transfer->resource);
- if (spt->dt) {
+ if (spr->dt) {
/* display target */
struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys;
- winsys->displaytarget_unmap(winsys, spt->dt);
+ winsys->displaytarget_unmap(winsys, spr->dt);
}
if (transfer->usage & PIPE_TRANSFER_WRITE) {
/* Mark the texture as dirty to expire the tile caches. */
- spt->timestamp++;
+ 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,
unsigned bind_flags)
{
- struct softpipe_resource *buffer;
+ struct softpipe_resource *spr;
- buffer = CALLOC_STRUCT(softpipe_resource);
- if(!buffer)
+ spr = CALLOC_STRUCT(softpipe_resource);
+ if (!spr)
return NULL;
-
- pipe_reference_init(&buffer->base.reference, 1);
- buffer->base.screen = screen;
- buffer->base.format = PIPE_FORMAT_R8_UNORM; /* ?? */
- buffer->base.bind = bind_flags;
- buffer->base._usage = PIPE_USAGE_IMMUTABLE;
- buffer->base.flags = 0;
- buffer->base.width0 = bytes;
- buffer->base.height0 = 1;
- buffer->base.depth0 = 1;
- buffer->userBuffer = TRUE;
- buffer->data = ptr;
-
- return &buffer->base;
+ pipe_reference_init(&spr->base.reference, 1);
+ spr->base.screen = screen;
+ spr->base.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+ spr->base.bind = bind_flags;
+ spr->base.usage = PIPE_USAGE_IMMUTABLE;
+ spr->base.flags = 0;
+ spr->base.width0 = bytes;
+ spr->base.height0 = 1;
+ spr->base.depth0 = 1;
+ spr->base.array_size = 1;
+ spr->userBuffer = TRUE;
+ spr->data = ptr;
+
+ return &spr->base;
}
-
-
-
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->buffer_subdata = u_default_buffer_subdata;
+ pipe->texture_subdata = u_default_texture_subdata;
+
+ pipe->create_surface = softpipe_create_surface;
+ pipe->surface_destroy = softpipe_surface_destroy;
+ pipe->clear_texture = util_clear_texture;
}
+
void
softpipe_init_screen_texture_funcs(struct pipe_screen *screen)
{
screen->resource_create = softpipe_resource_create;
+ screen->resource_create_front = softpipe_resource_create_front;
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;
}
-
-
-
projects / mesa.git / blobdiff