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;
}
+4 -4
View File
@@ -128,11 +128,11 @@ int vkb_emu_format_properties(vkb_physdev *pd, VkFormat format, VkFormatProperti
VkFormat vkb_emu_real_format(vkb_physdev *pd, VkFormat format, VkImageUsageFlags *usage, VkImageCreateFlags *flags)
{
if (!vkb_emu_is_emulated_format(pd, format)) return format;
/* The server creates the decoded image as storage-capable UNORM, mutable to the view format. */
*flags &= ~(VkImageCreateFlags)(VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT);
*flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
/* As the server creates it (server_emu_bcn.c): decoded format, mutable, extended usage. */
*flags &= ~(VkImageCreateFlags)VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
*flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
*usage |= VK_IMAGE_USAGE_STORAGE_BIT;
return vkb_bc_storage_format(format);
return vkb_bc_view_format(format);
}
/* Image creation is rewritten on the server (it knows the decode); nothing to do here. */
+364
View File
@@ -0,0 +1,364 @@
#version 450
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* BCn block decoder for the Mali bridge's BC texture emulation. One invocation decodes one 4x4
* block from the copy's source buffer and stores it into the decoded image (a 2D array view of one
* mip level). The arithmetic follows bcdec (third_party/bcdec, MIT/Unlicense, Sergii Kudlai) so the
* output can be checked bit-for-bit against it. Built once per format family (FMT_BC1 ... FMT_BC7).
*/
layout(local_size_x = 8, local_size_y = 8) in;
layout(std430, binding = 0) readonly buffer Src { uint w[]; } src;
#if defined(FMT_BC6H)
layout(rgba16f, binding = 1) uniform writeonly image2DArray dst;
#elif defined(FMT_BC4)
layout(r8, binding = 1) uniform writeonly image2DArray dst;
#elif defined(FMT_BC5)
layout(rg8, binding = 1) uniform writeonly image2DArray dst;
#else
layout(rgba8, binding = 1) uniform writeonly image2DArray dst;
#endif
layout(push_constant) uniform PC {
uint src_word; /* first block, in 32-bit words from the bound range's start */
uint row_blocks; /* blocks per row in the buffer */
uint layer_blocks; /* blocks per layer in the buffer */
uint flags; /* 1: BC1 without alpha (alpha forced to 1); 2: signed (BC4/5/6H); first layer << 8 */
ivec2 dst_off; /* texel offset of the region in the image */
uvec2 extent; /* texels to write */
} pc;
#extension GL_GOOGLE_include_directive : require
#include "bc_tables.glsl"
uint bits(uvec4 b, uint pos, uint n)
{
if (n == 0u) return 0u;
uint wi = pos >> 5, o = pos & 31u;
uint v = b[wi] >> o;
if (o + n > 32u && wi < 3u) v |= b[wi + 1u] << (32u - o);
return n == 32u ? v : (v & ((1u << n) - 1u));
}
int sext(int v, int n) { return (v << (32 - n)) >> (32 - n); }
void put(uint tx, uint ty, vec4 v)
{
uvec2 blk = gl_GlobalInvocationID.xy;
uvec2 p = blk * 4u + uvec2(tx, ty);
if (p.x < pc.extent.x && p.y < pc.extent.y)
imageStore(dst, ivec3(pc.dst_off + ivec2(p), int(gl_GlobalInvocationID.z + (pc.flags >> 8))), v);
}
/* ------------------------------------------------------------------ BC1-3 */
uvec4 rgb565(uint c)
{
uint r = (c >> 11) & 31u, g = (c >> 5) & 63u, b = c & 31u;
return uvec4((r * 527u + 23u) >> 6, (g * 259u + 33u) >> 6, (b * 527u + 23u) >> 6, 255u);
}
void color_block(uint lo, uint idx, bool opaque, inout uvec4 texels[16])
{
uint c0 = lo & 0xffffu, c1 = lo >> 16;
uint r0 = (c0 >> 11) & 31u, g0 = (c0 >> 5) & 63u, b0 = c0 & 31u;
uint r1 = (c1 >> 11) & 31u, g1 = (c1 >> 5) & 63u, b1 = c1 & 31u;
uvec4 ref[4];
ref[0] = rgb565(c0);
ref[1] = rgb565(c1);
if (c0 > c1 || opaque) {
ref[2] = uvec4(((2u * r0 + r1) * 351u + 61u) >> 7, ((2u * g0 + g1) * 2763u + 1039u) >> 11, ((2u * b0 + b1) * 351u + 61u) >> 7, 255u);
ref[3] = uvec4(((r0 + r1 * 2u) * 351u + 61u) >> 7, ((g0 + g1 * 2u) * 2763u + 1039u) >> 11, ((b0 + b1 * 2u) * 351u + 61u) >> 7, 255u);
} else {
ref[2] = uvec4(((r0 + r1) * 1053u + 125u) >> 8, ((g0 + g1) * 4145u + 1019u) >> 11, ((b0 + b1) * 1053u + 125u) >> 8, 255u);
ref[3] = uvec4(0u);
}
for (uint t = 0u; t < 16u; t++) texels[t] = ref[(idx >> (2u * t)) & 3u];
}
/* BC3's alpha block as bcdec decodes it (integer division). */
void smooth_alpha(uint lo, uint hi, out uint a[16])
{
uint a0 = lo & 0xffu, a1 = (lo >> 8) & 0xffu;
uint pal[8];
pal[0] = a0;
pal[1] = a1;
if (a0 > a1) {
pal[2] = (6u * a0 + a1) / 7u; pal[3] = (5u * a0 + 2u * a1) / 7u; pal[4] = (4u * a0 + 3u * a1) / 7u;
pal[5] = (3u * a0 + 4u * a1) / 7u; pal[6] = (2u * a0 + 5u * a1) / 7u; pal[7] = (a0 + 6u * a1) / 7u;
} else {
pal[2] = (4u * a0 + a1) / 5u; pal[3] = (3u * a0 + 2u * a1) / 5u; pal[4] = (2u * a0 + 3u * a1) / 5u;
pal[5] = (a0 + 4u * a1) / 5u; pal[6] = 0u; pal[7] = 255u;
}
uvec4 b = uvec4(lo, hi, 0u, 0u);
for (uint t = 0u; t < 16u; t++) a[t] = pal[bits(b, 16u + 3u * t, 3u)];
}
/* BC4/BC5 channel (bcdec's precise variant), as the byte pattern of the unsigned/signed value. */
void bc4_channel(uint lo, uint hi, bool sgn, out uint v[16])
{
int e0, e1;
if (sgn) {
e0 = max(sext(int(lo & 0xffu), 8), -127);
e1 = max(sext(int((lo >> 8) & 0xffu), 8), -127);
} else {
e0 = int(lo & 0xffu);
e1 = int((lo >> 8) & 0xffu);
}
const int w6[6] = int[6](9363, 18724, 28086, 37450, 46812, 56173);
const int w4[4] = int[4](13107, 26215, 39321, 52429);
int pal[8];
pal[0] = e0;
pal[1] = e1;
if (e0 > e1) {
for (int i = 0; i < 6; i++) pal[2 + i] = (w6[5 - i] * e0 + w6[i] * e1 + 32768) >> 16;
} else {
for (int i = 0; i < 4; i++) pal[2 + i] = (w4[3 - i] * e0 + w4[i] * e1 + 32768) >> 16;
pal[6] = sgn ? -127 : 0;
pal[7] = sgn ? 127 : 255;
}
uvec4 b = uvec4(lo, hi, 0u, 0u);
for (uint t = 0u; t < 16u; t++) v[t] = uint(pal[bits(b, 16u + 3u * t, 3u)]) & 0xffu;
}
/* ------------------------------------------------------------------ BC6H */
int bc6_unquantize(int val, int nbits, bool sgn)
{
if (!sgn) {
if (nbits >= 15) return val;
if (val == 0) return 0;
if (val == (1 << nbits) - 1) return 0xffff;
return ((val << 16) + 0x8000) >> nbits;
}
if (nbits >= 16) return val;
int s = 0;
if (val < 0) { s = 1; val = -val; }
int unq;
if (val == 0) unq = 0;
else if (val >= (1 << (nbits - 1)) - 1) unq = 0x7fff;
else unq = ((val << 15) + 0x4000) >> (nbits - 1);
return s != 0 ? -unq : unq;
}
uint bc6_finish(int val, bool sgn)
{
if (!sgn) return uint((val * 31) >> 6);
val = val < 0 ? -(((-val) * 31) >> 5) : (val * 31) >> 5;
uint s = 0u;
if (val < 0) { s = 0x8000u; val = -val; }
return s | uint(val);
}
void bc6h(uvec4 blk, bool sgn)
{
uint pos = 0u;
uint code = bits(blk, 0u, 2u);
pos = 2u;
if (code > 1u) { code |= bits(blk, 2u, 3u) << 2; pos = 5u; }
int mode = BC6_MODE_OF_CODE[code];
if (mode < 0) {
for (uint t = 0u; t < 16u; t++) put(t & 3u, t >> 2, vec4(0.0, 0.0, 0.0, 1.0));
return;
}
int ep[12];
for (int i = 0; i < 12; i++) ep[i] = 0;
uint part_id = 0u;
for (uint e = BC6_LAYOUT_START[mode]; e < BC6_LAYOUT_START[mode + 1]; e++) {
uint d = BC6_LAYOUT[e];
uint target = d & 15u, n = (d >> 4) & 31u, sh = (d >> 9) & 31u;
uint v = bits(blk, pos, n);
pos += n;
if ((d & (1u << 14)) != 0u) v = bitfieldReverse(v) >> (32u - n);
if (target == 12u) part_id = v;
else ep[target] |= int(v << sh);
}
bool two = mode < 10;
int npts = two ? 4 : 2;
int w = BC6_BITS_W[mode];
if (sgn) { ep[0] = sext(ep[0], w); ep[4] = sext(ep[4], w); ep[8] = sext(ep[8], w); }
if ((mode != 9 && mode != 10) || sgn) {
for (int i = 1; i < npts; i++) {
ep[i] = sext(ep[i], BC6_BITS_DR[mode]);
ep[4 + i] = sext(ep[4 + i], BC6_BITS_DG[mode]);
ep[8 + i] = sext(ep[8 + i], BC6_BITS_DB[mode]);
}
}
if (mode != 9 && mode != 10) {
for (int i = 1; i < npts; i++) {
for (int c = 0; c < 3; c++) {
int v = (ep[c * 4 + i] + ep[c * 4]) & ((1 << w) - 1);
ep[c * 4 + i] = sgn ? sext(v, w) : v;
}
}
}
for (int i = 0; i < 12; i++) ep[i] = bc6_unquantize(ep[i], w, sgn);
const int w3[8] = int[8](0, 9, 18, 27, 37, 46, 55, 64);
const int w4[16] = int[16](0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64);
uint part = BC7_PART2[part_id], anchor = BC7_PART2_ANCHOR[part_id] & 15u;
for (uint t = 0u; t < 16u; t++) {
uint subset = two ? ((part >> (2u * t)) & 3u) : 0u;
uint nb = two ? 3u : 4u;
if (t == 0u || (two && subset == 1u && t == anchor)) nb--;
uint idx = bits(blk, pos, nb);
pos += nb;
int wt = two ? w3[idx] : w4[idx];
int s2 = int(subset) * 2;
uvec3 h;
for (int c = 0; c < 3; c++) {
int a = ep[c * 4 + s2], b = ep[c * 4 + s2 + 1];
h[c] = bc6_finish((a * (64 - wt) + b * wt + 32) >> 6, sgn);
}
put(t & 3u, t >> 2, vec4(unpackHalf2x16(h.x).x, unpackHalf2x16(h.y).x, unpackHalf2x16(h.z).x, 1.0));
}
}
/* ------------------------------------------------------------------ BC7 */
void bc7(uvec4 blk)
{
uint mode = 0u;
while (mode < 8u && bits(blk, mode, 1u) == 0u) mode++;
if (mode >= 8u) {
for (uint t = 0u; t < 16u; t++) put(t & 3u, t >> 2, vec4(0.0));
return;
}
uint pos = mode + 1u;
uint nparts = 1u, part_id = 0u, rotation = 0u, isel = 0u;
if (mode == 0u || mode == 1u || mode == 2u || mode == 3u || mode == 7u) {
nparts = (mode == 0u || mode == 2u) ? 3u : 2u;
uint pb = mode == 0u ? 4u : 6u;
part_id = bits(blk, pos, pb);
pos += pb;
}
uint neps = nparts * 2u;
if (mode == 4u || mode == 5u) {
rotation = bits(blk, pos, 2u);
pos += 2u;
if (mode == 4u) { isel = bits(blk, pos, 1u); pos += 1u; }
}
int cb = BC7_BITS_RGB[mode], ab = BC7_BITS_A[mode];
uint ep[6][4];
for (uint c = 0u; c < 3u; c++)
for (uint e = 0u; e < neps; e++) { ep[e][c] = bits(blk, pos, uint(cb)); pos += uint(cb); }
for (uint e = 0u; e < neps; e++) {
if (ab > 0) { ep[e][3] = bits(blk, pos, uint(ab)); pos += uint(ab); }
else ep[e][3] = 0u;
}
const uint has_pbits = 203u; /* 0b11001011 */
bool pbits = ((has_pbits >> mode) & 1u) != 0u || mode == 1u;
if (mode == 0u || mode == 1u || mode == 3u || mode == 6u || mode == 7u) {
for (uint e = 0u; e < neps; e++)
for (uint c = 0u; c < 4u; c++) ep[e][c] <<= 1;
if (mode == 1u) {
uint p0 = bits(blk, pos, 1u), p1 = bits(blk, pos + 1u, 1u);
pos += 2u;
for (uint c = 0u; c < 3u; c++) { ep[0][c] |= p0; ep[1][c] |= p0; ep[2][c] |= p1; ep[3][c] |= p1; }
} else {
for (uint e = 0u; e < neps; e++) {
uint p = bits(blk, pos, 1u);
pos += 1u;
for (uint c = 0u; c < 4u; c++) ep[e][c] |= p;
}
}
}
for (uint e = 0u; e < neps; e++) {
uint j = uint(cb) + ((has_pbits >> mode) & 1u);
for (uint c = 0u; c < 3u; c++) {
ep[e][c] = ep[e][c] << (8u - j);
ep[e][c] = (ep[e][c] | (ep[e][c] >> j)) & 0xffu;
}
j = uint(ab) + ((has_pbits >> mode) & 1u);
ep[e][3] = ep[e][3] << (8u - j);
ep[e][3] = (ep[e][3] | (ep[e][3] >> j)) & 0xffu;
if (ab == 0) ep[e][3] = 255u;
}
const uint w2[4] = uint[4](0u, 21u, 43u, 64u);
const uint w3[8] = uint[8](0u, 9u, 18u, 27u, 37u, 46u, 55u, 64u);
const uint w4[16] = uint[16](0u, 4u, 9u, 13u, 17u, 21u, 26u, 30u, 34u, 38u, 43u, 47u, 51u, 55u, 60u, 64u);
uint ib = (mode == 0u || mode == 1u) ? 3u : (mode == 6u ? 4u : 2u);
uint ib2 = mode == 4u ? 3u : (mode == 5u ? 2u : 0u);
uint part = nparts == 2u ? BC7_PART2[part_id] : (nparts == 3u ? BC7_PART3[part_id] : 0u);
uint anchors = nparts == 2u ? BC7_PART2_ANCHOR[part_id] : (nparts == 3u ? BC7_PART3_ANCHOR[part_id] : 0u);
uint idx1[16];
for (uint t = 0u; t < 16u; t++) {
uint subset = (part >> (2u * t)) & 3u;
uint nb = ib;
bool anchor = t == 0u || (subset == 1u && t == (anchors & 15u)) || (subset == 2u && t == (anchors >> 4));
if (anchor) nb--;
idx1[t] = bits(blk, pos, nb);
pos += nb;
}
for (uint t = 0u; t < 16u; t++) {
uint subset = (part >> (2u * t)) & 3u;
uint e0 = subset * 2u, e1 = e0 + 1u;
uint i1 = idx1[t];
uvec4 c;
if (ib2 == 0u) {
uint wt = ib == 2u ? w2[i1] : (ib == 3u ? w3[i1] : w4[i1]);
for (uint k = 0u; k < 4u; k++) c[k] = (ep[e0][k] * (64u - wt) + ep[e1][k] * wt + 32u) >> 6;
} else {
uint nb2 = t == 0u ? ib2 - 1u : ib2;
uint i2 = bits(blk, pos, nb2);
pos += nb2;
uint wa = ib == 2u ? w2[i1] : w3[i1];
uint wb = ib2 == 2u ? w2[i2] : w3[i2];
uint wc = isel == 0u ? wa : wb, wal = isel == 0u ? wb : wa;
for (uint k = 0u; k < 3u; k++) c[k] = (ep[e0][k] * (64u - wc) + ep[e1][k] * wc + 32u) >> 6;
c.w = (ep[e0][3] * (64u - wal) + ep[e1][3] * wal + 32u) >> 6;
}
if (rotation == 1u) c = c.agbr;
else if (rotation == 2u) c = c.rabg;
else if (rotation == 3u) c = c.rgab;
put(t & 3u, t >> 2, vec4(c) / 255.0);
}
}
/* ------------------------------------------------------------------ main */
void main()
{
uvec2 blk = gl_GlobalInvocationID.xy;
uvec2 nblk = (pc.extent + 3u) / 4u;
if (blk.x >= nblk.x || blk.y >= nblk.y) return;
#if defined(FMT_BC1) || defined(FMT_BC4)
uint words = 2u;
#else
uint words = 4u;
#endif
uint base = pc.src_word + (gl_GlobalInvocationID.z * pc.layer_blocks + blk.y * pc.row_blocks + blk.x) * words;
uvec4 b = uvec4(src.w[base], src.w[base + 1u], words > 2u ? src.w[base + 2u] : 0u, words > 2u ? src.w[base + 3u] : 0u);
bool sgn = (pc.flags & 2u) != 0u;
#if defined(FMT_BC1)
uvec4 tex[16];
color_block(b.x, b.y, false, tex);
for (uint t = 0u; t < 16u; t++) {
uvec4 c = tex[t];
if ((pc.flags & 1u) != 0u) c.w = 255u;
put(t & 3u, t >> 2, vec4(c) / 255.0);
}
#elif defined(FMT_BC2) || defined(FMT_BC3)
uvec4 tex[16];
color_block(b.z, b.w, true, tex);
uint a[16];
#if defined(FMT_BC2)
for (uint t = 0u; t < 16u; t++) a[t] = bits(b, 4u * t, 4u) * 17u;
#else
smooth_alpha(b.x, b.y, a);
#endif
for (uint t = 0u; t < 16u; t++) put(t & 3u, t >> 2, vec4(tex[t].rgb, a[t]) / 255.0);
#elif defined(FMT_BC4)
uint v[16];
bc4_channel(b.x, b.y, sgn, v);
for (uint t = 0u; t < 16u; t++) put(t & 3u, t >> 2, vec4(float(v[t]) / 255.0, 0.0, 0.0, 1.0));
#elif defined(FMT_BC5)
uint r[16], g[16];
bc4_channel(b.x, b.y, sgn, r);
bc4_channel(b.z, b.w, sgn, g);
for (uint t = 0u; t < 16u; t++) put(t & 3u, t >> 2, vec4(float(r[t]) / 255.0, float(g[t]) / 255.0, 0.0, 1.0));
#elif defined(FMT_BC6H)
bc6h(b, sgn);
#elif defined(FMT_BC7)
bc7(b);
#endif
}
+14
View File
@@ -0,0 +1,14 @@
/* Generated by gen_bc_tables.py from bcdec.h (MIT/Unlicense, Sergii Kudlai) - do not edit. */
const int BC6_MODE_OF_CODE[32] = int[32](0, 1, 2, 10, -1, -1, 3, 11, -1, -1, 4, 12, -1, -1, 5, 13, -1, -1, 6, -1, -1, -1, 7, -1, -1, -1, 8, -1, -1, -1, 9, -1);
const uint BC6_LAYOUT_START[15] = uint[15](0u, 20u, 44u, 63u, 84u, 105u, 125u, 145u, 167u, 189u, 213u, 219u, 228u, 237u, 246u);
const uint BC6_LAYOUT[246] = uint[246](2070u, 2074u, 2075u, 160u, 164u, 168u, 81u, 2071u, 70u, 85u, 27u, 71u, 89u, 539u, 74u, 82u, 1051u, 83u, 1563u, 92u, 2582u, 2071u, 2583u, 112u, 27u, 539u, 2074u, 116u, 2586u, 1051u, 2070u, 120u, 1563u, 2587u, 2075u, 97u, 70u, 101u, 71u, 105u, 74u, 98u, 99u, 92u, 160u, 164u, 168u, 81u, 5136u, 70u, 69u, 5140u, 27u, 71u, 73u, 5144u, 539u, 74u, 82u, 1051u, 83u, 1563u, 92u, 160u, 164u, 168u, 65u, 5136u, 2071u, 70u, 85u, 5140u, 71u, 73u, 5144u, 539u, 74u, 66u, 27u, 1051u, 67u, 2070u, 1563u, 92u, 160u, 164u, 168u, 65u, 5136u, 2074u, 70u, 69u, 5140u, 27u, 71u, 89u, 5144u, 74u, 66u, 539u, 1051u, 67u, 2075u, 1563u, 92u, 144u, 2074u, 148u, 2070u, 152u, 2075u, 81u, 2071u, 70u, 85u, 27u, 71u, 89u, 539u, 74u, 82u, 1051u, 83u, 1563u, 92u, 128u, 2071u, 2074u, 132u, 1051u, 2070u, 136u, 1563u, 2075u, 97u, 70u, 85u, 27u, 71u, 89u, 539u, 74u, 98u, 99u, 92u, 128u, 27u, 2074u, 132u, 2582u, 2070u, 136u, 2583u, 2075u, 81u, 2071u, 70u, 101u, 71u, 89u, 539u, 74u, 82u, 1051u, 83u, 1563u, 92u, 128u, 539u, 2074u, 132u, 2586u, 2070u, 136u, 2587u, 2075u, 81u, 2071u, 70u, 85u, 27u, 71u, 105u, 74u, 82u, 1051u, 83u, 1563u, 92u, 96u, 2071u, 27u, 539u, 2074u, 100u, 2582u, 2586u, 1051u, 2070u, 104u, 2583u, 1563u, 2587u, 2075u, 97u, 70u, 101u, 71u, 105u, 74u, 98u, 99u, 92u, 160u, 164u, 168u, 161u, 165u, 169u, 160u, 164u, 168u, 145u, 5136u, 149u, 5140u, 153u, 5144u, 160u, 164u, 168u, 129u, 21536u, 133u, 21540u, 137u, 21544u, 160u, 164u, 168u, 65u, 21600u, 69u, 21604u, 73u, 21608u);
const int BC6_BITS_W[14] = int[14](10, 7, 11, 11, 11, 9, 8, 8, 8, 6, 10, 11, 12, 16);
const int BC6_BITS_DR[14] = int[14](5, 6, 5, 4, 4, 5, 6, 5, 5, 6, 10, 9, 8, 4);
const int BC6_BITS_DG[14] = int[14](5, 6, 4, 5, 4, 5, 5, 6, 5, 6, 10, 9, 8, 4);
const int BC6_BITS_DB[14] = int[14](5, 6, 4, 4, 5, 5, 5, 5, 6, 6, 10, 9, 8, 4);
const uint BC7_PART2[64] = uint[64](1347440720u, 1077952576u, 1414812756u, 1414549568u, 1346387968u, 1431589968u, 1431588928u, 1414545408u, 1346371584u, 1431655504u, 1431584768u, 1413480448u, 1431655488u, 1431633920u, 1431655680u, 1426063360u, 1427439872u, 16468u, 352387072u, 4214868u, 16464u, 352649472u, 83951616u, 1079005268u, 4210768u, 83951872u, 336860180u, 85202000u, 18175040u, 5592320u, 352403540u, 88162640u, 1145324612u, 1426085120u, 289673540u, 84234320u, 89130320u, 286344260u, 1091846420u, 1141969220u, 352669780u, 17125440u, 84152400u, 88428880u, 339820820u, 1342506320u, 1094784020u, 1315840u, 267524u, 1070096u, 273944576u, 68486144u, 1346438420u, 1090851920u, 88166420u, 335888720u, 1090848020u, 1095782420u, 1073812820u, 1410662720u, 1347441920u, 5591120u, 353701904u, 1414792196u);
const uint BC7_PART2_ANCHOR[64] = uint[64](15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u, 2u, 8u, 2u, 2u, 8u, 8u, 15u, 2u, 8u, 2u, 2u, 8u, 8u, 2u, 2u, 15u, 15u, 6u, 8u, 2u, 8u, 15u, 15u, 2u, 8u, 2u, 2u, 2u, 15u, 15u, 6u, 6u, 2u, 6u, 8u, 15u, 15u, 2u, 2u, 15u, 15u, 15u, 15u, 15u, 2u, 2u, 15u);
const uint BC7_PART3[64] = uint[64](2858963024u, 1784303680u, 1515864576u, 1414570152u, 2779054080u, 2694860880u, 1431675040u, 1515868240u, 2857697280u, 2857719040u, 2863289600u, 2425393296u, 2492765332u, 2762253476u, 2846200912u, 705315408u, 2777960512u, 172118100u, 2779096320u, 1436590240u, 2829603924u, 1785348160u, 2762231808u, 437912832u, 5285028u, 2862977168u, 342452500u, 1768494080u, 2693105056u, 2860651540u, 1352967248u, 1784283648u, 2846195712u, 1351655592u, 2829094992u, 606348324u, 11162880u, 613566756u, 608801316u, 1352993360u, 1342874960u, 2863285316u, 1717960704u, 2778768800u, 1352683680u, 1764256040u, 1152035396u, 1717986816u, 2856600644u, 1420317864u, 2508232064u, 2526451200u, 2824098984u, 2157286784u, 2853442580u, 2526412800u, 2863272980u, 2689618080u, 2695210400u, 2516582400u, 1082146944u, 2846402984u, 2863311428u, 709513812u);
const uint BC7_PART3_ANCHOR[64] = uint[64](243u, 131u, 143u, 63u, 248u, 243u, 63u, 143u, 248u, 248u, 246u, 246u, 246u, 245u, 243u, 131u, 243u, 131u, 248u, 63u, 243u, 131u, 246u, 138u, 53u, 248u, 104u, 166u, 248u, 245u, 175u, 143u, 248u, 63u, 243u, 165u, 166u, 138u, 152u, 175u, 111u, 243u, 143u, 245u, 63u, 111u, 111u, 143u, 243u, 63u, 245u, 245u, 245u, 248u, 245u, 250u, 245u, 250u, 248u, 253u, 63u, 252u, 243u, 131u);
const int BC7_BITS_RGB[8] = int[8](4, 6, 5, 7, 5, 7, 7, 5);
const int BC7_BITS_A[8] = int[8](0, 0, 0, 0, 6, 8, 7, 5);
+20
View File
@@ -0,0 +1,20 @@
#!/bin/bash
# Compiles the BCn decoder variants into app/src/main/cpp/vkbridge/bc_spv.h (committed, so a build
# needs no shader compiler). Needs glslangValidator; regenerates bc_tables.glsl first.
set -eu
cd "$(dirname "$0")"
python3 gen_bc_tables.py
out=../../../app/src/main/cpp/vkbridge/bc_spv.h
tmp=$(mktemp -d)
{
echo "/* Generated by tools/vkbridge/shaders/build.sh from bc_decode.comp - do not edit. */"
echo "#pragma once"
echo "#include <stdint.h>"
} > "$out"
for f in BC1 BC2 BC3 BC4 BC5 BC6H BC7; do
name=spv_$(echo $f | tr A-Z a-z)
glslangValidator -V --target-env vulkan1.1 -DFMT_$f --vn "$name" -o "$tmp/$name.h" bc_decode.comp >/dev/null
grep -v '^ *//\|#pragma once' "$tmp/$name.h" | sed 's/^const uint32_t/static const uint32_t/' >> "$out"
done
rm -rf "$tmp"
echo "wrote $out"
+91
View File
@@ -0,0 +1,91 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-3.0-or-later
"""
Generates bc_tables.glsl from bcdec.h (third_party/bcdec, MIT/Unlicense): the BC6H per-mode bit
layouts (as a table instead of 14 hand-written cases) and the BC6H/BC7 partition and anchor tables.
BC6H layout entry (uint): target (r0..r3 = 0..3, g0..g3 = 4..7, b0..b3 = 8..11, partition = 12)
| nbits << 4 | shift << 9 | reversed << 14.
"""
import os
import re
here = os.path.dirname(os.path.abspath(__file__))
src = open(os.path.join(here, '..', 'third_party', 'bcdec', 'bcdec.h')).read()
# ---- BC6H modes
bc6 = src[src.rindex('BCDECDEF void bcdec_bc6h_half('):src.rindex('BCDECDEF void bcdec_bc6h_float(')]
cases = re.findall(r'case (0b[01]+): \{(.*?)\} break;', bc6, re.S)
comp = {'r': 0, 'g': 4, 'b': 8}
modes = {}
for code, body in cases:
entries = []
mode_idx = None
body = re.sub(r'/\*.*?\*/', '', body, flags=re.S)
for line in body.split('\n'):
line = line.split('/*')[0].strip()
if not line:
continue
m = re.match(r'mode = (\d+);', line)
if m:
mode_idx = int(m.group(1))
continue
m = re.match(r'partition = bcdec__bitstream_read_bits\(&bstream, (\d+)\);', line)
if m:
entries.append((12, int(m.group(1)), 0, 0))
continue
m = re.match(r'([rgb])\[(\d)\] \|= bcdec__bitstream_read_bit(s_r|s)?\(&bstream(?:, (\d+))?\)(?: << (\d+))?;', line)
if not m:
raise SystemExit(f'unparsed BC6H line: {line}')
c, i, kind, n, sh = m.groups()
nbits = int(n) if n else 1
entries.append((comp[c] + int(i), nbits, int(sh) if sh else 0, 1 if kind == 's_r' else 0))
modes[int(code, 2)] = (mode_idx, entries)
out = []
out.append('/* Generated by gen_bc_tables.py from bcdec.h (MIT/Unlicense, Sergii Kudlai) - do not edit. */')
code_to_mode = [-1] * 32
offsets, flat = [0] * 14, []
for code in sorted(modes, key=lambda c: modes[c][0]):
idx, entries = modes[code]
code_to_mode[code] = idx
offsets[idx] = len(flat)
for t, n, sh, rv in entries:
flat.append(t | (n << 4) | (sh << 9) | (rv << 14))
offsets.append(len(flat))
out.append(f'const int BC6_MODE_OF_CODE[32] = int[32]({", ".join(map(str, code_to_mode))});')
out.append(f'const uint BC6_LAYOUT_START[15] = uint[15]({", ".join(str(o) + "u" for o in offsets)});')
out.append(f'const uint BC6_LAYOUT[{len(flat)}] = uint[{len(flat)}]({", ".join(str(v) + "u" for v in flat)});')
def actual_bits(fn_src, rows):
m = re.search(r'static char actual_bits_count\[\d\]\[\d+\] = \{(.*?)\};', fn_src, re.S)
return [list(map(int, re.findall(r'-?\d+', r.split('/*')[0]))) for r in re.findall(r'\{([^{}]*)\}', m.group(1))][:rows]
ab6 = actual_bits(bc6, 4)
for k, name in enumerate(['W', 'DR', 'DG', 'DB']):
out.append(f'const int BC6_BITS_{name}[14] = int[14]({", ".join(map(str, ab6[k]))});')
# ---- partition tables (BC7's 2- and 3-subset; BC6H uses the first 32 of the 2-subset table)
bc7 = src[src.rindex('BCDECDEF void bcdec_bc7('):]
table = bc7[bc7.index('partition_sets[2][64][4][4] = {'):bc7.index('static int aWeight2')]
rows = re.findall(r'\{ \{([^}]*)\}, \{([^}]*)\}, \{([^}]*)\}, \{([^}]*)\} \}', table)
assert len(rows) == 128, len(rows)
for name, part in (('BC7_PART2', rows[:64]), ('BC7_PART3', rows[64:])):
packed, anchors = [], []
for r in part:
vals = [int(v) for row in r for v in row.split(',')]
word, anc = 0, [0, 0, 0]
for t, v in enumerate(vals):
word |= (v & 3) << (2 * t)
if v & 0x80:
anc[v & 3] = t
packed.append(word)
anchors.append(anc[1] | (anc[2] << 4))
out.append(f'const uint {name}[64] = uint[64]({", ".join(str(p) + "u" for p in packed)});')
out.append(f'const uint {name}_ANCHOR[64] = uint[64]({", ".join(str(a) + "u" for a in anchors)});')
ab7 = actual_bits(bc7, 2)
out.append(f'const int BC7_BITS_RGB[8] = int[8]({", ".join(map(str, ab7[0]))});')
out.append(f'const int BC7_BITS_A[8] = int[8]({", ".join(map(str, ab7[1]))});')
open(os.path.join(here, 'bc_tables.glsl'), 'w').write('\n'.join(out) + '\n')
print(f'bc_tables.glsl: {len(flat)} BC6H layout entries, {len(modes)} modes')
+319
View File
@@ -0,0 +1,319 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* bcn_check: uploads random blocks of every BC format (every BC6H and BC7 mode forced in turn),
* blits the texture to RGBA32F and compares each texel with bcdec's CPU decode. Run it natively
* (the GPU's own BC decoder) and through the bridge with BC emulated.
*/
#define VK_NO_PROTOTYPES
#include <vulkan/vulkan.h>
#include <dlfcn.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BCDEC_IMPLEMENTATION
#define BCDEC_BC4BC5_PRECISE
#include "../third_party/bcdec/bcdec.h"
#define TEX 64 /* 16x16 blocks */
static PFN_vkGetInstanceProcAddr gipa;
static VkInstance inst;
static VkPhysicalDevice pd;
static VkDevice dev;
static VkQueue queue;
static VkCommandPool pool;
static VkPhysicalDeviceMemoryProperties mp;
#define F(n) static PFN_##n n
F(vkCreateInstance); F(vkEnumeratePhysicalDevices); F(vkGetPhysicalDeviceMemoryProperties); F(vkCreateDevice);
F(vkGetDeviceProcAddr); F(vkGetPhysicalDeviceFeatures); F(vkGetPhysicalDeviceFormatProperties); F(vkGetDeviceQueue);
F(vkCreateCommandPool); F(vkAllocateCommandBuffers); F(vkBeginCommandBuffer); F(vkEndCommandBuffer); F(vkQueueSubmit);
F(vkQueueWaitIdle); F(vkCreateBuffer); F(vkGetBufferMemoryRequirements); F(vkAllocateMemory); F(vkBindBufferMemory);
F(vkMapMemory); F(vkCreateImage); F(vkGetImageMemoryRequirements); F(vkBindImageMemory); F(vkCmdPipelineBarrier);
F(vkCmdCopyBufferToImage); F(vkCmdBlitImage); F(vkCmdCopyImageToBuffer); F(vkDestroyImage); F(vkDestroyBuffer);
F(vkFreeMemory); F(vkGetPhysicalDeviceProperties);
#undef F
static uint32_t find_type(uint32_t bits, VkMemoryPropertyFlags want)
{
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
if ((bits & (1u << i)) && (mp.memoryTypes[i].propertyFlags & want) == want) return i;
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
if (bits & (1u << i)) return i;
return 0;
}
static VkDeviceMemory bind_mem(VkMemoryRequirements r, VkMemoryPropertyFlags want)
{
VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, r.size, find_type(r.memoryTypeBits, want)};
VkDeviceMemory m;
vkAllocateMemory(dev, &ai, NULL, &m);
return m;
}
static uint64_t rng = 0x9E3779B97F4A7C15ull;
static uint32_t rnd(void)
{
rng ^= rng << 13;
rng ^= rng >> 7;
rng ^= rng << 17;
return (uint32_t)(rng >> 16);
}
/* Random block; for BC6H/BC7 the mode is chosen by `mode` (cycled per block). */
static void make_block(VkFormat f, uint8_t *b, int bytes, int mode)
{
for (int i = 0; i < bytes; i++) b[i] = (uint8_t)rnd();
if (f == VK_FORMAT_BC7_UNORM_BLOCK) {
int m = mode % 8;
b[0] = (uint8_t)((b[0] & ~((1u << (m + 1)) - 1)) | (1u << m));
} else if (f == VK_FORMAT_BC6H_UFLOAT_BLOCK || f == VK_FORMAT_BC6H_SFLOAT_BLOCK) {
static const uint8_t codes[14] = {0, 1, 2, 6, 10, 14, 18, 22, 26, 30, 3, 7, 11, 15};
int c = codes[mode % 14];
if (c < 2) b[0] = (uint8_t)((b[0] & ~3u) | c);
else b[0] = (uint8_t)((b[0] & ~31u) | c);
}
}
static float h2f(uint16_t h)
{
uint32_t s = (h >> 15) & 1, e = (h >> 10) & 31, m = h & 1023;
float v;
if (e == 0) v = ldexpf((float)m, -24);
else if (e == 31) v = m ? NAN : INFINITY;
else v = ldexpf((float)(m | 1024), (int)e - 25);
return s ? -v : v;
}
/* Reference texel (RGBA float) at (x, y) of the texture made from `blocks`. */
static void reference(VkFormat f, const uint8_t *blocks, int bytes, int x, int y, float out[4])
{
const uint8_t *b = blocks + ((y / 4) * (TEX / 4) + (x / 4)) * bytes;
int tx = x & 3, ty = y & 3;
uint8_t px8[16 * 4];
int8_t spx[16 * 2];
uint16_t px16[16 * 3];
out[0] = out[1] = out[2] = 0;
out[3] = 1;
switch (f) {
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: bcdec_bc1(b, px8, 16); break;
case VK_FORMAT_BC2_UNORM_BLOCK: bcdec_bc2(b, px8, 16); break;
case VK_FORMAT_BC3_UNORM_BLOCK: bcdec_bc3(b, px8, 16); break;
case VK_FORMAT_BC7_UNORM_BLOCK: bcdec_bc7(b, px8, 16); break;
case VK_FORMAT_BC4_UNORM_BLOCK: bcdec_bc4(b, px8, 4, 0); out[0] = px8[ty * 4 + tx] / 255.0f; return;
case VK_FORMAT_BC4_SNORM_BLOCK: bcdec_bc4(b, spx, 4, 1); out[0] = fmaxf(spx[ty * 4 + tx] / 127.0f, -1.0f); return;
case VK_FORMAT_BC5_UNORM_BLOCK:
bcdec_bc5(b, px8, 8, 0);
out[0] = px8[(ty * 4 + tx) * 2] / 255.0f;
out[1] = px8[(ty * 4 + tx) * 2 + 1] / 255.0f;
return;
case VK_FORMAT_BC5_SNORM_BLOCK:
bcdec_bc5(b, spx, 8, 1);
out[0] = fmaxf(spx[(ty * 4 + tx) * 2] / 127.0f, -1.0f);
out[1] = fmaxf(spx[(ty * 4 + tx) * 2 + 1] / 127.0f, -1.0f);
return;
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
case VK_FORMAT_BC6H_SFLOAT_BLOCK:
bcdec_bc6h_half(b, px16, 12, f == VK_FORMAT_BC6H_SFLOAT_BLOCK);
for (int c = 0; c < 3; c++) out[c] = h2f(px16[(ty * 4 + tx) * 3 + c]);
return;
default: return;
}
for (int c = 0; c < 4; c++) out[c] = px8[(ty * 4 + tx) * 4 + c] / 255.0f;
}
static VkCommandBuffer begin(void)
{
VkCommandBufferAllocateInfo ai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1};
VkCommandBuffer cb;
vkAllocateCommandBuffers(dev, &ai, &cb);
VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, NULL};
vkBeginCommandBuffer(cb, &bi);
return cb;
}
static void barrier(VkCommandBuffer cb, VkImage img, VkImageLayout from, VkImageLayout to)
{
VkImageMemoryBarrier b = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT,
VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, from, to, VK_QUEUE_FAMILY_IGNORED,
VK_QUEUE_FAMILY_IGNORED, img, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, &b);
}
static int failures;
static void test_format(VkFormat f, const char *name, float tol)
{
int bytes = (f == VK_FORMAT_BC1_RGBA_UNORM_BLOCK || f == VK_FORMAT_BC4_UNORM_BLOCK || f == VK_FORMAT_BC4_SNORM_BLOCK) ? 8 : 16;
int nblocks = (TEX / 4) * (TEX / 4);
uint8_t *blocks = malloc((size_t)nblocks * bytes);
for (int i = 0; i < nblocks; i++) make_block(f, blocks + i * bytes, bytes, i);
VkFormatProperties fp;
vkGetPhysicalDeviceFormatProperties(pd, f, &fp);
if (!(fp.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT)) {
printf("SKIP %s: no blit from this format\n", name);
free(blocks);
return;
}
/* staging */
VkBufferCreateInfo bci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, 0, (VkDeviceSize)TEX * TEX * 16,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, NULL};
VkBuffer up, down;
vkCreateBuffer(dev, &bci, NULL, &up);
vkCreateBuffer(dev, &bci, NULL, &down);
VkMemoryRequirements r;
vkGetBufferMemoryRequirements(dev, up, &r);
VkDeviceMemory upm = bind_mem(r, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkBindBufferMemory(dev, up, upm, 0);
vkGetBufferMemoryRequirements(dev, down, &r);
VkDeviceMemory downm = bind_mem(r, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkBindBufferMemory(dev, down, downm, 0);
void *upp, *downp;
vkMapMemory(dev, upm, 0, VK_WHOLE_SIZE, 0, &upp);
vkMapMemory(dev, downm, 0, VK_WHOLE_SIZE, 0, &downp);
/* upload at an odd 16-byte offset with a padded row, to exercise the decoder's addressing */
const VkDeviceSize off = 48;
const uint32_t row_tex = TEX + 8;
memset(upp, 0xcd, (size_t)TEX * TEX * 16);
for (int by = 0; by < TEX / 4; by++)
memcpy((uint8_t *)upp + off + (size_t)by * (row_tex / 4) * bytes, blocks + (size_t)by * (TEX / 4) * bytes, (size_t)(TEX / 4) * bytes);
/* images */
VkImageCreateInfo ici = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, NULL, 0, VK_IMAGE_TYPE_2D, f, {TEX, TEX, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
VK_SHARING_MODE_EXCLUSIVE, 0, NULL, VK_IMAGE_LAYOUT_UNDEFINED};
VkImage bc, rgba;
if (vkCreateImage(dev, &ici, NULL, &bc) != VK_SUCCESS) {
printf("FAIL %s: cannot create the image\n", name);
failures++;
return;
}
VkMemoryRequirements ir;
vkGetImageMemoryRequirements(dev, bc, &ir);
VkDeviceMemory bcm = bind_mem(ir, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(dev, bc, bcm, 0);
ici.format = VK_FORMAT_R32G32B32A32_SFLOAT;
vkCreateImage(dev, &ici, NULL, &rgba);
vkGetImageMemoryRequirements(dev, rgba, &ir);
VkDeviceMemory rgbam = bind_mem(ir, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(dev, rgba, rgbam, 0);
VkCommandBuffer cb = begin();
barrier(cb, bc, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkBufferImageCopy c = {off, row_tex, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {TEX, TEX, 1}};
vkCmdCopyBufferToImage(cb, up, bc, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &c);
barrier(cb, bc, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
barrier(cb, rgba, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkImageBlit bl = {{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {{0, 0, 0}, {TEX, TEX, 1}}, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {{0, 0, 0}, {TEX, TEX, 1}}};
vkCmdBlitImage(cb, bc, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rgba, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bl, VK_FILTER_NEAREST);
barrier(cb, rgba, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
VkBufferImageCopy rb = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {TEX, TEX, 1}};
vkCmdCopyImageToBuffer(cb, rgba, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, down, 1, &rb);
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT};
vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &mb, 0, NULL, 0, NULL);
vkEndCommandBuffer(cb);
VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 1, &cb, 0, NULL};
vkQueueSubmit(queue, 1, &si, VK_NULL_HANDLE);
vkQueueWaitIdle(queue);
const float *got = downp;
int bad = 0, nan_skip = 0;
float worst = 0;
int wx = 0, wy = 0, wc = 0;
for (int y = 0; y < TEX; y++)
for (int x = 0; x < TEX; x++) {
float want[4];
reference(f, blocks, bytes, x, y, want);
for (int ch = 0; ch < 4; ch++) {
float g = got[(y * TEX + x) * 4 + ch], w = want[ch];
if (isnan(w) || isinf(w)) {
nan_skip++;
continue;
}
float d = fabsf(g - w);
float lim = (f == VK_FORMAT_BC6H_UFLOAT_BLOCK || f == VK_FORMAT_BC6H_SFLOAT_BLOCK) ? tol * fmaxf(1.0f, fabsf(w)) : tol;
if (!(d <= lim)) {
bad++;
if (!(d <= worst)) {
worst = d;
wx = x;
wy = y;
wc = ch;
}
}
}
}
if (bad) {
float want[4];
reference(f, blocks, bytes, wx, wy, want);
printf("FAIL %s: %d of %d values differ from bcdec; worst %.4f at (%d,%d) ch %d: got %g want %g (block mode byte 0x%02x)\n", name, bad,
TEX * TEX * 4, worst, wx, wy, wc, got[(wy * TEX + wx) * 4 + wc], want[wc],
blocks[((wy / 4) * (TEX / 4) + (wx / 4)) * bytes]);
failures++;
} else {
printf("PASS %s: %d texels match bcdec%s\n", name, TEX * TEX, nan_skip ? " (inf/nan references skipped)" : "");
}
vkDestroyImage(dev, bc, NULL);
vkDestroyImage(dev, rgba, NULL);
vkDestroyBuffer(dev, up, NULL);
vkDestroyBuffer(dev, down, NULL);
vkFreeMemory(dev, upm, NULL);
vkFreeMemory(dev, downm, NULL);
vkFreeMemory(dev, bcm, NULL);
vkFreeMemory(dev, rgbam, NULL);
free(blocks);
}
int main(int argc, char **argv)
{
int gpu = argc > 1 ? atoi(argv[1]) : 0;
void *lib = dlopen("libvulkan.so.1", RTLD_NOW);
gipa = (PFN_vkGetInstanceProcAddr)dlsym(lib, "vkGetInstanceProcAddr");
#define G(n) n = (PFN_##n)gipa(inst, #n)
G(vkCreateInstance);
VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO, NULL, "bcn_check", 1, NULL, 0, VK_API_VERSION_1_1};
VkInstanceCreateInfo ici = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, NULL, 0, &app, 0, NULL, 0, NULL};
if (vkCreateInstance(&ici, NULL, &inst)) return 2;
G(vkEnumeratePhysicalDevices); G(vkGetPhysicalDeviceMemoryProperties); G(vkCreateDevice); G(vkGetDeviceProcAddr);
G(vkGetPhysicalDeviceFeatures); G(vkGetPhysicalDeviceFormatProperties); G(vkGetPhysicalDeviceProperties);
uint32_t n = 8;
VkPhysicalDevice pds[8];
vkEnumeratePhysicalDevices(inst, &n, pds);
pd = pds[gpu];
VkPhysicalDeviceProperties props;
vkGetPhysicalDeviceProperties(pd, &props);
VkPhysicalDeviceFeatures feats;
vkGetPhysicalDeviceFeatures(pd, &feats);
printf("%s, textureCompressionBC=%u\n", props.deviceName, feats.textureCompressionBC);
if (!feats.textureCompressionBC) return 1;
vkGetPhysicalDeviceMemoryProperties(pd, &mp);
float prio = 1;
VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, NULL, 0, 0, 1, &prio};
VkPhysicalDeviceFeatures en = {0};
en.textureCompressionBC = VK_TRUE;
VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, NULL, 0, 1, &qci, 0, NULL, 0, NULL, &en};
if (vkCreateDevice(pd, &dci, NULL, &dev)) return 2;
#undef G
#define G(n) n = (PFN_##n)vkGetDeviceProcAddr(dev, #n)
G(vkGetDeviceQueue); G(vkCreateCommandPool); G(vkAllocateCommandBuffers); G(vkBeginCommandBuffer); G(vkEndCommandBuffer);
G(vkQueueSubmit); G(vkQueueWaitIdle); G(vkCreateBuffer); G(vkGetBufferMemoryRequirements); G(vkAllocateMemory);
G(vkBindBufferMemory); G(vkMapMemory); G(vkCreateImage); G(vkGetImageMemoryRequirements); G(vkBindImageMemory);
G(vkCmdPipelineBarrier); G(vkCmdCopyBufferToImage); G(vkCmdBlitImage); G(vkCmdCopyImageToBuffer); G(vkDestroyImage);
G(vkDestroyBuffer); G(vkFreeMemory);
#undef G
vkGetDeviceQueue(dev, 0, 0, &queue);
VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, 0};
vkCreateCommandPool(dev, &pci, NULL, &pool);
float u8 = 1.5f / 255.0f;
test_format(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, "BC1", u8);
test_format(VK_FORMAT_BC2_UNORM_BLOCK, "BC2", u8);
test_format(VK_FORMAT_BC3_UNORM_BLOCK, "BC3", u8);
test_format(VK_FORMAT_BC4_UNORM_BLOCK, "BC4 unorm", u8);
test_format(VK_FORMAT_BC4_SNORM_BLOCK, "BC4 snorm", 1.5f / 127.0f);
test_format(VK_FORMAT_BC5_UNORM_BLOCK, "BC5 unorm", u8);
test_format(VK_FORMAT_BC5_SNORM_BLOCK, "BC5 snorm", 1.5f / 127.0f);
test_format(VK_FORMAT_BC6H_UFLOAT_BLOCK, "BC6H ufloat (all 14 modes)", 0.002f);
test_format(VK_FORMAT_BC6H_SFLOAT_BLOCK, "BC6H sfloat (all 14 modes)", 0.002f);
test_format(VK_FORMAT_BC7_UNORM_BLOCK, "BC7 (all 8 modes)", u8);
printf("%s\n", failures ? "FAILED" : "OK");
return failures ? 1 : 0;
}
File diff suppressed because it is too large. Load diff