src/gallium/drivers/zink/zink_resource.c

   1 /*
   2  * Copyright 2018 Collabora Ltd.
   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
  24 #include "zink_resource.h"
  25
  26 #include "zink_batch.h"
  27 #include "zink_context.h"
  28 #include "zink_screen.h"
  29
  30 #include "util/slab.h"
  31 #include "util/u_debug.h"
  32 #include "util/format/u_format.h"
  33 #include "util/u_transfer_helper.h"
  34 #include "util/u_inlines.h"
  35 #include "util/u_memory.h"
  36
  37 #include "frontend/sw_winsys.h"
  38
  39 static void
  40 zink_resource_destroy(struct pipe_screen *pscreen,
  41                       struct pipe_resource *pres)
  42 {
  43    struct zink_screen *screen = zink_screen(pscreen);
  44    struct zink_resource *res = zink_resource(pres);
  45    if (pres->target == PIPE_BUFFER)
  46       vkDestroyBuffer(screen->dev, res->buffer, NULL);
  47    else
  48       vkDestroyImage(screen->dev, res->image, NULL);
  49
  50    vkFreeMemory(screen->dev, res->mem, NULL);
  51    FREE(res);
  52 }
  53
  54 static uint32_t
  55 get_memory_type_index(struct zink_screen *screen,
  56                       const VkMemoryRequirements *reqs,
  57                       VkMemoryPropertyFlags props)
  58 {
  59    for (uint32_t i = 0u; i < VK_MAX_MEMORY_TYPES; i++) {
  60       if (((reqs->memoryTypeBits >> i) & 1) == 1) {
  61          if ((screen->mem_props.memoryTypes[i].propertyFlags & props) == props) {
  62             return i;
  63             break;
  64          }
  65       }
  66    }
  67
  68    unreachable("Unsupported memory-type");
  69    return 0;
  70 }
  71
  72 static VkImageAspectFlags
  73 aspect_from_format(enum pipe_format fmt)
  74 {
  75    if (util_format_is_depth_or_stencil(fmt)) {
  76       VkImageAspectFlags aspect = 0;
  77       const struct util_format_description *desc = util_format_description(fmt);
  78       if (util_format_has_depth(desc))
  79          aspect |= VK_IMAGE_ASPECT_DEPTH_BIT;
  80       if (util_format_has_stencil(desc))
  81          aspect |= VK_IMAGE_ASPECT_STENCIL_BIT;
  82       return aspect;
  83    } else
  84      return VK_IMAGE_ASPECT_COLOR_BIT;
  85 }
  86
  87 static struct pipe_resource *
  88 resource_create(struct pipe_screen *pscreen,
  89                 const struct pipe_resource *templ,
  90                 struct winsys_handle *whandle,
  91                 unsigned external_usage)
  92 {
  93    struct zink_screen *screen = zink_screen(pscreen);
  94    struct zink_resource *res = CALLOC_STRUCT(zink_resource);
  95
  96    res->base = *templ;
  97
  98    pipe_reference_init(&res->base.reference, 1);
  99    res->base.screen = pscreen;
 100
 101    VkMemoryRequirements reqs;
 102    VkMemoryPropertyFlags flags = 0;
 103
 104    res->internal_format = templ->format;
 105    if (templ->target == PIPE_BUFFER) {
 106       VkBufferCreateInfo bci = {};
 107       bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 108       bci.size = templ->width0;
 109
 110       bci.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
 111                   VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 112
 113       if (templ->bind & PIPE_BIND_VERTEX_BUFFER)
 114          bci.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
 115
 116       if (templ->bind & PIPE_BIND_INDEX_BUFFER)
 117          bci.usage |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
 118
 119       if (templ->bind & PIPE_BIND_CONSTANT_BUFFER)
 120          bci.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 121
 122       if (templ->bind & PIPE_BIND_SHADER_BUFFER)
 123          bci.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
 124
 125       if (templ->bind & PIPE_BIND_COMMAND_ARGS_BUFFER)
 126          bci.usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
 127
 128       if (templ->bind == (PIPE_BIND_STREAM_OUTPUT | PIPE_BIND_CUSTOM)) {
 129          bci.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
 130       } else if (templ->bind & PIPE_BIND_STREAM_OUTPUT) {
 131          bci.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
 132       }
 133
 134       if (vkCreateBuffer(screen->dev, &bci, NULL, &res->buffer) !=
 135           VK_SUCCESS) {
 136          FREE(res);
 137          return NULL;
 138       }
 139
 140       vkGetBufferMemoryRequirements(screen->dev, res->buffer, &reqs);
 141       flags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
 142    } else {
 143       res->format = zink_get_format(screen, templ->format);
 144
 145       VkImageCreateInfo ici = {};
 146       ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 147       ici.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
 148
 149       switch (templ->target) {
 150       case PIPE_TEXTURE_1D:
 151       case PIPE_TEXTURE_1D_ARRAY:
 152          ici.imageType = VK_IMAGE_TYPE_1D;
 153          break;
 154
 155       case PIPE_TEXTURE_CUBE:
 156       case PIPE_TEXTURE_CUBE_ARRAY:
 157          ici.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 158          /* fall-through */
 159       case PIPE_TEXTURE_2D:
 160       case PIPE_TEXTURE_2D_ARRAY:
 161       case PIPE_TEXTURE_RECT:
 162          ici.imageType = VK_IMAGE_TYPE_2D;
 163          break;
 164
 165       case PIPE_TEXTURE_3D:
 166          ici.imageType = VK_IMAGE_TYPE_3D;
 167          if (templ->bind & PIPE_BIND_RENDER_TARGET)
 168             ici.flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
 169          break;
 170
 171       case PIPE_BUFFER:
 172          unreachable("PIPE_BUFFER should already be handled");
 173
 174       default:
 175          unreachable("Unknown target");
 176       }
 177
 178       ici.format = res->format;
 179       ici.extent.width = templ->width0;
 180       ici.extent.height = templ->height0;
 181       ici.extent.depth = templ->depth0;
 182       ici.mipLevels = templ->last_level + 1;
 183       ici.arrayLayers = MAX2(templ->array_size, 1);
 184       ici.samples = templ->nr_samples ? templ->nr_samples : VK_SAMPLE_COUNT_1_BIT;
 185       ici.tiling = templ->bind & PIPE_BIND_LINEAR ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
 186
 187       if (templ->target == PIPE_TEXTURE_CUBE ||
 188           templ->target == PIPE_TEXTURE_CUBE_ARRAY)
 189          ici.arrayLayers *= 6;
 190
 191       if (templ->bind & PIPE_BIND_SHARED)
 192          ici.tiling = VK_IMAGE_TILING_LINEAR;
 193
 194       if (templ->usage == PIPE_USAGE_STAGING)
 195          ici.tiling = VK_IMAGE_TILING_LINEAR;
 196
 197       /* sadly, gallium doesn't let us know if it'll ever need this, so we have to assume */
 198       ici.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 199                   VK_IMAGE_USAGE_TRANSFER_DST_BIT |
 200                   VK_IMAGE_USAGE_SAMPLED_BIT;
 201
 202       if (templ->bind & PIPE_BIND_SHADER_IMAGE)
 203          ici.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
 204
 205       if (templ->bind & PIPE_BIND_RENDER_TARGET)
 206          ici.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 207
 208       if (templ->bind & PIPE_BIND_DEPTH_STENCIL)
 209          ici.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 210
 211       if (templ->flags & PIPE_RESOURCE_FLAG_SPARSE)
 212          ici.usage |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
 213
 214       if (templ->bind & PIPE_BIND_STREAM_OUTPUT)
 215          ici.usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
 216
 217       ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 218       ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 219       res->layout = VK_IMAGE_LAYOUT_UNDEFINED;
 220
 221       VkResult result = vkCreateImage(screen->dev, &ici, NULL, &res->image);
 222       if (result != VK_SUCCESS) {
 223          FREE(res);
 224          return NULL;
 225       }
 226
 227       res->optimial_tiling = ici.tiling != VK_IMAGE_TILING_LINEAR;
 228       res->aspect = aspect_from_format(templ->format);
 229
 230       vkGetImageMemoryRequirements(screen->dev, res->image, &reqs);
 231       if (templ->usage == PIPE_USAGE_STAGING || (screen->winsys && (templ->bind & (PIPE_BIND_SCANOUT|PIPE_BIND_DISPLAY_TARGET|PIPE_BIND_SHARED))))
 232         flags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
 233       else
 234         flags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 235    }
 236
 237    VkMemoryAllocateInfo mai = {};
 238    mai.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 239    mai.allocationSize = reqs.size;
 240    mai.memoryTypeIndex = get_memory_type_index(screen, &reqs, flags);
 241
 242    VkExportMemoryAllocateInfo emai = {};
 243    if (templ->bind & PIPE_BIND_SHARED) {
 244       emai.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
 245       emai.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
 246       mai.pNext = &emai;
 247    }
 248
 249    VkImportMemoryFdInfoKHR imfi = {
 250       VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
 251       NULL,
 252    };
 253
 254    if (whandle && whandle->type == WINSYS_HANDLE_TYPE_FD) {
 255       imfi.pNext = NULL;
 256       imfi.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
 257       imfi.fd = whandle->handle;
 258
 259       emai.pNext = &imfi;
 260    }
 261
 262    if (vkAllocateMemory(screen->dev, &mai, NULL, &res->mem) != VK_SUCCESS)
 263       goto fail;
 264
 265    res->offset = 0;
 266    res->size = reqs.size;
 267
 268    if (templ->target == PIPE_BUFFER)
 269       vkBindBufferMemory(screen->dev, res->buffer, res->mem, res->offset);
 270    else
 271       vkBindImageMemory(screen->dev, res->image, res->mem, res->offset);
 272
 273    if (screen->winsys && (templ->bind & (PIPE_BIND_DISPLAY_TARGET |
 274                                          PIPE_BIND_SCANOUT |
 275                                          PIPE_BIND_SHARED))) {
 276       struct sw_winsys *winsys = screen->winsys;
 277       res->dt = winsys->displaytarget_create(screen->winsys,
 278                                              res->base.bind,
 279                                              res->base.format,
 280                                              templ->width0,
 281                                              templ->height0,
 282                                              64, NULL,
 283                                              &res->dt_stride);
 284    }
 285
 286    return &res->base;
 287
 288 fail:
 289    if (templ->target == PIPE_BUFFER)
 290       vkDestroyBuffer(screen->dev, res->buffer, NULL);
 291    else
 292       vkDestroyImage(screen->dev, res->image, NULL);
 293
 294    FREE(res);
 295
 296    return NULL;
 297 }
 298
 299 static struct pipe_resource *
 300 zink_resource_create(struct pipe_screen *pscreen,
 301                      const struct pipe_resource *templ)
 302 {
 303    return resource_create(pscreen, templ, NULL, 0);
 304 }
 305
 306 static bool
 307 zink_resource_get_handle(struct pipe_screen *pscreen,
 308                          struct pipe_context *context,
 309                          struct pipe_resource *tex,
 310                          struct winsys_handle *whandle,
 311                          unsigned usage)
 312 {
 313    struct zink_resource *res = zink_resource(tex);
 314    struct zink_screen *screen = zink_screen(pscreen);
 315    VkMemoryGetFdInfoKHR fd_info = {};
 316    int fd;
 317
 318    if (res->base.target != PIPE_BUFFER) {
 319       VkImageSubresource sub_res = {};
 320       VkSubresourceLayout sub_res_layout = {};
 321
 322       sub_res.aspectMask = res->aspect;
 323
 324       vkGetImageSubresourceLayout(screen->dev, res->image, &sub_res, &sub_res_layout);
 325
 326       whandle->stride = sub_res_layout.rowPitch;
 327    }
 328
 329    if (whandle->type == WINSYS_HANDLE_TYPE_FD) {
 330       fd_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
 331       fd_info.memory = res->mem;
 332       fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
 333       VkResult result = (*screen->vk_GetMemoryFdKHR)(screen->dev, &fd_info, &fd);
 334       if (result != VK_SUCCESS)
 335          return false;
 336       whandle->handle = fd;
 337    }
 338    return true;
 339 }
 340
 341 static struct pipe_resource *
 342 zink_resource_from_handle(struct pipe_screen *pscreen,
 343                  const struct pipe_resource *templ,
 344                  struct winsys_handle *whandle,
 345                  unsigned usage)
 346 {
 347    return resource_create(pscreen, templ, whandle, usage);
 348 }
 349
 350 static bool
 351 zink_transfer_copy_bufimage(struct zink_context *ctx,
 352                             struct zink_resource *res,
 353                             struct zink_resource *staging_res,
 354                             struct zink_transfer *trans,
 355                             bool buf2img)
 356 {
 357    struct zink_batch *batch = zink_batch_no_rp(ctx);
 358
 359    if (buf2img) {
 360       if (res->layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
 361          zink_resource_barrier(batch->cmdbuf, res, res->aspect,
 362                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 363       }
 364    } else {
 365       if (res->layout != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) {
 366          zink_resource_barrier(batch->cmdbuf, res, res->aspect,
 367                                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
 368       }
 369    }
 370
 371    VkBufferImageCopy copyRegion = {};
 372    copyRegion.bufferOffset = staging_res->offset;
 373    copyRegion.bufferRowLength = 0;
 374    copyRegion.bufferImageHeight = 0;
 375    copyRegion.imageSubresource.mipLevel = trans->base.level;
 376    copyRegion.imageSubresource.layerCount = 1;
 377    if (res->base.array_size > 1) {
 378       copyRegion.imageSubresource.baseArrayLayer = trans->base.box.z;
 379       copyRegion.imageSubresource.layerCount = trans->base.box.depth;
 380       copyRegion.imageExtent.depth = 1;
 381    } else {
 382       copyRegion.imageOffset.z = trans->base.box.z;
 383       copyRegion.imageExtent.depth = trans->base.box.depth;
 384    }
 385    copyRegion.imageOffset.x = trans->base.box.x;
 386    copyRegion.imageOffset.y = trans->base.box.y;
 387
 388    copyRegion.imageExtent.width = trans->base.box.width;
 389    copyRegion.imageExtent.height = trans->base.box.height;
 390
 391    zink_batch_reference_resoure(batch, res);
 392    zink_batch_reference_resoure(batch, staging_res);
 393
 394    /* we're using u_transfer_helper_deinterleave, which means we'll be getting PIPE_TRANSFER_* usage
 395     * to indicate whether to copy either the depth or stencil aspects
 396     */
 397    unsigned aspects = 0;
 398    assert((trans->base.usage & (PIPE_TRANSFER_DEPTH_ONLY | PIPE_TRANSFER_STENCIL_ONLY)) !=
 399           (PIPE_TRANSFER_DEPTH_ONLY | PIPE_TRANSFER_STENCIL_ONLY));
 400    if (trans->base.usage & PIPE_TRANSFER_DEPTH_ONLY)
 401       aspects = VK_IMAGE_ASPECT_DEPTH_BIT;
 402    else if (trans->base.usage & PIPE_TRANSFER_STENCIL_ONLY)
 403       aspects = VK_IMAGE_ASPECT_STENCIL_BIT;
 404    else {
 405       aspects = aspect_from_format(res->base.format);
 406    }
 407    while (aspects) {
 408       int aspect = 1 << u_bit_scan(&aspects);
 409       copyRegion.imageSubresource.aspectMask = aspect;
 410
 411       /* this may or may not work with multisampled depth/stencil buffers depending on the driver implementation:
 412        *
 413        * srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
 414        * - vkCmdCopyImageToBuffer spec
 415        *
 416        * dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
 417        * - vkCmdCopyBufferToImage spec
 418        */
 419       if (buf2img)
 420          vkCmdCopyBufferToImage(batch->cmdbuf, staging_res->buffer, res->image, res->layout, 1, &copyRegion);
 421       else
 422          vkCmdCopyImageToBuffer(batch->cmdbuf, res->image, res->layout, staging_res->buffer, 1, &copyRegion);
 423    }
 424
 425    return true;
 426 }
 427
 428 static void *
 429 zink_transfer_map(struct pipe_context *pctx,
 430                   struct pipe_resource *pres,
 431                   unsigned level,
 432                   unsigned usage,
 433                   const struct pipe_box *box,
 434                   struct pipe_transfer **transfer)
 435 {
 436    struct zink_context *ctx = zink_context(pctx);
 437    struct zink_screen *screen = zink_screen(pctx->screen);
 438    struct zink_resource *res = zink_resource(pres);
 439
 440    struct zink_transfer *trans = slab_alloc(&ctx->transfer_pool);
 441    if (!trans)
 442       return NULL;
 443
 444    memset(trans, 0, sizeof(*trans));
 445    pipe_resource_reference(&trans->base.resource, pres);
 446
 447    trans->base.resource = pres;
 448    trans->base.level = level;
 449    trans->base.usage = usage;
 450    trans->base.box = *box;
 451
 452    void *ptr;
 453    if (pres->target == PIPE_BUFFER) {
 454       if (usage & PIPE_TRANSFER_READ) {
 455          /* need to wait for rendering to finish
 456           * TODO: optimize/fix this to be much less obtrusive
 457           * mesa/mesa#2966
 458           */
 459          struct pipe_fence_handle *fence = NULL;
 460          pctx->flush(pctx, &fence, PIPE_FLUSH_HINT_FINISH);
 461          if (fence) {
 462             pctx->screen->fence_finish(pctx->screen, NULL, fence,
 463                                        PIPE_TIMEOUT_INFINITE);
 464             pctx->screen->fence_reference(pctx->screen, &fence, NULL);
 465          }
 466       }
 467
 468
 469       VkResult result = vkMapMemory(screen->dev, res->mem, res->offset, res->size, 0, &ptr);
 470       if (result != VK_SUCCESS)
 471          return NULL;
 472
 473       trans->base.stride = 0;
 474       trans->base.layer_stride = 0;
 475       ptr = ((uint8_t *)ptr) + box->x;
 476    } else {
 477       if (res->optimial_tiling || ((res->base.usage != PIPE_USAGE_STAGING))) {
 478          enum pipe_format format = pres->format;
 479          if (usage & PIPE_TRANSFER_DEPTH_ONLY)
 480             format = util_format_get_depth_only(pres->format);
 481          else if (usage & PIPE_TRANSFER_STENCIL_ONLY)
 482             format = PIPE_FORMAT_S8_UINT;
 483          trans->base.stride = util_format_get_stride(format, box->width);
 484          trans->base.layer_stride = util_format_get_2d_size(format,
 485                                                             trans->base.stride,
 486                                                             box->height);
 487
 488          struct pipe_resource templ = *pres;
 489          templ.format = format;
 490          templ.usage = PIPE_USAGE_STAGING;
 491          templ.target = PIPE_BUFFER;
 492          templ.bind = 0;
 493          templ.width0 = trans->base.layer_stride * box->depth;
 494          templ.height0 = templ.depth0 = 0;
 495          templ.last_level = 0;
 496          templ.array_size = 1;
 497          templ.flags = 0;
 498
 499          trans->staging_res = zink_resource_create(pctx->screen, &templ);
 500          if (!trans->staging_res)
 501             return NULL;
 502
 503          struct zink_resource *staging_res = zink_resource(trans->staging_res);
 504
 505          if (usage & PIPE_TRANSFER_READ) {
 506             struct zink_context *ctx = zink_context(pctx);
 507             bool ret = zink_transfer_copy_bufimage(ctx, res,
 508                                                    staging_res, trans,
 509                                                    false);
 510             if (ret == false)
 511                return NULL;
 512
 513             /* need to wait for rendering to finish */
 514             struct pipe_fence_handle *fence = NULL;
 515             pctx->flush(pctx, &fence, PIPE_FLUSH_HINT_FINISH);
 516             if (fence) {
 517                pctx->screen->fence_finish(pctx->screen, NULL, fence,
 518                                           PIPE_TIMEOUT_INFINITE);
 519                pctx->screen->fence_reference(pctx->screen, &fence, NULL);
 520             }
 521          }
 522
 523          VkResult result = vkMapMemory(screen->dev, staging_res->mem,
 524                                        staging_res->offset,
 525                                        staging_res->size, 0, &ptr);
 526          if (result != VK_SUCCESS)
 527             return NULL;
 528
 529       } else {
 530          assert(!res->optimial_tiling);
 531          VkResult result = vkMapMemory(screen->dev, res->mem, res->offset, res->size, 0, &ptr);
 532          if (result != VK_SUCCESS)
 533             return NULL;
 534          VkImageSubresource isr = {
 535             res->aspect,
 536             level,
 537             0
 538          };
 539          VkSubresourceLayout srl;
 540          vkGetImageSubresourceLayout(screen->dev, res->image, &isr, &srl);
 541          trans->base.stride = srl.rowPitch;
 542          trans->base.layer_stride = srl.arrayPitch;
 543          ptr = ((uint8_t *)ptr) + box->z * srl.depthPitch +
 544                                   box->y * srl.rowPitch +
 545                                   box->x;
 546       }
 547    }
 548
 549    *transfer = &trans->base;
 550    return ptr;
 551 }
 552
 553 static void
 554 zink_transfer_unmap(struct pipe_context *pctx,
 555                     struct pipe_transfer *ptrans)
 556 {
 557    struct zink_context *ctx = zink_context(pctx);
 558    struct zink_screen *screen = zink_screen(pctx->screen);
 559    struct zink_resource *res = zink_resource(ptrans->resource);
 560    struct zink_transfer *trans = (struct zink_transfer *)ptrans;
 561    if (trans->staging_res) {
 562       struct zink_resource *staging_res = zink_resource(trans->staging_res);
 563       vkUnmapMemory(screen->dev, staging_res->mem);
 564
 565       if (trans->base.usage & PIPE_TRANSFER_WRITE) {
 566          struct zink_context *ctx = zink_context(pctx);
 567
 568          zink_transfer_copy_bufimage(ctx, res, staging_res, trans, true);
 569       }
 570
 571       pipe_resource_reference(&trans->staging_res, NULL);
 572    } else
 573       vkUnmapMemory(screen->dev, res->mem);
 574
 575    pipe_resource_reference(&trans->base.resource, NULL);
 576    slab_free(&ctx->transfer_pool, ptrans);
 577 }
 578
 579 static struct pipe_resource *
 580 zink_resource_get_separate_stencil(struct pipe_resource *pres)
 581 {
 582    /* For packed depth-stencil, we treat depth as the primary resource
 583     * and store S8 as the "second plane" resource.
 584     */
 585    if (pres->next && pres->next->format == PIPE_FORMAT_S8_UINT)
 586       return pres->next;
 587
 588    return NULL;
 589
 590 }
 591
 592 void
 593 zink_get_depth_stencil_resources(struct pipe_resource *res,
 594                                  struct zink_resource **out_z,
 595                                  struct zink_resource **out_s)
 596 {
 597    if (!res) {
 598       if (out_z) *out_z = NULL;
 599       if (out_s) *out_s = NULL;
 600       return;
 601    }
 602
 603    if (res->format != PIPE_FORMAT_S8_UINT) {
 604       if (out_z) *out_z = zink_resource(res);
 605       if (out_s) *out_s = zink_resource(zink_resource_get_separate_stencil(res));
 606    } else {
 607       if (out_z) *out_z = NULL;
 608       if (out_s) *out_s = zink_resource(res);
 609    }
 610 }
 611
 612 static void
 613 zink_resource_set_separate_stencil(struct pipe_resource *pres,
 614                                    struct pipe_resource *stencil)
 615 {
 616    assert(util_format_has_depth(util_format_description(pres->format)));
 617    pipe_resource_reference(&pres->next, stencil);
 618 }
 619
 620 static enum pipe_format
 621 zink_resource_get_internal_format(struct pipe_resource *pres)
 622 {
 623    struct zink_resource *res = zink_resource(pres);
 624    return res->internal_format;
 625 }
 626
 627 static const struct u_transfer_vtbl transfer_vtbl = {
 628    .resource_create       = zink_resource_create,
 629    .resource_destroy      = zink_resource_destroy,
 630    .transfer_map          = zink_transfer_map,
 631    .transfer_unmap        = zink_transfer_unmap,
 632    .transfer_flush_region = u_default_transfer_flush_region,
 633    .get_internal_format   = zink_resource_get_internal_format,
 634    .set_stencil           = zink_resource_set_separate_stencil,
 635    .get_stencil           = zink_resource_get_separate_stencil,
 636 };
 637
 638 void
 639 zink_screen_resource_init(struct pipe_screen *pscreen)
 640 {
 641    pscreen->resource_create = zink_resource_create;
 642    pscreen->resource_destroy = zink_resource_destroy;
 643    pscreen->transfer_helper = u_transfer_helper_create(&transfer_vtbl, true, true, false, false);
 644
 645    if (zink_screen(pscreen)->have_KHR_external_memory_fd) {
 646       pscreen->resource_get_handle = zink_resource_get_handle;
 647       pscreen->resource_from_handle = zink_resource_from_handle;
 648    }
 649 }
 650
 651 void
 652 zink_context_resource_init(struct pipe_context *pctx)
 653 {
 654    pctx->transfer_map = u_transfer_helper_deinterleave_transfer_map;
 655    pctx->transfer_unmap = u_transfer_helper_deinterleave_transfer_unmap;
 656
 657    pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region;
 658    pctx->buffer_subdata = u_default_buffer_subdata;
 659    pctx->texture_subdata = u_default_texture_subdata;
 660 }