hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 1857

Browse Source
This commit is contained in:
pineappleEA
2021-07-07 22:12:25 +02:00
parent c73b4b3ce7
commit 28b8f1ac43
7 changed files with 69 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
src/video_core/textures/astc.cpp
View File

@@ -18,15 +18,11 @@
#include <algorithm>
#include <cassert>
#include <cstring>
#if __cpp_lib_parallel_algorithm
#include <execution>
#endif
#include <span>
#include <vector>
#include <boost/container/static_vector.hpp>
#include "common/alignment.h"
#include "common/common_types.h"
#include "video_core/textures/astc.h"
@@ -1554,87 +1550,30 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
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) {
struct ASTCStrideInfo {
u32 z{};
u32 index{};
};
u32 block_index = 0;
std::size_t depth_offset = 0;
for (u32 z = 0; z < depth; z++) {
for (u32 y = 0; y < height; y += block_height) {
for (u32 x = 0; x < width; x += block_width) {
const std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)};
const u32 rows = Common::DivideUp(height, block_height);
const u32 cols = Common::DivideUp(width, block_width);
// Blocks can be at most 12x12
std::array<u32, 12 * 12> uncompData;
DecompressBlock(blockPtr, block_width, block_height, uncompData);
const u32 num_strides = depth * rows;
std::vector<ASTCStrideInfo> astc_strides(num_strides);
u32 decompWidth = std::min(block_width, width - x);
u32 decompHeight = std::min(block_height, height - y);
for (u32 z = 0; z < depth; ++z) {
for (u32 index = 0; index < rows; ++index) {
astc_strides.emplace_back(ASTCStrideInfo{
.z{z},
.index{index},
});
}
}
auto decompress_stride = [&](const ASTCStrideInfo& stride) {
const u32 y = stride.index * block_height;
const u32 depth_offset = stride.z * height * width * 4;
for (u32 x_index = 0; x_index < cols; ++x_index) {
const u32 block_index = (stride.z * rows * cols) + (stride.index * cols) + x_index;
const u32 x = x_index * block_width;
const std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)};
// Blocks can be at most 12x12
std::array<u32, 12 * 12> uncompData;
DecompressBlock(blockPtr, block_width, block_height, uncompData);
const u32 decompWidth = std::min(block_width, width - x);
const u32 decompHeight = std::min(block_height, height - y);
const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
for (u32 h = 0; h < decompHeight; ++h) {
std::memcpy(outRow.data() + h * width * 4, uncompData.data() + h * block_width,
decompWidth * 4);
const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
for (u32 jj = 0; jj < decompHeight; jj++) {
std::memcpy(outRow.data() + jj * width * 4,
uncompData.data() + jj * block_width, decompWidth * 4);
}
++block_index;
}
}
};
#if __cpp_lib_parallel_algorithm
std::for_each(std::execution::par, astc_strides.cbegin(), astc_strides.cend(),
decompress_stride);
#else
std::for_each(astc_strides.cbegin(), astc_strides.cend(), decompress_stride);
#endif
// const u32 rows = Common::DivideUp(height, block_height);
// const u32 cols = Common::DivideUp(width, block_width);
// for (u32 z = 0; z < depth; ++z) {
// const u32 depth_offset = z * height * width * 4;
// for (u32 y_index = 0; y_index < rows; ++y_index) {
// const u32 y = y_index * block_height;
// for (u32 x_index = 0; x_index < cols; ++x_index) {
// const u32 block_index = (z * rows * cols) + (y_index * cols) + x_index;
// const u32 x = x_index * block_width;
// const std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)};
// // Blocks can be at most 12x12
// std::array<u32, 12 * 12> uncompData;
// DecompressBlock(blockPtr, block_width, block_height, uncompData);
// u32 decompWidth = std::min(block_width, width - x);
// u32 decompHeight = std::min(block_height, height - y);
// const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
// for (u32 h = 0; h < decompHeight; ++h) {
// std::memcpy(outRow.data() + h * width * 4, uncompData.data() + h *
// block_width,
// decompWidth * 4);
// }
// }
// }
// }
depth_offset += height * width * 4;
}
}
} // namespace Tegra::Texture::ASTC