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 unsigned u_default_is_resource_referenced( struct pipe_context *pipe,
  77                                            struct pipe_resource *resource,
  78                                            unsigned level, int layer)
  79 {
  80    return 0;
  81 }
  82
  83 struct pipe_transfer * u_default_get_transfer(struct pipe_context *context,
  84                                               struct pipe_resource *resource,
  85                                               unsigned level,
  86                                               unsigned usage,
  87                                               const struct pipe_box *box)
  88 {
  89    struct pipe_transfer *transfer = CALLOC_STRUCT(pipe_transfer);
  90    if (transfer == NULL)
  91       return NULL;
  92
  93    transfer->resource = resource;
  94    transfer->level = level;
  95    transfer->usage = usage;
  96    transfer->box = *box;
  97
  98    /* Note strides are zero, this is ok for buffers, but not for
  99     * textures 2d & higher at least.
 100     */
 101    return transfer;
 102 }
 103
 104 void u_default_transfer_unmap( struct pipe_context *pipe,
 105                                struct pipe_transfer *transfer )
 106 {
 107 }
 108
 109 void u_default_transfer_destroy(struct pipe_context *pipe,
 110                                 struct pipe_transfer *transfer)
 111 {
 112    FREE(transfer);
 113 }
 114
 115 void u_default_redefine_user_buffer(struct pipe_context *ctx,
 116                                     struct pipe_resource *resource,
 117                                     unsigned offset,
 118                                     unsigned size)
 119 {
 120    resource->width0 = MAX2(resource->width0, offset + size);
 121 }