// SPDX-License-Identifier: Apache-2.0

// ----------------------------------------------------------------------------

// Copyright 2011-2021 Arm Limited

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not

// use this file except in compliance with the License. You may obtain a copy

// of the License at:

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

// License for the specific language governing permissions and limitations

// under the License.

// ----------------------------------------------------------------------------

#if !defined(ASTCENC_DECOMPRESS_ONLY)

/**

* @brief Functions to compress a symbolic block.

*/

#include "astcenc_internal.h"

#include "astcenc_diagnostic_trace.h"

#include <cassert>

#include <cstring>

#include <cstdio>

/**

* @brief Merge two planes of endpoints into a single vector.

*

* @param ep_plane1 The endpoints for plane 1.

* @param ep_plane2 The endpoints for plane 2.

* @param component_plane2 The color component for plane 2.

* @param[out] result The merged output.

*/

static void merge_endpoints(

const endpoints& ep_plane1,

const endpoints& ep_plane2,

int component_plane2,

endpoints& result

) {

int partition_count = ep_plane1.partition_count;

vmask4 sep_mask = vint4::lane_id() == vint4(component_plane2);

result.partition_count = partition_count;

promise(partition_count > 0);

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

{

result.endpt0[i] = select(ep_plane1.endpt0[i], ep_plane2.endpt0[i], sep_mask);

result.endpt1[i] = select(ep_plane1.endpt1[i], ep_plane2.endpt1[i], sep_mask);

}

}

/**

* @brief Attempt to improve weights given a chosen configuration.

*

* Given a fixed weight grid decimation and weight value quantization, iterate

* over all weights (per partition and per plane) and attempt to improve image

* quality by moving each weight up by one or down by one quantization step.

*/

static bool realign_weights(

astcenc_profile decode_mode,

const block_size_descriptor* bsd,

const imageblock* blk,

const error_weight_block* ewb,

symbolic_compressed_block* scb,

uint8_t* weight_set8_plane1,

uint8_t* weight_set8_plane2

) {

// Get the partition descriptor

int partition_count = scb->partition_count;

const partition_info *pt = get_partition_table(bsd, partition_count);

pt += scb->partition_index;

// Get the quantization table

const int packed_index = bsd->block_mode_packed_index[scb->block_mode];

assert(packed_index >= 0 && packed_index < bsd->block_mode_count);

const block_mode& bm = bsd->block_modes[packed_index];

int weight_quant_level = bm.quant_mode;

const quantization_and_transfer_table *qat = &(quant_and_xfer_tables[weight_quant_level]);

// Get the decimation table

const decimation_table* dt = bsd->decimation_tables[bm.decimation_mode];

int weight_count = dt->weight_count;

int max_plane = bm.is_dual_plane;

int plane2_component = bm.is_dual_plane ? scb->plane2_component : -1;

vmask4 plane_mask = vint4::lane_id() == vint4(plane2_component);

// Decode the color endpoints

bool rgb_hdr;

bool alpha_hdr;

vint4 endpnt0[4];

vint4 endpnt1[4];

vfloat4 endpnt0f[4];

vfloat4 offset[4];

promise(partition_count > 0);

promise(weight_count > 0);

promise(max_plane >= 0);

for (int pa_idx = 0; pa_idx < partition_count; pa_idx++)

{

unpack_color_endpoints(decode_mode,

scb->color_formats[pa_idx],

scb->color_quant_level,

scb->color_values[pa_idx],

&rgb_hdr, &alpha_hdr,

&endpnt0[pa_idx],

&endpnt1[pa_idx]);

}

uint8_t uq_pl_weights[MAX_WEIGHTS_PER_BLOCK];

uint8_t* weight_set8 = weight_set8_plane1;

bool adjustments = false;

// For each plane and partition ...

for (int pl_idx = 0; pl_idx <= max_plane; pl_idx++)

{

for (int pa_idx = 0; pa_idx < partition_count; pa_idx++)

{

// Compute the endpoint delta for all components in current plane

vint4 epd = endpnt1[pa_idx] - endpnt0[pa_idx];

epd = select(epd, vint4::zero(), plane_mask);

endpnt0f[pa_idx] = int_to_float(endpnt0[pa_idx]);

offset[pa_idx] = int_to_float(epd) * (1.0f / 64.0f);

}

// Create an unquantized weight grid for this decimation level

for (int we_idx = 0; we_idx < weight_count; we_idx++)

{

uq_pl_weights[we_idx] = qat->unquantized_value[weight_set8[we_idx]];

}

// For each weight compute previous, current, and next errors

for (int we_idx = 0; we_idx < weight_count; we_idx++)

{

int uqw = uq_pl_weights[we_idx];

uint32_t prev_and_next = qat->prev_next_values[uqw];

int prev_wt_uq = prev_and_next & 0xFF;

int next_wt_uq = (prev_and_next >> 8) & 0xFF;

int uqw_next_dif = next_wt_uq - uqw;

int uqw_prev_dif = prev_wt_uq - uqw;

float current_error = 0.0f;

float up_error = 0.0f;

float down_error = 0.0f;

// Interpolate the colors to create the diffs

int texels_to_evaluate = dt->weight_texel_count[we_idx];

promise(texels_to_evaluate > 0);

for (int te_idx = 0; te_idx < texels_to_evaluate; te_idx++)

{

int texel = dt->weight_texel[te_idx][we_idx];

const uint8_t *texel_weights = dt->texel_weights_texel[we_idx][te_idx];

const float *texel_weights_float = dt->texel_weights_float_texel[we_idx][te_idx];

float twf0 = texel_weights_float[0];

float weight_base =

((static_cast<float>(uqw) * twf0

+ static_cast<float>(uq_pl_weights[texel_weights[1]]) * texel_weights_float[1])

+ (static_cast<float>(uq_pl_weights[texel_weights[2]]) * texel_weights_float[2]

+ static_cast<float>(uq_pl_weights[texel_weights[3]]) * texel_weights_float[3]));

int partition = pt->partition_of_texel[texel];

weight_base = weight_base + 0.5f;

float plane_weight = astc::flt_rd(weight_base);

float plane_up_weight = astc::flt_rd(weight_base + static_cast<float>(uqw_next_dif) * twf0) - plane_weight;

float plane_down_weight = astc::flt_rd(weight_base + static_cast<float>(uqw_prev_dif) * twf0) - plane_weight;

vfloat4 color_offset = offset[partition];

vfloat4 color_base = endpnt0f[partition];

vfloat4 color = color_base + color_offset * plane_weight;

vfloat4 origcolor = blk->texel(texel);

vfloat4 error_weight = ewb->error_weights[texel];

vfloat4 colordiff = color - origcolor;

vfloat4 color_up_diff = colordiff + color_offset * plane_up_weight;

vfloat4 color_down_diff = colordiff + color_offset * plane_down_weight;

current_error += dot_s(colordiff * colordiff, error_weight);

up_error += dot_s(color_up_diff * color_up_diff, error_weight);

down_error += dot_s(color_down_diff * color_down_diff, error_weight);

}

// Check if the prev or next error is better, and if so use it

if ((up_error < current_error) && (up_error < down_error))

{

uq_pl_weights[we_idx] = next_wt_uq;

weight_set8[we_idx] = (uint8_t)((prev_and_next >> 24) & 0xFF);

adjustments = true;

}

else if (down_error < current_error)

{

uq_pl_weights[we_idx] = prev_wt_uq;

weight_set8[we_idx] = (uint8_t)((prev_and_next >> 16) & 0xFF);

adjustments = true;

}

}

// Prepare iteration for plane 2

weight_set8 = weight_set8_plane2;

plane_mask = ~plane_mask;

}

return adjustments;

}

/*

function for compressing a block symbolically, given that we have already decided on a partition

*/

static float compress_symbolic_block_fixed_partition_1plane(

const astcenc_config& config,

bool only_always,

int tune_candidate_limit,

float tune_errorval_threshold,

int max_refinement_iters,

const block_size_descriptor* bsd,

int partition_count,

int partition_index,

const imageblock* blk,

const error_weight_block* ewb,

symbolic_compressed_block& scb,

compress_fixed_partition_buffers* tmpbuf

) {

promise(partition_count > 0);

promise(tune_candidate_limit > 0);

promise(max_refinement_iters > 0);

promise(bsd->decimation_mode_count > 0);

static const int free_bits_for_partition_count[5] = {

0, 115 - 4, 111 - 4 - PARTITION_BITS, 108 - 4 - PARTITION_BITS, 105 - 4 - PARTITION_BITS

};

const partition_info *pt = get_partition_table(bsd, partition_count);

pt += partition_index;

// first, compute ideal weights and endpoint colors, under the assumption that

// there is no quantization or decimation going on.

endpoints_and_weights *ei = &tmpbuf->ei1;

endpoints_and_weights *eix = tmpbuf->eix1;

compute_endpoints_and_ideal_weights_1plane(bsd, pt, blk, ewb, ei);

// next, compute ideal weights and endpoint colors for every decimation.

const decimation_table *const *dts = bsd->decimation_tables;

float *decimated_quantized_weights = tmpbuf->decimated_quantized_weights;

float *decimated_weights = tmpbuf->decimated_weights;

float *flt_quantized_decimated_quantized_weights = tmpbuf->flt_quantized_decimated_quantized_weights;

uint8_t *u8_quantized_decimated_quantized_weights = tmpbuf->u8_quantized_decimated_quantized_weights;

// for each decimation mode, compute an ideal set of weights

// (that is, weights computed with the assumption that they are not quantized)

for (int i = 0; i < bsd->decimation_mode_count; i++)

{

const decimation_mode& dm = bsd->decimation_modes[i];

if (dm.maxprec_1plane < 0 || (only_always && !dm.percentile_always) || !dm.percentile_hit)

{

continue;

}

compute_ideal_weights_for_decimation_table(

*ei,

eix[i],

*(dts[i]),

decimated_quantized_weights + i * MAX_WEIGHTS_PER_BLOCK,

decimated_weights + i * MAX_WEIGHTS_PER_BLOCK);

}

// compute maximum colors for the endpoints and ideal weights.

// for each endpoint-and-ideal-weight pair, compute the smallest weight value

// that will result in a color value greater than 1.

vfloat4 min_ep(10.0f);

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

{

vfloat4 ep = (vfloat4(1.0f) - ei->ep.endpt0[i]) / (ei->ep.endpt1[i] - ei->ep.endpt0[i]);

vmask4 use_ep = (ep > vfloat4(0.5f)) & (ep < min_ep);

min_ep = select(min_ep, ep, use_ep);

}

float min_wt_cutoff = hmin_s(min_ep);

// for each mode, use the angular method to compute a shift.

float weight_low_value[MAX_WEIGHT_MODES];

float weight_high_value[MAX_WEIGHT_MODES];

compute_angular_endpoints_1plane(

only_always, bsd,

decimated_quantized_weights, decimated_weights,

weight_low_value, weight_high_value);

// for each mode (which specifies a decimation and a quantization):

// * compute number of bits needed for the quantized weights.

// * generate an optimized set of quantized weights.

// * compute quantization errors for the mode.

int qwt_bitcounts[MAX_WEIGHT_MODES];

float qwt_errors[MAX_WEIGHT_MODES];

for (int i = 0; i < bsd->block_mode_count; ++i)

{

const block_mode& bm = bsd->block_modes[i];

if (bm.is_dual_plane || (only_always && !bm.percentile_always) || !bm.percentile_hit)

{

qwt_errors[i] = 1e38f;

continue;

}

if (weight_high_value[i] > 1.02f * min_wt_cutoff)

{

weight_high_value[i] = 1.0f;

}

int decimation_mode = bm.decimation_mode;

// compute weight bitcount for the mode

int bits_used_by_weights = get_ise_sequence_bitcount(

dts[decimation_mode]->weight_count,

(quant_method)bm.quant_mode);

int bitcount = free_bits_for_partition_count[partition_count] - bits_used_by_weights;

if (bitcount <= 0 || bits_used_by_weights < 24 || bits_used_by_weights > 96)

{

qwt_errors[i] = 1e38f;

continue;

}

qwt_bitcounts[i] = bitcount;

// then, generate the optimized set of weights for the weight mode.

compute_quantized_weights_for_decimation_table(

dts[decimation_mode],

weight_low_value[i], weight_high_value[i],

decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * decimation_mode,

flt_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * i,

u8_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * i,

bm.quant_mode);

// then, compute weight-errors for the weight mode.

qwt_errors[i] = compute_error_of_weight_set_1plane(

&(eix[decimation_mode]),

dts[decimation_mode],

flt_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * i);

}

// for each weighting mode, determine the optimal combination of color endpoint encodings

// and weight encodings; return results for the 4 best-looking modes.

int partition_format_specifiers[TUNE_MAX_TRIAL_CANDIDATES][4];

int quantized_weight[TUNE_MAX_TRIAL_CANDIDATES];

int color_quant_level[TUNE_MAX_TRIAL_CANDIDATES];

int color_quant_level_mod[TUNE_MAX_TRIAL_CANDIDATES];

determine_optimal_set_of_endpoint_formats_to_use(

bsd, pt, blk, ewb, &(ei->ep), qwt_bitcounts, qwt_errors,

tune_candidate_limit, partition_format_specifiers, quantized_weight,

color_quant_level, color_quant_level_mod);

// then iterate over the tune_candidate_limit believed-to-be-best modes to

// find out which one is actually best.

float best_errorval_in_mode = 1e30f;

float best_errorval_in_scb = scb.errorval;

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

{

TRACE_NODE(node0, "candidate");

uint8_t *u8_weight_src;

const int qw_packed_index = quantized_weight[i];

if (qw_packed_index < 0)

{

trace_add_data("failed", "error_block");

continue;

}

assert(qw_packed_index >= 0 && qw_packed_index < bsd->block_mode_count);

const block_mode& qw_bm = bsd->block_modes[qw_packed_index];

int decimation_mode = qw_bm.decimation_mode;

int weight_quant_mode = qw_bm.quant_mode;

const decimation_table *dt = dts[decimation_mode];

promise(dt->weight_count > 0);

u8_weight_src = u8_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * qw_packed_index;

trace_add_data("weight_x", dt->weight_x);

trace_add_data("weight_y", dt->weight_y);

trace_add_data("weight_z", dt->weight_z);

trace_add_data("weight_quant", weight_quant_mode);

// recompute the ideal color endpoints before storing them.

vfloat4 rgbs_colors[4];

vfloat4 rgbo_colors[4];

symbolic_compressed_block workscb;

for (int l = 0; l < max_refinement_iters; l++)

{

recompute_ideal_colors_1plane(

weight_quant_mode, &(eix[decimation_mode].ep),

rgbs_colors, rgbo_colors, u8_weight_src, pt, dt, blk, ewb);

// quantize the chosen color

// store the colors for the block

for (int j = 0; j < partition_count; j++)

{

workscb.color_formats[j] = pack_color_endpoints(

eix[decimation_mode].ep.endpt0[j],

eix[decimation_mode].ep.endpt1[j],

rgbs_colors[j],

rgbo_colors[j],

partition_format_specifiers[i][j],

workscb.color_values[j],

color_quant_level[i]);

}

// if all the color endpoint modes are the same, we get a few more

// bits to store colors; let's see if we can take advantage of this:

// requantize all the colors and see if the endpoint modes remain the same;

// if they do, then exploit it.

workscb.color_formats_matched = 0;

if ((partition_count >= 2 && workscb.color_formats[0] == workscb.color_formats[1]

&& color_quant_level[i] != color_quant_level_mod[i])

&& (partition_count == 2 || (workscb.color_formats[0] == workscb.color_formats[2]

&& (partition_count == 3 || (workscb.color_formats[0] == workscb.color_formats[3])))))

{

int colorvals[4][12];

int color_formats_mod[4] { 0 };

for (int j = 0; j < partition_count; j++)

{

color_formats_mod[j] = pack_color_endpoints(

eix[decimation_mode].ep.endpt0[j],

eix[decimation_mode].ep.endpt1[j],

rgbs_colors[j],

rgbo_colors[j],

partition_format_specifiers[i][j],

colorvals[j],

color_quant_level_mod[i]);

}

if (color_formats_mod[0] == color_formats_mod[1]

&& (partition_count == 2 || (color_formats_mod[0] == color_formats_mod[2]

&& (partition_count == 3 || (color_formats_mod[0] == color_formats_mod[3])))))

{

workscb.color_formats_matched = 1;

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

{

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

{

workscb.color_values[j][k] = colorvals[j][k];

}

workscb.color_formats[j] = color_formats_mod[j];

}

}

}

// store header fields

workscb.partition_count = partition_count;

workscb.partition_index = partition_index;

workscb.color_quant_level = workscb.color_formats_matched ? color_quant_level_mod[i] : color_quant_level[i];

workscb.block_mode = qw_bm.mode_index;

workscb.error_block = 0;

if (workscb.color_quant_level < 4)

{

workscb.error_block = 1; // should never happen, but cannot prove it impossible.

}

// Pre-realign test

if (l == 0)

{

for (int j = 0; j < dt->weight_count; j++)

{

workscb.weights[j] = u8_weight_src[j];

}

float errorval = compute_symbolic_block_difference(config, bsd, &workscb, blk, ewb);

if (errorval == -1e30f)

{

errorval = -errorval;

workscb.error_block = 1;

}

trace_add_data("error_prerealign", errorval);

best_errorval_in_mode = astc::min(errorval, best_errorval_in_mode);

// Average refinement improvement is 3.5% per iteration

// (allow 5%), but the first iteration can help more so we give

// it a extra 10% leeway. Use this knowledge to drive a

// heuristic to skip blocks that are unlikely to catch up with

// the best block we have already.

int iters_remaining = max_refinement_iters - l;

float threshold = (0.05f * static_cast<float>(iters_remaining)) + 1.1f;

if (errorval > (threshold * best_errorval_in_scb))

{

break;

}

if (errorval < best_errorval_in_scb)

{

best_errorval_in_scb = errorval;

workscb.errorval = errorval;

scb = workscb;

if (errorval < tune_errorval_threshold)

{

return errorval;

}

}

}

// perform a final pass over the weights to try to improve them.

bool adjustments = realign_weights(

config.profile, bsd, blk, ewb, &workscb,

u8_weight_src, nullptr);

// Post-realign test

for (int j = 0; j < dt->weight_count; j++)

{

workscb.weights[j] = u8_weight_src[j];

}

float errorval = compute_symbolic_block_difference(config, bsd, &workscb, blk, ewb);

if (errorval == -1e30f)

{

errorval = -errorval;

workscb.error_block = 1;

}

trace_add_data("error_postrealign", errorval);

best_errorval_in_mode = astc::min(errorval, best_errorval_in_mode);

// Average refinement improvement is 3.5% per iteration, so skip

// blocks that are unlikely to catch up with the best block we

// have already. Assume a 5% per step to give benefit of the doubt

int iters_remaining = max_refinement_iters - 1 - l;

float threshold = (0.05f * static_cast<float>(iters_remaining)) + 1.0f;

if (errorval > (threshold * best_errorval_in_scb))

{

break;

}

if (errorval < best_errorval_in_scb)

{

best_errorval_in_scb = errorval;

workscb.errorval = errorval;

scb = workscb;

if (errorval < tune_errorval_threshold)

{

return errorval;

}

}

if (!adjustments)

{

break;

}

}

}

return best_errorval_in_mode;

}

static float compress_symbolic_block_fixed_partition_2planes(

const astcenc_config& config,

int tune_candidate_limit,

float tune_errorval_threshold,

int max_refinement_iters,

const block_size_descriptor* bsd,

int partition_count,

int partition_index,

int plane2_component,

const imageblock* blk,

const error_weight_block* ewb,

symbolic_compressed_block& scb,

compress_fixed_partition_buffers* tmpbuf

) {

promise(partition_count > 0);

promise(tune_candidate_limit > 0);

promise(max_refinement_iters > 0);

promise(bsd->decimation_mode_count > 0);

static const int free_bits_for_partition_count[5] = {

0, 113 - 4, 109 - 4 - PARTITION_BITS, 106 - 4 - PARTITION_BITS, 103 - 4 - PARTITION_BITS

};

const partition_info *pt = get_partition_table(bsd, partition_count);

pt += partition_index;

// first, compute ideal weights and endpoint colors

endpoints_and_weights *ei1 = &tmpbuf->ei1;

endpoints_and_weights *ei2 = &tmpbuf->ei2;

endpoints_and_weights *eix1 = tmpbuf->eix1;

endpoints_and_weights *eix2 = tmpbuf->eix2;

compute_endpoints_and_ideal_weights_2planes(bsd, pt, blk, ewb, plane2_component, ei1, ei2);

// next, compute ideal weights and endpoint colors for every decimation.

const decimation_table *const *dts = bsd->decimation_tables;

float *decimated_quantized_weights = tmpbuf->decimated_quantized_weights;

float *decimated_weights = tmpbuf->decimated_weights;

float *flt_quantized_decimated_quantized_weights = tmpbuf->flt_quantized_decimated_quantized_weights;

uint8_t *u8_quantized_decimated_quantized_weights = tmpbuf->u8_quantized_decimated_quantized_weights;

// for each decimation mode, compute an ideal set of weights

for (int i = 0; i < bsd->decimation_mode_count; i++)

{

const decimation_mode& dm = bsd->decimation_modes[i];

if (dm.maxprec_2planes < 0 || !dm.percentile_hit)

{

continue;

}

compute_ideal_weights_for_decimation_table(

*ei1,

eix1[i],

*(dts[i]),

decimated_quantized_weights + (2 * i) * MAX_WEIGHTS_PER_BLOCK,

decimated_weights + (2 * i) * MAX_WEIGHTS_PER_BLOCK);

compute_ideal_weights_for_decimation_table(

*ei2,

eix2[i],

*(dts[i]),

decimated_quantized_weights + (2 * i + 1) * MAX_WEIGHTS_PER_BLOCK,

decimated_weights + (2 * i + 1) * MAX_WEIGHTS_PER_BLOCK);

}

// compute maximum colors for the endpoints and ideal weights.

// for each endpoint-and-ideal-weight pair, compute the smallest weight value

// that will result in a color value greater than 1.

vfloat4 min_ep1(10.0f);

vfloat4 min_ep2(10.0f);

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

{

vfloat4 ep1 = (vfloat4(1.0f) - ei1->ep.endpt0[i]) / (ei1->ep.endpt1[i] - ei1->ep.endpt0[i]);

vmask4 use_ep1 = (ep1 > vfloat4(0.5f)) & (ep1 < min_ep1);

min_ep1 = select(min_ep1, ep1, use_ep1);

vfloat4 ep2 = (vfloat4(1.0f) - ei2->ep.endpt0[i]) / (ei2->ep.endpt1[i] - ei2->ep.endpt0[i]);

vmask4 use_ep2 = (ep2 > vfloat4(0.5f)) & (ep2 < min_ep2);

min_ep2 = select(min_ep2, ep2, use_ep2);

}

vfloat4 err_max(1e30f);

vmask4 err_mask = vint4::lane_id() == vint4(plane2_component);

// Set the plane2 component to max error in ep1

min_ep1 = select(min_ep1, err_max, err_mask);

float min_wt_cutoff1 = hmin_s(min_ep1);

// Set the minwt2 to the plane2 component min in ep2

float min_wt_cutoff2 = hmin_s(select(err_max, min_ep2, err_mask));

float weight_low_value1[MAX_WEIGHT_MODES];

float weight_high_value1[MAX_WEIGHT_MODES];

float weight_low_value2[MAX_WEIGHT_MODES];

float weight_high_value2[MAX_WEIGHT_MODES];

compute_angular_endpoints_2planes(

bsd,

decimated_quantized_weights, decimated_weights,

weight_low_value1, weight_high_value1,

weight_low_value2, weight_high_value2);

// for each mode (which specifies a decimation and a quantization):

// * generate an optimized set of quantized weights.

// * compute quantization errors for each mode

// * compute number of bits needed for the quantized weights.

int qwt_bitcounts[MAX_WEIGHT_MODES];

float qwt_errors[MAX_WEIGHT_MODES];

for (int i = 0; i < bsd->block_mode_count; ++i)

{

const block_mode& bm = bsd->block_modes[i];

if (!bm.is_dual_plane || !bm.percentile_hit)

{

qwt_errors[i] = 1e38f;

continue;

}

int decimation_mode = bm.decimation_mode;

if (weight_high_value1[i] > 1.02f * min_wt_cutoff1)

{

weight_high_value1[i] = 1.0f;

}

if (weight_high_value2[i] > 1.02f * min_wt_cutoff2)

{

weight_high_value2[i] = 1.0f;

}

// compute weight bitcount for the mode

int bits_used_by_weights = get_ise_sequence_bitcount(

2 * dts[decimation_mode]->weight_count,

(quant_method)bm.quant_mode);

int bitcount = free_bits_for_partition_count[partition_count] - bits_used_by_weights;

if (bitcount <= 0 || bits_used_by_weights < 24 || bits_used_by_weights > 96)

{

qwt_errors[i] = 1e38f;

continue;

}

qwt_bitcounts[i] = bitcount;

// then, generate the optimized set of weights for the mode.

compute_quantized_weights_for_decimation_table(

dts[decimation_mode],

weight_low_value1[i],

weight_high_value1[i],

decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * decimation_mode),

flt_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * i),

u8_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * i), bm.quant_mode);

compute_quantized_weights_for_decimation_table(

dts[decimation_mode],

weight_low_value2[i],

weight_high_value2[i],

decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * decimation_mode + 1),

flt_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * i + 1),

u8_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * i + 1), bm.quant_mode);

// then, compute quantization errors for the block mode.

qwt_errors[i] = compute_error_of_weight_set_2planes(

&(eix1[decimation_mode]),

&(eix2[decimation_mode]),

dts[decimation_mode],

flt_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * i),

flt_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * i + 1));

}

// decide the optimal combination of color endpoint encodings and weight encodings.

int partition_format_specifiers[TUNE_MAX_TRIAL_CANDIDATES][4];

int quantized_weight[TUNE_MAX_TRIAL_CANDIDATES];

int color_quant_level[TUNE_MAX_TRIAL_CANDIDATES];

int color_quant_level_mod[TUNE_MAX_TRIAL_CANDIDATES];

endpoints epm;

merge_endpoints(ei1->ep, ei2->ep, plane2_component, epm);

determine_optimal_set_of_endpoint_formats_to_use(

bsd, pt, blk, ewb, &epm, qwt_bitcounts, qwt_errors,

tune_candidate_limit, partition_format_specifiers, quantized_weight,

color_quant_level, color_quant_level_mod);

// then iterate over the tune_candidate_limit believed-to-be-best modes to

// find out which one is actually best.

float best_errorval_in_mode = 1e30f;

float best_errorval_in_scb = scb.errorval;

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

{

TRACE_NODE(node0, "candidate");

const int qw_packed_index = quantized_weight[i];

if (qw_packed_index < 0)

{

trace_add_data("failed", "error_block");

continue;

}

uint8_t *u8_weight1_src;

uint8_t *u8_weight2_src;

assert(qw_packed_index >= 0 && qw_packed_index < bsd->block_mode_count);

const block_mode& qw_bm = bsd->block_modes[qw_packed_index];

int decimation_mode = qw_bm.decimation_mode;

int weight_quant_mode = qw_bm.quant_mode;

const decimation_table *dt = dts[decimation_mode];

promise(dt->weight_count > 0);

u8_weight1_src = u8_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * qw_packed_index);

u8_weight2_src = u8_quantized_decimated_quantized_weights + MAX_WEIGHTS_PER_BLOCK * (2 * qw_packed_index + 1);

trace_add_data("weight_x", dt->weight_x);

trace_add_data("weight_y", dt->weight_y);

trace_add_data("weight_z", dt->weight_z);

trace_add_data("weight_quant", weight_quant_mode);

// recompute the ideal color endpoints before storing them.

merge_endpoints(eix1[decimation_mode].ep, eix2[decimation_mode].ep, plane2_component, epm);

vfloat4 rgbs_colors[4];

vfloat4 rgbo_colors[4];

symbolic_compressed_block workscb;

for (int l = 0; l < max_refinement_iters; l++)

{

recompute_ideal_colors_2planes(

weight_quant_mode, &epm, rgbs_colors, rgbo_colors,

u8_weight1_src, u8_weight2_src, plane2_component, pt, dt, blk, ewb);

// store the colors for the block

for (int j = 0; j < partition_count; j++)

{

workscb.color_formats[j] = pack_color_endpoints(

epm.endpt0[j],

epm.endpt1[j],

rgbs_colors[j], rgbo_colors[j],

partition_format_specifiers[i][j],

workscb.color_values[j],

color_quant_level[i]);

}

workscb.color_formats_matched = 0;

if ((partition_count >= 2 && workscb.color_formats[0] == workscb.color_formats[1]

&& color_quant_level[i] != color_quant_level_mod[i])

&& (partition_count == 2 || (workscb.color_formats[0] == workscb.color_formats[2]

&& (partition_count == 3 || (workscb.color_formats[0] == workscb.color_formats[3])))))

{

int colorvals[4][12];

int color_formats_mod[4] { 0 };

for (int j = 0; j < partition_count; j++)

{

color_formats_mod[j] = pack_color_endpoints(

epm.endpt0[j],

epm.endpt1[j],

rgbs_colors[j],

rgbo_colors[j],

partition_format_specifiers[i][j],

colorvals[j],

color_quant_level_mod[i]);

}

if (color_formats_mod[0] == color_formats_mod[1]

&& (partition_count == 2 || (color_formats_mod[0] == color_formats_mod[2]

&& (partition_count == 3 || (color_formats_mod[0] == color_formats_mod[3])))))

{

workscb.color_formats_matched = 1;

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

{

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

{

workscb.color_values[j][k] = colorvals[j][k];

}

workscb.color_formats[j] = color_formats_mod[j];

}

}

}

// store header fields

workscb.partition_count = partition_count;

workscb.partition_index = partition_index;

workscb.color_quant_level = workscb.color_formats_matched ? color_quant_level_mod[i] : color_quant_level[i];

workscb.block_mode = qw_bm.mode_index;

workscb.plane2_component = plane2_component;

workscb.error_block = 0;

if (workscb.color_quant_level < 4)

{

workscb.error_block = 1; // should never happen, but cannot prove it impossible

}

// Pre-realign test

if (l == 0)

{

for (int j = 0; j < dt->weight_count; j++)

{

workscb.weights[j] = u8_weight1_src[j];

workscb.weights[j + PLANE2_WEIGHTS_OFFSET] = u8_weight2_src[j];

}

float errorval = compute_symbolic_block_difference(config, bsd, &workscb, blk, ewb);

if (errorval == -1e30f)

{

errorval = -errorval;

workscb.error_block = 1;

}

trace_add_data("error_prerealign", errorval);

best_errorval_in_mode = astc::min(errorval, best_errorval_in_mode);

// Average refinement improvement is 3.5% per iteration

// (allow 5%), but the first iteration can help more so we give

// it a extra 10% leeway. Use this knowledge to drive a

// heuristic to skip blocks that are unlikely to catch up with

// the best block we have already.

int iters_remaining = max_refinement_iters - l;

float threshold = (0.05f * static_cast<float>(iters_remaining)) + 1.1f;

if (errorval > (threshold * best_errorval_in_scb))

{

break;

}

if (errorval < best_errorval_in_scb)

{

best_errorval_in_scb = errorval;

workscb.errorval = errorval;

scb = workscb;

if (errorval < tune_errorval_threshold)

{

return errorval;

}

}

}

// perform a final pass over the weights to try to improve them.

bool adjustments = realign_weights(

config.profile, bsd, blk, ewb, &workscb,

u8_weight1_src, u8_weight2_src);

// Post-realign test

for (int j = 0; j < dt->weight_count; j++)

{

workscb.weights[j] = u8_weight1_src[j];

workscb.weights[j + PLANE2_WEIGHTS_OFFSET] = u8_weight2_src[j];

}

float errorval = compute_symbolic_block_difference(config, bsd, &workscb, blk, ewb);

if (errorval == -1e30f)

{

errorval = -errorval;

workscb.error_block = 1;

}

trace_add_data("error_postrealign", errorval);

best_errorval_in_mode = astc::min(errorval, best_errorval_in_mode);

// Average refinement improvement is 3.5% per iteration, so skip

// blocks that are unlikely to catch up with the best block we

// have already. Assume a 5% per step to give benefit of the doubt

int iters_remaining = max_refinement_iters - 1 - l;

float threshold = (0.05f * static_cast<float>(iters_remaining)) + 1.0f;

if (errorval > (threshold * best_errorval_in_scb))

{

break;

}

if (errorval < best_errorval_in_scb)

{

best_errorval_in_scb = errorval;

workscb.errorval = errorval;

scb = workscb;

if (errorval < tune_errorval_threshold)

{

return errorval;

}

}

if (!adjustments)

{

break;

}

}

}

return best_errorval_in_mode;

}

void expand_deblock_weights(

astcenc_context& ctx

) {

unsigned int xdim = ctx.config.block_x;

unsigned int ydim = ctx.config.block_y;

unsigned int zdim = ctx.config.block_z;

float centerpos_x = static_cast<float>(xdim - 1) * 0.5f;

float centerpos_y = static_cast<float>(ydim - 1) * 0.5f;

float centerpos_z = static_cast<float>(zdim - 1) * 0.5f;

float *bef = ctx.deblock_weights;

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

{

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

{

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

{

float xdif = (static_cast<float>(x) - centerpos_x) / static_cast<float>(xdim);

float ydif = (static_cast<float>(y) - centerpos_y) / static_cast<float>(ydim);

float zdif = (static_cast<float>(z) - centerpos_z) / static_cast<float>(zdim);

float wdif = 0.36f;

float dist = astc::sqrt(xdif * xdif + ydif * ydif + zdif * zdif + wdif * wdif);

*bef = astc::pow(dist, ctx.config.b_deblock_weight);

bef++;

}

}

}

}

// Function to set error weights for each color component for each texel in a block.

// Returns the sum of all the error values set.

static float prepare_error_weight_block(