src/gallium/drivers/virgl/virgl_texture.c

   1 /*
   2  * Copyright 2014, 2015 Red Hat.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23 #include "util/u_format.h"
  24 #include "util/u_inlines.h"
  25 #include "util/u_memory.h"
  26
  27 #include "virgl_context.h"
  28 #include "virgl_resource.h"
  29 #include "virgl_screen.h"
  30
  31 static void virgl_copy_region_with_blit(struct pipe_context *pipe,
  32                                         struct pipe_resource *dst,
  33                                         unsigned dst_level,
  34                                         unsigned dstx, unsigned dsty, unsigned dstz,
  35                                         struct pipe_resource *src,
  36                                         unsigned src_level,
  37                                         const struct pipe_box *src_box)
  38 {
  39    struct pipe_blit_info blit;
  40
  41    memset(&blit, 0, sizeof(blit));
  42    blit.src.resource = src;
  43    blit.src.format = src->format;
  44    blit.src.level = src_level;
  45    blit.src.box = *src_box;
  46    blit.dst.resource = dst;
  47    blit.dst.format = dst->format;
  48    blit.dst.level = dst_level;
  49    blit.dst.box.x = dstx;
  50    blit.dst.box.y = dsty;
  51    blit.dst.box.z = dstz;
  52    blit.dst.box.width = src_box->width;
  53    blit.dst.box.height = src_box->height;
  54    blit.dst.box.depth = src_box->depth;
  55    blit.mask = util_format_get_mask(src->format) &
  56       util_format_get_mask(dst->format);
  57    blit.filter = PIPE_TEX_FILTER_NEAREST;
  58
  59    if (blit.mask) {
  60       pipe->blit(pipe, &blit);
  61    }
  62 }
  63
  64 static unsigned temp_bind(unsigned orig)
  65 {
  66    unsigned warn = ~(PIPE_BIND_RENDER_TARGET | PIPE_BIND_DEPTH_STENCIL |
  67                      PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DISPLAY_TARGET);
  68    if (orig & warn)
  69       debug_printf("VIRGL: Warning, possibly unhandled bind: %x\n",
  70                    orig & warn);
  71
  72    return orig & (PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_RENDER_TARGET);
  73 }
  74
  75 static void virgl_init_temp_resource_from_box(struct pipe_resource *res,
  76                                               struct pipe_resource *orig,
  77                                               const struct pipe_box *box,
  78                                               unsigned level, unsigned flags)
  79 {
  80    memset(res, 0, sizeof(*res));
  81    res->bind = temp_bind(orig->bind);
  82    res->format = orig->format;
  83    res->width0 = box->width;
  84    res->height0 = box->height;
  85    res->depth0 = 1;
  86    res->array_size = 1;
  87    res->usage = PIPE_USAGE_STAGING;
  88    res->flags = flags;
  89
  90    /* We must set the correct texture target and dimensions for a 3D box. */
  91    if (box->depth > 1 && util_max_layer(orig, level) > 0)
  92       res->target = orig->target;
  93    else
  94       res->target = PIPE_TEXTURE_2D;
  95
  96    switch (res->target) {
  97    case PIPE_TEXTURE_1D_ARRAY:
  98    case PIPE_TEXTURE_2D_ARRAY:
  99    case PIPE_TEXTURE_CUBE_ARRAY:
 100       res->array_size = box->depth;
 101       break;
 102    case PIPE_TEXTURE_3D:
 103       res->depth0 = box->depth;
 104       break;
 105    default:
 106       break;
 107    }
 108 }
 109
 110 static void *virgl_texture_transfer_map(struct pipe_context *ctx,
 111                                         struct pipe_resource *resource,
 112                                         unsigned level,
 113                                         unsigned usage,
 114                                         const struct pipe_box *box,
 115                                         struct pipe_transfer **transfer)
 116 {
 117    struct virgl_context *vctx = virgl_context(ctx);
 118    struct virgl_screen *vs = virgl_screen(ctx->screen);
 119    struct virgl_resource *vtex = virgl_resource(resource);
 120    struct virgl_resource *src_res;
 121    struct virgl_transfer *trans;
 122    void *ptr;
 123    boolean readback = TRUE;
 124    bool flush;
 125
 126    trans = virgl_resource_create_transfer(&vctx->transfer_pool, resource,
 127                                           &vtex->metadata, level, usage, box);
 128
 129    flush = virgl_res_needs_flush(vctx, trans);
 130    if (flush)
 131       ctx->flush(ctx, NULL, 0);
 132
 133    if (resource->nr_samples > 1) {
 134       struct pipe_resource templ;
 135       virgl_init_temp_resource_from_box(&templ, resource, box, level, 0);
 136
 137       trans->resolve_tmp = (struct virgl_resource *)ctx->screen->resource_create(ctx->screen, &templ);
 138
 139       virgl_copy_region_with_blit(ctx, &trans->resolve_tmp->u.b, 0, 0, 0, 0, resource, level, box);
 140       ctx->flush(ctx, NULL, 0);
 141       /* we want to do a resolve blit into the temporary */
 142       src_res = trans->resolve_tmp;
 143       struct virgl_resource_metadata *data = &trans->resolve_tmp->metadata;
 144       trans->base.stride = data->stride[level];
 145       trans->base.layer_stride = data->layer_stride[level];
 146       trans->offset = 0;
 147    } else {
 148       src_res = vtex;
 149       trans->resolve_tmp = NULL;
 150    }
 151
 152    readback = virgl_res_needs_readback(vctx, src_res, usage, level);
 153    if (readback) {
 154       vs->vws->transfer_get(vs->vws, src_res->hw_res, box, trans->base.stride,
 155                             trans->l_stride, trans->offset, level);
 156
 157       vs->vws->resource_wait(vs->vws, vtex->hw_res);
 158    }
 159
 160    ptr = vs->vws->resource_map(vs->vws, src_res->hw_res);
 161    if (!ptr) {
 162       virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
 163       return NULL;
 164    }
 165
 166    *transfer = &trans->base;
 167    return ptr + trans->offset;
 168 }
 169
 170 static void virgl_texture_transfer_unmap(struct pipe_context *ctx,
 171                                          struct pipe_transfer *transfer)
 172 {
 173    struct virgl_context *vctx = virgl_context(ctx);
 174    struct virgl_transfer *trans = virgl_transfer(transfer);
 175    struct virgl_resource *vtex = virgl_resource(transfer->resource);
 176    bool queue_unmap = false;
 177
 178    if (transfer->usage & PIPE_TRANSFER_WRITE &&
 179        (transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT) == 0) {
 180       if (trans->resolve_tmp) {
 181          struct virgl_winsys *vws = virgl_screen(ctx->screen)->vws;
 182          vws->transfer_put(vws, vtex->hw_res, &transfer->box,
 183                            trans->base.stride, trans->l_stride,
 184                            trans->offset, transfer->level);
 185       } else
 186          queue_unmap = true;
 187    }
 188
 189    pipe_resource_reference((struct pipe_resource **)&trans->resolve_tmp, NULL);
 190
 191    if (queue_unmap)
 192       virgl_transfer_queue_unmap(&vctx->queue, trans);
 193    else
 194       virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
 195 }
 196
 197 static const struct u_resource_vtbl virgl_texture_vtbl =
 198 {
 199    virgl_resource_get_handle,           /* get_handle */
 200    virgl_resource_destroy,              /* resource_destroy */
 201    virgl_texture_transfer_map,          /* transfer_map */
 202    NULL,                                /* transfer_flush_region */
 203    virgl_texture_transfer_unmap,        /* transfer_unmap */
 204 };
 205
 206 void virgl_texture_init(struct virgl_resource *res)
 207 {
 208    res->u.vtbl = &virgl_texture_vtbl;
 209 }