diff --git a/runtime/astc_probe.c b/runtime/astc_probe.c index 4728a5ef..e6e6f51c 100644 --- a/runtime/astc_probe.c +++ b/runtime/astc_probe.c @@ -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 #include #include #include @@ -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); diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index a75c9523..99db3f5c 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -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,