to reduce the call indirections with u_resource_vtbl.
The worst call tree you could get was:
- u_transfer_inline_write_vtbl
- u_default_transfer_inline_write
- u_transfer_map_vtbl
- driver_transfer_map
- u_transfer_unmap_vtbl
- driver_transfer_unmap
That's 6 indirect calls. Some drivers only had 5. The goal is to have
1 indirect call for drivers that care. The resource type can be determined
statically at most call sites.
The new interface is:
pipe_context::buffer_subdata(ctx, resource, usage, offset, size, data)
pipe_context::texture_subdata(ctx, resource, level, usage, box, data,
stride, layer_stride)
v2: fix whitespace, correct ilo's behavior
Reviewed-by: Nicolai Hähnle <nicolai.haehnle@amd.com>
Acked-by: Roland Scheidegger <sroland@vmware.com>
up_consts(struct pp_queue_t *ppq)
{
struct pipe_context *pipe = ppq->p->pipe;
- struct pipe_box box;
-
- u_box_2d(0, 0, sizeof(constants), 1, &box);
- pipe->transfer_inline_write(pipe, ppq->constbuf, 0, PIPE_TRANSFER_WRITE,
- &box, constants, sizeof(constants),
- sizeof(constants));
+ pipe->buffer_subdata(pipe, ppq->constbuf, PIPE_TRANSFER_WRITE,
+ 0, sizeof(constants), constants);
}
/** Run function of the MLAA filter. */
u_box_2d(0, 0, 165, 165, &box);
- ppq->p->pipe->transfer_inline_write(ppq->p->pipe, ppq->areamaptex, 0,
- PIPE_TRANSFER_WRITE, &box,
- areamap, 165 * 2, sizeof(areamap));
+ ppq->p->pipe->texture_subdata(ppq->p->pipe, ppq->areamaptex, 0,
+ PIPE_TRANSFER_WRITE, &box,
+ areamap, 165 * 2, sizeof(areamap));
ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, offsetvs, true,
"offsetvs");
unsigned size,
const void *data)
{
- struct pipe_box box;
unsigned access = PIPE_TRANSFER_WRITE;
if (offset == 0 && size == buf->width0) {
access |= PIPE_TRANSFER_DISCARD_RANGE;
}
- u_box_1d(offset, size, &box);
-
- pipe->transfer_inline_write( pipe,
- buf,
- 0,
- access,
- &box,
- data,
- size,
- 0);
+ pipe->buffer_subdata(pipe, buf, access, offset, size, data);
}
/**
unsigned offset, unsigned size,
const void *data)
{
- struct pipe_box box;
-
- u_box_1d(offset, size, &box);
-
- pipe->transfer_inline_write(pipe,
- buf,
- 0,
- (PIPE_TRANSFER_WRITE |
- PIPE_TRANSFER_UNSYNCHRONIZED),
- &box,
- data,
- 0, 0);
+ pipe->buffer_subdata(pipe, buf,
+ (PIPE_TRANSFER_WRITE |
+ PIPE_TRANSFER_UNSYNCHRONIZED),
+ offset, size, data);
}
#include "util/u_transfer.h"
#include "util/u_memory.h"
-/* One-shot transfer operation with data supplied in a user
- * pointer. XXX: strides??
- */
-void u_default_transfer_inline_write( struct pipe_context *pipe,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
+void u_default_buffer_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
{
struct pipe_transfer *transfer = NULL;
+ struct pipe_box box;
uint8_t *map = NULL;
assert(!(usage & PIPE_TRANSFER_READ));
- /* the write flag is implicit by the nature of transfer_inline_write */
+ /* the write flag is implicit by the nature of buffer_subdata */
usage |= PIPE_TRANSFER_WRITE;
- /* transfer_inline_write implicitly discards the rewritten buffer range */
- if (resource->target == PIPE_BUFFER &&
- box->x == 0 && box->width == resource->width0) {
+ /* buffer_subdata implicitly discards the rewritten buffer range */
+ if (offset == 0 && size == resource->width0) {
usage |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
} else {
usage |= PIPE_TRANSFER_DISCARD_RANGE;
}
+ u_box_1d(offset, size, &box);
+
+ map = pipe->transfer_map(pipe, resource, 0, usage, &box, &transfer);
+ if (!map)
+ return;
+
+ memcpy(map, data, size);
+ pipe_transfer_unmap(pipe, transfer);
+}
+
+void u_default_texture_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride)
+{
+ struct pipe_transfer *transfer = NULL;
+ const uint8_t *src_data = data;
+ uint8_t *map = NULL;
+
+ assert(!(usage & PIPE_TRANSFER_READ));
+
+ /* the write flag is implicit by the nature of texture_subdata */
+ usage |= PIPE_TRANSFER_WRITE;
+
+ /* texture_subdata implicitly discards the rewritten buffer range */
+ usage |= PIPE_TRANSFER_DISCARD_RANGE;
+
map = pipe->transfer_map(pipe,
resource,
level,
if (!map)
return;
- if (resource->target == PIPE_BUFFER) {
- assert(box->height == 1);
- assert(box->depth == 1);
-
- memcpy(map, data, box->width);
- }
- else {
- const uint8_t *src_data = data;
-
- util_copy_box(map,
- resource->format,
- transfer->stride, /* bytes */
- transfer->layer_stride, /* bytes */
- 0, 0, 0,
- box->width,
- box->height,
- box->depth,
- src_data,
- stride, /* bytes */
- layer_stride, /* bytes */
- 0, 0, 0);
- }
+ util_copy_box(map,
+ resource->format,
+ transfer->stride, /* bytes */
+ transfer->layer_stride, /* bytes */
+ 0, 0, 0,
+ box->width,
+ box->height,
+ box->depth,
+ src_data,
+ stride, /* bytes */
+ layer_stride, /* bytes */
+ 0, 0, 0);
pipe_transfer_unmap(pipe, transfer);
}
struct u_resource *ur = u_resource(transfer->resource);
ur->vtbl->transfer_unmap(pipe, transfer);
}
-
-void u_transfer_inline_write_vtbl( struct pipe_context *pipe,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
-{
- struct u_resource *ur = u_resource(resource);
- ur->vtbl->transfer_inline_write(pipe,
- resource,
- level,
- usage,
- box,
- data,
- stride,
- layer_stride);
-}
-
-
-
-
struct pipe_resource *resource,
struct winsys_handle *handle);
-void u_default_transfer_inline_write( struct pipe_context *pipe,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride);
+void u_default_buffer_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data);
+
+void u_default_texture_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride);
void u_default_transfer_flush_region( struct pipe_context *pipe,
struct pipe_transfer *transfer,
void (*transfer_unmap)( struct pipe_context *,
struct pipe_transfer *transfer );
-
- void (*transfer_inline_write)( struct pipe_context *pipe,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride);
};
void u_transfer_unmap_vtbl( struct pipe_context *rm_ctx,
struct pipe_transfer *transfer );
-void u_transfer_inline_write_vtbl( struct pipe_context *rm_ctx,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride);
-
#endif
the transfer object. The pointer into the resource should be considered
invalid and discarded.
-``transfer_inline_write`` performs a simplified transfer for simple writes.
-Basically transfer_map, data write, and transfer_unmap all in one.
+``texture_subdata`` and ``buffer_subdata`` perform a simplified
+transfer for simple writes. Basically transfer_map, data write, and
+transfer_unmap all in one.
The box parameter to some of these functions defines a 1D, 2D or 3D
}
static void
-dd_context_transfer_inline_write(struct pipe_context *_pipe,
- struct pipe_resource *resource,
- unsigned level, unsigned usage,
- const struct pipe_box *box,
- const void *data, unsigned stride,
- unsigned layer_stride)
+dd_context_buffer_subdata(struct pipe_context *_pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
+{
+ struct pipe_context *pipe = dd_context(_pipe)->pipe;
+
+ pipe->buffer_subdata(pipe, resource, usage, offset, size, data);
+}
+
+static void
+dd_context_texture_subdata(struct pipe_context *_pipe,
+ struct pipe_resource *resource,
+ unsigned level, unsigned usage,
+ const struct pipe_box *box,
+ const void *data, unsigned stride,
+ unsigned layer_stride)
{
struct pipe_context *pipe = dd_context(_pipe)->pipe;
- pipe->transfer_inline_write(pipe, resource, level, usage, box, data,
- stride, layer_stride);
+ pipe->texture_subdata(pipe, resource, level, usage, box, data,
+ stride, layer_stride);
}
CTX_INIT(transfer_map);
CTX_INIT(transfer_flush_region);
CTX_INIT(transfer_unmap);
- CTX_INIT(transfer_inline_write);
+ CTX_INIT(buffer_subdata);
+ CTX_INIT(texture_subdata);
CTX_INIT(texture_barrier);
CTX_INIT(memory_barrier);
/* create_video_codec */
.transfer_map = fd_resource_transfer_map,
.transfer_flush_region = fd_resource_transfer_flush_region,
.transfer_unmap = fd_resource_transfer_unmap,
- .transfer_inline_write = u_default_transfer_inline_write,
};
static uint32_t
pctx->transfer_map = u_transfer_map_vtbl;
pctx->transfer_flush_region = u_transfer_flush_region_vtbl;
pctx->transfer_unmap = u_transfer_unmap_vtbl;
- pctx->transfer_inline_write = u_transfer_inline_write_vtbl;
+ pctx->buffer_subdata = u_default_buffer_subdata;
+ pctx->texture_subdata = u_default_texture_subdata;
pctx->create_surface = fd_create_surface;
pctx->surface_destroy = fd_surface_destroy;
pctx->resource_copy_region = fd_resource_copy_region;
i915->base.transfer_map = u_transfer_map_vtbl;
i915->base.transfer_flush_region = u_transfer_flush_region_vtbl;
i915->base.transfer_unmap = u_transfer_unmap_vtbl;
- i915->base.transfer_inline_write = u_transfer_inline_write_vtbl;
+ i915->base.buffer_subdata = i915_buffer_subdata;
+ i915->base.texture_subdata = u_default_texture_subdata;
}
void
i915_buffer_create(struct pipe_screen *screen,
const struct pipe_resource *template);
+void
+i915_buffer_subdata(struct pipe_context *rm_ctx,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data);
+
#endif /* I915_RESOURCE_H */
util_slab_free(&i915->transfer_pool, transfer);
}
-static void
-i915_buffer_transfer_inline_write( struct pipe_context *rm_ctx,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
+void
+i915_buffer_subdata(struct pipe_context *rm_ctx,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
{
struct i915_buffer *buffer = i915_buffer(resource);
- memcpy(buffer->data + box->x,
- data,
- box->width);
+ memcpy(buffer->data + offset, data, size);
}
i915_buffer_transfer_map, /* transfer_map */
u_default_transfer_flush_region, /* transfer_flush_region */
i915_buffer_transfer_unmap, /* transfer_unmap */
- i915_buffer_transfer_inline_write /* transfer_inline_write */
};
}
#if 0
-static void i915_transfer_inline_write( struct pipe_context *pipe,
+static void i915_texture_subdata(struct pipe_context *pipe,
struct pipe_resource *resource,
unsigned level,
unsigned usage,
i915_texture_transfer_map, /* transfer_map */
u_default_transfer_flush_region, /* transfer_flush_region */
i915_texture_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
return ptr;
}
-static void
-ilo_transfer_inline_write(struct pipe_context *pipe,
- struct pipe_resource *res,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
+static void ilo_buffer_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
{
- if (likely(res->target == PIPE_BUFFER) &&
- !(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
- /* they should specify just an offset and a size */
- assert(level == 0);
- assert(box->y == 0);
- assert(box->z == 0);
- assert(box->height == 1);
- assert(box->depth == 1);
-
- buf_pwrite(ilo_context(pipe), res,
- usage, box->x, box->width, data);
- }
- else {
- u_default_transfer_inline_write(pipe, res,
- level, usage, box, data, stride, layer_stride);
- }
+ if (usage & PIPE_TRANSFER_UNSYNCHRONIZED)
+ u_default_buffer_subdata(pipe, resource, usage, offset, size, data);
+ else
+ buf_pwrite(ilo_context(pipe), resource, usage, offset, size, data);
}
/**
ilo->base.transfer_map = ilo_transfer_map;
ilo->base.transfer_flush_region = ilo_transfer_flush_region;
ilo->base.transfer_unmap = ilo_transfer_unmap;
- ilo->base.transfer_inline_write = ilo_transfer_inline_write;
+ ilo->base.buffer_subdata = ilo_buffer_subdata;
+ ilo->base.texture_subdata = u_default_texture_subdata;
}
pipe->transfer_unmap = llvmpipe_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;
}
FREE(transfer);
}
-static void noop_transfer_inline_write(struct pipe_context *pipe,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
+static void noop_buffer_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
+{
+}
+
+static void noop_texture_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride)
{
}
ctx->transfer_map = noop_transfer_map;
ctx->transfer_flush_region = noop_transfer_flush_region;
ctx->transfer_unmap = noop_transfer_unmap;
- ctx->transfer_inline_write = noop_transfer_inline_write;
+ ctx->buffer_subdata = noop_buffer_subdata;
+ ctx->texture_subdata = noop_texture_subdata;
noop_init_state_functions(ctx);
return ctx;
nouveau_buffer_transfer_map, /* transfer_map */
nouveau_buffer_transfer_flush_region, /* transfer_flush_region */
nouveau_buffer_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
struct pipe_resource *
nv30_miptree_transfer_map,
u_default_transfer_flush_region,
nv30_miptree_transfer_unmap,
- u_default_transfer_inline_write
};
struct pipe_resource *
pipe->transfer_map = u_transfer_map_vtbl;
pipe->transfer_flush_region = u_transfer_flush_region_vtbl;
pipe->transfer_unmap = u_transfer_unmap_vtbl;
- pipe->transfer_inline_write = u_transfer_inline_write_vtbl;
+ pipe->buffer_subdata = u_default_buffer_subdata;
+ pipe->texture_subdata = u_default_texture_subdata;
pipe->create_surface = nv30_miptree_surface_new;
pipe->surface_destroy = nv30_miptree_surface_del;
pipe->resource_copy_region = nv30_resource_copy_region;
nv50_miptree_transfer_map, /* transfer_map */
u_default_transfer_flush_region, /* transfer_flush_region */
nv50_miptree_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
static inline bool
pcontext->transfer_map = u_transfer_map_vtbl;
pcontext->transfer_flush_region = u_transfer_flush_region_vtbl;
pcontext->transfer_unmap = u_transfer_unmap_vtbl;
- pcontext->transfer_inline_write = u_transfer_inline_write_vtbl;
+ pcontext->buffer_subdata = u_default_buffer_subdata;
+ pcontext->texture_subdata = u_default_texture_subdata;
pcontext->create_surface = nv50_surface_create;
pcontext->surface_destroy = nv50_surface_destroy;
pcontext->invalidate_resource = nv50_invalidate_resource;
nvc0_miptree_transfer_map, /* transfer_map */
u_default_transfer_flush_region, /* transfer_flush_region */
nvc0_miptree_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
struct pipe_resource *
pcontext->transfer_map = u_transfer_map_vtbl;
pcontext->transfer_flush_region = u_transfer_flush_region_vtbl;
pcontext->transfer_unmap = u_transfer_unmap_vtbl;
- pcontext->transfer_inline_write = u_transfer_inline_write_vtbl;
+ pcontext->buffer_subdata = u_default_buffer_subdata;
+ pcontext->texture_subdata = u_default_texture_subdata;
pcontext->create_surface = nvc0_surface_create;
pcontext->surface_destroy = nv50_surface_destroy;
pcontext->invalidate_resource = nv50_invalidate_resource;
r300->context.transfer_map = u_transfer_map_vtbl;
r300->context.transfer_flush_region = u_default_transfer_flush_region;
r300->context.transfer_unmap = u_transfer_unmap_vtbl;
- r300->context.transfer_inline_write = u_default_transfer_inline_write;
+ r300->context.buffer_subdata = u_default_buffer_subdata;
+ r300->context.texture_subdata = u_default_texture_subdata;
r300->context.create_surface = r300_create_surface;
r300->context.surface_destroy = r300_surface_destroy;
}
r300_buffer_transfer_map, /* transfer_map */
NULL, /* transfer_flush_region */
r300_buffer_transfer_unmap, /* transfer_unmap */
- NULL /* transfer_inline_write */
};
struct pipe_resource *r300_buffer_create(struct pipe_screen *screen,
r300_texture_transfer_map, /* transfer_map */
NULL, /* transfer_flush_region */
r300_texture_transfer_unmap, /* transfer_unmap */
- NULL /* transfer_inline_write */
};
/* The common texture constructor. */
assert(0 && "TODO");
}
-static void r600_compute_global_transfer_inline_write(struct pipe_context *pipe,
- struct pipe_resource *resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
-{
- assert(0 && "TODO");
-}
-
static void r600_compute_global_buffer_destroy(struct pipe_screen *screen,
struct pipe_resource *res)
{
r600_compute_global_transfer_map, /* transfer_map */
r600_compute_global_transfer_flush_region,/* transfer_flush_region */
r600_compute_global_transfer_unmap, /* transfer_unmap */
- r600_compute_global_transfer_inline_write /* transfer_inline_write */
};
struct pipe_resource *r600_compute_global_buffer_create(struct pipe_screen *screen,
r600_buffer_transfer_map, /* transfer_map */
r600_buffer_flush_region, /* transfer_flush_region */
r600_buffer_transfer_unmap, /* transfer_unmap */
- NULL /* transfer_inline_write */
};
static struct r600_resource *
rctx->b.transfer_map = u_transfer_map_vtbl;
rctx->b.transfer_flush_region = u_transfer_flush_region_vtbl;
rctx->b.transfer_unmap = u_transfer_unmap_vtbl;
- rctx->b.transfer_inline_write = u_default_transfer_inline_write;
- rctx->b.memory_barrier = r600_memory_barrier;
+ rctx->b.buffer_subdata = u_default_buffer_subdata;
+ rctx->b.texture_subdata = u_default_texture_subdata;
+ rctx->b.memory_barrier = r600_memory_barrier;
rctx->b.flush = r600_flush_from_st;
rctx->b.set_debug_callback = r600_set_debug_callback;
r600_texture_transfer_map, /* transfer_map */
u_default_transfer_flush_region, /* transfer_flush_region */
r600_texture_transfer_unmap, /* transfer_unmap */
- NULL /* transfer_inline_write */
};
struct pipe_surface *r600_create_surface_custom(struct pipe_context *pipe,
static void
-rbug_context_transfer_inline_write(struct pipe_context *_context,
- struct pipe_resource *_resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
+rbug_context_buffer_subdata(struct pipe_context *_context,
+ struct pipe_resource *_resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
+{
+ struct rbug_context *rb_pipe = rbug_context(_context);
+ struct rbug_resource *rb_resource = rbug_resource(_resource);
+ struct pipe_context *context = rb_pipe->pipe;
+ struct pipe_resource *resource = rb_resource->resource;
+
+ pipe_mutex_lock(rb_pipe->call_mutex);
+ context->buffer_subdata(context, resource, usage, offset, size, data);
+ pipe_mutex_unlock(rb_pipe->call_mutex);
+}
+
+
+static void
+rbug_context_texture_subdata(struct pipe_context *_context,
+ struct pipe_resource *_resource,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride)
{
struct rbug_context *rb_pipe = rbug_context(_context);
struct rbug_resource *rb_resource = rbug_resource(_resource);
struct pipe_resource *resource = rb_resource->resource;
pipe_mutex_lock(rb_pipe->call_mutex);
- context->transfer_inline_write(context,
- resource,
- level,
- usage,
- box,
- data,
- stride,
- layer_stride);
+ context->texture_subdata(context,
+ resource,
+ level,
+ usage,
+ box,
+ data,
+ stride,
+ layer_stride);
pipe_mutex_unlock(rb_pipe->call_mutex);
}
rb_pipe->base.transfer_map = rbug_context_transfer_map;
rb_pipe->base.transfer_unmap = rbug_context_transfer_unmap;
rb_pipe->base.transfer_flush_region = rbug_context_transfer_flush_region;
- rb_pipe->base.transfer_inline_write = rbug_context_transfer_inline_write;
+ rb_pipe->base.buffer_subdata = rbug_context_buffer_subdata;
+ rb_pipe->base.texture_subdata = rbug_context_texture_subdata;
rb_pipe->pipe = pipe;
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;
svga->pipe.transfer_map = u_transfer_map_vtbl;
svga->pipe.transfer_flush_region = u_transfer_flush_region_vtbl;
svga->pipe.transfer_unmap = u_transfer_unmap_vtbl;
- svga->pipe.transfer_inline_write = u_transfer_inline_write_vtbl;
+ svga->pipe.buffer_subdata = u_default_buffer_subdata;
+ svga->pipe.texture_subdata = u_default_texture_subdata;
if (svga_have_vgpu10(svga)) {
svga->pipe.generate_mipmap = svga_texture_generate_mipmap;
svga_buffer_transfer_map, /* transfer_map */
svga_buffer_transfer_flush_region, /* transfer_flush_region */
svga_buffer_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
svga_texture_transfer_map, /* transfer_map */
u_default_transfer_flush_region, /* transfer_flush_region */
svga_texture_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
ctx->pipe.transfer_unmap = swr_transfer_unmap;
ctx->pipe.transfer_flush_region = u_default_transfer_flush_region;
- ctx->pipe.transfer_inline_write = u_default_transfer_inline_write;
+ ctx->pipe.buffer_subdata = u_default_buffer_subdata;
+ ctx->pipe.texture_subdata = u_default_texture_subdata;
ctx->pipe.resource_copy_region = swr_resource_copy;
ctx->pipe.render_condition = swr_render_condition;
/*
* Map and transfers can't be serialized so we convert all write transfers
- * to transfer_inline_write and ignore read transfers.
+ * to texture/buffer_subdata and ignore read transfers.
*/
map = context->transfer_map(context, texture, level, usage, box, &result);
if (tr_trans->map) {
/*
- * Fake a transfer_inline_write
+ * Fake a texture/buffer_subdata
*/
struct pipe_resource *resource = transfer->resource;
unsigned stride = transfer->stride;
unsigned layer_stride = transfer->layer_stride;
- trace_dump_call_begin("pipe_context", "transfer_inline_write");
+ if (resource->target == PIPE_BUFFER)
+ trace_dump_call_begin("pipe_context", "buffer_subdata");
+ else
+ trace_dump_call_begin("pipe_context", "texture_subdata");
trace_dump_arg(ptr, context);
trace_dump_arg(ptr, resource);
static void
-trace_context_transfer_inline_write(struct pipe_context *_context,
- struct pipe_resource *_resource,
- unsigned level,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned layer_stride)
+trace_context_buffer_subdata(struct pipe_context *_context,
+ struct pipe_resource *_resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
+{
+ struct trace_context *tr_context = trace_context(_context);
+ struct trace_resource *tr_res = trace_resource(_resource);
+ struct pipe_context *context = tr_context->pipe;
+ struct pipe_resource *resource = tr_res->resource;
+ struct pipe_box box;
+
+ assert(resource->screen == context->screen);
+
+ trace_dump_call_begin("pipe_context", "buffer_subdata");
+
+ trace_dump_arg(ptr, context);
+ trace_dump_arg(ptr, resource);
+ trace_dump_arg(uint, usage);
+ trace_dump_arg(uint, offset);
+ trace_dump_arg(uint, size);
+
+ trace_dump_arg_begin("data");
+ u_box_1d(offset, size, &box);
+ trace_dump_box_bytes(data, resource, &box, 0, 0);
+ trace_dump_arg_end();
+
+ trace_dump_call_end();
+
+ context->buffer_subdata(context, resource, usage, offset, size, data);
+}
+
+
+static void
+trace_context_texture_subdata(struct pipe_context *_context,
+ struct pipe_resource *_resource,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride)
{
struct trace_context *tr_context = trace_context(_context);
struct trace_resource *tr_res = trace_resource(_resource);
assert(resource->screen == context->screen);
- trace_dump_call_begin("pipe_context", "transfer_inline_write");
+ trace_dump_call_begin("pipe_context", "texture_subdata");
trace_dump_arg(ptr, context);
trace_dump_arg(ptr, resource);
trace_dump_call_end();
- context->transfer_inline_write(context, resource, level, usage, box,
- data, stride, layer_stride);
+ context->texture_subdata(context, resource, level, usage, box,
+ data, stride, layer_stride);
}
TR_CTX_INIT(transfer_map);
TR_CTX_INIT(transfer_unmap);
TR_CTX_INIT(transfer_flush_region);
- TR_CTX_INIT(transfer_inline_write);
+ TR_CTX_INIT(buffer_subdata);
+ TR_CTX_INIT(texture_subdata);
#undef TR_CTX_INIT
.transfer_map = vc4_resource_transfer_map,
.transfer_flush_region = u_default_transfer_flush_region,
.transfer_unmap = vc4_resource_transfer_unmap,
- .transfer_inline_write = u_default_transfer_inline_write,
};
static void
pctx->transfer_map = u_transfer_map_vtbl;
pctx->transfer_flush_region = u_transfer_flush_region_vtbl;
pctx->transfer_unmap = u_transfer_unmap_vtbl;
- pctx->transfer_inline_write = u_transfer_inline_write_vtbl;
+ pctx->buffer_subdata = u_default_buffer_subdata;
+ pctx->texture_subdata = u_default_texture_subdata;
pctx->create_surface = vc4_create_surface;
pctx->surface_destroy = vc4_surface_destroy;
pctx->resource_copy_region = util_resource_copy_region;
virgl_buffer_transfer_map, /* transfer_map */
virgl_buffer_transfer_flush_region, /* transfer_flush_region */
virgl_buffer_transfer_unmap, /* transfer_unmap */
- virgl_transfer_inline_write /* transfer_inline_write */
};
struct pipe_resource *virgl_buffer_create(struct virgl_screen *vs,
screen->resource_destroy = u_resource_destroy_vtbl;
}
+static void virgl_buffer_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
+{
+ struct pipe_box box;
+
+ u_box_1d(offset, size, &box);
+ virgl_transfer_inline_write(pipe, resource, 0, usage, &box, data, 0, 0);
+}
+
void virgl_init_context_resource_functions(struct pipe_context *ctx)
{
ctx->transfer_map = u_transfer_map_vtbl;
ctx->transfer_flush_region = u_transfer_flush_region_vtbl;
ctx->transfer_unmap = u_transfer_unmap_vtbl;
- ctx->transfer_inline_write = u_transfer_inline_write_vtbl;
+ ctx->buffer_subdata = virgl_buffer_subdata;
+ ctx->texture_subdata = u_default_texture_subdata;
}
virgl_texture_transfer_map, /* transfer_map */
NULL, /* transfer_flush_region */
virgl_texture_transfer_unmap, /* transfer_unmap */
- u_default_transfer_inline_write /* transfer_inline_write */
};
struct pipe_resource *
struct pipe_transfer *transfer);
/* One-shot transfer operation with data supplied in a user
- * pointer. XXX: strides??
- */
- void (*transfer_inline_write)( struct pipe_context *,
- struct pipe_resource *,
- unsigned level,
- unsigned usage, /* a combination of PIPE_TRANSFER_x */
- const struct pipe_box *,
- const void *data,
- unsigned stride,
- unsigned layer_stride);
+ * pointer.
+ */
+ void (*buffer_subdata)(struct pipe_context *,
+ struct pipe_resource *,
+ unsigned usage, /* a combination of PIPE_TRANSFER_x */
+ unsigned offset,
+ unsigned size,
+ const void *data);
+
+ void (*texture_subdata)(struct pipe_context *,
+ struct pipe_resource *,
+ unsigned level,
+ unsigned usage, /* a combination of PIPE_TRANSFER_x */
+ const struct pipe_box *,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride);
/**
* Flush any pending framebuffer writes and invalidate texture caches.
box rect { {{ 0, 0, 0 }}, {{ info.width0, info.height0, info.depth0 }} };
unsigned cpp = util_format_get_blocksize(info.format);
- q.pipe->transfer_inline_write(q.pipe, pipe, 0, PIPE_TRANSFER_WRITE,
- rect, data_ptr, cpp * info.width0,
- cpp * info.width0 * info.height0);
+ if (pipe->target == PIPE_BUFFER)
+ q.pipe->buffer_subdata(q.pipe, pipe, PIPE_TRANSFER_WRITE,
+ 0, info.width0, data_ptr);
+ else
+ q.pipe->texture_subdata(q.pipe, pipe, 0, PIPE_TRANSFER_WRITE,
+ rect, data_ptr, cpp * info.width0,
+ cpp * info.width0 * info.height0);
}
}
struct pipe_context *pipe = This->pipe;
assert(This->base.pool == D3DPOOL_MANAGED && This->managed.dirty);
- pipe->transfer_inline_write(pipe, This->base.resource, 0, 0,
- &This->managed.dirty_box,
- (char *)This->managed.data + This->managed.dirty_box.x,
- This->size, This->size);
+ pipe->buffer_subdata(pipe, This->base.resource, 0,
+ This->managed.dirty_box.x,
+ This->managed.dirty_box.width,
+ (char *)This->managed.data + This->managed.dirty_box.x);
This->managed.dirty = FALSE;
}
DBG("upload ConstantF [%u .. %u]\n", x, (x) + (c) - 1); \
box.x = (p) * 4 * sizeof(float); \
box.width = (c) * 4 * sizeof(float); \
- pipe->transfer_inline_write(pipe, buf, 0, usage, &box, &((d)[p * 4]), \
- 0, 0); \
+ pipe->buffer_subdata(pipe, buf, usage, box.x, box.width, &((d)[p * 4])); \
} while(0)
/* OK, this is a bit ugly ... */
box.x = x;
box.width = c * 4;
DBG("upload ConstantB [%u .. %u]\n", x, x + c - 1);
- pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data_b, 0, 0);
+ pipe->buffer_subdata(pipe, buf, usage, box.x, box.width, data_b);
}
/* int4 */
box.x += x * 4 * sizeof(int);
box.width = c * 4 * sizeof(int);
c = 0;
- pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data, 0, 0);
+ pipe->buffer_subdata(pipe, buf, usage, box.x, box.width, data);
}
}
if (c) {
box.x = buf->width0 - (NINE_MAX_CONST_I * 4 + NINE_MAX_CONST_B) * 4;
box.x += x * 4 * sizeof(int);
box.width = c * 4 * sizeof(int);
- pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data, 0, 0);
+ pipe->buffer_subdata(pipe, buf, usage, box.x, box.width, data);
}
/* TODO: only upload these when shader itself changes */
n += r->end - r->bgn;
box.width = (r->end - r->bgn) * 4 * sizeof(float);
data = &lconstf_data[4 * n];
- pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data, 0, 0);
+ pipe->buffer_subdata(pipe, buf, usage, box.x, box.width, data);
r = r->next;
}
}
ptr = NineSurface9_GetSystemMemPointer(This, box.x, box.y);
- pipe->transfer_inline_write(pipe, res, This->level, 0,
- &box, ptr, This->stride, 0);
+ pipe->texture_subdata(pipe, res, This->level, 0,
+ &box, ptr, This->stride, 0);
return D3D_OK;
}
ptr = NineVolume9_GetSystemMemPointer(This, box.x, box.y, box.z);
- pipe->transfer_inline_write(pipe, res, This->level, 0, &box,
- ptr, This->stride, This->layer_stride);
+ pipe->texture_subdata(pipe, res, This->level, 0, &box,
+ ptr, This->stride, This->layer_stride);
return D3D_OK;
}
box.width = def->nFrameWidth;
box.height = def->nFrameHeight;
box.depth = 1;
- priv->s_pipe->transfer_inline_write(priv->s_pipe, views[0]->texture, 0,
- PIPE_TRANSFER_WRITE, &box,
- ptr, def->nStride, 0);
+ priv->s_pipe->texture_subdata(priv->s_pipe, views[0]->texture, 0,
+ PIPE_TRANSFER_WRITE, &box,
+ ptr, def->nStride, 0);
ptr = ((uint8_t*)buf->pBuffer) + (def->nStride * box.height);
box.width = def->nFrameWidth / 2;
box.height = def->nFrameHeight / 2;
box.depth = 1;
- priv->s_pipe->transfer_inline_write(priv->s_pipe, views[1]->texture, 0,
- PIPE_TRANSFER_WRITE, &box,
- ptr, def->nStride, 0);
+ priv->s_pipe->texture_subdata(priv->s_pipe, views[1]->texture, 0,
+ PIPE_TRANSFER_WRITE, &box,
+ ptr, def->nStride, 0);
} else {
struct pipe_blit_info blit;
struct vl_video_buffer *dst_buf = (struct vl_video_buffer *)vbuf;
vlVaVideoSurfaceSize(surf, i, &width, &height);
for (j = 0; j < views[i]->texture->array_size; ++j) {
struct pipe_box dst_box = {0, 0, j, width, height, 1};
- drv->pipe->transfer_inline_write(drv->pipe, views[i]->texture, 0,
- PIPE_TRANSFER_WRITE, &dst_box,
- data[i] + pitches[i] * j,
- pitches[i] * views[i]->texture->array_size, 0);
+ drv->pipe->texture_subdata(drv->pipe, views[i]->texture, 0,
+ PIPE_TRANSFER_WRITE, &dst_box,
+ data[i] + pitches[i] * j,
+ pitches[i] * views[i]->texture->array_size, 0);
}
}
pipe_mutex_unlock(drv->mutex);
vlVdpResolveDelayedRendering(vlsurface->device, NULL, NULL);
dst_box = RectToPipeBox(destination_rect, vlsurface->sampler_view->texture);
- pipe->transfer_inline_write(pipe, vlsurface->sampler_view->texture, 0,
- PIPE_TRANSFER_WRITE, &dst_box, *source_data,
- *source_pitches, 0);
+ pipe->texture_subdata(pipe, vlsurface->sampler_view->texture, 0,
+ PIPE_TRANSFER_WRITE, &dst_box, *source_data,
+ *source_pitches, 0);
pipe_mutex_unlock(vlsurface->device->mutex);
vlVdpResolveDelayedRendering(vlsurface->device, NULL, NULL);
dst_box = RectToPipeBox(destination_rect, vlsurface->sampler_view->texture);
- pipe->transfer_inline_write(pipe, vlsurface->sampler_view->texture, 0,
- PIPE_TRANSFER_WRITE, &dst_box, *source_data,
- *source_pitches, 0);
+ pipe->texture_subdata(pipe, vlsurface->sampler_view->texture, 0,
+ PIPE_TRANSFER_WRITE, &dst_box, *source_data,
+ *source_pitches, 0);
pipe_mutex_unlock(vlsurface->device->mutex);
return VDP_STATUS_OK;
box.height = res->height0;
box.depth = res->depth0;
- context->transfer_inline_write(context, res, 0, PIPE_TRANSFER_WRITE, &box,
- source_data[0], source_pitch[0],
- source_pitch[0] * res->height0);
+ context->texture_subdata(context, res, 0, PIPE_TRANSFER_WRITE, &box,
+ source_data[0], source_pitch[0],
+ source_pitch[0] * res->height0);
memset(&sv_tmpl, 0, sizeof(sv_tmpl));
u_sampler_view_default_template(&sv_tmpl, res, res->format);
box.height = res->height0;
box.depth = res->depth0;
- context->transfer_inline_write(context, res, 0, PIPE_TRANSFER_WRITE, &box, color_table,
- util_format_get_stride(colortbl_format, res->width0), 0);
+ context->texture_subdata(context, res, 0, PIPE_TRANSFER_WRITE, &box, color_table,
+ util_format_get_stride(colortbl_format, res->width0), 0);
memset(&sv_tmpl, 0, sizeof(sv_tmpl));
u_sampler_view_default_template(&sv_tmpl, res, res->format);
sv->texture->width0, sv->texture->height0, 1
};
- pipe->transfer_inline_write(pipe, sv->texture, 0, PIPE_TRANSFER_WRITE, &dst_box,
- source_data[i], source_pitches[i], 0);
+ pipe->texture_subdata(pipe, sv->texture, 0, PIPE_TRANSFER_WRITE, &dst_box,
+ source_data[i], source_pitches[i], 0);
}
if (!csc_matrix) {
width, height, 1
};
- pipe->transfer_inline_write(pipe, sv->texture, 0,
- PIPE_TRANSFER_WRITE, &dst_box,
- source_data[i] + source_pitches[i] * j,
- source_pitches[i] * sv->texture->array_size,
- 0);
+ pipe->texture_subdata(pipe, sv->texture, 0,
+ PIPE_TRANSFER_WRITE, &dst_box,
+ source_data[i] + source_pitches[i] * j,
+ source_pitches[i] * sv->texture->array_size,
+ 0);
}
}
pipe_mutex_unlock(p_surf->device->mutex);
u_box_2d(0,0,SIZE,SIZE, &box);
- ctx->transfer_inline_write(ctx,
- samptex,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- tex2d,
- sizeof tex2d[0],
- sizeof tex2d);
+ ctx->texture_subdata(ctx,
+ samptex,
+ 0,
+ PIPE_TRANSFER_WRITE,
+ &box,
+ tex2d,
+ sizeof tex2d[0],
+ sizeof tex2d);
/* Possibly read back & compare against original data:
*/
u_box_2d(0, 0, width, height, &box);
- info->ctx->transfer_inline_write(info->ctx,
- tex,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- data,
- row_stride,
- image_bytes);
+ info->ctx->texture_subdata(info->ctx,
+ tex,
+ 0,
+ PIPE_TRANSFER_WRITE,
+ &box,
+ data,
+ row_stride,
+ image_bytes);
/* Possibly read back & compare against original data:
*/
static void init_fs_constbuf( void )
{
struct pipe_resource templat;
- struct pipe_box box;
templat.target = PIPE_BUFFER;
templat.format = PIPE_FORMAT_R8_UNORM;
exit(4);
{
- u_box_2d(0,0,sizeof(constants1),1, &box);
-
- ctx->transfer_inline_write(ctx,
- constbuf1,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- constants1,
- sizeof constants1,
- sizeof constants1);
-
+ ctx->buffer_subdata(ctx, constbuf1,
+ PIPE_TRANSFER_WRITE,
+ 0, sizeof(constants1), constants1);
pipe_set_constant_buffer(ctx,
PIPE_SHADER_GEOMETRY, 0,
constbuf1);
}
{
- u_box_2d(0,0,sizeof(constants2),1, &box);
-
- ctx->transfer_inline_write(ctx,
- constbuf2,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- constants2,
- sizeof constants2,
- sizeof constants2);
-
+ ctx->buffer_subdata(ctx, constbuf2,
+ PIPE_TRANSFER_WRITE,
+ 0, sizeof(constants2), constants2);
pipe_set_constant_buffer(ctx,
PIPE_SHADER_GEOMETRY, 1,
u_box_2d(0,0,SIZE,SIZE, &box);
- ctx->transfer_inline_write(ctx,
- samptex,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- tex2d,
- sizeof tex2d[0],
- sizeof tex2d);
+ ctx->texture_subdata(ctx,
+ samptex,
+ 0,
+ PIPE_TRANSFER_WRITE,
+ &box,
+ tex2d,
+ sizeof tex2d[0],
+ sizeof tex2d);
/* Possibly read back & compare against original data:
*/
u_box_2d(0,0,SIZE,SIZE, &box);
- ctx->transfer_inline_write(ctx,
- samptex,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- tex2d,
- sizeof tex2d[0],
- sizeof tex2d);
+ ctx->texture_subdata(ctx,
+ samptex,
+ 0,
+ PIPE_TRANSFER_WRITE,
+ &box,
+ tex2d,
+ sizeof tex2d[0],
+ sizeof tex2d);
/* Possibly read back & compare against original data:
*/
u_box_2d(0,0,sizeof(constants),1, &box);
- ctx->transfer_inline_write(ctx,
- constbuf,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- constants,
- sizeof constants,
- sizeof constants);
-
+ ctx->buffer_subdata(ctx, constbuf,
+ PIPE_TRANSFER_WRITE,
+ 0, sizeof(constants), constants);
pipe_set_constant_buffer(ctx,
PIPE_SHADER_VERTEX, 0,
u_box_2d(0,0,SIZE,SIZE, &box);
- ctx->transfer_inline_write(ctx,
- samptex,
- 0,
- PIPE_TRANSFER_WRITE,
- &box,
- tex2d,
- sizeof tex2d[0],
- sizeof tex2d);
+ ctx->texture_subdata(ctx,
+ samptex,
+ 0,
+ PIPE_TRANSFER_WRITE,
+ &box,
+ tex2d,
+ sizeof tex2d[0],
+ sizeof tex2d);
/* Possibly read back & compare against original data:
*/
* This should be the same as creating a new buffer, but we avoid
* a lot of validation in Mesa.
*/
- struct pipe_box box;
-
- u_box_1d(0, size, &box);
- pipe->transfer_inline_write(pipe, st_obj->buffer, 0,
- PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
- &box, data, 0, 0);
+ pipe->buffer_subdata(pipe, st_obj->buffer,
+ PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
+ 0, size, data);
return GL_TRUE;
} else if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER)) {
pipe->invalidate_resource(pipe, st_obj->buffer);
if (!dst)
goto fallback;
- /* Try transfer_inline_write, which should be the fastest memcpy path. */
+ /* Try texture_subdata, which should be the fastest memcpy path. */
if (pixels &&
!_mesa_is_bufferobj(unpack->BufferObj) &&
_mesa_texstore_can_use_memcpy(ctx, texImage->_BaseFormat,
}
u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box);
- pipe->transfer_inline_write(pipe, dst, dst_level, 0,
- &box, data, stride, layer_stride);
+ pipe->texture_subdata(pipe, dst, dst_level, 0,
+ &box, data, stride, layer_stride);
return;
}
projects / mesa.git / commitdiff