yuzu/yuzu-android
1
0
Fork 0
mirror of https://github.com/yuzu-emu/yuzu-android.git synced 2024-12-25 04:55:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

flattening

Browse source
This commit is contained in:
Ameer J 2023-07-30 12:41:52 -04:00
parent ac09cc3504
commit 27c8bb9615
1 changed files with 44 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

87
src/video_core/host_shaders/astc_decoder.comp
View file

@ -140,8 +140,6 @@ int result_index = 0;
EncodingData texel_vector[144];
int texel_vector_index = 0;
uint unquantized_texel_weights[2][144];
// Replicates low num_bits such that [(to_bit - 1):(to_bit - 1 - from_bit)]
// is the same as [(num_bits - 1):0] and repeats all the way down.
uint Replicate(uint val, uint num_bits, uint to_bit) {
@ -879,58 +877,60 @@ uint UnquantizeTexelWeight(EncodingData val) {
return result;
}
void UnquantizeTexelWeights(bool dual_plane, uvec2 size) {
uint weight_idx = 0;
uint unquantized[2][144];
uint area = size.x * size.y;
for (uint itr = 0; itr < texel_vector_index; itr++) {
unquantized[0][weight_idx] = UnquantizeTexelWeight(texel_vector[itr]);
if (dual_plane) {
++itr;
unquantized[1][weight_idx] = UnquantizeTexelWeight(texel_vector[itr]);
if (itr == texel_vector_index) {
break;
}
}
if (++weight_idx >= (area))
break;
}
void UnquantizeTexelWeights(bool is_dual_plane, uvec2 size, out uint unquantized_texel_weights[2 * 144]) {
const uint Ds = uint((block_dims.x * 0.5f + 1024) / (block_dims.x - 1));
const uint Dt = uint((block_dims.y * 0.5f + 1024) / (block_dims.y - 1));
const uint k_plane_scale = dual_plane ? 2 : 1;
for (uint plane = 0; plane < k_plane_scale; plane++) {
const uint num_planes = is_dual_plane ? 2 : 1;
const uint area = size.x * size.y;
const uint loop_count = min(result_index, area * num_planes);
uint unquantized[2 * 144];
for (uint itr = 0; itr < loop_count; ++itr) {
unquantized[itr] = UnquantizeTexelWeight(texel_vector[itr]);
}
for (uint plane = 0; plane < num_planes; ++plane) {
for (uint t = 0; t < block_dims.y; t++) {
for (uint s = 0; s < block_dims.x; s++) {
uint cs = Ds * s;
uint ct = Dt * t;
uint gs = (cs * (size.x - 1) + 32) >> 6;
uint gt = (ct * (size.y - 1) + 32) >> 6;
uint js = gs >> 4;
uint fs = gs & 0xF;
uint jt = gt >> 4;
uint ft = gt & 0x0F;
uint w11 = (fs * ft + 8) >> 4;
uint w10 = ft - w11;
uint w01 = fs - w11;
uint w00 = 16 - fs - ft + w11;
uvec4 w = uvec4(w00, w01, w10, w11);
uint v0 = jt * size.x + js;
const uint cs = Ds * s;
const uint ct = Dt * t;
const uint gs = (cs * (size.x - 1) + 32) >> 6;
const uint gt = (ct * (size.y - 1) + 32) >> 6;
const uint js = gs >> 4;
const uint fs = gs & 0xF;
const uint jt = gt >> 4;
const uint ft = gt & 0x0F;
const uint w11 = (fs * ft + 8) >> 4;
const uint w10 = ft - w11;
const uint w01 = fs - w11;
const uint w00 = 16 - fs - ft + w11;
const uvec4 w = uvec4(w00, w01, w10, w11);
const uint v0 = jt * size.x + js;
uvec4 p = uvec4(0);
#define VectorIndicesFromBase(offset_base) \
const uint offset = is_dual_plane ? 2 * offset_base + plane : offset_base; \
if (v0 < area) {
p.x = unquantized[plane][v0];
const uint offset_base = v0;
VectorIndicesFromBase(offset_base);
p.x = unquantized[offset];
}
if ((v0 + 1) < (area)) {
p.y = unquantized[plane][v0 + 1];
const uint offset_base = v0 + 1;
VectorIndicesFromBase(offset_base);
p.y = unquantized[offset];
}
if ((v0 + size.x) < (area)) {
p.z = unquantized[plane][(v0 + size.x)];
const uint offset_base = v0 + size.x;
VectorIndicesFromBase(offset_base);
p.z = unquantized[offset];
}
if ((v0 + size.x + 1) < (area)) {
p.w = unquantized[plane][(v0 + size.x + 1)];
const uint offset_base = v0 + size.x + 1;
VectorIndicesFromBase(offset_base);
p.w = unquantized[offset];
}
unquantized_texel_weights[plane][t * block_dims.x + s] = (uint(dot(p, w)) + 8) >> 4;
unquantized_texel_weights[plane * 144 + t * block_dims.x + s] = (uint(dot(p, w)) + 8) >> 4;
}
}
}
@ -1208,7 +1208,8 @@ void DecompressBlock(ivec3 coord) {
texel_flag = true; // use texel "vector" and bit stream in integer decoding
DecodeIntegerSequence(params.max_weight, GetNumWeightValues(params.size, params.dual_plane));
UnquantizeTexelWeights(params.dual_plane, params.size);
uint unquantized_texel_weights[2 * 144];
UnquantizeTexelWeights(params.dual_plane, params.size, unquantized_texel_weights);
for (uint j = 0; j < block_dims.y; j++) {
for (uint i = 0; i < block_dims.x; i++) {
@ -1220,10 +1221,10 @@ void DecompressBlock(ivec3 coord) {
const uvec4 C0 = ReplicateByteTo16(endpoints[local_partition][0]);
const uvec4 C1 = ReplicateByteTo16(endpoints[local_partition][1]);
const uint weight_offset = (j * block_dims.x + i);
const uint primary_weight = unquantized_texel_weights[weight_offset][0];
const uint primary_weight = unquantized_texel_weights[weight_offset];
uvec4 weight_vec = uvec4(primary_weight);
if (params.dual_plane) {
const uint secondary_weight = unquantized_texel_weights[weight_offset][1];
const uint secondary_weight = unquantized_texel_weights[weight_offset + 144];
for (uint c = 0; c < 4; c++) {
const bool is_secondary = ((plane_index + 1u) & 3u) == c;
weight_vec[c] = is_secondary ? secondary_weight : primary_weight;