leblane/TextureTaffy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
TextureTaffy/Source/ispc_texcomp/kernel.ispc

3798 lines
106 KiB
Text
Raw Permalink Normal View History

Initial code commit
2023-04-28 15:47:06 +03:00
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016, Intel Corporation
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of
// the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef ISPC_UINT_IS_DEFINED
//these are defined in ISPC version 1.13.0 and later
typedef unsigned int8 uint8;
typedef unsigned int32 uint32;
typedef unsigned int64 uint64;
#endif
///////////////////////////
// generic helpers
inline float RCP(float x)
{
return 1.0f/x; // uses rcp when compiled with --opt=fast-math
//return rcp(x);
//return rcp_fast(x);
}
inline float RSQRT(float x)
{
return 1.0f/sqrt(x); // uses rsqrt when compiled with --opt=fast-math
//return rsqrt(x);
//return rsqrt_fast(x);
}
inline void swap_ints(int u[], int v[], uniform int n)
{
for (uniform int i=0; i<n; i++)
{
int t = u[i];
u[i] = v[i];
v[i] = t;
}
}
inline void swap_uints(uint32 u[], uint32 v[], uniform int n)
{
for (uniform int i=0; i<n; i++)
{
uint32 t = u[i];
u[i] = v[i];
v[i] = t;
}
}
inline float sq(float v)
{
return v*v;
}
inline int pow2(int x)
{
return 1<<x;
}
inline float clamp(float v, int a, int b)
{
return clamp(v, (float)a, (float)b);
}
// the following helpers isolate performance warnings
inline unsigned int32 gather_uint(const uniform unsigned int32* const uniform ptr, int idx)
{
return ptr[idx]; // (perf warning expected)
}
inline unsigned int32 gather_uint(const varying unsigned int32* const uniform ptr, int idx)
{
return ptr[idx]; // (perf warning expected)
}
inline int32 gather_int(const uniform int32* const uniform ptr, int idx)
{
return ptr[idx]; // (perf warning expected)
}
inline float gather_float(varying float* uniform ptr, int idx)
{
return ptr[idx]; // (perf warning expected)
}
inline void scatter_uint(uniform unsigned int32* ptr, int idx, uint32 value)
{
ptr[idx] = value; // (perf warning expected)
}
inline void scatter_int(varying int32* uniform ptr, int idx, uint32 value)
{
ptr[idx] = value; // (perf warning expected)
}
inline uint32 shift_right(uint32 v, const uniform int bits)
{
return v>>bits; // (perf warning expected)
}
///////////////////////////////////////////////////////////
// BC1/BC7 shared
struct rgba_surface
{
uint8* ptr;
int width, height, stride;
};
inline void load_block_interleaved(float block[48], uniform rgba_surface* uniform src, int xx, uniform int yy)
{
for (uniform int y = 0; y<4; y++)
for (uniform int x = 0; x<4; x++)
{
uniform unsigned int32* uniform src_ptr = (unsigned int32*)&src->ptr[(yy * 4 + y)*src->stride];
unsigned int32 rgba = gather_uint(src_ptr, xx * 4 + x);
block[16 * 0 + y * 4 + x] = (int)((rgba >> 0) & 255);
block[16 * 1 + y * 4 + x] = (int)((rgba >> 8) & 255);
block[16 * 2 + y * 4 + x] = (int)((rgba >> 16) & 255);
}
}
inline void load_block_interleaved_rgba(float block[64], uniform rgba_surface* uniform src, int xx, uniform int yy)
{
for (uniform int y=0; y<4; y++)
for (uniform int x=0; x<4; x++)
{
uniform unsigned int32* uniform src_ptr = (unsigned int32*)&src->ptr[(yy*4+y)*src->stride];
unsigned int32 rgba = gather_uint(src_ptr, xx*4+x);
block[16*0+y*4+x] = (int)((rgba>> 0)&255);
block[16*1+y*4+x] = (int)((rgba>> 8)&255);
block[16*2+y*4+x] = (int)((rgba>>16)&255);
block[16*3+y*4+x] = (int)((rgba>>24)&255);
}
}
inline void load_block_interleaved_16bit(float block[48], uniform rgba_surface* uniform src, int xx, uniform int yy)
{
for (uniform int y = 0; y<4; y++)
for (uniform int x = 0; x<4; x++)
{
uniform unsigned int32* uniform src_ptr_r = (unsigned int32*)&src->ptr[(yy * 4 + y)*src->stride + 0];
uniform unsigned int32* uniform src_ptr_g = (unsigned int32*)&src->ptr[(yy * 4 + y)*src->stride + 2];
uniform unsigned int32* uniform src_ptr_b = (unsigned int32*)&src->ptr[(yy * 4 + y)*src->stride + 4];
unsigned int32 xr = gather_uint(src_ptr_r, (xx * 4 + x) * 2);
unsigned int32 xg = gather_uint(src_ptr_g, (xx * 4 + x) * 2);
unsigned int32 xb = gather_uint(src_ptr_b, (xx * 4 + x) * 2);
block[16 * 0 + y * 4 + x] = (int)(xr & 0xFFFF);
block[16 * 1 + y * 4 + x] = (int)(xg & 0xFFFF);
block[16 * 2 + y * 4 + x] = (int)(xb & 0xFFFF);
block[16 * 3 + y * 4 + x] = 0;
}
}
inline void load_block_r_8bit(float block[16], uniform rgba_surface* uniform src, int xx, uniform int yy)
{
for (uniform int y=0; y<4; y++)
{
uniform unsigned int32* uniform src_ptr = (unsigned int32*)&src->ptr[(yy*4+y)*src->stride];
unsigned int32 rrrr = gather_uint(src_ptr, xx);
block[y*4+0] = (int)((rrrr>> 0)&255);
block[y*4+1] = (int)((rrrr>> 8)&255);
block[y*4+2] = (int)((rrrr>>16)&255);
block[y*4+3] = (int)((rrrr>>24)&255);
}
}
inline void load_block_interleaved_rg_8bit(float block[32], uniform rgba_surface* uniform src, int xx, uniform int yy)
{
for (uniform int y=0; y<4; y++)
{
uniform unsigned int32* uniform src_ptr = (unsigned int32*)&src->ptr[(yy*4+y)*src->stride];
unsigned int32 rgrg0 = gather_uint(src_ptr, xx * 2 + 0);
unsigned int32 rgrg1 = gather_uint(src_ptr, xx * 2 + 1);
// r
block[16*0+y*4+0] = (int)((rgrg0>> 0)&255);
block[16*0+y*4+1] = (int)((rgrg0>>16)&255);
block[16*0+y*4+2] = (int)((rgrg1>> 0)&255);
block[16*0+y*4+3] = (int)((rgrg1>>16)&255);
// g
block[16*1+y*4+0] = (int)((rgrg0>> 8)&255);
block[16*1+y*4+1] = (int)((rgrg0>>24)&255);
block[16*1+y*4+2] = (int)((rgrg1>> 8)&255);
block[16*1+y*4+3] = (int)((rgrg1>>24)&255);
}
}
inline void store_data(uniform uint8 dst[], int width, int xx, uniform int yy, uint32 data[], int data_size)
{
for (uniform int k=0; k<data_size; k++)
{
uniform uint32* dst_ptr = (uint32*)&dst[(yy)*width*data_size];
scatter_uint(dst_ptr, xx*data_size+k, data[k]);
}
}
inline void ssymv(float a[3], float covar[6], float b[3])
{
a[0] = covar[0]*b[0]+covar[1]*b[1]+covar[2]*b[2];
a[1] = covar[1]*b[0]+covar[3]*b[1]+covar[4]*b[2];
a[2] = covar[2]*b[0]+covar[4]*b[1]+covar[5]*b[2];
}
inline void ssymv3(float a[4], float covar[10], float b[4])
{
a[0] = covar[0]*b[0]+covar[1]*b[1]+covar[2]*b[2];
a[1] = covar[1]*b[0]+covar[4]*b[1]+covar[5]*b[2];
a[2] = covar[2]*b[0]+covar[5]*b[1]+covar[7]*b[2];
}
inline void ssymv4(float a[4], float covar[10], float b[4])
{
a[0] = covar[0]*b[0]+covar[1]*b[1]+covar[2]*b[2]+covar[3]*b[3];
a[1] = covar[1]*b[0]+covar[4]*b[1]+covar[5]*b[2]+covar[6]*b[3];
a[2] = covar[2]*b[0]+covar[5]*b[1]+covar[7]*b[2]+covar[8]*b[3];
a[3] = covar[3]*b[0]+covar[6]*b[1]+covar[8]*b[2]+covar[9]*b[3];
}
inline void compute_axis3(float axis[3], float covar[6], uniform const int powerIterations)
{
float vec[3] = {1,1,1};
for (uniform int i=0; i<powerIterations; i++)
{
ssymv(axis, covar, vec);
for (uniform int p=0; p<3; p++) vec[p] = axis[p];
if (i%2==1) // renormalize every other iteration
{
float norm_sq = 0;
for (uniform int p=0; p<3; p++)
norm_sq += axis[p]*axis[p];
float rnorm = RSQRT(norm_sq);
for (uniform int p=0; p<3; p++) vec[p] *= rnorm;
}
}
for (uniform int p=0; p<3; p++) axis[p] = vec[p];
}
inline void compute_axis(float axis[4], float covar[10], uniform const int powerIterations, uniform int channels)
{
float vec[4] = {1,1,1,1};
for (uniform int i=0; i<powerIterations; i++)
{
if (channels == 3) ssymv3(axis, covar, vec);
if (channels == 4) ssymv4(axis, covar, vec);
for (uniform int p=0; p<channels; p++) vec[p] = axis[p];
if (i%2==1) // renormalize every other iteration
{
float norm_sq = 0;
for (uniform int p=0; p<channels; p++)
norm_sq += axis[p]*axis[p];
float rnorm = RSQRT(norm_sq);
for (uniform int p=0; p<channels; p++) vec[p] *= rnorm;
}
}
for (uniform int p=0; p<channels; p++) axis[p] = vec[p];
}
///////////////////////////////////////////////////////////
// BC1/BC3 encoding
inline int stb__Mul8Bit(int a, int b)
{
int t = a*b + 128;
return (t + (t >> 8)) >> 8;
}
inline unsigned int16 stb__As16Bit(int r, int g, int b)
{
return (stb__Mul8Bit(r,31) << 11) + (stb__Mul8Bit(g,63) << 5) + stb__Mul8Bit(b,31);
}
inline unsigned int16 enc_rgb565(float c[3])
{
return stb__As16Bit((int)c[0], (int)c[1], (int)c[2]);
}
inline void dec_rgb565(float c[3], int p)
{
int c2 = (p>>0)&31;
int c1 = (p>>5)&63;
int c0 = (p>>11)&31;
c[0] = (c0<<3)+(c0>>2);
c[1] = (c1<<2)+(c1>>4);
c[2] = (c2<<3)+(c2>>2);
}
inline void pick_endpoints_dc(int c0[3], int c1[3], int block[48], int iaxis[3])
{
for (uniform int p=0; p<3; p++)
for (uniform int y=0; y<4; y++)
for (uniform int x=0; x<4; x++)
{
c0[p] += block[p*16+y*4+x];
}
for (uniform int p=0; p<3; p++)
c0[p] >>= 4;
}
inline void pick_endpoints(float c0[3], float c1[3], float block[48], float axis[3], float dc[3])
{
float min_dot = 256*256;
float max_dot = 0;
for (uniform int y=0; y<4; y++)
for (uniform int x=0; x<4; x++)
{
float dot = 0;
for (uniform int p=0; p<3; p++)
dot += (block[p*16+y*4+x]-dc[p])*axis[p];
min_dot = min(min_dot, dot);
max_dot = max(max_dot, dot);
}
if (max_dot-min_dot < 1.0f)
{
min_dot -= 0.5f;
max_dot += 0.5f;
}
float norm_sq = 0;
for (uniform int p=0; p<3; p++)
norm_sq += axis[p]*axis[p];
float rnorm_sq = RCP(norm_sq);
for (uniform int p=0; p<3; p++)
{
c0[p] = clamp(dc[p]+min_dot*rnorm_sq*axis[p], 0, 255);
c1[p] = clamp(dc[p]+max_dot*rnorm_sq*axis[p], 0, 255);
}
}
inline uint32 fast_quant(float block[48], int p0, int p1)
{
float c0[3];
float c1[3];
dec_rgb565(c0, p0);
dec_rgb565(c1, p1);
float dir[3];
for (uniform int p=0; p<3; p++) dir[p] = c1[p]-c0[p];
float sq_norm = 0;
for (uniform int p=0; p<3; p++) sq_norm += sq(dir[p]);
float rsq_norm = RCP(sq_norm);
for (uniform int p=0; p<3; p++) dir[p] *= rsq_norm*3;
float bias = 0.5;
for (uniform int p=0; p<3; p++) bias -= c0[p]*dir[p];
uint32 bits = 0;
uint32 scaler = 1;
for (uniform int k=0; k<16; k++)
{
float dot = 0;
for (uniform int p=0; p<3; p++)
dot += block[k+p*16]*dir[p];
int q = clamp((int)(dot+bias), 0, 3);
//bits += q<<(k*2);
bits += q*scaler;
scaler *= 4;
}
return bits;
}
inline void compute_covar_dc(float covar[6], float dc[3], float block[48])
{
for (uniform int i=0; i<6; i++) covar[i] = 0;
for (uniform int p=0; p<3; p++) dc[p] = 0;
for (uniform int k=0; k<16; k++)
{
for (uniform int p=0; p<3; p++)
dc[p] += block[k+p*16];
}
for (uniform int p=0; p<3; p++) dc[p] /= 16;
for (uniform int k=0; k<16; k++)
{
float rgb[3];
for (uniform int p=0; p<3; p++)
rgb[p] = block[k+p*16]-dc[p];
covar[0] += rgb[0]*rgb[0];
covar[1] += rgb[0]*rgb[1];
covar[2] += rgb[0]*rgb[2];
covar[3] += rgb[1]*rgb[1];
covar[4] += rgb[1]*rgb[2];
covar[5] += rgb[2]*rgb[2];
}
}
// ugly, but makes BC1 compression 20% faster overall
inline void compute_covar_dc_ugly(float covar[6], float dc[3], float block[48])
{
for (uniform int p=0; p<3; p++)
{
float acc = 0;
for (uniform int k=0; k<16; k++)
acc += block[k+p*16];
dc[p] = acc/16;
}
float covar0 = 0.0f;
float covar1 = 0.0f;
float covar2 = 0.0f;
float covar3 = 0.0f;
float covar4 = 0.0f;
float covar5 = 0.0f;
for (uniform int k=0; k<16; k++)
{
float rgb0, rgb1, rgb2;
rgb0 = block[k+0*16]-dc[0];
rgb1 = block[k+1*16]-dc[1];
rgb2 = block[k+2*16]-dc[2];
covar0 += rgb0*rgb0;
covar1 += rgb0*rgb1;
covar2 += rgb0*rgb2;
covar3 += rgb1*rgb1;
covar4 += rgb1*rgb2;
covar5 += rgb2*rgb2;
}
covar[0] = covar0;
covar[1] = covar1;
covar[2] = covar2;
covar[3] = covar3;
covar[4] = covar4;
covar[5] = covar5;
}
inline void bc1_refine(int pe[2], float block[48], unsigned int32 bits, float dc[3])
{
float c0[3];
float c1[3];
if ((bits ^ (bits*4)) < 4)
{
// single color
for (uniform int p=0; p<3; p++)
{
c0[p] = dc[p];
c1[p] = dc[p];
}
}
else
{
float Atb1[3] = {0,0,0};
float sum_q = 0;
float sum_qq = 0;
unsigned int32 shifted_bits = bits;
for (uniform int k=0; k<16; k++)
{
float q = (int)(shifted_bits&3);
shifted_bits >>= 2;
float x = 3-q;
float y = q;
sum_q += q;
sum_qq += q*q;
for (uniform int p=0; p<3; p++) Atb1[p] += x*block[k+p*16];
}
float sum[3];
float Atb2[3];
for (uniform int p=0; p<3; p++)
{
sum[p] = dc[p]*16;
Atb2[p] = 3*sum[p]-Atb1[p];
}
float Cxx = 16*sq(3)-2*3*sum_q+sum_qq;
float Cyy = sum_qq;
float Cxy = 3*sum_q-sum_qq;
float scale = 3.0f * RCP(Cxx*Cyy - Cxy*Cxy);
for (uniform int p=0; p<3; p++)
{
c0[p] = (Atb1[p]*Cyy - Atb2[p]*Cxy)*scale;
c1[p] = (Atb2[p]*Cxx - Atb1[p]*Cxy)*scale;
c0[p] = clamp(c0[p], 0, 255);
c1[p] = clamp(c1[p], 0, 255);
}
}
pe[0] = enc_rgb565(c0);
pe[1] = enc_rgb565(c1);
}
inline uint32 fix_qbits(uint32 qbits)
{
uniform const uint32 mask_01b = 0x55555555;
uniform const uint32 mask_10b = 0xAAAAAAAA;
uint32 qbits0 = qbits&mask_01b;
uint32 qbits1 = qbits&mask_10b;
qbits = (qbits1>>1) + (qbits1 ^ (qbits0<<1));
return qbits;
}
inline void CompressBlockBC1_core(float block[48], uint32 data[2])
{
uniform const int powerIterations = 4;
uniform const int refineIterations = 1;
float covar[6];
float dc[3];
compute_covar_dc_ugly(covar, dc, block);
float eps = 0.001;
covar[0] += eps;
covar[3] += eps;
covar[5] += eps;
float axis[3];
compute_axis3(axis, covar, powerIterations);
float c0[3];
float c1[3];
pick_endpoints(c0, c1, block, axis, dc);
int p[2];
p[0] = enc_rgb565(c0);
p[1] = enc_rgb565(c1);
if (p[0]<p[1]) swap_ints(&p[0], &p[1], 1);
data[0] = (1<<16)*p[1]+p[0];
data[1] = fast_quant(block, p[0], p[1]);
// refine
for (uniform int i=0; i<refineIterations; i++)
{
bc1_refine(p, block, data[1], dc);
if (p[0]<p[1]) swap_ints(&p[0], &p[1], 1);
data[0] = (1<<16)*p[1]+p[0];
data[1] = fast_quant(block, p[0], p[1]);
}
data[1] = fix_qbits(data[1]);
}
inline void CompressBlockBC3_alpha(float block[16], uint32 data[2])
{
float ep[2] = { 255, 0 };
for (uniform int k=0; k<16; k++)
{
ep[0] = min(ep[0], block[k]);
ep[1] = max(ep[1], block[k]);
}
if (ep[0] == ep[1]) ep[1] = ep[0]+0.1f;
uint32 qblock[2] = { 0, 0 };
float scale = 7.0f/(ep[1]-ep[0]);
for (uniform int k=0; k<16; k++)
{
float v = block[k];
float proj = (v-ep[0])*scale+0.5f;
int q = clamp((int)proj, 0, 7);
q = 7-q;
if (q > 0) q++;
if (q==8) q = 1;
qblock[k/8] |= q << ((k%8)*3);
}
// (could be improved by refinement)
data[0] = clamp((int)ep[0], 0, 255)*256+clamp((int)ep[1], 0, 255);
data[0] |= qblock[0]<<16;
data[1] = qblock[0]>>16;
data[1] |= qblock[1]<<8;
}
inline void CompressBlockBC1(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[])
{
float block[48];
uint32 data[2];
load_block_interleaved(block, src, xx, yy);
CompressBlockBC1_core(block, data);
store_data(dst, src->width, xx, yy, data, 2);
}
inline void CompressBlockBC3(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[])
{
float block[64];
uint32 data[4];
load_block_interleaved_rgba(block, src, xx, yy);
CompressBlockBC3_alpha(&block[48], &data[0]);
CompressBlockBC1_core(block, &data[2]);
store_data(dst, src->width, xx, yy, data, 4);
}
inline void CompressBlockBC4(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[])
{
float block[16];
uint32 data[2];
load_block_r_8bit(block, src, xx, yy);
CompressBlockBC3_alpha(block, data);
store_data(dst, src->width, xx, yy, data, 2);
}
inline void CompressBlockBC5(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[])
{
float block[32];
uint32 data[4];
load_block_interleaved_rg_8bit(block, src, xx, yy);
CompressBlockBC3_alpha(block, data);
CompressBlockBC3_alpha(&block[16], &data[2]);
store_data(dst, src->width, xx, yy, data, 4);
}
export void CompressBlocksBC1_ispc(uniform rgba_surface src[], uniform uint8 dst[])
{
for (uniform int yy = 0; yy<src->height/4; yy++)
foreach (xx = 0 ... src->width/4)
{
CompressBlockBC1(src, xx, yy, dst);
}
}
export void CompressBlocksBC3_ispc(uniform rgba_surface src[], uniform uint8 dst[])
{
for (uniform int yy = 0; yy<src->height/4; yy++)
foreach (xx = 0 ... src->width/4)
{
CompressBlockBC3(src, xx, yy, dst);
}
}
export void CompressBlocksBC4_ispc(uniform rgba_surface src[], uniform uint8 dst[])
{
for (uniform int yy = 0; yy<src->height/4; yy++)
foreach (xx = 0 ... src->width/4)
{
CompressBlockBC4(src, xx, yy, dst);
}
}
export void CompressBlocksBC5_ispc(uniform rgba_surface src[], uniform uint8 dst[])
{
for (uniform int yy = 0; yy<src->height/4; yy++)
foreach (xx = 0 ... src->width/4)
{
CompressBlockBC5(src, xx, yy, dst);
}
}
///////////////////////////////////////////////////////////
// BC7 encoding
struct bc7_enc_settings
{
bool mode_selection[4];
int refineIterations[8];
bool skip_mode2;
int fastSkipTreshold_mode1;
int fastSkipTreshold_mode3;
int fastSkipTreshold_mode7;
int mode45_channel0;
int refineIterations_channel;
int channels;
};
struct bc7_enc_state
{
float block[64];
float opaque_err; // error for coding alpha=255
float best_err;
uint32 best_data[5]; // 4, +1 margin for skips
// settings
uniform bool mode_selection[4];
uniform int refineIterations[8];
uniform bool skip_mode2;
uniform int fastSkipTreshold_mode1;
uniform int fastSkipTreshold_mode3;
uniform int fastSkipTreshold_mode7;
uniform int mode45_channel0;
uniform int refineIterations_channel;
uniform int channels;
};
struct mode45_parameters
{
int qep[8];
uint32 qblock[2];
int aqep[2];
uint32 aqblock[2];
int rotation;
int swap;
};
void bc7_code_mode01237(uint32 data[5], int qep[6], uint32 qblock[2], int part_id, uniform int mode);
void bc7_code_mode45(uint32 data[5], mode45_parameters params[], uniform int mode);
void bc7_code_mode6(uint32 data[5], int qep[8], uint32 qblock[2]);
///////////////////////////
// BC7 format data
inline uniform const int* uniform get_unquant_table(uniform int bits)
{
assert(bits>=2 && bits<=4); // invalid bit size
static uniform const int unquant_table_2bits[] = { 0, 21, 43, 64 };
static uniform const int unquant_table_3bits[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
static uniform const int unquant_table_4bits[] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
uniform const int* uniform unquant_tables[] = {unquant_table_2bits, unquant_table_3bits, unquant_table_4bits};
return unquant_tables[bits-2];
}
inline uint32 get_pattern(int part_id)
{
static uniform const uint32 pattern_table[] = {
0x50505050u, 0x40404040u, 0x54545454u, 0x54505040u, 0x50404000u, 0x55545450u, 0x55545040u, 0x54504000u,
0x50400000u, 0x55555450u, 0x55544000u, 0x54400000u, 0x55555440u, 0x55550000u, 0x55555500u, 0x55000000u,
0x55150100u, 0x00004054u, 0x15010000u, 0x00405054u, 0x00004050u, 0x15050100u, 0x05010000u, 0x40505054u,
0x00404050u, 0x05010100u, 0x14141414u, 0x05141450u, 0x01155440u, 0x00555500u, 0x15014054u, 0x05414150u,
0x44444444u, 0x55005500u, 0x11441144u, 0x05055050u, 0x05500550u, 0x11114444u, 0x41144114u, 0x44111144u,
0x15055054u, 0x01055040u, 0x05041050u, 0x05455150u, 0x14414114u, 0x50050550u, 0x41411414u, 0x00141400u,
0x00041504u, 0x00105410u, 0x10541000u, 0x04150400u, 0x50410514u, 0x41051450u, 0x05415014u, 0x14054150u,
0x41050514u, 0x41505014u, 0x40011554u, 0x54150140u, 0x50505500u, 0x00555050u, 0x15151010u, 0x54540404u,
0xAA685050u, 0x6A5A5040u, 0x5A5A4200u, 0x5450A0A8u, 0xA5A50000u, 0xA0A05050u, 0x5555A0A0u, 0x5A5A5050u,
0xAA550000u, 0xAA555500u, 0xAAAA5500u, 0x90909090u, 0x94949494u, 0xA4A4A4A4u, 0xA9A59450u, 0x2A0A4250u,
0xA5945040u, 0x0A425054u, 0xA5A5A500u, 0x55A0A0A0u, 0xA8A85454u, 0x6A6A4040u, 0xA4A45000u, 0x1A1A0500u,
0x0050A4A4u, 0xAAA59090u, 0x14696914u, 0x69691400u, 0xA08585A0u, 0xAA821414u, 0x50A4A450u, 0x6A5A0200u,
0xA9A58000u, 0x5090A0A8u, 0xA8A09050u, 0x24242424u, 0x00AA5500u, 0x24924924u, 0x24499224u, 0x50A50A50u,
0x500AA550u, 0xAAAA4444u, 0x66660000u, 0xA5A0A5A0u, 0x50A050A0u, 0x69286928u, 0x44AAAA44u, 0x66666600u,
0xAA444444u, 0x54A854A8u, 0x95809580u, 0x96969600u, 0xA85454A8u, 0x80959580u, 0xAA141414u, 0x96960000u,
0xAAAA1414u, 0xA05050A0u, 0xA0A5A5A0u, 0x96000000u, 0x40804080u, 0xA9A8A9A8u, 0xAAAAAA44u, 0x2A4A5254u
};
return gather_uint(pattern_table, part_id);
}
inline int get_pattern_mask(int part_id, int j)
{
static uniform const uint32 pattern_mask_table[] = {
0xCCCC3333u, 0x88887777u, 0xEEEE1111u, 0xECC81337u, 0xC880377Fu, 0xFEEC0113u, 0xFEC80137u, 0xEC80137Fu,
0xC80037FFu, 0xFFEC0013u, 0xFE80017Fu, 0xE80017FFu, 0xFFE80017u, 0xFF0000FFu, 0xFFF0000Fu, 0xF0000FFFu,
0xF71008EFu, 0x008EFF71u, 0x71008EFFu, 0x08CEF731u, 0x008CFF73u, 0x73108CEFu, 0x3100CEFFu, 0x8CCE7331u,
0x088CF773u, 0x3110CEEFu, 0x66669999u, 0x366CC993u, 0x17E8E817u, 0x0FF0F00Fu, 0x718E8E71u, 0x399CC663u,
0xAAAA5555u, 0xF0F00F0Fu, 0x5A5AA5A5u, 0x33CCCC33u, 0x3C3CC3C3u, 0x55AAAA55u, 0x96966969u, 0xA55A5AA5u,
0x73CE8C31u, 0x13C8EC37u, 0x324CCDB3u, 0x3BDCC423u, 0x69969669u, 0xC33C3CC3u, 0x99666699u, 0x0660F99Fu,
0x0272FD8Du, 0x04E4FB1Bu, 0x4E40B1BFu, 0x2720D8DFu, 0xC93636C9u, 0x936C6C93u, 0x39C6C639u, 0x639C9C63u,
0x93366CC9u, 0x9CC66339u, 0x817E7E81u, 0xE71818E7u, 0xCCF0330Fu, 0x0FCCF033u, 0x774488BBu, 0xEE2211DDu,
0x08CC0133u, 0x8CC80037u, 0xCC80006Fu, 0xEC001331u, 0x330000FFu, 0x00CC3333u, 0xFF000033u, 0xCCCC0033u,
0x0F0000FFu, 0x0FF0000Fu, 0x00F0000Fu, 0x44443333u, 0x66661111u, 0x22221111u, 0x136C0013u, 0x008C8C63u,
0x36C80137u, 0x08CEC631u, 0x3330000Fu, 0xF0000333u, 0x00EE1111u, 0x88880077u, 0x22C0113Fu, 0x443088CFu,
0x0C22F311u, 0x03440033u, 0x69969009u, 0x9960009Fu, 0x03303443u, 0x00660699u, 0xC22C3113u, 0x8C0000EFu,
0x1300007Fu, 0xC4003331u, 0x004C1333u, 0x22229999u, 0x00F0F00Fu, 0x24929249u, 0x29429429u, 0xC30C30C3u,
0xC03C3C03u, 0x00AA0055u, 0xAA0000FFu, 0x30300303u, 0xC0C03333u, 0x90900909u, 0xA00A5005u, 0xAAA0000Fu,
0x0AAA0555u, 0xE0E01111u, 0x70700707u, 0x6660000Fu, 0x0EE01111u, 0x07707007u, 0x06660999u, 0x660000FFu,
0x00660099u, 0x0CC03333u, 0x03303003u, 0x60000FFFu, 0x80807777u, 0x10100101u, 0x000A0005u, 0x08CE8421u
};
uint32 mask_packed = gather_uint(pattern_mask_table, part_id);
int mask0 = mask_packed&0xFFFF;
int mask1 = mask_packed>>16;
int mask = (j==2) ? (~mask0)&(~mask1) : ( (j==0) ? mask0 : mask1 );
return mask;
}
inline void get_skips(int skips[3], int part_id)
{
static uniform const int skip_table[] = {
0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u,
0xf0u, 0x20u, 0x80u, 0x20u, 0x20u, 0x80u, 0x80u, 0xf0u, 0x20u, 0x80u, 0x20u, 0x20u, 0x80u, 0x80u, 0x20u, 0x20u,
0xf0u, 0xf0u, 0x60u, 0x80u, 0x20u, 0x80u, 0xf0u, 0xf0u, 0x20u, 0x80u, 0x20u, 0x20u, 0x20u, 0xf0u, 0xf0u, 0x60u,
0x60u, 0x20u, 0x60u, 0x80u, 0xf0u, 0xf0u, 0x20u, 0x20u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0xf0u, 0x20u, 0x20u, 0xf0u,
0x3fu, 0x38u, 0xf8u, 0xf3u, 0x8fu, 0x3fu, 0xf3u, 0xf8u, 0x8fu, 0x8fu, 0x6fu, 0x6fu, 0x6fu, 0x5fu, 0x3fu, 0x38u,
0x3fu, 0x38u, 0x8fu, 0xf3u, 0x3fu, 0x38u, 0x6fu, 0xa8u, 0x53u, 0x8fu, 0x86u, 0x6au, 0x8fu, 0x5fu, 0xfau, 0xf8u,
0x8fu, 0xf3u, 0x3fu, 0x5au, 0x6au, 0xa8u, 0x89u, 0xfau, 0xf6u, 0x3fu, 0xf8u, 0x5fu, 0xf3u, 0xf6u, 0xf6u, 0xf8u,
0x3fu, 0xf3u, 0x5fu, 0x5fu, 0x5fu, 0x8fu, 0x5fu, 0xafu, 0x5fu, 0xafu, 0x8fu, 0xdfu, 0xf3u, 0xcfu, 0x3fu, 0x38u
};
int skip_packed = gather_int(skip_table, part_id);
skips[0] = 0;
skips[1] = skip_packed>>4;
skips[2] = skip_packed&15;
}
///////////////////////////
// PCA helpers
inline void compute_stats_masked(float stats[15], float block[64], int mask, uniform int channels)
{
for (uniform int i=0; i<15; i++) stats[i] = 0;
int mask_shifted = mask<<1;
for (uniform int k=0; k<16; k++)
{
mask_shifted >>= 1;
//if ((mask_shifted&1) == 0) continue;
int flag = (mask_shifted&1);
float rgba[4];
for (uniform int p=0; p<channels; p++) rgba[p] = block[k+p*16];
for (uniform int p=0; p<channels; p++) rgba[p] *= flag;
stats[14] += flag;
stats[10] += rgba[0];
stats[11] += rgba[1];
stats[12] += rgba[2];
stats[0] += rgba[0]*rgba[0];
stats[1] += rgba[0]*rgba[1];
stats[2] += rgba[0]*rgba[2];
stats[4] += rgba[1]*rgba[1];
stats[5] += rgba[1]*rgba[2];
stats[7] += rgba[2]*rgba[2];
if (channels==4)
{
stats[13] += rgba[3];
stats[3] += rgba[0]*rgba[3];
stats[6] += rgba[1]*rgba[3];
stats[8] += rgba[2]*rgba[3];
stats[9] += rgba[3]*rgba[3];
}
}
}
inline void covar_from_stats(float covar[10], float stats[15], uniform int channels)
{
covar[0] = stats[0] - stats[10+0]*stats[10+0]/stats[14];
covar[1] = stats[1] - stats[10+0]*stats[10+1]/stats[14];
covar[2] = stats[2] - stats[10+0]*stats[10+2]/stats[14];
covar[4] = stats[4] - stats[10+1]*stats[10+1]/stats[14];
covar[5] = stats[5] - stats[10+1]*stats[10+2]/stats[14];
covar[7] = stats[7] - stats[10+2]*stats[10+2]/stats[14];
if (channels == 4)
{
covar[3] = stats[3] - stats[10+0]*stats[10+3]/stats[14];
covar[6] = stats[6] - stats[10+1]*stats[10+3]/stats[14];
covar[8] = stats[8] - stats[10+2]*stats[10+3]/stats[14];
covar[9] = stats[9] - stats[10+3]*stats[10+3]/stats[14];
}
}
inline void compute_covar_dc_masked(float covar[6], float dc[3], float block[64], int mask, uniform int channels)
{
float stats[15];
compute_stats_masked(stats, block, mask, channels);
covar_from_stats(covar, stats, channels);
for (uniform int p=0; p<channels; p++) dc[p] = stats[10+p]/stats[14];
}
void block_pca_axis(float axis[4], float dc[4], float block[64], int mask, uniform int channels)
{
uniform const int powerIterations = 8; // 4 not enough for HQ
float covar[10];
compute_covar_dc_masked(covar, dc, block, mask, channels);
//float var = covar[0] + covar[4] + covar[7] + covar[9] + 256;
float inv_var = 1.0 / (256 * 256);
for (uniform int k = 0; k < 10; k++)
{
covar[k] *= inv_var;
}
float eps = sq(0.001);
covar[0] += eps;
covar[4] += eps;
covar[7] += eps;
covar[9] += eps;
compute_axis(axis, covar, powerIterations, channels);
}
void block_segment_core(float ep[], float block[64], int mask, uniform int channels)
{
float axis[4];
float dc[4];
block_pca_axis(axis, dc, block, mask, channels);
float ext[2];
ext[0] = +1e99;
ext[1] = -1e99;
// find min/max
int mask_shifted = mask<<1;
for (uniform int k=0; k<16; k++)
{
mask_shifted >>= 1;
if ((mask_shifted&1) == 0) continue;
float dot = 0;
for (uniform int p=0; p<channels; p++)
dot += axis[p]*(block[16*p+k]-dc[p]);
ext[0] = min(ext[0], dot);
ext[1] = max(ext[1], dot);
}
// create some distance if the endpoints collapse
if (ext[1]-ext[0] < 1.0f)
{
ext[0] -= 0.5f;
ext[1] += 0.5f;
}
for (uniform int i=0; i<2; i++)
for (uniform int p=0; p<channels; p++)
{
ep[4*i+p] = ext[i]*axis[p]+dc[p];
}
}
void block_segment(float ep[], float block[64], int mask, uniform int channels)
{
block_segment_core(ep, block, mask, channels);
for (uniform int i=0; i<2; i++)
for (uniform int p=0; p<channels; p++)
{
ep[4*i+p] = clamp(ep[4*i+p], 0, 255);
}
}
float get_pca_bound(float covar[10], uniform int channels)
{
uniform const int powerIterations = 4; // quite approximative, but enough for bounding
float inv_var = 1.0 / (256 * 256);
for (uniform int k = 0; k < 10; k++)
{
covar[k] *= inv_var;
}
float eps = sq(0.001);
covar[0] += eps;
covar[4] += eps;
covar[7] += eps;
float axis[4];
compute_axis(axis, covar, powerIterations, channels);
float vec[4];
if (channels == 3) ssymv3(vec, covar, axis);
if (channels == 4) ssymv4(vec, covar, axis);
float sq_sum = 0.0f;
for (uniform int p=0; p<channels; p++) sq_sum += sq(vec[p]);
float lambda = sqrt(sq_sum);
float bound = covar[0]+covar[4]+covar[7];
if (channels == 4) bound += covar[9];
bound -= lambda;
bound = max(bound, 0.0);
return bound;
}
float block_pca_bound(float block[64], int mask, uniform int channels)
{
float stats[15];
compute_stats_masked(stats, block, mask, channels);
float covar[10];
covar_from_stats(covar, stats, channels);
return get_pca_bound(covar, channels);
}
float block_pca_bound_split(float block[64], int mask, float full_stats[15], uniform int channels)
{
float stats[15];
compute_stats_masked(stats, block, mask, channels);
float covar1[10];
covar_from_stats(covar1, stats, channels);
for (uniform int i=0; i<15; i++)
stats[i] = full_stats[i] - stats[i];
float covar2[10];
covar_from_stats(covar2, stats, channels);
float bound = 0.0f;
bound += get_pca_bound(covar1, channels);
bound += get_pca_bound(covar2, channels);
return sqrt(bound)*256;
}
///////////////////////////
// endpoint quantization
inline int unpack_to_byte(int v, uniform const int bits)
{
assert(bits >= 4);
int vv = v<<(8-bits);
return vv + shift_right(vv, bits);
}
void ep_quant0367(int qep[], float ep[], uniform int mode, uniform int channels)
{
uniform int bits = 7;
if (mode == 0) bits = 4;
if (mode == 7) bits = 5;
uniform int levels = 1 << bits;
uniform int levels2 = levels*2-1;
for (uniform int i=0; i<2; i++)
{
int qep_b[8];
for (uniform int b=0; b<2; b++)
for (uniform int p=0; p<4; p++)
{
int v = (int)((ep[i*4+p]/255.0f*levels2-b)/2+0.5)*2+b;
qep_b[b*4+p] = clamp(v, b, levels2-1+b);
}
float ep_b[8];
for (uniform int j=0; j<8; j++)
ep_b[j] = qep_b[j];
if (mode==0)
for (uniform int j=0; j<8; j++)
ep_b[j] = unpack_to_byte(qep_b[j], 5);
float err0 = 0.0f;
float err1 = 0.0f;
for (uniform int p=0; p<channels; p++)
{
err0 += sq(ep[i*4+p]-ep_b[0+p]);
err1 += sq(ep[i*4+p]-ep_b[4+p]);
}
for (uniform int p=0; p<4; p++)
qep[i*4+p] = (err0<err1) ? qep_b[0+p] : qep_b[4+p];
}
}
void ep_quant1(int qep[], float ep[], uniform int mode)
{
int qep_b[16];
for (uniform int b=0; b<2; b++)
for (uniform int i=0; i<8; i++)
{
int v = ((int)((ep[i]/255.0f*127.0f-b)/2+0.5))*2+b;
qep_b[b*8+i] = clamp(v, b, 126+b);
}
// dequant
float ep_b[16];
for (uniform int k=0; k<16; k++)
ep_b[k] = unpack_to_byte(qep_b[k], 7);
float err0 = 0.0f;
float err1 = 0.0f;
for (uniform int j = 0; j < 2; j++)
for (uniform int p = 0; p < 3; p++)
{
err0 += sq(ep[j * 4 + p] - ep_b[0 + j * 4 + p]);
err1 += sq(ep[j * 4 + p] - ep_b[8 + j * 4 + p]);
}
for (uniform int i=0; i<8; i++)
qep[i] = (err0<err1) ? qep_b[0+i] : qep_b[8+i];
}
void ep_quant245(int qep[], float ep[], uniform int mode)
{
uniform int bits = 5;
if (mode == 5) bits = 7;
uniform int levels = 1 << bits;
for (uniform int i=0; i<8; i++)
{
int v = ((int)(ep[i]/255.0f*(levels-1)+0.5));
qep[i] = clamp(v, 0, levels-1);
}
}
void ep_quant(int qep[], float ep[], uniform int mode, uniform int channels)
{
assert(mode <= 7);
static uniform const int pairs_table[] = {3,2,3,2,1,1,1,2};
uniform const int pairs = pairs_table[mode];
if (mode == 0 || mode == 3 || mode == 6 || mode == 7)
{
for (uniform int i=0; i<pairs; i++)
ep_quant0367(&qep[i*8], &ep[i*8], mode, channels);
}
else if (mode == 1)
{
for (uniform int i=0; i<pairs; i++)
ep_quant1(&qep[i*8], &ep[i*8], mode);
}
else if (mode == 2 || mode == 4 || mode == 5)
{
for (uniform int i=0; i<pairs; i++)
ep_quant245(&qep[i*8], &ep[i*8], mode);
}
else
assert(false);
}
void ep_dequant(float ep[], int qep[], uniform int mode)
{
assert(mode <= 7);
static uniform const int pairs_table[] = {3,2,3,2,1,1,1,2};
uniform const int pairs = pairs_table[mode];
// mode 3, 6 are 8-bit
if (mode == 3 || mode == 6)
{
for (uniform int i=0; i<8*pairs; i++)
ep[i] = qep[i];
}
else if (mode == 1 || mode == 5)
{
for (uniform int i=0; i<8*pairs; i++)
ep[i] = unpack_to_byte(qep[i], 7);
}
else if (mode == 0 || mode == 2 || mode == 4)
{
for (uniform int i=0; i<8*pairs; i++)
ep[i] = unpack_to_byte(qep[i], 5);
}
else if (mode == 7)
{
for (uniform int i=0; i<8*pairs; i++)
ep[i] = unpack_to_byte(qep[i], 6);
}
else
assert(false);
}
void ep_quant_dequant(int qep[], float ep[], uniform int mode, uniform int channels)
{
ep_quant(qep, ep, mode, channels);
ep_dequant(ep, qep, mode);
}
///////////////////////////
// pixel quantization
float block_quant(uint32 qblock[2], float block[64], uniform int bits, float ep[], uint32 pattern, uniform int channels)
{
float total_err = 0;
uniform const int* uniform unquant_table = get_unquant_table(bits);
int levels = 1 << bits;
// 64-bit qblock: 5% overhead in this function
for (uniform int k=0; k<2; k++) qblock[k] = 0;
int pattern_shifted = pattern;
for (uniform int k=0; k<16; k++)
{
int j = pattern_shifted&3;
pattern_shifted >>= 2;
float proj = 0;
float div = 0;
for (uniform int p=0; p<channels; p++)
{
float ep_a = gather_float(ep, 8*j+0+p);
float ep_b = gather_float(ep, 8*j+4+p);
proj += (block[k+p*16]-ep_a)*(ep_b-ep_a);
div += sq(ep_b-ep_a);
}
proj /= div;
int q1 = (int)(proj*levels+0.5);
q1 = clamp(q1, 1, levels-1);
float err0 = 0;
float err1 = 0;
int w0 = gather_int(unquant_table, q1-1);
int w1 = gather_int(unquant_table, q1);
for (uniform int p=0; p<channels; p++)
{
float ep_a = gather_float(ep, 8*j+0+p);
float ep_b = gather_float(ep, 8*j+4+p);
float dec_v0 = (int)(((64-w0)*ep_a + w0*ep_b + 32)/64);
float dec_v1 = (int)(((64-w1)*ep_a + w1*ep_b + 32)/64);
err0 += sq(dec_v0 - block[k+p*16]);
err1 += sq(dec_v1 - block[k+p*16]);
}
int best_err = err1;
int best_q = q1;
if (err0<err1)
{
best_err = err0;
best_q = q1-1;
}
assert(best_q>=0 && best_q<=levels-1);
qblock[k/8] += ((uint32)best_q) << 4*(k%8);
total_err += best_err;
}
return total_err;
}
///////////////////////////
// LS endpoint refinement
void opt_endpoints(float ep[], float block[64], uniform int bits, uint32 qblock[2], int mask, uniform int channels)
{
uniform int levels = 1 << bits;
float Atb1[4] = {0,0,0,0};
float sum_q = 0;
float sum_qq = 0;
float sum[5] = {0,0,0,0,0};
int mask_shifted = mask<<1;
for (uniform int k1=0; k1<2; k1++)
{
uint32 qbits_shifted = qblock[k1];
for (uniform int k2=0; k2<8; k2++)
{
uniform int k = k1*8+k2;
float q = (int)(qbits_shifted&15);
qbits_shifted >>= 4;
mask_shifted >>= 1;
if ((mask_shifted&1) == 0) continue;
int x = (levels-1)-q;
int y = q;
sum_q += q;
sum_qq += q*q;
sum[4] += 1;
for (uniform int p=0; p<channels; p++) sum[p] += block[k+p*16];
for (uniform int p=0; p<channels; p++) Atb1[p] += x*block[k+p*16];
}
}
float Atb2[4];
for (uniform int p=0; p<channels; p++)
{
//sum[p] = dc[p]*16;
Atb2[p] = (levels-1)*sum[p]-Atb1[p];
}
float Cxx = sum[4]*sq(levels-1)-2*(levels-1)*sum_q+sum_qq;
float Cyy = sum_qq;
float Cxy = (levels-1)*sum_q-sum_qq;
float scale = (levels-1) / (Cxx*Cyy - Cxy*Cxy);
for (uniform int p=0; p<channels; p++)
{
ep[0+p] = (Atb1[p]*Cyy - Atb2[p]*Cxy)*scale;
ep[4+p] = (Atb2[p]*Cxx - Atb1[p]*Cxy)*scale;
//ep[0+p] = clamp(ep[0+p], 0, 255);
//ep[4+p] = clamp(ep[4+p], 0, 255);
}
if (abs(Cxx*Cyy - Cxy*Cxy) < 0.001)
{
// flatten
for (uniform int p=0; p<channels; p++)
{
ep[0+p] = sum[p]/sum[4];
ep[4+p] = ep[0+p];
}
}
}
//////////////////////////
// parameter estimation
float compute_opaque_err(float block[64], uniform int channels)
{
if (channels == 3) return 0;
float err = 0.0f;
for (uniform int k=0; k<16; k++)
{
err += sq(block[48+k]-255);
}
return err;
}
float bc7_enc_mode01237_part_fast(int qep[24], uint32 qblock[2], float block[64], int part_id, uniform int mode)
{
uint32 pattern = get_pattern(part_id);
uniform int bits = 2; if (mode == 0 || mode == 1) bits = 3;
uniform int pairs = 2; if (mode == 0 || mode == 2) pairs = 3;
uniform int channels = 3; if (mode == 7) channels = 4;
float ep[24];
for (uniform int j=0; j<pairs; j++)
{
int mask = get_pattern_mask(part_id, j);
block_segment(&ep[j*8], block, mask, channels);
}
ep_quant_dequant(qep, ep, mode, channels);
float total_err = block_quant(qblock, block, bits, ep, pattern, channels);
return total_err;
}
void bc7_enc_mode01237(bc7_enc_state state[], uniform int mode, int part_list[], uniform int part_count)
{
if (part_count == 0) return;
uniform int bits = 2; if (mode == 0 || mode == 1) bits = 3;
uniform int pairs = 2; if (mode == 0 || mode == 2) pairs = 3;
uniform int channels = 3; if (mode == 7) channels = 4;
int best_qep[24];
uint32 best_qblock[2];
int best_part_id = -1;
float best_err = 1e99;
for (uniform int part=0; part<part_count; part++)
{
int part_id = part_list[part]&63;
if (pairs == 3) part_id += 64;
int qep[24];
uint32 qblock[2];
float err = bc7_enc_mode01237_part_fast(qep, qblock, state->block, part_id, mode);
if (err<best_err)
{
for (uniform int i=0; i<8*pairs; i++) best_qep[i] = qep[i];
for (uniform int k=0; k<2; k++) best_qblock[k] = qblock[k];
best_part_id = part_id;
best_err = err;
}
}
// refine
uniform int refineIterations = state->refineIterations[mode];
for (uniform int _=0; _<refineIterations; _++)
{
float ep[24];
for (uniform int j=0; j<pairs; j++)
{
int mask = get_pattern_mask(best_part_id, j);
opt_endpoints(&ep[j*8], state->block, bits, best_qblock, mask, channels);
}
int qep[24];
uint32 qblock[2];
ep_quant_dequant(qep, ep, mode, channels);
uint32 pattern = get_pattern(best_part_id);
float err = block_quant(qblock, state->block, bits, ep, pattern, channels);
if (err<best_err)
{
for (uniform int i=0; i<8*pairs; i++) best_qep[i] = qep[i];
for (uniform int k=0; k<2; k++) best_qblock[k] = qblock[k];
best_err = err;
}
}
if (mode != 7) best_err += state->opaque_err; // take into account alpha channel
if (best_err<state->best_err)
{
state->best_err = best_err;
bc7_code_mode01237(state->best_data, best_qep, best_qblock, best_part_id, mode);
}
}
void partial_sort_list(int list[], uniform int length, uniform int partial_count)
{
for (uniform int k=0; k<partial_count; k++)
{
int best_idx = k;
int best_value = list[k];
for (uniform int i=k+1; i<length; i++)
{
if (best_value > list[i])
{
best_value = list[i];
best_idx = i;
}
}
// swap
scatter_int(list, best_idx, list[k]);
list[k] = best_value;
}
}
void bc7_enc_mode02(bc7_enc_state state[])
{
int part_list[64];
for (uniform int part=0; part<64; part++)
part_list[part] = part;
bc7_enc_mode01237(state, 0, part_list, 16);
if (!state->skip_mode2) bc7_enc_mode01237(state, 2, part_list, 64); // usually not worth the time
}
void bc7_enc_mode13(bc7_enc_state state[])
{
if (state->fastSkipTreshold_mode1 == 0 && state->fastSkipTreshold_mode3 == 0) return;
float full_stats[15];
compute_stats_masked(full_stats, state->block, -1, 3);
int part_list[64];
for (uniform int part=0; part<64; part++)
{
int mask = get_pattern_mask(part+0, 0);
float bound12 = block_pca_bound_split(state->block, mask, full_stats, 3);
int bound = (int)(bound12);
part_list[part] = part+bound*64;
}
partial_sort_list(part_list, 64, max(state->fastSkipTreshold_mode1, state->fastSkipTreshold_mode3));
bc7_enc_mode01237(state, 1, part_list, state->fastSkipTreshold_mode1);
bc7_enc_mode01237(state, 3, part_list, state->fastSkipTreshold_mode3);
}
void bc7_enc_mode7(bc7_enc_state state[])
{
if (state->fastSkipTreshold_mode7 == 0) return;
float full_stats[15];
compute_stats_masked(full_stats, state->block, -1, state->channels);
int part_list[64];
for (uniform int part=0; part<64; part++)
{
int mask = get_pattern_mask(part+0, 0);
float bound12 = block_pca_bound_split(state->block, mask, full_stats, state->channels);
int bound = (int)(bound12);
part_list[part] = part+bound*64;
}
partial_sort_list(part_list, 64, state->fastSkipTreshold_mode7);
bc7_enc_mode01237(state, 7, part_list, state->fastSkipTreshold_mode7);
}
void channel_quant_dequant(int qep[2], float ep[2], uniform int epbits)
{
int elevels = (1<<epbits);
for (uniform int i=0; i<2; i++)
{
int v = ((int)(ep[i]/255.0f*(elevels-1)+0.5));
qep[i] = clamp(v, 0, elevels-1);
ep[i] = unpack_to_byte(qep[i], epbits);
}
}
void channel_opt_endpoints(float ep[2], float block[16], uniform int bits, uint32 qblock[2])
{
uniform int levels = 1 << bits;
float Atb1 = 0;
float sum_q = 0;
float sum_qq = 0;
float sum = 0;
for (uniform int k1=0; k1<2; k1++)
{
uint32 qbits_shifted = qblock[k1];
for (uniform int k2=0; k2<8; k2++)
{
uniform int k = k1*8+k2;
float q = (int)(qbits_shifted&15);
qbits_shifted >>= 4;
int x = (levels-1)-q;
int y = q;
sum_q += q;
sum_qq += q*q;
sum += block[k];
Atb1 += x*block[k];
}
}
float Atb2 = (levels-1)*sum-Atb1;
float Cxx = 16*sq(levels-1)-2*(levels-1)*sum_q+sum_qq;
float Cyy = sum_qq;
float Cxy = (levels-1)*sum_q-sum_qq;
float scale = (levels-1) / (Cxx*Cyy - Cxy*Cxy);
ep[0] = (Atb1*Cyy - Atb2*Cxy)*scale;
ep[1] = (Atb2*Cxx - Atb1*Cxy)*scale;
ep[0] = clamp(ep[0], 0, 255);
ep[1] = clamp(ep[1], 0, 255);
if (abs(Cxx*Cyy - Cxy*Cxy) < 0.001)
{
ep[0] = sum/16;
ep[1] = ep[0];
}
}
float channel_opt_quant(uint32 qblock[2], float block[16], uniform int bits, float ep[])
{
uniform const int* uniform unquant_table = get_unquant_table(bits);
int levels = (1<<bits);
qblock[0] = 0;
qblock[1] = 0;
float total_err = 0;
for (uniform int k=0; k<16; k++)
{
float proj = (block[k]-ep[0])/(ep[1]-ep[0]+0.001f);
int q1 = (int)(proj*levels+0.5);
q1 = clamp(q1, 1, levels-1);
float err0 = 0;
float err1 = 0;
int w0 = gather_int(unquant_table, q1-1);
int w1 = gather_int(unquant_table, q1);
float dec_v0 = (int)(((64-w0)*ep[0] + w0*ep[1] + 32)/64);
float dec_v1 = (int)(((64-w1)*ep[0] + w1*ep[1] + 32)/64);
err0 += sq(dec_v0 - block[k]);
err1 += sq(dec_v1 - block[k]);
int best_err = err1;
int best_q = q1;
if (err0<err1)
{
best_err = err0;
best_q = q1-1;
}
qblock[k/8] += ((uint32)best_q) << 4*(k%8);
total_err += best_err;
}
return total_err;
}
float opt_channel(bc7_enc_state state[], uint32 qblock[2], int qep[2], float block[16], uniform int bits, uniform int epbits)
{
float ep[2] = {255,0};
for (uniform int k=0; k<16; k++)
{
ep[0] = min(ep[0], block[k]);
ep[1] = max(ep[1], block[k]);
}
channel_quant_dequant(qep, ep, epbits);
float err = channel_opt_quant(qblock, block, bits, ep);
// refine
uniform const int refineIterations = state->refineIterations_channel;
for (uniform int i=0; i<refineIterations; i++)
{
channel_opt_endpoints(ep, block, bits, qblock);
channel_quant_dequant(qep, ep, epbits);
err = channel_opt_quant(qblock, block, bits, ep);
}
return err;
}
void bc7_enc_mode45_candidate(bc7_enc_state state[], mode45_parameters best_candidate[],
float best_err[], uniform int mode, uniform int rotation, uniform int swap)
{
uniform int bits = 2;
uniform int abits = 2; if (mode==4) abits = 3;
uniform int aepbits = 8; if (mode==4) aepbits = 6;
if (swap==1) { bits = 3; abits = 2; } // (mode 4)
float block[48];
for (uniform int k=0; k<16; k++)
{
for (uniform int p=0; p<3; p++)
block[k+p*16] = state->block[k+p*16];
if (rotation < 3)
{
// apply channel rotation
if (state->channels == 4) block[k+rotation*16] = state->block[k+3*16];
if (state->channels == 3) block[k+rotation*16] = 255;
}
}
float ep[8];
block_segment(ep, block, -1, 3);
int qep[8];
ep_quant_dequant(qep, ep, mode, 3);
uint32 qblock[2];
float err = block_quant(qblock, block, bits, ep, 0, 3);
// refine
uniform int refineIterations = state->refineIterations[mode];
for (uniform int i=0; i<refineIterations; i++)
{
opt_endpoints(ep, block, bits, qblock, -1, 3);
ep_quant_dequant(qep, ep, mode, 3);
err = block_quant(qblock, block, bits, ep, 0, 3);
}
// encoding selected channel
int aqep[2];
uint32 aqblock[2];
err += opt_channel(state, aqblock, aqep, &state->block[rotation*16], abits, aepbits);
if (err<*best_err)
{
swap_ints(best_candidate->qep, qep, 8);
swap_uints(best_candidate->qblock, qblock, 2);
swap_ints(best_candidate->aqep, aqep, 2);
swap_uints(best_candidate->aqblock, aqblock, 2);
best_candidate->rotation = rotation;
best_candidate->swap = swap;
*best_err = err;
}
}
void bc7_enc_mode45(bc7_enc_state state[])
{
mode45_parameters best_candidate;
float best_err = state->best_err;
memset(&best_candidate, 0, sizeof(mode45_parameters));
uniform int channel0 = state->mode45_channel0;
for (uniform int p=channel0; p<state->channels; p++)
{
bc7_enc_mode45_candidate(state, &best_candidate, &best_err, 4, p, 0);
bc7_enc_mode45_candidate(state, &best_candidate, &best_err, 4, p, 1);
}
// mode 4
if (best_err<state->best_err)
{
state->best_err = best_err;
bc7_code_mode45(state->best_data, &best_candidate, 4);
}
for (uniform int p=channel0; p<state->channels; p++)
{
bc7_enc_mode45_candidate(state, &best_candidate, &best_err, 5, p, 0);
}
// mode 5
if (best_err<state->best_err)
{
state->best_err = best_err;
bc7_code_mode45(state->best_data, &best_candidate, 5);
}
}
void bc7_enc_mode6(bc7_enc_state state[])
{
uniform int mode = 6;
uniform int bits = 4;
float ep[8];
block_segment(ep, state->block, -1, state->channels);
if (state->channels == 3)
{
ep[3] = ep[7] = 255;
}
int qep[8];
ep_quant_dequant(qep, ep, mode, state->channels);
uint32 qblock[2];
float err = block_quant(qblock, state->block, bits, ep, 0, state->channels);
// refine
uniform int refineIterations = state->refineIterations[mode];
for (uniform int i=0; i<refineIterations; i++)
{
opt_endpoints(ep, state->block, bits, qblock, -1, state->channels);
ep_quant_dequant(qep, ep, mode, state->channels);
err = block_quant(qblock, state->block, bits, ep, 0, state->channels);
}
if (err<state->best_err)
{
state->best_err = err;
bc7_code_mode6(state->best_data, qep, qblock);
}
}
//////////////////////////
// BC7 bitstream coding
void bc7_code_apply_swap_mode456(int qep[], uniform int channels, uint32 qblock[2], uniform int bits)
{
uniform int levels = 1 << bits;
if ((qblock[0]&15)>=levels/2)
{
swap_ints(&qep[0], &qep[channels], channels);
for (uniform int k=0; k<2; k++)
qblock[k] = (uint32)(0x11111111*(levels-1)) - qblock[k];
}
assert((qblock[0]&15) < levels/2);
}
int bc7_code_apply_swap_mode01237(int qep[], uint32 qblock[2], uniform int mode, int part_id)
{
uniform int bits = 2; if (mode == 0 || mode == 1) bits = 3;
uniform int pairs = 2; if (mode == 0 || mode == 2) pairs = 3;
int flips = 0;
uniform int levels = 1 << bits;
int skips[3];
get_skips(skips, part_id);
for (uniform int j=0; j<pairs; j++)
{
int k0 = skips[j];
//int q = (qblock[k0/8]>>((k0%8)*4))&15;
int q = ((gather_uint(qblock, k0>>3)<<(28-(k0&7)*4))>>28);
if (q>=levels/2)
{
swap_ints(&qep[8*j], &qep[8*j+4], 4);
uint32 pmask = get_pattern_mask(part_id, j);
flips |= pmask;
}
}
return flips;
}
void put_bits(uint32 data[5], uniform int* uniform pos, uniform int bits, int v)
{
assert(v<pow2(bits));
data[*pos/32] |= ((uint32)v) << (*pos%32);
if (*pos%32+bits>32)
{
data[*pos/32+1] |= shift_right(v, 32-*pos%32);
}
*pos += bits;
}
inline void data_shl_1bit_from(uint32 data[5], int from)
{
if (from < 96)
{
assert(from > 64+10);
uint32 shifted = (data[2]>>1) | (data[3]<<31);
uint32 mask = (pow2(from-64)-1)>>1;
data[2] = (mask&data[2]) | (~mask&shifted);
data[3] = (data[3]>>1) | (data[4]<<31);
data[4] = data[4]>>1;
}
else if (from < 128)
{
uint32 shifted = (data[3]>>1) | (data[4]<<31);
uint32 mask = (pow2(from-96)-1)>>1;
data[3] = (mask&data[3]) | (~mask&shifted);
data[4] = data[4]>>1;
}
}
void bc7_code_qblock(uint32 data[5], uniform int* uniform pPos, uint32 qblock[2], uniform int bits, int flips)
{
uniform int levels = 1 << bits;
int flips_shifted = flips;
for (uniform int k1=0; k1<2; k1++)
{
uint32 qbits_shifted = qblock[k1];
for (uniform int k2=0; k2<8; k2++)
{
int q = qbits_shifted&15;
if ((flips_shifted&1)>0) q = (levels-1)-q;
if (k1==0 && k2==0) put_bits(data, pPos, bits-1, q);
else put_bits(data, pPos, bits , q);
qbits_shifted >>= 4;
flips_shifted >>= 1;
}
}
}
void bc7_code_adjust_skip_mode01237(uint32 data[5], uniform int mode, int part_id)
{
uniform int bits = 2; if (mode == 0 || mode == 1) bits = 3;
uniform int pairs = 2; if (mode == 0 || mode == 2) pairs = 3;
int skips[3];
get_skips(skips, part_id);
if (pairs>2 && skips[1] < skips[2])
{
int t = skips[1]; skips[1] = skips[2]; skips[2] = t;
}
for (uniform int j=1; j<pairs; j++)
{
int k = skips[j];
data_shl_1bit_from(data, 128+(pairs-1)-(15-k)*bits);
}
}
void bc7_code_mode01237(uint32 data[5], int qep[], uint32 qblock[2], int part_id, uniform int mode)
{
uniform int bits = 2; if (mode == 0 || mode == 1) bits = 3;
uniform int pairs = 2; if (mode == 0 || mode == 2) pairs = 3;
uniform int channels = 3; if (mode == 7) channels = 4;
int flips = bc7_code_apply_swap_mode01237(qep, qblock, mode, part_id);
for (uniform int k=0; k<5; k++) data[k] = 0;
uniform int pos = 0;
// mode 0-3, 7
put_bits(data, &pos, mode+1, 1<<mode);
// partition
if (mode==0)
{
put_bits(data, &pos, 4, part_id&15);
}
else
{
put_bits(data, &pos, 6, part_id&63);
}
// endpoints
for (uniform int p=0; p<channels; p++)
for (uniform int j=0; j<pairs*2; j++)
{
if (mode == 0)
{
put_bits(data, &pos, 4, qep[j*4+0+p]>>1);
}
else if (mode == 1)
{
put_bits(data, &pos, 6, qep[j*4+0+p]>>1);
}
else if (mode == 2)
{
put_bits(data, &pos, 5, qep[j*4+0+p]);
}
else if (mode == 3)
{
put_bits(data, &pos, 7, qep[j*4+0+p]>>1);
}
else if (mode == 7)
{
put_bits(data, &pos, 5, qep[j*4+0+p]>>1);
}
else
{
assert(false);
}
}
// p bits
if (mode == 1)
for (uniform int j=0; j<2; j++)
{
put_bits(data, &pos, 1, qep[j*8]&1);
}
if (mode == 0 || mode == 3 || mode == 7)
for (uniform int j=0; j<pairs*2; j++)
{
put_bits(data, &pos, 1, qep[j*4]&1);
}
// quantized values
bc7_code_qblock(data, &pos, qblock, bits, flips);
bc7_code_adjust_skip_mode01237(data, mode, part_id);
}
void bc7_code_mode45(uint32 data[5], varying mode45_parameters* uniform params, uniform int mode)
{
int qep[8];
uint32 qblock[2];
int aqep[2];
uint32 aqblock[2];
swap_ints(params->qep, qep, 8);
swap_uints(params->qblock, qblock, 2);
swap_ints(params->aqep, aqep, 2);
swap_uints(params->aqblock, aqblock, 2);
int rotation = params->rotation;
int swap = params->swap;
uniform int bits = 2;
uniform int abits = 2; if (mode==4) abits = 3;
uniform int epbits = 7; if (mode==4) epbits = 5;
uniform int aepbits = 8; if (mode==4) aepbits = 6;
if (!swap)
{
bc7_code_apply_swap_mode456(qep, 4, qblock, bits);
bc7_code_apply_swap_mode456(aqep, 1, aqblock, abits);
}
else
{
swap_uints(qblock, aqblock, 2);
bc7_code_apply_swap_mode456(aqep, 1, qblock, bits);
bc7_code_apply_swap_mode456(qep, 4, aqblock, abits);
}
for (uniform int k=0; k<5; k++) data[k] = 0;
uniform int pos = 0;
// mode 4-5
put_bits(data, &pos, mode+1, 1<<mode);
// rotation
//put_bits(data, &pos, 2, (rotation+1)%4);
put_bits(data, &pos, 2, (rotation+1)&3);
if (mode==4)
{
put_bits(data, &pos, 1, swap);
}
// endpoints
for (uniform int p=0; p<3; p++)
{
put_bits(data, &pos, epbits, qep[0+p]);
put_bits(data, &pos, epbits, qep[4+p]);
}
// alpha endpoints
put_bits(data, &pos, aepbits, aqep[0]);
put_bits(data, &pos, aepbits, aqep[1]);
// quantized values
bc7_code_qblock(data, &pos, qblock, bits, 0);
bc7_code_qblock(data, &pos, aqblock, abits, 0);
}
void bc7_code_mode6(uint32 data[5], int qep[8], uint32 qblock[2])
{
bc7_code_apply_swap_mode456(qep, 4, qblock, 4);
for (uniform int k=0; k<5; k++) data[k] = 0;
uniform int pos = 0;
// mode 6
put_bits(data, &pos, 7, 64);
// endpoints
for (uniform int p=0; p<4; p++)
{
put_bits(data, &pos, 7, qep[0+p]>>1);
put_bits(data, &pos, 7, qep[4+p]>>1);
}
// p bits
put_bits(data, &pos, 1, qep[0]&1);
put_bits(data, &pos, 1, qep[4]&1);
// quantized values
bc7_code_qblock(data, &pos, qblock, 4, 0);
}
//////////////////////////
// BC7 core
inline void CompressBlockBC7_core(bc7_enc_state state[])
{
if (state->mode_selection[0]) bc7_enc_mode02(state);
if (state->mode_selection[1]) bc7_enc_mode13(state);
if (state->mode_selection[1]) bc7_enc_mode7(state);
if (state->mode_selection[2]) bc7_enc_mode45(state);
if (state->mode_selection[3]) bc7_enc_mode6(state);
}
void bc7_enc_copy_settings(bc7_enc_state state[], uniform bc7_enc_settings settings[])
{
state->channels = settings->channels;
// mode02
state->mode_selection[0] = settings->mode_selection[0];
state->skip_mode2 = settings->skip_mode2;
state->refineIterations[0] = settings->refineIterations[0];
state->refineIterations[2] = settings->refineIterations[2];
// mode137
state->mode_selection[1] = settings->mode_selection[1];
state->fastSkipTreshold_mode1 = settings->fastSkipTreshold_mode1;
state->fastSkipTreshold_mode3 = settings->fastSkipTreshold_mode3;
state->fastSkipTreshold_mode7 = settings->fastSkipTreshold_mode7;
state->refineIterations[1] = settings->refineIterations[1];
state->refineIterations[3] = settings->refineIterations[3];
state->refineIterations[7] = settings->refineIterations[7];
// mode45
state->mode_selection[2] = settings->mode_selection[2];
state->mode45_channel0 = settings->mode45_channel0;
state->refineIterations_channel = settings->refineIterations_channel;
state->refineIterations[4] = settings->refineIterations[4];
state->refineIterations[5] = settings->refineIterations[5];
// mode6
state->mode_selection[3] = settings->mode_selection[3];
state->refineIterations[6] = settings->refineIterations[6];
}
inline void CompressBlockBC7(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[],
uniform bc7_enc_settings settings[])
{
bc7_enc_state _state;
varying bc7_enc_state* uniform state = &_state;
bc7_enc_copy_settings(state, settings);
load_block_interleaved_rgba(state->block, src, xx, yy);
state->best_err = 1e99;
state->opaque_err = compute_opaque_err(state->block, state->channels);
CompressBlockBC7_core(state);
store_data(dst, src->width, xx, yy, state->best_data, 4);
}
export void CompressBlocksBC7_ispc(uniform rgba_surface src[], uniform uint8 dst[], uniform bc7_enc_settings settings[])
{
for (uniform int yy = 0; yy<src->height/4; yy++)
foreach (xx = 0 ... src->width/4)
{
CompressBlockBC7(src, xx, yy, dst, settings);
}
}
///////////////////////////////////////////////////////////
// BC6H encoding
struct bc6h_enc_settings
{
bool slow_mode;
bool fast_mode;
int refineIterations_1p;
int refineIterations_2p;
int fastSkipTreshold;
};
struct bc6h_enc_state
{
float block[64];
float best_err;
uint32 best_data[5]; // 4, +1 margin for skips
float rgb_bounds[6];
float max_span;
int max_span_idx;
int mode;
int epb;
int qbounds[8];
// settings
uniform bool slow_mode;
uniform bool fast_mode;
uniform int refineIterations_1p;
uniform int refineIterations_2p;
uniform int fastSkipTreshold;
};
void bc6h_code_2p(uint32 data[5], int pqep[], uint32 qblock[2], int part_id, int mode);
void bc6h_code_1p(uint32 data[5], int qep[8], uint32 qblock[2], int mode);
///////////////////////////
// BC6H format data
inline uniform int get_mode_prefix(uniform int mode)
{
static uniform const int mode_prefix_table[] =
{
0, 1, 2, 6, 10, 14, 18, 22, 26, 30, 3, 7, 11, 15
};
return mode_prefix_table[mode];
}
inline uniform float get_span(uniform int mode)
{
static uniform const float span_table[] =
{
0.9 * 0xFFFF / 64, // (0) 4 / 10
0.9 * 0xFFFF / 4, // (1) 5 / 7
0.8 * 0xFFFF / 256, // (2) 3 / 11
-1, -1,
0.9 * 0xFFFF / 32, // (5) 4 / 9
0.9 * 0xFFFF / 16, // (6) 4 / 8
-1, -1,
0xFFFF, // (9) absolute
0xFFFF, // (10) absolute
0.95 * 0xFFFF / 8, // (11) 8 / 11
0.95 * 0xFFFF / 32, // (12) 7 / 12
6, // (13) 3 / 16
};
uniform int span = span_table[mode];
assert(span > 0);
return span;
}
inline uniform int get_mode_bits(uniform int mode)
{
static uniform const int mode_bits_table[] =
{
10, 7, 11, -1, -1,
9, 8, -1, -1, 6,
10, 11, 12, 16,
};
uniform int mode_bits = mode_bits_table[mode];
assert(mode_bits > 0);
return mode_bits;
}
///////////////////////////
// endpoint quantization
inline int unpack_to_uf16(uint32 v, int bits)
{
if (bits >= 15) return v;
if (v == 0) return 0;
if (v == (1<<bits)-1) return 0xFFFF;
return (v * 2 + 1) << (15-bits);
}
void ep_quant_bc6h(int qep[], float ep[], int bits, uniform int pairs)
{
int levels = 1 << bits;
for (uniform int i = 0; i < 8 * pairs; i++)
{
int v = ((int)(ep[i] / (256 * 256.0f - 1) * (levels - 1) + 0.5));
qep[i] = clamp(v, 0, levels - 1);
}
}
void ep_dequant_bc6h(float ep[], int qep[], int bits, uniform int pairs)
{
for (uniform int i = 0; i < 8 * pairs; i++)
ep[i] = unpack_to_uf16(qep[i], bits);
}
void ep_quant_dequant_bc6h(bc6h_enc_state state[], int qep[], float ep[], uniform int pairs)
{
int bits = state->epb;
ep_quant_bc6h(qep, ep, bits, pairs);
for (uniform int i = 0; i < 2 * pairs; i++)
for (uniform int p = 0; p < 3; p++)
{
qep[i * 4 + p] = clamp(qep[i * 4 + p], state->qbounds[p], state->qbounds[4 + p]);
}
ep_dequant_bc6h(ep, qep, bits, pairs);
}
//////////////////////////
// parameter estimation
float bc6h_enc_2p_part_fast(bc6h_enc_state state[], int qep[16], uint32 qblock[2], int part_id)
{
uint32 pattern = get_pattern(part_id);
uniform int bits = 3;
uniform int pairs = 2;
uniform int channels = 3;
float ep[16];
for (uniform int j = 0; j<pairs; j++)
{
int mask = get_pattern_mask(part_id, j);
block_segment_core(&ep[j * 8], state->block, mask, channels);
}
ep_quant_dequant_bc6h(state, qep, ep, 2);
float total_err = block_quant(qblock, state->block, bits, ep, pattern, channels);
return total_err;
}
void bc6h_enc_2p_list(bc6h_enc_state state[], int part_list[], uniform int part_count)
{
if (part_count == 0) return;
uniform int bits = 3;
uniform int pairs = 2;
uniform int channels = 3;
int best_qep[24];
uint32 best_qblock[2];
int best_part_id = -1;
float best_err = 1e99;
for (uniform int part = 0; part<part_count; part++)
{
int part_id = part_list[part] & 31;
int qep[24];
uint32 qblock[2];
float err = bc6h_enc_2p_part_fast(state, qep, qblock, part_id);
if (err<best_err)
{
for (uniform int i = 0; i<8 * pairs; i++) best_qep[i] = qep[i];
for (uniform int k = 0; k<2; k++) best_qblock[k] = qblock[k];
best_part_id = part_id;
best_err = err;
}
}
// refine
uniform int refineIterations = state->refineIterations_2p;
for (uniform int _ = 0; _<refineIterations; _++)
{
float ep[24];
for (uniform int j = 0; j<pairs; j++)
{
int mask = get_pattern_mask(best_part_id, j);
opt_endpoints(&ep[j * 8], state->block, bits, best_qblock, mask, channels);
}
int qep[24];
uint32 qblock[2];
ep_quant_dequant_bc6h(state, qep, ep, 2);
uint32 pattern = get_pattern(best_part_id);
float err = block_quant(qblock, state->block, bits, ep, pattern, channels);
if (err<best_err)
{
for (uniform int i = 0; i<8 * pairs; i++) best_qep[i] = qep[i];
for (uniform int k = 0; k<2; k++) best_qblock[k] = qblock[k];
best_err = err;
}
}
if (best_err<state->best_err)
{
state->best_err = best_err;
bc6h_code_2p(state->best_data, best_qep, best_qblock, best_part_id, state->mode);
}
}
void bc6h_enc_2p(bc6h_enc_state state[])
{
float full_stats[15];
compute_stats_masked(full_stats, state->block, -1, 3);
int part_list[32];
for (uniform int part = 0; part < 32; part++)
{
int mask = get_pattern_mask(part, 0);
float bound12 = block_pca_bound_split(state->block, mask, full_stats, 3);
int bound = (int)(bound12);
part_list[part] = part + bound * 64;
}
partial_sort_list(part_list, 32, state->fastSkipTreshold);
bc6h_enc_2p_list(state, part_list, state->fastSkipTreshold);
}
void bc6h_enc_1p(bc6h_enc_state state[])
{
float ep[8];
block_segment_core(ep, state->block, -1, 3);
int qep[8];
ep_quant_dequant_bc6h(state, qep, ep, 1);
uint32 qblock[2];
float err = block_quant(qblock, state->block, 4, ep, 0, 3);
// refine
uniform int refineIterations = state->refineIterations_1p;
for (uniform int i = 0; i<refineIterations; i++)
{
opt_endpoints(ep, state->block, 4, qblock, -1, 3);
ep_quant_dequant_bc6h(state, qep, ep, 1);
err = block_quant(qblock, state->block, 4, ep, 0, 3);
}
if (err < state->best_err)
{
state->best_err = err;
bc6h_code_1p(state->best_data, qep, qblock, state->mode);
}
}
inline void compute_qbounds(bc6h_enc_state state[], float rgb_span[3])
{
float bounds[8];
for (uniform int p = 0; p < 3; p++)
{
float middle = (state->rgb_bounds[p] + state->rgb_bounds[3 + p]) / 2;
bounds[ p] = middle - rgb_span[p] / 2;
bounds[4+p] = middle + rgb_span[p] / 2;
}
ep_quant_bc6h(state->qbounds, bounds, state->epb, 1);
}
void compute_qbounds(bc6h_enc_state state[], float span)
{
float rgb_span[3] = { span, span, span };
compute_qbounds(state, rgb_span);
}
void compute_qbounds2(bc6h_enc_state state[], float span, int max_span_idx)
{
float rgb_span[3] = { span, span, span };
for (uniform int p = 0; p < 3; p++)
{
rgb_span[p] *= (p == max_span_idx) ? 2 : 1;
}
compute_qbounds(state, rgb_span);
}
void bc6h_test_mode(bc6h_enc_state state[], uniform int mode, uniform bool enc, uniform float margin)
{
uniform int mode_bits = get_mode_bits(mode);
uniform float span = get_span(mode);
float max_span = state->max_span;
int max_span_idx = state->max_span_idx;
if (max_span * margin > span) return;
if (mode >= 10)
{
state->epb = mode_bits;
state->mode = mode;
compute_qbounds(state, span);
if (enc) bc6h_enc_1p(state);
}
else if (mode <= 1 || mode == 5 || mode == 9)
{
state->epb = mode_bits;
state->mode = mode;
compute_qbounds(state, span);
if (enc) bc6h_enc_2p(state);
}
else
{
state->epb = mode_bits;
state->mode = mode + max_span_idx;
compute_qbounds2(state, span, max_span_idx);
if (enc) bc6h_enc_2p(state);
}
}
//////////////////////////
// BC6H bitstream coding
int bit_at(int v, uniform int pos)
{
return (v >> pos) & 1;
}
uint32 reverse_bits(uint32 v, uniform int bits)
{
if (bits == 2)
{
return (v >> 1) + (v & 1) * 2;
}
if (bits == 6)
{
v = (v & 0x5555) * 2 + ((v >> 1) & 0x5555);
return (v >> 4) + ((v >> 2) & 3) * 4 + (v & 3) * 16;
}
else
{
assert(false);
}
}
void bc6h_pack(uint32 packed[], int qep[], int mode)
{
if (mode == 0)
{
int pred_qep[16];
for (uniform int p = 0; p < 3; p++)
{
pred_qep[ p] = qep[p];
pred_qep[ 4 + p] = (qep[ 4 + p] - qep[p]) & 31;
pred_qep[ 8 + p] = (qep[ 8 + p] - qep[p]) & 31;
pred_qep[12 + p] = (qep[12 + p] - qep[p]) & 31;
}
for (uniform int i = 1; i < 4; i++)
for (uniform int p = 0; p < 3; p++)
{
assert( qep[i * 4 + p] - qep[p] <= 15);
assert(-16 <= qep[i * 4 + p] - qep[p]);
}
/*
g2[4], b2[4], b3[4],
r0[9:0],
g0[9:0],
b0[9:0],
r1[4:0], g3[4], g2[3:0],
g1[4:0], b3[0], g3[3:0],
b1[4:0], b3[1], b2[3:0],
r2[4:0], b3[2],
r3[4:0], b3[3]
*/
uint32 pqep[10];
pqep[4] = pred_qep[4] + (pred_qep[ 8 + 1] & 15) * 64;
pqep[5] = pred_qep[5] + (pred_qep[12 + 1] & 15) * 64;
pqep[6] = pred_qep[6] + (pred_qep[ 8 + 2] & 15) * 64;
pqep[4] += bit_at(pred_qep[12 + 1], 4) << 5;
pqep[5] += bit_at(pred_qep[12 + 2], 0) << 5;
pqep[6] += bit_at(pred_qep[12 + 2], 1) << 5;
pqep[8] = pred_qep[ 8] + bit_at(pred_qep[12 + 2], 2) * 32;
pqep[9] = pred_qep[12] + bit_at(pred_qep[12 + 2], 3) * 32;
packed[0] = get_mode_prefix(0);
packed[0] += bit_at(pred_qep[ 8 + 1], 4) << 2;
packed[0] += bit_at(pred_qep[ 8 + 2], 4) << 3;
packed[0] += bit_at(pred_qep[12 + 2], 4) << 4;
packed[1] = (pred_qep[2] << 20) + (pred_qep[1] << 10) + pred_qep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
packed[3] = (pqep[9] << 6) + pqep[8];
}
else if (mode == 1)
{
int pred_qep[16];
for (uniform int p = 0; p < 3; p++)
{
pred_qep[ p] = qep[p];
pred_qep[ 4 + p] = (qep[ 4 + p] - qep[p]) & 63;
pred_qep[ 8 + p] = (qep[ 8 + p] - qep[p]) & 63;
pred_qep[12 + p] = (qep[12 + p] - qep[p]) & 63;
}
for (uniform int i = 1; i < 4; i++)
for (uniform int p = 0; p < 3; p++)
{
assert( qep[i * 4 + p] - qep[p] <= 31);
assert(-32 <= qep[i * 4 + p] - qep[p]);
}
/*
g2[5], g3[4], g3[5],
r0[6:0], b3[0], b3[1], b2[4],
g0[6:0], b2[5], b3[2], g2[4],
b0[6:0], b3[3], b3[5], b3[4],
r1[5:0], g2[3:0],
g1[5:0], g3[3:0],
b1[5:0], b2[3:0],
r2[5:0],
r3[5:0]
*/
uint32 pqep[8];
pqep[0] = pred_qep[0];
pqep[0] += bit_at(pred_qep[12 + 2], 0) << 7;
pqep[0] += bit_at(pred_qep[12 + 2], 1) << 8;
pqep[0] += bit_at(pred_qep[ 8 + 2], 4) << 9;
pqep[1] = pred_qep[1];
pqep[1] += bit_at(pred_qep[ 8 + 2], 5) << 7;
pqep[1] += bit_at(pred_qep[12 + 2], 2) << 8;
pqep[1] += bit_at(pred_qep[ 8 + 1], 4) << 9;
pqep[2] = pred_qep[2];
pqep[2] += bit_at(pred_qep[12 + 2], 3) << 7;
pqep[2] += bit_at(pred_qep[12 + 2], 5) << 8;
pqep[2] += bit_at(pred_qep[12 + 2], 4) << 9;
pqep[4] = pred_qep[4] + (pred_qep[ 8 + 1] & 15) * 64;
pqep[5] = pred_qep[5] + (pred_qep[12 + 1] & 15) * 64;
pqep[6] = pred_qep[6] + (pred_qep[ 8 + 2] & 15) * 64;
packed[0] = get_mode_prefix(1);
packed[0] += bit_at(pred_qep[ 8 + 1], 5) << 2;
packed[0] += bit_at(pred_qep[12 + 1], 4) << 3;
packed[0] += bit_at(pred_qep[12 + 1], 5) << 4;
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
packed[3] = (pred_qep[12] << 6) + pred_qep[8];
}
else if (mode == 2 || mode == 3 || mode == 4)
{
/*
r0[9:0], g0[9:0], b0[9:0],
r1[3:0], xx[y], xx[y], g2[3:0],
g1[3:0], xx[y], xx[y], g3[3:0],
b1[3:0], xx[y], xx[y], b2[3:0],
r2[3:0], xx[y], xx[y],
r3[3:0], xx[y], xx[y]
*/
int dqep[16];
for (uniform int p = 0; p < 3; p++)
{
int mask = 15;
if (p == mode - 2) mask = 31;
dqep[p] = qep[p];
dqep[ 4 + p] = (qep[ 4 + p] - qep[p]) & mask;
dqep[ 8 + p] = (qep[ 8 + p] - qep[p]) & mask;
dqep[12 + p] = (qep[12 + p] - qep[p]) & mask;
}
for (uniform int i = 1; i < 4; i++)
for (uniform int p = 0; p < 3; p++)
{
int bits = 4;
if (p == mode - 2) bits = 5;
//assert( qep[i * 4 + p] - qep[p] <= (1<<bits)/2 - 1);
//assert(-(1<<bits)/2 <= qep[i * 4 + p] - qep[p]);
}
uint32 pqep[10];
pqep[0] = dqep[0] & 1023;
pqep[1] = dqep[1] & 1023;
pqep[2] = dqep[2] & 1023;
pqep[4] = dqep[4] + (dqep[ 8 + 1] & 15) * 64;
pqep[5] = dqep[5] + (dqep[12 + 1] & 15) * 64;
pqep[6] = dqep[6] + (dqep[ 8 + 2] & 15) * 64;
pqep[8] = dqep[8];
pqep[9] = dqep[12];
if (mode == 2)
{
/*
r0[9:0], g0[9:0], b0[9:0],
r1[3:0], r1[4], r0[10], g2[3:0],
g1[3:0], g0[10], b3[0], g3[3:0],
b1[3:0], b0[10], b3[1], b2[3:0],
r2[3:0], r2[4], b3[2],
r3[3:0], r3[4], b3[3]
*/
packed[0] = get_mode_prefix(2);
//
pqep[5] += bit_at(dqep[0 + 1], 10) << 4;
pqep[6] += bit_at(dqep[0 + 2], 10) << 4;
//
//
pqep[4] += bit_at(dqep[0 + 0], 10) << 5;
pqep[5] += bit_at(dqep[12 + 2], 0) << 5;
pqep[6] += bit_at(dqep[12 + 2], 1) << 5;
pqep[8] += bit_at(dqep[12 + 2], 2) << 5;
pqep[9] += bit_at(dqep[12 + 2], 3) << 5;
}
if (mode == 3)
{
/*
r0[9:0], g0[9:0], b0[9:0],
r1[3:0], r0[10], g3[4], g2[3:0],
g1[3:0], g1[4], g0[10], g3[3:0],
b1[3:0], b0[10], b3[1], b2[3:0],
r2[3:0], b3[0], b3[2],
r3[3:0], g2[4], b3[3]
*/
packed[0] = get_mode_prefix(3);
pqep[4] += bit_at(dqep[0 + 0], 10) << 4;
//
pqep[6] += bit_at(dqep[0 + 2], 10) << 4;
pqep[8] += bit_at(dqep[12 + 2], 0) << 4;
pqep[9] += bit_at(dqep[ 8 + 1], 4) << 4;
pqep[4] += bit_at(dqep[12 + 1], 4) << 5;
pqep[5] += bit_at(dqep[0 + 1], 10) << 5;
pqep[6] += bit_at(dqep[12 + 2], 1) << 5;
pqep[8] += bit_at(dqep[12 + 2], 2) << 5;
pqep[9] += bit_at(dqep[12 + 2], 3) << 5;
}
if (mode == 4)
{
/*
r0[9:0], g0[9:0], b0[9:0],
r1[3:0], r0[10], b2[4], g2[3:0],
g1[3:0], g0[10], b3[0], g3[3:0],
b1[3:0], b1[4], b0[10], b2[3:0],
r2[3:0], b3[1], b3[2],
r3[3:0], b3[4], b3[3]
*/
packed[0] = get_mode_prefix(4);
pqep[4] += bit_at(dqep[0 + 0], 10) << 4;
pqep[5] += bit_at(dqep[0 + 1], 10) << 4;
//
pqep[8] += bit_at(dqep[12 + 2], 1) << 4;
pqep[9] += bit_at(dqep[12 + 2], 4) << 4;
pqep[4] += bit_at(dqep[ 8 + 2], 4) << 5;
pqep[5] += bit_at(dqep[12 + 2], 0) << 5;
pqep[6] += bit_at(dqep[0 + 2], 10) << 5;
pqep[8] += bit_at(dqep[12 + 2], 2) << 5;
pqep[9] += bit_at(dqep[12 + 2], 3) << 5;
}
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
packed[3] = (pqep[9] << 6) + pqep[8];
}
else if (mode == 5)
{
int dqep[16];
for (uniform int p = 0; p < 3; p++)
{
dqep[p] = qep[p];
dqep[ 4 + p] = (qep[ 4 + p] - qep[p]) & 31;
dqep[ 8 + p] = (qep[ 8 + p] - qep[p]) & 31;
dqep[12 + p] = (qep[12 + p] - qep[p]) & 31;
}
for (uniform int i = 1; i < 4; i++)
for (uniform int p = 0; p < 3; p++)
{
assert( qep[i * 4 + p] - qep[p] <= 15);
assert(-16 <= qep[i * 4 + p] - qep[p]);
}
/*
r0[8:0], b2[4],
g0[8:0], g2[4],
b0[8:0], b3[4],
r1[4:0], g3[4], g2[3:0],
g1[4:0], b3[0], g3[3:0],
b1[4:0], b3[1], b2[3:0],
r2[4:0], b3[2],
r3[4:0], b3[3]
*/
uint32 pqep[10];
pqep[0] = dqep[0];
pqep[1] = dqep[1];
pqep[2] = dqep[2];
pqep[4] = dqep[4] + (dqep[ 8 + 1] & 15) * 64;
pqep[5] = dqep[5] + (dqep[12 + 1] & 15) * 64;
pqep[6] = dqep[6] + (dqep[ 8 + 2] & 15) * 64;
pqep[8] = dqep[8];
pqep[9] = dqep[12];
pqep[0] += bit_at(dqep[ 8 + 2], 4) << 9;
pqep[1] += bit_at(dqep[ 8 + 1], 4) << 9;
pqep[2] += bit_at(dqep[12 + 2], 4) << 9;
pqep[4] += bit_at(dqep[12 + 1], 4) << 5;
pqep[5] += bit_at(dqep[12 + 2], 0) << 5;
pqep[6] += bit_at(dqep[12 + 2], 1) << 5;
pqep[8] += bit_at(dqep[12 + 2], 2) << 5;
pqep[9] += bit_at(dqep[12 + 2], 3) << 5;
packed[0] = get_mode_prefix(5);
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
packed[3] = (pqep[9] << 6) + pqep[8];
}
else if (mode == 6 || mode == 7 || mode == 8)
{
/*
r0[7:0], xx[y], b2[4],
g0[7:0], xx[y], g2[4],
b0[7:0], xx[y], b3[4],
r1[4:0], xx[y], g2[3:0],
g1[4:0], xx[y], g3[3:0],
b1[4:0], xx[y], b2[3:0],
r2[4:0], xx[y],
r3[4:0], xx[y]
*/
int dqep[16];
for (uniform int p = 0; p < 3; p++)
{
int mask = 31;
if (p == mode - 6) mask = 63;
dqep[p] = qep[p];
dqep[ 4 + p] = (qep[ 4 + p] - qep[p]) & mask;
dqep[ 8 + p] = (qep[ 8 + p] - qep[p]) & mask;
dqep[12 + p] = (qep[12 + p] - qep[p]) & mask;
}
for (uniform int i = 1; i < 4; i++)
for (uniform int p = 0; p < 3; p++)
{
int bits = 5;
if (p == mode - 6) bits = 6;
//assert( qep[i * 4 + p] - qep[p] <= (1<<bits)/2 - 1);
//assert(-(1<<bits)/2 <= qep[i * 4 + p] - qep[p]);
}
uint32 pqep[10];
pqep[0] = dqep[0];
pqep[0] += bit_at(dqep[ 8 + 2], 4) << 9;
pqep[1] = dqep[1];
pqep[1] += bit_at(dqep[ 8 + 1], 4) << 9;
pqep[2] = dqep[2];
pqep[2] += bit_at(dqep[12 + 2], 4) << 9;
pqep[4] = dqep[4] + (dqep[ 8 + 1] & 15) * 64;
pqep[5] = dqep[5] + (dqep[12 + 1] & 15) * 64;
pqep[6] = dqep[6] + (dqep[ 8 + 2] & 15) * 64;
pqep[8] = dqep[8];
pqep[9] = dqep[12];
if (mode == 6)
{
/*
r0[7:0], g3[4], b2[4],
g0[7:0], b3[2], g2[4],
b0[7:0], b3[3], b3[4],
r1[4:0], r1[5], g2[3:0],
g1[4:0], b3[0], g3[3:0],
b1[4:0], b3[1], b2[3:0],
r2[5:0],
r3[5:0]
*/
packed[0] = get_mode_prefix(6);
pqep[0] += bit_at(dqep[12 + 1], 4) << 8;
pqep[1] += bit_at(dqep[12 + 2], 2) << 8;
pqep[2] += bit_at(dqep[12 + 2], 3) << 8;
//
pqep[5] += bit_at(dqep[12 + 2], 0) << 5;
pqep[6] += bit_at(dqep[12 + 2], 1) << 5;
//
//
}
if (mode == 7)
{
/*
r0[7:0], b3[0], b2[4],
g0[7:0], g2[5], g2[4],
b0[7:0], g3[5], b3[4],
r1[4:0], g3[4], g2[3:0],
g1[4:0], g1[5], g3[3:0],
b1[4:0], b3[1], b2[3:0],
r2[4:0], b3[2],
r3[4:0], b3[3]
*/
packed[0] = get_mode_prefix(7);
pqep[0] += bit_at(dqep[12 + 2], 0) << 8;
pqep[1] += bit_at(dqep[ 8 + 1], 5) << 8;
pqep[2] += bit_at(dqep[12 + 1], 5) << 8;
pqep[4] += bit_at(dqep[12 + 1], 4) << 5;
//
pqep[6] += bit_at(dqep[12 + 2], 1) << 5;
pqep[8] += bit_at(dqep[12 + 2], 2) << 5;
pqep[9] += bit_at(dqep[12 + 2], 3) << 5;
}
if (mode == 8)
{
/*
r0[7:0], b3[1], b2[4],
g0[7:0], b2[5], g2[4],
b0[7:0], b3[5], b3[4],
r1[4:0], g3[4], g2[3:0],
g1[4:0], b3[0], g3[3:0],
b1[4:0], b1[5], b2[3:0],
r2[4:0], b3[2],
r3[4:0], b3[3]
*/
packed[0] = get_mode_prefix(8);
pqep[0] += bit_at(dqep[12 + 2], 1) << 8;
pqep[1] += bit_at(dqep[ 8 + 2], 5) << 8;
pqep[2] += bit_at(dqep[12 + 2], 5) << 8;
pqep[4] += bit_at(dqep[12 + 1], 4) << 5;
pqep[5] += bit_at(dqep[12 + 2], 0) << 5;
//
pqep[8] += bit_at(dqep[12 + 2], 2) << 5;
pqep[9] += bit_at(dqep[12 + 2], 3) << 5;
}
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
packed[3] = (pqep[9] << 6) + pqep[8];
}
else if (mode == 9)
{
/*
r0[5:0], g3[4], b3[0], b3[1], b2[4], // 10
g0[5:0], g2[5], b2[5], b3[2], g2[4], // 10
b0[5:0], g3[5], b3[3], b3[5], b3[4], // 10
r1[5:0], g2[3:0], // 10
g1[5:0], g3[3:0], // 10
b1[5:0], b2[3:0], // 10
r2[5:0], // 6
r3[5:0] // 6
*/
uint32 pqep[10];
pqep[0] = qep[0];
pqep[0] += bit_at(qep[12 + 1], 4) << 6;
pqep[0] += bit_at(qep[12 + 2], 0) << 7;
pqep[0] += bit_at(qep[12 + 2], 1) << 8;
pqep[0] += bit_at(qep[ 8 + 2], 4) << 9;
pqep[1] = qep[1];
pqep[1] += bit_at(qep[ 8 + 1], 5) << 6;
pqep[1] += bit_at(qep[ 8 + 2], 5) << 7;
pqep[1] += bit_at(qep[12 + 2], 2) << 8;
pqep[1] += bit_at(qep[ 8 + 1], 4) << 9;
pqep[2] = qep[2];
pqep[2] += bit_at(qep[12 + 1], 5) << 6;
pqep[2] += bit_at(qep[12 + 2], 3) << 7;
pqep[2] += bit_at(qep[12 + 2], 5) << 8;
pqep[2] += bit_at(qep[12 + 2], 4) << 9;
pqep[4] = qep[4] + (qep[ 8 + 1] & 15) * 64;
pqep[5] = qep[5] + (qep[12 + 1] & 15) * 64;
pqep[6] = qep[6] + (qep[ 8 + 2] & 15) * 64;
packed[0] = get_mode_prefix(9);
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
packed[3] = (qep[12] << 6) + qep[8];
}
else if (mode == 10)
{
// the only mode with nothing to do ~
packed[0] = get_mode_prefix(10);
packed[1] = (qep[2] << 20) + (qep[1] << 10) + qep[0];
packed[2] = (qep[6] << 20) + (qep[5] << 10) + qep[4];
}
else if (mode == 11)
{
int dqep[8];
for (uniform int p = 0; p < 3; p++)
{
dqep[p] = qep[p];
dqep[4 + p] = (qep[4 + p] - qep[p]) & 511;
}
for (uniform int i = 1; i < 2; i++)
for (uniform int p = 0; p < 3; p++)
{
assert( qep[i * 4 + p] - qep[p] <= 255);
assert(-256 <= qep[i * 4 + p] - qep[p]);
}
/*
r0[9:0], g0[9:0], b0[9:0],
r1[8:0], r0[10],
g1[8:0], g0[10],
b1[8:0], b0[10]
*/
uint32 pqep[8];
pqep[0] = dqep[0] & 1023;
pqep[1] = dqep[1] & 1023;
pqep[2] = dqep[2] & 1023;
pqep[4] = dqep[4] + (dqep[0] >> 10) * 512;
pqep[5] = dqep[5] + (dqep[1] >> 10) * 512;
pqep[6] = dqep[6] + (dqep[2] >> 10) * 512;
packed[0] = get_mode_prefix(11);
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
}
else if (mode == 12)
{
int dqep[8];
for (uniform int p = 0; p < 3; p++)
{
dqep[p] = qep[p];
dqep[4 + p] = (qep[4 + p] - qep[p]) & 255;
}
for (uniform int i = 1; i < 2; i++)
for (uniform int p = 0; p < 3; p++)
{
assert( qep[i * 4 + p] - qep[p] <= 127);
assert(-128 <= qep[i * 4 + p] - qep[p]);
}
/*
r0[9:0], g0[9:0], b0[9:0],
r1[7:0], r0[10:11],
g1[7:0], g0[10:11],
b1[7:0], b0[10:11]
*/
uint32 pqep[8];
pqep[0] = dqep[0] & 1023;
pqep[1] = dqep[1] & 1023;
pqep[2] = dqep[2] & 1023;
pqep[4] = dqep[4] + reverse_bits(dqep[0] >> 10, 2) * 256;
pqep[5] = dqep[5] + reverse_bits(dqep[1] >> 10, 2) * 256;
pqep[6] = dqep[6] + reverse_bits(dqep[2] >> 10, 2) * 256;
packed[0] = get_mode_prefix(12);
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
}
else if (mode == 13)
{
int dqep[8];
for (uniform int p = 0; p < 3; p++)
{
dqep[p] = qep[p];
dqep[4 + p] = (qep[4 + p] - qep[p]) & 15;
}
for (uniform int i = 1; i < 2; i++)
for (uniform int p = 0; p < 3; p++)
{
assert( qep[i * 4 + p] - qep[p] <= 7);
assert(-8 <= qep[i * 4 + p] - qep[p]);
}
/*
r0[9:0], g0[9:0], b0[9:0],
r1[3:0], r0[10:15],
g1[3:0], g0[10:15],
b1[3:0], b0[10:15]
*/
uint32 pqep[8];
pqep[0] = dqep[0] & 1023;
pqep[1] = dqep[1] & 1023;
pqep[2] = dqep[2] & 1023;
pqep[4] = dqep[4] + reverse_bits(dqep[0] >> 10, 6) * 16;
pqep[5] = dqep[5] + reverse_bits(dqep[1] >> 10, 6) * 16;
pqep[6] = dqep[6] + reverse_bits(dqep[2] >> 10, 6) * 16;
packed[0] = get_mode_prefix(13);
packed[1] = (pqep[2] << 20) + (pqep[1] << 10) + pqep[0];
packed[2] = (pqep[6] << 20) + (pqep[5] << 10) + pqep[4];
}
else
{
assert(false);
}
}
void bc6h_code_2p(uint32 data[5], int qep[], uint32 qblock[2], int part_id, int mode)
{
uniform int bits = 3;
uniform int pairs = 2;
uniform int channels = 3;
int flips = bc7_code_apply_swap_mode01237(qep, qblock, 1, part_id);
for (uniform int k=0; k<5; k++) data[k] = 0;
uniform int pos = 0;
uint32 packed[4];
bc6h_pack(packed, qep, mode);
// mode
put_bits(data, &pos, 5, packed[0]);
// endpoints
put_bits(data, &pos, 30, packed[1]);
put_bits(data, &pos, 30, packed[2]);
put_bits(data, &pos, 12, packed[3]);
// partition
put_bits(data, &pos, 5, part_id);
// quantized values
bc7_code_qblock(data, &pos, qblock, bits, flips);
bc7_code_adjust_skip_mode01237(data, 1, part_id);
}
void bc6h_code_1p(uint32 data[5], int qep[8], uint32 qblock[2], int mode)
{
bc7_code_apply_swap_mode456(qep, 4, qblock, 4);
for (uniform int k = 0; k<5; k++) data[k] = 0;
uniform int pos = 0;
uint32 packed[4];
bc6h_pack(packed, qep, mode);
// mode
put_bits(data, &pos, 5, packed[0]);
// endpoints
put_bits(data, &pos, 30, packed[1]);
put_bits(data, &pos, 30, packed[2]);
// quantized values
bc7_code_qblock(data, &pos, qblock, 4, 0);
}
//////////////////////////
// BC6H core
void bc6h_setup(bc6h_enc_state state[])
{
for (uniform int p = 0; p < 3; p++)
{
state->rgb_bounds[p ] = 0xFFFF;
state->rgb_bounds[3+p] = 0;
}
// uf16 conversion, min/max
for (uniform int p = 0; p < 3; p++)
for (uniform int k = 0; k < 16; k++)
{
state->block[p * 16 + k] = (state->block[p * 16 + k] / 31) * 64;
state->rgb_bounds[p ] = min(state->rgb_bounds[p ], state->block[p * 16 + k]);
state->rgb_bounds[3+p] = max(state->rgb_bounds[3+p], state->block[p * 16 + k]);
}
state->max_span = 0;
state->max_span_idx = 0;
float rgb_span[0] = { 0, 0, 0 };
for (uniform int p = 0; p < 3; p++)
{
rgb_span[p] = state->rgb_bounds[3+p] - state->rgb_bounds[p];
if (rgb_span[p] > state->max_span)
{
state->max_span_idx = p;
state->max_span = rgb_span[p];
}
}
}
inline void CompressBlockBC6H_core(bc6h_enc_state state[])
{
bc6h_setup(state);
if (state->slow_mode)
{
bc6h_test_mode(state, 0, true, 0);
bc6h_test_mode(state, 1, true, 0);
bc6h_test_mode(state, 2, true, 0);
bc6h_test_mode(state, 5, true, 0);
bc6h_test_mode(state, 6, true, 0);
bc6h_test_mode(state, 9, true, 0);
bc6h_test_mode(state, 10, true, 0);
bc6h_test_mode(state, 11, true, 0);
bc6h_test_mode(state, 12, true, 0);
bc6h_test_mode(state, 13, true, 0);
}
else
{
if (state->fastSkipTreshold > 0)
{
bc6h_test_mode(state, 9, false, 0);
if (state->fast_mode) bc6h_test_mode(state, 1, false, 1);
bc6h_test_mode(state, 6, false, 1 / 1.2);
bc6h_test_mode(state, 5, false, 1 / 1.2);
bc6h_test_mode(state, 0, false, 1 / 1.2);
bc6h_test_mode(state, 2, false, 1);
bc6h_enc_2p(state);
if (!state->fast_mode) bc6h_test_mode(state, 1, true, 0);
}
bc6h_test_mode(state, 10, false, 0);
bc6h_test_mode(state, 11, false, 1);
bc6h_test_mode(state, 12, false, 1);
bc6h_test_mode(state, 13, false, 1);
bc6h_enc_1p(state);
}
}
void bc6h_enc_copy_settings(bc6h_enc_state state[], uniform bc6h_enc_settings settings[])
{
state->slow_mode = settings->slow_mode;
state->fast_mode = settings->fast_mode;
state->fastSkipTreshold = settings->fastSkipTreshold;
state->refineIterations_1p = settings->refineIterations_1p;
state->refineIterations_2p = settings->refineIterations_2p;
}
inline void CompressBlockBC6H(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[], uniform bc6h_enc_settings settings[])
{
bc6h_enc_state _state;
varying bc6h_enc_state* uniform state = &_state;
bc6h_enc_copy_settings(state, settings);
load_block_interleaved_16bit(state->block, src, xx, yy);
state->best_err = 1e99;
CompressBlockBC6H_core(state);
store_data(dst, src->width, xx, yy, state->best_data, 4);
}
export void CompressBlocksBC6H_ispc(uniform rgba_surface src[], uniform uint8 dst[], uniform bc6h_enc_settings settings[])
{
for (uniform int yy = 0; yy<src->height / 4; yy++)
foreach(xx = 0 ... src->width / 4)
{
CompressBlockBC6H(src, xx, yy, dst, settings);
}
}
///////////////////////////////////////////////////////////
// ETC encoding
struct etc_enc_settings
{
int fastSkipTreshold;
};
struct etc_enc_state
{
float block[64];
int prev_qcenter[3];
float best_err;
uint32 best_data[2];
uniform bool diff;
// settings
uniform int fastSkipTreshold;
};
inline uniform int get_etc1_dY(uniform int table, uniform int q)
{
static uniform const int etc_codeword_table[8][4] =
{
{ -8, -2, 2, 8 },
{ -17, -5, 5, 17 },
{ -29, -9, 9, 29 },
{ -42, -13, 13, 42 },
{ -60, -18, 18, 60 },
{ -80, -24, 24, 80 },
{ -106, -33, 33, 106 },
{ -183, -47, 47, 183 },
};
return etc_codeword_table[table][q];
}
uniform int remap_q[] = { 2, 3, 1, 0 };
int get_remap2_q(int x)
{
x -= 2;
if (x < 0) x = 1 - x;
return x;
}
int extend_4to8bits(int value)
{
return (value << 4) | value;
}
int extend_5to8bits(int value)
{
return (value << 3) | (value >> 2);
}
int quantize_4bits(float value)
{
return clamp((value / 255.0f) * 15 + 0.5, 0, 15);
}
int quantize_5bits(float value)
{
return clamp((value / 255.0f) * 31 + 0.5, 0, 31);
}
void center_quant_dequant(int qcenter[3], float center[3], uniform bool diff, int prev_qcenter[3])
{
if (diff)
{
for (uniform int p = 0; p < 3; p++)
{
qcenter[p] = quantize_5bits(center[p]);
if (prev_qcenter[0] >= 0)
{
if (qcenter[p] - prev_qcenter[p] > 3) qcenter[p] = prev_qcenter[p] + 3;
if (qcenter[p] - prev_qcenter[p] < -4) qcenter[p] = prev_qcenter[p] - 4;
}
center[p] = extend_5to8bits(qcenter[p]);
}
}
else
{
for (uniform int p = 0; p < 3; p++)
{
qcenter[p] = quantize_4bits(center[p]);
center[p] = extend_4to8bits(qcenter[p]);
}
}
}
float quantize_pixels_etc1_half(uint32 qblock[1], float block[48], float center[3], uniform int table)
{
float total_err = 0;
uint32 bits = 0;
for (uniform int y = 0; y < 2; y++)
for (uniform int x = 0; x < 4; x++)
{
float best_err = sq(255) * 3;
int best_q = -1;
for (uniform int q = 0; q < 4; q++)
{
int dY = get_etc1_dY(table, remap_q[q]);
float err = 0;
for (int p = 0; p < 3; p++)
err += sq(block[16 * p + y*4+x] - clamp(center[p] + dY, 0, 255));
if (err < best_err)
{
best_err = err;
best_q = q;
}
}
assert(best_q >= 0);
bits |= (best_q & 1) << (x * 4 + y);
bits |= (best_q >> 1) << (x * 4 + y + 16);
total_err += best_err;
}
qblock[0] = bits;
return total_err;
}
float compress_etc1_half_1(uint32 out_qbits[1], int out_table[1], int out_qcenter[3],
float half_pixels[], uniform bool diff, int prev_qcenter[3])
{
float dc[3];
for (uniform int p = 0; p<3; p++) dc[p] = 0;
for (uniform int k = 0; k<8; k++)
{
for (uniform int p = 0; p<3; p++)
dc[p] += half_pixels[k + p * 16];
}
float best_error = sq(255) * 3 * 8.0f;
int best_table = -1;
int best_qcenter[3];
uint32 best_qbits;
for (uniform int table_level = 0; table_level < 8; table_level++)
{
float center[3];
int qcenter[3];
uint32 qbits;
for (uniform int p = 0; p < 3; p++) center[p] = dc[p] / 8 - get_etc1_dY(table_level, 2);
center_quant_dequant(qcenter, center, diff, prev_qcenter);
float err = quantize_pixels_etc1_half(&qbits, half_pixels, center, table_level);
if (err < best_error)
{
best_error = err;
best_table = table_level;
best_qbits = qbits;
for (uniform int p = 0; p < 3; p++) best_qcenter[p] = qcenter[p];
}
}
out_table[0] = best_table;
out_qbits[0] = best_qbits;
for (uniform int p = 0; p < 3; p++) out_qcenter[p] = best_qcenter[p];
return best_error;
}
float optimize_center(float colors[4][10], uniform int p, uniform int table_level)
{
float best_center = 0;
for (uniform int q = 0; q < 4; q++)
{
best_center += (colors[q][7 + p] - get_etc1_dY(table_level, q)) * colors[q][3];
}
best_center /= 8;
float best_err = 0;
for (uniform int q = 0; q < 4; q++)
{
float dY = get_etc1_dY(table_level, q);
best_err += sq(clamp(best_center + dY, 0, 255) - colors[q][7 + p]) * colors[q][3];
}
for (uniform int branch = 0; branch < 4; branch++)
{
float new_center = 0;
float sum = 0;
for (uniform int q = 0; q < 4; q++)
{
if (branch <= 1 && q <= branch) continue;
if (branch >= 2 && q >= branch) continue;
new_center += (colors[q][7 + p] - get_etc1_dY(table_level, q)) * colors[q][3];
sum += colors[q][3];
}
new_center /= sum;
float err = 0;
for (uniform int q = 0; q < 4; q++)
{
float dY = get_etc1_dY(table_level, q);
err += sq(clamp(new_center + dY, 0, 255) - colors[q][7 + p]) * colors[q][3];
}
if (err < best_err)
{
best_err = err;
best_center = new_center;
}
}
return best_center;
}
float compress_etc1_half_7(uint32 out_qbits[1], int out_table[1], int out_qcenter[3],
float half_pixels[], etc_enc_state state[])
{
int err_list[165];
int y_sorted_inv[8];
float y_sorted[8];
{
int y_sorted_idx[8];
for (uniform int k = 0; k < 8; k++)
{
float value = 0;
for (uniform int p = 0; p < 3; p++)
value += half_pixels[k + p * 16];
y_sorted_idx[k] = (((int)value) << 4) + k;
}
partial_sort_list(y_sorted_idx, 8, 8);
for (uniform int k = 0; k < 8; k++)
y_sorted_inv[k] = ((y_sorted_idx[k] & 0xF) << 4) + k;
for (uniform int k = 0; k < 8; k++)
y_sorted[k] = (y_sorted_idx[k] >> 4) / 3.0f;
partial_sort_list(y_sorted_inv, 8, 8);
}
uniform int idx = -1;
for (uniform int level1 = 0; level1 <= 8; level1++)
for (uniform int level2 = level1; level2 <= 8; level2++)
for (uniform int level3 = level2; level3 <= 8; level3++)
{
idx++;
assert(idx < 165);
float sum[4];
float sum_sq[4];
float count[4];
float inv_count[4];
for (uniform int q = 0; q < 4; q++)
{
sum[q] = 0;
sum_sq[q] = 0;
count[q] = 0;
inv_count[q] = 0;
}
for (uniform int k = 0; k < 8; k++)
{
uniform int q = 0;
if (k >= level1) q = 1;
if (k >= level2) q = 2;
if (k >= level3) q = 3;
sum[q] += y_sorted[k];
sum_sq[q] += sq(y_sorted[k]);
count[q] += 1;
}
for (uniform int q = 0; q < 4; q++)
{
if (count[q] > 0) inv_count[q] = 1 / count[q];
}
float base_err = 0;
for (uniform int q = 0; q < 4; q++) base_err += sum_sq[q] - sq(sum[q]) * inv_count[q];
float t_err = sq(256) * 8;
for (uniform int table_level = 0; table_level < 8; table_level++)
{
float center = 0;
for (uniform int q = 0; q < 4; q++) center += sum[q] - get_etc1_dY(table_level, q) * count[q];
center /= 8;
float err = base_err;
for (uniform int q = 0; q < 4; q++)
{
err += sq(center + get_etc1_dY(table_level, q) - sum[q] * inv_count[q])*count[q];
}
t_err = min(t_err, err);
}
int packed = (level1 * 16 + level2) * 16 + level3;
err_list[idx] = (((int)t_err) << 12) + packed;
}
partial_sort_list(err_list, 165, state->fastSkipTreshold);
float best_error = sq(255) * 3 * 8.0f;
int best_table = -1;
int best_qcenter[3];
uint32 best_qbits;
for (uniform int i = 0; i < state->fastSkipTreshold; i++)
{
int packed = err_list[i] & 0xFFF;
int level1 = (packed >> 8) & 0xF;
int level2 = (packed >> 4) & 0xF;
int level3 = (packed >> 0) & 0xF;
float colors[4][10];
for (uniform int p = 0; p < 7; p++)
for (uniform int q = 0; q < 4; q++) colors[q][p] = 0;
uint32 qbits = 0;
for (uniform int kk = 0; kk < 8; kk++)
{
int k = y_sorted_inv[kk] & 0xF;
int qq = 0;
if (k >= level1) qq = 1;
if (k >= level2) qq = 2;
if (k >= level3) qq = 3;
uniform int xx = kk & 3;
uniform int yy = kk >> 2;
int qqq = get_remap2_q(qq);
qbits |= (qqq & 1) << (yy + xx * 4);
qbits |= (qqq >> 1) << (16 + yy + xx * 4);
float qvec[4];
for (uniform int q = 0; q < 4; q++)
{
qvec[q] = q == qq ? 1.0 : 0.0;
colors[q][3] += qvec[q];
}
for (uniform int p = 0; p < 3; p++)
{
float value = half_pixels[16 * p + kk];
for (uniform int q = 0; q < 4; q++)
{
colors[q][p] += value * qvec[q];
colors[q][4 + p] += sq(value) * qvec[q];
}
}
}
float base_err = 0;
for (uniform int q = 0; q < 4; q++)
{
if (colors[q][3] > 0)
for (uniform int p = 0; p < 3; p++)
{
colors[q][7 + p] = colors[q][p] / colors[q][3];
base_err += colors[q][4 + p] - sq(colors[q][7 + p])*colors[q][3];
}
}
for (uniform int table_level = 0; table_level < 8; table_level++)
{
float center[3];
int qcenter[3];
for (uniform int p = 0; p < 3; p++)
{
center[p] = optimize_center(colors, p, table_level);
}
center_quant_dequant(qcenter, center, state->diff, state->prev_qcenter);
float err = base_err;
for (uniform int q = 0; q < 4; q++)
{
int dY = get_etc1_dY(table_level, q);
for (uniform int p = 0; p < 3; p++)
err += sq(clamp(center[p] + dY, 0, 255) - colors[q][7 + p])*colors[q][3];
}
if (err < best_error)
{
best_error = err;
best_table = table_level;
best_qbits = qbits;
for (uniform int p = 0; p < 3; p++) best_qcenter[p] = qcenter[p];
}
}
}
out_table[0] = best_table;
out_qbits[0] = best_qbits;
for (uniform int p = 0; p < 3; p++) out_qcenter[p] = best_qcenter[p];
return best_error;
}
float compress_etc1_half(uint32 qbits[1], int table[1], int qcenter[3], float half_pixels[], etc_enc_state state[])
{
float err = compress_etc1_half_7(qbits, table, qcenter, half_pixels, state);
for (uniform int p = 0; p < 3; p++)
state->prev_qcenter[p] = qcenter[p];
return err;
}
//////////////////////////
// ETC1 core
inline uint32 bswap32(uint32 v)
{
uint32 r = 0;
r += ((v >> 24) & 255) << 0;
r += ((v >> 16) & 255) << 8;
r += ((v >> 8) & 255) << 16;
r += ((v >> 0) & 255) << 24;
return r;
}
void etc_pack(uint32 data[], uint32 qbits[2], int tables[2], int qcenters[2][3], uniform int diff, uniform int flip)
{
for (uniform int k = 0; k < 2; k++) data[k] = 0;
uniform int pos = 0;
if (diff == 0)
{
put_bits(data, &pos, 4, qcenters[1][0]);
put_bits(data, &pos, 4, qcenters[0][0]);
put_bits(data, &pos, 4, qcenters[1][1]);
put_bits(data, &pos, 4, qcenters[0][1]);
put_bits(data, &pos, 4, qcenters[1][2]);
put_bits(data, &pos, 4, qcenters[0][2]);
}
else
{
put_bits(data, &pos, 3, (qcenters[1][0] - qcenters[0][0]) & 7);
put_bits(data, &pos, 5, qcenters[0][0]);
put_bits(data, &pos, 3, (qcenters[1][1] - qcenters[0][1]) & 7);
put_bits(data, &pos, 5, qcenters[0][1]);
put_bits(data, &pos, 3, (qcenters[1][2] - qcenters[0][2]) & 7);
put_bits(data, &pos, 5, qcenters[0][2]);
}
put_bits(data, &pos, 1, flip);
put_bits(data, &pos, 1, diff);
put_bits(data, &pos, 3, tables[1]);
put_bits(data, &pos, 3, tables[0]);
uint32 all_qbits_flipped = (qbits[1] << 2) | qbits[0];
uint32 all_qbits = 0;
if (flip != 0) all_qbits = all_qbits_flipped;
if (flip == 0)
for (uniform int k = 0; k < 2; k++)
for (uniform int y = 0; y < 4; y++)
for (uniform int x = 0; x < 4; x++)
{
int bit = (all_qbits_flipped >> (k * 16 + x * 4 + y)) & 1;
all_qbits += bit << (k * 16 + y * 4 + x);
}
data[1] = bswap32(all_qbits);
}
inline void CompressBlockETC1_core(etc_enc_state state[])
{
float flipped_block[48];
for (uniform int y = 0; y < 4; y++)
for (uniform int x = 0; x < 4; x++)
for (uniform int p = 0; p < 3; p++)
{
flipped_block[16 * p + x * 4 + y] = state->block[16 * p + y * 4 + x];
}
for (uniform int flip = 0; flip < 2; flip++)
for (uniform int diff = 1; diff >= 0; diff--)
{
state->diff = diff == 1;
state->prev_qcenter[0] = -1;
varying float * uniform pixels = state->block;
if (flip == 0) pixels = flipped_block;
uint32 qbits[2];
int tables[2];
int qcenters[2][3];
float err = 0;
err += compress_etc1_half(&qbits[0], &tables[0], qcenters[0], &pixels[0], state);
err += compress_etc1_half(&qbits[1], &tables[1], qcenters[1], &pixels[8], state);
if (err < state->best_err)
{
state->best_err = err;
etc_pack(state->best_data, qbits, tables, qcenters, diff, flip);
}
}
}
void etc_enc_copy_settings(etc_enc_state state[], uniform etc_enc_settings settings[])
{
state->fastSkipTreshold = settings->fastSkipTreshold;
}
inline void CompressBlockETC1(uniform rgba_surface src[], int xx, uniform int yy, uniform uint8 dst[], uniform etc_enc_settings settings[])
{
etc_enc_state _state;
varying etc_enc_state* uniform state = &_state;
etc_enc_copy_settings(state, settings);
load_block_interleaved(state->block, src, xx, yy);
state->best_err = 1e99;
CompressBlockETC1_core(state);
store_data(dst, src->width, xx, yy, state->best_data, 2);
}
export void CompressBlocksETC1_ispc(uniform rgba_surface src[], uniform uint8 dst[], uniform etc_enc_settings settings[])
{
for (uniform int yy = 0; yy<src->height / 4; yy++)
foreach(xx = 0 ... src->width / 4)
{
CompressBlockETC1(src, xx, yy, dst, settings);
}
}
export uniform int ISPCIsa_ispc()
{
#if defined(ISPC_TARGET_SSE2)
return 0;
#elif defined(ISPC_TARGET_SSE4)
return 1;
#elif defined(ISPC_TARGET_AVX2)
return 2;
#else
return -1;
#endif
}
Reference in a new issue Copy permalink