unsigned int block_mode,

unsigned int& weights_x,

unsigned int& weights_y,

bool& is_dual_plane,

unsigned int& quant_mode,

unsigned int& weight_bits

) {

unsigned int base_quant_mode = (block_mode >> 4) & 1;

unsigned int H = (block_mode >> 9) & 1;

unsigned int D = (block_mode >> 10) & 1;

unsigned int A = (block_mode >> 5) & 0x3;

weights_x = 0;

weights_y = 0;

if ((block_mode & 3) != 0)

{

base_quant_mode |= (block_mode & 3) << 1;

unsigned int B = (block_mode >> 7) & 3;

switch ((block_mode >> 2) & 3)

{

case 0:

weights_x = B + 4;

weights_y = A + 2;

break;

case 1:

weights_x = B + 8;

weights_y = A + 2;

break;

case 2:

weights_x = A + 2;

weights_y = B + 8;

break;

case 3:

B &= 1;

if (block_mode & 0x100)

{

weights_x = B + 2;

weights_y = A + 2;

}

else

{

weights_x = A + 2;

weights_y = B + 6;

}

break;

}

}

else

{

base_quant_mode |= ((block_mode >> 2) & 3) << 1;

if (((block_mode >> 2) & 3) == 0)

{

return false;

}

unsigned int B = (block_mode >> 9) & 3;

switch ((block_mode >> 7) & 3)

{

case 0:

weights_x = 12;

weights_y = A + 2;

break;

case 1:

weights_x = A + 2;

weights_y = 12;

break;

case 2:

weights_x = A + 6;

weights_y = B + 6;

D = 0;

H = 0;

break;

case 3:

switch ((block_mode >> 5) & 3)

{

case 0:

weights_x = 6;

weights_y = 10;

break;

case 1:

weights_x = 10;

weights_y = 6;

break;

case 2:

case 3:

return false;

}

break;

}

}

unsigned int weight_count = weights_x * weights_y * (D + 1);

quant_mode = (base_quant_mode - 2) + 6 * H;

is_dual_plane = D != 0;

weight_bits = get_ise_sequence_bitcount(weight_count, static_cast<quant_method>(quant_mode));

return (weight_count <= BLOCK_MAX_WEIGHTS &&

weight_bits >= BLOCK_MIN_WEIGHT_BITS &&

weight_bits <= BLOCK_MAX_WEIGHT_BITS);

unsigned int block_mode,

unsigned int& weights_x,

unsigned int& weights_y,

unsigned int& weights_z,

bool& is_dual_plane,

unsigned int& quant_mode,

unsigned int& weight_bits

) {

unsigned int base_quant_mode = (block_mode >> 4) & 1;

unsigned int H = (block_mode >> 9) & 1;

unsigned int D = (block_mode >> 10) & 1;

unsigned int A = (block_mode >> 5) & 0x3;

weights_x = 0;

weights_y = 0;

weights_z = 0;

if ((block_mode & 3) != 0)

{

base_quant_mode |= (block_mode & 3) << 1;

unsigned int B = (block_mode >> 7) & 3;

unsigned int C = (block_mode >> 2) & 0x3;

weights_x = A + 2;

weights_y = B + 2;

weights_z = C + 2;

}

else

{

base_quant_mode |= ((block_mode >> 2) & 3) << 1;

if (((block_mode >> 2) & 3) == 0)

{

return false;

}

int B = (block_mode >> 9) & 3;

if (((block_mode >> 7) & 3) != 3)

{

D = 0;

H = 0;

}

switch ((block_mode >> 7) & 3)

{

case 0:

weights_x = 6;

weights_y = B + 2;

weights_z = A + 2;

break;

case 1:

weights_x = A + 2;

weights_y = 6;

weights_z = B + 2;

break;

case 2:

weights_x = A + 2;

weights_y = B + 2;

weights_z = 6;

break;

case 3:

weights_x = 2;

weights_y = 2;

weights_z = 2;

switch ((block_mode >> 5) & 3)

{

case 0:

weights_x = 6;

break;

case 1:

weights_y = 6;

break;

case 2:

weights_z = 6;

break;

case 3:

return false;

}

break;

}

}

unsigned int weight_count = weights_x * weights_y * weights_z * (D + 1);

quant_mode = (base_quant_mode - 2) + 6 * H;

is_dual_plane = D != 0;

weight_bits = get_ise_sequence_bitcount(weight_count, static_cast<quant_method>(quant_mode));

return (weight_count <= BLOCK_MAX_WEIGHTS &&

weight_bits >= BLOCK_MIN_WEIGHT_BITS &&

weight_bits <= BLOCK_MAX_WEIGHT_BITS);

unsigned int texels_x,

unsigned int texels_y,

unsigned int weights_x,

unsigned int weights_y,

decimation_info& di,

dt_init_working_buffers& wb

) {

unsigned int texels_per_block = texels_x * texels_y;

unsigned int weights_per_block = weights_x * weights_y;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

uint8_t max_texel_count_of_weight = 0;

#endif

promise(weights_per_block > 0);

promise(texels_per_block > 0);

promise(texels_x > 0);

promise(texels_y > 0);

for (unsigned int i = 0; i < weights_per_block; i++)

{

wb.texel_count_of_weight[i] = 0;

}

for (unsigned int i = 0; i < texels_per_block; i++)

{

wb.weight_count_of_texel[i] = 0;

}

for (unsigned int y = 0; y < texels_y; y++)

{

for (unsigned int x = 0; x < texels_x; x++)

{

unsigned int texel = y * texels_x + x;

unsigned int x_weight = (((1024 + texels_x / 2) / (texels_x - 1)) * x * (weights_x - 1) + 32) >> 6;

unsigned int y_weight = (((1024 + texels_y / 2) / (texels_y - 1)) * y * (weights_y - 1) + 32) >> 6;

unsigned int x_weight_frac = x_weight & 0xF;

unsigned int y_weight_frac = y_weight & 0xF;

unsigned int x_weight_int = x_weight >> 4;

unsigned int y_weight_int = y_weight >> 4;

unsigned int qweight[4];

qweight[0] = x_weight_int + y_weight_int * weights_x;

qweight[1] = qweight[0] + 1;

qweight[2] = qweight[0] + weights_x;

qweight[3] = qweight[2] + 1;

// Truncated-precision bilinear interpolation

unsigned int prod = x_weight_frac * y_weight_frac;

unsigned int weight[4];

weight[3] = (prod + 8) >> 4;

weight[1] = x_weight_frac - weight[3];

weight[2] = y_weight_frac - weight[3];

weight[0] = 16 - x_weight_frac - y_weight_frac + weight[3];

for (unsigned int i = 0; i < 4; i++)

{

if (weight[i] != 0)

{

wb.grid_weights_of_texel[texel][wb.weight_count_of_texel[texel]] = static_cast<uint8_t>(qweight[i]);

wb.weights_of_texel[texel][wb.weight_count_of_texel[texel]] = static_cast<uint8_t>(weight[i]);

wb.weight_count_of_texel[texel]++;

wb.texels_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(texel);

wb.texel_weights_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(weight[i]);

wb.texel_count_of_weight[qweight[i]]++;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

max_texel_count_of_weight = astc::max(max_texel_count_of_weight, wb.texel_count_of_weight[qweight[i]]);

#endif

}

}

}

}

uint8_t max_texel_weight_count = 0;

for (unsigned int i = 0; i < texels_per_block; i++)

{

di.texel_weight_count[i] = wb.weight_count_of_texel[i];

max_texel_weight_count = astc::max(max_texel_weight_count, di.texel_weight_count[i]);

for (unsigned int j = 0; j < wb.weight_count_of_texel[i]; j++)

{

di.texel_weight_contribs_int_tr[j][i] = wb.weights_of_texel[i][j];

#if !defined(ASTCENC_DECOMPRESS_ONLY)

di.texel_weight_contribs_float_tr[j][i] = static_cast<float>(wb.weights_of_texel[i][j]) * (1.0f / WEIGHTS_TEXEL_SUM);

#endif

di.texel_weights_tr[j][i] = wb.grid_weights_of_texel[i][j];

}

// Init all 4 entries so we can rely on zeros for vectorization

for (unsigned int j = wb.weight_count_of_texel[i]; j < 4; j++)

{

di.texel_weight_contribs_int_tr[j][i] = 0;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

di.texel_weight_contribs_float_tr[j][i] = 0.0f;

#endif

di.texel_weights_tr[j][i] = 0;

}

}

di.max_texel_weight_count = max_texel_weight_count;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

for (unsigned int i = 0; i < weights_per_block; i++)

{

unsigned int texel_count_wt = wb.texel_count_of_weight[i];

di.weight_texel_count[i] = static_cast<uint8_t>(texel_count_wt);

for (unsigned int j = 0; j < texel_count_wt; j++)

{

uint8_t texel = wb.texels_of_weight[i][j];

// Create transposed versions of these for better vectorization

di.weight_texels_tr[j][i] = texel;

di.weights_texel_contribs_tr[j][i] = static_cast<float>(wb.texel_weights_of_weight[i][j]);

// Store the per-texel contribution of this weight for each texel it contributes to

di.texel_contrib_for_weight[j][i] = 0.0f;

for (unsigned int k = 0; k < 4; k++)

{

uint8_t dttw = di.texel_weights_tr[k][texel];

float dttwf = di.texel_weight_contribs_float_tr[k][texel];

if (dttw == i && dttwf != 0.0f)

{

di.texel_contrib_for_weight[j][i] = di.texel_weight_contribs_float_tr[k][texel];

break;

}

}

}

// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails

// Match last texel in active lane in SIMD group, for better gathers

uint8_t last_texel = di.weight_texels_tr[texel_count_wt - 1][i];

for (unsigned int j = texel_count_wt; j < max_texel_count_of_weight; j++)

{

di.weight_texels_tr[j][i] = last_texel;

di.weights_texel_contribs_tr[j][i] = 0.0f;

}

}

#endif

// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails

size_t texels_per_block_simd = round_up_to_simd_multiple_vla(texels_per_block);

for (size_t i = texels_per_block; i < texels_per_block_simd; i++)

{

di.texel_weight_count[i] = 0;

for (size_t j = 0; j < 4; j++)

{

#if !defined(ASTCENC_DECOMPRESS_ONLY)

di.texel_weight_contribs_float_tr[j][i] = 0;

#endif

di.texel_weights_tr[j][i] = 0;

di.texel_weight_contribs_int_tr[j][i] = 0;

}

}

#if !defined(ASTCENC_DECOMPRESS_ONLY)

// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails

// Match last texel in active lane in SIMD group, for better gathers

unsigned int last_texel_count_wt = wb.texel_count_of_weight[weights_per_block - 1];

uint8_t last_texel = di.weight_texels_tr[last_texel_count_wt - 1][weights_per_block - 1];

size_t weights_per_block_simd = round_up_to_simd_multiple_vla(weights_per_block);

for (size_t i = weights_per_block; i < weights_per_block_simd; i++)

{

di.weight_texel_count[i] = 0;

for (size_t j = 0; j < max_texel_count_of_weight; j++)

{

di.weight_texels_tr[j][i] = last_texel;

di.weights_texel_contribs_tr[j][i] = 0.0f;

}

}

#endif

di.texel_count = static_cast<uint8_t>(texels_per_block);

di.weight_count = static_cast<uint8_t>(weights_per_block);

di.weight_x = static_cast<uint8_t>(weights_x);

di.weight_y = static_cast<uint8_t>(weights_y);

di.weight_z = 1;

unsigned int texels_x,

unsigned int texels_y,

unsigned int texels_z,

unsigned int weights_x,

unsigned int weights_y,

unsigned int weights_z,

decimation_info& di,

dt_init_working_buffers& wb

) {

unsigned int texels_per_block = texels_x * texels_y * texels_z;

unsigned int weights_per_block = weights_x * weights_y * weights_z;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

uint8_t max_texel_count_of_weight = 0;

#endif

promise(weights_per_block > 0);

promise(texels_per_block > 0);

for (unsigned int i = 0; i < weights_per_block; i++)

{

wb.texel_count_of_weight[i] = 0;

}

for (unsigned int i = 0; i < texels_per_block; i++)

{

wb.weight_count_of_texel[i] = 0;

}

for (unsigned int z = 0; z < texels_z; z++)

{

for (unsigned int y = 0; y < texels_y; y++)

{

for (unsigned int x = 0; x < texels_x; x++)

{

int texel = (z * texels_y + y) * texels_x + x;

int x_weight = (((1024 + texels_x / 2) / (texels_x - 1)) * x * (weights_x - 1) + 32) >> 6;

int y_weight = (((1024 + texels_y / 2) / (texels_y - 1)) * y * (weights_y - 1) + 32) >> 6;

int z_weight = (((1024 + texels_z / 2) / (texels_z - 1)) * z * (weights_z - 1) + 32) >> 6;

int x_weight_frac = x_weight & 0xF;

int y_weight_frac = y_weight & 0xF;

int z_weight_frac = z_weight & 0xF;

int x_weight_int = x_weight >> 4;

int y_weight_int = y_weight >> 4;

int z_weight_int = z_weight >> 4;

int qweight[4];

int weight[4];

qweight[0] = (z_weight_int * weights_y + y_weight_int) * weights_x + x_weight_int;

qweight[3] = ((z_weight_int + 1) * weights_y + (y_weight_int + 1)) * weights_x + (x_weight_int + 1);

// simplex interpolation

int fs = x_weight_frac;

int ft = y_weight_frac;

int fp = z_weight_frac;

int cas = ((fs > ft) << 2) + ((ft > fp) << 1) + ((fs > fp));

int N = weights_x;

int NM = weights_x * weights_y;

int s1, s2, w0, w1, w2, w3;

switch (cas)

{

case 7:

s1 = 1;

s2 = N;

w0 = 16 - fs;

w1 = fs - ft;

w2 = ft - fp;

w3 = fp;

break;

case 3:

s1 = N;

s2 = 1;

w0 = 16 - ft;

w1 = ft - fs;

w2 = fs - fp;

w3 = fp;

break;

case 5:

s1 = 1;

s2 = NM;

w0 = 16 - fs;

w1 = fs - fp;

w2 = fp - ft;

w3 = ft;

break;

case 4:

s1 = NM;

s2 = 1;

w0 = 16 - fp;

w1 = fp - fs;

w2 = fs - ft;

w3 = ft;

break;

case 2:

s1 = N;

s2 = NM;

w0 = 16 - ft;

w1 = ft - fp;

w2 = fp - fs;

w3 = fs;

break;

case 0:

s1 = NM;

s2 = N;

w0 = 16 - fp;

w1 = fp - ft;

w2 = ft - fs;

w3 = fs;

break;

default:

s1 = NM;

s2 = N;

w0 = 16 - fp;

w1 = fp - ft;

w2 = ft - fs;

w3 = fs;

break;

}

qweight[1] = qweight[0] + s1;

qweight[2] = qweight[1] + s2;

weight[0] = w0;

weight[1] = w1;

weight[2] = w2;

weight[3] = w3;

for (unsigned int i = 0; i < 4; i++)

{

if (weight[i] != 0)

{

wb.grid_weights_of_texel[texel][wb.weight_count_of_texel[texel]] = static_cast<uint8_t>(qweight[i]);

wb.weights_of_texel[texel][wb.weight_count_of_texel[texel]] = static_cast<uint8_t>(weight[i]);

wb.weight_count_of_texel[texel]++;

wb.texels_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(texel);

wb.texel_weights_of_weight[qweight[i]][wb.texel_count_of_weight[qweight[i]]] = static_cast<uint8_t>(weight[i]);

wb.texel_count_of_weight[qweight[i]]++;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

max_texel_count_of_weight = astc::max(max_texel_count_of_weight, wb.texel_count_of_weight[qweight[i]]);

#endif

}

}

}

}

}

uint8_t max_texel_weight_count = 0;

for (unsigned int i = 0; i < texels_per_block; i++)

{

di.texel_weight_count[i] = wb.weight_count_of_texel[i];

max_texel_weight_count = astc::max(max_texel_weight_count, di.texel_weight_count[i]);

// Init all 4 entries so we can rely on zeros for vectorization

for (unsigned int j = 0; j < 4; j++)

{

di.texel_weight_contribs_int_tr[j][i] = 0;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

di.texel_weight_contribs_float_tr[j][i] = 0.0f;

#endif

di.texel_weights_tr[j][i] = 0;

}

for (unsigned int j = 0; j < wb.weight_count_of_texel[i]; j++)

{

di.texel_weight_contribs_int_tr[j][i] = wb.weights_of_texel[i][j];

#if !defined(ASTCENC_DECOMPRESS_ONLY)

di.texel_weight_contribs_float_tr[j][i] = static_cast<float>(wb.weights_of_texel[i][j]) * (1.0f / WEIGHTS_TEXEL_SUM);

#endif

di.texel_weights_tr[j][i] = wb.grid_weights_of_texel[i][j];

}

}

di.max_texel_weight_count = max_texel_weight_count;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

for (unsigned int i = 0; i < weights_per_block; i++)

{

unsigned int texel_count_wt = wb.texel_count_of_weight[i];

di.weight_texel_count[i] = static_cast<uint8_t>(texel_count_wt);

for (unsigned int j = 0; j < texel_count_wt; j++)

{

unsigned int texel = wb.texels_of_weight[i][j];

// Create transposed versions of these for better vectorization

di.weight_texels_tr[j][i] = static_cast<uint8_t>(texel);

di.weights_texel_contribs_tr[j][i] = static_cast<float>(wb.texel_weights_of_weight[i][j]);

// Store the per-texel contribution of this weight for each texel it contributes to

di.texel_contrib_for_weight[j][i] = 0.0f;

for (unsigned int k = 0; k < 4; k++)

{

uint8_t dttw = di.texel_weights_tr[k][texel];

float dttwf = di.texel_weight_contribs_float_tr[k][texel];

if (dttw == i && dttwf != 0.0f)

{

di.texel_contrib_for_weight[j][i] = di.texel_weight_contribs_float_tr[k][texel];

break;

}

}

}

// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails

// Match last texel in active lane in SIMD group, for better gathers

uint8_t last_texel = di.weight_texels_tr[texel_count_wt - 1][i];

for (unsigned int j = texel_count_wt; j < max_texel_count_of_weight; j++)

{

di.weight_texels_tr[j][i] = last_texel;

di.weights_texel_contribs_tr[j][i] = 0.0f;

}

}

#endif

// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails

size_t texels_per_block_simd = round_up_to_simd_multiple_vla(texels_per_block);

for (size_t i = texels_per_block; i < texels_per_block_simd; i++)

{

di.texel_weight_count[i] = 0;

for (size_t j = 0; j < 4; j++)

{

#if !defined(ASTCENC_DECOMPRESS_ONLY)

di.texel_weight_contribs_float_tr[j][i] = 0;

#endif

di.texel_weights_tr[j][i] = 0;

di.texel_weight_contribs_int_tr[j][i] = 0;

}

}

#if !defined(ASTCENC_DECOMPRESS_ONLY)

// Initialize array tail so we can over-fetch with SIMD later to avoid loop tails

// Match last texel in active lane in SIMD group, for better gathers

int last_texel_count_wt = wb.texel_count_of_weight[weights_per_block - 1];

uint8_t last_texel = di.weight_texels_tr[last_texel_count_wt - 1][weights_per_block - 1];

size_t weights_per_block_simd = round_up_to_simd_multiple_vla(weights_per_block);

for (size_t i = weights_per_block; i < weights_per_block_simd; i++)

{

di.weight_texel_count[i] = 0;

for (size_t j = 0; j < max_texel_count_of_weight; j++)

{

di.weight_texels_tr[j][i] = last_texel;

di.weights_texel_contribs_tr[j][i] = 0.0f;

}

}

#endif

di.texel_count = static_cast<uint8_t>(texels_per_block);

di.weight_count = static_cast<uint8_t>(weights_per_block);

di.weight_x = static_cast<uint8_t>(weights_x);

di.weight_y = static_cast<uint8_t>(weights_y);

di.weight_z = static_cast<uint8_t>(weights_z);

block_size_descriptor& bsd

) {

// Use all texels for kmeans on a small block

if (bsd.texel_count <= BLOCK_MAX_KMEANS_TEXELS)

{

for (uint8_t i = 0; i < bsd.texel_count; i++)

{

bsd.kmeans_texels[i] = i;

}

return;

}

// Select a random subset of BLOCK_MAX_KMEANS_TEXELS for kmeans on a large block

uint64_t rng_state[2];

astc::rand_init(rng_state);

// Initialize array used for tracking used indices

bool seen[BLOCK_MAX_TEXELS];

for (uint8_t i = 0; i < bsd.texel_count; i++)

{

seen[i] = false;

}

// Assign 64 random indices, retrying if we see repeats

unsigned int arr_elements_set = 0;

while (arr_elements_set < BLOCK_MAX_KMEANS_TEXELS)

{

uint8_t texel = static_cast<uint8_t>(astc::rand(rng_state));

texel = texel % bsd.texel_count;

if (!seen[texel])

{

bsd.kmeans_texels[arr_elements_set++] = texel;

seen[texel] = true;

}

}

unsigned int texels_x,

unsigned int texels_y,

unsigned int weights_x,

unsigned int weights_y,

block_size_descriptor& bsd,

dt_init_working_buffers& wb,

unsigned int index

) {

unsigned int weight_count = weights_x * weights_y;

assert(weight_count <= BLOCK_MAX_WEIGHTS);

bool try_2planes = (2 * weight_count) <= BLOCK_MAX_WEIGHTS;

decimation_info& di = bsd.decimation_tables[index];

init_decimation_info_2d(texels_x, texels_y, weights_x, weights_y, di, wb);

int maxprec_1plane = -1;

int maxprec_2planes = -1;

for (int i = 0; i < 12; i++)

{

unsigned int bits_1plane = get_ise_sequence_bitcount(weight_count, static_cast<quant_method>(i));

if (bits_1plane >= BLOCK_MIN_WEIGHT_BITS && bits_1plane <= BLOCK_MAX_WEIGHT_BITS)

{

maxprec_1plane = i;

}

if (try_2planes)

{

unsigned int bits_2planes = get_ise_sequence_bitcount(2 * weight_count, static_cast<quant_method>(i));

if (bits_2planes >= BLOCK_MIN_WEIGHT_BITS && bits_2planes <= BLOCK_MAX_WEIGHT_BITS)

{

maxprec_2planes = i;

}

}

}

// At least one of the two should be valid ...

assert(maxprec_1plane >= 0 || maxprec_2planes >= 0);

bsd.decimation_modes[index].maxprec_1plane = static_cast<int8_t>(maxprec_1plane);

bsd.decimation_modes[index].maxprec_2planes = static_cast<int8_t>(maxprec_2planes);

bsd.decimation_modes[index].refprec_1plane = 0;

bsd.decimation_modes[index].refprec_2planes = 0;

unsigned int texels_x,

unsigned int texels_y,

bool can_omit_modes,

float mode_cutoff,

block_size_descriptor& bsd

) {

// Store a remap table for storing packed decimation modes.

// Indexing uses [Y * 16 + X] and max size for each axis is 12.

static const unsigned int MAX_DMI = 12 * 16 + 12;

int decimation_mode_index[MAX_DMI];

dt_init_working_buffers* wb = new dt_init_working_buffers;

bsd.dim_x = static_cast<uint8_t>(texels_x);

bsd.dim_y = static_cast<uint8_t>(texels_y);

bsd.dim_z = 1;

bsd.texel_count = static_cast<uint8_t>(texels_x * texels_y);

for (unsigned int i = 0; i < MAX_DMI; i++)

{

decimation_mode_index[i] = -1;

}

// Gather all the decimation grids that can be used with the current block

#if !defined(ASTCENC_DECOMPRESS_ONLY)

const float *percentiles = get_2d_percentile_table(texels_x, texels_y);

float always_cutoff = 0.0f;

#else

// Unused in decompress-only builds

(void)can_omit_modes;

(void)mode_cutoff;

#endif

// Construct the list of block formats referencing the decimation tables

unsigned int packed_bm_idx = 0;

unsigned int packed_dm_idx = 0;

// Trackers

unsigned int bm_counts[4] { 0 };

unsigned int dm_counts[4] { 0 };

// Clear the list to a known-bad value

for (unsigned int i = 0; i < WEIGHTS_MAX_BLOCK_MODES; i++)

{

bsd.block_mode_packed_index[i] = BLOCK_BAD_BLOCK_MODE;

}

// Iterate four times to build a usefully ordered list:

// - Pass 0 - keep selected single plane "always" block modes

// - Pass 1 - keep selected single plane "non-always" block modes

// - Pass 2 - keep select dual plane block modes

// - Pass 3 - keep everything else that's legal

unsigned int limit = can_omit_modes ? 3 : 4;

for (unsigned int j = 0; j < limit; j ++)

{

for (unsigned int i = 0; i < WEIGHTS_MAX_BLOCK_MODES; i++)

{

// Skip modes we've already included in a previous pass

if (bsd.block_mode_packed_index[i] != BLOCK_BAD_BLOCK_MODE)

{

continue;

}

// Decode parameters

unsigned int weights_x;

unsigned int weights_y;

bool is_dual_plane;

unsigned int quant_mode;

unsigned int weight_bits;

bool valid = decode_block_mode_2d(i, weights_x, weights_y, is_dual_plane, quant_mode, weight_bits);

// Always skip invalid encodings for the current block size

if (!valid || (weights_x > texels_x) || (weights_y > texels_y))

{

continue;

}

// Selectively skip dual plane encodings

if (((j <= 1) && is_dual_plane) || (j == 2 && !is_dual_plane))

{

continue;

}

// Always skip encodings we can't physically encode based on

// generic encoding bit availability

if (is_dual_plane)

{

// This is the only check we need as only support 1 partition

if ((109 - weight_bits) <= 0)

{

continue;

}

}

else

{

// This is conservative - fewer bits may be available for > 1 partition

if ((111 - weight_bits) <= 0)

{

continue;

}

}

// Selectively skip encodings based on percentile

bool percentile_hit = false;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

if (j == 0)

{

percentile_hit = percentiles[i] <= always_cutoff;

}

else

{

percentile_hit = percentiles[i] <= mode_cutoff;

}

#endif

if (j != 3 && !percentile_hit)

{

continue;

}

// Allocate and initialize the decimation table entry if we've not used it yet

int decimation_mode = decimation_mode_index[weights_y * 16 + weights_x];

if (decimation_mode < 0)

{

construct_dt_entry_2d(texels_x, texels_y, weights_x, weights_y, bsd, *wb, packed_dm_idx);

decimation_mode_index[weights_y * 16 + weights_x] = packed_dm_idx;

decimation_mode = packed_dm_idx;

dm_counts[j]++;

packed_dm_idx++;

}

auto& bm = bsd.block_modes[packed_bm_idx];

bm.decimation_mode = static_cast<uint8_t>(decimation_mode);

bm.quant_mode = static_cast<uint8_t>(quant_mode);

bm.is_dual_plane = static_cast<uint8_t>(is_dual_plane);

bm.weight_bits = static_cast<uint8_t>(weight_bits);

bm.mode_index = static_cast<uint16_t>(i);

auto& dm = bsd.decimation_modes[decimation_mode];

if (is_dual_plane)

{

dm.set_ref_2plane(bm.get_weight_quant_mode());

}

else

{

dm.set_ref_1plane(bm.get_weight_quant_mode());

}

bsd.block_mode_packed_index[i] = static_cast<uint16_t>(packed_bm_idx);

packed_bm_idx++;

bm_counts[j]++;

}

}

bsd.block_mode_count_1plane_always = bm_counts[0];

bsd.block_mode_count_1plane_selected = bm_counts[0] + bm_counts[1];

bsd.block_mode_count_1plane_2plane_selected = bm_counts[0] + bm_counts[1] + bm_counts[2];

bsd.block_mode_count_all = bm_counts[0] + bm_counts[1] + bm_counts[2] + bm_counts[3];

bsd.decimation_mode_count_always = dm_counts[0];

bsd.decimation_mode_count_selected = dm_counts[0] + dm_counts[1] + dm_counts[2];

bsd.decimation_mode_count_all = dm_counts[0] + dm_counts[1] + dm_counts[2] + dm_counts[3];

#if !defined(ASTCENC_DECOMPRESS_ONLY)

assert(bsd.block_mode_count_1plane_always > 0);

assert(bsd.decimation_mode_count_always > 0);

delete[] percentiles;

#endif

// Ensure the end of the array contains valid data (should never get read)

for (unsigned int i = bsd.decimation_mode_count_all; i < WEIGHTS_MAX_DECIMATION_MODES; i++)

{

bsd.decimation_modes[i].maxprec_1plane = -1;