#ifndef INTEL_WINSYS_H
#define INTEL_WINSYS_H
+#include "pipe/p_state.h"
+
struct intel_context;
struct pipe_context;
struct pipe_winsys;
-struct pipe_buffer_handle;
+struct pipe_buffer;
struct _DriBufferObject;
struct pipe_winsys *
struct pipe_winsys *winsys );
+struct intel_buffer {
+ struct pipe_buffer base;
+ struct _DriBufferObject *driBO;
+};
-/* Turn the pipe opaque buffer pointer into a dri_bufmgr opaque
- * buffer pointer...
- */
-static INLINE struct _DriBufferObject *
-dri_bo( struct pipe_buffer_handle *bo )
+static INLINE struct intel_buffer *
+intel_buffer( struct pipe_buffer *buf )
{
- return (struct _DriBufferObject *)bo;
+ return (struct intel_buffer *)buf;
}
-static INLINE struct pipe_buffer_handle *
-pipe_bo( struct _DriBufferObject *bo )
+static INLINE struct _DriBufferObject *
+dri_bo( struct pipe_buffer *buf )
{
- return (struct pipe_buffer_handle *)bo;
+ return intel_buffer(buf)->driBO;
}
}
static void intel_i915_batch_reloc( struct i915_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned access_flags,
unsigned delta )
{
#include "pipe/p_defines.h"
#include "pipe/p_state.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
/* Most callbacks map direcly onto dri_bufmgr operations:
*/
static void *intel_buffer_map(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned flags )
{
unsigned drm_flags = 0;
}
static void intel_buffer_unmap(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *buf)
+ struct pipe_buffer *buf)
{
driBOUnmap( dri_bo(buf) );
}
static void
-intel_buffer_reference(struct pipe_winsys *winsys,
- struct pipe_buffer_handle **ptr,
- struct pipe_buffer_handle *buf)
+intel_buffer_destroy(struct pipe_winsys *winsys,
+ struct pipe_buffer *buf)
{
- if (*ptr) {
- driBOUnReference( dri_bo(*ptr) );
- *ptr = NULL;
- }
-
- if (buf) {
- driBOReference( dri_bo(buf) );
- *ptr = buf;
- }
+ driBOUnReference( dri_bo(buf) );
}
* for all buffers.
* Grabs the hardware lock!
*/
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
intel_buffer_create(struct pipe_winsys *winsys,
unsigned alignment,
unsigned usage,
unsigned size )
{
- struct _DriBufferObject *buffer;
+ struct intel_buffer *buffer = CALLOC_STRUCT( intel_buffer );
struct intel_pipe_winsys *iws = intel_pipe_winsys(winsys);
unsigned flags = 0;
+ buffer->base.refcount = 1;
+ buffer->base.alignment = alignment;
+ buffer->base.usage = usage;
+ buffer->base.size = size;
+
if (usage & (PIPE_BUFFER_USAGE_VERTEX /*| IWS_BUFFER_USAGE_LOCAL*/)) {
flags |= DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED;
} else {
#endif
driGenBuffers( iws->regionPool,
- "pipe buffer", 1, &buffer, alignment, flags, 0 );
- driBOData( buffer, size, NULL, 0 );
- return pipe_bo(buffer);
+ "pipe buffer", 1, &buffer->driBO, alignment, flags, 0 );
+
+ driBOData( buffer->driBO, size, NULL, 0 );
+
+ return &buffer->base;
}
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
intel_user_buffer_create(struct pipe_winsys *winsys, void *ptr, unsigned bytes)
{
- struct _DriBufferObject *buffer;
+ struct intel_buffer *buffer = CALLOC_STRUCT( intel_buffer );
struct intel_pipe_winsys *iws = intel_pipe_winsys(winsys);
+
driGenUserBuffer( iws->regionPool,
- "pipe user buffer", &buffer, ptr, bytes);
- return pipe_bo(buffer);
+ "pipe user buffer", &buffer->driBO, ptr, bytes);
+
+ return &buffer->base;
}
return -1;
if(ret) {
- winsys->buffer_reference(winsys, &surf->buffer, NULL);
+ pipe_buffer_reference(winsys, &surf->buffer, NULL);
return ret;
}
surf->refcount--;
if (surf->refcount == 0) {
if (surf->buffer)
- winsys->buffer_reference(winsys, &surf->buffer, NULL);
+ pipe_buffer_reference(winsys, &surf->buffer, NULL);
free(surf);
}
*s = NULL;
iws->winsys.user_buffer_create = intel_user_buffer_create;
iws->winsys.buffer_map = intel_buffer_map;
iws->winsys.buffer_unmap = intel_buffer_unmap;
- iws->winsys.buffer_reference = intel_buffer_reference;
+ iws->winsys.buffer_destroy = intel_buffer_destroy;
iws->winsys.flush_frontbuffer = intel_flush_frontbuffer;
iws->winsys.printf = intel_printf;
iws->winsys.get_name = intel_get_name;
* buffer pointer...
*/
static inline struct xm_buffer *
-xm_bo( struct pipe_buffer_handle *bo )
+xm_bo( struct pipe_buffer *bo )
{
return (struct xm_buffer *) bo;
}
-static inline struct pipe_buffer_handle *
+static inline struct pipe_buffer *
pipe_bo( struct xm_buffer *bo )
{
- return (struct pipe_buffer_handle *) bo;
+ return (struct pipe_buffer *) bo;
}
/* Turn a softpipe winsys into an xm/softpipe winsys:
/* Most callbacks map direcly onto dri_bufmgr operations:
*/
static void *
-xm_buffer_map(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
+xm_buffer_map(struct pipe_winsys *pws, struct pipe_buffer *buf,
unsigned flags)
{
struct xm_buffer *xm_buf = xm_bo(buf);
}
static void
-xm_buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer_handle *buf)
+xm_buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer *buf)
{
struct xm_buffer *xm_buf = xm_bo(buf);
xm_buf->mapped = NULL;
static void
xm_buffer_reference(struct pipe_winsys *pws,
- struct pipe_buffer_handle **ptr,
- struct pipe_buffer_handle *buf)
+ struct pipe_buffer **ptr,
+ struct pipe_buffer *buf)
{
if (*ptr) {
struct xm_buffer *oldBuf = xm_bo(*ptr);
}
static void
-xm_buffer_data(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
+xm_buffer_data(struct pipe_winsys *pws, struct pipe_buffer *buf,
unsigned size, const void *data, unsigned usage)
{
struct xm_buffer *xm_buf = xm_bo(buf);
}
static void
-xm_buffer_subdata(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
+xm_buffer_subdata(struct pipe_winsys *pws, struct pipe_buffer *buf,
unsigned long offset, unsigned long size, const void *data)
{
struct xm_buffer *xm_buf = xm_bo(buf);
}
static void
-xm_buffer_get_subdata(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
+xm_buffer_get_subdata(struct pipe_winsys *pws, struct pipe_buffer *buf,
unsigned long offset, unsigned long size, void *data)
{
const struct xm_buffer *xm_buf = xm_bo(buf);
}
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
xm_buffer_create(struct pipe_winsys *pws,
unsigned alignment,
unsigned flags,
/**
* Create buffer which wraps user-space data.
*/
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
xm_user_buffer_create(struct pipe_winsys *pws, void *ptr, unsigned bytes)
{
struct xm_buffer *buffer = CALLOC_STRUCT(xm_buffer);
*/
boolean
cell_draw_elements(struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned mode, unsigned start, unsigned count)
{
unsigned start, unsigned count);
boolean cell_draw_elements(struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned mode, unsigned start, unsigned count);
/* The data is held here:
*/
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
unsigned long buffer_size;
};
static boolean failover_draw_elements( struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned prim, unsigned start, unsigned count)
{
i915_fill_blit(struct i915_context *i915,
unsigned cpp,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
short x, short y,
short w, short h,
i915_copy_blit( struct i915_context *i915,
unsigned cpp,
short src_pitch,
- struct pipe_buffer_handle *src_buffer,
+ struct pipe_buffer *src_buffer,
unsigned src_offset,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
short src_x, short src_y,
short dst_x, short dst_y,
extern void i915_copy_blit(struct i915_context *i915,
unsigned cpp,
short src_pitch,
- struct pipe_buffer_handle *src_buffer,
+ struct pipe_buffer *src_buffer,
unsigned src_offset,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
short srcx, short srcy,
short dstx, short dsty,
extern void i915_fill_blit(struct i915_context *i915,
unsigned cpp,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
short x, short y,
short w, short h, unsigned color);
static boolean
i915_draw_elements( struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned prim, unsigned start, unsigned count)
{
/* The data is held here:
*/
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
};
struct i915_context
unsigned *batch_start;
/** Vertex buffer */
- struct pipe_buffer_handle *vbo;
+ struct pipe_buffer *vbo;
struct i915_state current;
unsigned hardware_dirty;
#include "pipe/draw/draw_vbuf.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#include "i915_context.h"
assert(i915->vbo);
winsys->buffer_unmap(winsys, i915->vbo);
- winsys->buffer_reference(winsys, &i915->vbo, NULL);
+ pipe_buffer_reference(winsys, &i915->vbo, NULL);
}
OUT_BATCH(enabled);
for (unit = 0; unit < I915_TEX_UNITS; unit++) {
if (enabled & (1 << unit)) {
- struct pipe_buffer_handle *buf =
+ struct pipe_buffer *buf =
i915->texture[unit]->buffer;
uint offset = 0;
assert(buf);
if (ps) {
assert(ps->refcount);
assert(ps->winsys);
- pipe->winsys->buffer_reference(pipe->winsys, &ps->buffer, tex->buffer);
+ pipe_buffer_reference(pipe->winsys, &ps->buffer, tex->buffer);
ps->format = pt->format;
ps->cpp = pt->cpp;
ps->width = pt->width[level];
DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
*/
- pipe->winsys->buffer_reference(pipe->winsys, &tex->buffer, NULL);
+ pipe_buffer_reference(pipe->winsys, &tex->buffer, NULL);
for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
if (tex->image_offset[i])
* etc.
*/
-struct pipe_buffer_handle;
+struct pipe_buffer;
struct pipe_winsys;
* I915_BUFFER_ACCESS_READ macros.
*/
void (*batch_reloc)( struct i915_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned access_flags,
unsigned delta );
void brw_fill_blit(struct brw_context *brw,
unsigned cpp,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
boolean dst_tiled,
short x, short y,
void brw_copy_blit(struct brw_context *brw,
unsigned cpp,
short src_pitch,
- struct pipe_buffer_handle *src_buffer,
+ struct pipe_buffer *src_buffer,
unsigned src_offset,
boolean src_tiled,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
boolean dst_tiled,
short src_x, short src_y,
#include "pipe/p_compiler.h"
-struct pipe_buffer_handle;
+struct pipe_buffer;
struct brw_context;
void brw_fill_blit(struct brw_context *intel,
unsigned cpp,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
boolean dst_tiled,
short x, short y,
void brw_copy_blit(struct brw_context *intel,
unsigned cpp,
short src_pitch,
- struct pipe_buffer_handle *src_buffer,
+ struct pipe_buffer *src_buffer,
unsigned src_offset,
boolean src_tiled,
short dst_pitch,
- struct pipe_buffer_handle *dst_buffer,
+ struct pipe_buffer *dst_buffer,
unsigned dst_offset,
boolean dst_tiled,
short src_x, short src_y,
/* The data is held here:
*/
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
};
/* Data about a particular attempt to compile a program. Note that
struct brw_cache;
struct brw_mem_pool {
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
unsigned size;
unsigned offset; /* offset of first free byte */
unsigned nr_surfaces;
unsigned max_threads;
- struct pipe_buffer_handle *scratch_buffer;
+ struct pipe_buffer *scratch_buffer;
unsigned scratch_buffer_size;
unsigned sampler_count;
* fallback conditions.
*/
static boolean brw_try_draw_elements( struct pipe_context *pipe,
- struct pipe_buffer_handle *index_buffer,
+ struct pipe_buffer *index_buffer,
unsigned index_size,
unsigned mode,
unsigned start,
static boolean brw_draw_elements( struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned mode,
unsigned start,
unsigned max_index );
boolean brw_upload_indices(struct brw_context *brw,
- const struct pipe_buffer_handle *index_buffer,
+ const struct pipe_buffer *index_buffer,
int ib_size, int start, int count);
boolean brw_upload_vertex_buffers( struct brw_context *brw );
unsigned dword;
} vb0;
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
unsigned offset;
unsigned max_index;
}
boolean brw_upload_indices( struct brw_context *brw,
- const struct pipe_buffer_handle *index_buffer,
+ const struct pipe_buffer *index_buffer,
int ib_size, int start, int count)
{
/* Emit the indexbuffer packet:
void brw_init_caches( struct brw_context *brw );
void brw_destroy_caches( struct brw_context *brw );
-static inline struct pipe_buffer_handle *brw_cache_buffer(struct brw_context *brw,
+static inline struct pipe_buffer *brw_cache_buffer(struct brw_context *brw,
enum brw_cache_id id)
{
return brw->cache[id].pool->buffer;
#include "pipe/p_winsys.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
#include "brw_context.h"
#include "brw_state.h"
{
struct brw_mem_pool *pool = &brw->pool[pool_id];
- pool->brw->pipe.winsys->buffer_reference( pool->brw->pipe.winsys,
- &pool->buffer,
- NULL );
+ pipe_buffer_reference( pool->brw->pipe.winsys,
+ &pool->buffer,
+ NULL );
}
if (ps) {
assert(ps->format);
assert(ps->refcount);
- pipe->winsys->buffer_reference(pipe->winsys, &ps->buffer, tex->buffer);
+ pipe_buffer_reference(pipe->winsys, &ps->buffer, tex->buffer);
ps->format = pt->format;
ps->cpp = pt->cpp;
ps->width = pt->width[level];
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#include "brw_context.h"
DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
*/
- pipe->winsys->buffer_reference(pipe->winsys, &tex->buffer, NULL);
+ pipe_buffer_reference(pipe->winsys, &tex->buffer, NULL);
for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
if (tex->image_offset[i])
* etc.
*/
-struct pipe_buffer_handle;
+struct pipe_buffer;
struct pipe_fence_handle;
struct pipe_winsys;
* I915_BUFFER_ACCESS_READ macros.
*/
void (*batch_reloc)(struct brw_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned access_flags,
unsigned delta);
* simulator:
*/
void (*buffer_subdata_typed)(struct brw_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned long offset,
unsigned long size,
const void *data,
* of places yet:
*/
unsigned (*get_buffer_offset)( struct brw_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned flags );
};
}
static unsigned brw_buffer_offset(struct brw_context *brw,
- struct pipe_buffer_handle *buffer)
+ struct pipe_buffer *buffer)
{
return brw->winsys->get_buffer_offset(brw->winsys,
buffer,
unsigned mode, unsigned start, unsigned count);
boolean (*draw_elements)( struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned mode, unsigned start, unsigned count);
static INLINE void
pipe_surface_reference(struct pipe_surface **ptr, struct pipe_surface *surf)
{
- assert(ptr);
- if (*ptr) {
+ /* bump the refcount first */
+ if (surf)
+ surf->refcount++;
+
+ if (*ptr /* && --(*ptr)->refcount == 0 */) {
struct pipe_winsys *winsys = (*ptr)->winsys;
winsys->surface_release(winsys, ptr);
assert(!*ptr);
}
- if (surf) {
- /* reference the new thing */
- surf->refcount++;
- *ptr = surf;
- }
+
+ *ptr = surf;
+}
+
+
+/* XXX: thread safety issues!
+ */
+static INLINE void
+pipe_buffer_reference(struct pipe_winsys *winsys,
+ struct pipe_buffer **ptr,
+ struct pipe_buffer *buf)
+{
+ if (buf)
+ buf->refcount++;
+
+ if (*ptr && --(*ptr)->refcount == 0)
+ winsys->buffer_destroy( winsys, *ptr );
+
+ *ptr = buf;
}
+
/**
* \sa pipe_surface_reference
*/
struct pipe_texture *pt)
{
assert(ptr);
+
+ if (pt)
+ pt->refcount++;
+
if (*ptr) {
pipe->texture_release(pipe, ptr);
assert(!*ptr);
}
- if (pt) {
- /* reference the new thing */
- pt->refcount++;
- *ptr = pt;
- }
+
+ *ptr = pt;
}
struct pipe_surface;
struct pipe_winsys;
-/* opaque type */
-struct pipe_buffer_handle;
+
+
+/**
+ * The driver will certainly subclass this to include actual memory
+ * management information.
+ */
+struct pipe_buffer {
+ unsigned alignment;
+ unsigned usage;
+ unsigned size;
+
+ /** Reference count */
+ unsigned refcount;
+};
+
* Constants for vertex/fragment shaders
*/
struct pipe_constant_buffer {
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
unsigned size; /** in bytes */
};
*/
struct pipe_surface
{
- struct pipe_buffer_handle *buffer; /**< driver private buffer handle */
+ struct pipe_buffer *buffer; /**< driver private buffer handle */
enum pipe_format format; /**< PIPE_FORMAT_x */
unsigned status; /**< PIPE_SURFACE_STATUS_x */
unsigned clear_value; /**< may be temporary */
unsigned pitch:11; /**< stride to same attrib in next vertex, in bytes */
unsigned max_index; /**< number of vertices in this buffer */
unsigned buffer_offset; /**< offset to start of data in buffer, in bytes */
- struct pipe_buffer_handle *buffer; /**< the actual buffer */
+ struct pipe_buffer *buffer; /**< the actual buffer */
};
*/
-/** Opaque type for a buffer */
-struct pipe_buffer_handle;
-
/** Opaque type */
struct pipe_fence_handle;
* usage argument is only an optimization hint, not a guarantee, therefore
* proper behavior must be observed in all circumstances.
*/
- struct pipe_buffer_handle *(*buffer_create)( struct pipe_winsys *sws,
+ struct pipe_buffer *(*buffer_create)( struct pipe_winsys *sws,
unsigned alignment,
unsigned usage,
unsigned size );
/** Create a buffer that wraps user-space data */
- struct pipe_buffer_handle *(*user_buffer_create)(struct pipe_winsys *sws,
+ struct pipe_buffer *(*user_buffer_create)(struct pipe_winsys *sws,
void *ptr,
unsigned bytes);
* flags is bitmask of PIPE_BUFFER_FLAG_READ/WRITE.
*/
void *(*buffer_map)( struct pipe_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned usage );
void (*buffer_unmap)( struct pipe_winsys *sws,
- struct pipe_buffer_handle *buf );
+ struct pipe_buffer *buf );
- /** Set ptr = buf, with reference counting */
- void (*buffer_reference)( struct pipe_winsys *sws,
- struct pipe_buffer_handle **ptr,
- struct pipe_buffer_handle *buf );
+ void (*buffer_destroy)( struct pipe_winsys *sws,
+ struct pipe_buffer *buf );
/** Set ptr = fence, with reference counting */
DRIVER_SOURCES = \
pb_buffer.c \
pb_buffer_client.c \
- pb_buffer_handle.c \
pb_buffer_fenced.c \
pb_buffer_malloc.c \
- pb_buffer_null.c \
pb_bufmgr_fenced.c \
pb_bufmgr_mm.c \
pb_bufmgr_pool.c
#include "pb_buffer.h"
+#include "pipe/p_winsys.h"
-void
-buffer_reference(struct pipe_buffer **dst,
- struct pipe_buffer *src)
+
+static void *
+pb_winsys_map(struct pipe_winsys *winsys,
+ struct pipe_buffer *ws_buf,
+ unsigned flags)
+{
+ struct pb_buffer *buf = pb_buffer(ws_buf);
+
+ return buf->vtbl->map(buf, flags);
+}
+
+static void
+pb_winsys_unmap(struct pipe_winsys *winsys,
+ struct pipe_buffer *ws_buf)
+{
+ struct pb_buffer *buf = pb_buffer(ws_buf);
+
+ buf->vtbl->unmap(buf);
+}
+
+static void
+pb_winsys_destroy(struct pipe_winsys *winsys,
+ struct pipe_buffer *ws_buf)
+{
+ struct pb_buffer *buf = pb_buffer(ws_buf);
+
+ buf->vtbl->destroy(buf);
+}
+
+
+
+void
+pb_init_winsys(struct pipe_winsys *winsys)
{
- if(*dst != src) {
- if (src)
- src->vtbl->reference(src);
-
- if (*dst)
- (*dst)->vtbl->release(*dst);
-
- *dst = src;
- }
+ winsys->buffer_map = pb_winsys_map;
+ winsys->buffer_unmap = pb_winsys_unmap;
+ winsys->buffer_destroy = pb_winsys_destroy;
}
#include <assert.h>
#include <stdlib.h>
+#include "pipe/p_state.h"
-struct pipe_buffer_vtbl;
-
+struct pb_vtbl;
/**
- * Base class for all pipe buffers.
+ * Base class for all pb_* buffers.
*/
-struct pipe_buffer
+struct pb_buffer
{
+ struct pipe_buffer base;
+
/**
* Pointer to the virtual function table.
*
* Avoid accessing this table directly. Use the inline functions below
* instead to avoid mistakes.
*/
- const struct pipe_buffer_vtbl *vtbl;
+ const struct pb_vtbl *vtbl;
};
-
/**
* Virtual function table for the buffer storage operations.
*
* Note that creation is not done through this table.
*/
-struct pipe_buffer_vtbl
+struct pb_vtbl
{
- /**
- * Add a reference to the buffer.
- *
- * This method can be a no-op for buffers that don't need reference
- * counting.
- */
- void (*reference)( struct pipe_buffer *buf );
-
- /**
- * Release a reference to this buffer and destroy it.
- */
- void (*release)( struct pipe_buffer *buf );
+ void (*destroy)( struct pb_buffer *buf );
/**
* Map the entire data store of a buffer object into the client's address.
* flags is bitmask of PIPE_BUFFER_FLAG_READ/WRITE.
*/
- void *(*map)( struct pipe_buffer *buf,
+ void *(*map)( struct pb_buffer *buf,
unsigned flags );
- void (*unmap)( struct pipe_buffer *buf );
+ void (*unmap)( struct pb_buffer *buf );
/**
* Get the base buffer and the offset.
*
* Note that this will increase the reference count of the base buffer.
*/
- void (*get_base_buffer)( struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
+ void (*get_base_buffer)( struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
unsigned *offset );
};
-/** *dst = src with reference counting */
-void
-buffer_reference(struct pipe_buffer **dst,
- struct pipe_buffer *src);
-
-
-static inline void
-buffer_release(struct pipe_buffer *buf)
-{
- assert(buf);
- buf->vtbl->release(buf);
-}
-
-
+/* Accessor functions for pb->vtbl:
+ */
static inline void *
-buffer_map(struct pipe_buffer *buf,
- unsigned flags)
+pb_map(struct pb_buffer *buf,
+ unsigned flags)
{
assert(buf);
return buf->vtbl->map(buf, flags);
static inline void
-buffer_unmap(struct pipe_buffer *buf)
+pb_unmap(struct pb_buffer *buf)
{
assert(buf);
buf->vtbl->unmap(buf);
static inline void
-buffer_get_base_buffer( struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
- unsigned *offset )
+pb_get_base_buffer( struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
+ unsigned *offset )
{
buf->vtbl->get_base_buffer(buf, base_buf, offset);
}
+static inline void
+pb_destroy(struct pb_buffer *buf)
+{
+ assert(buf);
+ buf->vtbl->destroy(buf);
+}
+
-/** Placeholder for empty buffers. */
-extern struct pipe_buffer null_buffer;
/**
- * Client buffers (also designated as user buffers) are just for convenience
- * of the state tracker, so that it can masquerade its own data as a buffer.
+ * User buffers are special buffers that initially reference memory
+ * held by the user but which may if necessary copy that memory into
+ * device memory behind the scenes, for submission to hardware.
+ *
+ * These are particularly useful when the referenced data is never
+ * submitted to hardware at all, in the particular case of software
+ * vertex processing.
*/
-struct pipe_buffer *
-client_buffer_create(void *data);
+struct pb_buffer *
+pb_user_buffer_create(void *data, unsigned bytes);
/**
* Malloc-based buffer to store data that can't be used by the graphics
* hardware.
*/
-struct pipe_buffer *
-malloc_buffer_create(unsigned size);
+struct pb_buffer *
+pb_malloc_buffer_create( unsigned alignment,
+ unsigned usage,
+ unsigned size );
+
+
+
+static inline struct pipe_buffer *
+pb_pipe_buffer( struct pb_buffer *pbuf )
+{
+ return &pbuf->base;
+}
+
+static inline struct pb_buffer *
+pb_buffer( struct pipe_buffer *buf )
+{
+ /* Could add a magic cookie check on debug builds.
+ */
+ return (struct pb_buffer *)buf;
+}
+
+void
+pb_init_winsys(struct pipe_winsys *winsys);
#endif /*PB_BUFFER_H_*/
#include "pb_buffer.h"
+#include "pipe/p_util.h"
-struct client_buffer
+struct pb_user_buffer
{
- struct pipe_buffer base;
+ struct pb_buffer base;
void *data;
};
-extern const struct pipe_buffer_vtbl client_buffer_vtbl;
+extern const struct pb_vtbl pb_user_buffer_vtbl;
-static inline struct client_buffer *
-client_buffer(struct pipe_buffer *buf)
+static INLINE struct pb_user_buffer *
+pb_user_buffer(struct pb_buffer *buf)
{
assert(buf);
- assert(buf->vtbl == &client_buffer_vtbl);
- return (struct client_buffer *)buf;
+ assert(buf->vtbl == &pb_user_buffer_vtbl);
+ return (struct pb_user_buffer *)buf;
}
static void
-client_buffer_reference(struct pipe_buffer *buf)
-{
- /* No-op */
-}
-
-
-static void
-client_buffer_release(struct pipe_buffer *buf)
+pb_user_buffer_destroy(struct pb_buffer *buf)
{
assert(buf);
free(buf);
static void *
-client_buffer_map(struct pipe_buffer *buf,
+pb_user_buffer_map(struct pb_buffer *buf,
unsigned flags)
{
- return client_buffer(buf)->data;
+ return pb_user_buffer(buf)->data;
}
static void
-client_buffer_unmap(struct pipe_buffer *buf)
+pb_user_buffer_unmap(struct pb_buffer *buf)
{
/* No-op */
}
static void
-client_buffer_get_base_buffer(struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
+pb_user_buffer_get_base_buffer(struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
unsigned *offset)
{
*base_buf = buf;
}
-const struct pipe_buffer_vtbl
-client_buffer_vtbl = {
- client_buffer_reference,
- client_buffer_release,
- client_buffer_map,
- client_buffer_unmap,
- client_buffer_get_base_buffer
+const struct pb_vtbl
+pb_user_buffer_vtbl = {
+ pb_user_buffer_destroy,
+ pb_user_buffer_map,
+ pb_user_buffer_unmap,
+ pb_user_buffer_get_base_buffer
};
-struct pipe_buffer *
-client_buffer_create(void *data)
+struct pb_buffer *
+pb_user_buffer_create(void *data, unsigned bytes)
{
- struct client_buffer *buf;
-
- buf = (struct client_buffer *)malloc(sizeof(struct client_buffer));
+ struct pb_user_buffer *buf = CALLOC_STRUCT(pb_user_buffer);
+
if(!buf)
return NULL;
- buf->base.vtbl = &client_buffer_vtbl;
-
+ buf->base.vtbl = &pb_user_buffer_vtbl;
+ buf->base.base.size = bytes;
buf->data = data;
return &buf->base;
*/
struct fenced_buffer
{
- struct pipe_buffer base;
+ struct pb_buffer base;
- struct pipe_buffer *buffer;
+ struct pb_buffer *buffer;
unsigned refcount;
struct pipe_fence_handle *fence;
};
-static inline struct fenced_buffer *
-fenced_buffer(struct pipe_buffer *buf)
+static INLINE struct fenced_buffer *
+fenced_buffer(struct pb_buffer *buf)
{
assert(buf);
assert(buf->vtbl == &fenced_buffer_vtbl);
}
-static void
-_fenced_buffer_destroy(struct fenced_buffer *fenced_buf)
-{
- buffer_release(fenced_buf->buffer);
- free(fenced_buf);
-}
static void
LIST_DEL(list);
fenced_list->numDelayed--;
-
- _fenced_buffer_destroy(fenced_buf);
- }
-}
-
-static void
-fenced_buffer_reference(struct pipe_buffer *buf)
-{
- struct fenced_buffer *fenced_buf = fenced_buffer(buf);
- struct fenced_buffer_list *fenced_list = fenced_buf->list;
-
- _glthread_LOCK_MUTEX(fenced_list->mutex);
- fenced_buf->refcount++;
- _glthread_UNLOCK_MUTEX(fenced_list->mutex);
+ /* Do the delayed destroy:
+ */
+ pb_destroy(fenced_buf->buffer);
+ free(fenced_buf);
+ }
}
static void
-fenced_buffer_release(struct pipe_buffer *buf)
+fenced_buffer_destroy(struct pb_buffer *buf)
{
struct fenced_buffer *fenced_buf = fenced_buffer(buf);
struct fenced_buffer_list *fenced_list = fenced_buf->list;
- _glthread_LOCK_MUTEX(fenced_list->mutex);
-
- fenced_buf->refcount--;
- if(!fenced_buf->refcount) {
- if (fenced_buf->fence) {
- LIST_ADDTAIL(&fenced_buf->head, &fenced_list->delayed);
- fenced_list->numDelayed++;
- }
- else {
- _fenced_buffer_destroy(fenced_buf);
- }
-
- if ((fenced_list->numDelayed % fenced_list->checkDelayed) == 0)
- _fenced_buffer_list_check_free(fenced_list, 0);
+ if (fenced_buf->fence) {
+ LIST_ADDTAIL(&fenced_buf->head, &fenced_list->delayed);
+ fenced_list->numDelayed++;
+ }
+ else {
+ pb_destroy(fenced_buf->buffer);
+ free(fenced_buf);
}
- _glthread_UNLOCK_MUTEX(fenced_list->mutex);
+ if ((fenced_list->numDelayed % fenced_list->checkDelayed) == 0)
+ _fenced_buffer_list_check_free(fenced_list, 0);
}
static void *
-fenced_buffer_map(struct pipe_buffer *buf,
+fenced_buffer_map(struct pb_buffer *buf,
unsigned flags)
{
struct fenced_buffer *fenced_buf = fenced_buffer(buf);
- return buffer_map(fenced_buf->buffer, flags);
+ return pb_map(fenced_buf->buffer, flags);
}
static void
-fenced_buffer_unmap(struct pipe_buffer *buf)
+fenced_buffer_unmap(struct pb_buffer *buf)
{
struct fenced_buffer *fenced_buf = fenced_buffer(buf);
- buffer_unmap(fenced_buf->buffer);
+ pb_unmap(fenced_buf->buffer);
}
static void
-fenced_buffer_get_base_buffer(struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
+fenced_buffer_get_base_buffer(struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
unsigned *offset)
{
struct fenced_buffer *fenced_buf = fenced_buffer(buf);
- buffer_get_base_buffer(fenced_buf->buffer, base_buf, offset);
+ pb_get_base_buffer(fenced_buf->buffer, base_buf, offset);
}
-const struct pipe_buffer_vtbl
+const struct pb_vtbl
fenced_buffer_vtbl = {
- fenced_buffer_reference,
- fenced_buffer_release,
+ fenced_buffer_destroy,
fenced_buffer_map,
fenced_buffer_unmap,
fenced_buffer_get_base_buffer
};
-struct pipe_buffer *
+struct pb_buffer *
fenced_buffer_create(struct fenced_buffer_list *fenced_list,
- struct pipe_buffer *buffer)
+ struct pb_buffer *buffer)
{
struct fenced_buffer *buf;
if(!buffer)
return NULL;
- buf = (struct fenced_buffer *)calloc(1, sizeof(struct fenced_buffer));
+ buf = CALLOC_STRUCT(fenced_buffer);
if(!buf)
return NULL;
void
-buffer_fence(struct pipe_buffer *buf,
+buffer_fence(struct pb_buffer *buf,
struct pipe_fence_handle *fence)
{
- if(buf->vtbl == &fenced_buffer_vtbl) {
- struct fenced_buffer *fenced_buf = fenced_buffer(buf);
- struct fenced_buffer_list *fenced_list = fenced_buf->list;
- struct pipe_winsys *winsys = fenced_list->winsys;
+ struct fenced_buffer *fenced_buf = fenced_buffer(buf);
+ struct fenced_buffer_list *fenced_list = fenced_buf->list;
+ struct pipe_winsys *winsys = fenced_list->winsys;
- _glthread_LOCK_MUTEX(fenced_list->mutex);
- winsys->fence_reference(winsys, &fenced_buf->fence, fence);
- _glthread_UNLOCK_MUTEX(fenced_list->mutex);
- }
- else
- assert(0);
+ _glthread_LOCK_MUTEX(fenced_list->mutex);
+ winsys->fence_reference(winsys, &fenced_buf->fence, fence);
+ _glthread_UNLOCK_MUTEX(fenced_list->mutex);
}
*
* NOTE: Made public for debugging purposes.
*/
-extern const struct pipe_buffer_vtbl fenced_buffer_vtbl;
+extern const struct pb_vtbl fenced_buffer_vtbl;
/**
*
* NOTE: this will not increase the buffer reference count.
*/
-struct pipe_buffer *
+struct pb_buffer *
fenced_buffer_create(struct fenced_buffer_list *fenced,
- struct pipe_buffer *buffer);
+ struct pb_buffer *buffer);
/**
* Set a buffer's fence.
*
- * NOTE: Although it takes a generic pipe buffer argument, it will fail
+ * NOTE: Although it takes a generic pb_buffer argument, it will fail
* on everything but buffers returned by fenced_buffer_create.
*/
void
-buffer_fence(struct pipe_buffer *buf,
+buffer_fence(struct pb_buffer *buf,
struct pipe_fence_handle *fence);
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * 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
- * 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.
- *
- **************************************************************************/
-
-/**
- * \file
- * Drop-in implementation of the winsys driver functions for buffer handles.
- *
- * \author José Fonseca <jrfonseca@tungstengraphics.com>
- */
-
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include "pipe/p_winsys.h"
-#include "pipe/p_defines.h"
-
-#include "pb_buffer.h"
-#include "pb_buffer_handle.h"
-
-
-static struct pipe_buffer_handle *
-buffer_handle_create(struct pipe_winsys *winsys,
- unsigned alignment,
- unsigned usage,
- unsigned size)
-{
- struct pipe_buffer_handle *handle;
-
- handle = (struct pipe_buffer_handle *)malloc(sizeof(struct pipe_buffer_handle));
- if(!handle)
- return NULL;
-
- handle->refcount = 1;
- handle->alignment = alignment;
- handle->usage = usage;
- handle->size = size;
-
- handle->buf = &null_buffer;
-
- return handle;
-}
-
-
-static struct pipe_buffer_handle *
-buffer_handle_create_user(struct pipe_winsys *winsys,
- void *data, unsigned size)
-{
- struct pipe_buffer_handle *handle;
- struct pipe_buffer *buf;
-
- handle = buffer_handle_create(winsys, 1, 0, size);
- if(!handle)
- return NULL;
-
- buf = client_buffer_create(data);
- if(!buf) {
- free(handle);
- return NULL;
- }
-
- buffer_handle_data(handle, buf);
-
- return handle;
-}
-
-
-static void *
-buffer_handle_map(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *handle,
- unsigned flags)
-{
- return buffer_map(handle->buf, flags);
-}
-
-
-static void
-buffer_handle_unmap(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *handle)
-{
- buffer_unmap(handle->buf);
-}
-
-
-static void
-buffer_handle_reference(struct pipe_winsys *winsys,
- struct pipe_buffer_handle **dst,
- struct pipe_buffer_handle *src)
-{
- /* XXX: should this be thread safe? */
-
- if (src) {
- src->refcount++;
- }
-
- if (*dst) {
- (*dst)->refcount--;
- if ((*dst)->refcount == 0) {
- buffer_release((*dst)->buf);
- free(*dst);
- }
- }
-
- *dst = src;
-}
-
-
-void
-buffer_handle_init_winsys(struct pipe_winsys *winsys)
-{
- winsys->buffer_create = buffer_handle_create;
- winsys->user_buffer_create = buffer_handle_create_user;
- winsys->buffer_map = buffer_handle_map;
- winsys->buffer_unmap = buffer_handle_unmap;
- winsys->buffer_reference = buffer_handle_reference;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * 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
- * 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.
- *
- **************************************************************************/
-
-/**
- * \file
- * Buffer handle interface.
- *
- * \author José Fonseca <jrfonseca@tungstengraphics.com>
- */
-
-#ifndef PB_BUFFER_HANDLE_H_
-#define PB_BUFFER_HANDLE_H_
-
-
-#include <assert.h>
-
-#include "pb_buffer.h"
-
-
-/**
- * Buffer handle.
- *
- * The buffer handle and the buffer data storage are separate entities. This
- * is modelled after ARB_vertex_buffer_object, which is the interface that
- * Gallium requires. See p_winsys.h for more information.
- */
-struct pipe_buffer_handle
-{
- /** Reference count */
- unsigned refcount;
-
- /** Allocation characteristics */
- unsigned alignment;
- unsigned usage;
- unsigned size;
-
- /**
- * The actual buffer.
- *
- * It should never be NULL. Use null_buffer instead.
- */
- struct pipe_buffer *buf;
-};
-
-
-/**
- * Set buffer storage.
- *
- * NOTE: this will not increase the buffer reference count.
- */
-static inline void
-buffer_handle_data(struct pipe_buffer_handle *handle,
- struct pipe_buffer *buf)
-{
- assert(handle);
- assert(handle->buf);
- buffer_release(handle->buf);
- assert(buf);
- handle->buf = buf;
-}
-
-
-static inline void
-buffer_handle_clear(struct pipe_buffer_handle *handle)
-{
- buffer_handle_data(handle, &null_buffer);
-}
-
-
-static inline int
-buffer_handle_has_data(struct pipe_buffer_handle *handle) {
- assert(handle);
- assert(handle->buf);
- return handle->buf != &null_buffer;
-}
-
-
-/**
- * Fill in the pipe_winsys' buffer-related callbacks.
- *
- * Specifically, the fullfilled functions are:
- * - buffer_create
- * - user_buffer_create
- * - buffer_map
- * - buffer_unmap
- * - buffer_reference
- * - buffer_subdata
- * - buffer_get_subdata
- *
- * NOTE: buffer_data is left untouched.
- */
-void
-buffer_handle_init_winsys(struct pipe_winsys *winsys);
-
-
-#endif /*PB_BUFFER_HANDLE_H_*/
struct malloc_buffer
{
- struct pipe_buffer base;
+ struct pb_buffer base;
void *data;
};
-extern const struct pipe_buffer_vtbl malloc_buffer_vtbl;
+extern const struct pb_vtbl malloc_buffer_vtbl;
-static inline struct malloc_buffer *
-malloc_buffer(struct pipe_buffer *buf)
+static INLINE struct malloc_buffer *
+malloc_buffer(struct pb_buffer *buf)
{
assert(buf);
assert(buf->vtbl == &malloc_buffer_vtbl);
static void
-malloc_buffer_reference(struct pipe_buffer *buf)
-{
- /* no-op */
-}
-
-
-static void
-malloc_buffer_release(struct pipe_buffer *buf)
+malloc_buffer_destroy(struct pb_buffer *buf)
{
free(malloc_buffer(buf)->data);
free(buf);
static void *
-malloc_buffer_map(struct pipe_buffer *buf,
+malloc_buffer_map(struct pb_buffer *buf,
unsigned flags)
{
return malloc_buffer(buf)->data;
static void
-malloc_buffer_unmap(struct pipe_buffer *buf)
+malloc_buffer_unmap(struct pb_buffer *buf)
{
/* No-op */
}
static void
-malloc_buffer_get_base_buffer(struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
+malloc_buffer_get_base_buffer(struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
unsigned *offset)
{
*base_buf = buf;
}
-const struct pipe_buffer_vtbl
+const struct pb_vtbl
malloc_buffer_vtbl = {
- malloc_buffer_reference,
- malloc_buffer_release,
+ malloc_buffer_destroy,
malloc_buffer_map,
malloc_buffer_unmap,
malloc_buffer_get_base_buffer
};
-struct pipe_buffer *
-malloc_buffer_create(unsigned size)
+struct pb_buffer *
+pb_malloc_buffer_create( unsigned alignment,
+ unsigned usage,
+ unsigned size )
{
struct malloc_buffer *buf;
return NULL;
buf->base.vtbl = &malloc_buffer_vtbl;
-
+ buf->base.base.alignment = alignment;
+ buf->base.base.usage = usage;
+ buf->base.base.size = size;
+
buf->data = malloc(size);
if(!buf->data) {
free(buf);
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * 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
- * 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.
- *
- **************************************************************************/
-
-/**
- * \file
- * Null buffer implementation.
- *
- * We have a special null buffer object so that we can safely call buffer
- * operations without having to check whether the buffer pointer is null or not.
- *
- * \author José Fonseca <jrfonseca@tungstengraphics.com>
- */
-
-
-#include "pipe/p_winsys.h"
-#include "pipe/p_defines.h"
-
-#include "pb_buffer.h"
-
-
-static void
-null_buffer_reference(struct pipe_buffer *buf)
-{
- /* No-op */
-}
-
-
-static void
-null_buffer_release(struct pipe_buffer *buf)
-{
- /* No-op */
-}
-
-
-static void *
-null_buffer_map(struct pipe_buffer *buf,
- unsigned flags)
-{
- assert(0);
- return NULL;
-}
-
-
-static void
-null_buffer_unmap(struct pipe_buffer *buf)
-{
- assert(0);
-}
-
-
-static void
-null_buffer_get_base_buffer(struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
- unsigned *offset)
-{
- *base_buf = buf;
- *offset = 0;
-}
-
-
-const struct pipe_buffer_vtbl
-pipe_buffer_vtbl = {
- null_buffer_reference,
- null_buffer_release,
- null_buffer_map,
- null_buffer_unmap,
- null_buffer_get_base_buffer
-};
-
-
-struct pipe_buffer
-null_buffer = {
- &pipe_buffer_vtbl
-};
/**
* Abstract base class for all buffer managers.
*/
-struct buffer_manager
+struct pb_manager
{
/* XXX: we will likely need more allocation flags */
- struct pipe_buffer *
- (*create_buffer)( struct buffer_manager *mgr,
+ struct pb_buffer *
+ (*create_buffer)( struct pb_manager *mgr,
size_t size );
void
- (*destroy)( struct buffer_manager *mgr );
+ (*destroy)( struct pb_manager *mgr );
};
*
* It is meant to manage the allocation of batch buffer pools.
*/
-struct buffer_manager *
-pool_bufmgr_create(struct buffer_manager *provider,
+struct pb_manager *
+pool_bufmgr_create(struct pb_manager *provider,
size_t n, size_t size);
* with the size of the heap, and then using the old mm memory manager to manage
* that heap.
*/
-struct buffer_manager *
-mm_bufmgr_create(struct buffer_manager *provider,
+struct pb_manager *
+mm_bufmgr_create(struct pb_manager *provider,
size_t size, size_t align2);
/**
*
* Buffer will be release when the manager is destroyed.
*/
-struct buffer_manager *
-mm_bufmgr_create_from_buffer(struct pipe_buffer *buffer,
+struct pb_manager *
+mm_bufmgr_create_from_buffer(struct pb_buffer *buffer,
size_t size, size_t align2);
* NOTE: the buffer manager that provides the buffers will be destroyed
* at the same time.
*/
-struct buffer_manager *
-fenced_bufmgr_create(struct buffer_manager *provider,
+struct pb_manager *
+fenced_bufmgr_create(struct pb_manager *provider,
struct pipe_winsys *winsys);
#include "pb_bufmgr.h"
-struct fenced_buffer_manager
+struct fenced_pb_manager
{
- struct buffer_manager base;
+ struct pb_manager base;
- struct buffer_manager *provider;
+ struct pb_manager *provider;
struct fenced_buffer_list *fenced_list;
};
-static inline struct fenced_buffer_manager *
-fenced_buffer_manager(struct buffer_manager *mgr)
+static inline struct fenced_pb_manager *
+fenced_pb_manager(struct pb_manager *mgr)
{
assert(mgr);
- return (struct fenced_buffer_manager *)mgr;
+ return (struct fenced_pb_manager *)mgr;
}
-static struct pipe_buffer *
-fenced_bufmgr_create_buffer(struct buffer_manager *mgr, size_t size)
+static struct pb_buffer *
+fenced_bufmgr_create_buffer(struct pb_manager *mgr, size_t size)
{
- struct fenced_buffer_manager *fenced_mgr = fenced_buffer_manager(mgr);
- struct pipe_buffer *buf;
- struct pipe_buffer *fenced_buf;
+ struct fenced_pb_manager *fenced_mgr = fenced_pb_manager(mgr);
+ struct pb_buffer *buf;
+ struct pb_buffer *fenced_buf;
/* check for free buffers before allocating new ones */
fenced_buffer_list_check_free(fenced_mgr->fenced_list, 0);
fenced_buf = fenced_buffer_create(fenced_mgr->fenced_list, buf);
if(!fenced_buf) {
- buffer_release(buf);
+ pb_destroy(buf);
}
return fenced_buf;
static void
-fenced_bufmgr_destroy(struct buffer_manager *mgr)
+fenced_bufmgr_destroy(struct pb_manager *mgr)
{
- struct fenced_buffer_manager *fenced_mgr = fenced_buffer_manager(mgr);
+ struct fenced_pb_manager *fenced_mgr = fenced_pb_manager(mgr);
fenced_buffer_list_destroy(fenced_mgr->fenced_list);
}
-struct buffer_manager *
-fenced_bufmgr_create(struct buffer_manager *provider,
+struct pb_manager *
+fenced_bufmgr_create(struct pb_manager *provider,
struct pipe_winsys *winsys)
{
- struct fenced_buffer_manager *fenced_mgr;
+ struct fenced_pb_manager *fenced_mgr;
- fenced_mgr = (struct fenced_buffer_manager *)calloc(1, sizeof(*fenced_mgr));
+ fenced_mgr = (struct fenced_pb_manager *)calloc(1, sizeof(*fenced_mgr));
if (!fenced_mgr)
return NULL;
#define SUPER(__derived) (&(__derived)->base)
-struct mm_buffer_manager
+struct mm_pb_manager
{
- struct buffer_manager base;
+ struct pb_manager base;
_glthread_Mutex mutex;
size_t align2;
- struct pipe_buffer *buffer;
+ struct pb_buffer *buffer;
void *map;
};
-static inline struct mm_buffer_manager *
-mm_buffer_manager(struct buffer_manager *mgr)
+static inline struct mm_pb_manager *
+mm_pb_manager(struct pb_manager *mgr)
{
assert(mgr);
- return (struct mm_buffer_manager *)mgr;
+ return (struct mm_pb_manager *)mgr;
}
struct mm_buffer
{
- struct pipe_buffer base;
+ struct pb_buffer base;
- struct mm_buffer_manager *mgr;
+ struct mm_pb_manager *mgr;
struct mem_block *block;
};
static inline struct mm_buffer *
-mm_buffer(struct pipe_buffer *buf)
+mm_buffer(struct pb_buffer *buf)
{
assert(buf);
return (struct mm_buffer *)buf;
static void
-mm_buffer_reference(struct pipe_buffer *buf)
-{
- /* No-op */
-}
-
-
-static void
-mm_buffer_release(struct pipe_buffer *buf)
+mm_buffer_destroy(struct pb_buffer *buf)
{
struct mm_buffer *mm_buf = mm_buffer(buf);
- struct mm_buffer_manager *mm = mm_buf->mgr;
+ struct mm_pb_manager *mm = mm_buf->mgr;
_glthread_LOCK_MUTEX(mm->mutex);
mmFreeMem(mm_buf->block);
static void *
-mm_buffer_map(struct pipe_buffer *buf,
+mm_buffer_map(struct pb_buffer *buf,
unsigned flags)
{
struct mm_buffer *mm_buf = mm_buffer(buf);
- struct mm_buffer_manager *mm = mm_buf->mgr;
+ struct mm_pb_manager *mm = mm_buf->mgr;
return (unsigned char *) mm->map + mm_buf->block->ofs;
}
static void
-mm_buffer_unmap(struct pipe_buffer *buf)
+mm_buffer_unmap(struct pb_buffer *buf)
{
/* No-op */
}
static void
-mm_buffer_get_base_buffer(struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
+mm_buffer_get_base_buffer(struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
unsigned *offset)
{
struct mm_buffer *mm_buf = mm_buffer(buf);
- struct mm_buffer_manager *mm = mm_buf->mgr;
- buffer_get_base_buffer(mm->buffer, base_buf, offset);
+ struct mm_pb_manager *mm = mm_buf->mgr;
+ pb_get_base_buffer(mm->buffer, base_buf, offset);
*offset += mm_buf->block->ofs;
}
-static const struct pipe_buffer_vtbl
+static const struct pb_vtbl
mm_buffer_vtbl = {
- mm_buffer_reference,
- mm_buffer_release,
+ mm_buffer_destroy,
mm_buffer_map,
mm_buffer_unmap,
mm_buffer_get_base_buffer
};
-static struct pipe_buffer *
-mm_bufmgr_create_buffer(struct buffer_manager *mgr,
+static struct pb_buffer *
+mm_bufmgr_create_buffer(struct pb_manager *mgr,
size_t size)
{
- struct mm_buffer_manager *mm = mm_buffer_manager(mgr);
+ struct mm_pb_manager *mm = mm_pb_manager(mgr);
struct mm_buffer *mm_buf;
_glthread_LOCK_MUTEX(mm->mutex);
static void
-mm_bufmgr_destroy(struct buffer_manager *mgr)
+mm_bufmgr_destroy(struct pb_manager *mgr)
{
- struct mm_buffer_manager *mm = mm_buffer_manager(mgr);
+ struct mm_pb_manager *mm = mm_pb_manager(mgr);
_glthread_LOCK_MUTEX(mm->mutex);
mmDestroy(mm->heap);
- buffer_unmap(mm->buffer);
- buffer_release(mm->buffer);
+ pb_unmap(mm->buffer);
+ pb_destroy(mm->buffer);
_glthread_UNLOCK_MUTEX(mm->mutex);
}
-struct buffer_manager *
-mm_bufmgr_create_from_buffer(struct pipe_buffer *buffer,
+struct pb_manager *
+mm_bufmgr_create_from_buffer(struct pb_buffer *buffer,
size_t size, size_t align2)
{
- struct mm_buffer_manager *mm;
+ struct mm_pb_manager *mm;
if(!buffer)
return NULL;
- mm = (struct mm_buffer_manager *)calloc(1, sizeof(*mm));
+ mm = (struct mm_pb_manager *)calloc(1, sizeof(*mm));
if (!mm)
return NULL;
mm->buffer = buffer;
- mm->map = buffer_map(mm->buffer,
- PIPE_BUFFER_USAGE_CPU_READ |
- PIPE_BUFFER_USAGE_CPU_WRITE);
+ mm->map = pb_map(mm->buffer,
+ PIPE_BUFFER_USAGE_CPU_READ |
+ PIPE_BUFFER_USAGE_CPU_WRITE);
if(!mm->map)
goto failure;
if(mm->heap)
mmDestroy(mm->heap);
if(mm->map)
- buffer_unmap(mm->buffer);
+ pb_unmap(mm->buffer);
if(mm)
free(mm);
return NULL;
}
-struct buffer_manager *
-mm_bufmgr_create(struct buffer_manager *provider,
+struct pb_manager *
+mm_bufmgr_create(struct pb_manager *provider,
size_t size, size_t align2)
{
- struct pipe_buffer *buffer;
- struct buffer_manager *mgr;
+ struct pb_buffer *buffer;
+ struct pb_manager *mgr;
assert(provider);
assert(provider->create_buffer);
mgr = mm_bufmgr_create_from_buffer(buffer, size, align2);
if (!mgr) {
- buffer_release(buffer);
+ pb_destroy(buffer);
return NULL;
}
#define SUPER(__derived) (&(__derived)->base)
-struct pool_buffer_manager
+struct pool_pb_manager
{
- struct buffer_manager base;
+ struct pb_manager base;
_glthread_Mutex mutex;
struct list_head free;
- struct pipe_buffer *buffer;
+ struct pb_buffer *buffer;
void *map;
struct pool_buffer *bufs;
};
-static inline struct pool_buffer_manager *
-pool_buffer_manager(struct buffer_manager *mgr)
+static inline struct pool_pb_manager *
+pool_pb_manager(struct pb_manager *mgr)
{
assert(mgr);
- return (struct pool_buffer_manager *)mgr;
+ return (struct pool_pb_manager *)mgr;
}
struct pool_buffer
{
- struct pipe_buffer base;
+ struct pb_buffer base;
- struct pool_buffer_manager *mgr;
+ struct pool_pb_manager *mgr;
struct list_head head;
static inline struct pool_buffer *
-pool_buffer(struct pipe_buffer *buf)
+pool_buffer(struct pb_buffer *buf)
{
assert(buf);
return (struct pool_buffer *)buf;
}
-static void
-pool_buffer_reference(struct pipe_buffer *buf)
-{
- /* No-op */
-}
-
static void
-pool_buffer_release(struct pipe_buffer *buf)
+pool_buffer_destroy(struct pb_buffer *buf)
{
struct pool_buffer *pool_buf = pool_buffer(buf);
- struct pool_buffer_manager *pool = pool_buf->mgr;
+ struct pool_pb_manager *pool = pool_buf->mgr;
_glthread_LOCK_MUTEX(pool->mutex);
LIST_ADD(&pool_buf->head, &pool->free);
static void *
-pool_buffer_map(struct pipe_buffer *buf, unsigned flags)
+pool_buffer_map(struct pb_buffer *buf, unsigned flags)
{
struct pool_buffer *pool_buf = pool_buffer(buf);
- struct pool_buffer_manager *pool = pool_buf->mgr;
+ struct pool_pb_manager *pool = pool_buf->mgr;
void *map;
_glthread_LOCK_MUTEX(pool->mutex);
static void
-pool_buffer_unmap(struct pipe_buffer *buf)
+pool_buffer_unmap(struct pb_buffer *buf)
{
/* No-op */
}
static void
-pool_buffer_get_base_buffer(struct pipe_buffer *buf,
- struct pipe_buffer **base_buf,
+pool_buffer_get_base_buffer(struct pb_buffer *buf,
+ struct pb_buffer **base_buf,
unsigned *offset)
{
struct pool_buffer *pool_buf = pool_buffer(buf);
- struct pool_buffer_manager *pool = pool_buf->mgr;
- buffer_get_base_buffer(pool->buffer, base_buf, offset);
+ struct pool_pb_manager *pool = pool_buf->mgr;
+ pb_get_base_buffer(pool->buffer, base_buf, offset);
*offset += pool_buf->start;
}
-static const struct pipe_buffer_vtbl
+static const struct pb_vtbl
pool_buffer_vtbl = {
- pool_buffer_reference,
- pool_buffer_release,
+ pool_buffer_destroy,
pool_buffer_map,
pool_buffer_unmap,
pool_buffer_get_base_buffer
};
-static struct pipe_buffer *
-pool_bufmgr_create_buffer(struct buffer_manager *mgr, size_t size)
+static struct pb_buffer *
+pool_bufmgr_create_buffer(struct pb_manager *mgr, size_t size)
{
- struct pool_buffer_manager *pool = pool_buffer_manager(mgr);
+ struct pool_pb_manager *pool = pool_pb_manager(mgr);
struct pool_buffer *pool_buf;
struct list_head *item;
static void
-pool_bufmgr_destroy(struct buffer_manager *mgr)
+pool_bufmgr_destroy(struct pb_manager *mgr)
{
- struct pool_buffer_manager *pool = pool_buffer_manager(mgr);
+ struct pool_pb_manager *pool = pool_pb_manager(mgr);
_glthread_LOCK_MUTEX(pool->mutex);
free(pool->bufs);
- buffer_unmap(pool->buffer);
- buffer_release(pool->buffer);
+ pb_unmap(pool->buffer);
+ pb_destroy(pool->buffer);
_glthread_UNLOCK_MUTEX(pool->mutex);
}
-struct buffer_manager *
-pool_bufmgr_create(struct buffer_manager *provider,
+struct pb_manager *
+pool_bufmgr_create(struct pb_manager *provider,
size_t numBufs,
size_t bufSize)
{
- struct pool_buffer_manager *pool;
+ struct pool_pb_manager *pool;
struct pool_buffer *pool_buf;
int i;
- pool = (struct pool_buffer_manager *)calloc(1, sizeof(*pool));
+ pool = (struct pool_pb_manager *)calloc(1, sizeof(*pool));
if (!pool)
return NULL;
if (!pool->buffer)
goto failure;
- pool->map = buffer_map(pool->buffer,
+ pool->map = pb_map(pool->buffer,
PIPE_BUFFER_USAGE_CPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE);
if(!pool->map)
if(pool->bufs)
free(pool->bufs);
if(pool->map)
- buffer_unmap(pool->buffer);
+ pb_unmap(pool->buffer);
if(pool->buffer)
- buffer_release(pool->buffer);
+ pb_destroy(pool->buffer);
if(pool)
free(pool);
return NULL;
for (i = 0; i < Elements(softpipe->constants); i++) {
if (softpipe->constants[i].buffer) {
- ws->buffer_reference(ws, &softpipe->constants[i].buffer, NULL);
+ pipe_buffer_reference(ws, &softpipe->constants[i].buffer, NULL);
}
}
*/
boolean
softpipe_draw_elements(struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned mode, unsigned start, unsigned count)
{
unsigned start, unsigned count);
boolean softpipe_draw_elements(struct pipe_context *pipe,
- struct pipe_buffer_handle *indexBuffer,
+ struct pipe_buffer *indexBuffer,
unsigned indexSize,
unsigned mode, unsigned start, unsigned count);
#include "pipe/p_defines.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#include "pipe/draw/draw_context.h"
#include "pipe/p_shader_tokens.h"
assert(index == 0);
/* note: reference counting */
- ws->buffer_reference(ws,
- &softpipe->constants[shader].buffer,
- buf->buffer);
+ pipe_buffer_reference(ws,
+ &softpipe->constants[shader].buffer,
+ buf->buffer);
softpipe->constants[shader].size = buf->size;
softpipe->dirty |= SP_NEW_CONSTANTS;
DBG("%s deleting %p\n", __FUNCTION__, (void *) spt);
*/
- pipe->winsys->buffer_reference(pipe->winsys, &spt->buffer, NULL);
+ pipe_buffer_reference(pipe->winsys, &spt->buffer, NULL);
FREE(spt);
}
if (ps) {
assert(ps->refcount);
assert(ps->winsys);
- pipe->winsys->buffer_reference(pipe->winsys, &ps->buffer, spt->buffer);
+ pipe_buffer_reference(pipe->winsys, &ps->buffer, spt->buffer);
ps->format = pt->format;
ps->cpp = pt->cpp;
ps->width = pt->width[level];
/* The data is held here:
*/
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
unsigned long buffer_size;
};
#include "pipe/p_format.h"
#include "pipe/p_context.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
#include "pipe/softpipe/sp_winsys.h"
#ifdef GALLIUM_CELL
*/
struct xm_buffer
{
+ struct pipe_buffer base;
boolean userBuffer; /** Is this a user-space buffer? */
- int refcount;
- unsigned size;
void *data;
void *mapped;
};
* buffer pointer...
*/
static INLINE struct xm_buffer *
-xm_bo( struct pipe_buffer_handle *bo )
+xm_buffer( struct pipe_buffer *buf )
{
- return (struct xm_buffer *) bo;
+ return (struct xm_buffer *)buf;
}
-static INLINE struct pipe_buffer_handle *
-pipe_bo( struct xm_buffer *bo )
-{
- return (struct pipe_buffer_handle *) bo;
-}
/* Most callbacks map direcly onto dri_bufmgr operations:
*/
static void *
-xm_buffer_map(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
+xm_buffer_map(struct pipe_winsys *pws, struct pipe_buffer *buf,
unsigned flags)
{
- struct xm_buffer *xm_buf = xm_bo(buf);
+ struct xm_buffer *xm_buf = xm_buffer(buf);
xm_buf->mapped = xm_buf->data;
return xm_buf->mapped;
}
static void
-xm_buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer_handle *buf)
+xm_buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer *buf)
{
- struct xm_buffer *xm_buf = xm_bo(buf);
+ struct xm_buffer *xm_buf = xm_buffer(buf);
xm_buf->mapped = NULL;
}
static void
-xm_buffer_reference(struct pipe_winsys *pws,
- struct pipe_buffer_handle **ptr,
- struct pipe_buffer_handle *buf)
+xm_buffer_destroy(struct pipe_winsys *pws,
+ struct pipe_buffer *buf)
{
- if (*ptr) {
- struct xm_buffer *oldBuf = xm_bo(*ptr);
- oldBuf->refcount--;
- assert(oldBuf->refcount >= 0);
- if (oldBuf->refcount == 0) {
- if (oldBuf->data) {
- if (!oldBuf->userBuffer)
- align_free(oldBuf->data);
- oldBuf->data = NULL;
- }
- free(oldBuf);
- }
- *ptr = NULL;
- }
+ struct xm_buffer *oldBuf = xm_buffer(buf);
- assert(!(*ptr));
-
- if (buf) {
- struct xm_buffer *newBuf = xm_bo(buf);
- newBuf->refcount++;
- *ptr = buf;
+ if (oldBuf->data) {
+ if (!oldBuf->userBuffer)
+ align_free(oldBuf->data);
+ oldBuf->data = NULL;
}
+
+ free(oldBuf);
}
xmesa_display_surface_tiled(XMesaBuffer b, const struct pipe_surface *surf)
{
XImage *ximage = b->tempImage;
- struct xm_buffer *xm_buf = xm_bo(surf->buffer);
+ struct xm_buffer *xm_buf = xm_buffer(surf->buffer);
const uint tilesPerRow = (surf->width + TILE_SIZE - 1) / TILE_SIZE;
uint x, y;
xmesa_display_surface(XMesaBuffer b, const struct pipe_surface *surf)
{
XImage *ximage = b->tempImage;
- struct xm_buffer *xm_buf = xm_bo(surf->buffer);
+ struct xm_buffer *xm_buf = xm_buffer(surf->buffer);
const struct xmesa_surface *xm_surf
= xmesa_surface((struct pipe_surface *) surf);
}
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
xm_buffer_create(struct pipe_winsys *pws,
unsigned alignment,
unsigned usage,
unsigned size)
{
struct xm_buffer *buffer = CALLOC_STRUCT(xm_buffer);
- buffer->refcount = 1;
+ buffer->base.refcount = 1;
+ buffer->base.alignment = alignment;
+ buffer->base.usage = usage;
+ buffer->base.size = size;
/* align to 16-byte multiple for Cell */
buffer->data = align_malloc(size, max(alignment, 16));
- buffer->size = size;
- return pipe_bo(buffer);
+ return &buffer->base;
}
/**
* Create buffer which wraps user-space data.
*/
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
xm_user_buffer_create(struct pipe_winsys *pws, void *ptr, unsigned bytes)
{
struct xm_buffer *buffer = CALLOC_STRUCT(xm_buffer);
+ buffer->base.refcount = 1;
+ buffer->base.size = bytes;
buffer->userBuffer = TRUE;
- buffer->refcount = 1;
buffer->data = ptr;
- buffer->size = bytes;
- return pipe_bo(buffer);
+
+ return &buffer->base;
}
surf->refcount--;
if (surf->refcount == 0) {
if (surf->buffer)
- winsys->buffer_reference(winsys, &surf->buffer, NULL);
+ pipe_buffer_reference(winsys, &surf->buffer, NULL);
free(surf);
}
*s = NULL;
ws->user_buffer_create = xm_user_buffer_create;
ws->buffer_map = xm_buffer_map;
ws->buffer_unmap = xm_buffer_unmap;
- ws->buffer_reference = xm_buffer_reference;
+ ws->buffer_destroy = xm_buffer_destroy;
ws->surface_alloc = xm_surface_alloc;
ws->surface_alloc_storage = xm_surface_alloc_storage;
#include "pipe/p_winsys.h"
#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
#include "pipe/i965simple/brw_winsys.h"
#include "brw_aub.h"
#include "xm_winsys_aub.h"
static INLINE struct aub_buffer *
-aub_bo( struct pipe_buffer_handle *bo )
+aub_bo( struct pipe_buffer *bo )
{
return (struct aub_buffer *)bo;
}
-static INLINE struct pipe_buffer_handle *
+static INLINE struct pipe_buffer *
pipe_bo( struct aub_buffer *bo )
{
- return (struct pipe_buffer_handle *)bo;
+ return (struct pipe_buffer *)bo;
}
static void *aub_buffer_map(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned flags )
{
struct aub_buffer *sbo = aub_bo(buf);
}
static void aub_buffer_unmap(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *buf)
+ struct pipe_buffer *buf)
{
struct aub_pipe_winsys *iws = aub_pipe_winsys(winsys);
struct aub_buffer *sbo = aub_bo(buf);
static void
-aub_buffer_reference(struct pipe_winsys *winsys,
- struct pipe_buffer_handle **ptr,
- struct pipe_buffer_handle *buf)
+aub_buffer_destroy(struct pipe_winsys *winsys,
+ struct pipe_buffer *buf)
{
- if (*ptr) {
- assert(aub_bo(*ptr)->refcount != 0);
- if (--(aub_bo(*ptr)->refcount) == 0)
- free(*ptr);
- *ptr = NULL;
- }
-
- if (buf) {
- aub_bo(buf)->refcount++;
- *ptr = buf;
- }
+ free(buf);
}
void xmesa_buffer_subdata_aub(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned long offset,
unsigned long size,
const void *data,
/* Pipe has no concept of pools. We choose the tex/region pool
* for all buffers.
*/
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
aub_buffer_create(struct pipe_winsys *winsys,
unsigned alignment,
unsigned usage,
}
-static struct pipe_buffer_handle *
+static struct pipe_buffer *
aub_user_buffer_create(struct pipe_winsys *winsys, void *ptr, unsigned bytes)
{
struct aub_buffer *sbo;
surf->refcount--;
if (surf->refcount == 0) {
if (surf->buffer)
- winsys->buffer_reference(winsys, &surf->buffer, NULL);
+ pipe_buffer_reference(winsys, &surf->buffer, NULL);
free(surf);
}
*s = NULL;
iws->winsys.user_buffer_create = aub_user_buffer_create;
iws->winsys.buffer_map = aub_buffer_map;
iws->winsys.buffer_unmap = aub_buffer_unmap;
- iws->winsys.buffer_reference = aub_buffer_reference;
+ iws->winsys.buffer_destroy = aub_buffer_destroy;
iws->winsys.flush_frontbuffer = aub_flush_frontbuffer;
iws->winsys.printf = aub_printf;
iws->winsys.get_name = aub_get_name;
}
static void aub_i965_batch_reloc( struct brw_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned access_flags,
unsigned delta )
{
}
static unsigned aub_i965_get_buffer_offset( struct brw_winsys *sws,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned access_flags )
{
return aub_bo(buf)->offset;
static void aub_i965_buffer_subdata_typed(struct brw_winsys *winsys,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned long offset,
unsigned long size,
const void *data,
struct pipe_context;
struct pipe_winsys;
-struct pipe_buffer_handle;
+struct pipe_buffer;
struct pipe_surface;
struct pipe_winsys *
void xmesa_buffer_subdata_aub(struct pipe_winsys *winsys,
- struct pipe_buffer_handle *buf,
+ struct pipe_buffer *buf,
unsigned long offset,
unsigned long size,
const void *data,
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
+#include "pipe/p_inlines.h"
#include "st_context.h"
#include "st_atom.h"
_mesa_load_state_parameters(st->ctx, params);
if (cbuf->buffer && cbuf->size != paramBytes)
- ws->buffer_reference( ws, &cbuf->buffer, NULL );
+ pipe_buffer_reference( ws, &cbuf->buffer, NULL );
if (!cbuf->buffer) {
cbuf->buffer = ws->buffer_create(ws, 1, PIPE_BUFFER_USAGE_CONSTANT,
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
+#include "pipe/p_inlines.h"
struct st_buffer_object *st_obj = st_buffer_object(obj);
if (st_obj->buffer)
- pipe->winsys->buffer_reference(pipe->winsys, &st_obj->buffer, NULL);
+ pipe_buffer_reference(pipe->winsys, &st_obj->buffer, NULL);
free(st_obj);
}
buffer_usage = 0;
}
- pipe->winsys->buffer_reference( pipe->winsys, &st_obj->buffer, NULL );
+ pipe_buffer_reference( pipe->winsys, &st_obj->buffer, NULL );
st_obj->buffer = pipe->winsys->buffer_create( pipe->winsys, 32, buffer_usage,
size );
struct st_context;
struct gl_buffer_object;
-struct pipe_buffer_handle;
+struct pipe_buffer;
/**
* State_tracker vertex/pixel buffer object, derived from Mesa's
struct st_buffer_object
{
struct gl_buffer_object Base;
- struct pipe_buffer_handle *buffer;
+ struct pipe_buffer *buffer;
GLsizeiptrARB size;
};
}
if (strb->surface->buffer)
- pipe->winsys->buffer_reference(pipe->winsys, &strb->surface->buffer,
- NULL);
+ pipe_buffer_reference(pipe->winsys, &strb->surface->buffer,
+ NULL);
/* Determine surface format here */
if (strb->format != PIPE_FORMAT_NONE) {
#include "st_program.h"
#include "pipe/p_context.h"
#include "pipe/p_winsys.h"
+#include "pipe/p_inlines.h"
#include "pipe/draw/draw_context.h"
#include "pipe/cso_cache/cso_cache.h"
for (i = 0; i < Elements(st->state.constants); i++) {
if (st->state.constants[i].buffer) {
- ws->buffer_reference(ws, &st->state.constants[i].buffer, NULL);
+ pipe_buffer_reference(ws, &st->state.constants[i].buffer, NULL);
}
}
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
+#include "pipe/p_inlines.h"
#include "pipe/draw/draw_private.h"
#include "pipe/draw/draw_context.h"
assert(stobj->buffer);
vbuffer[attr].buffer = NULL;
- winsys->buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
+ pipe_buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
vbuffer[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
velement.src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
assert(velement.src_offset <= 2048); /* 11-bit field */
if (ib) {
/* indexed primitive */
struct gl_buffer_object *bufobj = ib->obj;
- struct pipe_buffer_handle *indexBuf = NULL;
+ struct pipe_buffer *indexBuf = NULL;
unsigned indexSize, indexOffset, i;
switch (ib->type) {
if (bufobj && bufobj->Name) {
/* elements/indexes are in a real VBO */
struct st_buffer_object *stobj = st_buffer_object(bufobj);
- winsys->buffer_reference(winsys, &indexBuf, stobj->buffer);
+ pipe_buffer_reference(winsys, &indexBuf, stobj->buffer);
indexOffset = (unsigned) ib->ptr / indexSize;
}
else {
prims[i].start + indexOffset, prims[i].count);
}
- winsys->buffer_reference(winsys, &indexBuf, NULL);
+ pipe_buffer_reference(winsys, &indexBuf, NULL);
}
else {
/* non-indexed */
/* unreference buffers (frees wrapped user-space buffer objects) */
for (attr = 0; attr < vs->num_inputs; attr++) {
- winsys->buffer_reference(winsys, &vbuffer[attr].buffer, NULL);
+ pipe_buffer_reference(winsys, &vbuffer[attr].buffer, NULL);
assert(!vbuffer[attr].buffer);
pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]);
}
const float height = ctx->DrawBuffer->Height;
const unsigned vertex_bytes = numVertex * numAttribs * 4 * sizeof(float);
struct pipe_context *pipe = ctx->st->pipe;
- struct pipe_buffer_handle *vbuf;
+ struct pipe_buffer *vbuf;
struct pipe_vertex_buffer vbuffer;
struct pipe_vertex_element velement;
unsigned i;
pipe->draw_arrays(pipe, prim, 0, numVertex);
/* XXX: do one-time */
- pipe->winsys->buffer_reference(pipe->winsys, &vbuf, NULL);
+ pipe_buffer_reference(pipe->winsys, &vbuf, NULL);
}
struct pipe_winsys *winsys = pipe->winsys;
const struct st_vertex_program *vp;
const struct pipe_shader_state *vs;
- struct pipe_buffer_handle *index_buffer_handle = 0;
+ struct pipe_buffer *index_buffer_handle = 0;
struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
GLuint attr, i;
ubyte *mapped_constants;
assert(stobj->buffer);
vbuffer[attr].buffer = NULL;
- winsys->buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
+ pipe_buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
vbuffer[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
velement.src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
}
if (draw->vertex_buffer[i].buffer) {
pipe->winsys->buffer_unmap(pipe->winsys,
draw->vertex_buffer[i].buffer);
- winsys->buffer_reference(winsys, &draw->vertex_buffer[i].buffer, NULL);
+ pipe_buffer_reference(winsys, &draw->vertex_buffer[i].buffer, NULL);
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
}
projects / mesa.git / commitdiff