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