blob: c4fb9eb2436ba51412c8b197384b9ce0d73aa360 [file] [log] [blame]
// basisu_uastc_enc.cpp
// Copyright (C) 2019-2020 Binomial LLC. All Rights Reserved.
//
// 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.
#include "basisu_uastc_enc.h"
#include "basisu_astc_decomp.h"
#include "basisu_gpu_texture.h"
#include "basisu_bc7enc.h"
#ifdef _DEBUG
// When BASISU_VALIDATE_UASTC_ENC is 1, we pack and unpack to/from UASTC and ASTC, then validate that each codec returns the exact same results. This is slower.
#define BASISU_VALIDATE_UASTC_ENC 1
#endif
#define BASISU_SUPPORT_FORCE_MODE 0
using namespace basist;
namespace basisu
{
const uint32_t MAX_ENCODE_RESULTS = 512;
#if BASISU_VALIDATE_UASTC_ENC
static void validate_func(bool condition, int line)
{
if (!condition)
{
fprintf(stderr, "basisu_uastc_enc: Internal validation failed on line %u!\n", line);
}
}
#define VALIDATE(c) validate_func(c, __LINE__);
#else
#define VALIDATE(c)
#endif
enum dxt_constants
{
cDXT1SelectorBits = 2U, cDXT1SelectorValues = 1U << cDXT1SelectorBits, cDXT1SelectorMask = cDXT1SelectorValues - 1U,
cDXT5SelectorBits = 3U, cDXT5SelectorValues = 1U << cDXT5SelectorBits, cDXT5SelectorMask = cDXT5SelectorValues - 1U,
};
struct dxt1_block
{
enum { cTotalEndpointBytes = 2, cTotalSelectorBytes = 4 };
uint8_t m_low_color[cTotalEndpointBytes];
uint8_t m_high_color[cTotalEndpointBytes];
uint8_t m_selectors[cTotalSelectorBytes];
inline void clear() { basisu::clear_obj(*this); }
inline uint32_t get_high_color() const { return m_high_color[0] | (m_high_color[1] << 8U); }
inline uint32_t get_low_color() const { return m_low_color[0] | (m_low_color[1] << 8U); }
inline void set_low_color(uint16_t c) { m_low_color[0] = static_cast<uint8_t>(c & 0xFF); m_low_color[1] = static_cast<uint8_t>((c >> 8) & 0xFF); }
inline void set_high_color(uint16_t c) { m_high_color[0] = static_cast<uint8_t>(c & 0xFF); m_high_color[1] = static_cast<uint8_t>((c >> 8) & 0xFF); }
inline uint32_t get_selector(uint32_t x, uint32_t y) const { assert((x < 4U) && (y < 4U)); return (m_selectors[y] >> (x * cDXT1SelectorBits))& cDXT1SelectorMask; }
inline void set_selector(uint32_t x, uint32_t y, uint32_t val) { assert((x < 4U) && (y < 4U) && (val < 4U)); m_selectors[y] &= (~(cDXT1SelectorMask << (x * cDXT1SelectorBits))); m_selectors[y] |= (val << (x * cDXT1SelectorBits)); }
static uint16_t pack_color(const color_rgba& color, bool scaled, uint32_t bias = 127U)
{
uint32_t r = color.r, g = color.g, b = color.b;
if (scaled)
{
r = (r * 31U + bias) / 255U;
g = (g * 63U + bias) / 255U;
b = (b * 31U + bias) / 255U;
}
return static_cast<uint16_t>(basisu::minimum(b, 31U) | (basisu::minimum(g, 63U) << 5U) | (basisu::minimum(r, 31U) << 11U));
}
static uint16_t pack_unscaled_color(uint32_t r, uint32_t g, uint32_t b) { return static_cast<uint16_t>(b | (g << 5U) | (r << 11U)); }
};
#define UASTC_WRITE_MODE_DESCS 0
static inline void uastc_write_bits(uint8_t* pBuf, uint32_t& bit_offset, uint64_t code, uint32_t codesize, const char* pDesc)
{
(void)pDesc;
#if UASTC_WRITE_MODE_DESCS
if (pDesc)
printf("%s: %u %u\n", pDesc, bit_offset, codesize);
#endif
assert((codesize == 64) || (code < (1ULL << codesize)));
while (codesize)
{
uint32_t byte_bit_offset = bit_offset & 7;
uint32_t bits_to_write = basisu::minimum<int>(codesize, 8 - byte_bit_offset);
pBuf[bit_offset >> 3] |= (code << byte_bit_offset);
code >>= bits_to_write;
codesize -= bits_to_write;
bit_offset += bits_to_write;
}
}
void pack_uastc(basist::uastc_block& blk, const uastc_encode_results& result, const etc_block& etc1_blk, uint32_t etc1_bias, const eac_a8_block& etc_eac_a8_blk, bool bc1_hint0, bool bc1_hint1)
{
if ((g_uastc_mode_has_alpha[result.m_uastc_mode]) && (result.m_uastc_mode != UASTC_MODE_INDEX_SOLID_COLOR))
{
assert(etc_eac_a8_blk.m_multiplier >= 1);
}
uint8_t buf[32];
memset(buf, 0, sizeof(buf));
uint32_t block_bit_offset = 0;
#if UASTC_WRITE_MODE_DESCS
printf("**** Mode: %u\n", result.m_uastc_mode);
#endif
uastc_write_bits(buf, block_bit_offset, g_uastc_mode_huff_codes[result.m_uastc_mode][0], g_uastc_mode_huff_codes[result.m_uastc_mode][1], "mode");
if (result.m_uastc_mode == UASTC_MODE_INDEX_SOLID_COLOR)
{
uastc_write_bits(buf, block_bit_offset, result.m_solid_color.r, 8, "R");
uastc_write_bits(buf, block_bit_offset, result.m_solid_color.g, 8, "G");
uastc_write_bits(buf, block_bit_offset, result.m_solid_color.b, 8, "B");
uastc_write_bits(buf, block_bit_offset, result.m_solid_color.a, 8, "A");
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_diff_bit(), 1, "ETC1D");
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_inten_table(0), 3, "ETC1I");
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_selector(0, 0), 2, "ETC1S");
uint32_t r, g, b;
if (etc1_blk.get_diff_bit())
etc_block::unpack_color5(r, g, b, etc1_blk.get_base5_color(), false);
else
etc_block::unpack_color4(r, g, b, etc1_blk.get_base4_color(0), false);
uastc_write_bits(buf, block_bit_offset, r, 5, "ETC1R");
uastc_write_bits(buf, block_bit_offset, g, 5, "ETC1G");
uastc_write_bits(buf, block_bit_offset, b, 5, "ETC1B");
memcpy(&blk, buf, sizeof(blk));
return;
}
if (g_uastc_mode_has_bc1_hint0[result.m_uastc_mode])
uastc_write_bits(buf, block_bit_offset, bc1_hint0, 1, "BC1H0");
else
{
assert(bc1_hint0 == false);
}
if (g_uastc_mode_has_bc1_hint1[result.m_uastc_mode])
uastc_write_bits(buf, block_bit_offset, bc1_hint1, 1, "BC1H1");
else
{
assert(bc1_hint1 == false);
}
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_flip_bit(), 1, "ETC1F");
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_diff_bit(), 1, "ETC1D");
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_inten_table(0), 3, "ETC1I0");
uastc_write_bits(buf, block_bit_offset, etc1_blk.get_inten_table(1), 3, "ETC1I1");
if (g_uastc_mode_has_etc1_bias[result.m_uastc_mode])
uastc_write_bits(buf, block_bit_offset, etc1_bias, 5, "ETC1BIAS");
else
{
assert(etc1_bias == 0);
}
if (g_uastc_mode_has_alpha[result.m_uastc_mode])
{
const uint32_t etc2_hints = etc_eac_a8_blk.m_table | (etc_eac_a8_blk.m_multiplier << 4);
assert(etc2_hints > 0 && etc2_hints <= 0xFF);
uastc_write_bits(buf, block_bit_offset, etc2_hints, 8, "ETC2TM");
}
uint32_t subsets = 1;
switch (result.m_uastc_mode)
{
case 2:
case 4:
case 7:
case 9:
case 16:
uastc_write_bits(buf, block_bit_offset, result.m_common_pattern, 5, "PAT");
subsets = 2;
break;
case 3:
uastc_write_bits(buf, block_bit_offset, result.m_common_pattern, 4, "PAT");
subsets = 3;
break;
default:
break;
}
#ifdef _DEBUG
uint32_t part_seed = 0;
switch (result.m_uastc_mode)
{
case 2:
case 4:
case 9:
case 16:
part_seed = g_astc_bc7_common_partitions2[result.m_common_pattern].m_astc;
break;
case 3:
part_seed = g_astc_bc7_common_partitions3[result.m_common_pattern].m_astc;
break;
case 7:
part_seed = g_bc7_3_astc2_common_partitions[result.m_common_pattern].m_astc2;
break;
default:
break;
}
#endif
uint32_t total_planes = 1;
switch (result.m_uastc_mode)
{
case 6:
case 11:
case 13:
uastc_write_bits(buf, block_bit_offset, result.m_astc.m_ccs, 2, "COMPSEL");
total_planes = 2;
break;
case 17:
// CCS field is always 3 for dual plane LA.
assert(result.m_astc.m_ccs == 3);
total_planes = 2;
break;
default:
break;
}
uint8_t weights[32];
memcpy(weights, result.m_astc.m_weights, 16 * total_planes);
uint8_t endpoints[18];
memcpy(endpoints, result.m_astc.m_endpoints, sizeof(endpoints));
const uint32_t total_comps = g_uastc_mode_comps[result.m_uastc_mode];
// LLAA
// LLAA LLAA
// LLAA LLAA LLAA
// RRGGBB
// RRGGBB RRGGBB
// RRGGBB RRGGBB RRGGBB
// RRGGBBAA
// RRGGBBAA RRGGBBAA
const uint32_t weight_bits = g_uastc_mode_weight_bits[result.m_uastc_mode];
const uint8_t* pPartition_pattern;
const uint8_t* pSubset_anchor_indices = basist::get_anchor_indices(subsets, result.m_uastc_mode, result.m_common_pattern, pPartition_pattern);
for (uint32_t plane_index = 0; plane_index < total_planes; plane_index++)
{
for (uint32_t subset_index = 0; subset_index < subsets; subset_index++)
{
const uint32_t anchor_index = pSubset_anchor_indices[subset_index];
#ifdef _DEBUG
if (subsets >= 2)
{
for (uint32_t i = 0; i < 16; i++)
{
const uint32_t part_index = astc_compute_texel_partition(part_seed, i & 3, i >> 2, 0, subsets, true);
if (part_index == subset_index)
{
assert(anchor_index == i);
break;
}
}
}
else
{
assert(!anchor_index);
}
#endif
// Check anchor weight's MSB - if it's set then invert this subset's weights and swap the endpoints
if (weights[anchor_index * total_planes + plane_index] & (1 << (weight_bits - 1)))
{
for (uint32_t i = 0; i < 16; i++)
{
const uint32_t part_index = pPartition_pattern[i];
#ifdef _DEBUG
if (subsets >= 2)
{
assert(part_index == (uint32_t)astc_compute_texel_partition(part_seed, i & 3, i >> 2, 0, subsets, true));
}
else
{
assert(!part_index);
}
#endif
if (part_index == subset_index)
weights[i * total_planes + plane_index] = ((1 << weight_bits) - 1) - weights[i * total_planes + plane_index];
}
if (total_planes == 2)
{
for (int c = 0; c < (int)total_comps; c++)
{
const uint32_t comp_plane = (total_comps == 2) ? c : ((c == result.m_astc.m_ccs) ? 1 : 0);
if (comp_plane == plane_index)
std::swap(endpoints[c * 2 + 0], endpoints[c * 2 + 1]);
}
}
else
{
for (uint32_t c = 0; c < total_comps; c++)
std::swap(endpoints[subset_index * total_comps * 2 + c * 2 + 0], endpoints[subset_index * total_comps * 2 + c * 2 + 1]);
}
}
} // subset_index
} // plane_index
const uint32_t total_values = total_comps * 2 * subsets;
const uint32_t endpoint_range = g_uastc_mode_endpoint_ranges[result.m_uastc_mode];
uint32_t bit_values[18];
uint32_t tq_values[8];
uint32_t total_tq_values = 0;
uint32_t tq_accum = 0;
uint32_t tq_mul = 1;
const uint32_t ep_bits = g_astc_bise_range_table[endpoint_range][0];
const uint32_t ep_trits = g_astc_bise_range_table[endpoint_range][1];
const uint32_t ep_quints = g_astc_bise_range_table[endpoint_range][2];
for (uint32_t i = 0; i < total_values; i++)
{
uint32_t val = endpoints[i];
uint32_t bits = val & ((1 << ep_bits) - 1);
uint32_t tq = val >> ep_bits;
bit_values[i] = bits;
if (ep_trits)
{
assert(tq < 3);
tq_accum += tq * tq_mul;
tq_mul *= 3;
if (tq_mul == 243)
{
tq_values[total_tq_values++] = tq_accum;
tq_accum = 0;
tq_mul = 1;
}
}
else if (ep_quints)
{
assert(tq < 5);
tq_accum += tq * tq_mul;
tq_mul *= 5;
if (tq_mul == 125)
{
tq_values[total_tq_values++] = tq_accum;
tq_accum = 0;
tq_mul = 1;
}
}
}
uint32_t total_endpoint_bits = 0;
for (uint32_t i = 0; i < total_tq_values; i++)
{
const uint32_t num_bits = ep_trits ? 8 : 7;
uastc_write_bits(buf, block_bit_offset, tq_values[i], num_bits, "ETQ");
total_endpoint_bits += num_bits;
}
if (tq_mul > 1)
{
uint32_t num_bits;
if (ep_trits)
{
if (tq_mul == 3)
num_bits = 2;
else if (tq_mul == 9)
num_bits = 4;
else if (tq_mul == 27)
num_bits = 5;
else //if (tq_mul == 81)
num_bits = 7;
}
else
{
if (tq_mul == 5)
num_bits = 3;
else //if (tq_mul == 25)
num_bits = 5;
}
uastc_write_bits(buf, block_bit_offset, tq_accum, num_bits, "ETQ");
total_endpoint_bits += num_bits;
}
for (uint32_t i = 0; i < total_values; i++)
{
uastc_write_bits(buf, block_bit_offset, bit_values[i], ep_bits, "EBITS");
total_endpoint_bits += ep_bits;
}
#if UASTC_WRITE_MODE_DESCS
uint32_t weight_start = block_bit_offset;
#endif
uint32_t total_weight_bits = 0;
const uint32_t plane_shift = (total_planes == 2) ? 1 : 0;
for (uint32_t i = 0; i < 16 * total_planes; i++)
{
uint32_t numbits = weight_bits;
for (uint32_t s = 0; s < subsets; s++)
{
if (pSubset_anchor_indices[s] == (i >> plane_shift))
{
numbits--;
break;
}
}
uastc_write_bits(buf, block_bit_offset, weights[i], numbits, nullptr);
total_weight_bits += numbits;
}
#if UASTC_WRITE_MODE_DESCS
printf("WEIGHTS: %u %u\n", weight_start, total_weight_bits);
#endif
assert(block_bit_offset <= 128);
memcpy(&blk, buf, sizeof(blk));
#if UASTC_WRITE_MODE_DESCS
printf("Total bits: %u, endpoint bits: %u, weight bits: %u\n", block_bit_offset, total_endpoint_bits, total_weight_bits);
#endif
}
// MODE 0
// 0. DualPlane: 0, WeightRange: 8 (16), Subsets: 1, CEM: 8 (RGB Direct ), EndpointRange: 19 (192) MODE6 RGB
// 18. DualPlane: 0, WeightRange: 11 (32), Subsets: 1, CEM: 8 (RGB Direct ), EndpointRange: 11 (32) MODE6 RGB
static void astc_mode0_or_18(uint32_t mode, const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params, const uint8_t *pForce_selectors = nullptr)
{
const uint32_t endpoint_range = (mode == 18) ? 11 : 19;
const uint32_t weight_range = (mode == 18) ? 11 : 8;
color_cell_compressor_params ccell_params;
memset(&ccell_params, 0, sizeof(ccell_params));
ccell_params.m_num_pixels = 16;
ccell_params.m_pPixels = (color_quad_u8*)&block[0][0];
ccell_params.m_num_selector_weights = (mode == 18) ? 32 : 16;
ccell_params.m_pSelector_weights = (mode == 18) ? g_astc_weights5 : g_astc_weights4;
ccell_params.m_pSelector_weightsx = (mode == 18) ? (const bc7enc_vec4F*)g_astc_weights5x : (const bc7enc_vec4F*)g_astc_weights4x;
ccell_params.m_astc_endpoint_range = endpoint_range;
ccell_params.m_weights[0] = 1;
ccell_params.m_weights[1] = 1;
ccell_params.m_weights[2] = 1;
ccell_params.m_weights[3] = 1;
ccell_params.m_pForce_selectors = pForce_selectors;
color_cell_compressor_results ccell_results;
uint8_t ccell_result_selectors[16];
uint8_t ccell_result_selectors_temp[16];
memset(&ccell_results, 0, sizeof(ccell_results));
ccell_results.m_pSelectors = &ccell_result_selectors[0];
ccell_results.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err = color_cell_compression(255, &ccell_params, &ccell_results, &comp_params);
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = weight_range;// (mode == 18) ? 11 : 8;
astc_results.m_ccs = 0;
astc_results.m_subsets = 1;
astc_results.m_partition_seed = 0;
astc_results.m_cem = 8;
astc_results.m_endpoints[0] = ccell_results.m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[1] = ccell_results.m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[2] = ccell_results.m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[3] = ccell_results.m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[4] = ccell_results.m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[5] = ccell_results.m_astc_high_endpoint.m_c[2];
bool invert = false;
if (pForce_selectors == nullptr)
{
int s0 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0], astc_results.m_endpoints[1]);
std::swap(astc_results.m_endpoints[2], astc_results.m_endpoints[3]);
std::swap(astc_results.m_endpoints[4], astc_results.m_endpoints[5]);
invert = true;
}
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
astc_results.m_weights[x + y * 4] = ccell_result_selectors[x + y * 4];
if (invert)
astc_results.m_weights[x + y * 4] = ((mode == 18) ? 31 : 15) - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = mode;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = part_err;
total_results++;
}
}
// MODE 1
// 1-subset, 2-bit indices, 8-bit endpoints, BC7 mode 3
// DualPlane: 0, WeightRange: 2 (4), Subsets: 1, CEM: 8 (RGB Direct ), EndpointRange: 20 (256) MODE3 or MODE5 RGB
static void astc_mode1(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
color_cell_compressor_params ccell_params;
memset(&ccell_params, 0, sizeof(ccell_params));
ccell_params.m_num_pixels = 16;
ccell_params.m_pPixels = (color_quad_u8*)&block[0][0];
ccell_params.m_num_selector_weights = 4;
ccell_params.m_pSelector_weights = g_bc7_weights2;
ccell_params.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params.m_astc_endpoint_range = 20;
ccell_params.m_weights[0] = 1;
ccell_params.m_weights[1] = 1;
ccell_params.m_weights[2] = 1;
ccell_params.m_weights[3] = 1;
color_cell_compressor_results ccell_results;
uint8_t ccell_result_selectors[16];
uint8_t ccell_result_selectors_temp[16];
memset(&ccell_results, 0, sizeof(ccell_results));
ccell_results.m_pSelectors = &ccell_result_selectors[0];
ccell_results.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err = color_cell_compression(255, &ccell_params, &ccell_results, &comp_params);
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = 2;
astc_results.m_ccs = 0;
astc_results.m_subsets = 1;
astc_results.m_partition_seed = 0;
astc_results.m_cem = 8;
astc_results.m_endpoints[0] = ccell_results.m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[1] = ccell_results.m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[2] = ccell_results.m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[3] = ccell_results.m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[4] = ccell_results.m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[5] = ccell_results.m_astc_high_endpoint.m_c[2];
const uint32_t range = 20;
bool invert = false;
int s0 = g_astc_unquant[range][astc_results.m_endpoints[0]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[2]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[range][astc_results.m_endpoints[1]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[3]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0], astc_results.m_endpoints[1]);
std::swap(astc_results.m_endpoints[2], astc_results.m_endpoints[3]);
std::swap(astc_results.m_endpoints[4], astc_results.m_endpoints[5]);
invert = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
astc_results.m_weights[x + y * 4] = ccell_result_selectors[x + y * 4];
if (invert)
astc_results.m_weights[x + y * 4] = 3 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 1;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = part_err;
total_results++;
}
}
static uint32_t estimate_partition2(uint32_t num_weights, uint32_t num_comps, const uint32_t* pWeights, const color_rgba block[4][4], const uint32_t weights[4])
{
assert(pWeights[0] == 0 && pWeights[num_weights - 1] == 64);
uint64_t best_err = UINT64_MAX;
uint32_t best_common_pattern = 0;
for (uint32_t common_pattern = 0; common_pattern < TOTAL_ASTC_BC7_COMMON_PARTITIONS2; common_pattern++)
{
const uint32_t bc7_pattern = g_astc_bc7_common_partitions2[common_pattern].m_bc7;
const uint8_t* pPartition = &g_bc7_partition2[bc7_pattern * 16];
color_quad_u8 subset_colors[2][16];
uint32_t subset_total_colors[2] = { 0, 0 };
for (uint32_t index = 0; index < 16; index++)
subset_colors[pPartition[index]][subset_total_colors[pPartition[index]]++] = ((const color_quad_u8*)block)[index];
uint64_t total_subset_err = 0;
for (uint32_t subset = 0; (subset < 2) && (total_subset_err < best_err); subset++)
total_subset_err += color_cell_compression_est_astc(num_weights, num_comps, pWeights, subset_total_colors[subset], &subset_colors[subset][0], best_err, weights);
if (total_subset_err < best_err)
{
best_err = total_subset_err;
best_common_pattern = common_pattern;
}
}
return best_common_pattern;
}
// MODE 2
// 2-subset, 3-bit indices, 4-bit endpoints, BC7 mode 1
// DualPlane: 0, WeightRange: 5 (8), Subsets: 2, CEM: 8 (RGB Direct ), EndpointRange: 8 (16) MODE1
static void astc_mode2(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params, bool estimate_partition)
{
uint32_t first_common_pattern = 0;
uint32_t last_common_pattern = TOTAL_ASTC_BC7_COMMON_PARTITIONS2;
if (estimate_partition)
{
const uint32_t weights[4] = { 1, 1, 1, 1 };
first_common_pattern = estimate_partition2(8, 3, g_bc7_weights3, block, weights);
last_common_pattern = first_common_pattern + 1;
}
for (uint32_t common_pattern = first_common_pattern; common_pattern < last_common_pattern; common_pattern++)
{
const uint32_t bc7_pattern = g_astc_bc7_common_partitions2[common_pattern].m_bc7;
color_rgba part_pixels[2][16];
uint32_t part_pixel_index[4][4];
uint32_t num_part_pixels[2] = { 0, 0 };
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t part = g_bc7_partition2[16 * bc7_pattern + x + y * 4];
part_pixel_index[y][x] = num_part_pixels[part];
part_pixels[part][num_part_pixels[part]++] = block[y][x];
}
}
color_cell_compressor_params ccell_params[2];
color_cell_compressor_results ccell_results[2];
uint8_t ccell_result_selectors[2][16];
uint8_t ccell_result_selectors_temp[2][16];
uint64_t total_part_err = 0;
for (uint32_t part = 0; part < 2; part++)
{
memset(&ccell_params[part], 0, sizeof(ccell_params[part]));
ccell_params[part].m_num_pixels = num_part_pixels[part];
ccell_params[part].m_pPixels = (color_quad_u8*)&part_pixels[part][0];
ccell_params[part].m_num_selector_weights = 8;
ccell_params[part].m_pSelector_weights = g_bc7_weights3;
ccell_params[part].m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights3x;
ccell_params[part].m_astc_endpoint_range = 8;
ccell_params[part].m_weights[0] = 1;
ccell_params[part].m_weights[1] = 1;
ccell_params[part].m_weights[2] = 1;
ccell_params[part].m_weights[3] = 1;
memset(&ccell_results[part], 0, sizeof(ccell_results[part]));
ccell_results[part].m_pSelectors = &ccell_result_selectors[part][0];
ccell_results[part].m_pSelectors_temp = &ccell_result_selectors_temp[part][0];
uint64_t part_err = color_cell_compression(255, &ccell_params[part], &ccell_results[part], &comp_params);
total_part_err += part_err;
} // part
{
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = 5;
astc_results.m_ccs = 0;
astc_results.m_subsets = 2;
astc_results.m_partition_seed = g_astc_bc7_common_partitions2[common_pattern].m_astc;
astc_results.m_cem = 8;
uint32_t p0 = 0;
uint32_t p1 = 1;
if (g_astc_bc7_common_partitions2[common_pattern].m_invert)
std::swap(p0, p1);
astc_results.m_endpoints[0] = ccell_results[p0].m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[1] = ccell_results[p0].m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[2] = ccell_results[p0].m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[3] = ccell_results[p0].m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[4] = ccell_results[p0].m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[5] = ccell_results[p0].m_astc_high_endpoint.m_c[2];
const uint32_t range = 8;
bool invert[2] = { false, false };
int s0 = g_astc_unquant[range][astc_results.m_endpoints[0]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[2]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[range][astc_results.m_endpoints[1]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[3]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0], astc_results.m_endpoints[1]);
std::swap(astc_results.m_endpoints[2], astc_results.m_endpoints[3]);
std::swap(astc_results.m_endpoints[4], astc_results.m_endpoints[5]);
invert[0] = true;
}
astc_results.m_endpoints[6] = ccell_results[p1].m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[7] = ccell_results[p1].m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[8] = ccell_results[p1].m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[9] = ccell_results[p1].m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[10] = ccell_results[p1].m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[11] = ccell_results[p1].m_astc_high_endpoint.m_c[2];
s0 = g_astc_unquant[range][astc_results.m_endpoints[0 + 6]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[2 + 6]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[4 + 6]].m_unquant;
s1 = g_astc_unquant[range][astc_results.m_endpoints[1 + 6]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[3 + 6]].m_unquant + g_astc_unquant[range][astc_results.m_endpoints[5 + 6]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0 + 6], astc_results.m_endpoints[1 + 6]);
std::swap(astc_results.m_endpoints[2 + 6], astc_results.m_endpoints[3 + 6]);
std::swap(astc_results.m_endpoints[4 + 6], astc_results.m_endpoints[5 + 6]);
invert[1] = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t bc7_part = g_bc7_partition2[16 * bc7_pattern + x + y * 4];
astc_results.m_weights[x + y * 4] = ccell_result_selectors[bc7_part][part_pixel_index[y][x]];
uint32_t astc_part = bc7_part;
if (g_astc_bc7_common_partitions2[common_pattern].m_invert)
astc_part = 1 - astc_part;
if (invert[astc_part])
astc_results.m_weights[x + y * 4] = 7 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 2;
pResults[total_results].m_common_pattern = common_pattern;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = total_part_err;
total_results++;
}
}
} // common_pattern
}
// MODE 3
// 3-subsets, 2-bit indices, [0,11] endpoints, BC7 mode 2
// DualPlane: 0, WeightRange: 2 (4), Subsets: 3, CEM: 8 (RGB Direct ), EndpointRange: 7 (12) MODE2
static void astc_mode3(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params, bool estimate_partition)
{
uint32_t first_common_pattern = 0;
uint32_t last_common_pattern = TOTAL_ASTC_BC7_COMMON_PARTITIONS3;
if (estimate_partition)
{
uint64_t best_err = UINT64_MAX;
uint32_t best_common_pattern = 0;
const uint32_t weights[4] = { 1, 1, 1, 1 };
for (uint32_t common_pattern = 0; common_pattern < TOTAL_ASTC_BC7_COMMON_PARTITIONS3; common_pattern++)
{
const uint32_t bc7_pattern = g_astc_bc7_common_partitions3[common_pattern].m_bc7;
const uint8_t* pPartition = &g_bc7_partition3[bc7_pattern * 16];
color_quad_u8 subset_colors[3][16];
uint32_t subset_total_colors[3] = { 0, 0 };
for (uint32_t index = 0; index < 16; index++)
subset_colors[pPartition[index]][subset_total_colors[pPartition[index]]++] = ((const color_quad_u8*)block)[index];
uint64_t total_subset_err = 0;
for (uint32_t subset = 0; (subset < 3) && (total_subset_err < best_err); subset++)
total_subset_err += color_cell_compression_est_astc(4, 3, g_bc7_weights2, subset_total_colors[subset], &subset_colors[subset][0], best_err, weights);
if (total_subset_err < best_err)
{
best_err = total_subset_err;
best_common_pattern = common_pattern;
}
}
first_common_pattern = best_common_pattern;
last_common_pattern = best_common_pattern + 1;
}
for (uint32_t common_pattern = first_common_pattern; common_pattern < last_common_pattern; common_pattern++)
{
const uint32_t endpoint_range = 7;
const uint32_t bc7_pattern = g_astc_bc7_common_partitions3[common_pattern].m_bc7;
color_rgba part_pixels[3][16];
uint32_t part_pixel_index[4][4];
uint32_t num_part_pixels[3] = { 0, 0, 0 };
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t bc7_part = g_bc7_partition3[16 * bc7_pattern + x + y * 4];
part_pixel_index[y][x] = num_part_pixels[bc7_part];
part_pixels[bc7_part][num_part_pixels[bc7_part]++] = block[y][x];
}
}
color_cell_compressor_params ccell_params[3];
color_cell_compressor_results ccell_results[3];
uint8_t ccell_result_selectors[3][16];
uint8_t ccell_result_selectors_temp[3][16];
uint64_t total_part_err = 0;
for (uint32_t bc7_part = 0; bc7_part < 3; bc7_part++)
{
memset(&ccell_params[bc7_part], 0, sizeof(ccell_params[bc7_part]));
ccell_params[bc7_part].m_num_pixels = num_part_pixels[bc7_part];
ccell_params[bc7_part].m_pPixels = (color_quad_u8*)&part_pixels[bc7_part][0];
ccell_params[bc7_part].m_num_selector_weights = 4;
ccell_params[bc7_part].m_pSelector_weights = g_bc7_weights2;
ccell_params[bc7_part].m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params[bc7_part].m_astc_endpoint_range = endpoint_range;
ccell_params[bc7_part].m_weights[0] = 1;
ccell_params[bc7_part].m_weights[1] = 1;
ccell_params[bc7_part].m_weights[2] = 1;
ccell_params[bc7_part].m_weights[3] = 1;
memset(&ccell_results[bc7_part], 0, sizeof(ccell_results[bc7_part]));
ccell_results[bc7_part].m_pSelectors = &ccell_result_selectors[bc7_part][0];
ccell_results[bc7_part].m_pSelectors_temp = &ccell_result_selectors_temp[bc7_part][0];
uint64_t part_err = color_cell_compression(255, &ccell_params[bc7_part], &ccell_results[bc7_part], &comp_params);
total_part_err += part_err;
} // part
{
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = 2;
astc_results.m_ccs = 0;
astc_results.m_subsets = 3;
astc_results.m_partition_seed = g_astc_bc7_common_partitions3[common_pattern].m_astc;
astc_results.m_cem = 8;
uint32_t astc_to_bc7_part[3]; // converts ASTC to BC7 partition index
const uint32_t perm = g_astc_bc7_common_partitions3[common_pattern].m_astc_to_bc7_perm;
astc_to_bc7_part[0] = g_astc_to_bc7_partition_index_perm_tables[perm][0];
astc_to_bc7_part[1] = g_astc_to_bc7_partition_index_perm_tables[perm][1];
astc_to_bc7_part[2] = g_astc_to_bc7_partition_index_perm_tables[perm][2];
bool invert_astc_part[3] = { false, false, false };
for (uint32_t astc_part = 0; astc_part < 3; astc_part++)
{
uint8_t* pEndpoints = &astc_results.m_endpoints[6 * astc_part];
pEndpoints[0] = ccell_results[astc_to_bc7_part[astc_part]].m_astc_low_endpoint.m_c[0];
pEndpoints[1] = ccell_results[astc_to_bc7_part[astc_part]].m_astc_high_endpoint.m_c[0];
pEndpoints[2] = ccell_results[astc_to_bc7_part[astc_part]].m_astc_low_endpoint.m_c[1];
pEndpoints[3] = ccell_results[astc_to_bc7_part[astc_part]].m_astc_high_endpoint.m_c[1];
pEndpoints[4] = ccell_results[astc_to_bc7_part[astc_part]].m_astc_low_endpoint.m_c[2];
pEndpoints[5] = ccell_results[astc_to_bc7_part[astc_part]].m_astc_high_endpoint.m_c[2];
int s0 = g_astc_unquant[endpoint_range][pEndpoints[0]].m_unquant + g_astc_unquant[endpoint_range][pEndpoints[2]].m_unquant + g_astc_unquant[endpoint_range][pEndpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][pEndpoints[1]].m_unquant + g_astc_unquant[endpoint_range][pEndpoints[3]].m_unquant + g_astc_unquant[endpoint_range][pEndpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(pEndpoints[0], pEndpoints[1]);
std::swap(pEndpoints[2], pEndpoints[3]);
std::swap(pEndpoints[4], pEndpoints[5]);
invert_astc_part[astc_part] = true;
}
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t bc7_part = g_bc7_partition3[16 * bc7_pattern + x + y * 4];
astc_results.m_weights[x + y * 4] = ccell_result_selectors[bc7_part][part_pixel_index[y][x]];
uint32_t astc_part = 0;
for (uint32_t i = 0; i < 3; i++)
{
if (astc_to_bc7_part[i] == bc7_part)
{
astc_part = i;
break;
}
}
if (invert_astc_part[astc_part])
astc_results.m_weights[x + y * 4] = 3 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 3;
pResults[total_results].m_common_pattern = common_pattern;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = total_part_err;
total_results++;
}
}
} // common_pattern
}
// MODE 4
// DualPlane: 0, WeightRange: 2 (4), Subsets: 2, CEM: 8 (RGB Direct ), EndpointRange: 12 (40) MODE3
static void astc_mode4(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params, bool estimate_partition)
{
//const uint32_t weight_range = 2;
const uint32_t endpoint_range = 12;
uint32_t first_common_pattern = 0;
uint32_t last_common_pattern = TOTAL_ASTC_BC7_COMMON_PARTITIONS2;
if (estimate_partition)
{
const uint32_t weights[4] = { 1, 1, 1, 1 };
first_common_pattern = estimate_partition2(4, 3, g_bc7_weights2, block, weights);
last_common_pattern = first_common_pattern + 1;
}
for (uint32_t common_pattern = first_common_pattern; common_pattern < last_common_pattern; common_pattern++)
{
const uint32_t bc7_pattern = g_astc_bc7_common_partitions2[common_pattern].m_bc7;
color_rgba part_pixels[2][16];
uint32_t part_pixel_index[4][4];
uint32_t num_part_pixels[2] = { 0, 0 };
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t part = g_bc7_partition2[16 * bc7_pattern + x + y * 4];
part_pixel_index[y][x] = num_part_pixels[part];
part_pixels[part][num_part_pixels[part]++] = block[y][x];
}
}
color_cell_compressor_params ccell_params[2];
color_cell_compressor_results ccell_results[2];
uint8_t ccell_result_selectors[2][16];
uint8_t ccell_result_selectors_temp[2][16];
uint64_t total_part_err = 0;
for (uint32_t part = 0; part < 2; part++)
{
memset(&ccell_params[part], 0, sizeof(ccell_params[part]));
ccell_params[part].m_num_pixels = num_part_pixels[part];
ccell_params[part].m_pPixels = (color_quad_u8*)&part_pixels[part][0];
ccell_params[part].m_num_selector_weights = 4;
ccell_params[part].m_pSelector_weights = g_bc7_weights2;
ccell_params[part].m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params[part].m_astc_endpoint_range = endpoint_range;
ccell_params[part].m_weights[0] = 1;
ccell_params[part].m_weights[1] = 1;
ccell_params[part].m_weights[2] = 1;
ccell_params[part].m_weights[3] = 1;
memset(&ccell_results[part], 0, sizeof(ccell_results[part]));
ccell_results[part].m_pSelectors = &ccell_result_selectors[part][0];
ccell_results[part].m_pSelectors_temp = &ccell_result_selectors_temp[part][0];
uint64_t part_err = color_cell_compression(255, &ccell_params[part], &ccell_results[part], &comp_params);
total_part_err += part_err;
} // part
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = 2;
astc_results.m_ccs = 0;
astc_results.m_subsets = 2;
astc_results.m_partition_seed = g_astc_bc7_common_partitions2[common_pattern].m_astc;
astc_results.m_cem = 8;
uint32_t p0 = 0;
uint32_t p1 = 1;
if (g_astc_bc7_common_partitions2[common_pattern].m_invert)
std::swap(p0, p1);
astc_results.m_endpoints[0] = ccell_results[p0].m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[1] = ccell_results[p0].m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[2] = ccell_results[p0].m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[3] = ccell_results[p0].m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[4] = ccell_results[p0].m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[5] = ccell_results[p0].m_astc_high_endpoint.m_c[2];
bool invert[2] = { false, false };
int s0 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0], astc_results.m_endpoints[1]);
std::swap(astc_results.m_endpoints[2], astc_results.m_endpoints[3]);
std::swap(astc_results.m_endpoints[4], astc_results.m_endpoints[5]);
invert[0] = true;
}
astc_results.m_endpoints[6] = ccell_results[p1].m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[7] = ccell_results[p1].m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[8] = ccell_results[p1].m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[9] = ccell_results[p1].m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[10] = ccell_results[p1].m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[11] = ccell_results[p1].m_astc_high_endpoint.m_c[2];
s0 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[0 + 6]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[2 + 6]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[4 + 6]].m_unquant;
s1 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[1 + 6]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[3 + 6]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[5 + 6]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0 + 6], astc_results.m_endpoints[1 + 6]);
std::swap(astc_results.m_endpoints[2 + 6], astc_results.m_endpoints[3 + 6]);
std::swap(astc_results.m_endpoints[4 + 6], astc_results.m_endpoints[5 + 6]);
invert[1] = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t bc7_part = g_bc7_partition2[16 * bc7_pattern + x + y * 4];
astc_results.m_weights[x + y * 4] = ccell_result_selectors[bc7_part][part_pixel_index[y][x]];
uint32_t astc_part = bc7_part;
if (g_astc_bc7_common_partitions2[common_pattern].m_invert)
astc_part = 1 - astc_part;
if (invert[astc_part])
astc_results.m_weights[x + y * 4] = 3 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 4;
pResults[total_results].m_common_pattern = common_pattern;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = total_part_err;
total_results++;
}
} // common_pattern
}
// MODE 5
// DualPlane: 0, WeightRange: 5 (8), Subsets: 1, CEM: 8 (RGB Direct ), EndpointRange: 20 (256) BC7 MODE 6 (or MODE 1 1-subset)
static void astc_mode5(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
const uint32_t weight_range = 5;
const uint32_t endpoint_range = 20;
color_cell_compressor_params ccell_params;
memset(&ccell_params, 0, sizeof(ccell_params));
ccell_params.m_num_pixels = 16;
ccell_params.m_pPixels = (color_quad_u8*)&block[0][0];
ccell_params.m_num_selector_weights = 8;
ccell_params.m_pSelector_weights = g_bc7_weights3;
ccell_params.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights3x;
ccell_params.m_astc_endpoint_range = endpoint_range;
ccell_params.m_weights[0] = 1;
ccell_params.m_weights[1] = 1;
ccell_params.m_weights[2] = 1;
ccell_params.m_weights[3] = 1;
color_cell_compressor_results ccell_results;
uint8_t ccell_result_selectors[16];
uint8_t ccell_result_selectors_temp[16];
memset(&ccell_results, 0, sizeof(ccell_results));
ccell_results.m_pSelectors = &ccell_result_selectors[0];
ccell_results.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err = color_cell_compression(255, &ccell_params, &ccell_results, &comp_params);
// ASTC
astc_block_desc blk;
memset(&blk, 0, sizeof(blk));
blk.m_dual_plane = false;
blk.m_weight_range = weight_range;
blk.m_ccs = 0;
blk.m_subsets = 1;
blk.m_partition_seed = 0;
blk.m_cem = 8;
blk.m_endpoints[0] = ccell_results.m_astc_low_endpoint.m_c[0];
blk.m_endpoints[1] = ccell_results.m_astc_high_endpoint.m_c[0];
blk.m_endpoints[2] = ccell_results.m_astc_low_endpoint.m_c[1];
blk.m_endpoints[3] = ccell_results.m_astc_high_endpoint.m_c[1];
blk.m_endpoints[4] = ccell_results.m_astc_low_endpoint.m_c[2];
blk.m_endpoints[5] = ccell_results.m_astc_high_endpoint.m_c[2];
bool invert = false;
int s0 = g_astc_unquant[endpoint_range][blk.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][blk.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(blk.m_endpoints[0], blk.m_endpoints[1]);
std::swap(blk.m_endpoints[2], blk.m_endpoints[3]);
std::swap(blk.m_endpoints[4], blk.m_endpoints[5]);
invert = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
blk.m_weights[x + y * 4] = ccell_result_selectors[x + y * 4];
if (invert)
blk.m_weights[x + y * 4] = 7 - blk.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 5;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = blk;
pResults[total_results].m_astc_err = part_err;
total_results++;
}
}
// MODE 6
// DualPlane: 1, WeightRange: 2 (4), Subsets: 1, CEM: 8 (RGB Direct ), EndpointRange: 18 (160) BC7 MODE5
static void astc_mode6(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
for (uint32_t rot_comp = 0; rot_comp < 3; rot_comp++)
{
const uint32_t weight_range = 2;
const uint32_t endpoint_range = 18;
color_quad_u8 block_rgb[16];
color_quad_u8 block_a[16];
for (uint32_t i = 0; i < 16; i++)
{
block_rgb[i] = ((color_quad_u8*)&block[0][0])[i];
block_a[i] = block_rgb[i];
uint8_t c = block_a[i].m_c[rot_comp];
block_a[i].m_c[0] = c;
block_a[i].m_c[1] = c;
block_a[i].m_c[2] = c;
block_a[i].m_c[3] = 255;
block_rgb[i].m_c[rot_comp] = 255;
}
uint8_t ccell_result_selectors_temp[16];
color_cell_compressor_params ccell_params_rgb;
memset(&ccell_params_rgb, 0, sizeof(ccell_params_rgb));
ccell_params_rgb.m_num_pixels = 16;
ccell_params_rgb.m_pPixels = block_rgb;
ccell_params_rgb.m_num_selector_weights = 4;
ccell_params_rgb.m_pSelector_weights = g_bc7_weights2;
ccell_params_rgb.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params_rgb.m_astc_endpoint_range = endpoint_range;
ccell_params_rgb.m_weights[0] = 1;
ccell_params_rgb.m_weights[1] = 1;
ccell_params_rgb.m_weights[2] = 1;
ccell_params_rgb.m_weights[3] = 1;
color_cell_compressor_results ccell_results_rgb;
uint8_t ccell_result_selectors_rgb[16];
memset(&ccell_results_rgb, 0, sizeof(ccell_results_rgb));
ccell_results_rgb.m_pSelectors = &ccell_result_selectors_rgb[0];
ccell_results_rgb.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err_rgb = color_cell_compression(255, &ccell_params_rgb, &ccell_results_rgb, &comp_params);
color_cell_compressor_params ccell_params_a;
memset(&ccell_params_a, 0, sizeof(ccell_params_a));
ccell_params_a.m_num_pixels = 16;
ccell_params_a.m_pPixels = block_a;
ccell_params_a.m_num_selector_weights = 4;
ccell_params_a.m_pSelector_weights = g_bc7_weights2;
ccell_params_a.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params_a.m_astc_endpoint_range = endpoint_range;
ccell_params_a.m_weights[0] = 1;
ccell_params_a.m_weights[1] = 1;
ccell_params_a.m_weights[2] = 1;
ccell_params_a.m_weights[3] = 1;
color_cell_compressor_results ccell_results_a;
uint8_t ccell_result_selectors_a[16];
memset(&ccell_results_a, 0, sizeof(ccell_results_a));
ccell_results_a.m_pSelectors = &ccell_result_selectors_a[0];
ccell_results_a.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err_a = color_cell_compression(255, &ccell_params_a, &ccell_results_a, &comp_params) / 3;
uint64_t total_err = part_err_rgb + part_err_a;
// ASTC
astc_block_desc blk;
memset(&blk, 0, sizeof(blk));
blk.m_dual_plane = true;
blk.m_weight_range = weight_range;
blk.m_ccs = rot_comp;
blk.m_subsets = 1;
blk.m_partition_seed = 0;
blk.m_cem = 8;
blk.m_endpoints[0] = (rot_comp == 0 ? ccell_results_a : ccell_results_rgb).m_astc_low_endpoint.m_c[0];
blk.m_endpoints[1] = (rot_comp == 0 ? ccell_results_a : ccell_results_rgb).m_astc_high_endpoint.m_c[0];
blk.m_endpoints[2] = (rot_comp == 1 ? ccell_results_a : ccell_results_rgb).m_astc_low_endpoint.m_c[1];
blk.m_endpoints[3] = (rot_comp == 1 ? ccell_results_a : ccell_results_rgb).m_astc_high_endpoint.m_c[1];
blk.m_endpoints[4] = (rot_comp == 2 ? ccell_results_a : ccell_results_rgb).m_astc_low_endpoint.m_c[2];
blk.m_endpoints[5] = (rot_comp == 2 ? ccell_results_a : ccell_results_rgb).m_astc_high_endpoint.m_c[2];
bool invert = false;
int s0 = g_astc_unquant[endpoint_range][blk.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][blk.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(blk.m_endpoints[0], blk.m_endpoints[1]);
std::swap(blk.m_endpoints[2], blk.m_endpoints[3]);
std::swap(blk.m_endpoints[4], blk.m_endpoints[5]);
invert = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
uint32_t rgb_index = ccell_result_selectors_rgb[x + y * 4];
uint32_t a_index = ccell_result_selectors_a[x + y * 4];
if (invert)
{
rgb_index = 3 - rgb_index;
a_index = 3 - a_index;
}
blk.m_weights[(x + y * 4) * 2 + 0] = (uint8_t)rgb_index;
blk.m_weights[(x + y * 4) * 2 + 1] = (uint8_t)a_index;
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 6;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = blk;
pResults[total_results].m_astc_err = total_err;
total_results++;
}
} // rot_comp
}
// MODE 7 - 2 subset ASTC, 3 subset BC7
// DualPlane: 0, WeightRange: 2 (4), Subsets: 2, CEM: 8 (RGB Direct ), EndpointRange: 12 (40) MODE2
static void astc_mode7(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params, bool estimate_partition)
{
uint32_t first_common_pattern = 0;
uint32_t last_common_pattern = TOTAL_BC7_3_ASTC2_COMMON_PARTITIONS;
if (estimate_partition)
{
uint64_t best_err = UINT64_MAX;
uint32_t best_common_pattern = 0;
const uint32_t weights[4] = { 1, 1, 1, 1 };
for (uint32_t common_pattern = 0; common_pattern < TOTAL_BC7_3_ASTC2_COMMON_PARTITIONS; common_pattern++)
{
const uint8_t* pPartition = &g_bc7_3_astc2_patterns2[common_pattern][0];
#ifdef _DEBUG
const uint32_t astc_pattern = g_bc7_3_astc2_common_partitions[common_pattern].m_astc2;
const uint32_t bc7_pattern = g_bc7_3_astc2_common_partitions[common_pattern].m_bc73;
const uint32_t common_pattern_k = g_bc7_3_astc2_common_partitions[common_pattern].k;
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t astc_part = bc7_convert_partition_index_3_to_2(g_bc7_partition3[16 * bc7_pattern + x + y * 4], common_pattern_k);
assert((int)astc_part == astc_compute_texel_partition(astc_pattern, x, y, 0, 2, true));
assert(astc_part == pPartition[x + y * 4]);
}
}
#endif
color_quad_u8 subset_colors[2][16];
uint32_t subset_total_colors[2] = { 0, 0 };
for (uint32_t index = 0; index < 16; index++)
subset_colors[pPartition[index]][subset_total_colors[pPartition[index]]++] = ((const color_quad_u8*)block)[index];
uint64_t total_subset_err = 0;
for (uint32_t subset = 0; (subset < 2) && (total_subset_err < best_err); subset++)
total_subset_err += color_cell_compression_est_astc(4, 3, g_bc7_weights2, subset_total_colors[subset], &subset_colors[subset][0], best_err, weights);
if (total_subset_err < best_err)
{
best_err = total_subset_err;
best_common_pattern = common_pattern;
}
}
first_common_pattern = best_common_pattern;
last_common_pattern = best_common_pattern + 1;
}
//const uint32_t weight_range = 2;
const uint32_t endpoint_range = 12;
for (uint32_t common_pattern = first_common_pattern; common_pattern < last_common_pattern; common_pattern++)
{
const uint32_t astc_pattern = g_bc7_3_astc2_common_partitions[common_pattern].m_astc2;
const uint32_t bc7_pattern = g_bc7_3_astc2_common_partitions[common_pattern].m_bc73;
const uint32_t common_pattern_k = g_bc7_3_astc2_common_partitions[common_pattern].k;
color_rgba part_pixels[2][16];
uint32_t part_pixel_index[4][4];
uint32_t num_part_pixels[2] = { 0, 0 };
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t astc_part = bc7_convert_partition_index_3_to_2(g_bc7_partition3[16 * bc7_pattern + x + y * 4], common_pattern_k);
#ifdef _DEBUG
assert((int)astc_part == astc_compute_texel_partition(astc_pattern, x, y, 0, 2, true));
#endif
part_pixel_index[y][x] = num_part_pixels[astc_part];
part_pixels[astc_part][num_part_pixels[astc_part]++] = block[y][x];
}
}
color_cell_compressor_params ccell_params[2];
color_cell_compressor_results ccell_results[2];
uint8_t ccell_result_selectors[2][16];
uint8_t ccell_result_selectors_temp[2][16];
uint64_t total_part_err = 0;
for (uint32_t part = 0; part < 2; part++)
{
memset(&ccell_params[part], 0, sizeof(ccell_params[part]));
ccell_params[part].m_num_pixels = num_part_pixels[part];
ccell_params[part].m_pPixels = (color_quad_u8*)&part_pixels[part][0];
ccell_params[part].m_num_selector_weights = 4;
ccell_params[part].m_pSelector_weights = g_bc7_weights2;
ccell_params[part].m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params[part].m_astc_endpoint_range = endpoint_range;
ccell_params[part].m_weights[0] = 1;
ccell_params[part].m_weights[1] = 1;
ccell_params[part].m_weights[2] = 1;
ccell_params[part].m_weights[3] = 1;
memset(&ccell_results[part], 0, sizeof(ccell_results[part]));
ccell_results[part].m_pSelectors = &ccell_result_selectors[part][0];
ccell_results[part].m_pSelectors_temp = &ccell_result_selectors_temp[part][0];
uint64_t part_err = color_cell_compression(255, &ccell_params[part], &ccell_results[part], &comp_params);
total_part_err += part_err;
} // part
// ASTC
astc_block_desc blk;
memset(&blk, 0, sizeof(blk));
blk.m_dual_plane = false;
blk.m_weight_range = 2;
blk.m_ccs = 0;
blk.m_subsets = 2;
blk.m_partition_seed = astc_pattern;
blk.m_cem = 8;
const uint32_t p0 = 0;
const uint32_t p1 = 1;
blk.m_endpoints[0] = ccell_results[p0].m_astc_low_endpoint.m_c[0];
blk.m_endpoints[1] = ccell_results[p0].m_astc_high_endpoint.m_c[0];
blk.m_endpoints[2] = ccell_results[p0].m_astc_low_endpoint.m_c[1];
blk.m_endpoints[3] = ccell_results[p0].m_astc_high_endpoint.m_c[1];
blk.m_endpoints[4] = ccell_results[p0].m_astc_low_endpoint.m_c[2];
blk.m_endpoints[5] = ccell_results[p0].m_astc_high_endpoint.m_c[2];
bool invert[2] = { false, false };
int s0 = g_astc_unquant[endpoint_range][blk.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][blk.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(blk.m_endpoints[0], blk.m_endpoints[1]);
std::swap(blk.m_endpoints[2], blk.m_endpoints[3]);
std::swap(blk.m_endpoints[4], blk.m_endpoints[5]);
invert[0] = true;
}
blk.m_endpoints[6] = ccell_results[p1].m_astc_low_endpoint.m_c[0];
blk.m_endpoints[7] = ccell_results[p1].m_astc_high_endpoint.m_c[0];
blk.m_endpoints[8] = ccell_results[p1].m_astc_low_endpoint.m_c[1];
blk.m_endpoints[9] = ccell_results[p1].m_astc_high_endpoint.m_c[1];
blk.m_endpoints[10] = ccell_results[p1].m_astc_low_endpoint.m_c[2];
blk.m_endpoints[11] = ccell_results[p1].m_astc_high_endpoint.m_c[2];
s0 = g_astc_unquant[endpoint_range][blk.m_endpoints[0 + 6]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[2 + 6]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[4 + 6]].m_unquant;
s1 = g_astc_unquant[endpoint_range][blk.m_endpoints[1 + 6]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[3 + 6]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[5 + 6]].m_unquant;
if (s1 < s0)
{
std::swap(blk.m_endpoints[0 + 6], blk.m_endpoints[1 + 6]);
std::swap(blk.m_endpoints[2 + 6], blk.m_endpoints[3 + 6]);
std::swap(blk.m_endpoints[4 + 6], blk.m_endpoints[5 + 6]);
invert[1] = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t astc_part = bc7_convert_partition_index_3_to_2(g_bc7_partition3[16 * bc7_pattern + x + y * 4], common_pattern_k);
blk.m_weights[x + y * 4] = ccell_result_selectors[astc_part][part_pixel_index[y][x]];
if (invert[astc_part])
blk.m_weights[x + y * 4] = 3 - blk.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 7;
pResults[total_results].m_common_pattern = common_pattern;
pResults[total_results].m_astc = blk;
pResults[total_results].m_astc_err = total_part_err;
total_results++;
}
} // common_pattern
}
static void estimate_partition2_list(uint32_t num_weights, uint32_t num_comps, const uint32_t* pWeights, const color_rgba block[4][4], uint32_t* pParts, uint32_t max_parts, const uint32_t weights[4])
{
assert(pWeights[0] == 0 && pWeights[num_weights - 1] == 64);
const uint32_t MAX_PARTS = 8;
assert(max_parts <= MAX_PARTS);
uint64_t part_error[MAX_PARTS];
memset(part_error, 0xFF, sizeof(part_error));
memset(pParts, 0, sizeof(pParts[0]) * max_parts);
for (uint32_t common_pattern = 0; common_pattern < TOTAL_ASTC_BC7_COMMON_PARTITIONS2; common_pattern++)
{
const uint32_t bc7_pattern = g_astc_bc7_common_partitions2[common_pattern].m_bc7;
const uint8_t* pPartition = &g_bc7_partition2[bc7_pattern * 16];
color_quad_u8 subset_colors[2][16];
uint32_t subset_total_colors[2] = { 0, 0 };
for (uint32_t index = 0; index < 16; index++)
subset_colors[pPartition[index]][subset_total_colors[pPartition[index]]++] = ((const color_quad_u8*)block)[index];
uint64_t total_subset_err = 0;
for (uint32_t subset = 0; subset < 2; subset++)
total_subset_err += color_cell_compression_est_astc(num_weights, num_comps, pWeights, subset_total_colors[subset], &subset_colors[subset][0], UINT64_MAX, weights);
for (int i = 0; i < (int)max_parts; i++)
{
if (total_subset_err < part_error[i])
{
for (int j = max_parts - 1; j > i; --j)
{
pParts[j] = pParts[j - 1];
part_error[j] = part_error[j - 1];
}
pParts[i] = common_pattern;
part_error[i] = total_subset_err;
break;
}
}
}
#ifdef _DEBUG
for (uint32_t i = 0; i < max_parts - 1; i++)
{
assert(part_error[i] <= part_error[i + 1]);
}
#endif
}
// 9. DualPlane: 0, WeightRange: 2 (4), Subsets: 2, CEM: 12 (RGBA Direct), EndpointRange: 8 (16) - BC7 MODE 7
// 16. DualPlane: 0, WeightRange : 2 (4), Subsets : 2, CEM: 4 (LA Direct), EndpointRange : 20 (256) - BC7 MODE 7
static void astc_mode9_or_16(uint32_t mode, const color_rgba source_block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params, uint32_t estimate_partition_list_size)
{
assert(mode == 9 || mode == 16);
const color_rgba* pBlock = &source_block[0][0];
color_rgba temp_block[16];
if (mode == 16)
{
for (uint32_t i = 0; i < 16; i++)
{
if (mode == 16)
{
assert(pBlock[i].r == pBlock[i].g);
assert(pBlock[i].r == pBlock[i].b);
}
const uint32_t l = pBlock[i].r;
const uint32_t a = pBlock[i].a;
// Use (l,0,0,a) not (l,l,l,a) so both components are treated equally.
temp_block[i].set_noclamp_rgba(l, 0, 0, a);
}
pBlock = temp_block;
}
const uint32_t weights[4] = { 1, 1, 1, 1 };
//const uint32_t weight_range = 2;
const uint32_t endpoint_range = (mode == 16) ? 20 : 8;
uint32_t first_common_pattern = 0;
uint32_t last_common_pattern = TOTAL_ASTC_BC7_COMMON_PARTITIONS2;
bool use_part_list = false;
const uint32_t MAX_PARTS = 8;
uint32_t parts[MAX_PARTS];
if (estimate_partition_list_size == 1)
{
first_common_pattern = estimate_partition2(4, 4, g_bc7_weights2, (const color_rgba(*)[4])pBlock, weights);
last_common_pattern = first_common_pattern + 1;
}
else if (estimate_partition_list_size > 0)
{
assert(estimate_partition_list_size <= MAX_PARTS);
estimate_partition_list_size = std::min(estimate_partition_list_size, MAX_PARTS);
estimate_partition2_list(4, 4, g_bc7_weights2, (const color_rgba(*)[4])pBlock, parts, estimate_partition_list_size, weights);
first_common_pattern = 0;
last_common_pattern = estimate_partition_list_size;
use_part_list = true;
#ifdef _DEBUG
assert(parts[0] == estimate_partition2(4, 4, g_bc7_weights2, (const color_rgba(*)[4])pBlock, weights));
#endif
}
for (uint32_t common_pattern_iter = first_common_pattern; common_pattern_iter < last_common_pattern; common_pattern_iter++)
{
const uint32_t common_pattern = use_part_list ? parts[common_pattern_iter] : common_pattern_iter;
const uint32_t bc7_pattern = g_astc_bc7_common_partitions2[common_pattern].m_bc7;
color_rgba part_pixels[2][16];
uint32_t part_pixel_index[4][4];
uint32_t num_part_pixels[2] = { 0, 0 };
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t part = g_bc7_partition2[16 * bc7_pattern + x + y * 4];
part_pixel_index[y][x] = num_part_pixels[part];
part_pixels[part][num_part_pixels[part]++] = pBlock[y * 4 + x];
}
}
color_cell_compressor_params ccell_params[2];
color_cell_compressor_results ccell_results[2];
uint8_t ccell_result_selectors[2][16];
uint8_t ccell_result_selectors_temp[2][16];
uint64_t total_err = 0;
for (uint32_t subset = 0; subset < 2; subset++)
{
memset(&ccell_params[subset], 0, sizeof(ccell_params[subset]));
ccell_params[subset].m_num_pixels = num_part_pixels[subset];
ccell_params[subset].m_pPixels = (color_quad_u8*)&part_pixels[subset][0];
ccell_params[subset].m_num_selector_weights = 4;
ccell_params[subset].m_pSelector_weights = g_bc7_weights2;
ccell_params[subset].m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params[subset].m_astc_endpoint_range = endpoint_range;
ccell_params[subset].m_weights[0] = weights[0];
ccell_params[subset].m_weights[1] = weights[1];
ccell_params[subset].m_weights[2] = weights[2];
ccell_params[subset].m_weights[3] = weights[3];
ccell_params[subset].m_has_alpha = true;
memset(&ccell_results[subset], 0, sizeof(ccell_results[subset]));
ccell_results[subset].m_pSelectors = &ccell_result_selectors[subset][0];
ccell_results[subset].m_pSelectors_temp = &ccell_result_selectors_temp[subset][0];
uint64_t subset_err = color_cell_compression(255, &ccell_params[subset], &ccell_results[subset], &comp_params);
if (mode == 16)
{
color_rgba colors[4];
for (uint32_t c = 0; c < 4; c++)
{
colors[0].m_comps[c] = g_astc_unquant[endpoint_range][ccell_results[subset].m_astc_low_endpoint.m_c[(c < 3) ? 0 : 3]].m_unquant;
colors[3].m_comps[c] = g_astc_unquant[endpoint_range][ccell_results[subset].m_astc_high_endpoint.m_c[(c < 3) ? 0 : 3]].m_unquant;
}
for (uint32_t i = 1; i < 4 - 1; i++)
for (uint32_t c = 0; c < 4; c++)
colors[i].m_comps[c] = (uint8_t)astc_interpolate(colors[0].m_comps[c], colors[3].m_comps[c], g_bc7_weights2[i], false);
for (uint32_t p = 0; p < ccell_params[subset].m_num_pixels; p++)
{
color_rgba orig_pix(part_pixels[subset][p]);
orig_pix.g = orig_pix.r;
orig_pix.b = orig_pix.r;
total_err += color_distance_la(orig_pix, colors[ccell_result_selectors[subset][p]]);
}
}
else
{
total_err += subset_err;
}
} // subset
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = 2;
astc_results.m_ccs = 0;
astc_results.m_subsets = 2;
astc_results.m_partition_seed = g_astc_bc7_common_partitions2[common_pattern].m_astc;
astc_results.m_cem = (mode == 16) ? 4 : 12;
uint32_t part[2] = { 0, 1 };
if (g_astc_bc7_common_partitions2[common_pattern].m_invert)
std::swap(part[0], part[1]);
bool invert[2] = { false, false };
for (uint32_t p = 0; p < 2; p++)
{
if (mode == 16)
{
astc_results.m_endpoints[p * 4 + 0] = ccell_results[part[p]].m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[p * 4 + 1] = ccell_results[part[p]].m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[p * 4 + 2] = ccell_results[part[p]].m_astc_low_endpoint.m_c[3];
astc_results.m_endpoints[p * 4 + 3] = ccell_results[part[p]].m_astc_high_endpoint.m_c[3];
}
else
{
for (uint32_t c = 0; c < 4; c++)
{
astc_results.m_endpoints[p * 8 + c * 2] = ccell_results[part[p]].m_astc_low_endpoint.m_c[c];
astc_results.m_endpoints[p * 8 + c * 2 + 1] = ccell_results[part[p]].m_astc_high_endpoint.m_c[c];
}
int s0 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[p * 8 + 0]].m_unquant +
g_astc_unquant[endpoint_range][astc_results.m_endpoints[p * 8 + 2]].m_unquant +
g_astc_unquant[endpoint_range][astc_results.m_endpoints[p * 8 + 4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[p * 8 + 1]].m_unquant +
g_astc_unquant[endpoint_range][astc_results.m_endpoints[p * 8 + 3]].m_unquant +
g_astc_unquant[endpoint_range][astc_results.m_endpoints[p * 8 + 5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[p * 8 + 0], astc_results.m_endpoints[p * 8 + 1]);
std::swap(astc_results.m_endpoints[p * 8 + 2], astc_results.m_endpoints[p * 8 + 3]);
std::swap(astc_results.m_endpoints[p * 8 + 4], astc_results.m_endpoints[p * 8 + 5]);
std::swap(astc_results.m_endpoints[p * 8 + 6], astc_results.m_endpoints[p * 8 + 7]);
invert[p] = true;
}
}
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
const uint32_t bc7_part = g_bc7_partition2[16 * bc7_pattern + x + y * 4];
astc_results.m_weights[x + y * 4] = ccell_result_selectors[bc7_part][part_pixel_index[y][x]];
uint32_t astc_part = bc7_part;
if (g_astc_bc7_common_partitions2[common_pattern].m_invert)
astc_part = 1 - astc_part;
if (invert[astc_part])
astc_results.m_weights[x + y * 4] = 3 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = mode;
pResults[total_results].m_common_pattern = common_pattern;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = total_err;
total_results++;
}
} // common_pattern
}
// MODE 10
// DualPlane: 0, WeightRange: 8 (16), Subsets: 1, CEM: 12 (RGBA Direct ), EndpointRange: 13 (48) MODE6
static void astc_mode10(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
const uint32_t weight_range = 8;
const uint32_t endpoint_range = 13;
color_cell_compressor_params ccell_params;
memset(&ccell_params, 0, sizeof(ccell_params));
ccell_params.m_num_pixels = 16;
ccell_params.m_pPixels = (color_quad_u8*)&block[0][0];
ccell_params.m_num_selector_weights = 16;
ccell_params.m_pSelector_weights = g_astc_weights4;
ccell_params.m_pSelector_weightsx = (const bc7enc_vec4F*)g_astc_weights4x;
ccell_params.m_astc_endpoint_range = endpoint_range;
ccell_params.m_weights[0] = 1;
ccell_params.m_weights[1] = 1;
ccell_params.m_weights[2] = 1;
ccell_params.m_weights[3] = 1;
ccell_params.m_has_alpha = true;
color_cell_compressor_results ccell_results;
uint8_t ccell_result_selectors[16];
uint8_t ccell_result_selectors_temp[16];
memset(&ccell_results, 0, sizeof(ccell_results));
ccell_results.m_pSelectors = &ccell_result_selectors[0];
ccell_results.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err = color_cell_compression(255, &ccell_params, &ccell_results, &comp_params);
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = weight_range;
astc_results.m_ccs = 0;
astc_results.m_subsets = 1;
astc_results.m_partition_seed = 0;
astc_results.m_cem = 12;
astc_results.m_endpoints[0] = ccell_results.m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[1] = ccell_results.m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[2] = ccell_results.m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[3] = ccell_results.m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[4] = ccell_results.m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[5] = ccell_results.m_astc_high_endpoint.m_c[2];
astc_results.m_endpoints[6] = ccell_results.m_astc_low_endpoint.m_c[3];
astc_results.m_endpoints[7] = ccell_results.m_astc_high_endpoint.m_c[3];
bool invert = false;
int s0 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0], astc_results.m_endpoints[1]);
std::swap(astc_results.m_endpoints[2], astc_results.m_endpoints[3]);
std::swap(astc_results.m_endpoints[4], astc_results.m_endpoints[5]);
std::swap(astc_results.m_endpoints[6], astc_results.m_endpoints[7]);
invert = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
astc_results.m_weights[x + y * 4] = ccell_result_selectors[x + y * 4];
if (invert)
astc_results.m_weights[x + y * 4] = 15 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 10;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = part_err;
total_results++;
}
}
// 11. DualPlane: 1, WeightRange: 2 (4), Subsets: 1, CEM: 12 (RGBA Direct), EndpointRange: 13 (48) MODE5
// 17. DualPlane: 1, WeightRange : 2 (4), Subsets : 1, CEM : 4 (LA Direct), EndpointRange : 20 (256) BC7 MODE5
static void astc_mode11_or_17(uint32_t mode, const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
assert((mode == 11) || (mode == 17));
const uint32_t weight_range = 2;
const uint32_t endpoint_range = (mode == 17) ? 20 : 13;
bc7enc_compress_block_params local_comp_params(comp_params);
local_comp_params.m_perceptual = false;
local_comp_params.m_weights[0] = 1;
local_comp_params.m_weights[1] = 1;
local_comp_params.m_weights[2] = 1;
local_comp_params.m_weights[3] = 1;
const uint32_t last_rot_comp = (mode == 17) ? 1 : 4;
for (uint32_t rot_comp = 0; rot_comp < last_rot_comp; rot_comp++)
{
color_quad_u8 block_rgb[16];
color_quad_u8 block_a[16];
for (uint32_t i = 0; i < 16; i++)
{
block_rgb[i] = ((color_quad_u8*)&block[0][0])[i];
block_a[i] = block_rgb[i];
if (mode == 17)
{
assert(block_rgb[i].m_c[0] == block_rgb[i].m_c[1]);
assert(block_rgb[i].m_c[0] == block_rgb[i].m_c[2]);
block_a[i].m_c[0] = block_rgb[i].m_c[3];
block_a[i].m_c[1] = block_rgb[i].m_c[3];
block_a[i].m_c[2] = block_rgb[i].m_c[3];
block_a[i].m_c[3] = 255;
block_rgb[i].m_c[1] = block_rgb[i].m_c[0];
block_rgb[i].m_c[2] = block_rgb[i].m_c[0];
block_rgb[i].m_c[3] = 255;
}
else
{
uint8_t c = block_a[i].m_c[rot_comp];
block_a[i].m_c[0] = c;
block_a[i].m_c[1] = c;
block_a[i].m_c[2] = c;
block_a[i].m_c[3] = 255;
block_rgb[i].m_c[rot_comp] = block_rgb[i].m_c[3];
block_rgb[i].m_c[3] = 255;
}
}
uint8_t ccell_result_selectors_temp[16];
color_cell_compressor_params ccell_params_rgb;
memset(&ccell_params_rgb, 0, sizeof(ccell_params_rgb));
ccell_params_rgb.m_num_pixels = 16;
ccell_params_rgb.m_pPixels = block_rgb;
ccell_params_rgb.m_num_selector_weights = 4;
ccell_params_rgb.m_pSelector_weights = g_bc7_weights2;
ccell_params_rgb.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params_rgb.m_astc_endpoint_range = endpoint_range;
ccell_params_rgb.m_weights[0] = 1;
ccell_params_rgb.m_weights[1] = 1;
ccell_params_rgb.m_weights[2] = 1;
ccell_params_rgb.m_weights[3] = 1;
color_cell_compressor_results ccell_results_rgb;
uint8_t ccell_result_selectors_rgb[16];
memset(&ccell_results_rgb, 0, sizeof(ccell_results_rgb));
ccell_results_rgb.m_pSelectors = &ccell_result_selectors_rgb[0];
ccell_results_rgb.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err_rgb = color_cell_compression(255, &ccell_params_rgb, &ccell_results_rgb, &local_comp_params);
color_cell_compressor_params ccell_params_a;
memset(&ccell_params_a, 0, sizeof(ccell_params_a));
ccell_params_a.m_num_pixels = 16;
ccell_params_a.m_pPixels = block_a;
ccell_params_a.m_num_selector_weights = 4;
ccell_params_a.m_pSelector_weights = g_bc7_weights2;
ccell_params_a.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights2x;
ccell_params_a.m_astc_endpoint_range = endpoint_range;
ccell_params_a.m_weights[0] = 1;
ccell_params_a.m_weights[1] = 1;
ccell_params_a.m_weights[2] = 1;
ccell_params_a.m_weights[3] = 1;
color_cell_compressor_results ccell_results_a;
uint8_t ccell_result_selectors_a[16];
memset(&ccell_results_a, 0, sizeof(ccell_results_a));
ccell_results_a.m_pSelectors = &ccell_result_selectors_a[0];
ccell_results_a.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err_a = color_cell_compression(255, &ccell_params_a, &ccell_results_a, &local_comp_params) / 3;
uint64_t total_err = (mode == 17) ? ((part_err_rgb / 3) + part_err_a) : (part_err_rgb + part_err_a);
// ASTC
astc_block_desc blk;
memset(&blk, 0, sizeof(blk));
blk.m_dual_plane = true;
blk.m_weight_range = weight_range;
blk.m_ccs = (mode == 17) ? 3 : rot_comp;
blk.m_subsets = 1;
blk.m_partition_seed = 0;
blk.m_cem = (mode == 17) ? 4 : 12;
bool invert = false;
if (mode == 17)
{
assert(ccell_results_rgb.m_astc_low_endpoint.m_c[0] == ccell_results_rgb.m_astc_low_endpoint.m_c[1]);
assert(ccell_results_rgb.m_astc_low_endpoint.m_c[0] == ccell_results_rgb.m_astc_low_endpoint.m_c[2]);
assert(ccell_results_rgb.m_astc_high_endpoint.m_c[0] == ccell_results_rgb.m_astc_high_endpoint.m_c[1]);
assert(ccell_results_rgb.m_astc_high_endpoint.m_c[0] == ccell_results_rgb.m_astc_high_endpoint.m_c[2]);
blk.m_endpoints[0] = ccell_results_rgb.m_astc_low_endpoint.m_c[0];
blk.m_endpoints[1] = ccell_results_rgb.m_astc_high_endpoint.m_c[0];
blk.m_endpoints[2] = ccell_results_a.m_astc_low_endpoint.m_c[0];
blk.m_endpoints[3] = ccell_results_a.m_astc_high_endpoint.m_c[0];
}
else
{
blk.m_endpoints[0] = (rot_comp == 0 ? ccell_results_a : ccell_results_rgb).m_astc_low_endpoint.m_c[0];
blk.m_endpoints[1] = (rot_comp == 0 ? ccell_results_a : ccell_results_rgb).m_astc_high_endpoint.m_c[0];
blk.m_endpoints[2] = (rot_comp == 1 ? ccell_results_a : ccell_results_rgb).m_astc_low_endpoint.m_c[1];
blk.m_endpoints[3] = (rot_comp == 1 ? ccell_results_a : ccell_results_rgb).m_astc_high_endpoint.m_c[1];
blk.m_endpoints[4] = (rot_comp == 2 ? ccell_results_a : ccell_results_rgb).m_astc_low_endpoint.m_c[2];
blk.m_endpoints[5] = (rot_comp == 2 ? ccell_results_a : ccell_results_rgb).m_astc_high_endpoint.m_c[2];
if (rot_comp == 3)
{
blk.m_endpoints[6] = ccell_results_a.m_astc_low_endpoint.m_c[0];
blk.m_endpoints[7] = ccell_results_a.m_astc_high_endpoint.m_c[0];
}
else
{
blk.m_endpoints[6] = ccell_results_rgb.m_astc_low_endpoint.m_c[rot_comp];
blk.m_endpoints[7] = ccell_results_rgb.m_astc_high_endpoint.m_c[rot_comp];
}
int s0 = g_astc_unquant[endpoint_range][blk.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][blk.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][blk.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(blk.m_endpoints[0], blk.m_endpoints[1]);
std::swap(blk.m_endpoints[2], blk.m_endpoints[3]);
std::swap(blk.m_endpoints[4], blk.m_endpoints[5]);
std::swap(blk.m_endpoints[6], blk.m_endpoints[7]);
invert = true;
}
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
uint32_t rgb_index = ccell_result_selectors_rgb[x + y * 4];
uint32_t a_index = ccell_result_selectors_a[x + y * 4];
if (invert)
{
rgb_index = 3 - rgb_index;
a_index = 3 - a_index;
}
blk.m_weights[(x + y * 4) * 2 + 0] = (uint8_t)rgb_index;
blk.m_weights[(x + y * 4) * 2 + 1] = (uint8_t)a_index;
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = mode;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = blk;
pResults[total_results].m_astc_err = total_err;
total_results++;
}
} // rot_comp
}
// MODE 12
// DualPlane: 0, WeightRange: 5 (8), Subsets: 1, CEM: 12 (RGBA Direct ), EndpointRange: 19 (192) MODE6
static void astc_mode12(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
const uint32_t weight_range = 5;
const uint32_t endpoint_range = 19;
color_cell_compressor_params ccell_params;
memset(&ccell_params, 0, sizeof(ccell_params));
ccell_params.m_num_pixels = 16;
ccell_params.m_pPixels = (color_quad_u8*)&block[0][0];
ccell_params.m_num_selector_weights = 8;
ccell_params.m_pSelector_weights = g_bc7_weights3;
ccell_params.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights3x;
ccell_params.m_astc_endpoint_range = endpoint_range;
ccell_params.m_weights[0] = 1;
ccell_params.m_weights[1] = 1;
ccell_params.m_weights[2] = 1;
ccell_params.m_weights[3] = 1;
ccell_params.m_has_alpha = true;
color_cell_compressor_results ccell_results;
uint8_t ccell_result_selectors[16];
uint8_t ccell_result_selectors_temp[16];
memset(&ccell_results, 0, sizeof(ccell_results));
ccell_results.m_pSelectors = &ccell_result_selectors[0];
ccell_results.m_pSelectors_temp = &ccell_result_selectors_temp[0];
uint64_t part_err = color_cell_compression(255, &ccell_params, &ccell_results, &comp_params);
// ASTC
astc_block_desc astc_results;
memset(&astc_results, 0, sizeof(astc_results));
astc_results.m_dual_plane = false;
astc_results.m_weight_range = weight_range;
astc_results.m_ccs = 0;
astc_results.m_subsets = 1;
astc_results.m_partition_seed = 0;
astc_results.m_cem = 12;
astc_results.m_endpoints[0] = ccell_results.m_astc_low_endpoint.m_c[0];
astc_results.m_endpoints[1] = ccell_results.m_astc_high_endpoint.m_c[0];
astc_results.m_endpoints[2] = ccell_results.m_astc_low_endpoint.m_c[1];
astc_results.m_endpoints[3] = ccell_results.m_astc_high_endpoint.m_c[1];
astc_results.m_endpoints[4] = ccell_results.m_astc_low_endpoint.m_c[2];
astc_results.m_endpoints[5] = ccell_results.m_astc_high_endpoint.m_c[2];
astc_results.m_endpoints[6] = ccell_results.m_astc_low_endpoint.m_c[3];
astc_results.m_endpoints[7] = ccell_results.m_astc_high_endpoint.m_c[3];
bool invert = false;
int s0 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[0]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[2]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[4]].m_unquant;
int s1 = g_astc_unquant[endpoint_range][astc_results.m_endpoints[1]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[3]].m_unquant + g_astc_unquant[endpoint_range][astc_results.m_endpoints[5]].m_unquant;
if (s1 < s0)
{
std::swap(astc_results.m_endpoints[0], astc_results.m_endpoints[1]);
std::swap(astc_results.m_endpoints[2], astc_results.m_endpoints[3]);
std::swap(astc_results.m_endpoints[4], astc_results.m_endpoints[5]);
std::swap(astc_results.m_endpoints[6], astc_results.m_endpoints[7]);
invert = true;
}
for (uint32_t y = 0; y < 4; y++)
{
for (uint32_t x = 0; x < 4; x++)
{
astc_results.m_weights[x + y * 4] = ccell_result_selectors[x + y * 4];
if (invert)
astc_results.m_weights[x + y * 4] = 7 - astc_results.m_weights[x + y * 4];
}
}
assert(total_results < MAX_ENCODE_RESULTS);
if (total_results < MAX_ENCODE_RESULTS)
{
pResults[total_results].m_uastc_mode = 12;
pResults[total_results].m_common_pattern = 0;
pResults[total_results].m_astc = astc_results;
pResults[total_results].m_astc_err = part_err;
total_results++;
}
}
// 13. DualPlane: 1, WeightRange: 0 (2), Subsets: 1, CEM: 12 (RGBA Direct ), EndpointRange: 20 (256) MODE5
static void astc_mode13(const color_rgba block[4][4], uastc_encode_results* pResults, uint32_t& total_results, bc7enc_compress_block_params& comp_params)
{
bc7enc_compress_block_params local_comp_params(comp_params);
local_comp_params.m_perceptual = false;
local_comp_params.m_weights[0] = 1;
local_comp_params.m_weights[1] = 1;
local_comp_params.m_weights[2] = 1;
local_comp_params.m_weights[3] = 1;
for (uint32_t rot_comp = 0; rot_comp < 4; rot_comp++)
{
const uint32_t weight_range = 0;
const uint32_t endpoint_range = 20;
color_quad_u8 block_rgb[16];
color_quad_u8 block_a[16];
for (uint32_t i = 0; i < 16; i++)
{
block_rgb[i] = ((color_quad_u8*)&block[0][0])[i];
block_a[i] = block_rgb[i];
uint8_t c = block_a[i].m_c[rot_comp];
block_a[i].m_c[0] = c;
block_a[i].m_c[1] = c;
block_a[i].m_c[2] = c;
block_a[i].m_c[3] = 255;
block_rgb[i].m_c[rot_comp] = block_rgb[i].m_c[3];
block_rgb[i].m_c[3] = 255;
}
uint8_t ccell_result_selectors_temp[16];
color_cell_compressor_params ccell_params_rgb;
memset(&ccell_params_rgb, 0, sizeof(ccell_params_rgb));
ccell_params_rgb.m_num_pixels = 16;
ccell_params_rgb.m_pPixels = block_rgb;
ccell_params_rgb.m_num_selector_weights = 2;
ccell_params_rgb.m_pSelector_weights = g_bc7_weights1;
ccell_params_rgb.m_pSelector_weightsx = (const bc7enc_vec4F*)g_bc7_weights1x;
ccell_params_rgb.m_astc_endpoint_range = endpoint_range;
ccell_params_rgb.m_weights[0] = 1;
ccell_params_rgb.m_weights[1] = 1;
ccell_params_rgb.m_weights[2] = 1;