* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+#ifndef TEXCOMPRESS_S3TC_TMP_H
+#define TEXCOMPRESS_S3TC_TMP_H
+
#ifdef __APPLE__
#include <OpenGL/gl.h>
#else
#define BCOMP 2
#define ACOMP 3
-void fetch_2d_texel_rgb_dxt1(GLint srcRowStride, const GLubyte *pixdata,
- GLint i, GLint j, GLvoid *texel);
-void fetch_2d_texel_rgba_dxt1(GLint srcRowStride, const GLubyte *pixdata,
- GLint i, GLint j, GLvoid *texel);
-void fetch_2d_texel_rgba_dxt3(GLint srcRowStride, const GLubyte *pixdata,
- GLint i, GLint j, GLvoid *texel);
-void fetch_2d_texel_rgba_dxt5(GLint srcRowStride, const GLubyte *pixdata,
- GLint i, GLint j, GLvoid *texel);
-
-void tx_compress_dxtn(GLint srccomps, GLint width, GLint height,
- const GLubyte *srcPixData, GLenum destformat,
- GLubyte *dest, GLint dstRowStride);
-
#define EXP5TO8R(packedcol) \
((((packedcol) >> 8) & 0xf8) | (((packedcol) >> 13) & 0x7))
const GLushort color0 = img_block_src[0] | (img_block_src[1] << 8);
const GLushort color1 = img_block_src[2] | (img_block_src[3] << 8);
const GLuint bits = img_block_src[4] | (img_block_src[5] << 8) |
- (img_block_src[6] << 16) | (img_block_src[7] << 24);
+ (img_block_src[6] << 16) | ((GLuint)img_block_src[7] << 24);
/* What about big/little endian? */
GLubyte bit_pos = 2 * (j * 4 + i) ;
GLubyte code = (GLubyte) ((bits >> bit_pos) & 3);
}
-void fetch_2d_texel_rgb_dxt1(GLint srcRowStride, const GLubyte *pixdata,
+static void fetch_2d_texel_rgb_dxt1(GLint srcRowStride, const GLubyte *pixdata,
GLint i, GLint j, GLvoid *texel)
{
/* Extract the (i,j) pixel from pixdata and return it
}
-void fetch_2d_texel_rgba_dxt1(GLint srcRowStride, const GLubyte *pixdata,
+static void fetch_2d_texel_rgba_dxt1(GLint srcRowStride, const GLubyte *pixdata,
GLint i, GLint j, GLvoid *texel)
{
/* Extract the (i,j) pixel from pixdata and return it
dxt135_decode_imageblock(blksrc, (i&3), (j&3), 1, texel);
}
-void fetch_2d_texel_rgba_dxt3(GLint srcRowStride, const GLubyte *pixdata,
+static void fetch_2d_texel_rgba_dxt3(GLint srcRowStride, const GLubyte *pixdata,
GLint i, GLint j, GLvoid *texel) {
/* Extract the (i,j) pixel from pixdata and return it
GLchan *rgba = (GLchan *) texel;
const GLubyte *blksrc = (pixdata + ((srcRowStride + 3) / 4 * (j / 4) + (i / 4)) * 16);
-#if 0
- /* Simple 32bit version. */
-/* that's pretty brain-dead for a single pixel, isn't it? */
- const GLubyte bit_pos = 4 * ((j&3) * 4 + (i&3));
- const GLuint alpha_low = blksrc[0] | (blksrc[1] << 8) | (blksrc[2] << 16) | (blksrc[3] << 24);
- const GLuint alpha_high = blksrc[4] | (blksrc[5] << 8) | (blksrc[6] << 16) | (blksrc[7] << 24);
-
- dxt135_decode_imageblock(blksrc + 8, (i&3), (j&3), 2, texel);
- if (bit_pos < 32)
- rgba[ACOMP] = UBYTE_TO_CHAN( (GLubyte)(EXP4TO8((alpha_low >> bit_pos) & 15)) );
- else
- rgba[ACOMP] = UBYTE_TO_CHAN( (GLubyte)(EXP4TO8((alpha_high >> (bit_pos - 32)) & 15)) );
-#endif
-#if 1
-/* TODO test this! */
const GLubyte anibble = (blksrc[((j&3) * 4 + (i&3)) / 2] >> (4 * (i&1))) & 0xf;
dxt135_decode_imageblock(blksrc + 8, (i&3), (j&3), 2, texel);
rgba[ACOMP] = UBYTE_TO_CHAN( (GLubyte)(EXP4TO8(anibble)) );
-#endif
-
}
-void fetch_2d_texel_rgba_dxt5(GLint srcRowStride, const GLubyte *pixdata,
+static void fetch_2d_texel_rgba_dxt5(GLint srcRowStride, const GLubyte *pixdata,
GLint i, GLint j, GLvoid *texel) {
/* Extract the (i,j) pixel from pixdata and return it
const GLubyte *blksrc = (pixdata + ((srcRowStride + 3) / 4 * (j / 4) + (i / 4)) * 16);
const GLubyte alpha0 = blksrc[0];
const GLubyte alpha1 = blksrc[1];
-#if 0
- const GLubyte bit_pos = 3 * ((j&3) * 4 + (i&3));
- /* simple 32bit version */
- const GLuint bits_low = blksrc[2] | (blksrc[3] << 8) | (blksrc[4] << 16) | (blksrc[5] << 24);
- const GLuint bits_high = blksrc[6] | (blksrc[7] << 8);
- GLubyte code;
-
- if (bit_pos < 30)
- code = (GLubyte) ((bits_low >> bit_pos) & 7);
- else if (bit_pos == 30)
- code = (GLubyte) ((bits_low >> 30) & 3) | ((bits_high << 2) & 4);
- else
- code = (GLubyte) ((bits_high >> (bit_pos - 32)) & 7);
-#endif
-#if 1
-/* TODO test this! */
const GLubyte bit_pos = ((j&3) * 4 + (i&3)) * 3;
const GLubyte acodelow = blksrc[2 + bit_pos / 8];
const GLubyte acodehigh = blksrc[3 + bit_pos / 8];
const GLubyte code = (acodelow >> (bit_pos & 0x7) |
(acodehigh << (8 - (bit_pos & 0x7)))) & 0x7;
-#endif
dxt135_decode_imageblock(blksrc + 8, (i&3), (j&3), 2, texel);
-#if 0
- if (alpha0 > alpha1) {
- switch (code) {
- case 0:
- rgba[ACOMP] = UBYTE_TO_CHAN( alpha0 );
- break;
- case 1:
- rgba[ACOMP] = UBYTE_TO_CHAN( alpha1 );
- break;
- case 2:
- case 3:
- case 4:
- case 5:
- case 6:
- case 7:
- rgba[ACOMP] = UBYTE_TO_CHAN( ((alpha0 * (8 - code) + (alpha1 * (code - 1))) / 7) );
- break;
- }
- }
- else {
- switch (code) {
- case 0:
- rgba[ACOMP] = UBYTE_TO_CHAN( alpha0 );
- break;
- case 1:
- rgba[ACOMP] = UBYTE_TO_CHAN( alpha1 );
- break;
- case 2:
- case 3:
- case 4:
- case 5:
- rgba[ACOMP] = UBYTE_TO_CHAN( ((alpha0 * (6 - code) + (alpha1 * (code - 1))) / 5) );
- break;
- case 6:
- rgba[ACOMP] = 0;
- break;
- case 7:
- rgba[ACOMP] = CHAN_MAX;
- break;
- }
- }
-#endif
-/* not sure. Which version is faster? */
-#if 1
-/* TODO test this */
if (code == 0)
rgba[ACOMP] = UBYTE_TO_CHAN( alpha0 );
else if (code == 1)
rgba[ACOMP] = 0;
else
rgba[ACOMP] = CHAN_MAX;
-#endif
}
#define ALPHACUT 127
-static void fancybasecolorsearch( GLubyte *blkaddr, GLubyte srccolors[4][4][4], GLubyte *bestcolor[2],
- GLint numxpixels, GLint numypixels, GLint type, GLboolean haveAlpha)
+static void fancybasecolorsearch( UNUSED GLubyte *blkaddr, GLubyte srccolors[4][4][4], GLubyte *bestcolor[2],
+ GLint numxpixels, GLint numypixels, UNUSED GLint type, UNUSED GLboolean haveAlpha)
{
/* use same luminance-weighted distance metric to determine encoding as for finding the base colors */
GLuint pixerror, pixerrorred, pixerrorgreen, pixerrorblue, pixerrorbest;
GLint colordist, blockerrlin[2][3];
GLubyte nrcolor[2];
- GLint pixerrorcolorbest[3];
+ GLint pixerrorcolorbest[3] = {0};
GLubyte enc = 0;
GLubyte cv[4][4];
GLubyte testcolor[2][3];
}
}
testerror += pixerrorbest;
- bits |= enc << (2 * (j * 4 + i));
+ bits |= (uint32_t)enc << (2 * (j * 4 + i));
}
}
/* some hw might disagree but actually decoding should always use 4-color encoding
}
}
testerror2 += pixerrorbest;
- bits2 |= enc << (2 * (j * 4 + i));
+ bits2 |= (uint32_t)enc << (2 * (j * 4 + i));
}
}
} else {
}
-void tx_compress_dxtn(GLint srccomps, GLint width, GLint height, const GLubyte *srcPixData,
+static void tx_compress_dxtn(GLint srccomps, GLint width, GLint height, const GLubyte *srcPixData,
GLenum destFormat, GLubyte *dest, GLint dstRowStride)
{
GLubyte *blkaddr = dest;
}
break;
default:
- fprintf(stderr, "libdxtn: Bad dstFormat %d in tx_compress_dxtn\n", destFormat);
+ assert(false);
return;
}
}
+
+#endif