Update tile_manager.cpp

Author: diegolix29

src/video_core/texture_cache/tile_manager.cpp

@@ -71,7 +71,7 @@ struct DetilerParams {
     u32 num_levels;
     u32 pitch0;
     u32 height;
-    u32 sizes[14];
+    std::array<u32, 14> sizes{};
 };
 
 TileManager::TileManager(const Vulkan::Instance& instance, Vulkan::Scheduler& scheduler)
@@ -264,33 +264,71 @@ std::pair<vk::Buffer, u32> TileManager::TryDetile(vk::Buffer in_buffer, u32 in_o
     cmdbuf.pushDescriptorSetKHR(vk::PipelineBindPoint::eCompute, *detiler->pl_layout, 0,
                                 set_writes);
 
-    DetilerParams params;
+    DetilerParams params{};
     params.num_levels = info.resources.levels;
     params.pitch0 = info.pitch >> (info.props.is_block ? 2u : 0u);
     params.height = info.size.height;
-    if (info.tiling_mode == AmdGpu::TilingMode::Texture_Volume ||
-        info.tiling_mode == AmdGpu::TilingMode::Display_MicroTiled) {
-        ASSERT(info.resources.levels == 1);
+
+    const bool is_volume = info.tiling_mode == AmdGpu::TilingMode::Texture_Volume;
+    const bool is_display = info.tiling_mode == AmdGpu::TilingMode::Display_MicroTiled;
+
+    if (is_volume || is_display) {
+        // Display surfaces must not use mipmaps.
+        if (is_display && info.resources.levels > 1) {
+            LOG_ERROR(Lib_Videodec, "Display tiling with multiple mip levels is not supported.");
+            return {}; // or handle error
+        }
+
+        ASSERT(in_buffer != out_buffer.first);
+
         const auto tiles_per_row = info.pitch / 8u;
-        const auto tiles_per_slice = tiles_per_row * ((info.size.height + 7u) / 8u);
+        const auto tiles_per_slice = tiles_per_row * (Common::AlignUp(info.size.height, 8u) / 8u);
+
         params.sizes[0] = tiles_per_row;
         params.sizes[1] = tiles_per_slice;
+
+        for (size_t i = 2; i < params.sizes.size(); ++i)
+            params.sizes[i] = 0;
     } else {
-        ASSERT(info.resources.levels <= 14);
-        std::memset(&params.sizes, 0, sizeof(params.sizes));
-        for (int m = 0; m < info.resources.levels; ++m) {
-            params.sizes[m] = info.mips_layout[m].size + (m > 0 ? params.sizes[m - 1] : 0);
+        if (info.resources.levels > params.sizes.size()) {
+            LOG_ERROR(Lib_Videodec, "Too many mip levels: {}, max supported is {}",
+                      info.resources.levels, params.sizes.size());
+            return {};
         }
+
+        u32 accum = 0;
+        for (uint32_t m = 0; m < info.resources.levels; ++m) {
+            accum += info.mips_layout[m].size;
+            params.sizes[m] = accum;
+        }
+        for (uint32_t m = info.resources.levels; m < params.sizes.size(); ++m)
+            params.sizes[m] = 0;
     }
 
+    // Log DetilerParams for debug
+    LOG_DEBUG(Lib_Videodec, "DetilerParams: levels={}, pitch0={}, height={}", params.num_levels,
+              params.pitch0, params.height);
+    for (size_t i = 0; i < params.sizes.size(); ++i)
+        LOG_DEBUG(Lib_Videodec, "  sizes[{}] = {}", i, params.sizes[i]);
+
     cmdbuf.pushConstants(*detiler->pl_layout, vk::ShaderStageFlagBits::eCompute, 0u, sizeof(params),
                          &params);
 
-    ASSERT((image_size % 64) == 0);
-    const auto bpp = info.num_bits * (info.props.is_block ? 16u : 1u);
-    const auto num_tiles = image_size / (64 * (bpp / 8));
+    // Make sure size is aligned
+    const auto aligned_image_size = Common::AlignUp(image_size, 64u);
+    ASSERT((aligned_image_size % 64) == 0);
+
+    const auto bits_per_pixel = info.num_bits * (info.props.is_block ? 16u : 1u);
+    ASSERT((bits_per_pixel % 8) == 0);
+
+    const auto bytes_per_pixel = bits_per_pixel / 8;
+    const auto num_tiles = aligned_image_size / (64 * bytes_per_pixel);
+
+    LOG_DEBUG(Lib_Videodec, "Dispatch: image_size={}, aligned={}, bpp={}, num_tiles={}", image_size,
+              aligned_image_size, bits_per_pixel, num_tiles);
+
     cmdbuf.dispatch(num_tiles, 1, 1);
-    return {out_buffer.first, 0};
+    return std::make_pair(out_buffer.first, 0u);
 }
 
 } // namespace VideoCore