X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_bufferobjects.c;h=7374bb0acc5ae68dbdf50e6cc7cef2bf4f5ce6c2;hb=8b881ad1c3d9dd3c96afbdbb608a7240d40e9c92;hp=8e09d0b9324152ebb196665c949e314d10d48adc;hpb=890679d4322e7ba4f12f32532a3fdd277edff886;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.c b/src/mesa/state_tracker/st_cb_bufferobjects.c index 8e09d0b9324..7374bb0acc5 100644 --- a/src/mesa/state_tracker/st_cb_bufferobjects.c +++ b/src/mesa/state_tracker/st_cb_bufferobjects.c @@ -36,13 +36,12 @@ #include "main/arrayobj.h" #include "main/bufferobj.h" -#include "st_inlines.h" #include "st_context.h" #include "st_cb_bufferobjects.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" -#include "pipe/p_inlines.h" +#include "util/u_inlines.h" /** @@ -52,7 +51,7 @@ * internal structure where somehow shared. */ static struct gl_buffer_object * -st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target) +st_bufferobj_alloc(struct gl_context *ctx, GLuint name, GLenum target) { struct st_buffer_object *st_obj = ST_CALLOC_STRUCT(st_buffer_object); @@ -71,14 +70,17 @@ st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target) * Called via glDeleteBuffersARB(). */ static void -st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj) +st_bufferobj_free(struct gl_context *ctx, struct gl_buffer_object *obj) { struct st_buffer_object *st_obj = st_buffer_object(obj); + assert(obj->RefCount == 0); + assert(st_obj->transfer == NULL); + if (st_obj->buffer) - pipe_buffer_reference(&st_obj->buffer, NULL); + pipe_resource_reference(&st_obj->buffer, NULL); - _mesa_free(st_obj); + free(st_obj); } @@ -90,7 +92,7 @@ st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj) * Called via glBufferSubDataARB(). */ static void -st_bufferobj_subdata(GLcontext *ctx, +st_bufferobj_subdata(struct gl_context *ctx, GLenum target, GLintptrARB offset, GLsizeiptrARB size, @@ -103,8 +105,26 @@ st_bufferobj_subdata(GLcontext *ctx, ASSERT(size >= 0); ASSERT(offset + size <= obj->Size); - st_cond_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, - offset, size, data); + if (!size) + return; + + /* + * According to ARB_vertex_buffer_object specification, if data is null, + * then the contents of the buffer object's data store is undefined. We just + * ignore, and leave it unchanged. + */ + if (!data) + return; + + /* Now that transfers are per-context, we don't have to figure out + * flushing here. Usually drivers won't need to flush in this case + * even if the buffer is currently referenced by hardware - they + * just queue the upload as dma rather than mapping the underlying + * buffer directly. + */ + pipe_buffer_write(st_context(ctx)->pipe, + st_obj->buffer, + offset, size, data); } @@ -112,7 +132,7 @@ st_bufferobj_subdata(GLcontext *ctx, * Called via glGetBufferSubDataARB(). */ static void -st_bufferobj_get_subdata(GLcontext *ctx, +st_bufferobj_get_subdata(struct gl_context *ctx, GLenum target, GLintptrARB offset, GLsizeiptrARB size, @@ -125,8 +145,11 @@ st_bufferobj_get_subdata(GLcontext *ctx, ASSERT(size >= 0); ASSERT(offset + size <= obj->Size); - st_cond_flush_pipe_buffer_read(st_context(ctx), st_obj->buffer, - offset, size, data); + if (!size) + return; + + pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer, + offset, size, data); } @@ -138,7 +161,7 @@ st_bufferobj_get_subdata(GLcontext *ctx, * \return GL_TRUE for success, GL_FALSE if out of memory */ static GLboolean -st_bufferobj_data(GLcontext *ctx, +st_bufferobj_data(struct gl_context *ctx, GLenum target, GLsizeiptrARB size, const GLvoid * data, @@ -148,7 +171,7 @@ st_bufferobj_data(GLcontext *ctx, struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); - unsigned buffer_usage; + unsigned bind, pipe_usage; st_obj->Base.Size = size; st_obj->Base.Usage = usage; @@ -156,38 +179,69 @@ st_bufferobj_data(GLcontext *ctx, switch(target) { case GL_PIXEL_PACK_BUFFER_ARB: case GL_PIXEL_UNPACK_BUFFER_ARB: - buffer_usage = PIPE_BUFFER_USAGE_PIXEL; + bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; break; case GL_ARRAY_BUFFER_ARB: - buffer_usage = PIPE_BUFFER_USAGE_VERTEX; + bind = PIPE_BIND_VERTEX_BUFFER; break; case GL_ELEMENT_ARRAY_BUFFER_ARB: - buffer_usage = PIPE_BUFFER_USAGE_INDEX; + bind = PIPE_BIND_INDEX_BUFFER; break; default: - buffer_usage = 0; + bind = 0; } - pipe_buffer_reference( &st_obj->buffer, NULL ); + switch (usage) { + case GL_STATIC_DRAW: + case GL_STATIC_READ: + case GL_STATIC_COPY: + pipe_usage = PIPE_USAGE_STATIC; + break; + case GL_DYNAMIC_DRAW: + case GL_DYNAMIC_READ: + case GL_DYNAMIC_COPY: + pipe_usage = PIPE_USAGE_DYNAMIC; + break; + case GL_STREAM_DRAW: + case GL_STREAM_READ: + case GL_STREAM_COPY: + pipe_usage = PIPE_USAGE_STREAM; + break; + default: + pipe_usage = PIPE_USAGE_DEFAULT; + } - st_obj->buffer = pipe_buffer_create( pipe->screen, 32, buffer_usage, size ); + pipe_resource_reference( &st_obj->buffer, NULL ); - if (!st_obj->buffer) { - return GL_FALSE; + if (size != 0) { + st_obj->buffer = pipe_buffer_create(pipe->screen, bind, + pipe_usage, size); + + if (!st_obj->buffer) { + return GL_FALSE; + } + + if (data) + pipe_buffer_write(pipe, st_obj->buffer, 0, size, data); + return GL_TRUE; } - if (data) - st_no_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, 0, - size, data); return GL_TRUE; } +/** + * Dummy data whose's pointer is used for zero size buffers or ranges. + */ +static long st_bufferobj_zero_length = 0; + + + /** * Called via glMapBufferARB(). */ static void * -st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access, +st_bufferobj_map(struct gl_context *ctx, GLenum target, GLenum access, struct gl_buffer_object *obj) { struct st_buffer_object *st_obj = st_buffer_object(obj); @@ -195,21 +249,28 @@ st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access, switch (access) { case GL_WRITE_ONLY: - flags = PIPE_BUFFER_USAGE_CPU_WRITE; + flags = PIPE_TRANSFER_WRITE; break; case GL_READ_ONLY: - flags = PIPE_BUFFER_USAGE_CPU_READ; + flags = PIPE_TRANSFER_READ; break; case GL_READ_WRITE: - /* fall-through */ default: - flags = PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE; + flags = PIPE_TRANSFER_READ_WRITE; break; } - obj->Pointer = st_cond_flush_pipe_buffer_map(st_context(ctx), - st_obj->buffer, - flags); + /* Handle zero-size buffers here rather than in drivers */ + if (obj->Size == 0) { + obj->Pointer = &st_bufferobj_zero_length; + } + else { + obj->Pointer = pipe_buffer_map(st_context(ctx)->pipe, + st_obj->buffer, + flags, + &st_obj->transfer); + } + if (obj->Pointer) { obj->Offset = 0; obj->Length = obj->Size; @@ -222,48 +283,77 @@ st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access, * Called via glMapBufferRange(). */ static void * -st_bufferobj_map_range(GLcontext *ctx, GLenum target, +st_bufferobj_map_range(struct gl_context *ctx, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, struct gl_buffer_object *obj) { struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); - uint flags = 0x0; + enum pipe_transfer_usage flags = 0x0; if (access & GL_MAP_WRITE_BIT) - flags |= PIPE_BUFFER_USAGE_CPU_WRITE; + flags |= PIPE_TRANSFER_WRITE; if (access & GL_MAP_READ_BIT) - flags |= PIPE_BUFFER_USAGE_CPU_READ; + flags |= PIPE_TRANSFER_READ; if (access & GL_MAP_FLUSH_EXPLICIT_BIT) - flags |= PIPE_BUFFER_USAGE_FLUSH_EXPLICIT; + flags |= PIPE_TRANSFER_FLUSH_EXPLICIT; + + if (access & GL_MAP_INVALIDATE_BUFFER_BIT) { + flags |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE; + } + else if (access & GL_MAP_INVALIDATE_RANGE_BIT) { + if (offset == 0 && length == obj->Size) + flags |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE; + else + flags |= PIPE_TRANSFER_DISCARD_RANGE; + } + if (access & GL_MAP_UNSYNCHRONIZED_BIT) + flags |= PIPE_TRANSFER_UNSYNCHRONIZED; + /* ... other flags ... */ if (access & MESA_MAP_NOWAIT_BIT) - flags |= PIPE_BUFFER_USAGE_DONTBLOCK; + flags |= PIPE_TRANSFER_DONTBLOCK; assert(offset >= 0); assert(length >= 0); assert(offset < obj->Size); assert(offset + length <= obj->Size); - obj->Pointer = pipe_buffer_map_range(pipe->screen, st_obj->buffer, offset, length, flags); + /* + * We go out of way here to hide the degenerate yet valid case of zero + * length range from the pipe driver. + */ + if (!length) { + obj->Pointer = &st_bufferobj_zero_length; + } + else { + obj->Pointer = pipe_buffer_map_range(pipe, + st_obj->buffer, + offset, length, + flags, + &st_obj->transfer); + if (obj->Pointer) { + obj->Pointer = (ubyte *) obj->Pointer + offset; + } + } + if (obj->Pointer) { - obj->Pointer = (ubyte *) obj->Pointer + offset; obj->Offset = offset; obj->Length = length; obj->AccessFlags = access; } - + return obj->Pointer; } static void -st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, +st_bufferobj_flush_mapped_range(struct gl_context *ctx, GLenum target, GLintptr offset, GLsizeiptr length, struct gl_buffer_object *obj) { @@ -274,8 +364,12 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, assert(offset >= 0); assert(length >= 0); assert(offset + length <= obj->Length); + assert(obj->Pointer); - pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer, + if (!length) + return; + + pipe_buffer_flush_mapped_range(pipe, st_obj->transfer, obj->Offset + offset, length); } @@ -284,12 +378,15 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, * Called via glUnmapBufferARB(). */ static GLboolean -st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj) +st_bufferobj_unmap(struct gl_context *ctx, GLenum target, struct gl_buffer_object *obj) { struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); - pipe_buffer_unmap(pipe->screen, st_obj->buffer); + if (obj->Length) + pipe_buffer_unmap(pipe, st_obj->transfer); + + st_obj->transfer = NULL; obj->Pointer = NULL; obj->Offset = 0; obj->Length = 0; @@ -301,7 +398,7 @@ st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj) * Called via glCopyBufferSubData(). */ static void -st_copy_buffer_subdata(GLcontext *ctx, +st_copy_buffer_subdata(struct gl_context *ctx, struct gl_buffer_object *src, struct gl_buffer_object *dst, GLintptr readOffset, GLintptr writeOffset, @@ -310,27 +407,32 @@ st_copy_buffer_subdata(GLcontext *ctx, struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *srcObj = st_buffer_object(src); struct st_buffer_object *dstObj = st_buffer_object(dst); - ubyte *srcPtr, *dstPtr; + struct pipe_box box; + + if(!size) + return; /* buffer should not already be mapped */ assert(!src->Pointer); assert(!dst->Pointer); - srcPtr = (ubyte *) pipe_buffer_map_range(pipe->screen, - srcObj->buffer, - readOffset, size, - PIPE_BUFFER_USAGE_CPU_READ); + u_box_1d(readOffset, size, &box); - dstPtr = (ubyte *) pipe_buffer_map_range(pipe->screen, - dstObj->buffer, - writeOffset, size, - PIPE_BUFFER_USAGE_CPU_WRITE); + pipe->resource_copy_region(pipe, dstObj->buffer, 0, writeOffset, 0, 0, + srcObj->buffer, 0, &box); +} - if (srcPtr && dstPtr) - _mesa_memcpy(dstPtr + writeOffset, srcPtr + readOffset, size); - pipe_buffer_unmap(pipe->screen, srcObj->buffer); - pipe_buffer_unmap(pipe->screen, dstObj->buffer); +/* TODO: if buffer wasn't created with appropriate usage flags, need + * to recreate it now and copy contents -- or possibly create a + * gallium entrypoint to extend the usage flags and let the driver + * decide if a copy is necessary. + */ +void +st_bufferobj_validate_usage(struct st_context *st, + struct st_buffer_object *obj, + unsigned usage) +{ }