rafi99-bat/Ryujinx
1
0
Fork 0
forked from Mirror/Ryujinx
Code Pull requests Activity

ASTC optimizations (#845)

Browse source 
* ASTC optimizations

* Move code to Ryujinx.Common

* Support 3D textures

* Address feedback

* Remove ASTC logging

* Use stackalloc instead of a Buffer20 struct

* Code style and cleanup

* Respond to feedback

* Rearrange public/private property ordering
This commit is contained in:
Alex Barney 2019-12-26 23:09:49 -07:00 committed by Thog
parent 947e14d3be
commit d1ab9fb42c
12 changed files with 1009 additions and 599 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
Ryujinx.Common/Utilities/Buffers.cs Normal file
View file

@ -0,0 +1,59 @@
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Ryujinx.Common.Utilities
{
[DebuggerDisplay("{ToString()}")]
[StructLayout(LayoutKind.Sequential, Size = 16)]
public struct Buffer16
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)] private ulong _dummy0;
[DebuggerBrowsable(DebuggerBrowsableState.Never)] private ulong _dummy1;
public byte this[int i]
{
get => Bytes[i];
set => Bytes[i] = value;
}
public Span<byte> Bytes => SpanHelpers.AsByteSpan(ref this);
// Prevent a defensive copy by changing the read-only in reference to a reference with Unsafe.AsRef()
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Span<byte>(in Buffer16 value)
{
return SpanHelpers.AsByteSpan(ref Unsafe.AsRef(in value));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ReadOnlySpan<byte>(in Buffer16 value)
{
return SpanHelpers.AsReadOnlyByteSpan(ref Unsafe.AsRef(in value));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ref T As<T>() where T : unmanaged
{
if (Unsafe.SizeOf<T>() > (uint)Unsafe.SizeOf<Buffer16>())
{
throw new ArgumentException();
}
return ref MemoryMarshal.GetReference(AsSpan<T>());
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Span<T> AsSpan<T>() where T : unmanaged
{
return SpanHelpers.AsSpan<Buffer16, T>(ref this);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public readonly ReadOnlySpan<T> AsReadOnlySpan<T>() where T : unmanaged
{
return SpanHelpers.AsReadOnlySpan<Buffer16, T>(ref Unsafe.AsRef(in this));
}
}
}

61
Ryujinx.Common/Utilities/SpanHelpers.cs Normal file
View file

@ -0,0 +1,61 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Ryujinx.Common.Utilities
{
public static class SpanHelpers
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> CreateSpan<T>(ref T reference, int length)
{
return MemoryMarshal.CreateSpan(ref reference, length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> AsSpan<T>(ref T reference) where T : unmanaged
{
return CreateSpan(ref reference, 1);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<TSpan> AsSpan<TStruct, TSpan>(ref TStruct reference)
where TStruct : unmanaged where TSpan : unmanaged
{
return CreateSpan(ref Unsafe.As<TStruct, TSpan>(ref reference),
Unsafe.SizeOf<TStruct>() / Unsafe.SizeOf<TSpan>());
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<byte> AsByteSpan<T>(ref T reference) where T : unmanaged
{
return CreateSpan(ref Unsafe.As<T, byte>(ref reference), Unsafe.SizeOf<T>());
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ReadOnlySpan<T> CreateReadOnlySpan<T>(ref T reference, int length)
{
return MemoryMarshal.CreateReadOnlySpan(ref reference, length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ReadOnlySpan<T> AsReadOnlySpan<T>(ref T reference) where T : unmanaged
{
return CreateReadOnlySpan(ref reference, 1);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ReadOnlySpan<TSpan> AsReadOnlySpan<TStruct, TSpan>(ref TStruct reference)
where TStruct : unmanaged where TSpan : unmanaged
{
return CreateReadOnlySpan(ref Unsafe.As<TStruct, TSpan>(ref reference),
Unsafe.SizeOf<TStruct>() / Unsafe.SizeOf<TSpan>());
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ReadOnlySpan<byte> AsReadOnlyByteSpan<T>(ref T reference) where T : unmanaged
{
return CreateReadOnlySpan(ref Unsafe.As<T, byte>(ref reference), Unsafe.SizeOf<T>());
}
}
}

3
Ryujinx.Graphics.Gpu/Image/Texture.cs
View file

@ -7,6 +7,7 @@ using Ryujinx.Graphics.Texture.Astc;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Ryujinx.Common.Logging;
namespace Ryujinx.Graphics.Gpu.Image
{
@ -246,7 +247,7 @@ namespace Ryujinx.Graphics.Gpu.Image
if (!_context.Capabilities.SupportsAstcCompression && _info.FormatInfo.Format.IsAstc())
{
if (!AstcDecoder.TryDecodeToRgba8(
data,
data.ToArray(),
_info.FormatInfo.BlockWidth,
_info.FormatInfo.BlockHeight,
_info.Width,

579
Ryujinx.Graphics.Texture/Astc/AstcDecoder.cs
View file

@ -1,20 +1,179 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ryujinx.Common.Utilities;
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Texture.Astc
{
// https://github.com/GammaUNC/FasTC/blob/master/ASTCEncoder/src/Decompressor.cpp
public static class AstcDecoder
public class AstcDecoder
{
private ReadOnlyMemory<byte> InputBuffer { get; }
private Memory<byte> OutputBuffer { get; }
private int BlockSizeX { get; }
private int BlockSizeY { get; }
private AstcLevel[] Levels { get; }
private bool Success { get; set; }
public int TotalBlockCount { get; }
public AstcDecoder(
ReadOnlyMemory<byte> inputBuffer,
Memory<byte> outputBuffer,
int blockWidth,
int blockHeight,
int width,
int height,
int depth,
int levels)
{
if ((uint)blockWidth > 12 || (uint)blockHeight > 12)
{
throw new AstcDecoderException("Invalid block size.");
}
InputBuffer = inputBuffer;
OutputBuffer = outputBuffer;
BlockSizeX = blockWidth;
BlockSizeY = blockHeight;
Levels = new AstcLevel[levels];
TotalBlockCount = 0;
int currentInputBlock = 0;
int currentOutputOffset = 0;
for (int i = 0; i < levels; i++)
{
ref AstcLevel level = ref Levels[i];
level.ImageSizeX = Math.Max(1, width >> i);
level.ImageSizeY = Math.Max(1, height >> i);
level.ImageSizeZ = Math.Max(1, depth >> i);
level.BlockCountX = (level.ImageSizeX + blockWidth - 1) / blockWidth;
level.BlockCountY = (level.ImageSizeY + blockHeight - 1) / blockHeight;
level.StartBlock = currentInputBlock;
level.OutputByteOffset = currentOutputOffset;
currentInputBlock += level.TotalBlockCount;
currentOutputOffset += level.PixelCount * 4;
}
TotalBlockCount = currentInputBlock;
}
private struct AstcLevel
{
public int ImageSizeX { get; set; }
public int ImageSizeY { get; set; }
public int ImageSizeZ { get; set; }
public int BlockCountX { get; set; }
public int BlockCountY { get; set; }
public int StartBlock { get; set; }
public int OutputByteOffset { get; set; }
public int TotalBlockCount => BlockCountX * BlockCountY * ImageSizeZ;
public int PixelCount => ImageSizeX * ImageSizeY * ImageSizeZ;
}
public static int QueryDecompressedSize(int sizeX, int sizeY, int sizeZ, int levelCount)
{
int size = 0;
for (int i = 0; i < levelCount; i++)
{
int levelSizeX = Math.Max(1, sizeX >> i);
int levelSizeY = Math.Max(1, sizeY >> i);
int levelSizeZ = Math.Max(1, sizeZ >> i);
size += levelSizeX * levelSizeY * levelSizeZ;
}
return size * 4;
}
public void ProcessBlock(int index)
{
Buffer16 inputBlock = MemoryMarshal.Cast<byte, Buffer16>(InputBuffer.Span)[index];
Span<int> decompressedData = stackalloc int[144];
try
{
DecompressBlock(inputBlock, decompressedData, BlockSizeX, BlockSizeY);
}
catch (Exception)
{
Success = false;
}
Span<byte> decompressedBytes = MemoryMarshal.Cast<int, byte>(decompressedData);
AstcLevel levelInfo = GetLevelInfo(index);
WriteDecompressedBlock(decompressedBytes, OutputBuffer.Span.Slice(levelInfo.OutputByteOffset),
index - levelInfo.StartBlock, levelInfo);
}
private AstcLevel GetLevelInfo(int blockIndex)
{
foreach (AstcLevel levelInfo in Levels)
{
if (blockIndex < levelInfo.StartBlock + levelInfo.TotalBlockCount)
{
return levelInfo;
}
}
throw new AstcDecoderException("Invalid block index.");
}
private void WriteDecompressedBlock(ReadOnlySpan<byte> block, Span<byte> outputBuffer, int blockIndex, AstcLevel level)
{
int stride = level.ImageSizeX * 4;
int blockCordX = blockIndex % level.BlockCountX;
int blockCordY = blockIndex / level.BlockCountX;
int pixelCordX = blockCordX * BlockSizeX;
int pixelCordY = blockCordY * BlockSizeY;
int outputPixelsX = Math.Min(pixelCordX + BlockSizeX, level.ImageSizeX) - pixelCordX;
int outputPixelsY = Math.Min(pixelCordY + BlockSizeY, level.ImageSizeY * level.ImageSizeZ) - pixelCordY;
int outputStart = pixelCordX * 4 + pixelCordY * stride;
int outputOffset = outputStart;
int inputOffset = 0;
for (int i = 0; i < outputPixelsY; i++)
{
ReadOnlySpan<byte> blockRow = block.Slice(inputOffset, outputPixelsX * 4);
Span<byte> outputRow = outputBuffer.Slice(outputOffset);
blockRow.CopyTo(outputRow);
inputOffset += BlockSizeX * 4;
outputOffset += stride;
}
}
struct TexelWeightParams
{
public int Width;
public int Height;
public bool DualPlane;
public int MaxWeight;
public bool DualPlane;
public bool Error;
public bool VoidExtentLdr;
public bool VoidExtentHdr;
@ -48,7 +207,7 @@ namespace Ryujinx.Graphics.Texture.Astc
}
public static bool TryDecodeToRgba8(
Span<byte> data,
ReadOnlyMemory<byte> data,
int blockWidth,
int blockHeight,
int width,
@ -57,87 +216,97 @@ namespace Ryujinx.Graphics.Texture.Astc
int levels,
out Span<byte> decoded)
{
bool success = true;
byte[] output = new byte[QueryDecompressedSize(width, height, depth, levels)];
using (MemoryStream inputStream = new MemoryStream(data.ToArray()))
{
BinaryReader binReader = new BinaryReader(inputStream);
AstcDecoder decoder = new AstcDecoder(data, output, blockWidth, blockHeight, width, height, depth, levels);
using (MemoryStream outputStream = new MemoryStream())
for (int i = 0; i < decoder.TotalBlockCount; i++)
{
int blockIndex = 0;
int mipOffset = 0;
for (int l = 0; l < levels; l++)
{
int sliceSize = width * height * 4;
for (int k = 0; k < depth; k++)
for (int j = 0; j < height; j += blockHeight)
for (int i = 0; i < width; i += blockWidth)
{
int[] decompressedData = new int[144];
try
{
DecompressBlock(binReader.ReadBytes(0x10), decompressedData, blockWidth, blockHeight);
}
catch (Exception)
{
success = false;
decoder.ProcessBlock(i);
}
int decompressedWidth = Math.Min(blockWidth, width - i);
int decompressedHeight = Math.Min(blockHeight, height - j);
decoded = output;
int baseOffset = mipOffset + k * sliceSize + (j * width + i) * 4;
return decoder.Success;
}
for (int jj = 0; jj < decompressedHeight; jj++)
public static bool TryDecodeToRgba8(
ReadOnlyMemory<byte> data,
Memory<byte> outputBuffer,
int blockWidth,
int blockHeight,
int width,
int height,
int depth,
int levels)
{
outputStream.Seek(baseOffset + jj * width * 4, SeekOrigin.Begin);
AstcDecoder decoder = new AstcDecoder(data, outputBuffer, blockWidth, blockHeight, width, height, depth, levels);
byte[] outputBuffer = new byte[decompressedData.Length * sizeof(int)];
Buffer.BlockCopy(decompressedData, 0, outputBuffer, 0, outputBuffer.Length);
outputStream.Write(outputBuffer, jj * blockWidth * 4, decompressedWidth * 4);
for (int i = 0; i < decoder.TotalBlockCount; i++)
{
decoder.ProcessBlock(i);
}
blockIndex++;
return decoder.Success;
}
mipOffset += sliceSize * depth;
public static bool TryDecodeToRgba8P(
ReadOnlyMemory<byte> data,
Memory<byte> outputBuffer,
int blockWidth,
int blockHeight,
int width,
int height,
int depth,
int levels)
{
AstcDecoder decoder = new AstcDecoder(data, outputBuffer, blockWidth, blockHeight, width, height, depth, levels);
width = Math.Max(1, width >> 1);
height = Math.Max(1, height >> 1);
depth = Math.Max(1, depth >> 1);
// Lazy parallelism
Enumerable.Range(0, decoder.TotalBlockCount).AsParallel().ForAll(x => decoder.ProcessBlock(x));
return decoder.Success;
}
decoded = outputStream.ToArray();
}
}
public static bool TryDecodeToRgba8P(
ReadOnlyMemory<byte> data,
int blockWidth,
int blockHeight,
int width,
int height,
int depth,
int levels,
out Span<byte> decoded)
{
byte[] output = new byte[QueryDecompressedSize(width, height, depth, levels)];
return success;
AstcDecoder decoder = new AstcDecoder(data, output, blockWidth, blockHeight, width, height, depth, levels);
Enumerable.Range(0, decoder.TotalBlockCount).AsParallel().ForAll(x => decoder.ProcessBlock(x));
decoded = output;
return decoder.Success;
}
public static bool DecompressBlock(
byte[] inputBuffer,
int[] outputBuffer,
Buffer16 inputBlock,
Span<int> outputBuffer,
int blockWidth,
int blockHeight)
{
BitArrayStream bitStream = new BitArrayStream(new BitArray(inputBuffer));
TexelWeightParams texelParams = DecodeBlockInfo(bitStream);
BitStream128 bitStream = new BitStream128(inputBlock);
DecodeBlockInfo(ref bitStream, out TexelWeightParams texelParams);
if (texelParams.Error)
{
throw new AstcDecoderException("Invalid block mode.");
throw new AstcDecoderException("Invalid block mode");
}
if (texelParams.VoidExtentLdr)
{
FillVoidExtentLdr(bitStream, outputBuffer, blockWidth, blockHeight);
FillVoidExtentLdr(ref bitStream, outputBuffer, blockWidth, blockHeight);
return true;
}
@ -170,11 +339,12 @@ namespace Ryujinx.Graphics.Texture.Astc
// each partition.
// Determine partitions, partition index, and color endpoint modes
int planeIndices = -1;
int planeIndices;
int partitionIndex;
uint[] colorEndpointMode = { 0, 0, 0, 0 };
BitArrayStream colorEndpointStream = new BitArrayStream(new BitArray(16 * 8));
Span<uint> colorEndpointMode = stackalloc uint[4];
BitStream128 colorEndpointStream = new BitStream128();
// Read extra config data...
uint baseColorEndpointMode = 0;
@ -194,7 +364,7 @@ namespace Ryujinx.Graphics.Texture.Astc
// Remaining bits are color endpoint data...
int numberWeightBits = texelParams.GetPackedBitSize();
int remainingBits = 128 - numberWeightBits - bitStream.Position;
int remainingBits = bitStream.BitsLeft - numberWeightBits;
// Consider extra bits prior to texel data...
uint extraColorEndpointModeBits = 0;
@ -243,7 +413,7 @@ namespace Ryujinx.Graphics.Texture.Astc
uint tempColorEndpointMode = (extraColorEndpointMode << 6) | baseColorEndpointMode;
tempColorEndpointMode >>= 2;
bool[] c = new bool[4];
Span<bool> c = stackalloc bool[4];
for (int i = 0; i < numberPartitions; i++)
{
@ -251,7 +421,7 @@ namespace Ryujinx.Graphics.Texture.Astc
tempColorEndpointMode >>= 1;
}
byte[] m = new byte[4];
Span<byte> m = stackalloc byte[4];
for (int i = 0; i < numberPartitions; i++)
{
@ -272,7 +442,7 @@ namespace Ryujinx.Graphics.Texture.Astc
{
uint tempColorEndpointMode = baseColorEndpointMode >> 2;
for (uint i = 0; i < numberPartitions; i++)
for (int i = 0; i < numberPartitions; i++)
{
colorEndpointMode[i] = tempColorEndpointMode;
}
@ -283,27 +453,24 @@ namespace Ryujinx.Graphics.Texture.Astc
{
Debug.Assert(colorEndpointMode[i] < 16);
}
Debug.Assert(bitStream.Position + texelParams.GetPackedBitSize() == 128);
Debug.Assert(bitStream.BitsLeft == texelParams.GetPackedBitSize());
// 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);
Span<int> colorValues = stackalloc int[32]; // Four values * two endpoints * four maximum partitions
DecodeColorValues(colorValues, ref colorEndpointStream, 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];
EndPointSet endPoints;
unsafe { _ = &endPoints; } // Skip struct initialization
int colorValuesPosition = 0;
for (int i = 0; i < numberPartitions; i++)
{
ComputeEndpoints(endPoints[i], colorValues, colorEndpointMode[i], ref colorValuesPosition);
ComputeEndpoints(endPoints.Get(i), colorValues, colorEndpointMode[i], ref colorValuesPosition);
}
// Read the texel weight data.
byte[] texelWeightData = (byte[])inputBuffer.Clone();
Buffer16 texelWeightData = inputBlock;
// Reverse everything
for (int i = 0; i < 8; i++)
@ -322,17 +489,21 @@ namespace Ryujinx.Graphics.Texture.Astc
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));
IntegerSequence texelWeightValues;
unsafe { _ = &texelWeightValues; } // Skip struct initialization
texelWeightValues.Reset();
IntegerEncoded.DecodeIntegerSequence(texelWeightValues, weightBitStream, texelParams.MaxWeight, texelParams.GetNumWeightValues());
BitStream128 weightBitStream = new BitStream128(texelWeightData);
IntegerEncoded.DecodeIntegerSequence(ref texelWeightValues, ref 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];
Weights weights;
unsafe { _ = &weights; } // Skip struct initialization
UnquantizeTexelWeights(weights, texelWeightValues, texelParams, blockWidth, blockHeight);
UnquantizeTexelWeights(ref weights, ref texelWeightValues, ref texelParams, blockWidth, blockHeight);
ushort[] table = Bits.Replicate8_16Table;
// Now that we have endpoints and weights, we can interpolate and generate
// the proper decoding...
@ -343,13 +514,13 @@ namespace Ryujinx.Graphics.Texture.Astc
int partition = Select2dPartition(partitionIndex, i, j, numberPartitions, ((blockHeight * blockWidth) < 32));
Debug.Assert(partition < numberPartitions);
AstcPixel pixel = new AstcPixel(0, 0, 0, 0);
AstcPixel pixel = new AstcPixel();
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 component0 = endPoints.Get(partition)[0].GetComponent(component);
component0 = table[component0];
int component1 = endPoints.Get(partition)[1].GetComponent(component);
component1 = table[component1];
int plane = 0;
@ -358,7 +529,7 @@ namespace Ryujinx.Graphics.Texture.Astc
plane = 1;
}
int weight = weights[plane][j * blockWidth + i];
int weight = weights.Get(plane)[j * blockWidth + i];
int finalComponent = (component0 * (64 - weight) + component1 * weight + 32) / 64;
if (finalComponent == 65535)
@ -379,6 +550,38 @@ namespace Ryujinx.Graphics.Texture.Astc
return true;
}
// Blocks can be at most 12x12, so we can have as many as 144 weights
[StructLayout(LayoutKind.Sequential, Size = 144 * sizeof(int) * Count)]
private struct Weights
{
private int _start;
public const int Count = 2;
public Span<int> this[int index]
{
get
{
if ((uint)index >= Count)
{
throw new ArgumentOutOfRangeException();
}
ref int start = ref Unsafe.Add(ref _start, index * 144);
return MemoryMarshal.CreateSpan(ref start, 144);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Span<int> Get(int index)
{
ref int start = ref Unsafe.Add(ref _start, index * 144);
return MemoryMarshal.CreateSpan(ref start, 144);
}
}
private static int Select2dPartition(int seed, int x, int y, int partitionCount, bool isSmallBlock)
{
return SelectPartition(seed, x, y, 0, partitionCount, isSmallBlock);
@ -466,43 +669,49 @@ namespace Ryujinx.Graphics.Texture.Astc
}
static void UnquantizeTexelWeights(
int[][] outputBuffer,
List<IntegerEncoded> weights,
TexelWeightParams texelParams,
ref Weights outputBuffer,
ref IntegerSequence weights,
ref TexelWeightParams texelParams,
int blockWidth,
int blockHeight)
{
int weightIndices = 0;
int[][] unquantized = new int[2][];
unquantized[0] = new int[144];
unquantized[1] = new int[144];
Weights unquantized;
unsafe { _ = &unquantized; } // Skip struct initialization
for (int i = 0; i < weights.Count; i++)
Span<IntegerEncoded> weightsList = weights.List;
Span<int> unquantized0 = unquantized[0];
Span<int> unquantized1 = unquantized[1];
for (int i = 0; i < weightsList.Length; i++)
{
unquantized[0][weightIndices] = UnquantizeTexelWeight(weights[i]);
unquantized0[weightIndices] = UnquantizeTexelWeight(weightsList[i]);
if (texelParams.DualPlane)
{
i++;
unquantized[1][weightIndices] = UnquantizeTexelWeight(weights[i]);
unquantized1[weightIndices] = UnquantizeTexelWeight(weightsList[i]);
if (i == weights.Count)
if (i == weightsList.Length)
{
break;
}
}
if (++weightIndices >= (texelParams.Width * texelParams.Height)) 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 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++)
{
Span<int> unquantizedSpan = unquantized.Get(plane);
Span<int> outputSpan = outputBuffer.Get(plane);
for (int t = 0; t < blockHeight; t++)
{
for (int s = 0; s < blockWidth; s++)
@ -520,38 +729,34 @@ namespace Ryujinx.Graphics.Texture.Astc
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;
int weight = 8;
if (v0 < (texelParams.Width * texelParams.Height))
int wxh = texelParams.Width * texelParams.Height;
if (v0 < wxh)
{
p00 = unquantized[plane][v0];
weight += unquantizedSpan[v0] * (16 - fs - ft + w11);
if (v0 + 1 < wxh)
{
weight += unquantizedSpan[v0 + 1] * (fs - w11);
}
}
if (v0 + 1 < (texelParams.Width * texelParams.Height))
if (v0 + texelParams.Width < wxh)
{
p01 = unquantized[plane][v0 + 1];
weight += unquantizedSpan[v0 + texelParams.Width] * (ft - w11);
if (v0 + texelParams.Width + 1 < wxh)
{
weight += unquantizedSpan[v0 + texelParams.Width + 1] * w11;
}
}
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;
outputSpan[t * blockWidth + s] = weight >> 4;
}
}
}
@ -562,7 +767,7 @@ namespace Ryujinx.Graphics.Texture.Astc
int bitValue = intEncoded.BitValue;
int bitLength = intEncoded.NumberBits;
int a = BitArrayStream.Replicate(bitValue & 1, 1, 7);
int a = Bits.Replicate1_7(bitValue & 1);
int b = 0, c = 0, d = 0;
int result = 0;
@ -570,7 +775,7 @@ namespace Ryujinx.Graphics.Texture.Astc
switch (intEncoded.GetEncoding())
{
case IntegerEncoded.EIntegerEncoding.JustBits:
result = BitArrayStream.Replicate(bitValue, bitLength, 6);
result = Bits.Replicate(bitValue, bitLength, 6);
break;
case IntegerEncoded.EIntegerEncoding.Trit:
@ -582,8 +787,13 @@ namespace Ryujinx.Graphics.Texture.Astc
{
case 0:
{
int[] results = { 0, 32, 63 };
result = results[d];
result = d switch
{
0 => 0,
1 => 32,
2 => 63,
_ => 0
};
break;
}
@ -628,8 +838,15 @@ namespace Ryujinx.Graphics.Texture.Astc
{
case 0:
{
int[] results = { 0, 16, 32, 47, 63 };
result = results[d];
result = d switch
{
0 => 0,
1 => 16,
2 => 32,
3 => 47,
4 => 63,
_ => 0
};
break;
}
@ -683,33 +900,27 @@ namespace Ryujinx.Graphics.Texture.Astc
return (byte)((((b) * 0x80200802L) & 0x0884422110L) * 0x0101010101L >> 32);
}
static uint[] ReadUintColorValues(int number, int[] colorValues, ref int colorValuesPosition)
static Span<uint> ReadUintColorValues(int number, Span<int> colorValues, ref int colorValuesPosition)
{
uint[] ret = new uint[number];
Span<int> ret = colorValues.Slice(colorValuesPosition, number);
for (int i = 0; i < number; i++)
{
ret[i] = (uint)colorValues[colorValuesPosition++];
colorValuesPosition += number;
return MemoryMarshal.Cast<int, uint>(ret);
}
return ret;
}
static int[] ReadIntColorValues(int number, int[] colorValues, ref int colorValuesPosition)
static Span<int> ReadIntColorValues(int number, Span<int> colorValues, ref int colorValuesPosition)
{
int[] ret = new int[number];
Span<int> ret = colorValues.Slice(colorValuesPosition, number);
for (int i = 0; i < number; i++)
{
ret[i] = colorValues[colorValuesPosition++];
}
colorValuesPosition += number;
return ret;
}
static void ComputeEndpoints(
AstcPixel[] endPoints,
int[] colorValues,
Span<AstcPixel> endPoints,
Span<int> colorValues,
uint colorEndpointMode,
ref int colorValuesPosition)
{
@ -717,7 +928,7 @@ namespace Ryujinx.Graphics.Texture.Astc
{
case 0:
{
uint[] val = ReadUintColorValues(2, colorValues, ref colorValuesPosition);
Span<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]);
@ -728,7 +939,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case 1:
{
uint[] val = ReadUintColorValues(2, colorValues, ref colorValuesPosition);
Span<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);
@ -740,7 +951,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case 4:
{
uint[] val = ReadUintColorValues(4, colorValues, ref colorValuesPosition);
Span<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]);
@ -750,10 +961,10 @@ namespace Ryujinx.Graphics.Texture.Astc
case 5:
{
int[] val = ReadIntColorValues(4, colorValues, ref colorValuesPosition);
Span<int> val = ReadIntColorValues(4, colorValues, ref colorValuesPosition);
BitArrayStream.BitTransferSigned(ref val[1], ref val[0]);
BitArrayStream.BitTransferSigned(ref val[3], ref val[2]);
Bits.BitTransferSigned(ref val[1], ref val[0]);
Bits.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]));
@ -766,7 +977,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case 6:
{
uint[] val = ReadUintColorValues(4, colorValues, ref colorValuesPosition);
Span<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]);
@ -776,7 +987,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case 8:
{
uint[] val = ReadUintColorValues(6, colorValues, ref colorValuesPosition);
Span<uint> val = ReadUintColorValues(6, colorValues, ref colorValuesPosition);
if (val[1] + val[3] + val[5] >= val[0] + val[2] + val[4])
{
@ -794,11 +1005,11 @@ namespace Ryujinx.Graphics.Texture.Astc
case 9:
{
int[] val = ReadIntColorValues(6, colorValues, ref colorValuesPosition);
Span<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]);
Bits.BitTransferSigned(ref val[1], ref val[0]);
Bits.BitTransferSigned(ref val[3], ref val[2]);
Bits.BitTransferSigned(ref val[5], ref val[4]);
if (val[1] + val[3] + val[5] >= 0)
{
@ -819,7 +1030,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case 10:
{
uint[] val = ReadUintColorValues(6, colorValues, ref colorValuesPosition);
Span<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]);
@ -829,7 +1040,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case 12:
{
uint[] val = ReadUintColorValues(8, colorValues, ref colorValuesPosition);
Span<uint> val = ReadUintColorValues(8, colorValues, ref colorValuesPosition);
if (val[1] + val[3] + val[5] >= val[0] + val[2] + val[4])
{
@ -847,12 +1058,12 @@ namespace Ryujinx.Graphics.Texture.Astc
case 13:
{
int[] val = ReadIntColorValues(8, colorValues, ref colorValuesPosition);
Span<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]);
Bits.BitTransferSigned(ref val[1], ref val[0]);
Bits.BitTransferSigned(ref val[3], ref val[2]);
Bits.BitTransferSigned(ref val[5], ref val[4]);
Bits.BitTransferSigned(ref val[7], ref val[6]);
if (val[1] + val[3] + val[5] >= 0)
{
@ -877,9 +1088,9 @@ namespace Ryujinx.Graphics.Texture.Astc
}
static void DecodeColorValues(
int[] outputValues,
byte[] inputData,
uint[] modes,
Span<int> outputValues,
ref BitStream128 colorBitStream,
Span<uint> modes,
int numberPartitions,
int numberBitsForColorData)
{
@ -919,16 +1130,17 @@ namespace Ryujinx.Graphics.Texture.Astc
}
// We now have enough to decode our integer sequence.
List<IntegerEncoded> integerEncodedSequence = new List<IntegerEncoded>();
BitArrayStream colorBitStream = new BitArrayStream(new BitArray(inputData));
IntegerSequence integerEncodedSequence;
unsafe { _ = &integerEncodedSequence; } // Skip struct initialization
integerEncodedSequence.Reset();
IntegerEncoded.DecodeIntegerSequence(integerEncodedSequence, colorBitStream, range, numberValues);
IntegerEncoded.DecodeIntegerSequence(ref integerEncodedSequence, ref 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)
foreach (ref IntegerEncoded intEncoded in integerEncodedSequence.List)
{
int bitLength = intEncoded.NumberBits;
int bitValue = intEncoded.BitValue;
@ -937,13 +1149,13 @@ namespace Ryujinx.Graphics.Texture.Astc
int a = 0, b = 0, c = 0, d = 0;
// A is just the lsb replicated 9 times.
a = BitArrayStream.Replicate(bitValue & 1, 1, 9);
a = Bits.Replicate(bitValue & 1, 1, 9);
switch (intEncoded.GetEncoding())
{
case IntegerEncoded.EIntegerEncoding.JustBits:
{
outputValues[outputIndices++] = BitArrayStream.Replicate(bitValue, bitLength, 8);
outputValues[outputIndices++] = Bits.Replicate(bitValue, bitLength, 8);
break;
}
@ -1096,7 +1308,7 @@ namespace Ryujinx.Graphics.Texture.Astc
}
}
static void FillVoidExtentLdr(BitArrayStream bitStream, int[] outputBuffer, int blockWidth, int blockHeight)
static void FillVoidExtentLdr(ref BitStream128 bitStream, Span<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)
@ -1121,9 +1333,9 @@ namespace Ryujinx.Graphics.Texture.Astc
}
}
static TexelWeightParams DecodeBlockInfo(BitArrayStream bitStream)
static void DecodeBlockInfo(ref BitStream128 bitStream, out TexelWeightParams texelParams)
{
TexelWeightParams texelParams = new TexelWeightParams();
texelParams = new TexelWeightParams();
// Read the entire block mode all at once
ushort modeBits = (ushort)bitStream.ReadBits(11);
@ -1146,14 +1358,15 @@ namespace Ryujinx.Graphics.Texture.Astc
texelParams.Error = true;
}
return texelParams;
return;
}
// First check if the last four bits are zero
if ((modeBits & 0xF) == 0)
{
texelParams.Error = true;
return texelParams;
return;
}
// If the last two bits are zero, then if bits
@ -1162,14 +1375,14 @@ namespace Ryujinx.Graphics.Texture.Astc
{
texelParams.Error = true;
return texelParams;
return;
}
// 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;
int layout;
if ((modeBits & 0x1) != 0 || (modeBits & 0x2) != 0)
{
@ -1378,18 +1591,16 @@ namespace Ryujinx.Graphics.Texture.Astc
if (h)
{
int[] maxWeights = { 9, 11, 15, 19, 23, 31 };
ReadOnlySpan<byte> maxWeights = new byte[] { 9, 11, 15, 19, 23, 31 };
texelParams.MaxWeight = maxWeights[r - 2];
}
else
{
int[] maxWeights = { 1, 2, 3, 4, 5, 7 };
ReadOnlySpan<byte> maxWeights = new byte[] { 1, 2, 3, 4, 5, 7 };
texelParams.MaxWeight = maxWeights[r - 2];
}
texelParams.DualPlane = d;
return texelParams;
}
}
}

112
Ryujinx.Graphics.Texture/Astc/AstcPixel.cs
View file

@ -1,16 +1,23 @@
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Texture.Astc
{
class AstcPixel
[StructLayout(LayoutKind.Sequential)]
struct AstcPixel
{
public short R { get; set; }
public short G { get; set; }
public short B { get; set; }
public short A { get; set; }
internal const int StructSize = 12;
byte[] _bitDepth = new byte[4];
public short A;
public short R;
public short G;
public short B;
private uint _bitDepthInt;
private Span<byte> BitDepth => MemoryMarshal.CreateSpan(ref Unsafe.As<uint, byte>(ref _bitDepthInt), 4);
private Span<short> Components => MemoryMarshal.CreateSpan(ref A, 4);
public AstcPixel(short a, short r, short g, short b)
{
@ -19,8 +26,7 @@ namespace Ryujinx.Graphics.Texture.Astc
G = g;
B = b;
for (int i = 0; i < 4; i++)
_bitDepth[i] = 8;
_bitDepthInt = 0x08080808;
}
public void ClampByte()
@ -33,96 +39,20 @@ namespace Ryujinx.Graphics.Texture.Astc
public short GetComponent(int index)
{
switch(index)
{
case 0: return A;
case 1: return R;
case 2: return G;
case 3: return B;
}
return 0;
return Components[index];
}
public void SetComponent(int index, int value)
{
switch (index)
{
case 0:
A = (short)value;
break;
case 1:
R = (short)value;
break;
case 2:
G = (short)value;
break;
case 3:
B = (short)value;
break;
}
}
public void ChangeBitDepth(byte[] depth)
{
for (int i = 0; i< 4; i++)
{
int value = ChangeBitDepth(GetComponent(i), _bitDepth[i], depth[i]);
SetComponent(i, value);
_bitDepth[i] = depth[i];
}
}
short ChangeBitDepth(short value, byte oldDepth, byte newDepth)
{
Debug.Assert(newDepth <= 8);
Debug.Assert(oldDepth <= 8);
if (oldDepth == newDepth)
{
// Do nothing
return value;
}
else if (oldDepth == 0 && newDepth != 0)
{
return (short)((1 << newDepth) - 1);
}
else if (newDepth > oldDepth)
{
return (short)BitArrayStream.Replicate(value, oldDepth, newDepth);
}
else
{
// oldDepth > newDepth
if (newDepth == 0)
{
return 0xFF;
}
else
{
byte bitsWasted = (byte)(oldDepth - newDepth);
short tempValue = value;
tempValue = (short)((tempValue + (1 << (bitsWasted - 1))) >> bitsWasted);
tempValue = Math.Min(Math.Max((short)0, tempValue), (short)((1 << newDepth) - 1));
return (byte)(tempValue);
}
}
Components[index] = (short)value;
}
public int Pack()
{
AstcPixel newPixel = new AstcPixel(A, R, G, B);
byte[] eightBitDepth = { 8, 8, 8, 8 };
newPixel.ChangeBitDepth(eightBitDepth);
return (byte)newPixel.A << 24 |
(byte)newPixel.B << 16 |
(byte)newPixel.G << 8 |
(byte)newPixel.R << 0;
return A << 24 |
B << 16 |
G << 8 |
R << 0;
}
// Adds more precision to the blue channel as described

121
Ryujinx.Graphics.Texture/Astc/BitArrayStream.cs
View file

@ -1,121 +0,0 @@
using System;
using System.Collections;
namespace Ryujinx.Graphics.Texture.Astc
{
public class BitArrayStream
{
public BitArray BitsArray;
public int Position { get; private set; }
public BitArrayStream(BitArray bitArray)
{
BitsArray = bitArray;
Position = 0;
}
public short ReadBits(int length)
{
int retValue = 0;
for (int i = Position; i < Position + length; i++)
{
if (BitsArray[i])
{
retValue |= 1 << (i - Position);
}
}
Position += length;
return (short)retValue;
}
public int ReadBits(int start, int end)
{
int retValue = 0;
for (int i = start; i <= end; i++)
{
if (BitsArray[i])
{
retValue |= 1 << (i - start);
}
}
return retValue;
}
public int ReadBit(int index)
{
return Convert.ToInt32(BitsArray[index]);
}
public void WriteBits(int value, int length)
{
for (int i = Position; i < Position + length; i++)
{
BitsArray[i] = ((value >> (i - Position)) & 1) != 0;
}
Position += length;
}
public byte[] ToByteArray()
{
byte[] retArray = new byte[(BitsArray.Length + 7) / 8];
BitsArray.CopyTo(retArray, 0);
return retArray;
}
public static int Replicate(int value, int numberBits, int toBit)
{
if (numberBits == 0) return 0;
if (toBit == 0) return 0;
int tempValue = value & ((1 << numberBits) - 1);
int retValue = tempValue;
int resLength = numberBits;
while (resLength < toBit)
{
int comp = 0;
if (numberBits > toBit - resLength)
{
int newShift = toBit - resLength;
comp = numberBits - newShift;
numberBits = newShift;
}
retValue <<= numberBits;
retValue |= tempValue >> comp;
resLength += numberBits;
}
return retValue;
}
public static int PopCnt(int number)
{
int counter;
for (counter = 0; number != 0; counter++)
{
number &= number - 1;
}
return counter;
}
public static void Swap<T>(ref T lhs, ref T rhs)
{
T temp = lhs;
lhs = rhs;
rhs = temp;
}
// Transfers a bit as described in C.2.14
public static void BitTransferSigned(ref int a, ref int b)
{
b >>= 1;
b |= a & 0x80;
a >>= 1;
a &= 0x3F;
if ((a & 0x20) != 0) a -= 0x40;
}
}
}

72
Ryujinx.Graphics.Texture/Astc/BitStream128.cs Normal file
View file

@ -0,0 +1,72 @@
using Ryujinx.Common.Utilities;
using System;
using System.Diagnostics;
namespace Ryujinx.Graphics.Texture.Astc
{
public struct BitStream128
{
private Buffer16 _data;
public int BitsLeft { get; set; }
public BitStream128(Buffer16 data)
{
_data = data;
BitsLeft = 128;
}
public int ReadBits(int bitCount)
{
Debug.Assert(bitCount < 32);
if (bitCount == 0)
{
return 0;
}
int mask = (1 << bitCount) - 1;
int value = _data.As<int>() & mask;
Span<ulong> span = _data.AsSpan<ulong>();
ulong carry = span[1] << (64 - bitCount);
span[0] = (span[0] >> bitCount) | carry;
span[1] >>= bitCount;
BitsLeft -= bitCount;
return value;
}
public void WriteBits(int value, int bitCount)
{
Debug.Assert(bitCount < 32);
if (bitCount == 0) return;
ulong maskedValue = (uint)(value & ((1 << bitCount) - 1));
Span<ulong> span = _data.AsSpan<ulong>();
if (BitsLeft < 64)
{
ulong lowMask = maskedValue << BitsLeft;
span[0] |= lowMask;
}
if (BitsLeft + bitCount > 64)
{
if (BitsLeft > 64)
{
span[1] |= maskedValue << (BitsLeft - 64);
}
else
{
span[1] |= maskedValue >> (64 - BitsLeft);
}
}
BitsLeft += bitCount;
}
}
}

66
Ryujinx.Graphics.Texture/Astc/Bits.cs Normal file
View file

@ -0,0 +1,66 @@
namespace Ryujinx.Graphics.Texture.Astc
{
internal static class Bits
{
public static readonly ushort[] Replicate8_16Table;
public static readonly byte[] Replicate1_7Table;
static Bits()
{
Replicate8_16Table = new ushort[0x200];
Replicate1_7Table = new byte[0x200];
for (int i = 0; i < 0x200; i++)
{
Replicate8_16Table[i] = (ushort)Replicate(i, 8, 16);
Replicate1_7Table[i] = (byte)Replicate(i, 1, 7);
}
}
public static int Replicate8_16(int value)
{
return Replicate8_16Table[value];
}
public static int Replicate1_7(int value)
{
return Replicate1_7Table[value];
}
public static int Replicate(int value, int numberBits, int toBit)
{
if (numberBits == 0) return 0;
if (toBit == 0) return 0;
int tempValue = value & ((1 << numberBits) - 1);
int retValue = tempValue;
int resLength = numberBits;
while (resLength < toBit)
{
int comp = 0;
if (numberBits > toBit - resLength)
{
int newShift = toBit - resLength;
comp = numberBits - newShift;
numberBits = newShift;
}
retValue <<= numberBits;
retValue |= tempValue >> comp;
resLength += numberBits;
}
return retValue;
}
// Transfers a bit as described in C.2.14
public static void BitTransferSigned(ref int a, ref int b)
{
b >>= 1;
b |= a & 0x80;
a >>= 1;
a &= 0x3F;
if ((a & 0x20) != 0) a -= 0x40;
}
}
}

23
Ryujinx.Graphics.Texture/Astc/EndPointSet.cs Normal file
View file

@ -0,0 +1,23 @@
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Texture.Astc
{
[StructLayout(LayoutKind.Sequential, Size = AstcPixel.StructSize * 8)]
internal struct EndPointSet
{
private AstcPixel _start;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Span<AstcPixel> Get(int index)
{
Debug.Assert(index < 4);
ref AstcPixel start = ref Unsafe.Add(ref _start, index * 2);
return MemoryMarshal.CreateSpan(ref start, 2);
}
}
}

316
Ryujinx.Graphics.Texture/Astc/IntegerEncoded.cs
View file

@ -1,11 +1,14 @@
using System.Collections;
using System.Collections.Generic;
using System;
using System.Numerics;
namespace Ryujinx.Graphics.Texture.Astc
{
public struct IntegerEncoded
internal struct IntegerEncoded
{
public enum EIntegerEncoding
internal const int StructSize = 8;
private static readonly IntegerEncoded[] Encodings;
public enum EIntegerEncoding : byte
{
JustBits,
Quint,
@ -13,15 +16,25 @@ namespace Ryujinx.Graphics.Texture.Astc
}
EIntegerEncoding _encoding;
public int NumberBits { get; private set; }
public byte NumberBits { get; private set; }
public byte TritValue { get; private set; }
public byte QuintValue { get; private set; }
public int BitValue { get; private set; }
public int TritValue { get; private set; }
public int QuintValue { get; private set; }
static IntegerEncoded()
{
Encodings = new IntegerEncoded[0x100];
for (int i = 0; i < Encodings.Length; i++)
{
Encodings[i] = CreateEncodingCalc(i);
}
}
public IntegerEncoded(EIntegerEncoding encoding, int numBits)
{
_encoding = encoding;
NumberBits = numBits;
NumberBits = (byte)numBits;
BitValue = 0;
TritValue = 0;
QuintValue = 0;
@ -52,6 +65,11 @@ namespace Ryujinx.Graphics.Texture.Astc
}
public static IntegerEncoded CreateEncoding(int maxVal)
{
return Encodings[maxVal];
}
private static IntegerEncoded CreateEncodingCalc(int maxVal)
{
while (maxVal > 0)
{
@ -60,19 +78,19 @@ namespace Ryujinx.Graphics.Texture.Astc
// Is maxVal a power of two?
if ((check & (check - 1)) == 0)
{
return new IntegerEncoded(EIntegerEncoding.JustBits, BitArrayStream.PopCnt(maxVal));
return new IntegerEncoded(EIntegerEncoding.JustBits, BitOperations.PopCount((uint)maxVal));
}
// Is maxVal of the type 3*2^n - 1?
if ((check % 3 == 0) && ((check / 3) & ((check / 3) - 1)) == 0)
{
return new IntegerEncoded(EIntegerEncoding.Trit, BitArrayStream.PopCnt(check / 3 - 1));
return new IntegerEncoded(EIntegerEncoding.Trit, BitOperations.PopCount((uint)(check / 3 - 1)));
}
// Is maxVal of the type 5*2^n - 1?
if ((check % 5 == 0) && ((check / 5) & ((check / 5) - 1)) == 0)
{
return new IntegerEncoded(EIntegerEncoding.Quint, BitArrayStream.PopCnt(check / 5 - 1));
return new IntegerEncoded(EIntegerEncoding.Quint, BitOperations.PopCount((uint)(check / 5 - 1)));
}
// Apparently it can't be represented with a bounded integer sequence...
@ -84,148 +102,76 @@ namespace Ryujinx.Graphics.Texture.Astc
}
public static void DecodeTritBlock(
BitArrayStream bitStream,
List<IntegerEncoded> listIntegerEncoded,
ref BitStream128 bitStream,
ref IntegerSequence listIntegerEncoded,
int numberBitsPerValue)
{
// Implement the algorithm in section C.2.12
int[] m = new int[5];
int[] t = new int[5];
int T;
Span<int> m = stackalloc int[5];
// Read the trit encoded block according to
// table C.2.14
m[0] = bitStream.ReadBits(numberBitsPerValue);
T = bitStream.ReadBits(2);
int encoded = bitStream.ReadBits(2);
m[1] = bitStream.ReadBits(numberBitsPerValue);
T |= bitStream.ReadBits(2) << 2;
encoded |= bitStream.ReadBits(2) << 2;
m[2] = bitStream.ReadBits(numberBitsPerValue);
T |= bitStream.ReadBits(1) << 4;
encoded |= bitStream.ReadBits(1) << 4;
m[3] = bitStream.ReadBits(numberBitsPerValue);
T |= bitStream.ReadBits(2) << 5;
encoded |= bitStream.ReadBits(2) << 5;
m[4] = bitStream.ReadBits(numberBitsPerValue);
T |= bitStream.ReadBits(1) << 7;
encoded |= bitStream.ReadBits(1) << 7;
int c = 0;
ReadOnlySpan<byte> encodings = GetTritEncoding(encoded);
BitArrayStream tb = new BitArrayStream(new BitArray(new int[] { T }));
if (tb.ReadBits(2, 4) == 7)
{
c = (tb.ReadBits(5, 7) << 2) | tb.ReadBits(0, 1);
t[4] = t[3] = 2;
}
else
{
c = tb.ReadBits(0, 4);
if (tb.ReadBits(5, 6) == 3)
{
t[4] = 2;
t[3] = tb.ReadBit(7);
}
else
{
t[4] = tb.ReadBit(7);
t[3] = tb.ReadBits(5, 6);
}
}
BitArrayStream cb = new BitArrayStream(new BitArray(new int[] { c }));
if (cb.ReadBits(0, 1) == 3)
{
t[2] = 2;
t[1] = cb.ReadBit(4);
t[0] = (cb.ReadBit(3) << 1) | (cb.ReadBit(2) & ~cb.ReadBit(3));
}
else if (cb.ReadBits(2, 3) == 3)
{
t[2] = 2;
t[1] = 2;
t[0] = cb.ReadBits(0, 1);
}
else
{
t[2] = cb.ReadBit(4);
t[1] = cb.ReadBits(2, 3);
t[0] = (cb.ReadBit(1) << 1) | (cb.ReadBit(0) & ~cb.ReadBit(1));
}
IntegerEncoded intEncoded = new IntegerEncoded(EIntegerEncoding.Trit, numberBitsPerValue);
for (int i = 0; i < 5; i++)
{
IntegerEncoded intEncoded = new IntegerEncoded(EIntegerEncoding.Trit, numberBitsPerValue)
{
BitValue = m[i],
TritValue = t[i]
};
listIntegerEncoded.Add(intEncoded);
intEncoded.BitValue = m[i];
intEncoded.TritValue = encodings[i];
listIntegerEncoded.Add(ref intEncoded);
}
}
public static void DecodeQuintBlock(
BitArrayStream bitStream,
List<IntegerEncoded> listIntegerEncoded,
ref BitStream128 bitStream,
ref IntegerSequence listIntegerEncoded,
int numberBitsPerValue)
{
ReadOnlySpan<byte> interleavedBits = new byte[] { 3, 2, 2 };
// Implement the algorithm in section C.2.12
int[] m = new int[3];
int[] qa = new int[3];
int q;
Span<int> m = stackalloc int[3];
ulong encoded = 0;
int encodedBitsRead = 0;
// Read the trit encoded block according to
// table C.2.15
m[0] = bitStream.ReadBits(numberBitsPerValue);
q = bitStream.ReadBits(3);
m[1] = bitStream.ReadBits(numberBitsPerValue);
q |= bitStream.ReadBits(2) << 3;
m[2] = bitStream.ReadBits(numberBitsPerValue);
q |= bitStream.ReadBits(2) << 5;
for (int i = 0; i < m.Length; i++)
{
m[i] = bitStream.ReadBits(numberBitsPerValue);
BitArrayStream qb = new BitArrayStream(new BitArray(new int[] { q }));
if (qb.ReadBits(1, 2) == 3 && qb.ReadBits(5, 6) == 0)
{
qa[0] = qa[1] = 4;
qa[2] = (qb.ReadBit(0) << 2) | ((qb.ReadBit(4) & ~qb.ReadBit(0)) << 1) | (qb.ReadBit(3) & ~qb.ReadBit(0));
}
else
{
int c = 0;
if (qb.ReadBits(1, 2) == 3)
{
qa[2] = 4;
c = (qb.ReadBits(3, 4) << 3) | ((~qb.ReadBits(5, 6) & 3) << 1) | qb.ReadBit(0);
}
else
{
qa[2] = qb.ReadBits(5, 6);
c = qb.ReadBits(0, 4);
uint encodedBits = (uint)bitStream.ReadBits(interleavedBits[i]);
encoded |= encodedBits << encodedBitsRead;
encodedBitsRead += interleavedBits[i];
}
BitArrayStream cb = new BitArrayStream(new BitArray(new int[] { c }));
if (cb.ReadBits(0, 2) == 5)
{
qa[1] = 4;
qa[0] = cb.ReadBits(3, 4);
}
else
{
qa[1] = cb.ReadBits(3, 4);
qa[0] = cb.ReadBits(0, 2);
}
}
ReadOnlySpan<byte> encodings = GetQuintEncoding((int)encoded);
for (int i = 0; i < 3; i++)
{
IntegerEncoded intEncoded = new IntegerEncoded(EIntegerEncoding.Quint, numberBitsPerValue)
{
BitValue = m[i],
QuintValue = qa[i]
QuintValue = encodings[i]
};
listIntegerEncoded.Add(intEncoded);
listIntegerEncoded.Add(ref intEncoded);
}
}
public static void DecodeIntegerSequence(
List<IntegerEncoded> decodeIntegerSequence,
BitArrayStream bitStream,
ref IntegerSequence decodeIntegerSequence,
ref BitStream128 bitStream,
int maxRange,
int numberValues)
{
@ -240,7 +186,7 @@ namespace Ryujinx.Graphics.Texture.Astc
{
case EIntegerEncoding.Quint:
{
DecodeQuintBlock(bitStream, decodeIntegerSequence, intEncoded.NumberBits);
DecodeQuintBlock(ref bitStream, ref decodeIntegerSequence, intEncoded.NumberBits);
numberValuesDecoded += 3;
break;
@ -248,7 +194,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case EIntegerEncoding.Trit:
{
DecodeTritBlock(bitStream, decodeIntegerSequence, intEncoded.NumberBits);
DecodeTritBlock(ref bitStream, ref decodeIntegerSequence, intEncoded.NumberBits);
numberValuesDecoded += 5;
break;
@ -257,7 +203,7 @@ namespace Ryujinx.Graphics.Texture.Astc
case EIntegerEncoding.JustBits:
{
intEncoded.BitValue = bitStream.ReadBits(intEncoded.NumberBits);
decodeIntegerSequence.Add(intEncoded);
decodeIntegerSequence.Add(ref intEncoded);
numberValuesDecoded++;
break;
@ -265,5 +211,135 @@ namespace Ryujinx.Graphics.Texture.Astc
}
}
}
private static ReadOnlySpan<byte> GetTritEncoding(int index)
{
return TritEncodings.Slice(index * 5, 5);
}
private static ReadOnlySpan<byte> GetQuintEncoding(int index)
{
return QuintEncodings.Slice(index * 3, 3);
}
private static ReadOnlySpan<byte> TritEncodings => new byte[]
{
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0,
2, 1, 0, 0, 0, 1, 0, 2, 0, 0, 0, 2, 0, 0, 0,
1, 2, 0, 0, 0, 2, 2, 0, 0, 0, 2, 0, 2, 0, 0,
0, 2, 2, 0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 0, 0,
2, 0, 2, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0,
2, 0, 1, 0, 0, 0, 1, 2, 0, 0, 0, 1, 1, 0, 0,
1, 1, 1, 0, 0, 2, 1, 1, 0, 0, 1, 1, 2, 0, 0,
0, 2, 1, 0, 0, 1, 2, 1, 0, 0, 2, 2, 1, 0, 0,
2, 1, 2, 0, 0, 0, 0, 0, 2, 2, 1, 0, 0, 2, 2,
2, 0, 0, 2, 2, 0, 0, 2, 2, 2, 0, 0, 0, 1, 0,
1, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 0, 2, 1, 0,
0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 2, 1, 0, 1, 0,
1, 0, 2, 1, 0, 0, 2, 0, 1, 0, 1, 2, 0, 1, 0,
2, 2, 0, 1, 0, 2, 0, 2, 1, 0, 0, 2, 2, 1, 0,
1, 2, 2, 1, 0, 2, 2, 2, 1, 0, 2, 0, 2, 1, 0,
0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 2, 0, 1, 1, 0,
0, 1, 2, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0,
2, 1, 1, 1, 0, 1, 1, 2, 1, 0, 0, 2, 1, 1, 0,
1, 2, 1, 1, 0, 2, 2, 1, 1, 0, 2, 1, 2, 1, 0,
0, 1, 0, 2, 2, 1, 1, 0, 2, 2, 2, 1, 0, 2, 2,
1, 0, 2, 2, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 0,
2, 0, 0, 2, 0, 0, 0, 2, 2, 0, 0, 1, 0, 2, 0,
1, 1, 0, 2, 0, 2, 1, 0, 2, 0, 1, 0, 2, 2, 0,
0, 2, 0, 2, 0, 1, 2, 0, 2, 0, 2, 2, 0, 2, 0,
2, 0, 2, 2, 0, 0, 2, 2, 2, 0, 1, 2, 2, 2, 0,
2, 2, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 1, 2, 0,
1, 0, 1, 2, 0, 2, 0, 1, 2, 0, 0, 1, 2, 2, 0,
0, 1, 1, 2, 0, 1, 1, 1, 2, 0, 2, 1, 1, 2, 0,
1, 1, 2, 2, 0, 0, 2, 1, 2, 0, 1, 2, 1, 2, 0,
2, 2, 1, 2, 0, 2, 1, 2, 2, 0, 0, 2, 0, 2, 2,
1, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2,
0, 0, 0, 0, 2, 1, 0, 0, 0, 2, 2, 0, 0, 0, 2,
0, 0, 2, 0, 2, 0, 1, 0, 0, 2, 1, 1, 0, 0, 2,
2, 1, 0, 0, 2, 1, 0, 2, 0, 2, 0, 2, 0, 0, 2,
1, 2, 0, 0, 2, 2, 2, 0, 0, 2, 2, 0, 2, 0, 2,
0, 2, 2, 0, 2, 1, 2, 2, 0, 2, 2, 2, 2, 0, 2,
2, 0, 2, 0, 2, 0, 0, 1, 0, 2, 1, 0, 1, 0, 2,
2, 0, 1, 0, 2, 0, 1, 2, 0, 2, 0, 1, 1, 0, 2,
1, 1, 1, 0, 2, 2, 1, 1, 0, 2, 1, 1, 2, 0, 2,
0, 2, 1, 0, 2, 1, 2, 1, 0, 2, 2, 2, 1, 0, 2,
2, 1, 2, 0, 2, 0, 2, 2, 2, 2, 1, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 1,
1, 0, 0, 0, 1, 2, 0, 0, 0, 1, 0, 0, 2, 0, 1,
0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 2, 1, 0, 0, 1,
1, 0, 2, 0, 1, 0, 2, 0, 0, 1, 1, 2, 0, 0, 1,
2, 2, 0, 0, 1, 2, 0, 2, 0, 1, 0, 2, 2, 0, 1,
1, 2, 2, 0, 1, 2, 2, 2, 0, 1, 2, 0, 2, 0, 1,
0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 2, 0, 1, 0, 1,
0, 1, 2, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,
2, 1, 1, 0, 1, 1, 1, 2, 0, 1, 0, 2, 1, 0, 1,
1, 2, 1, 0, 1, 2, 2, 1, 0, 1, 2, 1, 2, 0, 1,
0, 0, 1, 2, 2, 1, 0, 1, 2, 2, 2, 0, 1, 2, 2,
0, 1, 2, 2, 2, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
2, 0, 0, 1, 1, 0, 0, 2, 1, 1, 0, 1, 0, 1, 1,
1, 1, 0, 1, 1, 2, 1, 0, 1, 1, 1, 0, 2, 1, 1,
0, 2, 0, 1, 1, 1, 2, 0, 1, 1, 2, 2, 0, 1, 1,
2, 0, 2, 1, 1, 0, 2, 2, 1, 1, 1, 2, 2, 1, 1,
2, 2, 2, 1, 1, 2, 0, 2, 1, 1, 0, 0, 1, 1, 1,
1, 0, 1, 1, 1, 2, 0, 1, 1, 1, 0, 1, 2, 1, 1,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1, 1, 2, 1, 1, 0, 2, 1, 1, 1, 1, 2, 1, 1, 1,
2, 2, 1, 1, 1, 2, 1, 2, 1, 1, 0, 1, 1, 2, 2,
1, 1, 1, 2, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2,
0, 0, 0, 2, 1, 1, 0, 0, 2, 1, 2, 0, 0, 2, 1,
0, 0, 2, 2, 1, 0, 1, 0, 2, 1, 1, 1, 0, 2, 1,
2, 1, 0, 2, 1, 1, 0, 2, 2, 1, 0, 2, 0, 2, 1,
1, 2, 0, 2, 1, 2, 2, 0, 2, 1, 2, 0, 2, 2, 1,
0, 2, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1,
2, 0, 2, 2, 1, 0, 0, 1, 2, 1, 1, 0, 1, 2, 1,
2, 0, 1, 2, 1, 0, 1, 2, 2, 1, 0, 1, 1, 2, 1,
1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 1,
0, 2, 1, 2, 1, 1, 2, 1, 2, 1, 2, 2, 1, 2, 1,
2, 1, 2, 2, 1, 0, 2, 1, 2, 2, 1, 2, 1, 2, 2,
2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 0, 0, 0, 1, 2,
1, 0, 0, 1, 2, 2, 0, 0, 1, 2, 0, 0, 2, 1, 2,
0, 1, 0, 1, 2, 1, 1, 0, 1, 2, 2, 1, 0, 1, 2,
1, 0, 2, 1, 2, 0, 2, 0, 1, 2, 1, 2, 0, 1, 2,
2, 2, 0, 1, 2, 2, 0, 2, 1, 2, 0, 2, 2, 1, 2,
1, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 0, 2, 1, 2,
0, 0, 1, 1, 2, 1, 0, 1, 1, 2, 2, 0, 1, 1, 2,
0, 1, 2, 1, 2, 0, 1, 1, 1, 2, 1, 1, 1, 1, 2,
2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 0, 2, 1, 1, 2,
1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 2, 1, 2, 1, 2,
0, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 1, 2, 2, 2
};
private static ReadOnlySpan<byte> QuintEncodings => new byte[]
{
0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0,
0, 4, 0, 4, 4, 0, 4, 4, 4, 0, 1, 0, 1, 1, 0,
2, 1, 0, 3, 1, 0, 4, 1, 0, 1, 4, 0, 4, 4, 1,
4, 4, 4, 0, 2, 0, 1, 2, 0, 2, 2, 0, 3, 2, 0,
4, 2, 0, 2, 4, 0, 4, 4, 2, 4, 4, 4, 0, 3, 0,
1, 3, 0, 2, 3, 0, 3, 3, 0, 4, 3, 0, 3, 4, 0,
4, 4, 3, 4, 4, 4, 0, 0, 1, 1, 0, 1, 2, 0, 1,
3, 0, 1, 4, 0, 1, 0, 4, 1, 4, 0, 4, 0, 4, 4,
0, 1, 1, 1, 1, 1, 2, 1, 1, 3, 1, 1, 4, 1, 1,
1, 4, 1, 4, 1, 4, 1, 4, 4, 0, 2, 1, 1, 2, 1,
2, 2, 1, 3, 2, 1, 4, 2, 1, 2, 4, 1, 4, 2, 4,
2, 4, 4, 0, 3, 1, 1, 3, 1, 2, 3, 1, 3, 3, 1,
4, 3, 1, 3, 4, 1, 4, 3, 4, 3, 4, 4, 0, 0, 2,
1, 0, 2, 2, 0, 2, 3, 0, 2, 4, 0, 2, 0, 4, 2,
2, 0, 4, 3, 0, 4, 0, 1, 2, 1, 1, 2, 2, 1, 2,
3, 1, 2, 4, 1, 2, 1, 4, 2, 2, 1, 4, 3, 1, 4,
0, 2, 2, 1, 2, 2, 2, 2, 2, 3, 2, 2, 4, 2, 2,
2, 4, 2, 2, 2, 4, 3, 2, 4, 0, 3, 2, 1, 3, 2,
2, 3, 2, 3, 3, 2, 4, 3, 2, 3, 4, 2, 2, 3, 4,
3, 3, 4, 0, 0, 3, 1, 0, 3, 2, 0, 3, 3, 0, 3,
4, 0, 3, 0, 4, 3, 0, 0, 4, 1, 0, 4, 0, 1, 3,
1, 1, 3, 2, 1, 3, 3, 1, 3, 4, 1, 3, 1, 4, 3,
0, 1, 4, 1, 1, 4, 0, 2, 3, 1, 2, 3, 2, 2, 3,
3, 2, 3, 4, 2, 3, 2, 4, 3, 0, 2, 4, 1, 2, 4,
0, 3, 3, 1, 3, 3, 2, 3, 3, 3, 3, 3, 4, 3, 3,
3, 4, 3, 0, 3, 4, 1, 3, 4
};
}
}

31
Ryujinx.Graphics.Texture/Astc/IntegerSequence.cs Normal file
View file

@ -0,0 +1,31 @@
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Texture.Astc
{
[StructLayout(LayoutKind.Sequential, Size = IntegerEncoded.StructSize * Capacity + sizeof(int))]
internal struct IntegerSequence
{
private const int Capacity = 100;
private int _length;
private IntegerEncoded _start;
public Span<IntegerEncoded> List => MemoryMarshal.CreateSpan(ref _start, _length);
public void Reset() => _length = 0;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Add(ref IntegerEncoded item)
{
Debug.Assert(_length < Capacity);
int oldLength = _length;
_length++;
List[oldLength] = item;
}
}
}

1
Ryujinx.Graphics.Texture/Ryujinx.Graphics.Texture.csproj
View file

@ -6,6 +6,7 @@
<PropertyGroup>
<TargetFramework>netcoreapp3.0</TargetFramework>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
</Project>