Ryujinx/Ryujinx.Graphics.Texture/Utils/BC67Utils.cs

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

namespace Ryujinx.Graphics.Texture.Utils
{
    static class BC67Utils
    {
        private static byte[][] _quantizationLut;
        private static byte[][] _quantizationLutNoPBit;

        static BC67Utils()
        {
            _quantizationLut = new byte[5][];
            _quantizationLutNoPBit = new byte[5][];

            for (int depth = 4; depth < 9; depth++)
            {
                byte[] lut = new byte[512];
                byte[] lutNoPBit = new byte[256];

                for (int i = 0; i < lut.Length; i++)
                {
                    lut[i] = QuantizeComponentForLut((byte)i, depth, i >> 8);

                    if (i < lutNoPBit.Length)
                    {
                        lutNoPBit[i] = QuantizeComponentForLut((byte)i, depth);
                    }
                }

                _quantizationLut[depth - 4] = lut;
                _quantizationLutNoPBit[depth - 4] = lutNoPBit;
            }
        }

        public static (RgbaColor8, RgbaColor8) GetMinMaxColors(ReadOnlySpan<uint> tile, int w, int h)
        {
            if (Sse41.IsSupported && w == 4 && h == 4)
            {
                GetMinMaxColorsOneSubset4x4Sse41(tile, out RgbaColor8 minColor, out RgbaColor8 maxColor);

                return (minColor, maxColor);
            }
            else
            {
                RgbaColor8 minColor = new RgbaColor8(255, 255, 255, 255);
                RgbaColor8 maxColor = default;

                for (int i = 0; i < tile.Length; i++)
                {
                    RgbaColor8 color = RgbaColor8.FromUInt32(tile[i]);

                    minColor.R = Math.Min(minColor.R, color.R);
                    minColor.G = Math.Min(minColor.G, color.G);
                    minColor.B = Math.Min(minColor.B, color.B);
                    minColor.A = Math.Min(minColor.A, color.A);

                    maxColor.R = Math.Max(maxColor.R, color.R);
                    maxColor.G = Math.Max(maxColor.G, color.G);
                    maxColor.B = Math.Max(maxColor.B, color.B);
                    maxColor.A = Math.Max(maxColor.A, color.A);
                }

                return (minColor, maxColor);
            }
        }

        public static void GetMinMaxColors(
            ReadOnlySpan<byte> partitionTable,
            ReadOnlySpan<uint> tile,
            int w,
            int h,
            Span<RgbaColor8> minColors,
            Span<RgbaColor8> maxColors,
            int subsetCount)
        {
            if (Sse41.IsSupported && w == 4 && h == 4)
            {
                if (subsetCount == 1)
                {
                    GetMinMaxColorsOneSubset4x4Sse41(tile, out minColors[0], out maxColors[0]);
                    return;
                }
                else if (subsetCount == 2)
                {
                    GetMinMaxColorsTwoSubsets4x4Sse41(partitionTable, tile, minColors, maxColors);
                    return;
                }
            }

            minColors.Fill(new RgbaColor8(255, 255, 255, 255));

            int i = 0;
            for (int ty = 0; ty < h; ty++)
            {
                for (int tx = 0; tx < w; tx++)
                {
                    int subset = partitionTable[ty * w + tx];
                    RgbaColor8 color = RgbaColor8.FromUInt32(tile[i++]);

                    minColors[subset].R = Math.Min(minColors[subset].R, color.R);
                    minColors[subset].G = Math.Min(minColors[subset].G, color.G);
                    minColors[subset].B = Math.Min(minColors[subset].B, color.B);
                    minColors[subset].A = Math.Min(minColors[subset].A, color.A);

                    maxColors[subset].R = Math.Max(maxColors[subset].R, color.R);
                    maxColors[subset].G = Math.Max(maxColors[subset].G, color.G);
                    maxColors[subset].B = Math.Max(maxColors[subset].B, color.B);
                    maxColors[subset].A = Math.Max(maxColors[subset].A, color.A);
                }
            }
        }

        private static unsafe void GetMinMaxColorsOneSubset4x4Sse41(ReadOnlySpan<uint> tile, out RgbaColor8 minColor, out RgbaColor8 maxColor)
        {
            Vector128<byte> min = Vector128<byte>.AllBitsSet;
            Vector128<byte> max = Vector128<byte>.Zero;
            Vector128<byte> row0, row1, row2, row3;

            fixed (uint* pTile = tile)
            {
                row0 = Sse2.LoadVector128(pTile).AsByte();
                row1 = Sse2.LoadVector128(pTile + 4).AsByte();
                row2 = Sse2.LoadVector128(pTile + 8).AsByte();
                row3 = Sse2.LoadVector128(pTile + 12).AsByte();
            }

            min = Sse2.Min(min, row0);
            max = Sse2.Max(max, row0);
            min = Sse2.Min(min, row1);
            max = Sse2.Max(max, row1);
            min = Sse2.Min(min, row2);
            max = Sse2.Max(max, row2);
            min = Sse2.Min(min, row3);
            max = Sse2.Max(max, row3);

            minColor = HorizontalMin(min);
            maxColor = HorizontalMax(max);
        }

        private static unsafe void GetMinMaxColorsTwoSubsets4x4Sse41(
            ReadOnlySpan<byte> partitionTable,
            ReadOnlySpan<uint> tile,
            Span<RgbaColor8> minColors,
            Span<RgbaColor8> maxColors)
        {
            Vector128<byte> partitionMask;

            fixed (byte* pPartitionTable = partitionTable)
            {
                partitionMask = Sse2.LoadVector128(pPartitionTable);
            }

            Vector128<byte> subset0Mask = Sse2.CompareEqual(partitionMask, Vector128<byte>.Zero);

            Vector128<byte> subset0MaskRep16Low = Sse2.UnpackLow(subset0Mask, subset0Mask);
            Vector128<byte> subset0MaskRep16High = Sse2.UnpackHigh(subset0Mask, subset0Mask);

            Vector128<byte> subset0Mask0 = Sse2.UnpackLow(subset0MaskRep16Low.AsInt16(), subset0MaskRep16Low.AsInt16()).AsByte();
            Vector128<byte> subset0Mask1 = Sse2.UnpackHigh(subset0MaskRep16Low.AsInt16(), subset0MaskRep16Low.AsInt16()).AsByte();
            Vector128<byte> subset0Mask2 = Sse2.UnpackLow(subset0MaskRep16High.AsInt16(), subset0MaskRep16High.AsInt16()).AsByte();
            Vector128<byte> subset0Mask3 = Sse2.UnpackHigh(subset0MaskRep16High.AsInt16(), subset0MaskRep16High.AsInt16()).AsByte();

            Vector128<byte> min0 = Vector128<byte>.AllBitsSet;
            Vector128<byte> min1 = Vector128<byte>.AllBitsSet;
            Vector128<byte> max0 = Vector128<byte>.Zero;
            Vector128<byte> max1 = Vector128<byte>.Zero;

            Vector128<byte> row0, row1, row2, row3;

            fixed (uint* pTile = tile)
            {
                row0 = Sse2.LoadVector128(pTile).AsByte();
                row1 = Sse2.LoadVector128(pTile + 4).AsByte();
                row2 = Sse2.LoadVector128(pTile + 8).AsByte();
                row3 = Sse2.LoadVector128(pTile + 12).AsByte();
            }

            min0 = Sse2.Min(min0, Sse41.BlendVariable(min0, row0, subset0Mask0));
            min0 = Sse2.Min(min0, Sse41.BlendVariable(min0, row1, subset0Mask1));
            min0 = Sse2.Min(min0, Sse41.BlendVariable(min0, row2, subset0Mask2));
            min0 = Sse2.Min(min0, Sse41.BlendVariable(min0, row3, subset0Mask3));

            min1 = Sse2.Min(min1, Sse2.Or(row0, subset0Mask0));
            min1 = Sse2.Min(min1, Sse2.Or(row1, subset0Mask1));
            min1 = Sse2.Min(min1, Sse2.Or(row2, subset0Mask2));
            min1 = Sse2.Min(min1, Sse2.Or(row3, subset0Mask3));

            max0 = Sse2.Max(max0, Sse2.And(row0, subset0Mask0));
            max0 = Sse2.Max(max0, Sse2.And(row1, subset0Mask1));
            max0 = Sse2.Max(max0, Sse2.And(row2, subset0Mask2));
            max0 = Sse2.Max(max0, Sse2.And(row3, subset0Mask3));

            max1 = Sse2.Max(max1, Sse2.AndNot(subset0Mask0, row0));
            max1 = Sse2.Max(max1, Sse2.AndNot(subset0Mask1, row1));
            max1 = Sse2.Max(max1, Sse2.AndNot(subset0Mask2, row2));
            max1 = Sse2.Max(max1, Sse2.AndNot(subset0Mask3, row3));

            minColors[0] = HorizontalMin(min0);
            minColors[1] = HorizontalMin(min1);
            maxColors[0] = HorizontalMax(max0);
            maxColors[1] = HorizontalMax(max1);
        }

        private static RgbaColor8 HorizontalMin(Vector128<byte> x)
        {
            x = Sse2.Min(x, Sse2.Shuffle(x.AsInt32(), 0x31).AsByte());
            x = Sse2.Min(x, Sse2.Shuffle(x.AsInt32(), 2).AsByte());
            return RgbaColor8.FromUInt32(x.AsUInt32().GetElement(0));
        }

        private static RgbaColor8 HorizontalMax(Vector128<byte> x)
        {
            x = Sse2.Max(x, Sse2.Shuffle(x.AsInt32(), 0x31).AsByte());
            x = Sse2.Max(x, Sse2.Shuffle(x.AsInt32(), 2).AsByte());
            return RgbaColor8.FromUInt32(x.AsUInt32().GetElement(0));
        }

        public static int SelectIndices(
            ReadOnlySpan<uint> values,
            uint endPoint0,
            uint endPoint1,
            int pBit0,
            int pBit1,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            uint alphaMask)
        {
            if (Sse41.IsSupported)
            {
                if (indexBitCount == 2)
                {
                    return Select2BitIndicesSse41(
                        values,
                        endPoint0,
                        endPoint1,
                        pBit0,
                        pBit1,
                        indexBitCount,
                        indexCount,
                        colorDepth,
                        alphaDepth,
                        alphaMask);
                }
                else if (indexBitCount == 3)
                {
                    return Select3BitIndicesSse41(
                        values,
                        endPoint0,
                        endPoint1,
                        pBit0,
                        pBit1,
                        indexBitCount,
                        indexCount,
                        colorDepth,
                        alphaDepth,
                        alphaMask);
                }
                else if (indexBitCount == 4)
                {
                    return Select4BitIndicesOneSubsetSse41(
                        values,
                        endPoint0,
                        endPoint1,
                        pBit0,
                        pBit1,
                        indexBitCount,
                        indexCount,
                        colorDepth,
                        alphaDepth,
                        alphaMask);
                }
            }

            return SelectIndicesFallback(
                values,
                endPoint0,
                endPoint1,
                pBit0,
                pBit1,
                indexBitCount,
                indexCount,
                colorDepth,
                alphaDepth,
                alphaMask);
        }

        private static unsafe int Select2BitIndicesSse41(
            ReadOnlySpan<uint> values,
            uint endPoint0,
            uint endPoint1,
            int pBit0,
            int pBit1,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            uint alphaMask)
        {
            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            int errorSum = 0;

            RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoint0), colorDepth, alphaDepth, pBit0);
            RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoint1), colorDepth, alphaDepth, pBit1);

            Vector128<byte> c0Rep = Vector128.Create(c0.ToUInt32() | alphaMaskForPalette).AsByte();
            Vector128<byte> c1Rep = Vector128.Create(c1.ToUInt32() | alphaMaskForPalette).AsByte();

            Vector128<byte> c0c1 = Sse2.UnpackLow(c0Rep, c1Rep);

            Vector128<byte> rWeights;
            Vector128<byte> lWeights;

            fixed (byte* pWeights = BC67Tables.Weights[0], pInvWeights = BC67Tables.InverseWeights[0])
            {
                rWeights = Sse2.LoadScalarVector128((uint*)pWeights).AsByte();
                lWeights = Sse2.LoadScalarVector128((uint*)pInvWeights).AsByte();
            }

            Vector128<byte> iWeights = Sse2.UnpackLow(lWeights, rWeights);
            Vector128<byte> iWeights01 = Sse2.UnpackLow(iWeights.AsInt16(), iWeights.AsInt16()).AsByte();
            Vector128<byte> iWeights0 = Sse2.UnpackLow(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights1 = Sse2.UnpackHigh(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();

            Vector128<short> pal0 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights0.AsSByte()));
            Vector128<short> pal1 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights1.AsSByte()));

            for (int i = 0; i < values.Length; i++)
            {
                uint c = values[i] | alphaMask;

                Vector128<short> color = Sse41.ConvertToVector128Int16(Vector128.Create(c).AsByte());

                Vector128<short> delta0 = Sse2.Subtract(color, pal0);
                Vector128<short> delta1 = Sse2.Subtract(color, pal1);

                Vector128<int> deltaSum0 = Sse2.MultiplyAddAdjacent(delta0, delta0);
                Vector128<int> deltaSum1 = Sse2.MultiplyAddAdjacent(delta1, delta1);

                Vector128<int> deltaSum01 = Ssse3.HorizontalAdd(deltaSum0, deltaSum1);

                Vector128<ushort> delta = Sse41.PackUnsignedSaturate(deltaSum01, deltaSum01);

                Vector128<ushort> min = Sse41.MinHorizontal(delta);

                ushort error = min.GetElement(0);

                errorSum += error;
            }

            return errorSum;
        }

        private static unsafe int Select3BitIndicesSse41(
            ReadOnlySpan<uint> values,
            uint endPoint0,
            uint endPoint1,
            int pBit0,
            int pBit1,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            uint alphaMask)
        {
            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            int errorSum = 0;

            RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoint0), colorDepth, alphaDepth, pBit0);
            RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoint1), colorDepth, alphaDepth, pBit1);

            Vector128<byte> c0Rep = Vector128.Create(c0.ToUInt32() | alphaMaskForPalette).AsByte();
            Vector128<byte> c1Rep = Vector128.Create(c1.ToUInt32() | alphaMaskForPalette).AsByte();

            Vector128<byte> c0c1 = Sse2.UnpackLow(c0Rep, c1Rep);

            Vector128<byte> rWeights;
            Vector128<byte> lWeights;

            fixed (byte* pWeights = BC67Tables.Weights[1], pInvWeights = BC67Tables.InverseWeights[1])
            {
                rWeights = Sse2.LoadScalarVector128((ulong*)pWeights).AsByte();
                lWeights = Sse2.LoadScalarVector128((ulong*)pInvWeights).AsByte();
            }

            Vector128<byte> iWeights = Sse2.UnpackLow(lWeights, rWeights);
            Vector128<byte> iWeights01 = Sse2.UnpackLow(iWeights.AsInt16(), iWeights.AsInt16()).AsByte();
            Vector128<byte> iWeights23 = Sse2.UnpackHigh(iWeights.AsInt16(), iWeights.AsInt16()).AsByte();
            Vector128<byte> iWeights0 = Sse2.UnpackLow(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights1 = Sse2.UnpackHigh(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights2 = Sse2.UnpackLow(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();
            Vector128<byte> iWeights3 = Sse2.UnpackHigh(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();

            Vector128<short> pal0 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights0.AsSByte()));
            Vector128<short> pal1 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights1.AsSByte()));
            Vector128<short> pal2 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights2.AsSByte()));
            Vector128<short> pal3 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights3.AsSByte()));

            for (int i = 0; i < values.Length; i++)
            {
                uint c = values[i] | alphaMask;

                Vector128<short> color = Sse41.ConvertToVector128Int16(Vector128.Create(c).AsByte());

                Vector128<short> delta0 = Sse2.Subtract(color, pal0);
                Vector128<short> delta1 = Sse2.Subtract(color, pal1);
                Vector128<short> delta2 = Sse2.Subtract(color, pal2);
                Vector128<short> delta3 = Sse2.Subtract(color, pal3);

                Vector128<int> deltaSum0 = Sse2.MultiplyAddAdjacent(delta0, delta0);
                Vector128<int> deltaSum1 = Sse2.MultiplyAddAdjacent(delta1, delta1);
                Vector128<int> deltaSum2 = Sse2.MultiplyAddAdjacent(delta2, delta2);
                Vector128<int> deltaSum3 = Sse2.MultiplyAddAdjacent(delta3, delta3);

                Vector128<int> deltaSum01 = Ssse3.HorizontalAdd(deltaSum0, deltaSum1);
                Vector128<int> deltaSum23 = Ssse3.HorizontalAdd(deltaSum2, deltaSum3);

                Vector128<ushort> delta = Sse41.PackUnsignedSaturate(deltaSum01, deltaSum23);

                Vector128<ushort> min = Sse41.MinHorizontal(delta);

                ushort error = min.GetElement(0);

                errorSum += error;
            }

            return errorSum;
        }

        private static unsafe int Select4BitIndicesOneSubsetSse41(
            ReadOnlySpan<uint> values,
            uint endPoint0,
            uint endPoint1,
            int pBit0,
            int pBit1,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            uint alphaMask)
        {
            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            int errorSum = 0;

            RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoint0), colorDepth, alphaDepth, pBit0);
            RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoint1), colorDepth, alphaDepth, pBit1);

            Vector128<byte> c0Rep = Vector128.Create(c0.ToUInt32() | alphaMaskForPalette).AsByte();
            Vector128<byte> c1Rep = Vector128.Create(c1.ToUInt32() | alphaMaskForPalette).AsByte();

            Vector128<byte> c0c1 = Sse2.UnpackLow(c0Rep, c1Rep);

            Vector128<byte> rWeights;
            Vector128<byte> lWeights;

            fixed (byte* pWeights = BC67Tables.Weights[2], pInvWeights = BC67Tables.InverseWeights[2])
            {
                rWeights = Sse2.LoadVector128(pWeights);
                lWeights = Sse2.LoadVector128(pInvWeights);
            }

            Vector128<byte> iWeightsLow = Sse2.UnpackLow(lWeights, rWeights);
            Vector128<byte> iWeightsHigh = Sse2.UnpackHigh(lWeights, rWeights);
            Vector128<byte> iWeights01 = Sse2.UnpackLow(iWeightsLow.AsInt16(), iWeightsLow.AsInt16()).AsByte();
            Vector128<byte> iWeights23 = Sse2.UnpackHigh(iWeightsLow.AsInt16(), iWeightsLow.AsInt16()).AsByte();
            Vector128<byte> iWeights45 = Sse2.UnpackLow(iWeightsHigh.AsInt16(), iWeightsHigh.AsInt16()).AsByte();
            Vector128<byte> iWeights67 = Sse2.UnpackHigh(iWeightsHigh.AsInt16(), iWeightsHigh.AsInt16()).AsByte();
            Vector128<byte> iWeights0 = Sse2.UnpackLow(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights1 = Sse2.UnpackHigh(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights2 = Sse2.UnpackLow(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();
            Vector128<byte> iWeights3 = Sse2.UnpackHigh(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();
            Vector128<byte> iWeights4 = Sse2.UnpackLow(iWeights45.AsInt16(), iWeights45.AsInt16()).AsByte();
            Vector128<byte> iWeights5 = Sse2.UnpackHigh(iWeights45.AsInt16(), iWeights45.AsInt16()).AsByte();
            Vector128<byte> iWeights6 = Sse2.UnpackLow(iWeights67.AsInt16(), iWeights67.AsInt16()).AsByte();
            Vector128<byte> iWeights7 = Sse2.UnpackHigh(iWeights67.AsInt16(), iWeights67.AsInt16()).AsByte();

            Vector128<short> pal0 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights0.AsSByte()));
            Vector128<short> pal1 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights1.AsSByte()));
            Vector128<short> pal2 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights2.AsSByte()));
            Vector128<short> pal3 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights3.AsSByte()));
            Vector128<short> pal4 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights4.AsSByte()));
            Vector128<short> pal5 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights5.AsSByte()));
            Vector128<short> pal6 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights6.AsSByte()));
            Vector128<short> pal7 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights7.AsSByte()));

            for (int i = 0; i < values.Length; i++)
            {
                uint c = values[i] | alphaMask;

                Vector128<short> color = Sse41.ConvertToVector128Int16(Vector128.Create(c).AsByte());

                Vector128<short> delta0 = Sse2.Subtract(color, pal0);
                Vector128<short> delta1 = Sse2.Subtract(color, pal1);
                Vector128<short> delta2 = Sse2.Subtract(color, pal2);
                Vector128<short> delta3 = Sse2.Subtract(color, pal3);
                Vector128<short> delta4 = Sse2.Subtract(color, pal4);
                Vector128<short> delta5 = Sse2.Subtract(color, pal5);
                Vector128<short> delta6 = Sse2.Subtract(color, pal6);
                Vector128<short> delta7 = Sse2.Subtract(color, pal7);

                Vector128<int> deltaSum0 = Sse2.MultiplyAddAdjacent(delta0, delta0);
                Vector128<int> deltaSum1 = Sse2.MultiplyAddAdjacent(delta1, delta1);
                Vector128<int> deltaSum2 = Sse2.MultiplyAddAdjacent(delta2, delta2);
                Vector128<int> deltaSum3 = Sse2.MultiplyAddAdjacent(delta3, delta3);
                Vector128<int> deltaSum4 = Sse2.MultiplyAddAdjacent(delta4, delta4);
                Vector128<int> deltaSum5 = Sse2.MultiplyAddAdjacent(delta5, delta5);
                Vector128<int> deltaSum6 = Sse2.MultiplyAddAdjacent(delta6, delta6);
                Vector128<int> deltaSum7 = Sse2.MultiplyAddAdjacent(delta7, delta7);

                Vector128<int> deltaSum01 = Ssse3.HorizontalAdd(deltaSum0, deltaSum1);
                Vector128<int> deltaSum23 = Ssse3.HorizontalAdd(deltaSum2, deltaSum3);
                Vector128<int> deltaSum45 = Ssse3.HorizontalAdd(deltaSum4, deltaSum5);
                Vector128<int> deltaSum67 = Ssse3.HorizontalAdd(deltaSum6, deltaSum7);

                Vector128<ushort> delta0123 = Sse41.PackUnsignedSaturate(deltaSum01, deltaSum23);
                Vector128<ushort> delta4567 = Sse41.PackUnsignedSaturate(deltaSum45, deltaSum67);

                Vector128<ushort> min0123 = Sse41.MinHorizontal(delta0123);
                Vector128<ushort> min4567 = Sse41.MinHorizontal(delta4567);

                ushort minPos0123 = min0123.GetElement(0);
                ushort minPos4567 = min4567.GetElement(0);

                if (minPos4567 < minPos0123)
                {
                    errorSum += minPos4567;
                }
                else
                {
                    errorSum += minPos0123;
                }
            }

            return errorSum;
        }

        private static int SelectIndicesFallback(
            ReadOnlySpan<uint> values,
            uint endPoint0,
            uint endPoint1,
            int pBit0,
            int pBit1,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            uint alphaMask)
        {
            int errorSum = 0;

            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            Span<uint> palette = stackalloc uint[indexCount];

            RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoint0), colorDepth, alphaDepth, pBit0);
            RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoint1), colorDepth, alphaDepth, pBit1);

            Unsafe.As<RgbaColor8, uint>(ref c0) |= alphaMaskForPalette;
            Unsafe.As<RgbaColor8, uint>(ref c1) |= alphaMaskForPalette;

            palette[0] = c0.ToUInt32();
            palette[indexCount - 1] = c1.ToUInt32();

            for (int j = 1; j < indexCount - 1; j++)
            {
                palette[j] = Interpolate(c0, c1, j, indexBitCount).ToUInt32();
            }

            for (int i = 0; i < values.Length; i++)
            {
                uint color = values[i] | alphaMask;

                int bestMatchScore = int.MaxValue;
                int bestMatchIndex = 0;

                for (int j = 0; j < indexCount; j++)
                {
                    int score = SquaredDifference(
                        RgbaColor8.FromUInt32(color).GetColor32(),
                        RgbaColor8.FromUInt32(palette[j]).GetColor32());

                    if (score < bestMatchScore)
                    {
                        bestMatchScore = score;
                        bestMatchIndex = j;
                    }
                }

                errorSum += bestMatchScore;
            }

            return errorSum;
        }

        public static int SelectIndices(
            ReadOnlySpan<uint> tile,
            int w,
            int h,
            ReadOnlySpan<uint> endPoints0,
            ReadOnlySpan<uint> endPoints1,
            ReadOnlySpan<int> pBitValues,
            Span<byte> indices,
            int subsetCount,
            int partition,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            int pBits,
            uint alphaMask)
        {
            if (Sse41.IsSupported)
            {
                if (indexBitCount == 2)
                {
                    return Select2BitIndicesSse41(
                        tile,
                        w,
                        h,
                        endPoints0,
                        endPoints1,
                        pBitValues,
                        indices,
                        subsetCount,
                        partition,
                        colorDepth,
                        alphaDepth,
                        pBits,
                        alphaMask);
                }
                else if (indexBitCount == 3)
                {
                    return Select3BitIndicesSse41(
                        tile,
                        w,
                        h,
                        endPoints0,
                        endPoints1,
                        pBitValues,
                        indices,
                        subsetCount,
                        partition,
                        colorDepth,
                        alphaDepth,
                        pBits,
                        alphaMask);
                }
                else if (indexBitCount == 4)
                {
                    Debug.Assert(subsetCount == 1);

                    return Select4BitIndicesOneSubsetSse41(
                        tile,
                        w,
                        h,
                        endPoints0[0],
                        endPoints1[0],
                        pBitValues,
                        indices,
                        partition,
                        colorDepth,
                        alphaDepth,
                        pBits,
                        alphaMask);
                }
            }

            return SelectIndicesFallback(
                tile,
                w,
                h,
                endPoints0,
                endPoints1,
                pBitValues,
                indices,
                subsetCount,
                partition,
                indexBitCount,
                indexCount,
                colorDepth,
                alphaDepth,
                pBits,
                alphaMask);
        }

        private static unsafe int Select2BitIndicesSse41(
            ReadOnlySpan<uint> tile,
            int w,
            int h,
            ReadOnlySpan<uint> endPoints0,
            ReadOnlySpan<uint> endPoints1,
            ReadOnlySpan<int> pBitValues,
            Span<byte> indices,
            int subsetCount,
            int partition,
            int colorDepth,
            int alphaDepth,
            int pBits,
            uint alphaMask)
        {
            byte[] partitionTable = BC67Tables.PartitionTable[subsetCount - 1][partition];

            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            int errorSum = 0;

            for (int subset = 0; subset < subsetCount; subset++)
            {
                int pBit0 = -1, pBit1 = -1;

                if (pBits == subsetCount)
                {
                    pBit0 = pBit1 = pBitValues[subset];
                }
                else if (pBits != 0)
                {
                    pBit0 = pBitValues[subset * 2];
                    pBit1 = pBitValues[subset * 2 + 1];
                }

                RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoints0[subset]), colorDepth, alphaDepth, pBit0);
                RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoints1[subset]), colorDepth, alphaDepth, pBit1);

                Vector128<byte> c0Rep = Vector128.Create(c0.ToUInt32() | alphaMaskForPalette).AsByte();
                Vector128<byte> c1Rep = Vector128.Create(c1.ToUInt32() | alphaMaskForPalette).AsByte();

                Vector128<byte> c0c1 = Sse2.UnpackLow(c0Rep, c1Rep);

                Vector128<byte> rWeights;
                Vector128<byte> lWeights;

                fixed (byte* pWeights = BC67Tables.Weights[0], pInvWeights = BC67Tables.InverseWeights[0])
                {
                    rWeights = Sse2.LoadScalarVector128((uint*)pWeights).AsByte();
                    lWeights = Sse2.LoadScalarVector128((uint*)pInvWeights).AsByte();
                }

                Vector128<byte> iWeights = Sse2.UnpackLow(lWeights, rWeights);
                Vector128<byte> iWeights01 = Sse2.UnpackLow(iWeights.AsInt16(), iWeights.AsInt16()).AsByte();
                Vector128<byte> iWeights0 = Sse2.UnpackLow(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
                Vector128<byte> iWeights1 = Sse2.UnpackHigh(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();

                Vector128<short> pal0 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights0.AsSByte()));
                Vector128<short> pal1 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights1.AsSByte()));

                int i = 0;
                for (int ty = 0; ty < h; ty++)
                {
                    for (int tx = 0; tx < w; tx++, i++)
                    {
                        int tileOffset = ty * 4 + tx;
                        if (partitionTable[tileOffset] != subset)
                        {
                            continue;
                        }

                        uint c = tile[i] | alphaMask;

                        Vector128<short> color = Sse41.ConvertToVector128Int16(Vector128.Create(c).AsByte());

                        Vector128<short> delta0 = Sse2.Subtract(color, pal0);
                        Vector128<short> delta1 = Sse2.Subtract(color, pal1);

                        Vector128<int> deltaSum0 = Sse2.MultiplyAddAdjacent(delta0, delta0);
                        Vector128<int> deltaSum1 = Sse2.MultiplyAddAdjacent(delta1, delta1);

                        Vector128<int> deltaSum01 = Ssse3.HorizontalAdd(deltaSum0, deltaSum1);

                        Vector128<ushort> delta = Sse41.PackUnsignedSaturate(deltaSum01, deltaSum01);

                        Vector128<ushort> min = Sse41.MinHorizontal(delta);

                        uint minPos = min.AsUInt32().GetElement(0);
                        ushort error = (ushort)minPos;
                        uint index = minPos >> 16;

                        indices[tileOffset] = (byte)index;
                        errorSum += error;
                    }
                }
            }

            return errorSum;
        }

        private static unsafe int Select3BitIndicesSse41(
            ReadOnlySpan<uint> tile,
            int w,
            int h,
            ReadOnlySpan<uint> endPoints0,
            ReadOnlySpan<uint> endPoints1,
            ReadOnlySpan<int> pBitValues,
            Span<byte> indices,
            int subsetCount,
            int partition,
            int colorDepth,
            int alphaDepth,
            int pBits,
            uint alphaMask)
        {
            byte[] partitionTable = BC67Tables.PartitionTable[subsetCount - 1][partition];

            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            int errorSum = 0;

            for (int subset = 0; subset < subsetCount; subset++)
            {
                int pBit0 = -1, pBit1 = -1;

                if (pBits == subsetCount)
                {
                    pBit0 = pBit1 = pBitValues[subset];
                }
                else if (pBits != 0)
                {
                    pBit0 = pBitValues[subset * 2];
                    pBit1 = pBitValues[subset * 2 + 1];
                }

                RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoints0[subset]), colorDepth, alphaDepth, pBit0);
                RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoints1[subset]), colorDepth, alphaDepth, pBit1);

                Vector128<byte> c0Rep = Vector128.Create(c0.ToUInt32() | alphaMaskForPalette).AsByte();
                Vector128<byte> c1Rep = Vector128.Create(c1.ToUInt32() | alphaMaskForPalette).AsByte();

                Vector128<byte> c0c1 = Sse2.UnpackLow(c0Rep, c1Rep);

                Vector128<byte> rWeights;
                Vector128<byte> lWeights;

                fixed (byte* pWeights = BC67Tables.Weights[1], pInvWeights = BC67Tables.InverseWeights[1])
                {
                    rWeights = Sse2.LoadScalarVector128((ulong*)pWeights).AsByte();
                    lWeights = Sse2.LoadScalarVector128((ulong*)pInvWeights).AsByte();
                }

                Vector128<byte> iWeights = Sse2.UnpackLow(lWeights, rWeights);
                Vector128<byte> iWeights01 = Sse2.UnpackLow(iWeights.AsInt16(), iWeights.AsInt16()).AsByte();
                Vector128<byte> iWeights23 = Sse2.UnpackHigh(iWeights.AsInt16(), iWeights.AsInt16()).AsByte();
                Vector128<byte> iWeights0 = Sse2.UnpackLow(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
                Vector128<byte> iWeights1 = Sse2.UnpackHigh(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
                Vector128<byte> iWeights2 = Sse2.UnpackLow(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();
                Vector128<byte> iWeights3 = Sse2.UnpackHigh(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();

                Vector128<short> pal0 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights0.AsSByte()));
                Vector128<short> pal1 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights1.AsSByte()));
                Vector128<short> pal2 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights2.AsSByte()));
                Vector128<short> pal3 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights3.AsSByte()));

                int i = 0;
                for (int ty = 0; ty < h; ty++)
                {
                    for (int tx = 0; tx < w; tx++, i++)
                    {
                        int tileOffset = ty * 4 + tx;
                        if (partitionTable[tileOffset] != subset)
                        {
                            continue;
                        }

                        uint c = tile[i] | alphaMask;

                        Vector128<short> color = Sse41.ConvertToVector128Int16(Vector128.Create(c).AsByte());

                        Vector128<short> delta0 = Sse2.Subtract(color, pal0);
                        Vector128<short> delta1 = Sse2.Subtract(color, pal1);
                        Vector128<short> delta2 = Sse2.Subtract(color, pal2);
                        Vector128<short> delta3 = Sse2.Subtract(color, pal3);

                        Vector128<int> deltaSum0 = Sse2.MultiplyAddAdjacent(delta0, delta0);
                        Vector128<int> deltaSum1 = Sse2.MultiplyAddAdjacent(delta1, delta1);
                        Vector128<int> deltaSum2 = Sse2.MultiplyAddAdjacent(delta2, delta2);
                        Vector128<int> deltaSum3 = Sse2.MultiplyAddAdjacent(delta3, delta3);

                        Vector128<int> deltaSum01 = Ssse3.HorizontalAdd(deltaSum0, deltaSum1);
                        Vector128<int> deltaSum23 = Ssse3.HorizontalAdd(deltaSum2, deltaSum3);

                        Vector128<ushort> delta = Sse41.PackUnsignedSaturate(deltaSum01, deltaSum23);

                        Vector128<ushort> min = Sse41.MinHorizontal(delta);

                        uint minPos = min.AsUInt32().GetElement(0);
                        ushort error = (ushort)minPos;
                        uint index = minPos >> 16;

                        indices[tileOffset] = (byte)index;
                        errorSum += error;
                    }
                }
            }

            return errorSum;
        }

        private static unsafe int Select4BitIndicesOneSubsetSse41(
            ReadOnlySpan<uint> tile,
            int w,
            int h,
            uint endPoint0,
            uint endPoint1,
            ReadOnlySpan<int> pBitValues,
            Span<byte> indices,
            int partition,
            int colorDepth,
            int alphaDepth,
            int pBits,
            uint alphaMask)
        {
            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            int errorSum = 0;

            int pBit0 = -1, pBit1 = -1;

            if (pBits != 0)
            {
                pBit0 = pBitValues[0];
                pBit1 = pBitValues[1];
            }

            RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoint0), colorDepth, alphaDepth, pBit0);
            RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoint1), colorDepth, alphaDepth, pBit1);

            Vector128<byte> c0Rep = Vector128.Create(c0.ToUInt32() | alphaMaskForPalette).AsByte();
            Vector128<byte> c1Rep = Vector128.Create(c1.ToUInt32() | alphaMaskForPalette).AsByte();

            Vector128<byte> c0c1 = Sse2.UnpackLow(c0Rep, c1Rep);

            Vector128<byte> rWeights;
            Vector128<byte> lWeights;

            fixed (byte* pWeights = BC67Tables.Weights[2], pInvWeights = BC67Tables.InverseWeights[2])
            {
                rWeights = Sse2.LoadVector128(pWeights);
                lWeights = Sse2.LoadVector128(pInvWeights);
            }

            Vector128<byte> iWeightsLow = Sse2.UnpackLow(lWeights, rWeights);
            Vector128<byte> iWeightsHigh = Sse2.UnpackHigh(lWeights, rWeights);
            Vector128<byte> iWeights01 = Sse2.UnpackLow(iWeightsLow.AsInt16(), iWeightsLow.AsInt16()).AsByte();
            Vector128<byte> iWeights23 = Sse2.UnpackHigh(iWeightsLow.AsInt16(), iWeightsLow.AsInt16()).AsByte();
            Vector128<byte> iWeights45 = Sse2.UnpackLow(iWeightsHigh.AsInt16(), iWeightsHigh.AsInt16()).AsByte();
            Vector128<byte> iWeights67 = Sse2.UnpackHigh(iWeightsHigh.AsInt16(), iWeightsHigh.AsInt16()).AsByte();
            Vector128<byte> iWeights0 = Sse2.UnpackLow(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights1 = Sse2.UnpackHigh(iWeights01.AsInt16(), iWeights01.AsInt16()).AsByte();
            Vector128<byte> iWeights2 = Sse2.UnpackLow(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();
            Vector128<byte> iWeights3 = Sse2.UnpackHigh(iWeights23.AsInt16(), iWeights23.AsInt16()).AsByte();
            Vector128<byte> iWeights4 = Sse2.UnpackLow(iWeights45.AsInt16(), iWeights45.AsInt16()).AsByte();
            Vector128<byte> iWeights5 = Sse2.UnpackHigh(iWeights45.AsInt16(), iWeights45.AsInt16()).AsByte();
            Vector128<byte> iWeights6 = Sse2.UnpackLow(iWeights67.AsInt16(), iWeights67.AsInt16()).AsByte();
            Vector128<byte> iWeights7 = Sse2.UnpackHigh(iWeights67.AsInt16(), iWeights67.AsInt16()).AsByte();

            Vector128<short> pal0 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights0.AsSByte()));
            Vector128<short> pal1 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights1.AsSByte()));
            Vector128<short> pal2 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights2.AsSByte()));
            Vector128<short> pal3 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights3.AsSByte()));
            Vector128<short> pal4 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights4.AsSByte()));
            Vector128<short> pal5 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights5.AsSByte()));
            Vector128<short> pal6 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights6.AsSByte()));
            Vector128<short> pal7 = ShiftRoundToNearest(Ssse3.MultiplyAddAdjacent(c0c1, iWeights7.AsSByte()));

            int i = 0;
            for (int ty = 0; ty < h; ty++)
            {
                for (int tx = 0; tx < w; tx++, i++)
                {
                    uint c = tile[i] | alphaMask;

                    Vector128<short> color = Sse41.ConvertToVector128Int16(Vector128.Create(c).AsByte());

                    Vector128<short> delta0 = Sse2.Subtract(color, pal0);
                    Vector128<short> delta1 = Sse2.Subtract(color, pal1);
                    Vector128<short> delta2 = Sse2.Subtract(color, pal2);
                    Vector128<short> delta3 = Sse2.Subtract(color, pal3);
                    Vector128<short> delta4 = Sse2.Subtract(color, pal4);
                    Vector128<short> delta5 = Sse2.Subtract(color, pal5);
                    Vector128<short> delta6 = Sse2.Subtract(color, pal6);
                    Vector128<short> delta7 = Sse2.Subtract(color, pal7);

                    Vector128<int> deltaSum0 = Sse2.MultiplyAddAdjacent(delta0, delta0);
                    Vector128<int> deltaSum1 = Sse2.MultiplyAddAdjacent(delta1, delta1);
                    Vector128<int> deltaSum2 = Sse2.MultiplyAddAdjacent(delta2, delta2);
                    Vector128<int> deltaSum3 = Sse2.MultiplyAddAdjacent(delta3, delta3);
                    Vector128<int> deltaSum4 = Sse2.MultiplyAddAdjacent(delta4, delta4);
                    Vector128<int> deltaSum5 = Sse2.MultiplyAddAdjacent(delta5, delta5);
                    Vector128<int> deltaSum6 = Sse2.MultiplyAddAdjacent(delta6, delta6);
                    Vector128<int> deltaSum7 = Sse2.MultiplyAddAdjacent(delta7, delta7);

                    Vector128<int> deltaSum01 = Ssse3.HorizontalAdd(deltaSum0, deltaSum1);
                    Vector128<int> deltaSum23 = Ssse3.HorizontalAdd(deltaSum2, deltaSum3);
                    Vector128<int> deltaSum45 = Ssse3.HorizontalAdd(deltaSum4, deltaSum5);
                    Vector128<int> deltaSum67 = Ssse3.HorizontalAdd(deltaSum6, deltaSum7);

                    Vector128<ushort> delta0123 = Sse41.PackUnsignedSaturate(deltaSum01, deltaSum23);
                    Vector128<ushort> delta4567 = Sse41.PackUnsignedSaturate(deltaSum45, deltaSum67);

                    Vector128<ushort> min0123 = Sse41.MinHorizontal(delta0123);
                    Vector128<ushort> min4567 = Sse41.MinHorizontal(delta4567);

                    uint minPos0123 = min0123.AsUInt32().GetElement(0);
                    uint minPos4567 = min4567.AsUInt32().GetElement(0);

                    if ((ushort)minPos4567 < (ushort)minPos0123)
                    {
                        errorSum += (ushort)minPos4567;
                        indices[ty * 4 + tx] = (byte)(8 + (minPos4567 >> 16));
                    }
                    else
                    {
                        errorSum += (ushort)minPos0123;
                        indices[ty * 4 + tx] = (byte)(minPos0123 >> 16);
                    }
                }
            }

            return errorSum;
        }

        private static Vector128<short> ShiftRoundToNearest(Vector128<short> x)
        {
            return Sse2.ShiftRightLogical(Sse2.Add(x, Vector128.Create((short)32)), 6);
        }

        private static int SelectIndicesFallback(
            ReadOnlySpan<uint> tile,
            int w,
            int h,
            ReadOnlySpan<uint> endPoints0,
            ReadOnlySpan<uint> endPoints1,
            ReadOnlySpan<int> pBitValues,
            Span<byte> indices,
            int subsetCount,
            int partition,
            int indexBitCount,
            int indexCount,
            int colorDepth,
            int alphaDepth,
            int pBits,
            uint alphaMask)
        {
            int errorSum = 0;

            uint alphaMaskForPalette = alphaMask;

            if (alphaDepth == 0)
            {
                alphaMaskForPalette |= new RgbaColor8(0, 0, 0, 255).ToUInt32();
            }

            Span<uint> palette = stackalloc uint[subsetCount * indexCount];

            for (int subset = 0; subset < subsetCount; subset++)
            {
                int palBase = subset * indexCount;

                int pBit0 = -1, pBit1 = -1;

                if (pBits == subsetCount)
                {
                    pBit0 = pBit1 = pBitValues[subset];
                }
                else if (pBits != 0)
                {
                    pBit0 = pBitValues[subset * 2];
                    pBit1 = pBitValues[subset * 2 + 1];
                }

                RgbaColor8 c0 = Quantize(RgbaColor8.FromUInt32(endPoints0[subset]), colorDepth, alphaDepth, pBit0);
                RgbaColor8 c1 = Quantize(RgbaColor8.FromUInt32(endPoints1[subset]), colorDepth, alphaDepth, pBit1);

                Unsafe.As<RgbaColor8, uint>(ref c0) |= alphaMaskForPalette;
                Unsafe.As<RgbaColor8, uint>(ref c1) |= alphaMaskForPalette;

                palette[palBase + 0] = c0.ToUInt32();
                palette[palBase + indexCount - 1] = c1.ToUInt32();

                for (int j = 1; j < indexCount - 1; j++)
                {
                    palette[palBase + j] = Interpolate(c0, c1, j, indexBitCount).ToUInt32();
                }
            }

            int i = 0;
            for (int ty = 0; ty < h; ty++)
            {
                for (int tx = 0; tx < w; tx++)
                {
                    int subset = BC67Tables.PartitionTable[subsetCount - 1][partition][ty * 4 + tx];
                    uint color = tile[i++] | alphaMask;

                    int bestMatchScore = int.MaxValue;
                    int bestMatchIndex = 0;

                    for (int j = 0; j < indexCount; j++)
                    {
                        int score = SquaredDifference(
                            RgbaColor8.FromUInt32(color).GetColor32(),
                            RgbaColor8.FromUInt32(palette[subset * indexCount + j]).GetColor32());

                        if (score < bestMatchScore)
                        {
                            bestMatchScore = score;
                            bestMatchIndex = j;
                        }
                    }

                    indices[ty * 4 + tx] = (byte)bestMatchIndex;
                    errorSum += bestMatchScore;
                }
            }

            return errorSum;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int SquaredDifference(RgbaColor32 color1, RgbaColor32 color2)
        {
            RgbaColor32 delta = color1 - color2;
            return RgbaColor32.Dot(delta, delta);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static RgbaColor8 Interpolate(RgbaColor8 color1, RgbaColor8 color2, int weightIndex, int indexBitCount)
        {
            return Interpolate(color1.GetColor32(), color2.GetColor32(), weightIndex, indexBitCount).GetColor8();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static RgbaColor32 Interpolate(RgbaColor32 color1, RgbaColor32 color2, int weightIndex, int indexBitCount)
        {
            Debug.Assert(indexBitCount >= 2 && indexBitCount <= 4);

            int weight = (((weightIndex << 7) / ((1 << indexBitCount) - 1)) + 1) >> 1;

            RgbaColor32 weightV = new RgbaColor32(weight);
            RgbaColor32 invWeightV = new RgbaColor32(64 - weight);

            return (color1 * invWeightV + color2 * weightV + new RgbaColor32(32)) >> 6;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static RgbaColor32 Interpolate(
            RgbaColor32 color1,
            RgbaColor32 color2,
            int colorWeightIndex,
            int alphaWeightIndex,
            int colorIndexBitCount,
            int alphaIndexBitCount)
        {
            Debug.Assert(colorIndexBitCount >= 2 && colorIndexBitCount <= 4);
            Debug.Assert(alphaIndexBitCount >= 2 && alphaIndexBitCount <= 4);

            int colorWeight = BC67Tables.Weights[colorIndexBitCount - 2][colorWeightIndex];
            int alphaWeight = BC67Tables.Weights[alphaIndexBitCount - 2][alphaWeightIndex];

            RgbaColor32 weightV = new RgbaColor32(colorWeight);
            weightV.A = alphaWeight;
            RgbaColor32 invWeightV = new RgbaColor32(64) - weightV;

            return (color1 * invWeightV + color2 * weightV + new RgbaColor32(32)) >> 6;
        }

        public static RgbaColor8 Quantize(RgbaColor8 color, int colorBits, int alphaBits, int pBit = -1)
        {
            if (alphaBits == 0)
            {
                int colorShift = 8 - colorBits;

                uint c;

                if (pBit >= 0)
                {
                    byte[] lutColor = _quantizationLut[colorBits - 4];

                    Debug.Assert(pBit <= 1);
                    int high = pBit << 8;
                    uint mask = (0xffu >> (colorBits + 1)) * 0x10101;

                    c = lutColor[color.R | high];
                    c |= (uint)lutColor[color.G | high] << 8;
                    c |= (uint)lutColor[color.B | high] << 16;

                    c <<= colorShift;
                    c |= (c >> (colorBits + 1)) & mask;
                    c |= ((uint)pBit * 0x10101) << (colorShift - 1);
                }
                else
                {
                    byte[] lutColor = _quantizationLutNoPBit[colorBits - 4];

                    uint mask = (0xffu >> colorBits) * 0x10101;

                    c = lutColor[color.R];
                    c |= (uint)lutColor[color.G] << 8;
                    c |= (uint)lutColor[color.B] << 16;

                    c <<= colorShift;
                    c |= (c >> colorBits) & mask;
                }

                c |= (uint)color.A << 24;

                return RgbaColor8.FromUInt32(c);
            }

            return QuantizeFallback(color, colorBits, alphaBits, pBit);
        }

        private static RgbaColor8 QuantizeFallback(RgbaColor8 color, int colorBits, int alphaBits, int pBit = -1)
        {
            byte r = UnquantizeComponent(QuantizeComponent(color.R, colorBits, pBit), colorBits, pBit);
            byte g = UnquantizeComponent(QuantizeComponent(color.G, colorBits, pBit), colorBits, pBit);
            byte b = UnquantizeComponent(QuantizeComponent(color.B, colorBits, pBit), colorBits, pBit);
            byte a = alphaBits == 0 ? color.A : UnquantizeComponent(QuantizeComponent(color.A, alphaBits, pBit), alphaBits, pBit);
            return new RgbaColor8(r, g, b, a);
        }

        public static byte QuantizeComponent(byte component, int bits, int pBit = -1)
        {
            return pBit >= 0 ? _quantizationLut[bits - 4][component | (pBit << 8)] : _quantizationLutNoPBit[bits - 4][component];
        }

        private static byte QuantizeComponentForLut(byte component, int bits, int pBit = -1)
        {
            int shift = 8 - bits;
            int fill = component >> bits;

            if (pBit >= 0)
            {
                Debug.Assert(pBit <= 1);
                fill >>= 1;
                fill |= pBit << (shift - 1);
            }

            int q1 = component >> shift;
            int q2 = Math.Max(q1 - 1, 0);
            int q3 = Math.Min(q1 + 1, (1 << bits) - 1);

            int delta1 = FastAbs(((q1 << shift) | fill) - component);
            int delta2 = component - ((q2 << shift) | fill);
            int delta3 = ((q3 << shift) | fill) - component;

            if (delta1 < delta2 && delta1 < delta3)
            {
                return (byte)q1;
            }
            else if (delta2 < delta3)
            {
                return (byte)q2;
            }
            else
            {
                return (byte)q3;
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int FastAbs(int x)
        {
            int sign = x >> 31;
            return (x + sign) ^ sign;
        }

        private static byte UnquantizeComponent(byte component, int bits, int pBit)
        {
            int shift = 8 - bits;
            int value = component << shift;

            if (pBit >= 0)
            {
                Debug.Assert(pBit <= 1);
                value |= value >> (bits + 1);
                value |= pBit << (shift - 1);
            }
            else
            {
                value |= value >> bits;
            }

            return (byte)value;
        }
    }
}