#include "util/slab.h"
#include "util/u_debug.h"
-#include "util/u_format.h"
+#include "util/format/u_format.h"
+#include "util/u_transfer_helper.h"
#include "util/u_inlines.h"
#include "util/u_memory.h"
-#include "state_tracker/sw_winsys.h"
+#include "frontend/sw_winsys.h"
static void
zink_resource_destroy(struct pipe_screen *pscreen,
return 0;
}
-VkImageAspectFlags
-zink_aspect_from_format(enum pipe_format fmt)
+static VkImageAspectFlags
+aspect_from_format(enum pipe_format fmt)
{
if (util_format_is_depth_or_stencil(fmt)) {
VkImageAspectFlags aspect = 0;
}
static struct pipe_resource *
-zink_resource_create(struct pipe_screen *pscreen,
- const struct pipe_resource *templ)
+resource_create(struct pipe_screen *pscreen,
+ const struct pipe_resource *templ,
+ struct winsys_handle *whandle,
+ unsigned external_usage)
{
struct zink_screen *screen = zink_screen(pscreen);
struct zink_resource *res = CALLOC_STRUCT(zink_resource);
VkMemoryRequirements reqs;
VkMemoryPropertyFlags flags = 0;
+
+ res->internal_format = templ->format;
if (templ->target == PIPE_BUFFER) {
VkBufferCreateInfo bci = {};
bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bci.size = templ->width0;
- bci.usage = 0;
+ bci.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT;
if (templ->bind & PIPE_BIND_VERTEX_BUFFER)
bci.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
if (templ->bind & PIPE_BIND_COMMAND_ARGS_BUFFER)
bci.usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
- if (templ->usage == PIPE_USAGE_STAGING)
- bci.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+ if (templ->bind == (PIPE_BIND_STREAM_OUTPUT | PIPE_BIND_CUSTOM)) {
+ bci.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
+ } else if (templ->bind & PIPE_BIND_STREAM_OUTPUT) {
+ bci.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
+ }
if (vkCreateBuffer(screen->dev, &bci, NULL, &res->buffer) !=
VK_SUCCESS) {
vkGetBufferMemoryRequirements(screen->dev, res->buffer, &reqs);
flags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
} else {
- res->format = zink_get_format(templ->format);
+ res->format = zink_get_format(screen, templ->format);
VkImageCreateInfo ici = {};
ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+ ici.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
switch (templ->target) {
case PIPE_TEXTURE_1D:
ici.imageType = VK_IMAGE_TYPE_1D;
break;
- case PIPE_TEXTURE_2D:
- case PIPE_TEXTURE_2D_ARRAY:
case PIPE_TEXTURE_CUBE:
case PIPE_TEXTURE_CUBE_ARRAY:
+ ici.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+ /* fall-through */
+ case PIPE_TEXTURE_2D:
+ case PIPE_TEXTURE_2D_ARRAY:
case PIPE_TEXTURE_RECT:
ici.imageType = VK_IMAGE_TYPE_2D;
- /* cube and 2D array needs some quirks here */
- if (templ->target == PIPE_TEXTURE_CUBE)
- ici.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
- else if (templ->target == PIPE_TEXTURE_2D_ARRAY)
- ici.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR;
- else if (templ->target == PIPE_TEXTURE_CUBE_ARRAY)
- ici.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT |
- VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR;
break;
case PIPE_TEXTURE_3D:
ici.imageType = VK_IMAGE_TYPE_3D;
+ if (templ->bind & PIPE_BIND_RENDER_TARGET)
+ ici.flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
break;
case PIPE_BUFFER:
ici.extent.height = templ->height0;
ici.extent.depth = templ->depth0;
ici.mipLevels = templ->last_level + 1;
- ici.arrayLayers = templ->array_size;
+ ici.arrayLayers = MAX2(templ->array_size, 1);
ici.samples = templ->nr_samples ? templ->nr_samples : VK_SAMPLE_COUNT_1_BIT;
ici.tiling = templ->bind & PIPE_BIND_LINEAR ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
templ->target == PIPE_TEXTURE_CUBE_ARRAY)
ici.arrayLayers *= 6;
- if (templ->bind & (PIPE_BIND_DISPLAY_TARGET |
- PIPE_BIND_SCANOUT |
- PIPE_BIND_SHARED)) {
- // assert(ici.tiling == VK_IMAGE_TILING_LINEAR);
+ if (templ->bind & PIPE_BIND_SHARED)
ici.tiling = VK_IMAGE_TILING_LINEAR;
- }
if (templ->usage == PIPE_USAGE_STAGING)
ici.tiling = VK_IMAGE_TILING_LINEAR;
/* sadly, gallium doesn't let us know if it'll ever need this, so we have to assume */
- ici.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-
- if (templ->bind & PIPE_BIND_SAMPLER_VIEW)
- ici.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+ ici.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT;
if (templ->bind & PIPE_BIND_SHADER_IMAGE)
ici.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
res->optimial_tiling = ici.tiling != VK_IMAGE_TILING_LINEAR;
- res->aspect = zink_aspect_from_format(templ->format);
+ res->aspect = aspect_from_format(templ->format);
vkGetImageMemoryRequirements(screen->dev, res->image, &reqs);
if (templ->usage == PIPE_USAGE_STAGING || (screen->winsys && (templ->bind & (PIPE_BIND_SCANOUT|PIPE_BIND_DISPLAY_TARGET|PIPE_BIND_SHARED))))
mai.pNext = &emai;
}
+ VkImportMemoryFdInfoKHR imfi = {
+ VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
+ NULL,
+ };
+
+ if (whandle && whandle->type == WINSYS_HANDLE_TYPE_FD) {
+ imfi.pNext = NULL;
+ imfi.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
+ imfi.fd = whandle->handle;
+
+ emai.pNext = &imfi;
+ }
+
if (vkAllocateMemory(screen->dev, &mai, NULL, &res->mem) != VK_SUCCESS)
goto fail;
return NULL;
}
+static struct pipe_resource *
+zink_resource_create(struct pipe_screen *pscreen,
+ const struct pipe_resource *templ)
+{
+ return resource_create(pscreen, templ, NULL, 0);
+}
+
static bool
zink_resource_get_handle(struct pipe_screen *pscreen,
struct pipe_context *context,
}
if (whandle->type == WINSYS_HANDLE_TYPE_FD) {
-
- if (!screen->vk_GetMemoryFdKHR)
- screen->vk_GetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)vkGetDeviceProcAddr(screen->dev, "vkGetMemoryFdKHR");
- if (!screen->vk_GetMemoryFdKHR)
- return false;
fd_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
fd_info.memory = res->mem;
fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
static struct pipe_resource *
zink_resource_from_handle(struct pipe_screen *pscreen,
- const struct pipe_resource *templat,
+ const struct pipe_resource *templ,
struct winsys_handle *whandle,
unsigned usage)
{
- return NULL;
-}
-
-void
-zink_screen_resource_init(struct pipe_screen *pscreen)
-{
- pscreen->resource_create = zink_resource_create;
- pscreen->resource_destroy = zink_resource_destroy;
- pscreen->resource_get_handle = zink_resource_get_handle;
- pscreen->resource_from_handle = zink_resource_from_handle;
+ return resource_create(pscreen, templ, whandle, usage);
}
static bool
{
struct zink_batch *batch = zink_batch_no_rp(ctx);
- if (res->layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL &&
- res->layout != VK_IMAGE_LAYOUT_GENERAL) {
- zink_resource_barrier(batch->cmdbuf, res, res->aspect,
- VK_IMAGE_LAYOUT_GENERAL);
- res->layout = VK_IMAGE_LAYOUT_GENERAL;
+ if (buf2img) {
+ if (res->layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
+ zink_resource_barrier(batch->cmdbuf, res, res->aspect,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+ }
+ } else {
+ if (res->layout != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) {
+ zink_resource_barrier(batch->cmdbuf, res, res->aspect,
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+ }
}
VkBufferImageCopy copyRegion = {};
zink_batch_reference_resoure(batch, res);
zink_batch_reference_resoure(batch, staging_res);
- unsigned aspects = res->aspect;
+ /* we're using u_transfer_helper_deinterleave, which means we'll be getting PIPE_TRANSFER_* usage
+ * to indicate whether to copy either the depth or stencil aspects
+ */
+ unsigned aspects = 0;
+ assert((trans->base.usage & (PIPE_TRANSFER_DEPTH_ONLY | PIPE_TRANSFER_STENCIL_ONLY)) !=
+ (PIPE_TRANSFER_DEPTH_ONLY | PIPE_TRANSFER_STENCIL_ONLY));
+ if (trans->base.usage & PIPE_TRANSFER_DEPTH_ONLY)
+ aspects = VK_IMAGE_ASPECT_DEPTH_BIT;
+ else if (trans->base.usage & PIPE_TRANSFER_STENCIL_ONLY)
+ aspects = VK_IMAGE_ASPECT_STENCIL_BIT;
+ else {
+ aspects = aspect_from_format(res->base.format);
+ }
while (aspects) {
int aspect = 1 << u_bit_scan(&aspects);
copyRegion.imageSubresource.aspectMask = aspect;
void *ptr;
if (pres->target == PIPE_BUFFER) {
+ if (usage & PIPE_TRANSFER_READ) {
+ /* need to wait for rendering to finish
+ * TODO: optimize/fix this to be much less obtrusive
+ * mesa/mesa#2966
+ */
+ struct pipe_fence_handle *fence = NULL;
+ pctx->flush(pctx, &fence, PIPE_FLUSH_HINT_FINISH);
+ if (fence) {
+ pctx->screen->fence_finish(pctx->screen, NULL, fence,
+ PIPE_TIMEOUT_INFINITE);
+ pctx->screen->fence_reference(pctx->screen, &fence, NULL);
+ }
+ }
+
+
VkResult result = vkMapMemory(screen->dev, res->mem, res->offset, res->size, 0, &ptr);
if (result != VK_SUCCESS)
return NULL;
ptr = ((uint8_t *)ptr) + box->x;
} else {
if (res->optimial_tiling || ((res->base.usage != PIPE_USAGE_STAGING))) {
- trans->base.stride = util_format_get_stride(pres->format, box->width);
- trans->base.layer_stride = util_format_get_2d_size(pres->format,
+ enum pipe_format format = pres->format;
+ if (usage & PIPE_TRANSFER_DEPTH_ONLY)
+ format = util_format_get_depth_only(pres->format);
+ else if (usage & PIPE_TRANSFER_STENCIL_ONLY)
+ format = PIPE_FORMAT_S8_UINT;
+ trans->base.stride = util_format_get_stride(format, box->width);
+ trans->base.layer_stride = util_format_get_2d_size(format,
trans->base.stride,
box->height);
struct pipe_resource templ = *pres;
+ templ.format = format;
templ.usage = PIPE_USAGE_STAGING;
templ.target = PIPE_BUFFER;
templ.bind = 0;
false);
if (ret == false)
return NULL;
+
+ /* need to wait for rendering to finish */
+ struct pipe_fence_handle *fence = NULL;
+ pctx->flush(pctx, &fence, PIPE_FLUSH_HINT_FINISH);
+ if (fence) {
+ pctx->screen->fence_finish(pctx->screen, NULL, fence,
+ PIPE_TIMEOUT_INFINITE);
+ pctx->screen->fence_reference(pctx->screen, &fence, NULL);
+ }
}
VkResult result = vkMapMemory(screen->dev, staging_res->mem,
slab_free(&ctx->transfer_pool, ptrans);
}
+static struct pipe_resource *
+zink_resource_get_separate_stencil(struct pipe_resource *pres)
+{
+ /* For packed depth-stencil, we treat depth as the primary resource
+ * and store S8 as the "second plane" resource.
+ */
+ if (pres->next && pres->next->format == PIPE_FORMAT_S8_UINT)
+ return pres->next;
+
+ return NULL;
+
+}
+
+void
+zink_get_depth_stencil_resources(struct pipe_resource *res,
+ struct zink_resource **out_z,
+ struct zink_resource **out_s)
+{
+ if (!res) {
+ if (out_z) *out_z = NULL;
+ if (out_s) *out_s = NULL;
+ return;
+ }
+
+ if (res->format != PIPE_FORMAT_S8_UINT) {
+ if (out_z) *out_z = zink_resource(res);
+ if (out_s) *out_s = zink_resource(zink_resource_get_separate_stencil(res));
+ } else {
+ if (out_z) *out_z = NULL;
+ if (out_s) *out_s = zink_resource(res);
+ }
+}
+
+static void
+zink_resource_set_separate_stencil(struct pipe_resource *pres,
+ struct pipe_resource *stencil)
+{
+ assert(util_format_has_depth(util_format_description(pres->format)));
+ pipe_resource_reference(&pres->next, stencil);
+}
+
+static enum pipe_format
+zink_resource_get_internal_format(struct pipe_resource *pres)
+{
+ struct zink_resource *res = zink_resource(pres);
+ return res->internal_format;
+}
+
+static const struct u_transfer_vtbl transfer_vtbl = {
+ .resource_create = zink_resource_create,
+ .resource_destroy = zink_resource_destroy,
+ .transfer_map = zink_transfer_map,
+ .transfer_unmap = zink_transfer_unmap,
+ .transfer_flush_region = u_default_transfer_flush_region,
+ .get_internal_format = zink_resource_get_internal_format,
+ .set_stencil = zink_resource_set_separate_stencil,
+ .get_stencil = zink_resource_get_separate_stencil,
+};
+
+void
+zink_screen_resource_init(struct pipe_screen *pscreen)
+{
+ pscreen->resource_create = zink_resource_create;
+ pscreen->resource_destroy = zink_resource_destroy;
+ pscreen->transfer_helper = u_transfer_helper_create(&transfer_vtbl, true, true, false, false);
+
+ if (zink_screen(pscreen)->have_KHR_external_memory_fd) {
+ pscreen->resource_get_handle = zink_resource_get_handle;
+ pscreen->resource_from_handle = zink_resource_from_handle;
+ }
+}
+
void
zink_context_resource_init(struct pipe_context *pctx)
{
- pctx->transfer_map = zink_transfer_map;
- pctx->transfer_unmap = zink_transfer_unmap;
+ pctx->transfer_map = u_transfer_helper_deinterleave_transfer_map;
+ pctx->transfer_unmap = u_transfer_helper_deinterleave_transfer_unmap;
- pctx->transfer_flush_region = u_default_transfer_flush_region;
+ pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region;
pctx->buffer_subdata = u_default_buffer_subdata;
pctx->texture_subdata = u_default_texture_subdata;
}
projects / mesa.git / blobdiff