#include "glheader.h"
#include "hash.h"
#include "imports.h"
#include "image.h"
#include "context.h"
#include "bufferobj.h"
static INLINE struct gl_buffer_object *
get_buffer(GLcontext *ctx, GLenum target)
{
struct gl_buffer_object * bufObj = NULL;
switch (target) {
case GL_ARRAY_BUFFER_ARB:
bufObj = ctx->Array.ArrayBufferObj;
break;
case GL_ELEMENT_ARRAY_BUFFER_ARB:
bufObj = ctx->Array.ElementArrayBufferObj;
break;
case GL_PIXEL_PACK_BUFFER_EXT:
bufObj = ctx->Pack.BufferObj;
break;
case GL_PIXEL_UNPACK_BUFFER_EXT:
bufObj = ctx->Unpack.BufferObj;
break;
default:
return NULL;
}
ASSERT(bufObj);
return bufObj;
}
static struct gl_buffer_object *
buffer_object_subdata_range_good( GLcontext * ctx, GLenum target,
GLintptrARB offset, GLsizeiptrARB size,
const char *caller )
{
struct gl_buffer_object *bufObj;
if (size < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", caller);
return NULL;
}
if (offset < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(offset < 0)", caller);
return NULL;
}
bufObj = get_buffer(ctx, target);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller);
return NULL;
}
if (bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
return NULL;
}
if (offset + size > bufObj->Size) {
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(size + offset > buffer size)", caller);
return NULL;
}
if (bufObj->Pointer) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
return NULL;
}
return bufObj;
}
struct gl_buffer_object *
_mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target )
{
struct gl_buffer_object *obj;
(void) ctx;
obj = MALLOC_STRUCT(gl_buffer_object);
_mesa_initialize_buffer_object(obj, name, target);
return obj;
}
void
_mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
{
(void) ctx;
if (bufObj->Data)
_mesa_free(bufObj->Data);
_mesa_free(bufObj);
}
void
_mesa_unbind_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
{
if (bufObj != ctx->Array.NullBufferObj) {
bufObj->RefCount--;
if (bufObj->RefCount <= 0) {
ASSERT(ctx->Array.ArrayBufferObj != bufObj);
ASSERT(ctx->Array.ElementArrayBufferObj != bufObj);
ASSERT(ctx->Array.ArrayObj->Vertex.BufferObj != bufObj);
ASSERT(ctx->Driver.DeleteBuffer);
ctx->Driver.DeleteBuffer(ctx, bufObj);
}
}
}
void
_mesa_initialize_buffer_object( struct gl_buffer_object *obj,
GLuint name, GLenum target )
{
(void) target;
_mesa_bzero(obj, sizeof(struct gl_buffer_object));
obj->RefCount = 1;
obj->Name = name;
obj->Usage = GL_STATIC_DRAW_ARB;
obj->Access = GL_READ_WRITE_ARB;
}
void
_mesa_save_buffer_object( GLcontext *ctx, struct gl_buffer_object *obj )
{
if (obj->Name > 0) {
_mesa_HashInsert(ctx->Shared->BufferObjects, obj->Name, obj);
}
}
void
_mesa_remove_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
{
if (bufObj->Name > 0) {
_mesa_HashRemove(ctx->Shared->BufferObjects, bufObj->Name);
}
}
void
_mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
const GLvoid * data, GLenum usage,
struct gl_buffer_object * bufObj )
{
void * new_data;
(void) ctx; (void) target;
new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );
if (new_data) {
bufObj->Data = (GLubyte *) new_data;
bufObj->Size = size;
bufObj->Usage = usage;
if (data) {
_mesa_memcpy( bufObj->Data, data, size );
}
}
}
void
_mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
GLsizeiptrARB size, const GLvoid * data,
struct gl_buffer_object * bufObj )
{
(void) ctx; (void) target;
ASSERT(size + offset <= bufObj->Size);
if (bufObj->Data) {
_mesa_memcpy( (GLubyte *) bufObj->Data + offset, data, size );
}
}
void
_mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
GLsizeiptrARB size, GLvoid * data,
struct gl_buffer_object * bufObj )
{
(void) ctx; (void) target;
if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {
_mesa_memcpy( data, (GLubyte *) bufObj->Data + offset, size );
}
}
void *
_mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access,
struct gl_buffer_object *bufObj )
{
(void) ctx;
(void) target;
(void) access;
ASSERT(!bufObj->OnCard);
if (bufObj->Pointer) {
return NULL;
}
bufObj->Pointer = bufObj->Data;
return bufObj->Pointer;
}
GLboolean
_mesa_buffer_unmap( GLcontext *ctx, GLenum target,
struct gl_buffer_object *bufObj )
{
(void) ctx;
(void) target;
ASSERT(!bufObj->OnCard);
bufObj->Pointer = NULL;
return GL_TRUE;
}
void
_mesa_init_buffer_objects( GLcontext *ctx )
{
ctx->Array.NullBufferObj = _mesa_new_buffer_object(ctx, 0, 0);
if (ctx->Array.NullBufferObj)
ctx->Array.NullBufferObj->RefCount = 1000;
ctx->Array.ArrayBufferObj = ctx->Array.NullBufferObj;
ctx->Array.ElementArrayBufferObj = ctx->Array.NullBufferObj;
}
GLboolean
_mesa_validate_pbo_access(GLuint dimensions,
const struct gl_pixelstore_attrib *pack,
GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLenum type, const GLvoid *ptr)
{
GLvoid *start, *end;
const GLubyte *sizeAddr;
ASSERT(pack->BufferObj->Name != 0);
if (pack->BufferObj->Size == 0)
return GL_FALSE;
start = _mesa_image_address(dimensions, pack, ptr, width, height,
format, type, 0, 0, 0);
end = _mesa_image_address(dimensions, pack, ptr, width, height,
format, type, depth-1, height-1, width);
sizeAddr = ((const GLubyte *) 0) + pack->BufferObj->Size;
if ((const GLubyte *) start > sizeAddr) {
return GL_FALSE;
}
if ((const GLubyte *) end > sizeAddr) {
return GL_FALSE;
}
return GL_TRUE;
}
struct gl_buffer_object *
_mesa_lookup_bufferobj(GLcontext *ctx, GLuint buffer)
{
if (buffer == 0)
return NULL;
else
return (struct gl_buffer_object *)
_mesa_HashLookup(ctx->Shared->BufferObjects, buffer);
}
void GLAPIENTRY
_mesa_BindBufferARB(GLenum target, GLuint buffer)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *oldBufObj;
struct gl_buffer_object *newBufObj = NULL;
struct gl_buffer_object **bindTarget = NULL;
ASSERT_OUTSIDE_BEGIN_END(ctx);
switch (target) {
case GL_ARRAY_BUFFER_ARB:
bindTarget = &ctx->Array.ArrayBufferObj;
break;
case GL_ELEMENT_ARRAY_BUFFER_ARB:
bindTarget = &ctx->Array.ElementArrayBufferObj;
break;
case GL_PIXEL_PACK_BUFFER_EXT:
bindTarget = &ctx->Pack.BufferObj;
break;
case GL_PIXEL_UNPACK_BUFFER_EXT:
bindTarget = &ctx->Unpack.BufferObj;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target)");
return;
}
oldBufObj = get_buffer(ctx, target);
if (oldBufObj && oldBufObj->Name == buffer)
return;
if (buffer == 0) {
newBufObj = ctx->Array.NullBufferObj;
}
else {
newBufObj = _mesa_lookup_bufferobj(ctx, buffer);
if (!newBufObj) {
ASSERT(ctx->Driver.NewBufferObject);
newBufObj = ctx->Driver.NewBufferObject(ctx, buffer, target);
if (!newBufObj) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");
return;
}
_mesa_save_buffer_object(ctx, newBufObj);
}
}
*bindTarget = newBufObj;
newBufObj->RefCount++;
if (ctx->Driver.BindBuffer && newBufObj)
ctx->Driver.BindBuffer( ctx, target, newBufObj );
if (oldBufObj) {
oldBufObj->RefCount--;
assert(oldBufObj->RefCount >= 0);
if (oldBufObj->RefCount == 0) {
assert(oldBufObj->Name != 0);
ASSERT(ctx->Driver.DeleteBuffer);
ctx->Driver.DeleteBuffer( ctx, oldBufObj );
}
}
}
void GLAPIENTRY
_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
{
GET_CURRENT_CONTEXT(ctx);
GLsizei i;
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (n < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glDeleteBuffersARB(n)");
return;
}
_glthread_LOCK_MUTEX(ctx->Shared->Mutex);
for (i = 0; i < n; i++) {
struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);
if (bufObj) {
GLuint j;
ASSERT(bufObj->Name == ids[i]);
if (ctx->Array.ArrayObj->Vertex.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->Vertex.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
if (ctx->Array.ArrayObj->Normal.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->Normal.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
if (ctx->Array.ArrayObj->Color.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->Color.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
if (ctx->Array.ArrayObj->SecondaryColor.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->SecondaryColor.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
if (ctx->Array.ArrayObj->FogCoord.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->FogCoord.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
if (ctx->Array.ArrayObj->Index.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->Index.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
if (ctx->Array.ArrayObj->EdgeFlag.BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->EdgeFlag.BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
for (j = 0; j < MAX_TEXTURE_UNITS; j++) {
if (ctx->Array.ArrayObj->TexCoord[j].BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->TexCoord[j].BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
}
for (j = 0; j < VERT_ATTRIB_MAX; j++) {
if (ctx->Array.ArrayObj->VertexAttrib[j].BufferObj == bufObj) {
bufObj->RefCount--;
ctx->Array.ArrayObj->VertexAttrib[j].BufferObj = ctx->Array.NullBufferObj;
ctx->Array.NullBufferObj->RefCount++;
}
}
if (ctx->Array.ArrayBufferObj == bufObj) {
_mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
}
if (ctx->Array.ElementArrayBufferObj == bufObj) {
_mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
}
if (ctx->Pack.BufferObj == bufObj) {
_mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );
}
if (ctx->Unpack.BufferObj == bufObj) {
_mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );
}
_mesa_remove_buffer_object(ctx, bufObj);
_mesa_unbind_buffer_object(ctx, bufObj);
}
}
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
}
void GLAPIENTRY
_mesa_GenBuffersARB(GLsizei n, GLuint *buffer)
{
GET_CURRENT_CONTEXT(ctx);
GLuint first;
GLint i;
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (n < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB");
return;
}
if (!buffer) {
return;
}
_glthread_LOCK_MUTEX(ctx->Shared->Mutex);
first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);
for (i = 0; i < n; i++) {
struct gl_buffer_object *bufObj;
GLuint name = first + i;
GLenum target = 0;
bufObj = ctx->Driver.NewBufferObject( ctx, name, target );
if (!bufObj) {
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenBuffersARB");
return;
}
_mesa_save_buffer_object(ctx, bufObj);
buffer[i] = first + i;
}
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
}
GLboolean GLAPIENTRY
_mesa_IsBufferARB(GLuint id)
{
struct gl_buffer_object *bufObj;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
_glthread_LOCK_MUTEX(ctx->Shared->Mutex);
bufObj = _mesa_lookup_bufferobj(ctx, id);
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
return bufObj ? GL_TRUE : GL_FALSE;
}
void GLAPIENTRY
_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
const GLvoid * data, GLenum usage)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (size < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glBufferDataARB(size < 0)");
return;
}
switch (usage) {
case GL_STREAM_DRAW_ARB:
case GL_STREAM_READ_ARB:
case GL_STREAM_COPY_ARB:
case GL_STATIC_DRAW_ARB:
case GL_STATIC_READ_ARB:
case GL_STATIC_COPY_ARB:
case GL_DYNAMIC_DRAW_ARB:
case GL_DYNAMIC_READ_ARB:
case GL_DYNAMIC_COPY_ARB:
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)");
return;
}
bufObj = get_buffer(ctx, target);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" );
return;
}
if (bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB" );
return;
}
if (bufObj->Pointer) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer is mapped)" );
return;
}
ASSERT(ctx->Driver.BufferData);
ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj );
}
void GLAPIENTRY
_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,
GLsizeiptrARB size, const GLvoid * data)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
ASSERT_OUTSIDE_BEGIN_END(ctx);
bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
"glBufferSubDataARB" );
if (!bufObj) {
return;
}
ASSERT(ctx->Driver.BufferSubData);
ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj );
}
void GLAPIENTRY
_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset,
GLsizeiptrARB size, void * data)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
ASSERT_OUTSIDE_BEGIN_END(ctx);
bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
"glGetBufferSubDataARB" );
if (!bufObj) {
return;
}
ASSERT(ctx->Driver.GetBufferSubData);
ctx->Driver.GetBufferSubData( ctx, target, offset, size, data, bufObj );
}
void * GLAPIENTRY
_mesa_MapBufferARB(GLenum target, GLenum access)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object * bufObj;
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
switch (access) {
case GL_READ_ONLY_ARB:
case GL_WRITE_ONLY_ARB:
case GL_READ_WRITE_ARB:
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)");
return NULL;
}
bufObj = get_buffer(ctx, target);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" );
return NULL;
}
if (bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB" );
return NULL;
}
if (bufObj->Pointer) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");
return NULL;
}
ASSERT(ctx->Driver.MapBuffer);
bufObj->Pointer = ctx->Driver.MapBuffer( ctx, target, access, bufObj );
if (!bufObj->Pointer) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)");
}
bufObj->Access = access;
return bufObj->Pointer;
}
GLboolean GLAPIENTRY
_mesa_UnmapBufferARB(GLenum target)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
GLboolean status = GL_TRUE;
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
bufObj = get_buffer(ctx, target);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" );
return GL_FALSE;
}
if (bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );
return GL_FALSE;
}
if (!bufObj->Pointer) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");
return GL_FALSE;
}
if (ctx->Driver.UnmapBuffer) {
status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );
}
bufObj->Access = GL_READ_WRITE_ARB;
bufObj->Pointer = NULL;
return status;
}
void GLAPIENTRY
_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
ASSERT_OUTSIDE_BEGIN_END(ctx);
bufObj = get_buffer(ctx, target);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_ENUM, "GetBufferParameterivARB(target)" );
return;
}
if (bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "GetBufferParameterivARB" );
return;
}
switch (pname) {
case GL_BUFFER_SIZE_ARB:
*params = (GLint) bufObj->Size;
break;
case GL_BUFFER_USAGE_ARB:
*params = bufObj->Usage;
break;
case GL_BUFFER_ACCESS_ARB:
*params = bufObj->Access;
break;
case GL_BUFFER_MAPPED_ARB:
*params = (bufObj->Pointer != NULL);
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname)");
return;
}
}
void GLAPIENTRY
_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object * bufObj;
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (pname != GL_BUFFER_MAP_POINTER_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(pname)");
return;
}
bufObj = get_buffer(ctx, target);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" );
return;
}
if (bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );
return;
}
*params = bufObj->Pointer;
}