/******************************************************************************
@File PVRTDecompress.cpp
@Title PVRTDecompress
@Version
@Copyright Copyright (c) Imagination Technologies Limited.
@Platform ANSI compatible
@Description PVRTC Texture Decompression.
******************************************************************************/
/*****************************************************************************
* INCLUDES
*****************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include "PVRTDecompress.h"
#include "PVRTTexture.h"
#include "PVRTGlobal.h"
/***********************************************************
DECOMPRESSION ROUTINES
************************************************************/
/*****************************************************************************
* Useful structs
*****************************************************************************/
struct Pixel32
{
PVRTuint8 red,green,blue,alpha;
};
struct Pixel128S
{
PVRTint32 red,green,blue,alpha;
};
struct PVRTCWord
{
PVRTuint32 u32ModulationData;
PVRTuint32 u32ColourData;
};
struct PVRTCWordIndices
{
int P[2], Q[2], R[2], S[2];
};
/********************************************************************************/
/*!***********************************************************************
@Function getColourA
@Input u32ColourData Colour information from a PVRTCWord.
@Return Returns the first colour in a PVRTCWord's colour data.
@Description Decodes the first colour in a PVRTCWord's colour data.
*************************************************************************/
static Pixel32 getColourA(PVRTuint32 u32ColourData)
{
Pixel32 colour;
// Opaque Colour Mode - RGB 554
if ((u32ColourData & 0x8000) != 0)
{
colour.red = (PVRTuint8)((u32ColourData & 0x7c00) >> 10); // 5->5 bits
colour.green = (PVRTuint8)((u32ColourData & 0x3e0) >> 5); // 5->5 bits
colour.blue = (PVRTuint8)(u32ColourData & 0x1e) | ((u32ColourData & 0x1e) >> 4); // 4->5 bits
colour.alpha = (PVRTuint8)0xf;// 0->4 bits
}
// Transparent Colour Mode - ARGB 3443
else
{
colour.red = (PVRTuint8)((u32ColourData & 0xf00) >> 7) | ((u32ColourData & 0xf00) >> 11); // 4->5 bits
colour.green = (PVRTuint8)((u32ColourData & 0xf0) >> 3) | ((u32ColourData & 0xf0) >> 7); // 4->5 bits
colour.blue = (PVRTuint8)((u32ColourData & 0xe) << 1) | ((u32ColourData & 0xe) >> 2); // 3->5 bits
colour.alpha = (PVRTuint8)((u32ColourData & 0x7000) >> 11);// 3->4 bits - note 0 at right
}
return colour;
}
/*!***********************************************************************
@Function getColourB
@Input u32ColourData Colour information from a PVRTCWord.
@Return Returns the second colour in a PVRTCWord's colour data.
@Description Decodes the second colour in a PVRTCWord's colour data.
*************************************************************************/
static Pixel32 getColourB(PVRTuint32 u32ColourData)
{
Pixel32 colour;
// Opaque Colour Mode - RGB 555
if (u32ColourData & 0x80000000)
{
colour.red = (PVRTuint8)((u32ColourData & 0x7c000000) >> 26); // 5->5 bits
colour.green = (PVRTuint8)((u32ColourData & 0x3e00000) >> 21); // 5->5 bits
colour.blue = (PVRTuint8)((u32ColourData & 0x1f0000) >> 16); // 5->5 bits
colour.alpha = (PVRTuint8)0xf;// 0 bits
}
// Transparent Colour Mode - ARGB 3444
else
{
colour.red = (PVRTuint8)(((u32ColourData & 0xf000000) >> 23) | ((u32ColourData & 0xf000000) >> 27)); // 4->5 bits
colour.green = (PVRTuint8)(((u32ColourData & 0xf00000) >> 19) | ((u32ColourData & 0xf00000) >> 23)); // 4->5 bits
colour.blue = (PVRTuint8)(((u32ColourData & 0xf0000) >> 15) | ((u32ColourData & 0xf0000) >> 19)); // 4->5 bits
colour.alpha = (PVRTuint8)((u32ColourData & 0x70000000) >> 27);// 3->4 bits - note 0 at right
}
return colour;
}
/*!***********************************************************************
@Function interpolateColours
@Input P,Q,R,S Low bit-rate colour values for each PVRTCWord.
@Modified pPixel Output array for upscaled colour values.
@Input ui8Bpp Number of bpp.
@Description Bilinear upscale from 2x2 pixels to 4x4/8x4 pixels (depending on PVRTC bpp mode).
*************************************************************************/
static void interpolateColours(Pixel32 P, Pixel32 Q, Pixel32 R, Pixel32 S,
Pixel128S *pPixel, PVRTuint8 ui8Bpp)
{
PVRTuint32 ui32WordWidth=4;
PVRTuint32 ui32WordHeight=4;
if (ui8Bpp==2)
ui32WordWidth=8;
//Convert to int 32.
Pixel128S hP = {(PVRTint32)P.red,(PVRTint32)P.green,(PVRTint32)P.blue,(PVRTint32)P.alpha};
Pixel128S hQ = {(PVRTint32)Q.red,(PVRTint32)Q.green,(PVRTint32)Q.blue,(PVRTint32)Q.alpha};
Pixel128S hR = {(PVRTint32)R.red,(PVRTint32)R.green,(PVRTint32)R.blue,(PVRTint32)R.alpha};
Pixel128S hS = {(PVRTint32)S.red,(PVRTint32)S.green,(PVRTint32)S.blue,(PVRTint32)S.alpha};
//Get vectors.
Pixel128S QminusP = {hQ.red - hP.red, hQ.green - hP.green, hQ.blue - hP.blue, hQ.alpha - hP.alpha};
Pixel128S SminusR = {hS.red - hR.red, hS.green - hR.green, hS.blue - hR.blue, hS.alpha - hR.alpha};
//Multiply colours.
hP.red *= ui32WordWidth;
hP.green *= ui32WordWidth;
hP.blue *= ui32WordWidth;
hP.alpha *= ui32WordWidth;
hR.red *= ui32WordWidth;
hR.green *= ui32WordWidth;
hR.blue *= ui32WordWidth;
hR.alpha *= ui32WordWidth;
if (ui8Bpp==2)
{
//Loop through pixels to achieve results.
for (unsigned int x=0; x < ui32WordWidth; x++)
{
Pixel128S Result={4*hP.red, 4*hP.green, 4*hP.blue, 4*hP.alpha};
Pixel128S dY = {hR.red - hP.red, hR.green - hP.green, hR.blue - hP.blue, hR.alpha - hP.alpha};
for (unsigned int y=0; y < ui32WordHeight; y++)
{
pPixel[y*ui32WordWidth+x].red = (PVRTint32)((Result.red >> 7) + (Result.red >> 2));
pPixel[y*ui32WordWidth+x].green = (PVRTint32)((Result.green >> 7) + (Result.green >> 2));
pPixel[y*ui32WordWidth+x].blue = (PVRTint32)((Result.blue >> 7) + (Result.blue >> 2));
pPixel[y*ui32WordWidth+x].alpha = (PVRTint32)((Result.alpha >> 5) + (Result.alpha >> 1));
Result.red += dY.red;
Result.green += dY.green;
Result.blue += dY.blue;
Result.alpha += dY.alpha;
}
hP.red += QminusP.red;
hP.green += QminusP.green;
hP.blue += QminusP.blue;
hP.alpha += QminusP.alpha;
hR.red += SminusR.red;
hR.green += SminusR.green;
hR.blue += SminusR.blue;
hR.alpha += SminusR.alpha;
}
}
else
{
//Loop through pixels to achieve results.
for (unsigned int y=0; y < ui32WordHeight; y++)
{
Pixel128S Result={4*hP.red, 4*hP.green, 4*hP.blue, 4*hP.alpha};
Pixel128S dY = {hR.red - hP.red, hR.green - hP.green, hR.blue - hP.blue, hR.alpha - hP.alpha};
for (unsigned int x=0; x < ui32WordWidth; x++)
{
pPixel[y*ui32WordWidth+x].red = (PVRTint32)((Result.red >> 6) + (Result.red >> 1));
pPixel[y*ui32WordWidth+x].green = (PVRTint32)((Result.green >> 6) + (Result.green >> 1));
pPixel[y*ui32WordWidth+x].blue = (PVRTint32)((Result.blue >> 6) + (Result.blue >> 1));
pPixel[y*ui32WordWidth+x].alpha = (PVRTint32)((Result.alpha >> 4) + (Result.alpha));
Result.red += dY.red;
Result.green += dY.green;
Result.blue += dY.blue;
Result.alpha += dY.alpha;
}
hP.red += QminusP.red;
hP.green += QminusP.green;
hP.blue += QminusP.blue;
hP.alpha += QminusP.alpha;
hR.red += SminusR.red;
hR.green += SminusR.green;
hR.blue += SminusR.blue;
hR.alpha += SminusR.alpha;
}
}
}
/*!***********************************************************************
@Function unpackModulations
@Input word PVRTCWord to be decompressed
@Input offsetX X position within the PVRTCWord
@Input offsetY Y position within the PVRTCWord
@Modified i32ModulationValues The array of modulation values.
@Modified i32ModulationModes The array of modulation modes.
@Input ui8Bpp Number of bpp.
@Description Reads out and decodes the modulation values within the a given PVRTCWord
*************************************************************************/
static void unpackModulations(const PVRTCWord& word, int offsetX, int offsetY, PVRTint32 i32ModulationValues[16][8], PVRTint32 i32ModulationModes[16][8], PVRTuint8 ui8Bpp)
{
PVRTuint32 WordModMode = word.u32ColourData & 0x1;
PVRTuint32 ModulationBits = word.u32ModulationData;
// Unpack differently depending on 2bpp or 4bpp modes.
if (ui8Bpp==2)
{
if(WordModMode)
{
// determine which of the three modes are in use:
// If this is the either the H-only or V-only interpolation mode...
if(ModulationBits & 0x1)
{
// look at the "LSB" for the "centre" (V=2,H=4) texel. Its LSB is now
// actually used to indicate whether it's the H-only mode or the V-only...
// The centre texel data is the at (y==2, x==4) and so its LSB is at bit 20.
if(ModulationBits & (0x1 << 20))
{
// This is the V-only mode
WordModMode = 3;
}
else
{
// This is the H-only mode
WordModMode = 2;
}
// Create an extra bit for the centre pixel so that it looks like
// we have 2 actual bits for this texel. It makes later coding much easier.
if(ModulationBits & (0x1 << 21))
{
// set it to produce code for 1.0
ModulationBits |= (0x1 << 20);
}
else
{
// clear it to produce 0.0 code
ModulationBits &= ~(0x1 << 20);
}
}// end if H-Only or V-Only interpolation mode was chosen
if(ModulationBits & 0x2)
{
ModulationBits |= 0x1; /*set it*/
}
else
{
ModulationBits &= ~0x1; /*clear it*/
}
// run through all the pixels in the block. Note we can now treat all the
// "stored" values as if they have 2bits (even when they didn't!)
for(int y = 0; y < 4; y++)
{
for(int x = 0; x < 8; x++)
{
i32ModulationModes[x+offsetX][y+offsetY] = WordModMode;
// if this is a stored value...
if(((x^y)&1) == 0)
{
i32ModulationValues[x+offsetX][y+offsetY] = ModulationBits & 3;
ModulationBits >>= 2;
}
}
} // end for y
}
// else if direct encoded 2bit mode - i.e. 1 mode bit per pixel
else
{
for(int y = 0; y < 4; y++)
{
for(int x = 0; x < 8; x++)
{
i32ModulationModes[x+offsetX][y+offsetY] = WordModMode;
/*
// double the bits so 0=> 00, and 1=>11
*/
if(ModulationBits & 1)
{
i32ModulationValues[x+offsetX][y+offsetY] = 0x3;
}
else
{
i32ModulationValues[x+offsetX][y+offsetY] = 0x0;
}
ModulationBits >>= 1;
}
}// end for y
}
}
else
{
//Much simpler than the 2bpp decompression, only two modes, so the n/8 values are set directly.
// run through all the pixels in the word.
if (WordModMode)
{
for(int y = 0; y < 4; y++)
{
for(int x = 0; x < 4; x++)
{
i32ModulationValues[y+offsetY][x+offsetX] = ModulationBits & 3;
//if (i32ModulationValues==0) {}; don't need to check 0, 0 = 0/8.
if (i32ModulationValues[y+offsetY][x+offsetX]==1) { i32ModulationValues[y+offsetY][x+offsetX]=4;}
else if (i32ModulationValues[y+offsetY][x+offsetX]==2) { i32ModulationValues[y+offsetY][x+offsetX]=14;} //+10 tells the decompressor to punch through alpha.
else if (i32ModulationValues[y+offsetY][x+offsetX]==3) { i32ModulationValues[y+offsetY][x+offsetX]=8;}
ModulationBits >>= 2;
} // end for x
} // end for y
}
else
{
for(int y = 0; y < 4; y++)
{
for(int x = 0; x < 4; x++)
{
i32ModulationValues[y+offsetY][x+offsetX] = ModulationBits & 3;
i32ModulationValues[y+offsetY][x+offsetX]*=3;
if (i32ModulationValues[y+offsetY][x+offsetX]>3) i32ModulationValues[y+offsetY][x+offsetX]-=1;
ModulationBits >>= 2;
} // end for x
} // end for y
}
}
}
/*!***********************************************************************
@Function getModulationValues
@Input i32ModulationValues The array of modulation values.
@Input i32ModulationModes The array of modulation modes.
@Input xPos The x Position within the current word.
@Input yPos The y Position within the current word.
@Input ui8Bpp Number of bpp.
@Return Returns the modulation value.
@Description Gets the effective modulation values for a given pixel.
*************************************************************************/
static PVRTint32 getModulationValues(PVRTint32 i32ModulationValues[16][8],PVRTint32 i32ModulationModes[16][8],PVRTuint32 xPos,PVRTuint32 yPos,PVRTuint8 ui8Bpp)
{
if (ui8Bpp==2)
{
const int RepVals0[4] = {0, 3, 5, 8};
// extract the modulation value. If a simple encoding
if(i32ModulationModes[xPos][yPos]==0)
{
return RepVals0[i32ModulationValues[xPos][yPos]];
}
else
{
// if this is a stored value
if(((xPos^yPos)&1)==0)
{
return RepVals0[i32ModulationValues[xPos][yPos]];
}
// else average from the neighbours
// if H&V interpolation...
else if(i32ModulationModes[xPos][yPos] == 1)
{
return (RepVals0[i32ModulationValues[xPos][yPos-1]] +
RepVals0[i32ModulationValues[xPos][yPos+1]] +
RepVals0[i32ModulationValues[xPos-1][yPos]] +
RepVals0[i32ModulationValues[xPos+1][yPos]] + 2) / 4;
}
// else if H-Only
else if(i32ModulationModes[xPos][yPos] == 2)
{
return (RepVals0[i32ModulationValues[xPos-1][yPos]] +
RepVals0[i32ModulationValues[xPos+1][yPos]] + 1) / 2;
}
// else it's V-Only
else
{
return (RepVals0[i32ModulationValues[xPos][yPos-1]] +
RepVals0[i32ModulationValues[xPos][yPos+1]] + 1) / 2;
}
}
}
else if (ui8Bpp==4)
return i32ModulationValues[xPos][yPos];
return 0;
}
/*!***********************************************************************
@Function pvrtcGetDecompressedPixels
@Input P,Q,R,S PVRTWords in current decompression area.
@Modified pColourData Output pixels.
@Input ui8Bpp Number of bpp.
@Description Gets decompressed pixels for a given decompression area.
*************************************************************************/
static void pvrtcGetDecompressedPixels(const PVRTCWord& P, const PVRTCWord& Q,
const PVRTCWord& R, const PVRTCWord& S,
Pixel32 *pColourData,
PVRTuint8 ui8Bpp)
{
//4bpp only needs 8*8 values, but 2bpp needs 16*8, so rather than wasting processor time we just statically allocate 16*8.
PVRTint32 i32ModulationValues[16][8];
//Only 2bpp needs this.
PVRTint32 i32ModulationModes[16][8];
//4bpp only needs 16 values, but 2bpp needs 32, so rather than wasting processor time we just statically allocate 32.
Pixel128S upscaledColourA[32];
Pixel128S upscaledColourB[32];
PVRTuint32 ui32WordWidth=4;
PVRTuint32 ui32WordHeight=4;
if (ui8Bpp==2)
ui32WordWidth=8;
//Get the modulations from each word.
unpackModulations(P, 0, 0, i32ModulationValues, i32ModulationModes, ui8Bpp);
unpackModulations(Q, ui32WordWidth, 0, i32ModulationValues, i32ModulationModes, ui8Bpp);
unpackModulations(R, 0, ui32WordHeight, i32ModulationValues, i32ModulationModes, ui8Bpp);
unpackModulations(S, ui32WordWidth, ui32WordHeight, i32ModulationValues, i32ModulationModes, ui8Bpp);
// Bilinear upscale image data from 2x2 -> 4x4
interpolateColours(getColourA(P.u32ColourData), getColourA(Q.u32ColourData),
getColourA(R.u32ColourData), getColourA(S.u32ColourData),
upscaledColourA, ui8Bpp);
interpolateColours(getColourB(P.u32ColourData), getColourB(Q.u32ColourData),
getColourB(R.u32ColourData), getColourB(S.u32ColourData),
upscaledColourB, ui8Bpp);
for (unsigned int y=0; y < ui32WordHeight; y++)
{
for (unsigned int x=0; x < ui32WordWidth; x++)
{
PVRTint32 mod = getModulationValues(i32ModulationValues,i32ModulationModes,x+ui32WordWidth/2,y+ui32WordHeight/2,ui8Bpp);
bool punchthroughAlpha=false;
if (mod>10) {punchthroughAlpha=true; mod-=10;}
Pixel128S result;
result.red = (upscaledColourA[y*ui32WordWidth+x].red * (8-mod) + upscaledColourB[y*ui32WordWidth+x].red * mod) / 8;
result.green = (upscaledColourA[y*ui32WordWidth+x].green * (8-mod) + upscaledColourB[y*ui32WordWidth+x].green * mod) / 8;
result.blue = (upscaledColourA[y*ui32WordWidth+x].blue * (8-mod) + upscaledColourB[y*ui32WordWidth+x].blue * mod) / 8;
if (punchthroughAlpha) result.alpha = 0;
else result.alpha = (upscaledColourA[y*ui32WordWidth+x].alpha * (8-mod) + upscaledColourB[y*ui32WordWidth+x].alpha * mod) / 8;
//Convert the 32bit precision result to 8 bit per channel colour.
if (ui8Bpp==2)
{
pColourData[y*ui32WordWidth+x].red = (PVRTuint8)result.red;
pColourData[y*ui32WordWidth+x].green = (PVRTuint8)result.green;
pColourData[y*ui32WordWidth+x].blue = (PVRTuint8)result.blue;
pColourData[y*ui32WordWidth+x].alpha = (PVRTuint8)result.alpha;
}
else if (ui8Bpp==4)
{
pColourData[y+x*ui32WordHeight].red = (PVRTuint8)result.red;
pColourData[y+x*ui32WordHeight].green = (PVRTuint8)result.green;
pColourData[y+x*ui32WordHeight].blue = (PVRTuint8)result.blue;
pColourData[y+x*ui32WordHeight].alpha = (PVRTuint8)result.alpha;
}
}
}
}
/*!***********************************************************************
@Function wrapWordIndex
@Input numWords Total number of PVRTCWords in the current surface.
@Input word Original index for a PVRTCWord.
@Return unsigned int Wrapped PVRTCWord index.
@Description Maps decompressed data to the correct location in the output buffer.
*************************************************************************/
static unsigned int wrapWordIndex(unsigned int numWords, int word)
{
return ((word + numWords) % numWords);
}
#if defined(_DEBUG)
/*!***********************************************************************
@Function isPowerOf2
@Input input Value to be checked
@Returns true if the number is an integer power of two, else false.
@Description Check that a number is an integer power of two, i.e.
1, 2, 4, 8, ... etc.
Returns false for zero.
*************************************************************************/
static bool isPowerOf2( unsigned int input )
{
unsigned int minus1;
if( !input ) return 0;
minus1 = input - 1;
return ( (input | minus1) == (input ^ minus1) );
}
#endif
/*!***********************************************************************
@Function TwiddleUV
@Input YSize Y dimension of the texture in pixels
@Input XSize X dimension of the texture in pixels
@Input YPos Pixel Y position
@Input XPos Pixel X position
@Returns The twiddled offset of the pixel
@Description Given the Word (or pixel) coordinates and the dimension of
the texture in words (or pixels) this returns the twiddled
offset of the word (or pixel) from the start of the map.
NOTE: the dimensions of the texture must be a power of 2
*************************************************************************/
static PVRTuint32 TwiddleUV(PVRTuint32 XSize, PVRTuint32 YSize, PVRTuint32 XPos, PVRTuint32 YPos)
{
//Initially assume X is the larger size.
PVRTuint32 MinDimension=XSize;
PVRTuint32 MaxValue=YPos;
PVRTuint32 Twiddled=0;
PVRTuint32 SrcBitPos=1;
PVRTuint32 DstBitPos=1;
int ShiftCount=0;
//Check the sizes are valid.
_ASSERT(YPos < YSize);
_ASSERT(XPos < XSize);
_ASSERT(isPowerOf2(YSize));
_ASSERT(isPowerOf2(XSize));
//If Y is the larger dimension - switch the min/max values.
if(YSize < XSize)
{
MinDimension = YSize;
MaxValue = XPos;
}
// Step through all the bits in the "minimum" dimension
while(SrcBitPos < MinDimension)
{
if(YPos & SrcBitPos)
{
Twiddled |= DstBitPos;
}
if(XPos & SrcBitPos)
{
Twiddled |= (DstBitPos << 1);
}
SrcBitPos <<= 1;
DstBitPos <<= 2;
ShiftCount += 1;
}
// Prepend any unused bits
MaxValue >>= ShiftCount;
Twiddled |= (MaxValue << (2*ShiftCount));
return Twiddled;
}
/*!***********************************************************************
@Function mapDecompressedData
@Modified pOutput The PVRTC texture data to decompress
@Input width Width of the texture surface.
@Input pWord A pointer to the decompressed PVRTCWord in pixel form.
@Input &words Indices for the PVRTCword.
@Input ui8Bpp number of bits per pixel
@Description Maps decompressed data to the correct location in the output buffer.
*************************************************************************/
static void mapDecompressedData(Pixel32* pOutput, int width,
const Pixel32 *pWord,
const PVRTCWordIndices &words,
const PVRTuint8 ui8Bpp)
{
PVRTuint32 ui32WordWidth=4;
PVRTuint32 ui32WordHeight=4;
if (ui8Bpp==2)
ui32WordWidth=8;
for (unsigned int y=0; y < ui32WordHeight/2; y++)
{
for (unsigned int x=0; x < ui32WordWidth/2; x++)
{
pOutput[(((words.P[1] * ui32WordHeight) + y + ui32WordHeight/2)
* width + words.P[0] *ui32WordWidth + x + ui32WordWidth/2)] = pWord[y*ui32WordWidth+x]; // map P
pOutput[(((words.Q[1] * ui32WordHeight) + y + ui32WordHeight/2)
* width + words.Q[0] *ui32WordWidth + x)] = pWord[y*ui32WordWidth+x+ui32WordWidth/2]; // map Q
pOutput[(((words.R[1] * ui32WordHeight) + y)
* width + words.R[0] *ui32WordWidth + x + ui32WordWidth/2)] = pWord[(y+ui32WordHeight/2)*ui32WordWidth+x]; // map R
pOutput[(((words.S[1] * ui32WordHeight) + y)
* width + words.S[0] *ui32WordWidth + x)] = pWord[(y+ui32WordHeight/2)*ui32WordWidth+x+ui32WordWidth/2]; // map S
}
}
}
/*!***********************************************************************
@Function pvrtcDecompress
@Input pCompressedData The PVRTC texture data to decompress
@Modified pDecompressedData The output buffer to decompress into.
@Input ui32Width X dimension of the texture
@Input ui32Height Y dimension of the texture
@Input ui8Bpp number of bits per pixel
@Description Internally decompresses PVRTC to RGBA 8888
*************************************************************************/
static int pvrtcDecompress( PVRTuint8 *pCompressedData,
Pixel32 *pDecompressedData,
PVRTuint32 ui32Width,
PVRTuint32 ui32Height,
PVRTuint8 ui8Bpp)
{
PVRTuint32 ui32WordWidth=4;
PVRTuint32 ui32WordHeight=4;
if (ui8Bpp==2)
ui32WordWidth=8;
PVRTuint32 *pWordMembers = (PVRTuint32 *)pCompressedData;
Pixel32 *pOutData = pDecompressedData;
// Calculate number of words
int i32NumXWords = (int)(ui32Width / ui32WordWidth);
int i32NumYWords = (int)(ui32Height / ui32WordHeight);
// Structs used for decompression
PVRTCWordIndices indices;
Pixel32 *pPixels;
pPixels = (Pixel32*)malloc(ui32WordWidth*ui32WordHeight*sizeof(Pixel32));
// For each row of words
for(int wordY=-1; wordY < i32NumYWords-1; wordY++)
{
// for each column of words
for(int wordX=-1; wordX < i32NumXWords-1; wordX++)
{
indices.P[0] = wrapWordIndex(i32NumXWords, wordX);
indices.P[1] = wrapWordIndex(i32NumYWords, wordY);
indices.Q[0] = wrapWordIndex(i32NumXWords, wordX + 1);
indices.Q[1] = wrapWordIndex(i32NumYWords, wordY);
indices.R[0] = wrapWordIndex(i32NumXWords, wordX);
indices.R[1] = wrapWordIndex(i32NumYWords, wordY + 1);
indices.S[0] = wrapWordIndex(i32NumXWords, wordX + 1);
indices.S[1] = wrapWordIndex(i32NumYWords, wordY + 1);
//Work out the offsets into the twiddle structs, multiply by two as there are two members per word.
PVRTuint32 WordOffsets[4] =
{
TwiddleUV(i32NumXWords,i32NumYWords,indices.P[0], indices.P[1])*2,
TwiddleUV(i32NumXWords,i32NumYWords,indices.Q[0], indices.Q[1])*2,
TwiddleUV(i32NumXWords,i32NumYWords,indices.R[0], indices.R[1])*2,
TwiddleUV(i32NumXWords,i32NumYWords,indices.S[0], indices.S[1])*2,
};
//Access individual elements to fill out PVRTCWord
PVRTCWord P,Q,R,S;
P.u32ColourData = pWordMembers[WordOffsets[0]+1];
P.u32ModulationData = pWordMembers[WordOffsets[0]];
Q.u32ColourData = pWordMembers[WordOffsets[1]+1];
Q.u32ModulationData = pWordMembers[WordOffsets[1]];
R.u32ColourData = pWordMembers[WordOffsets[2]+1];
R.u32ModulationData = pWordMembers[WordOffsets[2]];
S.u32ColourData = pWordMembers[WordOffsets[3]+1];
S.u32ModulationData = pWordMembers[WordOffsets[3]];
// assemble 4 words into struct to get decompressed pixels from
pvrtcGetDecompressedPixels(P,Q,R,S,pPixels,ui8Bpp);
mapDecompressedData(pOutData, ui32Width, pPixels, indices, ui8Bpp);
} // for each word
} // for each row of words
free(pPixels);
//Return the data size
return ui32Width * ui32Height / (PVRTuint32)(ui32WordWidth/2);
}
/*!***********************************************************************
@Function PVRTDecompressPVRTC
@Input pCompressedData The PVRTC texture data to decompress
@Input Do2bitMode Signifies whether the data is PVRTC2 or PVRTC4
@Input XDim X dimension of the texture
@Input YDim Y dimension of the texture
@Modified pResultImage The decompressed texture data
@Return Returns the amount of data that was decompressed.
@Description Decompresses PVRTC to RGBA 8888
*************************************************************************/
int PVRTDecompressPVRTC(const void *pCompressedData,
const int Do2bitMode,
const int XDim,
const int YDim,
unsigned char* pResultImage)
{
//Cast the output buffer to a Pixel32 pointer.
Pixel32* pDecompressedData = (Pixel32*)pResultImage;
//Check the X and Y values are at least the minimum size.
int XTrueDim = PVRT_MAX(XDim,((Do2bitMode==1)?16:8));
int YTrueDim = PVRT_MAX(YDim,8);
//If the dimensions aren't correct, we need to create a new buffer instead of just using the provided one, as the buffer will overrun otherwise.
if(XTrueDim!=XDim || YTrueDim!=YDim)
{
pDecompressedData=(Pixel32*)malloc(XTrueDim*YTrueDim*sizeof(Pixel32));
}
//Decompress the surface.
int retval = pvrtcDecompress((PVRTuint8*)pCompressedData,pDecompressedData,XTrueDim,YTrueDim,(Do2bitMode==1?2:4));
//If the dimensions were too small, then copy the new buffer back into the output buffer.
if(XTrueDim!=XDim || YTrueDim!=YDim)
{
//Loop through all the required pixels.
for (int x=0; x<XDim; ++x)
{
for (int y=0; y<YDim; ++y)
{
((Pixel32*)pResultImage)[x+y*XDim]=pDecompressedData[x+y*XTrueDim];
}
}
//Free the temporary buffer.
free(pDecompressedData);
}
return retval;
}
/****************************
** ETC Compression
****************************/
/*****************************************************************************
Macros
*****************************************************************************/
#define _CLAMP_(X,Xmin,Xmax) ( (X)<(Xmax) ? ( (X)<(Xmin)?(Xmin):(X) ) : (Xmax) )
/*****************************************************************************
Constants
******************************************************************************/
unsigned int ETC_FLIP = 0x01000000;
unsigned int ETC_DIFF = 0x02000000;
const int mod[8][4]={{2, 8,-2,-8},
{5, 17, -5, -17},
{9, 29, -9, -29},
{13, 42, -13, -42},
{18, 60, -18, -60},
{24, 80, -24, -80},
{33, 106, -33, -106},
{47, 183, -47, -183}};
/*!***********************************************************************
@Function modifyPixel
@Input red Red value of pixel
@Input green Green value of pixel
@Input blue Blue value of pixel
@Input x Pixel x position in block
@Input y Pixel y position in block
@Input modBlock Values for the current block
@Input modTable Modulation values
@Returns Returns actual pixel colour
@Description Used by ETCTextureDecompress
*************************************************************************/
static unsigned int modifyPixel(int red, int green, int blue, int x, int y, unsigned int modBlock, int modTable)
{
int index = x*4+y, pixelMod;
unsigned int mostSig = modBlock<<1;
if (index<8)
pixelMod = mod[modTable][((modBlock>>(index+24))&0x1)+((mostSig>>(index+8))&0x2)];
else
pixelMod = mod[modTable][((modBlock>>(index+8))&0x1)+((mostSig>>(index-8))&0x2)];
red = _CLAMP_(red+pixelMod,0,255);
green = _CLAMP_(green+pixelMod,0,255);
blue = _CLAMP_(blue+pixelMod,0,255);
return ((red<<16) + (green<<8) + blue)|0xff000000;
}
/*!***********************************************************************
@Function ETCTextureDecompress
@Input pSrcData The ETC texture data to decompress
@Input x X dimension of the texture
@Input y Y dimension of the texture
@Modified pDestData The decompressed texture data
@Input nMode The format of the data
@Returns The number of bytes of ETC data decompressed
@Description Decompresses ETC to RGBA 8888
*************************************************************************/
static int ETCTextureDecompress(const void * const pSrcData, const int &x, const int &y, const void *pDestData,const int &/*nMode*/)
{
unsigned int blockTop, blockBot, *input = (unsigned int*)pSrcData, *output;
unsigned char red1, green1, blue1, red2, green2, blue2;
bool bFlip, bDiff;
int modtable1,modtable2;
for(int i=0;i<y;i+=4)
{
for(int m=0;m<x;m+=4)
{
blockTop = *(input++);
blockBot = *(input++);
output = (unsigned int*)pDestData + i*x +m;
// check flipbit
bFlip = (blockTop & ETC_FLIP) != 0;
bDiff = (blockTop & ETC_DIFF) != 0;
if(bDiff)
{ // differential mode 5 colour bits + 3 difference bits
// get base colour for subblock 1
blue1 = (unsigned char)((blockTop&0xf80000)>>16);
green1 = (unsigned char)((blockTop&0xf800)>>8);
red1 = (unsigned char)(blockTop&0xf8);
// get differential colour for subblock 2
signed char blues = (signed char)(blue1>>3) + ((signed char) ((blockTop & 0x70000) >> 11)>>5);
signed char greens = (signed char)(green1>>3) + ((signed char)((blockTop & 0x700) >>3)>>5);
signed char reds = (signed char)(red1>>3) + ((signed char)((blockTop & 0x7)<<5)>>5);
blue2 = (unsigned char)blues;
green2 = (unsigned char)greens;
red2 = (unsigned char)reds;
red1 = red1 +(red1>>5); // copy bits to lower sig
green1 = green1 + (green1>>5); // copy bits to lower sig
blue1 = blue1 + (blue1>>5); // copy bits to lower sig
red2 = (red2<<3) +(red2>>2); // copy bits to lower sig
green2 = (green2<<3) + (green2>>2); // copy bits to lower sig
blue2 = (blue2<<3) + (blue2>>2); // copy bits to lower sig
}
else
{ // individual mode 4 + 4 colour bits
// get base colour for subblock 1
blue1 = (unsigned char)((blockTop&0xf00000)>>16);
blue1 = blue1 +(blue1>>4); // copy bits to lower sig
green1 = (unsigned char)((blockTop&0xf000)>>8);
green1 = green1 + (green1>>4); // copy bits to lower sig
red1 = (unsigned char)(blockTop&0xf0);
red1 = red1 + (red1>>4); // copy bits to lower sig
// get base colour for subblock 2
blue2 = (unsigned char)((blockTop&0xf0000)>>12);
blue2 = blue2 +(blue2>>4); // copy bits to lower sig
green2 = (unsigned char)((blockTop&0xf00)>>4);
green2 = green2 + (green2>>4); // copy bits to lower sig
red2 = (unsigned char)((blockTop&0xf)<<4);
red2 = red2 + (red2>>4); // copy bits to lower sig
}
// get the modtables for each subblock
modtable1 = (blockTop>>29)&0x7;
modtable2 = (blockTop>>26)&0x7;
if(!bFlip)
{ // 2 2x4 blocks side by side
for(int j=0;j<4;j++) // vertical
{
for(int k=0;k<2;k++) // horizontal
{
*(output+j*x+k) = modifyPixel(red1,green1,blue1,k,j,blockBot,modtable1);
*(output+j*x+k+2) = modifyPixel(red2,green2,blue2,k+2,j,blockBot,modtable2);
}
}
}
else
{ // 2 4x2 blocks on top of each other
for(int j=0;j<2;j++)
{
for(int k=0;k<4;k++)
{
*(output+j*x+k) = modifyPixel(red1,green1,blue1,k,j,blockBot,modtable1);
*(output+(j+2)*x+k) = modifyPixel(red2,green2,blue2,k,j+2,blockBot,modtable2);
}
}
}
}
}
return x*y/2;
}
/*!***********************************************************************
@Function PVRTDecompressETC
@Input pSrcData The ETC texture data to decompress
@Input x X dimension of the texture
@Input y Y dimension of the texture
@Modified pDestData The decompressed texture data
@Input nMode The format of the data
@Returns The number of bytes of ETC data decompressed
@Description Decompresses ETC to RGBA 8888
*************************************************************************/
int PVRTDecompressETC(const void * const pSrcData,
const unsigned int &x,
const unsigned int &y,
void *pDestData,
const int &nMode)
{
int i32read;
if(x<ETC_MIN_TEXWIDTH || y<ETC_MIN_TEXHEIGHT)
{ // decompress into a buffer big enough to take the minimum size
char* pTempBuffer = (char*)malloc(PVRT_MAX(x,ETC_MIN_TEXWIDTH)*PVRT_MAX(y,ETC_MIN_TEXHEIGHT)*4);
i32read = ETCTextureDecompress(pSrcData,PVRT_MAX(x,ETC_MIN_TEXWIDTH),PVRT_MAX(y,ETC_MIN_TEXHEIGHT),pTempBuffer,nMode);
for(unsigned int i=0;i<y;i++)
{ // copy from larger temp buffer to output data
memcpy((char*)(pDestData)+i*x*4,pTempBuffer+PVRT_MAX(x,ETC_MIN_TEXWIDTH)*4*i,x*4);
}
if(pTempBuffer) free(pTempBuffer);
}
else // decompress larger MIP levels straight into the output data
i32read = ETCTextureDecompress(pSrcData,x,y,pDestData,nMode);
// swap r and b channels
unsigned char* pSwap = (unsigned char*)pDestData, swap;
for(unsigned int i=0;i<y;i++)
for(unsigned int j=0;j<x;j++)
{
swap = pSwap[0];
pSwap[0] = pSwap[2];
pSwap[2] = swap;
pSwap+=4;
}
return i32read;
}
/*****************************************************************************
End of file (PVRTDecompress.cpp)
*****************************************************************************/