mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-21 04:55:56 +00:00
Skip BC3 texel writes that end inside a block, and check the BC3 encoder in --probe-astc
A BC3 image takes whole 4x4 blocks or a part ending on the mip's edge; a WriteTexels region of a 5x5 or 6x6 footprint may end inside one. --probe-astc encodes every footprint to BC3 and holds the blocks to alpha, palette-place, flat-colour and PSNR bounds. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
c67ef58763
commit
67b1c03b0d
2 files changed
+152
-7
No files matched your search
+146
-6
@@ -3,8 +3,10 @@
|
||||
// HDR void extents, random blocks kept by what they exercise (1-4 partitions, dual plane with 1-3 partitions, every
|
||||
// weight grid and quantization the random modes reach), then plain random blocks (mostly error blocks, HDR endpoint
|
||||
// modes among them). Each case decodes two regions into two mip levels of an RGBA8 image with cropped edges, and
|
||||
// compares both the decoder's texels (readback) and what the image holds afterwards. Also times one 2048x2048 texture
|
||||
// on the CPU (astc_decode_ldr_mt) and on the GPU (wall time of the upload batch).
|
||||
// compares both the decoder's texels (readback) and what the image holds afterwards. The same regions also go through
|
||||
// the BC3 encoder (TOTK_ASTC_BC) into a BC3 image, whose blocks are decoded here and held to error bounds (bc_check).
|
||||
// Also times one 2048x2048 texture on the CPU (astc_decode_ldr_mt) and on the GPU (wall time of the upload batch).
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -26,7 +28,8 @@ static const uint8_t dims[14][2] = {{4, 4}, {5, 4}, {5, 5}, {6, 5}, {6, 6}, {8,
|
||||
// Buckets of valid blocks: partitions 1-4 single plane, then dual plane with 1-3 partitions.
|
||||
enum { NB = 7, PER_BUCKET = 48 };
|
||||
static const char *const bucket_name[NB] = {"1p", "2p", "3p", "4p", "dual 1p", "dual 2p", "dual 3p"};
|
||||
static uint64_t g_bucket[NB], g_void, g_err, g_blocks, g_texels;
|
||||
static uint64_t g_bucket[NB], g_void, g_err, g_blocks, g_texels, g_bc_cases;
|
||||
static double g_bc_db = 99; // the lowest BC3 PSNR of all cases
|
||||
|
||||
static int dual_bit(uint32_t m) {
|
||||
if (!(m & 3) && (m >> 7 & 3) == 2) return 0; // the 6..10 x 6..10 modes have no dual plane
|
||||
@@ -77,9 +80,9 @@ typedef struct {
|
||||
VmaAllocation alloc;
|
||||
} Img;
|
||||
|
||||
static int make_image(VkCtx *c, uint32_t w, uint32_t h, uint32_t levels, int srgb, Img *o) {
|
||||
static int make_image(VkCtx *c, uint32_t w, uint32_t h, uint32_t levels, VkFormat format, Img *o) {
|
||||
VkImageCreateInfo ci = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .imageType = VK_IMAGE_TYPE_2D,
|
||||
.format = srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM, .extent = {w, h, 1},
|
||||
.format = format, .extent = {w, h, 1},
|
||||
.mipLevels = levels, .arrayLayers = 1, .samples = VK_SAMPLE_COUNT_1_BIT,
|
||||
.tiling = VK_IMAGE_TILING_OPTIMAL,
|
||||
.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
|
||||
@@ -120,7 +123,7 @@ static double now_ms(void) {
|
||||
static int gpu_decode(VkCtx *c, const uint8_t *blk, size_t n0, size_t n1, uint32_t w0, uint32_t h0, uint32_t w1,
|
||||
uint32_t h1, uint32_t bw, uint32_t bh, int srgb, uint8_t *out_rb, uint8_t *out_img, double *ms) {
|
||||
Img im;
|
||||
if (!make_image(c, w0, h0, 2, srgb, &im)) return 0;
|
||||
if (!make_image(c, w0, h0, 2, srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM, &im)) return 0;
|
||||
size_t t0 = (size_t)w0 * h0 * 4, t1 = (size_t)w1 * h1 * 4;
|
||||
VkCommandBuffer cb = vk_upload_begin();
|
||||
VkBuffer sb, rb, ib;
|
||||
@@ -152,6 +155,123 @@ static int gpu_decode(VkCtx *c, const uint8_t *blk, size_t n0, size_t n1, uint32
|
||||
return ok;
|
||||
}
|
||||
|
||||
// The same two regions decoded and encoded to BC3 (TOTK_ASTC_BC) into a BC3 image; out: its blocks read back, level 0
|
||||
// then level 1, rows of 4x4 blocks. 0 on a Vulkan failure or when nothing was recorded.
|
||||
static int gpu_bc(VkCtx *c, const uint8_t *blk, size_t n0, size_t n1, uint32_t w0, uint32_t h0, uint32_t w1, uint32_t h1,
|
||||
uint32_t bw, uint32_t bh, int srgb, uint8_t *out) {
|
||||
Img im;
|
||||
if (!make_image(c, w0, h0, 2, srgb ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK, &im)) return 0;
|
||||
size_t b0 = (size_t)((w0 + 3) / 4) * ((h0 + 3) / 4) * 16, b1 = (size_t)((w1 + 3) / 4) * ((h1 + 3) / 4) * 16;
|
||||
VkCommandBuffer cb = vk_upload_begin();
|
||||
VkBuffer sb, ib;
|
||||
VmaAllocation ia;
|
||||
uint8_t *stg = vk_staging((n0 + n1) * 16, &sb, NULL), *imap = vk_staging(b0 + b1, &ib, &ia);
|
||||
memcpy(stg, blk, (n0 + n1) * 16);
|
||||
to_general(cb, im.img);
|
||||
VkAstcRegion ar[2] = {{.src = 0, .w = w0, .h = h0, .slices = 1, .level = 0},
|
||||
{.src = n0 * 16, .w = w1, .h = h1, .slices = 1, .level = 1}};
|
||||
barrier(cb, ALL_RW, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT);
|
||||
int ok = vk_astc_record(cb, sb, (n0 + n1) * 16, ar, 2, bw, bh, srgb, 1, im.img, VK_IMAGE_ASPECT_COLOR_BIT, VK_NULL_HANDLE);
|
||||
barrier(cb, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, ALL_RW);
|
||||
VkBufferImageCopy cp[2] = {{.bufferOffset = 0, .imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .imageExtent = {w0, h0, 1}},
|
||||
{.bufferOffset = b0, .imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 1, 0, 1}, .imageExtent = {w1, h1, 1}}};
|
||||
vkCmdCopyImageToBuffer(cb, im.img, VK_IMAGE_LAYOUT_GENERAL, ib, 2, cp);
|
||||
barrier(cb, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_READ_BIT);
|
||||
vk_upload_end();
|
||||
vk_upload_flush(1);
|
||||
vmaInvalidateAllocation(c->vma, ia, 0, VK_WHOLE_SIZE);
|
||||
memcpy(out, imap, b0 + b1);
|
||||
vmaDestroyBuffer(c->vma, ib, ia);
|
||||
vk_defer_image(im.img, im.alloc);
|
||||
vk_upload_flush(1);
|
||||
return ok;
|
||||
}
|
||||
|
||||
// One BC3 block to 16 RGBA8 texels, as the format defines it (565 endpoints widened by bit replication; the colour
|
||||
// block always in four-colour mode). pos: each texel's place on the line from endpoint 0 (0) to endpoint 1 (3).
|
||||
static void bc3_decode(const uint8_t b[16], uint8_t t[16][4], uint8_t ep[2][3], int pos[16]) {
|
||||
uint8_t a[8] = {b[0], b[1]}, p[4][3];
|
||||
if (a[0] > a[1])
|
||||
for (int i = 1; i < 7; i++) a[i + 1] = (uint8_t)(((7 - i) * a[0] + i * a[1] + 3) / 7);
|
||||
else {
|
||||
for (int i = 1; i < 5; i++) a[i + 1] = (uint8_t)(((5 - i) * a[0] + i * a[1] + 2) / 5);
|
||||
a[6] = 0, a[7] = 255;
|
||||
}
|
||||
uint64_t ai = 0;
|
||||
for (int i = 0; i < 6; i++) ai |= (uint64_t)b[2 + i] << 8 * i;
|
||||
for (int k = 0; k < 2; k++) {
|
||||
unsigned v = b[8 + 2 * k] | b[9 + 2 * k] << 8, r = v >> 11, g = v >> 5 & 63, bl = v & 31;
|
||||
p[k][0] = (uint8_t)(r << 3 | r >> 2), p[k][1] = (uint8_t)(g << 2 | g >> 4), p[k][2] = (uint8_t)(bl << 3 | bl >> 2);
|
||||
}
|
||||
for (int ch = 0; ch < 3; ch++)
|
||||
p[2][ch] = (uint8_t)((2 * p[0][ch] + p[1][ch] + 1) / 3), p[3][ch] = (uint8_t)((p[0][ch] + 2 * p[1][ch] + 1) / 3);
|
||||
uint32_t ci = b[12] | b[13] << 8 | b[14] << 16 | (uint32_t)b[15] << 24;
|
||||
static const int code_pos[4] = {0, 3, 1, 2};
|
||||
for (int i = 0; i < 16; i++) {
|
||||
memcpy(t[i], p[ci >> 2 * i & 3], 3);
|
||||
t[i][3] = a[ai >> 3 * i & 7];
|
||||
pos[i] = code_pos[ci >> 2 * i & 3];
|
||||
}
|
||||
memcpy(ep, p, 6);
|
||||
}
|
||||
|
||||
// BC3 is lossy, so these are bounds, not bit-exactness. In every block: alpha within a fourteenth of the block's alpha
|
||||
// range (the eight-value mode's half step); each texel on the palette entry nearest its projection onto the endpoint
|
||||
// line (within rounding, when the endpoints are apart); a block of one colour within the 565 rounding, alpha exact.
|
||||
// Per level, a PSNR floor against astc_decode_ldr for gross damage: the random blocks are noise, so it is low (19 dB
|
||||
// at worst for 5x5 level 1 on an RX 9070). *db: the level's PSNR.
|
||||
enum { BC_MIN_DB = 15 };
|
||||
static int bc_check(const uint8_t *want, const uint8_t *blocks, uint32_t w, uint32_t h, const char *what, double *db) {
|
||||
uint32_t bx = (w + 3) / 4, by = (h + 3) / 4;
|
||||
double se = 0;
|
||||
for (uint32_t y4 = 0; y4 < by; y4++)
|
||||
for (uint32_t x4 = 0; x4 < bx; x4++) {
|
||||
uint8_t t[16][4], ep[2][3], lo[4] = {255, 255, 255, 255}, hi[4] = {0};
|
||||
int pos[16];
|
||||
bc3_decode(blocks + 16 * ((size_t)y4 * bx + x4), t, ep, pos);
|
||||
double axis[3], len2 = 0;
|
||||
for (int ch = 0; ch < 3; ch++) axis[ch] = (double)ep[1][ch] - ep[0][ch], len2 += axis[ch] * axis[ch];
|
||||
for (int pass = 0; pass < 2; pass++)
|
||||
for (int i = 0; i < 16; i++) {
|
||||
uint32_t x = x4 * 4 + (i & 3), y = y4 * 4 + (i >> 2);
|
||||
if (x >= w || y >= h) continue;
|
||||
const uint8_t *s = want + 4 * ((size_t)y * w + x);
|
||||
if (!pass) {
|
||||
for (int ch = 0; ch < 4; ch++) lo[ch] = s[ch] < lo[ch] ? s[ch] : lo[ch], hi[ch] = s[ch] > hi[ch] ? s[ch] : hi[ch];
|
||||
continue;
|
||||
}
|
||||
int flat = !memcmp(lo, hi, 4), lim[4] = {5, 3, 5, 0};
|
||||
if (len2 >= 64) { // shorter lines: rounding alone can move a texel to the next entry
|
||||
double proj = 0;
|
||||
for (int ch = 0; ch < 3; ch++) proj += ((double)s[ch] - ep[0][ch]) * axis[ch];
|
||||
proj = proj / len2 * 3;
|
||||
proj = proj < 0 ? 0 : proj > 3 ? 3 : proj;
|
||||
if (fabs(pos[i] - proj) > 0.75) { // a wrong code mapping is a whole place off
|
||||
printf("probe-astc: FAIL BC3 %s: texel (%u,%u) on palette place %d, its projection is %.2f\n",
|
||||
what, x, y, pos[i], proj);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
for (int ch = 0; ch < 4; ch++) {
|
||||
int d = abs((int)t[i][ch] - s[ch]);
|
||||
se += (double)d * d;
|
||||
if ((ch == 3 && d > (hi[3] - lo[3]) / 14 + 1) || (flat && d > lim[ch])) {
|
||||
printf("probe-astc: FAIL BC3 %s: texel (%u,%u) channel %d: astc %02x%02x%02x%02x bc3 %02x%02x%02x%02x\n",
|
||||
what, x, y, ch, s[0], s[1], s[2], s[3], t[i][0], t[i][1], t[i][2], t[i][3]);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
double mse = se / ((double)w * h * 4);
|
||||
*db = mse > 0 ? 10 * log10(255.0 * 255.0 / mse) : 99;
|
||||
if (*db < BC_MIN_DB) {
|
||||
printf("probe-astc: FAIL BC3 %s: PSNR %.1f dB, below %d\n", what, *db, BC_MIN_DB);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int first_diff(const uint8_t *a, const uint8_t *b, size_t texels, size_t *at) {
|
||||
for (size_t i = 0; i < texels; i++)
|
||||
if (memcmp(a + 4 * i, b + 4 * i, 4)) { *at = i; return 1; }
|
||||
@@ -189,6 +309,22 @@ static int test_case(VkCtx *c, uint32_t bw, uint32_t bh, int srgb) {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!bad && vk_astc_bc()) {
|
||||
size_t b0 = (size_t)((w0 + 3) / 4) * ((h0 + 3) / 4) * 16, b1 = (size_t)((w1 + 3) / 4) * ((h1 + 3) / 4) * 16;
|
||||
uint8_t *bc = malloc(b0 + b1);
|
||||
char what[2][48];
|
||||
double db[2] = {0, 0};
|
||||
for (int lv = 0; lv < 2; lv++) snprintf(what[lv], sizeof what[lv], "%ux%u %s level %d", bw, bh, srgb ? "sRGB" : "linear", lv);
|
||||
if (!gpu_bc(c, blk, n0, n1, w0, h0, w1, h1, bw, bh, srgb, bc)) {
|
||||
printf("probe-astc: FAIL BC3 %s: the encode was not recorded\n", what[0]);
|
||||
bad = 1;
|
||||
}
|
||||
bad = bad || bc_check(want, bc, w0, h0, what[0], &db[0]) || bc_check(want + t0 * 4, bc + b0, w1, h1, what[1], &db[1]);
|
||||
for (int lv = 0; lv < 2 && !bad; lv++)
|
||||
if (db[lv] < g_bc_db) g_bc_db = db[lv];
|
||||
g_bc_cases += !bad;
|
||||
free(bc);
|
||||
}
|
||||
g_blocks += n0 + n1, g_texels += t0 + t1;
|
||||
free(blk), free(want), free(rb), free(im);
|
||||
return bad;
|
||||
@@ -223,6 +359,7 @@ static void timing(VkCtx *c, uint32_t bw, uint32_t bh) {
|
||||
}
|
||||
|
||||
int probe_astc(void) {
|
||||
_putenv_s("TOTK_ASTC_BC", "1"); // also builds the BC3 encoder; the RGBA8 cases pass bc 0 and do not use it
|
||||
if (!vk_init()) { printf("probe-astc: FAIL vk_init\n"); return 1; }
|
||||
VkCtx *c = vk_ctx();
|
||||
printf("probe-astc: GPU %s, textureCompressionASTC_LDR %d, mode %d\n", c->props.deviceName, c->has_astc_ldr,
|
||||
@@ -236,6 +373,9 @@ int probe_astc(void) {
|
||||
for (int s = 0; s < 2 && !bad; s++) bad = test_case(c, dims[i][0], dims[i][1], s);
|
||||
for (int b = 0; b < NB && !bad; b++)
|
||||
if (!g_bucket[b]) { printf("probe-astc: FAIL no valid %s block was generated\n", bucket_name[b]); bad = 1; }
|
||||
if (!bad && !vk_astc_bc()) printf("probe-astc: BC3 encoder not available on this device: not checked\n");
|
||||
else if (!bad) printf("probe-astc: BC3 encode: %llu cases within the bounds, lowest PSNR %.1f dB (floor %d)\n",
|
||||
(unsigned long long)g_bc_cases, g_bc_db, BC_MIN_DB);
|
||||
if (!bad) {
|
||||
timing(c, 4, 4);
|
||||
timing(c, 6, 6);
|
||||
|
||||
@@ -1216,7 +1216,12 @@ static int image_texels(Tex *e, const Region *g, const NVNcopyRegion *r, uint8_t
|
||||
vmaFlushAllocation(c->vma, sa, 0, VK_WHOLE_SIZE);
|
||||
barrier(cb, ALL_RW, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT);
|
||||
int done = 0;
|
||||
if (agpu) {
|
||||
// A BC3 image takes whole 4x4 blocks, or a part that ends on the mip's edge; a region of a 5x5 or 6x6 footprint
|
||||
// may end inside a block (vk_astc_record checks the start corner).
|
||||
uint32_t mw = e->t.d.width >> g->level, mh = e->t.d.height >> g->level;
|
||||
int bc_cut = e->f.astc_bc && (((w & 3) && (uint32_t)r->xoffset + w != (mw ? mw : 1)) ||
|
||||
((h & 3) && (uint32_t)r->yoffset + h != (mh ? mh : 1)));
|
||||
if (agpu && !bc_cut) { // bc_cut: nothing recorded, logged below as not decoded
|
||||
VkAstcRegion *ar = calloc((size_t)g->nz, sizeof *ar);
|
||||
for (int z = 0; z < g->nz; z++)
|
||||
ar[z] = (VkAstcRegion){.src = slice * (size_t)z, .w = w, .h = h, .slices = 1, .level = rg[z].imageSubresource.mipLevel,
|
||||
|
||||
Reference in new issue
Block a user