Initial work

Ryujinx.Graphics.Texture/Astc/AstcDecoderException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.Graphics.Texture.Astc
+{
+    public class AstcDecoderException : Exception
+    {
+        public AstcDecoderException(string exMsg) : base(exMsg) { }
+    }
+}

Ryujinx.Graphics.Texture/Astc/AstcPixel.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Diagnostics;
+
+namespace Ryujinx.Graphics.Texture.Astc
+{
+    class AstcPixel
+    {
+        public short R { get; set; }
+        public short G { get; set; }
+        public short B { get; set; }
+        public short A { get; set; }
+
+        byte[] _bitDepth = new byte[4];
+
+        public AstcPixel(short a, short r, short g, short b)
+        {
+            A = a;
+            R = r;
+            G = g;
+            B = b;
+
+            for (int i = 0; i < 4; i++)
+                _bitDepth[i] = 8;
+        }
+
+        public void ClampByte()
+        {
+            R = Math.Min(Math.Max(R, (short)0), (short)255);
+            G = Math.Min(Math.Max(G, (short)0), (short)255);
+            B = Math.Min(Math.Max(B, (short)0), (short)255);
+            A = Math.Min(Math.Max(A, (short)0), (short)255);
+        }
+
+        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;
+        }
+
+        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);
+                }
+            }
+        }
+
+        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;
+        }
+
+        // Adds more precision to the blue channel as described
+        // in C.2.14
+        public static AstcPixel BlueContract(int a, int r, int g, int b)
+        {
+            return new AstcPixel((short)(a),
+                                 (short)((r + b) >> 1),
+                                 (short)((g + b) >> 1),
+                                 (short)(b));
+        }
+    }
+}

Ryujinx.Graphics.Texture/Astc/BitArrayStream.cs

@@ -0,0 +1,121 @@
+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;
+        }
+    }
+}

Ryujinx.Graphics.Texture/Astc/IntegerEncoded.cs

@@ -0,0 +1,269 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Texture.Astc
+{
+    public struct IntegerEncoded
+    {
+        public enum EIntegerEncoding
+        {
+            JustBits,
+            Quint,
+            Trit
+        }
+
+        EIntegerEncoding _encoding;
+        public int NumberBits { get; private set; }
+        public int BitValue   { get; private set; }
+        public int TritValue  { get; private set; }
+        public int QuintValue { get; private set; }
+
+        public IntegerEncoded(EIntegerEncoding encoding, int numBits)
+        {
+            _encoding  = encoding;
+            NumberBits = numBits;
+            BitValue   = 0;
+            TritValue  = 0;
+            QuintValue = 0;
+        }
+
+        public bool MatchesEncoding(IntegerEncoded other)
+        {
+            return _encoding == other._encoding && NumberBits == other.NumberBits;
+        }
+
+        public EIntegerEncoding GetEncoding()
+        {
+            return _encoding;
+        }
+
+        public int GetBitLength(int numberVals)
+        {
+            int totalBits = NumberBits * numberVals;
+            if (_encoding == EIntegerEncoding.Trit)
+            {
+                totalBits += (numberVals * 8 + 4) / 5;
+            }
+            else if (_encoding == EIntegerEncoding.Quint)
+            {
+                totalBits += (numberVals * 7 + 2) / 3;
+            }
+            return totalBits;
+        }
+
+        public static IntegerEncoded CreateEncoding(int maxVal)
+        {
+            while (maxVal > 0)
+            {
+                int check = maxVal + 1;
+
+                // Is maxVal a power of two?
+                if ((check & (check - 1)) == 0)
+                {
+                    return new IntegerEncoded(EIntegerEncoding.JustBits, BitArrayStream.PopCnt(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));
+                }
+
+                // 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));
+                }
+
+                // Apparently it can't be represented with a bounded integer sequence...
+                // just iterate.
+                maxVal--;
+            }
+
+            return new IntegerEncoded(EIntegerEncoding.JustBits, 0);
+        }
+
+        public static void DecodeTritBlock(
+            BitArrayStream       bitStream,
+            List<IntegerEncoded> listIntegerEncoded,
+            int                  numberBitsPerValue)
+        {
+            // Implement the algorithm in section C.2.12
+            int[] m = new int[5];
+            int[] t = new int[5];
+            int T;
+
+            // Read the trit encoded block according to
+            // table C.2.14
+            m[0] = bitStream.ReadBits(numberBitsPerValue);
+            T    = bitStream.ReadBits(2);
+            m[1] = bitStream.ReadBits(numberBitsPerValue);
+            T   |= bitStream.ReadBits(2) << 2;
+            m[2] = bitStream.ReadBits(numberBitsPerValue);
+            T   |= bitStream.ReadBits(1) << 4;
+            m[3] = bitStream.ReadBits(numberBitsPerValue);
+            T   |= bitStream.ReadBits(2) << 5;
+            m[4] = bitStream.ReadBits(numberBitsPerValue);
+            T   |= bitStream.ReadBits(1) << 7;
+
+            int c = 0;
+
+            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));
+            }
+
+            for (int i = 0; i < 5; i++)
+            {
+                IntegerEncoded intEncoded = new IntegerEncoded(EIntegerEncoding.Trit, numberBitsPerValue)
+                {
+                    BitValue  = m[i],
+                    TritValue = t[i]
+                };
+                listIntegerEncoded.Add(intEncoded);
+            }
+        }
+
+        public static void DecodeQuintBlock(
+            BitArrayStream       bitStream,
+            List<IntegerEncoded> listIntegerEncoded,
+            int                  numberBitsPerValue)
+        {
+            // Implement the algorithm in section C.2.12
+            int[] m = new int[3];
+            int[] qa = new int[3];
+            int q;
+
+            // 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;
+
+            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);
+                }
+
+                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);
+                }
+            }
+
+            for (int i = 0; i < 3; i++)
+            {
+                IntegerEncoded intEncoded = new IntegerEncoded(EIntegerEncoding.Quint, numberBitsPerValue)
+                {
+                    BitValue   = m[i],
+                    QuintValue = qa[i]
+                };
+                listIntegerEncoded.Add(intEncoded);
+            }
+        }
+
+        public static void DecodeIntegerSequence(
+            List<IntegerEncoded> decodeIntegerSequence,
+            BitArrayStream       bitStream,
+            int                  maxRange,
+            int                  numberValues)
+        {
+            // Determine encoding parameters
+            IntegerEncoded intEncoded = CreateEncoding(maxRange);
+
+            // Start decoding
+            int numberValuesDecoded = 0;
+            while (numberValuesDecoded < numberValues)
+            {
+                switch (intEncoded.GetEncoding())
+                {
+                    case EIntegerEncoding.Quint:
+                    {
+                        DecodeQuintBlock(bitStream, decodeIntegerSequence, intEncoded.NumberBits);
+                        numberValuesDecoded += 3;
+
+                        break;
+                    }
+
+                    case EIntegerEncoding.Trit:
+                    {
+                        DecodeTritBlock(bitStream, decodeIntegerSequence, intEncoded.NumberBits);
+                        numberValuesDecoded += 5;
+
+                        break;
+                    }
+
+                    case EIntegerEncoding.JustBits:
+                    {
+                        intEncoded.BitValue = bitStream.ReadBits(intEncoded.NumberBits);
+                        decodeIntegerSequence.Add(intEncoded);
+                        numberValuesDecoded++;
+
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}