public int GetPackedBitSize()
{
// How many indices do we have?
int Indices = Height * Width;
if (DualPlane)
{
Indices *= 2;
}
IntegerEncoded IntEncoded = IntegerEncoded.CreateEncoding(MaxWeight);
return(IntEncoded.GetBitLength(Indices));
}
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);
}
}
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);
}
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);
}
