src/gallium/auxiliary/util/u_transfer.c

   1 #include "pipe/p_context.h"
   2 #include "util/u_rect.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    const uint8_t *src_data = data;
  22    unsigned i;
  23
  24    transfer = pipe->get_transfer(pipe,
  25                                  resource,
  26                                  level,
  27                                  usage,
  28                                  box );
  29    if (transfer == NULL)
  30       goto out;
  31
  32    map = pipe_transfer_map(pipe, transfer);
  33    if (map == NULL)
  34       goto out;
  35
  36    for (i = 0; i < box->depth; i++) {
  37       util_copy_rect(map,
  38                      resource->format,
  39                      transfer->stride, /* bytes */
  40                      0, 0,
  41                      box->width,
  42                      box->height,
  43                      src_data,
  44                      stride,       /* bytes */
  45                      0, 0);
  46       map += transfer->layer_stride;
  47       src_data += layer_stride;
  48    }
  49
  50 out:
  51    if (map)
  52       pipe_transfer_unmap(pipe, transfer);
  53
  54    if (transfer)
  55       pipe_transfer_destroy(pipe, transfer);
  56 }
  57
  58
  59 boolean u_default_resource_get_handle(struct pipe_screen *screen,
  60                                       struct pipe_resource *resource,
  61                                       struct winsys_handle *handle)
  62 {
  63    return FALSE;
  64 }
  65
  66
  67
  68 void u_default_transfer_flush_region( struct pipe_context *pipe,
  69                                       struct pipe_transfer *transfer,
  70                                       const struct pipe_box *box)
  71 {
  72    /* This is a no-op implementation, nothing to do.
  73     */
  74 }
  75
  76 struct pipe_transfer * u_default_get_transfer(struct pipe_context *context,
  77                                               struct pipe_resource *resource,
  78                                               unsigned level,
  79                                               unsigned usage,
  80                                               const struct pipe_box *box)
  81 {
  82    struct pipe_transfer *transfer = CALLOC_STRUCT(pipe_transfer);
  83    if (transfer == NULL)
  84       return NULL;
  85
  86    transfer->resource = resource;
  87    transfer->level = level;
  88    transfer->usage = usage;
  89    transfer->box = *box;
  90
  91    /* Note strides are zero, this is ok for buffers, but not for
  92     * textures 2d & higher at least.
  93     */
  94    return transfer;
  95 }
  96
  97 void u_default_transfer_unmap( struct pipe_context *pipe,
  98                                struct pipe_transfer *transfer )
  99 {
 100 }
 101
 102 void u_default_transfer_destroy(struct pipe_context *pipe,
 103                                 struct pipe_transfer *transfer)
 104 {
 105    FREE(transfer);
 106 }
 107
 108 void u_default_redefine_user_buffer(struct pipe_context *ctx,
 109                                     struct pipe_resource *resource,
 110                                     unsigned offset,
 111                                     unsigned size)
 112 {
 113    resource->width0 = MAX2(resource->width0, offset + size);
 114 }