src/util/texcompress_astc_luts.cpp - platform/external/mesa3d - Git at Google

 /* Copyright (c) 2017-2022 Hans-Kristian Arntzen
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */

 #include <assert.h>
 #include <cstdint>
 #include <cstring>
 #include <mutex>
 #include <unordered_map>
 #include <vector>

 #include "texcompress_astc_luts.h"

 namespace Granite
 {
 static void build_astc_unquant_weight_lut(uint8_t *lut, size_t range, const ASTCQuantizationMode &mode)
 {
 	for (size_t i = 0; i < range; i++)
 	{
 		auto &v = lut[i];

 		if (!mode.quints && !mode.trits)
 		{
 			switch (mode.bits)
 			{
 			case 1:
 				v = i * 63;
 				break;

 			case 2:
 				v = i * 0x15;
 				break;

 			case 3:
 				v = i * 9;
 				break;

 			case 4:
 				v = (i << 2) | (i >> 2);
 				break;

 			case 5:
 				v = (i << 1) | (i >> 4);
 				break;

 			default:
 				v = 0;
 				break;
 			}
 		}
 		else if (mode.bits == 0)
 		{
 			if (mode.trits)
 				v = 32 * i;
 			else
 				v = 16 * i;
 		}
 		else
 		{
 			unsigned b = (i >> 1) & 1;
 			unsigned c = (i >> 2) & 1;
 			unsigned A, B, C, D;

 			A = 0x7f * (i & 1);
 			D = i >> mode.bits;
 			B = 0;

 			if (mode.trits)
 			{
 				static const unsigned Cs[3] = { 50, 23, 11 };
 				C = Cs[mode.bits - 1];
 				if (mode.bits == 2)
 					B = 0x45 * b;
 				else if (mode.bits == 3)
 					B = 0x21 * b + 0x42 * c;
 			}
 			else
 			{
 				static const unsigned Cs[2] = { 28, 13 };
 				C = Cs[mode.bits - 1];
 				if (mode.bits == 2)
 					B = 0x42 * b;
 			}

 			unsigned unq = D * C + B;
 			unq ^= A;
 			unq = (A & 0x20) | (unq >> 2);
 			v = unq;
 		}

 		// Expand [0, 63] to [0, 64].
 		if (mode.bits != 0 && v > 32)
 			v++;
 	}
 }

 static void build_astc_unquant_endpoint_lut(uint8_t *lut, size_t range, const ASTCQuantizationMode &mode)
 {
 	for (size_t i = 0; i < range; i++)
 	{
 		auto &v = lut[i];

 		if (!mode.quints && !mode.trits)
 		{
 			// Bit-replication.
 			switch (mode.bits)
 			{
 			case 1:
 				v = i * 0xff;
 				break;

 			case 2:
 				v = i * 0x55;
 				break;

 			case 3:
 				v = (i << 5) | (i << 2) | (i >> 1);
 				break;

 			case 4:
 				v = i * 0x11;
 				break;

 			case 5:
 				v = (i << 3) | (i >> 2);
 				break;

 			case 6:
 				v = (i << 2) | (i >> 4);
 				break;

 			case 7:
 				v = (i << 1) | (i >> 6);
 				break;

 			default:
 				v = i;
 				break;
 			}
 		}
 		else
 		{
 			unsigned A, B, C, D;
 			unsigned b = (i >> 1) & 1;
 			unsigned c = (i >> 2) & 1;
 			unsigned d = (i >> 3) & 1;
 			unsigned e = (i >> 4) & 1;
 			unsigned f = (i >> 5) & 1;

 			B = 0;
 			D = i >> mode.bits;
 			A = (i & 1) * 0x1ff;

 			if (mode.trits)
 			{
 				static const unsigned Cs[6] = { 204, 93, 44, 22, 11, 5 };
 				C = Cs[mode.bits - 1];

 				switch (mode.bits)
 				{
 				case 2:
 					B = b * 0x116;
 					break;

 				case 3:
 					B = b * 0x85 + c * 0x10a;
 					break;

 				case 4:
 					B = b * 0x41 + c * 0x82 + d * 0x104;
 					break;

 				case 5:
 					B = b * 0x20 + c * 0x40 + d * 0x81 + e * 0x102;
 					break;

 				case 6:
 					B = b * 0x10 + c * 0x20 + d * 0x40 + e * 0x80 + f * 0x101;
 					break;
 				}
 			}
 			else
 			{
 				static const unsigned Cs[5] = { 113, 54, 26, 13, 6 };
 				C = Cs[mode.bits - 1];

 				switch (mode.bits)
 				{
 				case 2:
 					B = b * 0x10c;
 					break;

 				case 3:
 					B = b * 0x82 + c * 0x105;
 					break;

 				case 4:
 					B = b * 0x40 + c * 0x81 + d * 0x102;
 					break;

 				case 5:
 					B = b * 0x20 + c * 0x40 + d * 0x80 + e * 0x101;
 					break;
 				}
 			}

 			unsigned unq = D * C + B;
 			unq ^= A;
 			unq = (A & 0x80) | (unq >> 2);
 			v = uint8_t(unq);
 		}
 	}
 }

 static unsigned astc_value_range(const ASTCQuantizationMode &mode)
 {
 	unsigned value_range = 1u << mode.bits;
 	if (mode.trits)
 		value_range *= 3;
 	if (mode.quints)
 		value_range *= 5;

 	if (value_range == 1)
 		value_range = 0;
 	return value_range;
 }

 static uint32_t astc_hash52(uint32_t p)
 {
 	p ^= p >> 15; p -= p << 17; p += p << 7; p += p << 4;
 	p ^= p >>  5; p += p << 16; p ^= p >> 7; p ^= p >> 3;
 	p ^= p <<  6; p ^= p >> 17;
 	return p;
 }

 // Copy-paste from spec.
 static int astc_select_partition(int seed, int x, int y, int z, int partitioncount, bool small_block)
 {
 	if (small_block)
 	{
 		x <<= 1;
 		y <<= 1;
 		z <<= 1;
 	}

 	seed += (partitioncount - 1) * 1024;
 	uint32_t rnum = astc_hash52(seed);
 	uint8_t seed1 = rnum & 0xF;
 	uint8_t seed2 = (rnum >> 4) & 0xF;
 	uint8_t seed3 = (rnum >> 8) & 0xF;
 	uint8_t seed4 = (rnum >> 12) & 0xF;
 	uint8_t seed5 = (rnum >> 16) & 0xF;
 	uint8_t seed6 = (rnum >> 20) & 0xF;
 	uint8_t seed7 = (rnum >> 24) & 0xF;
 	uint8_t seed8 = (rnum >> 28) & 0xF;
 	uint8_t seed9 = (rnum >> 18) & 0xF;
 	uint8_t seed10 = (rnum >> 22) & 0xF;
 	uint8_t seed11 = (rnum >> 26) & 0xF;
 	uint8_t seed12 = ((rnum >> 30) | (rnum << 2)) & 0xF;

 	seed1 *= seed1; seed2 *= seed2; seed3 *= seed3; seed4 *= seed4;
 	seed5 *= seed5; seed6 *= seed6; seed7 *= seed7; seed8 *= seed8;
 	seed9 *= seed9; seed10 *= seed10; seed11 *= seed11; seed12 *= seed12;

 	int sh1, sh2, sh3;
 	if (seed & 1)
 	{
 		sh1 = seed & 2 ? 4 : 5;
 		sh2 = partitioncount == 3 ? 6 : 5;
 	}
 	else
 	{
 		sh1 = partitioncount == 3 ? 6 : 5;
 		sh2 = seed & 2 ? 4 : 5;
 	}
 	sh3 = (seed & 0x10) ? sh1 : sh2;

 	seed1 >>= sh1; seed2 >>= sh2; seed3 >>= sh1; seed4 >>= sh2;
 	seed5 >>= sh1; seed6 >>= sh2; seed7 >>= sh1; seed8 >>= sh2;
 	seed9 >>= sh3; seed10 >>= sh3; seed11 >>= sh3; seed12 >>= sh3;

 	int a = seed1 * x + seed2 * y + seed11 * z + (rnum >> 14);
 	int b = seed3 * x + seed4 * y + seed12 * z + (rnum >> 10);
 	int c = seed5 * x + seed6 * y + seed9 * z + (rnum >> 6);
 	int d = seed7 * x + seed8 * y + seed10 * z + (rnum >> 2);

 	a &= 0x3f; b &= 0x3f; c &= 0x3f; d &= 0x3f;

 	if (partitioncount < 4)
 		d = 0;
 	if (partitioncount < 3)
 		c = 0;

 	if (a >= b && a >= c && a >= d)
 		return 0;
 	else if (b >= c && b >= d)
 		return 1;
 	else if (c >= d)
 		return 2;
 	else
 		return 3;
 }

 ASTCLutHolder::PartitionTable::PartitionTable(unsigned block_width, unsigned block_height)
 {
 	bool small_block = (block_width * block_height) < 31;

 	lut_width = block_width * 32;
 	lut_height = block_height * 32;
 	lut_buffer.resize(lut_width * lut_height);

 	for (unsigned seed_y = 0; seed_y < 32; seed_y++)
 	{
 		for (unsigned seed_x = 0; seed_x < 32; seed_x++)
 		{
 			unsigned seed = seed_y * 32 + seed_x;
 			for (unsigned block_y = 0; block_y < block_height; block_y++)
 			{
 				for (unsigned block_x = 0; block_x < block_width; block_x++)
 				{
 					int part2 = astc_select_partition(seed, block_x, block_y, 0, 2, small_block);
 					int part3 = astc_select_partition(seed, block_x, block_y, 0, 3, small_block);
 					int part4 = astc_select_partition(seed, block_x, block_y, 0, 4, small_block);
 					lut_buffer[(seed_y * block_height + block_y) * lut_width + (seed_x * block_width + block_x)] =
 							(part2 << 0) | (part3 << 2) | (part4 << 4);
 				}
 			}
 		}
 	}
 }

 ASTCLutHolder::PartitionTable &ASTCLutHolder::get_partition_table(unsigned width, unsigned height)
 {
 	std::lock_guard<std::mutex> holder{table_lock};
 	auto itr = tables.find(width * 16 + height);
 	if (itr != tables.end())
 	{
 		return itr->second;
 	}
 	else
 	{
 		auto &t = tables[width * 16 + height];
 		t = { width, height };
 		return t;
 	}
 }

 ASTCLutHolder &get_astc_luts()
 {
 	static ASTCLutHolder holder;
 	return holder;
 }

 ASTCLutHolder::ASTCLutHolder()
 {
 	init_color_endpoint();
 	init_weight_luts();
 	init_trits_quints();
 }

 void ASTCLutHolder::init_color_endpoint()
 {
 	auto &unquant_lut = color_endpoint.unquant_lut;

 	for (size_t i = 0; i < astc_num_quantization_modes; i++)
 	{
 		auto value_range = astc_value_range(astc_quantization_modes[i]);
 		color_endpoint.unquant_lut_offsets[i] = color_endpoint.unquant_offset;
 		build_astc_unquant_endpoint_lut(unquant_lut + color_endpoint.unquant_offset, value_range, astc_quantization_modes[i]);
 		color_endpoint.unquant_offset += value_range;
 	}

 	auto &lut = color_endpoint.lut;

 	// We can have a maximum of 9 endpoint pairs, i.e. 18 endpoint values in total.
 	for (unsigned pairs_minus_1 = 0; pairs_minus_1 < 9; pairs_minus_1++)
 	{
 		for (unsigned remaining = 0; remaining < 128; remaining++)
 		{
 			bool found_mode = false;
 			for (auto &mode : astc_quantization_modes)
 			{
 				unsigned num_values = (pairs_minus_1 + 1) * 2;
 				unsigned total_bits = mode.bits * num_values +
 				                      (mode.quints * 7 * num_values + 2) / 3 +
 				                      (mode.trits * 8 * num_values + 4) / 5;

 				if (total_bits <= remaining)
 				{
 					found_mode = true;
 					lut[pairs_minus_1][remaining][0] = mode.bits;
 					lut[pairs_minus_1][remaining][1] = mode.trits;
 					lut[pairs_minus_1][remaining][2] = mode.quints;
 					lut[pairs_minus_1][remaining][3] = color_endpoint.unquant_lut_offsets[&mode - astc_quantization_modes];
 					break;
 				}
 			}

 			if (!found_mode)
 				memset(lut[pairs_minus_1][remaining], 0, sizeof(lut[pairs_minus_1][remaining]));
 		}
 	}
 }

 void ASTCLutHolder::init_weight_luts()
 {
 	auto &lut = weights.lut;
 	auto &unquant_lut = weights.unquant_lut;
 	auto &unquant_offset = weights.unquant_offset;

 	for (size_t i = 0; i < astc_num_weight_modes; i++)
 	{
 		auto value_range = astc_value_range(astc_weight_modes[i]);
 		lut[i][0] = astc_weight_modes[i].bits;
 		lut[i][1] = astc_weight_modes[i].trits;
 		lut[i][2] = astc_weight_modes[i].quints;
 		lut[i][3] = unquant_offset;
 		build_astc_unquant_weight_lut(unquant_lut + unquant_offset, value_range, astc_weight_modes[i]);
 		unquant_offset += value_range;
 	}

 	assert(unquant_offset <= 256);
 }

 void ASTCLutHolder::init_trits_quints()
 {
 	// From specification.
 	auto &trits_quints = integer.trits_quints;

 	for (unsigned T = 0; T < 256; T++)
 	{
 		unsigned C;
 		uint8_t t0, t1, t2, t3, t4;

 		if (((T >> 2) & 7) == 7)
 		{
 			C = (((T >> 5) & 7) << 2) | (T & 3);
 			t4 = t3 = 2;
 		}
 		else
 		{
 			C = T & 0x1f;
 			if (((T >> 5) & 3) == 3)
 			{
 				t4 = 2;
 				t3 = (T >> 7) & 1;
 			}
 			else
 			{
 				t4 = (T >> 7) & 1;
 				t3 = (T >> 5) & 3;
 			}
 		}

 		if ((C & 3) == 3)
 		{
 			t2 = 2;
 			t1 = (C >> 4) & 1;
 			t0 = (((C >> 3) & 1) << 1) | (((C >> 2) & 1) & ~(((C >> 3) & 1)));
 		}
 		else if (((C >> 2) & 3) == 3)
 		{
 			t2 = 2;
 			t1 = 2;
 			t0 = C & 3;
 		}
 		else
 		{
 			t2 = (C >> 4) & 1;
 			t1 = (C >> 2) & 3;
 			t0 = (((C >> 1) & 1) << 1) | ((C & 1) & ~(((C >> 1) & 1)));
 		}

 		trits_quints[T] = t0 | (t1 << 3) | (t2 << 6) | (t3 << 9) | (t4 << 12);
 	}

 	for (unsigned Q = 0; Q < 128; Q++)
 	{
 		unsigned C;
 		uint8_t q0, q1, q2;
 		if (((Q >> 1) & 3) == 3 && ((Q >> 5) & 3) == 0)
 		{
 			q2 = ((Q & 1) << 2) | ((((Q >> 4) & 1) & ~(Q & 1)) << 1) | (((Q >> 3) & 1) & ~(Q & 1));
 			q1 = q0 = 4;
 		}
 		else
 		{
 			if (((Q >> 1) & 3) == 3)
 			{
 				q2 = 4;
 				C = (((Q >> 3) & 3) << 3) | ((~(Q >> 5) & 3) << 1) | (Q & 1);
 			}
 			else
 			{
 				q2 = (Q >> 5) & 3;
 				C = Q & 0x1f;
 			}

 			if ((C & 7) == 5)
 			{
 				q1 = 4;
 				q0 = (C >> 3) & 3;
 			}
 			else
 			{
 				q1 = (C >> 3) & 3;
 				q0 = C & 7;
 			}
 		}

 		trits_quints[256 + Q] = q0 | (q1 << 3) | (q2 << 6);
 	}
 }
 }
	/* Copyright (c) 2017-2022 Hans-Kristian Arntzen
	*
	* Permission is hereby granted, free of charge, to any person obtaining
	* a copy of this software and associated documentation files (the
	* "Software"), to deal in the Software without restriction, including
	* without limitation the rights to use, copy, modify, merge, publish,
	* distribute, sublicense, and/or sell copies of the Software, and to
	* permit persons to whom the Software is furnished to do so, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice shall be
	* included in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#include <assert.h>
	#include <cstdint>
	#include <cstring>
	#include <mutex>
	#include <unordered_map>
	#include <vector>

	#include "texcompress_astc_luts.h"

	namespace Granite
	{
	static void build_astc_unquant_weight_lut(uint8_t *lut, size_t range, const ASTCQuantizationMode &mode)
	{
	for (size_t i = 0; i < range; i++)
	{
	auto &v = lut[i];

	if (!mode.quints && !mode.trits)
	{
	switch (mode.bits)
	{
	case 1:
	v = i * 63;
	break;

	case 2:
	v = i * 0x15;
	break;

	case 3:
	v = i * 9;
	break;

	case 4:
	v = (i << 2) \| (i >> 2);
	break;

	case 5:
	v = (i << 1) \| (i >> 4);
	break;

	default:
	v = 0;
	break;
	}
	}
	else if (mode.bits == 0)
	{
	if (mode.trits)
	v = 32 * i;
	else
	v = 16 * i;
	}
	else
	{
	unsigned b = (i >> 1) & 1;
	unsigned c = (i >> 2) & 1;
	unsigned A, B, C, D;

	A = 0x7f * (i & 1);
	D = i >> mode.bits;
	B = 0;

	if (mode.trits)
	{
	static const unsigned Cs[3] = { 50, 23, 11 };
	C = Cs[mode.bits - 1];
	if (mode.bits == 2)
	B = 0x45 * b;
	else if (mode.bits == 3)
	B = 0x21 * b + 0x42 * c;
	}
	else
	{
	static const unsigned Cs[2] = { 28, 13 };
	C = Cs[mode.bits - 1];
	if (mode.bits == 2)
	B = 0x42 * b;
	}

	unsigned unq = D * C + B;
	unq ^= A;
	unq = (A & 0x20) \| (unq >> 2);
	v = unq;
	}

	// Expand [0, 63] to [0, 64].
	if (mode.bits != 0 && v > 32)
	v++;
	}
	}

	static void build_astc_unquant_endpoint_lut(uint8_t *lut, size_t range, const ASTCQuantizationMode &mode)
	{
	for (size_t i = 0; i < range; i++)
	{
	auto &v = lut[i];

	if (!mode.quints && !mode.trits)
	{
	// Bit-replication.
	switch (mode.bits)
	{
	case 1:
	v = i * 0xff;
	break;

	case 2:
	v = i * 0x55;
	break;

	case 3:
	v = (i << 5) \| (i << 2) \| (i >> 1);
	break;

	case 4:
	v = i * 0x11;
	break;

	case 5:
	v = (i << 3) \| (i >> 2);
	break;

	case 6:
	v = (i << 2) \| (i >> 4);
	break;

	case 7:
	v = (i << 1) \| (i >> 6);
	break;

	default:
	v = i;
	break;
	}
	}
	else
	{
	unsigned A, B, C, D;
	unsigned b = (i >> 1) & 1;
	unsigned c = (i >> 2) & 1;
	unsigned d = (i >> 3) & 1;
	unsigned e = (i >> 4) & 1;
	unsigned f = (i >> 5) & 1;

	B = 0;
	D = i >> mode.bits;
	A = (i & 1) * 0x1ff;

	if (mode.trits)
	{
	static const unsigned Cs[6] = { 204, 93, 44, 22, 11, 5 };
	C = Cs[mode.bits - 1];

	switch (mode.bits)
	{
	case 2:
	B = b * 0x116;
	break;

	case 3:
	B = b * 0x85 + c * 0x10a;
	break;

	case 4:
	B = b * 0x41 + c * 0x82 + d * 0x104;
	break;

	case 5:
	B = b * 0x20 + c * 0x40 + d * 0x81 + e * 0x102;
	break;

	case 6:
	B = b * 0x10 + c * 0x20 + d * 0x40 + e * 0x80 + f * 0x101;
	break;
	}
	}
	else
	{
	static const unsigned Cs[5] = { 113, 54, 26, 13, 6 };
	C = Cs[mode.bits - 1];

	switch (mode.bits)
	{
	case 2:
	B = b * 0x10c;
	break;

	case 3:
	B = b * 0x82 + c * 0x105;
	break;

	case 4:
	B = b * 0x40 + c * 0x81 + d * 0x102;
	break;

	case 5:
	B = b * 0x20 + c * 0x40 + d * 0x80 + e * 0x101;
	break;
	}
	}

	unsigned unq = D * C + B;
	unq ^= A;
	unq = (A & 0x80) \| (unq >> 2);
	v = uint8_t(unq);
	}
	}
	}

	static unsigned astc_value_range(const ASTCQuantizationMode &mode)
	{
	unsigned value_range = 1u << mode.bits;
	if (mode.trits)
	value_range *= 3;
	if (mode.quints)
	value_range *= 5;

	if (value_range == 1)
	value_range = 0;
	return value_range;
	}

	static uint32_t astc_hash52(uint32_t p)
	{
	p ^= p >> 15; p -= p << 17; p += p << 7; p += p << 4;
	p ^= p >> 5; p += p << 16; p ^= p >> 7; p ^= p >> 3;
	p ^= p << 6; p ^= p >> 17;
	return p;
	}

	// Copy-paste from spec.
	static int astc_select_partition(int seed, int x, int y, int z, int partitioncount, bool small_block)
	{
	if (small_block)
	{
	x <<= 1;
	y <<= 1;
	z <<= 1;
	}

	seed += (partitioncount - 1) * 1024;
	uint32_t rnum = astc_hash52(seed);
	uint8_t seed1 = rnum & 0xF;
	uint8_t seed2 = (rnum >> 4) & 0xF;
	uint8_t seed3 = (rnum >> 8) & 0xF;
	uint8_t seed4 = (rnum >> 12) & 0xF;
	uint8_t seed5 = (rnum >> 16) & 0xF;
	uint8_t seed6 = (rnum >> 20) & 0xF;
	uint8_t seed7 = (rnum >> 24) & 0xF;
	uint8_t seed8 = (rnum >> 28) & 0xF;
	uint8_t seed9 = (rnum >> 18) & 0xF;
	uint8_t seed10 = (rnum >> 22) & 0xF;
	uint8_t seed11 = (rnum >> 26) & 0xF;
	uint8_t seed12 = ((rnum >> 30) \| (rnum << 2)) & 0xF;

	seed1 = seed1; seed2 = seed2; seed3 = seed3; seed4 = seed4;
	seed5 = seed5; seed6 = seed6; seed7 = seed7; seed8 = seed8;
	seed9 = seed9; seed10 = seed10; seed11 = seed11; seed12 = seed12;

	int sh1, sh2, sh3;
	if (seed & 1)
	{
	sh1 = seed & 2 ? 4 : 5;
	sh2 = partitioncount == 3 ? 6 : 5;
	}
	else
	{
	sh1 = partitioncount == 3 ? 6 : 5;
	sh2 = seed & 2 ? 4 : 5;
	}
	sh3 = (seed & 0x10) ? sh1 : sh2;

	seed1 >>= sh1; seed2 >>= sh2; seed3 >>= sh1; seed4 >>= sh2;
	seed5 >>= sh1; seed6 >>= sh2; seed7 >>= sh1; seed8 >>= sh2;
	seed9 >>= sh3; seed10 >>= sh3; seed11 >>= sh3; seed12 >>= sh3;

	int a = seed1 * x + seed2 * y + seed11 * z + (rnum >> 14);
	int b = seed3 * x + seed4 * y + seed12 * z + (rnum >> 10);
	int c = seed5 * x + seed6 * y + seed9 * z + (rnum >> 6);
	int d = seed7 * x + seed8 * y + seed10 * z + (rnum >> 2);

	a &= 0x3f; b &= 0x3f; c &= 0x3f; d &= 0x3f;

	if (partitioncount < 4)
	d = 0;
	if (partitioncount < 3)
	c = 0;

	if (a >= b && a >= c && a >= d)
	return 0;
	else if (b >= c && b >= d)
	return 1;
	else if (c >= d)
	return 2;
	else
	return 3;
	}

	ASTCLutHolder::PartitionTable::PartitionTable(unsigned block_width, unsigned block_height)
	{
	bool small_block = (block_width * block_height) < 31;

	lut_width = block_width * 32;
	lut_height = block_height * 32;
	lut_buffer.resize(lut_width * lut_height);

	for (unsigned seed_y = 0; seed_y < 32; seed_y++)
	{
	for (unsigned seed_x = 0; seed_x < 32; seed_x++)
	{
	unsigned seed = seed_y * 32 + seed_x;
	for (unsigned block_y = 0; block_y < block_height; block_y++)
	{
	for (unsigned block_x = 0; block_x < block_width; block_x++)
	{
	int part2 = astc_select_partition(seed, block_x, block_y, 0, 2, small_block);
	int part3 = astc_select_partition(seed, block_x, block_y, 0, 3, small_block);
	int part4 = astc_select_partition(seed, block_x, block_y, 0, 4, small_block);
	lut_buffer[(seed_y * block_height + block_y) * lut_width + (seed_x * block_width + block_x)] =
	(part2 << 0) \| (part3 << 2) \| (part4 << 4);
	}
	}
	}
	}
	}

	ASTCLutHolder::PartitionTable &ASTCLutHolder::get_partition_table(unsigned width, unsigned height)
	{
	std::lock_guard<std::mutex> holder{table_lock};
	auto itr = tables.find(width * 16 + height);
	if (itr != tables.end())
	{
	return itr->second;
	}
	else
	{
	auto &t = tables[width * 16 + height];
	t = { width, height };
	return t;
	}
	}

	ASTCLutHolder &get_astc_luts()
	{
	static ASTCLutHolder holder;
	return holder;
	}

	ASTCLutHolder::ASTCLutHolder()
	{
	init_color_endpoint();
	init_weight_luts();
	init_trits_quints();
	}

	void ASTCLutHolder::init_color_endpoint()
	{
	auto &unquant_lut = color_endpoint.unquant_lut;

	for (size_t i = 0; i < astc_num_quantization_modes; i++)
	{
	auto value_range = astc_value_range(astc_quantization_modes[i]);
	color_endpoint.unquant_lut_offsets[i] = color_endpoint.unquant_offset;
	build_astc_unquant_endpoint_lut(unquant_lut + color_endpoint.unquant_offset, value_range, astc_quantization_modes[i]);
	color_endpoint.unquant_offset += value_range;
	}

	auto &lut = color_endpoint.lut;

	// We can have a maximum of 9 endpoint pairs, i.e. 18 endpoint values in total.
	for (unsigned pairs_minus_1 = 0; pairs_minus_1 < 9; pairs_minus_1++)
	{
	for (unsigned remaining = 0; remaining < 128; remaining++)
	{
	bool found_mode = false;
	for (auto &mode : astc_quantization_modes)
	{
	unsigned num_values = (pairs_minus_1 + 1) * 2;
	unsigned total_bits = mode.bits * num_values +
	(mode.quints * 7 * num_values + 2) / 3 +
	(mode.trits * 8 * num_values + 4) / 5;

	if (total_bits <= remaining)
	{
	found_mode = true;
	lut[pairs_minus_1][remaining][0] = mode.bits;
	lut[pairs_minus_1][remaining][1] = mode.trits;
	lut[pairs_minus_1][remaining][2] = mode.quints;
	lut[pairs_minus_1][remaining][3] = color_endpoint.unquant_lut_offsets[&mode - astc_quantization_modes];
	break;
	}
	}

	if (!found_mode)
	memset(lut[pairs_minus_1][remaining], 0, sizeof(lut[pairs_minus_1][remaining]));
	}
	}
	}

	void ASTCLutHolder::init_weight_luts()
	{
	auto &lut = weights.lut;
	auto &unquant_lut = weights.unquant_lut;
	auto &unquant_offset = weights.unquant_offset;

	for (size_t i = 0; i < astc_num_weight_modes; i++)
	{
	auto value_range = astc_value_range(astc_weight_modes[i]);
	lut[i][0] = astc_weight_modes[i].bits;
	lut[i][1] = astc_weight_modes[i].trits;
	lut[i][2] = astc_weight_modes[i].quints;
	lut[i][3] = unquant_offset;
	build_astc_unquant_weight_lut(unquant_lut + unquant_offset, value_range, astc_weight_modes[i]);
	unquant_offset += value_range;
	}

	assert(unquant_offset <= 256);
	}

	void ASTCLutHolder::init_trits_quints()
	{
	// From specification.
	auto &trits_quints = integer.trits_quints;

	for (unsigned T = 0; T < 256; T++)
	{
	unsigned C;
	uint8_t t0, t1, t2, t3, t4;

	if (((T >> 2) & 7) == 7)
	{
	C = (((T >> 5) & 7) << 2) \| (T & 3);
	t4 = t3 = 2;
	}
	else
	{
	C = T & 0x1f;
	if (((T >> 5) & 3) == 3)
	{
	t4 = 2;
	t3 = (T >> 7) & 1;
	}
	else
	{
	t4 = (T >> 7) & 1;
	t3 = (T >> 5) & 3;
	}
	}

	if ((C & 3) == 3)
	{
	t2 = 2;
	t1 = (C >> 4) & 1;
	t0 = (((C >> 3) & 1) << 1) \| (((C >> 2) & 1) & ~(((C >> 3) & 1)));
	}
	else if (((C >> 2) & 3) == 3)
	{
	t2 = 2;
	t1 = 2;
	t0 = C & 3;
	}
	else
	{
	t2 = (C >> 4) & 1;
	t1 = (C >> 2) & 3;
	t0 = (((C >> 1) & 1) << 1) \| ((C & 1) & ~(((C >> 1) & 1)));
	}

	trits_quints[T] = t0 \| (t1 << 3) \| (t2 << 6) \| (t3 << 9) \| (t4 << 12);
	}

	for (unsigned Q = 0; Q < 128; Q++)
	{
	unsigned C;
	uint8_t q0, q1, q2;
	if (((Q >> 1) & 3) == 3 && ((Q >> 5) & 3) == 0)
	{
	q2 = ((Q & 1) << 2) \| ((((Q >> 4) & 1) & ~(Q & 1)) << 1) \| (((Q >> 3) & 1) & ~(Q & 1));
	q1 = q0 = 4;
	}
	else
	{
	if (((Q >> 1) & 3) == 3)
	{
	q2 = 4;
	C = (((Q >> 3) & 3) << 3) \| ((~(Q >> 5) & 3) << 1) \| (Q & 1);
	}
	else
	{
	q2 = (Q >> 5) & 3;
	C = Q & 0x1f;
	}

	if ((C & 7) == 5)
	{
	q1 = 4;
	q0 = (C >> 3) & 3;
	}
	else
	{
	q1 = (C >> 3) & 3;
	q0 = C & 7;
	}
	}

	trits_quints[256 + Q] = q0 \| (q1 << 3) \| (q2 << 6);
	}
	}
	}