From 5c671fd7f8198bed2fc32b33b81d1081f1486ed9 Mon Sep 17 00:00:00 2001 From: marha Date: Mon, 4 Jul 2011 14:21:49 +0200 Subject: xserver mesa git update 4 July 2011 --- mesalib/src/SConscript | 1 + mesalib/src/gallium/auxiliary/util/u_upload_mgr.c | 520 +++++++++++----------- mesalib/src/gallium/auxiliary/util/u_upload_mgr.h | 256 ++++++----- 3 files changed, 404 insertions(+), 373 deletions(-) (limited to 'mesalib/src') diff --git a/mesalib/src/SConscript b/mesalib/src/SConscript index 7b614daee..6d7bd6cd6 100644 --- a/mesalib/src/SConscript +++ b/mesalib/src/SConscript @@ -22,6 +22,7 @@ SConscript('mesa/SConscript') SConscript('mapi/vgapi/SConscript') if env['platform'] != 'embedded': + SConscript('glx/SConscript') SConscript('egl/main/SConscript') SConscript('glu/sgi/SConscript') SConscript('glut/glx/SConscript') diff --git a/mesalib/src/gallium/auxiliary/util/u_upload_mgr.c b/mesalib/src/gallium/auxiliary/util/u_upload_mgr.c index e2e7829fb..e50db6d67 100644 --- a/mesalib/src/gallium/auxiliary/util/u_upload_mgr.c +++ b/mesalib/src/gallium/auxiliary/util/u_upload_mgr.c @@ -1,251 +1,269 @@ -/************************************************************************** - * - * Copyright 2009 VMware, Inc. - * 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 VMWARE 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. - * - **************************************************************************/ - -/* Helper utility for uploading user buffers & other data, and - * coalescing small buffers into larger ones. - */ - -#include "pipe/p_defines.h" -#include "util/u_inlines.h" -#include "pipe/p_context.h" -#include "util/u_memory.h" -#include "util/u_math.h" - -#include "u_upload_mgr.h" - - -struct u_upload_mgr { - struct pipe_context *pipe; - - unsigned default_size; /* Minimum size of the upload buffer, in bytes. */ - unsigned alignment; /* Alignment of each sub-allocation. */ - unsigned bind; /* Bitmask of PIPE_BIND_* flags. */ - - struct pipe_resource *buffer; /* Upload buffer. */ - struct pipe_transfer *transfer; /* Transfer object for the upload buffer. */ - uint8_t *map; /* Pointer to the mapped upload buffer. */ - unsigned size; /* Actual size of the upload buffer. */ - unsigned offset; /* Aligned offset to the upload buffer, pointing - * at the first unused byte. */ -}; - - -struct u_upload_mgr *u_upload_create( struct pipe_context *pipe, - unsigned default_size, - unsigned alignment, - unsigned bind ) -{ - struct u_upload_mgr *upload = CALLOC_STRUCT( u_upload_mgr ); - if (!upload) - return NULL; - - upload->pipe = pipe; - upload->default_size = default_size; - upload->alignment = alignment; - upload->bind = bind; - upload->buffer = NULL; - - return upload; -} - -/* Release old buffer. - * - * This must usually be called prior to firing the command stream - * which references the upload buffer, as many memory managers will - * cause subsequent maps of a fired buffer to wait. - * - * Can improve this with a change to pipe_buffer_write to use the - * DONT_WAIT bit, but for now, it's easiest just to grab a new buffer. - */ -void u_upload_flush( struct u_upload_mgr *upload ) -{ - /* Unmap and unreference the upload buffer. */ - if (upload->transfer) { - if (upload->offset) { - pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer, - 0, upload->offset); - } - pipe_transfer_unmap(upload->pipe, upload->transfer); - pipe_transfer_destroy(upload->pipe, upload->transfer); - upload->transfer = NULL; - } - pipe_resource_reference( &upload->buffer, NULL ); - upload->size = 0; -} - - -void u_upload_destroy( struct u_upload_mgr *upload ) -{ - u_upload_flush( upload ); - FREE( upload ); -} - - -static enum pipe_error -u_upload_alloc_buffer( struct u_upload_mgr *upload, - unsigned min_size ) -{ - unsigned size; - - /* Release the old buffer, if present: - */ - u_upload_flush( upload ); - - /* Allocate a new one: - */ - size = align(MAX2(upload->default_size, min_size), 4096); - - upload->buffer = pipe_buffer_create( upload->pipe->screen, - upload->bind, - PIPE_USAGE_STREAM, - size ); - if (upload->buffer == NULL) - goto fail; - - /* Map the new buffer. */ - upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, - 0, size, - PIPE_TRANSFER_WRITE | - PIPE_TRANSFER_FLUSH_EXPLICIT, - &upload->transfer); - - upload->size = size; - - upload->offset = 0; - return 0; - -fail: - if (upload->buffer) - pipe_resource_reference( &upload->buffer, NULL ); - - return PIPE_ERROR_OUT_OF_MEMORY; -} - -enum pipe_error u_upload_alloc( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned size, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed, - void **ptr ) -{ - unsigned alloc_size = align( size, upload->alignment ); - unsigned alloc_offset = align(min_out_offset, upload->alignment); - unsigned offset; - - /* Make sure we have enough space in the upload buffer - * for the sub-allocation. */ - if (MAX2(upload->offset, alloc_offset) + alloc_size > upload->size) { - enum pipe_error ret = u_upload_alloc_buffer(upload, - alloc_offset + alloc_size); - if (ret) - return ret; - - *flushed = TRUE; - } else { - *flushed = FALSE; - } - - offset = MAX2(upload->offset, alloc_offset); - - assert(offset < upload->buffer->width0); - assert(offset + size <= upload->buffer->width0); - assert(size); - - /* Emit the return values: */ - *ptr = upload->map + offset; - pipe_resource_reference( outbuf, upload->buffer ); - *out_offset = offset; - - upload->offset = offset + alloc_size; - return PIPE_OK; -} - -enum pipe_error u_upload_data( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned size, - const void *data, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed ) -{ - uint8_t *ptr; - enum pipe_error ret = u_upload_alloc(upload, min_out_offset, size, - out_offset, outbuf, flushed, - (void**)&ptr); - if (ret) - return ret; - - memcpy(ptr, data, size); - return PIPE_OK; -} - - -/* As above, but upload the full contents of a buffer. Useful for - * uploading user buffers, avoids generating an explosion of GPU - * buffers if you have an app that does lots of small vertex buffer - * renders or DrawElements calls. - */ -enum pipe_error u_upload_buffer( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned offset, - unsigned size, - struct pipe_resource *inbuf, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed ) -{ - enum pipe_error ret = PIPE_OK; - struct pipe_transfer *transfer = NULL; - const char *map = NULL; - - map = (const char *)pipe_buffer_map(upload->pipe, - inbuf, - PIPE_TRANSFER_READ, - &transfer); - - if (map == NULL) { - ret = PIPE_ERROR_OUT_OF_MEMORY; - goto done; - } - - if (0) - debug_printf("upload ptr %p ofs %d sz %d\n", map, offset, size); - - ret = u_upload_data( upload, - min_out_offset, - size, - map + offset, - out_offset, - outbuf, flushed ); - -done: - if (map) - pipe_buffer_unmap( upload->pipe, transfer ); - - return ret; -} +/************************************************************************** + * + * Copyright 2009 VMware, Inc. + * 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 VMWARE 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. + * + **************************************************************************/ + +/* Helper utility for uploading user buffers & other data, and + * coalescing small buffers into larger ones. + */ + +#include "pipe/p_defines.h" +#include "util/u_inlines.h" +#include "pipe/p_context.h" +#include "util/u_memory.h" +#include "util/u_math.h" + +#include "u_upload_mgr.h" + + +struct u_upload_mgr { + struct pipe_context *pipe; + + unsigned default_size; /* Minimum size of the upload buffer, in bytes. */ + unsigned alignment; /* Alignment of each sub-allocation. */ + unsigned bind; /* Bitmask of PIPE_BIND_* flags. */ + + struct pipe_resource *buffer; /* Upload buffer. */ + struct pipe_transfer *transfer; /* Transfer object for the upload buffer. */ + uint8_t *map; /* Pointer to the mapped upload buffer. */ + unsigned size; /* Actual size of the upload buffer. */ + unsigned offset; /* Aligned offset to the upload buffer, pointing + * at the first unused byte. */ +}; + + +struct u_upload_mgr *u_upload_create( struct pipe_context *pipe, + unsigned default_size, + unsigned alignment, + unsigned bind ) +{ + struct u_upload_mgr *upload = CALLOC_STRUCT( u_upload_mgr ); + if (!upload) + return NULL; + + upload->pipe = pipe; + upload->default_size = default_size; + upload->alignment = alignment; + upload->bind = bind; + upload->buffer = NULL; + + return upload; +} + +void u_upload_unmap( struct u_upload_mgr *upload ) +{ + if (upload->transfer) { + struct pipe_box *box = &upload->transfer->box; + if (upload->offset > box->x) { + + pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer, + box->x, upload->offset - box->x); + } + pipe_transfer_unmap(upload->pipe, upload->transfer); + pipe_transfer_destroy(upload->pipe, upload->transfer); + upload->transfer = NULL; + upload->map = NULL; + } +} + +/* Release old buffer. + * + * This must usually be called prior to firing the command stream + * which references the upload buffer, as many memory managers will + * cause subsequent maps of a fired buffer to wait. + * + * Can improve this with a change to pipe_buffer_write to use the + * DONT_WAIT bit, but for now, it's easiest just to grab a new buffer. + */ +void u_upload_flush( struct u_upload_mgr *upload ) +{ + /* Unmap and unreference the upload buffer. */ + u_upload_unmap(upload); + pipe_resource_reference( &upload->buffer, NULL ); + upload->size = 0; +} + + +void u_upload_destroy( struct u_upload_mgr *upload ) +{ + u_upload_flush( upload ); + FREE( upload ); +} + + +static enum pipe_error +u_upload_alloc_buffer( struct u_upload_mgr *upload, + unsigned min_size ) +{ + unsigned size; + + /* Release the old buffer, if present: + */ + u_upload_flush( upload ); + + /* Allocate a new one: + */ + size = align(MAX2(upload->default_size, min_size), 4096); + + upload->buffer = pipe_buffer_create( upload->pipe->screen, + upload->bind, + PIPE_USAGE_STREAM, + size ); + if (upload->buffer == NULL) + goto fail; + + /* Map the new buffer. */ + upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, + 0, size, + PIPE_TRANSFER_WRITE | + PIPE_TRANSFER_FLUSH_EXPLICIT, + &upload->transfer); + + upload->size = size; + + upload->offset = 0; + return 0; + +fail: + if (upload->buffer) + pipe_resource_reference( &upload->buffer, NULL ); + + return PIPE_ERROR_OUT_OF_MEMORY; +} + +enum pipe_error u_upload_alloc( struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned *out_offset, + struct pipe_resource **outbuf, + boolean *flushed, + void **ptr ) +{ + unsigned alloc_size = align( size, upload->alignment ); + unsigned alloc_offset = align(min_out_offset, upload->alignment); + unsigned offset; + + /* Make sure we have enough space in the upload buffer + * for the sub-allocation. */ + if (MAX2(upload->offset, alloc_offset) + alloc_size > upload->size) { + enum pipe_error ret = u_upload_alloc_buffer(upload, + alloc_offset + alloc_size); + if (ret) + return ret; + + *flushed = TRUE; + } else { + *flushed = FALSE; + } + + offset = MAX2(upload->offset, alloc_offset); + + if (!upload->map) { + upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, + offset, upload->size - offset, + PIPE_TRANSFER_WRITE | + PIPE_TRANSFER_FLUSH_EXPLICIT | + PIPE_TRANSFER_UNSYNCHRONIZED, + &upload->transfer); + } + + assert(offset < upload->buffer->width0); + assert(offset + size <= upload->buffer->width0); + assert(size); + + /* Emit the return values: */ + *ptr = upload->map + offset; + pipe_resource_reference( outbuf, upload->buffer ); + *out_offset = offset; + + upload->offset = offset + alloc_size; + return PIPE_OK; +} + +enum pipe_error u_upload_data( struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + const void *data, + unsigned *out_offset, + struct pipe_resource **outbuf, + boolean *flushed ) +{ + uint8_t *ptr; + enum pipe_error ret = u_upload_alloc(upload, min_out_offset, size, + out_offset, outbuf, flushed, + (void**)&ptr); + if (ret) + return ret; + + memcpy(ptr, data, size); + return PIPE_OK; +} + + +/* As above, but upload the full contents of a buffer. Useful for + * uploading user buffers, avoids generating an explosion of GPU + * buffers if you have an app that does lots of small vertex buffer + * renders or DrawElements calls. + */ +enum pipe_error u_upload_buffer( struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned offset, + unsigned size, + struct pipe_resource *inbuf, + unsigned *out_offset, + struct pipe_resource **outbuf, + boolean *flushed ) +{ + enum pipe_error ret = PIPE_OK; + struct pipe_transfer *transfer = NULL; + const char *map = NULL; + + map = (const char *)pipe_buffer_map_range(upload->pipe, + inbuf, + offset, size, + PIPE_TRANSFER_READ, + &transfer); + + if (map == NULL) { + ret = PIPE_ERROR_OUT_OF_MEMORY; + goto done; + } + + if (0) + debug_printf("upload ptr %p ofs %d sz %d\n", map, offset, size); + + ret = u_upload_data( upload, + min_out_offset, + size, + map, + out_offset, + outbuf, flushed ); + +done: + if (map) + pipe_buffer_unmap( upload->pipe, transfer ); + + return ret; +} diff --git a/mesalib/src/gallium/auxiliary/util/u_upload_mgr.h b/mesalib/src/gallium/auxiliary/util/u_upload_mgr.h index ed13fbe82..989151398 100644 --- a/mesalib/src/gallium/auxiliary/util/u_upload_mgr.h +++ b/mesalib/src/gallium/auxiliary/util/u_upload_mgr.h @@ -1,122 +1,134 @@ -/************************************************************************** - * - * Copyright 2009 VMware, Inc. - * 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 VMWARE 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. - * - **************************************************************************/ - -/* Helper utility for uploading user buffers & other data, and - * coalescing small buffers into larger ones. - */ - -#ifndef U_UPLOAD_MGR_H -#define U_UPLOAD_MGR_H - -#include "pipe/p_compiler.h" - -struct pipe_context; -struct pipe_resource; - - -/** - * Create the upload manager. - * - * \param pipe Pipe driver. - * \param default_size Minimum size of the upload buffer, in bytes. - * \param alignment Alignment of each suballocation in the upload buffer. - * \param bind Bitmask of PIPE_BIND_* flags. - */ -struct u_upload_mgr *u_upload_create( struct pipe_context *pipe, - unsigned default_size, - unsigned alignment, - unsigned bind ); - -/** - * Destroy the upload manager. - */ -void u_upload_destroy( struct u_upload_mgr *upload ); - -/* Unmap and release old buffer. - * - * This must usually be called prior to firing the command stream - * which references the upload buffer, as many memory managers either - * don't like firing a mapped buffer or cause subsequent maps of a - * fired buffer to wait. For now, it's easiest just to grab a new - * buffer. - */ -void u_upload_flush( struct u_upload_mgr *upload ); - -/** - * Sub-allocate new memory from the upload buffer. - * - * \param upload Upload manager - * \param min_out_offset Minimum offset that should be returned in out_offset. - * \param size Size of the allocation. - * \param out_offset Pointer to where the new buffer offset will be returned. - * \param outbuf Pointer to where the upload buffer will be returned. - * \param flushed Whether the upload buffer was flushed. - * \param ptr Pointer to the allocated memory that is returned. - */ -enum pipe_error u_upload_alloc( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned size, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed, - void **ptr ); - - -/** - * Allocate and write data to the upload buffer. - * - * Same as u_upload_alloc, but in addition to that, it copies "data" - * to the pointer returned from u_upload_alloc. - */ -enum pipe_error u_upload_data( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned size, - const void *data, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed ); - - -/** - * Allocate and copy an input buffer to the upload buffer. - * - * Same as u_upload_data, except that the input data comes from a buffer - * instead of a user pointer. - */ -enum pipe_error u_upload_buffer( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned offset, - unsigned size, - struct pipe_resource *inbuf, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed ); - - - -#endif - +/************************************************************************** + * + * Copyright 2009 VMware, Inc. + * 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 VMWARE 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. + * + **************************************************************************/ + +/* Helper utility for uploading user buffers & other data, and + * coalescing small buffers into larger ones. + */ + +#ifndef U_UPLOAD_MGR_H +#define U_UPLOAD_MGR_H + +#include "pipe/p_compiler.h" + +struct pipe_context; +struct pipe_resource; + + +/** + * Create the upload manager. + * + * \param pipe Pipe driver. + * \param default_size Minimum size of the upload buffer, in bytes. + * \param alignment Alignment of each suballocation in the upload buffer. + * \param bind Bitmask of PIPE_BIND_* flags. + */ +struct u_upload_mgr *u_upload_create( struct pipe_context *pipe, + unsigned default_size, + unsigned alignment, + unsigned bind ); + +/** + * Destroy the upload manager. + */ +void u_upload_destroy( struct u_upload_mgr *upload ); + +/* Unmap and release old upload buffer. + * + * This is like u_upload_unmap() except the upload buffer is released for + * recycling. This should be called on real hardware flushes on systems + * that don't support the PIPE_TRANSFER_UNSYNCHRONIZED flag, as otherwise + * the next u_upload_buffer will cause a sync on the buffer. + */ + +void u_upload_flush( struct u_upload_mgr *upload ); + +/** + * Unmap upload buffer + * + * \param upload Upload manager + * + * This must usually be called prior to firing the command stream + * which references the upload buffer, as many memory managers either + * don't like firing a mapped buffer or cause subsequent maps of a + * fired buffer to wait. + */ +void u_upload_unmap( struct u_upload_mgr *upload ); + +/** + * Sub-allocate new memory from the upload buffer. + * + * \param upload Upload manager + * \param min_out_offset Minimum offset that should be returned in out_offset. + * \param size Size of the allocation. + * \param out_offset Pointer to where the new buffer offset will be returned. + * \param outbuf Pointer to where the upload buffer will be returned. + * \param flushed Whether the upload buffer was flushed. + * \param ptr Pointer to the allocated memory that is returned. + */ +enum pipe_error u_upload_alloc( struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned *out_offset, + struct pipe_resource **outbuf, + boolean *flushed, + void **ptr ); + + +/** + * Allocate and write data to the upload buffer. + * + * Same as u_upload_alloc, but in addition to that, it copies "data" + * to the pointer returned from u_upload_alloc. + */ +enum pipe_error u_upload_data( struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + const void *data, + unsigned *out_offset, + struct pipe_resource **outbuf, + boolean *flushed ); + + +/** + * Allocate and copy an input buffer to the upload buffer. + * + * Same as u_upload_data, except that the input data comes from a buffer + * instead of a user pointer. + */ +enum pipe_error u_upload_buffer( struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned offset, + unsigned size, + struct pipe_resource *inbuf, + unsigned *out_offset, + struct pipe_resource **outbuf, + boolean *flushed ); + + + +#endif + -- cgit v1.2.3