mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 05:16:01 +00:00
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:
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
@@ -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)
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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 = ®s[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;
|
||||
}
|
||||
@@ -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; }
|
||||
@@ -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 *)®ions[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);
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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. */
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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);
|
||||
Executable
+20
@@ -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"
|
||||
@@ -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')
|
||||
@@ -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;
|
||||
}
|
||||
+1512
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user