void
pb_init_winsys(struct pipe_winsys *winsys)
{
- winsys->user_buffer_create = pb_winsys_user_buffer_create;
- winsys->buffer_map = pb_winsys_buffer_map;
- winsys->buffer_unmap = pb_winsys_buffer_unmap;
- winsys->buffer_destroy = pb_winsys_buffer_destroy;
+ winsys->_user_buffer_create = pb_winsys_user_buffer_create;
+ winsys->_buffer_map = pb_winsys_buffer_map;
+ winsys->_buffer_unmap = pb_winsys_buffer_unmap;
+ winsys->_buffer_destroy = pb_winsys_buffer_destroy;
}
struct pipe_winsys *backend = timed_winsys(winsys)->backend;
uint64_t start = time_start();
- struct pipe_buffer *buf = backend->buffer_create( backend, alignment, usage, size );
+ struct pipe_buffer *buf =
+ backend->_buffer_create( backend, alignment, usage, size );
time_finish(winsys, start, 0, __FUNCTION__);
struct pipe_winsys *backend = timed_winsys(winsys)->backend;
uint64_t start = time_start();
- struct pipe_buffer *buf = backend->user_buffer_create( backend, data, bytes );
+ struct pipe_buffer *buf = backend->_user_buffer_create( backend, data, bytes );
time_finish(winsys, start, 1, __FUNCTION__);
struct pipe_winsys *backend = timed_winsys(winsys)->backend;
uint64_t start = time_start();
- void *map = backend->buffer_map( backend, buf, flags );
+ void *map = backend->_buffer_map( backend, buf, flags );
time_finish(winsys, start, 2, __FUNCTION__);
struct pipe_winsys *backend = timed_winsys(winsys)->backend;
uint64_t start = time_start();
- backend->buffer_unmap( backend, buf );
+ backend->_buffer_unmap( backend, buf );
time_finish(winsys, start, 3, __FUNCTION__);
}
struct pipe_winsys *backend = timed_winsys(winsys)->backend;
uint64_t start = time_start();
- backend->buffer_destroy( backend, buf );
+ backend->_buffer_destroy( backend, buf );
time_finish(winsys, start, 4, __FUNCTION__);
}
struct pipe_winsys *backend = timed_winsys(winsys)->backend;
uint64_t start = time_start();
- struct pipe_buffer *ret = backend->surface_buffer_create( backend, width, height,
+ struct pipe_buffer *ret = backend->_surface_buffer_create( backend, width, height,
format, usage, stride );
time_finish(winsys, start, 7, __FUNCTION__);
{
struct timed_winsys *ws = CALLOC_STRUCT(timed_winsys);
- ws->base.user_buffer_create = timed_user_buffer_create;
- ws->base.buffer_map = timed_buffer_map;
- ws->base.buffer_unmap = timed_buffer_unmap;
- ws->base.buffer_destroy = timed_buffer_destroy;
- ws->base.buffer_create = timed_buffer_create;
+ ws->base._user_buffer_create = timed_user_buffer_create;
+ ws->base._buffer_map = timed_buffer_map;
+ ws->base._buffer_unmap = timed_buffer_unmap;
+ ws->base._buffer_destroy = timed_buffer_destroy;
+ ws->base._buffer_create = timed_buffer_create;
+ ws->base._surface_buffer_create = timed_surface_buffer_create;
ws->base.flush_frontbuffer = timed_flush_frontbuffer;
ws->base.get_name = timed_get_name;
- ws->base.surface_buffer_create = timed_surface_buffer_create;
ws->base.fence_reference = timed_fence_reference;
ws->base.fence_signalled = timed_fence_signalled;
ws->base.fence_finish = timed_fence_finish;
uint i;
for (i = 0; i < 2; i++) {
if (sp->constants[i].size) {
- sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer,
- PIPE_BUFFER_USAGE_CPU_READ);
+ sp->mapped_constants[i] = ws->_buffer_map(ws, sp->constants[i].buffer,
+ PIPE_BUFFER_USAGE_CPU_READ);
cell_flush_buffer_range(sp, sp->mapped_constants[i],
sp->constants[i].buffer->size);
}
uint i;
for (i = 0; i < 2; i++) {
if (sp->constants[i].size)
- ws->buffer_unmap(ws, sp->constants[i].buffer);
+ ws->_buffer_unmap(ws, sp->constants[i].buffer);
sp->mapped_constants[i] = NULL;
}
}
draw_flush(cell->draw);
/* note: reference counting */
- winsys_buffer_reference(ws,
- &cell->constants[shader].buffer,
- buf->buffer);
+ pipe_buffer_reference(pipe->screen,
+ &cell->constants[shader].buffer,
+ buf->buffer);
cell->constants[shader].size = buf->size;
if (shader == PIPE_SHADER_VERTEX)
cell_texture_layout(ct);
- ct->buffer = ws->buffer_create(ws, 32, PIPE_BUFFER_USAGE_PIXEL,
- ct->buffer_size);
+ ct->buffer = ws->_buffer_create(ws, 32, PIPE_BUFFER_USAGE_PIXEL,
+ ct->buffer_size);
if (!ct->buffer) {
FREE(ct);
*/
if (ct->tiled_buffer[i]) {
ct->tiled_mapped[i] = NULL;
- winsys_buffer_reference(screen->winsys, &ct->tiled_buffer[i], NULL);
+ pipe_buffer_reference(screen, &ct->tiled_buffer[i], NULL);
}
}
/* allocate buffer for tiled data now */
struct pipe_winsys *ws = screen->winsys;
uint bytes = bufWidth * bufHeight * 4 * numFaces;
- ct->tiled_buffer[level] = ws->buffer_create(ws, 16,
- PIPE_BUFFER_USAGE_PIXEL,
- bytes);
+ ct->tiled_buffer[level] = ws->_buffer_create(ws, 16,
+ PIPE_BUFFER_USAGE_PIXEL,
+ bytes);
/* and map it */
- ct->tiled_mapped[level] = ws->buffer_map(ws, ct->tiled_buffer[level],
- PIPE_BUFFER_USAGE_GPU_READ);
+ ct->tiled_mapped[level] = ws->_buffer_map(ws, ct->tiled_buffer[level],
+ PIPE_BUFFER_USAGE_GPU_READ);
}
dst = (uint *) ((ubyte *) ct->tiled_mapped[level] + offset);
if (ps) {
assert(ps->refcount);
assert(ps->winsys);
- winsys_buffer_reference(ws, &ps->buffer, ct->buffer);
+ pipe_buffer_reference(screen, &ps->buffer, ct->buffer);
ps->format = pt->format;
ps->block = pt->block;
ps->width = pt->width[level];
if (buf) {
void *mapped;
if (buf->buffer && buf->buffer->size &&
- (mapped = ws->buffer_map(ws, buf->buffer,
- PIPE_BUFFER_USAGE_CPU_READ))) {
+ (mapped = ws->_buffer_map(ws, buf->buffer,
+ PIPE_BUFFER_USAGE_CPU_READ))) {
memcpy(i915->current.constants[shader], mapped, buf->buffer->size);
- ws->buffer_unmap(ws, buf->buffer);
+ ws->_buffer_unmap(ws, buf->buffer);
i915->current.num_user_constants[shader]
= buf->buffer->size / (4 * sizeof(float));
}
tex_size = tex->stride * tex->total_nblocksy;
- tex->buffer = ws->buffer_create(ws, 64,
- PIPE_BUFFER_USAGE_PIXEL,
- tex_size);
+ tex->buffer = ws->_buffer_create(ws, 64,
+ PIPE_BUFFER_USAGE_PIXEL,
+ tex_size);
if (!tex->buffer)
goto fail;
#if 0
- void *ptr = ws->buffer_map(ws, tex->buffer,
+ void *ptr = ws->_buffer_map(ws, tex->buffer,
PIPE_BUFFER_USAGE_CPU_WRITE);
memset(ptr, 0x80, tex_size);
- ws->buffer_unmap(ws, tex->buffer);
+ ws->_buffer_unmap(ws, tex->buffer);
#endif
return &tex->base;
/* FIXME: buffer size is num_consts + num_immediates */
if (brw->vs.prog_data->num_consts) {
/* map the vertex constant buffer and copy to curbe: */
- void *data = ws->buffer_map(ws, cbuffer->buffer, 0);
+ void *data = ws->_buffer_map(ws, cbuffer->buffer, 0);
/* FIXME: this is wrong. the cbuffer->buffer->size currently
* represents size of consts + immediates. so if we'll
* have both we'll copy over the end of the buffer
* with the subsequent memcpy */
memcpy(&buf[offset], data, cbuffer->buffer->size);
- ws->buffer_unmap(ws, cbuffer->buffer);
+ ws->_buffer_unmap(ws, cbuffer->buffer);
offset += cbuffer->buffer->size;
}
/*immediates*/
tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
if (brw_miptree_layout(tex))
- tex->buffer = ws->buffer_create(ws, 64,
- PIPE_BUFFER_USAGE_PIXEL,
- tex->stride *
- tex->total_nblocksy);
+ tex->buffer = ws->_buffer_create(ws, 64,
+ PIPE_BUFFER_USAGE_PIXEL,
+ tex->stride *
+ tex->total_nblocksy);
if (!tex->buffer) {
FREE(tex);
__FUNCTION__, (void *) *pt, (*pt)->refcount - 1);
*/
if (--(*pt)->refcount <= 0) {
- struct pipe_winsys *ws = screen->winsys;
struct brw_texture *tex = (struct brw_texture *)*pt;
uint i;
DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
*/
- winsys_buffer_reference(ws, &tex->buffer, NULL);
+ pipe_buffer_reference(screen, &tex->buffer, NULL);
for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
if (tex->image_offset[i])
struct pipe_texture *pt,
unsigned face, unsigned level, unsigned zslice)
{
- struct pipe_winsys *ws = screen->winsys;
struct brw_texture *tex = (struct brw_texture *)pt;
struct pipe_surface *ps;
unsigned offset; /* in bytes */
if (ps) {
ps->refcount = 1;
pipe_texture_reference(&ps->texture, pt);
- winsys_buffer_reference(ws, &ps->buffer, tex->buffer);
+ pipe_buffer_reference(screen, &ps->buffer, tex->buffer);
ps->format = pt->format;
ps->width = pt->width[level];
ps->height = pt->height[level];
nv04_miptree_layout(mt);
- mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+ mt->buffer = ws->_buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
mt->total_size);
if (!mt->buffer) {
FREE(mt);
struct pipe_winsys *ws = screen->winsys;
void *map;
- map = ws->buffer_map(ws, surface->buffer, flags);
+ map = ws->_buffer_map(ws, surface->buffer, flags);
if (!map)
return NULL;
{
struct pipe_winsys *ws = screen->winsys;
- ws->buffer_unmap(ws, surface->buffer);
+ ws->_buffer_unmap(ws, surface->buffer);
}
static void
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (nv04->vertex_buffer[i].buffer) {
void *buf
- = pipe->winsys->buffer_map(pipe->winsys,
+ = pipe->winsys->_buffer_map(pipe->winsys,
nv04->vertex_buffer[i].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_vertex_buffer(draw, i, buf);
/* Map index buffer, if present */
if (indexBuffer) {
void *mapped_indexes
- = pipe->winsys->buffer_map(pipe->winsys, indexBuffer,
+ = pipe->winsys->_buffer_map(pipe->winsys, indexBuffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
}
*/
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (nv04->vertex_buffer[i].buffer) {
- pipe->winsys->buffer_unmap(pipe->winsys, nv04->vertex_buffer[i].buffer);
+ pipe->winsys->_buffer_unmap(pipe->winsys, nv04->vertex_buffer[i].buffer);
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
}
if (indexBuffer) {
- pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer);
+ pipe->winsys->_buffer_unmap(pipe->winsys, indexBuffer);
draw_set_mapped_element_buffer(draw, 0, NULL);
}
nv10_miptree_layout(mt);
- mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+ mt->buffer = ws->_buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
mt->total_size);
if (!mt->buffer) {
FREE(mt);
size_t size = (size_t)vertex_size * (size_t)nr_vertices;
assert(!nv10_render->buffer);
- nv10_render->buffer = winsys->buffer_create(winsys, 64, PIPE_BUFFER_USAGE_VERTEX, size);
+ nv10_render->buffer = winsys->_buffer_create(winsys, 64, PIPE_BUFFER_USAGE_VERTEX, size);
nv10->dirty |= NV10_NEW_VTXARRAYS;
- return winsys->buffer_map(winsys,
+ return winsys->_buffer_map(winsys,
nv10_render->buffer,
PIPE_BUFFER_USAGE_CPU_WRITE);
}
struct pipe_screen *pscreen = &nv10->screen->pipe;
assert(nv10_render->buffer);
- winsys->buffer_unmap(winsys, nv10_render->buffer);
+ winsys->_buffer_unmap(winsys, nv10_render->buffer);
pipe_buffer_reference(pscreen, &nv10_render->buffer, NULL);
}
struct pipe_winsys *ws = screen->winsys;
void *map;
- map = ws->buffer_map(ws, surface->buffer, flags);
+ map = ws->_buffer_map(ws, surface->buffer, flags);
if (!map)
return NULL;
{
struct pipe_winsys *ws = screen->winsys;
- ws->buffer_unmap(ws, surface->buffer);
+ ws->_buffer_unmap(ws, surface->buffer);
}
static void
if (buf) {
void *mapped;
if (buf->buffer && buf->buffer->size &&
- (mapped = ws->buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
+ (mapped = ws->_buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
{
memcpy(nv10->constbuf[shader], mapped, buf->buffer->size);
nv10->constbuf_nr[shader] =
buf->buffer->size / (4 * sizeof(float));
- ws->buffer_unmap(ws, buf->buffer);
+ ws->_buffer_unmap(ws, buf->buffer);
}
}
}
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (nv10->vtxbuf[i].buffer) {
void *buf
- = pipe->winsys->buffer_map(pipe->winsys,
+ = pipe->winsys->_buffer_map(pipe->winsys,
nv10->vtxbuf[i].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_vertex_buffer(draw, i, buf);
/* Map index buffer, if present */
if (indexBuffer) {
void *mapped_indexes
- = pipe->winsys->buffer_map(pipe->winsys, indexBuffer,
+ = pipe->winsys->_buffer_map(pipe->winsys, indexBuffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
}
*/
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (nv10->vtxbuf[i].buffer) {
- pipe->winsys->buffer_unmap(pipe->winsys, nv10->vtxbuf[i].buffer);
+ pipe->winsys->_buffer_unmap(pipe->winsys, nv10->vtxbuf[i].buffer);
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
}
if (indexBuffer) {
- pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer);
+ pipe->winsys->_buffer_unmap(pipe->winsys, indexBuffer);
draw_set_mapped_element_buffer(draw, 0, NULL);
}
nv20_miptree_layout(mt);
- mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+ mt->buffer = ws->_buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
mt->total_size);
if (!mt->buffer) {
FREE(mt);
nv20__allocate_pbuffer(struct nv20_vbuf_render *nv20_render, size_t size)
{
struct pipe_winsys *winsys = nv20_render->nv20->pipe.winsys;
- nv20_render->pbuffer = winsys->buffer_create(winsys, 64,
+ nv20_render->pbuffer = winsys->_buffer_create(winsys, 64,
PIPE_BUFFER_USAGE_VERTEX, size);
- return winsys->buffer_map(winsys,
+ return winsys->_buffer_map(winsys,
nv20_render->pbuffer,
PIPE_BUFFER_USAGE_CPU_WRITE);
}
struct pipe_screen *pscreen = &nv20->screen->pipe;
if (nv20_render->pbuffer) {
- winsys->buffer_unmap(winsys, nv20_render->pbuffer);
+ winsys->_buffer_unmap(winsys, nv20_render->pbuffer);
pipe_buffer_reference(pscreen, &nv20_render->pbuffer, NULL);
} else if (nv20_render->mbuffer) {
FREE(nv20_render->mbuffer);
struct pipe_winsys *ws = screen->winsys;
void *map;
- map = ws->buffer_map(ws, surface->buffer, flags);
+ map = ws->_buffer_map(ws, surface->buffer, flags);
if (!map)
return NULL;
{
struct pipe_winsys *ws = screen->winsys;
- ws->buffer_unmap(ws, surface->buffer);
+ ws->_buffer_unmap(ws, surface->buffer);
}
static void
if (buf) {
void *mapped;
if (buf->buffer && buf->buffer->size &&
- (mapped = ws->buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
+ (mapped = ws->_buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
{
memcpy(nv20->constbuf[shader], mapped, buf->buffer->size);
nv20->constbuf_nr[shader] =
buf->buffer->size / (4 * sizeof(float));
- ws->buffer_unmap(ws, buf->buffer);
+ ws->_buffer_unmap(ws, buf->buffer);
}
}
}
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (nv20->vtxbuf[i].buffer) {
void *buf
- = pipe->winsys->buffer_map(pipe->winsys,
+ = pipe->winsys->_buffer_map(pipe->winsys,
nv20->vtxbuf[i].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_vertex_buffer(draw, i, buf);
/* Map index buffer, if present */
if (indexBuffer) {
void *mapped_indexes
- = pipe->winsys->buffer_map(pipe->winsys, indexBuffer,
+ = pipe->winsys->_buffer_map(pipe->winsys, indexBuffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
}
*/
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (nv20->vtxbuf[i].buffer) {
- pipe->winsys->buffer_unmap(pipe->winsys, nv20->vtxbuf[i].buffer);
+ pipe->winsys->_buffer_unmap(pipe->winsys, nv20->vtxbuf[i].buffer);
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
}
if (indexBuffer) {
- pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer);
+ pipe->winsys->_buffer_unmap(pipe->winsys, indexBuffer);
draw_set_mapped_element_buffer(draw, 0, NULL);
}
float *map = NULL;
if (constbuf) {
- map = ws->buffer_map(ws, constbuf,
+ map = ws->_buffer_map(ws, constbuf,
PIPE_BUFFER_USAGE_CPU_READ);
}
}
if (constbuf) {
- ws->buffer_unmap(ws, constbuf);
+ ws->_buffer_unmap(ws, constbuf);
}
}
uint32_t *map;
int i;
- map = ws->buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+ map = ws->_buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
#if 0
for (i = 0; i < fp->insn_len; i++) {
}
}
- ws->buffer_unmap(ws, fp->buffer);
+ ws->_buffer_unmap(ws, fp->buffer);
}
static boolean
return FALSE;
}
- fp->buffer = ws->buffer_create(ws, 0x100, 0, fp->insn_len * 4);
+ fp->buffer = ws->_buffer_create(ws, 0x100, 0, fp->insn_len * 4);
nv30_fragprog_upload(nv30, fp);
so = so_new(8, 1);
if (fp->nr_consts) {
float *map;
- map = ws->buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
for (i = 0; i < fp->nr_consts; i++) {
struct nv30_fragment_program_data *fpd = &fp->consts[i];
uint32_t *p = &fp->insn[fpd->offset];
memcpy(p, cb, 4 * sizeof(float));
new_consts = TRUE;
}
- ws->buffer_unmap(ws, constbuf);
+ ws->_buffer_unmap(ws, constbuf);
if (new_consts)
nv30_fragprog_upload(nv30, fp);
nv30_miptree_layout(mt);
- mt->buffer = ws->buffer_create(ws, 256,
+ mt->buffer = ws->_buffer_create(ws, 256,
PIPE_BUFFER_USAGE_PIXEL |
NOUVEAU_BUFFER_USAGE_TEXTURE,
mt->total_size);
return;
pipe_texture_reference(&ps->texture, NULL);
- pipe_buffer_reference(pscreen->winsys, &ps->buffer, NULL);
+ pipe_buffer_reference(pscreen, &ps->buffer, NULL);
FREE(ps);
}
assert(surface_to_map);
- map = ws->buffer_map(ws, surface_to_map->buffer, flags);
+ map = ws->_buffer_map(ws, surface_to_map->buffer, flags);
if (!map)
return NULL;
assert(surface_to_unmap);
- ws->buffer_unmap(ws, surface_to_unmap->buffer);
+ ws->_buffer_unmap(ws, surface_to_unmap->buffer);
if (surface_to_unmap != surface) {
struct nv30_screen *nvscreen = nv30_screen(screen);
if (nv30_vbo_format_to_hw(ve->src_format, &type, &ncomp))
return FALSE;
- map = ws->buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
map += vb->buffer_offset + ve->src_offset;
switch (type) {
so_data (so, fui(v[0]));
break;
default:
- ws->buffer_unmap(ws, vb->buffer);
+ ws->_buffer_unmap(ws, vb->buffer);
return FALSE;
}
}
break;
default:
- ws->buffer_unmap(ws, vb->buffer);
+ ws->_buffer_unmap(ws, vb->buffer);
return FALSE;
}
- ws->buffer_unmap(ws, vb->buffer);
+ ws->_buffer_unmap(ws, vb->buffer);
return TRUE;
}
struct pipe_winsys *ws = pipe->winsys;
void *map;
- map = ws->buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
if (!ib) {
NOUVEAU_ERR("failed mapping ib\n");
return FALSE;
break;
}
- ws->buffer_unmap(ws, ib);
+ ws->_buffer_unmap(ws, ib);
return TRUE;
}
float *map = NULL;
if (constbuf) {
- map = ws->buffer_map(ws, constbuf,
+ map = ws->_buffer_map(ws, constbuf,
PIPE_BUFFER_USAGE_CPU_READ);
}
}
if (constbuf) {
- ws->buffer_unmap(ws, constbuf);
+ ws->_buffer_unmap(ws, constbuf);
}
}
nv40_state_emit(nv40);
for (i = 0; i < nv40->vtxbuf_nr; i++) {
- map = ws->buffer_map(ws, nv40->vtxbuf[i].buffer,
- PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, nv40->vtxbuf[i].buffer,
+ PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_vertex_buffer(nv40->draw, i, map);
}
if (idxbuf) {
- map = ws->buffer_map(ws, idxbuf, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, idxbuf, PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_element_buffer(nv40->draw, idxbuf_size, map);
} else {
draw_set_mapped_element_buffer(nv40->draw, 0, NULL);
if (nv40->constbuf[PIPE_SHADER_VERTEX]) {
const unsigned nr = nv40->constbuf_nr[PIPE_SHADER_VERTEX];
- map = ws->buffer_map(ws, nv40->constbuf[PIPE_SHADER_VERTEX],
+ map = ws->_buffer_map(ws, nv40->constbuf[PIPE_SHADER_VERTEX],
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_constant_buffer(nv40->draw, map, nr);
}
draw_arrays(nv40->draw, mode, start, count);
for (i = 0; i < nv40->vtxbuf_nr; i++)
- ws->buffer_unmap(ws, nv40->vtxbuf[i].buffer);
+ ws->_buffer_unmap(ws, nv40->vtxbuf[i].buffer);
if (idxbuf)
- ws->buffer_unmap(ws, idxbuf);
+ ws->_buffer_unmap(ws, idxbuf);
if (nv40->constbuf[PIPE_SHADER_VERTEX])
- ws->buffer_unmap(ws, nv40->constbuf[PIPE_SHADER_VERTEX]);
+ ws->_buffer_unmap(ws, nv40->constbuf[PIPE_SHADER_VERTEX]);
draw_flush(nv40->draw);
pipe->flush(pipe, 0, NULL);
uint32_t *map;
int i;
- map = ws->buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+ map = ws->_buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
#if 0
for (i = 0; i < fp->insn_len; i++) {
}
}
- ws->buffer_unmap(ws, fp->buffer);
+ ws->_buffer_unmap(ws, fp->buffer);
}
static boolean
return FALSE;
}
- fp->buffer = ws->buffer_create(ws, 0x100, 0, fp->insn_len * 4);
+ fp->buffer = ws->_buffer_create(ws, 0x100, 0, fp->insn_len * 4);
nv40_fragprog_upload(nv40, fp);
so = so_new(4, 1);
if (fp->nr_consts) {
float *map;
- map = ws->buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
for (i = 0; i < fp->nr_consts; i++) {
struct nv40_fragment_program_data *fpd = &fp->consts[i];
uint32_t *p = &fp->insn[fpd->offset];
memcpy(p, cb, 4 * sizeof(float));
new_consts = TRUE;
}
- ws->buffer_unmap(ws, constbuf);
+ ws->_buffer_unmap(ws, constbuf);
if (new_consts)
nv40_fragprog_upload(nv40, fp);
nv40_miptree_layout(mt);
- mt->buffer = ws->buffer_create(ws, 256, buf_usage, mt->total_size);
+ mt->buffer = ws->_buffer_create(ws, 256, buf_usage, mt->total_size);
if (!mt->buffer) {
FREE(mt);
return NULL;
assert(surface_to_map);
- map = ws->buffer_map(ws, surface_to_map->buffer, flags);
+ map = ws->_buffer_map(ws, surface_to_map->buffer, flags);
if (!map)
return NULL;
assert(surface_to_unmap);
- ws->buffer_unmap(ws, surface_to_unmap->buffer);
+ ws->_buffer_unmap(ws, surface_to_unmap->buffer);
if (surface_to_unmap != surface) {
struct nv40_screen *nvscreen = nv40_screen(screen);
if (nv40_vbo_format_to_hw(ve->src_format, &type, &ncomp))
return FALSE;
- map = ws->buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
map += vb->buffer_offset + ve->src_offset;
switch (type) {
so_data (so, fui(v[0]));
break;
default:
- ws->buffer_unmap(ws, vb->buffer);
+ ws->_buffer_unmap(ws, vb->buffer);
return FALSE;
}
}
break;
default:
- ws->buffer_unmap(ws, vb->buffer);
+ ws->_buffer_unmap(ws, vb->buffer);
return FALSE;
}
- ws->buffer_unmap(ws, vb->buffer);
+ ws->_buffer_unmap(ws, vb->buffer);
return TRUE;
}
struct pipe_winsys *ws = pipe->winsys;
void *map;
- map = ws->buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
+ map = ws->_buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
if (!ib) {
NOUVEAU_ERR("failed mapping ib\n");
return FALSE;
break;
}
- ws->buffer_unmap(ws, ib);
+ ws->_buffer_unmap(ws, ib);
return TRUE;
}
float *map = NULL;
if (constbuf) {
- map = ws->buffer_map(ws, constbuf,
+ map = ws->_buffer_map(ws, constbuf,
PIPE_BUFFER_USAGE_CPU_READ);
}
}
if (constbuf)
- ws->buffer_unmap(ws, constbuf);
+ ws->_buffer_unmap(ws, constbuf);
}
/* Upload vtxprog */
size = align(size, 64);
size *= align(pt->height[l], 8) * pt->block.size;
- lvl->image[i] = ws->buffer_create(ws, 256, 0, size);
+ lvl->image[i] = ws->_buffer_create(ws, 256, 0, size);
lvl->image_offset[i] = mt->total_size;
mt->total_size += size;
}
}
- mt->buffer = ws->buffer_create(ws, 256, usage, mt->total_size);
+ mt->buffer = ws->_buffer_create(ws, 256, usage, mt->total_size);
if (!mt->buffer) {
FREE(mt);
return NULL;
}
if (p->param_nr) {
- float *map = ws->buffer_map(ws, nv50->constbuf[p->type],
+ float *map = ws->_buffer_map(ws, nv50->constbuf[p->type],
PIPE_BUFFER_USAGE_CPU_READ);
nv50_program_upload_data(nv50, map, p->data->start,
p->param_nr);
- ws->buffer_unmap(ws, nv50->constbuf[p->type]);
+ ws->_buffer_unmap(ws, nv50->constbuf[p->type]);
}
if (p->immd_nr) {
boolean upload = FALSE;
if (!p->buffer) {
- p->buffer = ws->buffer_create(ws, 0x100, 0, p->exec_size * 4);
+ p->buffer = ws->_buffer_create(ws, 0x100, 0, p->exec_size * 4);
upload = TRUE;
}
assert (q->type == PIPE_QUERY_OCCLUSION_COUNTER);
q->type = type;
- q->buffer = ws->buffer_create(ws, 256, 0, 16);
+ q->buffer = ws->_buffer_create(ws, 256, 0, 16);
if (!q->buffer) {
FREE(q);
return NULL;
struct nv50_query *q = nv50_query(pq);
if (q) {
- pipe_buffer_reference(pipe, &q->buffer, NULL);
+ pipe_buffer_reference(pipe->screen, &q->buffer, NULL);
FREE(q);
}
}
*/
if (!q->ready) {
- uint32_t *map = ws->buffer_map(ws, q->buffer,
+ uint32_t *map = ws->_buffer_map(ws, q->buffer,
PIPE_BUFFER_USAGE_CPU_READ);
q->result = map[1];
q->ready = TRUE;
- ws->buffer_unmap(ws, q->buffer);
+ ws->_buffer_unmap(ws, q->buffer);
}
*result = q->result;
so_data (so, 8);
/* Shared constant buffer */
- screen->constbuf = ws->buffer_create(ws, 0, 0, 128 * 4 * 4);
+ screen->constbuf = ws->_buffer_create(ws, 0, 0, 128 * 4 * 4);
if (nvws->res_init(&screen->vp_data_heap, 0, 128)) {
NOUVEAU_ERR("Error initialising constant buffer\n");
nv50_screen_destroy(&screen->pipe);
* blocks. At some point we *may* want to go the NVIDIA way of doing
* things?
*/
- screen->tic = ws->buffer_create(ws, 0, 0, 32 * 8 * 4);
+ screen->tic = ws->_buffer_create(ws, 0, 0, 32 * 8 * 4);
so_method(so, screen->tesla, 0x1280, 3);
so_reloc (so, screen->tic, 0, NOUVEAU_BO_VRAM |
NOUVEAU_BO_RD | NOUVEAU_BO_HIGH, 0, 0);
NOUVEAU_BO_RD | NOUVEAU_BO_LOW, 0, 0);
so_data (so, 0x00000800);
- screen->tsc = ws->buffer_create(ws, 0, 0, 32 * 8 * 4);
+ screen->tsc = ws->_buffer_create(ws, 0, 0, 32 * 8 * 4);
so_method(so, screen->tesla, 0x1280, 3);
so_reloc (so, screen->tsc, 0, NOUVEAU_BO_VRAM |
NOUVEAU_BO_RD | NOUVEAU_BO_HIGH, 0, 0);
{
struct pipe_winsys *ws = screen->winsys;
- return ws->buffer_map(ws, ps->buffer, flags);
+ return ws->_buffer_map(ws, ps->buffer, flags);
}
static void
{
struct pipe_winsys *ws = pscreen->winsys;
- ws->buffer_unmap(ws, ps->buffer);
+ ws->_buffer_unmap(ws, ps->buffer);
}
void
{
struct nv50_context *nv50 = nv50_context(pipe);
struct pipe_winsys *ws = pipe->winsys;
- void *map = ws->buffer_map(ws, indexBuffer, PIPE_BUFFER_USAGE_CPU_READ);
+ void *map = ws->_buffer_map(ws, indexBuffer, PIPE_BUFFER_USAGE_CPU_READ);
nv50_state_validate(nv50);
static void softpipe_destroy( struct pipe_context *pipe )
{
struct softpipe_context *softpipe = softpipe_context( pipe );
- struct pipe_winsys *ws = pipe->winsys;
+ struct pipe_screen *screen = pipe->screen;
uint i;
if (softpipe->draw)
for (i = 0; i < Elements(softpipe->constants); i++) {
if (softpipe->constants[i].buffer) {
- winsys_buffer_reference(ws, &softpipe->constants[i].buffer, NULL);
+ pipe_buffer_reference(screen, &softpipe->constants[i].buffer, NULL);
}
}
uint i;
for (i = 0; i < PIPE_SHADER_TYPES; i++) {
if (sp->constants[i].buffer && sp->constants[i].buffer->size)
- sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer,
+ sp->mapped_constants[i] = ws->_buffer_map(ws, sp->constants[i].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
}
for (i = 0; i < 2; i++) {
if (sp->constants[i].buffer && sp->constants[i].buffer->size)
- ws->buffer_unmap(ws, sp->constants[i].buffer);
+ ws->_buffer_unmap(ws, sp->constants[i].buffer);
sp->mapped_constants[i] = NULL;
}
}
const struct pipe_constant_buffer *buf)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
- struct pipe_winsys *ws = pipe->winsys;
+ struct pipe_screen *screen = pipe->screen;
assert(shader < PIPE_SHADER_TYPES);
assert(index == 0);
/* note: reference counting */
- winsys_buffer_reference(ws,
+ pipe_buffer_reference(screen,
&softpipe->constants[shader].buffer,
buf ? buf->buffer : NULL);
depth = minify(depth);
}
- spt->buffer = ws->buffer_create(ws, 32,
- PIPE_BUFFER_USAGE_PIXEL,
- buffer_size);
+ spt->buffer = ws->_buffer_create(ws, 32,
+ PIPE_BUFFER_USAGE_PIXEL,
+ buffer_size);
return spt->buffer != NULL;
}
spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width[0]);
spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height[0]);
- spt->buffer = ws->surface_buffer_create( ws,
- spt->base.width[0],
- spt->base.height[0],
- spt->base.format,
- usage,
- &spt->stride[0]);
+ spt->buffer = ws->_surface_buffer_create( ws,
+ spt->base.width[0],
+ spt->base.height[0],
+ spt->base.format,
+ usage,
+ &spt->stride[0]);
return spt->buffer != NULL;
}
trace_dump_arg(format, format);
trace_dump_arg(uint, usage);
- result = winsys->surface_buffer_create(winsys,
+ result = winsys->_surface_buffer_create(winsys,
width, height,
format,
usage,
trace_dump_arg(uint, usage);
trace_dump_arg(uint, size);
- buffer = winsys->buffer_create(winsys, alignment, usage, size);
+ buffer = winsys->_buffer_create(winsys, alignment, usage, size);
trace_dump_ret(ptr, buffer);
/* Zero the buffer to avoid dumping uninitialized memory */
if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
void *map;
- map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+ map = winsys->_buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
if(map) {
memset(map, 0, buffer->size);
- winsys->buffer_unmap(winsys, buffer);
+ winsys->_buffer_unmap(winsys, buffer);
}
}
trace_dump_arg_end();
trace_dump_arg(uint, size);
- result = winsys->user_buffer_create(winsys, data, size);
+ result = winsys->_user_buffer_create(winsys, data, size);
trace_dump_ret(ptr, result);
const void *map;
if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
- map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_READ);
+ map = winsys->_buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_READ);
if(map) {
trace_dump_call_begin("pipe_winsys", "buffer_write");
trace_dump_call_end();
- winsys->buffer_unmap(winsys, buffer);
+ winsys->_buffer_unmap(winsys, buffer);
}
}
}
struct pipe_winsys *winsys = tr_ws->winsys;
void *map;
- map = winsys->buffer_map(winsys, buffer, usage);
+ map = winsys->_buffer_map(winsys, buffer, usage);
if(map) {
if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
assert(!hash_table_get(tr_ws->buffer_maps, buffer));
hash_table_remove(tr_ws->buffer_maps, buffer);
}
- winsys->buffer_unmap(winsys, buffer);
+ winsys->_buffer_unmap(winsys, buffer);
}
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, buffer);
- winsys->buffer_destroy(winsys, buffer);
+ winsys->_buffer_destroy(winsys, buffer);
trace_dump_call_end();
}
tr_ws->base.destroy = trace_winsys_destroy;
tr_ws->base.get_name = trace_winsys_get_name;
tr_ws->base.flush_frontbuffer = trace_winsys_flush_frontbuffer;
- tr_ws->base.surface_buffer_create = trace_winsys_surface_buffer_create;
- tr_ws->base.buffer_create = trace_winsys_buffer_create;
- tr_ws->base.user_buffer_create = trace_winsys_user_buffer_create;
- tr_ws->base.buffer_map = trace_winsys_buffer_map;
- tr_ws->base.buffer_unmap = trace_winsys_buffer_unmap;
- tr_ws->base.buffer_destroy = trace_winsys_buffer_destroy;
+ tr_ws->base._surface_buffer_create = trace_winsys_surface_buffer_create;
+ tr_ws->base._buffer_create = trace_winsys_buffer_create;
+ tr_ws->base._user_buffer_create = trace_winsys_user_buffer_create;
+ tr_ws->base._buffer_map = trace_winsys_buffer_map;
+ tr_ws->base._buffer_unmap = trace_winsys_buffer_unmap;
+ tr_ws->base._buffer_destroy = trace_winsys_buffer_destroy;
tr_ws->base.fence_reference = trace_winsys_fence_reference;
tr_ws->base.fence_signalled = trace_winsys_fence_signalled;
tr_ws->base.fence_finish = trace_winsys_fence_finish;
}
-/* XXX: thread safety issues!
- */
-static INLINE void
-winsys_buffer_reference(struct pipe_winsys *winsys,
- struct pipe_buffer **ptr,
- struct pipe_buffer *buf)
-{
- if (buf) {
- assert(buf->refcount);
- buf->refcount++;
- }
-
- if (*ptr) {
- assert((*ptr)->refcount);
- if(--(*ptr)->refcount == 0)
- winsys->buffer_destroy( winsys, *ptr );
- }
-
- *ptr = buf;
-}
-
-
-
/**
* \sa pipe_surface_reference
*/
pipe_buffer_create( struct pipe_screen *screen,
unsigned alignment, unsigned usage, unsigned size )
{
- return screen->winsys->buffer_create(screen->winsys, alignment, usage, size);
+ if (screen->buffer_create)
+ return screen->buffer_create(screen, alignment, usage, size);
+ else
+ return screen->winsys->_buffer_create(screen->winsys, alignment, usage, size);
}
static INLINE struct pipe_buffer *
pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size )
{
- return screen->winsys->user_buffer_create(screen->winsys, ptr, size);
+ if (screen->user_buffer_create)
+ return screen->user_buffer_create(screen, ptr, size);
+ else
+ return screen->winsys->_user_buffer_create(screen->winsys, ptr, size);
}
static INLINE void *
struct pipe_buffer *buf,
unsigned usage)
{
- return screen->winsys->buffer_map(screen->winsys, buf, usage);
+ if (screen->buffer_map)
+ return screen->buffer_map(screen, buf, usage);
+ else
+ return screen->winsys->_buffer_map(screen->winsys, buf, usage);
}
static INLINE void
pipe_buffer_unmap(struct pipe_screen *screen,
struct pipe_buffer *buf)
{
- screen->winsys->buffer_unmap(screen->winsys, buf);
+ if (screen->buffer_unmap)
+ screen->buffer_unmap(screen, buf);
+ else
+ screen->winsys->_buffer_unmap(screen->winsys, buf);
}
-/* XXX when we're using this everywhere, get rid of
- * winsys_buffer_reference() above.
+/* XXX: thread safety issues!
*/
static INLINE void
pipe_buffer_reference(struct pipe_screen *screen,
struct pipe_buffer **ptr,
struct pipe_buffer *buf)
{
- winsys_buffer_reference(screen->winsys, ptr, buf);
+ if (buf) {
+ assert(buf->refcount);
+ buf->refcount++;
+ }
+
+ if (*ptr) {
+ assert((*ptr)->refcount);
+ if(--(*ptr)->refcount == 0) {
+ if (screen->buffer_destroy)
+ screen->buffer_destroy( screen, *ptr );
+ else
+ screen->winsys->_buffer_destroy( screen->winsys, *ptr );
+ }
+ }
+
+ *ptr = buf;
}
void (*surface_unmap)( struct pipe_screen *,
struct pipe_surface *surface );
-
+
+
+ /**
+ * Buffer management. Buffer attributes are mostly fixed over its lifetime.
+ *
+ *
+ */
+ struct pipe_buffer *(*buffer_create)( struct pipe_screen *screen,
+ unsigned alignment,
+ unsigned usage,
+ unsigned size );
+
+ /**
+ * Create a buffer that wraps user-space data.
+ *
+ * Effectively this schedules a delayed call to buffer_create
+ * followed by an upload of the data at *some point in the future*,
+ * or perhaps never. Basically the allocate/upload is delayed
+ * until the buffer is actually passed to hardware.
+ *
+ * The intention is to provide a quick way to turn regular data
+ * into a buffer, and secondly to avoid a copy operation if that
+ * data subsequently turns out to be only accessed by the CPU.
+ *
+ * Common example is OpenGL vertex buffers that are subsequently
+ * processed either by software TNL in the driver or by passing to
+ * hardware.
+ *
+ * XXX: What happens if the delayed call to buffer_create() fails?
+ *
+ * Note that ptr may be accessed at any time upto the time when the
+ * buffer is destroyed, so the data must not be freed before then.
+ */
+ struct pipe_buffer *(*user_buffer_create)(struct pipe_screen *screen,
+ void *ptr,
+ unsigned bytes);
+
+ /**
+ * Allocate storage for a display target surface.
+ *
+ * Often surfaces which are meant to be blitted to the front screen (i.e.,
+ * display targets) must be allocated with special characteristics, memory
+ * pools, or obtained directly from the windowing system.
+ *
+ * This callback is invoked by the pipe_screenwhen creating a texture marked
+ * with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET flag to get the underlying
+ * buffer storage.
+ */
+ struct pipe_buffer *(*surface_buffer_create)(struct pipe_screen *screen,
+ unsigned width, unsigned height,
+ enum pipe_format format,
+ unsigned usage,
+ unsigned *stride);
+
+
+ /**
+ * Map the entire data store of a buffer object into the client's address.
+ * flags is bitmask of PIPE_BUFFER_USAGE_CPU_READ/WRITE flags.
+ */
+ void *(*buffer_map)( struct pipe_screen *screen,
+ struct pipe_buffer *buf,
+ unsigned usage );
+
+ void (*buffer_unmap)( struct pipe_screen *screen,
+ struct pipe_buffer *buf );
+
+ void (*buffer_destroy)( struct pipe_screen *screen,
+ struct pipe_buffer *buf );
};
* alignment indicates the client's alignment requirements, eg for
* SSE instructions.
*/
- struct pipe_buffer *(*buffer_create)( struct pipe_winsys *ws,
+ struct pipe_buffer *(*_buffer_create)( struct pipe_winsys *ws,
unsigned alignment,
unsigned usage,
unsigned size );
* Note that ptr may be accessed at any time upto the time when the
* buffer is destroyed, so the data must not be freed before then.
*/
- struct pipe_buffer *(*user_buffer_create)(struct pipe_winsys *ws,
+ struct pipe_buffer *(*_user_buffer_create)(struct pipe_winsys *ws,
void *ptr,
unsigned bytes);
* with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET flag to get the underlying
* buffer storage.
*/
- struct pipe_buffer *(*surface_buffer_create)(struct pipe_winsys *ws,
+ struct pipe_buffer *(*_surface_buffer_create)(struct pipe_winsys *ws,
unsigned width, unsigned height,
enum pipe_format format,
unsigned usage,
* Map the entire data store of a buffer object into the client's address.
* flags is bitmask of PIPE_BUFFER_USAGE_CPU_READ/WRITE flags.
*/
- void *(*buffer_map)( struct pipe_winsys *ws,
+ void *(*_buffer_map)( struct pipe_winsys *ws,
struct pipe_buffer *buf,
unsigned usage );
- void (*buffer_unmap)( struct pipe_winsys *ws,
+ void (*_buffer_unmap)( struct pipe_winsys *ws,
struct pipe_buffer *buf );
- void (*buffer_destroy)( struct pipe_winsys *ws,
+ void (*_buffer_destroy)( struct pipe_winsys *ws,
struct pipe_buffer *buf );
projects / mesa.git / commitdiff