Пример #1
0
        static int UnquantizeTexelWeight(IntegerEncoded IntEncoded)
        {
            int BitValue  = IntEncoded.BitValue;
            int BitLength = IntEncoded.NumberBits;

            int A = BitArrayStream.Replicate(BitValue & 1, 1, 7);
            int B = 0, C = 0, D = 0;

            int Result = 0;

            switch (IntEncoded.GetEncoding())
            {
            case IntegerEncoded.EIntegerEncoding.JustBits:
                Result = BitArrayStream.Replicate(BitValue, BitLength, 6);
                break;

            case IntegerEncoded.EIntegerEncoding.Trit:
            {
                D = IntEncoded.TritValue;
                Debug.Assert(D < 3);

                switch (BitLength)
                {
                case 0:
                {
                    int[] Results = { 0, 32, 63 };
                    Result = Results[D];

                    break;
                }

                case 1:
                {
                    C = 50;
                    break;
                }

                case 2:
                {
                    C = 23;
                    int b = (BitValue >> 1) & 1;
                    B = (b << 6) | (b << 2) | b;

                    break;
                }

                case 3:
                {
                    C = 11;
                    int cb = (BitValue >> 1) & 3;
                    B = (cb << 5) | cb;

                    break;
                }

                default:
                    throw new ASTCDecoderException("Invalid trit encoding for texel weight");
                }

                break;
            }

            case IntegerEncoded.EIntegerEncoding.Quint:
            {
                D = IntEncoded.QuintValue;
                Debug.Assert(D < 5);

                switch (BitLength)
                {
                case 0:
                {
                    int[] Results = { 0, 16, 32, 47, 63 };
                    Result = Results[D];

                    break;
                }

                case 1:
                {
                    C = 28;

                    break;
                }

                case 2:
                {
                    C = 13;
                    int b = (BitValue >> 1) & 1;
                    B = (b << 6) | (b << 1);

                    break;
                }

                default:
                    throw new ASTCDecoderException("Invalid quint encoding for texel weight");
                }

                break;
            }
            }

            if (IntEncoded.GetEncoding() != IntegerEncoded.EIntegerEncoding.JustBits && BitLength > 0)
            {
                // Decode the value...
                Result  = D * C + B;
                Result ^= A;
                Result  = (A & 0x20) | (Result >> 2);
            }

            Debug.Assert(Result < 64);

            // Change from [0,63] to [0,64]
            if (Result > 32)
            {
                Result += 1;
            }

            return(Result);
        }
Пример #2
0
        static void DecodeColorValues(
            int[] OutputValues,
            byte[] InputData,
            uint[] Modes,
            int NumberPartitions,
            int NumberBitsForColorData)
        {
            // First figure out how many color values we have
            int NumberValues = 0;

            for (int i = 0; i < NumberPartitions; i++)
            {
                NumberValues += (int)((Modes[i] >> 2) + 1) << 1;
            }

            // Then based on the number of values and the remaining number of bits,
            // figure out the max value for each of them...
            int Range = 256;

            while (--Range > 0)
            {
                IntegerEncoded IntEncoded = IntegerEncoded.CreateEncoding(Range);
                int            BitLength  = IntEncoded.GetBitLength(NumberValues);

                if (BitLength <= NumberBitsForColorData)
                {
                    // Find the smallest possible range that matches the given encoding
                    while (--Range > 0)
                    {
                        IntegerEncoded NewIntEncoded = IntegerEncoded.CreateEncoding(Range);
                        if (!NewIntEncoded.MatchesEncoding(IntEncoded))
                        {
                            break;
                        }
                    }

                    // Return to last matching range.
                    Range++;
                    break;
                }
            }

            // We now have enough to decode our integer sequence.
            List <IntegerEncoded> IntegerEncodedSequence = new List <IntegerEncoded>();
            BitArrayStream        ColorBitStream         = new BitArrayStream(new BitArray(InputData));

            IntegerEncoded.DecodeIntegerSequence(IntegerEncodedSequence, ColorBitStream, Range, NumberValues);

            // Once we have the decoded values, we need to dequantize them to the 0-255 range
            // This procedure is outlined in ASTC spec C.2.13
            int OutputIndices = 0;

            foreach (IntegerEncoded IntEncoded in IntegerEncodedSequence)
            {
                int BitLength = IntEncoded.NumberBits;
                int BitValue  = IntEncoded.BitValue;

                Debug.Assert(BitLength >= 1);

                int A = 0, B = 0, C = 0, D = 0;
                // A is just the lsb replicated 9 times.
                A = BitArrayStream.Replicate(BitValue & 1, 1, 9);

                switch (IntEncoded.GetEncoding())
                {
                case IntegerEncoded.EIntegerEncoding.JustBits:
                {
                    OutputValues[OutputIndices++] = BitArrayStream.Replicate(BitValue, BitLength, 8);

                    break;
                }

                case IntegerEncoded.EIntegerEncoding.Trit:
                {
                    D = IntEncoded.TritValue;

                    switch (BitLength)
                    {
                    case 1:
                    {
                        C = 204;

                        break;
                    }

                    case 2:
                    {
                        C = 93;
                        // B = b000b0bb0
                        int b = (BitValue >> 1) & 1;
                        B = (b << 8) | (b << 4) | (b << 2) | (b << 1);

                        break;
                    }

                    case 3:
                    {
                        C = 44;
                        // B = cb000cbcb
                        int cb = (BitValue >> 1) & 3;
                        B = (cb << 7) | (cb << 2) | cb;

                        break;
                    }


                    case 4:
                    {
                        C = 22;
                        // B = dcb000dcb
                        int dcb = (BitValue >> 1) & 7;
                        B = (dcb << 6) | dcb;

                        break;
                    }

                    case 5:
                    {
                        C = 11;
                        // B = edcb000ed
                        int edcb = (BitValue >> 1) & 0xF;
                        B = (edcb << 5) | (edcb >> 2);

                        break;
                    }

                    case 6:
                    {
                        C = 5;
                        // B = fedcb000f
                        int fedcb = (BitValue >> 1) & 0x1F;
                        B = (fedcb << 4) | (fedcb >> 4);

                        break;
                    }

                    default:
                        throw new ASTCDecoderException("Unsupported trit encoding for color values!");
                    }

                    break;
                }

                case IntegerEncoded.EIntegerEncoding.Quint:
                {
                    D = IntEncoded.QuintValue;

                    switch (BitLength)
                    {
                    case 1:
                    {
                        C = 113;

                        break;
                    }

                    case 2:
                    {
                        C = 54;
                        // B = b0000bb00
                        int b = (BitValue >> 1) & 1;
                        B = (b << 8) | (b << 3) | (b << 2);

                        break;
                    }

                    case 3:
                    {
                        C = 26;
                        // B = cb0000cbc
                        int cb = (BitValue >> 1) & 3;
                        B = (cb << 7) | (cb << 1) | (cb >> 1);

                        break;
                    }

                    case 4:
                    {
                        C = 13;
                        // B = dcb0000dc
                        int dcb = (BitValue >> 1) & 7;
                        B = (dcb << 6) | (dcb >> 1);

                        break;
                    }

                    case 5:
                    {
                        C = 6;
                        // B = edcb0000e
                        int edcb = (BitValue >> 1) & 0xF;
                        B = (edcb << 5) | (edcb >> 3);

                        break;
                    }

                    default:
                        throw new ASTCDecoderException("Unsupported quint encoding for color values!");
                    }
                    break;
                }
                }

                if (IntEncoded.GetEncoding() != IntegerEncoded.EIntegerEncoding.JustBits)
                {
                    int T = D * C + B;
                    T ^= A;
                    T  = (A & 0x80) | (T >> 2);

                    OutputValues[OutputIndices++] = T;
                }
            }

            // Make sure that each of our values is in the proper range...
            for (int i = 0; i < NumberValues; i++)
            {
                Debug.Assert(OutputValues[i] <= 255);
            }
        }
Пример #3
0
        public static bool DecompressBlock(
            byte[] InputBuffer,
            int[] OutputBuffer,
            int BlockWidth,
            int BlockHeight)
        {
            BitArrayStream    BitStream   = new BitArrayStream(new BitArray(InputBuffer));
            TexelWeightParams TexelParams = DecodeBlockInfo(BitStream);

            if (TexelParams.Error)
            {
                throw new Exception("Invalid block mode");
            }

            //  Console.WriteLine($"BlockWidth {BlockWidth} {BlockHeight} BlockHeight");
            //  Console.WriteLine($"TexelParams {TexelParams.Width} X {TexelParams.Height}");

            if (TexelParams.VoidExtentLDR)
            {
                FillVoidExtentLDR(BitStream, OutputBuffer, BlockWidth, BlockHeight);

                return(true);
            }

            if (TexelParams.VoidExtentHDR)
            {
                throw new Exception("HDR void extent blocks are unsupported!");
            }

            if (TexelParams.Width > BlockWidth)
            {
                throw new Exception("Texel weight grid width should be smaller than block width");
            }

            if (TexelParams.Height > BlockHeight)
            {
                throw new Exception("Texel weight grid height should be smaller than block height");
            }

            // Read num partitions
            int NumberPartitions = BitStream.ReadBits(2) + 1;

            Debug.Assert(NumberPartitions <= 4);

            if (NumberPartitions == 4 && TexelParams.DualPlane)
            {
                throw new Exception("Dual plane mode is incompatible with four partition blocks");
            }

            // Based on the number of partitions, read the color endpoint mode for
            // each partition.

            // Determine partitions, partition index, and color endpoint modes
            int PlaneIndices = -1;
            int PartitionIndex;

            uint[] ColorEndpointMode = { 0, 0, 0, 0 };

            BitArrayStream ColorEndpointStream = new BitArrayStream(new BitArray(16 * 8));

            // Read extra config data...
            uint BaseColorEndpointMode = 0;

            if (NumberPartitions == 1)
            {
                ColorEndpointMode[0] = (uint)BitStream.ReadBits(4);
                PartitionIndex       = 0;
            }
            else
            {
                PartitionIndex        = BitStream.ReadBits(10);
                BaseColorEndpointMode = (uint)BitStream.ReadBits(6);
            }

            uint BaseMode = (BaseColorEndpointMode & 3);

            // Remaining bits are color endpoint data...
            int NumberWeightBits = TexelParams.GetPackedBitSize();
            int RemainingBits    = 128 - NumberWeightBits - BitStream.Position;

            // Consider extra bits prior to texel data...
            uint ExtraColorEndpointModeBits = 0;

            if (BaseMode != 0)
            {
                switch (NumberPartitions)
                {
                case 2: ExtraColorEndpointModeBits += 2; break;

                case 3: ExtraColorEndpointModeBits += 5; break;

                case 4: ExtraColorEndpointModeBits += 8; break;

                default: Debug.Assert(false); break;
                }
            }

            RemainingBits -= (int)ExtraColorEndpointModeBits;

            // Do we have a dual plane situation?
            int PlaneSelectorBits = 0;

            if (TexelParams.DualPlane)
            {
                PlaneSelectorBits = 2;
            }

            RemainingBits -= PlaneSelectorBits;

            // Read color data...
            int ColorDataBits = RemainingBits;

            while (RemainingBits > 0)
            {
                int NumberBits = Math.Min(RemainingBits, 8);
                int Bits       = BitStream.ReadBits(NumberBits);
                ColorEndpointStream.WriteBits(Bits, NumberBits);
                RemainingBits -= 8;
            }

            // Read the plane selection bits
            PlaneIndices = BitStream.ReadBits(PlaneSelectorBits);

            // Read the rest of the CEM
            if (BaseMode != 0)
            {
                uint ExtraColorEndpointMode = (uint)BitStream.ReadBits((int)ExtraColorEndpointModeBits);
                uint TempColorEndpointMode  = (ExtraColorEndpointMode << 6) | BaseColorEndpointMode;
                TempColorEndpointMode >>= 2;

                bool[] C = new bool[4];

                for (int i = 0; i < NumberPartitions; i++)
                {
                    C[i] = (TempColorEndpointMode & 1) != 0;
                    TempColorEndpointMode >>= 1;
                }

                byte[] M = new byte[4];

                for (int i = 0; i < NumberPartitions; i++)
                {
                    M[i] = (byte)(TempColorEndpointMode & 3);
                    TempColorEndpointMode >>= 2;
                    Debug.Assert(M[i] <= 3);
                }

                for (int i = 0; i < NumberPartitions; i++)
                {
                    ColorEndpointMode[i] = BaseMode;
                    if (!(C[i]))
                    {
                        ColorEndpointMode[i] -= 1;
                    }
                    ColorEndpointMode[i] <<= 2;
                    ColorEndpointMode[i]  |= M[i];
                }
            }
            else if (NumberPartitions > 1)
            {
                uint TempColorEndpointMode = BaseColorEndpointMode >> 2;

                for (uint i = 0; i < NumberPartitions; i++)
                {
                    ColorEndpointMode[i] = TempColorEndpointMode;
                }
            }

            // Make sure everything up till here is sane.
            for (int i = 0; i < NumberPartitions; i++)
            {
                Debug.Assert(ColorEndpointMode[i] < 16);
            }
            Debug.Assert(BitStream.Position + TexelParams.GetPackedBitSize() == 128);

            // Decode both color data and texel weight data
            int[] ColorValues = new int[32]; // Four values * two endpoints * four maximum partitions
            DecodeColorValues(ColorValues, ColorEndpointStream.ToByteArray(), ColorEndpointMode, NumberPartitions, ColorDataBits);

            ASTCPixel[][] EndPoints = new ASTCPixel[4][];
            EndPoints[0] = new ASTCPixel[2];
            EndPoints[1] = new ASTCPixel[2];
            EndPoints[2] = new ASTCPixel[2];
            EndPoints[3] = new ASTCPixel[2];

            int ColorValuesPosition = 0;

            for (int i = 0; i < NumberPartitions; i++)
            {
                ComputeEndpoints(EndPoints[i], ColorValues, ColorEndpointMode[i], ref ColorValuesPosition);
            }

            // Read the texel weight data.
            byte[] TexelWeightData = (byte[])InputBuffer.Clone();

            // Reverse everything
            for (int i = 0; i < 8; i++)
            {
                byte a = ReverseByte(TexelWeightData[i]);
                byte b = ReverseByte(TexelWeightData[15 - i]);

                TexelWeightData[i]      = b;
                TexelWeightData[15 - i] = a;
            }

            // Make sure that higher non-texel bits are set to zero
            int ClearByteStart = (TexelParams.GetPackedBitSize() >> 3) + 1;

            TexelWeightData[ClearByteStart - 1] &= (byte)((1 << (TexelParams.GetPackedBitSize() % 8)) - 1);

            int cLen = 16 - ClearByteStart;

            for (int i = ClearByteStart; i < ClearByteStart + cLen; i++)
            {
                TexelWeightData[i] = 0;
            }

            List <IntegerEncoded> TexelWeightValues = new List <IntegerEncoded>();
            BitArrayStream        WeightBitStream   = new BitArrayStream(new BitArray(TexelWeightData));

            IntegerEncoded.DecodeIntegerSequence(TexelWeightValues, WeightBitStream, TexelParams.MaxWeight, TexelParams.GetNumWeightValues());

            // Blocks can be at most 12x12, so we can have as many as 144 weights
            int[][] Weights = new int[2][];
            Weights[0] = new int[144];
            Weights[1] = new int[144];

            UnquantizeTexelWeights(Weights, TexelWeightValues, TexelParams, BlockWidth, BlockHeight);

            // Now that we have endpoints and weights, we can interpolate and generate
            // the proper decoding...
            for (int j = 0; j < BlockHeight; j++)
            {
                for (int i = 0; i < BlockWidth; i++)
                {
                    int Partition = Select2DPartition(PartitionIndex, i, j, NumberPartitions, ((BlockHeight * BlockWidth) < 32));
                    Debug.Assert(Partition < NumberPartitions);

                    ASTCPixel Pixel = new ASTCPixel(0, 0, 0, 0);
                    for (int Component = 0; Component < 4; Component++)
                    {
                        int Component0 = EndPoints[Partition][0].GetComponent(Component);
                        Component0 = BitArrayStream.Replicate(Component0, 8, 16);
                        int Component1 = EndPoints[Partition][1].GetComponent(Component);
                        Component1 = BitArrayStream.Replicate(Component1, 8, 16);

                        int Plane = 0;

                        if (TexelParams.DualPlane && (((PlaneIndices + 1) & 3) == Component))
                        {
                            Plane = 1;
                        }

                        int Weight         = Weights[Plane][j * BlockWidth + i];
                        int FinalComponent = (Component0 * (64 - Weight) + Component1 * Weight + 32) / 64;

                        if (FinalComponent == 65535)
                        {
                            Pixel.SetComponent(Component, 255);
                        }
                        else
                        {
                            double FinalComponentFloat = FinalComponent;
                            Pixel.SetComponent(Component, (int)(255.0 * (FinalComponentFloat / 65536.0) + 0.5));
                        }
                    }

                    OutputBuffer[j * BlockWidth + i] = Pixel.Pack();
                }
            }

            return(true);
        }