private 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; 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 EIntegerEncoding.JustBits: { OutputValues[OutputIndices++] = BitArrayStream.Replicate(BitValue, BitLength, 8); break; } case EIntegerEncoding.Trit: { D = IntEncoded.TritValue; switch (BitLength) { case 1: { C = 204; break; } case 2: { C = 93; int b = (BitValue >> 1) & 1; B = (b << 8) | (b << 4) | (b << 2) | (b << 1); break; } case 3: { C = 44; int cb = (BitValue >> 1) & 3; B = (cb << 7) | (cb << 2) | cb; break; } case 4: { C = 22; int dcb = (BitValue >> 1) & 7; B = (dcb << 6) | dcb; break; } case 5: { C = 11; int edcb = (BitValue >> 1) & 0xF; B = (edcb << 5) | (edcb >> 2); break; } case 6: { C = 5; int fedcb = (BitValue >> 1) & 0x1F; B = (fedcb << 4) | (fedcb >> 4); break; } default: throw new Exception("Unsupported trit encoding for color values!"); } break; } case EIntegerEncoding.Quint: { D = IntEncoded.QuintValue; switch (BitLength) { case 1: { C = 113; break; } case 2: { C = 54; int b = (BitValue >> 1) & 1; B = (b << 8) | (b << 3) | (b << 2); break; } case 3: { C = 26; int cb = (BitValue >> 1) & 3; B = (cb << 7) | (cb << 1) | (cb >> 1); break; } case 4: { C = 13; int dcb = (BitValue >> 1) & 7; B = (dcb << 6) | (dcb >> 1); break; } case 5: { C = 6; int edcb = (BitValue >> 1) & 0xF; B = (edcb << 5) | (edcb >> 3); break; } default: throw new Exception("Unsupported quint encoding for color values!"); } break; } } if (IntEncoded.GetEncoding() != EIntegerEncoding.JustBits) { int T = D * C + B; T ^= A; T = (A & 0x80) | (T >> 2); OutputValues[OutputIndices++] = T; } } }
private 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"); } 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; 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 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: 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 int 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; } 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; } } // 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)); 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); }