feat(vkbridge): BC1-BC7 texture emulation (GPU decode on upload)

BC images are created decoded (RGBA8/R8/RG8/RGBA16F, keeping sRGB/SNORM meaning) and every
buffer->image upload is a compute dispatch (shaders/bc_decode.comp, a GLSL port of bcdec with
BC6H mode layouts generated from its source). The app's compute bindings are restored after.
bcn_check: all 10 formats incl. every BC6H/BC7 mode bit-exact with bcdec; DXVK accepts the
Mali-like device (BC, clip/cull, maintenance5 emulated) and its BC/clip checks pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR
This commit is contained in:
ahmadandClaude Opus 5.5 authored and Ahmad Sayed Alsayed Ebrahim committed 2026-10-10 14:28:13 +03:00
1 parent 2e569b850a
commit 92c94c5c15
16 files changed
+7645 -29

No files matched your search

File diff suppressed because it is too large. Load diff
+7 -1
View File
@@ -99,6 +99,12 @@ void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32
VkPhysicalDeviceFeatures real;
inst->real.vkGetPhysicalDeviceFeatures(pd, &real);
VkPhysicalDeviceFeatures *f = find_features(ci);
if ((emu & VKB_EMU_BCN) && !f) {
/* The BC decoder writes R8/RG8 storage images: it needs this feature on, so the request
* gets a features structure if it had none. */
f = vkb_arena_alloc(a, sizeof(*f));
ci->pEnabledFeatures = f;
}
if (f) {
/* pEnabledFeatures came from the request: it is ours to change. Anything the client asked
* for that the GPU does not have is either emulated or would fail the call. */
@@ -107,11 +113,11 @@ void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32
for (size_t i = 0; i < sizeof(*f) / sizeof(VkBool32); i++) {
if (want[i] && !have[i]) want[i] = VK_FALSE;
}
if (emu & VKB_EMU_BCN) f->shaderStorageImageExtendedFormats = VK_TRUE;
}
if (emu & VKB_EMU_DIVISOR) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
if (emu & VKB_EMU_DEPTH_CLIP) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
if (emu & VKB_EMU_MAINT5) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
(void)a;
}
void vkb_emu_device_init(vkb_srv_table *dev, uint32_t emu)
+18 -1
View File
@@ -5,7 +5,7 @@
#include "vkb_server.h"
/* Emulations that are implemented (the rest are never offered to the client). */
#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5 | VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE)
#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5 | VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE | VKB_EMU_BCN)
#define VKB_EMU_BUCKETS 1024
@@ -33,9 +33,26 @@ typedef struct vkb_emu_device {
vkb_emu_image *images[VKB_EMU_BUCKETS];
vkb_emu_buffer *buffers[VKB_EMU_BUCKETS];
void *bcn; /* server_emu_bcn.c */
void *cmdstate; /* server_emu_cmdstate.c */
void *shaders; /* server_emu_shader.c */
} vkb_emu_device;
/* command buffer state (server_emu_cmdstate.c) */
void vkb_emu_cmdstate_install(vkb_srv_table *dev);
void vkb_emu_cmdstate_uninstall(vkb_srv_table *dev);
void vkb_emu_restore_compute(vkb_emu_device *e, VkCommandBuffer cb);
void *vkb_emu_cb_gfx(vkb_emu_device *e, VkCommandBuffer cb, size_t size);
/* graphics-side hooks (server_emu_divisor.c) */
void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p);
void vkb_emu_gfx_reset(void *gfx);
void vkb_emu_gfx_free(void *gfx);
/* BCn (server_emu_bcn.c) */
void vkb_emu_bcn_install(vkb_srv_table *dev);
void vkb_emu_bcn_uninstall(vkb_srv_table *dev);
VkFormat vkb_emu_bcn_view_format(vkb_emu_device *e, VkImage image, VkFormat requested);
void vkb_emu_bcn_buffer_usage(vkb_emu_device *e, VkBufferCreateInfo *ci);
int vkb_emu_bcn_blocks_readback(vkb_emu_device *e, VkImage img);
/* layer (server_emu_layer.c) */
vkb_emu_device *vkb_emu_cur(void);
const vkb_dispatch *vkb_emu_real(void);
+401
View File
@@ -0,0 +1,401 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* BC1-BC7 textures on a GPU without them (textureCompressionBC missing; DXVK and vkd3d-proton
* refuse such a device). The image the app creates in a BC format is created decoded instead
* (RGBA8 / R8 / RG8 / RGBA16F, see vkb_emu_formats.h), mutable so sRGB/SNORM views work, and
* every upload - vkCmdCopyBufferToImage(2), how all BC data arrives - becomes a compute dispatch
* that decodes the blocks from the source buffer straight into it (shaders/bc_decode.comp). The
* app's compute bindings are restored afterwards (server_emu_cmdstate.c).
*
* Not emulated (logged once): reading a BC image back to a buffer, and copies between BC and
* uncompressed images (they would need an encoder).
*/
#define _GNU_SOURCE
#include "server_emu.h"
#include "vkb_emu_formats.h"
#include "bc_spv.h"
#include <stdlib.h>
#include <string.h>
enum { FAM_BC1, FAM_BC2, FAM_BC3, FAM_BC4, FAM_BC5, FAM_BC6H, FAM_BC7, FAM_COUNT };
typedef struct bcn_state {
VkDescriptorSetLayout dsl;
VkPipelineLayout layout;
VkPipeline pipes[FAM_COUNT];
VkDeviceSize ssbo_align;
pthread_mutex_t lock;
} bcn_state;
typedef struct bcn_image {
VkImageView views[16]; /* per mip: 2D array storage view of every layer */
} bcn_image;
typedef struct pc_t {
uint32_t src_word, row_blocks, layer_blocks, flags;
int32_t dst_off[2];
uint32_t extent[2];
} pc_t;
static int family(VkFormat f)
{
switch (f) {
case VK_FORMAT_BC1_RGB_UNORM_BLOCK: case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return FAM_BC1;
case VK_FORMAT_BC2_UNORM_BLOCK: case VK_FORMAT_BC2_SRGB_BLOCK: return FAM_BC2;
case VK_FORMAT_BC3_UNORM_BLOCK: case VK_FORMAT_BC3_SRGB_BLOCK: return FAM_BC3;
case VK_FORMAT_BC4_UNORM_BLOCK: case VK_FORMAT_BC4_SNORM_BLOCK: return FAM_BC4;
case VK_FORMAT_BC5_UNORM_BLOCK: case VK_FORMAT_BC5_SNORM_BLOCK: return FAM_BC5;
case VK_FORMAT_BC6H_UFLOAT_BLOCK: case VK_FORMAT_BC6H_SFLOAT_BLOCK: return FAM_BC6H;
default: return FAM_BC7;
}
}
static uint32_t family_flags(VkFormat f)
{
uint32_t fl = 0;
if (f == VK_FORMAT_BC1_RGB_UNORM_BLOCK || f == VK_FORMAT_BC1_RGB_SRGB_BLOCK) fl |= 1;
if (f == VK_FORMAT_BC4_SNORM_BLOCK || f == VK_FORMAT_BC5_SNORM_BLOCK || f == VK_FORMAT_BC6H_SFLOAT_BLOCK) fl |= 2;
return fl;
}
int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd)
{
VkPhysicalDeviceFeatures f;
idt->vkGetPhysicalDeviceFeatures(pd, &f);
if (!f.shaderStorageImageExtendedFormats) {
VKB_WARN("BC emulation: the GPU lacks shaderStorageImageExtendedFormats");
return 0;
}
static const VkFormat need[] = {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R16G16B16A16_SFLOAT};
for (size_t i = 0; i < sizeof(need) / sizeof(need[0]); i++) {
VkFormatProperties fp;
idt->vkGetPhysicalDeviceFormatProperties(pd, need[i], &fp);
if (!(fp.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
VKB_WARN("BC emulation: format %d cannot be a storage image", need[i]);
return 0;
}
}
VkPhysicalDeviceProperties p;
idt->vkGetPhysicalDeviceProperties(pd, &p);
if (p.apiVersion >= VK_API_VERSION_1_4) return 1;
uint32_t n = 0;
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL);
VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e));
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e);
int ok = 0;
for (uint32_t i = 0; i < n; i++) ok |= !strcmp(e[i].extensionName, "VK_KHR_push_descriptor");
free(e);
if (!ok) VKB_WARN("BC emulation: the GPU lacks VK_KHR_push_descriptor");
return ok;
}
/* ------------------------------------------------------------------ images */
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci)
{
if (!(e->flags & VKB_EMU_BCN) || !vkb_is_bc(ci->format)) return;
/* The image keeps the meaning of the app's format (sRGB, SNORM) so blits and copies convert as
* they would; the decoder writes it through a view in the storage format (EXTENDED_USAGE lets
* the image carry STORAGE although sRGB/SNORM formats cannot be stored to). */
static __thread VkFormat list[2];
VkFormat view = vkb_bc_view_format(ci->format), st = vkb_bc_storage_format(ci->format);
list[0] = view;
list[1] = st;
ci->format = view;
ci->flags &= ~(VkImageCreateFlags)VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
ci->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
ci->usage |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci->pNext; b; b = b->pNext) {
if (b->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO) {
VkImageFormatListCreateInfo *fl = (VkImageFormatListCreateInfo *)b;
fl->viewFormatCount = view == st ? 1 : 2;
fl->pViewFormats = list;
}
}
}
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img)
{
bcn_image *bi = img->emu;
if (!bi) return;
for (int i = 0; i < 16; i++)
if (bi->views[i]) e->dev->real.vkDestroyImageView(e->dev->device, bi->views[i], NULL);
free(bi);
img->emu = NULL;
}
VkFormat vkb_emu_bcn_view_format(vkb_emu_device *e, VkImage image, VkFormat requested)
{
if (!(e->flags & VKB_EMU_BCN)) return requested;
if (vkb_is_bc(requested)) return vkb_bc_view_format(requested);
vkb_emu_image *r = vkb_emu_find_image(e, image);
if (r && vkb_is_bc(r->client_format)) {
VKB_ONCE(VKB_LOG_WARN, "BC emulation: an uncompressed view (format %d) of a BC image shows decoded texels (logged once)", requested);
return vkb_bc_view_format(r->client_format);
}
return requested;
}
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateImageView(VkDevice device, const VkImageViewCreateInfo *ci,
const VkAllocationCallbacks *pAllocator, VkImageView *pView)
{
VkImageViewCreateInfo *v = (VkImageViewCreateInfo *)ci;
v->format = vkb_emu_bcn_view_format(vkb_emu_cur(), ci->image, ci->format);
return vkb_emu_real()->vkCreateImageView(device, v, pAllocator, pView);
}
void vkb_emu_bcn_buffer_usage(vkb_emu_device *e, VkBufferCreateInfo *ci)
{
/* The decoder reads uploads as a storage buffer. */
if ((e->flags & VKB_EMU_BCN) && (ci->usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) ci->usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
/* ------------------------------------------------------------------ decoder */
static VkPipeline pipeline(vkb_emu_device *e, int fam)
{
bcn_state *s = e->bcn;
if (s->pipes[fam]) return s->pipes[fam];
pthread_mutex_lock(&s->lock);
if (!s->pipes[fam]) {
static const uint32_t *const code[FAM_COUNT] = {spv_bc1, spv_bc2, spv_bc3, spv_bc4, spv_bc5, spv_bc6h, spv_bc7};
static const size_t size[FAM_COUNT] = {sizeof(spv_bc1), sizeof(spv_bc2), sizeof(spv_bc3), sizeof(spv_bc4),
sizeof(spv_bc5), sizeof(spv_bc6h), sizeof(spv_bc7)};
const vkb_dispatch *r = &e->dev->real;
VkDevice d = e->dev->device;
VkShaderModuleCreateInfo mci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, size[fam], code[fam]};
VkShaderModule m;
if (r->vkCreateShaderModule(d, &mci, NULL, &m) == VK_SUCCESS) {
VkComputePipelineCreateInfo pci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
pci.stage = (VkPipelineShaderStageCreateInfo){VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0,
VK_SHADER_STAGE_COMPUTE_BIT, m, "main", NULL};
pci.layout = s->layout;
if (r->vkCreateComputePipelines(d, VK_NULL_HANDLE, 1, &pci, NULL, &s->pipes[fam]) != VK_SUCCESS) {
VKB_ERR("BC emulation: decoder pipeline %d failed to build", fam);
s->pipes[fam] = VK_NULL_HANDLE;
}
r->vkDestroyShaderModule(d, m, NULL);
}
}
pthread_mutex_unlock(&s->lock);
return s->pipes[fam];
}
static VkImageView storage_view(vkb_emu_device *e, vkb_emu_image *img, uint32_t mip)
{
if (mip >= 16) return VK_NULL_HANDLE;
pthread_mutex_lock(&e->lock);
if (!img->emu) img->emu = calloc(1, sizeof(bcn_image));
bcn_image *bi = img->emu;
VkImageView v = bi->views[mip];
pthread_mutex_unlock(&e->lock);
if (v) return v;
VkImageViewUsageCreateInfo usage = {VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, NULL, VK_IMAGE_USAGE_STORAGE_BIT};
VkImageViewCreateInfo ci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, &usage, 0, img->image, VK_IMAGE_VIEW_TYPE_2D_ARRAY,
vkb_bc_storage_format(img->client_format),
{0}, {VK_IMAGE_ASPECT_COLOR_BIT, mip, 1, 0, img->layers}};
if (e->dev->real.vkCreateImageView(e->dev->device, &ci, NULL, &v) != VK_SUCCESS) return VK_NULL_HANDLE;
pthread_mutex_lock(&e->lock);
if (bi->views[mip]) {
e->dev->real.vkDestroyImageView(e->dev->device, v, NULL);
v = bi->views[mip];
} else {
bi->views[mip] = v;
}
pthread_mutex_unlock(&e->lock);
return v;
}
typedef struct region {
VkDeviceSize offset;
uint32_t row_length, image_height;
VkImageSubresourceLayers sub;
VkOffset3D ioff;
VkExtent3D iext;
} region;
static void decode(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, vkb_emu_image *img, VkImageLayout layout,
uint32_t n, const region *regs)
{
bcn_state *s = e->bcn;
const vkb_dispatch *r = &e->dev->real;
if (img->type != VK_IMAGE_TYPE_2D) {
VKB_ONCE(VKB_LOG_WARN, "BC emulation: uploads to 1D/3D BC images are not decoded (logged once)");
return;
}
VkPipeline pipe = pipeline(e, family(img->client_format));
if (!pipe) return;
for (uint32_t i = 0; i < n; i++) {
const region *g = &regs[i];
VkImageView view = storage_view(e, img, g->sub.mipLevel);
if (!view) continue;
VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, g->sub.mipLevel, 1, g->sub.baseArrayLayer, g->sub.layerCount};
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT};
VkImageMemoryBarrier ib = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
layout, VK_IMAGE_LAYOUT_GENERAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, img->image, range};
r->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
0, 1, &mb, 0, NULL, 1, &ib);
VkDeviceSize aligned = g->offset & ~(s->ssbo_align - 1);
VkDescriptorBufferInfo bi = {src, aligned, VK_WHOLE_SIZE};
VkDescriptorImageInfo ii = {VK_NULL_HANDLE, view, VK_IMAGE_LAYOUT_GENERAL};
VkWriteDescriptorSet w[2] = {
{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, VK_NULL_HANDLE, 0, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, NULL, &bi, NULL},
{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, VK_NULL_HANDLE, 1, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &ii, NULL, NULL}};
r->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pipe);
r->vkCmdPushDescriptorSet(cb, VK_PIPELINE_BIND_POINT_COMPUTE, s->layout, 0, 2, w);
uint32_t w_tex = g->row_length ? g->row_length : g->iext.width;
uint32_t h_tex = g->image_height ? g->image_height : g->iext.height;
pc_t pc;
pc.src_word = (uint32_t)((g->offset - aligned) / 4);
pc.row_blocks = (w_tex + 3) / 4;
pc.layer_blocks = pc.row_blocks * ((h_tex + 3) / 4);
pc.flags = family_flags(img->client_format) | (g->sub.baseArrayLayer << 8);
pc.dst_off[0] = g->ioff.x;
pc.dst_off[1] = g->ioff.y;
pc.extent[0] = g->iext.width;
pc.extent[1] = g->iext.height;
r->vkCmdPushConstants(cb, s->layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
uint32_t bw = (g->iext.width + 3) / 4, bh = (g->iext.height + 3) / 4;
r->vkCmdDispatch(cb, (bw + 7) / 8, (bh + 7) / 8, g->sub.layerCount);
ib.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
ib.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT;
ib.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
ib.newLayout = layout;
r->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &ib);
}
vkb_emu_restore_compute(e, cb);
}
static vkb_emu_image *bc_image(vkb_emu_device *e, VkImage img)
{
if (!(e->flags & VKB_EMU_BCN)) return NULL;
vkb_emu_image *r = vkb_emu_find_image(e, img);
return r && vkb_is_bc(r->client_format) ? r : NULL;
}
int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
const VkBufferImageCopy *regions)
{
vkb_emu_image *img = bc_image(e, dst);
if (!img) return 0;
region *g = malloc((n ? n : 1) * sizeof(*g));
for (uint32_t i = 0; i < n; i++)
g[i] = (region){regions[i].bufferOffset, regions[i].bufferRowLength, regions[i].bufferImageHeight, regions[i].imageSubresource,
regions[i].imageOffset, regions[i].imageExtent};
decode(e, cb, src, img, dl, n, g);
free(g);
return 1;
}
int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info)
{
vkb_emu_image *img = bc_image(e, info->dstImage);
if (!img) return 0;
region *g = malloc((info->regionCount ? info->regionCount : 1) * sizeof(*g));
for (uint32_t i = 0; i < info->regionCount; i++) {
const VkBufferImageCopy2 *r = &info->pRegions[i];
g[i] = (region){r->bufferOffset, r->bufferRowLength, r->bufferImageHeight, r->imageSubresource, r->imageOffset, r->imageExtent};
}
decode(e, cb, info->srcBuffer, img, info->dstImageLayout, info->regionCount, g);
free(g);
return 1;
}
/* Copies between BC images copy decoded texels; a region may run past a small mip's edge (whole
* blocks), which the decoded image does not have. */
static void clamp_region(const vkb_emu_image *s, const vkb_emu_image *d, const VkImageSubresourceLayers *ss,
const VkImageSubresourceLayers *ds, const VkOffset3D *so, const VkOffset3D *dof, VkExtent3D *ext)
{
uint32_t sw = s->extent.width >> ss->mipLevel, sh = s->extent.height >> ss->mipLevel;
uint32_t dw = d->extent.width >> ds->mipLevel, dh = d->extent.height >> ds->mipLevel;
if (!sw) sw = 1;
if (!sh) sh = 1;
if (!dw) dw = 1;
if (!dh) dh = 1;
if ((uint32_t)so->x + ext->width > sw) ext->width = sw > (uint32_t)so->x ? sw - (uint32_t)so->x : 0;
if ((uint32_t)so->y + ext->height > sh) ext->height = sh > (uint32_t)so->y ? sh - (uint32_t)so->y : 0;
if ((uint32_t)dof->x + ext->width > dw) ext->width = dw > (uint32_t)dof->x ? dw - (uint32_t)dof->x : 0;
if ((uint32_t)dof->y + ext->height > dh) ext->height = dh > (uint32_t)dof->y ? dh - (uint32_t)dof->y : 0;
}
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, uint32_t n,
const VkImageCopy *regions)
{
vkb_emu_image *s = bc_image(e, src), *d = bc_image(e, dst);
if (!s && !d) return 0;
if (!s || !d || vkb_bc_storage_format(s->client_format) != vkb_bc_storage_format(d->client_format)) {
VKB_ONCE(VKB_LOG_WARN, "BC emulation: a copy between a BC image and another format is skipped (logged once)");
return 1;
}
VkImageCopy *c = (VkImageCopy *)regions;
for (uint32_t i = 0; i < n; i++)
clamp_region(s, d, &c[i].srcSubresource, &c[i].dstSubresource, &c[i].srcOffset, &c[i].dstOffset, &c[i].extent);
e->dev->real.vkCmdCopyImage(cb, src, sl, dst, dl, n, regions);
return 1;
}
int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info)
{
vkb_emu_image *s = bc_image(e, info->srcImage), *d = bc_image(e, info->dstImage);
if (!s && !d) return 0;
if (!s || !d || vkb_bc_storage_format(s->client_format) != vkb_bc_storage_format(d->client_format)) {
VKB_ONCE(VKB_LOG_WARN, "BC emulation: a copy between a BC image and another format is skipped (logged once)");
return 1;
}
VkImageCopy2 *c = (VkImageCopy2 *)info->pRegions;
for (uint32_t i = 0; i < info->regionCount; i++)
clamp_region(s, d, &c[i].srcSubresource, &c[i].dstSubresource, &c[i].srcOffset, &c[i].dstOffset, &c[i].extent);
e->dev->real.vkCmdCopyImage2(cb, info);
return 1;
}
int vkb_emu_bcn_blocks_readback(vkb_emu_device *e, VkImage img)
{
if (!bc_image(e, img)) return 0;
VKB_ONCE(VKB_LOG_WARN, "BC emulation: reading a BC image back to a buffer is not supported (logged once)");
return 1;
}
/* ------------------------------------------------------------------ install */
void vkb_emu_bcn_install(vkb_srv_table *dev)
{
vkb_emu_device *e = dev->emu;
if (!(e->flags & VKB_EMU_BCN)) return;
bcn_state *s = calloc(1, sizeof(*s));
pthread_mutex_init(&s->lock, NULL);
VkPhysicalDeviceProperties p;
dev->real.vkGetPhysicalDeviceProperties(dev->physical, &p);
s->ssbo_align = p.limits.minStorageBufferOffsetAlignment ? p.limits.minStorageBufferOffsetAlignment : 4;
VkDescriptorSetLayoutBinding b[2] = {{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}};
VkDescriptorSetLayoutCreateInfo dci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL,
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, 2, b};
VkPushConstantRange pr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc_t)};
if (dev->real.vkCreateDescriptorSetLayout(dev->device, &dci, NULL, &s->dsl) != VK_SUCCESS) {
VKB_ERR("BC emulation: cannot create the decoder's descriptor layout");
free(s);
e->flags &= ~VKB_EMU_BCN;
return;
}
VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0, 1, &s->dsl, 1, &pr};
dev->real.vkCreatePipelineLayout(dev->device, &plci, NULL, &s->layout);
e->bcn = s;
dev->dt.vkCreateImageView = emu_CreateImageView;
}
void vkb_emu_bcn_uninstall(vkb_srv_table *dev)
{
bcn_state *s = dev->emu->bcn;
if (!s) return;
for (int i = 0; i < FAM_COUNT; i++)
if (s->pipes[i]) dev->real.vkDestroyPipeline(dev->device, s->pipes[i], NULL);
dev->real.vkDestroyPipelineLayout(dev->device, s->layout, NULL);
dev->real.vkDestroyDescriptorSetLayout(dev->device, s->dsl, NULL);
pthread_mutex_destroy(&s->lock);
free(s);
dev->emu->bcn = NULL;
}
@@ -0,0 +1,249 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* What an app has bound in a command buffer, for emulations that record commands of their own
* into it (the BCn decoder's dispatches) and must leave the app's state as it was: the compute
* pipeline, compute descriptor sets, push constants and push descriptors. Bind calls are kept as
* they were made (a later call that covers an earlier one replaces it) and replayed in order.
*/
#define _GNU_SOURCE
#include "server_emu.h"
#include <stdlib.h>
#include <string.h>
typedef struct bind_sets {
VkPipelineLayout layout;
uint32_t first, count, ndyn;
VkDescriptorSet sets[32];
uint32_t dyn[64];
} bind_sets;
typedef struct push_consts {
VkPipelineLayout layout;
VkShaderStageFlags stages;
uint32_t offset, size;
uint8_t data[256];
} push_consts;
typedef struct push_tmpl {
VkDescriptorUpdateTemplate tmpl;
VkPipelineLayout layout;
uint32_t set;
void *data;
size_t size;
} push_tmpl;
typedef struct cb_state {
VkCommandBuffer cb;
VkPipeline compute_pipeline;
bind_sets *sets;
uint32_t nsets, capsets;
push_consts *pcs;
uint32_t npcs, cappcs;
push_tmpl *pts;
uint32_t npts, cappts;
void *gfx; /* graphics-side state (divisor emulation) */
struct cb_state *next;
} cb_state;
#define CB_BUCKETS 512
typedef struct cmdstate {
pthread_mutex_t lock;
cb_state *b[CB_BUCKETS];
} cmdstate;
/* Packed size of the template data being pushed (set by the raw push handler, server_misc.c). */
__thread size_t vkb_emu_push_size;
static cmdstate *g_states_for(vkb_emu_device *e) { return (cmdstate *)e->cmdstate; }
static unsigned ch(VkCommandBuffer cb)
{
uint64_t k = (uint64_t)(uintptr_t)cb;
k ^= k >> 30;
k *= 0xbf58476d1ce4e5b9ull;
return (unsigned)(k >> 55) & (CB_BUCKETS - 1);
}
static cb_state *get(vkb_emu_device *e, VkCommandBuffer cb)
{
cmdstate *s = g_states_for(e);
pthread_mutex_lock(&s->lock);
cb_state *c = s->b[ch(cb)];
while (c && c->cb != cb) c = c->next;
if (!c) {
c = calloc(1, sizeof(*c));
c->cb = cb;
c->next = s->b[ch(cb)];
s->b[ch(cb)] = c;
}
pthread_mutex_unlock(&s->lock);
return c;
}
void *vkb_emu_cb_gfx(vkb_emu_device *e, VkCommandBuffer cb, size_t size)
{
cb_state *c = get(e, cb);
if (!c->gfx) c->gfx = calloc(1, size);
return c->gfx;
}
static void reset(cb_state *c)
{
c->compute_pipeline = VK_NULL_HANDLE;
c->nsets = 0;
c->npcs = 0;
for (uint32_t i = 0; i < c->npts; i++) free(c->pts[i].data);
c->npts = 0;
vkb_emu_gfx_reset(c->gfx);
}
/* ------------------------------------------------------------------ wrappers */
static VKAPI_ATTR VkResult VKAPI_CALL emu_BeginCommandBuffer(VkCommandBuffer cb, const VkCommandBufferBeginInfo *info)
{
reset(get(vkb_emu_cur(), cb));
return vkb_emu_real()->vkBeginCommandBuffer(cb, info);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindPipeline(VkCommandBuffer cb, VkPipelineBindPoint bp, VkPipeline p)
{
vkb_emu_device *e = vkb_emu_cur();
if (bp == VK_PIPELINE_BIND_POINT_COMPUTE) get(e, cb)->compute_pipeline = p;
if (bp == VK_PIPELINE_BIND_POINT_GRAPHICS) vkb_emu_gfx_bind_pipeline(e, cb, p);
vkb_emu_real()->vkCmdBindPipeline(cb, bp, p);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindDescriptorSets(VkCommandBuffer cb, VkPipelineBindPoint bp, VkPipelineLayout layout,
uint32_t first, uint32_t count, const VkDescriptorSet *sets,
uint32_t ndyn, const uint32_t *dyn)
{
if (bp == VK_PIPELINE_BIND_POINT_COMPUTE && count <= 32 && ndyn <= 64) {
cb_state *c = get(vkb_emu_cur(), cb);
/* Drop earlier calls this one covers completely. */
uint32_t k = 0;
for (uint32_t i = 0; i < c->nsets; i++) {
bind_sets *b = &c->sets[i];
if (b->first >= first && b->first + b->count <= first + count) continue;
c->sets[k++] = *b;
}
c->nsets = k;
if (c->nsets == c->capsets) {
c->capsets = c->capsets ? c->capsets * 2 : 8;
c->sets = realloc(c->sets, c->capsets * sizeof(*c->sets));
}
bind_sets *b = &c->sets[c->nsets++];
b->layout = layout;
b->first = first;
b->count = count;
b->ndyn = ndyn;
memcpy(b->sets, sets, count * sizeof(*sets));
if (ndyn) memcpy(b->dyn, dyn, ndyn * sizeof(*dyn));
}
vkb_emu_real()->vkCmdBindDescriptorSets(cb, bp, layout, first, count, sets, ndyn, dyn);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdPushConstants(VkCommandBuffer cb, VkPipelineLayout layout, VkShaderStageFlags stages,
uint32_t offset, uint32_t size, const void *data)
{
if ((stages & VK_SHADER_STAGE_COMPUTE_BIT) && offset + size <= 256) {
cb_state *c = get(vkb_emu_cur(), cb);
uint32_t k = 0;
for (uint32_t i = 0; i < c->npcs; i++) {
push_consts *p = &c->pcs[i];
if (p->offset >= offset && p->offset + p->size <= offset + size && p->stages == stages) continue;
c->pcs[k++] = *p;
}
c->npcs = k;
if (c->npcs == c->cappcs) {
c->cappcs = c->cappcs ? c->cappcs * 2 : 8;
c->pcs = realloc(c->pcs, c->cappcs * sizeof(*c->pcs));
}
push_consts *p = &c->pcs[c->npcs++];
p->layout = layout;
p->stages = stages;
p->offset = offset;
p->size = size;
memcpy(p->data + offset, data, size);
}
vkb_emu_real()->vkCmdPushConstants(cb, layout, stages, offset, size, data);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdPushDescriptorSetWithTemplate(VkCommandBuffer cb, VkDescriptorUpdateTemplate tmpl,
VkPipelineLayout layout, uint32_t set, const void *data)
{
/* Only the template's bind point decides; recording it for both costs nothing when replayed
* into the same bind point it was made for. Sizes are unknown here: the bridge's raw template
* path hands over the packed size (vkb_emu_push_size). */
vkb_emu_device *e = vkb_emu_cur();
cb_state *c = get(e, cb);
size_t size = vkb_emu_push_size;
if (size && size < (1u << 20)) {
if (c->npts == c->cappts) {
c->cappts = c->cappts ? c->cappts * 2 : 4;
c->pts = realloc(c->pts, c->cappts * sizeof(*c->pts));
}
push_tmpl *p = &c->pts[c->npts++];
p->tmpl = tmpl;
p->layout = layout;
p->set = set;
p->size = size;
p->data = malloc(size);
memcpy(p->data, data, size);
}
vkb_emu_real()->vkCmdPushDescriptorSetWithTemplate(cb, tmpl, layout, set, data);
}
/* Puts back what the app had bound for compute after an emulation recorded its own dispatch. */
void vkb_emu_restore_compute(vkb_emu_device *e, VkCommandBuffer cb)
{
cb_state *c = get(e, cb);
const vkb_dispatch *r = vkb_emu_real();
if (c->compute_pipeline) r->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, c->compute_pipeline);
for (uint32_t i = 0; i < c->nsets; i++) {
bind_sets *b = &c->sets[i];
r->vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_COMPUTE, b->layout, b->first, b->count, b->sets, b->ndyn, b->dyn);
}
for (uint32_t i = 0; i < c->npts; i++) {
push_tmpl *p = &c->pts[i];
r->vkCmdPushDescriptorSetWithTemplate(cb, p->tmpl, p->layout, p->set, p->data);
}
for (uint32_t i = 0; i < c->npcs; i++) {
push_consts *p = &c->pcs[i];
r->vkCmdPushConstants(cb, p->layout, p->stages, p->offset, p->size, p->data + p->offset);
}
}
void vkb_emu_cmdstate_install(vkb_srv_table *dev)
{
vkb_emu_device *e = dev->emu;
cmdstate *s = calloc(1, sizeof(*s));
pthread_mutex_init(&s->lock, NULL);
e->cmdstate = s;
dev->dt.vkBeginCommandBuffer = emu_BeginCommandBuffer;
dev->dt.vkCmdBindPipeline = emu_CmdBindPipeline;
dev->dt.vkCmdBindDescriptorSets = emu_CmdBindDescriptorSets;
dev->dt.vkCmdPushConstants = emu_CmdPushConstants;
if (dev->real.vkCmdPushDescriptorSetWithTemplate) dev->dt.vkCmdPushDescriptorSetWithTemplate = emu_CmdPushDescriptorSetWithTemplate;
}
void vkb_emu_cmdstate_uninstall(vkb_srv_table *dev)
{
cmdstate *s = dev->emu->cmdstate;
if (!s) return;
for (int i = 0; i < CB_BUCKETS; i++) {
while (s->b[i]) {
cb_state *c = s->b[i];
s->b[i] = c->next;
reset(c);
free(c->sets);
free(c->pcs);
free(c->pts);
vkb_emu_gfx_free(c->gfx);
free(c);
}
}
pthread_mutex_destroy(&s->lock);
free(s);
dev->emu->cmdstate = NULL;
}
+15 -20
View File
@@ -1,30 +1,25 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* Hooks of the feature emulations that are not implemented yet: everything passes through.
* Installs the feature emulations into a device, and the graphics-state hooks of the ones that
* are not implemented yet (vertex attribute divisor).
*/
#define _GNU_SOURCE
#include "server_emu.h"
int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd) { (void)idt; (void)pd; return 0; }
void vkb_emu_install_features(vkb_srv_table *dev) { vkb_emu_shader_install(dev); }
void vkb_emu_uninstall_features(vkb_srv_table *dev) { vkb_emu_shader_uninstall(dev); }
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci) { (void)e; (void)ci; }
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img) { (void)e; (void)img; }
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
uint32_t n, const VkImageCopy *regions)
void vkb_emu_install_features(vkb_srv_table *dev)
{
(void)e; (void)cb; (void)src; (void)sl; (void)dst; (void)dl; (void)n; (void)regions;
return 0;
vkb_emu_cmdstate_install(dev);
vkb_emu_shader_install(dev);
vkb_emu_bcn_install(dev);
}
int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info) { (void)e; (void)cb; (void)info; return 0; }
int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
const VkBufferImageCopy *regions)
void vkb_emu_uninstall_features(vkb_srv_table *dev)
{
(void)e; (void)cb; (void)src; (void)dst; (void)dl; (void)n; (void)regions;
return 0;
}
int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info)
{
(void)e; (void)cb; (void)info;
return 0;
vkb_emu_bcn_uninstall(dev);
vkb_emu_shader_uninstall(dev);
vkb_emu_cmdstate_uninstall(dev);
}
void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p) { (void)e; (void)cb; (void)p; }
void vkb_emu_gfx_reset(void *gfx) { (void)gfx; }
void vkb_emu_gfx_free(void *gfx) { (void)gfx; }
+5 -2
View File
@@ -139,6 +139,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBuffer(VkDevice device, const Vk
VkBufferUsageFlags2CreateInfo *u = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
if (u) ci->usage = (VkBufferUsageFlags)u->usage;
}
vkb_emu_bcn_buffer_usage(e, ci);
VkResult r = vkb_emu_real()->vkCreateBuffer(device, ci, pAllocator, pBuffer);
if (r == VK_SUCCESS) track_buffer(e, *pBuffer, ci->size);
return r;
@@ -363,6 +364,7 @@ static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer(VkCommandBuffer cb, V
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < n; i++) fix_layers(e, src, (VkImageSubresourceLayers *)&regions[i].imageSubresource);
if (vkb_emu_bcn_blocks_readback(e, src)) return;
vkb_emu_real()->vkCmdCopyImageToBuffer(cb, src, sl, dst, n, regions);
}
@@ -371,6 +373,7 @@ static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer2(VkCommandBuffer cb,
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < info->regionCount; i++)
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource);
if (vkb_emu_bcn_blocks_readback(e, info->srcImage)) return;
vkb_emu_real()->vkCmdCopyImageToBuffer2(cb, info);
}
@@ -407,6 +410,8 @@ void vkb_emu_install(vkb_srv_table *dev)
dt->vkCmdCopyBufferToImage = emu_CmdCopyBufferToImage;
if (dev->real.vkCmdCopyImage2) dt->vkCmdCopyImage2 = emu_CmdCopyImage2;
if (dev->real.vkCmdCopyBufferToImage2) dt->vkCmdCopyBufferToImage2 = emu_CmdCopyBufferToImage2;
dt->vkCmdCopyImageToBuffer = emu_CmdCopyImageToBuffer;
if (dev->real.vkCmdCopyImageToBuffer2) dt->vkCmdCopyImageToBuffer2 = emu_CmdCopyImageToBuffer2;
if (e->flags & VKB_EMU_MAINT5) {
dt->vkCreateBufferView = emu_CreateBufferView;
dt->vkCmdBindIndexBuffer2 = emu_CmdBindIndexBuffer2;
@@ -415,10 +420,8 @@ void vkb_emu_install(vkb_srv_table *dev)
dt->vkGetDeviceImageSubresourceLayout = emu_GetDeviceImageSubresourceLayout;
dt->vkCmdBlitImage = emu_CmdBlitImage;
dt->vkCmdResolveImage = emu_CmdResolveImage;
dt->vkCmdCopyImageToBuffer = emu_CmdCopyImageToBuffer;
if (dev->real.vkCmdBlitImage2) dt->vkCmdBlitImage2 = emu_CmdBlitImage2;
if (dev->real.vkCmdResolveImage2) dt->vkCmdResolveImage2 = emu_CmdResolveImage2;
if (dev->real.vkCmdCopyImageToBuffer2) dt->vkCmdCopyImageToBuffer2 = emu_CmdCopyImageToBuffer2;
if (dev->real.vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = emu_CmdBindVertexBuffers2;
}
vkb_emu_install_features(dev);
+4 -1
View File
@@ -247,7 +247,7 @@ void vkb_sv_vkCreateDevice(vkb_srv_call *c)
inst->real.vkEnumerateDeviceExtensionProperties(pd, NULL, &avail_n, avail);
uint32_t extra_n = 0;
const char *const *extra = vkb_mem_required_extensions(strategy, &extra_n);
const char **exts = vkb_dec_alloc(&c->d, (ci->enabledExtensionCount + extra_n + 8) * sizeof(char *));
const char **exts = vkb_dec_alloc(&c->d, (ci->enabledExtensionCount + extra_n + 10) * sizeof(char *));
uint32_t n = 0;
for (uint32_t i = 0; i < ci->enabledExtensionCount; i++) {
const char *e = ci->ppEnabledExtensionNames[i];
@@ -266,6 +266,9 @@ void vkb_sv_vkCreateDevice(vkb_srv_call *c)
};
for (size_t i = 0; i < sizeof(wsi_exts) / sizeof(wsi_exts[0]); i++)
if (has_ext(avail, avail_n, wsi_exts[i]) && !list_has(exts, n, wsi_exts[i])) exts[n++] = wsi_exts[i];
/* The BC decoder binds its buffer and image with push descriptors. */
if ((emu & VKB_EMU_BCN) && has_ext(avail, avail_n, "VK_KHR_push_descriptor") && !list_has(exts, n, "VK_KHR_push_descriptor"))
exts[n++] = "VK_KHR_push_descriptor";
ci->enabledExtensionCount = n;
ci->ppEnabledExtensionNames = exts;
ci->enabledLayerCount = 0;
+3
View File
@@ -46,5 +46,8 @@ void vkb_sv_vkbPushDescRaw(vkb_srv_call *c)
vkb_srv_missing(c, "vkCmdPushDescriptorSetWithTemplate");
return;
}
extern __thread size_t vkb_emu_push_size;
vkb_emu_push_size = n;
c->dt->vkCmdPushDescriptorSetWithTemplate(cb, tmpl, layout, set, data);
vkb_emu_push_size = 0;
}