mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-07-25 11:34:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

pixel_format: Remove unused tables, refactor

Browse Source
This commit is contained in:
IndecisiveTurtle 2025-06-08 17:52:20 +03:00
parent 8ffcfc87bd
commit b60f821d8d
7 changed files with 105 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/shader_recompiler/ir/passes/lower_buffer_format_to_raw.cpp
View File

@ -15,7 +15,7 @@ struct FormatInfo {
AmdGpu::NumberFormat num_format;
AmdGpu::CompMapping swizzle;
AmdGpu::NumberConversion num_conversion;
int num_components;
u32 num_components;
};
static bool IsBufferFormatLoad(const IR::Inst& inst) {

2
src/video_core/amdgpu/liverpool.h
View File

@ -914,7 +914,7 @@ struct Liverpool {
}
size_t GetColorSliceSize() const {
const auto num_bytes_per_element = NumBits(info.format) / 8u;
const auto num_bytes_per_element = NumBitsPerBlock(info.format) / 8u;
const auto slice_size =
num_bytes_per_element * (slice.tile_max + 1) * 64u * NumSamples();
return slice_size;

214
src/video_core/amdgpu/pixel_format.cpp
View File

@ -111,136 +111,106 @@ std::string_view NameOf(NumberFormat fmt) {
}
}
int NumComponents(DataFormat format) {
constexpr std::array num_components_per_element = {
0, 1, 1, 2, 1, 2, 3, 3, 4, 4, 4, 2, 4, 3, 4, -1, 3, 4, 4, 4, 2,
2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 3, 4, 4, 4, 1, 2, 3, 4,
-1, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 1};
const u32 index = static_cast<u32>(format);
if (index >= num_components_per_element.size()) {
return 0;
}
return num_components_per_element[index];
}
int NumBits(DataFormat format) {
const std::array num_bits_per_element = {
0, 8, 16, 16, 32, 32, 32, 32, 32, 32, 32, 64, 64, 96, 128, -1, 16, 16, 16, 16, 32,
32, 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, 16, 32, 4, 8, 8, 4, 8, 8, 8,
-1, -1, 8, 8, 8, 8, 8, 8, 16, 16, 32, 32, 32, 64, 64, 8, 16, 1, 1};
const u32 index = static_cast<u32>(format);
if (index >= num_bits_per_element.size()) {
return 0;
}
return num_bits_per_element[index];
}
static constexpr std::array component_bits = {
std::array{0, 0, 0, 0}, // 0 FormatInvalid
std::array{8, 0, 0, 0}, // 1 Format8
std::array{16, 0, 0, 0}, // 2 Format16
std::array{8, 8, 0, 0}, // 3 Format8_8
std::array{32, 0, 0, 0}, // 4 Format32
std::array{16, 16, 0, 0}, // 5 Format16_16
std::array{11, 11, 10, 0}, // 6 Format10_11_11
std::array{10, 11, 11, 0}, // 7 Format11_11_10
std::array{2, 10, 10, 10}, // 8 Format10_10_10_2
std::array{10, 10, 10, 2}, // 9 Format2_10_10_10
std::array{8, 8, 8, 8}, // 10 Format8_8_8_8
std::array{32, 32, 0, 0}, // 11 Format32_32
std::array{16, 16, 16, 16}, // 12 Format16_16_16_16
std::array{32, 32, 32, 0}, // 13 Format32_32_32
std::array{32, 32, 32, 32}, // 14 Format32_32_32_32
std::array{0, 0, 0, 0}, // 15
std::array{5, 6, 5, 0}, // 16 Format5_6_5
std::array{5, 5, 5, 1}, // 17 Format1_5_5_5
std::array{1, 5, 5, 5}, // 18 Format5_5_5_1
std::array{4, 4, 4, 4}, // 19 Format4_4_4_4
std::array{24, 8, 0, 0}, // 20 Format8_24
std::array{8, 24, 0, 0}, // 21 Format24_8
std::array{8, 24, 0, 0}, // 22 FormatX24_8_32
std::array{0, 0, 0, 0}, // 23
std::array{0, 0, 0, 0}, // 24
std::array{0, 0, 0, 0}, // 25
std::array{0, 0, 0, 0}, // 26
std::array{0, 0, 0, 0}, // 27
std::array{0, 0, 0, 0}, // 28
std::array{0, 0, 0, 0}, // 29
std::array{0, 0, 0, 0}, // 30
std::array{0, 0, 0, 0}, // 31
std::array{0, 0, 0, 0}, // 32 FormatGB_GR
std::array{0, 0, 0, 0}, // 33 FormatBG_RG
std::array{0, 0, 0, 0}, // 34 Format5_9_9_9
std::array{0, 0, 0, 0}, // 35 FormatBc1
std::array{0, 0, 0, 0}, // 36 FormatBc2
std::array{0, 0, 0, 0}, // 37 FormatBc3
std::array{0, 0, 0, 0}, // 38 FormatBc4
std::array{0, 0, 0, 0}, // 39 FormatBc5
std::array{0, 0, 0, 0}, // 40 FormatBc6
std::array{0, 0, 0, 0}, // 41 FormatBc7
static constexpr std::array NUM_COMPONENTS = {
0, // 0 FormatInvalid
1, // 1 Format8
1, // 2 Format16
2, // 3 Format8_8
1, // 4 Format32
2, // 5 Format16_16
3, // 6 Format10_11_11
3, // 7 Format11_11_10
4, // 8 Format10_10_10_2
4, // 9 Format2_10_10_10
4, // 10 Format8_8_8_8
2, // 11 Format32_32
4, // 12 Format16_16_16_16
3, // 13 Format32_32_32
4, // 14 Format32_32_32_32
0, // 15
3, // 16 Format5_6_5
4, // 17 Format1_5_5_5
4, // 18 Format5_5_5_1
4, // 19 Format4_4_4_4
2, // 20 Format8_24
2, // 21 Format24_8
2, // 22 FormatX24_8_32
0, // 23
0, // 24
0, // 25
0, // 26
0, // 27
0, // 28
0, // 29
0, // 30
0, // 31
3, // 32 FormatGB_GR
3, // 33 FormatBG_RG
4, // 34 Format5_9_9_9
4, // 35 FormatBc1
4, // 36 FormatBc2
4, // 37 FormatBc3
1, // 38 FormatBc4
2, // 39 FormatBc5
3, // 40 FormatBc6
4, // 41 FormatBc7
};
u32 ComponentBits(DataFormat format, u32 comp) {
u32 NumComponents(DataFormat format) {
const u32 index = static_cast<u32>(format);
if (index >= component_bits.size() || comp >= 4) {
return 0;
}
return component_bits[index][comp];
ASSERT_MSG(index < NUM_COMPONENTS.size(), "Invalid data format = {}", format);
return NUM_COMPONENTS[index];
}
static constexpr std::array component_offset = {
std::array{-1, -1, -1, -1}, // 0 FormatInvalid
std::array{0, -1, -1, -1}, // 1 Format8
std::array{0, -1, -1, -1}, // 2 Format16
std::array{0, 8, -1, -1}, // 3 Format8_8
std::array{0, -1, -1, -1}, // 4 Format32
std::array{0, 16, -1, -1}, // 5 Format16_16
std::array{0, 11, 22, -1}, // 6 Format10_11_11
std::array{0, 10, 21, -1}, // 7 Format11_11_10
std::array{0, 2, 12, 22}, // 8 Format10_10_10_2
std::array{0, 10, 20, 30}, // 9 Format2_10_10_10
std::array{0, 8, 16, 24}, // 10 Format8_8_8_8
std::array{0, 32, -1, -1}, // 11 Format32_32
std::array{0, 16, 32, 48}, // 12 Format16_16_16_16
std::array{0, 32, 64, -1}, // 13 Format32_32_32
std::array{0, 32, 64, 96}, // 14 Format32_32_32_32
std::array{-1, -1, -1, -1}, // 15
std::array{0, 5, 11, -1}, // 16 Format5_6_5
std::array{0, 5, 10, 15}, // 17 Format1_5_5_5
std::array{0, 1, 6, 11}, // 18 Format5_5_5_1
std::array{0, 4, 8, 12}, // 19 Format4_4_4_4
std::array{0, 24, -1, -1}, // 20 Format8_24
std::array{0, 8, -1, -1}, // 21 Format24_8
std::array{0, 8, -1, -1}, // 22 FormatX24_8_32
std::array{-1, -1, -1, -1}, // 23
std::array{-1, -1, -1, -1}, // 24
std::array{-1, -1, -1, -1}, // 25
std::array{-1, -1, -1, -1}, // 26
std::array{-1, -1, -1, -1}, // 27
std::array{-1, -1, -1, -1}, // 28
std::array{-1, -1, -1, -1}, // 29
std::array{-1, -1, -1, -1}, // 30
std::array{-1, -1, -1, -1}, // 31
std::array{-1, -1, -1, -1}, // 32 FormatGB_GR
std::array{-1, -1, -1, -1}, // 33 FormatBG_RG
std::array{-1, -1, -1, -1}, // 34 Format5_9_9_9
std::array{-1, -1, -1, -1}, // 35 FormatBc1
std::array{-1, -1, -1, -1}, // 36 FormatBc2
std::array{-1, -1, -1, -1}, // 37 FormatBc3
std::array{-1, -1, -1, -1}, // 38 FormatBc4
std::array{-1, -1, -1, -1}, // 39 FormatBc5
std::array{-1, -1, -1, -1}, // 40 FormatBc6
std::array{-1, -1, -1, -1}, // 41 FormatBc7
static constexpr std::array BITS_PER_BLOCK = {
0, // 0 FormatInvalid
8, // 1 Format8
16, // 2 Format16
16, // 3 Format8_8
32, // 4 Format32
32, // 5 Format16_16
32, // 6 Format10_11_11
32, // 7 Format11_11_10
32, // 8 Format10_10_10_2
32, // 9 Format2_10_10_10
32, // 10 Format8_8_8_8
64, // 11 Format32_32
64, // 12 Format16_16_16_16
96, // 13 Format32_32_32
128, // 14 Format32_32_32_32
0, // 15
16, // 16 Format5_6_5
16, // 17 Format1_5_5_5
16, // 18 Format5_5_5_1
16, // 19 Format4_4_4_4
32, // 20 Format8_24
32, // 21 Format24_8
64, // 22 FormatX24_8_32
0, // 23
0, // 24
0, // 25
0, // 26
0, // 27
0, // 28
0, // 29
0, // 30
0, // 31
16, // 32 FormatGB_GR
16, // 33 FormatBG_RG
32, // 34 Format5_9_9_9
64, // 35 FormatBc1
128, // 36 FormatBc2
128, // 37 FormatBc3
64, // 38 FormatBc4
128, // 39 FormatBc5
128, // 40 FormatBc6
128, // 41 FormatBc7
};
s32 ComponentOffset(DataFormat format, u32 comp) {
u32 NumBitsPerBlock(DataFormat format) {
const u32 index = static_cast<u32>(format);
if (index >= component_offset.size() || comp >= 4) {
return -1;
}
return component_offset[index][comp];
ASSERT_MSG(index < BITS_PER_BLOCK.size(), "Invalid data format = {}", format);
return BITS_PER_BLOCK[index];
}
} // namespace AmdGpu

6
src/video_core/amdgpu/pixel_format.h
View File

@ -310,10 +310,8 @@ constexpr bool IsInteger(const NumberFormat nfmt) {
std::string_view NameOf(DataFormat fmt);
std::string_view NameOf(NumberFormat fmt);
int NumComponents(DataFormat format);
int NumBits(DataFormat format);
u32 ComponentBits(DataFormat format, u32 comp);
s32 ComponentOffset(DataFormat format, u32 comp);
u32 NumComponents(DataFormat format);
u32 NumBitsPerBlock(DataFormat format);
} // namespace AmdGpu

5
src/video_core/texture_cache/image_info.cpp
View File

@ -81,7 +81,7 @@ ImageInfo::ImageInfo(const AmdGpu::Liverpool::ColorBuffer& buffer,
tiling_mode = buffer.GetTilingMode();
pixel_format = LiverpoolToVK::SurfaceFormat(buffer.GetDataFmt(), buffer.GetNumberFmt());
num_samples = buffer.NumSamples();
num_bits = NumBits(buffer.GetDataFmt());
num_bits = NumBitsPerBlock(buffer.GetDataFmt());
type = vk::ImageType::e2D;
size.width = hint.Valid() ? hint.width : buffer.Pitch();
size.height = hint.Valid() ? hint.height : buffer.Height();
@ -142,7 +142,7 @@ ImageInfo::ImageInfo(const AmdGpu::Image& image, const Shader::ImageResource& de
resources.levels = image.NumLevels();
resources.layers = image.NumLayers();
num_samples = image.NumSamples();
num_bits = NumBits(image.GetDataFmt());
num_bits = NumBitsPerBlock(image.GetDataFmt());
guest_address = image.Address();
@ -163,7 +163,6 @@ void ImageInfo::UpdateSize() {
if (props.is_block) {
mip_w = (mip_w + 3) / 4;
mip_h = (mip_h + 3) / 4;
bpp *= 16;
}
mip_w = std::max(mip_w, 1u);
mip_h = std::max(mip_h, 1u);

6
src/video_core/texture_cache/texture_cache.cpp
View File

@ -512,9 +512,9 @@ void TextureCache::RefreshImage(Image& image, Vulkan::Scheduler* custom_schedule
// So this calculation should be very uncommon and reasonably fast
// For now we'll just check up to 64 first pixels
const auto addr = std::bit_cast<u8*>(image.info.guest_address);
const auto w = std::min(image.info.size.width, u32(8));
const auto h = std::min(image.info.size.height, u32(8));
const auto size = w * h * image.info.num_bits / 8;
const u32 w = std::min(image.info.size.width, u32(8));
const u32 h = std::min(image.info.size.height, u32(8));
const u32 size = w * h * image.info.num_bits >> (3 + image.info.props.is_block ? 4 : 0);
const u64 hash = XXH3_64bits(addr, size);
if (image.hash == hash) {
image.flags &= ~ImageFlagBits::MaybeCpuDirty;

10
src/video_core/texture_cache/tile_manager.cpp
View File

@ -25,10 +25,9 @@
namespace VideoCore {
const DetilerContext* TileManager::GetDetiler(const ImageInfo& info) const {
const auto bpp = info.num_bits * (info.props.is_block ? 16 : 1);
switch (info.tiling_mode) {
case AmdGpu::TilingMode::Texture_MicroTiled:
switch (bpp) {
switch (info.num_bits) {
case 8:
return &detilers[DetilerType::Micro8];
case 16:
@ -43,7 +42,7 @@ const DetilerContext* TileManager::GetDetiler(const ImageInfo& info) const {
return nullptr;
}
case AmdGpu::TilingMode::Texture_Volume:
switch (bpp) {
switch (info.num_bits) {
case 8:
return &detilers[DetilerType::Macro8];
case 32:
@ -55,7 +54,7 @@ const DetilerContext* TileManager::GetDetiler(const ImageInfo& info) const {
}
break;
case AmdGpu::TilingMode::Display_MicroTiled:
switch (bpp) {
switch (info.num_bits) {
case 64:
return &detilers[DetilerType::Display_Micro64];
default:
@ -287,8 +286,7 @@ std::pair<vk::Buffer, u32> TileManager::TryDetile(vk::Buffer in_buffer, u32 in_o
&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));
const auto num_tiles = image_size / (64 * (info.num_bits / 8));
cmdbuf.dispatch(num_tiles, 1, 1);
return {out_buffer.first, 0};
}