ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
project64/Source/Project64-video/TextureEnhancer/tc-1.1+/dxtn.c

884 lines
25 KiB
C
Raw Blame History

// Project64 - A Nintendo 64 emulator
// https://www.pj64-emu.com/
// Copyright(C) 2001-2021 Project64
// Copyright(C) 2007 Hiroshi Morii
// Copyright(C) 2004 Daniel Borca
// GNU/GPLv2 licensed: https://gnu.org/licenses/gpl-2.0.html
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <stdint.h>
#include "types.h"
#include "internal.h"
#include "dxtn.h"
/*
DXTn encoder
The encoder was built by reversing the decoder,
and is vaguely based on FXT1 codec. Note that this code
is merely a proof of concept, since it is highly unoptimized!
*/
#define MAX_COMP 4 // Ever needed maximum number of components in texel
#define MAX_VECT 4 // Ever needed maximum number of base vectors to find
#define N_TEXELS 16 // Number of texels in a block (always 16)
#define COLOR565(v) (word)((((v)[RCOMP] & 0xf8) << 8) | (((v)[GCOMP] & 0xfc) << 3) | ((v)[BCOMP] >> 3))
static const int dxtn_color_tlat[2][4] = {
{ 0, 2, 3, 1 },
{ 0, 2, 1, 3 }
};
static const int dxtn_alpha_tlat[2][8] = {
{ 0, 2, 3, 4, 5, 6, 7, 1 },
{ 0, 2, 3, 4, 5, 1, 6, 7 }
};
static void
dxt1_rgb_quantize(dword *cc, const byte *lines[], int comps)
{
float b, iv[MAX_COMP]; // Interpolation vector
dword hi; // High doubleword
int color0, color1;
int n_vect;
const int n_comp = 3;
int black = 0;
#ifndef YUV
int minSum = 2000; // Big enough
#else
int minSum = 2000000;
#endif
int maxSum = -1; // Small enough
int minCol = 0; // phoudoin: Silent compiler!
int maxCol = 0; // phoudoin: Silent compiler!
byte input[N_TEXELS][MAX_COMP];
int i, k, l;
// Make the whole block opaque
// We will NEVER reference ACOMP of any pixel
// 4 texels each line
#ifndef ARGB
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
for (i = 0; i < comps; i++) {
input[k + l * 4][i] = *lines[l]++;
}
}
}
#else
// H.Morii - Support for ARGB inputs
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
input[k + l * 4][2] = *lines[l]++;
input[k + l * 4][1] = *lines[l]++;
input[k + l * 4][0] = *lines[l]++;
if (comps == 4) input[k + l * 4][3] = *lines[l]++;
}
}
#endif
/*
Our solution here is to find the darkest and brightest colors in
the 4x4 tile and use those as the two representative colors.
There are probably better algorithms to use (histogram-based).
*/
for (k = 0; k < N_TEXELS; k++) {
int sum = 0;
#ifndef YUV
for (i = 0; i < n_comp; i++) {
sum += input[k][i];
}
#else
/* RGB to YUV conversion according to CCIR 601 specs
Y = 0.299R+0.587G+0.114B
U = 0.713(R - Y) = 0.500R-0.419G-0.081B
V = 0.564(B - Y) = -0.169R-0.331G+0.500B
*/
sum = 299 * input[k][RCOMP] + 587 * input[k][GCOMP] + 114 * input[k][BCOMP];
#endif
if (minSum > sum) {
minSum = sum;
minCol = k;
}
if (maxSum < sum) {
maxSum = sum;
maxCol = k;
}
if (sum == 0) {
black = 1;
}
}
color0 = COLOR565(input[minCol]);
color1 = COLOR565(input[maxCol]);
if (color0 == color1) {
// We'll use 3-vector
cc[0] = color0 | (color1 << 16);
hi = black ? -1 : 0;
}
else {
if (black && ((color0 == 0) || (color1 == 0))) {
// We still can use 4-vector
black = 0;
}
if (black ^ (color0 <= color1)) {
int aux;
aux = color0;
color0 = color1;
color1 = aux;
aux = minCol;
minCol = maxCol;
maxCol = aux;
}
n_vect = (color0 <= color1) ? 2 : 3;
MAKEIVEC(n_vect, n_comp, iv, b, input[minCol], input[maxCol]);
// Add in texels
cc[0] = color0 | (color1 << 16);
hi = 0;
for (k = N_TEXELS - 1; k >= 0; k--) {
int texel = 3;
int sum = 0;
if (black) {
for (i = 0; i < n_comp; i++) {
sum += input[k][i];
}
}
if (!black || sum) {
// Interpolate color
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
texel = dxtn_color_tlat[black][texel];
}
// Add in texel
hi <<= 2;
hi |= texel;
}
}
cc[1] = hi;
}
static void
dxt1_rgba_quantize(dword *cc, const byte *lines[], int comps)
{
float b, iv[MAX_COMP]; // Interpolation vector
dword hi; // High doubleword
int color0, color1;
int n_vect;
const int n_comp = 3;
int transparent = 0;
#ifndef YUV
int minSum = 2000; // Big enough
#else
int minSum = 2000000;
#endif
int maxSum = -1; // Small enough
int minCol = 0; // phoudoin: Silent compiler!
int maxCol = 0; // phoudoin: Silent compiler!
byte input[N_TEXELS][MAX_COMP];
int i, k, l;
if (comps == 3) {
// Make the whole block opaque
memset(input, -1, sizeof(input));
}
// 4 texels each line
#ifndef ARGB
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
for (i = 0; i < comps; i++) {
input[k + l * 4][i] = *lines[l]++;
}
}
}
#else
// H.Morii - Support for ARGB inputs
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
input[k + l * 4][2] = *lines[l]++;
input[k + l * 4][1] = *lines[l]++;
input[k + l * 4][0] = *lines[l]++;
if (comps == 4) input[k + l * 4][3] = *lines[l]++;
}
}
#endif
/*
Our solution here is to find the darkest and brightest colors in
the 4x4 tile and use those as the two representative colors.
There are probably better algorithms to use (histogram-based).
*/
for (k = 0; k < N_TEXELS; k++) {
int sum = 0;
#ifndef YUV
for (i = 0; i < n_comp; i++) {
sum += input[k][i];
}
#else
sum = 299 * input[k][RCOMP] + 587 * input[k][GCOMP] + 114 * input[k][BCOMP];
#endif
if (minSum > sum) {
minSum = sum;
minCol = k;
}
if (maxSum < sum) {
maxSum = sum;
maxCol = k;
}
if (input[k][ACOMP] < 128) {
transparent = 1;
}
}
color0 = COLOR565(input[minCol]);
color1 = COLOR565(input[maxCol]);
if (color0 == color1) {
// We'll use 3-vector
cc[0] = color0 | (color1 << 16);
hi = transparent ? -1 : 0;
}
else {
if (transparent ^ (color0 <= color1)) {
int aux;
aux = color0;
color0 = color1;
color1 = aux;
aux = minCol;
minCol = maxCol;
maxCol = aux;
}
n_vect = (color0 <= color1) ? 2 : 3;
MAKEIVEC(n_vect, n_comp, iv, b, input[minCol], input[maxCol]);
// Add in texels
cc[0] = color0 | (color1 << 16);
hi = 0;
for (k = N_TEXELS - 1; k >= 0; k--) {
int texel = 3;
if (input[k][ACOMP] >= 128) {
// Interpolate color
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
texel = dxtn_color_tlat[transparent][texel];
}
// Add in texel
hi <<= 2;
hi |= texel;
}
}
cc[1] = hi;
}
static void
dxt3_rgba_quantize(dword *cc, const byte *lines[], int comps)
{
float b, iv[MAX_COMP]; // Interpolation vector
dword lolo, lohi; // Low quadword: lo DWORD, hi DWORD
dword hihi; // High quadword: high DWORD
int color0, color1;
const int n_vect = 3;
const int n_comp = 3;
#ifndef YUV
int minSum = 2000; // Big enough
#else
int minSum = 2000000;
#endif
int maxSum = -1; // Small enough
int minCol = 0; // phoudoin: Silent compiler!
int maxCol = 0; // phoudoin: Silent compiler!
byte input[N_TEXELS][MAX_COMP];
int i, k, l;
if (comps == 3) {
// Make the whole block opaque
memset(input, -1, sizeof(input));
}
// 4 texels each line
#ifndef ARGB
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
for (i = 0; i < comps; i++) {
input[k + l * 4][i] = *lines[l]++;
}
}
}
#else
// H.Morii - Support for ARGB inputs
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
input[k + l * 4][2] = *lines[l]++;
input[k + l * 4][1] = *lines[l]++;
input[k + l * 4][0] = *lines[l]++;
if (comps == 4) input[k + l * 4][3] = *lines[l]++;
}
}
#endif
/* TODO:
Our solution here is to find the darkest and brightest colors in
the 4x4 tile and use those as the two representative colors.
There are probably better algorithms to use (histogram-based).
*/
for (k = 0; k < N_TEXELS; k++) {
int sum = 0;
#ifndef YUV
for (i = 0; i < n_comp; i++) {
sum += input[k][i];
}
#else
sum = 299 * input[k][RCOMP] + 587 * input[k][GCOMP] + 114 * input[k][BCOMP];
#endif
if (minSum > sum) {
minSum = sum;
minCol = k;
}
if (maxSum < sum) {
maxSum = sum;
maxCol = k;
}
}
// Add in alphas
lolo = lohi = 0;
for (k = N_TEXELS - 1; k >= N_TEXELS / 2; k--) {
// Add in alpha
lohi <<= 4;
lohi |= input[k][ACOMP] >> 4;
}
cc[1] = lohi;
for (; k >= 0; k--) {
// Add in alpha
lolo <<= 4;
lolo |= input[k][ACOMP] >> 4;
}
cc[0] = lolo;
color0 = COLOR565(input[minCol]);
color1 = COLOR565(input[maxCol]);
#ifdef RADEON
/* H.Morii - Workaround for ATI Radeon
* According to the OpenGL EXT_texture_compression_s3tc specs,
* the encoding of the RGB components for DXT3 and DXT5 formats
* use the non-transparent encodings of DXT1 but treated as
* though color0 > color1, regardless of the actual values of
* color0 and color1. ATI Radeons however require the values to
* be color0 > color1.
*/
if (color0 < color1) {
int aux;
aux = color0;
color0 = color1;
color1 = aux;
aux = minCol;
minCol = maxCol;
maxCol = aux;
}
#endif
cc[2] = color0 | (color1 << 16);
hihi = 0;
if (color0 != color1) {
MAKEIVEC(n_vect, n_comp, iv, b, input[minCol], input[maxCol]);
// Add in texels
for (k = N_TEXELS - 1; k >= 0; k--) {
int texel;
// Interpolate color
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
texel = dxtn_color_tlat[0][texel];
// Add in texel
hihi <<= 2;
hihi |= texel;
}
}
cc[3] = hihi;
}
static void
dxt5_rgba_quantize(dword *cc, const byte *lines[], int comps)
{
float b, iv[MAX_COMP]; // Interpolation vector
qword lo; // Low quadword
dword hihi; // High quadword: high DWORD
int color0, color1;
const int n_vect = 3;
const int n_comp = 3;
#ifndef YUV
int minSum = 2000; // Big enough
#else
int minSum = 2000000;
#endif
int maxSum = -1; // Small enough
int minCol = 0; // phoudoin: Silent compiler!
int maxCol = 0; // phoudoin: Silent compiler!
int alpha0 = 2000; // Big enough
int alpha1 = -1; // Small enough
int anyZero = 0, anyOne = 0;
int a_vect;
byte input[N_TEXELS][MAX_COMP];
int i, k, l;
if (comps == 3) {
// Make the whole block opaque
memset(input, -1, sizeof(input));
}
// 4 texels each line
#ifndef ARGB
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
for (i = 0; i < comps; i++) {
input[k + l * 4][i] = *lines[l]++;
}
}
}
#else
// H.Morii - Support for ARGB inputs
for (l = 0; l < 4; l++) {
for (k = 0; k < 4; k++) {
input[k + l * 4][2] = *lines[l]++;
input[k + l * 4][1] = *lines[l]++;
input[k + l * 4][0] = *lines[l]++;
if (comps == 4) input[k + l * 4][3] = *lines[l]++;
}
}
#endif
/*
Our solution here is to find the darkest and brightest colors in
the 4x4 tile and use those as the two representative colors.
There are probably better algorithms to use (histogram-based).
*/
for (k = 0; k < N_TEXELS; k++) {
int sum = 0;
#ifndef YUV
for (i = 0; i < n_comp; i++) {
sum += input[k][i];
}
#else
sum = 299 * input[k][RCOMP] + 587 * input[k][GCOMP] + 114 * input[k][BCOMP];
#endif
if (minSum > sum) {
minSum = sum;
minCol = k;
}
if (maxSum < sum) {
maxSum = sum;
maxCol = k;
}
if (alpha0 > input[k][ACOMP]) {
alpha0 = input[k][ACOMP];
}
if (alpha1 < input[k][ACOMP]) {
alpha1 = input[k][ACOMP];
}
if (input[k][ACOMP] == 0) {
anyZero = 1;
}
if (input[k][ACOMP] == 255) {
anyOne = 1;
}
}
// Add in alphas
if (alpha0 == alpha1) {
// We'll use 6-vector
cc[0] = alpha0 | (alpha1 << 8);
cc[1] = 0;
}
else {
if (anyZero && ((alpha0 == 0) || (alpha1 == 0))) {
// We still might use 8-vector
anyZero = 0;
}
if (anyOne && ((alpha0 == 255) || (alpha1 == 255))) {
// We still might use 8-vector
anyOne = 0;
}
if ((anyZero | anyOne) ^ (alpha0 <= alpha1)) {
int aux;
aux = alpha0;
alpha0 = alpha1;
alpha1 = aux;
}
a_vect = (alpha0 <= alpha1) ? 5 : 7;
// Compute interpolation vector
iv[ACOMP] = (float)a_vect / (alpha1 - alpha0);
b = -iv[ACOMP] * alpha0 + 0.5F;
// Add in alphas
Q_MOV32(lo, 0);
for (k = N_TEXELS - 1; k >= 0; k--) {
int texel = -1;
if (anyZero | anyOne) {
if (input[k][ACOMP] == 0) {
texel = 6;
}
else if (input[k][ACOMP] == 255) {
texel = 7;
}
}
// Interpolate alpha
if (texel == -1) {
float dot = input[k][ACOMP] * iv[ACOMP];
texel = (int)(dot + b);
#if SAFECDOT
if (texel < 0) {
texel = 0;
}
else if (texel > a_vect) {
texel = a_vect;
}
#endif
texel = dxtn_alpha_tlat[anyZero | anyOne][texel];
}
// Add in texel
Q_SHL(lo, 3);
Q_OR32(lo, texel);
}
Q_SHL(lo, 16);
Q_OR32(lo, alpha0 | (alpha1 << 8));
((qword *)cc)[0] = lo;
}
color0 = COLOR565(input[minCol]);
color1 = COLOR565(input[maxCol]);
#ifdef RADEON /* H.Morii - Workaround for ATI Radeon */
if (color0 < color1) {
int aux;
aux = color0;
color0 = color1;
color1 = aux;
aux = minCol;
minCol = maxCol;
maxCol = aux;
}
#endif
cc[2] = color0 | (color1 << 16);
hihi = 0;
if (color0 != color1) {
MAKEIVEC(n_vect, n_comp, iv, b, input[minCol], input[maxCol]);
// Add in texels
for (k = N_TEXELS - 1; k >= 0; k--) {
int texel;
// Interpolate color
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
texel = dxtn_color_tlat[0][texel];
// Add in texel
hihi <<= 2;
hihi |= texel;
}
}
cc[3] = hihi;
}
#define ENCODER(dxtn, n) \
int TAPIENTRY \
dxtn##_encode (int width, int height, int comps, \
const void *source, int srcRowStride, \
void *dest, int destRowStride) \
{ \
int x, y; \
const byte *data; \
dword *encoded = (dword *)dest; \
void *newSource = NULL; \
\
/* Replicate image if width is not M4 or height is not M4 */ \
if ((width & 3) | (height & 3)) { \
int newWidth = (width + 3) & ~3; \
int newHeight = (height + 3) & ~3; \
newSource = malloc(comps * newWidth * newHeight * sizeof(byte *));\
_mesa_upscale_teximage2d(width, height, newWidth, newHeight, \
comps, (const byte *)source, \
srcRowStride, (byte *)newSource); \
source = newSource; \
width = newWidth; \
height = newHeight; \
srcRowStride = comps * newWidth; \
} \
\
data = (const byte *)source; \
destRowStride = (destRowStride - width * n) / 4; \
for (y = 0; y < height; y += 4) { \
unsigned int offs = 0 + (y + 0) * srcRowStride; \
for (x = 0; x < width; x += 4) { \
const byte *lines[4]; \
lines[0] = &data[offs]; \
lines[1] = lines[0] + srcRowStride; \
lines[2] = lines[1] + srcRowStride; \
lines[3] = lines[2] + srcRowStride; \
offs += 4 * comps; \
dxtn##_quantize(encoded, lines, comps); \
/* 4x4 block */ \
encoded += n; \
} \
encoded += destRowStride; \
} \
\
if (newSource != NULL) { \
free(newSource); \
} \
\
return 0; \
}
ENCODER(dxt1_rgb, 2)
ENCODER(dxt1_rgba, 2)
ENCODER(dxt3_rgba, 4)
ENCODER(dxt5_rgba, 4)
/*
DXTn decoder
The decoder is based on GL_EXT_texture_compression_s3tc
specification and serves as a concept for the encoder.
*/
// Lookup table for scaling 4-bit colors up to 8-bit
static const byte _rgb_scale_4[] = {
0, 17, 34, 51, 68, 85, 102, 119,
136, 153, 170, 187, 204, 221, 238, 255
};
// Lookup table for scaling 5-bit colors up to 8-bit
static const byte _rgb_scale_5[] = {
0, 8, 16, 25, 33, 41, 49, 58,
66, 74, 82, 90, 99, 107, 115, 123,
132, 140, 148, 156, 165, 173, 181, 189,
197, 206, 214, 222, 230, 239, 247, 255
};
// Lookup table for scaling 6-bit colors up to 8-bit
static const byte _rgb_scale_6[] = {
0, 4, 8, 12, 16, 20, 24, 28,
32, 36, 40, 45, 49, 53, 57, 61,
65, 69, 73, 77, 81, 85, 89, 93,
97, 101, 105, 109, 113, 117, 121, 125,
130, 134, 138, 142, 146, 150, 154, 158,
162, 166, 170, 174, 178, 182, 186, 190,
194, 198, 202, 206, 210, 215, 219, 223,
227, 231, 235, 239, 243, 247, 251, 255
};
#define CC_SEL(cc, which) (((dword *)(cc))[(which) / 32] >> ((which) & 31))
#define UP4(c) _rgb_scale_4[(c) & 15]
#define UP5(c) _rgb_scale_5[(c) & 31]
#define UP6(c) _rgb_scale_6[(c) & 63]
#define ZERO_4UBV(v) *((dword *)(v)) = 0
void TAPIENTRY
dxt1_rgb_decode_1(const void *texture, int stride,
int i, int j, byte *rgba)
{
const byte *src = (const byte *)texture
+ ((j / 4) * ((stride + 3) / 4) + i / 4) * 8;
const int code = (src[4 + (j & 3)] >> ((i & 3) * 2)) & 0x3;
if (code == 0) {
rgba[RCOMP] = UP5(CC_SEL(src, 11));
rgba[GCOMP] = UP6(CC_SEL(src, 5));
rgba[BCOMP] = UP5(CC_SEL(src, 0));
}
else if (code == 1) {
rgba[RCOMP] = UP5(CC_SEL(src, 27));
rgba[GCOMP] = UP6(CC_SEL(src, 21));
rgba[BCOMP] = UP5(CC_SEL(src, 16));
}
else {
const word col0 = src[0] | (src[1] << 8);
const word col1 = src[2] | (src[3] << 8);
if (col0 > col1) {
if (code == 2) {
rgba[RCOMP] = (UP5(col0 >> 11) * 2 + UP5(col1 >> 11)) / 3;
rgba[GCOMP] = (UP6(col0 >> 5) * 2 + UP6(col1 >> 5)) / 3;
rgba[BCOMP] = (UP5(col0) * 2 + UP5(col1)) / 3;
}
else {
rgba[RCOMP] = (UP5(col0 >> 11) + 2 * UP5(col1 >> 11)) / 3;
rgba[GCOMP] = (UP6(col0 >> 5) + 2 * UP6(col1 >> 5)) / 3;
rgba[BCOMP] = (UP5(col0) + 2 * UP5(col1)) / 3;
}
}
else {
if (code == 2) {
rgba[RCOMP] = (UP5(col0 >> 11) + UP5(col1 >> 11)) / 2;
rgba[GCOMP] = (UP6(col0 >> 5) + UP6(col1 >> 5)) / 2;
rgba[BCOMP] = (UP5(col0) + UP5(col1)) / 2;
}
else {
ZERO_4UBV(rgba);
}
}
}
rgba[ACOMP] = 255;
}
void TAPIENTRY
dxt1_rgba_decode_1(const void *texture, int stride,
int i, int j, byte *rgba)
{
// Same as rgb_dxt1 above, except alpha=0 if col0<=col1 and code=3.
const byte *src = (const byte *)texture
+ ((j / 4) * ((stride + 3) / 4) + i / 4) * 8;
const int code = (src[4 + (j & 3)] >> ((i & 3) * 2)) & 0x3;
if (code == 0) {
rgba[RCOMP] = UP5(CC_SEL(src, 11));
rgba[GCOMP] = UP6(CC_SEL(src, 5));
rgba[BCOMP] = UP5(CC_SEL(src, 0));
rgba[ACOMP] = 255;
}
else if (code == 1) {
rgba[RCOMP] = UP5(CC_SEL(src, 27));
rgba[GCOMP] = UP6(CC_SEL(src, 21));
rgba[BCOMP] = UP5(CC_SEL(src, 16));
rgba[ACOMP] = 255;
}
else {
const word col0 = src[0] | (src[1] << 8);
const word col1 = src[2] | (src[3] << 8);
if (col0 > col1) {
if (code == 2) {
rgba[RCOMP] = (UP5(col0 >> 11) * 2 + UP5(col1 >> 11)) / 3;
rgba[GCOMP] = (UP6(col0 >> 5) * 2 + UP6(col1 >> 5)) / 3;
rgba[BCOMP] = (UP5(col0) * 2 + UP5(col1)) / 3;
}
else {
rgba[RCOMP] = (UP5(col0 >> 11) + 2 * UP5(col1 >> 11)) / 3;
rgba[GCOMP] = (UP6(col0 >> 5) + 2 * UP6(col1 >> 5)) / 3;
rgba[BCOMP] = (UP5(col0) + 2 * UP5(col1)) / 3;
}
rgba[ACOMP] = 255;
}
else {
if (code == 2) {
rgba[RCOMP] = (UP5(col0 >> 11) + UP5(col1 >> 11)) / 2;
rgba[GCOMP] = (UP6(col0 >> 5) + UP6(col1 >> 5)) / 2;
rgba[BCOMP] = (UP5(col0) + UP5(col1)) / 2;
rgba[ACOMP] = 255;
}
else {
ZERO_4UBV(rgba);
}
}
}
}
void TAPIENTRY
dxt3_rgba_decode_1(const void *texture, int stride,
int i, int j, byte *rgba)
{
const byte *src = (const byte *)texture
+ ((j / 4) * ((stride + 3) / 4) + i / 4) * 16;
const int code = (src[12 + (j & 3)] >> ((i & 3) * 2)) & 0x3;
const dword *cc = (const dword *)(src + 8);
if (code == 0) {
rgba[RCOMP] = UP5(CC_SEL(cc, 11));
rgba[GCOMP] = UP6(CC_SEL(cc, 5));
rgba[BCOMP] = UP5(CC_SEL(cc, 0));
}
else if (code == 1) {
rgba[RCOMP] = UP5(CC_SEL(cc, 27));
rgba[GCOMP] = UP6(CC_SEL(cc, 21));
rgba[BCOMP] = UP5(CC_SEL(cc, 16));
}
else if (code == 2) {
// (col0 * (4 - code) + col1 * (code - 1)) / 3
rgba[RCOMP] = (UP5(CC_SEL(cc, 11)) * 2 + UP5(CC_SEL(cc, 27))) / 3;
rgba[GCOMP] = (UP6(CC_SEL(cc, 5)) * 2 + UP6(CC_SEL(cc, 21))) / 3;
rgba[BCOMP] = (UP5(CC_SEL(cc, 0)) * 2 + UP5(CC_SEL(cc, 16))) / 3;
}
else {
rgba[RCOMP] = (UP5(CC_SEL(cc, 11)) + 2 * UP5(CC_SEL(cc, 27))) / 3;
rgba[GCOMP] = (UP6(CC_SEL(cc, 5)) + 2 * UP6(CC_SEL(cc, 21))) / 3;
rgba[BCOMP] = (UP5(CC_SEL(cc, 0)) + 2 * UP5(CC_SEL(cc, 16))) / 3;
}
rgba[ACOMP] = UP4(src[((j & 3) * 4 + (i & 3)) / 2] >> ((i & 1) * 4));
}
void TAPIENTRY
dxt5_rgba_decode_1(const void *texture, int stride,
int i, int j, byte *rgba)
{
const byte *src = (const byte *)texture
+ ((j / 4) * ((stride + 3) / 4) + i / 4) * 16;
const int code = (src[12 + (j & 3)] >> ((i & 3) * 2)) & 0x3;
const dword *cc = (const dword *)(src + 8);
const byte alpha0 = src[0];
const byte alpha1 = src[1];
const int alphaShift = (((j & 3) * 4) + (i & 3)) * 3 + 16;
const int acode = ((alphaShift == 31)
? CC_SEL(src + 2, alphaShift - 16)
: CC_SEL(src, alphaShift)) & 0x7;
if (code == 0) {
rgba[RCOMP] = UP5(CC_SEL(cc, 11));
rgba[GCOMP] = UP6(CC_SEL(cc, 5));
rgba[BCOMP] = UP5(CC_SEL(cc, 0));
}
else if (code == 1) {
rgba[RCOMP] = UP5(CC_SEL(cc, 27));
rgba[GCOMP] = UP6(CC_SEL(cc, 21));
rgba[BCOMP] = UP5(CC_SEL(cc, 16));
}
else if (code == 2) {
// (col0 * (4 - code) + col1 * (code - 1)) / 3
rgba[RCOMP] = (UP5(CC_SEL(cc, 11)) * 2 + UP5(CC_SEL(cc, 27))) / 3;
rgba[GCOMP] = (UP6(CC_SEL(cc, 5)) * 2 + UP6(CC_SEL(cc, 21))) / 3;
rgba[BCOMP] = (UP5(CC_SEL(cc, 0)) * 2 + UP5(CC_SEL(cc, 16))) / 3;
}
else {
rgba[RCOMP] = (UP5(CC_SEL(cc, 11)) + 2 * UP5(CC_SEL(cc, 27))) / 3;
rgba[GCOMP] = (UP6(CC_SEL(cc, 5)) + 2 * UP6(CC_SEL(cc, 21))) / 3;
rgba[BCOMP] = (UP5(CC_SEL(cc, 0)) + 2 * UP5(CC_SEL(cc, 16))) / 3;
}
if (acode == 0) {
rgba[ACOMP] = alpha0;
}
else if (acode == 1) {
rgba[ACOMP] = alpha1;
}
else if (alpha0 > alpha1) {
rgba[ACOMP] = (uint8_t)(((8 - acode) * alpha0 + (acode - 1) * alpha1) / 7);
}
else if (acode == 6) {
rgba[ACOMP] = 0;
}
else if (acode == 7) {
rgba[ACOMP] = 255;
}
else {
rgba[ACOMP] = (uint8_t)(((6 - acode) * alpha0 + (acode - 1) * alpha1) / 5);
}
}
Reference in New Issue View Git Blame Copy Permalink