src/gallium/auxiliary/util/u_transfer.c

   1 #include "pipe/p_context.h"
   2 #include "util/u_surface.h"
   3 #include "util/u_inlines.h"
   4 #include "util/u_transfer.h"
   5 #include "util/u_memory.h"
   6
   7 /* One-shot transfer operation with data supplied in a user
   8  * pointer.  XXX: strides??
   9  */
  10 void u_default_transfer_inline_write( struct pipe_context *pipe,
  11                                       struct pipe_resource *resource,
  12                                       unsigned level,
  13                                       unsigned usage,
  14                                       const struct pipe_box *box,
  15                                       const void *data,
  16                                       unsigned stride,
  17                                       unsigned layer_stride)
  18 {
  19    struct pipe_transfer *transfer = NULL;
  20    uint8_t *map = NULL;
  21
  22    assert(!(usage & PIPE_TRANSFER_READ));
  23
  24    /* the write flag is implicit by the nature of transfer_inline_write */
  25    usage |= PIPE_TRANSFER_WRITE;
  26
  27    /* transfer_inline_write implicitly discards the rewritten buffer range */
  28    if (box->x == 0 && box->width == resource->width0) {
  29       usage |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
  30    } else {
  31       usage |= PIPE_TRANSFER_DISCARD_RANGE;
  32    }
  33
  34    map = pipe->transfer_map(pipe,
  35                             resource,
  36                             level,
  37                             usage,
  38                             box, &transfer);
  39    if (map == NULL)
  40       return;
  41
  42    if (resource->target == PIPE_BUFFER) {
  43       assert(box->height == 1);
  44       assert(box->depth == 1);
  45
  46       memcpy(map, data, box->width);
  47    }
  48    else {
  49       const uint8_t *src_data = data;
  50
  51       util_copy_box(map,
  52                     resource->format,
  53                     transfer->stride, /* bytes */
  54                     transfer->layer_stride, /* bytes */
  55                     0, 0, 0,
  56                     box->width,
  57                     box->height,
  58                     box->depth,
  59                     src_data,
  60                     stride,       /* bytes */
  61                     layer_stride, /* bytes */
  62                     0, 0, 0);
  63    }
  64
  65    pipe_transfer_unmap(pipe, transfer);
  66 }
  67
  68
  69 boolean u_default_resource_get_handle(struct pipe_screen *screen,
  70                                       struct pipe_resource *resource,
  71                                       struct winsys_handle *handle)
  72 {
  73    return FALSE;
  74 }
  75
  76
  77
  78 void u_default_transfer_flush_region( struct pipe_context *pipe,
  79                                       struct pipe_transfer *transfer,
  80                                       const struct pipe_box *box)
  81 {
  82    /* This is a no-op implementation, nothing to do.
  83     */
  84 }
  85
  86 void u_default_transfer_unmap( struct pipe_context *pipe,
  87                                struct pipe_transfer *transfer )
  88 {
  89 }
  90
  91
  92 static INLINE struct u_resource *
  93 u_resource( struct pipe_resource *res )
  94 {
  95    return (struct u_resource *)res;
  96 }
  97
  98 boolean u_resource_get_handle_vtbl(struct pipe_screen *screen,
  99                                    struct pipe_resource *resource,
 100                                    struct winsys_handle *handle)
 101 {
 102    struct u_resource *ur = u_resource(resource);
 103    return ur->vtbl->resource_get_handle(screen, resource, handle);
 104 }
 105
 106 void u_resource_destroy_vtbl(struct pipe_screen *screen,
 107                              struct pipe_resource *resource)
 108 {
 109    struct u_resource *ur = u_resource(resource);
 110    ur->vtbl->resource_destroy(screen, resource);
 111 }
 112
 113 void *u_transfer_map_vtbl(struct pipe_context *context,
 114                           struct pipe_resource *resource,
 115                           unsigned level,
 116                           unsigned usage,
 117                           const struct pipe_box *box,
 118                           struct pipe_transfer **transfer)
 119 {
 120    struct u_resource *ur = u_resource(resource);
 121    return ur->vtbl->transfer_map(context, resource, level, usage, box,
 122                                  transfer);
 123 }
 124
 125 void u_transfer_flush_region_vtbl( struct pipe_context *pipe,
 126                                    struct pipe_transfer *transfer,
 127                                    const struct pipe_box *box)
 128 {
 129    struct u_resource *ur = u_resource(transfer->resource);
 130    ur->vtbl->transfer_flush_region(pipe, transfer, box);
 131 }
 132
 133 void u_transfer_unmap_vtbl( struct pipe_context *pipe,
 134                             struct pipe_transfer *transfer )
 135 {
 136    struct u_resource *ur = u_resource(transfer->resource);
 137    ur->vtbl->transfer_unmap(pipe, transfer);
 138 }
 139
 140 void u_transfer_inline_write_vtbl( struct pipe_context *pipe,
 141                                    struct pipe_resource *resource,
 142                                    unsigned level,
 143                                    unsigned usage,
 144                                    const struct pipe_box *box,
 145                                    const void *data,
 146                                    unsigned stride,
 147                                    unsigned layer_stride)
 148 {
 149    struct u_resource *ur = u_resource(resource);
 150    ur->vtbl->transfer_inline_write(pipe,
 151                                    resource,
 152                                    level,
 153                                    usage,
 154                                    box,
 155                                    data,
 156                                    stride,
 157                                    layer_stride);
 158 }
 159
 160
 161
 162