1// basis_etc.cpp
2// Copyright (C) 2019-2021 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
25namespace 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