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

early-access version 1489

Browse Source
This commit is contained in:
pineappleEA
2021-02-28 05:08:39 +01:00
parent 2073701e78
commit 70ed6ce99a
42 changed files with 554 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/video_core/host_shaders/CMakeLists.txt
View File

@@ -6,7 +6,6 @@ set(SHADER_FILES
convert_float_to_depth.frag
full_screen_triangle.vert
opengl_copy_bc4.comp
opengl_copy_bgr16.comp
opengl_copy_bgra.comp
opengl_present.frag
opengl_present.vert

451
src/video_core/host_shaders/astc_decoder.comp
View File

@@ -48,15 +48,6 @@ UNIFORM(6) uint block_height;
UNIFORM(7) uint block_height_mask;
END_PUSH_CONSTANTS
uint current_index = 0;
int bitsread = 0;
uint total_bitsread = 0;
uint local_buff[16];
const int JustBits = 0;
const int Quint = 1;
const int Trit = 2;
struct EncodingData {
uint encoding;
uint num_bits;
@@ -66,11 +57,11 @@ struct EncodingData {
struct TexelWeightParams {
uvec2 size;
bool dual_plane;
uint max_weight;
bool Error;
bool VoidExtentLDR;
bool VoidExtentHDR;
bool dual_plane;
bool error_state;
bool void_extent_ldr;
bool void_extent_hdr;
};
// Swizzle data
@@ -114,6 +105,72 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
const int BLOCK_SIZE_IN_BYTES = 16;
const int BLOCK_INFO_ERROR = 0;
const int BLOCK_INFO_VOID_EXTENT_HDR = 1;
const int BLOCK_INFO_VOID_EXTENT_LDR = 2;
const int BLOCK_INFO_NORMAL = 3;
const int JUST_BITS = 0;
const int QUINT = 1;
const int TRIT = 2;
// The following constants are expanded variants of the Replicate()
// function calls corresponding to the following arguments:
// value: index into the generated table
// num_bits: the after "REPLICATE" in the table name. i.e. 4 is num_bits in REPLICATE_4.
// to_bit: the integer after "TO_"
const uint REPLICATE_BIT_TO_7_TABLE[2] = uint[](0, 127);
const uint REPLICATE_1_BIT_TO_9_TABLE[2] = uint[](0, 511);
const uint REPLICATE_1_BIT_TO_8_TABLE[2] = uint[](0, 255);
const uint REPLICATE_2_BIT_TO_8_TABLE[4] = uint[](0, 85, 170, 255);
const uint REPLICATE_3_BIT_TO_8_TABLE[8] = uint[](0, 36, 73, 109, 146, 182, 219, 255);
const uint REPLICATE_4_BIT_TO_8_TABLE[16] =
uint[](0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255);
const uint REPLICATE_5_BIT_TO_8_TABLE[32] =
uint[](0, 8, 16, 24, 33, 41, 49, 57, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165,
173, 181, 189, 198, 206, 214, 222, 231, 239, 247, 255);
const uint REPLICATE_1_BIT_TO_6_TABLE[2] = uint[](0, 63);
const uint REPLICATE_2_BIT_TO_6_TABLE[4] = uint[](0, 21, 42, 63);
const uint REPLICATE_3_BIT_TO_6_TABLE[8] = uint[](0, 9, 18, 27, 36, 45, 54, 63);
const uint REPLICATE_4_BIT_TO_6_TABLE[16] =
uint[](0, 4, 8, 12, 17, 21, 25, 29, 34, 38, 42, 46, 51, 55, 59, 63);
const uint REPLICATE_5_BIT_TO_6_TABLE[32] =
uint[](0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 33, 35, 37, 39, 41, 43, 45,
47, 49, 51, 53, 55, 57, 59, 61, 63);
// Input ASTC texture globals
uint current_index = 0;
int bitsread = 0;
uint total_bitsread = 0;
uint local_buff[16];
// Color data globals
uint color_endpoint_data[16];
int color_bitsread = 0;
uint total_color_bitsread = 0;
int color_index = 0;
int colvals_index = 0;
// Weight data globals
uint texel_weight_data[16];
int texel_bitsread = 0;
uint total_texel_bitsread = 0;
int texel_index = 0;
bool texel_flag = false;
// Global "vectors" to be pushed into when decoding
EncodingData result_vector[100];
int result_index = 0;
EncodingData texel_vector[100];
int texel_vector_index = 0;
uint unquantized_texel_weights[2][144];
uint SwizzleOffset(uvec2 pos) {
pos = pos & SWIZZLE_MASK;
return swizzle_table[pos.y * 64 + pos.x];
@@ -124,21 +181,10 @@ uint ReadTexel(uint offset) {
return bitfieldExtract(astc_data[offset / 4], int((offset * 8) & 24), 8);
}
const int BLOCK_SIZE_IN_BYTES = 16;
const int BLOCK_INFO_ERROR = 0;
const int BLOCK_INFO_VOID_EXTENT_HDR = 1;
const int BLOCK_INFO_VOID_EXTENT_LDR = 2;
const int BLOCK_INFO_NORMAL = 3;
// Replicates low numBits such that [(toBit - 1):(toBit - 1 - fromBit)]
// is the same as [(numBits - 1):0] and repeats all the way down.
// 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) {
if (num_bits == 0) {
return 0;
}
if (to_bit == 0) {
if (num_bits == 0 || to_bit == 0) {
return 0;
}
const uint v = val & uint((1 << num_bits) - 1);
@@ -163,28 +209,14 @@ uvec4 ReplicateByteTo16(uvec4 value) {
REPLICATE_BYTE_TO_16_TABLE[value.z], REPLICATE_BYTE_TO_16_TABLE[value.w]);
}
const uint REPLICATE_BIT_TO_7_TABLE[2] = uint[](0, 127);
uint ReplicateBitTo7(uint value) {
return REPLICATE_BIT_TO_7_TABLE[value];
;
}
const uint REPLICATE_1_BIT_TO_9_TABLE[2] = uint[](0, 511);
uint ReplicateBitTo9(uint value) {
return REPLICATE_1_BIT_TO_9_TABLE[value];
}
const uint REPLICATE_1_BIT_TO_8_TABLE[2] = uint[](0, 255);
const uint REPLICATE_2_BIT_TO_8_TABLE[4] = uint[](0, 85, 170, 255);
const uint REPLICATE_3_BIT_TO_8_TABLE[8] = uint[](0, 36, 73, 109, 146, 182, 219, 255);
const uint REPLICATE_4_BIT_TO_8_TABLE[16] =
uint[](0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255);
const uint REPLICATE_5_BIT_TO_8_TABLE[32] =
uint[](0, 8, 16, 24, 33, 41, 49, 57, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165,
173, 181, 189, 198, 206, 214, 222, 231, 239, 247, 255);
uint FastReplicateTo8(uint value, uint num_bits) {
switch (num_bits) {
case 1:
@@ -207,15 +239,6 @@ uint FastReplicateTo8(uint value, uint num_bits) {
return Replicate(value, num_bits, 8);
}
const uint REPLICATE_1_BIT_TO_6_TABLE[2] = uint[](0, 63);
const uint REPLICATE_2_BIT_TO_6_TABLE[4] = uint[](0, 21, 42, 63);
const uint REPLICATE_3_BIT_TO_6_TABLE[8] = uint[](0, 9, 18, 27, 36, 45, 54, 63);
const uint REPLICATE_4_BIT_TO_6_TABLE[16] =
uint[](0, 4, 8, 12, 17, 21, 25, 29, 34, 38, 42, 46, 51, 55, 59, 63);
const uint REPLICATE_5_BIT_TO_6_TABLE[32] =
uint[](0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 33, 35, 37, 39, 41, 43, 45,
47, 49, 51, 53, 55, 57, 59, 61, 63);
uint FastReplicateTo6(uint value, uint num_bits) {
switch (num_bits) {
case 1:
@@ -232,23 +255,23 @@ uint FastReplicateTo6(uint value, uint num_bits) {
return Replicate(value, num_bits, 6);
}
uint div3_floor(uint v) {
uint Div3Floor(uint v) {
return (v * 0x5556) >> 16;
}
uint div3_ceil(uint v) {
return div3_floor(v + 2);
uint Div3Ceil(uint v) {
return Div3Floor(v + 2);
}
uint div5_floor(uint v) {
uint Div5Floor(uint v) {
return (v * 0x3334) >> 16;
}
uint div5_ceil(uint v) {
return div5_floor(v + 4);
uint Div5Ceil(uint v) {
return Div5Floor(v + 4);
}
uint hash52(uint p) {
uint Hash52(uint p) {
p ^= p >> 15;
p -= p << 17;
p += p << 7;
@@ -263,9 +286,9 @@ uint hash52(uint p) {
}
uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bool small_block) {
if (1 == partition_count)
if (partition_count == 1) {
return 0;
}
if (small_block) {
x <<= 1;
y <<= 1;
@@ -274,7 +297,7 @@ uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bo
seed += (partition_count - 1) * 1024;
uint rnum = hash52(uint(seed));
uint rnum = Hash52(uint(seed));
uint seed1 = uint(rnum & 0xF);
uint seed2 = uint((rnum >> 4) & 0xF);
uint seed3 = uint((rnum >> 8) & 0xF);
@@ -334,18 +357,22 @@ uint SelectPartition(uint seed, uint x, uint y, uint z, uint partition_count, bo
c &= 0x3F;
d &= 0x3F;
if (partition_count < 4)
if (partition_count < 4) {
d = 0;
if (partition_count < 3)
}
if (partition_count < 3) {
c = 0;
}
if (a >= b && a >= c && a >= d)
if (a >= b && a >= c && a >= d) {
return 0;
else if (b >= c && b >= d)
} else if (b >= c && b >= d) {
return 1;
else if (c >= d)
} else if (c >= d) {
return 2;
return 3;
} else {
return 3;
}
}
uint Select2DPartition(uint seed, uint x, uint y, uint partition_count, bool small_block) {
@@ -357,10 +384,10 @@ uint ReadBit() {
return 0;
}
uint bit = bitfieldExtract(local_buff[current_index], bitsread, 1);
bitsread++;
total_bitsread++;
++bitsread;
++total_bitsread;
if (bitsread == 8) {
current_index++;
++current_index;
bitsread = 0;
}
return bit;
@@ -374,36 +401,22 @@ uint StreamBits(uint num_bits) {
return ret;
}
// Define color data.
uint color_endpoint_data[16];
int color_bitsread = 0;
uint total_color_bitsread = 0;
int color_index = 0;
// Define color data.
uint texel_weight_data[16];
int texel_bitsread = 0;
uint total_texel_bitsread = 0;
int texel_index = 0;
bool texel_flag = false;
uint ReadColorBit() {
uint bit = 0;
if (texel_flag) {
bit = bitfieldExtract(texel_weight_data[texel_index], texel_bitsread, 1);
texel_bitsread++;
total_texel_bitsread++;
++texel_bitsread;
++total_texel_bitsread;
if (texel_bitsread == 8) {
texel_index++;
++texel_index;
texel_bitsread = 0;
}
} else {
bit = bitfieldExtract(color_endpoint_data[color_index], color_bitsread, 1);
color_bitsread++;
total_color_bitsread++;
++color_bitsread;
++total_color_bitsread;
if (color_bitsread == 8) {
color_index++;
++color_index;
color_bitsread = 0;
}
}
@@ -418,29 +431,23 @@ uint StreamColorBits(uint num_bits) {
return ret;
}
EncodingData result_vector[100];
int result_index = 0;
EncodingData texel_vector[100];
int texel_vector_index = 0;
void ResultEmplaceBack(EncodingData val) {
if (texel_flag) {
texel_vector[texel_vector_index] = val;
texel_vector_index++;
++texel_vector_index;
} else {
result_vector[result_index] = val;
result_index++;
++result_index;
}
}
// Returns the number of bits required to encode n_vals values.
uint GetBitLength(uint n_vals, uint encoding_index) {
uint total_bits = encoding_values[encoding_index].num_bits * n_vals;
if (encoding_values[encoding_index].encoding == Trit) {
total_bits += div5_ceil(n_vals * 8);
} else if (encoding_values[encoding_index].encoding == Quint) {
total_bits += div3_ceil(n_vals * 7);
if (encoding_values[encoding_index].encoding == TRIT) {
total_bits += Div5Ceil(n_vals * 8);
} else if (encoding_values[encoding_index].encoding == QUINT) {
total_bits += Div3Ceil(n_vals * 7);
}
return total_bits;
}
@@ -475,7 +482,7 @@ uint BitsOp(uint bits, uint start, uint end) {
return ((bits >> start) & mask);
}
void DecodeQuintBlock(uint num_bits) { // Value number of bits
void DecodeQuintBlock(uint num_bits) {
uint m[3];
uint q[3];
uint Q;
@@ -499,7 +506,6 @@ void DecodeQuintBlock(uint num_bits) { // Value number of bits
q[2] = BitsOp(Q, 5, 6);
C = BitsOp(Q, 0, 4);
}
if (BitsOp(C, 0, 2) == 5) {
q[1] = 4;
q[0] = BitsOp(C, 3, 4);
@@ -508,10 +514,9 @@ void DecodeQuintBlock(uint num_bits) { // Value number of bits
q[0] = BitsOp(C, 0, 2);
}
}
for (uint i = 0; i < 3; i++) {
EncodingData val;
val.encoding = Quint;
val.encoding = QUINT;
val.num_bits = num_bits;
val.bit_value = m[i];
val.quint_trit_value = q[i];
@@ -563,7 +568,7 @@ void DecodeTritBlock(uint num_bits) {
}
for (uint i = 0; i < 5; i++) {
EncodingData val;
val.encoding = Trit;
val.encoding = TRIT;
val.num_bits = num_bits;
val.bit_value = m[i];
val.quint_trit_value = t[i];
@@ -576,17 +581,15 @@ void DecodeIntegerSequence(uint max_range, uint num_values) {
uint vals_decoded = 0;
while (vals_decoded < num_values) {
switch (val.encoding) {
case Quint:
case QUINT:
DecodeQuintBlock(val.num_bits);
vals_decoded += 3;
break;
case Trit:
case TRIT:
DecodeTritBlock(val.num_bits);
vals_decoded += 5;
break;
case JustBits:
case JUST_BITS:
val.bit_value = StreamColorBits(val.num_bits);
ResultEmplaceBack(val);
vals_decoded++;
@@ -604,21 +607,21 @@ void DecodeColorValues(out uint color_values[32], uvec4 modes, uint num_partitio
int range = 256;
while (--range > 0) {
EncodingData val = encoding_values[range];
uint bitLength = GetBitLength(num_values, range);
if (bitLength <= color_data_bits) {
uint bit_length = GetBitLength(num_values, range);
if (bit_length <= color_data_bits) {
while (--range > 0) {
EncodingData newval = encoding_values[range];
if (newval.encoding != val.encoding && newval.num_bits != val.num_bits) {
break;
}
}
range++;
++range;
break;
}
}
DecodeIntegerSequence(range, num_values);
uint out_index = 0;
for (int itr = 0; itr < result_index; itr++) {
for (int itr = 0; itr < result_index; ++itr) {
if (out_index >= num_values) {
break;
}
@@ -628,77 +631,83 @@ void DecodeColorValues(out uint color_values[32], uvec4 modes, uint num_partitio
uint A = 0, B = 0, C = 0, D = 0;
A = ReplicateBitTo9((bitval & 1));
switch (val.encoding) {
case JustBits:
case JUST_BITS:
color_values[out_index++] = FastReplicateTo8(bitval, bitlen);
break;
case Trit: {
case TRIT: {
D = val.quint_trit_value;
switch (bitlen) {
case 1: {
case 1:
C = 204;
} break;
break;
case 2: {
C = 93;
uint b = (bitval >> 1) & 1;
B = (b << 8) | (b << 4) | (b << 2) | (b << 1);
} break;
break;
}
case 3: {
C = 44;
uint cb = (bitval >> 1) & 3;
B = (cb << 7) | (cb << 2) | cb;
} break;
break;
}
case 4: {
C = 22;
uint dcb = (bitval >> 1) & 7;
B = (dcb << 6) | dcb;
} break;
break;
}
case 5: {
C = 11;
uint edcb = (bitval >> 1) & 0xF;
B = (edcb << 5) | (edcb >> 2);
} break;
break;
}
case 6: {
C = 5;
uint fedcb = (bitval >> 1) & 0x1F;
B = (fedcb << 4) | (fedcb >> 4);
} break;
break;
}
} break;
case Quint: {
}
break;
}
case QUINT: {
D = val.quint_trit_value;
switch (bitlen) {
case 1: {
case 1:
C = 113;
} break;
break;
case 2: {
C = 54;
uint b = (bitval >> 1) & 1;
B = (b << 8) | (b << 3) | (b << 2);
} break;
break;
}
case 3: {
C = 26;
uint cb = (bitval >> 1) & 3;
B = (cb << 7) | (cb << 1) | (cb >> 1);
} break;
break;
}
case 4: {
C = 13;
uint dcb = (bitval >> 1) & 7;
B = (dcb << 6) | (dcb >> 1);
} break;
break;
}
case 5: {
C = 6;
uint edcb = (bitval >> 1) & 0xF;
B = (edcb << 5) | (edcb >> 3);
} break;
break;
}
} break;
}
break;
}
if (val.encoding != JustBits) {
}
if (val.encoding != JUST_BITS) {
uint T = (D * C) + B;
T ^= A;
T = (A & 0x80) | (T >> 2);
@@ -709,18 +718,18 @@ void DecodeColorValues(out uint color_values[32], uvec4 modes, uint num_partitio
ivec2 BitTransferSigned(int a, int b) {
ivec2 transferred;
transferred[1] = b >> 1;
transferred[1] |= a & 0x80;
transferred[0] = a >> 1;
transferred[0] &= 0x3F;
if ((transferred[0] & 0x20) > 0) {
transferred[0] -= 0x40;
transferred.y = b >> 1;
transferred.y |= a & 0x80;
transferred.x = a >> 1;
transferred.x &= 0x3F;
if ((transferred.x & 0x20) > 0) {
transferred.x -= 0x40;
}
return transferred;
}
uvec4 ClampByte(ivec4 color) {
for (uint i = 0; i < 4; i++) {
for (uint i = 0; i < 4; ++i) {
color[i] = (color[i] < 0) ? 0 : ((color[i] > 255) ? 255 : color[i]);
}
return uvec4(color);
@@ -730,8 +739,6 @@ ivec4 BlueContract(int a, int r, int g, int b) {
return ivec4(a, (r + b) >> 1, (g + b) >> 1, b);
}
int colvals_index = 0;
void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
uint color_endpoint_mode) {
#define READ_UINT_VALUES(N) \
@@ -751,40 +758,40 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
READ_UINT_VALUES(2)
ep1 = uvec4(0xFF, v[0], v[0], v[0]);
ep2 = uvec4(0xFF, v[1], v[1], v[1]);
} break;
break;
}
case 1: {
READ_UINT_VALUES(2)
uint L0 = (v[0] >> 2) | (v[1] & 0xC0);
uint L1 = max(L0 + (v[1] & 0x3F), 0xFFU);
ep1 = uvec4(0xFF, L0, L0, L0);
ep2 = uvec4(0xFF, L1, L1, L1);
} break;
break;
}
case 4: {
READ_UINT_VALUES(4)
ep1 = uvec4(v[2], v[0], v[0], v[0]);
ep2 = uvec4(v[3], v[1], v[1], v[1]);
} break;
break;
}
case 5: {
READ_INT_VALUES(4)
ivec2 transferred = BitTransferSigned(v[1], v[0]);
v[1] = transferred[0];
v[0] = transferred[1];
v[1] = transferred.x;
v[0] = transferred.y;
transferred = BitTransferSigned(v[3], v[2]);
v[3] = transferred[0];
v[2] = transferred[1];
v[3] = transferred.x;
v[2] = transferred.y;
ep1 = ClampByte(ivec4(v[2], v[0], v[0], v[0]));
ep2 = ClampByte(ivec4((v[2] + v[3]), v[0] + v[1], v[0] + v[1], v[0] + v[1]));
} break;
break;
}
case 6: {
READ_UINT_VALUES(4)
ep1 = uvec4(0xFF, v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8);
ep2 = uvec4(0xFF, v[0], v[1], v[2]);
} break;
break;
}
case 8: {
READ_UINT_VALUES(6)
if (v[1] + v[3] + v[5] >= v[0] + v[2] + v[4]) {
@@ -794,19 +801,19 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = uvec4(BlueContract(0xFF, int(v[1]), int(v[3]), int(v[5])));
ep2 = uvec4(BlueContract(0xFF, int(v[0]), int(v[2]), int(v[4])));
}
} break;
break;
}
case 9: {
READ_INT_VALUES(6)
ivec2 transferred = BitTransferSigned(v[1], v[0]);
v[1] = transferred[0];
v[0] = transferred[1];
v[1] = transferred.x;
v[0] = transferred.y;
transferred = BitTransferSigned(v[3], v[2]);
v[3] = transferred[0];
v[2] = transferred[1];
v[3] = transferred.x;
v[2] = transferred.y;
transferred = BitTransferSigned(v[5], v[4]);
v[5] = transferred[0];
v[4] = transferred[1];
v[5] = transferred.x;
v[4] = transferred.y;
if (v[1] + v[3] + v[5] >= 0) {
ep1 = ClampByte(ivec4(0xFF, v[0], v[2], v[4]));
ep2 = ClampByte(ivec4(0xFF, v[0] + v[1], v[2] + v[3], v[4] + v[5]));
@@ -814,14 +821,14 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = ClampByte(BlueContract(0xFF, v[0] + v[1], v[2] + v[3], v[4] + v[5]));
ep2 = ClampByte(BlueContract(0xFF, v[0], v[2], v[4]));
}
} break;
break;
}
case 10: {
READ_UINT_VALUES(6)
ep1 = uvec4(v[4], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8);
ep2 = uvec4(v[5], v[0], v[1], v[2]);
} break;
break;
}
case 12: {
READ_UINT_VALUES(8)
if (v[1] + v[3] + v[5] >= v[0] + v[2] + v[4]) {
@@ -831,24 +838,24 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = uvec4(BlueContract(int(v[7]), int(v[1]), int(v[3]), int(v[5])));
ep2 = uvec4(BlueContract(int(v[6]), int(v[0]), int(v[2]), int(v[4])));
}
} break;
break;
}
case 13: {
READ_INT_VALUES(8)
ivec2 transferred = BitTransferSigned(v[1], v[0]);
v[1] = transferred[0];
v[0] = transferred[1];
v[1] = transferred.x;
v[0] = transferred.y;
transferred = BitTransferSigned(v[3], v[2]);
v[3] = transferred[0];
v[2] = transferred[1];
v[3] = transferred.x;
v[2] = transferred.y;
transferred = BitTransferSigned(v[5], v[4]);
v[5] = transferred[0];
v[4] = transferred[1];
v[5] = transferred.x;
v[4] = transferred.y;
transferred = BitTransferSigned(v[7], v[6]);
v[7] = transferred[0];
v[6] = transferred[1];
v[7] = transferred.x;
v[6] = transferred.y;
if (v[1] + v[3] + v[5] >= 0) {
ep1 = ClampByte(ivec4(v[6], v[0], v[2], v[4]));
@@ -857,7 +864,8 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, inout uint color_values[32],
ep1 = ClampByte(BlueContract(v[6] + v[7], v[0] + v[1], v[2] + v[3], v[4] + v[5]));
ep2 = ClampByte(BlueContract(v[6], v[0], v[2], v[4]));
}
} break;
break;
}
}
#undef READ_UINT_VALUES
#undef READ_INT_VALUES
@@ -870,52 +878,61 @@ uint UnquantizeTexelWeight(EncodingData val) {
uint B = 0, C = 0, D = 0;
uint result = 0;
switch (val.encoding) {
case JustBits:
case JUST_BITS:
result = FastReplicateTo6(bitval, bitlen);
break;
case Trit: {
case TRIT: {
D = val.quint_trit_value;
switch (bitlen) {
case 0: {
uint results[3] = {0, 32, 63};
result = results[D];
} break;
break;
}
case 1: {
C = 50;
} break;
break;
}
case 2: {
C = 23;
uint b = (bitval >> 1) & 1;
B = (b << 6) | (b << 2) | b;
} break;
break;
}
case 3: {
C = 11;
uint cb = (bitval >> 1) & 3;
B = (cb << 5) | cb;
} break;
break;
}
default:
break;
}
} break;
case Quint: {
break;
}
case QUINT: {
D = val.quint_trit_value;
switch (bitlen) {
case 0: {
uint results[5] = {0, 16, 32, 47, 63};
result = results[D];
} break;
break;
}
case 1: {
C = 28;
} break;
break;
}
case 2: {
C = 13;
uint b = (bitval >> 1) & 1;
B = (b << 6) | (b << 1);
} break;
break;
}
} break;
}
break;
}
if (val.encoding != JustBits && bitlen > 0) {
}
if (val.encoding != JUST_BITS && bitlen > 0) {
result = D * C + B;
result ^= A;
result = (A & 0x20) | (result >> 2);
@@ -926,7 +943,7 @@ uint UnquantizeTexelWeight(EncodingData val) {
return result;
}
void UnquantizeTexelWeights(out uint outbuffer[2][144], bool dual_plane, uvec2 size) {
void UnquantizeTexelWeights(bool dual_plane, uvec2 size) {
uint weight_idx = 0;
uint unquantized[2][144];
uint area = size.x * size.y;
@@ -977,7 +994,7 @@ void UnquantizeTexelWeights(out uint outbuffer[2][144], bool dual_plane, uvec2 s
if ((v0 + size.x + 1) < (area)) {
p.w = unquantized[plane][(v0 + size.x + 1)];
}
outbuffer[plane][t * block_dims.x + s] = (uint(dot(p, w)) + 8) >> 4;
unquantized_texel_weights[plane][t * block_dims.x + s] = (uint(dot(p, w)) + 8) >> 4;
}
}
}
@@ -1015,25 +1032,25 @@ int FindLayout(uint mode) {
}
TexelWeightParams DecodeBlockInfo(uint block_index) {
TexelWeightParams params = TexelWeightParams(uvec2(0), false, 0, false, false, false);
TexelWeightParams params = TexelWeightParams(uvec2(0), 0, false, false, false, false);
uint mode = StreamBits(11);
if ((mode & 0x1ff) == 0x1fc) {
if ((mode & 0x200) != 0) {
params.VoidExtentHDR = true;
params.void_extent_hdr = true;
} else {
params.VoidExtentLDR = true;
params.void_extent_ldr = true;
}
if ((mode & 0x400) == 0 || StreamBits(1) == 0) {
params.Error = true;
params.error_state = true;
}
return params;
}
if ((mode & 0xf) == 0) {
params.Error = true;
params.error_state = true;
return params;
}
if ((mode & 3) == 0 && (mode & 0x1c0) == 0x1c0) {
params.Error = true;
params.error_state = true;
return params;
}
uint A, B;
@@ -1084,7 +1101,7 @@ TexelWeightParams DecodeBlockInfo(uint block_index) {
params.size = uvec2(A + 6, B + 6);
break;
default:
params.Error = true;
params.error_state = true;
break;
}
params.dual_plane = (mode_layout != 9) && ((mode & 0x400) != 0);
@@ -1117,7 +1134,6 @@ void FillVoidExtentLDR(ivec3 coord, uint block_index) {
for (int i = 0; i < 4; i++) {
StreamBits(13);
}
uint r_u = StreamBits(16);
uint g_u = StreamBits(16);
uint b_u = StreamBits(16);
@@ -1135,15 +1151,15 @@ void FillVoidExtentLDR(ivec3 coord, uint block_index) {
void DecompressBlock(ivec3 coord, uint block_index) {
TexelWeightParams params = DecodeBlockInfo(block_index);
if (params.Error) {
if (params.error_state) {
FillError(coord);
return;
}
if (params.VoidExtentHDR) {
if (params.void_extent_hdr) {
FillError(coord);
return;
}
if (params.VoidExtentLDR) {
if (params.void_extent_ldr) {
FillVoidExtentLDR(coord, block_index);
return;
}
@@ -1204,7 +1220,7 @@ void DecompressBlock(ivec3 coord, uint block_index) {
int nb = int(min(remaining_bits, 8U));
uint b = StreamBits(nb);
color_endpoint_data[ced_pointer] = uint(bitfieldExtract(b, 0, nb));
ced_pointer++;
++ced_pointer;
remaining_bits -= nb;
}
plane_index = int(StreamBits(plane_selector_bits));
@@ -1262,13 +1278,12 @@ void DecompressBlock(ivec3 coord, uint block_index) {
uint(
((1 << (GetPackedBitSize(params.size, params.dual_plane, params.max_weight) % 8)) - 1));
for (uint i = 0; i < 16 - clear_byte_start; i++) {
texel_weight_data[clear_byte_start + i] = uint(0U);
texel_weight_data[clear_byte_start + i] = 0U;
}
texel_flag = true; // use texel "vector" and bit stream in integer decoding
DecodeIntegerSequence(params.max_weight, GetNumWeightValues(params.size, params.dual_plane));
uint weights[2][144];
UnquantizeTexelWeights(weights, params.dual_plane, params.size);
UnquantizeTexelWeights(params.dual_plane, params.size);
for (uint j = 0; j < block_dims.y; j++) {
for (uint i = 0; i < block_dims.x; i++) {
@@ -1283,7 +1298,7 @@ void DecompressBlock(ivec3 coord, uint block_index) {
if (params.dual_plane && (((plane_index + 1) & 3) == c)) {
plane_vec[c] = 1;
}
weight_vec[c] = weights[plane_vec[c]][j * block_dims.x + i];
weight_vec[c] = unquantized_texel_weights[plane_vec[c]][j * block_dims.x + i];
}
vec4 Cf = vec4((C0 * (uvec4(64) - weight_vec) + C1 * weight_vec + uvec4(32)) >> 6);
p = (Cf / 65535.0);
@@ -1309,8 +1324,8 @@ void main() {
offset += swizzle;
const ivec3 coord = ivec3(gl_GlobalInvocationID * uvec3(block_dims, 1));
uint block_index = pos.z * num_image_blocks.x * num_image_blocks.y +
pos.y * num_image_blocks.x + pos.x;
uint block_index =
pos.z * num_image_blocks.x * num_image_blocks.y + pos.y * num_image_blocks.x + pos.x;
current_index = 0;
bitsread = 0;

8
src/video_core/host_shaders/opengl_copy_bgra.comp
View File

@@ -6,10 +6,10 @@
layout (local_size_x = 4, local_size_y = 4) in;
layout(binding = 0, rgba8) readonly uniform image2D bgr_input;
layout(binding = 1, rgba8) writeonly uniform image2D bgr_output;
layout(binding = 0, rgba8) readonly uniform image2DArray bgr_input;
layout(binding = 1, rgba8) writeonly uniform image2DArray bgr_output;
void main() {
vec4 color = imageLoad(bgr_input, ivec2(gl_GlobalInvocationID.xy));
imageStore(bgr_output, ivec2(gl_GlobalInvocationID.xy), color.bgra);
vec4 color = imageLoad(bgr_input, ivec3(gl_GlobalInvocationID));
imageStore(bgr_output, ivec3(gl_GlobalInvocationID), color.bgra);
}