1 files changed, 164 insertions, 128 deletions

diff --git a/src/gallium/auxiliary/util/u_inlines.h b/src/gallium/auxiliary/util/u_inlines.h
index e22ab188e11..c2f4f05990b 100644
--- a/src/gallium/auxiliary/util/u_inlines.h
+++ b/src/gallium/auxiliary/util/u_inlines.h
@@ -34,6 +34,7 @@
 #include "pipe/p_screen.h"
 #include "util/u_debug.h"
 #include "util/u_atomic.h"
+#include "util/u_box.h"
 
 
 #ifdef __cplusplus
@@ -87,18 +88,6 @@ pipe_reference(struct pipe_reference *ptr, struct pipe_reference *reference)
    return destroy;
 }
 
-static INLINE void
-pipe_buffer_reference(struct pipe_buffer **ptr, struct pipe_buffer *buf)
-{
-   struct pipe_buffer *old_buf;
-
-   assert(ptr);
-   old_buf = *ptr;
-
-   if (pipe_reference(&(*ptr)->reference, &buf->reference))
-      old_buf->screen->buffer_destroy(old_buf);
-   *ptr = buf;
-}
 
 static INLINE void
 pipe_surface_reference(struct pipe_surface **ptr, struct pipe_surface *surf)
@@ -110,16 +99,18 @@ pipe_surface_reference(struct pipe_surface **ptr, struct pipe_surface *surf)
    *ptr = surf;
 }
 
+
 static INLINE void
-pipe_texture_reference(struct pipe_texture **ptr, struct pipe_texture *tex)
+pipe_resource_reference(struct pipe_resource **ptr, struct pipe_resource *tex)
 {
-   struct pipe_texture *old_tex = *ptr;
+   struct pipe_resource *old_tex = *ptr;
 
    if (pipe_reference(&(*ptr)->reference, &tex->reference))
-      old_tex->screen->texture_destroy(old_tex);
+      old_tex->screen->resource_destroy(old_tex->screen, old_tex);
    *ptr = tex;
 }
 
+
 static INLINE void
 pipe_sampler_view_reference(struct pipe_sampler_view **ptr, struct pipe_sampler_view *view)
 {
@@ -135,91 +126,135 @@ pipe_sampler_view_reference(struct pipe_sampler_view **ptr, struct pipe_sampler_
  * Convenience wrappers for screen buffer functions.
  */
 
-static INLINE struct pipe_buffer *
+static INLINE struct pipe_resource *
 pipe_buffer_create( struct pipe_screen *screen,
-                    unsigned alignment, unsigned usage, unsigned size )
+		    unsigned bind,
+		    unsigned size )
 {
-   return screen->buffer_create(screen, alignment, usage, size);
+   struct pipe_resource buffer;
+   memset(&buffer, 0, sizeof buffer);
+   buffer.target = PIPE_BUFFER;
+   buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */
+   buffer.bind = bind;
+   buffer._usage = PIPE_USAGE_DEFAULT;
+   buffer.flags = 0;
+   buffer.width0 = size;
+   buffer.height0 = 1;
+   buffer.depth0 = 1;
+   return screen->resource_create(screen, &buffer);
 }
 
-static INLINE struct pipe_buffer *
-pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size )
+
+static INLINE struct pipe_resource *
+pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size,
+			 unsigned usage )
 {
-   return screen->user_buffer_create(screen, ptr, size);
+   return screen->user_buffer_create(screen, ptr, size, usage);
 }
 
 static INLINE void *
-pipe_buffer_map(struct pipe_screen *screen,
-                struct pipe_buffer *buf,
-                unsigned usage)
+pipe_buffer_map_range(struct pipe_context *pipe,
+		      struct pipe_resource *buffer,
+		      unsigned offset,
+		      unsigned length,
+		      unsigned usage,
+		      struct pipe_transfer **transfer)
 {
-   if(screen->buffer_map_range) {
-      unsigned offset = 0;
-      unsigned length = buf->size;
-      return screen->buffer_map_range(screen, buf, offset, length, usage);
+   struct pipe_box box;
+   void *map;
+
+   assert(offset < buffer->width0);
+   assert(offset + length <= buffer->width0);
+   assert(length);
+   
+   u_box_1d(offset, length, &box);
+
+   *transfer = pipe->get_transfer( pipe,
+				   buffer,
+				   u_subresource(0, 0),
+				   usage,
+				   &box);
+   
+   if (*transfer == NULL)
+      return NULL;
+
+   map = pipe->transfer_map( pipe, *transfer );
+   if (map == NULL) {
+      pipe->transfer_destroy( pipe, *transfer );
+      return NULL;
    }
-   else
-      return screen->buffer_map(screen, buf, usage);
+
+   /* Match old screen->buffer_map_range() behaviour, return pointer
+    * to where the beginning of the buffer would be:
+    */
+   return (void *)((char *)map - offset);
 }
 
-static INLINE void
-pipe_buffer_unmap(struct pipe_screen *screen,
-                  struct pipe_buffer *buf)
+
+static INLINE void *
+pipe_buffer_map(struct pipe_context *pipe,
+                struct pipe_resource *buffer,
+                unsigned usage,
+		struct pipe_transfer **transfer)
 {
-   screen->buffer_unmap(screen, buf);
+   return pipe_buffer_map_range(pipe, buffer, 0, buffer->width0, usage, transfer);
 }
 
-static INLINE void *
-pipe_buffer_map_range(struct pipe_screen *screen,
-                struct pipe_buffer *buf,
-                unsigned offset,
-                unsigned length,
-                unsigned usage)
+
+static INLINE void
+pipe_buffer_unmap(struct pipe_context *pipe,
+                  struct pipe_resource *buf,
+		  struct pipe_transfer *transfer)
 {
-   assert(offset < buf->size);
-   assert(offset + length <= buf->size);
-   assert(length);
-   if(screen->buffer_map_range)
-      return screen->buffer_map_range(screen, buf, offset, length, usage);
-   else
-      return screen->buffer_map(screen, buf, usage);
+   if (transfer) {
+      pipe->transfer_unmap(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
+   }
 }
 
 static INLINE void
-pipe_buffer_flush_mapped_range(struct pipe_screen *screen,
-                               struct pipe_buffer *buf,
+pipe_buffer_flush_mapped_range(struct pipe_context *pipe,
+			       struct pipe_transfer *transfer,
                                unsigned offset,
                                unsigned length)
 {
-   assert(offset < buf->size);
-   assert(offset + length <= buf->size);
+   struct pipe_box box;
+   int transfer_offset;
+
    assert(length);
-   if(screen->buffer_flush_mapped_range)
-      screen->buffer_flush_mapped_range(screen, buf, offset, length);
+   assert(transfer->box.x <= offset);
+   assert(offset + length <= transfer->box.x + transfer->box.width);
+
+   /* Match old screen->buffer_flush_mapped_range() behaviour, where
+    * offset parameter is relative to the start of the buffer, not the
+    * mapped range.
+    */
+   transfer_offset = offset - transfer->box.x;
+   
+   u_box_1d(transfer_offset, length, &box);
+
+   pipe->transfer_flush_region(pipe, transfer, &box);
 }
 
 static INLINE void
-pipe_buffer_write(struct pipe_screen *screen,
-                  struct pipe_buffer *buf,
-                  unsigned offset, unsigned size,
+pipe_buffer_write(struct pipe_context *pipe,
+                  struct pipe_resource *buf,
+                  unsigned offset,
+		  unsigned size,
                   const void *data)
 {
-   void *map;
-   
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
-   assert(size);
-
-   map = pipe_buffer_map_range(screen, buf, offset, size, 
-                               PIPE_BUFFER_USAGE_CPU_WRITE | 
-                               PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
-                               PIPE_BUFFER_USAGE_DISCARD);
-   assert(map);
-   if(map) {
-      memcpy((uint8_t *)map + offset, data, size);
-      pipe_buffer_flush_mapped_range(screen, buf, offset, size);
-      pipe_buffer_unmap(screen, buf);
-   }
+   struct pipe_box box;
+
+   u_box_1d(offset, size, &box);
+
+   pipe->transfer_inline_write( pipe,
+				buf,
+				u_subresource(0,0),
+				PIPE_TRANSFER_WRITE,
+				&box,
+				data,
+				size,
+				0);
 }
 
 /**
@@ -229,86 +264,87 @@ pipe_buffer_write(struct pipe_screen *screen,
  * been written before.
  */
 static INLINE void
-pipe_buffer_write_nooverlap(struct pipe_screen *screen,
-                            struct pipe_buffer *buf,
+pipe_buffer_write_nooverlap(struct pipe_context *pipe,
+                            struct pipe_resource *buf,
                             unsigned offset, unsigned size,
                             const void *data)
 {
-   void *map;
-
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
-   assert(size);
-
-   map = pipe_buffer_map_range(screen, buf, offset, size,
-                               PIPE_BUFFER_USAGE_CPU_WRITE |
-                               PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
-                               PIPE_BUFFER_USAGE_DISCARD |
-                               PIPE_BUFFER_USAGE_UNSYNCHRONIZED);
-   assert(map);
-   if(map) {
-      memcpy((uint8_t *)map + offset, data, size);
-      pipe_buffer_flush_mapped_range(screen, buf, offset, size);
-      pipe_buffer_unmap(screen, buf);
-   }
+   struct pipe_box box;
+
+   u_box_1d(offset, size, &box);
+
+   pipe->transfer_inline_write(pipe, 
+			       buf,
+			       u_subresource(0,0),
+			       (PIPE_TRANSFER_WRITE |
+				PIPE_TRANSFER_NOOVERWRITE),
+			       &box,
+			       data,
+			       0, 0);
 }
 
 static INLINE void
-pipe_buffer_read(struct pipe_screen *screen,
-                 struct pipe_buffer *buf,
-                 unsigned offset, unsigned size,
+pipe_buffer_read(struct pipe_context *pipe,
+                 struct pipe_resource *buf,
+                 unsigned offset,
+		 unsigned size,
                  void *data)
 {
-   void *map;
-   
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
-   assert(size);
-
-   map = pipe_buffer_map_range(screen, buf, offset, size, PIPE_BUFFER_USAGE_CPU_READ);
-   assert(map);
-   if(map) {
-      memcpy(data, (const uint8_t *)map + offset, size);
-      pipe_buffer_unmap(screen, buf);
-   }
+   struct pipe_transfer *src_transfer;
+   ubyte *map;
+
+   map = (ubyte *) pipe_buffer_map_range(pipe,
+					 buf,
+					 offset, size,
+					 PIPE_TRANSFER_READ,
+					 &src_transfer);
+
+   if (map)
+      memcpy(data, map + offset, size);
+
+   pipe_buffer_unmap(pipe, buf, src_transfer);
+}
+
+static INLINE struct pipe_transfer *
+pipe_get_transfer( struct pipe_context *context,
+		       struct pipe_resource *resource,
+		       unsigned face, unsigned level,
+		       unsigned zslice,
+		       enum pipe_transfer_usage usage,
+		       unsigned x, unsigned y,
+		       unsigned w, unsigned h)
+{
+   struct pipe_box box;
+   u_box_2d_zslice( x, y, zslice, w, h, &box );
+   return context->get_transfer( context,
+				 resource,
+				 u_subresource(face, level),
+				 usage,
+				 &box );
 }
 
 static INLINE void *
 pipe_transfer_map( struct pipe_context *context,
-                   struct pipe_transfer *transf )
+                   struct pipe_transfer *transfer )
 {
-   return context->transfer_map(context, transf);
+   return context->transfer_map( context, transfer );
 }
 
 static INLINE void
 pipe_transfer_unmap( struct pipe_context *context,
-                     struct pipe_transfer *transf )
+                     struct pipe_transfer *transfer )
 {
-   context->transfer_unmap(context, transf);
+   context->transfer_unmap( context, transfer );
 }
 
+
 static INLINE void
-pipe_transfer_destroy( struct pipe_context *context,
-                       struct pipe_transfer *transfer )
+pipe_transfer_destroy( struct pipe_context *context, 
+		       struct pipe_transfer *transfer )
 {
-   context->tex_transfer_destroy(context, transfer);
+   context->transfer_destroy(context, transfer);
 }
 
-static INLINE unsigned
-pipe_transfer_buffer_flags( struct pipe_transfer *transf )
-{
-   switch (transf->usage & PIPE_TRANSFER_READ_WRITE) {
-   case PIPE_TRANSFER_READ_WRITE:
-      return PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE;
-   case PIPE_TRANSFER_READ:
-      return PIPE_BUFFER_USAGE_CPU_READ;
-   case PIPE_TRANSFER_WRITE:
-      return PIPE_BUFFER_USAGE_CPU_WRITE;
-   default:
-      debug_assert(0);
-      return 0;
-   }
-}
 
 #ifdef __cplusplus
 }