mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-07-26 03:55:37 +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::NumberFormat num_format;
AmdGpu::CompMapping swizzle; AmdGpu::CompMapping swizzle;
AmdGpu::NumberConversion num_conversion; AmdGpu::NumberConversion num_conversion;
int num_components; u32 num_components;
}; };
static bool IsBufferFormatLoad(const IR::Inst& inst) { 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 { 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 = const auto slice_size =
num_bytes_per_element * (slice.tile_max + 1) * 64u * NumSamples(); num_bytes_per_element * (slice.tile_max + 1) * 64u * NumSamples();
return slice_size; 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) { static constexpr std::array NUM_COMPONENTS = {
constexpr std::array num_components_per_element = { 0, // 0 FormatInvalid
0, 1, 1, 2, 1, 2, 3, 3, 4, 4, 4, 2, 4, 3, 4, -1, 3, 4, 4, 4, 2, 1, // 1 Format8
2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 3, 4, 4, 4, 1, 2, 3, 4, 1, // 2 Format16
-1, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 1}; 2, // 3 Format8_8
1, // 4 Format32
const u32 index = static_cast<u32>(format); 2, // 5 Format16_16
if (index >= num_components_per_element.size()) { 3, // 6 Format10_11_11
return 0; 3, // 7 Format11_11_10
} 4, // 8 Format10_10_10_2
return num_components_per_element[index]; 4, // 9 Format2_10_10_10
} 4, // 10 Format8_8_8_8
2, // 11 Format32_32
int NumBits(DataFormat format) { 4, // 12 Format16_16_16_16
const std::array num_bits_per_element = { 3, // 13 Format32_32_32
0, 8, 16, 16, 32, 32, 32, 32, 32, 32, 32, 64, 64, 96, 128, -1, 16, 16, 16, 16, 32, 4, // 14 Format32_32_32_32
32, 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, 16, 32, 4, 8, 8, 4, 8, 8, 8, 0, // 15
-1, -1, 8, 8, 8, 8, 8, 8, 16, 16, 32, 32, 32, 64, 64, 8, 16, 1, 1}; 3, // 16 Format5_6_5
4, // 17 Format1_5_5_5
const u32 index = static_cast<u32>(format); 4, // 18 Format5_5_5_1
if (index >= num_bits_per_element.size()) { 4, // 19 Format4_4_4_4
return 0; 2, // 20 Format8_24
} 2, // 21 Format24_8
return num_bits_per_element[index]; 2, // 22 FormatX24_8_32
} 0, // 23
0, // 24
static constexpr std::array component_bits = { 0, // 25
std::array{0, 0, 0, 0}, // 0 FormatInvalid 0, // 26
std::array{8, 0, 0, 0}, // 1 Format8 0, // 27
std::array{16, 0, 0, 0}, // 2 Format16 0, // 28
std::array{8, 8, 0, 0}, // 3 Format8_8 0, // 29
std::array{32, 0, 0, 0}, // 4 Format32 0, // 30
std::array{16, 16, 0, 0}, // 5 Format16_16 0, // 31
std::array{11, 11, 10, 0}, // 6 Format10_11_11 3, // 32 FormatGB_GR
std::array{10, 11, 11, 0}, // 7 Format11_11_10 3, // 33 FormatBG_RG
std::array{2, 10, 10, 10}, // 8 Format10_10_10_2 4, // 34 Format5_9_9_9
std::array{10, 10, 10, 2}, // 9 Format2_10_10_10 4, // 35 FormatBc1
std::array{8, 8, 8, 8}, // 10 Format8_8_8_8 4, // 36 FormatBc2
std::array{32, 32, 0, 0}, // 11 Format32_32 4, // 37 FormatBc3
std::array{16, 16, 16, 16}, // 12 Format16_16_16_16 1, // 38 FormatBc4
std::array{32, 32, 32, 0}, // 13 Format32_32_32 2, // 39 FormatBc5
std::array{32, 32, 32, 32}, // 14 Format32_32_32_32 3, // 40 FormatBc6
std::array{0, 0, 0, 0}, // 15 4, // 41 FormatBc7
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
}; };
u32 ComponentBits(DataFormat format, u32 comp) { u32 NumComponents(DataFormat format) {
const u32 index = static_cast<u32>(format); const u32 index = static_cast<u32>(format);
if (index >= component_bits.size() || comp >= 4) { ASSERT_MSG(index < NUM_COMPONENTS.size(), "Invalid data format = {}", format);
return 0; return NUM_COMPONENTS[index];
}
return component_bits[index][comp];
} }
static constexpr std::array component_offset = { static constexpr std::array BITS_PER_BLOCK = {
std::array{-1, -1, -1, -1}, // 0 FormatInvalid 0, // 0 FormatInvalid
std::array{0, -1, -1, -1}, // 1 Format8 8, // 1 Format8
std::array{0, -1, -1, -1}, // 2 Format16 16, // 2 Format16
std::array{0, 8, -1, -1}, // 3 Format8_8 16, // 3 Format8_8
std::array{0, -1, -1, -1}, // 4 Format32 32, // 4 Format32
std::array{0, 16, -1, -1}, // 5 Format16_16 32, // 5 Format16_16
std::array{0, 11, 22, -1}, // 6 Format10_11_11 32, // 6 Format10_11_11
std::array{0, 10, 21, -1}, // 7 Format11_11_10 32, // 7 Format11_11_10
std::array{0, 2, 12, 22}, // 8 Format10_10_10_2 32, // 8 Format10_10_10_2
std::array{0, 10, 20, 30}, // 9 Format2_10_10_10 32, // 9 Format2_10_10_10
std::array{0, 8, 16, 24}, // 10 Format8_8_8_8 32, // 10 Format8_8_8_8
std::array{0, 32, -1, -1}, // 11 Format32_32 64, // 11 Format32_32
std::array{0, 16, 32, 48}, // 12 Format16_16_16_16 64, // 12 Format16_16_16_16
std::array{0, 32, 64, -1}, // 13 Format32_32_32 96, // 13 Format32_32_32
std::array{0, 32, 64, 96}, // 14 Format32_32_32_32 128, // 14 Format32_32_32_32
std::array{-1, -1, -1, -1}, // 15 0, // 15
std::array{0, 5, 11, -1}, // 16 Format5_6_5 16, // 16 Format5_6_5
std::array{0, 5, 10, 15}, // 17 Format1_5_5_5 16, // 17 Format1_5_5_5
std::array{0, 1, 6, 11}, // 18 Format5_5_5_1 16, // 18 Format5_5_5_1
std::array{0, 4, 8, 12}, // 19 Format4_4_4_4 16, // 19 Format4_4_4_4
std::array{0, 24, -1, -1}, // 20 Format8_24 32, // 20 Format8_24
std::array{0, 8, -1, -1}, // 21 Format24_8 32, // 21 Format24_8
std::array{0, 8, -1, -1}, // 22 FormatX24_8_32 64, // 22 FormatX24_8_32
std::array{-1, -1, -1, -1}, // 23 0, // 23
std::array{-1, -1, -1, -1}, // 24 0, // 24
std::array{-1, -1, -1, -1}, // 25 0, // 25
std::array{-1, -1, -1, -1}, // 26 0, // 26
std::array{-1, -1, -1, -1}, // 27 0, // 27
std::array{-1, -1, -1, -1}, // 28 0, // 28
std::array{-1, -1, -1, -1}, // 29 0, // 29
std::array{-1, -1, -1, -1}, // 30 0, // 30
std::array{-1, -1, -1, -1}, // 31 0, // 31
std::array{-1, -1, -1, -1}, // 32 FormatGB_GR 16, // 32 FormatGB_GR
std::array{-1, -1, -1, -1}, // 33 FormatBG_RG 16, // 33 FormatBG_RG
std::array{-1, -1, -1, -1}, // 34 Format5_9_9_9 32, // 34 Format5_9_9_9
std::array{-1, -1, -1, -1}, // 35 FormatBc1 64, // 35 FormatBc1
std::array{-1, -1, -1, -1}, // 36 FormatBc2 128, // 36 FormatBc2
std::array{-1, -1, -1, -1}, // 37 FormatBc3 128, // 37 FormatBc3
std::array{-1, -1, -1, -1}, // 38 FormatBc4 64, // 38 FormatBc4
std::array{-1, -1, -1, -1}, // 39 FormatBc5 128, // 39 FormatBc5
std::array{-1, -1, -1, -1}, // 40 FormatBc6 128, // 40 FormatBc6
std::array{-1, -1, -1, -1}, // 41 FormatBc7 128, // 41 FormatBc7
}; };
s32 ComponentOffset(DataFormat format, u32 comp) { u32 NumBitsPerBlock(DataFormat format) {
const u32 index = static_cast<u32>(format); const u32 index = static_cast<u32>(format);
if (index >= component_offset.size() || comp >= 4) { ASSERT_MSG(index < BITS_PER_BLOCK.size(), "Invalid data format = {}", format);
return -1; return BITS_PER_BLOCK[index];
}
return component_offset[index][comp];
} }
} // namespace AmdGpu } // 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(DataFormat fmt);
std::string_view NameOf(NumberFormat fmt); std::string_view NameOf(NumberFormat fmt);
int NumComponents(DataFormat format); u32 NumComponents(DataFormat format);
int NumBits(DataFormat format); u32 NumBitsPerBlock(DataFormat format);
u32 ComponentBits(DataFormat format, u32 comp);
s32 ComponentOffset(DataFormat format, u32 comp);
} // namespace AmdGpu } // 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(); tiling_mode = buffer.GetTilingMode();
pixel_format = LiverpoolToVK::SurfaceFormat(buffer.GetDataFmt(), buffer.GetNumberFmt()); pixel_format = LiverpoolToVK::SurfaceFormat(buffer.GetDataFmt(), buffer.GetNumberFmt());
num_samples = buffer.NumSamples(); num_samples = buffer.NumSamples();
num_bits = NumBits(buffer.GetDataFmt()); num_bits = NumBitsPerBlock(buffer.GetDataFmt());
type = vk::ImageType::e2D; type = vk::ImageType::e2D;
size.width = hint.Valid() ? hint.width : buffer.Pitch(); size.width = hint.Valid() ? hint.width : buffer.Pitch();
size.height = hint.Valid() ? hint.height : buffer.Height(); 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.levels = image.NumLevels();
resources.layers = image.NumLayers(); resources.layers = image.NumLayers();
num_samples = image.NumSamples(); num_samples = image.NumSamples();
num_bits = NumBits(image.GetDataFmt()); num_bits = NumBitsPerBlock(image.GetDataFmt());
guest_address = image.Address(); guest_address = image.Address();
@ -163,7 +163,6 @@ void ImageInfo::UpdateSize() {
if (props.is_block) { if (props.is_block) {
mip_w = (mip_w + 3) / 4; mip_w = (mip_w + 3) / 4;
mip_h = (mip_h + 3) / 4; mip_h = (mip_h + 3) / 4;
bpp *= 16;
} }
mip_w = std::max(mip_w, 1u); mip_w = std::max(mip_w, 1u);
mip_h = std::max(mip_h, 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 // So this calculation should be very uncommon and reasonably fast
// For now we'll just check up to 64 first pixels // For now we'll just check up to 64 first pixels
const auto addr = std::bit_cast<u8*>(image.info.guest_address); const auto addr = std::bit_cast<u8*>(image.info.guest_address);
const auto w = std::min(image.info.size.width, u32(8)); const u32 w = std::min(image.info.size.width, u32(8));
const auto h = std::min(image.info.size.height, u32(8)); const u32 h = std::min(image.info.size.height, u32(8));
const auto size = w * h * image.info.num_bits / 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); const u64 hash = XXH3_64bits(addr, size);
if (image.hash == hash) { if (image.hash == hash) {
image.flags &= ~ImageFlagBits::MaybeCpuDirty; image.flags &= ~ImageFlagBits::MaybeCpuDirty;

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

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