src/mesa/state_tracker/st_cb_bufferobjects.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 /**
  30  * Functions for pixel buffer objects and vertex/element buffer objects.
  31  */
  32
  33
  34 #include "main/imports.h"
  35 #include "main/mtypes.h"
  36 #include "main/arrayobj.h"
  37 #include "main/bufferobj.h"
  38
  39 #include "st_inlines.h"
  40 #include "st_context.h"
  41 #include "st_cb_bufferobjects.h"
  42
  43 #include "pipe/p_context.h"
  44 #include "pipe/p_defines.h"
  45 #include "pipe/p_inlines.h"
  46
  47
  48 /**
  49  * There is some duplication between mesa's bufferobjects and our
  50  * bufmgr buffers.  Both have an integer handle and a hashtable to
  51  * lookup an opaque structure.  It would be nice if the handles and
  52  * internal structure where somehow shared.
  53  */
  54 static struct gl_buffer_object *
  55 st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target)
  56 {
  57    struct st_buffer_object *st_obj = ST_CALLOC_STRUCT(st_buffer_object);
  58
  59    if (!st_obj)
  60       return NULL;
  61
  62    _mesa_initialize_buffer_object(&st_obj->Base, name, target);
  63
  64    return &st_obj->Base;
  65 }
  66
  67
  68
  69 /**
  70  * Deallocate/free a vertex/pixel buffer object.
  71  * Called via glDeleteBuffersARB().
  72  */
  73 static void
  74 st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj)
  75 {
  76    struct st_buffer_object *st_obj = st_buffer_object(obj);
  77
  78    if (st_obj->buffer)
  79       pipe_buffer_reference(&st_obj->buffer, NULL);
  80
  81    _mesa_free(st_obj);
  82 }
  83
  84
  85
  86 /**
  87  * Replace data in a subrange of buffer object.  If the data range
  88  * specified by size + offset extends beyond the end of the buffer or
  89  * if data is NULL, no copy is performed.
  90  * Called via glBufferSubDataARB().
  91  */
  92 static void
  93 st_bufferobj_subdata(GLcontext *ctx,
  94                      GLenum target,
  95                      GLintptrARB offset,
  96                      GLsizeiptrARB size,
  97                      const GLvoid * data, struct gl_buffer_object *obj)
  98 {
  99    struct st_buffer_object *st_obj = st_buffer_object(obj);
 100
 101    /* we may be called from VBO code, so double-check params here */
 102    ASSERT(offset >= 0);
 103    ASSERT(size >= 0);
 104    ASSERT(offset + size <= obj->Size);
 105
 106    if (!size)
 107       return;
 108
 109    /*
 110     * According to ARB_vertex_buffer_object specification, if data is null,
 111     * then the contents of the buffer object's data store is undefined. We just
 112     * ignore, and leave it unchanged.
 113     */
 114    if (!data)
 115       return;
 116
 117    st_cond_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer,
 118                                    offset, size, data);
 119 }
 120
 121
 122 /**
 123  * Called via glGetBufferSubDataARB().
 124  */
 125 static void
 126 st_bufferobj_get_subdata(GLcontext *ctx,
 127                          GLenum target,
 128                          GLintptrARB offset,
 129                          GLsizeiptrARB size,
 130                          GLvoid * data, struct gl_buffer_object *obj)
 131 {
 132    struct st_buffer_object *st_obj = st_buffer_object(obj);
 133
 134    /* we may be called from VBO code, so double-check params here */
 135    ASSERT(offset >= 0);
 136    ASSERT(size >= 0);
 137    ASSERT(offset + size <= obj->Size);
 138
 139    if (!size)
 140       return;
 141
 142    st_cond_flush_pipe_buffer_read(st_context(ctx), st_obj->buffer,
 143                                   offset, size, data);
 144 }
 145
 146
 147 /**
 148  * Allocate space for and store data in a buffer object.  Any data that was
 149  * previously stored in the buffer object is lost.  If data is NULL,
 150  * memory will be allocated, but no copy will occur.
 151  * Called via ctx->Driver.BufferData().
 152  * \return GL_TRUE for success, GL_FALSE if out of memory
 153  */
 154 static GLboolean
 155 st_bufferobj_data(GLcontext *ctx,
 156                   GLenum target,
 157                   GLsizeiptrARB size,
 158                   const GLvoid * data,
 159                   GLenum usage,
 160                   struct gl_buffer_object *obj)
 161 {
 162    struct st_context *st = st_context(ctx);
 163    struct pipe_context *pipe = st->pipe;
 164    struct st_buffer_object *st_obj = st_buffer_object(obj);
 165    unsigned buffer_usage;
 166
 167    st_obj->Base.Size = size;
 168    st_obj->Base.Usage = usage;
 169
 170    switch(target) {
 171    case GL_PIXEL_PACK_BUFFER_ARB:
 172    case GL_PIXEL_UNPACK_BUFFER_ARB:
 173       buffer_usage = PIPE_BUFFER_USAGE_PIXEL;
 174       break;
 175    case GL_ARRAY_BUFFER_ARB:
 176       buffer_usage = PIPE_BUFFER_USAGE_VERTEX;
 177       break;
 178    case GL_ELEMENT_ARRAY_BUFFER_ARB:
 179       buffer_usage = PIPE_BUFFER_USAGE_INDEX;
 180       break;
 181    default:
 182       buffer_usage = 0;
 183    }
 184
 185    pipe_buffer_reference( &st_obj->buffer, NULL );
 186
 187    if (size != 0) {
 188       st_obj->buffer = pipe_buffer_create(pipe->screen, 32, buffer_usage, size);
 189
 190       if (!st_obj->buffer) {
 191          return GL_FALSE;
 192       }
 193
 194       if (data)
 195          st_no_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, 0,
 196                                        size, data);
 197       return GL_TRUE;
 198    }
 199
 200    return GL_TRUE;
 201 }
 202
 203
 204 /**
 205  * Called via glMapBufferARB().
 206  */
 207 static void *
 208 st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,
 209                  struct gl_buffer_object *obj)
 210 {
 211    struct st_buffer_object *st_obj = st_buffer_object(obj);
 212    uint flags;
 213
 214    switch (access) {
 215    case GL_WRITE_ONLY:
 216       flags = PIPE_BUFFER_USAGE_CPU_WRITE;
 217       break;
 218    case GL_READ_ONLY:
 219       flags = PIPE_BUFFER_USAGE_CPU_READ;
 220       break;
 221    case GL_READ_WRITE:
 222       /* fall-through */
 223    default:
 224       flags = PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE;
 225       break;
 226    }
 227
 228    obj->Pointer = st_cond_flush_pipe_buffer_map(st_context(ctx),
 229                                                 st_obj->buffer,
 230                                                 flags);
 231    if (obj->Pointer) {
 232       obj->Offset = 0;
 233       obj->Length = obj->Size;
 234    }
 235    return obj->Pointer;
 236 }
 237
 238
 239 /**
 240  * Dummy data whose's pointer is used for zero length ranges.
 241  */
 242 static long
 243 st_bufferobj_zero_length_range = 0;
 244
 245
 246 /**
 247  * Called via glMapBufferRange().
 248  */
 249 static void *
 250 st_bufferobj_map_range(GLcontext *ctx, GLenum target,
 251                        GLintptr offset, GLsizeiptr length, GLbitfield access,
 252                        struct gl_buffer_object *obj)
 253 {
 254    struct pipe_context *pipe = st_context(ctx)->pipe;
 255    struct st_buffer_object *st_obj = st_buffer_object(obj);
 256    uint flags = 0x0;
 257
 258    if (access & GL_MAP_WRITE_BIT)
 259       flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
 260
 261    if (access & GL_MAP_READ_BIT)
 262       flags |= PIPE_BUFFER_USAGE_CPU_READ;
 263
 264    if (access & GL_MAP_FLUSH_EXPLICIT_BIT)
 265       flags |= PIPE_BUFFER_USAGE_FLUSH_EXPLICIT;
 266
 267    if (access & GL_MAP_UNSYNCHRONIZED_BIT)
 268       flags |= PIPE_BUFFER_USAGE_UNSYNCHRONIZED;
 269
 270    /* ... other flags ...
 271     */
 272
 273    if (access & MESA_MAP_NOWAIT_BIT)
 274       flags |= PIPE_BUFFER_USAGE_DONTBLOCK;
 275
 276    assert(offset >= 0);
 277    assert(length >= 0);
 278    assert(offset < obj->Size);
 279    assert(offset + length <= obj->Size);
 280
 281    /*
 282     * We go out of way here to hide the degenerate yet valid case of zero
 283     * length range from the pipe driver.
 284     */
 285    if (!length) {
 286       obj->Pointer = &st_bufferobj_zero_length_range;
 287    }
 288    else {
 289       obj->Pointer = pipe_buffer_map_range(pipe->screen, st_obj->buffer, offset, length, flags);
 290       if (obj->Pointer) {
 291          obj->Pointer = (ubyte *) obj->Pointer + offset;
 292       }
 293    }
 294
 295    if (obj->Pointer) {
 296       obj->Offset = offset;
 297       obj->Length = length;
 298       obj->AccessFlags = access;
 299    }
 300
 301    return obj->Pointer;
 302 }
 303
 304
 305 static void
 306 st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target,
 307                                 GLintptr offset, GLsizeiptr length,
 308                                 struct gl_buffer_object *obj)
 309 {
 310    struct pipe_context *pipe = st_context(ctx)->pipe;
 311    struct st_buffer_object *st_obj = st_buffer_object(obj);
 312
 313    /* Subrange is relative to mapped range */
 314    assert(offset >= 0);
 315    assert(length >= 0);
 316    assert(offset + length <= obj->Length);
 317
 318    if (!length)
 319       return;
 320
 321    pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer,
 322                                   obj->Offset + offset, length);
 323 }
 324
 325
 326 /**
 327  * Called via glUnmapBufferARB().
 328  */
 329 static GLboolean
 330 st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj)
 331 {
 332    struct pipe_context *pipe = st_context(ctx)->pipe;
 333    struct st_buffer_object *st_obj = st_buffer_object(obj);
 334
 335    if(obj->Length)
 336       pipe_buffer_unmap(pipe->screen, st_obj->buffer);
 337
 338    obj->Pointer = NULL;
 339    obj->Offset = 0;
 340    obj->Length = 0;
 341    return GL_TRUE;
 342 }
 343
 344
 345 /**
 346  * Called via glCopyBufferSubData().
 347  */
 348 static void
 349 st_copy_buffer_subdata(GLcontext *ctx,
 350                        struct gl_buffer_object *src,
 351                        struct gl_buffer_object *dst,
 352                        GLintptr readOffset, GLintptr writeOffset,
 353                        GLsizeiptr size)
 354 {
 355    struct pipe_context *pipe = st_context(ctx)->pipe;
 356    struct st_buffer_object *srcObj = st_buffer_object(src);
 357    struct st_buffer_object *dstObj = st_buffer_object(dst);
 358    ubyte *srcPtr, *dstPtr;
 359
 360    if(!size)
 361       return;
 362
 363    /* buffer should not already be mapped */
 364    assert(!src->Pointer);
 365    assert(!dst->Pointer);
 366
 367    srcPtr = (ubyte *) pipe_buffer_map_range(pipe->screen,
 368                                             srcObj->buffer,
 369                                             readOffset, size,
 370                                             PIPE_BUFFER_USAGE_CPU_READ);
 371
 372    dstPtr = (ubyte *) pipe_buffer_map_range(pipe->screen,
 373                                             dstObj->buffer,
 374                                             writeOffset, size,
 375                                             PIPE_BUFFER_USAGE_CPU_WRITE);
 376
 377    if (srcPtr && dstPtr)
 378       _mesa_memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
 379
 380    pipe_buffer_unmap(pipe->screen, srcObj->buffer);
 381    pipe_buffer_unmap(pipe->screen, dstObj->buffer);
 382 }
 383
 384
 385 void
 386 st_init_bufferobject_functions(struct dd_function_table *functions)
 387 {
 388    functions->NewBufferObject = st_bufferobj_alloc;
 389    functions->DeleteBuffer = st_bufferobj_free;
 390    functions->BufferData = st_bufferobj_data;
 391    functions->BufferSubData = st_bufferobj_subdata;
 392    functions->GetBufferSubData = st_bufferobj_get_subdata;
 393    functions->MapBuffer = st_bufferobj_map;
 394    functions->MapBufferRange = st_bufferobj_map_range;
 395    functions->FlushMappedBufferRange = st_bufferobj_flush_mapped_range;
 396    functions->UnmapBuffer = st_bufferobj_unmap;
 397    functions->CopyBufferSubData = st_copy_buffer_subdata;
 398
 399    /* For GL_APPLE_vertex_array_object */
 400    functions->NewArrayObject = _mesa_new_array_object;
 401    functions->DeleteArrayObject = _mesa_delete_array_object;
 402 }