astc_decoder: Refactor for style and more efficient memory use

src/video_core/CMakeLists.txt

@@ -236,7 +236,6 @@ add_library(video_core STATIC
     texture_cache/types.h
     texture_cache/util.cpp
     texture_cache/util.h
-    textures/astc.cpp
     textures/astc.h
     textures/decoders.cpp
     textures/decoders.h

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -307,7 +307,7 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4
 
 [[nodiscard]] bool CanBeAccelerated(const TextureCacheRuntime& runtime,
                                     const VideoCommon::ImageInfo& info) {
-    return (!runtime.HasNativeASTC() && IsPixelFormatASTC(info.format));
+    return !runtime.HasNativeASTC() && IsPixelFormatASTC(info.format);
     // Disable other accelerated uploads for now as they don't implement swizzled uploads
     return false;
     switch (info.type) {
@@ -568,12 +568,13 @@ void TextureCacheRuntime::BlitFramebuffer(Framebuffer* dst, Framebuffer* src,
 
 void TextureCacheRuntime::AccelerateImageUpload(Image& image, const ImageBufferMap& map,
                                                 std::span<const SwizzleParameters> swizzles) {
-    if (IsPixelFormatASTC(image.info.format)) {
-        return util_shaders.ASTCDecode(image, map, swizzles);
-    }
     switch (image.info.type) {
     case ImageType::e2D:
-        return util_shaders.BlockLinearUpload2D(image, map, swizzles);
+        if (IsPixelFormatASTC(image.info.format)) {
+            return util_shaders.ASTCDecode(image, map, swizzles);
+        } else {
+            return util_shaders.BlockLinearUpload2D(image, map, swizzles);
+        }
     case ImageType::e3D:
         return util_shaders.BlockLinearUpload3D(image, map, swizzles);
     case ImageType::Linear:

src/video_core/renderer_opengl/util_shaders.cpp

@@ -2,11 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <bit>
-#include <fstream>
 #include <span>
-#include <streambuf>
-#include <string>
 #include <string_view>
 
 #include <glad/glad.h>
@@ -24,7 +20,6 @@
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_texture_cache.h"
 #include "video_core/renderer_opengl/util_shaders.h"
-#include "video_core/surface.h"
 #include "video_core/texture_cache/accelerated_swizzle.h"
 #include "video_core/texture_cache/types.h"
 #include "video_core/texture_cache/util.h"
@@ -36,6 +31,7 @@ namespace OpenGL {
 using namespace HostShaders;
 using namespace Tegra::Texture::ASTC;
 
+using VideoCommon::Extent2D;
 using VideoCommon::Extent3D;
 using VideoCommon::ImageCopy;
 using VideoCommon::ImageType;
@@ -69,33 +65,15 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
       pitch_unswizzle_program(MakeProgram(PITCH_UNSWIZZLE_COMP)),
       copy_bgra_program(MakeProgram(OPENGL_COPY_BGRA_COMP)),
       copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)) {
-    MakeBuffers();
+    const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
+    swizzle_table_buffer.Create();
+    astc_buffer.Create();
+    glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
+    glNamedBufferStorage(astc_buffer.handle, sizeof(ASTC_BUFFER_DATA), &ASTC_BUFFER_DATA, 0);
 }
 
 UtilShaders::~UtilShaders() = default;
 
-void UtilShaders::MakeBuffers() {
-    const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
-    swizzle_table_buffer.Create();
-    glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
-
-    astc_encodings_buffer.Create();
-    glNamedBufferStorage(astc_encodings_buffer.handle, sizeof(EncodingsValues), &EncodingsValues,
-                         0);
-    replicate_6_to_8_buffer.Create();
-    glNamedBufferStorage(replicate_6_to_8_buffer.handle, sizeof(REPLICATE_6_BIT_TO_8_TABLE),
-                         &REPLICATE_6_BIT_TO_8_TABLE, 0);
-    replicate_7_to_8_buffer.Create();
-    glNamedBufferStorage(replicate_7_to_8_buffer.handle, sizeof(REPLICATE_7_BIT_TO_8_TABLE),
-                         &REPLICATE_7_BIT_TO_8_TABLE, 0);
-    replicate_8_to_8_buffer.Create();
-    glNamedBufferStorage(replicate_8_to_8_buffer.handle, sizeof(REPLICATE_8_BIT_TO_8_TABLE),
-                         &REPLICATE_8_BIT_TO_8_TABLE, 0);
-    replicate_byte_to_16_buffer.Create();
-    glNamedBufferStorage(replicate_byte_to_16_buffer.handle, sizeof(REPLICATE_BYTE_TO_16_TABLE),
-                         &REPLICATE_BYTE_TO_16_TABLE, 0);
-}
-
 void UtilShaders::ASTCDecode(Image& image, const ImageBufferMap& map,
                              std::span<const VideoCommon::SwizzleParameters> swizzles) {
     static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
@@ -108,47 +86,51 @@ void UtilShaders::ASTCDecode(Image& image, const ImageBufferMap& map,
     static constexpr GLuint BINDING_BYTE_TO_16_BUFFER = 6;
 
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
-    static constexpr GLuint LOC_NUM_IMAGE_BLOCKS = 0;
-    static constexpr GLuint LOC_BLOCK_DIMS = 1;
 
-    const Extent3D tile_size = {
+    const Extent2D tile_size{
-        VideoCore::Surface::DefaultBlockWidth(image.info.format),
+        .width = VideoCore::Surface::DefaultBlockWidth(image.info.format),
-        VideoCore::Surface::DefaultBlockHeight(image.info.format),
+        .height = VideoCore::Surface::DefaultBlockHeight(image.info.format),
     };
     program_manager.BindHostCompute(astc_decoder_program.handle);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_ENC_BUFFER, astc_encodings_buffer.handle);
+    glBindBufferRange(GL_SHADER_STORAGE_BUFFER, BINDING_ENC_BUFFER, astc_buffer.handle,
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_6_TO_8_BUFFER,
+                      offsetof(AstcBufferData, encoding_values),
-                     replicate_6_to_8_buffer.handle);
+                      sizeof(AstcBufferData::encoding_values));
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_7_TO_8_BUFFER,
+    glBindBufferRange(GL_SHADER_STORAGE_BUFFER, BINDING_6_TO_8_BUFFER, astc_buffer.handle,
-                     replicate_7_to_8_buffer.handle);
+                      offsetof(AstcBufferData, replicate_6_to_8),
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_8_TO_8_BUFFER,
+                      sizeof(AstcBufferData::replicate_6_to_8));
-                     replicate_8_to_8_buffer.handle);
+    glBindBufferRange(GL_SHADER_STORAGE_BUFFER, BINDING_7_TO_8_BUFFER, astc_buffer.handle,
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_BYTE_TO_16_BUFFER,
+                      offsetof(AstcBufferData, replicate_7_to_8),
-                     replicate_byte_to_16_buffer.handle);
+                      sizeof(AstcBufferData::replicate_7_to_8));
+    glBindBufferRange(GL_SHADER_STORAGE_BUFFER, BINDING_8_TO_8_BUFFER, astc_buffer.handle,
+                      offsetof(AstcBufferData, replicate_8_to_8),
+                      sizeof(AstcBufferData::replicate_8_to_8));
+    glBindBufferRange(GL_SHADER_STORAGE_BUFFER, BINDING_BYTE_TO_16_BUFFER, astc_buffer.handle,
+                      offsetof(AstcBufferData, replicate_byte_to_16),
+                      sizeof(AstcBufferData::replicate_byte_to_16));
 
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
-    glUniform2ui(LOC_BLOCK_DIMS, tile_size.width, tile_size.height);
+    glUniform2ui(1, tile_size.width, tile_size.height);
+    // Ensure buffer data is valid before dispatching
+    glFlush();
     for (const SwizzleParameters& swizzle : swizzles) {
+        const size_t input_offset = swizzle.buffer_offset + map.offset;
+        const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U);
+        const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 32U);
+
+        const auto params = MakeBlockLinearSwizzle2DParams(swizzle, image.info);
+        ASSERT(params.origin == (std::array<u32, 3>{0, 0, 0}));
+        ASSERT(params.destination == (std::array<s32, 3>{0, 0, 0}));
+
+        glUniform1ui(2, params.bytes_per_block_log2);
+        glUniform1ui(3, params.layer_stride);
+        glUniform1ui(4, params.block_size);
+        glUniform1ui(5, params.x_shift);
+        glUniform1ui(6, params.block_height);
+        glUniform1ui(7, params.block_height_mask);
+
         glBindImageTexture(BINDING_OUTPUT_IMAGE, image.StorageHandle(), swizzle.level, GL_TRUE, 0,
                            GL_WRITE_ONLY, GL_RGBA8);
-        const size_t input_offset = swizzle.buffer_offset + map.offset;
-        const auto num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U);
-        const auto num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 32U);
-
-        glUniform2ui(LOC_NUM_IMAGE_BLOCKS, swizzle.num_tiles.width, swizzle.num_tiles.height);
-
-        // To unswizzle the ASTC data
-        const auto params = MakeBlockLinearSwizzle2DParams(swizzle, image.info);
-        glUniform3uiv(2, 1, params.origin.data());
-        glUniform3iv(3, 1, params.destination.data());
-        glUniform1ui(4, params.bytes_per_block_log2);
-        glUniform1ui(5, params.layer_stride);
-        glUniform1ui(6, params.block_size);
-        glUniform1ui(7, params.x_shift);
-        glUniform1ui(8, params.block_height);
-        glUniform1ui(9, params.block_height_mask);
-
         // ASTC texture data
         glBindBufferRange(GL_SHADER_STORAGE_BUFFER, BINDING_INPUT_BUFFER, map.buffer, input_offset,
                           image.guest_size_bytes - swizzle.buffer_offset);

src/video_core/renderer_opengl/util_shaders.h

@@ -40,8 +40,6 @@ public:
     explicit UtilShaders(ProgramManager& program_manager);
     ~UtilShaders();
 
-    void MakeBuffers();
-
     void ASTCDecode(Image& image, const ImageBufferMap& map,
                     std::span<const VideoCommon::SwizzleParameters> swizzles);
 
@@ -64,11 +62,7 @@ private:
     ProgramManager& program_manager;
 
     OGLBuffer swizzle_table_buffer;
-    OGLBuffer astc_encodings_buffer;
+    OGLBuffer astc_buffer;
-    OGLBuffer replicate_6_to_8_buffer;
-    OGLBuffer replicate_7_to_8_buffer;
-    OGLBuffer replicate_8_to_8_buffer;
-    OGLBuffer replicate_byte_to_16_buffer;
 
     OGLProgram astc_decoder_program;
     OGLProgram block_linear_unswizzle_2d_program;

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -35,13 +35,13 @@ using namespace Tegra::Texture::ASTC;
 
 namespace {
 
-constexpr u32 ASTC_BINDING_SWIZZLE_BUFFER = 0;
+constexpr u32 ASTC_BINDING_INPUT_BUFFER = 0;
-constexpr u32 ASTC_BINDING_INPUT_BUFFER = 1;
+constexpr u32 ASTC_BINDING_ENC_BUFFER = 1;
-constexpr u32 ASTC_BINDING_ENC_BUFFER = 2;
+constexpr u32 ASTC_BINDING_6_TO_8_BUFFER = 2;
-constexpr u32 ASTC_BINDING_6_TO_8_BUFFER = 3;
+constexpr u32 ASTC_BINDING_7_TO_8_BUFFER = 3;
-constexpr u32 ASTC_BINDING_7_TO_8_BUFFER = 4;
+constexpr u32 ASTC_BINDING_8_TO_8_BUFFER = 4;
-constexpr u32 ASTC_BINDING_8_TO_8_BUFFER = 5;
+constexpr u32 ASTC_BINDING_BYTE_TO_16_BUFFER = 5;
-constexpr u32 ASTC_BINDING_BYTE_TO_16_BUFFER = 6;
+constexpr u32 ASTC_BINDING_SWIZZLE_BUFFER = 6;
 constexpr u32 ASTC_BINDING_OUTPUT_IMAGE = 7;
 
 VkPushConstantRange BuildComputePushConstantRange(std::size_t size) {
@@ -74,56 +74,56 @@ std::array<VkDescriptorSetLayoutBinding, 2> BuildInputOutputDescriptorSetBinding
 std::array<VkDescriptorSetLayoutBinding, 8> BuildASTCDescriptorSetBindings() {
     return {{
         {
-            .binding = ASTC_BINDING_SWIZZLE_BUFFER, // Swizzle buffer
+            .binding = ASTC_BINDING_INPUT_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_INPUT_BUFFER, // ASTC Img data buffer
+            .binding = ASTC_BINDING_ENC_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_ENC_BUFFER, // Encodings buffer
+            .binding = ASTC_BINDING_6_TO_8_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_6_TO_8_BUFFER, // BINDING_6_TO_8_BUFFER
+            .binding = ASTC_BINDING_7_TO_8_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_7_TO_8_BUFFER, // BINDING_7_TO_8_BUFFER
+            .binding = ASTC_BINDING_8_TO_8_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_8_TO_8_BUFFER, // BINDING_8_TO_8_BUFFER
+            .binding = ASTC_BINDING_BYTE_TO_16_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_BYTE_TO_16_BUFFER, // BINDING_BYTE_TO_16_BUFFER
+            .binding = ASTC_BINDING_SWIZZLE_BUFFER,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
             .pImmutableSamplers = nullptr,
         },
         {
-            .binding = ASTC_BINDING_OUTPUT_IMAGE, // Output image
+            .binding = ASTC_BINDING_OUTPUT_IMAGE,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
             .descriptorCount = 1,
             .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
@@ -145,20 +145,12 @@ VkDescriptorUpdateTemplateEntryKHR BuildInputOutputDescriptorUpdateTemplate() {
 
 std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateTemplateEntry() {
     return {{
-        {
-            .dstBinding = ASTC_BINDING_SWIZZLE_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 0 * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        },
         {
             .dstBinding = ASTC_BINDING_INPUT_BUFFER,
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 1 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
         {
@@ -166,7 +158,7 @@ std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateT
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 2 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_ENC_BUFFER * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
         {
@@ -174,7 +166,7 @@ std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateT
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 3 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_6_TO_8_BUFFER * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
         {
@@ -182,7 +174,7 @@ std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateT
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 4 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_7_TO_8_BUFFER * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
         {
@@ -190,7 +182,7 @@ std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateT
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 5 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_8_TO_8_BUFFER * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
         {
@@ -198,7 +190,15 @@ std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateT
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = 6 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_BYTE_TO_16_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        },
+        {
+            .dstBinding = ASTC_BINDING_SWIZZLE_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = ASTC_BINDING_SWIZZLE_BUFFER * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
         {
@@ -206,16 +206,20 @@ std::array<VkDescriptorUpdateTemplateEntryKHR, 8> BuildASTCPassDescriptorUpdateT
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-            .offset = 7 * sizeof(DescriptorUpdateEntry),
+            .offset = ASTC_BINDING_OUTPUT_IMAGE * sizeof(DescriptorUpdateEntry),
             .stride = sizeof(DescriptorUpdateEntry),
         },
     }};
 }
 
 struct AstcPushConstants {
-    std::array<u32, 2> num_image_blocks;
     std::array<u32, 2> blocks_dims;
-    VideoCommon::Accelerated::BlockLinearSwizzle2DParams params;
+    u32 bytes_per_block_log2;
+    u32 layer_stride;
+    u32 block_size;
+    u32 x_shift;
+    u32 block_height;
+    u32 block_height_mask;
 };
 
 struct AstcBufferData {
@@ -419,11 +423,12 @@ ASTCDecoderPass::ASTCDecoderPass(const Device& device_, VKScheduler& scheduler_,
 ASTCDecoderPass::~ASTCDecoderPass() = default;
 
 void ASTCDecoderPass::MakeDataBuffer() {
+    constexpr size_t TOTAL_BUFFER_SIZE = sizeof(ASTC_BUFFER_DATA) + sizeof(SWIZZLE_TABLE);
     data_buffer = device.GetLogical().CreateBuffer(VkBufferCreateInfo{
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
-        .size = sizeof(ASTC_BUFFER_DATA),
+        .size = TOTAL_BUFFER_SIZE,
         .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyIndexCount = 0,
@@ -431,15 +436,19 @@ void ASTCDecoderPass::MakeDataBuffer() {
     });
     data_buffer_commit = memory_allocator.Commit(data_buffer, MemoryUsage::Upload);
 
-    const auto staging_ref =
+    const auto staging_ref = staging_buffer_pool.Request(TOTAL_BUFFER_SIZE, MemoryUsage::Upload);
-        staging_buffer_pool.Request(sizeof(ASTC_BUFFER_DATA), MemoryUsage::Upload);
     std::memcpy(staging_ref.mapped_span.data(), &ASTC_BUFFER_DATA, sizeof(ASTC_BUFFER_DATA));
-    scheduler.Record([src = staging_ref.buffer, dst = *data_buffer](vk::CommandBuffer cmdbuf) {
+    // Tack on the swizzle table at the end of the buffer
+    std::memcpy(staging_ref.mapped_span.data() + sizeof(ASTC_BUFFER_DATA), &SWIZZLE_TABLE,
+                sizeof(SWIZZLE_TABLE));
+
+    scheduler.Record([src = staging_ref.buffer, offset = staging_ref.offset, dst = *data_buffer,
+                      TOTAL_BUFFER_SIZE](vk::CommandBuffer cmdbuf) {
         cmdbuf.CopyBuffer(src, dst,
                           VkBufferCopy{
-                              .srcOffset = 0,
+                              .srcOffset = offset,
                               .dstOffset = 0,
-                              .size = sizeof(ASTC_BUFFER_DATA),
+                              .size = TOTAL_BUFFER_SIZE,
                           });
         cmdbuf.PipelineBarrier(
             VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0,
@@ -448,61 +457,58 @@ void ASTCDecoderPass::MakeDataBuffer() {
                 .pNext = nullptr,
                 .srcAccessMask = 0,
                 .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
-            },
+            });
-            {}, {});
     });
 }
 
 void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
                                std::span<const VideoCommon::SwizzleParameters> swizzles) {
     using namespace VideoCommon::Accelerated;
-    const VideoCommon::Extent2D tile_size{
+    const std::array<u32, 2> block_dims{
-        .width = VideoCore::Surface::DefaultBlockWidth(image.info.format),
+        VideoCore::Surface::DefaultBlockWidth(image.info.format),
-        .height = VideoCore::Surface::DefaultBlockHeight(image.info.format),
+        VideoCore::Surface::DefaultBlockHeight(image.info.format),
     };
     scheduler.RequestOutsideRenderPassOperationContext();
     if (!data_buffer) {
         MakeDataBuffer();
     }
+    const VkPipeline vk_pipeline = *pipeline;
     const VkImageAspectFlags aspect_mask = image.AspectMask();
     const VkImage vk_image = image.Handle();
     const bool is_initialized = image.ExchangeInitialization();
-    scheduler.Record([vk_image, aspect_mask, is_initialized](vk::CommandBuffer cmdbuf) {
+    scheduler.Record(
-        const VkImageMemoryBarrier image_barrier{
+        [vk_pipeline, vk_image, aspect_mask, is_initialized](vk::CommandBuffer cmdbuf) {
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            const VkImageMemoryBarrier image_barrier{
-            .pNext = nullptr,
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+                .pNext = nullptr,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
+                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-            .oldLayout = is_initialized ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_UNDEFINED,
+                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .oldLayout = is_initialized ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_UNDEFINED,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .subresourceRange{
+                .image = vk_image,
-                .aspectMask = aspect_mask,
+                .subresourceRange{
-                .baseMipLevel = 0,
+                    .aspectMask = aspect_mask,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
+                    .baseMipLevel = 0,
-                .baseArrayLayer = 0,
+                    .levelCount = VK_REMAINING_MIP_LEVELS,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
+                    .baseArrayLayer = 0,
-            },
+                    .layerCount = VK_REMAINING_ARRAY_LAYERS,
-        };
+                },
-        cmdbuf.PipelineBarrier(0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
+            };
-    });
+            cmdbuf.PipelineBarrier(is_initialized ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT : 0,
-    const std::array<u32, 2> block_dims{tile_size.width, tile_size.height};
+                                   VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
+            cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
+        });
     for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
         const size_t input_offset = swizzle.buffer_offset + map.offset;
         const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U);
         const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 32U);
         const u32 num_dispatches_z = image.info.resources.layers;
-        const std::array num_image_blocks{swizzle.num_tiles.width, swizzle.num_tiles.height};
-        const u32 layer_image_size =
-            image.guest_size_bytes - static_cast<u32>(swizzle.buffer_offset);
 
         update_descriptor_queue.Acquire();
-        update_descriptor_queue.AddBuffer(*data_buffer,
+        update_descriptor_queue.AddBuffer(map.buffer, input_offset,
-                                          offsetof(AstcBufferData, swizzle_table_buffer),
+                                          image.guest_size_bytes - swizzle.buffer_offset);
-                                          sizeof(AstcBufferData::swizzle_table_buffer));
-        update_descriptor_queue.AddBuffer(map.buffer, input_offset, layer_image_size);
         update_descriptor_queue.AddBuffer(*data_buffer, offsetof(AstcBufferData, encoding_values),
                                           sizeof(AstcBufferData::encoding_values));
         update_descriptor_queue.AddBuffer(*data_buffer, offsetof(AstcBufferData, replicate_6_to_8),
@@ -514,18 +520,28 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
         update_descriptor_queue.AddBuffer(*data_buffer,
                                           offsetof(AstcBufferData, replicate_byte_to_16),
                                           sizeof(AstcBufferData::replicate_byte_to_16));
+        update_descriptor_queue.AddBuffer(*data_buffer, sizeof(AstcBufferData),
+                                          sizeof(SWIZZLE_TABLE));
         update_descriptor_queue.AddImage(image.StorageImageView(swizzle.level));
 
         const VkDescriptorSet set = CommitDescriptorSet(update_descriptor_queue);
         const VkPipelineLayout vk_layout = *layout;
-        const VkPipeline vk_pipeline = *pipeline;
+
         // To unswizzle the ASTC data
         const auto params = MakeBlockLinearSwizzle2DParams(swizzle, image.info);
-        scheduler.Record([vk_layout, vk_pipeline, buffer = map.buffer, num_dispatches_x,
+        ASSERT(params.origin == (std::array<u32, 3>{0, 0, 0}));
-                          num_dispatches_y, num_dispatches_z, num_image_blocks, block_dims, params,
+        ASSERT(params.destination == (std::array<s32, 3>{0, 0, 0}));
-                          set, input_offset](vk::CommandBuffer cmdbuf) {
+        scheduler.Record([vk_layout, num_dispatches_x, num_dispatches_y, num_dispatches_z,
-            const AstcPushConstants uniforms{num_image_blocks, block_dims, params};
+                          block_dims, params, set](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
+            const AstcPushConstants uniforms{
+                .blocks_dims = block_dims,
+                .bytes_per_block_log2 = params.bytes_per_block_log2,
+                .layer_stride = params.layer_stride,
+                .block_size = params.block_size,
+                .x_shift = params.x_shift,
+                .block_height = params.block_height,
+                .block_height_mask = params.block_height_mask,
+            };
             cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, vk_layout, 0, set, {});
             cmdbuf.PushConstants(vk_layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
             cmdbuf.Dispatch(num_dispatches_x, num_dispatches_y, num_dispatches_z);
@@ -550,7 +566,8 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
                 .layerCount = VK_REMAINING_ARRAY_LAYERS,
             },
         };
-        cmdbuf.PipelineBarrier(0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                               VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, image_barrier);
     });
 }
 

src/video_core/texture_cache/util.cpp

@@ -47,7 +47,6 @@
 #include "video_core/texture_cache/formatter.h"
 #include "video_core/texture_cache/samples_helper.h"
 #include "video_core/texture_cache/util.h"
-#include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
 
 namespace VideoCommon {
@@ -879,17 +878,8 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
         ASSERT(copy.image_extent == mip_size);
         ASSERT(copy.buffer_row_length == Common::AlignUp(mip_size.width, tile_size.width));
         ASSERT(copy.buffer_image_height == Common::AlignUp(mip_size.height, tile_size.height));
-
+        DecompressBC4(input.subspan(copy.buffer_offset), copy.image_extent,
-        if (IsPixelFormatASTC(info.format)) {
+                      output.subspan(output_offset));
-            ASSERT(copy.image_extent.depth == 1);
-            Tegra::Texture::ASTC::Decompress(input.subspan(copy.buffer_offset),
-                                             copy.image_extent.width, copy.image_extent.height,
-                                             copy.image_subresource.num_layers, tile_size.width,
-                                             tile_size.height, output.subspan(output_offset));
-        } else {
-            DecompressBC4(input.subspan(copy.buffer_offset), copy.image_extent,
-                          output.subspan(output_offset));
-        }
         copy.buffer_offset = output_offset;
         copy.buffer_row_length = mip_size.width;
         copy.buffer_image_height = mip_size.height;

src/video_core/textures/astc.h

@@ -4,20 +4,12 @@
 
 #pragma once
 
-#include <cstdint>
+#include <bit>
+#include "common/common_types.h"
 
 namespace Tegra::Texture::ASTC {
 
-/// Count the number of bits set in a number.
+enum class IntegerEncoding { JustBits, Quint, Trit };
-constexpr u32 Popcnt(u32 n) {
-    u32 c = 0;
-    for (; n; c++) {
-        n &= n - 1;
-    }
-    return c;
-}
-
-enum class IntegerEncoding { JustBits, Qus32, Trit };
 
 struct IntegerEncodedValue {
     constexpr IntegerEncodedValue() = default;
@@ -29,55 +21,55 @@ struct IntegerEncodedValue {
         return encoding == other.encoding && num_bits == other.num_bits;
     }
 
-    // Returns the number of bits required to encode nVals values.
+    // Returns the number of bits required to encode num_vals values.
-    u32 GetBitLength(u32 nVals) const {
+    u32 GetBitLength(u32 num_vals) const {
-        u32 totalBits = num_bits * nVals;
+        u32 total_bits = num_bits * num_vals;
         if (encoding == IntegerEncoding::Trit) {
-            totalBits += (nVals * 8 + 4) / 5;
+            total_bits += (num_vals * 8 + 4) / 5;
-        } else if (encoding == IntegerEncoding::Qus32) {
+        } else if (encoding == IntegerEncoding::Quint) {
-            totalBits += (nVals * 7 + 2) / 3;
+            total_bits += (num_vals * 7 + 2) / 3;
         }
-        return totalBits;
+        return total_bits;
     }
 
     IntegerEncoding encoding{};
     u32 num_bits = 0;
     u32 bit_value = 0;
     union {
-        u32 qus32_value = 0;
+        u32 quint_value = 0;
         u32 trit_value;
     };
 };
 
 // Returns a new instance of this struct that corresponds to the
-// can take no more than maxval values
+// can take no more than mav_value values
-static constexpr IntegerEncodedValue CreateEncoding(u32 maxVal) {
+constexpr IntegerEncodedValue CreateEncoding(u32 mav_value) {
-    while (maxVal > 0) {
+    while (mav_value > 0) {
-        u32 check = maxVal + 1;
+        u32 check = mav_value + 1;
 
-        // Is maxVal a power of two?
+        // Is mav_value a power of two?
         if (!(check & (check - 1))) {
-            return IntegerEncodedValue(IntegerEncoding::JustBits, Popcnt(maxVal));
+            return IntegerEncodedValue(IntegerEncoding::JustBits, std::popcount(mav_value));
         }
 
-        // Is maxVal of the type 3*2^n - 1?
+        // Is mav_value of the type 3*2^n - 1?
         if ((check % 3 == 0) && !((check / 3) & ((check / 3) - 1))) {
-            return IntegerEncodedValue(IntegerEncoding::Trit, Popcnt(check / 3 - 1));
+            return IntegerEncodedValue(IntegerEncoding::Trit, std::popcount(check / 3 - 1));
         }
 
-        // Is maxVal of the type 5*2^n - 1?
+        // Is mav_value of the type 5*2^n - 1?
         if ((check % 5 == 0) && !((check / 5) & ((check / 5) - 1))) {
-            return IntegerEncodedValue(IntegerEncoding::Qus32, Popcnt(check / 5 - 1));
+            return IntegerEncodedValue(IntegerEncoding::Quint, std::popcount(check / 5 - 1));
         }
 
         // Apparently it can't be represented with a bounded integer sequence...
         // just iterate.
-        maxVal--;
+        mav_value--;
     }
     return IntegerEncodedValue(IntegerEncoding::JustBits, 0);
 }
 
-static constexpr std::array<IntegerEncodedValue, 256> MakeEncodedValues() {
+constexpr std::array<IntegerEncodedValue, 256> MakeEncodedValues() {
     std::array<IntegerEncodedValue, 256> encodings{};
     for (std::size_t i = 0; i < encodings.size(); ++i) {
         encodings[i] = CreateEncoding(static_cast<u32>(i));
@@ -85,41 +77,38 @@ static constexpr std::array<IntegerEncodedValue, 256> MakeEncodedValues() {
     return encodings;
 }
 
-static constexpr std::array<IntegerEncodedValue, 256> EncodingsValues = MakeEncodedValues();
+constexpr std::array<IntegerEncodedValue, 256> EncodingsValues = MakeEncodedValues();
 
-// Replicates low numBits such that [(toBit - 1):(toBit - 1 - fromBit)]
+// Replicates low num_bits such that [(to_bit - 1):(to_bit - 1 - from_bit)]
-// is the same as [(numBits - 1):0] and repeats all the way down.
+// is the same as [(num_bits - 1):0] and repeats all the way down.
 template <typename IntType>
-static constexpr IntType Replicate(IntType val, u32 numBits, u32 toBit) {
+constexpr IntType Replicate(IntType val, u32 num_bits, u32 to_bit) {
-    if (numBits == 0) {
+    if (num_bits == 0 || to_bit == 0) {
         return 0;
     }
-    if (toBit == 0) {
+    const IntType v = val & static_cast<IntType>((1 << num_bits) - 1);
-        return 0;
-    }
-    const IntType v = val & static_cast<IntType>((1 << numBits) - 1);
     IntType res = v;
-    u32 reslen = numBits;
+    u32 reslen = num_bits;
-    while (reslen < toBit) {
+    while (reslen < to_bit) {
         u32 comp = 0;
-        if (numBits > toBit - reslen) {
+        if (num_bits > to_bit - reslen) {
-            u32 newshift = toBit - reslen;
+            u32 newshift = to_bit - reslen;
-            comp = numBits - newshift;
+            comp = num_bits - newshift;
-            numBits = newshift;
+            num_bits = newshift;
         }
-        res = static_cast<IntType>(res << numBits);
+        res = static_cast<IntType>(res << num_bits);
         res = static_cast<IntType>(res | (v >> comp));
-        reslen += numBits;
+        reslen += num_bits;
     }
     return res;
 }
 
-static constexpr std::size_t NumReplicateEntries(u32 num_bits) {
+constexpr std::size_t NumReplicateEntries(u32 num_bits) {
     return std::size_t(1) << num_bits;
 }
 
 template <typename IntType, u32 num_bits, u32 to_bit>
-static constexpr auto MakeReplicateTable() {
+constexpr auto MakeReplicateTable() {
     std::array<IntType, NumReplicateEntries(num_bits)> table{};
     for (IntType value = 0; value < static_cast<IntType>(std::size(table)); ++value) {
         table[value] = Replicate(value, num_bits, to_bit);
@@ -127,78 +116,17 @@ static constexpr auto MakeReplicateTable() {
     return table;
 }
 
-static constexpr auto REPLICATE_BYTE_TO_16_TABLE = MakeReplicateTable<u32, 8, 16>();
+constexpr auto REPLICATE_BYTE_TO_16_TABLE = MakeReplicateTable<u32, 8, 16>();
-static constexpr u32 ReplicateByteTo16(std::size_t value) {
+constexpr auto REPLICATE_6_BIT_TO_8_TABLE = MakeReplicateTable<u32, 6, 8>();
-    return REPLICATE_BYTE_TO_16_TABLE[value];
+constexpr auto REPLICATE_7_BIT_TO_8_TABLE = MakeReplicateTable<u32, 7, 8>();
-}
+constexpr auto REPLICATE_8_BIT_TO_8_TABLE = MakeReplicateTable<u32, 8, 8>();
 
-static constexpr auto REPLICATE_BIT_TO_7_TABLE = MakeReplicateTable<u32, 1, 7>();
+struct AstcBufferData {
-static constexpr u32 ReplicateBitTo7(std::size_t value) {
+    decltype(EncodingsValues) encoding_values = EncodingsValues;
-    return REPLICATE_BIT_TO_7_TABLE[value];
+    decltype(REPLICATE_6_BIT_TO_8_TABLE) replicate_6_to_8 = REPLICATE_6_BIT_TO_8_TABLE;
-}
+    decltype(REPLICATE_7_BIT_TO_8_TABLE) replicate_7_to_8 = REPLICATE_7_BIT_TO_8_TABLE;
-
+    decltype(REPLICATE_8_BIT_TO_8_TABLE) replicate_8_to_8 = REPLICATE_8_BIT_TO_8_TABLE;
-static constexpr auto REPLICATE_BIT_TO_9_TABLE = MakeReplicateTable<u32, 1, 9>();
+    decltype(REPLICATE_BYTE_TO_16_TABLE) replicate_byte_to_16 = REPLICATE_BYTE_TO_16_TABLE;
-static constexpr u32 ReplicateBitTo9(std::size_t value) {
+} constexpr ASTC_BUFFER_DATA;
-    return REPLICATE_BIT_TO_9_TABLE[value];
-}
-
-static constexpr auto REPLICATE_1_BIT_TO_8_TABLE = MakeReplicateTable<u32, 1, 8>();
-static constexpr auto REPLICATE_2_BIT_TO_8_TABLE = MakeReplicateTable<u32, 2, 8>();
-static constexpr auto REPLICATE_3_BIT_TO_8_TABLE = MakeReplicateTable<u32, 3, 8>();
-static constexpr auto REPLICATE_4_BIT_TO_8_TABLE = MakeReplicateTable<u32, 4, 8>();
-static constexpr auto REPLICATE_5_BIT_TO_8_TABLE = MakeReplicateTable<u32, 5, 8>();
-static constexpr auto REPLICATE_6_BIT_TO_8_TABLE = MakeReplicateTable<u32, 6, 8>();
-static constexpr auto REPLICATE_7_BIT_TO_8_TABLE = MakeReplicateTable<u32, 7, 8>();
-static constexpr auto REPLICATE_8_BIT_TO_8_TABLE = MakeReplicateTable<u32, 8, 8>();
-/// Use a precompiled table with the most common usages, if it's not in the expected range, fallback
-/// to the runtime implementation
-static constexpr u32 FastReplicateTo8(u32 value, u32 num_bits) {
-    switch (num_bits) {
-    case 1:
-        return REPLICATE_1_BIT_TO_8_TABLE[value];
-    case 2:
-        return REPLICATE_2_BIT_TO_8_TABLE[value];
-    case 3:
-        return REPLICATE_3_BIT_TO_8_TABLE[value];
-    case 4:
-        return REPLICATE_4_BIT_TO_8_TABLE[value];
-    case 5:
-        return REPLICATE_5_BIT_TO_8_TABLE[value];
-    case 6:
-        return REPLICATE_6_BIT_TO_8_TABLE[value];
-    case 7:
-        return REPLICATE_7_BIT_TO_8_TABLE[value];
-    case 8:
-        return REPLICATE_8_BIT_TO_8_TABLE[value];
-    default:
-        return Replicate(value, num_bits, 8);
-    }
-}
-
-static constexpr auto REPLICATE_1_BIT_TO_6_TABLE = MakeReplicateTable<u32, 1, 6>();
-static constexpr auto REPLICATE_2_BIT_TO_6_TABLE = MakeReplicateTable<u32, 2, 6>();
-static constexpr auto REPLICATE_3_BIT_TO_6_TABLE = MakeReplicateTable<u32, 3, 6>();
-static constexpr auto REPLICATE_4_BIT_TO_6_TABLE = MakeReplicateTable<u32, 4, 6>();
-static constexpr auto REPLICATE_5_BIT_TO_6_TABLE = MakeReplicateTable<u32, 5, 6>();
-
-static constexpr u32 FastReplicateTo6(u32 value, u32 num_bits) {
-    switch (num_bits) {
-    case 1:
-        return REPLICATE_1_BIT_TO_6_TABLE[value];
-    case 2:
-        return REPLICATE_2_BIT_TO_6_TABLE[value];
-    case 3:
-        return REPLICATE_3_BIT_TO_6_TABLE[value];
-    case 4:
-        return REPLICATE_4_BIT_TO_6_TABLE[value];
-    case 5:
-        return REPLICATE_5_BIT_TO_6_TABLE[value];
-    default:
-        return Replicate(value, num_bits, 6);
-    }
-}
-
-void Decompress(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth,
-                uint32_t block_width, uint32_t block_height, std::span<uint8_t> output);
 
 } // namespace Tegra::Texture::ASTC