encoder/basisu_astc_ldr_common.cpp

// File: basisu_astc_ldr_common.cpp
// Copyright (C) 2019-2026 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_enc.h"
#include "../transcoder/basisu_astc_helpers.h"
#include "../transcoder/basisu_astc_hdr_core.h"
#include "basisu_astc_hdr_common.h"
#include "basisu_astc_ldr_common.h"

#define BASISU_FORCE_EXHAUSTIVE_EVAL (0)
#define BASISU_USE_ORIG_GET_COLORS (0)

namespace basisu
{

namespace astc_ldr
{
	static bool g_initialized;
	static vec4F g_astc_ls_raw_weights_ise[ASTC_LDR_MAX_RAW_WEIGHTS];
			
	color_rgba blue_contract_enc(color_rgba orig, bool& did_clamp, int encoded_b)
	{
		color_rgba enc;

		int tr = orig.r * 2 - encoded_b;
		int tg = orig.g * 2 - encoded_b;
		if ((tr < 0) || (tr > 255) || (tg < 0) || (tg > 255))
			did_clamp = true;

		enc.r = (uint8_t)basisu::clamp<int>(tr, 0, 255);
		enc.g = (uint8_t)basisu::clamp<int>(tg, 0, 255);
		enc.b = (uint8_t)orig.b;
		enc.a = orig.a;
		return enc;
	}

	color_rgba blue_contract_dec(int enc_r, int enc_g, int enc_b, int enc_a)
	{
		color_rgba dec;
		dec.r = (uint8_t)((enc_r + enc_b) >> 1);
		dec.g = (uint8_t)((enc_g + enc_b) >> 1);
		dec.b = (uint8_t)enc_b;
		dec.a = (uint8_t)enc_a;
		return dec;
	}

	void global_init()
	{
		if (g_initialized)
			return;

		// Precomputed weight constants used during least fit determination. For each entry: w * w, (1.0f - w) * w, (1.0f - w) * (1.0f - w), w
		for (uint32_t iw = 0; iw <= 64; iw++)
		{
			float w = (float)iw * (1.0f / 64.0f);

			g_astc_ls_raw_weights_ise[iw].set(w * w, (1.0f - w) * w, (1.0f - w) * (1.0f - w), w);
		}
				
		g_initialized = true;
	}

	static inline const vec4F* get_ls_weights_ise(uint32_t weight_ise_range)
	{
		assert((weight_ise_range <= astc_helpers::BISE_32_LEVELS) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		// astc_helpers::BISE_64_LEVELS indicates raw [0,64] weights (65 total), otherwise ISE weights (<= 32 levels total)
		return (weight_ise_range == astc_helpers::BISE_64_LEVELS) ? g_astc_ls_raw_weights_ise : &g_astc_ls_weights_ise[weight_ise_range][0];
	}
	
	static bool compute_least_squares_endpoints_1D(
		uint32_t N, const uint8_t* pSelectors, const vec4F* pSelector_weights,
		float* pXl, float* pXh, const float* pVals, float bounds_min, float bounds_max)
	{
		float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
		float q00_r = 0.0f, q10_r = 0.0f, t_r = 0.0f;

		for (uint32_t i = 0; i < N; i++)
		{
			const uint32_t sel = pSelectors[i];

			z00 += pSelector_weights[sel][0];
			z10 += pSelector_weights[sel][1];
			z11 += pSelector_weights[sel][2];

			float w = pSelector_weights[sel][3];

			q00_r += w * pVals[i];
			t_r += pVals[i];
		}

		q10_r = t_r - q00_r;

		z01 = z10;

		float det = z00 * z11 - z01 * z10;
		if (fabs(det) < 1e-8f)
			return false;

		det = 1.0f / det;

		float iz00, iz01, iz10, iz11;
		iz00 = z11 * det;
		iz01 = -z01 * det;
		iz10 = -z10 * det;
		iz11 = z00 * det;

		*pXh = (float)(iz00 * q00_r + iz01 * q10_r); *pXl = (float)(iz10 * q00_r + iz11 * q10_r);

		float l = saturate(*pXl), h = saturate(*pXh);

		if (bounds_min == bounds_max)
		{
			l = bounds_min;
			h = bounds_max;
		}

		*pXl = l;
		*pXh = h;

		return true;
	}

	static bool compute_least_squares_endpoints_2D(
		uint32_t N, const uint8_t* pSelectors, const vec4F* pSelector_weights,
		vec2F* pXl, vec2F* pXh, const vec2F* pColors, const vec2F& bounds_min, const vec2F& bounds_max)
	{
		float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
		float q00_r = 0.0f, q10_r = 0.0f, t_r = 0.0f;
		float q00_g = 0.0f, q10_g = 0.0f, t_g = 0.0f;

		for (uint32_t i = 0; i < N; i++)
		{
			const uint32_t sel = pSelectors[i];

			z00 += pSelector_weights[sel][0];
			z10 += pSelector_weights[sel][1];
			z11 += pSelector_weights[sel][2];

			float w = pSelector_weights[sel][3];

			q00_r += w * pColors[i][0];
			t_r += pColors[i][0];

			q00_g += w * pColors[i][1];
			t_g += pColors[i][1];
		}

		q10_r = t_r - q00_r;
		q10_g = t_g - q00_g;

		z01 = z10;

		float det = z00 * z11 - z01 * z10;
		if (fabs(det) < 1e-8f)
			return false;

		det = 1.0f / det;

		float iz00, iz01, iz10, iz11;
		iz00 = z11 * det;
		iz01 = -z01 * det;
		iz10 = -z10 * det;
		iz11 = z00 * det;

		(*pXh)[0] = (float)(iz00 * q00_r + iz01 * q10_r); (*pXl)[0] = (float)(iz10 * q00_r + iz11 * q10_r);
		(*pXh)[1] = (float)(iz00 * q00_g + iz01 * q10_g); (*pXl)[1] = (float)(iz10 * q00_g + iz11 * q10_g);

		for (uint32_t c = 0; c < 2; c++)
		{
			float l = saturate((*pXl)[c]), h = saturate((*pXh)[c]);

			if (bounds_min[c] == bounds_max[c])
			{
				l = bounds_min[c];
				h = bounds_max[c];
			}

			(*pXl)[c] = l;
			(*pXh)[c] = h;
		}

		return true;
	}

	static bool compute_least_squares_endpoints_3D(
		uint32_t N, const uint8_t* pSelectors, const vec4F* pSelector_weights,
		vec4F* pXl, vec4F* pXh, const vec4F* pColors, const vec4F& bounds_min, const vec4F& bounds_max)
	{
		float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
		float q00_r = 0.0f, q10_r = 0.0f, t_r = 0.0f;
		float q00_g = 0.0f, q10_g = 0.0f, t_g = 0.0f;
		float q00_b = 0.0f, q10_b = 0.0f, t_b = 0.0f;

		for (uint32_t i = 0; i < N; i++)
		{
			const uint32_t sel = pSelectors[i];

			z00 += pSelector_weights[sel][0];
			z10 += pSelector_weights[sel][1];
			z11 += pSelector_weights[sel][2];

			float w = pSelector_weights[sel][3];

			q00_r += w * pColors[i][0];
			t_r += pColors[i][0];

			q00_g += w * pColors[i][1];
			t_g += pColors[i][1];

			q00_b += w * pColors[i][2];
			t_b += pColors[i][2];
		}

		q10_r = t_r - q00_r;
		q10_g = t_g - q00_g;
		q10_b = t_b - q00_b;

		z01 = z10;

		float det = z00 * z11 - z01 * z10;
		if (fabs(det) < 1e-8f)
			return false;

		det = 1.0f / det;

		float iz00, iz01, iz10, iz11;
		iz00 = z11 * det;
		iz01 = -z01 * det;
		iz10 = -z10 * det;
		iz11 = z00 * det;

		(*pXh)[0] = (float)(iz00 * q00_r + iz01 * q10_r); (*pXl)[0] = (float)(iz10 * q00_r + iz11 * q10_r);
		(*pXh)[1] = (float)(iz00 * q00_g + iz01 * q10_g); (*pXl)[1] = (float)(iz10 * q00_g + iz11 * q10_g);
		(*pXh)[2] = (float)(iz00 * q00_b + iz01 * q10_b); (*pXl)[2] = (float)(iz10 * q00_b + iz11 * q10_b);

		(*pXh)[3] = 0;
		(*pXl)[3] = 0;

		for (uint32_t c = 0; c < 3; c++)
		{
			float l = saturate((*pXl)[c]), h = saturate((*pXh)[c]);

			if (bounds_min[c] == bounds_max[c])
			{
				l = bounds_min[c];
				h = bounds_max[c];
			}

			(*pXl)[c] = l;
			(*pXh)[c] = h;
		}

		return true;
	}
		
	static bool compute_least_squares_endpoints_4D(
		uint32_t N, const uint8_t* pSelectors, const vec4F* pSelector_weights,
		vec4F* pXl, vec4F* pXh, const vec4F* pColors, const vec4F& bounds_min, const vec4F& bounds_max)
	{
		float z00 = 0.0f, z01 = 0.0f, z10 = 0.0f, z11 = 0.0f;
		float q00_r = 0.0f, q10_r = 0.0f, t_r = 0.0f;
		float q00_g = 0.0f, q10_g = 0.0f, t_g = 0.0f;
		float q00_b = 0.0f, q10_b = 0.0f, t_b = 0.0f;
		float q00_a = 0.0f, q10_a = 0.0f, t_a = 0.0f;

		for (uint32_t i = 0; i < N; i++)
		{
			const uint32_t sel = pSelectors[i];
			z00 += pSelector_weights[sel][0];
			z10 += pSelector_weights[sel][1];
			z11 += pSelector_weights[sel][2];

			float w = pSelector_weights[sel][3];
			q00_r += w * pColors[i][0]; t_r += pColors[i][0];
			q00_g += w * pColors[i][1]; t_g += pColors[i][1];
			q00_b += w * pColors[i][2]; t_b += pColors[i][2];
			q00_a += w * pColors[i][3]; t_a += pColors[i][3];
		}

		q10_r = t_r - q00_r;
		q10_g = t_g - q00_g;
		q10_b = t_b - q00_b;
		q10_a = t_a - q00_a;

		z01 = z10;

		float det = z00 * z11 - z01 * z10;
		if (fabs(det) < 1e-8f)
			return false;

		det = 1.0f / det;

		float iz00, iz01, iz10, iz11;
		iz00 = z11 * det;
		iz01 = -z01 * det;
		iz10 = -z10 * det;
		iz11 = z00 * det;

		(*pXh)[0] = (float)(iz00 * q00_r + iz01 * q10_r); (*pXl)[0] = (float)(iz10 * q00_r + iz11 * q10_r);
		(*pXh)[1] = (float)(iz00 * q00_g + iz01 * q10_g); (*pXl)[1] = (float)(iz10 * q00_g + iz11 * q10_g);
		(*pXh)[2] = (float)(iz00 * q00_b + iz01 * q10_b); (*pXl)[2] = (float)(iz10 * q00_b + iz11 * q10_b);
		(*pXh)[3] = (float)(iz00 * q00_a + iz01 * q10_a); (*pXl)[3] = (float)(iz10 * q00_a + iz11 * q10_a);

		for (uint32_t c = 0; c < 4; c++)
		{
			float l = saturate((*pXl)[c]), h = saturate((*pXh)[c]);

			if (bounds_min[c] == bounds_max[c])
			{
				l = bounds_min[c];
				h = bounds_max[c];
			}

			(*pXl)[c] = l;
			(*pXh)[c] = h;
		}

		return true;
	}

#if 0
	static void dequant_astc_weights(uint32_t n, const uint8_t* pSrc_ise_vals, uint32_t from_ise_range, uint8_t* pDst_raw_weights)
	{
		const auto& dequant_tab = astc_helpers::g_dequant_tables.get_weight_tab(from_ise_range).m_ISE_to_val;

		for (uint32_t i = 0; i < n; i++)
			pDst_raw_weights[i] = dequant_tab[pSrc_ise_vals[i]];
	}
#endif

#if 0
	static void dequant_astc_endpoints(uint32_t n, const uint8_t* pSrc_ise_vals, uint32_t from_ise_range, uint8_t* pDst_raw_weights)
	{
		const auto& dequant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(from_ise_range).m_ISE_to_val;

		for (uint32_t i = 0; i < n; i++)
			pDst_raw_weights[i] = dequant_tab[pSrc_ise_vals[i]];
	}
#endif
		
	int apply_delta_to_bise_weight_val(uint32_t weight_ise_range, int ise_val, int delta)
	{
		if (delta == 0)
			return ise_val;

		uint32_t num_ise_levels = astc_helpers::get_ise_levels(weight_ise_range);

		const auto& ISE_to_rank = astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_range).m_ISE_to_rank;
		const auto& rank_to_ISE = astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_range).m_rank_to_ISE;

		int cur_rank = ISE_to_rank[ise_val];
		int new_rank = basisu::clamp<int>(cur_rank + delta, 0, (int)num_ise_levels - 1);

		return rank_to_ISE[new_rank];
	}

	// v must be [0,1]
	// converts to nearest ISE index with proper precise rounding
	static uint8_t precise_round_bise_endpoint_val(float v, uint32_t endpoint_ise_range)
	{
		assert((v >= 0) && (v <= 1.0f));

		const auto& quant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_val_to_ise;
		const auto& dequant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_val;

		v = saturate(v);

		const int iv = clamp((int)std::roundf(v * 255.0f), 0, 255);

		uint8_t ise_index = 0;

		float best_err = BIG_FLOAT_VAL;
		for (int iscale_delta = -1; iscale_delta <= 1; iscale_delta++)
		{
			const int trial_ise_index = astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, quant_tab[iv], iscale_delta);

			const float dequant_val = dequant_tab[trial_ise_index] * (1.0f / 255.0f);

			const float dequant_err = fabs(dequant_val - v);
			if (dequant_err < best_err)
			{
				best_err = dequant_err;
				ise_index = (uint8_t)trial_ise_index;
			}
		} // iscale_delta

		return ise_index;
	}

	// returns true if blue contraction was actually used
	// note the encoded endpoints may be swapped
	// TODO: Pass in vec4F l/h and let it more precisely quantize in here.
	struct cem_encode_ldr_rgb_or_rgba_direct_result
	{
		bool m_is_blue_contracted;
		bool m_endpoints_are_swapped;
		bool m_any_degen;
	};

	static cem_encode_ldr_rgb_or_rgba_direct_result cem_encode_ldr_rgb_or_rgba_direct(
		uint32_t cem_index, uint32_t endpoint_ise_range, const color_rgba& l, const color_rgba& h, uint8_t* pEndpoint_vals,
		bool try_blue_contract)
	{
		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT));

		cem_encode_ldr_rgb_or_rgba_direct_result res;

		bool& endpoints_are_swapped = res.m_endpoints_are_swapped;
		bool& any_degen = res.m_any_degen;
		bool& is_blue_contracted = res.m_is_blue_contracted;

		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT));

		const bool has_alpha = (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT);

		const auto& quant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_val_to_ise;
		const auto& dequant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_val;

		//const auto &ISE_to_rank = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_rank;
		//const auto &rank_to_ISE = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_rank_to_ISE;

		color_rgba enc_l(l), enc_h(h);
		endpoints_are_swapped = false;

		is_blue_contracted = false;
		if (try_blue_contract)
		{
			int enc_v4 = quant_tab[enc_l.b], enc_v5 = quant_tab[enc_h.b];
			int dec_v4 = dequant_tab[enc_v4], dec_v5 = dequant_tab[enc_v5];

			bool did_clamp = false;
			enc_l = blue_contract_enc(h, did_clamp, dec_v5); // yes, they're swapped in the spec
			enc_h = blue_contract_enc(l, did_clamp, dec_v4);

			if (!did_clamp)
			{
				is_blue_contracted = true;
				endpoints_are_swapped = true;
			}
			else
			{
				enc_l = l;
				enc_h = h;
			}
		}

		int enc_v0 = quant_tab[enc_l.r], enc_v2 = quant_tab[enc_l.g], enc_v4 = quant_tab[enc_l.b];
		int enc_v1 = quant_tab[enc_h.r], enc_v3 = quant_tab[enc_h.g], enc_v5 = quant_tab[enc_h.b];

		int enc_v6 = 0, enc_v7 = 0;
		if (has_alpha)
		{
			enc_v6 = quant_tab[enc_l.a];
			enc_v7 = quant_tab[enc_h.a];
		}

		any_degen = false;
		if ((enc_v0 == enc_v1) && (l.r != h.r))
			any_degen = true;
		if ((enc_v2 == enc_v3) && (l.g != h.g))
			any_degen = true;
		if ((enc_v4 == enc_v5) && (l.b != h.b))
			any_degen = true;
		if (has_alpha)
		{
			if ((enc_v6 == enc_v7) && (l.a != h.a))
				any_degen = true;
		}

		int dec_v0 = dequant_tab[enc_v0], dec_v2 = dequant_tab[enc_v2], dec_v4 = dequant_tab[enc_v4];
		int dec_v1 = dequant_tab[enc_v1], dec_v3 = dequant_tab[enc_v3], dec_v5 = dequant_tab[enc_v5];

		int s0 = dec_v0 + dec_v2 + dec_v4;
		int s1 = dec_v1 + dec_v3 + dec_v5;

		bool should_swap = false;

		if ((s1 == s0) && (is_blue_contracted))
		{
			// if sums are equal we can't use blue contraction at all, so undo it
			enc_l = l;
			enc_h = h;

			is_blue_contracted = false;
			endpoints_are_swapped = false;

			enc_v0 = quant_tab[enc_l.r], enc_v2 = quant_tab[enc_l.g], enc_v4 = quant_tab[enc_l.b];
			enc_v1 = quant_tab[enc_h.r], enc_v3 = quant_tab[enc_h.g], enc_v5 = quant_tab[enc_h.b];

			dec_v0 = dequant_tab[enc_v0], dec_v2 = dequant_tab[enc_v2], dec_v4 = dequant_tab[enc_v4];
			dec_v1 = dequant_tab[enc_v1], dec_v3 = dequant_tab[enc_v3], dec_v5 = dequant_tab[enc_v5];

			if (has_alpha)
			{
				enc_v6 = quant_tab[enc_l.a];
				enc_v7 = quant_tab[enc_h.a];
			}

			s0 = dec_v0 + dec_v2 + dec_v4;
			s1 = dec_v1 + dec_v3 + dec_v5;
		}

		if (s1 >= s0)
		{
			if (is_blue_contracted)
				should_swap = true;
		}
		else
		{
			if (!is_blue_contracted)
				should_swap = true;
		}

		if (should_swap)
		{
			endpoints_are_swapped = !endpoints_are_swapped;

			std::swap(enc_v0, enc_v1);
			std::swap(enc_v2, enc_v3);
			std::swap(enc_v4, enc_v5);
			std::swap(enc_v6, enc_v7);
		}

		pEndpoint_vals[0] = (uint8_t)enc_v0;
		pEndpoint_vals[1] = (uint8_t)enc_v1;

		pEndpoint_vals[2] = (uint8_t)enc_v2;
		pEndpoint_vals[3] = (uint8_t)enc_v3;

		pEndpoint_vals[4] = (uint8_t)enc_v4;
		pEndpoint_vals[5] = (uint8_t)enc_v5;

		if (has_alpha)
		{
			pEndpoint_vals[6] = (uint8_t)enc_v6;
			pEndpoint_vals[7] = (uint8_t)enc_v7;
		}

	#ifdef _DEBUG
		{
			int check_s0 = dequant_tab[enc_v0] + dequant_tab[enc_v2] + dequant_tab[enc_v4];
			int check_s1 = dequant_tab[enc_v1] + dequant_tab[enc_v3] + dequant_tab[enc_v5];

			if (check_s1 >= check_s0)
			{
				assert(!is_blue_contracted);
			}
			else
			{
				assert(is_blue_contracted);
			}
		}
	#endif

		return res;
	}

	// Cannot fail
	// scale=1 cannot be packed
	static void cem_encode_ldr_rgb_or_rgba_base_scale(
		uint32_t cem_index, uint32_t endpoint_ise_range, float scale, float l_a, const vec4F& h, uint8_t* pEndpoint_vals)
	{
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE) || (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A));
		assert((scale >= 0.0f) && (scale < 1.0f));

		const bool has_alpha = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A);

		const auto& quant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_val_to_ise;
		const auto& dequant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_val;

		const uint32_t total_vals_to_pack = has_alpha ? 6 : 4;

		float vals_to_pack[6] = { 0 };

		vals_to_pack[0] = h[0];
		vals_to_pack[1] = h[1];
		vals_to_pack[2] = h[2];
		vals_to_pack[3] = clamp(scale * (256.0f / 255.0f), 0.0f, 1.0f);

		if (has_alpha)
		{
			vals_to_pack[4] = l_a;
			vals_to_pack[5] = h[3];
		}

		for (uint32_t c = 0; c < total_vals_to_pack; c++)
		{
			const float v = vals_to_pack[c];
			const int iv = clamp((int)std::roundf(v * 255.0f), 0, 255);

			float best_err = BIG_FLOAT_VAL;
			for (int iscale_delta = -1; iscale_delta <= 1; iscale_delta++)
			{
				const int trial_ise_index = astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, quant_tab[iv], iscale_delta);

				const float dequant_val = dequant_tab[trial_ise_index] * (1.0f / 255.0f);

				const float dequant_err = fabs(dequant_val - v);
				if (dequant_err < best_err)
				{
					best_err = dequant_err;
					pEndpoint_vals[c] = (uint8_t)trial_ise_index;
				}
			} // iscale_delta

		} // c
	}

#if 0
	static int clamp6(int val, bool& was_clamped)
	{
		if (val < -32)
		{
			val = -32;
			was_clamped = true;
		}
		else if (val > 31)
		{
			val = 31;
			was_clamped = true;
		}
		return val;
	}
#endif
		
	// returns true if blue contraction was used
	// note the encoded endpoints may be swapped
	struct rgb_base_offset_res
	{
		bool m_failed_flag;
		bool m_used_blue_contraction;
		bool m_blue_contraction_clamped;
		bool m_delta_clamped;
		bool m_any_degen;
		bool m_endpoints_swapped;
	};

	// May fail if the tiebreaking logic isn't strong enough.
	static rgb_base_offset_res cem_encode_ldr_rgb_or_rgba_base_offset(uint32_t cem_index, uint32_t endpoint_ise_range, const color_rgba& orig_l, const color_rgba& orig_h, uint8_t* pEndpoint_vals, bool use_blue_contract)
	{
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) || (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET));

		const bool has_alpha = (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET);

		rgb_base_offset_res res;
		res.m_failed_flag = false;
		res.m_used_blue_contraction = false;
		res.m_blue_contraction_clamped = false;
		res.m_delta_clamped = false;
		res.m_any_degen = false;
		res.m_endpoints_swapped = false;

		bool blue_contraction_clamped = false;

		bool status = basist::astc_ldr_t::pack_base_offset(
			cem_index, endpoint_ise_range, pEndpoint_vals,
			convert_to_basist_color_rgba(orig_l), convert_to_basist_color_rgba(orig_h),
			use_blue_contract, true,
			blue_contraction_clamped, res.m_delta_clamped, res.m_endpoints_swapped);
		
		assert(status);

		if (!status)
		{
			res.m_failed_flag = true;
			return res;
		}
		
		// Verify the actual BC status by unpacking to be absolutely sure
		res.m_used_blue_contraction = astc_helpers::used_blue_contraction(cem_index, pEndpoint_vals, endpoint_ise_range);

		color_rgba dec_l, dec_h;
		astc_ldr::decode_endpoints(cem_index, pEndpoint_vals, endpoint_ise_range, dec_l, dec_h);
				
		const uint32_t num_comps = (has_alpha ? 4 : 3);
		for (uint32_t c = 0; c < num_comps; c++)
		{
			if (orig_l[c] != orig_h[c])
				continue;

			// Desired L/H are not equal, but packed are equal=degenerate pack (loss of freedom).
			if (dec_l[c] == dec_h[c])
			{
				res.m_any_degen = true;
				break;
			}
		} //  c

		return res;
	}

	// L or LA direct
	static void encode_cem0_4(uint32_t cem_index, float lum_l, float lum_h, float a_l, float a_h, uint32_t endpoint_ise_range, uint8_t* pEndpoints)
	{
		assert((cem_index == astc_helpers::CEM_LDR_LUM_DIRECT) || (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT));

		const bool has_alpha = (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);

		pEndpoints[0] = precise_round_bise_endpoint_val(lum_l, endpoint_ise_range);
		pEndpoints[1] = precise_round_bise_endpoint_val(lum_h, endpoint_ise_range);

		if (has_alpha)
		{
			pEndpoints[2] = precise_round_bise_endpoint_val(a_l, endpoint_ise_range);
			pEndpoints[3] = precise_round_bise_endpoint_val(a_h, endpoint_ise_range);
		}
	}

	// Returned in ISE order
	// TODO: Investigate alpha handling here vs. latest spec.
	// https://raw.githubusercontent.com/KhronosGroup/DataFormat/refs/heads/main/astc.txt
	// The safest thing to do may be to assume non-sRGB in the encoder. I don't know yet.
	// How should alpha be handled here for lowest divergence from actual ASTC decoding hardware?
	// See https://registry.khronos.org/OpenGL/extensions/EXT/EXT_texture_compression_astc_decode_mode.txt 			
	// All channels including alpha >>8.
	uint32_t get_colors(const color_rgba& l, const color_rgba& h, uint32_t weight_ise_index, color_rgba* pColors, bool decode_mode_srgb)
	{
		const uint32_t total_weights = astc_helpers::get_ise_levels(weight_ise_index);

#if BASISU_USE_ORIG_GET_COLORS
		for (uint32_t i = 0; i < total_weights; i++)
		{
			uint32_t w = basisu::g_ise_weight_lerps[weight_ise_index][1 + i];

			for (uint32_t c = 0; c < 4; c++)
			{
				int le = l[c], he = h[c];
								
				if (decode_mode_srgb)
				{
					le = (le << 8) | 0x80;
					he = (he << 8) | 0x80;
				}
				else
				{
					le = (le << 8) | le;
					he = (he << 8) | he;
				}

				uint32_t k = astc_helpers::weight_interpolate(le, he, w);
								
				pColors[i][c] = (uint8_t)(k >> 8);
			} // c
		} // i 
#else
		int le_r = l.r, he_r = h.r, le_g = l.g, he_g = h.g, le_b = l.b, he_b = h.b, le_a = l.a, he_a = h.a;

		const bool rgb_only = (le_a == 255) && (he_a == 255);

		if (decode_mode_srgb)
		{
			le_r = (le_r << 8) | 0x80;
			he_r = (he_r << 8) | 0x80;

			le_g = (le_g << 8) | 0x80;
			he_g = (he_g << 8) | 0x80;

			le_b = (le_b << 8) | 0x80;
			he_b = (he_b << 8) | 0x80;

			le_a = (le_a << 8) | 0x80;
			he_a = (he_a << 8) | 0x80;
		}
		else
		{
			le_r = (le_r << 8) | le_r;
			he_r = (he_r << 8) | he_r;

			le_g = (le_g << 8) | le_g;
			he_g = (he_g << 8) | he_g;

			le_b = (le_b << 8) | le_b;
			he_b = (he_b << 8) | he_b;

			le_a = (le_a << 8) | le_a;
			he_a = (he_a << 8) | he_a;
		}

		if (rgb_only)
		{
			for (uint32_t i = 0; i < total_weights; i++)
			{
				const uint32_t w = basisu::g_ise_weight_lerps[weight_ise_index][1 + i];

				const uint32_t k_r = astc_helpers::weight_interpolate(le_r, he_r, w);
				const uint32_t k_g = astc_helpers::weight_interpolate(le_g, he_g, w);
				const uint32_t k_b = astc_helpers::weight_interpolate(le_b, he_b, w);

				pColors[i].r = (uint8_t)(k_r >> 8);
				pColors[i].g = (uint8_t)(k_g >> 8);
				pColors[i].b = (uint8_t)(k_b >> 8);
				pColors[i].a = 255;

			} // i 
		}
		else
		{
			for (uint32_t i = 0; i < total_weights; i++)
			{
				const uint32_t w = basisu::g_ise_weight_lerps[weight_ise_index][1 + i];

				const uint32_t k_r = astc_helpers::weight_interpolate(le_r, he_r, w);
				const uint32_t k_g = astc_helpers::weight_interpolate(le_g, he_g, w);
				const uint32_t k_b = astc_helpers::weight_interpolate(le_b, he_b, w);
				const uint32_t k_a = astc_helpers::weight_interpolate(le_a, he_a, w);

				pColors[i].r = (uint8_t)(k_r >> 8);
				pColors[i].g = (uint8_t)(k_g >> 8);
				pColors[i].b = (uint8_t)(k_b >> 8);
				pColors[i].a = (uint8_t)(k_a >> 8);

			} // i 
		}
#endif

		return total_weights;
	}

	// Returns 65 colors (NOT just 64 - 0-64 weight levels, so 65).
	uint32_t get_colors_raw_weights(const color_rgba& l, const color_rgba& h, color_rgba* pColors, bool decode_mode_srgb)
	{
#if BASISU_USE_ORIG_GET_COLORS
		for (uint32_t w = 0; w <= 64; w++)
		{
			for (uint32_t c = 0; c < 4; c++)
			{
				int le = l[c], he = h[c];
								
				if (decode_mode_srgb)
				{
					le = (le << 8) | 0x80;
					he = (he << 8) | 0x80;
				}
				else
				{
					le = (le << 8) | le;
					he = (he << 8) | he;
				}

				uint32_t k = astc_helpers::weight_interpolate(le, he, w);

				pColors[w][c] = (uint8_t)(k >> 8);

			} // c
		} // i 
#else
		int le_r = l.r, he_r = h.r, le_g = l.g, he_g = h.g, le_b = l.b, he_b = h.b, le_a = l.a, he_a = h.a;

		const bool rgb_only = (le_a == 255) && (he_a == 255);

		if (decode_mode_srgb)
		{
			le_r = (le_r << 8) | 0x80;
			he_r = (he_r << 8) | 0x80;

			le_g = (le_g << 8) | 0x80;
			he_g = (he_g << 8) | 0x80;

			le_b = (le_b << 8) | 0x80;
			he_b = (he_b << 8) | 0x80;

			le_a = (le_a << 8) | 0x80;
			he_a = (he_a << 8) | 0x80;
		}
		else
		{
			le_r = (le_r << 8) | le_r;
			he_r = (he_r << 8) | he_r;

			le_g = (le_g << 8) | le_g;
			he_g = (he_g << 8) | he_g;

			le_b = (le_b << 8) | le_b;
			he_b = (he_b << 8) | he_b;

			le_a = (le_a << 8) | le_a;
			he_a = (he_a << 8) | he_a;
		}

		if (rgb_only)
		{
			for (uint32_t w = 0; w <= 64; w++)
			{
				const uint32_t k_r = astc_helpers::weight_interpolate(le_r, he_r, w);
				const uint32_t k_g = astc_helpers::weight_interpolate(le_g, he_g, w);
				const uint32_t k_b = astc_helpers::weight_interpolate(le_b, he_b, w);

				pColors[w].r = (uint8_t)(k_r >> 8);
				pColors[w].g = (uint8_t)(k_g >> 8);
				pColors[w].b = (uint8_t)(k_b >> 8);
				pColors[w].a = 255;

			} // i 
		}
		else
		{
			for (uint32_t w = 0; w <= 64; w++)
			{
				const uint32_t k_r = astc_helpers::weight_interpolate(le_r, he_r, w);
				const uint32_t k_g = astc_helpers::weight_interpolate(le_g, he_g, w);
				const uint32_t k_b = astc_helpers::weight_interpolate(le_b, he_b, w);
				const uint32_t k_a = astc_helpers::weight_interpolate(le_a, he_a, w);

				pColors[w].r = (uint8_t)(k_r >> 8);
				pColors[w].g = (uint8_t)(k_g >> 8);
				pColors[w].b = (uint8_t)(k_b >> 8);
				pColors[w].a = (uint8_t)(k_a >> 8);

			} // i 
		}
#endif

		return ASTC_LDR_MAX_RAW_WEIGHTS;
	}

	// Assumes ise 20 (256 levels)
	void decode_endpoints_ise20(uint32_t cem_index, const uint8_t* pEndpoint_vals, color_rgba& l, color_rgba& h)
	{
		assert(astc_helpers::is_cem_ldr(cem_index));

		int ldr_endpoints[4][2];
		astc_helpers::decode_endpoint(cem_index, ldr_endpoints, pEndpoint_vals);

		for (uint32_t c = 0; c < 4; c++)
		{
			assert((ldr_endpoints[c][0] >= 0) && (ldr_endpoints[c][0] <= 255));
			assert((ldr_endpoints[c][1] >= 0) && (ldr_endpoints[c][1] <= 255));

			l[c] = (uint8_t)ldr_endpoints[c][0];
			h[c] = (uint8_t)ldr_endpoints[c][1];
		}
	}

	void decode_endpoints(uint32_t cem_index, const uint8_t* pEndpoint_vals, uint32_t endpoint_ise_index, color_rgba& l, color_rgba& h, float* pScale)
	{
		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);

		const auto& endpoint_dequant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_index).m_ISE_to_val;

		uint8_t dequantized_endpoints[astc_helpers::MAX_CEM_ENDPOINT_VALS];
		for (uint32_t i = 0; i < total_endpoint_vals; i++)
			dequantized_endpoints[i] = endpoint_dequant_tab[pEndpoint_vals[i]];

		decode_endpoints_ise20(cem_index, dequantized_endpoints, l, h);

		if ((pScale) && ((cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE) || (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A)))
		{
			*pScale = (float)dequantized_endpoints[3] * (1.0f / 256.0f);
		}
	}

	uint32_t get_colors(uint32_t cem_index, const uint8_t* pEndpoint_vals, uint32_t endpoint_ise_index, uint32_t weight_ise_index, color_rgba* pColors, bool decode_mode_srgb)
	{
		color_rgba l, h;
		decode_endpoints(cem_index, pEndpoint_vals, endpoint_ise_index, l, h);

		return get_colors(l, h, weight_ise_index, pColors, decode_mode_srgb);
	}

	// Decodes 65 colors
	uint32_t get_colors_raw_weights(uint32_t cem_index, const uint8_t* pEndpoint_vals, uint32_t endpoint_ise_index, color_rgba* pColors, bool decode_mode_srgb)
	{
		color_rgba l, h;
		decode_endpoints(cem_index, pEndpoint_vals, endpoint_ise_index, l, h);

		return get_colors_raw_weights(l, h, pColors, decode_mode_srgb);
	}

#if 0
	static vec4F calc_incremental_pca_4D(uint32_t num_pixels, const vec4F* pPixels, const vec4F& mean_f)
	{
		vec4F mean_axis(0.0f);

		for (uint32_t i = 0; i < num_pixels; i++)
		{
			vec4F orig_color(pPixels[i]);

			vec4F color(orig_color - mean_f);

			vec4F a(color * color[0]);
			vec4F b(color * color[1]);
			vec4F c(color * color[2]);
			vec4F d(color * color[3]);
			vec4F n(i ? mean_axis : color);

			n.normalize_in_place();

			mean_axis[0] += a.dot(n);
			mean_axis[1] += b.dot(n);
			mean_axis[2] += c.dot(n);
			mean_axis[3] += d.dot(n);
		}

		if (mean_axis.norm() < 1e-5f)
			mean_axis = vec4F(1.0f, 1.0f, 1.0f, 1.0f);

		mean_axis.normalize_in_place();

		return mean_axis;
	}
#endif
		
	static vec4F calc_pca_4D(uint32_t num_pixels, const vec4F* pPixels, const vec4F& mean_f)
	{
		float m00 = 0, m01 = 0, m02 = 0, m03 = 0;
		float m11 = 0, m12 = 0, m13 = 0;
		float m22 = 0, m23 = 0;
		float m33 = 0;

		for (size_t i = 0; i < num_pixels; ++i)
		{
			const vec4F v(pPixels[i] - mean_f);

			m00 += v[0] * v[0]; m01 += v[0] * v[1]; m02 += v[0] * v[2]; m03 += v[0] * v[3];
			m11 += v[1] * v[1]; m12 += v[1] * v[2]; m13 += v[1] * v[3];
			m22 += v[2] * v[2]; m23 += v[2] * v[3];
			m33 += v[3] * v[3];
		}

		// TODO: Seed from channel variances
		vec4F v(.6f, .75f, .4f, .75f);

		const uint32_t NUM_POW_ITERS = 6; // must be even
		for (uint32_t i = 0; i < NUM_POW_ITERS; ++i)
		{
			vec4F w(
				m00 * v[0] + m01 * v[1] + m02 * v[2] + m03 * v[3],
				m01 * v[0] + m11 * v[1] + m12 * v[2] + m13 * v[3],
				m02 * v[0] + m12 * v[1] + m22 * v[2] + m23 * v[3],
				m03 * v[0] + m13 * v[1] + m23 * v[2] + m33 * v[3]
			);

			if (i & 1)
				w.normalize_in_place();
			v = w;
		}

		if (v.norm() < 1e-5f)
			v = vec4F(.5f, .5f, .5f, .5f);

		return v;
	}

	static vec4F calc_pca_3D(uint32_t num_pixels, const vec4F* pPixels, const vec4F& mean_f)
	{
		float cov[6] = { 0, 0, 0, 0, 0, 0 };

		for (uint32_t i = 0; i < num_pixels; i++)
		{
			const vec4F& v = pPixels[i];
			float r = v[0] - mean_f[0];
			float g = v[1] - mean_f[1];
			float b = v[2] - mean_f[2];
			cov[0] += r * r; cov[1] += r * g; cov[2] += r * b; cov[3] += g * g; cov[4] += g * b; cov[5] += b * b;
		}

		float xr = .9f, xg = 1.0f, xb = .7f;
		for (uint32_t iter = 0; iter < 3; iter++)
		{
			float r = xr * cov[0] + xg * cov[1] + xb * cov[2];
			float g = xr * cov[1] + xg * cov[3] + xb * cov[4];
			float b = xr * cov[2] + xg * cov[4] + xb * cov[5];

			float m = maximumf(maximumf(fabsf(r), fabsf(g)), fabsf(b));
			if (m > 1e-10f)
			{
				m = 1.0f / m;
				r *= m; g *= m; b *= m;
			}

			xr = r; xg = g; xb = b;
		}

		float nrm = xr * xr + xg * xg + xb * xb;

		vec4F axis(0.57735027f, 0.57735027f, 0.57735027f, 0.0f);
		if (nrm > 1e-5f)
		{
			float inv_nrm = 1.0f / sqrtf(nrm);
			xr *= inv_nrm; xg *= inv_nrm; xb *= inv_nrm;
			axis.set(xr, xg, xb, 0);
		}

		return axis;
	}

	void pixel_stats_t::init(uint32_t num_pixels, const color_rgba* pPixels)
	{
		m_num_pixels = num_pixels;
		m_has_alpha = false;

		m_min.set(255, 255, 255, 255);
		m_max.set(0, 0, 0, 0);

		m_mean_f.clear();

		for (uint32_t i = 0; i < m_num_pixels; i++)
		{
			const color_rgba& px = pPixels[i];

			m_pixels[i] = px;

			m_pixels_f[i].set((float)px.r * (1.0f / 255.0f), (float)px.g * (1.0f / 255.0f), (float)px.b * (1.0f / 255.0f), (float)px.a * (1.0f / 255.0f));

			m_mean_f += m_pixels_f[i];

			m_min.r = basisu::minimum(m_min.r, px.r);
			m_min.g = basisu::minimum(m_min.g, px.g);
			m_min.b = basisu::minimum(m_min.b, px.b);
			m_min.a = basisu::minimum(m_min.a, px.a);

			m_max.r = basisu::maximum(m_max.r, px.r);
			m_max.g = basisu::maximum(m_max.g, px.g);
			m_max.b = basisu::maximum(m_max.b, px.b);
			m_max.a = basisu::maximum(m_max.a, px.a);
		}

		m_mean_f *= (1.0f / (float)m_num_pixels);
		m_mean_f.clamp(0.0f, 1.0f);

		m_min_f.set(m_min.r * (1.0f / 255.0f), m_min.g * (1.0f / 255.0f), m_min.b * (1.0f / 255.0f), m_min.a * (1.0f / 255.0f));
		m_max_f.set(m_max.r * (1.0f / 255.0f), m_max.g * (1.0f / 255.0f), m_max.b * (1.0f / 255.0f), m_max.a * (1.0f / 255.0f));

		m_has_alpha = (m_min.a < 255);

		// Mean and zero relative RGB (3D) PCA axes
		m_mean_rel_axis3 = calc_pca_3D(m_num_pixels, m_pixels_f, m_mean_f);
		m_zero_rel_axis3 = calc_pca_3D(m_num_pixels, m_pixels_f, vec4F(0.0f));

		// Mean relative RGBA (4D) PCA axes
		m_mean_rel_axis4 = calc_pca_4D(m_num_pixels, m_pixels_f, m_mean_f);

		for (uint32_t c = 0; c < 4u; c++)
			m_rgba_stats[c].calc_simplified_with_range(m_num_pixels, &m_pixels_f[0][c], 4);
	}
			
	static inline uint32_t square_of_diff(int a, int b)
	{
		assert((a >= 0) && (a <= 255));
		assert((b >= 0) && (b <= 255));

		int d = a - b;
		return (uint32_t)(d * d);
	}

	static uint64_t eval_solution(
		const pixel_stats_t& pixel_stats,
		uint32_t total_weights, const color_rgba* pWeight_colors,
		uint8_t* pWeight_vals, uint32_t weight_ise_index,
		const cem_encode_params& params)
	{
		BASISU_NOTE_UNUSED(weight_ise_index);
		assert((total_weights <= 32) || (total_weights == 65));

		const bool all_one_weights = (params.m_comp_weights[0] == 1) && (params.m_comp_weights[1] == 1) && (params.m_comp_weights[2] == 1) && (params.m_comp_weights[3] == 1);

		bool exhaustive_flag = params.m_use_exhaustive_weight_eval;
		if (BASISU_FORCE_EXHAUSTIVE_EVAL)
			exhaustive_flag = true;
		else if (!all_one_weights)
			exhaustive_flag = true;

		uint64_t total_err = 0;

		if (params.m_pForced_weight_vals0)
		{
			if (all_one_weights)
			{
				for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
				{
					const color_rgba& px = pixel_stats.m_pixels[c];

					const uint32_t w = params.m_pForced_weight_vals0[c];
					assert(w < total_weights);

					uint32_t err = square_of_diff(px.r, pWeight_colors[w].r) +
						square_of_diff(px.g, pWeight_colors[w].g) +
						square_of_diff(px.b, pWeight_colors[w].b) +
						square_of_diff(px.a, pWeight_colors[w].a);

					total_err += err;

					pWeight_vals[c] = (uint8_t)w;
				}
			}
			else
			{
				for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
				{
					const color_rgba& px = pixel_stats.m_pixels[c];

					const uint32_t w = params.m_pForced_weight_vals0[c];
					assert(w < total_weights);

					uint32_t err =
						params.m_comp_weights[0] * square_of_diff(px.r, pWeight_colors[w].r) +
						params.m_comp_weights[1] * square_of_diff(px.g, pWeight_colors[w].g) +
						params.m_comp_weights[2] * square_of_diff(px.b, pWeight_colors[w].b) +
						params.m_comp_weights[3] * square_of_diff(px.a, pWeight_colors[w].a);

					total_err += err;

					pWeight_vals[c] = (uint8_t)w;
				}
			}
		}
		else if (exhaustive_flag)
		{
			if (all_one_weights)
			{
				for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
				{
					const color_rgba& px = pixel_stats.m_pixels[c];

					uint32_t best_err = UINT32_MAX;
					uint32_t best_sel = 0;

					for (uint32_t i = 0; i < total_weights; i++)
					{
						uint32_t err =
							square_of_diff(px.r, pWeight_colors[i].r) +
							square_of_diff(px.g, pWeight_colors[i].g) +
							square_of_diff(px.b, pWeight_colors[i].b) +
							square_of_diff(px.a, pWeight_colors[i].a);

						if (err < best_err)
						{
							best_err = err;
							best_sel = i;
						}
					}

					total_err += best_err;
					pWeight_vals[c] = (uint8_t)best_sel;
				}
			}
			else
			{
				for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
				{
					const color_rgba& px = pixel_stats.m_pixels[c];

					uint32_t best_err = UINT32_MAX;
					uint32_t best_sel = 0;

					for (uint32_t i = 0; i < total_weights; i++)
					{
						uint32_t err =
							params.m_comp_weights[0] * square_of_diff(px.r, pWeight_colors[i].r) +
							params.m_comp_weights[1] * square_of_diff(px.g, pWeight_colors[i].g) +
							params.m_comp_weights[2] * square_of_diff(px.b, pWeight_colors[i].b) +
							params.m_comp_weights[3] * square_of_diff(px.a, pWeight_colors[i].a);

						if (err < best_err)
						{
							best_err = err;
							best_sel = i;
						}
					}

					total_err += best_err;
					pWeight_vals[c] = (uint8_t)best_sel;
				}
			}
		}
		else
		{
			assert(all_one_weights);

			// low endpoint must be the first color (w=0)
			const color_rgba& e_l = pWeight_colors[0];

			// high endpoint must be either the last color or the 2nd depending on the weight BISE range
			color_rgba e_h(pWeight_colors[1]);
			if ((total_weights == 65) || (g_ise_weight_lerps[weight_ise_index][total_weights] == 64))
				e_h = pWeight_colors[total_weights - 1];
			else
			{
				assert(g_ise_weight_lerps[weight_ise_index][1 + 1] == 64);
			}

			const int dr = e_h[0] - e_l[0], dg = e_h[1] - e_l[1], db = e_h[2] - e_l[2], da = e_h[3] - e_l[3];

			// computes weights between [0,64]
			const float f = 64.0f / (float)(basisu::squarei(dr) + basisu::squarei(dg) + basisu::squarei(db) + basisu::squarei(da) + .00000125f);

			const auto *pTab = (weight_ise_index <= astc_helpers::BISE_32_LEVELS) ? &astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_index).m_val_to_ise : nullptr;

			const int sofs = -(e_l[0] * dr + e_l[1] * dg + e_l[2] * db + e_l[3] * da);

			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				const color_rgba& px = pixel_stats.m_pixels[c];

				int sel = (int)(float(px[0] * dr + px[1] * dg + px[2] * db + px[3] * da + sofs) * f + .5f);

				if (sel < 0)
					sel = 0;
				else if (sel > 64)
					sel = 64;

				int best_sel = pTab ? (*pTab)[sel] : sel;

				assert(best_sel < (int)total_weights);

				total_err +=
					square_of_diff(px.r, pWeight_colors[best_sel].r) +
					square_of_diff(px.g, pWeight_colors[best_sel].g) +
					square_of_diff(px.b, pWeight_colors[best_sel].b) +
					square_of_diff(px.a, pWeight_colors[best_sel].a);

				pWeight_vals[c] = (uint8_t)best_sel;
			} // c
		}
		
		return total_err;
	}

	// Evaluates against raw weights [0,64], or to ISE quantized weights, depending on weight_ise_index.
	uint64_t eval_solution(
		const pixel_stats_t& pixel_stats,
		uint32_t cem_index,
		const uint8_t* pEndpoint_vals, uint32_t endpoint_ise_index,
		uint8_t* pWeight_vals, uint32_t weight_ise_index,
		const cem_encode_params& params)
	{
		assert((weight_ise_index <= astc_helpers::BISE_32_LEVELS) || (weight_ise_index == astc_helpers::BISE_64_LEVELS));

		color_rgba weight_colors[ASTC_LDR_MAX_RAW_WEIGHTS];
		uint32_t num_weights;

		assert((weight_ise_index <= astc_helpers::BISE_32_LEVELS) || (weight_ise_index == astc_helpers::BISE_64_LEVELS));
		
		// 64 levels isn't valid ASTC. It's used for raw weight mode.
		if (weight_ise_index == astc_helpers::BISE_64_LEVELS)
			num_weights = get_colors_raw_weights(cem_index, pEndpoint_vals, endpoint_ise_index, weight_colors, params.m_decode_mode_srgb);
		else
			num_weights = get_colors(cem_index, pEndpoint_vals, endpoint_ise_index, weight_ise_index, weight_colors, params.m_decode_mode_srgb);

		assert(num_weights <= std::size(weight_colors));

		uint64_t trial_err = eval_solution(
			pixel_stats,
			num_weights, weight_colors,
			pWeight_vals, weight_ise_index,
			params);

		return trial_err;
	}

	// Evaluates against raw weights [0,64], or to ISE quantized weights, depending on weight_ise_index.
	static uint64_t eval_solution_dp(
		uint32_t ccs_index,
		const pixel_stats_t& pixel_stats,
		uint32_t total_weights, const color_rgba* pWeight_colors,
		uint8_t* pWeight_vals0, uint8_t* pWeight_vals1, uint32_t weight_ise_index,
		const cem_encode_params& params)
	{
		BASISU_NOTE_UNUSED(weight_ise_index);

		assert(ccs_index <= 3);
		assert((total_weights <= 32) || (total_weights == 65));

		const bool all_one_weights = (params.m_comp_weights[0] == 1) && (params.m_comp_weights[1] == 1) && (params.m_comp_weights[2] == 1) && (params.m_comp_weights[3] == 1);

		bool exhaustive_flag = params.m_use_exhaustive_weight_eval;
		if (BASISU_FORCE_EXHAUSTIVE_EVAL)
			exhaustive_flag = true;
		else if (!all_one_weights)
			exhaustive_flag = true;

		uint64_t total_err = 0;

		if (params.m_pForced_weight_vals0)
		{
			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				const color_rgba& px = pixel_stats.m_pixels[c];

				const uint32_t w = params.m_pForced_weight_vals0[c];
				assert(w < total_weights);

				uint32_t err = 0;
				for (uint32_t o = 0; o < 4; o++)
					if (o != ccs_index)
						err += params.m_comp_weights[o] * square_of_diff(px[o], pWeight_colors[w][o]);

				total_err += err;

				pWeight_vals0[c] = (uint8_t)w;
			}
		}
		else if (exhaustive_flag)
		{
			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				const color_rgba& px = pixel_stats.m_pixels[c];

				uint32_t best_err = UINT32_MAX;
				uint32_t best_sel = 0;

				for (uint32_t i = 0; i < total_weights; i++)
				{
					uint32_t err = 0;
					for (uint32_t o = 0; o < 4; o++)
						if (o != ccs_index)
							err += params.m_comp_weights[o] * square_of_diff(px[o], pWeight_colors[i][o]);

					if (err < best_err)
					{
						best_err = err;
						best_sel = i;
					}
				}

				total_err += best_err;
				pWeight_vals0[c] = (uint8_t)best_sel;
			}
		}
		else
		{
			assert(all_one_weights);

			// low endpoint must be the first color (w=0)
			color_rgba e_l(pWeight_colors[0]);

			// high endpoint must be either the last color or the 2nd depending on the weight BISE range
			color_rgba e_h(pWeight_colors[1]);

			if ((total_weights == 65) || (g_ise_weight_lerps[weight_ise_index][total_weights] == 64))
				e_h = pWeight_colors[total_weights - 1];
			else
			{
				assert(g_ise_weight_lerps[weight_ise_index][1 + 1] == 64);
			}

			std::swap(e_l[ccs_index], e_l[3]);
			std::swap(e_h[ccs_index], e_h[3]);
			
			const int dr = e_h[0] - e_l[0], dg = e_h[1] - e_l[1], db = e_h[2] - e_l[2];
			
			const float f = 64.0f / (float)(basisu::squarei(dr) + basisu::squarei(dg) + basisu::squarei(db) + .00000125f);

			const int sofs = -(e_l[0] * dr + e_l[1] * dg + e_l[2] * db);
						
			const auto* pTab = (weight_ise_index <= astc_helpers::BISE_32_LEVELS) ? &astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_index).m_val_to_ise : nullptr;

			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				color_rgba px(pixel_stats.m_pixels[c]);
				std::swap(px[ccs_index], px[3]);

				int sel = (int)(float(px[0] * dr + px[1] * dg + px[2] * db + sofs) * f + .5f);

				if (sel < 0)
					sel = 0;
				else if (sel > 64)
					sel = 64;

				int best_sel = pTab ? (*pTab)[sel] : sel;

				assert(best_sel < (int)total_weights);

				color_rgba wc(pWeight_colors[best_sel]);
				std::swap(wc[ccs_index], wc[3]);

				total_err +=
					square_of_diff(px.r, wc.r) +
					square_of_diff(px.g, wc.g) +
					square_of_diff(px.b, wc.b);

				pWeight_vals0[c] = (uint8_t)best_sel;
			} // c
		}

		if (params.m_pForced_weight_vals1)
		{
			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				const color_rgba& px = pixel_stats.m_pixels[c];

				const uint32_t w = params.m_pForced_weight_vals1[c];
				assert(w < total_weights);

				uint32_t err = square_of_diff(px[ccs_index], pWeight_colors[w][ccs_index]);

				total_err += err * params.m_comp_weights[ccs_index];
				pWeight_vals1[c] = (uint8_t)w;
			}
		}
		else if (exhaustive_flag)
		{
			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				const color_rgba& px = pixel_stats.m_pixels[c];

				uint32_t best_err = UINT32_MAX;
				uint32_t best_sel = 0;

				for (uint32_t i = 0; i < total_weights; i++)
				{
					uint32_t err = square_of_diff(px[ccs_index], pWeight_colors[i][ccs_index]);

					if (err < best_err)
					{
						best_err = err;
						best_sel = i;
					}
				}

				total_err += best_err * params.m_comp_weights[ccs_index];
				pWeight_vals1[c] = (uint8_t)best_sel;
			}
		}
		else
		{
			assert(all_one_weights);

			// low endpoint must be the first color (w=0)
			color_rgba e_l(pWeight_colors[0]);

			// high endpoint must be either the last color or the 2nd depending on the weight BISE range
			color_rgba e_h(pWeight_colors[1]);

			if ((total_weights == 65) || (g_ise_weight_lerps[weight_ise_index][total_weights] == 64))
				e_h = pWeight_colors[total_weights - 1];
			else
			{
				assert(g_ise_weight_lerps[weight_ise_index][1 + 1] == 64);
			}

			const int la = e_l[ccs_index];
			const int ha = e_h[ccs_index];
			const int da = ha - la;

			const float f = 64.0f / (float)(da + .00000125f);
			
			const auto* pTab = (weight_ise_index <= astc_helpers::BISE_32_LEVELS) ? &astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_index).m_val_to_ise : nullptr;

			for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
			{
				const color_rgba &px = pixel_stats.m_pixels[c];

				const int pxa = px[ccs_index];
				
				int sel = (int)(float(pxa - la) * f + .5f);

				if (sel < 0)
					sel = 0;
				else if (sel > 64)
					sel = 64;

				int best_sel = pTab ? (*pTab)[sel] : sel;

				assert(best_sel < (int)total_weights);
								
				total_err += square_of_diff(pxa, pWeight_colors[best_sel][ccs_index]);

				pWeight_vals1[c] = (uint8_t)best_sel;
			} // c
		}

		return total_err;
	}

	// Evaluates against raw weights [0,64], or to ISE quantized weights, depending on weight_ise_index.
	uint64_t eval_solution_dp(
		const pixel_stats_t& pixel_stats,
		uint32_t cem_index, uint32_t ccs_index,
		const uint8_t* pEndpoint_vals, uint32_t endpoint_ise_index,
		uint8_t* pWeight_vals0, uint8_t* pWeight_vals1, uint32_t weight_ise_index,
		const cem_encode_params& params)
	{
		assert((weight_ise_index <= astc_helpers::BISE_32_LEVELS) || (weight_ise_index == astc_helpers::BISE_64_LEVELS));

		color_rgba weight_colors[ASTC_LDR_MAX_RAW_WEIGHTS];
		uint32_t num_weights;
		
		// 64 levels isn't valid ASTC. It's used for raw weight mode.
		if (weight_ise_index == astc_helpers::BISE_64_LEVELS)
			num_weights = get_colors_raw_weights(cem_index, pEndpoint_vals, endpoint_ise_index, weight_colors, params.m_decode_mode_srgb);
		else
			num_weights = get_colors(cem_index, pEndpoint_vals, endpoint_ise_index, weight_ise_index, weight_colors, params.m_decode_mode_srgb);

		uint64_t trial_err = eval_solution_dp(
			ccs_index,
			pixel_stats,
			num_weights, weight_colors,
			pWeight_vals0, pWeight_vals1, weight_ise_index,
			params);

		return trial_err;
	}

	// Direct - refine ISE quantized endpoints from float endpoints
	static void refine_cem8_or_12_endpoints(uint32_t cem_index, uint32_t endpoint_ise_range, uint8_t* pTrial_endpoint_vals, const vec4F& low_color_f, const vec4F& high_color_f, bool endpoints_are_swapped)
	{
		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT));

		if (endpoint_ise_range == astc_helpers::BISE_256_LEVELS)
			return;

		const uint32_t total_comps = (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT) ? 4 : 3;

		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));

		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t num_endpoint_ise_levels = astc_helpers::get_ise_levels(endpoint_ise_range);

		const auto& endpoint_dequant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_val;

		const auto& ISE_to_rank = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_rank;
		const auto& rank_to_ISE = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_rank_to_ISE;

		const bool orig_used_blue_contraction = astc_helpers::cem8_or_12_used_blue_contraction(cem_index, pTrial_endpoint_vals, endpoint_ise_range);

		uint32_t first_comp = 0;

		uint8_t refined_endpoint_vals[astc_helpers::NUM_MODE12_ENDPOINTS];
		memcpy(refined_endpoint_vals, pTrial_endpoint_vals, total_endpoint_vals);

		if (orig_used_blue_contraction)
		{
			// TODO expensive: 2*3*9 = 54 tries
			for (uint32_t e = 0; e < 2; e++)
			{
				float best_err = BIG_FLOAT_VAL;
				uint8_t best_refined_endpoint_vals[3] = { 0, 0, 0 };

				for (int b_delta = -1; b_delta <= 1; b_delta++)
				{
					for (int k = 0; k < 9; k++)
					{
						const int r_delta = (k % 3) - 1;
						const int g_delta = (k / 3) - 1;

						const int comp_deltas[3] = { r_delta, g_delta, b_delta };

						uint8_t trial_refined_endpoint_vals[3] = { 0, 0, 0 };

						for (uint32_t c = 0; c < 3; c++)
						{
							const int enc_val = pTrial_endpoint_vals[c * 2 + e];

							const int orig_rank = ISE_to_rank[enc_val];

							const int v_delta = comp_deltas[c];
							const int new_rank = basisu::clamp<int>(orig_rank + v_delta, 0, (int)num_endpoint_ise_levels - 1);
							const int new_enc_ise_val = rank_to_ISE[new_rank];

							trial_refined_endpoint_vals[c] = (uint8_t)new_enc_ise_val;

						} // c

						color_rgba trial_refined_endpoints_dequant(blue_contract_dec(endpoint_dequant_tab[trial_refined_endpoint_vals[0]], endpoint_dequant_tab[trial_refined_endpoint_vals[1]], endpoint_dequant_tab[trial_refined_endpoint_vals[2]], 255));

						vec3F trial_refined_endpoints_dequant_f(0.0f);
						for (uint32_t c = 0; c < 3; c++)
							trial_refined_endpoints_dequant_f[c] = (float)trial_refined_endpoints_dequant[c] * (1.0f / 255.0f);

						vec3F desired_endpoint;
						if (endpoints_are_swapped)
							desired_endpoint = (e == 0) ? vec3F(high_color_f) : vec3F(low_color_f);
						else
							desired_endpoint = (e == 0) ? vec3F(low_color_f) : vec3F(high_color_f);

						float trial_err = desired_endpoint.squared_distance(trial_refined_endpoints_dequant_f);
						if (trial_err < best_err)
						{
							best_err = trial_err;
							memcpy(best_refined_endpoint_vals, trial_refined_endpoint_vals, 3);
						}

					} // k

				} // b_delta

				for (uint32_t c = 0; c < 3; c++)
				{
					refined_endpoint_vals[c * 2 + e] = best_refined_endpoint_vals[c];
				} // c

			} // e

			// just refine A now (if it exists)
			first_comp = 3;
		}

		if (first_comp < total_comps)
		{
			for (uint32_t e = 0; e < 2; e++)
			{
				for (uint32_t c = first_comp; c < total_comps; c++)
				{
					const uint32_t idx = c * 2 + e;
					const int enc_val = pTrial_endpoint_vals[idx];

					const int orig_rank = ISE_to_rank[enc_val];

					int best_rank = orig_rank;
					float best_err = BIG_FLOAT_VAL;
					for (int v_delta = -1; v_delta <= 1; v_delta++)
					{
						int new_rank = basisu::clamp<int>(orig_rank + v_delta, 0, (int)num_endpoint_ise_levels - 1);
						int new_enc_ise_val = rank_to_ISE[new_rank];

						float dequant_val = (float)endpoint_dequant_tab[new_enc_ise_val] * (1.0f / 255.0f);

						float orig_val;
						if (endpoints_are_swapped)
							orig_val = (e == 0) ? high_color_f[c] : low_color_f[c];
						else
							orig_val = (e == 0) ? low_color_f[c] : high_color_f[c];

						float err = fabsf(dequant_val - orig_val);
						if (err < best_err)
						{
							best_err = err;
							best_rank = new_rank;
						}
					}

					refined_endpoint_vals[idx] = (uint8_t)rank_to_ISE[best_rank];

				} // c
			} // e
		}

		bool refined_used_blue_contraction = astc_helpers::cem8_or_12_used_blue_contraction(cem_index, refined_endpoint_vals, endpoint_ise_range);
		if (refined_used_blue_contraction == orig_used_blue_contraction)
		{
			memcpy(pTrial_endpoint_vals, refined_endpoint_vals, total_endpoint_vals);
		}
	}

	// Direct L/LA, single plane
	static bool try_cem0_or_4(uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		float lum_l, float lum_h, float a_l, float a_h,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals, uint64_t& trial_blk_error)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_LUM_DIRECT) || (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT));

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);

		const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);

		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE4_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		encode_cem0_4(cem_index, lum_l, lum_h, a_l, a_h, endpoint_ise_range, trial_endpoint_vals);

		uint64_t trial_err = eval_solution(
			pixel_stats,
			cem_index, trial_endpoint_vals, endpoint_ise_range,
			trial_weight_vals, weight_ise_range,
			enc_params);

		bool improved_flag = false;
		if (trial_err < trial_blk_error)
		{
			trial_blk_error = trial_err;
			memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
			memcpy(pTrial_weight_vals, trial_weight_vals, pixel_stats.m_num_pixels);
			improved_flag = true;
		}

		bool any_degen = false;
		if ((trial_endpoint_vals[0] == trial_endpoint_vals[1]) && (lum_l != lum_h))
			any_degen = true;

		if (cem_has_alpha)
		{
			if ((trial_endpoint_vals[2] == trial_endpoint_vals[3]) && (a_l != a_h))
				any_degen = true;
		}

		if (any_degen)
		{
			const int l_delta = (lum_l < lum_h) ? -1 : 1;
			const int a_delta = (a_l < a_h) ? -1 : 1;

			for (uint32_t t = 1; t <= 3; t++)
			{
				uint8_t fixed_endpoint_vals[astc_helpers::NUM_MODE4_ENDPOINTS];
				memcpy(fixed_endpoint_vals, trial_endpoint_vals, num_endpoint_vals);

				if (t & 1)
				{
					if ((trial_endpoint_vals[0] == trial_endpoint_vals[1]) && (lum_l != lum_h))
						fixed_endpoint_vals[0] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[0], l_delta);

					if (cem_has_alpha)
					{
						if ((trial_endpoint_vals[2] == trial_endpoint_vals[3]) && (a_l != a_h))
							fixed_endpoint_vals[2] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[2], a_delta);
					}
				}

				if (t & 2)
				{
					if ((trial_endpoint_vals[0] == trial_endpoint_vals[1]) && (lum_l != lum_h))
						fixed_endpoint_vals[1] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[1], -l_delta);

					if (cem_has_alpha)
					{
						if ((trial_endpoint_vals[2] == trial_endpoint_vals[3]) && (a_l != a_h))
							fixed_endpoint_vals[3] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[3], -a_delta);
					}
				}

				trial_err = eval_solution(
					pixel_stats,
					cem_index, fixed_endpoint_vals, endpoint_ise_range,
					trial_weight_vals, weight_ise_range,
					enc_params);

				if (trial_err < trial_blk_error)
				{
					trial_blk_error = trial_err;
					memcpy(pTrial_endpoint_vals, fixed_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
					memcpy(pTrial_weight_vals, trial_weight_vals, pixel_stats.m_num_pixels);
					improved_flag = true;
				}

			} // t
		}

		return improved_flag;
	}

	static bool try_cem4_dp_a(uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		float lum_l, float lum_h, float a_l, float a_h,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals0, uint8_t* pTrial_weight_vals1, uint64_t& trial_blk_error)
	{
		assert(g_initialized);
		assert(cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);

		const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);

		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE4_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals0[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t trial_weight_vals1[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		encode_cem0_4(cem_index, lum_l, lum_h, a_l, a_h, endpoint_ise_range, trial_endpoint_vals);

		uint64_t trial_err = eval_solution_dp(
			pixel_stats, cem_index, 3,
			trial_endpoint_vals, endpoint_ise_range,
			trial_weight_vals0, trial_weight_vals1, weight_ise_range,
			enc_params);

		bool improved_flag = false;
		if (trial_err < trial_blk_error)
		{
			trial_blk_error = trial_err;
			memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
			memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
			memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
			improved_flag = true;
		}

		bool any_degen = false;
		if ((trial_endpoint_vals[0] == trial_endpoint_vals[1]) && (lum_l != lum_h))
			any_degen = true;

		if (cem_has_alpha)
		{
			if ((trial_endpoint_vals[2] == trial_endpoint_vals[3]) && (a_l != a_h))
				any_degen = true;
		}

		if (any_degen)
		{
			const int l_delta = (lum_l < lum_h) ? -1 : 1;
			const int a_delta = (a_l < a_h) ? -1 : 1;

			for (uint32_t t = 1; t <= 3; t++)
			{
				uint8_t fixed_endpoint_vals[astc_helpers::NUM_MODE4_ENDPOINTS];
				memcpy(fixed_endpoint_vals, trial_endpoint_vals, num_endpoint_vals);

				if (t & 1)
				{
					if ((trial_endpoint_vals[0] == trial_endpoint_vals[1]) && (lum_l != lum_h))
						fixed_endpoint_vals[0] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[0], l_delta);

					if (cem_has_alpha)
					{
						if ((trial_endpoint_vals[2] == trial_endpoint_vals[3]) && (a_l != a_h))
							fixed_endpoint_vals[2] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[2], a_delta);
					}
				}

				if (t & 2)
				{
					if ((trial_endpoint_vals[0] == trial_endpoint_vals[1]) && (lum_l != lum_h))
						fixed_endpoint_vals[1] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[1], -l_delta);

					if (cem_has_alpha)
					{
						if ((trial_endpoint_vals[2] == trial_endpoint_vals[3]) && (a_l != a_h))
							fixed_endpoint_vals[3] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[3], -a_delta);
					}
				}

				trial_err = eval_solution_dp(
					pixel_stats, cem_index, 3,
					fixed_endpoint_vals, endpoint_ise_range,
					trial_weight_vals0, trial_weight_vals1, weight_ise_range,
					enc_params);

				if (trial_err < trial_blk_error)
				{
					trial_blk_error = trial_err;
					memcpy(pTrial_endpoint_vals, fixed_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
					memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
					memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
					improved_flag = true;
				}

			} // t
		}

		return improved_flag;
	}

	// Direct RGB/RGBA
	// Cannot fail, but may have to fall back to non-blue-contracted
	// Returns false if trial solution not improved
	static bool try_cem8_12(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		const vec4F& low_color_f, const vec4F& high_color_f,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals, uint64_t& trial_blk_error, bool& trial_used_blue_contraction,
		bool try_blue_contract, bool& tried_used_blue_contraction)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT));

		const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t num_comps = (cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) ? 3 : 4;

		color_rgba low_color, high_color;
		for (uint32_t c = 0; c < 4; c++)
		{
			low_color[c] = (uint8_t)basisu::clamp<int>((int)std::round(low_color_f[c] * 255.0f), 0, 255);
			high_color[c] = (uint8_t)basisu::clamp<int>((int)std::round(high_color_f[c] * 255.0f), 0, 255);
		}

		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE12_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		// Cannot fail, but may have to fall back to non-blue-contracted
		cem_encode_ldr_rgb_or_rgba_direct_result res = cem_encode_ldr_rgb_or_rgba_direct(cem_index, endpoint_ise_range, low_color, high_color, trial_endpoint_vals, try_blue_contract);

		// Let caller know if we tried blue contraction
		tried_used_blue_contraction = res.m_is_blue_contracted;

		if (endpoint_ise_range < astc_helpers::BISE_256_LEVELS)
		{
			refine_cem8_or_12_endpoints(cem_index, endpoint_ise_range, trial_endpoint_vals, low_color_f, high_color_f, res.m_endpoints_are_swapped);
		}

		uint64_t trial_err = eval_solution(
			pixel_stats, cem_index, 
			trial_endpoint_vals, endpoint_ise_range, 
			trial_weight_vals, weight_ise_range,
			enc_params);

		bool improved_flag = false;
		if (trial_err < trial_blk_error)
		{
			trial_blk_error = trial_err;
			memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
			memcpy(pTrial_weight_vals, trial_weight_vals, pixel_stats.m_num_pixels);
			trial_used_blue_contraction = res.m_is_blue_contracted;
			improved_flag = true;
		}

		if (res.m_any_degen)
		{
			color_rgba dec_l(0), dec_h(0);
			decode_endpoints(cem_index, trial_endpoint_vals, endpoint_ise_range, dec_l, dec_h);

			uint32_t s0 = dec_l.r + dec_l.g + dec_l.b + dec_l.a;
			uint32_t s1 = dec_h.r + dec_h.g + dec_h.b + dec_h.a;
			if (astc_helpers::cem8_or_12_used_blue_contraction(cem_index, trial_endpoint_vals, endpoint_ise_range))
				std::swap(s0, s1);

			for (uint32_t t = 1; t <= 3; t++)
			{
				uint8_t fixed_endpoint_vals[astc_helpers::NUM_MODE12_ENDPOINTS];
				memcpy(fixed_endpoint_vals, trial_endpoint_vals, num_endpoint_vals);

				if (t & 1)
				{
					for (uint32_t c = 0; c < num_comps; c++)
					{
						uint32_t l_idx = c * 2 + 0;
						uint32_t h_idx = c * 2 + 1;

						if ((trial_endpoint_vals[l_idx] == trial_endpoint_vals[h_idx]) && (low_color[c] != high_color[c]))
						{
							int delta = (s0 <= s1) ? -1 : 1;

							fixed_endpoint_vals[l_idx] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[l_idx], delta);
						}
					}
				}

				if (t & 2)
				{
					for (uint32_t c = 0; c < num_comps; c++)
					{
						uint32_t l_idx = c * 2 + 0;
						uint32_t h_idx = c * 2 + 1;

						if ((trial_endpoint_vals[l_idx] == trial_endpoint_vals[h_idx]) && (low_color[c] != high_color[c]))
						{
							int delta = (s0 <= s1) ? 1 : -1;

							fixed_endpoint_vals[h_idx] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[h_idx], delta);
						}
					}
				}

				bool fixed_used_blue_contraction = astc_helpers::cem8_or_12_used_blue_contraction(cem_index, fixed_endpoint_vals, endpoint_ise_range);
				if (fixed_used_blue_contraction != res.m_is_blue_contracted)
					continue;
								
				trial_err = eval_solution(
					pixel_stats,
					cem_index, fixed_endpoint_vals, endpoint_ise_range,
					trial_weight_vals, weight_ise_range,
					enc_params);

				if (trial_err < trial_blk_error)
				{
					trial_blk_error = trial_err;
					memcpy(pTrial_endpoint_vals, fixed_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
					memcpy(pTrial_weight_vals, trial_weight_vals, pixel_stats.m_num_pixels);
					trial_used_blue_contraction = res.m_is_blue_contracted;
					improved_flag = true;
				}

			} // t

		} // if (res.m_any_degen)

		return improved_flag;
	}

	static bool try_cem8_12_dp(
		uint32_t cem_index, uint32_t ccs_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		const vec4F& low_color_f, const vec4F& high_color_f,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals0, uint8_t* pTrial_weight_vals1, uint64_t& trial_blk_error, bool& trial_used_blue_contraction,
		bool try_blue_contract, bool& tried_used_blue_contraction)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT));

		bool improved_flag = false;

		const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t num_comps = (cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) ? 3 : 4;

		color_rgba low_color, high_color;
		for (uint32_t c = 0; c < 4; c++)
		{
			low_color[c] = (uint8_t)basisu::clamp<int>((int)std::round(low_color_f[c] * 255.0f), 0, 255);
			high_color[c] = (uint8_t)basisu::clamp<int>((int)std::round(high_color_f[c] * 255.0f), 0, 255);
		}

		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE12_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals0[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t trial_weight_vals1[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		// Cannot fail, but may have to fall back to non-blue-contracted
		cem_encode_ldr_rgb_or_rgba_direct_result res = cem_encode_ldr_rgb_or_rgba_direct(cem_index, endpoint_ise_range, low_color, high_color, trial_endpoint_vals, try_blue_contract);

		// Let caller know if we tried blue contraction
		tried_used_blue_contraction = res.m_is_blue_contracted;

		if (endpoint_ise_range < astc_helpers::BISE_256_LEVELS)
		{
			refine_cem8_or_12_endpoints(cem_index, endpoint_ise_range, trial_endpoint_vals, low_color_f, high_color_f, res.m_endpoints_are_swapped);
		}

		uint64_t trial_err = eval_solution_dp(pixel_stats, cem_index, ccs_index, trial_endpoint_vals, endpoint_ise_range, trial_weight_vals0, trial_weight_vals1, weight_ise_range, enc_params);

		if (trial_err < trial_blk_error)
		{
			trial_blk_error = trial_err;
			memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
			memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
			memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
			trial_used_blue_contraction = res.m_is_blue_contracted;
			improved_flag = true;
		}

		if (res.m_any_degen)
		{
			color_rgba dec_l(0), dec_h(0);
			decode_endpoints(cem_index, trial_endpoint_vals, endpoint_ise_range, dec_l, dec_h);

			uint32_t s0 = dec_l.r + dec_l.g + dec_l.b + dec_l.a;
			uint32_t s1 = dec_h.r + dec_h.g + dec_h.b + dec_h.a;
			if (astc_helpers::cem8_or_12_used_blue_contraction(cem_index, trial_endpoint_vals, endpoint_ise_range))
				std::swap(s0, s1);

			for (uint32_t t = 1; t <= 3; t++)
			{
				uint8_t fixed_endpoint_vals[astc_helpers::NUM_MODE12_ENDPOINTS];
				memcpy(fixed_endpoint_vals, trial_endpoint_vals, num_endpoint_vals);

				if (t & 1)
				{
					for (uint32_t c = 0; c < num_comps; c++)
					{
						uint32_t l_idx = c * 2 + 0;
						uint32_t h_idx = c * 2 + 1;

						if ((trial_endpoint_vals[l_idx] == trial_endpoint_vals[h_idx]) && (low_color[c] != high_color[c]))
						{
							int delta = (s0 <= s1) ? -1 : 1;

							fixed_endpoint_vals[l_idx] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[l_idx], delta);
						}
					}
				}

				if (t & 2)
				{
					for (uint32_t c = 0; c < num_comps; c++)
					{
						uint32_t l_idx = c * 2 + 0;
						uint32_t h_idx = c * 2 + 1;

						if ((trial_endpoint_vals[l_idx] == trial_endpoint_vals[h_idx]) && (low_color[c] != high_color[c]))
						{
							int delta = (s0 <= s1) ? 1 : -1;

							fixed_endpoint_vals[h_idx] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_endpoint_vals[h_idx], delta);
						}
					}
				}

				bool fixed_used_blue_contraction = astc_helpers::cem8_or_12_used_blue_contraction(cem_index, fixed_endpoint_vals, endpoint_ise_range);
				if (fixed_used_blue_contraction != res.m_is_blue_contracted)
					continue;

				trial_err = eval_solution_dp(pixel_stats, cem_index, ccs_index, fixed_endpoint_vals, endpoint_ise_range, trial_weight_vals0, trial_weight_vals1, weight_ise_range, enc_params);

				if (trial_err < trial_blk_error)
				{
					trial_blk_error = trial_err;
					memcpy(pTrial_endpoint_vals, fixed_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
					memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
					memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
					improved_flag = true;
				}

			} // t

		} // if (res.m_any_degen)

		return improved_flag;
	}

	static uint32_t compute_endpoint_distance(
		const color_rgba &low_color1, const color_rgba &high_color1,
		const color_rgba &low_color2, const color_rgba &high_color2)
	{
		uint32_t ll = color_distance(low_color2, low_color1, true);
		uint32_t lh = color_distance(low_color2, high_color1, true);

		uint32_t hl = color_distance(high_color2, low_color1, true);
		uint32_t hh = color_distance(high_color2, high_color1, true);

		uint32_t d0 = ll + hh;
		uint32_t d1 = lh + hl;

		return minimum(d0, d1);
	}

	// true if the direct encoding would be better vs. the current base+ofs encodiing
	static bool compare_base_ofs_vs_direct_encoding(
		uint32_t cem_index, 
		const uint8_t *pTrial_endpoint_vals, uint32_t endpoint_ise_range,
		const color_rgba &low_color, const color_rgba &high_color, 
		bool try_blue_contract)
	{
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) || (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET));

		color_rgba base_ofs_l, base_ofs_h;
		decode_endpoints(cem_index, pTrial_endpoint_vals, endpoint_ise_range, base_ofs_l, base_ofs_h);

		const uint32_t baseofs_best_d = compute_endpoint_distance(base_ofs_l, base_ofs_h, low_color, high_color);
		if (!baseofs_best_d)
			return false;

		uint8_t direct_endpoint_vals[astc_helpers::NUM_MODE12_ENDPOINTS] = { 0 };

		const uint32_t direct_cem_index = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) ? astc_helpers::CEM_LDR_RGB_DIRECT : astc_helpers::CEM_LDR_RGBA_DIRECT;

		cem_encode_ldr_rgb_or_rgba_direct_result direct_res = cem_encode_ldr_rgb_or_rgba_direct(direct_cem_index, endpoint_ise_range, low_color, high_color, direct_endpoint_vals, try_blue_contract);
		BASISU_NOTE_UNUSED(direct_res); // call populates direct_endpoint_vals (used below); its returned struct is unused - silence -Wunused-variable

		color_rgba direct_l, direct_h;
		decode_endpoints(direct_cem_index, direct_endpoint_vals, endpoint_ise_range, direct_l, direct_h);

		const uint32_t direct_best_d = compute_endpoint_distance(direct_l, direct_h, low_color, high_color);

		return direct_best_d < baseofs_best_d;
	}

	// base+offset rgb/rgba, single or dual plane
	static bool try_cem9_13_sp_or_dp(
		uint32_t cem_index, int ccs_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		const vec4F& low_color_f, const vec4F& high_color_f,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals0, uint8_t* pTrial_weight_vals1, uint64_t& trial_blk_error, bool& trial_used_blue_contraction,
		bool try_blue_contract, bool& tried_used_blue_contraction, 
		bool &try_direct_encoding_flag) // try_direct_encoding_flag is now a flag that indicates the base_ofs encoding clamped OR if the rgb(a) direct encoding may be better to try
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) || (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET));
		assert((ccs_index >= -1) && (ccs_index <= 3));
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		assert(pTrial_weight_vals0);
		assert((ccs_index == -1) || (pTrial_weight_vals1));
				
		//const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t num_comps = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) ? 3 : 4;

		color_rgba low_color, high_color;
		for (uint32_t c = 0; c < 4; c++)
		{
			low_color[c] = (uint8_t)basisu::clamp<int>((int)std::round(low_color_f[c] * 255.0f), 0, 255);
			high_color[c] = (uint8_t)basisu::clamp<int>((int)std::round(high_color_f[c] * 255.0f), 0, 255);
		}

		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE13_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals0[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t trial_weight_vals1[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		rgb_base_offset_res res = cem_encode_ldr_rgb_or_rgba_base_offset(cem_index, endpoint_ise_range, low_color, high_color, trial_endpoint_vals, try_blue_contract);

		tried_used_blue_contraction = res.m_used_blue_contraction;
		try_direct_encoding_flag = res.m_delta_clamped;

		if (res.m_failed_flag)
			return false;

		if (!try_direct_encoding_flag)
		{
			if (compare_base_ofs_vs_direct_encoding(cem_index, trial_endpoint_vals, endpoint_ise_range, low_color, high_color, try_blue_contract))
			{
				try_direct_encoding_flag = true;
			}
		}

		bool improved_flag = false;

		if (ccs_index == -1)
		{
			uint64_t trial_err = eval_solution(
				pixel_stats,
				cem_index, trial_endpoint_vals, endpoint_ise_range,
				trial_weight_vals0, weight_ise_range,
				enc_params);

			if (trial_err < trial_blk_error)
			{
				trial_blk_error = trial_err;
				memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
				memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
				if (pTrial_weight_vals1)
					memset(pTrial_weight_vals1, 0, pixel_stats.m_num_pixels);
				trial_used_blue_contraction = res.m_used_blue_contraction;
				improved_flag = true;
			}
		}
		else
		{
			uint64_t trial_err = eval_solution_dp(
				pixel_stats,
				cem_index, ccs_index, trial_endpoint_vals, endpoint_ise_range,
				trial_weight_vals0, trial_weight_vals1, weight_ise_range,
				enc_params);

			if (trial_err < trial_blk_error)
			{
				trial_blk_error = trial_err;
				memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
				memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
				memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
				trial_used_blue_contraction = res.m_used_blue_contraction;
				improved_flag = true;
			}
		}

		if (res.m_any_degen)
		{
			color_rgba dec_l(0), dec_h(0);
			decode_endpoints(cem_index, trial_endpoint_vals, endpoint_ise_range, dec_l, dec_h);

			// The packing in these modes is so complex that we're going to approximate the biasing, and hope for the best.
			const uint32_t num_ise_levels = astc_helpers::get_ise_levels(endpoint_ise_range);
			int vals_per_ise_level = (256 + num_ise_levels - 1) / num_ise_levels;

			// TODO: There is potential cross-talk between RGB and A with the way this is done.
			for (uint32_t p = 1; p <= 3; p++)
			{
				color_rgba trial_low_color(low_color), trial_high_color(high_color);

				for (uint32_t c = 0; c < num_comps; c++)
				{
					if (low_color[c] == high_color[c])
						continue;

					if (dec_l[c] != dec_h[c])
						continue;

					int delta = (low_color[c] < high_color[c]) ? -1 : 1;
					if (p & 1)
						trial_low_color[c] = (uint8_t)basisu::clamp<int>((int)trial_low_color[c] + vals_per_ise_level * delta, 0, 255);

					if (p & 2)
						trial_high_color[c] = (uint8_t)basisu::clamp<int>((int)trial_high_color[c] + vals_per_ise_level * -delta, 0, 255);
				} // c

				res = cem_encode_ldr_rgb_or_rgba_base_offset(cem_index, endpoint_ise_range, trial_low_color, trial_high_color, trial_endpoint_vals, try_blue_contract);

				if (res.m_failed_flag)
					continue;
																
				if (ccs_index == -1)
				{
					uint64_t trial_err = eval_solution(
						pixel_stats,
						cem_index, trial_endpoint_vals, endpoint_ise_range,
						trial_weight_vals0, weight_ise_range,
						enc_params);

					if (trial_err < trial_blk_error)
					{
						trial_blk_error = trial_err;
						memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
						memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
						if (pTrial_weight_vals1)
							memset(pTrial_weight_vals1, 0, pixel_stats.m_num_pixels);
						trial_used_blue_contraction = res.m_used_blue_contraction;
						if (res.m_delta_clamped)
							try_direct_encoding_flag = true;
						improved_flag = true;

						if (!try_direct_encoding_flag)
						{
							if (compare_base_ofs_vs_direct_encoding(cem_index, trial_endpoint_vals, endpoint_ise_range, low_color, high_color, try_blue_contract))
							{
								try_direct_encoding_flag = true;
							}
						}
					}
				}
				else
				{
					uint64_t trial_err = eval_solution_dp(
						pixel_stats,
						cem_index, ccs_index, trial_endpoint_vals, endpoint_ise_range,
						trial_weight_vals0, trial_weight_vals1, weight_ise_range,
						enc_params);

					if (trial_err < trial_blk_error)
					{
						trial_blk_error = trial_err;
						memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
						memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
						memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
						trial_used_blue_contraction = res.m_used_blue_contraction;
						if (res.m_delta_clamped)
							try_direct_encoding_flag = true;
						improved_flag = true;

						if (!try_direct_encoding_flag)
						{
							if (compare_base_ofs_vs_direct_encoding(cem_index, trial_endpoint_vals, endpoint_ise_range, low_color, high_color, try_blue_contract))
							{
								try_direct_encoding_flag = true;
							}
						}
					}
				}

			} // p
		}
		else
		{
			// Now factor in the quantization introduced into the low (base) color, and apply this to the offset, for gain.
			color_rgba dec_l(0), dec_h(0);
			decode_endpoints(cem_index, trial_endpoint_vals, endpoint_ise_range, dec_l, dec_h);

			if (res.m_endpoints_swapped)
				dec_l = low_color;	// high color is the quantized base
			else
				dec_h = high_color; // low color is the quantized base

			res = cem_encode_ldr_rgb_or_rgba_base_offset(cem_index, endpoint_ise_range, dec_l, dec_h, trial_endpoint_vals, try_blue_contract);

			if (!res.m_failed_flag)
			{
				if (ccs_index == -1)
				{
					uint64_t trial_err = eval_solution(
						pixel_stats,
						cem_index, trial_endpoint_vals, endpoint_ise_range,
						trial_weight_vals0, weight_ise_range,
						enc_params);

					if (trial_err < trial_blk_error)
					{
						trial_blk_error = trial_err;
						memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
						memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
						if (pTrial_weight_vals1)
							memset(pTrial_weight_vals1, 0, pixel_stats.m_num_pixels);
						trial_used_blue_contraction = res.m_used_blue_contraction;
						if (res.m_delta_clamped)
							try_direct_encoding_flag = true;
						improved_flag = true;

						if (!try_direct_encoding_flag)
						{
							if (compare_base_ofs_vs_direct_encoding(cem_index, trial_endpoint_vals, endpoint_ise_range, low_color, high_color, try_blue_contract))
							{
								try_direct_encoding_flag = true;
							}
						}
					}
				}
				else
				{
					uint64_t trial_err = eval_solution_dp(
						pixel_stats,
						cem_index, ccs_index, trial_endpoint_vals, endpoint_ise_range,
						trial_weight_vals0, trial_weight_vals1, weight_ise_range,
						enc_params);

					if (trial_err < trial_blk_error)
					{
						trial_blk_error = trial_err;
						memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
						memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
						memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
						trial_used_blue_contraction = res.m_used_blue_contraction;
						if (res.m_delta_clamped)
							try_direct_encoding_flag = true;
						improved_flag = true;

						if (!try_direct_encoding_flag)
						{
							if (compare_base_ofs_vs_direct_encoding(cem_index, trial_endpoint_vals, endpoint_ise_range, low_color, high_color, try_blue_contract))
							{
								try_direct_encoding_flag = true;
							}
						}
					}
				}
			}
		}
				
		return improved_flag;
	}

	// l/la direct, single plane
	static uint64_t encode_cem0_4(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals, uint64_t cur_blk_error)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_LUM_DIRECT) || (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT));
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);

		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t total_weights = pixel_stats.m_num_pixels;

		float lum_l = BIG_FLOAT_VAL, lum_h = -BIG_FLOAT_VAL;

		float pixel1F[ASTC_LDR_MAX_BLOCK_PIXELS];
		vec2F pixel2F[ASTC_LDR_MAX_BLOCK_PIXELS];

		for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
		{
			const vec4F& px = pixel_stats.m_pixels_f[i];

			float l = (px[0] + px[1] + px[2]) * (1.0f / 3.0f);

			pixel1F[i] = l;

			pixel2F[i][0] = l;
			pixel2F[i][1] = px[3];

			lum_l = minimum(lum_l, l);
			lum_h = maximum(lum_h, l);
		}

		const float a_l = pixel_stats.m_min_f[3];
		const float a_h = pixel_stats.m_max_f[3];

		const vec2F min_pixel2F(lum_l, a_l), max_pixel2F(lum_h, a_h);

		uint8_t trial_blk_endpoints[astc_helpers::MAX_CEM_ENDPOINT_VALS] = { 0 };
		uint8_t trial_blk_weights[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint64_t trial_blk_error = UINT64_MAX;

		bool did_improve = try_cem0_or_4(
			cem_index, pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			lum_l, lum_h, a_l, a_h,
			trial_blk_endpoints, trial_blk_weights, trial_blk_error);
		BASISU_NOTE_UNUSED(did_improve);

		if (trial_blk_error == UINT64_MAX)
			return cur_blk_error;

		if (trial_blk_error < cur_blk_error)
		{
			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals, trial_blk_weights, total_weights);
		}

		const uint32_t NUM_LS_OPT_PASSES = 3;

		for (uint32_t pass = 0; pass < NUM_LS_OPT_PASSES; pass++)
		{
			vec2F xl(lum_l, a_l), xh(lum_h, a_h);

			bool ls_res;
			if (cem_has_alpha)
			{
				ls_res = compute_least_squares_endpoints_2D(
					pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
					&xl, &xh, pixel2F, min_pixel2F, max_pixel2F);

			}
			else
			{
				ls_res = compute_least_squares_endpoints_1D(
					pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
					&xl[0], &xh[0], pixel1F, lum_l, lum_h);
			}
			if (!ls_res)
				break;

			bool did_improve_res = false;

			did_improve_res = try_cem0_or_4(
				cem_index, pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				xl[0], xh[0], xl[1], xh[1],
				trial_blk_endpoints, trial_blk_weights, trial_blk_error);

			BASISU_NOTE_UNUSED(did_improve_res);

			if (trial_blk_error >= cur_blk_error)
				break;

			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals, trial_blk_weights, total_weights);

		} // pass

		return cur_blk_error;
	}

	// lum+alpha direct, dual plane
	static uint64_t encode_cem4_dp_a(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals0, uint8_t* pWeight_vals1, uint64_t cur_blk_error)
	{
		assert(g_initialized);
		assert(cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t total_weights = pixel_stats.m_num_pixels;

		float alpha_vals[ASTC_LDR_MAX_BLOCK_PIXELS];

		for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
		{
			const vec4F& px = pixel_stats.m_pixels_f[i];

			alpha_vals[i] = px[3];
		}

		// First get plane0's low/high (lum)
		uint8_t lum_endpoints[astc_helpers::MAX_CEM_ENDPOINT_VALS];
		uint8_t lum_weights0[ASTC_LDR_MAX_BLOCK_PIXELS];

		uint64_t lum_blk_error = encode_cem0_4(
			astc_helpers::CEM_LDR_LUM_DIRECT,
			pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			lum_endpoints, lum_weights0, UINT64_MAX);

		if (lum_blk_error == UINT64_MAX)
			return cur_blk_error;

		const auto& dequant_endpoints_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_ISE_to_val;

		float lum_l = (float)dequant_endpoints_tab[lum_endpoints[0]] * (1.0f / 255.0f);
		float lum_h = (float)dequant_endpoints_tab[lum_endpoints[1]] * (1.0f / 255.0f);
		float a_l = pixel_stats.m_min_f[3];
		float a_h = pixel_stats.m_max_f[3];

		uint8_t trial_endpoints[astc_helpers::MAX_CEM_ENDPOINT_VALS];
		uint8_t trial_weights0[ASTC_LDR_MAX_BLOCK_PIXELS];
		uint8_t trial_weights1[ASTC_LDR_MAX_BLOCK_PIXELS];
		uint64_t trial_blk_error = UINT64_MAX;

		bool did_improve = try_cem4_dp_a(
			cem_index, pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			lum_l, lum_h, a_l, a_h,
			trial_endpoints, trial_weights0, trial_weights1, trial_blk_error);

		if (!did_improve)
		{
			assert(0);
			return cur_blk_error;
		}

		if (trial_blk_error < cur_blk_error)
		{
			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals0, trial_weights0, total_weights);
			memcpy(pWeight_vals1, trial_weights1, total_weights);
		}

		const uint32_t NUM_LS_OPT_PASSES = 3;

		for (uint32_t pass = 0; pass < NUM_LS_OPT_PASSES; pass++)
		{
			float xl = pixel_stats.m_min_f[3], xh = pixel_stats.m_max_f[3];

			bool ls_res = compute_least_squares_endpoints_1D(
				pixel_stats.m_num_pixels, trial_weights1, get_ls_weights_ise(weight_ise_range),
				&xl, &xh, alpha_vals, pixel_stats.m_min_f[3], pixel_stats.m_max_f[3]);
			if (!ls_res)
				break;

			did_improve = try_cem4_dp_a(
				cem_index, pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				lum_l, lum_h, xl, xh,
				trial_endpoints, trial_weights0, trial_weights1, trial_blk_error);

			if (!did_improve)
				break;

			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals0, trial_weights0, total_weights);
			memcpy(pWeight_vals1, trial_weights1, total_weights);

		} // pass

		return cur_blk_error;
	}
		
	struct weight_refiner
	{
		void init(uint32_t weight_ise_range, uint32_t total_pixels, const uint8_t *pInitial_ise_weights)
		{
			m_weight_ise_range = weight_ise_range;
			m_total_pixels = total_pixels;
			m_pISE_to_rank = &astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_range).m_ISE_to_rank;
			m_pRank_to_ise = &astc_helpers::g_dequant_tables.get_weight_tab(weight_ise_range).m_rank_to_ISE;
			m_num_weight_levels = astc_helpers::get_ise_levels(weight_ise_range);
						
			for (uint32_t i = 0; i < total_pixels; i++)
				m_start_weights[i] = (*m_pISE_to_rank)[pInitial_ise_weights[i]];

			m_min_weight = UINT32_MAX;
			m_max_weight = 0;
			m_sum_weight = 0;

			for (uint32_t i = 0; i < total_pixels; i++)
			{
				const uint32_t weight = m_start_weights[i];
				m_sum_weight += weight;
				m_min_weight = minimumu(m_min_weight, weight);
				m_max_weight = maximumu(m_max_weight, weight);
			}
		}

		void refine(uint32_t pass_index, uint8_t* pTrial_ise_weights)
		{
			switch (pass_index)
			{
			case 0:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if ((v == m_min_weight) && (v < (m_num_weight_levels - 1)))
						v++;

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 1:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if ((v == m_max_weight) && (v > 0))
						v--;

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 2:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if ((v == m_min_weight) && (v < (m_num_weight_levels - 1)))
						v++;
					else if ((v == m_max_weight) && (v > 0))
						v--;

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 3:
			{
				const int max_weight_rank_index = m_num_weight_levels - 1;
				int ly = -1, hy = max_weight_rank_index + 1;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int s = (int)clampf(floor((float)max_weight_rank_index * ((float)m_start_weights[i] - (float)ly) / ((float)hy - (float)ly) + .5f), 0, (float)max_weight_rank_index);
					pTrial_ise_weights[i] = (*m_pRank_to_ise)[s];
				}

				break;
			}
			case 4:
			{
				const int max_weight_rank_index = m_num_weight_levels - 1;
				int ly = -2, hy = max_weight_rank_index + 2;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int s = (int)clampf(floor((float)max_weight_rank_index * ((float)m_start_weights[i] - (float)ly) / ((float)hy - (float)ly) + .5f), 0, (float)max_weight_rank_index);
					pTrial_ise_weights[i] = (*m_pRank_to_ise)[s];
				}

				break;
			}
			case 5:
			{
				const int max_weight_rank_index = m_num_weight_levels - 1;
				int ly = -1, hy = max_weight_rank_index + 2;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int s = (int)clampf(floor((float)max_weight_rank_index * ((float)m_start_weights[i] - (float)ly) / ((float)hy - (float)ly) + .5f), 0, (float)max_weight_rank_index);
					pTrial_ise_weights[i] = (*m_pRank_to_ise)[s];
				}

				break;
			}
			case 6:
			{
				const int max_weight_rank_index = m_num_weight_levels - 1;
				int ly = -2, hy = max_weight_rank_index + 1;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int s = (int)clampf(floor((float)max_weight_rank_index * ((float)m_start_weights[i] - (float)ly) / ((float)hy - (float)ly) + .5f), 0, (float)max_weight_rank_index);
					pTrial_ise_weights[i] = (*m_pRank_to_ise)[s];
				}

				break;
			}
			case 7:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if ((v == m_min_weight) && (v < (m_num_weight_levels - 1)))
					{
						v++;
						if (v < (m_num_weight_levels - 1))
							v++;
					}

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;

				break;
			}
			case 8:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if ((v == m_max_weight) && (v > 0))
					{
						v--;
						if (v > 0)
							v--;
					}

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 9:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if ((v == m_min_weight) && (v < (m_num_weight_levels - 1)))
					{
						v++;
						if (v < (m_num_weight_levels - 1))
							v++;
					}
					else if ((v == m_max_weight) && (v > 0))
					{
						v--;
						if (v > 0)
							v--;
					}

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 10:
			{
				float mid_weight = (float)m_sum_weight / (float)m_total_pixels;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int v = m_start_weights[i];

					float fv = ((float)v - mid_weight) * .8f + ((float)m_num_weight_levels * .5f);

					v = clamp<int>((int)std::round(fv), 0, m_num_weight_levels - 1);

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 11:
			{
				float mid_weight = (float)m_sum_weight / (float)m_total_pixels;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int v = m_start_weights[i];

					float fv = ((float)v - mid_weight) * .9f + ((float)m_num_weight_levels * .5f);

					v = clamp<int>((int)std::round(fv), 0, m_num_weight_levels - 1);

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 12:
			{
				float mid_weight = (float)m_sum_weight / (float)m_total_pixels;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int v = m_start_weights[i];

					float fv = ((float)v - mid_weight) * 1.1f + ((float)m_num_weight_levels * .5f);

					v = clamp<int>((int)std::round(fv), 0, m_num_weight_levels - 1);

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 13:
			{
				float mid_weight = (float)m_sum_weight / (float)m_total_pixels;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int v = m_start_weights[i];

					float fv;
					if (v < mid_weight)
						fv = ((float)v - mid_weight) * .8f + ((float)m_num_weight_levels * .5f);
					else
						fv = (float)v;

					v = clamp<int>((int)std::round(fv), 0, m_num_weight_levels - 1);

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 14:
			{
				float mid_weight = (float)m_sum_weight / (float)m_total_pixels;

				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					int v = m_start_weights[i];

					float fv;
					if (v >= mid_weight)
						fv = ((float)v - mid_weight) * .8f + ((float)m_num_weight_levels * .5f);
					else
						fv = (float)v;

					v = clamp<int>((int)std::round(fv), 0, m_num_weight_levels - 1);

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 15:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if (v < (m_num_weight_levels - 1))
						v++;

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			case 16:
			{
				for (uint32_t i = 0; i < m_total_pixels; i++)
				{
					uint32_t v = m_start_weights[i];
					if (v)
						v--;

					pTrial_ise_weights[i] = (*m_pRank_to_ise)[v];
				}
				break;
			}
			default:
			{
				assert(0);
				memset(pTrial_ise_weights, 0, m_total_pixels);
				break;
			}
			}
		}

		uint32_t m_total_pixels;
		uint32_t m_weight_ise_range;
		uint32_t m_num_weight_levels;
		uint8_t m_start_weights[ASTC_LDR_MAX_BLOCK_PIXELS]; // ranks, not ISE

		uint32_t m_min_weight, m_max_weight, m_sum_weight;

		const basisu::vector<uint8_t>* m_pISE_to_rank;
		const basisu::vector<uint8_t>* m_pRank_to_ise;
	};

	// rgb/rgba direct or rgb/rgba base+offset, single plane
	static uint64_t encode_cem8_12_9_13(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals, uint64_t cur_blk_error, bool use_blue_contraction, bool* pTry_direct_encoding_flag)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT) ||
			(cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) || (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET));

		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		if (pTry_direct_encoding_flag)
			*pTry_direct_encoding_flag = false;

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT) || (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET);
		const bool cem_is_base_offset = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET) || (cem_index == astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET);

		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t total_weights = pixel_stats.m_num_pixels;

		float best_l = BIG_FLOAT_VAL, best_h = -BIG_FLOAT_VAL;
		//int best_l_index = 0, best_h_index = 0;

		for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
		{
			const vec4F px(pixel_stats.m_pixels_f[c] - pixel_stats.m_mean_f);

			float p = cem_has_alpha ? px.dot(pixel_stats.m_mean_rel_axis4) : px.dot3(pixel_stats.m_mean_rel_axis3);
			if (p < best_l)
			{
				best_l = p;
				//best_l_index = c;
			}

			if (p > best_h)
			{
				best_h = p;
				//best_h_index = c;
			}
		} // c

#if 0
		vec4F low_color_f(pixel_stats.m_pixels_f[best_l_index]), high_color_f(pixel_stats.m_pixels_f[best_h_index]);
#else
		vec4F low_color_f, high_color_f;
		if (cem_has_alpha)
		{
			low_color_f = pixel_stats.m_mean_rel_axis4 * best_l + pixel_stats.m_mean_f;
			high_color_f = pixel_stats.m_mean_rel_axis4 * best_h + pixel_stats.m_mean_f;
		}
		else
		{
			low_color_f = vec4F(pixel_stats.m_mean_rel_axis3) * best_l + pixel_stats.m_mean_f;
			high_color_f = vec4F(pixel_stats.m_mean_rel_axis3) * best_h + pixel_stats.m_mean_f;
		}

		low_color_f.clamp(0.0f, 1.0f);
		high_color_f.clamp(0.0f, 1.0f);
#endif

		uint8_t trial_blk_endpoints[astc_helpers::MAX_CEM_ENDPOINT_VALS] = { 0 };
		uint8_t trial_blk_weights[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint64_t trial_blk_error = UINT64_MAX;
		bool trial_used_blue_contraction = false;

		bool tried_used_blue_contraction = false;
				
		if (cem_is_base_offset)
		{
			bool try_direct_encoding_flag = false;
			
			try_cem9_13_sp_or_dp(
				cem_index, -1, pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				low_color_f, high_color_f,
				trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, 
				tried_used_blue_contraction, try_direct_encoding_flag);

			if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
				*pTry_direct_encoding_flag = true;
			
			if (tried_used_blue_contraction)
			{
				try_cem9_13_sp_or_dp(
					cem_index, -1, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_color_f, high_color_f,
					trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, false, 
					tried_used_blue_contraction, try_direct_encoding_flag);

				if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
					*pTry_direct_encoding_flag = true;
			}
		}
		else
		{
			try_cem8_12(
				cem_index, pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				low_color_f, high_color_f,
				trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction);

			if (tried_used_blue_contraction)
			{
				try_cem8_12(
					cem_index, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_color_f, high_color_f,
					trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction);
			}
		}

		if (trial_blk_error == UINT64_MAX)
			return cur_blk_error;

		if (trial_blk_error < cur_blk_error)
		{
			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals, trial_blk_weights, total_weights);
		}
				
		for (uint32_t pass = 0; pass < enc_params.m_max_ls_passes; pass++)
		{
			vec4F xl, xh;

			bool ls_res;
			if (cem_has_alpha)
			{
				ls_res = compute_least_squares_endpoints_4D(
					pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
					&xl, &xh, pixel_stats.m_pixels_f, pixel_stats.m_min_f, pixel_stats.m_max_f);
			}
			else
			{
				ls_res = compute_least_squares_endpoints_3D(
					pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
					&xl, &xh, pixel_stats.m_pixels_f, pixel_stats.m_min_f, pixel_stats.m_max_f);
			}
			if (!ls_res)
				break;
						
			if (cem_is_base_offset)
			{
				bool try_direct_encoding_flag = false;

				try_cem9_13_sp_or_dp(
					cem_index, -1, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					xl, xh,
					trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

				if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
					*pTry_direct_encoding_flag = true;

				if (tried_used_blue_contraction)
				{
					// Try without blue contraction for a minor gain.
					try_cem9_13_sp_or_dp(
						cem_index, -1, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction, try_direct_encoding_flag);

					if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
						*pTry_direct_encoding_flag = true;
				}
			}
			else
			{
				try_cem8_12(
					cem_index, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					xl, xh,
					trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction);

				if (tried_used_blue_contraction)
				{
					// Try without blue contraction for a minor gain.
					try_cem8_12(
						cem_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction);
				}
			}

			if (trial_blk_error >= cur_blk_error)
				break;

			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals, trial_blk_weights, total_weights);

		} // pass

		if ((enc_params.m_total_weight_refine_passes) && ((weight_ise_range != astc_helpers::BISE_2_LEVELS) && (weight_ise_range != astc_helpers::BISE_64_LEVELS)))
		{
			weight_refiner refiner;
			refiner.init(weight_ise_range, pixel_stats.m_num_pixels, pWeight_vals);

			for (uint32_t pass = 0; pass < enc_params.m_total_weight_refine_passes; pass++)
			{
				refiner.refine(pass, trial_blk_weights);

				vec4F xl, xh;

				bool ls_res;
				if (cem_has_alpha)
				{
					ls_res = compute_least_squares_endpoints_4D(
						pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
						&xl, &xh, pixel_stats.m_pixels_f, pixel_stats.m_min_f, pixel_stats.m_max_f);
				}
				else
				{
					ls_res = compute_least_squares_endpoints_3D(
						pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
						&xl, &xh, pixel_stats.m_pixels_f, pixel_stats.m_min_f, pixel_stats.m_max_f);
				}
				if (!ls_res)
					continue;

				if (cem_is_base_offset)
				{
					bool try_direct_encoding_flag = false;

					try_cem9_13_sp_or_dp(
						cem_index, -1, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

					if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
						*pTry_direct_encoding_flag = true;

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem9_13_sp_or_dp(
							cem_index, -1, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							xl, xh,
							trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction, try_direct_encoding_flag);

						if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
							*pTry_direct_encoding_flag = true;
					}
				}
				else
				{
					try_cem8_12(
						cem_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction);

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem8_12(
							cem_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							xl, xh,
							trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction);
					}
				}

				if (trial_blk_error < cur_blk_error)
				{
					cur_blk_error = trial_blk_error;
					memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
					memcpy(pWeight_vals, trial_blk_weights, total_weights);
				}

			} // pass
		}

		const uint32_t N = 4;
		if ((enc_params.m_worst_weight_nudging_flag) &&
			(pixel_stats.m_num_pixels > N) && 
			((weight_ise_range != astc_helpers::BISE_2_LEVELS) && (weight_ise_range != astc_helpers::BISE_64_LEVELS)))
		{
			const uint32_t NUM_NUDGING_PASSES = 1;
			for (uint32_t pass = 0; pass < NUM_NUDGING_PASSES; pass++)
			{
				color_rgba l, h;
				decode_endpoints(cem_index, pEndpoint_vals, endpoint_ise_range, l, h);

				vec4F dir;
				dir[0] = (float)(h[0] - l[0]);
				dir[1] = (float)(h[1] - l[1]);
				dir[2] = (float)(h[2] - l[2]);
				dir[3] = cem_has_alpha ? (float)(h[3] - l[3]) : 0.0f;

				dir.normalize_in_place();

				float errs[ASTC_LDR_MAX_BLOCK_PIXELS];
				float delta_dots[ASTC_LDR_MAX_BLOCK_PIXELS];
				for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
				{
					vec4F ofs(pixel_stats.m_pixels_f[i] - pixel_stats.m_mean_f);

					float proj = dir.dot(ofs);

					vec4F proj_vec(pixel_stats.m_mean_f + proj * dir);

					vec4F delta_vec(pixel_stats.m_pixels_f[i] - proj_vec);

					delta_dots[i] = dir.dot(delta_vec);

					errs[i] = cem_has_alpha ? vec4F::dot_product(delta_vec, delta_vec) : vec4F::dot_product3(delta_vec, delta_vec);
				}

				uint32_t errs_indices[ASTC_LDR_MAX_BLOCK_PIXELS];
				indirect_sort(pixel_stats.m_num_pixels, errs_indices, errs);
												
				memcpy(trial_blk_weights, pWeight_vals, total_weights);

				for (uint32_t i = 0; i < N; i++)
				{
					const uint32_t idx = errs_indices[pixel_stats.m_num_pixels - 1 - i];

					int delta_to_apply = (delta_dots[idx] > 0.0f) ? 1 : -1;

					trial_blk_weights[idx] = (uint8_t)apply_delta_to_bise_weight_val(weight_ise_range, trial_blk_weights[idx], delta_to_apply);
				} // i

				vec4F xl, xh;

				bool ls_res;
				if (cem_has_alpha)
				{
					ls_res = compute_least_squares_endpoints_4D(
						pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
						&xl, &xh, pixel_stats.m_pixels_f, pixel_stats.m_min_f, pixel_stats.m_max_f);
				}
				else
				{
					ls_res = compute_least_squares_endpoints_3D(
						pixel_stats.m_num_pixels, trial_blk_weights, get_ls_weights_ise(weight_ise_range),
						&xl, &xh, pixel_stats.m_pixels_f, pixel_stats.m_min_f, pixel_stats.m_max_f);
				}
				if (!ls_res)
					break;

				if (cem_is_base_offset)
				{
					bool try_direct_encoding_flag = false;
					
					try_cem9_13_sp_or_dp(
						cem_index, -1, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

					if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
						*pTry_direct_encoding_flag = true;

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem9_13_sp_or_dp(
							cem_index, -1, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							xl, xh,
							trial_blk_endpoints, trial_blk_weights, nullptr, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction, try_direct_encoding_flag);

						if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
							*pTry_direct_encoding_flag = true;
					}
				}
				else
				{
					try_cem8_12(
						cem_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction);

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem8_12(
							cem_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							xl, xh,
							trial_blk_endpoints, trial_blk_weights, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction);
					}
				}

				if (trial_blk_error < cur_blk_error)
				{
					cur_blk_error = trial_blk_error;
					memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
					memcpy(pWeight_vals, trial_blk_weights, total_weights);
				}
				else
				{
					break;
				}
			} // pass
		}

		if (enc_params.m_endpoint_refinement_flag)
		{
			const uint32_t num_comps = cem_has_alpha ? 4 : 3;
						
			for (uint32_t c = 0; c < num_comps; c++)
			{
				uint8_t base_endpoint_vals[astc_helpers::MAX_CEM_ENDPOINT_VALS];
				memcpy(base_endpoint_vals, pEndpoint_vals, total_endpoint_vals);

				for (int dl = -1; dl <= 1; dl++)
				{
					for (int dh = -1; dh <= 1; dh++)
					{
						if (!dl && !dh)
							continue;

						memcpy(trial_blk_endpoints, base_endpoint_vals, total_endpoint_vals);

						trial_blk_endpoints[c * 2 + 0] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_blk_endpoints[c * 2 + 0], dl);
						trial_blk_endpoints[c * 2 + 1] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, trial_blk_endpoints[c * 2 + 1], dh);
						
						if (!use_blue_contraction)
						{
							const bool uses_blue_contraction = astc_helpers::used_blue_contraction(cem_index, trial_blk_endpoints, endpoint_ise_range);
							if (uses_blue_contraction)
								continue;
						}

						trial_blk_error = eval_solution(
							pixel_stats,
							cem_index, trial_blk_endpoints, endpoint_ise_range,
							trial_blk_weights, weight_ise_range,
							enc_params);

						if (trial_blk_error < cur_blk_error)
						{
							cur_blk_error = trial_blk_error;
							memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
							memcpy(pWeight_vals, trial_blk_weights, total_weights);
						}

					} // dh

				} // dl
			}
		}

		return cur_blk_error;
	}

	// rgb/rgba direct, or rgb/rgba base+offset, dual plane
	static uint64_t encode_cem8_12_9_13_dp(
		uint32_t cem_index, uint32_t ccs_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals0, uint8_t* pWeight_vals1,
		uint64_t cur_blk_error, bool use_blue_contraction, bool * pTry_direct_encoding_flag)
	{
		assert(g_initialized);
		assert(ccs_index <= 3);
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		if (pTry_direct_encoding_flag)
			*pTry_direct_encoding_flag = false;

		bool cem_has_alpha = false, cem_is_base_offset = false;
		switch (cem_index)
		{
		case astc_helpers::CEM_LDR_RGB_DIRECT: break;
		case astc_helpers::CEM_LDR_RGBA_DIRECT: cem_has_alpha = true; break;
		case astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET: cem_is_base_offset = true; break;
		case astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET: cem_is_base_offset = true; cem_has_alpha = true; break;
		default:
			assert(0);
			return false;
		}

		assert((ccs_index <= 2) || cem_has_alpha);

		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t total_weights = pixel_stats.m_num_pixels;

		// Remove influence of the 2nd plane's values, recalc principle axis on other values.
		vec4F flattened_pixels[ASTC_LDR_MAX_BLOCK_PIXELS];
		for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
		{
			flattened_pixels[i] = pixel_stats.m_pixels_f[i];
			flattened_pixels[i][ccs_index] = 0.0f;
						
			if (!cem_has_alpha)
				flattened_pixels[i][3] = 0.0f;
		}

		vec4F flattened_pixels_mean(pixel_stats.m_mean_f);
		flattened_pixels_mean[ccs_index] = 0.0f;
		
		if (!cem_has_alpha)
			flattened_pixels_mean[3] = 0.0f;

		vec4F flattened_axis;
		if (!cem_has_alpha)
			flattened_axis = calc_pca_3D(pixel_stats.m_num_pixels, flattened_pixels, flattened_pixels_mean);
		else
			flattened_axis = calc_pca_4D(pixel_stats.m_num_pixels, flattened_pixels, flattened_pixels_mean);

		float best_l = BIG_FLOAT_VAL, best_h = -BIG_FLOAT_VAL;
		//int best_l_index = 0, best_h_index = 0;

		for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
		{
			const vec4F px(flattened_pixels[c] - flattened_pixels_mean);

			float p = px.dot(flattened_axis);
			if (p < best_l)
			{
				best_l = p;
				//best_l_index = c;
			}

			if (p > best_h)
			{
				best_h = p;
				//best_h_index = c;
			}
		} // c

#if 0
		vec4F low_color_f(pixel_stats.m_pixels_f[best_l_index]), high_color_f(pixel_stats.m_pixels_f[best_h_index]);
#else
		vec4F low_color_f, high_color_f;
		low_color_f = flattened_pixels_mean + flattened_axis * best_l;
		high_color_f = flattened_pixels_mean + flattened_axis * best_h;

		low_color_f.clamp(0.0f, 1.0f);
		high_color_f.clamp(0.0f, 1.0f);
#endif

		low_color_f[ccs_index] = pixel_stats.m_min_f[ccs_index];
		high_color_f[ccs_index] = pixel_stats.m_max_f[ccs_index];

		uint8_t trial_blk_endpoints[astc_helpers::MAX_CEM_ENDPOINT_VALS] = { 0 };
		uint8_t trial_blk_weights0[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t trial_blk_weights1[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint64_t trial_blk_error = UINT64_MAX;
		bool trial_used_blue_contraction = false;

		bool tried_used_blue_contraction = false;
		
		if (cem_is_base_offset)
		{
			bool try_direct_encoding_flag = false;

			try_cem9_13_sp_or_dp(
				cem_index, ccs_index, pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				low_color_f, high_color_f,
				trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1,
				trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

			if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
				*pTry_direct_encoding_flag = true;

			if (tried_used_blue_contraction)
			{
				try_cem9_13_sp_or_dp(
					cem_index, ccs_index, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_color_f, high_color_f,
					trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction, try_direct_encoding_flag);

				if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
					*pTry_direct_encoding_flag = true;
			}
		}
		else
		{
			try_cem8_12_dp(
				cem_index, ccs_index, pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				low_color_f, high_color_f,
				trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1,
				trial_blk_error, trial_used_blue_contraction, use_blue_contraction, tried_used_blue_contraction);

			if (tried_used_blue_contraction)
			{
				try_cem8_12_dp(
					cem_index, ccs_index, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_color_f, high_color_f,
					trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction, false, tried_used_blue_contraction);
			}
		}

		if (trial_blk_error == UINT64_MAX)
			return cur_blk_error;

		if (trial_blk_error < cur_blk_error)
		{
			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals0, trial_blk_weights0, total_weights);
			memcpy(pWeight_vals1, trial_blk_weights1, total_weights);
		}
				
		vec4F flattened_pixels_min_f(pixel_stats.m_min_f);
		flattened_pixels_min_f[ccs_index] = 0;

		vec4F flattened_pixels_max_f(pixel_stats.m_max_f);
		flattened_pixels_max_f[ccs_index] = 0;

		for (uint32_t pass = 0; pass < enc_params.m_max_ls_passes; pass++)
		{
			vec4F xl, xh;

			// TODO: Switch between 4D or 3D
			if (!compute_least_squares_endpoints_4D(
				pixel_stats.m_num_pixels, trial_blk_weights0, get_ls_weights_ise(weight_ise_range),
				&xl, &xh, flattened_pixels, flattened_pixels_min_f, flattened_pixels_max_f))
			{
				break;
			}

			color_rgba dec_l(0), dec_h(0);
			decode_endpoints(cem_index, trial_blk_endpoints, endpoint_ise_range, dec_l, dec_h);

			xl[ccs_index] = dec_l[ccs_index] * (1.0f / 255.0f);
			xh[ccs_index] = dec_h[ccs_index] * (1.0f / 255.0f);

			if (cem_is_base_offset)
			{
				bool try_direct_encoding_flag = false;

				try_cem9_13_sp_or_dp(
					cem_index, ccs_index, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					xl, xh,
					trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
					use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

				if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
					*pTry_direct_encoding_flag = true;

				if (tried_used_blue_contraction)
				{
					// Try without blue contraction for a minor gain.
					try_cem9_13_sp_or_dp(
						cem_index, ccs_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
						false, tried_used_blue_contraction, try_direct_encoding_flag);

					if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
						*pTry_direct_encoding_flag = true;
				}
			}
			else
			{
				try_cem8_12_dp(
					cem_index, ccs_index, pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					xl, xh,
					trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
					use_blue_contraction, tried_used_blue_contraction);

				if (tried_used_blue_contraction)
				{
					// Try without blue contraction for a minor gain.
					try_cem8_12_dp(
						cem_index, ccs_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
						false, tried_used_blue_contraction);
				}
			}

			if (trial_blk_error >= cur_blk_error)
				break;

			cur_blk_error = trial_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals0, trial_blk_weights0, total_weights);
			memcpy(pWeight_vals1, trial_blk_weights1, total_weights);

		} // pass

		const float ccs_bounds_min = pixel_stats.m_min_f[ccs_index];
		const float ccs_bounds_max = pixel_stats.m_max_f[ccs_index];
		float ccs_vals[ASTC_LDR_MAX_BLOCK_PIXELS];

		if (ccs_bounds_min != ccs_bounds_max)
		{
			for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
				ccs_vals[i] = pixel_stats.m_pixels_f[i][ccs_index];

			for (uint32_t pass = 0; pass < enc_params.m_max_ls_passes; pass++)
			{
				float xl = 0.0f, xh = 0.0f;

				if (!compute_least_squares_endpoints_1D(
					pixel_stats.m_num_pixels, trial_blk_weights1, get_ls_weights_ise(weight_ise_range),
					&xl, &xh, ccs_vals, ccs_bounds_min, ccs_bounds_max))
				{
					break;
				}

				color_rgba dec_l(0), dec_h(0);
				decode_endpoints(cem_index, trial_blk_endpoints, endpoint_ise_range, dec_l, dec_h);

				vec4F vl, vh;
				for (uint32_t c = 0; c < 4; c++)
				{
					if (c == ccs_index)
					{
						vl[c] = xl;
						vh[c] = xh;
					}
					else
					{
						vl[c] = (float)dec_l[c] * (1.0f / 255.0f);
						vh[c] = (float)dec_h[c] * (1.0f / 255.0f);
					}
				}

				if (cem_is_base_offset)
				{
					bool try_direct_encoding_flag = false;

					try_cem9_13_sp_or_dp(
						cem_index, ccs_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						vl, vh,
						trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
						use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

					if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
						*pTry_direct_encoding_flag = true;

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem9_13_sp_or_dp(
							cem_index, ccs_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							vl, vh,
							trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
							false, tried_used_blue_contraction, try_direct_encoding_flag);

						if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
							*pTry_direct_encoding_flag = true;
					}
				}
				else
				{
					try_cem8_12_dp(
						cem_index, ccs_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						vl, vh,
						trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
						use_blue_contraction, tried_used_blue_contraction);

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem8_12_dp(
							cem_index, ccs_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							vl, vh,
							trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
							false, tried_used_blue_contraction);
					}
				}

				if (trial_blk_error >= cur_blk_error)
					break;

				cur_blk_error = trial_blk_error;
				memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
				memcpy(pWeight_vals0, trial_blk_weights0, total_weights);
				memcpy(pWeight_vals1, trial_blk_weights1, total_weights);

			} // pass
		}

		if ((enc_params.m_total_weight_refine_passes) && ((weight_ise_range != astc_helpers::BISE_2_LEVELS) && (weight_ise_range != astc_helpers::BISE_64_LEVELS)))
		{
			weight_refiner refiner;
			refiner.init(weight_ise_range, pixel_stats.m_num_pixels, pWeight_vals0);

			for (uint32_t pass = 0; pass < enc_params.m_total_weight_refine_passes; pass++)
			{
				refiner.refine(pass, trial_blk_weights0);

				vec4F xl, xh;

				if (!compute_least_squares_endpoints_4D(
					pixel_stats.m_num_pixels, trial_blk_weights0, get_ls_weights_ise(weight_ise_range),
					&xl, &xh, flattened_pixels, flattened_pixels_min_f, flattened_pixels_max_f))
				{
					break;
				}

				color_rgba dec_l(0), dec_h(0);
				decode_endpoints(cem_index, trial_blk_endpoints, endpoint_ise_range, dec_l, dec_h);

				xl[ccs_index] = dec_l[ccs_index] * (1.0f / 255.0f);
				xh[ccs_index] = dec_h[ccs_index] * (1.0f / 255.0f);

				if (cem_is_base_offset)
				{
					bool try_direct_encoding_flag = false;

					try_cem9_13_sp_or_dp(
						cem_index, ccs_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
						use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);

					if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
						*pTry_direct_encoding_flag = true;

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem9_13_sp_or_dp(
							cem_index, ccs_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							xl, xh,
							trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
							false, tried_used_blue_contraction, try_direct_encoding_flag);

						if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
							*pTry_direct_encoding_flag = true;
					}
				}
				else
				{
					try_cem8_12_dp(
						cem_index, ccs_index, pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						xl, xh,
						trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
						use_blue_contraction, tried_used_blue_contraction);

					if (tried_used_blue_contraction)
					{
						// Try without blue contraction for a minor gain.
						try_cem8_12_dp(
							cem_index, ccs_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							xl, xh,
							trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
							false, tried_used_blue_contraction);
					}
				}

				if (trial_blk_error >= cur_blk_error)
					continue;

				cur_blk_error = trial_blk_error;
				memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
				memcpy(pWeight_vals0, trial_blk_weights0, total_weights);
				memcpy(pWeight_vals1, trial_blk_weights1, total_weights);

			} // pass

			if (ccs_bounds_min != ccs_bounds_max)
			{
				refiner.init(weight_ise_range, pixel_stats.m_num_pixels, pWeight_vals1);

				for (uint32_t pass = 0; pass < WEIGHT_REFINER_MAX_PASSES; pass++)
				{
					refiner.refine(pass, trial_blk_weights1);

					float xl = 0.0f, xh = 0.0f;

					if (!compute_least_squares_endpoints_1D(
						pixel_stats.m_num_pixels, trial_blk_weights1, get_ls_weights_ise(weight_ise_range),
						&xl, &xh, ccs_vals, ccs_bounds_min, ccs_bounds_max))
					{
						break;
					}
					
					color_rgba dec_l(0), dec_h(0);
					decode_endpoints(cem_index, trial_blk_endpoints, endpoint_ise_range, dec_l, dec_h);

					vec4F vl, vh;
					for (uint32_t c = 0; c < 4; c++)
					{
						if (c == ccs_index)
						{
							vl[c] = xl;
							vh[c] = xh;
						}
						else
						{
							vl[c] = (float)dec_l[c] * (1.0f / 255.0f);
							vh[c] = (float)dec_h[c] * (1.0f / 255.0f);
						}
					}

					bool did_improve_res = false;

					if (cem_is_base_offset)
					{
						bool try_direct_encoding_flag = false;

						did_improve_res = try_cem9_13_sp_or_dp(
							cem_index, ccs_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							vl, vh,
							trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
							use_blue_contraction, tried_used_blue_contraction, try_direct_encoding_flag);
						BASISU_NOTE_UNUSED(did_improve_res);

						if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
							*pTry_direct_encoding_flag = true;

						if (tried_used_blue_contraction)
						{
							// Try without blue contraction for a minor gain.
							did_improve_res = try_cem9_13_sp_or_dp(
								cem_index, ccs_index, pixel_stats, enc_params,
								endpoint_ise_range, weight_ise_range,
								vl, vh,
								trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
								false, tried_used_blue_contraction, try_direct_encoding_flag);

							if ((pTry_direct_encoding_flag) && (try_direct_encoding_flag))
								*pTry_direct_encoding_flag = true;
						}
					}
					else
					{
						did_improve_res = try_cem8_12_dp(
							cem_index, ccs_index, pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							vl, vh,
							trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
							use_blue_contraction, tried_used_blue_contraction);

						if (tried_used_blue_contraction)
						{
							// Try without blue contraction for a minor gain.
							did_improve_res = try_cem8_12_dp(
								cem_index, ccs_index, pixel_stats, enc_params,
								endpoint_ise_range, weight_ise_range,
								vl, vh,
								trial_blk_endpoints, trial_blk_weights0, trial_blk_weights1, trial_blk_error, trial_used_blue_contraction,
								false, tried_used_blue_contraction);
						}
					}

					if (trial_blk_error >= cur_blk_error)
						continue;

					cur_blk_error = trial_blk_error;
					memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
					memcpy(pWeight_vals0, trial_blk_weights0, total_weights);
					memcpy(pWeight_vals1, trial_blk_weights1, total_weights);

				} // pass
			} 
		}

		return cur_blk_error;
	}

	// base scale rgb/rgba
	// returns true if improved
	static bool try_cem6_10(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		float scale, float low_a_f, const vec4F& high_color_f,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals, uint64_t& trial_blk_error)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE) || (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A));
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		cem_encode_ldr_rgb_or_rgba_base_scale(cem_index, endpoint_ise_range, scale, low_a_f, high_color_f, trial_endpoint_vals);

		uint64_t trial_err = eval_solution(
			pixel_stats, cem_index, trial_endpoint_vals, endpoint_ise_range,
			trial_weight_vals, weight_ise_range,
			enc_params);

		bool improved_flag = false;
		if (trial_err < trial_blk_error)
		{
			trial_blk_error = trial_err;
			memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
			memcpy(pTrial_weight_vals, trial_weight_vals, pixel_stats.m_num_pixels);
			improved_flag = true;
		}

		const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);

		// TODO
		for (int delta = -1; delta <= 1; delta += 1)
		{
			if (!delta)
				continue;

			uint8_t fixed_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS];
			memcpy(fixed_endpoint_vals, trial_endpoint_vals, num_endpoint_vals);

			fixed_endpoint_vals[3] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, fixed_endpoint_vals[3], delta);

			trial_err = eval_solution(
				pixel_stats, cem_index, fixed_endpoint_vals, endpoint_ise_range,
				trial_weight_vals, weight_ise_range,
				enc_params);

			if (trial_err < trial_blk_error)
			{
				trial_blk_error = trial_err;
				memcpy(pTrial_endpoint_vals, fixed_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
				memcpy(pTrial_weight_vals, trial_weight_vals, pixel_stats.m_num_pixels);
				improved_flag = true;
			}
		}

		return improved_flag;
	}

	static bool try_cem6_10_dp(
		uint32_t cem_index, uint32_t ccs_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		float scale, float low_a_f, const vec4F& high_color_f,
		uint8_t* pTrial_endpoint_vals, uint8_t* pTrial_weight_vals0, uint8_t* pTrial_weight_vals1, uint64_t& trial_blk_error)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE) || (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A));
		assert(ccs_index <= 3);
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));
		assert(pTrial_weight_vals0 && pTrial_weight_vals1);
		
		uint8_t trial_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
		uint8_t trial_weight_vals0[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t trial_weight_vals1[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		cem_encode_ldr_rgb_or_rgba_base_scale(cem_index, endpoint_ise_range, scale, low_a_f, high_color_f, trial_endpoint_vals);

		uint64_t trial_err = eval_solution_dp(
			pixel_stats, cem_index, ccs_index,
			trial_endpoint_vals, endpoint_ise_range,
			trial_weight_vals0, trial_weight_vals1, weight_ise_range,
			enc_params);

		bool improved_flag = false;
		if (trial_err < trial_blk_error)
		{
			trial_blk_error = trial_err;
			memcpy(pTrial_endpoint_vals, trial_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
			memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
			memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
			improved_flag = true;
		}

		const uint32_t num_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);

		for (int delta = -1; delta <= 1; delta += 1)
		{
			if (!delta)
				continue;

			uint8_t fixed_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS];
			memcpy(fixed_endpoint_vals, trial_endpoint_vals, num_endpoint_vals);

			fixed_endpoint_vals[3] = (uint8_t)astc_helpers::apply_delta_to_bise_endpoint_val(endpoint_ise_range, fixed_endpoint_vals[3], delta);

			trial_err = eval_solution_dp(
				pixel_stats, cem_index, ccs_index,
				fixed_endpoint_vals, endpoint_ise_range,
				trial_weight_vals0, trial_weight_vals1, weight_ise_range,
				enc_params);

			if (trial_err < trial_blk_error)
			{
				trial_blk_error = trial_err;
				memcpy(pTrial_endpoint_vals, fixed_endpoint_vals, astc_helpers::get_num_cem_values(cem_index));
				memcpy(pTrial_weight_vals0, trial_weight_vals0, pixel_stats.m_num_pixels);
				memcpy(pTrial_weight_vals1, trial_weight_vals1, pixel_stats.m_num_pixels);
				improved_flag = true;
			}
		}

		return improved_flag;
	}

	// rgb/rgba base+scale
	static uint64_t encode_cem6_10(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals, uint64_t cur_blk_error)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE) || (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A));
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A);

		const uint32_t total_endpoint_vals = astc_helpers::get_num_cem_values(cem_index);
		const uint32_t total_weights = pixel_stats.m_num_pixels;

		float best_l = BIG_FLOAT_VAL, best_h = -BIG_FLOAT_VAL;
		//int best_l_index = 0, best_h_index = 0;

		for (uint32_t c = 0; c < pixel_stats.m_num_pixels; c++)
		{
			const vec3F px(pixel_stats.m_pixels_f[c]);

			float p = px.dot(pixel_stats.m_zero_rel_axis3);

			if (p < best_l)
			{
				best_l = p;
				//best_l_index = c;
			}

			if (p > best_h)
			{
				best_h = p;
				//best_h_index = c;
			}
		} // c

		const float MAX_S = 255.0f / 256.0f;
		const float EPS = 1e-6f;

		uint64_t trial_blk_error = UINT64_MAX;
		uint8_t trial_blk_endpoints[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
		uint8_t trial_blk_weights[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		uint64_t best_blk_error = UINT64_MAX;
		uint8_t best_blk_endpoints[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
		uint8_t best_blk_weights[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		vec3F low_color3_f(best_l * pixel_stats.m_zero_rel_axis3);
		low_color3_f.clamp(0.0f, 1.0f);

		vec3F high_color3_f(best_h * pixel_stats.m_zero_rel_axis3);
		high_color3_f.clamp(0.0f, 1.0f);

		float scale = MAX_S;

		float d = low_color3_f.dot(high_color3_f);
		float nrm = high_color3_f.norm();
		if (nrm > 0.0f)
			scale = saturate(d / nrm);
		scale = minimum(scale, MAX_S);

		vec4F low_color_f(low_color3_f[0], low_color3_f[1], low_color3_f[2], pixel_stats.m_min_f[3]);
		vec4F high_color_f(high_color3_f[0], high_color3_f[1], high_color3_f[2], pixel_stats.m_max_f[3]);

		try_cem6_10(
			cem_index,
			pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			scale, low_color_f[3], high_color_f,
			trial_blk_endpoints, trial_blk_weights, trial_blk_error);

		best_blk_error = trial_blk_error;
		memcpy(best_blk_endpoints, trial_blk_endpoints, total_endpoint_vals);
		memcpy(best_blk_weights, trial_blk_weights, total_weights);

		const uint32_t NUM_PASSES = 2;
		for (uint32_t pass = 0; pass < NUM_PASSES; pass++)
		{
			color_rgba actual_l(0), actual_h(0);
			float actual_scale = 0;
			decode_endpoints(cem_index, trial_blk_endpoints, endpoint_ise_range, actual_l, actual_h, &actual_scale);

			vec3F actual_high_f((float)actual_h[0], (float)actual_h[1], (float)actual_h[2]);
			actual_high_f *= (1.0f / 255.0f);

			// invalid on raw weights
			const auto& dequant_weights_tab = astc_helpers::g_dequant_tables.get_weight_tab(minimum<uint32_t>(astc_helpers::BISE_32_LEVELS, weight_ise_range)).m_ISE_to_val;

			vec3F Pa(0.0f), Pb(0.0f);
			float A = 0.0f, B = 0.0f, C = 0.0f;

			for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
			{
				const vec3F px(pixel_stats.m_pixels_f[i]);

				const int iw = (weight_ise_range == astc_helpers::BISE_64_LEVELS) ? trial_blk_weights[i] : dequant_weights_tab[trial_blk_weights[i]];
				float t = (float)iw * (1.0f / 64.0f);
				float bi = t, ai = 1.0f - t;

				Pa += px * ai;
				Pb += px * bi;

				A += ai * ai;
				B += ai * bi;
				C += bi * bi;
			}

			vec3F new_high = actual_high_f;
			float new_scale = actual_scale;

			float h2 = actual_high_f.norm();
			if ((h2 > EPS) && (A > EPS))
			{
				new_scale = (Pa.dot(actual_high_f) / h2 - B) / A;
				new_scale = clamp(new_scale, 0.0f, MAX_S);
			}

			const float den = A * new_scale * new_scale + 2.0f * B * new_scale + C;
			if (den > EPS)
			{
				new_high = (Pb + Pa * new_scale) / den;
			}

			h2 = new_high.norm();
			if ((h2 > EPS) && (A > EPS))
			{
				new_scale = (Pa.dot(new_high) / h2 - B) / A;
				new_scale = clamp(new_scale, 0.0f, MAX_S);
			}

			try_cem6_10(
				cem_index,
				pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				new_scale, (float)actual_l[3] * (1.0f / 255.0f), vec4F(new_high[0], new_high[1], new_high[2], (float)actual_h[3] * (1.0f / 255.0f)),
				trial_blk_endpoints, trial_blk_weights, trial_blk_error);

			if (trial_blk_error >= best_blk_error)
				break;

			best_blk_error = trial_blk_error;
			memcpy(best_blk_endpoints, trial_blk_endpoints, total_endpoint_vals);
			memcpy(best_blk_weights, trial_blk_weights, total_weights);

		} // pass

		if (cem_has_alpha)
		{
			// Try to refine low a/high given the current selectors.
			float bounds_min = pixel_stats.m_min_f[3];
			float bounds_max = pixel_stats.m_max_f[3];
			if (bounds_min != bounds_max)
			{
				float a_vals[ASTC_LDR_MAX_BLOCK_PIXELS];
				for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
					a_vals[i] = pixel_stats.m_pixels_f[i][3];

				const uint32_t TOTAL_PASSES = 1;
				for (uint32_t pass = 0; pass < TOTAL_PASSES; pass++)
				{
					float xl = 0.0f, xh = 0.0f;

					if (compute_least_squares_endpoints_1D(
						pixel_stats.m_num_pixels, best_blk_weights, get_ls_weights_ise(weight_ise_range),
						&xl, &xh, a_vals, bounds_min, bounds_max))
					{
						color_rgba actual_l(0), actual_h(0);
						float actual_scale = 0;
						decode_endpoints(cem_index, trial_blk_endpoints, endpoint_ise_range, actual_l, actual_h, &actual_scale);

						try_cem6_10(
							cem_index,
							pixel_stats, enc_params,
							endpoint_ise_range, weight_ise_range,
							actual_scale, xl, vec4F(actual_h[0], actual_h[1], actual_h[2], xh),
							trial_blk_endpoints, trial_blk_weights, trial_blk_error);

						if (trial_blk_error < best_blk_error)
						{
							best_blk_error = trial_blk_error;
							memcpy(best_blk_endpoints, trial_blk_endpoints, total_endpoint_vals);
							memcpy(best_blk_weights, trial_blk_weights, total_weights);
						}
						else
						{
							break;
						}
					}
					else
					{
						break;
					}
				} // pass
			}
		}

		if (best_blk_error < cur_blk_error)
		{
			cur_blk_error = best_blk_error;
			memcpy(pEndpoint_vals, trial_blk_endpoints, total_endpoint_vals);
			memcpy(pWeight_vals, trial_blk_weights, total_weights);
		}

		return cur_blk_error;
	}

	// rgba base+scale, dual plane a, ccs_index must be 3
	static uint64_t encode_cem10_dp_a(
		uint32_t cem_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals0, uint8_t* pWeight_vals1, uint64_t cur_blk_error)
	{
		assert(g_initialized);
		assert(cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A);
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));

		// RGB uses plane0, alpha plane1. So solve RGB first.
		uint8_t rgba_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
		uint8_t rgb_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t a_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		// First just solve RGB, single plane.
		uint64_t rgb_blk_error = encode_cem6_10(
			astc_helpers::CEM_LDR_RGB_BASE_SCALE,
			pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			rgba_endpoint_vals, rgb_weight_vals, UINT64_MAX);

		assert(rgb_blk_error != UINT64_MAX);

		if (rgb_blk_error == UINT64_MAX)
			return cur_blk_error;

		const auto& endpoint_quant_tab = astc_helpers::g_dequant_tables.get_endpoint_tab(endpoint_ise_range).m_val_to_ise;

		rgba_endpoint_vals[4] = endpoint_quant_tab[pixel_stats.m_min[3]];
		rgba_endpoint_vals[5] = endpoint_quant_tab[pixel_stats.m_max[3]];

		uint64_t rgba_blk_error = eval_solution_dp(
			pixel_stats,
			cem_index, 3,
			rgba_endpoint_vals, endpoint_ise_range,
			rgb_weight_vals, a_weight_vals, weight_ise_range,
			enc_params);

		assert(rgba_blk_error != UINT64_MAX);

		if (rgba_blk_error < cur_blk_error)
		{
			cur_blk_error = rgba_blk_error;
			memcpy(pEndpoint_vals, rgba_endpoint_vals, astc_helpers::NUM_MODE10_ENDPOINTS);
			memcpy(pWeight_vals0, rgb_weight_vals, pixel_stats.m_num_pixels);
			memcpy(pWeight_vals1, a_weight_vals, pixel_stats.m_num_pixels);

			if (!cur_blk_error)
				return cur_blk_error;
		}

		float bounds_min = pixel_stats.m_min_f[3], bounds_max = pixel_stats.m_max_f[3];
		if (bounds_min != bounds_max)
		{
			float a_vals[ASTC_LDR_MAX_BLOCK_PIXELS];
			for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
				a_vals[i] = pixel_stats.m_pixels_f[i][3];

			const uint32_t TOTAL_PASSES = 2;

			uint8_t trial_rgba_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
			uint8_t trial_rgb_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
			uint8_t trial_a_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

			for (uint32_t pass = 0; pass < TOTAL_PASSES; pass++)
			{
				float xl = 0.0f, xh = 0.0f;

				if (compute_least_squares_endpoints_1D(
					pixel_stats.m_num_pixels, pass ? trial_a_weight_vals : a_weight_vals, get_ls_weights_ise(weight_ise_range),
					&xl, &xh, a_vals, bounds_min, bounds_max))
				{
					memcpy(trial_rgba_endpoint_vals, rgba_endpoint_vals, astc_helpers::NUM_MODE10_ENDPOINTS);

					trial_rgba_endpoint_vals[4] = precise_round_bise_endpoint_val(xl, endpoint_ise_range);
					trial_rgba_endpoint_vals[5] = precise_round_bise_endpoint_val(xh, endpoint_ise_range);

					uint64_t trial_rgba_blk_error = eval_solution_dp(
						pixel_stats,
						cem_index, 3,
						trial_rgba_endpoint_vals, endpoint_ise_range,
						trial_rgb_weight_vals, trial_a_weight_vals, weight_ise_range,
						enc_params);

					assert(trial_rgba_blk_error != UINT64_MAX);

					if (trial_rgba_blk_error < cur_blk_error)
					{
						cur_blk_error = trial_rgba_blk_error;
						memcpy(pEndpoint_vals, trial_rgba_endpoint_vals, astc_helpers::NUM_MODE10_ENDPOINTS);
						memcpy(pWeight_vals0, trial_rgb_weight_vals, pixel_stats.m_num_pixels);
						memcpy(pWeight_vals1, trial_a_weight_vals, pixel_stats.m_num_pixels);
					}
					else
					{
						break;
					}
				}
				else
				{
					break;
				}
			} // pass
		}

		return cur_blk_error;
	}

	// rgb/rgba base+scale, dual plane rgb (not a!)
	static uint64_t encode_cem6_10_dp_rgb(
		uint32_t cem_index, uint32_t ccs_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals0, uint8_t* pWeight_vals1, uint64_t cur_blk_error)
	{
		assert(g_initialized);
		assert((cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE) || (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A));
		assert(ccs_index <= 2);
		assert((pixel_stats.m_num_pixels) && (pixel_stats.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert((endpoint_ise_range >= astc_helpers::FIRST_VALID_ENDPOINT_ISE_RANGE) && (endpoint_ise_range <= astc_helpers::LAST_VALID_ENDPOINT_ISE_RANGE));
		assert(((weight_ise_range >= astc_helpers::FIRST_VALID_WEIGHT_ISE_RANGE) && (weight_ise_range <= astc_helpers::LAST_VALID_WEIGHT_ISE_RANGE)) || (weight_ise_range == astc_helpers::BISE_64_LEVELS));
		assert(pWeight_vals0 && pWeight_vals1);

		// First solve using a single plane, then we'll introduce the other plane's weights and tune the encoded H/s values
		uint8_t sp_endpoint_vals[astc_helpers::NUM_MODE10_ENDPOINTS] = { 0 };
		uint8_t sp_weight_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };

		uint64_t sp_block_err = encode_cem6_10(
			cem_index,
			pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			sp_endpoint_vals, sp_weight_vals, UINT64_MAX);

		assert(sp_block_err != UINT64_MAX);
		BASISU_NOTE_UNUSED(sp_block_err);

		// Now compute both plane's weights using the initial H/s values
		uint8_t trial_weights0_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint8_t trial_weights1_vals[ASTC_LDR_MAX_BLOCK_PIXELS] = { 0 };
		uint64_t dp_blk_error = eval_solution_dp(
			pixel_stats,
			cem_index, ccs_index,
			sp_endpoint_vals, endpoint_ise_range,
			trial_weights0_vals, trial_weights1_vals, weight_ise_range,
			enc_params);

		if (dp_blk_error < cur_blk_error)
		{
			cur_blk_error = dp_blk_error;
			memcpy(pEndpoint_vals, sp_endpoint_vals, astc_helpers::NUM_MODE10_ENDPOINTS);
			memcpy(pWeight_vals0, trial_weights0_vals, pixel_stats.m_num_pixels);
			memcpy(pWeight_vals1, trial_weights1_vals, pixel_stats.m_num_pixels);

			if (!cur_blk_error)
				return cur_blk_error;
		}

		// Compute refined H/s values using the current weights.
		const float MAX_S = 255.0f / 256.0f;
		const float EPS = 1e-6f;

		vec3F Pa(0.0f); // (Pa_r,Pa_g,Pa_b)
		vec3F Pb(0.0f); // (Pb_r,Pb_g,Pb_b)
		float A[3] = { 0 }, B[3] = { 0 }, C[3] = { 0 }; // per-channel

		// invalid on raw weights
		const auto& dequant_weights_tab = astc_helpers::g_dequant_tables.get_weight_tab(minimum<uint32_t>(astc_helpers::BISE_32_LEVELS, weight_ise_range)).m_ISE_to_val;

		for (uint32_t i = 0; i < pixel_stats.m_num_pixels; i++)
		{
			float w0, w1;
			if (weight_ise_range == astc_helpers::BISE_64_LEVELS)
			{
				w0 = (float)trial_weights0_vals[i] * (1.0f / 64.0f);
				w1 = (float)trial_weights1_vals[i] * (1.0f / 64.0f);
			}
			else
			{
				w0 = dequant_weights_tab[trial_weights0_vals[i]] * (1.0f / 64.0f);
				w1 = dequant_weights_tab[trial_weights1_vals[i]] * (1.0f / 64.0f);
			}

			float w[3] = { w0, w0, w0 };
			w[ccs_index] = w1;

			const vec3F& p = pixel_stats.m_pixels_f[i];

			for (int c = 0; c < 3; ++c)
			{
				const float a = 1.0f - w[c];
				const float b = w[c];

				Pa[c] += a * p[c];
				Pb[c] += b * p[c];
				A[c] += a * a;
				B[c] += a * b;
				C[c] += b * b;
			} // c
		} // i

		color_rgba actual_l(0), actual_h(0);
		float actual_scale = 0;
		decode_endpoints(cem_index, sp_endpoint_vals, endpoint_ise_range, actual_l, actual_h, &actual_scale);

		vec3F H((float)actual_h[0], (float)actual_h[1], (float)actual_h[2]);
		H *= (1.0f / 255.0f);

		const float S1 = H[0] * Pa[0] + H[1] * Pa[1] + H[2] * Pa[2];
		float S2 = 0.0f, S3 = 0.0f;
		for (int c = 0; c < 3; c++)
		{
			const float H2 = H[c] * H[c];
			S2 += H2 * A[c];
			S3 += H2 * B[c];
		}

		float new_s = actual_scale;
		if (S2 > EPS)
			new_s = (S1 - S3) / S2;

		new_s = clamp(new_s, 0.0f, MAX_S);

		vec3F new_H(0.0f);
		for (int c = 0; c < 3; ++c)
		{
			const float den = A[c] * new_s * new_s + 2.0f * B[c] * new_s + C[c];

			float Hc = 0.0f;
			if (den > EPS)
			{
				const float num = Pb[c] + new_s * Pa[c];
				Hc = num / den;
			}
			new_H[c] = Hc;
		}

		bool improved_flag = try_cem6_10_dp(
			cem_index, ccs_index,
			pixel_stats, enc_params,
			endpoint_ise_range, weight_ise_range,
			new_s, (float)actual_l[3] * (1.0f / 255.0f), vec4F(new_H[0], new_H[1], new_H[2], (float)actual_h[3] * (1.0f / 255.0f)),
			pEndpoint_vals, pWeight_vals0, pWeight_vals1, cur_blk_error);
		(void)improved_flag;

		return cur_blk_error;
	}

	// dispatcher
	uint64_t cem_encode_pixels(
		uint32_t cem_index, int ccs_index,
		const pixel_stats_t& pixel_stats, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		uint8_t* pEndpoint_vals, uint8_t* pWeight_vals0, uint8_t* pWeight_vals1, uint64_t cur_blk_error,
		bool use_blue_contraction, bool * pTry_direct_encoding_flag)
	{
		assert(g_initialized);
		assert((ccs_index >= -1) && (ccs_index <= 3));
		assert(astc_helpers::is_cem_ldr(cem_index));
		assert(pEndpoint_vals);
		assert(pWeight_vals0);

		const bool dual_plane = (ccs_index >= 0);
		
		if (pTry_direct_encoding_flag)
			*pTry_direct_encoding_flag = false;

		uint64_t blk_error = UINT64_MAX;

		switch (cem_index)
		{
		case astc_helpers::CEM_LDR_LUM_DIRECT:
		{
			assert(!dual_plane);

			blk_error = encode_cem0_4(
				cem_index,
				pixel_stats, enc_params,
				endpoint_ise_range, weight_ise_range,
				pEndpoint_vals, pWeight_vals0, cur_blk_error);

			break;
		}
		case astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT:
		{
			if (dual_plane)
			{
				assert(ccs_index == 3);
				assert(pWeight_vals1);

				blk_error = encode_cem4_dp_a(
					cem_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, pWeight_vals1, cur_blk_error);
			}
			else
			{
				blk_error = encode_cem0_4(
					cem_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, cur_blk_error);
			}
			break;
		}

		case astc_helpers::CEM_LDR_RGB_DIRECT:
		case astc_helpers::CEM_LDR_RGBA_DIRECT:
		case astc_helpers::CEM_LDR_RGB_BASE_PLUS_OFFSET:
		case astc_helpers::CEM_LDR_RGBA_BASE_PLUS_OFFSET:
		{
			if (dual_plane)
			{
				assert(pWeight_vals1);
				blk_error = encode_cem8_12_9_13_dp(
					cem_index, ccs_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, pWeight_vals1, cur_blk_error, use_blue_contraction, pTry_direct_encoding_flag);
			}
			else
			{
				blk_error = encode_cem8_12_9_13(
					cem_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, cur_blk_error, use_blue_contraction, pTry_direct_encoding_flag);
			}
			break;
		}
		case astc_helpers::CEM_LDR_RGB_BASE_SCALE:
		{
			if (dual_plane)
			{
				assert(ccs_index <= 2);
				assert(pWeight_vals1);

				blk_error = encode_cem6_10_dp_rgb(
					cem_index, ccs_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, pWeight_vals1, cur_blk_error);
			}
			else
			{
				blk_error = encode_cem6_10(
					cem_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, cur_blk_error);
			}
			break;
		}
		case astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A:
		{
			if (dual_plane)
			{
				assert(pWeight_vals1);

				if (ccs_index == 3)
				{
					blk_error = encode_cem10_dp_a(
						cem_index,
						pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						pEndpoint_vals, pWeight_vals0, pWeight_vals1, cur_blk_error);
				}
				else
				{
					blk_error = encode_cem6_10_dp_rgb(
						cem_index, ccs_index,
						pixel_stats, enc_params,
						endpoint_ise_range, weight_ise_range,
						pEndpoint_vals, pWeight_vals0, pWeight_vals1, cur_blk_error);
				}
			}
			else
			{
				blk_error = encode_cem6_10(
					cem_index,
					pixel_stats, enc_params,
					endpoint_ise_range, weight_ise_range,
					pEndpoint_vals, pWeight_vals0, cur_blk_error);
			}
			break;
		}
		default:
		{
			assert(0);
			break;
		}
		}

		return blk_error;
	}

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

	float surrogate_evaluate_rgba_sp(const pixel_stats_t& ps, const vec4F& l, const vec4F& h, float* pWeights0, uint32_t num_weight_levels, 
		const cem_encode_params& enc_params, uint32_t flags)
	{
		assert(g_initialized);
		assert((ps.m_num_pixels) && (ps.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert(pWeights0);

		const float wr = (float)enc_params.m_comp_weights[0], wg = (float)enc_params.m_comp_weights[1],
			wb = (float)enc_params.m_comp_weights[2], wa = (float)enc_params.m_comp_weights[3];

		float total_err = 0;
				
		const bool compute_error = ((flags & cFlagNoError) == 0);

		float lr = l[0], lg = l[1], lb = l[2], la = l[3];
		float dr = h[0] - lr, dg = h[1] - lg, db = h[2] - lb, da = h[3] - la;
		float delta_col_nrm = dr * dr + dg * dg + db * db + da * da;

		if (flags & cFlagDisableQuant)
		{
			float f = (float)1.0f / (delta_col_nrm + REALLY_SMALL_FLOAT_VAL);

			lr *= -dr; lg *= -dg; lb *= -db; la *= -da;

			dr *= f; dg *= f; db *= f; da *= f;
			float l_sum = (lr + lg + lb + la) * f;

			for (uint32_t i = 0; i < ps.m_num_pixels; i++)
			{
				const vec4F& p = ps.m_pixels_f[i];
				const float r = p[0], g = p[1], b = p[2], a = p[3];

				float w = r * dr + g * dg + b * db + a * da + l_sum;

				if (w < 0.0f)
					w = 0.0f;
				else if (w > 1.0f)
					w = 1.0f;

				pWeights0[i] = w;

				if (compute_error)
				{
					float one_minus_w = 1.0f - w;

					float dec_r = l[0] * one_minus_w + h[0] * w;
					float dec_g = l[1] * one_minus_w + h[1] * w;
					float dec_b = l[2] * one_minus_w + h[2] * w;
					float dec_a = l[3] * one_minus_w + h[3] * w;

					float diff_r = r - dec_r;
					float diff_g = g - dec_g;
					float diff_b = b - dec_b;
					float diff_a = a - dec_a;

					total_err += (wr * diff_r * diff_r) + (wg * diff_g * diff_g) + (wb * diff_b * diff_b) + (wa * diff_a * diff_a);
				}

			} // i
		}
		else
		{
			const float inv_weight_levels = 1.0f / (float)(num_weight_levels - 1);
						
			float f = (float)(num_weight_levels - 1) / (delta_col_nrm + REALLY_SMALL_FLOAT_VAL);

			lr *= -dr; lg *= -dg; lb *= -db; la *= -da;

			dr *= f; dg *= f; db *= f; da *= f;
			float l_sum_biased = (lr + lg + lb + la) * f + .5f;
						
			for (uint32_t i = 0; i < ps.m_num_pixels; i++)
			{
				const vec4F& p = ps.m_pixels_f[i];
				const float r = p[0], g = p[1], b = p[2], a = p[3];

				float w = (float)fast_floorf_int(r * dr + g * dg + b * db + a * da + l_sum_biased) * inv_weight_levels;

				if (w < 0.0f)
					w = 0.0f;
				else if (w > 1.0f)
					w = 1.0f;

				pWeights0[i] = w;

				if (compute_error)
				{
					float one_minus_w = 1.0f - w;

					float dec_r = l[0] * one_minus_w + h[0] * w;
					float dec_g = l[1] * one_minus_w + h[1] * w;
					float dec_b = l[2] * one_minus_w + h[2] * w;
					float dec_a = l[3] * one_minus_w + h[3] * w;

					float diff_r = r - dec_r;
					float diff_g = g - dec_g;
					float diff_b = b - dec_b;
					float diff_a = a - dec_a;

					total_err += (wr * diff_r * diff_r) + (wg * diff_g * diff_g) + (wb * diff_b * diff_b) + (wa * diff_a * diff_a);
				}

			} // i
		}

		return total_err;
	}

	float surrogate_evaluate_rgba_dp(uint32_t ccs_index, const pixel_stats_t& ps, const vec4F& l, const vec4F& h, float* pWeights0, float* pWeights1, uint32_t num_weight_levels, 
		const cem_encode_params& enc_params, uint32_t flags)
	{
		assert(g_initialized);
		assert(ccs_index <= 3);
		assert((ps.m_num_pixels) && (ps.m_num_pixels <= ASTC_LDR_MAX_BLOCK_PIXELS));
		assert(pWeights0 && pWeights1);

		const float inv_weight_levels = 1.0f / (float)(num_weight_levels - 1);

		const uint32_t c0 = (ccs_index + 1) & 3, c1 = (ccs_index + 2) & 3, c2 = (ccs_index + 3) & 3;

		const float orig_lx = l[c0], orig_ly = l[c1], orig_lz = l[c2], orig_lw = l[ccs_index];
		const float orig_hx = h[c0], orig_hy = h[c1], orig_hz = h[c2], orig_hw = h[ccs_index];
		
		const float wx = (float)enc_params.m_comp_weights[c0], wy = (float)enc_params.m_comp_weights[c1],
			wz = (float)enc_params.m_comp_weights[c2], ww = (float)enc_params.m_comp_weights[ccs_index];
		
		float total_err = 0;

		const bool compute_error = ((flags & cFlagNoError) == 0);
				
		if (flags & cFlagDisableQuant)
		{
			// Plane 0
			{
				float dx = orig_hx - orig_lx, dy = orig_hy - orig_ly, dz = orig_hz - orig_lz;

				float delta_col_nrm = dx * dx + dy * dy + dz * dz;

				float f = (float)1.0f / (delta_col_nrm + REALLY_SMALL_FLOAT_VAL);

				float lx = orig_lx, ly = orig_ly, lz = orig_lz;
				lx *= -dx; ly *= -dy; lz *= -dz;

				dx *= f; dy *= f; dz *= f;
				float l_sum = (lx + ly + lz) * f;

				for (uint32_t i = 0; i < ps.m_num_pixels; i++)
				{
					const vec4F& p = ps.m_pixels_f[i];
					const float x = p[c0], y = p[c1], z = p[c2];

					float weight = x * dx + y * dy + z * dz + l_sum;

					if (weight < 0.0f)
						weight = 0.0f;
					else if (weight > 1.0f)
						weight = 1.0f;

					pWeights0[i] = weight;

					if (compute_error)
					{
						float one_minus_weight = 1.0f - weight;

						float dec_x = orig_lx * one_minus_weight + orig_hx * weight;
						float dec_y = orig_ly * one_minus_weight + orig_hy * weight;
						float dec_z = orig_lz * one_minus_weight + orig_hz * weight;

						float diff_x = x - dec_x;
						float diff_y = y - dec_y;
						float diff_z = z - dec_z;

						total_err += (wx * diff_x * diff_x) + (wy * diff_y * diff_y) + (wz * diff_z * diff_z);
					}

				} // i
			}

			// Plane 1
			{
				const float delta_w = orig_hw - orig_lw;
				const float f = (fabsf(delta_w) > REALLY_SMALL_FLOAT_VAL) ? (1.0f / delta_w) : 0.0f;

				for (uint32_t i = 0; i < ps.m_num_pixels; i++)
				{
					const vec4F& p = ps.m_pixels_f[i];
					const float w = p[ccs_index];

					float weight = (w - orig_lw) * f;

					if (weight < 0.0f)
						weight = 0.0f;
					else if (weight > 1.0f)
						weight = 1.0f;

					pWeights1[i] = weight;

					if (compute_error)
					{
						// Error for DP here is 0 if there's no quant and L/H are sufficient to cover the entire span.
						if ((w < orig_lw) || (w > orig_hw))
						{
							float one_minus_weight = 1.0f - weight;

							float dec_w = orig_lw * one_minus_weight + orig_hw * weight;

							float diff_w = w - dec_w;

							total_err += (ww * diff_w * diff_w);
						}
					}

				} // i
			}
		}
		else
		{
			// Plane 0
			{
				float dx = orig_hx - orig_lx, dy = orig_hy - orig_ly, dz = orig_hz - orig_lz;

				float delta_col_nrm = dx * dx + dy * dy + dz * dz;

				float f = (float)(num_weight_levels - 1) / (delta_col_nrm + REALLY_SMALL_FLOAT_VAL);

				float lx = orig_lx, ly = orig_ly, lz = orig_lz;
				lx *= -dx; ly *= -dy; lz *= -dz;

				dx *= f; dy *= f; dz *= f;
				float l_sum_biased = (lx + ly + lz) * f + .5f;

				for (uint32_t i = 0; i < ps.m_num_pixels; i++)
				{
					const vec4F& p = ps.m_pixels_f[i];
					const float x = p[c0], y = p[c1], z = p[c2];

					float weight = (float)fast_floorf_int(x * dx + y * dy + z * dz + l_sum_biased) * inv_weight_levels;

					if (weight < 0.0f)
						weight = 0.0f;
					else if (weight > 1.0f)
						weight = 1.0f;

					pWeights0[i] = weight;

					if (compute_error)
					{
						float one_minus_weight = 1.0f - weight;

						float dec_x = orig_lx * one_minus_weight + orig_hx * weight;
						float dec_y = orig_ly * one_minus_weight + orig_hy * weight;
						float dec_z = orig_lz * one_minus_weight + orig_hz * weight;

						float diff_x = x - dec_x;
						float diff_y = y - dec_y;
						float diff_z = z - dec_z;

						total_err += (wx * diff_x * diff_x) + (wy * diff_y * diff_y) + (wz * diff_z * diff_z);
					}

				} // i
			}

			// Plane 1
			{
				const float delta_w = orig_hw - orig_lw;
				const float f = (fabs(delta_w) > REALLY_SMALL_FLOAT_VAL) ? ((float)(num_weight_levels - 1) / delta_w) : 0.0f;

				for (uint32_t i = 0; i < ps.m_num_pixels; i++)
				{
					const vec4F& p = ps.m_pixels_f[i];
					const float w = p[ccs_index];

					float weight = (float)fast_floorf_int((w - orig_lw) * f + .5f) * inv_weight_levels;

					if (weight < 0.0f)
						weight = 0.0f;
					else if (weight > 1.0f)
						weight = 1.0f;

					pWeights1[i] = weight;

					if (compute_error)
					{
						float one_minus_weight = 1.0f - weight;

						float dec_w = orig_lw * one_minus_weight + orig_hw * weight;

						float diff_w = w - dec_w;

						total_err += (ww * diff_w * diff_w);
					}

				} // i
			}
		}

		return total_err;
	}

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

	float surrogate_quant_endpoint_val(float e, uint32_t num_endpoint_levels, uint32_t flags)
	{
		assert((e >= 0.0f) && (e <= 1.0f));

		if (flags & cFlagDisableQuant)
			return e;

		const float endpoint_levels_minus_1 = (float)(num_endpoint_levels - 1);
		const float inv_endpoint_levels = 1.0f / endpoint_levels_minus_1;
		return (float)fast_roundf_pos_int(e * endpoint_levels_minus_1) * inv_endpoint_levels;
	}

	vec4F surrogate_quant_endpoint(const vec4F& e, uint32_t num_endpoint_levels, uint32_t flags)
	{
		if (flags & cFlagDisableQuant)
			return e;

		const float endpoint_levels_minus_1 = (float)(num_endpoint_levels - 1);
		const float inv_endpoint_levels = 1.0f / endpoint_levels_minus_1;

		assert((e[0] >= 0.0f) && (e[0] <= 1.0f));
		assert((e[1] >= 0.0f) && (e[1] <= 1.0f));
		assert((e[2] >= 0.0f) && (e[2] <= 1.0f));
		assert((e[3] >= 0.0f) && (e[3] <= 1.0f));

		vec4F res;
		res[0] = (float)fast_roundf_pos_int(e[0] * endpoint_levels_minus_1) * inv_endpoint_levels;
		res[1] = (float)fast_roundf_pos_int(e[1] * endpoint_levels_minus_1) * inv_endpoint_levels;
		res[2] = (float)fast_roundf_pos_int(e[2] * endpoint_levels_minus_1) * inv_endpoint_levels;
		res[3] = (float)fast_roundf_pos_int(e[3] * endpoint_levels_minus_1) * inv_endpoint_levels;

		return res;
	}

	static uint32_t get_num_weight_levels(uint32_t weight_ise_range)
	{
		// astc_helpers::BISE_64_LEVELS=raw weights ([0,64], NOT [0,63])
		const uint32_t num_weight_levels = (weight_ise_range == astc_helpers::BISE_64_LEVELS) ? 65 : astc_helpers::get_ise_levels(weight_ise_range);
		return num_weight_levels;
	}

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

	static float cem_surrogate_encode_cem6_10_sp(
		uint32_t cem_index,
		const pixel_stats_t& ps, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		vec4F& low_endpoint, vec4F& high_endpoint, float &s, float* pWeights0, uint32_t flags)
	{
		const uint32_t num_endpoint_levels = astc_helpers::get_ise_levels(endpoint_ise_range);

		// astc_helpers::BISE_64_LEVELS=raw weights ([0,64], NOT [0,63])
		const uint32_t num_weight_levels = get_num_weight_levels(weight_ise_range);

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A);

		float d_min = BIG_FLOAT_VAL, d_max = -BIG_FLOAT_VAL;
		
		for (uint32_t i = 0; i < ps.m_num_pixels; i++)
		{
			const vec4F p(ps.m_pixels_f[i]);

			float dot = p.dot3(ps.m_zero_rel_axis3);

			if (dot < d_min)
				d_min = dot;

			if (dot > d_max)
				d_max = dot;
		}

		vec3F low_color3_f(d_min * ps.m_zero_rel_axis3);
		low_color3_f.clamp(0.0f, 1.0f);

		vec3F high_color3_f(d_max * ps.m_zero_rel_axis3);
		high_color3_f.clamp(0.0f, 1.0f);

		const float MAX_S = 255.0f / 256.0f;
		
		float scale = MAX_S;

		float d = low_color3_f.dot(high_color3_f);
		float nrm = high_color3_f.norm();
		if (nrm > 0.0f)
			scale = d / nrm;
				
		scale = clamp(scale, 0.0f, MAX_S);
		
		scale = surrogate_quant_endpoint_val(scale * (256.0f / 255.0f), num_endpoint_levels, flags);

		s = scale;

		high_endpoint = surrogate_quant_endpoint(vec4F(high_color3_f[0], high_color3_f[1], high_color3_f[2], cem_has_alpha ? ps.m_max_f[3] : 1.0f), num_endpoint_levels, flags);

		low_endpoint = vec4F(high_endpoint[0] * scale, high_endpoint[1] * scale, high_endpoint[2] * scale, cem_has_alpha ? ps.m_min_f[3] : 1.0f);

		return surrogate_evaluate_rgba_sp(ps, low_endpoint, high_endpoint, pWeights0, num_weight_levels, enc_params, flags);
	}

	static float cem_surrogate_encode_cem6_10_dp(
		uint32_t cem_index, uint32_t ccs_index,
		const pixel_stats_t& ps, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		vec4F& low_endpoint, vec4F& high_endpoint, float& s, float* pWeights0, float* pWeights1, uint32_t flags)
	{
		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A);
		BASISU_NOTE_UNUSED(cem_has_alpha);
		
		// astc_helpers::BISE_64_LEVELS=raw weights ([0,64], NOT [0,63])
		const uint32_t num_weight_levels = get_num_weight_levels(weight_ise_range);

		assert(cem_has_alpha || (ccs_index <= 2));
				
		float temp_weights[astc_ldr::ASTC_LDR_MAX_BLOCK_PIXELS];
		cem_surrogate_encode_cem6_10_sp(
			(ccs_index == 3) ? (uint32_t)astc_helpers::CEM_LDR_RGB_BASE_SCALE : cem_index,
			ps, enc_params, endpoint_ise_range, weight_ise_range, low_endpoint, high_endpoint, s, temp_weights, flags);

		if (ccs_index == 3)
		{
			low_endpoint[3] = ps.m_min_f[3];
			high_endpoint[3] = ps.m_max_f[3];
		}

		return surrogate_evaluate_rgba_dp(ccs_index, ps, low_endpoint, high_endpoint, pWeights0, pWeights1, num_weight_levels, enc_params, flags);
	}

	static float cem_surrogate_encode_cem8_12_sp(
		uint32_t cem_index,
		const pixel_stats_t& ps, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		vec4F& low_endpoint, vec4F& high_endpoint, float* pWeights0, uint32_t flags)
	{
		const uint32_t num_endpoint_levels = astc_helpers::get_ise_levels(endpoint_ise_range);
		
		// astc_helpers::BISE_64_LEVELS=raw weights ([0,64], NOT [0,63])
		const uint32_t num_weight_levels = get_num_weight_levels(weight_ise_range);

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT);
		const uint32_t num_comps = cem_has_alpha ? 4 : 3;

		float d_min = BIG_FLOAT_VAL, d_max = -BIG_FLOAT_VAL;
		uint32_t l_idx = 0, h_idx = 0;

		for (uint32_t i = 0; i < ps.m_num_pixels; i++)
		{
			const vec4F p(ps.m_pixels_f[i] - ps.m_mean_f);

			float dot = cem_has_alpha ? p.dot(ps.m_mean_rel_axis4) : p.dot3(ps.m_mean_rel_axis3);

			if (dot < d_min)
			{
				d_min = dot;
				l_idx = i;
			}

			if (dot > d_max)
			{
				d_max = dot;
				h_idx = i;
			}
		}
								
		low_endpoint = surrogate_quant_endpoint(ps.m_pixels_f[l_idx], num_endpoint_levels, flags);
		high_endpoint = surrogate_quant_endpoint(ps.m_pixels_f[h_idx], num_endpoint_levels, flags);

		if (!cem_has_alpha)
		{
			low_endpoint[3] = 1.0f;
			high_endpoint[3] = 1.0f;
		}

		if (low_endpoint.dot(vec4F(1.0f)) > high_endpoint.dot(vec4F(1.0f)))
			std::swap(low_endpoint, high_endpoint);
		
		if ((flags & cFlagDisableQuant) == 0)
		{
			for (uint32_t i = 0; i < num_comps; i++)
			{
				if ((low_endpoint[i] == high_endpoint[i]) && (ps.m_min_f[i] != ps.m_max_f[i]))
				{
					const float inv_endpoint_levels = 1.0f / (float)(num_endpoint_levels - 1);

					float best_dist = BIG_FLOAT_VAL;
					float best_l = 0.0f, best_h = 0.0f;

					for (int ld = -2; ld <= 0; ld++)
					{
						float actual_l = saturate(low_endpoint[i] + (float)ld * inv_endpoint_levels);

						for (int hd = 0; hd <= 2; hd++)
						{
							float actual_h = saturate(high_endpoint[i] + (float)hd * inv_endpoint_levels);

							float v0 = lerp(actual_l, actual_h, 1.0f / 3.0f);
							float v1 = lerp(actual_l, actual_h, 2.0f / 3.0f);
							assert(v0 <= v1);

							float dist0 = v0 - ps.m_min_f[0];
							float dist1 = v1 - ps.m_max_f[0];

							float total_dist = dist0 * dist0 + dist1 * dist1;
							if (total_dist < best_dist)
							{
								best_dist = total_dist;
								best_l = actual_l;
								best_h = actual_h;
							}
						} // hd
					} // ld

					low_endpoint[i] = best_l;
					high_endpoint[i] = best_h;
				}
			}
		}
						
		return surrogate_evaluate_rgba_sp(ps, low_endpoint, high_endpoint, pWeights0, num_weight_levels, enc_params, flags);
	}

	static float cem_surrogate_encode_cem8_12_dp(
		uint32_t cem_index, uint32_t ccs_index,
		const pixel_stats_t& ps, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		vec4F& low_endpoint, vec4F& high_endpoint, float* pWeights0, float *pWeights1, uint32_t flags)
	{
		assert(ccs_index <= 3);
		const uint32_t num_endpoint_levels = astc_helpers::get_ise_levels(endpoint_ise_range);

		// astc_helpers::BISE_64_LEVELS=raw weights ([0,64], NOT [0,63])
		const uint32_t num_weight_levels = get_num_weight_levels(weight_ise_range);

		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_RGBA_DIRECT);
		const uint32_t num_comps = cem_has_alpha ? 4 : 3;

		assert(cem_has_alpha || (ccs_index <= 2));

		vec4F flattened_pixels[ASTC_LDR_MAX_BLOCK_PIXELS];
		for (uint32_t i = 0; i < ps.m_num_pixels; i++)
		{
			flattened_pixels[i] = ps.m_pixels_f[i];
			
			flattened_pixels[i][ccs_index] = 0.0f;
			
			if (!cem_has_alpha)
				flattened_pixels[i][3] = 0.0f;
		}

		vec4F flattened_pixels_mean(ps.m_mean_f);
		flattened_pixels_mean[ccs_index] = 0.0f;
		
		if (!cem_has_alpha)
			flattened_pixels_mean[3] = 0.0f;

		// suppress bogus gcc warning on flattened_pixels
#ifndef __clang__
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#endif
		const vec4F flattened_axis(calc_pca_4D(ps.m_num_pixels, flattened_pixels, flattened_pixels_mean));

#ifndef __clang__
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif

		float best_dl = BIG_FLOAT_VAL, best_dh = -BIG_FLOAT_VAL;
		int best_l_index = 0, best_h_index = 0;

		for (uint32_t c = 0; c < ps.m_num_pixels; c++)
		{
			const vec4F px(flattened_pixels[c] - flattened_pixels_mean);

			float p = px.dot(flattened_axis);
			if (p < best_dl)
			{
				best_dl = p;
				best_l_index = c;
			}

			if (p > best_dh)
			{
				best_dh = p;
				best_h_index = c;
			}
		} // c
				
		vec4F low_color_f(ps.m_pixels_f[best_l_index]), high_color_f(ps.m_pixels_f[best_h_index]);

		low_color_f[ccs_index] = 0.0f;
		high_color_f[ccs_index] = 0.0f;

		if (!cem_has_alpha)
		{
			low_color_f[3] = 1.0f;
			high_color_f[3] = 1.0f;
		}

		if (low_color_f.dot(vec4F(1.0f)) > high_color_f.dot(vec4F(1.0f)))
			std::swap(low_color_f, high_color_f);
				
		low_color_f[ccs_index] = ps.m_min_f[ccs_index];
		high_color_f[ccs_index] = ps.m_max_f[ccs_index];

		if (!cem_has_alpha)
		{
			low_color_f[3] = 1.0f;
			high_color_f[3] = 1.0f;
		}
						
		low_endpoint = surrogate_quant_endpoint(low_color_f, num_endpoint_levels, flags);
		high_endpoint = surrogate_quant_endpoint(high_color_f, num_endpoint_levels, flags);

		if ((flags & cFlagDisableQuant) == 0)
		{
			for (uint32_t i = 0; i < num_comps; i++)
			{
				if ((low_endpoint[i] == high_endpoint[i]) && (ps.m_min_f[i] != ps.m_max_f[i]))
				{
					const float inv_endpoint_levels = 1.0f / (float)(num_endpoint_levels - 1);

					float best_dist = BIG_FLOAT_VAL;
					float best_l = 0.0f, best_h = 0.0f;

					for (int ld = -2; ld <= 0; ld++)
					{
						float actual_l = saturate(low_endpoint[i] + (float)ld * inv_endpoint_levels);

						for (int hd = 0; hd <= 2; hd++)
						{
							float actual_h = saturate(high_endpoint[i] + (float)hd * inv_endpoint_levels);

							float v0 = lerp(actual_l, actual_h, 1.0f / 3.0f);
							float v1 = lerp(actual_l, actual_h, 2.0f / 3.0f);
							assert(v0 <= v1);

							//if (v0 > v1)
							//	std::swap(v0, v1);

							float dist0 = v0 - ps.m_min_f[0];
							float dist1 = v1 - ps.m_max_f[0];

							float total_dist = dist0 * dist0 + dist1 * dist1;
							if (total_dist < best_dist)
							{
								best_dist = total_dist;
								best_l = actual_l;
								best_h = actual_h;
							}
						} // hd
					} // ld

					low_endpoint[i] = best_l;
					high_endpoint[i] = best_h;
				}
			}
		}

		return surrogate_evaluate_rgba_dp(ccs_index, ps, low_endpoint, high_endpoint, pWeights0, pWeights1, num_weight_levels, enc_params, flags);
	}

	static float cem_surrogate_encode_cem0_4_sp_or_dp(
		uint32_t cem_index, int ccs_index, 
		const pixel_stats_t& ps, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		vec4F& low_endpoint, vec4F& high_endpoint, float* pWeights0, float *pWeights1, uint32_t flags)
	{
		const bool cem_has_alpha = (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT);
		const bool dual_plane = (ccs_index == 3);

		if (cem_index == astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT)
		{
			assert((ccs_index == -1) || (ccs_index == 3));
		}
		else
		{
			assert(cem_index == astc_helpers::CEM_LDR_LUM_DIRECT);
			assert(ccs_index == -1);
		}

		const uint32_t num_endpoint_levels = astc_helpers::get_ise_levels(endpoint_ise_range);
		const uint32_t num_weight_levels = get_num_weight_levels(weight_ise_range);

		float lum_l = BIG_FLOAT_VAL, lum_h = -BIG_FLOAT_VAL;

		for (uint32_t i = 0; i < ps.m_num_pixels; i++)
		{
			const vec4F& px = ps.m_pixels_f[i];

			float l = (px[0] + px[1] + px[2]) * (1.0f / 3.0f);

			lum_l = minimum(lum_l, l);
			lum_h = maximum(lum_h, l);
		}

		const float a_l = cem_has_alpha ? ps.m_min_f[3] : 1.0f;
		const float a_h = cem_has_alpha ? ps.m_max_f[3] : 1.0f;

		low_endpoint.set(lum_l, lum_l, lum_l, a_l);
		high_endpoint.set(lum_h, lum_h, lum_h, a_h);

		low_endpoint = surrogate_quant_endpoint(low_endpoint, num_endpoint_levels, flags);
		high_endpoint = surrogate_quant_endpoint(high_endpoint, num_endpoint_levels, flags);

		if (dual_plane)
			return surrogate_evaluate_rgba_dp(ccs_index, ps, low_endpoint, high_endpoint, pWeights0, pWeights1, num_weight_levels, enc_params, flags);
		else
			return surrogate_evaluate_rgba_sp(ps, low_endpoint, high_endpoint, pWeights0, num_weight_levels, enc_params, flags);
	}
	
	float cem_surrogate_encode_pixels(
		uint32_t cem_index, int ccs_index,
		const pixel_stats_t& ps, const cem_encode_params& enc_params,
		uint32_t endpoint_ise_range, uint32_t weight_ise_range,
		vec4F &low_endpoint, vec4F &high_endpoint, float &s, float* pWeights0, float* pWeights1, uint32_t flags)
	{
		assert(g_initialized);
		assert((ccs_index >= -1) && (ccs_index <= 3));
		assert(astc_helpers::is_cem_ldr(cem_index));
		assert(pWeights0 && pWeights1);

		const bool dual_plane = (ccs_index >= 0);

		switch (cem_index)
		{
		case astc_helpers::CEM_LDR_LUM_DIRECT:
		case astc_helpers::CEM_LDR_LUM_ALPHA_DIRECT:
		{
			return cem_surrogate_encode_cem0_4_sp_or_dp(
				cem_index, ccs_index,
				ps, enc_params,
				endpoint_ise_range, weight_ise_range,
				low_endpoint, high_endpoint, pWeights0, pWeights1, flags);
		}
		case astc_helpers::CEM_LDR_RGB_BASE_SCALE:
		case astc_helpers::CEM_LDR_RGB_BASE_SCALE_PLUS_TWO_A:
		{
			if (dual_plane)
			{
				return cem_surrogate_encode_cem6_10_dp(
					cem_index, ccs_index,
					ps, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_endpoint, high_endpoint, s, pWeights0, pWeights1, flags);
			}
			else
			{
				return cem_surrogate_encode_cem6_10_sp(
					cem_index,
					ps, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_endpoint, high_endpoint, s, pWeights0, flags);
			}
			break;
		}
		case astc_helpers::CEM_LDR_RGB_DIRECT:
		case astc_helpers::CEM_LDR_RGBA_DIRECT:
		{
			if (dual_plane)
			{
				return cem_surrogate_encode_cem8_12_dp(
					cem_index, ccs_index,
					ps, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_endpoint, high_endpoint, pWeights0, pWeights1, flags);
			}
			else
			{
				return cem_surrogate_encode_cem8_12_sp(
					cem_index,
					ps, enc_params,
					endpoint_ise_range, weight_ise_range,
					low_endpoint, high_endpoint, pWeights0, flags);
			}
			
			break;
		}
		default:
			assert(0);
			break;
		}

		return BIG_FLOAT_VAL;
	}

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

	uint8_t g_part3_mapping[NUM_PART3_MAPPINGS][3] =
	{
		{ 0, 1, 2 },
		{ 1, 2, 0 },
		{ 2, 0, 1 },
		{ 0, 2, 1 },
		{ 1, 0, 2 },
		{ 2, 1, 0 }
	};

	partition_pattern_vec::partition_pattern_vec()
	{
		clear();
	}

	partition_pattern_vec::partition_pattern_vec(const partition_pattern_vec& other)
	{
		*this = other;
	}

	partition_pattern_vec::partition_pattern_vec(uint32_t width, uint32_t height, const uint8_t *pParts) :
		m_width(width), m_height(height)
	{
		if (pParts)
		{
			memcpy(m_parts, pParts, get_total());
		}
	}
		
	void partition_pattern_vec::init(uint32_t width, uint32_t height, const uint8_t* pParts)
	{
		m_width = width;
		m_height = height;
		if (pParts)
		{
			const uint32_t num_texels = get_total();
			memcpy(m_parts, pParts, num_texels);
		}
	}

	void partition_pattern_vec::clear()
	{
		m_width = 0;
		m_height = 0;
		memset(m_parts, 0, sizeof(m_parts));
	}

	partition_pattern_vec& partition_pattern_vec::operator= (const partition_pattern_vec& rhs)
	{
		if (this == &rhs)
			return *this;

		m_width = rhs.m_width;
		m_height = rhs.m_height;
		memcpy(m_parts, rhs.m_parts, get_total());
		
		return *this;
	}
			
	// originally was SAD distance, but that is slower
	int partition_pattern_vec::get_squared_distance(const partition_pattern_vec& other) const
	{
		const uint32_t total_pixels = get_total();

#if 0
		int total_dist = 0;
		for (uint32_t i = 0; i < total_pixels; i++)
			total_dist += squarei((int)m_parts[i] - (int)other.m_parts[i]);

		return total_dist;
#else
		int total_dist0 = 0, total_dist1 = 0, total_dist2 = 0, total_dist3 = 0;

		uint32_t idx = 0; 
		while ((idx + 4) <= total_pixels)
		{
			total_dist0 += squarei((int)m_parts[idx] - (int)other.m_parts[idx]);
			total_dist1 += squarei((int)m_parts[idx + 1] - (int)other.m_parts[idx + 1]);
			total_dist2 += squarei((int)m_parts[idx + 2] - (int)other.m_parts[idx + 2]);
			total_dist3 += squarei((int)m_parts[idx + 3] - (int)other.m_parts[idx + 3]);

			idx += 4;
		}

		while (idx < total_pixels)
		{
			total_dist0 += squarei((int)m_parts[idx] - (int)other.m_parts[idx]);
			++idx;
		}

		int total_dist = total_dist0 + total_dist1 + total_dist2 + total_dist3;

		return total_dist;
#endif
	}

	int partition_pattern_vec::get_squared_distance_2subsets(const partition_pattern_vec& other) const
	{
		const uint32_t total_pixels = get_total();

		int total_dist0 = 0, total_dist1 = 0, total_dist2 = 0, total_dist3 = 0;

		uint32_t idx = 0;
		while ((idx + 4) <= total_pixels)
		{
			total_dist0 += (m_parts[idx] ^ other.m_parts[idx]);
			total_dist1 += (m_parts[idx + 1] ^ other.m_parts[idx + 1]);
			total_dist2 += (m_parts[idx + 2] ^ other.m_parts[idx + 2]);
			total_dist3 += (m_parts[idx + 3] ^ other.m_parts[idx + 3]);

			idx += 4;
		}

		while (idx < total_pixels)
		{
			total_dist0 += squarei(m_parts[idx] ^ other.m_parts[idx]);
			++idx;
		}

		int total_dist = total_dist0 + total_dist1 + total_dist2 + total_dist3;

		return total_dist;
	}

	int partition_pattern_vec::get_squared_distance(const partition_pattern_vec& other, uint32_t num_subsets, uint32_t other_perm_index) const
	{
		assert((num_subsets >= 2) && (num_subsets <= 3));

		if (num_subsets == 2)
		{
			assert(other_perm_index < 2);
		}
		else
		{
			assert(other_perm_index < NUM_PART3_MAPPINGS);
		}

		const uint32_t total_pixels = get_total();

		int total_dist = 0;

		for (uint32_t i = 0; i < total_pixels; i++)
		{
			int p = other.m_parts[i];

			if (num_subsets == 2)
				p ^= other_perm_index;
			else
				p = g_part3_mapping[other_perm_index][p];

			total_dist += squarei((int)m_parts[i] - p);
		}

		return total_dist;
	}

	partition_pattern_vec partition_pattern_vec::get_permuted2(uint32_t permute_index) const
	{
		assert(permute_index <= 1);
		const uint32_t total_pixels = get_total();

		partition_pattern_vec res(m_width, m_height);
		for (uint32_t i = 0; i < total_pixels; i++)
		{
			assert(m_parts[i] <= 1);
			res.m_parts[i] = (uint8_t)(m_parts[i] ^ permute_index);
		}

		return res;
	}
		
	partition_pattern_vec partition_pattern_vec::get_permuted3(uint32_t permute_index) const
	{
		assert(permute_index <= 5);
		const uint32_t total_pixels = get_total();

		partition_pattern_vec res(m_width, m_height);
		for (uint32_t i = 0; i < total_pixels; i++)
		{
			assert(m_parts[i] <= 2);
			res.m_parts[i] = g_part3_mapping[permute_index][m_parts[i]];
		}
				
		return res;
	}

	partition_pattern_vec partition_pattern_vec::get_canonicalized() const
	{
		partition_pattern_vec res(m_width, m_height);
			
		const uint32_t total_pixels = get_total();
						
		int new_labels[4] = { -1, -1, -1, -1 };

		uint32_t next_index = 0;
		for (uint32_t i = 0; i < total_pixels; i++)
		{
			uint32_t p = m_parts[i];
			assert(p <= 3);

			if (new_labels[p] == -1)
				new_labels[p] = next_index++;

			res.m_parts[i] = (uint8_t)new_labels[p];
		}
				
		return res;
	}

	// This requires no redundant patterns, i.e. all must be unique.
	bool vp_tree::init(uint32_t n, const partition_pattern_vec* pUnique_pats)
	{
		clear();

		uint_vec pat_indices(n);
		for (uint32_t i = 0; i < n; i++)
			pat_indices[i] = i;

		std::pair<int, float> root_idx = find_best_vantage_point(n, pUnique_pats, pat_indices);

		if (root_idx.first == -1)
			return false;

		m_nodes.resize(1);
		m_nodes[0].m_vantage_point = pUnique_pats[root_idx.first];
		m_nodes[0].m_point_index = root_idx.first;
		m_nodes[0].m_dist = root_idx.second;
		m_nodes[0].m_inner_node = -1;
		m_nodes[0].m_outer_node = -1;

		uint_vec inner_list, outer_list;

		inner_list.reserve(n / 2);
		outer_list.reserve(n / 2);

		for (uint32_t pat_index = 0; pat_index < n; pat_index++)
		{
			if ((int)pat_index == root_idx.first)
				continue;

			const float dist = m_nodes[0].m_vantage_point.get_distance(pUnique_pats[pat_index]);

			if (dist <= root_idx.second)
				inner_list.push_back(pat_index);
			else
				outer_list.push_back(pat_index);
		}

		if (inner_list.size())
		{
			m_nodes[0].m_inner_node = create_node(n, pUnique_pats, inner_list);
			if (m_nodes[0].m_inner_node < 0)
				return false;
		}

		if (outer_list.size())
		{
			m_nodes[0].m_outer_node = create_node(n, pUnique_pats, outer_list);
			if (m_nodes[0].m_outer_node < 0)
				return false;
		}

		return true;
	}

	void vp_tree::find_nearest(uint32_t num_subsets, const partition_pattern_vec& desired_pat, result_queue& results, uint32_t max_results) const
	{
		assert((num_subsets >= 2) && (num_subsets <= 3));

		results.clear();

		if (!m_nodes.size())
			return;

		uint32_t num_desired_pats;
		partition_pattern_vec desired_pats[NUM_PART3_MAPPINGS];

		if (num_subsets == 2)
		{
			num_desired_pats = 2;
			for (uint32_t i = 0; i < 2; i++)
				desired_pats[i] = desired_pat.get_permuted2(i);
		}
		else
		{
			num_desired_pats = NUM_PART3_MAPPINGS;
			for (uint32_t i = 0; i < NUM_PART3_MAPPINGS; i++)
				desired_pats[i] = desired_pat.get_permuted3(i);
		}

#if 0
		find_nearest_at_node(0, num_desired_pats, desired_pats, results, max_results);
#else
		find_nearest_at_node_non_recursive(0, num_desired_pats, desired_pats, results, max_results);
#endif
	}

	void vp_tree::find_nearest_at_node(int node_index, uint32_t num_desired_pats, const partition_pattern_vec* pDesired_pats, result_queue& results, uint32_t max_results) const
	{
		float best_dist_to_vantage = BIG_FLOAT_VAL;
		uint32_t best_mapping = 0;
		for (uint32_t i = 0; i < num_desired_pats; i++)
		{
			float dist = pDesired_pats[i].get_distance(m_nodes[node_index].m_vantage_point);
			if (dist < best_dist_to_vantage)
			{
				best_dist_to_vantage = dist;
				best_mapping = i;
			}
		}

		result r;
		r.m_dist = best_dist_to_vantage;
		r.m_mapping_index = best_mapping;
		r.m_pat_index = m_nodes[node_index].m_point_index;

		results.insert(r, max_results);

		if (best_dist_to_vantage <= m_nodes[node_index].m_dist)
		{
			// inner first
			if (m_nodes[node_index].m_inner_node >= 0)
				find_nearest_at_node(m_nodes[node_index].m_inner_node, num_desired_pats, pDesired_pats, results, max_results);

			if (m_nodes[node_index].m_outer_node >= 0)
			{
				if ((results.get_size() < max_results) ||
					((m_nodes[node_index].m_dist - best_dist_to_vantage) <= results.get_highest_dist())
					)
				{
					find_nearest_at_node(m_nodes[node_index].m_outer_node, num_desired_pats, pDesired_pats, results, max_results);
				}
			}
		}
		else
		{
			// outer first
			if (m_nodes[node_index].m_outer_node >= 0)
				find_nearest_at_node(m_nodes[node_index].m_outer_node, num_desired_pats, pDesired_pats, results, max_results);

			if (m_nodes[node_index].m_inner_node >= 0)
			{
				if ((results.get_size() < max_results) ||
					((best_dist_to_vantage - m_nodes[node_index].m_dist) <= results.get_highest_dist())
					)
				{
					find_nearest_at_node(m_nodes[node_index].m_inner_node, num_desired_pats, pDesired_pats, results, max_results);
				}
			}
		}
	}

	void vp_tree::find_nearest_at_node_non_recursive(int init_node_index, uint32_t num_desired_pats, const partition_pattern_vec* pDesired_pats, result_queue& results, uint32_t max_results) const
	{
		uint_vec node_stack;
		node_stack.reserve(16);
		node_stack.push_back(init_node_index);

		do
		{
			const uint32_t node_index = node_stack.back();
			node_stack.pop_back();

			float best_dist_to_vantage = BIG_FLOAT_VAL;
			uint32_t best_mapping = 0;
			for (uint32_t i = 0; i < num_desired_pats; i++)
			{
				float dist = pDesired_pats[i].get_distance(m_nodes[node_index].m_vantage_point);
				if (dist < best_dist_to_vantage)
				{
					best_dist_to_vantage = dist;
					best_mapping = i;
				}
			}

			result r;
			r.m_dist = best_dist_to_vantage;
			r.m_mapping_index = best_mapping;
			r.m_pat_index = m_nodes[node_index].m_point_index;

			results.insert(r, max_results);

			if (best_dist_to_vantage <= m_nodes[node_index].m_dist)
			{
				if (m_nodes[node_index].m_outer_node >= 0)
				{
					if ((results.get_size() < max_results) ||
						((m_nodes[node_index].m_dist - best_dist_to_vantage) <= results.get_highest_dist())
						)
					{
						node_stack.push_back(m_nodes[node_index].m_outer_node);
					}
				}

				// inner first
				if (m_nodes[node_index].m_inner_node >= 0)
				{
					node_stack.push_back(m_nodes[node_index].m_inner_node);
				}
			}
			else
			{
				if (m_nodes[node_index].m_inner_node >= 0)
				{
					if ((results.get_size() < max_results) ||
						((best_dist_to_vantage - m_nodes[node_index].m_dist) <= results.get_highest_dist())
						)
					{
						node_stack.push_back(m_nodes[node_index].m_inner_node);
					}
				}

				// outer first
				if (m_nodes[node_index].m_outer_node >= 0)
				{
					node_stack.push_back(m_nodes[node_index].m_outer_node);
				}
			}

		} while (!node_stack.empty());
	}

	// returns the index of the new node, or -1 on error
	int vp_tree::create_node(uint32_t n, const partition_pattern_vec* pUnique_pats, const uint_vec& pat_indices)
	{
		std::pair<int, float> root_idx = find_best_vantage_point(n, pUnique_pats, pat_indices);

		if (root_idx.first < 0)
			return -1;

		m_nodes.resize(m_nodes.size() + 1);
		const uint32_t new_node_index = m_nodes.size_u32() - 1;

		m_nodes[new_node_index].m_vantage_point = pUnique_pats[root_idx.first];
		m_nodes[new_node_index].m_point_index = root_idx.first;
		m_nodes[new_node_index].m_dist = root_idx.second;
		m_nodes[new_node_index].m_inner_node = -1;
		m_nodes[new_node_index].m_outer_node = -1;

		uint_vec inner_list, outer_list;

		inner_list.reserve(pat_indices.size_u32() / 2);
		outer_list.reserve(pat_indices.size_u32() / 2);

		for (uint32_t pat_indices_iter = 0; pat_indices_iter < pat_indices.size(); pat_indices_iter++)
		{
			const uint32_t pat_index = pat_indices[pat_indices_iter];

			if ((int)pat_index == root_idx.first)
				continue;

			const float dist = m_nodes[new_node_index].m_vantage_point.get_distance(pUnique_pats[pat_index]);

			if (dist <= root_idx.second)
				inner_list.push_back(pat_index);
			else
				outer_list.push_back(pat_index);
		}

		if (inner_list.size())
			m_nodes[new_node_index].m_inner_node = create_node(n, pUnique_pats, inner_list);

		if (outer_list.size())
			m_nodes[new_node_index].m_outer_node = create_node(n, pUnique_pats, outer_list);

		return new_node_index;
	}

	// returns the pattern index of the vantage point (-1 on error), and the optimal split distance
	std::pair<int, float> vp_tree::find_best_vantage_point(uint32_t num_unique_pats, const partition_pattern_vec* pUnique_pats, const uint_vec& pat_indices)
	{
		BASISU_NOTE_UNUSED(num_unique_pats);

		const uint32_t n = pat_indices.size_u32();

		assert(n);
		if (n == 1)
			return std::pair(pat_indices[0], 0.0f);

		float best_split_metric = -1.0f;
		int best_split_pat = -1;
		float best_split_dist = 0.0f;
		float best_split_var = 0.0f;

		basisu::vector< std::pair<float, uint32_t> > dists;
		dists.reserve(n);

		float_vec float_dists;
		float_dists.reserve(n);

		for (uint32_t pat_indices_iter = 0; pat_indices_iter < n; pat_indices_iter++)
		{
			const uint32_t split_pat_index = pat_indices[pat_indices_iter];
			assert(split_pat_index < num_unique_pats);

			const partition_pattern_vec& trial_vantage = pUnique_pats[split_pat_index];

			dists.resize(0);
			float_dists.resize(0);

			for (uint32_t j = 0; j < n; j++)
			{
				const uint32_t pat_index = pat_indices[j];
				assert(pat_index < num_unique_pats);

				if (pat_index == split_pat_index)
					continue;

				float dist = trial_vantage.get_distance(pUnique_pats[pat_index]);
				dists.emplace_back(std::pair(dist, pat_index));

				float_dists.push_back(dist);
			}

			stats<double> s;
			s.calc(float_dists.size_u32(), float_dists.data());

			std::sort(dists.begin(), dists.end(), [](const auto& a, const auto& b) {
				return a.first < b.first;
				});

			const uint32_t num_dists = dists.size_u32();
			float split_dist = dists[num_dists / 2].first;
			if ((num_dists & 1) == 0)
				split_dist = (split_dist + dists[(num_dists / 2) - 1].first) * .5f;

			uint32_t total_inner = 0, total_outer = 0;

			for (uint32_t j = 0; j < n; j++)
			{
				const uint32_t pat_index = pat_indices[j];
				if (pat_index == split_pat_index)
					continue;

				float dist = trial_vantage.get_distance(pUnique_pats[pat_index]);

				if (dist <= split_dist)
					total_inner++;
				else
					total_outer++;
			}

			float split_metric = (float)minimum(total_inner, total_outer) / (float)maximum(total_inner, total_outer);

			if ((split_metric > best_split_metric) ||
				((split_metric == best_split_metric) && (s.m_var > best_split_var)))
			{
				best_split_metric = split_metric;
				best_split_dist = split_dist;
				best_split_pat = split_pat_index;
				best_split_var = (float)s.m_var;
			}
		}

		return std::pair(best_split_pat, best_split_dist);
	}

	void partition_lsh_map::init(uint32_t num_subsets, uint32_t n, const partition_pattern_vec* pUnique_pats)
	{
		assert((num_subsets >= 2) && (num_subsets <= 3));
		assert(n && pUnique_pats);

		const uint32_t total_texels = pUnique_pats[0].get_width() * pUnique_pats[0].get_height();

		m_num_subsets = num_subsets;
		m_num_samples = (num_subsets == 2) ? 6 : 5;
		//m_num_hash_tabs = (total_texels > 36) ? 12 : 8;
		m_num_hash_tabs = 12;

		const uint32_t hash_key_shift = (num_subsets == 2) ? 1 : 2;

		const uint32_t hash_tab_size = 1 << (m_num_samples * hash_key_shift);

		assert(m_num_samples <= cMaxSamples);
		assert(m_num_hash_tabs <= cMaxHashTabs);

		basisu::rand rnd;
		rnd.seed(33155);

		clear_obj(m_sample_indices);
				
		for (uint32_t h = 0; h < m_num_hash_tabs; h++)
		{
			for (uint32_t s = 0; s < m_num_samples; s++)
			{
				for (uint32_t t = 0; t < 4; t++)
				{
					const uint8_t rnd_index = (uint8_t)rnd.irand(0, total_texels - 1);
					
					m_sample_indices[h][s] = rnd_index;

					uint32_t b;
					for (b = 0; b < s; b++)
						if (rnd_index == m_sample_indices[h][b])
							break;
					
					if (b == s)
						break;
				}
			}

			m_hash_tabs[h].resize(hash_tab_size);
		} // h

		for (uint32_t unique_pat_index = 0; unique_pat_index < n; unique_pat_index++)
		{
			const partition_pattern_vec* pVec = &pUnique_pats[unique_pat_index];

			const uint32_t max_perm_index = (num_subsets == 2) ? (uint32_t)partition_pattern_vec::cMaxPermute2Index : (uint32_t)partition_pattern_vec::cMaxPermute3Index;
			
			for (uint32_t perm_index = 0; perm_index <= max_perm_index; perm_index++)
			{
				const partition_pattern_vec pv((num_subsets == 2) ? pVec->get_permuted2(perm_index) : pVec->get_permuted3(perm_index));

				for (uint32_t hash_tab_index = 0; hash_tab_index < m_num_hash_tabs; hash_tab_index++)
				{
					uint32_t hash_key = 0;

					for (uint32_t sample_index = 0; sample_index < m_num_samples; sample_index++)
					{
						hash_key <<= hash_key_shift;
						
						const uint32_t texel_index = m_sample_indices[hash_tab_index][sample_index];
						assert(texel_index < total_texels);

						hash_key |= pv[texel_index];
					} // i

					m_hash_tabs[hash_tab_index][hash_key].push_back(unique_pat_index);

				} // h

			} // perm_index

		} // unique_pat_index
	}

	static inline size_t unique_duplicates_only(uint32_t* pResults, size_t total_results)
	{
		if (total_results < 2)
			return 0;

		size_t i = 0, out = 0;
		while (i < total_results)
		{
			size_t j = i + 1;
			while ((j < total_results) && (pResults[j] == pResults[i]))
				++j;

			// j - i is the run length; keep this value only if it appeared 2+ times
			if ((j - i) >= 2)
				pResults[out++] = pResults[i];

			i = j;
		}
		return out;
	}

	uint32_t partition_lsh_map::find(const partition_pattern_vec& desired_pat, uint32_t* pResults, uint32_t max_results, bool filter_flag) const
	{
		assert(pResults && max_results);

		uint32_t total_results = 0;

		const uint32_t hash_key_shift = (m_num_subsets == 2) ? 1 : 2;

		for (uint32_t hash_tab_index = 0; hash_tab_index < m_num_hash_tabs; hash_tab_index++)
		{
			uint32_t hash_key = 0;

			for (uint32_t sample_index = 0; sample_index < m_num_samples; sample_index++)
			{
				hash_key <<= hash_key_shift;

				const uint32_t texel_index = m_sample_indices[hash_tab_index][sample_index];
				
				const uint32_t subset_index = desired_pat[texel_index];
				assert(subset_index < m_num_subsets);

				hash_key |= subset_index;
			} // i

			const auto& h_tab = m_hash_tabs[hash_tab_index][hash_key];
			
			uint32_t num_to_copy = h_tab.size_u32();
			
			uint32_t room_remaining = max_results - total_results;
			if (!room_remaining)
				break;

			if (num_to_copy > room_remaining)
				num_to_copy = room_remaining;

			assert((total_results + num_to_copy) <= max_results);

			// num_to_copy can be 0 for an empty hash bucket, in which case get_ptr()
			// returns nullptr -- guard the copy so we don't pass null to memcpy
			// (UB / UBSAN nonnull violation even with a 0 length).
			if (num_to_copy)
				memcpy(pResults + total_results, h_tab.get_ptr(), num_to_copy * sizeof(uint32_t));
			total_results += num_to_copy;

			if (total_results >= max_results)
				break;
						
		} // h

		if (!total_results)
			return 0;

		std::sort(pResults, pResults + total_results);
		
		size_t num_unique;
		if (filter_flag)
		{
			num_unique = unique_duplicates_only(pResults, total_results);
			assert((num_unique <= total_results) && (num_unique <= max_results));
		}
		else
		{
			num_unique = std::unique(pResults, pResults + total_results) - pResults;
			assert((num_unique >= 1) && (num_unique <= total_results) && (num_unique <= max_results));
		}
				
		return (uint32_t)num_unique;
	}

	void partitions_data::init(uint32_t num_partitions, uint32_t block_width, uint32_t block_height, bool init_vp_tree, bool init_lsh)
	{
		assert((num_partitions >= 2) && (num_partitions <= 4));

		//const uint32_t total_texels = block_width * block_height;

		m_width = block_width;
		m_height = block_height;
		m_num_partitions = num_partitions;
						
		m_part_vp_tree.clear();

		for (uint32_t i = 0; i < 1024; i++)
		{
			m_part_seed_to_unique_index[i] = -1;
			m_unique_index_to_part_seed[i] = -1;
		}

		//const bool is_small_block = astc_helpers::is_small_block(block_width, block_height);
	
		partition_hash_map part_hash;
		part_hash.reserve(1024);
		m_total_unique_patterns = 0;

		clear_obj(m_partition_pat_histograms);

		for (uint32_t seed_index = 0; seed_index < astc_helpers::NUM_PARTITION_PATTERNS; seed_index++)
		{
			partition_pattern_vec pat;
			uint32_t part_hist[4] = { 0 };

			pat.init(block_width, block_height);

			for (uint32_t y = 0; y < block_height; y++)
			{
				for (uint32_t x = 0; x < block_width; x++)
				{
					//const uint8_t p = (uint8_t)astc_helpers::compute_texel_partition(seed_index, x, y, 0, m_num_partitions, is_small_block);
					const uint8_t p = (uint8_t)astc_helpers::get_precomputed_texel_partition(block_width, block_height, seed_index, x, y, num_partitions);
					
					assert((p < m_num_partitions) && (p < 4));
										
					pat(x, y) = p;

					part_hist[p]++;
				} // x
			} // y
						
			bool skip_pat = false;
			for (uint32_t i = 0; i < m_num_partitions; i++)
			{
				if (!part_hist[i])
				{
					skip_pat = true;
					break;
				}
			}
			if (skip_pat)
				continue;

			partition_pattern_vec std_pat(pat.get_canonicalized());

			if (part_hash.contains(std_pat))
				continue;

			if (num_partitions == 2)
			{
				assert(!part_hash.contains(pat));
				assert(!part_hash.contains(pat.get_permuted2(1)));
			}
			else if (num_partitions == 3)
			{
				for (uint32_t i = 0; i < partition_pattern_vec::cMaxPermute3Index; i++)
				{
					assert(!part_hash.contains(pat.get_permuted3(i)));
				}
			}

			for (uint32_t c = 0; c < 4; c++)
				m_partition_pat_histograms[m_total_unique_patterns].m_hist[c] = (uint8_t)part_hist[c];

			part_hash.insert(std_pat, std::make_pair(seed_index, m_total_unique_patterns));

			m_part_seed_to_unique_index[seed_index] = (int16_t)m_total_unique_patterns;
			m_unique_index_to_part_seed[m_total_unique_patterns] = (int16_t)seed_index;
															
			m_partition_pats[m_total_unique_patterns] = pat;
						
			m_total_unique_patterns++;

		} // seed_index

		if (init_vp_tree)
		{
			m_part_vp_tree.init(m_total_unique_patterns, m_partition_pats);
		}

		if (init_lsh)
		{
			m_part_lhs_map.init(num_partitions, m_total_unique_patterns, m_partition_pats);
		}
	}
		
} //  namespace astc_ldr

} // namespace basisu