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_memory.h"
  24 #include "util/u_format.h"
  25 #include "virgl_screen.h"
  26 #include "virgl_resource.h"
  27 #include "virgl_context.h"
  28
  29 static void virgl_copy_region_with_blit(struct pipe_context *pipe,
  30                                         struct pipe_resource *dst,
  31                                         unsigned dst_level,
  32                                         unsigned dstx, unsigned dsty, unsigned dstz,
  33                                         struct pipe_resource *src,
  34                                         unsigned src_level,
  35                                         const struct pipe_box *src_box)
  36 {
  37    struct pipe_blit_info blit;
  38
  39    memset(&blit, 0, sizeof(blit));
  40    blit.src.resource = src;
  41    blit.src.format = src->format;
  42    blit.src.level = src_level;
  43    blit.src.box = *src_box;
  44    blit.dst.resource = dst;
  45    blit.dst.format = dst->format;
  46    blit.dst.level = dst_level;
  47    blit.dst.box.x = dstx;
  48    blit.dst.box.y = dsty;
  49    blit.dst.box.z = dstz;
  50    blit.dst.box.width = src_box->width;
  51    blit.dst.box.height = src_box->height;
  52    blit.dst.box.depth = src_box->depth;
  53    blit.mask = util_format_get_mask(src->format) &
  54       util_format_get_mask(dst->format);
  55    blit.filter = PIPE_TEX_FILTER_NEAREST;
  56
  57    if (blit.mask) {
  58       pipe->blit(pipe, &blit);
  59    }
  60 }
  61 static void virgl_init_temp_resource_from_box(struct pipe_resource *res,
  62                                               struct pipe_resource *orig,
  63                                               const struct pipe_box *box,
  64                                               unsigned level, unsigned flags)
  65 {
  66    memset(res, 0, sizeof(*res));
  67    res->format = orig->format;
  68    res->width0 = box->width;
  69    res->height0 = box->height;
  70    res->depth0 = 1;
  71    res->array_size = 1;
  72    res->usage = PIPE_USAGE_STAGING;
  73    res->flags = flags;
  74
  75    /* We must set the correct texture target and dimensions for a 3D box. */
  76    if (box->depth > 1 && util_max_layer(orig, level) > 0)
  77       res->target = orig->target;
  78    else
  79       res->target = PIPE_TEXTURE_2D;
  80
  81    switch (res->target) {
  82    case PIPE_TEXTURE_1D_ARRAY:
  83    case PIPE_TEXTURE_2D_ARRAY:
  84    case PIPE_TEXTURE_CUBE_ARRAY:
  85       res->array_size = box->depth;
  86       break;
  87    case PIPE_TEXTURE_3D:
  88       res->depth0 = box->depth;
  89       break;
  90    default:
  91       break;
  92    }
  93 }
  94
  95 static unsigned
  96 vrend_get_tex_image_offset(const struct virgl_texture *res,
  97                            unsigned level, unsigned layer)
  98 {
  99    const struct pipe_resource *pres = &res->base.u.b;
 100    const unsigned hgt = u_minify(pres->height0, level);
 101    const unsigned nblocksy = util_format_get_nblocksy(pres->format, hgt);
 102    unsigned offset = res->level_offset[level];
 103
 104    if (pres->target == PIPE_TEXTURE_CUBE ||
 105        pres->target == PIPE_TEXTURE_CUBE_ARRAY ||
 106        pres->target == PIPE_TEXTURE_3D ||
 107        pres->target == PIPE_TEXTURE_2D_ARRAY) {
 108       offset += layer * nblocksy * res->stride[level];
 109    }
 110    else if (pres->target == PIPE_TEXTURE_1D_ARRAY) {
 111       offset += layer * res->stride[level];
 112    }
 113    else {
 114       assert(layer == 0);
 115    }
 116
 117    return offset;
 118 }
 119
 120 static void *virgl_texture_transfer_map(struct pipe_context *ctx,
 121                                         struct pipe_resource *resource,
 122                                         unsigned level,
 123                                         unsigned usage,
 124                                         const struct pipe_box *box,
 125                                         struct pipe_transfer **transfer)
 126 {
 127    struct virgl_context *vctx = virgl_context(ctx);
 128    struct virgl_screen *vs = virgl_screen(ctx->screen);
 129    struct virgl_texture *vtex = virgl_texture(resource);
 130    enum pipe_format format = resource->format;
 131    struct virgl_transfer *trans;
 132    void *ptr;
 133    boolean readback = TRUE;
 134    uint32_t offset;
 135    struct virgl_hw_res *hw_res;
 136    const unsigned h = u_minify(vtex->base.u.b.height0, level);
 137    const unsigned nblocksy = util_format_get_nblocksy(format, h);
 138    bool is_depth = util_format_has_depth(util_format_description(resource->format));
 139    uint32_t l_stride;
 140    bool doflushwait;
 141
 142    doflushwait = virgl_res_needs_flush_wait(vctx, &vtex->base, usage);
 143    if (doflushwait)
 144       ctx->flush(ctx, NULL, 0);
 145
 146    trans = util_slab_alloc(&vctx->texture_transfer_pool);
 147    if (trans == NULL)
 148       return NULL;
 149
 150    trans->base.resource = resource;
 151    trans->base.level = level;
 152    trans->base.usage = usage;
 153    trans->base.box = *box;
 154    trans->base.stride = vtex->stride[level];
 155    trans->base.layer_stride = trans->base.stride * nblocksy;
 156
 157    if (resource->target != PIPE_TEXTURE_3D &&
 158        resource->target != PIPE_TEXTURE_CUBE &&
 159        resource->target != PIPE_TEXTURE_1D_ARRAY &&
 160        resource->target != PIPE_TEXTURE_2D_ARRAY &&
 161        resource->target != PIPE_TEXTURE_CUBE_ARRAY)
 162       l_stride = 0;
 163    else
 164       l_stride = trans->base.layer_stride;
 165
 166    if (is_depth && resource->nr_samples > 1) {
 167       struct pipe_resource tmp_resource;
 168       virgl_init_temp_resource_from_box(&tmp_resource, resource, box,
 169                                         level, 0);
 170
 171       trans->resolve_tmp = (struct virgl_resource *)ctx->screen->resource_create(ctx->screen, &tmp_resource);
 172
 173       virgl_copy_region_with_blit(ctx, &trans->resolve_tmp->u.b, 0, 0, 0, 0, resource, level, box);
 174       ctx->flush(ctx, NULL, 0);
 175       /* we want to do a resolve blit into the temporary */
 176       hw_res = trans->resolve_tmp->hw_res;
 177       offset = 0;
 178    } else {
 179       offset = vrend_get_tex_image_offset(vtex, level, box->z);
 180
 181       offset += box->y / util_format_get_blockheight(format) * trans->base.stride +
 182       box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
 183       hw_res = vtex->base.hw_res;
 184       trans->resolve_tmp = NULL;
 185    }
 186
 187    readback = virgl_res_needs_readback(vctx, &vtex->base, usage);
 188    if (readback)
 189       vs->vws->transfer_get(vs->vws, hw_res, box, trans->base.stride, l_stride, offset, level);
 190
 191    if (doflushwait || readback)
 192       vs->vws->resource_wait(vs->vws, vtex->base.hw_res);
 193
 194    ptr = vs->vws->resource_map(vs->vws, hw_res);
 195    if (!ptr) {
 196       return NULL;
 197    }
 198
 199    trans->offset = offset;
 200    *transfer = &trans->base;
 201
 202    return ptr + trans->offset;
 203 }
 204
 205 static void virgl_texture_transfer_unmap(struct pipe_context *ctx,
 206                                          struct pipe_transfer *transfer)
 207 {
 208    struct virgl_context *vctx = virgl_context(ctx);
 209    struct virgl_transfer *trans = virgl_transfer(transfer);
 210    struct virgl_texture *vtex = virgl_texture(transfer->resource);
 211    uint32_t l_stride;
 212
 213    if (transfer->resource->target != PIPE_TEXTURE_3D &&
 214        transfer->resource->target != PIPE_TEXTURE_CUBE &&
 215        transfer->resource->target != PIPE_TEXTURE_1D_ARRAY &&
 216        transfer->resource->target != PIPE_TEXTURE_2D_ARRAY &&
 217        transfer->resource->target != PIPE_TEXTURE_CUBE_ARRAY)
 218       l_stride = 0;
 219    else
 220       l_stride = trans->base.layer_stride;
 221
 222    if (trans->base.usage & PIPE_TRANSFER_WRITE) {
 223       if (!(transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT)) {
 224          struct virgl_screen *vs = virgl_screen(ctx->screen);
 225          vtex->base.clean = FALSE;
 226          vctx->num_transfers++;
 227          vs->vws->transfer_put(vs->vws, vtex->base.hw_res,
 228                                &transfer->box, trans->base.stride, l_stride, trans->offset, transfer->level);
 229
 230       }
 231    }
 232
 233    if (trans->resolve_tmp)
 234       pipe_resource_reference((struct pipe_resource **)&trans->resolve_tmp, NULL);
 235
 236    util_slab_free(&vctx->texture_transfer_pool, trans);
 237 }
 238
 239
 240 static boolean
 241 vrend_resource_layout(struct virgl_texture *res,
 242                       uint32_t *total_size)
 243 {
 244    struct pipe_resource *pt = &res->base.u.b;
 245    unsigned level;
 246    unsigned width = pt->width0;
 247    unsigned height = pt->height0;
 248    unsigned depth = pt->depth0;
 249    unsigned buffer_size = 0;
 250
 251    for (level = 0; level <= pt->last_level; level++) {
 252       unsigned slices;
 253
 254       if (pt->target == PIPE_TEXTURE_CUBE)
 255          slices = 6;
 256       else if (pt->target == PIPE_TEXTURE_3D)
 257          slices = depth;
 258       else
 259          slices = pt->array_size;
 260
 261       res->stride[level] = util_format_get_stride(pt->format, width);
 262       res->level_offset[level] = buffer_size;
 263
 264       buffer_size += (util_format_get_nblocksy(pt->format, height) *
 265                       slices * res->stride[level]);
 266
 267       width = u_minify(width, 1);
 268       height = u_minify(height, 1);
 269       depth = u_minify(depth, 1);
 270    }
 271
 272    if (pt->nr_samples <= 1)
 273       *total_size = buffer_size;
 274    else /* don't create guest backing store for MSAA */
 275       *total_size = 0;
 276    return TRUE;
 277 }
 278
 279 static boolean virgl_texture_get_handle(struct pipe_screen *screen,
 280                                          struct pipe_resource *ptex,
 281                                          struct winsys_handle *whandle)
 282 {
 283    struct virgl_screen *vs = virgl_screen(screen);
 284    struct virgl_texture *vtex = virgl_texture(ptex);
 285
 286    return vs->vws->resource_get_handle(vs->vws, vtex->base.hw_res, vtex->stride[0], whandle);
 287 }
 288
 289 static void virgl_texture_destroy(struct pipe_screen *screen,
 290                                   struct pipe_resource *res)
 291 {
 292    struct virgl_screen *vs = virgl_screen(screen);
 293    struct virgl_texture *vtex = virgl_texture(res);
 294    vs->vws->resource_unref(vs->vws, vtex->base.hw_res);
 295    FREE(vtex);
 296 }
 297
 298 static const struct u_resource_vtbl virgl_texture_vtbl =
 299 {
 300    virgl_texture_get_handle,            /* get_handle */
 301    virgl_texture_destroy,               /* resource_destroy */
 302    virgl_texture_transfer_map,          /* transfer_map */
 303    NULL,                                /* transfer_flush_region */
 304    virgl_texture_transfer_unmap,        /* transfer_unmap */
 305    NULL                                 /* transfer_inline_write */
 306 };
 307
 308 struct pipe_resource *
 309 virgl_texture_from_handle(struct virgl_screen *vs,
 310                           const struct pipe_resource *template,
 311                           struct winsys_handle *whandle)
 312 {
 313    struct virgl_texture *tex;
 314    uint32_t size;
 315
 316    tex = CALLOC_STRUCT(virgl_texture);
 317    tex->base.u.b = *template;
 318    tex->base.u.b.screen = &vs->base;
 319    pipe_reference_init(&tex->base.u.b.reference, 1);
 320    tex->base.u.vtbl = &virgl_texture_vtbl;
 321    vrend_resource_layout(tex, &size);
 322
 323    tex->base.hw_res = vs->vws->resource_create_from_handle(vs->vws, whandle);
 324    return &tex->base.u.b;
 325 }
 326
 327 struct pipe_resource *virgl_texture_create(struct virgl_screen *vs,
 328                                            const struct pipe_resource *template)
 329 {
 330    struct virgl_texture *tex;
 331    uint32_t size;
 332    unsigned vbind;
 333
 334    tex = CALLOC_STRUCT(virgl_texture);
 335    tex->base.clean = TRUE;
 336    tex->base.u.b = *template;
 337    tex->base.u.b.screen = &vs->base;
 338    pipe_reference_init(&tex->base.u.b.reference, 1);
 339    tex->base.u.vtbl = &virgl_texture_vtbl;
 340    vrend_resource_layout(tex, &size);
 341
 342    vbind = pipe_to_virgl_bind(template->bind);
 343    tex->base.hw_res = vs->vws->resource_create(vs->vws, template->target, template->format, vbind, template->width0, template->height0, template->depth0, template->array_size, template->last_level, template->nr_samples, size);
 344    if (!tex->base.hw_res) {
 345       FREE(tex);
 346       return NULL;
 347    }
 348    return &tex->base.u.b;
 349 }