Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
godotengine
GitHub Repository: godotengine/godot
 Path: blob/master/thirdparty/basis_universal/encoder/basisu_etc.cpp
9903 views
1
// basis_etc.cpp

2
// Copyright (C) 2019-2024 Binomial LLC. All Rights Reserved.

3
//

4
// Licensed under the Apache License, Version 2.0 (the "License");

5
// you may not use this file except in compliance with the License.

6
// You may obtain a copy of the License at

7
//

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

9
//

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

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

12
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

13
// See the License for the specific language governing permissions and

14
// limitations under the License.

15
#include "basisu_etc.h"

16


17
#if BASISU_SUPPORT_SSE

18
#define CPPSPMD_NAME(a) a##_sse41

19
#include "basisu_kernels_declares.h"

20
#endif

21


22
#define BASISU_DEBUG_ETC_ENCODER 0

23
#define BASISU_DEBUG_ETC_ENCODER_DEEPER 0

24


25
namespace basisu

26
{

27
	const int8_t g_etc2_eac_tables[16][8] =

28
	{

29
		{ -3, -6, -9, -15, 2, 5, 8, 14 }, { -3, -7, -10, -13, 2, 6, 9, 12 }, { -2, -5, -8, -13, 1, 4, 7, 12 }, { -2, -4, -6, -13, 1, 3, 5, 12 },

30
		{ -3, -6, -8, -12, 2, 5, 7, 11 }, { -3, -7, -9, -11, 2, 6, 8, 10 }, { -4, -7, -8, -11, 3, 6, 7, 10 }, { -3, -5, -8, -11, 2, 4, 7, 10 },

31
		{ -2, -6, -8, -10, 1, 5, 7, 9 }, { -2, -5, -8, -10, 1, 4, 7, 9 }, { -2, -4, -8, -10, 1, 3, 7, 9 }, { -2, -5, -7, -10, 1, 4, 6, 9 },

32
		{ -3, -4, -7, -10, 2, 3, 6, 9 }, { -1, -2, -3, -10, 0, 1, 2, 9 }, { -4, -6, -8, -9, 3, 5, 7, 8 }, { -3, -5, -7, -9, 2, 4, 6, 8 }

33
	};

34


35
	const int8_t g_etc2_eac_tables8[16][8] =

36
	{

37
		{ -24, -48, -72, -120, 16, 40, 64, 112 }, { -24,-56,-80,-104,16,48,72,96 }, { -16,-40,-64,-104,8,32,56,96 }, { -16,-32,-48,-104,8,24,40,96 },

38
		{ -24,-48,-64,-96,16,40,56,88 }, { -24,-56,-72,-88,16,48,64,80 }, { -32,-56,-64,-88,24,48,56,80 }, { -24,-40,-64,-88,16,32,56,80 },

39
		{ -16,-48,-64,-80,8,40,56,72 }, { -16,-40,-64,-80,8,32,56,72 }, { -16,-32,-64,-80,8,24,56,72 }, { -16,-40,-56,-80,8,32,48,72 },

40
		{ -24,-32,-56,-80,16,24,48,72 }, { -8,-16,-24,-80,0,8,16,72 }, { -32,-48,-64,-72,24,40,56,64 },	{ -24,-40,-56,-72,16,32,48,64 }

41
	};

42
		

43
	// Given an ETC1 diff/inten_table/selector, and an 8-bit desired color, this table encodes the best packed_color in the low byte, and the abs error in the high byte.

44
	static uint16_t g_etc1_inverse_lookup[2 * 8 * 4][256];      // [ diff/inten_table/selector][desired_color ]

45


46
	// g_color8_to_etc_block_config[color][table_index] = Supplies for each 8-bit color value a list of packed ETC1 diff/intensity table/selectors/packed_colors that map to that color.

47
	// To pack: diff | (inten << 1) | (selector << 4) | (packed_c << 8)

48
	static const uint16_t g_etc1_color8_to_etc_block_config_0_255[2][33] =

49
	{

50
		{ 0x0000,  0x0010,  0x0002,  0x0012,  0x0004,  0x0014,  0x0006,  0x0016,  0x0008,  0x0018,  0x000A,  0x001A,  0x000C,  0x001C,  0x000E,  0x001E,		  0x0001,  0x0011,  0x0003,  0x0013,  0x0005,  0x0015,  0x0007,  0x0017,  0x0009,  0x0019,  0x000B,  0x001B,  0x000D,  0x001D,  0x000F,  0x001F, 0xFFFF },

51
		{ 0x0F20,  0x0F30,  0x0E32,  0x0F22,  0x0E34,  0x0F24,  0x0D36,  0x0F26,  0x0C38,  0x0E28,  0x0B3A,  0x0E2A,  0x093C,  0x0E2C,  0x053E,  0x0D2E,		  0x1E31,  0x1F21,  0x1D33,  0x1F23,  0x1C35,  0x1E25,  0x1A37,  0x1E27,  0x1839,  0x1D29,  0x163B,  0x1C2B,  0x133D,  0x1B2D,  0x093F,  0x1A2F, 0xFFFF },

52
	};

53


54
	// Really only [254][11].

55
	static const uint16_t g_etc1_color8_to_etc_block_config_1_to_254[254][12] =

56
	{

57
		{ 0x021C, 0x0D0D, 0xFFFF }, { 0x0020, 0x0021, 0x0A0B, 0x061F, 0xFFFF }, { 0x0113, 0x0217, 0xFFFF }, { 0x0116, 0x031E,		0x0B0E, 0x0405, 0xFFFF }, { 0x0022, 0x0204, 0x050A, 0x0023, 0xFFFF }, { 0x0111, 0x0319, 0x0809, 0x170F, 0xFFFF }, {

58
		0x0303, 0x0215, 0x0607, 0xFFFF }, { 0x0030, 0x0114, 0x0408, 0x0031, 0x0201, 0x051D, 0xFFFF }, { 0x0100, 0x0024, 0x0306,		0x0025, 0x041B, 0x0E0D, 0xFFFF }, { 0x021A, 0x0121, 0x0B0B, 0x071F, 0xFFFF }, { 0x0213, 0x0317, 0xFFFF }, { 0x0112,

59
		0x0505, 0xFFFF }, { 0x0026, 0x070C, 0x0123, 0x0027, 0xFFFF }, { 0x0211, 0x0909, 0xFFFF }, { 0x0110, 0x0315, 0x0707,		0x0419, 0x180F, 0xFFFF }, { 0x0218, 0x0131, 0x0301, 0x0403, 0x061D, 0xFFFF }, { 0x0032, 0x0202, 0x0033, 0x0125, 0x051B,

60
		0x0F0D, 0xFFFF }, { 0x0028, 0x031C, 0x0221, 0x0029, 0xFFFF }, { 0x0120, 0x0313, 0x0C0B, 0x081F, 0xFFFF }, { 0x0605,		0x0417, 0xFFFF }, { 0x0216, 0x041E, 0x0C0E, 0x0223, 0x0127, 0xFFFF }, { 0x0122, 0x0304, 0x060A, 0x0311, 0x0A09, 0xFFFF

61
		}, { 0x0519, 0x190F, 0xFFFF }, { 0x002A, 0x0231, 0x0503, 0x0415, 0x0807, 0x002B, 0x071D, 0xFFFF }, { 0x0130, 0x0214,		0x0508, 0x0401, 0x0133, 0x0225, 0x061B, 0xFFFF }, { 0x0200, 0x0124, 0x0406, 0x0321, 0x0129, 0x100D, 0xFFFF }, { 0x031A,

62
		0x0D0B, 0x091F, 0xFFFF }, { 0x0413, 0x0705, 0x0517, 0xFFFF }, { 0x0212, 0x0034, 0x0323, 0x0035, 0x0227, 0xFFFF }, {		0x0126, 0x080C, 0x0B09, 0xFFFF }, { 0x0411, 0x0619, 0x1A0F, 0xFFFF }, { 0x0210, 0x0331, 0x0603, 0x0515, 0x0907, 0x012B,

63
		0xFFFF }, { 0x0318, 0x002C, 0x0501, 0x0233, 0x0325, 0x071B, 0x002D, 0x081D, 0xFFFF }, { 0x0132, 0x0302, 0x0229, 0x110D,		0xFFFF }, { 0x0128, 0x041C, 0x0421, 0x0E0B, 0x0A1F, 0xFFFF }, { 0x0220, 0x0513, 0x0617, 0xFFFF }, { 0x0135, 0x0805,

64
		0x0327, 0xFFFF }, { 0x0316, 0x051E, 0x0D0E, 0x0423, 0xFFFF }, { 0x0222, 0x0404, 0x070A, 0x0511, 0x0719, 0x0C09, 0x1B0F,		0xFFFF }, { 0x0703, 0x0615, 0x0A07, 0x022B, 0xFFFF }, { 0x012A, 0x0431, 0x0601, 0x0333, 0x012D, 0x091D, 0xFFFF }, {

65
		0x0230, 0x0314, 0x0036, 0x0608, 0x0425, 0x0037, 0x0329, 0x081B, 0x120D, 0xFFFF }, { 0x0300, 0x0224, 0x0506, 0x0521,		0x0F0B, 0x0B1F, 0xFFFF }, { 0x041A, 0x0613, 0x0717, 0xFFFF }, { 0x0235, 0x0905, 0xFFFF }, { 0x0312, 0x0134, 0x0523,

66
		0x0427, 0xFFFF }, { 0x0226, 0x090C, 0x002E, 0x0611, 0x0D09, 0x002F, 0xFFFF }, { 0x0715, 0x0B07, 0x0819, 0x032B, 0x1C0F,		0xFFFF }, { 0x0310, 0x0531, 0x0701, 0x0803, 0x022D, 0x0A1D, 0xFFFF }, { 0x0418, 0x012C, 0x0433, 0x0525, 0x0137, 0x091B,

67
		0x130D, 0xFFFF }, { 0x0232, 0x0402, 0x0621, 0x0429, 0xFFFF }, { 0x0228, 0x051C, 0x0713, 0x100B, 0x0C1F, 0xFFFF }, {		0x0320, 0x0335, 0x0A05, 0x0817, 0xFFFF }, { 0x0623, 0x0527, 0xFFFF }, { 0x0416, 0x061E, 0x0E0E, 0x0711, 0x0E09, 0x012F,

68
		0xFFFF }, { 0x0322, 0x0504, 0x080A, 0x0919, 0x1D0F, 0xFFFF }, { 0x0631, 0x0903, 0x0815, 0x0C07, 0x042B, 0x032D, 0x0B1D,		0xFFFF }, { 0x022A, 0x0801, 0x0533, 0x0625, 0x0237, 0x0A1B, 0xFFFF }, { 0x0330, 0x0414, 0x0136, 0x0708, 0x0721, 0x0529,

69
		0x140D, 0xFFFF }, { 0x0400, 0x0324, 0x0606, 0x0038, 0x0039, 0x110B, 0x0D1F, 0xFFFF }, { 0x051A, 0x0813, 0x0B05, 0x0917,		0xFFFF }, { 0x0723, 0x0435, 0x0627, 0xFFFF }, { 0x0412, 0x0234, 0x0F09, 0x022F, 0xFFFF }, { 0x0326, 0x0A0C, 0x012E,

70
		0x0811, 0x0A19, 0x1E0F, 0xFFFF }, { 0x0731, 0x0A03, 0x0915, 0x0D07, 0x052B, 0xFFFF }, { 0x0410, 0x0901, 0x0633, 0x0725,		0x0337, 0x0B1B, 0x042D, 0x0C1D, 0xFFFF }, { 0x0518, 0x022C, 0x0629, 0x150D, 0xFFFF }, { 0x0332, 0x0502, 0x0821, 0x0139,

71
		0x120B, 0x0E1F, 0xFFFF }, { 0x0328, 0x061C, 0x0913, 0x0A17, 0xFFFF }, { 0x0420, 0x0535, 0x0C05, 0x0727, 0xFFFF }, {		0x0823, 0x032F, 0xFFFF }, { 0x0516, 0x071E, 0x0F0E, 0x0911, 0x0B19, 0x1009, 0x1F0F, 0xFFFF }, { 0x0422, 0x0604, 0x090A,

72
		0x0B03, 0x0A15, 0x0E07, 0x062B, 0xFFFF }, { 0x0831, 0x0A01, 0x0733, 0x052D, 0x0D1D, 0xFFFF }, { 0x032A, 0x0825, 0x0437,		0x0729, 0x0C1B, 0x160D, 0xFFFF }, { 0x0430, 0x0514, 0x0236, 0x0808, 0x0921, 0x0239, 0x130B, 0x0F1F, 0xFFFF }, { 0x0500,

73
		0x0424, 0x0706, 0x0138, 0x0A13, 0x0B17, 0xFFFF }, { 0x061A, 0x0635, 0x0D05, 0xFFFF }, { 0x0923, 0x0827, 0xFFFF }, {		0x0512, 0x0334, 0x003A, 0x0A11, 0x1109, 0x003B, 0x042F, 0xFFFF }, { 0x0426, 0x0B0C, 0x022E, 0x0B15, 0x0F07, 0x0C19,

74
		0x072B, 0xFFFF }, { 0x0931, 0x0B01, 0x0C03, 0x062D, 0x0E1D, 0xFFFF }, { 0x0510, 0x0833, 0x0925, 0x0537, 0x0D1B, 0x170D,		0xFFFF }, { 0x0618, 0x032C, 0x0A21, 0x0339, 0x0829, 0xFFFF }, { 0x0432, 0x0602, 0x0B13, 0x140B, 0x101F, 0xFFFF }, {

75
		0x0428, 0x071C, 0x0735, 0x0E05, 0x0C17, 0xFFFF }, { 0x0520, 0x0A23, 0x0927, 0xFFFF }, { 0x0B11, 0x1209, 0x013B, 0x052F,		0xFFFF }, { 0x0616, 0x081E, 0x0D19, 0xFFFF }, { 0x0522, 0x0704, 0x0A0A, 0x0A31, 0x0D03, 0x0C15, 0x1007, 0x082B, 0x072D,

76
		0x0F1D, 0xFFFF }, { 0x0C01, 0x0933, 0x0A25, 0x0637, 0x0E1B, 0xFFFF }, { 0x042A, 0x0B21, 0x0929, 0x180D, 0xFFFF }, {		0x0530, 0x0614, 0x0336, 0x0908, 0x0439, 0x150B, 0x111F, 0xFFFF }, { 0x0600, 0x0524, 0x0806, 0x0238, 0x0C13, 0x0F05,

77
		0x0D17, 0xFFFF }, { 0x071A, 0x0B23, 0x0835, 0x0A27, 0xFFFF }, { 0x1309, 0x023B, 0x062F, 0xFFFF }, { 0x0612, 0x0434,		0x013A, 0x0C11, 0x0E19, 0xFFFF }, { 0x0526, 0x0C0C, 0x032E, 0x0B31, 0x0E03, 0x0D15, 0x1107, 0x092B, 0xFFFF }, { 0x0D01,

78
		0x0A33, 0x0B25, 0x0737, 0x0F1B, 0x082D, 0x101D, 0xFFFF }, { 0x0610, 0x0A29, 0x190D, 0xFFFF }, { 0x0718, 0x042C, 0x0C21,		0x0539, 0x160B, 0x121F, 0xFFFF }, { 0x0532, 0x0702, 0x0D13, 0x0E17, 0xFFFF }, { 0x0528, 0x081C, 0x0935, 0x1005, 0x0B27,

79
		0xFFFF }, { 0x0620, 0x0C23, 0x033B, 0x072F, 0xFFFF }, { 0x0D11, 0x0F19, 0x1409, 0xFFFF }, { 0x0716, 0x003C, 0x091E,		0x0F03, 0x0E15, 0x1207, 0x0A2B, 0x003D, 0xFFFF }, { 0x0622, 0x0804, 0x0B0A, 0x0C31, 0x0E01, 0x0B33, 0x092D, 0x111D,

80
		0xFFFF }, { 0x0C25, 0x0837, 0x0B29, 0x101B, 0x1A0D, 0xFFFF }, { 0x052A, 0x0D21, 0x0639, 0x170B, 0x131F, 0xFFFF }, {		0x0630, 0x0714, 0x0436, 0x0A08, 0x0E13, 0x0F17, 0xFFFF }, { 0x0700, 0x0624, 0x0906, 0x0338, 0x0A35, 0x1105, 0xFFFF }, {

81
		0x081A, 0x0D23, 0x0C27, 0xFFFF }, { 0x0E11, 0x1509, 0x043B, 0x082F, 0xFFFF }, { 0x0712, 0x0534, 0x023A, 0x0F15, 0x1307,		0x1019, 0x0B2B, 0x013D, 0xFFFF }, { 0x0626, 0x0D0C, 0x042E, 0x0D31, 0x0F01, 0x1003, 0x0A2D, 0x121D, 0xFFFF }, { 0x0C33,

82
		0x0D25, 0x0937, 0x111B, 0x1B0D, 0xFFFF }, { 0x0710, 0x0E21, 0x0739, 0x0C29, 0xFFFF }, { 0x0818, 0x052C, 0x0F13, 0x180B,		0x141F, 0xFFFF }, { 0x0632, 0x0802, 0x0B35, 0x1205, 0x1017, 0xFFFF }, { 0x0628, 0x091C, 0x0E23, 0x0D27, 0xFFFF }, {

83
		0x0720, 0x0F11, 0x1609, 0x053B, 0x092F, 0xFFFF }, { 0x1119, 0x023D, 0xFFFF }, { 0x0816, 0x013C, 0x0A1E, 0x0E31, 0x1103,		0x1015, 0x1407, 0x0C2B, 0x0B2D, 0x131D, 0xFFFF }, { 0x0722, 0x0904, 0x0C0A, 0x1001, 0x0D33, 0x0E25, 0x0A37, 0x121B,

84
		0xFFFF }, { 0x0F21, 0x0D29, 0x1C0D, 0xFFFF }, { 0x062A, 0x0839, 0x190B, 0x151F, 0xFFFF }, { 0x0730, 0x0814, 0x0536,		0x0B08, 0x1013, 0x1305, 0x1117, 0xFFFF }, { 0x0800, 0x0724, 0x0A06, 0x0438, 0x0F23, 0x0C35, 0x0E27, 0xFFFF }, { 0x091A,

85
		0x1709, 0x063B, 0x0A2F, 0xFFFF }, { 0x1011, 0x1219, 0x033D, 0xFFFF }, { 0x0812, 0x0634, 0x033A, 0x0F31, 0x1203, 0x1115,		0x1507, 0x0D2B, 0xFFFF }, { 0x0726, 0x0E0C, 0x052E, 0x1101, 0x0E33, 0x0F25, 0x0B37, 0x131B, 0x0C2D, 0x141D, 0xFFFF }, {

86
		0x0E29, 0x1D0D, 0xFFFF }, { 0x0810, 0x1021, 0x0939, 0x1A0B, 0x161F, 0xFFFF }, { 0x0918, 0x062C, 0x1113, 0x1217, 0xFFFF		}, { 0x0732, 0x0902, 0x0D35, 0x1405, 0x0F27, 0xFFFF }, { 0x0728, 0x0A1C, 0x1023, 0x073B, 0x0B2F, 0xFFFF }, { 0x0820,

87
		0x1111, 0x1319, 0x1809, 0xFFFF }, { 0x1303, 0x1215, 0x1607, 0x0E2B, 0x043D, 0xFFFF }, { 0x0916, 0x023C, 0x0B1E, 0x1031,		0x1201, 0x0F33, 0x0D2D, 0x151D, 0xFFFF }, { 0x0822, 0x0A04, 0x0D0A, 0x1025, 0x0C37, 0x0F29, 0x141B, 0x1E0D, 0xFFFF }, {

88
		0x1121, 0x0A39, 0x1B0B, 0x171F, 0xFFFF }, { 0x072A, 0x1213, 0x1317, 0xFFFF }, { 0x0830, 0x0914, 0x0636, 0x0C08, 0x0E35,		0x1505, 0xFFFF }, { 0x0900, 0x0824, 0x0B06, 0x0538, 0x1123, 0x1027, 0xFFFF }, { 0x0A1A, 0x1211, 0x1909, 0x083B, 0x0C2F,

89
		0xFFFF }, { 0x1315, 0x1707, 0x1419, 0x0F2B, 0x053D, 0xFFFF }, { 0x0912, 0x0734, 0x043A, 0x1131, 0x1301, 0x1403, 0x0E2D,		0x161D, 0xFFFF }, { 0x0826, 0x0F0C, 0x062E, 0x1033, 0x1125, 0x0D37, 0x151B, 0x1F0D, 0xFFFF }, { 0x1221, 0x0B39, 0x1029,

90
		0xFFFF }, { 0x0910, 0x1313, 0x1C0B, 0x181F, 0xFFFF }, { 0x0A18, 0x072C, 0x0F35, 0x1605, 0x1417, 0xFFFF }, { 0x0832,		0x0A02, 0x1223, 0x1127, 0xFFFF }, { 0x0828, 0x0B1C, 0x1311, 0x1A09, 0x093B, 0x0D2F, 0xFFFF }, { 0x0920, 0x1519, 0x063D,

91
		0xFFFF }, { 0x1231, 0x1503, 0x1415, 0x1807, 0x102B, 0x0F2D, 0x171D, 0xFFFF }, { 0x0A16, 0x033C, 0x0C1E, 0x1401, 0x1133,		0x1225, 0x0E37, 0x161B, 0xFFFF }, { 0x0922, 0x0B04, 0x0E0A, 0x1321, 0x1129, 0xFFFF }, { 0x0C39, 0x1D0B, 0x191F, 0xFFFF

92
		}, { 0x082A, 0x1413, 0x1705, 0x1517, 0xFFFF }, { 0x0930, 0x0A14, 0x0736, 0x0D08, 0x1323, 0x1035, 0x1227, 0xFFFF }, {		0x0A00, 0x0924, 0x0C06, 0x0638, 0x1B09, 0x0A3B, 0x0E2F, 0xFFFF }, { 0x0B1A, 0x1411, 0x1619, 0x073D, 0xFFFF }, { 0x1331,

93
		0x1603, 0x1515, 0x1907, 0x112B, 0xFFFF }, { 0x0A12, 0x0834, 0x053A, 0x1501, 0x1233, 0x1325, 0x0F37, 0x171B, 0x102D,		0x181D, 0xFFFF }, { 0x0926, 0x072E, 0x1229, 0xFFFF }, { 0x1421, 0x0D39, 0x1E0B, 0x1A1F, 0xFFFF }, { 0x0A10, 0x1513,

94
		0x1617, 0xFFFF }, { 0x0B18, 0x082C, 0x1135, 0x1805, 0x1327, 0xFFFF }, { 0x0932, 0x0B02, 0x1423, 0x0B3B, 0x0F2F, 0xFFFF		}, { 0x0928, 0x0C1C, 0x1511, 0x1719, 0x1C09, 0xFFFF }, { 0x0A20, 0x1703, 0x1615, 0x1A07, 0x122B, 0x083D, 0xFFFF }, {

95
		0x1431, 0x1601, 0x1333, 0x112D, 0x191D, 0xFFFF }, { 0x0B16, 0x043C, 0x0D1E, 0x1425, 0x1037, 0x1329, 0x181B, 0xFFFF }, {		0x0A22, 0x0C04, 0x0F0A, 0x1521, 0x0E39, 0x1F0B, 0x1B1F, 0xFFFF }, { 0x1613, 0x1717, 0xFFFF }, { 0x092A, 0x1235, 0x1905,

96
		0xFFFF }, { 0x0A30, 0x0B14, 0x0836, 0x0E08, 0x1523, 0x1427, 0xFFFF }, { 0x0B00, 0x0A24, 0x0D06, 0x0738, 0x1611, 0x1D09,		0x0C3B, 0x102F, 0xFFFF }, { 0x0C1A, 0x1715, 0x1B07, 0x1819, 0x132B, 0x093D, 0xFFFF }, { 0x1531, 0x1701, 0x1803, 0x122D,

97
		0x1A1D, 0xFFFF }, { 0x0B12, 0x0934, 0x063A, 0x1433, 0x1525, 0x1137, 0x191B, 0xFFFF }, { 0x0A26, 0x003E, 0x082E, 0x1621,		0x0F39, 0x1429, 0x003F, 0xFFFF }, { 0x1713, 0x1C1F, 0xFFFF }, { 0x0B10, 0x1335, 0x1A05, 0x1817, 0xFFFF }, { 0x0C18,

98
		0x092C, 0x1623, 0x1527, 0xFFFF }, { 0x0A32, 0x0C02, 0x1711, 0x1E09, 0x0D3B, 0x112F, 0xFFFF }, { 0x0A28, 0x0D1C, 0x1919,		0x0A3D, 0xFFFF }, { 0x0B20, 0x1631, 0x1903, 0x1815, 0x1C07, 0x142B, 0x132D, 0x1B1D, 0xFFFF }, { 0x1801, 0x1533, 0x1625,

99
		0x1237, 0x1A1B, 0xFFFF }, { 0x0C16, 0x053C, 0x0E1E, 0x1721, 0x1529, 0x013F, 0xFFFF }, { 0x0B22, 0x0D04, 0x1039, 0x1D1F,		0xFFFF }, { 0x1813, 0x1B05, 0x1917, 0xFFFF }, { 0x0A2A, 0x1723, 0x1435, 0x1627, 0xFFFF }, { 0x0B30, 0x0C14, 0x0936,

100
		0x0F08, 0x1F09, 0x0E3B, 0x122F, 0xFFFF }, { 0x0C00, 0x0B24, 0x0E06, 0x0838, 0x1811, 0x1A19, 0x0B3D, 0xFFFF }, { 0x0D1A,		0x1731, 0x1A03, 0x1915, 0x1D07, 0x152B, 0xFFFF }, { 0x1901, 0x1633, 0x1725, 0x1337, 0x1B1B, 0x142D, 0x1C1D, 0xFFFF }, {

101
		0x0C12, 0x0A34, 0x073A, 0x1629, 0x023F, 0xFFFF }, { 0x0B26, 0x013E, 0x092E, 0x1821, 0x1139, 0x1E1F, 0xFFFF }, { 0x1913,		0x1A17, 0xFFFF }, { 0x0C10, 0x1535, 0x1C05, 0x1727, 0xFFFF }, { 0x0D18, 0x0A2C, 0x1823, 0x0F3B, 0x132F, 0xFFFF }, {

102
		0x0B32, 0x0D02, 0x1911, 0x1B19, 0xFFFF }, { 0x0B28, 0x0E1C, 0x1B03, 0x1A15, 0x1E07, 0x162B, 0x0C3D, 0xFFFF }, { 0x0C20,		0x1831, 0x1A01, 0x1733, 0x152D, 0x1D1D, 0xFFFF }, { 0x1825, 0x1437, 0x1729, 0x1C1B, 0x033F, 0xFFFF }, { 0x0D16, 0x063C,

103
		0x0F1E, 0x1921, 0x1239, 0x1F1F, 0xFFFF }, { 0x0C22, 0x0E04, 0x1A13, 0x1B17, 0xFFFF }, { 0x1635, 0x1D05, 0xFFFF }, {		0x0B2A, 0x1923, 0x1827, 0xFFFF }, { 0x0C30, 0x0D14, 0x0A36, 0x1A11, 0x103B, 0x142F, 0xFFFF }, { 0x0D00, 0x0C24, 0x0F06,

104
		0x0938, 0x1B15, 0x1F07, 0x1C19, 0x172B, 0x0D3D, 0xFFFF }, { 0x0E1A, 0x1931, 0x1B01, 0x1C03, 0x162D, 0x1E1D, 0xFFFF }, {		0x1833, 0x1925, 0x1537, 0x1D1B, 0xFFFF }, { 0x0D12, 0x0B34, 0x083A, 0x1A21, 0x1339, 0x1829, 0x043F, 0xFFFF }, { 0x0C26,

105
		0x023E, 0x0A2E, 0x1B13, 0xFFFF }, { 0x1735, 0x1E05, 0x1C17, 0xFFFF }, { 0x0D10, 0x1A23, 0x1927, 0xFFFF }, { 0x0E18,		0x0B2C, 0x1B11, 0x113B, 0x152F, 0xFFFF }, { 0x0C32, 0x0E02, 0x1D19, 0x0E3D, 0xFFFF }, { 0x0C28, 0x0F1C, 0x1A31, 0x1D03,

106
		0x1C15, 0x182B, 0x172D, 0x1F1D, 0xFFFF }, { 0x0D20, 0x1C01, 0x1933, 0x1A25, 0x1637, 0x1E1B, 0xFFFF }, { 0x1B21, 0x1929,		0x053F, 0xFFFF }, { 0x0E16, 0x073C, 0x1439, 0xFFFF }, { 0x0D22, 0x0F04, 0x1C13, 0x1F05, 0x1D17, 0xFFFF }, { 0x1B23,

107
		0x1835, 0x1A27, 0xFFFF }, { 0x0C2A, 0x123B, 0x162F, 0xFFFF }, { 0x0D30, 0x0E14, 0x0B36, 0x1C11, 0x1E19, 0x0F3D, 0xFFFF		}, { 0x0E00, 0x0D24, 0x0A38, 0x1B31, 0x1E03, 0x1D15, 0x192B, 0xFFFF }, { 0x0F1A, 0x1D01, 0x1A33, 0x1B25, 0x1737, 0x1F1B,

108
		0x182D, 0xFFFF }, { 0x1A29, 0x063F, 0xFFFF }, { 0x0E12, 0x0C34, 0x093A, 0x1C21, 0x1539, 0xFFFF }, { 0x0D26, 0x033E,		0x0B2E, 0x1D13, 0x1E17, 0xFFFF }, { 0x1935, 0x1B27, 0xFFFF }, { 0x0E10, 0x1C23, 0x133B, 0x172F, 0xFFFF }, { 0x0F18,

109
		0x0C2C, 0x1D11, 0x1F19, 0xFFFF }, { 0x0D32, 0x0F02, 0x1F03, 0x1E15, 0x1A2B, 0x103D, 0xFFFF }, { 0x0D28, 0x1C31, 0x1E01,		0x1B33, 0x192D, 0xFFFF }, { 0x0E20, 0x1C25, 0x1837, 0x1B29, 0x073F, 0xFFFF }, { 0x1D21, 0x1639, 0xFFFF }, { 0x0F16,

110
		0x083C, 0x1E13, 0x1F17, 0xFFFF }, { 0x0E22, 0x1A35, 0xFFFF }, { 0x1D23, 0x1C27, 0xFFFF }, { 0x0D2A, 0x1E11, 0x143B,		0x182F, 0xFFFF }, { 0x0E30, 0x0F14, 0x0C36, 0x1F15, 0x1B2B, 0x113D, 0xFFFF }, { 0x0F00, 0x0E24, 0x0B38, 0x1D31, 0x1F01,

111
		0x1A2D, 0xFFFF }, { 0x1C33, 0x1D25, 0x1937, 0xFFFF }, { 0x1E21, 0x1739, 0x1C29, 0x083F, 0xFFFF }, { 0x0F12, 0x0D34,		0x0A3A, 0x1F13, 0xFFFF }, { 0x0E26, 0x043E, 0x0C2E, 0x1B35, 0xFFFF }, { 0x1E23, 0x1D27, 0xFFFF }, { 0x0F10, 0x1F11,		0x153B, 0x192F, 0xFFFF }, { 0x0D2C, 0x123D, 0xFFFF },

112
	};

113


114
	static uint32_t etc1_decode_value(uint32_t diff, uint32_t inten, uint32_t selector, uint32_t packed_c)

115
	{

116
		const uint32_t limit = diff ? 32 : 16; 

117
		BASISU_NOTE_UNUSED(limit);

118
		assert((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < limit));

119
		int c;

120
		if (diff)

121
			c = (packed_c >> 2) | (packed_c << 3);

122
		else

123
			c = packed_c | (packed_c << 4);

124
		c += g_etc1_inten_tables[inten][selector];

125
		c = clamp<int>(c, 0, 255);

126
		return c;

127
	}

128


129
	void pack_etc1_solid_color_init()

130
	{

131
		for (uint32_t diff = 0; diff < 2; diff++)

132
		{

133
			const uint32_t limit = diff ? 32 : 16;

134


135
			for (uint32_t inten = 0; inten < 8; inten++)

136
			{

137
				for (uint32_t selector = 0; selector < 4; selector++)

138
				{

139
					const uint32_t inverse_table_index = diff + (inten << 1) + (selector << 4);

140
					for (uint32_t color = 0; color < 256; color++)

141
					{

142
						uint32_t best_error = UINT32_MAX, best_packed_c = 0;

143
						for (uint32_t packed_c = 0; packed_c < limit; packed_c++)

144
						{

145
							int v = etc1_decode_value(diff, inten, selector, packed_c);

146
							uint32_t err = (uint32_t)labs(v - static_cast<int>(color));

147
							if (err < best_error)

148
							{

149
								best_error = err;

150
								best_packed_c = packed_c;

151
								if (!best_error)

152
									break;

153
							}

154
						}

155
						assert(best_error <= 255);

156
						g_etc1_inverse_lookup[inverse_table_index][color] = static_cast<uint16_t>(best_packed_c | (best_error << 8));

157
					}

158
				}

159
			}

160
		}

161


162
#if 0

163
		for (uint32_t y = 0; y < 64; y++)

164
		{

165
			printf("{");

166
			for (uint32_t x = 0; x < 256; x++)

167
			{

168
				printf("0x%X", g_etc1_inverse_lookup[y][x]);

169
				if (x != 255)

170
					printf(",");

171
				if (((x & 63) == 63) && (x != 255))

172
					printf("\n");

173
			}

174
			printf("},\n");

175
		}

176
#endif

177
	}

178


179
	// Packs solid color blocks efficiently using a set of small precomputed tables.

180
	// For random 888 inputs, MSE results are better than Erricson's ETC1 packer in "slow" mode ~9.5% of the time, is slightly worse only ~.01% of the time, and is equal the rest of the time.

181
	uint64_t pack_etc1_block_solid_color(etc_block& block, const uint8_t* pColor)

182
	{

183
		assert(g_etc1_inverse_lookup[0][255]);

184


185
		static uint32_t s_next_comp[4] = { 1, 2, 0, 1 };

186


187
		uint32_t best_error = UINT32_MAX, best_i = 0;

188
		int best_x = 0, best_packed_c1 = 0, best_packed_c2 = 0;

189


190
		// For each possible 8-bit value, there is a precomputed list of diff/inten/selector configurations that allow that 8-bit value to be encoded with no error.

191
		for (uint32_t i = 0; i < 3; i++)

192
		{

193
			const uint32_t c1 = pColor[s_next_comp[i]], c2 = pColor[s_next_comp[i + 1]];

194


195
			const int delta_range = 1;

196
			for (int delta = -delta_range; delta <= delta_range; delta++)

197
			{

198
				const int c_plus_delta = clamp<int>(pColor[i] + delta, 0, 255);

199


200
				const uint16_t* pTable;

201
				if (!c_plus_delta)

202
					pTable = g_etc1_color8_to_etc_block_config_0_255[0];

203
				else if (c_plus_delta == 255)

204
					pTable = g_etc1_color8_to_etc_block_config_0_255[1];

205
				else

206
					pTable = g_etc1_color8_to_etc_block_config_1_to_254[c_plus_delta - 1];

207


208
				do

209
				{

210
					const uint32_t x = *pTable++;

211


212
#ifdef _DEBUG

213
					const uint32_t diff = x & 1;

214
					const uint32_t inten = (x >> 1) & 7;

215
					const uint32_t selector = (x >> 4) & 3;

216
					const uint32_t p0 = (x >> 8) & 255;

217
					assert(etc1_decode_value(diff, inten, selector, p0) == (uint32_t)c_plus_delta);

218
#endif

219


220
					const uint16_t* pInverse_table = g_etc1_inverse_lookup[x & 0xFF];

221
					uint16_t p1 = pInverse_table[c1];

222
					uint16_t p2 = pInverse_table[c2];

223
					const uint32_t trial_error = square(c_plus_delta - pColor[i]) + square(p1 >> 8) + square(p2 >> 8);

224
					if (trial_error < best_error)

225
					{

226
						best_error = trial_error;

227
						best_x = x;

228
						best_packed_c1 = p1 & 0xFF;

229
						best_packed_c2 = p2 & 0xFF;

230
						best_i = i;

231
						if (!best_error)

232
							goto found_perfect_match;

233
					}

234
				} while (*pTable != 0xFFFF);

235
			}

236
		}

237
	found_perfect_match:

238


239
		const uint32_t diff = best_x & 1;

240
		const uint32_t inten = (best_x >> 1) & 7;

241


242
		block.m_bytes[3] = static_cast<uint8_t>(((inten | (inten << 3)) << 2) | (diff << 1));

243


244
		const uint32_t etc1_selector = g_selector_index_to_etc1[(best_x >> 4) & 3];

245
		*reinterpret_cast<uint16_t*>(&block.m_bytes[4]) = (etc1_selector & 2) ? 0xFFFF : 0;

246
		*reinterpret_cast<uint16_t*>(&block.m_bytes[6]) = (etc1_selector & 1) ? 0xFFFF : 0;

247


248
		const uint32_t best_packed_c0 = (best_x >> 8) & 255;

249
		if (diff)

250
		{

251
			block.m_bytes[best_i] = static_cast<uint8_t>(best_packed_c0 << 3);

252
			block.m_bytes[s_next_comp[best_i]] = static_cast<uint8_t>(best_packed_c1 << 3);

253
			block.m_bytes[s_next_comp[best_i + 1]] = static_cast<uint8_t>(best_packed_c2 << 3);

254
		}

255
		else

256
		{

257
			block.m_bytes[best_i] = static_cast<uint8_t>(best_packed_c0 | (best_packed_c0 << 4));

258
			block.m_bytes[s_next_comp[best_i]] = static_cast<uint8_t>(best_packed_c1 | (best_packed_c1 << 4));

259
			block.m_bytes[s_next_comp[best_i + 1]] = static_cast<uint8_t>(best_packed_c2 | (best_packed_c2 << 4));

260
		}

261


262
		return best_error;

263
	}

264
	

265
	const uint32_t BASISU_ETC1_CLUSTER_FIT_ORDER_TABLE_SIZE = 165;

266


267
	static const struct { uint8_t m_v[4]; } g_cluster_fit_order_tab[BASISU_ETC1_CLUSTER_FIT_ORDER_TABLE_SIZE] =

268
	{

269
		{ { 0, 0, 0, 8 } },{ { 0, 5, 2, 1 } },{ { 0, 6, 1, 1 } },{ { 0, 7, 0, 1 } },{ { 0, 7, 1, 0 } },

270
		{ { 0, 0, 8, 0 } },{ { 0, 0, 3, 5 } },{ { 0, 1, 7, 0 } },{ { 0, 0, 4, 4 } },{ { 0, 0, 2, 6 } },

271
		{ { 0, 0, 7, 1 } },{ { 0, 0, 1, 7 } },{ { 0, 0, 5, 3 } },{ { 1, 6, 0, 1 } },{ { 0, 0, 6, 2 } },

272
		{ { 0, 2, 6, 0 } },{ { 2, 4, 2, 0 } },{ { 0, 3, 5, 0 } },{ { 3, 3, 1, 1 } },{ { 4, 2, 0, 2 } },

273
		{ { 1, 5, 2, 0 } },{ { 0, 5, 3, 0 } },{ { 0, 6, 2, 0 } },{ { 2, 4, 1, 1 } },{ { 5, 1, 0, 2 } },

274
		{ { 6, 1, 1, 0 } },{ { 3, 3, 0, 2 } },{ { 6, 0, 0, 2 } },{ { 0, 8, 0, 0 } },{ { 6, 1, 0, 1 } },

275
		{ { 0, 1, 6, 1 } },{ { 1, 6, 1, 0 } },{ { 4, 1, 3, 0 } },{ { 0, 2, 5, 1 } },{ { 5, 0, 3, 0 } },

276
		{ { 5, 3, 0, 0 } },{ { 0, 1, 5, 2 } },{ { 0, 3, 4, 1 } },{ { 2, 5, 1, 0 } },{ { 1, 7, 0, 0 } },

277
		{ { 0, 1, 4, 3 } },{ { 6, 0, 2, 0 } },{ { 0, 4, 4, 0 } },{ { 2, 6, 0, 0 } },{ { 0, 2, 4, 2 } },

278
		{ { 0, 5, 1, 2 } },{ { 0, 6, 0, 2 } },{ { 3, 5, 0, 0 } },{ { 0, 4, 3, 1 } },{ { 3, 4, 1, 0 } },

279
		{ { 4, 3, 1, 0 } },{ { 1, 5, 0, 2 } },{ { 0, 3, 3, 2 } },{ { 1, 4, 1, 2 } },{ { 0, 4, 2, 2 } },

280
		{ { 2, 3, 3, 0 } },{ { 4, 4, 0, 0 } },{ { 1, 2, 4, 1 } },{ { 0, 5, 0, 3 } },{ { 0, 1, 3, 4 } },

281
		{ { 1, 5, 1, 1 } },{ { 1, 4, 2, 1 } },{ { 1, 3, 2, 2 } },{ { 5, 2, 1, 0 } },{ { 1, 3, 3, 1 } },

282
		{ { 0, 1, 2, 5 } },{ { 1, 1, 5, 1 } },{ { 0, 3, 2, 3 } },{ { 2, 5, 0, 1 } },{ { 3, 2, 2, 1 } },

283
		{ { 2, 3, 0, 3 } },{ { 1, 4, 3, 0 } },{ { 2, 2, 1, 3 } },{ { 6, 2, 0, 0 } },{ { 1, 0, 6, 1 } },

284
		{ { 3, 3, 2, 0 } },{ { 7, 1, 0, 0 } },{ { 3, 1, 4, 0 } },{ { 0, 2, 3, 3 } },{ { 0, 4, 1, 3 } },

285
		{ { 0, 4, 0, 4 } },{ { 0, 1, 0, 7 } },{ { 2, 0, 5, 1 } },{ { 2, 0, 4, 2 } },{ { 3, 0, 2, 3 } },

286
		{ { 2, 2, 4, 0 } },{ { 2, 2, 3, 1 } },{ { 4, 0, 3, 1 } },{ { 3, 2, 3, 0 } },{ { 2, 3, 2, 1 } },

287
		{ { 1, 3, 4, 0 } },{ { 7, 0, 1, 0 } },{ { 3, 0, 4, 1 } },{ { 1, 0, 5, 2 } },{ { 8, 0, 0, 0 } },

288
		{ { 3, 0, 1, 4 } },{ { 4, 1, 1, 2 } },{ { 4, 0, 2, 2 } },{ { 1, 2, 5, 0 } },{ { 4, 2, 1, 1 } },

289
		{ { 3, 4, 0, 1 } },{ { 2, 0, 3, 3 } },{ { 5, 0, 1, 2 } },{ { 5, 0, 0, 3 } },{ { 2, 4, 0, 2 } },

290
		{ { 2, 1, 4, 1 } },{ { 4, 0, 1, 3 } },{ { 2, 1, 5, 0 } },{ { 4, 2, 2, 0 } },{ { 4, 0, 4, 0 } },

291
		{ { 1, 0, 4, 3 } },{ { 1, 4, 0, 3 } },{ { 3, 0, 3, 2 } },{ { 4, 3, 0, 1 } },{ { 0, 1, 1, 6 } },

292
		{ { 1, 3, 1, 3 } },{ { 0, 2, 2, 4 } },{ { 2, 0, 2, 4 } },{ { 5, 1, 1, 1 } },{ { 3, 0, 5, 0 } },

293
		{ { 2, 3, 1, 2 } },{ { 3, 0, 0, 5 } },{ { 0, 3, 1, 4 } },{ { 5, 0, 2, 1 } },{ { 2, 1, 3, 2 } },

294
		{ { 2, 0, 6, 0 } },{ { 3, 1, 3, 1 } },{ { 5, 1, 2, 0 } },{ { 1, 0, 3, 4 } },{ { 1, 1, 6, 0 } },

295
		{ { 4, 0, 0, 4 } },{ { 2, 0, 1, 5 } },{ { 0, 3, 0, 5 } },{ { 1, 3, 0, 4 } },{ { 4, 1, 2, 1 } },

296
		{ { 1, 2, 3, 2 } },{ { 3, 1, 0, 4 } },{ { 5, 2, 0, 1 } },{ { 1, 2, 2, 3 } },{ { 3, 2, 1, 2 } },

297
		{ { 2, 2, 2, 2 } },{ { 6, 0, 1, 1 } },{ { 1, 2, 1, 4 } },{ { 1, 1, 4, 2 } },{ { 3, 2, 0, 3 } },

298
		{ { 1, 2, 0, 5 } },{ { 1, 0, 7, 0 } },{ { 3, 1, 2, 2 } },{ { 1, 0, 2, 5 } },{ { 2, 0, 0, 6 } },

299
		{ { 2, 1, 1, 4 } },{ { 2, 2, 0, 4 } },{ { 1, 1, 3, 3 } },{ { 7, 0, 0, 1 } },{ { 1, 0, 0, 7 } },

300
		{ { 2, 1, 2, 3 } },{ { 4, 1, 0, 3 } },{ { 3, 1, 1, 3 } },{ { 1, 1, 2, 4 } },{ { 2, 1, 0, 5 } },

301
		{ { 1, 0, 1, 6 } },{ { 0, 2, 1, 5 } },{ { 0, 2, 0, 6 } },{ { 1, 1, 1, 5 } },{ { 1, 1, 0, 6 } }

302
	};

303
		

304
	const int g_etc1_inten_tables[cETC1IntenModifierValues][cETC1SelectorValues] =

305
	{

306
		{ -8,  -2,   2,   8 }, { -17,  -5,  5,  17 }, { -29,  -9,   9,  29 }, {  -42, -13, 13,  42 },

307
		{ -60, -18, 18,  60 }, { -80, -24, 24,  80 }, { -106, -33, 33, 106 }, { -183, -47, 47, 183 }

308
	};

309


310
	const uint8_t g_etc1_to_selector_index[cETC1SelectorValues] = { 2, 3, 1, 0 };

311
	const uint8_t g_selector_index_to_etc1[cETC1SelectorValues] = { 3, 2, 0, 1 };

312


313
	// [flip][subblock][pixel_index]

314
	const etc_coord2 g_etc1_pixel_coords[2][2][8] =

315
	{

316
		{

317
		  {

318
			 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },

319
			 { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }

320
		  },

321
		  {

322
			 { 2, 0 }, { 2, 1 }, { 2, 2 }, { 2, 3 },

323
			 { 3, 0 }, { 3, 1 }, { 3, 2 }, { 3, 3 }

324
		  }

325
		},

326
		{

327
		  {

328
			 { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 },

329
			 { 0, 1 }, { 1, 1 }, { 2, 1 }, { 3, 1 }

330
		  },

331
		  {

332
			 { 0, 2 }, { 1, 2 }, { 2, 2 }, { 3, 2 },

333
			 { 0, 3 }, { 1, 3 }, { 2, 3 }, { 3, 3 }

334
		  },

335
		}

336
	};

337


338
	// [flip][subblock][pixel_index]

339
	const uint32_t g_etc1_pixel_indices[2][2][8] =

340
	{

341
		{

342
			{

343
				0 + 4 * 0, 0 + 4 * 1, 0 + 4 * 2, 0 + 4 * 3,

344
				1 + 4 * 0, 1 + 4 * 1, 1 + 4 * 2, 1 + 4 * 3

345
			},

346
			{

347
				2 + 4 * 0, 2 + 4 * 1, 2 + 4 * 2, 2 + 4 * 3,

348
				3 + 4 * 0, 3 + 4 * 1, 3 + 4 * 2, 3 + 4 * 3

349
			}

350
		},

351
		{

352
			{

353
				0 + 4 * 0, 1 + 4 * 0, 2 + 4 * 0, 3 + 4 * 0,

354
				0 + 4 * 1, 1 + 4 * 1, 2 + 4 * 1, 3 + 4 * 1

355
			},

356
			{

357
				0 + 4 * 2, 1 + 4 * 2, 2 + 4 * 2, 3 + 4 * 2,

358
				0 + 4 * 3, 1 + 4 * 3, 2 + 4 * 3, 3 + 4 * 3

359
			},

360
		}

361
	};

362


363
	uint16_t etc_block::pack_color5(const color_rgba& color, bool scaled, uint32_t bias)

364
	{

365
		return pack_color5(color.r, color.g, color.b, scaled, bias);

366
	}

367


368
	uint16_t etc_block::pack_color5(uint32_t r, uint32_t g, uint32_t b, bool scaled, uint32_t bias)

369
	{

370
		if (scaled)

371
		{

372
			r = (r * 31U + bias) / 255U;

373
			g = (g * 31U + bias) / 255U;

374
			b = (b * 31U + bias) / 255U;

375
		}

376


377
		r = minimum(r, 31U);

378
		g = minimum(g, 31U);

379
		b = minimum(b, 31U);

380


381
		return static_cast<uint16_t>(b | (g << 5U) | (r << 10U));

382
	}

383


384
	color_rgba etc_block::unpack_color5(uint16_t packed_color5, bool scaled, uint32_t alpha)

385
	{

386
		uint32_t b = packed_color5 & 31U;

387
		uint32_t g = (packed_color5 >> 5U) & 31U;

388
		uint32_t r = (packed_color5 >> 10U) & 31U;

389


390
		if (scaled)

391
		{

392
			b = (b << 3U) | (b >> 2U);

393
			g = (g << 3U) | (g >> 2U);

394
			r = (r << 3U) | (r >> 2U);

395
		}

396


397
		return color_rgba(cNoClamp, r, g, b, minimum(alpha, 255U));

398
	}

399


400
	void etc_block::unpack_color5(color_rgba& result, uint16_t packed_color5, bool scaled)

401
	{

402
		result = unpack_color5(packed_color5, scaled, 255);

403
	}

404


405
	void etc_block::unpack_color5(uint32_t& r, uint32_t& g, uint32_t& b, uint16_t packed_color5, bool scaled)

406
	{

407
		color_rgba c(unpack_color5(packed_color5, scaled, 0));

408
		r = c.r;

409
		g = c.g;

410
		b = c.b;

411
	}

412


413
	bool etc_block::unpack_color5(color_rgba& result, uint16_t packed_color5, uint16_t packed_delta3, bool scaled, uint32_t alpha)

414
	{

415
		color_rgba_i16 dc(unpack_delta3(packed_delta3));

416


417
		int b = (packed_color5 & 31U) + dc.b;

418
		int g = ((packed_color5 >> 5U) & 31U) + dc.g;

419
		int r = ((packed_color5 >> 10U) & 31U) + dc.r;

420


421
		bool success = true;

422
		if (static_cast<uint32_t>(r | g | b) > 31U)

423
		{

424
			success = false;

425
			r = clamp<int>(r, 0, 31);

426
			g = clamp<int>(g, 0, 31);

427
			b = clamp<int>(b, 0, 31);

428
		}

429


430
		if (scaled)

431
		{

432
			b = (b << 3U) | (b >> 2U);

433
			g = (g << 3U) | (g >> 2U);

434
			r = (r << 3U) | (r >> 2U);

435
		}

436


437
		result.set_noclamp_rgba(r, g, b, minimum(alpha, 255U));

438
		return success;

439
	}

440


441
	bool etc_block::unpack_color5(uint32_t& r, uint32_t& g, uint32_t& b, uint16_t packed_color5, uint16_t packed_delta3, bool scaled, uint32_t alpha)

442
	{

443
		color_rgba result;

444
		const bool success = unpack_color5(result, packed_color5, packed_delta3, scaled, alpha);

445
		r = result.r;

446
		g = result.g;

447
		b = result.b;

448
		return success;

449
	}

450


451
	uint16_t etc_block::pack_delta3(const color_rgba_i16& color)

452
	{

453
		return pack_delta3(color.r, color.g, color.b);

454
	}

455


456
	uint16_t etc_block::pack_delta3(int r, int g, int b)

457
	{

458
		assert((r >= cETC1ColorDeltaMin) && (r <= cETC1ColorDeltaMax));

459
		assert((g >= cETC1ColorDeltaMin) && (g <= cETC1ColorDeltaMax));

460
		assert((b >= cETC1ColorDeltaMin) && (b <= cETC1ColorDeltaMax));

461
		if (r < 0) r += 8;

462
		if (g < 0) g += 8;

463
		if (b < 0) b += 8;

464
		return static_cast<uint16_t>(b | (g << 3) | (r << 6));

465
	}

466


467
	color_rgba_i16 etc_block::unpack_delta3(uint16_t packed_delta3)

468
	{

469
		int r = (packed_delta3 >> 6) & 7;

470
		int g = (packed_delta3 >> 3) & 7;

471
		int b = packed_delta3 & 7;

472
		if (r >= 4) r -= 8;

473
		if (g >= 4) g -= 8;

474
		if (b >= 4) b -= 8;

475
		return color_rgba_i16(r, g, b, 255);

476
	}

477


478
	void etc_block::unpack_delta3(int& r, int& g, int& b, uint16_t packed_delta3)

479
	{

480
		r = (packed_delta3 >> 6) & 7;

481
		g = (packed_delta3 >> 3) & 7;

482
		b = packed_delta3 & 7;

483
		if (r >= 4) r -= 8;

484
		if (g >= 4) g -= 8;

485
		if (b >= 4) b -= 8;

486
	}

487


488
	uint16_t etc_block::pack_color4(const color_rgba& color, bool scaled, uint32_t bias)

489
	{

490
		return pack_color4(color.r, color.g, color.b, scaled, bias);

491
	}

492


493
	uint16_t etc_block::pack_color4(uint32_t r, uint32_t g, uint32_t b, bool scaled, uint32_t bias)

494
	{

495
		if (scaled)

496
		{

497
			r = (r * 15U + bias) / 255U;

498
			g = (g * 15U + bias) / 255U;

499
			b = (b * 15U + bias) / 255U;

500
		}

501


502
		r = minimum(r, 15U);

503
		g = minimum(g, 15U);

504
		b = minimum(b, 15U);

505


506
		return static_cast<uint16_t>(b | (g << 4U) | (r << 8U));

507
	}

508


509
	color_rgba etc_block::unpack_color4(uint16_t packed_color4, bool scaled, uint32_t alpha)

510
	{

511
		uint32_t b = packed_color4 & 15U;

512
		uint32_t g = (packed_color4 >> 4U) & 15U;

513
		uint32_t r = (packed_color4 >> 8U) & 15U;

514


515
		if (scaled)

516
		{

517
			b = (b << 4U) | b;

518
			g = (g << 4U) | g;

519
			r = (r << 4U) | r;

520
		}

521


522
		return color_rgba(cNoClamp, r, g, b, minimum(alpha, 255U));

523
	}

524


525
	void etc_block::unpack_color4(uint32_t& r, uint32_t& g, uint32_t& b, uint16_t packed_color4, bool scaled)

526
	{

527
		color_rgba c(unpack_color4(packed_color4, scaled, 0));

528
		r = c.r;

529
		g = c.g;

530
		b = c.b;

531
	}

532


533
	void etc_block::get_diff_subblock_colors(color_rgba* pDst, uint16_t packed_color5, uint32_t table_idx)

534
	{

535
		assert(table_idx < cETC1IntenModifierValues);

536
		const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];

537


538
		uint32_t r, g, b;

539
		unpack_color5(r, g, b, packed_color5, true);

540


541
		const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);

542


543
		const int y0 = pInten_modifer_table[0];

544
		pDst[0].set(ir + y0, ig + y0, ib + y0, 255);

545


546
		const int y1 = pInten_modifer_table[1];

547
		pDst[1].set(ir + y1, ig + y1, ib + y1, 255);

548


549
		const int y2 = pInten_modifer_table[2];

550
		pDst[2].set(ir + y2, ig + y2, ib + y2, 255);

551


552
		const int y3 = pInten_modifer_table[3];

553
		pDst[3].set(ir + y3, ig + y3, ib + y3, 255);

554
	}

555


556
	bool etc_block::get_diff_subblock_colors(color_rgba* pDst, uint16_t packed_color5, uint16_t packed_delta3, uint32_t table_idx)

557
	{

558
		assert(table_idx < cETC1IntenModifierValues);

559
		const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];

560


561
		uint32_t r, g, b;

562
		bool success = unpack_color5(r, g, b, packed_color5, packed_delta3, true);

563


564
		const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);

565


566
		const int y0 = pInten_modifer_table[0];

567
		pDst[0].set(ir + y0, ig + y0, ib + y0, 255);

568


569
		const int y1 = pInten_modifer_table[1];

570
		pDst[1].set(ir + y1, ig + y1, ib + y1, 255);

571


572
		const int y2 = pInten_modifer_table[2];

573
		pDst[2].set(ir + y2, ig + y2, ib + y2, 255);

574


575
		const int y3 = pInten_modifer_table[3];

576
		pDst[3].set(ir + y3, ig + y3, ib + y3, 255);

577


578
		return success;

579
	}

580


581
	void etc_block::get_abs_subblock_colors(color_rgba* pDst, uint16_t packed_color4, uint32_t table_idx)

582
	{

583
		assert(table_idx < cETC1IntenModifierValues);

584
		const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];

585


586
		uint32_t r, g, b;

587
		unpack_color4(r, g, b, packed_color4, true);

588


589
		const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);

590


591
		const int y0 = pInten_modifer_table[0];

592
		pDst[0].set(ir + y0, ig + y0, ib + y0, 255);

593


594
		const int y1 = pInten_modifer_table[1];

595
		pDst[1].set(ir + y1, ig + y1, ib + y1, 255);

596


597
		const int y2 = pInten_modifer_table[2];

598
		pDst[2].set(ir + y2, ig + y2, ib + y2, 255);

599


600
		const int y3 = pInten_modifer_table[3];

601
		pDst[3].set(ir + y3, ig + y3, ib + y3, 255);

602
	}

603
		

604
	bool unpack_etc1(const etc_block& block, color_rgba *pDst, bool preserve_alpha)

605
	{

606
		const bool diff_flag = block.get_diff_bit();

607
		const bool flip_flag = block.get_flip_bit();

608
		const uint32_t table_index0 = block.get_inten_table(0);

609
		const uint32_t table_index1 = block.get_inten_table(1);

610


611
		color_rgba subblock_colors0[4];

612
		color_rgba subblock_colors1[4];

613


614
		if (diff_flag)

615
		{

616
			const uint16_t base_color5 = block.get_base5_color();

617
			const uint16_t delta_color3 = block.get_delta3_color();

618
			etc_block::get_diff_subblock_colors(subblock_colors0, base_color5, table_index0);

619


620
			if (!etc_block::get_diff_subblock_colors(subblock_colors1, base_color5, delta_color3, table_index1))

621
				return false;

622
		}

623
		else

624
		{

625
			const uint16_t base_color4_0 = block.get_base4_color(0);

626
			etc_block::get_abs_subblock_colors(subblock_colors0, base_color4_0, table_index0);

627


628
			const uint16_t base_color4_1 = block.get_base4_color(1);

629
			etc_block::get_abs_subblock_colors(subblock_colors1, base_color4_1, table_index1);

630
		}

631


632
		if (preserve_alpha)

633
		{

634
			if (flip_flag)

635
			{

636
				for (uint32_t y = 0; y < 2; y++)

637
				{

638
					pDst[0].set_rgb(subblock_colors0[block.get_selector(0, y)]);

639
					pDst[1].set_rgb(subblock_colors0[block.get_selector(1, y)]);

640
					pDst[2].set_rgb(subblock_colors0[block.get_selector(2, y)]);

641
					pDst[3].set_rgb(subblock_colors0[block.get_selector(3, y)]);

642
					pDst += 4;

643
				}

644


645
				for (uint32_t y = 2; y < 4; y++)

646
				{

647
					pDst[0].set_rgb(subblock_colors1[block.get_selector(0, y)]);

648
					pDst[1].set_rgb(subblock_colors1[block.get_selector(1, y)]);

649
					pDst[2].set_rgb(subblock_colors1[block.get_selector(2, y)]);

650
					pDst[3].set_rgb(subblock_colors1[block.get_selector(3, y)]);

651
					pDst += 4;

652
				}

653
			}

654
			else

655
			{

656
				for (uint32_t y = 0; y < 4; y++)

657
				{

658
					pDst[0].set_rgb(subblock_colors0[block.get_selector(0, y)]);

659
					pDst[1].set_rgb(subblock_colors0[block.get_selector(1, y)]);

660
					pDst[2].set_rgb(subblock_colors1[block.get_selector(2, y)]);

661
					pDst[3].set_rgb(subblock_colors1[block.get_selector(3, y)]);

662
					pDst += 4;

663
				}

664
			}

665
		}

666
		else

667
		{

668
			if (flip_flag)

669
			{

670
				// 0000

671
				// 0000

672
				// 1111

673
				// 1111

674
				for (uint32_t y = 0; y < 2; y++)

675
				{

676
					pDst[0] = subblock_colors0[block.get_selector(0, y)];

677
					pDst[1] = subblock_colors0[block.get_selector(1, y)];

678
					pDst[2] = subblock_colors0[block.get_selector(2, y)];

679
					pDst[3] = subblock_colors0[block.get_selector(3, y)];

680
					pDst += 4;

681
				}

682


683
				for (uint32_t y = 2; y < 4; y++)

684
				{

685
					pDst[0] = subblock_colors1[block.get_selector(0, y)];

686
					pDst[1] = subblock_colors1[block.get_selector(1, y)];

687
					pDst[2] = subblock_colors1[block.get_selector(2, y)];

688
					pDst[3] = subblock_colors1[block.get_selector(3, y)];

689
					pDst += 4;

690
				}

691
			}

692
			else

693
			{

694
				// 0011

695
				// 0011

696
				// 0011

697
				// 0011

698
				for (uint32_t y = 0; y < 4; y++)

699
				{

700
					pDst[0] = subblock_colors0[block.get_selector(0, y)];

701
					pDst[1] = subblock_colors0[block.get_selector(1, y)];

702
					pDst[2] = subblock_colors1[block.get_selector(2, y)];

703
					pDst[3] = subblock_colors1[block.get_selector(3, y)];

704
					pDst += 4;

705
				}

706
			}

707
		}

708


709
		return true;

710
	}

711


712
	inline int extend_6_to_8(uint32_t n)

713
	{

714
		return (n << 2) | (n >> 4);

715
	}

716


717
	inline int extend_7_to_8(uint32_t n)

718
	{

719
		return (n << 1) | (n >> 6);

720
	}

721


722
	inline int extend_4_to_8(uint32_t n)

723
	{

724
		return (n << 4) | n;

725
	}

726
		

727
	uint64_t etc_block::evaluate_etc1_error(const color_rgba* pBlock_pixels, bool perceptual, int subblock_index) const

728
	{

729
		color_rgba unpacked_block[16];

730


731
		unpack_etc1(*this, unpacked_block);

732


733
		uint64_t total_error = 0;

734


735
		if (subblock_index < 0)

736
		{

737
			for (uint32_t i = 0; i < 16; i++)

738
				total_error += color_distance(perceptual, pBlock_pixels[i], unpacked_block[i], false);

739
		}

740
		else

741
		{

742
			const bool flip_bit = get_flip_bit();

743


744
			for (uint32_t i = 0; i < 8; i++)

745
			{

746
				const uint32_t idx = g_etc1_pixel_indices[flip_bit][subblock_index][i];

747


748
				total_error += color_distance(perceptual, pBlock_pixels[idx], unpacked_block[idx], false);

749
			}

750
		}

751


752
		return total_error;

753
	}

754


755
	void etc_block::get_subblock_pixels(color_rgba* pPixels, int subblock_index) const

756
	{

757
		if (subblock_index < 0)

758
			unpack_etc1(*this, pPixels);

759
		else

760
		{

761
			color_rgba unpacked_block[16];

762


763
			unpack_etc1(*this, unpacked_block);

764


765
			const bool flip_bit = get_flip_bit();

766


767
			for (uint32_t i = 0; i < 8; i++)

768
			{

769
				const uint32_t idx = g_etc1_pixel_indices[flip_bit][subblock_index][i];

770


771
				pPixels[i] = unpacked_block[idx];

772
			}

773
		}

774
	}

775
								

776
	bool etc1_optimizer::compute()

777
	{

778
		assert(m_pResult->m_pSelectors);

779


780
		if (m_pParams->m_pForce_selectors)

781
		{

782
			assert(m_pParams->m_quality >= cETCQualitySlow);

783
			if (m_pParams->m_quality < cETCQualitySlow)

784
				return false;

785
		}

786


787
		const uint32_t n = m_pParams->m_num_src_pixels;

788


789
		if (m_pParams->m_cluster_fit)

790
		{

791
			if (m_pParams->m_quality == cETCQualityFast)

792
				compute_internal_cluster_fit(4);

793
			else if (m_pParams->m_quality == cETCQualityMedium)

794
				compute_internal_cluster_fit(16);

795
			else if (m_pParams->m_quality == cETCQualitySlow)

796
				compute_internal_cluster_fit(64);

797
			else

798
				compute_internal_cluster_fit(BASISU_ETC1_CLUSTER_FIT_ORDER_TABLE_SIZE);

799
		}

800
		else

801
			compute_internal_neighborhood(m_br, m_bg, m_bb);

802


803
		if (!m_best_solution.m_valid)

804
		{

805
			m_pResult->m_error = UINT32_MAX;

806
			return false;

807
		}

808


809
		//const uint8_t* pSelectors = &m_best_solution.m_selectors[0];

810
		const uint8_t* pSelectors = m_pParams->m_pForce_selectors ? m_pParams->m_pForce_selectors : &m_best_solution.m_selectors[0];

811


812
#if defined(DEBUG) || defined(_DEBUG)

813
		{

814
			// sanity check the returned error

815
			color_rgba block_colors[4];

816
			m_best_solution.m_coords.get_block_colors(block_colors);

817


818
			const color_rgba* pSrc_pixels = m_pParams->m_pSrc_pixels;

819
			uint64_t actual_error = 0;

820
			

821
			bool perceptual;

822
			if (m_pParams->m_quality >= cETCQualityMedium)

823
				perceptual = m_pParams->m_perceptual;

824
			else

825
				perceptual = (m_pParams->m_quality == cETCQualityFast) ? false : m_pParams->m_perceptual;

826
						

827
			for (uint32_t i = 0; i < n; i++)

828
				actual_error += color_distance(perceptual, pSrc_pixels[i], block_colors[pSelectors[i]], false);

829


830
			assert(actual_error == m_best_solution.m_error);

831
		}

832
#endif      

833


834
		m_pResult->m_error = m_best_solution.m_error;

835


836
		m_pResult->m_block_color_unscaled = m_best_solution.m_coords.m_unscaled_color;

837
		m_pResult->m_block_color4 = m_best_solution.m_coords.m_color4;

838


839
		m_pResult->m_block_inten_table = m_best_solution.m_coords.m_inten_table;

840
		memcpy(m_pResult->m_pSelectors, pSelectors, n);

841
		m_pResult->m_n = n;

842


843
		return true;

844
	}

845


846
	void etc1_optimizer::refine_solution(uint32_t max_refinement_trials)

847
	{

848
		// Now we have the input block, the avg. color of the input pixels, a set of trial selector indices, and the block color+intensity index.

849
		// Now, for each component, attempt to refine the current solution by solving a simple linear equation. For example, for 4 colors:

850
		// The goal is:

851
		// pixel0 - (block_color+inten_table[selector0]) + pixel1 - (block_color+inten_table[selector1]) + pixel2 - (block_color+inten_table[selector2]) + pixel3 - (block_color+inten_table[selector3]) = 0

852
		// Rearranging this:

853
		// (pixel0 + pixel1 + pixel2 + pixel3) - (block_color+inten_table[selector0]) - (block_color+inten_table[selector1]) - (block_color+inten_table[selector2]) - (block_color+inten_table[selector3]) = 0

854
		// (pixel0 + pixel1 + pixel2 + pixel3) - block_color - inten_table[selector0] - block_color-inten_table[selector1] - block_color-inten_table[selector2] - block_color-inten_table[selector3] = 0

855
		// (pixel0 + pixel1 + pixel2 + pixel3) - 4*block_color - inten_table[selector0] - inten_table[selector1] - inten_table[selector2] - inten_table[selector3] = 0

856
		// (pixel0 + pixel1 + pixel2 + pixel3) - 4*block_color - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3]) = 0

857
		// (pixel0 + pixel1 + pixel2 + pixel3)/4 - block_color - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3])/4 = 0

858
		// block_color = (pixel0 + pixel1 + pixel2 + pixel3)/4 - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3])/4

859
		// So what this means:

860
		// optimal_block_color = avg_input - avg_inten_delta

861
		// So the optimal block color can be computed by taking the average block color and subtracting the current average of the intensity delta.

862
		// Unfortunately, optimal_block_color must then be quantized to 555 or 444 so it's not always possible to improve matters using this formula.

863
		// Also, the above formula is for unclamped intensity deltas. The actual implementation takes into account clamping.

864


865
		const uint32_t n = m_pParams->m_num_src_pixels;

866


867
		for (uint32_t refinement_trial = 0; refinement_trial < max_refinement_trials; refinement_trial++)

868
		{

869
			const uint8_t* pSelectors = &m_best_solution.m_selectors[0];

870
			const int* pInten_table = g_etc1_inten_tables[m_best_solution.m_coords.m_inten_table];

871


872
			int delta_sum_r = 0, delta_sum_g = 0, delta_sum_b = 0;

873
			const color_rgba base_color(m_best_solution.m_coords.get_scaled_color());

874
			for (uint32_t r = 0; r < n; r++)

875
			{

876
				const uint32_t s = *pSelectors++;

877
				const int yd_temp = pInten_table[s];

878
				// Compute actual delta being applied to each pixel, taking into account clamping.

879
				delta_sum_r += clamp<int>(base_color.r + yd_temp, 0, 255) - base_color.r;

880
				delta_sum_g += clamp<int>(base_color.g + yd_temp, 0, 255) - base_color.g;

881
				delta_sum_b += clamp<int>(base_color.b + yd_temp, 0, 255) - base_color.b;

882
			}

883


884
			if ((!delta_sum_r) && (!delta_sum_g) && (!delta_sum_b))

885
				break;

886


887
			const float avg_delta_r_f = static_cast<float>(delta_sum_r) / n;

888
			const float avg_delta_g_f = static_cast<float>(delta_sum_g) / n;

889
			const float avg_delta_b_f = static_cast<float>(delta_sum_b) / n;

890
			const int br1 = clamp<int>(static_cast<int32_t>((m_avg_color[0] - avg_delta_r_f) * m_limit / 255.0f + .5f), 0, m_limit);

891
			const int bg1 = clamp<int>(static_cast<int32_t>((m_avg_color[1] - avg_delta_g_f) * m_limit / 255.0f + .5f), 0, m_limit);

892
			const int bb1 = clamp<int>(static_cast<int32_t>((m_avg_color[2] - avg_delta_b_f) * m_limit / 255.0f + .5f), 0, m_limit);

893


894
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

895
			printf("Refinement trial %u, avg_delta %f %f %f\n", refinement_trial, avg_delta_r_f, avg_delta_g_f, avg_delta_b_f);

896
#endif

897


898
			if (!evaluate_solution(etc1_solution_coordinates(br1, bg1, bb1, 0, m_pParams->m_use_color4), m_trial_solution, &m_best_solution))

899
				break;

900


901
		}  // refinement_trial

902
	}

903


904
	void etc1_optimizer::compute_internal_neighborhood(int scan_r, int scan_g, int scan_b)

905
	{

906
		if (m_best_solution.m_error == 0)

907
			return;

908


909
		//const uint32_t n = m_pParams->m_num_src_pixels;

910
		const int scan_delta_size = m_pParams->m_scan_delta_size;

911


912
		// Scan through a subset of the 3D lattice centered around the avg block color trying each 3D (555 or 444) lattice point as a potential block color.

913
		// Each time a better solution is found try to refine the current solution's block color based of the current selectors and intensity table index.

914
		for (int zdi = 0; zdi < scan_delta_size; zdi++)

915
		{

916
			const int zd = m_pParams->m_pScan_deltas[zdi];

917
			const int mbb = scan_b + zd;

918
			if (mbb < 0) continue; else if (mbb > m_limit) break;

919


920
			for (int ydi = 0; ydi < scan_delta_size; ydi++)

921
			{

922
				const int yd = m_pParams->m_pScan_deltas[ydi];

923
				const int mbg = scan_g + yd;

924
				if (mbg < 0) continue; else if (mbg > m_limit) break;

925


926
				for (int xdi = 0; xdi < scan_delta_size; xdi++)

927
				{

928
					const int xd = m_pParams->m_pScan_deltas[xdi];

929
					const int mbr = scan_r + xd;

930
					if (mbr < 0) continue; else if (mbr > m_limit) break;

931


932
					etc1_solution_coordinates coords(mbr, mbg, mbb, 0, m_pParams->m_use_color4);

933


934
					if (!evaluate_solution(coords, m_trial_solution, &m_best_solution))

935
						continue;

936


937
					if (m_pParams->m_refinement)

938
					{

939
						refine_solution((m_pParams->m_quality == cETCQualityFast) ? 2 : (((xd | yd | zd) == 0) ? 4 : 2));

940
					}

941


942
				} // xdi

943
			} // ydi

944
		} // zdi

945
	}

946


947
	void etc1_optimizer::compute_internal_cluster_fit(uint32_t total_perms_to_try)

948
	{

949
		if ((!m_best_solution.m_valid) || ((m_br != m_best_solution.m_coords.m_unscaled_color.r) || (m_bg != m_best_solution.m_coords.m_unscaled_color.g) || (m_bb != m_best_solution.m_coords.m_unscaled_color.b)))

950
		{

951
			evaluate_solution(etc1_solution_coordinates(m_br, m_bg, m_bb, 0, m_pParams->m_use_color4), m_trial_solution, &m_best_solution);

952
		}

953


954
		if ((m_best_solution.m_error == 0) || (!m_best_solution.m_valid))

955
			return;

956


957
		for (uint32_t i = 0; i < total_perms_to_try; i++)

958
		{

959
			int delta_sum_r = 0, delta_sum_g = 0, delta_sum_b = 0;

960


961
			const int *pInten_table = g_etc1_inten_tables[m_best_solution.m_coords.m_inten_table];

962
			const color_rgba base_color(m_best_solution.m_coords.get_scaled_color());

963


964
			const uint8_t *pNum_selectors = g_cluster_fit_order_tab[i].m_v;

965


966
			for (uint32_t q = 0; q < 4; q++)

967
			{

968
				const int yd_temp = pInten_table[q];

969


970
				delta_sum_r += pNum_selectors[q] * (clamp<int>(base_color.r + yd_temp, 0, 255) - base_color.r);

971
				delta_sum_g += pNum_selectors[q] * (clamp<int>(base_color.g + yd_temp, 0, 255) - base_color.g);

972
				delta_sum_b += pNum_selectors[q] * (clamp<int>(base_color.b + yd_temp, 0, 255) - base_color.b);

973
			}

974


975
			if ((!delta_sum_r) && (!delta_sum_g) && (!delta_sum_b))

976
				continue;

977


978
			const float avg_delta_r_f = static_cast<float>(delta_sum_r) / 8;

979
			const float avg_delta_g_f = static_cast<float>(delta_sum_g) / 8;

980
			const float avg_delta_b_f = static_cast<float>(delta_sum_b) / 8;

981


982
			const int br1 = clamp<int>(static_cast<int32_t>((m_avg_color[0] - avg_delta_r_f) * m_limit / 255.0f + .5f), 0, m_limit);

983
			const int bg1 = clamp<int>(static_cast<int32_t>((m_avg_color[1] - avg_delta_g_f) * m_limit / 255.0f + .5f), 0, m_limit);

984
			const int bb1 = clamp<int>(static_cast<int32_t>((m_avg_color[2] - avg_delta_b_f) * m_limit / 255.0f + .5f), 0, m_limit);

985


986
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

987
			printf("Second refinement trial %u, avg_delta %f %f %f\n", i, avg_delta_r_f, avg_delta_g_f, avg_delta_b_f);

988
#endif

989


990
			evaluate_solution(etc1_solution_coordinates(br1, bg1, bb1, 0, m_pParams->m_use_color4), m_trial_solution, &m_best_solution);

991


992
			if (m_best_solution.m_error == 0)

993
				break;

994
		}

995
	}

996


997
	void etc1_optimizer::init(const params& params, results& result)

998
	{

999
		m_pParams = &params;

1000
		m_pResult = &result;

1001


1002
		const uint32_t n = m_pParams->m_num_src_pixels;

1003


1004
		m_selectors.resize(n);

1005
		m_best_selectors.resize(n);

1006
		m_temp_selectors.resize(n);

1007
		m_trial_solution.m_selectors.resize(n);

1008
		m_best_solution.m_selectors.resize(n);

1009


1010
		m_limit = m_pParams->m_use_color4 ? 15 : 31;

1011


1012
		vec3F avg_color(0.0f);

1013


1014
		m_luma.resize(n);

1015
		m_sorted_luma_indices.resize(n);

1016
		m_sorted_luma.resize(n);

1017
		

1018
		int min_r = 255, min_g = 255, min_b = 255;

1019
		int max_r = 0, max_g = 0, max_b = 0;

1020
		

1021
		for (uint32_t i = 0; i < n; i++)

1022
		{

1023
			const color_rgba& c = m_pParams->m_pSrc_pixels[i];

1024


1025
			min_r = basisu::minimum<int>(min_r, c.r);

1026
			min_g = basisu::minimum<int>(min_g, c.g);

1027
			min_b = basisu::minimum<int>(min_b, c.b);

1028


1029
			max_r = basisu::maximum<int>(max_r, c.r);

1030
			max_g = basisu::maximum<int>(max_g, c.g);

1031
			max_b = basisu::maximum<int>(max_b, c.b);

1032


1033
			const vec3F fc(c.r, c.g, c.b);

1034


1035
			avg_color += fc;

1036


1037
			m_luma[i] = static_cast<uint16_t>(c.r + c.g + c.b);

1038
			m_sorted_luma_indices[i] = i;

1039
		}

1040
		avg_color /= static_cast<float>(n);

1041
		m_avg_color = avg_color;

1042
		m_max_comp_spread = basisu::maximum(basisu::maximum(max_r - min_r, max_g - min_g), max_b - min_b);

1043


1044
		m_br = clamp<int>(static_cast<uint32_t>(m_avg_color[0] * m_limit / 255.0f + .5f), 0, m_limit);

1045
		m_bg = clamp<int>(static_cast<uint32_t>(m_avg_color[1] * m_limit / 255.0f + .5f), 0, m_limit);

1046
		m_bb = clamp<int>(static_cast<uint32_t>(m_avg_color[2] * m_limit / 255.0f + .5f), 0, m_limit);

1047


1048
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1049
		printf("Avg block color: %u %u %u\n", m_br, m_bg, m_bb);

1050
#endif

1051


1052
		if (m_pParams->m_quality == cETCQualityFast)

1053
		{

1054
			indirect_sort(n, &m_sorted_luma_indices[0], &m_luma[0]);

1055


1056
			m_pSorted_luma = &m_sorted_luma[0];

1057
			m_pSorted_luma_indices = &m_sorted_luma_indices[0];

1058
			

1059
			for (uint32_t i = 0; i < n; i++)

1060
				m_pSorted_luma[i] = m_luma[m_pSorted_luma_indices[i]];

1061
		}

1062


1063
		m_best_solution.m_coords.clear();

1064
		m_best_solution.m_valid = false;

1065
		m_best_solution.m_error = UINT64_MAX;

1066


1067
		clear_obj(m_solutions_tried);

1068
	}

1069


1070
	// Return false if we've probably already tried this solution, true if we have definitely not.

1071
	bool etc1_optimizer::check_for_redundant_solution(const etc1_solution_coordinates& coords)

1072
	{

1073
		// Hash first 3 bytes of color (RGB)

1074
		uint32_t kh = hash_hsieh((uint8_t*)&coords.m_unscaled_color.r, 3);

1075


1076
		uint32_t h0 = kh & cSolutionsTriedHashMask;

1077
		uint32_t h1 = (kh >> cSolutionsTriedHashBits) & cSolutionsTriedHashMask;

1078


1079
		// Simple Bloom filter lookup with k=2

1080
		if ( ((m_solutions_tried[h0 >> 3] & (1 << (h0 & 7))) != 0) &&

1081
		     ((m_solutions_tried[h1 >> 3] & (1 << (h1 & 7))) != 0) )

1082
			return false;

1083


1084
		m_solutions_tried[h0 >> 3] |= (1 << (h0 & 7));

1085
		m_solutions_tried[h1 >> 3] |= (1 << (h1 & 7));

1086


1087
		return true;

1088
	}

1089
		

1090
	static uint8_t g_eval_dist_tables[8][256] =

1091
	{

1092
		// 99% threshold

1093
		{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,},

1094
		{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,},

1095
		{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,},

1096
		{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,},

1097
		{ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,},

1098
		{ 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,},

1099
		{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,},

1100
		{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,}

1101
	};

1102


1103
	bool etc1_optimizer::evaluate_solution_slow(const etc1_solution_coordinates& coords, potential_solution& trial_solution, potential_solution* pBest_solution)

1104
	{

1105
		if (!check_for_redundant_solution(coords))

1106
			return false;

1107


1108
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1109
		printf("Eval solution: %u %u %u\n", coords.m_unscaled_color.r, coords.m_unscaled_color.g, coords.m_unscaled_color.b);

1110
#endif

1111


1112
		trial_solution.m_valid = false;

1113


1114
		if (m_pParams->m_constrain_against_base_color5)

1115
		{

1116
			const int dr = (int)coords.m_unscaled_color.r - (int)m_pParams->m_base_color5.r;

1117
			const int dg = (int)coords.m_unscaled_color.g - (int)m_pParams->m_base_color5.g;

1118
			const int db = (int)coords.m_unscaled_color.b - (int)m_pParams->m_base_color5.b;

1119


1120
			if ((minimum(dr, dg, db) < cETC1ColorDeltaMin) || (maximum(dr, dg, db) > cETC1ColorDeltaMax))

1121
			{

1122
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1123
				printf("Eval failed due to constraint from %u %u %u\n", m_pParams->m_base_color5.r, m_pParams->m_base_color5.g, m_pParams->m_base_color5.b);

1124
#endif

1125
				return false;

1126
			}

1127
		}

1128


1129
		const color_rgba base_color(coords.get_scaled_color());

1130


1131
		const uint32_t n = m_pParams->m_num_src_pixels;

1132
		assert(trial_solution.m_selectors.size() == n);

1133


1134
		trial_solution.m_error = INT64_MAX;

1135


1136
		const uint8_t *pSelectors_to_use = m_pParams->m_pForce_selectors;

1137


1138
		for (uint32_t inten_table = 0; inten_table < cETC1IntenModifierValues; inten_table++)

1139
		{

1140
			if (m_pParams->m_quality <= cETCQualityMedium)

1141
			{

1142
				if (!g_eval_dist_tables[inten_table][m_max_comp_spread])

1143
					continue;

1144
			}

1145


1146
#if 0

1147
			if (m_pParams->m_quality <= cETCQualityMedium)

1148
			{

1149
				// For tables 5-7, if the max component spread falls within certain ranges, skip the inten table. Statistically they are extremely unlikely to result in lower error.

1150
				if (inten_table == 7)

1151
				{

1152
					if (m_max_comp_spread < 42)

1153
						continue;

1154
				}

1155
				else if (inten_table == 6)

1156
				{

1157
					if ((m_max_comp_spread >= 12) && (m_max_comp_spread <= 31))

1158
						continue;

1159
				}

1160
				else if (inten_table == 5)

1161
				{

1162
					if ((m_max_comp_spread >= 13) && (m_max_comp_spread <= 21))

1163
						continue;

1164
				}

1165
			}

1166
#endif

1167


1168
			const int* pInten_table = g_etc1_inten_tables[inten_table];

1169


1170
			color_rgba block_colors[4];

1171
			for (uint32_t s = 0; s < 4; s++)

1172
			{

1173
				const int yd = pInten_table[s];

1174
				block_colors[s].set(base_color.r + yd, base_color.g + yd, base_color.b + yd, 255);

1175
			}

1176


1177
			uint64_t total_error = 0;

1178


1179
			const color_rgba* pSrc_pixels = m_pParams->m_pSrc_pixels;

1180


1181
			if (!g_cpu_supports_sse41)

1182
			{

1183
				for (uint32_t c = 0; c < n; c++)

1184
				{

1185
					const color_rgba& src_pixel = *pSrc_pixels++;

1186


1187
					uint32_t best_selector_index = 0;

1188
					uint32_t best_error = 0;

1189


1190
					if (pSelectors_to_use)

1191
					{

1192
						best_selector_index = pSelectors_to_use[c];

1193
						best_error = color_distance(m_pParams->m_perceptual, src_pixel, block_colors[best_selector_index], false);

1194
					}

1195
					else

1196
					{

1197
						best_error = color_distance(m_pParams->m_perceptual, src_pixel, block_colors[0], false);

1198


1199
						uint32_t trial_error = color_distance(m_pParams->m_perceptual, src_pixel, block_colors[1], false);

1200
						if (trial_error < best_error)

1201
						{

1202
							best_error = trial_error;

1203
							best_selector_index = 1;

1204
						}

1205


1206
						trial_error = color_distance(m_pParams->m_perceptual, src_pixel, block_colors[2], false);

1207
						if (trial_error < best_error)

1208
						{

1209
							best_error = trial_error;

1210
							best_selector_index = 2;

1211
						}

1212


1213
						trial_error = color_distance(m_pParams->m_perceptual, src_pixel, block_colors[3], false);

1214
						if (trial_error < best_error)

1215
						{

1216
							best_error = trial_error;

1217
							best_selector_index = 3;

1218
						}

1219
					}

1220


1221
					m_temp_selectors[c] = static_cast<uint8_t>(best_selector_index);

1222


1223
					total_error += best_error;

1224
					if (total_error >= trial_solution.m_error)

1225
						break;

1226
				}

1227
			}

1228
			else

1229
			{

1230
#if BASISU_SUPPORT_SSE

1231
				if (pSelectors_to_use)

1232
				{

1233
					if (m_pParams->m_perceptual)

1234
						perceptual_distance_rgb_4_N_sse41((int64_t*)&total_error, pSelectors_to_use, block_colors, pSrc_pixels, n, trial_solution.m_error);

1235
					else

1236
						linear_distance_rgb_4_N_sse41((int64_t*)&total_error, pSelectors_to_use, block_colors, pSrc_pixels, n, trial_solution.m_error);

1237
				}

1238
				else

1239
				{

1240
					if (m_pParams->m_perceptual)

1241
						find_selectors_perceptual_rgb_4_N_sse41((int64_t*)&total_error, &m_temp_selectors[0], block_colors, pSrc_pixels, n, trial_solution.m_error);

1242
					else

1243
						find_selectors_linear_rgb_4_N_sse41((int64_t*)&total_error, &m_temp_selectors[0], block_colors, pSrc_pixels, n, trial_solution.m_error);

1244
				}

1245
#endif

1246
			}

1247


1248
			if (total_error < trial_solution.m_error)

1249
			{

1250
				trial_solution.m_error = total_error;

1251
				trial_solution.m_coords.m_inten_table = inten_table;

1252
				trial_solution.m_selectors.swap(m_temp_selectors);

1253
				trial_solution.m_valid = true;

1254
			}

1255
		}

1256
		trial_solution.m_coords.m_unscaled_color = coords.m_unscaled_color;

1257
		trial_solution.m_coords.m_color4 = m_pParams->m_use_color4;

1258
				

1259
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1260
		printf("Eval done: %u error: %I64u best error so far: %I64u\n", (trial_solution.m_error < pBest_solution->m_error), trial_solution.m_error, pBest_solution->m_error);

1261
#endif

1262


1263
		bool success = false;

1264
		if (pBest_solution)

1265
		{

1266
			if (trial_solution.m_error < pBest_solution->m_error)

1267
			{

1268
				*pBest_solution = trial_solution;

1269
				success = true;

1270
			}

1271
		}

1272
				

1273
		return success;

1274
	}

1275


1276
	bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coords, potential_solution& trial_solution, potential_solution* pBest_solution)

1277
	{

1278
		if (!check_for_redundant_solution(coords))

1279
			return false;

1280


1281
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1282
		printf("Eval solution fast: %u %u %u\n", coords.m_unscaled_color.r, coords.m_unscaled_color.g, coords.m_unscaled_color.b);

1283
#endif

1284


1285
		if (m_pParams->m_constrain_against_base_color5)

1286
		{

1287
			const int dr = (int)coords.m_unscaled_color.r - (int)m_pParams->m_base_color5.r;

1288
			const int dg = (int)coords.m_unscaled_color.g - (int)m_pParams->m_base_color5.g;

1289
			const int db = (int)coords.m_unscaled_color.b - (int)m_pParams->m_base_color5.b;

1290


1291
			if ((minimum(dr, dg, db) < cETC1ColorDeltaMin) || (maximum(dr, dg, db) > cETC1ColorDeltaMax))

1292
			{

1293
				trial_solution.m_valid = false;

1294


1295
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1296
				printf("Eval failed due to constraint from %u %u %u\n", m_pParams->m_base_color5.r, m_pParams->m_base_color5.g, m_pParams->m_base_color5.b);

1297
#endif

1298
				return false;

1299
			}

1300
		}

1301


1302
		const color_rgba base_color(coords.get_scaled_color());

1303
		

1304
		const uint32_t n = m_pParams->m_num_src_pixels;

1305
		assert(trial_solution.m_selectors.size() == n);

1306


1307
		trial_solution.m_error = UINT64_MAX;

1308
								

1309
		const bool perceptual = (m_pParams->m_quality == cETCQualityFast) ? false : m_pParams->m_perceptual;

1310
				

1311
		for (int inten_table = cETC1IntenModifierValues - 1; inten_table >= 0; --inten_table)

1312
		{

1313
			const int* pInten_table = g_etc1_inten_tables[inten_table];

1314


1315
			uint32_t block_inten[4];

1316
			color_rgba block_colors[4];

1317
			for (uint32_t s = 0; s < 4; s++)

1318
			{

1319
				const int yd = pInten_table[s];

1320
				color_rgba block_color(base_color.r + yd, base_color.g + yd, base_color.b + yd, 255);

1321
				block_colors[s] = block_color;

1322
				block_inten[s] = block_color.r + block_color.g + block_color.b;

1323
			}

1324


1325
			// evaluate_solution_fast() enforces/assumes a total ordering of the input colors along the intensity (1,1,1) axis to more quickly classify the inputs to selectors.

1326
			// The inputs colors have been presorted along the projection onto this axis, and ETC1 block colors are always ordered along the intensity axis, so this classification is fast.

1327
			// 0   1   2   3

1328
			//   01  12  23

1329
			const uint32_t block_inten_midpoints[3] = { block_inten[0] + block_inten[1], block_inten[1] + block_inten[2], block_inten[2] + block_inten[3] };

1330
															

1331
			uint64_t total_error = 0;

1332
			const color_rgba* pSrc_pixels = m_pParams->m_pSrc_pixels;

1333
						

1334
			if (perceptual)

1335
			{

1336
				if ((m_pSorted_luma[n - 1] * 2) < block_inten_midpoints[0])

1337
				{

1338
					if (block_inten[0] > m_pSorted_luma[n - 1])

1339
					{

1340
						const uint32_t min_error = iabs((int)block_inten[0] - (int)m_pSorted_luma[n - 1]);

1341
						if (min_error >= trial_solution.m_error)

1342
							continue;

1343
					}

1344


1345
					memset(&m_temp_selectors[0], 0, n);

1346


1347
					for (uint32_t c = 0; c < n; c++)

1348
						total_error += color_distance(true, block_colors[0], pSrc_pixels[c], false);

1349
				}

1350
				else if ((m_pSorted_luma[0] * 2) >= block_inten_midpoints[2])

1351
				{

1352
					if (m_pSorted_luma[0] > block_inten[3])

1353
					{

1354
						const uint32_t min_error = iabs((int)m_pSorted_luma[0] - (int)block_inten[3]);

1355
						if (min_error >= trial_solution.m_error)

1356
							continue;

1357
					}

1358


1359
					memset(&m_temp_selectors[0], 3, n);

1360


1361
					for (uint32_t c = 0; c < n; c++)

1362
						total_error += color_distance(true, block_colors[3], pSrc_pixels[c], false);

1363
				}

1364
				else

1365
				{

1366
					if (!g_cpu_supports_sse41)

1367
					{

1368
						uint32_t cur_selector = 0, c;

1369
						for (c = 0; c < n; c++)

1370
						{

1371
							const uint32_t y = m_pSorted_luma[c];

1372
							while ((y * 2) >= block_inten_midpoints[cur_selector])

1373
								if (++cur_selector > 2)

1374
									goto done;

1375
							const uint32_t sorted_pixel_index = m_pSorted_luma_indices[c];

1376
							m_temp_selectors[sorted_pixel_index] = static_cast<uint8_t>(cur_selector);

1377
							total_error += color_distance(true, block_colors[cur_selector], pSrc_pixels[sorted_pixel_index], false);

1378
						}

1379
					done:

1380
						while (c < n)

1381
						{

1382
							const uint32_t sorted_pixel_index = m_pSorted_luma_indices[c];

1383
							m_temp_selectors[sorted_pixel_index] = 3;

1384
							total_error += color_distance(true, block_colors[3], pSrc_pixels[sorted_pixel_index], false);

1385
							++c;

1386
						}

1387
					}

1388
					else

1389
					{

1390
#if BASISU_SUPPORT_SSE

1391
						uint32_t cur_selector = 0, c;

1392


1393
						for (c = 0; c < n; c++)

1394
						{

1395
							const uint32_t y = m_pSorted_luma[c];

1396
							while ((y * 2) >= block_inten_midpoints[cur_selector])

1397
							{

1398
								if (++cur_selector > 2)

1399
									goto done3;

1400
							}

1401
							const uint32_t sorted_pixel_index = m_pSorted_luma_indices[c];

1402
							m_temp_selectors[sorted_pixel_index] = static_cast<uint8_t>(cur_selector);

1403
						}

1404
					done3:

1405


1406
						while (c < n)

1407
						{

1408
							const uint32_t sorted_pixel_index = m_pSorted_luma_indices[c];

1409
							m_temp_selectors[sorted_pixel_index] = 3;

1410
							++c;

1411
						}

1412


1413
						int64_t block_error;

1414
						perceptual_distance_rgb_4_N_sse41(&block_error, &m_temp_selectors[0], block_colors, pSrc_pixels, n, INT64_MAX);

1415
						total_error += block_error;

1416
#endif

1417
					}

1418
				}

1419
			}

1420
			else

1421
			{

1422
				if ((m_pSorted_luma[n - 1] * 2) < block_inten_midpoints[0])

1423
				{

1424
					if (block_inten[0] > m_pSorted_luma[n - 1])

1425
					{

1426
						const uint32_t min_error = iabs((int)block_inten[0] - (int)m_pSorted_luma[n - 1]);

1427
						if (min_error >= trial_solution.m_error)

1428
							continue;

1429
					}

1430


1431
					memset(&m_temp_selectors[0], 0, n);

1432


1433
					for (uint32_t c = 0; c < n; c++)

1434
						total_error += color_distance(block_colors[0], pSrc_pixels[c], false);

1435
				}

1436
				else if ((m_pSorted_luma[0] * 2) >= block_inten_midpoints[2])

1437
				{

1438
					if (m_pSorted_luma[0] > block_inten[3])

1439
					{

1440
						const uint32_t min_error = iabs((int)m_pSorted_luma[0] - (int)block_inten[3]);

1441
						if (min_error >= trial_solution.m_error)

1442
							continue;

1443
					}

1444


1445
					memset(&m_temp_selectors[0], 3, n);

1446


1447
					for (uint32_t c = 0; c < n; c++)

1448
						total_error += color_distance(block_colors[3], pSrc_pixels[c], false);

1449
				}

1450
				else

1451
				{

1452
					uint32_t cur_selector = 0, c;

1453
					for (c = 0; c < n; c++)

1454
					{

1455
						const uint32_t y = m_pSorted_luma[c];

1456
						while ((y * 2) >= block_inten_midpoints[cur_selector])

1457
							if (++cur_selector > 2)

1458
								goto done2;

1459
						const uint32_t sorted_pixel_index = m_pSorted_luma_indices[c];

1460
						m_temp_selectors[sorted_pixel_index] = static_cast<uint8_t>(cur_selector);

1461
						total_error += color_distance(block_colors[cur_selector], pSrc_pixels[sorted_pixel_index], false);

1462
					}

1463
				done2:

1464
					while (c < n)

1465
					{

1466
						const uint32_t sorted_pixel_index = m_pSorted_luma_indices[c];

1467
						m_temp_selectors[sorted_pixel_index] = 3;

1468
						total_error += color_distance(block_colors[3], pSrc_pixels[sorted_pixel_index], false);

1469
						++c;

1470
					}

1471
				}

1472
			}

1473


1474
			if (total_error < trial_solution.m_error)

1475
			{

1476
				trial_solution.m_error = total_error;

1477
				trial_solution.m_coords.m_inten_table = inten_table;

1478
				trial_solution.m_selectors.swap(m_temp_selectors);

1479
				trial_solution.m_valid = true;

1480
				if (!total_error)

1481
					break;

1482
			}

1483
		}

1484
		trial_solution.m_coords.m_unscaled_color = coords.m_unscaled_color;

1485
		trial_solution.m_coords.m_color4 = m_pParams->m_use_color4;

1486


1487
#if BASISU_DEBUG_ETC_ENCODER_DEEPER

1488
		printf("Eval done: %u error: %I64u best error so far: %I64u\n", (trial_solution.m_error < pBest_solution->m_error), trial_solution.m_error, pBest_solution->m_error);

1489
#endif

1490


1491
		bool success = false;

1492
		if (pBest_solution)

1493
		{

1494
			if (trial_solution.m_error < pBest_solution->m_error)

1495
			{

1496
				*pBest_solution = trial_solution;

1497
				success = true;

1498
			}

1499
		}

1500


1501
		return success;

1502
	}

1503


1504
	uint64_t pack_eac_a8(pack_eac_a8_results& results, const uint8_t* pPixels, uint32_t num_pixels, uint32_t base_search_rad, uint32_t mul_search_rad, uint32_t table_mask)

1505
	{

1506
		results.m_selectors.resize(num_pixels);

1507
		results.m_selectors_temp.resize(num_pixels);

1508


1509
		uint32_t min_alpha = 255, max_alpha = 0;

1510
		for (uint32_t i = 0; i < num_pixels; i++)

1511
		{

1512
			const uint32_t a = pPixels[i];

1513
			if (a < min_alpha) min_alpha = a;

1514
			if (a > max_alpha) max_alpha = a;

1515
		}

1516


1517
		if (min_alpha == max_alpha)

1518
		{

1519
			results.m_base = min_alpha;

1520
			results.m_table = 13;

1521
			results.m_multiplier = 1;

1522
			for (uint32_t i = 0; i < num_pixels; i++)

1523
				results.m_selectors[i] = 4;

1524
			return 0;

1525
		}

1526


1527
		const uint32_t alpha_range = max_alpha - min_alpha;

1528


1529
		uint64_t best_err = UINT64_MAX;

1530


1531
		for (uint32_t table = 0; table < 16; table++)

1532
		{

1533
			if ((table_mask & (1U << table)) == 0)

1534
				continue;

1535


1536
			const float range = (float)(g_etc2_eac_tables[table][ETC2_EAC_MAX_VALUE_SELECTOR] - g_etc2_eac_tables[table][ETC2_EAC_MIN_VALUE_SELECTOR]);

1537
			const int center = (int)roundf(lerp((float)min_alpha, (float)max_alpha, (float)(0 - g_etc2_eac_tables[table][ETC2_EAC_MIN_VALUE_SELECTOR]) / range));

1538


1539
			const int base_min = clamp255(center - base_search_rad);

1540
			const int base_max = clamp255(center + base_search_rad);

1541


1542
			const int mul = (int)roundf(alpha_range / range);

1543
			const int mul_low = clamp<int>(mul - mul_search_rad, 1, 15);

1544
			const int mul_high = clamp<int>(mul + mul_search_rad, 1, 15);

1545


1546
			for (int base = base_min; base <= base_max; base++)

1547
			{

1548
				for (int multiplier = mul_low; multiplier <= mul_high; multiplier++)

1549
				{

1550
					uint64_t total_err = 0;

1551


1552
					for (uint32_t i = 0; i < num_pixels; i++)

1553
					{

1554
						const int a = pPixels[i];

1555


1556
						uint32_t best_s_err = UINT32_MAX;

1557
						uint32_t best_s = 0;

1558
						for (uint32_t s = 0; s < 8; s++)

1559
						{

1560
							const int v = clamp255((int)multiplier * g_etc2_eac_tables[table][s] + (int)base);

1561


1562
							uint32_t err = iabs(a - v);

1563
							if (err < best_s_err)

1564
							{

1565
								best_s_err = err;

1566
								best_s = s;

1567
							}

1568
						}

1569


1570
						results.m_selectors_temp[i] = static_cast<uint8_t>(best_s);

1571


1572
						total_err += best_s_err * best_s_err;

1573
						if (total_err >= best_err)

1574
							break;

1575
					}

1576


1577
					if (total_err < best_err)

1578
					{

1579
						best_err = total_err;

1580
						results.m_base = base;

1581
						results.m_multiplier = multiplier;

1582
						results.m_table = table;

1583
						results.m_selectors.swap(results.m_selectors_temp);

1584
						if (!best_err)

1585
							return best_err;

1586
					}

1587


1588
				} // table

1589


1590
			} // multiplier

1591


1592
		} // base

1593


1594
		return best_err;

1595
	}

1596


1597
	void pack_eac_a8(eac_a8_block* pBlock, const uint8_t* pPixels, uint32_t base_search_rad, uint32_t mul_search_rad, uint32_t table_mask)

1598
	{

1599
		pack_eac_a8_results results;

1600
		pack_eac_a8(results, pPixels, 16, base_search_rad, mul_search_rad, table_mask);

1601


1602
		pBlock->m_base = results.m_base;

1603
		pBlock->m_multiplier = results.m_multiplier;

1604
		pBlock->m_table = results.m_table;

1605
		for (uint32_t y = 0; y < 4; y++)

1606
			for (uint32_t x = 0; x < 4; x++)

1607
				pBlock->set_selector(x, y, results.m_selectors[x + y * 4]);

1608
	}

1609


1610
} // namespace basisu

1611


1612