FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
This repository has been archived on 2022-06-27. You can view files and clone it, but cannot push or open issues or pull requests.
Xash3DArchive/launch/imagelib/img_dds.c

2481 lines
72 KiB
C
Raw Blame History

//=======================================================================
// Copyright XashXT Group 2008 ©
// img_dds.c - dds format load & save
//=======================================================================
#include "imagelib.h"
#include "mathlib.h"
// TODO: tune this ?
#define REDWEIGHT 4
#define GREENWEIGHT 16
#define BLUEWEIGHT 1
#define CHAN_MAX 255
#define ALPHACUT 127
static void Image_BaseColorSearch( byte *blkaddr, byte srccolors[4][4][4], byte *bestcolor[2], int numxpixels, int numypixels, int type, qboolean haveAlpha )
{
// use same luminance-weighted distance metric to determine encoding as for finding the base colors
// TODO: could also try to find a better encoding for the 3-color-encoding type, this really should be done
// if it's rgba_dxt1 and we have alpha in the block, currently even values which will be mapped to black
// due to their alpha value will influence the result
int i, j, colors, z;
uint pixerror, pixerrorred, pixerrorgreen, pixerrorblue, pixerrorbest;
int colordist, blockerrlin[2][3];
byte nrcolor[2];
int pixerrorcolorbest[3];
byte enc = 0;
byte cv[4][4];
byte testcolor[2][3];
if(((bestcolor[0][0] & 0xf8) << 8 | (bestcolor[0][1] & 0xfc) << 3 | bestcolor[0][2] >> 3) < ((bestcolor[1][0] & 0xf8) << 8 | (bestcolor[1][1] & 0xfc) << 3 | bestcolor[1][2] >> 3))
{
testcolor[0][0] = bestcolor[0][0];
testcolor[0][1] = bestcolor[0][1];
testcolor[0][2] = bestcolor[0][2];
testcolor[1][0] = bestcolor[1][0];
testcolor[1][1] = bestcolor[1][1];
testcolor[1][2] = bestcolor[1][2];
}
else
{
testcolor[1][0] = bestcolor[0][0];
testcolor[1][1] = bestcolor[0][1];
testcolor[1][2] = bestcolor[0][2];
testcolor[0][0] = bestcolor[1][0];
testcolor[0][1] = bestcolor[1][1];
testcolor[0][2] = bestcolor[1][2];
}
for( i = 0; i < 3; i ++ )
{
cv[0][i] = testcolor[0][i];
cv[1][i] = testcolor[1][i];
cv[2][i] = (testcolor[0][i] * 2 + testcolor[1][i]) / 3;
cv[3][i] = (testcolor[0][i] + testcolor[1][i] * 2) / 3;
}
blockerrlin[0][0] = 0;
blockerrlin[0][1] = 0;
blockerrlin[0][2] = 0;
blockerrlin[1][0] = 0;
blockerrlin[1][1] = 0;
blockerrlin[1][2] = 0;
nrcolor[0] = 0;
nrcolor[1] = 0;
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
pixerrorbest = 0xffffffff;
for( colors = 0; colors < 4; colors++ )
{
colordist = srccolors[j][i][0] - (cv[colors][0]);
pixerror = colordist * colordist * REDWEIGHT;
pixerrorred = colordist;
colordist = srccolors[j][i][1] - (cv[colors][1]);
pixerror += colordist * colordist * GREENWEIGHT;
pixerrorgreen = colordist;
colordist = srccolors[j][i][2] - (cv[colors][2]);
pixerror += colordist * colordist * BLUEWEIGHT;
pixerrorblue = colordist;
if( pixerror < pixerrorbest )
{
enc = colors;
pixerrorbest = pixerror;
pixerrorcolorbest[0] = pixerrorred;
pixerrorcolorbest[1] = pixerrorgreen;
pixerrorcolorbest[2] = pixerrorblue;
}
}
if( enc == 0 )
{
for( z = 0; z < 3; z++ )
{
blockerrlin[0][z] += 3 * pixerrorcolorbest[z];
}
nrcolor[0] += 3;
}
else if( enc == 2 )
{
for( z = 0; z < 3; z++ )
{
blockerrlin[0][z] += 2 * pixerrorcolorbest[z];
}
nrcolor[0] += 2;
for( z = 0; z < 3; z++ )
{
blockerrlin[1][z] += 1 * pixerrorcolorbest[z];
}
nrcolor[1] += 1;
}
else if( enc == 3 )
{
for( z = 0; z < 3; z++ )
{
blockerrlin[0][z] += 1 * pixerrorcolorbest[z];
}
nrcolor[0] += 1;
for( z = 0; z < 3; z++ )
{
blockerrlin[1][z] += 2 * pixerrorcolorbest[z];
}
nrcolor[1] += 2;
}
else if( enc == 1 )
{
for( z = 0; z < 3; z++ )
{
blockerrlin[1][z] += 3 * pixerrorcolorbest[z];
}
nrcolor[1] += 3;
}
}
}
if( nrcolor[0] == 0 ) nrcolor[0] = 1;
if( nrcolor[1] == 0 ) nrcolor[1] = 1;
for( j = 0; j < 2; j++ )
{
for( i = 0; i < 3; i++ )
{
int newvalue = testcolor[j][i] + blockerrlin[j][i] / nrcolor[j];
if( newvalue <= 0 ) testcolor[j][i] = 0;
else if( newvalue >= 255 ) testcolor[j][i] = 255;
else testcolor[j][i] = newvalue;
}
}
if((abs(testcolor[0][0] - testcolor[1][0]) < 8) && (abs(testcolor[0][1] - testcolor[1][1]) < 4) && (abs(testcolor[0][2] - testcolor[1][2]) < 8))
{
// both colors are so close they might get encoded as the same 16bit values
byte coldiffred, coldiffgreen, coldiffblue, coldiffmax, factor, ind0, ind1;
coldiffred = abs(testcolor[0][0] - testcolor[1][0]);
coldiffgreen = 2 * abs(testcolor[0][1] - testcolor[1][1]);
coldiffblue = abs(testcolor[0][2] - testcolor[1][2]);
coldiffmax = coldiffred;
if( coldiffmax < coldiffgreen ) coldiffmax = coldiffgreen;
if( coldiffmax < coldiffblue ) coldiffmax = coldiffblue;
if( coldiffmax > 0 )
{
if( coldiffmax > 4 ) factor = 2;
else if( coldiffmax > 2 ) factor = 3;
else factor = 4;
// won't do much if the color value is near 255...
// argh so many ifs
if( testcolor[1][1] >= testcolor[0][1] )
{
ind1 = 1;
ind0 = 0;
}
else
{
ind1 = 0;
ind0 = 1;
}
if((testcolor[ind1][1] + factor * coldiffgreen) <= 255 )
testcolor[ind1][1] += factor * coldiffgreen;
else testcolor[ind1][1] = 255;
if((testcolor[ind1][0] - testcolor[ind0][1]) > 0 )
{
if((testcolor[ind1][0] + factor * coldiffred) <= 255 )
testcolor[ind1][0] += factor * coldiffred;
else testcolor[ind1][0] = 255;
}
else
{
if((testcolor[ind0][0] + factor * coldiffred) <= 255 )
testcolor[ind0][0] += factor * coldiffred;
else testcolor[ind0][0] = 255;
}
if((testcolor[ind1][2] - testcolor[ind0][2]) > 0 )
{
if((testcolor[ind1][2] + factor * coldiffblue) <= 255 )
testcolor[ind1][2] += factor * coldiffblue;
else testcolor[ind1][2] = 255;
}
else
{
if((testcolor[ind0][2] + factor * coldiffblue) <= 255 )
testcolor[ind0][2] += factor * coldiffblue;
else testcolor[ind0][2] = 255;
}
}
}
if(((testcolor[0][0] & 0xf8) << 8 | (testcolor[0][1] & 0xfc) << 3 | testcolor[0][2] >> 3) < ((testcolor[1][0] & 0xf8) << 8 | (testcolor[1][1] & 0xfc) << 3 | testcolor[1][2]) >> 3)
{
for( i = 0; i < 3; i++ )
{
bestcolor[0][i] = testcolor[0][i];
bestcolor[1][i] = testcolor[1][i];
}
}
else
{
for( i = 0; i < 3; i++ )
{
bestcolor[0][i] = testcolor[1][i];
bestcolor[1][i] = testcolor[0][i];
}
}
}
static void Image_StoreBlock( byte *blkaddr, byte srccolors[4][4][4], byte *bestcolor[2], int numxpixels, int numypixels, uint type, qboolean haveAlpha )
{
// use same luminance-weighted distance metric to determine encoding as for finding the base colors
int i, j, colors;
uint testerror, testerror2, pixerror, pixerrorbest;
int colordist;
word color0, color1, tempcolor;
uint bits = 0, bits2 = 0;
byte *colorptr;
byte enc = 0;
byte cv[4][4];
bestcolor[0][0] = bestcolor[0][0] & 0xf8;
bestcolor[0][1] = bestcolor[0][1] & 0xfc;
bestcolor[0][2] = bestcolor[0][2] & 0xf8;
bestcolor[1][0] = bestcolor[1][0] & 0xf8;
bestcolor[1][1] = bestcolor[1][1] & 0xfc;
bestcolor[1][2] = bestcolor[1][2] & 0xf8;
color0 = bestcolor[0][0] << 8 | bestcolor[0][1] << 3 | bestcolor[0][2] >> 3;
color1 = bestcolor[1][0] << 8 | bestcolor[1][1] << 3 | bestcolor[1][2] >> 3;
if( color0 < color1 )
{
tempcolor = color0;
color0 = color1;
color1 = tempcolor;
colorptr = bestcolor[0];
bestcolor[0] = bestcolor[1];
bestcolor[1] = colorptr;
}
for( i = 0; i < 3; i++ )
{
cv[0][i] = bestcolor[0][i];
cv[1][i] = bestcolor[1][i];
cv[2][i] = (bestcolor[0][i] * 2 + bestcolor[1][i]) / 3;
cv[3][i] = (bestcolor[0][i] + bestcolor[1][i] * 2) / 3;
}
testerror = 0;
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
pixerrorbest = 0xffffffff;
for( colors = 0; colors < 4; colors++ )
{
colordist = srccolors[j][i][0] - cv[colors][0];
pixerror = colordist * colordist * REDWEIGHT;
colordist = srccolors[j][i][1] - cv[colors][1];
pixerror += colordist * colordist * GREENWEIGHT;
colordist = srccolors[j][i][2] - cv[colors][2];
pixerror += colordist * colordist * BLUEWEIGHT;
if( pixerror < pixerrorbest )
{
pixerrorbest = pixerror;
enc = colors;
}
}
testerror += pixerrorbest;
bits |= enc << (2 * (j * 4 + i));
}
}
for( i = 0; i < 3; i++ )
{
cv[2][i] = (bestcolor[0][i] + bestcolor[1][i]) / 2;
// this isn't used. Looks like the black color constant can only be used
// with RGB_DXT1 if I read the spec correctly (note though that the radeon gpu disagrees,
// it will decode 3 to black even with DXT3/5), and due to how the color searching works
// it won't get used even then
cv[3][i] = 0;
}
testerror2 = 0;
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
pixerrorbest = 0xffffffff;
if((type == PF_DXT1) && (srccolors[j][i][3] <= ALPHACUT))
{
enc = 3;
pixerrorbest = 0; // don't calculate error
}
else
{
// we're calculating the same what we have done already for colors 0-1 above...
for( colors = 0; colors < 3; colors++ )
{
colordist = srccolors[j][i][0] - cv[colors][0];
pixerror = colordist * colordist * REDWEIGHT;
colordist = srccolors[j][i][1] - cv[colors][1];
pixerror += colordist * colordist * GREENWEIGHT;
colordist = srccolors[j][i][2] - cv[colors][2];
pixerror += colordist * colordist * BLUEWEIGHT;
if( pixerror < pixerrorbest )
{
pixerrorbest = pixerror;
// need to exchange colors later
if( colors > 1 ) enc = colors;
else enc = colors ^ 1;
}
}
}
testerror2 += pixerrorbest;
bits2 |= enc << (2 * (j * 4 + i));
}
}
// finally we're finished, write back colors and bits
if((testerror > testerror2) || (haveAlpha))
{
*blkaddr++ = color1 & 0xFF;
*blkaddr++ = color1 >> 8;
*blkaddr++ = color0 & 0xFF;
*blkaddr++ = color0 >> 8;
*blkaddr++ = bits2 & 0xFF;
*blkaddr++ = (bits2 >> 8) & 0xFF;
*blkaddr++ = (bits2 >> 16) & 0xFF;
*blkaddr = bits2 >> 24;
}
else
{
*blkaddr++ = color0 & 0xFF;
*blkaddr++ = color0 >> 8;
*blkaddr++ = color1 & 0xFF;
*blkaddr++ = color1 >> 8;
*blkaddr++ = bits & 0xFF;
*blkaddr++ = ( bits >> 8) & 0xFF;
*blkaddr++ = ( bits >> 16) & 0xFF;
*blkaddr = bits >> 24;
}
}
static void Image_EncodeColorBlock( byte *blkaddr, byte srccolors[4][4][4], int numxpixels, int numypixels, uint type, int flags )
{
// simplistic approach. We need two base colors, simply use the "highest" and the "lowest" color
// present in the picture as base colors
// define lowest and highest color as shortest and longest vector to 0/0/0, though the
// vectors are weighted similar to their importance in rgb-luminance conversion
// doesn't work too well though...
// this seems to be a rather difficult problem
byte *bestcolor[2];
byte basecolors[2][3];
uint lowcv, highcv, testcv;
qboolean haveAlpha = false;
byte i, j;
lowcv = highcv = srccolors[0][0][0] * srccolors[0][0][0] * REDWEIGHT + srccolors[0][0][1] * srccolors[0][0][1] * GREENWEIGHT + srccolors[0][0][2] * srccolors[0][0][2] * BLUEWEIGHT;
bestcolor[0] = bestcolor[1] = srccolors[0][0];
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
// don't use this as a base color if the pixel will get black/transparent anyway
if((type != PF_DXT1) || (srccolors[j][i][3] <= ALPHACUT))
{
testcv = srccolors[j][i][0] * srccolors[j][i][0] * REDWEIGHT + srccolors[j][i][1] * srccolors[j][i][1] * GREENWEIGHT + srccolors[j][i][2] * srccolors[j][i][2] * BLUEWEIGHT;
if( testcv > highcv )
{
highcv = testcv;
bestcolor[1] = srccolors[j][i];
}
else if( testcv < lowcv )
{
lowcv = testcv;
bestcolor[0] = srccolors[j][i];
}
}
else haveAlpha = true;
}
}
if( type != PF_DXT1 )
{
// manually set alpha for DXT3 or DXT5
if( flags & IMAGE_HAS_ALPHA ) haveAlpha = true;
else haveAlpha = false;
}
// make sure the original color values won't get touched...
for( j = 0; j < 2; j++ )
{
for( i = 0; i < 3; i++ )
{
basecolors[j][i] = bestcolor[j][i];
}
}
bestcolor[0] = basecolors[0];
bestcolor[1] = basecolors[1];
// try to find better base colors
Image_BaseColorSearch( blkaddr, srccolors, bestcolor, numxpixels, numypixels, type, haveAlpha );
// find the best encoding for these colors, and store the result
Image_StoreBlock( blkaddr, srccolors, bestcolor, numxpixels, numypixels, type, haveAlpha );
}
static void Image_StoreAlphaBlock( byte *blkaddr, byte alphabase1, byte alphabase2, byte alphaenc[16] )
{
*blkaddr++ = alphabase1;
*blkaddr++ = alphabase2;
*blkaddr++ = alphaenc[0] | (alphaenc[1] << 3) | ((alphaenc[2] & 3) << 6);
*blkaddr++ = (alphaenc[2] >> 2) | (alphaenc[3] << 1) | (alphaenc[4] << 4) | ((alphaenc[5] & 1) << 7);
*blkaddr++ = (alphaenc[5] >> 1) | (alphaenc[6] << 2) | (alphaenc[7] << 5);
*blkaddr++ = alphaenc[8] | (alphaenc[9] << 3) | ((alphaenc[10] & 3) << 6);
*blkaddr++ = (alphaenc[10] >> 2) | (alphaenc[11] << 1) | (alphaenc[12] << 4) | ((alphaenc[13] & 1) << 7);
*blkaddr++ = (alphaenc[13] >> 1) | (alphaenc[14] << 2) | (alphaenc[15] << 5);
}
static void Image_EncodeDXT5alpha( byte *blkaddr, byte srccolors[4][4][4], int numxpixels, int numypixels )
{
byte alphabase[2], alphause[2];
short alphatest[2];
uint alphablockerror1, alphablockerror2, alphablockerror3;
byte i, j, aindex, acutValues[7];
byte alphaenc1[16], alphaenc2[16], alphaenc3[16];
qboolean alphaabsmin = false;
qboolean alphaabsmax = false;
short alphadist;
// find lowest and highest alpha value in block, alphabase[0] lowest, alphabase[1] highest
alphabase[0] = 0xFF;
alphabase[1] = 0x00;
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
if( srccolors[j][i][3] == 0 )
alphaabsmin = true;
else if( srccolors[j][i][3] == 255 )
alphaabsmax = true;
else
{
if( srccolors[j][i][3] > alphabase[1] )
alphabase[1] = srccolors[j][i][3];
if( srccolors[j][i][3] < alphabase[0] )
alphabase[0] = srccolors[j][i][3];
}
}
}
if((alphabase[0] > alphabase[1]) && !(alphaabsmin && alphaabsmax))
{
// one color, either max or min
// shortcut here since it is a very common case (and also avoids later problems)
// || (alphabase[0] == alphabase[1] && !alphaabsmin && !alphaabsmax)
// could also thest for alpha0 == alpha1 (and not min/max), but probably not common, so don't bother
alphabase[0] = srccolors[0][0][3];
*blkaddr++ = alphabase[0];
*blkaddr++;
*blkaddr++ = 0;
*blkaddr++ = 0;
*blkaddr++ = 0;
*blkaddr++ = 0;
*blkaddr++ = 0;
*blkaddr++ = 0;
return;
}
// find best encoding for alpha0 > alpha1
// it's possible this encoding is better even if both alphaabsmin and alphaabsmax are true
alphablockerror1 = 0x0;
alphablockerror2 = 0xffffffff;
alphablockerror3 = 0xffffffff;
if( alphaabsmin ) alphause[0] = 0;
else alphause[0] = alphabase[0];
if( alphaabsmax ) alphause[1] = 255;
else alphause[1] = alphabase[1];
// calculate the 7 cut values, just the middle between 2 of the computed alpha values
for( aindex = 0; aindex < 7; aindex++ )
{
// don't forget here is always rounded down
acutValues[aindex] = (alphause[0] * (2*aindex + 1) + alphause[1] * (14 - (2*aindex + 1))) / 14;
}
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
// maybe it's overkill to have the most complicated calculation just for the error
// calculation which we only need to figure out if encoding1 or encoding2 is better...
if( srccolors[j][i][3] > acutValues[0] )
{
alphaenc1[4*j + i] = 0;
alphadist = srccolors[j][i][3] - alphause[1];
}
else if( srccolors[j][i][3] > acutValues[1] )
{
alphaenc1[4*j + i] = 2;
alphadist = srccolors[j][i][3] - (alphause[1] * 6 + alphause[0] * 1) / 7;
}
else if( srccolors[j][i][3] > acutValues[2] )
{
alphaenc1[4*j + i] = 3;
alphadist = srccolors[j][i][3] - (alphause[1] * 5 + alphause[0] * 2) / 7;
}
else if( srccolors[j][i][3] > acutValues[3] )
{
alphaenc1[4*j + i] = 4;
alphadist = srccolors[j][i][3] - (alphause[1] * 4 + alphause[0] * 3) / 7;
}
else if( srccolors[j][i][3] > acutValues[4] )
{
alphaenc1[4*j + i] = 5;
alphadist = srccolors[j][i][3] - (alphause[1] * 3 + alphause[0] * 4) / 7;
}
else if( srccolors[j][i][3] > acutValues[5] )
{
alphaenc1[4*j + i] = 6;
alphadist = srccolors[j][i][3] - (alphause[1] * 2 + alphause[0] * 5) / 7;
}
else if( srccolors[j][i][3] > acutValues[6] )
{
alphaenc1[4*j + i] = 7;
alphadist = srccolors[j][i][3] - (alphause[1] * 1 + alphause[0] * 6) / 7;
}
else
{
alphaenc1[4*j + i] = 1;
alphadist = srccolors[j][i][3] - alphause[0];
}
alphablockerror1 += alphadist * alphadist;
}
}
// it's not very likely this encoding is better if both alphaabsmin and alphaabsmax
// are false but try it anyway
if( alphablockerror1 >= 32 )
{
// don't bother if encoding is already very good, this condition should also imply
// we have valid alphabase colors which we absolutely need (alphabase[0] <= alphabase[1])
alphablockerror2 = 0;
for( aindex = 0; aindex < 5; aindex++ )
{
// don't forget here is always rounded down
acutValues[aindex] = (alphabase[0] * (10 - (2*aindex + 1)) + alphabase[1] * (2*aindex + 1)) / 10;
}
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
// maybe it's overkill to have the most complicated calculation just for the error
// calculation which we only need to figure out if encoding1 or encoding2 is better...
if( srccolors[j][i][3] == 0 )
{
alphaenc2[4*j + i] = 6;
alphadist = 0;
}
else if( srccolors[j][i][3] == 255 )
{
alphaenc2[4*j + i] = 7;
alphadist = 0;
}
else if( srccolors[j][i][3] <= acutValues[0] )
{
alphaenc2[4*j + i] = 0;
alphadist = srccolors[j][i][3] - alphabase[0];
}
else if( srccolors[j][i][3] <= acutValues[1] )
{
alphaenc2[4*j + i] = 2;
alphadist = srccolors[j][i][3] - (alphabase[0] * 4 + alphabase[1] * 1) / 5;
}
else if( srccolors[j][i][3] <= acutValues[2] )
{
alphaenc2[4*j + i] = 3;
alphadist = srccolors[j][i][3] - (alphabase[0] * 3 + alphabase[1] * 2) / 5;
}
else if( srccolors[j][i][3] <= acutValues[3] )
{
alphaenc2[4*j + i] = 4;
alphadist = srccolors[j][i][3] - (alphabase[0] * 2 + alphabase[1] * 3) / 5;
}
else if( srccolors[j][i][3] <= acutValues[4] )
{
alphaenc2[4*j + i] = 5;
alphadist = srccolors[j][i][3] - (alphabase[0] * 1 + alphabase[1] * 4) / 5;
}
else
{
alphaenc2[4*j + i] = 1;
alphadist = srccolors[j][i][3] - alphabase[1];
}
alphablockerror2 += alphadist * alphadist;
}
}
// skip this if the error is already very small
// this encoding is MUCH better on average than #2 though, but expensive!
if((alphablockerror2 > 96) && (alphablockerror1 > 96))
{
short blockerrlin1 = 0;
short blockerrlin2 = 0;
byte nralphainrangelow = 0;
byte nralphainrangehigh = 0;
alphatest[0] = 0xff;
alphatest[1] = 0x0;
// if we have large range it's likely there are values close to 0/255, try to map them to 0/255
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
if((srccolors[j][i][3] > alphatest[1]) && (srccolors[j][i][3] < (255 -(alphabase[1] - alphabase[0]) / 28)))
alphatest[1] = srccolors[j][i][3];
if((srccolors[j][i][3] < alphatest[0]) && (srccolors[j][i][3] > (alphabase[1] - alphabase[0]) / 28))
alphatest[0] = srccolors[j][i][3];
}
}
// shouldn't happen too often, don't really care about those degenerated cases
if( alphatest[1] <= alphatest[0] )
{
alphatest[0] = 1;
alphatest[1] = 254;
}
for( aindex = 0; aindex < 5; aindex++ )
{
// don't forget here is always rounded down
acutValues[aindex] = (alphatest[0] * (10 - (2*aindex + 1)) + alphatest[1] * (2*aindex + 1)) / 10;
}
// find the "average" difference between the alpha values and the next encoded value.
// this is then used to calculate new base values.
// should there be some weighting, i.e. those values closer to alphatest[x] have more weight,
// since they will see more improvement, and also because the values in the middle are somewhat
// likely to get no improvement at all (because the base values might move in different directions)?
// OTOH it would mean the values in the middle are even less likely to get an improvement
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
if( srccolors[j][i][3] <= alphatest[0] / 2 )
{
// this does nothing
}
else if( srccolors[j][i][3] > ((255 + alphatest[1]) / 2))
{
// this does nothing
}
else if( srccolors[j][i][3] <= acutValues[0] )
{
blockerrlin1 += (srccolors[j][i][3] - alphatest[0]);
nralphainrangelow += 1;
}
else if( srccolors[j][i][3] <= acutValues[1] )
{
blockerrlin1 += (srccolors[j][i][3] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);
blockerrlin2 += (srccolors[j][i][3] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);
nralphainrangelow += 1;
nralphainrangehigh += 1;
}
else if( srccolors[j][i][3] <= acutValues[2] )
{
blockerrlin1 += (srccolors[j][i][3] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);
blockerrlin2 += (srccolors[j][i][3] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);
nralphainrangelow += 1;
nralphainrangehigh += 1;
}
else if( srccolors[j][i][3] <= acutValues[3] )
{
blockerrlin1 += (srccolors[j][i][3] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);
blockerrlin2 += (srccolors[j][i][3] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);
nralphainrangelow += 1;
nralphainrangehigh += 1;
}
else if( srccolors[j][i][3] <= acutValues[4] )
{
blockerrlin1 += (srccolors[j][i][3] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);
blockerrlin2 += (srccolors[j][i][3] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);
nralphainrangelow += 1;
nralphainrangehigh += 1;
}
else
{
blockerrlin2 += (srccolors[j][i][3] - alphatest[1]);
nralphainrangehigh += 1;
}
}
}
// shouldn't happen often, needed to avoid div by zero
if( nralphainrangelow == 0 ) nralphainrangelow = 1;
if( nralphainrangehigh == 0 ) nralphainrangehigh = 1;
alphatest[0] = alphatest[0] + (blockerrlin1 / nralphainrangelow);
// again shouldn't really happen often...
if( alphatest[0] < 0 )
{
alphatest[0] = 0;
}
alphatest[1] = alphatest[1] + (blockerrlin2 / nralphainrangehigh);
if( alphatest[1] > 255 )
{
alphatest[1] = 255;
}
alphablockerror3 = 0;
for( aindex = 0; aindex < 5; aindex++ )
{
// don't forget here is always rounded down
acutValues[aindex] = (alphatest[0] * (10 - (2*aindex + 1)) + alphatest[1] * (2*aindex + 1)) / 10;
}
for( j = 0; j < numypixels; j++ )
{
for( i = 0; i < numxpixels; i++ )
{
// maybe it's overkill to have the most complicated calculation just for the error
// calculation which we only need to figure out if encoding1 or encoding2 is better...
if( srccolors[j][i][3] <= alphatest[0] / 2 )
{
alphaenc3[4*j + i] = 6;
alphadist = srccolors[j][i][3];
}
else if( srccolors[j][i][3] > ((255 + alphatest[1]) / 2))
{
alphaenc3[4*j + i] = 7;
alphadist = 255 - srccolors[j][i][3];
}
else if( srccolors[j][i][3] <= acutValues[0] )
{
alphaenc3[4*j + i] = 0;
alphadist = srccolors[j][i][3] - alphatest[0];
}
else if( srccolors[j][i][3] <= acutValues[1] )
{
alphaenc3[4*j + i] = 2;
alphadist = srccolors[j][i][3] - (alphatest[0] * 4 + alphatest[1] * 1) / 5;
}
else if( srccolors[j][i][3] <= acutValues[2] )
{
alphaenc3[4*j + i] = 3;
alphadist = srccolors[j][i][3] - (alphatest[0] * 3 + alphatest[1] * 2) / 5;
}
else if( srccolors[j][i][3] <= acutValues[3] )
{
alphaenc3[4*j + i] = 4;
alphadist = srccolors[j][i][3] - (alphatest[0] * 2 + alphatest[1] * 3) / 5;
}
else if( srccolors[j][i][3] <= acutValues[4] )
{
alphaenc3[4*j + i] = 5;
alphadist = srccolors[j][i][3] - (alphatest[0] * 1 + alphatest[1] * 4) / 5;
}
else
{
alphaenc3[4*j + i] = 1;
alphadist = srccolors[j][i][3] - alphatest[1];
}
alphablockerror3 += alphadist * alphadist;
}
}
}
}
// write the alpha values and encoding back.
if((alphablockerror1 <= alphablockerror2) && (alphablockerror1 <= alphablockerror3))
Image_StoreAlphaBlock( blkaddr, alphause[1], alphause[0], alphaenc1 );
else if( alphablockerror2 <= alphablockerror3 )
Image_StoreAlphaBlock( blkaddr, alphabase[0], alphabase[1], alphaenc2 );
else Image_StoreAlphaBlock( blkaddr, (byte)alphatest[0], (byte)alphatest[1], alphaenc3 );
}
static void Image_ExtractColors( byte srcpixels[4][4][4], const byte *srcaddr, int srcRowStride, int numxpixels, int numypixels, int comps )
{
const byte *curaddr;
byte i, j, c;
for( j = 0; j < numypixels; j++ )
{
curaddr = srcaddr + j * srcRowStride * comps;
for( i = 0; i < numxpixels; i++ )
{
for( c = 0; c < comps; c++ )
srcpixels[j][i][c] = *curaddr++ / (CHAN_MAX / 255);
}
}
}
/*
====================
Image_DXTReadColors
read colors from dxt image
====================
*/
void Image_DXTReadColors( const byte* data, color32* out )
{
byte r0, g0, b0, r1, g1, b1;
b0 = data[0] & 0x1F;
g0 = ((data[0] & 0xE0) >> 5) | ((data[1] & 0x7) << 3);
r0 = (data[1] & 0xF8) >> 3;
b1 = data[2] & 0x1F;
g1 = ((data[2] & 0xE0) >> 5) | ((data[3] & 0x7) << 3);
r1 = (data[3] & 0xF8) >> 3;
out[0].r = r0<<3;
out[0].g = g0<<2;
out[0].b = b0<<3;
out[1].r = r1<<3;
out[1].g = g1<<2;
out[1].b = b1<<3;
}
/*
====================
Image_DXTReadColor
read one color from dxt image
====================
*/
void Image_DXTReadColor( word data, color32* out )
{
byte r, g, b;
b = data & 0x1f;
g = (data & 0x7E0) >>5;
r = (data & 0xF800)>>11;
out->r = r << 3;
out->g = g << 2;
out->b = b << 3;
}
void Image_CorrectPreMult( uint *data, int datasize )
{
int i;
for( i = 0; i < datasize; i += 4 )
{
if( data[i+3] != 0 ) // don't divide by 0.
{
data[i+0] = (byte)(((uint)data[i+0]<<8) / data[i+3]);
data[i+1] = (byte)(((uint)data[i+1]<<8) / data[i+3]);
data[i+2] = (byte)(((uint)data[i+2]<<8) / data[i+3]);
}
}
}
/*
====================
Image_GetBitsFromMask
====================
*/
void Image_GetBitsFromMask( uint Mask, uint *ShiftLeft, uint *ShiftRight )
{
uint Temp, i;
if( Mask == 0 )
{
*ShiftLeft = *ShiftRight = 0;
return;
}
Temp = Mask;
for (i = 0; i < 32; i++, Temp >>= 1)
{
if (Temp & 1) break;
}
*ShiftRight = i;
// Temp is preserved, so use it again:
for (i = 0; i < 8; i++, Temp >>= 1)
{
if(!(Temp & 1)) break;
}
*ShiftLeft = 8 - i;
}
qboolean Image_DXTWriteHeader( vfile_t *f, rgbdata_t *pix )
{
uint dwFourCC = 0, dwFlags1 = 0, dwFlags2 = 0, dwCaps1 = 0, dwCaps2 = 0;
uint dwLinearSize, dwBlockSize, dwSize = 124, dwSize2 = sizeof( dds_pixf_t );
uint dwRBitMask = 0, dwGBitMask = 0, dwBBitMask = 0, dwABitMask = 0;
uint dwWidth, dwHeight, dwDepth, dwMipCount;
uint dwIdent = DDSHEADER;
uint dwRGBBitCount = 0;
if( !pix || !pix->buffer )
return false;
// setup flags
dwFlags1 |= DDS_LINEARSIZE|DDS_WIDTH|DDS_HEIGHT|DDS_CAPS|DDS_PIXELFORMAT|DDS_PITCH;
dwFlags2 |= DDS_FOURCC;
dwMipCount = pix->numMips;
if( dwMipCount > 1 ) dwFlags1 |= DDS_MIPMAPCOUNT;
if( pix->depth > 1 ) dwFlags1 |= DDS_DEPTH;
switch( pix->type )
{
case PF_DXT1:
dwFourCC = TYPE_DXT1;
break;
case PF_DXT2:
dwFourCC = TYPE_DXT2;
break;
case PF_DXT3:
dwFourCC = TYPE_DXT3;
break;
case PF_DXT4:
dwFourCC = TYPE_DXT4;
break;
case PF_DXT5:
dwFourCC = TYPE_DXT5;
break;
case PF_ABGR_64:
dwFourCC = TYPE_$;
break;
case PF_R_16F:
dwFourCC = TYPE_o;
break;
case PF_GR_32F:
dwFourCC = TYPE_p;
break;
case PF_ABGR_64F:
dwFourCC = TYPE_q;
break;
case PF_R_32F:
dwFourCC = TYPE_r;
break;
case PF_GR_64F:
dwFourCC = TYPE_s;
break;
case PF_ABGR_128F:
dwFourCC = TYPE_t;
break;
default:
dwFlags2 &= ~DDS_FOURCC;
break;
}
// continue choosing format
if(!(dwFlags2 & DDS_FOURCC ))
{
switch( pix->type )
{
case PF_LUMINANCE:
dwABitMask = 0x000000FF;
dwFlags2 |= DDS_LUMINANCE;
dwRGBBitCount = 8;
break;
case PF_UV_16:
dwRBitMask = 0x000000FF;
dwGBitMask = 0x0000FF00;
dwFlags2 |= DDS_DUDV;
dwRGBBitCount = 16;
break;
case PF_UV_32:
dwRBitMask = 0x0000FFFF;
dwGBitMask = 0xFFFF0000;
dwFlags2 |= DDS_DUDV;
dwRGBBitCount = 32;
break;
case PF_LUMINANCE_ALPHA:
dwRBitMask = 0x000000FF;
dwABitMask = 0xFF000000;
dwFlags2 |= DDS_LUMINANCE;
dwFlags2 |= DDS_ALPHAPIXELS;
dwRGBBitCount = 16;
break;
case PF_BGR_24:
dwRBitMask = 0x000000FF;
dwGBitMask = 0x0000FF00;
dwBBitMask = 0x00FF0000;
dwFlags2 |= DDS_RGB;
dwRGBBitCount = 24;
break;
case PF_RGB_24:
dwRBitMask = 0x00FF0000;
dwGBitMask = 0x0000FF00;
dwBBitMask = 0x000000FF;
dwFlags2 |= DDS_RGB;
dwRGBBitCount = 24;
break;
case PF_BGRA_32:
dwRBitMask = 0x000000FF;
dwGBitMask = 0x0000FF00;
dwBBitMask = 0x00FF0000;
dwABitMask = 0xFF000000;
dwFlags2 |= DDS_RGBA;
dwRGBBitCount = 32;
break;
case PF_RGBA_32:
dwRBitMask = 0x00FF0000;
dwGBitMask = 0x0000FF00;
dwBBitMask = 0x000000FF;
dwABitMask = 0xFF000000;
dwFlags2 |= DDS_RGBA;
dwRGBBitCount = 32;
break;
default:
MsgDev( D_ERROR, "Image_DXTWriteHeader: unsupported type %s\n", PFDesc[pix->type].name );
return false;
}
}
dwWidth = pix->width;
dwHeight = pix->height;
VFS_Write( f, &dwIdent, sizeof(uint));
VFS_Write( f, &dwSize, sizeof(uint));
VFS_Write( f, &dwFlags1, sizeof(uint));
VFS_Write( f, &dwHeight, sizeof(uint));
VFS_Write( f, &dwWidth, sizeof(uint));
dwBlockSize = PFDesc[pix->type].block;
dwLinearSize = Image_DXTGetLinearSize( pix->type, pix->width, pix->height, 1, pix->bitsCount / 8 );
VFS_Write( f, &dwLinearSize, sizeof( uint ));
if( pix->depth > 1 )
{
dwDepth = pix->depth;
VFS_Write( f, &dwDepth, sizeof( uint ));
dwCaps2 |= DDS_VOLUME;
}
else VFS_Write( f, 0, sizeof( uint ));
VFS_Write( f, &dwMipCount, sizeof( uint ));
VFS_Write( f, 0, sizeof(uint));
VFS_Write( f, 0, sizeof(uint) * 10 ); // reserved fields
VFS_Write( f, &dwSize2, sizeof( uint ));
VFS_Write( f, &dwFlags2, sizeof( uint ));
VFS_Write( f, &dwFourCC, sizeof( uint ));
VFS_Write( f, &dwRGBBitCount, sizeof( uint ));
VFS_Write( f, &dwRBitMask, sizeof( uint ));
VFS_Write( f, &dwGBitMask, sizeof( uint ));
VFS_Write( f, &dwBBitMask, sizeof( uint ));
VFS_Write( f, &dwABitMask, sizeof( uint ));
dwCaps1 |= DDS_TEXTURE;
if( pix->numMips > 1 ) dwCaps1 |= DDS_MIPMAP|DDS_COMPLEX;
if( pix->flags & IMAGE_CUBEMAP )
{
dwCaps1 |= DDS_COMPLEX;
dwCaps2 |= DDS_CUBEMAP;
dwCaps2 |= DDS_CUBEMAP_ALL_SIDES;
}
VFS_Write( f, &dwCaps1, sizeof( uint ));
VFS_Write( f, &dwCaps2, sizeof( uint ));
VFS_Write( f, 0, sizeof( uint ) * 3 ); // other caps and TextureStage
return true;
}
size_t Image_DXTGetLinearSize( int type, int width, int height, int depth, int rgbcount )
{
size_t BlockSize = 0;
int block, bpp;
// right calcualte blocksize
block = PFDesc[type].block;
bpp = PFDesc[type].bpp;
if( block == 0 ) BlockSize = width * height * bpp;
else if( block > 0 ) BlockSize = ((width + 3)/4) * ((height + 3)/4) * depth * block;
else if( block < 0 && rgbcount > 0 ) BlockSize = width * height * depth * rgbcount;
else BlockSize = width * height * abs( block );
return BlockSize;
}
size_t Image_CompressDXT( vfile_t *f, int saveformat, rgbdata_t *pix )
{
byte srcpixels[4][4][4];
int numxpixels, numypixels;
int i, j, width, height;
const byte *srcaddr;
byte *blkaddr;
size_t dst_size;
int srccomps;
if( !pix || !pix->buffer )
return 0;
width = pix->width;
height = pix->height;
dst_size = Image_DXTGetLinearSize( saveformat, width, height, 1, 0 );
srccomps = PFDesc[pix->type].bpp;
blkaddr = image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, dst_size ); // alloc dst image size
switch( saveformat )
{
case PF_DXT1:
for( j = 0; j < height; j += 4 )
{
if( height > j + 3 ) numypixels = 4;
else numypixels = height - j;
srcaddr = pix->buffer + j * width * srccomps;
for( i = 0; i < width; i += 4 )
{
if( width > i + 3 ) numxpixels = 4;
else numxpixels = width - i;
Image_ExtractColors( srcpixels, srcaddr, width, numxpixels, numypixels, srccomps );
Image_EncodeColorBlock( blkaddr, srcpixels, numxpixels, numypixels, saveformat, pix->flags );
srcaddr += srccomps * numxpixels;
blkaddr += 8;
}
}
break;
case PF_DXT3:
for( j = 0; j < height; j += 4 )
{
if( height > j + 3 ) numypixels = 4;
else numypixels = height - j;
srcaddr = pix->buffer + j * width * srccomps;
for( i = 0; i < width; i += 4 )
{
if( width > i + 3 ) numxpixels = 4;
else numxpixels = width - i;
Image_ExtractColors( srcpixels, srcaddr, width, numxpixels, numypixels, srccomps );
*blkaddr++ = (srcpixels[0][0][3] >> 4) | (srcpixels[0][1][3] & 0xf0);
*blkaddr++ = (srcpixels[0][2][3] >> 4) | (srcpixels[0][3][3] & 0xf0);
*blkaddr++ = (srcpixels[1][0][3] >> 4) | (srcpixels[1][1][3] & 0xf0);
*blkaddr++ = (srcpixels[1][2][3] >> 4) | (srcpixels[1][3][3] & 0xf0);
*blkaddr++ = (srcpixels[2][0][3] >> 4) | (srcpixels[2][1][3] & 0xf0);
*blkaddr++ = (srcpixels[2][2][3] >> 4) | (srcpixels[2][3][3] & 0xf0);
*blkaddr++ = (srcpixels[3][0][3] >> 4) | (srcpixels[3][1][3] & 0xf0);
*blkaddr++ = (srcpixels[3][2][3] >> 4) | (srcpixels[3][3][3] & 0xf0);
Image_EncodeColorBlock( blkaddr, srcpixels, numxpixels, numypixels, saveformat, pix->flags );
srcaddr += srccomps * numxpixels;
blkaddr += 8;
}
}
break;
case PF_DXT5:
for( j = 0; j < height; j += 4 )
{
if( height > j + 3 ) numypixels = 4;
else numypixels = height - j;
srcaddr = pix->buffer + j * width * srccomps;
for( i = 0; i < width; i += 4 )
{
if( width > i + 3 ) numxpixels = 4;
else numxpixels = width - i;
Image_ExtractColors( srcpixels, srcaddr, width, numxpixels, numypixels, srccomps );
Image_EncodeDXT5alpha( blkaddr, srcpixels, numxpixels, numypixels );
Image_EncodeColorBlock( blkaddr + 8, srcpixels, numxpixels, numypixels, saveformat, pix->flags );
srcaddr += srccomps * numxpixels;
blkaddr += 16;
}
}
break;
default:
MsgDev( D_ERROR, "Image_CompressDXT: bad destination format %s\n", PFDesc[saveformat].name );
return 0;
}
dst_size = VFS_Write( f, image.tempbuffer, dst_size );
return dst_size;
}
void Image_CompressDDS( vfile_t *f, byte *buffer )
{
#if 0
int i, size = 0;
int w = image.curwidth;
int h = image.curheight;
int d = image.curdepth;
for( i = 0; i < image.cur_mips; i++, buffer += size )
{
Image_SetPixelFormat( w, h, d );
size = image.SizeOfFile;
if(!image.decompress( target, i, image.type, w, h, size, buffer ))
break; // there were errors
w = (w+1)>>1, h = (h+1)>>1, d = (d+1)>>1; // calc size of next mip
}
#endif
}
qboolean Image_DXTWriteImage( vfile_t *f, rgbdata_t *pix )
{
byte *in, *out, *buffer;
int i, bpp = PFDesc[pix->type].bpp;
// just write input buffer as valid
switch( pix->type )
{
case PF_RGB_24:
case PF_RGBA_32:
in = pix->buffer; // filp to BGRA
buffer = image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, pix->size );
for( i = 0, out = image.tempbuffer; i < pix->size; i += bpp, in += bpp )
{
*out++ = in[2];
*out++ = in[1];
*out++ = in[0];
if( pix->type == PF_RGBA_32 )
*out++ = in[3];
}
break;
case PF_BGR_24:
case PF_BGRA_32:
case PF_LUMINANCE:
case PF_LUMINANCE_ALPHA:
case PF_UV_16:
case PF_UV_32:
case PF_DXT1:
case PF_DXT3:
case PF_DXT5:
case PF_ABGR_64F:
buffer = pix->buffer;
break;
default: return false;
}
VFS_Write( f, buffer, pix->size );
return true;
}
void Image_DXTGetPixelFormat( dds_t *hdr )
{
uint bits = hdr->dsPixelFormat.dwRGBBitCount;
// All volume textures I've seem so far didn't have the DDS_COMPLEX flag set,
// even though this is normally required. But because noone does set it,
// also read images without it (TODO: check file size for 3d texture?)
if (!(hdr->dsCaps.dwCaps2 & DDS_VOLUME)) hdr->dwDepth = 1;
image.flags |= IMAGE_HAS_COLOR; // predict state
if( hdr->dsPixelFormat.dwFlags & DDS_ALPHA )
image.flags |= IMAGE_HAS_ALPHA;
if( hdr->dsPixelFormat.dwFlags & DDS_LUMINANCE )
image.flags &= ~IMAGE_HAS_COLOR;
if( hdr->dsPixelFormat.dwFlags & DDS_FOURCC )
{
switch( hdr->dsPixelFormat.dwFourCC )
{
case TYPE_DXT1: image.type = PF_DXT1; break;
case TYPE_DXT2: image.type = PF_DXT2; break;
case TYPE_DXT3: image.type = PF_DXT3; break;
case TYPE_DXT4: image.type = PF_DXT4; break;
case TYPE_DXT5: image.type = PF_DXT5; break;
case TYPE_ATI1: image.type = PF_ATI1N; break;
case TYPE_ATI2: image.type = PF_ATI2N; break;
case TYPE_RXGB: image.type = PF_RXGB; break;
case TYPE_$: image.type = PF_ABGR_64; break;
case TYPE_o: image.type = PF_R_16F; break;
case TYPE_p: image.type = PF_GR_32F; break;
case TYPE_q: image.type = PF_ABGR_64F; break;
case TYPE_r: image.type = PF_R_32F;
case TYPE_s: image.type = PF_GR_64F;
case TYPE_t: image.type = PF_ABGR_128F; break;
default: image.type = PF_UNKNOWN; break;
}
}
else
{
// this dds texture isn't compressed so write out ARGB or luminance format
if( hdr->dsPixelFormat.dwFlags & DDS_DUDV )
{
if( hdr->dsPixelFormat.dwRGBBitCount == 16 )
image.type = PF_UV_16;
else if( hdr->dsPixelFormat.dwRGBBitCount == 32 )
image.type = PF_UV_32;
}
else if( hdr->dsPixelFormat.dwFlags & DDS_LUMINANCE )
{
if( hdr->dsPixelFormat.dwFlags & DDS_ALPHAPIXELS )
image.type = PF_LUMINANCE_ALPHA;
else if( hdr->dsPixelFormat.dwRGBBitCount == 16 && hdr->dsPixelFormat.dwRBitMask == 0xFFFF )
image.type = PF_LUMINANCE_16;
else image.type = PF_LUMINANCE;
}
else
{
if( bits == 32 ) image.type = PF_ABGR_64;
else if( bits == 24 ) image.type = PF_BGR_24;
else image.type = PF_ARGB_32;
}
}
// setup additional flags
if( hdr->dsCaps.dwCaps1 & DDS_COMPLEX && hdr->dsCaps.dwCaps2 & DDS_CUBEMAP )
image.flags |= IMAGE_CUBEMAP;
if( hdr->dsPixelFormat.dwFlags & DDS_ALPHAPIXELS )
image.flags |= IMAGE_HAS_ALPHA;
if( hdr->dwFlags & DDS_MIPMAPCOUNT )
image.num_mips = hdr->dwMipMapCount;
else image.num_mips = 1;
if( image.type == PF_ARGB_32 || image.type == PF_LUMINANCE || image.type == PF_LUMINANCE_16 || image.type == PF_LUMINANCE_ALPHA )
{
// store RGBA mask into palette space
byte *tmp = image.palette = Mem_Alloc( Sys.imagepool, sizeof(uint) * 4 );
Mem_Copy( tmp, &hdr->dsPixelFormat.dwRBitMask, sizeof( uint )); tmp += 4;
Mem_Copy( tmp, &hdr->dsPixelFormat.dwGBitMask, sizeof( uint )); tmp += 4;
Mem_Copy( tmp, &hdr->dsPixelFormat.dwBBitMask, sizeof( uint )); tmp += 4;
Mem_Copy( tmp, &hdr->dsPixelFormat.dwABitMask, sizeof( uint )); tmp += 4;
}
}
void Image_DXTAdjustVolume( dds_t *hdr )
{
uint bits;
if( hdr->dwDepth <= 1 ) return;
bits = hdr->dsPixelFormat.dwRGBBitCount / 8;
hdr->dwFlags |= DDS_LINEARSIZE;
hdr->dwLinearSize = Image_DXTGetLinearSize( image.type, hdr->dwWidth, hdr->dwHeight, hdr->dwDepth, bits );
}
uint Image_DXTCalcMipmapSize( dds_t *hdr )
{
uint buffsize = 0;
int w = hdr->dwWidth;
int h = hdr->dwHeight;
int d = hdr->dwDepth;
int i, mipsize = 0;
int bits = hdr->dsPixelFormat.dwRGBBitCount / 8;
// now correct buffer size
for( i = 0; i < image.num_mips; i++, buffsize += mipsize )
{
mipsize = Image_DXTGetLinearSize( image.type, w, h, d, bits );
w = (w+1)>>1, h = (h+1)>>1, d = (d+1)>>1;
}
return buffsize;
}
uint Image_DXTCalcSize( const char *name, dds_t *hdr, size_t filesize )
{
size_t buffsize = 0;
int w = image.width;
int h = image.height;
int d = image.depth;
if( hdr->dsCaps.dwCaps2 & DDS_CUBEMAP )
{
// cubemap w*h always match for all sides
buffsize = Image_DXTCalcMipmapSize( hdr ) * 6;
}
else if( hdr->dwFlags & DDS_MIPMAPCOUNT )
{
// if mipcount > 1
buffsize = Image_DXTCalcMipmapSize( hdr );
}
else if( hdr->dwFlags & (DDS_LINEARSIZE|DDS_PITCH))
{
// just in case (no need, really)
buffsize = hdr->dwLinearSize;
}
else
{
// pretty solution for microsoft bug
buffsize = Image_DXTCalcMipmapSize( hdr );
}
if( filesize != buffsize ) // main check
{
MsgDev( D_WARN, "LoadDDS: (%s) probably corrupted(%i should be %i)\n", name, buffsize, filesize );
return false;
}
return buffsize;
}
void Image_AddRGBAToPack( uint target, int level, uint imageSize, const void* data )
{
// NOTE: just update bufer without checking for a type
image.rgba = Mem_Realloc( Sys.imagepool, image.rgba, image.ptr + imageSize );
Mem_Copy( image.rgba + image.ptr, data, imageSize ); // add mipmap or cubemapside
image.size += imageSize; // update image size
image.ptr += imageSize;
image.num_mips++;
}
/*
=============
Image_SetPixelFormat
update pixel format for miplevel or layer
=============
*/
void Image_SetPixelFormat( int width, int height, int depth )
{
image.bpp = PFDesc[image.type].bpp;
image.bpc = PFDesc[image.type].bpc;
image.curdepth = depth;
image.curwidth = width;
image.curheight = height;
image.bps = image.curwidth * image.bpp * image.bpc;
image.SizeOfPlane = image.bps * image.curheight;
image.SizeOfData = image.SizeOfPlane * image.curdepth;
// NOTE: size of current miplevel or cubemap side, not total (filesize - sizeof( header ))
image.SizeOfFile = Image_DXTGetLinearSize( image.type, width, height, depth, image.bits_count / 8 );
}
qboolean Image_DecompressFloat( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
uint floatformat = 0;
uint i, size = 0;
uint pixformat = PFDesc[intformat].format;
word *src = (word *)data;
uint *dest;
if( !src ) return false;
switch( pixformat )
{
case PF_R_16F:
case PF_GR_32F:
case PF_ABGR_64F:
size = width * height * image.curdepth * image.bpp;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
dest = (uint *)image.tempbuffer;
for( i = 0; i < size; i++, dest++, src++ )
*dest = Image_ShortToFloat( *src );
break;
case PF_R_32F:
case PF_GR_64F:
case PF_ABGR_128F:
size = image.SizeOfData;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
dest = (uint *)image.tempbuffer;
Mem_Copy( dest, data, image.SizeOfData );
break;
default: return false;
}
Image_AddRGBAToPack( target, level, size, dest );
return true;
}
qboolean Image_DecompressATI( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
int x, y, z, i, j, k, t1, t2, size;
byte Colours[8], XColours[8], YColours[8];
uint bitmask, bitmask2, CurrOffset, Offset = 0;
byte *fin, *fin2, *fout;
qboolean has_alpha = false;
if( !data ) return false;
fin = (byte *)data;
size = width * height * image.curdepth * 4;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
switch( PFDesc[intformat].format )
{
case PF_ATI1N:
image.flags &= ~IMAGE_HAS_COLOR;
image.flags |= IMAGE_HAS_ALPHA;
for( z = 0; z < image.curdepth; z++ )
{
for( y = 0; y < height; y += 4 )
{
for( x = 0; x < width; x += 4 )
{
// read palette
t1 = Colours[0] = fin[0];
t2 = Colours[1] = fin[1];
fin += 2;
if( t1 > t2 )
{
for( i = 2; i < 8; i++ )
Colours[i] = t1 + ((t2 - t1) * (i - 1)) / 7;
}
else
{
for( i = 2; i < 6; i++ )
Colours[i] = t1 + ((t2 - t1) * (i - 1)) / 5;
Colours[6] = 0;
Colours[7] = 0xFF;
}
// decompress pixel data
CurrOffset = Offset;
for( k = 0; k < 4; k += 2 )
{
// first three bytes
bitmask = ((uint)(fin[0]) << 0) | ((uint)(fin[1]) << 8) | ((uint)(fin[2]) << 16);
for( j = 0; j < 2; j++ )
{
// only put pixels out < height
if((y + k + j) < height )
{
for( i = 0; i < 4; i++ )
{
// only put pixels out < width
if((x + i) < width )
{
t1 = CurrOffset + (x + i);
fout[t1*4+0] = Colours[bitmask & 0x07];
fout[t1*4+1] = Colours[bitmask & 0x07];
fout[t1*4+2] = Colours[bitmask & 0x07];
fout[t1*4+3] = Colours[bitmask & 0x07];
}
bitmask >>= 3;
}
CurrOffset += image.bps;
}
}
fin += 3;
}
}
Offset += image.bps * 4;
}
}
break;
case PF_ATI2N:
image.flags |= IMAGE_HAS_COLOR;
image.flags &= ~IMAGE_HAS_ALPHA;
for( z = 0; z < image.curdepth; z++ )
{
for( y = 0; y < height; y += 4 )
{
for( x = 0; x < width; x += 4 )
{
fin2 = fin + 8;
// read Y palette
t1 = YColours[0] = fin[0];
t2 = YColours[1] = fin[1];
fin += 2;
if( t1 > t2 )
{
for( i = 2; i < 8; i++ )
YColours[i] = t1 + ((t2 - t1) * (i - 1)) / 7;
}
else
{
for( i = 2; i < 6; i++ )
YColours[i] = t1 + ((t2 - t1) * (i - 1)) / 5;
YColours[6] = 0;
YColours[7] = 0xFF;
}
// read X palette
t1 = XColours[0] = fin2[0];
t2 = XColours[1] = fin2[1];
fin2 += 2;
if( t1 > t2 )
{
for( i = 2; i < 8; ++i )
XColours[i] = t1 + ((t2 - t1) * (i - 1)) / 7;
}
else
{
for( i = 2; i < 6; ++i )
XColours[i] = t1 + ((t2 - t1) * (i - 1)) / 5;
XColours[6] = 0;
XColours[7] = 0xFF;
}
// decompress pixel data
CurrOffset = Offset;
for( k = 0; k < 4; k += 2 )
{
// first three bytes
bitmask = ((uint)(fin[0]) << 0) | ((uint)(fin[1]) << 8) | ((uint)(fin[2]) << 16);
bitmask2 = ((uint)(fin2[0]) << 0) | ((uint)(fin2[1]) << 8) | ((uint)(fin2[2]) << 16);
for( j = 0; j < 2; j++ )
{
// only put pixels out < height
if((y + k + j) < height )
{
for( i = 0; i < 4; i++ )
{
// only put pixels out < width
if((x + i) < width )
{
int t, tx, ty;
t1 = CurrOffset + (x + i) * 4;
fout[t1+1] = ty = YColours[bitmask & 0x07];
fout[t1+0] = tx = XColours[bitmask2 & 0x07];
// calculate b (z) component ((r/255)^2 + (g/255)^2 + (b/255)^2 = 1
t = 127 * 128 - (tx - 127) * (tx - 128) - (ty - 127) * (ty - 128);
if( t > 0 ) fout[t1+2] = (byte)(com.sqrt( t ) + 128);
else fout[t1+2] = 0x7F;
fout[t1+3] = 0xFF;
}
bitmask >>= 3;
bitmask2 >>= 3;
}
CurrOffset += image.bps;
}
}
fin += 3;
fin2 += 3;
}
// skip bytes that were read via fin2
fin += 8;
}
Offset += image.bps * 4;
}
}
break;
default: return false;
}
// make some post operations
Image_AddRGBAToPack( target, level, size, fout );
return true;
}
qboolean Image_DecompressDXT( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
color32 colours[4], *col;
color16 *color_0, *color_1;
word sAlpha, sColor0, sColor1;
uint bits, bitmask, Offset, size;
byte alphas[8], *alpha, *alphamask;
int w, h, x, y, z, i, j, k, Select;
qboolean has_alpha = false;
byte *fin, *fout;
if( !data ) return false;
fin = (byte *)data;
w = width;
h = height;
size = width * height * image.curdepth * 4;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
switch( PFDesc[intformat].format )
{
case PF_DXT1:
colours[0].a = 0xFF;
colours[1].a = 0xFF;
colours[2].a = 0xFF;
for( z = 0; z < image.curdepth; z++ )
{
for( y = 0; y < h; y += 4 )
{
for( x = 0; x < w; x += 4 )
{
sColor0 = *((word*)fin);
sColor0 = sColor0;
sColor1 = *((word*)(fin + 2));
sColor1 = sColor1;
Image_DXTReadColor(sColor0, colours);
Image_DXTReadColor(sColor1, colours + 1);
bitmask = ((uint*)fin)[1];
fin += 8;
if (sColor0 > sColor1)
{
// four-color block: derive the other two colors.
// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// These 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
colours[3].a = 0xFF;
}
else
{
// three-color block: derive the other color.
// 00 = color_0, 01 = color_1, 10 = color_2,
// 11 = transparent.
// These 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (colours[0].b + colours[1].b) / 2;
colours[2].g = (colours[0].g + colours[1].g) / 2;
colours[2].r = (colours[0].r + colours[1].r) / 2;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
colours[3].a = 0x00;
}
for( j = 0, k = 0; j < 4; j++ )
{
for( i = 0; i < 4; i++, k++ )
{
Select = (bitmask & (0x03 << k*2)) >> k*2;
col = &colours[Select];
if (((x + i) < w) && ((y + j) < h))
{
uint ofs = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp;
fout[ofs+0] = col->r;
fout[ofs+1] = col->g;
fout[ofs+2] = col->b;
fout[ofs+3] = col->a;
if( col->a == 0 ) has_alpha = true;
}
}
}
}
}
}
break;
case PF_DXT2:
image.flags |= IMAGE_PREMULT;
// intentional fallthrough
case PF_DXT3:
for( z = 0; z < image.curdepth; z++ )
{
for( y = 0; y < h; y += 4 )
{
for( x = 0; x < w; x += 4 )
{
alpha = fin;
fin += 8;
Image_DXTReadColors( fin, colours );
bitmask = ((uint*)fin)[1];
fin += 8;
// four-color block: derive the other two colors.
// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// These 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
k = 0;
for( j = 0; j < 4; j++ )
{
for( i = 0; i < 4; i++, k++ )
{
Select = (bitmask & (0x03 << k*2)) >> k*2;
col = &colours[Select];
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp;
fout[Offset + 0] = col->r;
fout[Offset + 1] = col->g;
fout[Offset + 2] = col->b;
}
}
}
for( j = 0; j < 4; j++ )
{
sAlpha = alpha[2*j] + 256*alpha[2*j+1];
for( i = 0; i < 4; i++ )
{
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp + 3;
fout[Offset] = sAlpha & 0x0F;
fout[Offset] = fout[Offset] | (fout[Offset]<<4);
if(sAlpha == 0) has_alpha = true;
}
sAlpha >>= 4;
}
}
}
}
}
break;
case PF_DXT4:
image.flags |= IMAGE_PREMULT;
// intentional fallthrough
case PF_DXT5:
for( z = 0; z < image.curdepth; z++ )
{
for( y = 0; y < h; y += 4 )
{
for( x = 0; x < w; x += 4 )
{
if( y >= h || x >= w ) break;
alphas[0] = fin[0];
alphas[1] = fin[1];
alphamask = fin + 2;
fin += 8;
Image_DXTReadColors(fin, colours);
bitmask = ((uint*)fin)[1];
fin += 8;
// four-color block: derive the other two colors.
// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// these 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
k = 0;
for( j = 0; j < 4; j++ )
{
for( i = 0; i < 4; i++, k++ )
{
Select = (bitmask & (0x03 << k*2)) >> k*2;
col = &colours[Select];
// only put pixels out < width or height
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp;
fout[Offset+0] = col->r;
fout[Offset+1] = col->g;
fout[Offset+2] = col->b;
}
}
}
// 8-alpha or 6-alpha block?
if( alphas[0] > alphas[1] )
{
// 8-alpha block: derive the other six alphas.
// bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010
alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011
alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100
alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101
alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110
alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111
}
else
{
// 6-alpha block.
// bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // bit code 010
alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // bit code 011
alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // bit code 100
alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // bit code 101
alphas[6] = 0x00; // bit code 110
alphas[7] = 0xFF; // bit code 111
}
// NOTE: Have to separate the next two loops,
// it operates on a 6-byte system.
// first three bytes
bits = (alphamask[0]) | (alphamask[1] << 8) | (alphamask[2] << 16);
for( j = 0; j < 2; j++ )
{
for( i = 0; i < 4; i++ )
{
// only put pixels out < width or height
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp + 3;
fout[Offset] = alphas[bits & 0x07];
}
bits >>= 3;
}
}
// last three bytes
bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16);
for( j = 2; j < 4; j++ )
{
for( i = 0; i < 4; i++ )
{
// only put pixels out < width or height
if (((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp + 3;
fout[Offset] = alphas[bits & 0x07];
if( bits & 0x07 ) has_alpha = true;
}
bits >>= 3;
}
}
}
}
}
break;
case PF_RXGB:
for( z = 0; z < image.curdepth; z++ )
{
for( y = 0; y < h; y += 4 )
{
for( x = 0; x < w; x += 4 )
{
if( y >= h || x >= w ) break;
alphas[0] = fin[0];
alphas[1] = fin[1];
alphamask = fin + 2;
fin += 8;
color_0 = ((color16*)fin);
color_1 = ((color16*)(fin+2));
bitmask = ((uint*)fin)[1];
fin += 8;
colours[0].r = color_0->r << 3;
colours[0].g = color_0->g << 2;
colours[0].b = color_0->b << 3;
colours[0].a = 0xFF;
colours[1].r = color_1->r << 3;
colours[1].g = color_1->g << 2;
colours[1].b = color_1->b << 3;
colours[1].a = 0xFF;
// four-color block: derive the other two colors.
// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// these 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[2].a = 0xFF;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
colours[3].a = 0xFF;
k = 0;
for( j = 0; j < 4; j++ )
{
for( i = 0; i < 4; i++, k++ )
{
Select = (bitmask & (0x03 << k*2)) >> k*2;
col = &colours[Select];
// only put pixels out < width or height
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp;
fout[Offset + 0] = col->r;
fout[Offset + 1] = col->g;
fout[Offset + 2] = col->b;
}
}
}
// 8-alpha or 6-alpha block?
if (alphas[0] > alphas[1])
{
// 8-alpha block: derive the other six alphas.
// bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010
alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011
alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100
alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101
alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110
alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111
}
else
{
// 6-alpha block.
// bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // bit code 010
alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // bit code 011
alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // bit code 100
alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // bit code 101
alphas[6] = 0x00; // bit code 110
alphas[7] = 0xFF; // bit code 111
}
// NOTE: Have to separate the next two loops,
// it operates on a 6-byte system.
// first three bytes
bits = *((int*)alphamask);
for( j = 0; j < 2; j++ )
{
for( i = 0; i < 4; i++ )
{
// only put pixels out < width or height
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp;
fout[Offset] = alphas[bits & 0x07];
}
bits >>= 3;
}
}
// last three bytes
bits = *((int*)&alphamask[3]);
for( j = 2; j < 4; j++ )
{
for( i = 0; i < 4; i++ )
{
// only put pixels out < width or height
if(((x + i) < w) && ((y + j) < h))
{
Offset = z * image.SizeOfPlane + (y + j) * image.bps + (x + i) * image.bpp;
fout[Offset] = alphas[bits & 0x07];
}
bits >>= 3;
}
}
}
}
}
default: return false;
}
// make some post operations
if( has_alpha ) image.flags |= IMAGE_HAS_ALPHA;
if( image.flags & IMAGE_PREMULT )
{
Image_CorrectPreMult((uint *)fout, size );
image.flags &= ~IMAGE_PREMULT;
}
Image_AddRGBAToPack( target, level, size, fout );
return true;
}
qboolean Image_DecompressARGB( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
uint ReadI = 0, TempBpp;
uint RedL, RedR, GreenL, GreenR, BlueL, BlueR, AlphaL, AlphaR;
uint r_bitmask, g_bitmask, b_bitmask, a_bitmask;
int i, w, h, size;
byte *fin, *fout;
if( !data ) return false;
w = width;
h = height;
fin = (byte *)data;
size = width * height * image.curdepth * 4;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
if( PFDesc[intformat].format == PF_LUMINANCE_16 )
{
Mem_Copy( fout, data, image.SizeOfData);
}
else if( image.palette )
{
byte *pal = image.palette; //copy ptr
r_bitmask = *(long *)pal; pal += 4;
g_bitmask = *(long *)pal; pal += 4;
b_bitmask = *(long *)pal; pal += 4;
a_bitmask = *(long *)pal; pal += 4;
}
else return false; // rgba mask unset
Image_GetBitsFromMask( r_bitmask, &RedL, &RedR );
Image_GetBitsFromMask( g_bitmask, &GreenL, &GreenR );
Image_GetBitsFromMask( b_bitmask, &BlueL, &BlueR );
Image_GetBitsFromMask( a_bitmask, &AlphaL, &AlphaR );
TempBpp = image.bits_count / 8;
for( i = 0; i < image.SizeOfData; i += image.bpp )
{
// TODO: This is SLOOOW...
// but the old version crashed in release build under
// winxp (and xp is right to stop this code - I always
// wondered that it worked the old way at all)
if( image.SizeOfData - i < 4 )
{
// less than 4 byte to write?
if( TempBpp == 1 ) ReadI = *((byte*) fin );
else if( TempBpp == 2 ) ReadI = *(short *)fin;
else if( TempBpp == 3 ) ReadI = *(short *)fin;
}
else ReadI = *(long *)fin;
fin += TempBpp;
fout[i] = ((ReadI & r_bitmask)>> RedR) << RedL;
if( image.bpp >= 3 )
{
fout[i+1] = ((ReadI & g_bitmask) >> GreenR) << GreenL;
fout[i+2] = ((ReadI & b_bitmask) >> BlueR) << BlueL;
if( image.bpp == 4 )
{
fout[i+3] = ((ReadI & a_bitmask) >> AlphaR) << AlphaL;
if( AlphaL >= 7 ) fout[i+3] = fout[i+3] ? 0xFF : 0x00;
else if( AlphaL >= 4 ) fout[i+3] = fout[i+3]|(fout[i+3] >> 4);
}
}
else if( image.bpp == 2 )
{
fout[i+1] = ((ReadI & a_bitmask) >> AlphaR) << AlphaL;
if( AlphaL >= 7 ) fout[i+1] = fout[i+1] ? 0xFF : 0x00;
else if( AlphaL >= 4 ) fout[i+1] = fout[i+1]|(fout[i+3] >> 4);
}
}
Image_AddRGBAToPack( target, level, size, fout );
return true;
}
qboolean Image_DecompressPal8( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
byte *fin, *fout;
int size;
if( !data ) return false;
fin = (byte *)data;
size = width * height * image.curdepth * 4;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
switch( PFDesc[intformat].format )
{
case PF_INDEXED_24:
if( image.flags & IMAGE_HAS_ALPHA )
{
if( image.flags & IMAGE_COLORINDEX )
Image_GetPaletteLMP( image.palette, LUMP_DECAL );
else Image_GetPaletteLMP( image.palette, LUMP_TRANSPARENT );
}
else Image_GetPaletteLMP( image.palette, LUMP_NORMAL );
// intentional falltrough
case PF_INDEXED_32:
if( !image.d_currentpal ) image.d_currentpal = ( uint *)image.palette;
if( !Image_Copy8bitRGBA( fin, fout, width * height )) return false;
break;
}
Image_AddRGBAToPack( target, level, size, fout );
return true;
}
qboolean Image_DecompressDUDV( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
byte *fin, *fout;
int i, size;
short *col;
if( !data ) return false;
fin = (byte *)data;
size = width * height * image.curdepth * 4;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
switch( PFDesc[intformat].format )
{
case PF_UV_16:
for( i = 0, col = (short *)fin; i < width * height; i++, col += sizeof( short ))
{
fout[(i<<2)+0] = col[0];
fout[(i<<2)+1] = col[1];
fout[(i<<2)+2] = 0;
fout[(i<<2)+3] = 0;
}
break;
case PF_UV_32:
Mem_Copy( fout, fin, size ); // nothing to process
break;
}
Image_AddRGBAToPack( target, level, size, fout );
return true;
}
qboolean Image_DecompressRGBA( uint target, int level, int intformat, uint width, uint height, uint imageSize, const void* data )
{
byte *fin, *fout;
int i, size;
color16 *col;
if( !data ) return false;
fin = (byte *)data;
size = width * height * image.curdepth * 4;
image.tempbuffer = Mem_Realloc( Sys.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
switch( PFDesc[intformat].format )
{
case PF_RGB_16:
for( i = 0, col = (color16 *)fin; i < width * height; i++ )
{
fout[(i<<2)+0] = col->r << 3;
fout[(i<<2)+1] = col->g << 2;
fout[(i<<2)+2] = col->b << 3;
fout[(i<<2)+3] = 255;
col += sizeof( color16 );
}
break;
case PF_RGB_24:
for (i = 0; i < width * height; i++ )
{
fout[(i<<2)+0] = fin[i*3+0];
fout[(i<<2)+1] = fin[i*3+1];
fout[(i<<2)+2] = fin[i*3+2];
fout[(i<<2)+3] = 255;
}
break;
case PF_BGR_24:
for (i = 0; i < width * height; i++ )
{
fout[(i<<2)+0] = fin[i*3+2];
fout[(i<<2)+1] = fin[i*3+1];
fout[(i<<2)+2] = fin[i*3+0];
fout[(i<<2)+3] = 255;
}
break;
case PF_RGBA_GN:
case PF_RGBA_32:
Mem_Copy( fout, fin, size );
break;
case PF_BGRA_32:
case PF_ABGR_64:
for( i = 0; i < width * height; i++ )
{
fout[i*4+0] = fin[i*4+2];
fout[i*4+1] = fin[i*4+1];
fout[i*4+2] = fin[i*4+0];
fout[i*4+3] = fin[i*4+3];
}
break;
default: return false;
}
Image_AddRGBAToPack( target, level, size, fout );
return true;
}
void Image_DecompressDDS( const byte *buffer, uint target )
{
int i, size = 0;
int w = image.curwidth;
int h = image.curheight;
int d = image.curdepth;
// filter by cubemap side
if( image.filter != CB_HINT_NO && image.filter != target )
return;
switch( image.type )
{
case PF_INDEXED_24:
case PF_INDEXED_32: image.decompress = Image_DecompressPal8; break;
case PF_RGBA_32:
case PF_BGRA_32: image.decompress = Image_DecompressRGBA; break;
case PF_ARGB_32: image.decompress = Image_DecompressARGB; break;
case PF_ABGR_64:
case PF_RGB_24:
case PF_BGR_24:
case PF_RGB_16: image.decompress = Image_DecompressRGBA; break;
case PF_DXT1:
case PF_DXT2:
case PF_DXT3:
case PF_DXT4:
case PF_DXT5:
case PF_RXGB: image.decompress = Image_DecompressDXT; break;
case PF_ATI1N:
case PF_ATI2N: image.decompress = Image_DecompressATI; break;
case PF_LUMINANCE:
case PF_LUMINANCE_16:
case PF_LUMINANCE_ALPHA: image.decompress = Image_DecompressARGB; break;
case PF_UV_16:
case PF_UV_32: image.decompress = Image_DecompressDUDV; break;
case PF_R_16F:
case PF_R_32F:
case PF_GR_32F:
case PF_GR_64F:
case PF_ABGR_64F:
case PF_ABGR_128F: image.decompress = Image_DecompressFloat; break;
case PF_RGBA_GN: image.decompress = Image_DecompressRGBA; break;
default: Sys_Error( "Image_DecompressDDS: unknown image format\n" );
}
for( i = 0; i < image.cur_mips; i++ )
{
Image_SetPixelFormat( w, h, d );
size = image.SizeOfFile;
if(!image.decompress( target, i, image.type, w, h, size, buffer ))
break; // there were errors
w = (w+1)>>1, h = (h+1)>>1, d = (d+1)>>1; // calc size of next mip
buffer += size;
}
}
qboolean Image_ForceDecompress( void )
{
int w, h;
// GL_ARB_texture_compression missing, force to decompress anyway
if(!( image.cmd_flags & IL_DDS_HARDWARE )) return true;
// non power of two images needs resample
// but resample code not supported compressed images
w = image.width, h = image.height;
Image_RoundDimensions( &w, &h );
if( w != image.width || h != image.height )
return true;
// extract cubemap side from complex image
if( image.filter != CB_HINT_NO )
return true;
// UNDONE: load it properly with gl loader
switch( image.type )
{
case PF_RXGB: return true; // g-cont. test it with GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ?
case PF_ATI1N: return true; // hey, how called your OpenGL extension, ATI ?
case PF_ATI2N: return true;
}
return false;
}
/*
=============
Image_LoadDDS
=============
*/
qboolean Image_LoadDDS( const char *name, const byte *buffer, size_t filesize )
{
dds_t header;
byte *fin;
uint i;
if( filesize < sizeof( dds_t ))
{
MsgDev( D_ERROR, "Image_LoadDDS: file (%s) have invalid size\n", name );
return false;
}
Mem_Copy( &header, buffer, sizeof( dds_t ));
if( header.dwIdent != DDSHEADER ) return false; // it's not a dds file, just skip it
if( header.dwSize != sizeof(dds_t) - sizeof( uint )) // size of the structure (minus MagicNum)
{
MsgDev( D_ERROR, "LoadDDS: (%s) have corrupted header\n", name );
return false;
}
if( header.dsPixelFormat.dwSize != sizeof(dds_pixf_t)) // size of the structure
{
MsgDev( D_ERROR, "LoadDDS: (%s) have corrupt pixelformat header\n", name );
return false;
}
image.width = header.dwWidth;
image.height = header.dwHeight;
image.bits_count = header.dsPixelFormat.dwRGBBitCount;
if( header.dwFlags & DDS_DEPTH) image.depth = header.dwDepth;
if(!Image_ValidSize( name )) return false;
Image_DXTGetPixelFormat( &header ); // and image type too :)
Image_DXTAdjustVolume( &header );
if( image.type == PF_UNKNOWN )
{
MsgDev( D_WARN, "LoadDDS: (%s) have unsupported compression type\n", name );
return false;
}
image.size = Image_DXTCalcSize( name, &header, filesize - 128 );
if( image.size == 0 ) return false; // just in case
fin = (byte *)(buffer + sizeof( dds_t ));
if( Image_ForceDecompress())
{
int offset, numsides = 1;
uint target = 1;
byte *buf = fin;
// if hardware loader is absent or image not power of two
// or user want load current side from cubemap we run software decompressing
if( image.flags & IMAGE_CUBEMAP ) numsides = 6;
Image_SetPixelFormat( image.width, image.height, image.depth ); // setup
image.size = image.ptr = 0;
if( image.cmd_flags & IL_IGNORE_MIPS )
image.cur_mips = 1;
else image.cur_mips = image.num_mips;
image.num_mips = 0; // clear mipcount
for( i = 0, offset = 0; i < numsides; i++, buf += offset )
{
Image_SetPixelFormat( image.curwidth, image.curheight, image.curdepth );
offset = image.SizeOfFile; // move pointer
Image_DecompressDDS( buf, target + i );
}
// now we can change type to RGBA
if( image.filter != CB_HINT_NO ) image.flags &= ~IMAGE_CUBEMAP; // side extracted
image.type = PF_RGBA_32;
image.bits_count = 32;
}
else
{
// dds files will be uncompressed on a render. requires minimal of info for set this
image.rgba = Mem_Alloc( Sys.imagepool, image.size );
Mem_Copy( image.rgba, fin, image.size );
}
return true;
}
qboolean Image_SaveDDS( const char *name, rgbdata_t *pix )
{
vfile_t *file; // virtual file
if( FS_FileExists( name, false ) && !(image.cmd_flags & IL_ALLOW_OVERWRITE ))
return false; // already existed
file = VFS_Open( NULL, "w" );
if( !file ) return false;
if( !Image_DXTWriteHeader( file, pix ))
{
MsgDev( D_ERROR, "Image_SaveDDS: unsupported format %s\n", PFDesc[pix->type].name );
VFS_Close( file );
return false;
}
if( !Image_DXTWriteImage( file, pix ))
{
MsgDev( D_ERROR, "Image_SaveDDS: can't create dds file\n" );
VFS_Close( file );
return false;
}
FS_WriteFile( name, VFS_GetBuffer( file ), VFS_Tell( file ));
VFS_Close( file ); // release virtual file
return true;
}
Reference in New Issue View Git Blame Copy Permalink