mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-11-30 21:12:01 +00:00
1f554c1093
* Renaming part 1 * Renaming part 2 * Renaming part 3 * Renaming part 4 * Renaming part 5 * Renaming part 6 * Renaming part 7 * Renaming part 8 * Renaming part 9 * Renaming part 10 * General cleanup * Thought I got all of these * Apply #595 * Additional renaming * Tweaks from feedback * Rename files
1385 lines
48 KiB
C#
1385 lines
48 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
|
|
namespace Ryujinx.Graphics.Texture
|
|
{
|
|
public class AstcDecoderException : Exception
|
|
{
|
|
public AstcDecoderException(string exMsg) : base(exMsg) { }
|
|
}
|
|
|
|
//https://github.com/GammaUNC/FasTC/blob/master/ASTCEncoder/src/Decompressor.cpp
|
|
public static class AstcDecoder
|
|
{
|
|
struct TexelWeightParams
|
|
{
|
|
public int Width;
|
|
public int Height;
|
|
public bool DualPlane;
|
|
public int MaxWeight;
|
|
public bool Error;
|
|
public bool VoidExtentLdr;
|
|
public bool VoidExtentHdr;
|
|
|
|
public int GetPackedBitSize()
|
|
{
|
|
// How many indices do we have?
|
|
int indices = Height * Width;
|
|
|
|
if (DualPlane)
|
|
{
|
|
indices *= 2;
|
|
}
|
|
|
|
IntegerEncoded intEncoded = IntegerEncoded.CreateEncoding(MaxWeight);
|
|
|
|
return intEncoded.GetBitLength(indices);
|
|
}
|
|
|
|
public int GetNumWeightValues()
|
|
{
|
|
int ret = Width * Height;
|
|
|
|
if (DualPlane)
|
|
{
|
|
ret *= 2;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
public static byte[] DecodeToRgba8888(
|
|
byte[] inputBuffer,
|
|
int blockX,
|
|
int blockY,
|
|
int blockZ,
|
|
int x,
|
|
int y,
|
|
int z)
|
|
{
|
|
using (MemoryStream inputStream = new MemoryStream(inputBuffer))
|
|
{
|
|
BinaryReader binReader = new BinaryReader(inputStream);
|
|
|
|
if (blockX > 12 || blockY > 12)
|
|
{
|
|
throw new AstcDecoderException("Block size unsupported!");
|
|
}
|
|
|
|
if (blockZ != 1 || z != 1)
|
|
{
|
|
// TODO: Support 3D textures?
|
|
throw new AstcDecoderException("3D compressed textures unsupported!");
|
|
}
|
|
|
|
using (MemoryStream outputStream = new MemoryStream())
|
|
{
|
|
int blockIndex = 0;
|
|
|
|
for (int j = 0; j < y; j += blockY)
|
|
{
|
|
for (int i = 0; i < x; i += blockX)
|
|
{
|
|
int[] decompressedData = new int[144];
|
|
|
|
DecompressBlock(binReader.ReadBytes(0x10), decompressedData, blockX, blockY);
|
|
|
|
int decompressedWidth = Math.Min(blockX, x - i);
|
|
int decompressedHeight = Math.Min(blockY, y - j);
|
|
int baseOffsets = (j * x + i) * 4;
|
|
|
|
for (int jj = 0; jj < decompressedHeight; jj++)
|
|
{
|
|
outputStream.Seek(baseOffsets + jj * x * 4, SeekOrigin.Begin);
|
|
|
|
byte[] outputBuffer = new byte[decompressedData.Length * sizeof(int)];
|
|
Buffer.BlockCopy(decompressedData, 0, outputBuffer, 0, outputBuffer.Length);
|
|
|
|
outputStream.Write(outputBuffer, jj * blockX * 4, decompressedWidth * 4);
|
|
}
|
|
|
|
blockIndex++;
|
|
}
|
|
}
|
|
|
|
return outputStream.ToArray();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool DecompressBlock(
|
|
byte[] inputBuffer,
|
|
int[] outputBuffer,
|
|
int blockWidth,
|
|
int blockHeight)
|
|
{
|
|
BitArrayStream bitStream = new BitArrayStream(new BitArray(inputBuffer));
|
|
TexelWeightParams texelParams = DecodeBlockInfo(bitStream);
|
|
|
|
if (texelParams.Error)
|
|
{
|
|
throw new AstcDecoderException("Invalid block mode");
|
|
}
|
|
|
|
if (texelParams.VoidExtentLdr)
|
|
{
|
|
FillVoidExtentLdr(bitStream, outputBuffer, blockWidth, blockHeight);
|
|
|
|
return true;
|
|
}
|
|
|
|
if (texelParams.VoidExtentHdr)
|
|
{
|
|
throw new AstcDecoderException("HDR void extent blocks are unsupported!");
|
|
}
|
|
|
|
if (texelParams.Width > blockWidth)
|
|
{
|
|
throw new AstcDecoderException("Texel weight grid width should be smaller than block width");
|
|
}
|
|
|
|
if (texelParams.Height > blockHeight)
|
|
{
|
|
throw new AstcDecoderException("Texel weight grid height should be smaller than block height");
|
|
}
|
|
|
|
// Read num partitions
|
|
int numberPartitions = bitStream.ReadBits(2) + 1;
|
|
Debug.Assert(numberPartitions <= 4);
|
|
|
|
if (numberPartitions == 4 && texelParams.DualPlane)
|
|
{
|
|
throw new AstcDecoderException("Dual plane mode is incompatible with four partition blocks");
|
|
}
|
|
|
|
// Based on the number of partitions, read the color endpoint mode for
|
|
// each partition.
|
|
|
|
// Determine partitions, partition index, and color endpoint modes
|
|
int planeIndices = -1;
|
|
int partitionIndex;
|
|
uint[] colorEndpointMode = { 0, 0, 0, 0 };
|
|
|
|
BitArrayStream colorEndpointStream = new BitArrayStream(new BitArray(16 * 8));
|
|
|
|
// Read extra config data...
|
|
uint baseColorEndpointMode = 0;
|
|
|
|
if (numberPartitions == 1)
|
|
{
|
|
colorEndpointMode[0] = (uint)bitStream.ReadBits(4);
|
|
partitionIndex = 0;
|
|
}
|
|
else
|
|
{
|
|
partitionIndex = bitStream.ReadBits(10);
|
|
baseColorEndpointMode = (uint)bitStream.ReadBits(6);
|
|
}
|
|
|
|
uint baseMode = (baseColorEndpointMode & 3);
|
|
|
|
// Remaining bits are color endpoint data...
|
|
int numberWeightBits = texelParams.GetPackedBitSize();
|
|
int remainingBits = 128 - numberWeightBits - bitStream.Position;
|
|
|
|
// Consider extra bits prior to texel data...
|
|
uint extraColorEndpointModeBits = 0;
|
|
|
|
if (baseMode != 0)
|
|
{
|
|
switch (numberPartitions)
|
|
{
|
|
case 2: extraColorEndpointModeBits += 2; break;
|
|
case 3: extraColorEndpointModeBits += 5; break;
|
|
case 4: extraColorEndpointModeBits += 8; break;
|
|
default: Debug.Assert(false); break;
|
|
}
|
|
}
|
|
|
|
remainingBits -= (int)extraColorEndpointModeBits;
|
|
|
|
// Do we have a dual plane situation?
|
|
int planeSelectorBits = 0;
|
|
|
|
if (texelParams.DualPlane)
|
|
{
|
|
planeSelectorBits = 2;
|
|
}
|
|
|
|
remainingBits -= planeSelectorBits;
|
|
|
|
// Read color data...
|
|
int colorDataBits = remainingBits;
|
|
|
|
while (remainingBits > 0)
|
|
{
|
|
int numberBits = Math.Min(remainingBits, 8);
|
|
int bits = bitStream.ReadBits(numberBits);
|
|
colorEndpointStream.WriteBits(bits, numberBits);
|
|
remainingBits -= 8;
|
|
}
|
|
|
|
// Read the plane selection bits
|
|
planeIndices = bitStream.ReadBits(planeSelectorBits);
|
|
|
|
// Read the rest of the CEM
|
|
if (baseMode != 0)
|
|
{
|
|
uint extraColorEndpointMode = (uint)bitStream.ReadBits((int)extraColorEndpointModeBits);
|
|
uint tempColorEndpointMode = (extraColorEndpointMode << 6) | baseColorEndpointMode;
|
|
tempColorEndpointMode >>= 2;
|
|
|
|
bool[] c = new bool[4];
|
|
|
|
for (int i = 0; i < numberPartitions; i++)
|
|
{
|
|
c[i] = (tempColorEndpointMode & 1) != 0;
|
|
tempColorEndpointMode >>= 1;
|
|
}
|
|
|
|
byte[] m = new byte[4];
|
|
|
|
for (int i = 0; i < numberPartitions; i++)
|
|
{
|
|
m[i] = (byte)(tempColorEndpointMode & 3);
|
|
tempColorEndpointMode >>= 2;
|
|
Debug.Assert(m[i] <= 3);
|
|
}
|
|
|
|
for (int i = 0; i < numberPartitions; i++)
|
|
{
|
|
colorEndpointMode[i] = baseMode;
|
|
if (!(c[i])) colorEndpointMode[i] -= 1;
|
|
colorEndpointMode[i] <<= 2;
|
|
colorEndpointMode[i] |= m[i];
|
|
}
|
|
}
|
|
else if (numberPartitions > 1)
|
|
{
|
|
uint tempColorEndpointMode = baseColorEndpointMode >> 2;
|
|
|
|
for (uint i = 0; i < numberPartitions; i++)
|
|
{
|
|
colorEndpointMode[i] = tempColorEndpointMode;
|
|
}
|
|
}
|
|
|
|
// Make sure everything up till here is sane.
|
|
for (int i = 0; i < numberPartitions; i++)
|
|
{
|
|
Debug.Assert(colorEndpointMode[i] < 16);
|
|
}
|
|
Debug.Assert(bitStream.Position + texelParams.GetPackedBitSize() == 128);
|
|
|
|
// Decode both color data and texel weight data
|
|
int[] colorValues = new int[32]; // Four values * two endpoints * four maximum partitions
|
|
DecodeColorValues(colorValues, colorEndpointStream.ToByteArray(), colorEndpointMode, numberPartitions, colorDataBits);
|
|
|
|
AstcPixel[][] endPoints = new AstcPixel[4][];
|
|
endPoints[0] = new AstcPixel[2];
|
|
endPoints[1] = new AstcPixel[2];
|
|
endPoints[2] = new AstcPixel[2];
|
|
endPoints[3] = new AstcPixel[2];
|
|
|
|
int colorValuesPosition = 0;
|
|
|
|
for (int i = 0; i < numberPartitions; i++)
|
|
{
|
|
ComputeEndpoints(endPoints[i], colorValues, colorEndpointMode[i], ref colorValuesPosition);
|
|
}
|
|
|
|
// Read the texel weight data.
|
|
byte[] texelWeightData = (byte[])inputBuffer.Clone();
|
|
|
|
// Reverse everything
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
byte a = ReverseByte(texelWeightData[i]);
|
|
byte b = ReverseByte(texelWeightData[15 - i]);
|
|
|
|
texelWeightData[i] = b;
|
|
texelWeightData[15 - i] = a;
|
|
}
|
|
|
|
// Make sure that higher non-texel bits are set to zero
|
|
int clearByteStart = (texelParams.GetPackedBitSize() >> 3) + 1;
|
|
texelWeightData[clearByteStart - 1] &= (byte)((1 << (texelParams.GetPackedBitSize() % 8)) - 1);
|
|
|
|
int cLen = 16 - clearByteStart;
|
|
for (int i = clearByteStart; i < clearByteStart + cLen; i++) texelWeightData[i] = 0;
|
|
|
|
List<IntegerEncoded> texelWeightValues = new List<IntegerEncoded>();
|
|
BitArrayStream weightBitStream = new BitArrayStream(new BitArray(texelWeightData));
|
|
|
|
IntegerEncoded.DecodeIntegerSequence(texelWeightValues, weightBitStream, texelParams.MaxWeight, texelParams.GetNumWeightValues());
|
|
|
|
// Blocks can be at most 12x12, so we can have as many as 144 weights
|
|
int[][] weights = new int[2][];
|
|
weights[0] = new int[144];
|
|
weights[1] = new int[144];
|
|
|
|
UnquantizeTexelWeights(weights, texelWeightValues, texelParams, blockWidth, blockHeight);
|
|
|
|
// Now that we have endpoints and weights, we can interpolate and generate
|
|
// the proper decoding...
|
|
for (int j = 0; j < blockHeight; j++)
|
|
{
|
|
for (int i = 0; i < blockWidth; i++)
|
|
{
|
|
int partition = Select2dPartition(partitionIndex, i, j, numberPartitions, ((blockHeight * blockWidth) < 32));
|
|
Debug.Assert(partition < numberPartitions);
|
|
|
|
AstcPixel pixel = new AstcPixel(0, 0, 0, 0);
|
|
for (int component = 0; component < 4; component++)
|
|
{
|
|
int component0 = endPoints[partition][0].GetComponent(component);
|
|
component0 = BitArrayStream.Replicate(component0, 8, 16);
|
|
int component1 = endPoints[partition][1].GetComponent(component);
|
|
component1 = BitArrayStream.Replicate(component1, 8, 16);
|
|
|
|
int plane = 0;
|
|
|
|
if (texelParams.DualPlane && (((planeIndices + 1) & 3) == component))
|
|
{
|
|
plane = 1;
|
|
}
|
|
|
|
int weight = weights[plane][j * blockWidth + i];
|
|
int finalComponent = (component0 * (64 - weight) + component1 * weight + 32) / 64;
|
|
|
|
if (finalComponent == 65535)
|
|
{
|
|
pixel.SetComponent(component, 255);
|
|
}
|
|
else
|
|
{
|
|
double finalComponentFloat = finalComponent;
|
|
pixel.SetComponent(component, (int)(255.0 * (finalComponentFloat / 65536.0) + 0.5));
|
|
}
|
|
}
|
|
|
|
outputBuffer[j * blockWidth + i] = pixel.Pack();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static int Select2dPartition(int seed, int x, int y, int partitionCount, bool isSmallBlock)
|
|
{
|
|
return SelectPartition(seed, x, y, 0, partitionCount, isSmallBlock);
|
|
}
|
|
|
|
private static int SelectPartition(int seed, int x, int y, int z, int partitionCount, bool isSmallBlock)
|
|
{
|
|
if (partitionCount == 1)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (isSmallBlock)
|
|
{
|
|
x <<= 1;
|
|
y <<= 1;
|
|
z <<= 1;
|
|
}
|
|
|
|
seed += (partitionCount - 1) * 1024;
|
|
|
|
int rightNum = Hash52((uint)seed);
|
|
byte seed01 = (byte)(rightNum & 0xF);
|
|
byte seed02 = (byte)((rightNum >> 4) & 0xF);
|
|
byte seed03 = (byte)((rightNum >> 8) & 0xF);
|
|
byte seed04 = (byte)((rightNum >> 12) & 0xF);
|
|
byte seed05 = (byte)((rightNum >> 16) & 0xF);
|
|
byte seed06 = (byte)((rightNum >> 20) & 0xF);
|
|
byte seed07 = (byte)((rightNum >> 24) & 0xF);
|
|
byte seed08 = (byte)((rightNum >> 28) & 0xF);
|
|
byte seed09 = (byte)((rightNum >> 18) & 0xF);
|
|
byte seed10 = (byte)((rightNum >> 22) & 0xF);
|
|
byte seed11 = (byte)((rightNum >> 26) & 0xF);
|
|
byte seed12 = (byte)(((rightNum >> 30) | (rightNum << 2)) & 0xF);
|
|
|
|
seed01 *= seed01; seed02 *= seed02;
|
|
seed03 *= seed03; seed04 *= seed04;
|
|
seed05 *= seed05; seed06 *= seed06;
|
|
seed07 *= seed07; seed08 *= seed08;
|
|
seed09 *= seed09; seed10 *= seed10;
|
|
seed11 *= seed11; seed12 *= seed12;
|
|
|
|
int seedHash1, seedHash2, seedHash3;
|
|
|
|
if ((seed & 1) != 0)
|
|
{
|
|
seedHash1 = (seed & 2) != 0 ? 4 : 5;
|
|
seedHash2 = (partitionCount == 3) ? 6 : 5;
|
|
}
|
|
else
|
|
{
|
|
seedHash1 = (partitionCount == 3) ? 6 : 5;
|
|
seedHash2 = (seed & 2) != 0 ? 4 : 5;
|
|
}
|
|
|
|
seedHash3 = (seed & 0x10) != 0 ? seedHash1 : seedHash2;
|
|
|
|
seed01 >>= seedHash1; seed02 >>= seedHash2; seed03 >>= seedHash1; seed04 >>= seedHash2;
|
|
seed05 >>= seedHash1; seed06 >>= seedHash2; seed07 >>= seedHash1; seed08 >>= seedHash2;
|
|
seed09 >>= seedHash3; seed10 >>= seedHash3; seed11 >>= seedHash3; seed12 >>= seedHash3;
|
|
|
|
int a = seed01 * x + seed02 * y + seed11 * z + (rightNum >> 14);
|
|
int b = seed03 * x + seed04 * y + seed12 * z + (rightNum >> 10);
|
|
int c = seed05 * x + seed06 * y + seed09 * z + (rightNum >> 6);
|
|
int d = seed07 * x + seed08 * y + seed10 * z + (rightNum >> 2);
|
|
|
|
a &= 0x3F; b &= 0x3F; c &= 0x3F; d &= 0x3F;
|
|
|
|
if (partitionCount < 4) d = 0;
|
|
if (partitionCount < 3) c = 0;
|
|
|
|
if (a >= b && a >= c && a >= d) return 0;
|
|
else if (b >= c && b >= d) return 1;
|
|
else if (c >= d) return 2;
|
|
return 3;
|
|
}
|
|
|
|
static int Hash52(uint val)
|
|
{
|
|
val ^= val >> 15; val -= val << 17; val += val << 7; val += val << 4;
|
|
val ^= val >> 5; val += val << 16; val ^= val >> 7; val ^= val >> 3;
|
|
val ^= val << 6; val ^= val >> 17;
|
|
|
|
return (int)val;
|
|
}
|
|
|
|
static void UnquantizeTexelWeights(
|
|
int[][] outputBuffer,
|
|
List<IntegerEncoded> weights,
|
|
TexelWeightParams texelParams,
|
|
int blockWidth,
|
|
int blockHeight)
|
|
{
|
|
int weightIndices = 0;
|
|
int[][] unquantized = new int[2][];
|
|
unquantized[0] = new int[144];
|
|
unquantized[1] = new int[144];
|
|
|
|
for (int i = 0; i < weights.Count; i++)
|
|
{
|
|
unquantized[0][weightIndices] = UnquantizeTexelWeight(weights[i]);
|
|
|
|
if (texelParams.DualPlane)
|
|
{
|
|
i++;
|
|
unquantized[1][weightIndices] = UnquantizeTexelWeight(weights[i]);
|
|
|
|
if (i == weights.Count)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (++weightIndices >= (texelParams.Width * texelParams.Height)) break;
|
|
}
|
|
|
|
// Do infill if necessary (Section C.2.18) ...
|
|
int ds = (1024 + (blockWidth / 2)) / (blockWidth - 1);
|
|
int dt = (1024 + (blockHeight / 2)) / (blockHeight - 1);
|
|
|
|
int planeScale = texelParams.DualPlane ? 2 : 1;
|
|
|
|
for (int plane = 0; plane < planeScale; plane++)
|
|
{
|
|
for (int t = 0; t < blockHeight; t++)
|
|
{
|
|
for (int s = 0; s < blockWidth; s++)
|
|
{
|
|
int cs = ds * s;
|
|
int ct = dt * t;
|
|
|
|
int gs = (cs * (texelParams.Width - 1) + 32) >> 6;
|
|
int gt = (ct * (texelParams.Height - 1) + 32) >> 6;
|
|
|
|
int js = gs >> 4;
|
|
int fs = gs & 0xF;
|
|
|
|
int jt = gt >> 4;
|
|
int ft = gt & 0x0F;
|
|
|
|
int w11 = (fs * ft + 8) >> 4;
|
|
int w10 = ft - w11;
|
|
int w01 = fs - w11;
|
|
int w00 = 16 - fs - ft + w11;
|
|
|
|
int v0 = js + jt * texelParams.Width;
|
|
|
|
int p00 = 0;
|
|
int p01 = 0;
|
|
int p10 = 0;
|
|
int p11 = 0;
|
|
|
|
if (v0 < (texelParams.Width * texelParams.Height))
|
|
{
|
|
p00 = unquantized[plane][v0];
|
|
}
|
|
|
|
if (v0 + 1 < (texelParams.Width * texelParams.Height))
|
|
{
|
|
p01 = unquantized[plane][v0 + 1];
|
|
}
|
|
|
|
if (v0 + texelParams.Width < (texelParams.Width * texelParams.Height))
|
|
{
|
|
p10 = unquantized[plane][v0 + texelParams.Width];
|
|
}
|
|
|
|
if (v0 + texelParams.Width + 1 < (texelParams.Width * texelParams.Height))
|
|
{
|
|
p11 = unquantized[plane][v0 + texelParams.Width + 1];
|
|
}
|
|
|
|
outputBuffer[plane][t * blockWidth + s] = (p00 * w00 + p01 * w01 + p10 * w10 + p11 * w11 + 8) >> 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int UnquantizeTexelWeight(IntegerEncoded intEncoded)
|
|
{
|
|
int bitValue = intEncoded.BitValue;
|
|
int bitLength = intEncoded.NumberBits;
|
|
|
|
int a = BitArrayStream.Replicate(bitValue & 1, 1, 7);
|
|
int b = 0, c = 0, d = 0;
|
|
|
|
int result = 0;
|
|
|
|
switch (intEncoded.GetEncoding())
|
|
{
|
|
case IntegerEncoded.EIntegerEncoding.JustBits:
|
|
result = BitArrayStream.Replicate(bitValue, bitLength, 6);
|
|
break;
|
|
|
|
case IntegerEncoded.EIntegerEncoding.Trit:
|
|
{
|
|
d = intEncoded.TritValue;
|
|
Debug.Assert(d < 3);
|
|
|
|
switch (bitLength)
|
|
{
|
|
case 0:
|
|
{
|
|
int[] results = { 0, 32, 63 };
|
|
result = results[d];
|
|
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
c = 50;
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
c = 23;
|
|
int b2 = (bitValue >> 1) & 1;
|
|
b = (b2 << 6) | (b2 << 2) | b2;
|
|
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
c = 11;
|
|
int cb = (bitValue >> 1) & 3;
|
|
b = (cb << 5) | cb;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw new AstcDecoderException("Invalid trit encoding for texel weight");
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case IntegerEncoded.EIntegerEncoding.Quint:
|
|
{
|
|
d = intEncoded.QuintValue;
|
|
Debug.Assert(d < 5);
|
|
|
|
switch (bitLength)
|
|
{
|
|
case 0:
|
|
{
|
|
int[] results = { 0, 16, 32, 47, 63 };
|
|
result = results[d];
|
|
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
c = 28;
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
c = 13;
|
|
int b2 = (bitValue >> 1) & 1;
|
|
b = (b2 << 6) | (b2 << 1);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw new AstcDecoderException("Invalid quint encoding for texel weight");
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (intEncoded.GetEncoding() != IntegerEncoded.EIntegerEncoding.JustBits && bitLength > 0)
|
|
{
|
|
// Decode the value...
|
|
result = d * c + b;
|
|
result ^= a;
|
|
result = (a & 0x20) | (result >> 2);
|
|
}
|
|
|
|
Debug.Assert(result < 64);
|
|
|
|
// Change from [0,63] to [0,64]
|
|
if (result > 32)
|
|
{
|
|
result += 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static byte ReverseByte(byte b)
|
|
{
|
|
// Taken from http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith64Bits
|
|
return (byte)((((b) * 0x80200802L) & 0x0884422110L) * 0x0101010101L >> 32);
|
|
}
|
|
|
|
static uint[] ReadUintColorValues(int number, int[] colorValues, ref int colorValuesPosition)
|
|
{
|
|
uint[] ret = new uint[number];
|
|
|
|
for (int i = 0; i < number; i++)
|
|
{
|
|
ret[i] = (uint)colorValues[colorValuesPosition++];
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int[] ReadIntColorValues(int number, int[] colorValues, ref int colorValuesPosition)
|
|
{
|
|
int[] ret = new int[number];
|
|
|
|
for (int i = 0; i < number; i++)
|
|
{
|
|
ret[i] = colorValues[colorValuesPosition++];
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void ComputeEndpoints(
|
|
AstcPixel[] endPoints,
|
|
int[] colorValues,
|
|
uint colorEndpointMode,
|
|
ref int colorValuesPosition)
|
|
{
|
|
switch (colorEndpointMode)
|
|
{
|
|
case 0:
|
|
{
|
|
uint[] val = ReadUintColorValues(2, colorValues, ref colorValuesPosition);
|
|
|
|
endPoints[0] = new AstcPixel(0xFF, (short)val[0], (short)val[0], (short)val[0]);
|
|
endPoints[1] = new AstcPixel(0xFF, (short)val[1], (short)val[1], (short)val[1]);
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
case 1:
|
|
{
|
|
uint[] val = ReadUintColorValues(2, colorValues, ref colorValuesPosition);
|
|
int l0 = (int)((val[0] >> 2) | (val[1] & 0xC0));
|
|
int l1 = (int)Math.Max(l0 + (val[1] & 0x3F), 0xFFU);
|
|
|
|
endPoints[0] = new AstcPixel(0xFF, (short)l0, (short)l0, (short)l0);
|
|
endPoints[1] = new AstcPixel(0xFF, (short)l1, (short)l1, (short)l1);
|
|
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
uint[] val = ReadUintColorValues(4, colorValues, ref colorValuesPosition);
|
|
|
|
endPoints[0] = new AstcPixel((short)val[2], (short)val[0], (short)val[0], (short)val[0]);
|
|
endPoints[1] = new AstcPixel((short)val[3], (short)val[1], (short)val[1], (short)val[1]);
|
|
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
int[] val = ReadIntColorValues(4, colorValues, ref colorValuesPosition);
|
|
|
|
BitArrayStream.BitTransferSigned(ref val[1], ref val[0]);
|
|
BitArrayStream.BitTransferSigned(ref val[3], ref val[2]);
|
|
|
|
endPoints[0] = new AstcPixel((short)val[2], (short)val[0], (short)val[0], (short)val[0]);
|
|
endPoints[1] = new AstcPixel((short)(val[2] + val[3]), (short)(val[0] + val[1]), (short)(val[0] + val[1]), (short)(val[0] + val[1]));
|
|
|
|
endPoints[0].ClampByte();
|
|
endPoints[1].ClampByte();
|
|
|
|
break;
|
|
}
|
|
|
|
case 6:
|
|
{
|
|
uint[] val = ReadUintColorValues(4, colorValues, ref colorValuesPosition);
|
|
|
|
endPoints[0] = new AstcPixel(0xFF, (short)(val[0] * val[3] >> 8), (short)(val[1] * val[3] >> 8), (short)(val[2] * val[3] >> 8));
|
|
endPoints[1] = new AstcPixel(0xFF, (short)val[0], (short)val[1], (short)val[2]);
|
|
|
|
break;
|
|
}
|
|
|
|
case 8:
|
|
{
|
|
uint[] val = ReadUintColorValues(6, colorValues, ref colorValuesPosition);
|
|
|
|
if (val[1] + val[3] + val[5] >= val[0] + val[2] + val[4])
|
|
{
|
|
endPoints[0] = new AstcPixel(0xFF, (short)val[0], (short)val[2], (short)val[4]);
|
|
endPoints[1] = new AstcPixel(0xFF, (short)val[1], (short)val[3], (short)val[5]);
|
|
}
|
|
else
|
|
{
|
|
endPoints[0] = AstcPixel.BlueContract(0xFF, (short)val[1], (short)val[3], (short)val[5]);
|
|
endPoints[1] = AstcPixel.BlueContract(0xFF, (short)val[0], (short)val[2], (short)val[4]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 9:
|
|
{
|
|
int[] val = ReadIntColorValues(6, colorValues, ref colorValuesPosition);
|
|
|
|
BitArrayStream.BitTransferSigned(ref val[1], ref val[0]);
|
|
BitArrayStream.BitTransferSigned(ref val[3], ref val[2]);
|
|
BitArrayStream.BitTransferSigned(ref val[5], ref val[4]);
|
|
|
|
if (val[1] + val[3] + val[5] >= 0)
|
|
{
|
|
endPoints[0] = new AstcPixel(0xFF, (short)val[0], (short)val[2], (short)val[4]);
|
|
endPoints[1] = new AstcPixel(0xFF, (short)(val[0] + val[1]), (short)(val[2] + val[3]), (short)(val[4] + val[5]));
|
|
}
|
|
else
|
|
{
|
|
endPoints[0] = AstcPixel.BlueContract(0xFF, val[0] + val[1], val[2] + val[3], val[4] + val[5]);
|
|
endPoints[1] = AstcPixel.BlueContract(0xFF, val[0], val[2], val[4]);
|
|
}
|
|
|
|
endPoints[0].ClampByte();
|
|
endPoints[1].ClampByte();
|
|
|
|
break;
|
|
}
|
|
|
|
case 10:
|
|
{
|
|
uint[] val = ReadUintColorValues(6, colorValues, ref colorValuesPosition);
|
|
|
|
endPoints[0] = new AstcPixel((short)val[4], (short)(val[0] * val[3] >> 8), (short)(val[1] * val[3] >> 8), (short)(val[2] * val[3] >> 8));
|
|
endPoints[1] = new AstcPixel((short)val[5], (short)val[0], (short)val[1], (short)val[2]);
|
|
|
|
break;
|
|
}
|
|
|
|
case 12:
|
|
{
|
|
uint[] val = ReadUintColorValues(8, colorValues, ref colorValuesPosition);
|
|
|
|
if (val[1] + val[3] + val[5] >= val[0] + val[2] + val[4])
|
|
{
|
|
endPoints[0] = new AstcPixel((short)val[6], (short)val[0], (short)val[2], (short)val[4]);
|
|
endPoints[1] = new AstcPixel((short)val[7], (short)val[1], (short)val[3], (short)val[5]);
|
|
}
|
|
else
|
|
{
|
|
endPoints[0] = AstcPixel.BlueContract((short)val[7], (short)val[1], (short)val[3], (short)val[5]);
|
|
endPoints[1] = AstcPixel.BlueContract((short)val[6], (short)val[0], (short)val[2], (short)val[4]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 13:
|
|
{
|
|
int[] val = ReadIntColorValues(8, colorValues, ref colorValuesPosition);
|
|
|
|
BitArrayStream.BitTransferSigned(ref val[1], ref val[0]);
|
|
BitArrayStream.BitTransferSigned(ref val[3], ref val[2]);
|
|
BitArrayStream.BitTransferSigned(ref val[5], ref val[4]);
|
|
BitArrayStream.BitTransferSigned(ref val[7], ref val[6]);
|
|
|
|
if (val[1] + val[3] + val[5] >= 0)
|
|
{
|
|
endPoints[0] = new AstcPixel((short)val[6], (short)val[0], (short)val[2], (short)val[4]);
|
|
endPoints[1] = new AstcPixel((short)(val[7] + val[6]), (short)(val[0] + val[1]), (short)(val[2] + val[3]), (short)(val[4] + val[5]));
|
|
}
|
|
else
|
|
{
|
|
endPoints[0] = AstcPixel.BlueContract(val[6] + val[7], val[0] + val[1], val[2] + val[3], val[4] + val[5]);
|
|
endPoints[1] = AstcPixel.BlueContract(val[6], val[0], val[2], val[4]);
|
|
}
|
|
|
|
endPoints[0].ClampByte();
|
|
endPoints[1].ClampByte();
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw new AstcDecoderException("Unsupported color endpoint mode (is it HDR?)");
|
|
}
|
|
}
|
|
|
|
static void DecodeColorValues(
|
|
int[] outputValues,
|
|
byte[] inputData,
|
|
uint[] modes,
|
|
int numberPartitions,
|
|
int numberBitsForColorData)
|
|
{
|
|
// First figure out how many color values we have
|
|
int numberValues = 0;
|
|
|
|
for (int i = 0; i < numberPartitions; i++)
|
|
{
|
|
numberValues += (int)((modes[i] >> 2) + 1) << 1;
|
|
}
|
|
|
|
// Then based on the number of values and the remaining number of bits,
|
|
// figure out the max value for each of them...
|
|
int range = 256;
|
|
|
|
while (--range > 0)
|
|
{
|
|
IntegerEncoded intEncoded = IntegerEncoded.CreateEncoding(range);
|
|
int bitLength = intEncoded.GetBitLength(numberValues);
|
|
|
|
if (bitLength <= numberBitsForColorData)
|
|
{
|
|
// Find the smallest possible range that matches the given encoding
|
|
while (--range > 0)
|
|
{
|
|
IntegerEncoded newIntEncoded = IntegerEncoded.CreateEncoding(range);
|
|
if (!newIntEncoded.MatchesEncoding(intEncoded))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Return to last matching range.
|
|
range++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// We now have enough to decode our integer sequence.
|
|
List<IntegerEncoded> integerEncodedSequence = new List<IntegerEncoded>();
|
|
BitArrayStream colorBitStream = new BitArrayStream(new BitArray(inputData));
|
|
|
|
IntegerEncoded.DecodeIntegerSequence(integerEncodedSequence, colorBitStream, range, numberValues);
|
|
|
|
// Once we have the decoded values, we need to dequantize them to the 0-255 range
|
|
// This procedure is outlined in ASTC spec C.2.13
|
|
int outputIndices = 0;
|
|
|
|
foreach (IntegerEncoded intEncoded in integerEncodedSequence)
|
|
{
|
|
int bitLength = intEncoded.NumberBits;
|
|
int bitValue = intEncoded.BitValue;
|
|
|
|
Debug.Assert(bitLength >= 1);
|
|
|
|
int a = 0, b = 0, c = 0, d = 0;
|
|
// A is just the lsb replicated 9 times.
|
|
a = BitArrayStream.Replicate(bitValue & 1, 1, 9);
|
|
|
|
switch (intEncoded.GetEncoding())
|
|
{
|
|
case IntegerEncoded.EIntegerEncoding.JustBits:
|
|
{
|
|
outputValues[outputIndices++] = BitArrayStream.Replicate(bitValue, bitLength, 8);
|
|
|
|
break;
|
|
}
|
|
|
|
case IntegerEncoded.EIntegerEncoding.Trit:
|
|
{
|
|
d = intEncoded.TritValue;
|
|
|
|
switch (bitLength)
|
|
{
|
|
case 1:
|
|
{
|
|
c = 204;
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
c = 93;
|
|
// B = b000b0bb0
|
|
int b2 = (bitValue >> 1) & 1;
|
|
b = (b2 << 8) | (b2 << 4) | (b2 << 2) | (b2 << 1);
|
|
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
c = 44;
|
|
// B = cb000cbcb
|
|
int cb = (bitValue >> 1) & 3;
|
|
b = (cb << 7) | (cb << 2) | cb;
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
case 4:
|
|
{
|
|
c = 22;
|
|
// B = dcb000dcb
|
|
int dcb = (bitValue >> 1) & 7;
|
|
b = (dcb << 6) | dcb;
|
|
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
c = 11;
|
|
// B = edcb000ed
|
|
int edcb = (bitValue >> 1) & 0xF;
|
|
b = (edcb << 5) | (edcb >> 2);
|
|
|
|
break;
|
|
}
|
|
|
|
case 6:
|
|
{
|
|
c = 5;
|
|
// B = fedcb000f
|
|
int fedcb = (bitValue >> 1) & 0x1F;
|
|
b = (fedcb << 4) | (fedcb >> 4);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw new AstcDecoderException("Unsupported trit encoding for color values!");
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case IntegerEncoded.EIntegerEncoding.Quint:
|
|
{
|
|
d = intEncoded.QuintValue;
|
|
|
|
switch (bitLength)
|
|
{
|
|
case 1:
|
|
{
|
|
c = 113;
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
c = 54;
|
|
// B = b0000bb00
|
|
int b2 = (bitValue >> 1) & 1;
|
|
b = (b2 << 8) | (b2 << 3) | (b2 << 2);
|
|
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
c = 26;
|
|
// B = cb0000cbc
|
|
int cb = (bitValue >> 1) & 3;
|
|
b = (cb << 7) | (cb << 1) | (cb >> 1);
|
|
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
c = 13;
|
|
// B = dcb0000dc
|
|
int dcb = (bitValue >> 1) & 7;
|
|
b = (dcb << 6) | (dcb >> 1);
|
|
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
c = 6;
|
|
// B = edcb0000e
|
|
int edcb = (bitValue >> 1) & 0xF;
|
|
b = (edcb << 5) | (edcb >> 3);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw new AstcDecoderException("Unsupported quint encoding for color values!");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (intEncoded.GetEncoding() != IntegerEncoded.EIntegerEncoding.JustBits)
|
|
{
|
|
int T = d * c + b;
|
|
T ^= a;
|
|
T = (a & 0x80) | (T >> 2);
|
|
|
|
outputValues[outputIndices++] = T;
|
|
}
|
|
}
|
|
|
|
// Make sure that each of our values is in the proper range...
|
|
for (int i = 0; i < numberValues; i++)
|
|
{
|
|
Debug.Assert(outputValues[i] <= 255);
|
|
}
|
|
}
|
|
|
|
static void FillVoidExtentLdr(BitArrayStream bitStream, int[] outputBuffer, int blockWidth, int blockHeight)
|
|
{
|
|
// Don't actually care about the void extent, just read the bits...
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
bitStream.ReadBits(13);
|
|
}
|
|
|
|
// Decode the RGBA components and renormalize them to the range [0, 255]
|
|
ushort r = (ushort)bitStream.ReadBits(16);
|
|
ushort g = (ushort)bitStream.ReadBits(16);
|
|
ushort b = (ushort)bitStream.ReadBits(16);
|
|
ushort a = (ushort)bitStream.ReadBits(16);
|
|
|
|
int rgba = (r >> 8) | (g & 0xFF00) | ((b) & 0xFF00) << 8 | ((a) & 0xFF00) << 16;
|
|
|
|
for (int j = 0; j < blockHeight; j++)
|
|
{
|
|
for (int i = 0; i < blockWidth; i++)
|
|
{
|
|
outputBuffer[j * blockWidth + i] = rgba;
|
|
}
|
|
}
|
|
}
|
|
|
|
static TexelWeightParams DecodeBlockInfo(BitArrayStream bitStream)
|
|
{
|
|
TexelWeightParams texelParams = new TexelWeightParams();
|
|
|
|
// Read the entire block mode all at once
|
|
ushort modeBits = (ushort)bitStream.ReadBits(11);
|
|
|
|
// Does this match the void extent block mode?
|
|
if ((modeBits & 0x01FF) == 0x1FC)
|
|
{
|
|
if ((modeBits & 0x200) != 0)
|
|
{
|
|
texelParams.VoidExtentHdr = true;
|
|
}
|
|
else
|
|
{
|
|
texelParams.VoidExtentLdr = true;
|
|
}
|
|
|
|
// Next two bits must be one.
|
|
if ((modeBits & 0x400) == 0 || bitStream.ReadBits(1) == 0)
|
|
{
|
|
texelParams.Error = true;
|
|
}
|
|
|
|
return texelParams;
|
|
}
|
|
|
|
// First check if the last four bits are zero
|
|
if ((modeBits & 0xF) == 0)
|
|
{
|
|
texelParams.Error = true;
|
|
return texelParams;
|
|
}
|
|
|
|
// If the last two bits are zero, then if bits
|
|
// [6-8] are all ones, this is also reserved.
|
|
if ((modeBits & 0x3) == 0 && (modeBits & 0x1C0) == 0x1C0)
|
|
{
|
|
texelParams.Error = true;
|
|
|
|
return texelParams;
|
|
}
|
|
|
|
// Otherwise, there is no error... Figure out the layout
|
|
// of the block mode. Layout is determined by a number
|
|
// between 0 and 9 corresponding to table C.2.8 of the
|
|
// ASTC spec.
|
|
int layout = 0;
|
|
|
|
if ((modeBits & 0x1) != 0 || (modeBits & 0x2) != 0)
|
|
{
|
|
// layout is in [0-4]
|
|
if ((modeBits & 0x8) != 0)
|
|
{
|
|
// layout is in [2-4]
|
|
if ((modeBits & 0x4) != 0)
|
|
{
|
|
// layout is in [3-4]
|
|
if ((modeBits & 0x100) != 0)
|
|
{
|
|
layout = 4;
|
|
}
|
|
else
|
|
{
|
|
layout = 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
layout = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// layout is in [0-1]
|
|
if ((modeBits & 0x4) != 0)
|
|
{
|
|
layout = 1;
|
|
}
|
|
else
|
|
{
|
|
layout = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// layout is in [5-9]
|
|
if ((modeBits & 0x100) != 0)
|
|
{
|
|
// layout is in [7-9]
|
|
if ((modeBits & 0x80) != 0)
|
|
{
|
|
// layout is in [7-8]
|
|
Debug.Assert((modeBits & 0x40) == 0);
|
|
|
|
if ((modeBits & 0x20) != 0)
|
|
{
|
|
layout = 8;
|
|
}
|
|
else
|
|
{
|
|
layout = 7;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
layout = 9;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// layout is in [5-6]
|
|
if ((modeBits & 0x80) != 0)
|
|
{
|
|
layout = 6;
|
|
}
|
|
else
|
|
{
|
|
layout = 5;
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Assert(layout < 10);
|
|
|
|
// Determine R
|
|
int r = (modeBits >> 4) & 1;
|
|
if (layout < 5)
|
|
{
|
|
r |= (modeBits & 0x3) << 1;
|
|
}
|
|
else
|
|
{
|
|
r |= (modeBits & 0xC) >> 1;
|
|
}
|
|
|
|
Debug.Assert(2 <= r && r <= 7);
|
|
|
|
// Determine width & height
|
|
switch (layout)
|
|
{
|
|
case 0:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
int b = (modeBits >> 7) & 0x3;
|
|
|
|
texelParams.Width = b + 4;
|
|
texelParams.Height = a + 2;
|
|
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
int b = (modeBits >> 7) & 0x3;
|
|
|
|
texelParams.Width = b + 8;
|
|
texelParams.Height = a + 2;
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
int b = (modeBits >> 7) & 0x3;
|
|
|
|
texelParams.Width = a + 2;
|
|
texelParams.Height = b + 8;
|
|
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
int b = (modeBits >> 7) & 0x1;
|
|
|
|
texelParams.Width = a + 2;
|
|
texelParams.Height = b + 6;
|
|
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
int b = (modeBits >> 7) & 0x1;
|
|
|
|
texelParams.Width = b + 2;
|
|
texelParams.Height = a + 2;
|
|
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
|
|
texelParams.Width = 12;
|
|
texelParams.Height = a + 2;
|
|
|
|
break;
|
|
}
|
|
|
|
case 6:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
|
|
texelParams.Width = a + 2;
|
|
texelParams.Height = 12;
|
|
|
|
break;
|
|
}
|
|
|
|
case 7:
|
|
{
|
|
texelParams.Width = 6;
|
|
texelParams.Height = 10;
|
|
|
|
break;
|
|
}
|
|
|
|
case 8:
|
|
{
|
|
texelParams.Width = 10;
|
|
texelParams.Height = 6;
|
|
break;
|
|
}
|
|
|
|
case 9:
|
|
{
|
|
int a = (modeBits >> 5) & 0x3;
|
|
int b = (modeBits >> 9) & 0x3;
|
|
|
|
texelParams.Width = a + 6;
|
|
texelParams.Height = b + 6;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
//Don't know this layout...
|
|
texelParams.Error = true;
|
|
break;
|
|
}
|
|
|
|
// Determine whether or not we're using dual planes
|
|
// and/or high precision layouts.
|
|
bool d = ((layout != 9) && ((modeBits & 0x400) != 0));
|
|
bool h = (layout != 9) && ((modeBits & 0x200) != 0);
|
|
|
|
if (h)
|
|
{
|
|
int[] maxWeights = { 9, 11, 15, 19, 23, 31 };
|
|
texelParams.MaxWeight = maxWeights[r - 2];
|
|
}
|
|
else
|
|
{
|
|
int[] maxWeights = { 1, 2, 3, 4, 5, 7 };
|
|
texelParams.MaxWeight = maxWeights[r - 2];
|
|
}
|
|
|
|
texelParams.DualPlane = d;
|
|
|
|
return texelParams;
|
|
}
|
|
}
|
|
}
|