oldunreal/KTexComp
0
0
Fork 0
mirror of https://github.com/OldUnreal/KTexComp.git synced 2026-04-02 21:28:59 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
KTexComp/ispc_texcomp/kernel_bptc.ispc
hanfling b8f19372ac Accumulated changes.
2021-06-23 22:39:38 +02:00

2748 lines
70 KiB
Plaintext
Raw Permalink Blame History

//
// BC6H and BC7 encoding implementation.
//
//
// 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.
//
#include "kernel_shared.isph"
///////////////////////////////////////////////////////////
// BC7 encoding
struct bc7_enc_settings
{
bool ModeEnabled[8];
int RefineIterations[8];
int fastSkipTreshold_mode1;
int fastSkipTreshold_mode3;
int fastSkipTreshold_mode7;
int mode45_channel0;
int refineIterations_channel;
int channels;
bool IgnoreAlphaError;
};
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 ModeEnabled[8];
uniform int RefineIterations[8];
uniform int fastSkipTreshold_mode1;
uniform int fastSkipTreshold_mode3;
uniform int fastSkipTreshold_mode13; // max(fastSkipTreshold_mode1,fastSkipTreshold_mode3)
uniform int fastSkipTreshold_mode7;
uniform int mode45_channel0;
uniform int refineIterations_channel;
uniform int channels;
uniform bool IgnoreAlphaError;
};
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] < 1f)
{
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 = 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 = 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]/255f*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 = 0f;
float err1 = 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]/255f*127f-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 = 0f;
float err1 = 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]/255f*(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 = 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;
}
}
// Modes 0, 1, 2 and 3 force alpha to 255, so alpha error can be precalculated.
if ( mode!=7 && !state->IgnoreAlphaError )
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);
}
}
#define BC7_PARTITION_COUNT 64
#define BC7_PARTITION_COUNT_MODE_0 16
#define BC7_PARTITION_COUNT_MODE_1 BC7_PARTITION_COUNT
#define BC7_PARTITION_COUNT_MODE_2 BC7_PARTITION_COUNT
#define BC7_PARTITION_COUNT_MODE_3 BC7_PARTITION_COUNT
#define BC7_PARTITION_COUNT_MODE_4 0
#define BC7_PARTITION_COUNT_MODE_5 0
#define BC7_PARTITION_COUNT_MODE_6 0
#define BC7_PARTITION_COUNT_MODE_7 BC7_PARTITION_COUNT
void bc7_enc_mode02( bc7_enc_state State[] )
{
if ( !State->ModeEnabled[0] && !State->ModeEnabled[2] )
return;
//
// !! FIX-ME !!
//
// Why does this even need to be filed manually each time? --han
//
int PartitionList[BC7_PARTITION_COUNT];
if ( State->ModeEnabled[0] || State->ModeEnabled[2] )
{
// Mode 0 only has 16 partions...
for ( uniform int Partition=0; Partition<BC7_PARTITION_COUNT_MODE_0; Partition++ )
PartitionList[Partition] = Partition;
// ...but Mode 2 has full 64 partions.
if ( State->ModeEnabled[2] )
for ( uniform int Partition=BC7_PARTITION_COUNT_MODE_0; Partition<BC7_PARTITION_COUNT_MODE_2; Partition++ )
PartitionList[Partition] = Partition;
}
if ( State->ModeEnabled[0] )
{
// Mode 0 only uses the first 16 partitions.
bc7_enc_mode01237( State, 0, PartitionList, BC7_PARTITION_COUNT_MODE_0 );
}
// Usually not worth the time.
if ( State->ModeEnabled[2] )
{
bc7_enc_mode01237( State, 2, PartitionList, BC7_PARTITION_COUNT_MODE_2 );
}
}
void bc7_enc_mode13( bc7_enc_state State[] )
{
if ( !State->ModeEnabled[1] && !State->ModeEnabled[3] )
return;
float full_stats[15];
compute_stats_masked( full_stats, State->block, -1, 3 );
int PartitionList[BC7_PARTITION_COUNT]; // Full 64 for both Mode 1 and 3.
for ( uniform int Partition=0; Partition<BC7_PARTITION_COUNT; Partition++ )
{
int mask = get_pattern_mask( Partition+0, 0 );
float bound12 = block_pca_bound_split( State->block, mask, full_stats, 3 );
int bound = (int)(bound12);
PartitionList[Partition] = Partition+bound*BC7_PARTITION_COUNT;
}
//
// !! FIX-ME !!
//
// partial_sort_list seems to be O(all*parts) For fastSkipTreshold>4 it may already be faster
// to just sort the complete list. In practice this threshold is likely somewhat larger,
// but this is probably a worthwhile optimization in particular for the slow profiles. --han
//
partial_sort_list( PartitionList, 64, State->fastSkipTreshold_mode13 );
if ( State->ModeEnabled[1] ) bc7_enc_mode01237( State, 1, PartitionList, State->fastSkipTreshold_mode1 );
if ( State->ModeEnabled[3] ) bc7_enc_mode01237( State, 3, PartitionList, State->fastSkipTreshold_mode3 );
}
void bc7_enc_mode7( bc7_enc_state State[] )
{
if ( !State->ModeEnabled[7] )
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;
}
//
// !! FIX-ME !!
//
// partial_sort_list seems to be O(all*parts) For fastSkipTreshold>4 it may already be faster
// to just sort the complete list. In practice this threshold is likely somewhat larger,
// but this is probably a worthwhile optimization in particular for the slow profiles. --han
//
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]/255f*(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;
}
// doswap == Mode 4 Index selection bit?. Rotation=0 swap red, differs from in file encoding. 4=no rotation.
void bc7_enc_mode45_candidate(bc7_enc_state state[], mode45_parameters best_candidate[], float best_err[], uniform int mode, uniform int rotation, uniform int doswap)
{
uniform int bits = 2;
uniform int abits = 2;
if (mode==4)
abits = 3;
uniform int aepbits = 8;
if (mode==4)
aepbits = 6;
if (doswap==1) // (mode 4)
{
bits = 3;
abits = 2;
}
float block[48]; // !! Why doesn't this have alpha..
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) // !! Like wtf?
{
// 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 = doswap;
*best_err = err;
}
}
void bc7_enc_mode45( bc7_enc_state State[] )
{
if ( !State->ModeEnabled[4] && !State->ModeEnabled[5] )
return;
mode45_parameters best_candidate;
float best_err = State->best_err;
memset( &best_candidate, 0, sizeof(mode45_parameters) );
uniform int channel0 = State->mode45_channel0;
// Mode 4.
if ( State->ModeEnabled[4] )
{
for ( uniform int Rotation=channel0; Rotation<State->channels; Rotation++ ) // !! Does <channels even make sense?
{
bc7_enc_mode45_candidate( State, &best_candidate, &best_err, 4, Rotation, 0 );
bc7_enc_mode45_candidate( State, &best_candidate, &best_err, 4, Rotation, 1 );
}
if ( best_err<State->best_err )
{
State->best_err = best_err;
bc7_code_mode45( State->best_data, &best_candidate, 4 );
}
}
// Mode 5.
if ( State->ModeEnabled[5] )
{
for ( uniform int Rotation=channel0; Rotation<State->channels; Rotation++ )
bc7_enc_mode45_candidate( State, &best_candidate, &best_err, 5, Rotation, 0 );
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[] )
{
if ( !State->ModeEnabled[6] )
return;
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;
}
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
// Returns false if no mode is enabled.
uniform bool CopyAndSanitizeEncodingSettingsBC7( bc7_enc_state EncState[], uniform bc7_enc_settings EncSettings[] )
{
EncState->IgnoreAlphaError = EncSettings->IgnoreAlphaError;
EncState->channels = EncSettings->channels;
uniform int NumEnabledModes = 0;
for ( uniform int Mode=0; Mode<8; Mode++ )
{
EncState->ModeEnabled[Mode] = EncSettings->ModeEnabled[Mode];
if ( EncState->ModeEnabled[Mode] )
NumEnabledModes++;
//
// Limit the RefineIterations somewhat, to avoid close to infinity loops. The maximum value
// used in original ispc_texcomp profiles was 4, so this value should be large enough.
//
EncState->RefineIterations[Mode] = clamp( EncSettings->RefineIterations[Mode], 0, 32 );
}
// Modes 0 and 2.
// Modes 1, 3 and 7.
EncState->fastSkipTreshold_mode1 = clamp( EncState->ModeEnabled[1] ? EncSettings->fastSkipTreshold_mode1 : 0, 0, BC7_PARTITION_COUNT_MODE_1 );
EncState->fastSkipTreshold_mode3 = clamp( EncState->ModeEnabled[3] ? EncSettings->fastSkipTreshold_mode3 : 0, 0, BC7_PARTITION_COUNT_MODE_3 );
EncState->fastSkipTreshold_mode7 = clamp( EncState->ModeEnabled[7] ? EncSettings->fastSkipTreshold_mode7 : 0, 0, BC7_PARTITION_COUNT_MODE_7 );
EncState->fastSkipTreshold_mode13 = max( EncState->fastSkipTreshold_mode1, EncState->fastSkipTreshold_mode3 );
// Modes 4 and 5.
EncState->mode45_channel0 = EncSettings->mode45_channel0;
EncState->refineIterations_channel = EncSettings->refineIterations_channel;
// Mode 6.
// Disable modes if no candidate partitions are allowed.
if ( EncSettings->fastSkipTreshold_mode1<=0 ) EncState->ModeEnabled[1] = false;
if ( EncSettings->fastSkipTreshold_mode3<=0 ) EncState->ModeEnabled[3] = false;
if ( EncSettings->fastSkipTreshold_mode7<=0 ) EncState->ModeEnabled[7] = false;
return NumEnabledModes>0;
}
///////////////////////////////////////////////////////////
// High level per block handling.
//
// !! FIX-ME !! Figure out why EncState is per block, and in any case move sanitization code to ispc code entry points.
inline void CompressBlockBC7( bc7_enc_state EncState[], uniform bc7_enc_settings EncSettings[] )
{
if ( !CopyAndSanitizeEncodingSettingsBC7(EncState,EncSettings) )
{
// !! FIX-ME !! No mode has been selected, deal with this
}
EncState->best_err = 1e99;
EncState->opaque_err = EncState->IgnoreAlphaError ? 0.0 : compute_opaque_err( EncState->block, EncState->channels );
bc7_enc_mode02( EncState );
bc7_enc_mode13( EncState );
bc7_enc_mode45( EncState );
bc7_enc_mode6( EncState );
bc7_enc_mode7( EncState );
}
///////////////////////////////////////////////////////////
// Dispatcher from input surface to block level.
//
// Templates would be nice here, but not in ispc, maybe preprocessor macros?
// Are there function pointers available in ispc?
//
// BC7.
inline void LoadCompressStoreBlockBC7_RGBA8( uniform Surface_RGBA8 InputSurface[], int HorizontalBlockIndex, uniform int VerticalBlockIndex, uniform uint8 OutputBlocks[], uniform bc7_enc_settings EncSettings[] )
{
bc7_enc_state EncState;
LoadUncompressed4x4BlockInterleaved_RGBA8( EncState.block, InputSurface, HorizontalBlockIndex, VerticalBlockIndex );
CompressBlockBC7( &EncState, EncSettings );
StoreCompressedBlock( OutputBlocks, InputSurface->Width, HorizontalBlockIndex, VerticalBlockIndex, EncState.best_data, 4 );
}
inline void LoadCompressStoreBlockBC7_RGBA16( uniform Surface_RGBA16 InputSurface[], int HorizontalBlockIndex, uniform int VerticalBlockIndex, uniform uint8 OutputBlocks[], uniform bc7_enc_settings EncSettings[] )
{
bc7_enc_state EncState;
LoadUncompressed4x4BlockInterleaved_RGBA16( EncState.block, InputSurface, HorizontalBlockIndex, VerticalBlockIndex );
CompressBlockBC7( &EncState, EncSettings );
StoreCompressedBlock( OutputBlocks, InputSurface->Width, HorizontalBlockIndex, VerticalBlockIndex, EncState.best_data, 4 );
}
export void BC7_Compress_RGBA8( uniform Surface_RGBA8 InputSurface[], uniform uint8 OutputBlocks[], uniform bc7_enc_settings EncSettings[] )
{
uniform int NumHorizontalBlocks = InputSurface->Width/4;
uniform int NumVerticalBlocks = InputSurface->Height/4;
for ( uniform int VerticalBlockIndex=0; VerticalBlockIndex<NumVerticalBlocks; VerticalBlockIndex++ )
foreach ( HorizontalBlockIndex=0...NumHorizontalBlocks )
LoadCompressStoreBlockBC7_RGBA8( InputSurface, HorizontalBlockIndex, VerticalBlockIndex, OutputBlocks, EncSettings );
}
export void BC7_Compress_RGBA16( uniform Surface_RGBA16 InputSurface[], uniform uint8 OutputBlocks[], uniform bc7_enc_settings EncSettings[] )
{
uniform int NumHorizontalBlocks = InputSurface->Width/4;
uniform int NumVerticalBlocks = InputSurface->Height/4;
for ( uniform int VerticalBlockIndex=0; VerticalBlockIndex<NumVerticalBlocks; VerticalBlockIndex++ )
foreach ( HorizontalBlockIndex=0...NumHorizontalBlocks )
LoadCompressStoreBlockBC7_RGBA16( InputSurface, HorizontalBlockIndex, VerticalBlockIndex, OutputBlocks, EncSettings );
}
///////////////////////////////////////////////////////////
// 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 * 256f - 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;
}
//
// !! FIX-ME !!
//
// partial_sort_list seems to be O(all*parts) For fastSkipTreshold>?? it may already be faster
// to just sort the complete list. In practice this threshold is likely somewhat larger,
// but this is probably a worthwhile optimization in particular for the slow profiles. --han
//
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_4x4_block_interleaved_16bit(state->block, src, xx, yy);
state->best_err = 1e99;
CompressBlockBC6H_core(state);
StoreCompressedBlock(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);
}
Reference in New Issue View Git Blame Copy Permalink