--- /dev/null
+// File: rg_etc1.cpp - Fast, high quality ETC1 block packer/unpacker - Rich Geldreich <richgel99@gmail.com>
+// Please see ZLIB license at the end of rg_etc1.h.
+//
+// For more information Ericsson Texture Compression (ETC/ETC1), see:
+// http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt
+//
+// v1.04 - 5/15/14 - Fix signed vs. unsigned subtraction problem (noticed when compiled with gcc) in pack_etc1_block_init().
+// This issue would cause an assert when this func. was called in debug. (Note this module was developed/testing with MSVC,
+// I still need to test it throughly when compiled with gcc.)
+//
+// v1.03 - 5/12/13 - Initial public release
+
+#include <stdlib.h>
+#include <memory.h>
+#include <assert.h>
+#include <math.h>
+
+#include "rg_etc1.h"
+
+#if defined(_DEBUG) || defined(DEBUG)
+#define RG_ETC1_BUILD_DEBUG
+#endif
+
+typedef unsigned long long uint64;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+typedef unsigned int uint32;
+typedef unsigned char DATA8;
+
+#define false 0
+#define true 1
+#define RG_ETC1_ASSERT assert
+
+#define MIN(A, B) ((A < B) ? A : B)
+#define MAX(A, B) ((A > B) ? A : B)
+#define CLAMP(Value, Low, High) ((Value < Low) ? Low : ((Value > High) ? High : Value))
+#define SQUARE(Value) (Value * Value)
+
+#ifndef UINT_MAX
+#define UINT_MAX 4294967295U
+#endif
+
+#ifndef ULLONG_MAX
+#define ULLONG_MAX 18446744073709551615ULL
+#endif
+
+#define cUINT32_MAX UINT_MAX
+#define cUINT64_MAX ULLONG_MAX
+#define RG_ETC1_ARRAY_SIZE(X) (sizeof(X) / sizeof((X)[0]))
+
+enum RG_Etc_Constants
+ {
+ cETC1BytesPerBlock = 8U,
+
+ cETC1SelectorBits = 2U,
+ cETC1SelectorValues = 1U << cETC1SelectorBits,
+ cETC1SelectorMask = cETC1SelectorValues - 1U,
+
+ cETC1BlockShift = 2U,
+ cETC1BlockSize = 1U << cETC1BlockShift,
+
+ cETC1LSBSelectorIndicesBitOffset = 0,
+ cETC1MSBSelectorIndicesBitOffset = 16,
+
+ cETC1FlipBitOffset = 32,
+ cETC1DiffBitOffset = 33,
+
+ cETC1IntenModifierNumBits = 3,
+ cETC1IntenModifierValues = 1 << cETC1IntenModifierNumBits,
+ cETC1RightIntenModifierTableBitOffset = 34,
+ cETC1LeftIntenModifierTableBitOffset = 37,
+
+ // Base+Delta encoding (5 bit bases, 3 bit delta)
+ cETC1BaseColorCompNumBits = 5,
+ cETC1BaseColorCompMax = 1 << cETC1BaseColorCompNumBits,
+
+ cETC1DeltaColorCompNumBits = 3,
+ cETC1DeltaColorComp = 1 << cETC1DeltaColorCompNumBits,
+ cETC1DeltaColorCompMax = 1 << cETC1DeltaColorCompNumBits,
+
+ cETC1BaseColor5RBitOffset = 59,
+ cETC1BaseColor5GBitOffset = 51,
+ cETC1BaseColor5BBitOffset = 43,
+
+ cETC1DeltaColor3RBitOffset = 56,
+ cETC1DeltaColor3GBitOffset = 48,
+ cETC1DeltaColor3BBitOffset = 40,
+
+ // Absolute (non-delta) encoding (two 4-bit per component bases)
+ cETC1AbsColorCompNumBits = 4,
+ cETC1AbsColorCompMax = 1 << cETC1AbsColorCompNumBits,
+
+ cETC1AbsColor4R1BitOffset = 60,
+ cETC1AbsColor4G1BitOffset = 52,
+ cETC1AbsColor4B1BitOffset = 44,
+
+ cETC1AbsColor4R2BitOffset = 56,
+ cETC1AbsColor4G2BitOffset = 48,
+ cETC1AbsColor4B2BitOffset = 40,
+
+ cETC1ColorDeltaMin = -4,
+ cETC1ColorDeltaMax = 3,
+
+ // Delta3:
+ // 0 1 2 3 4 5 6 7
+ // 000 001 010 011 100 101 110 111
+ // 0 1 2 3 -4 -3 -2 -1
+ };
+
+#ifndef WORDS_BIGENDIAN
+/* x86 */
+#define R_VAL(p) (((DATA8 *)(p))[0])
+#define G_VAL(p) (((DATA8 *)(p))[1])
+#define B_VAL(p) (((DATA8 *)(p))[2])
+#define A_VAL(p) (((DATA8 *)(p))[3])
+#define BA_VAL(p) ((DATA16 *)(p)[1])
+#define RG_VAL(p) ((DATA16 *)(p)[0])
+#else
+/* ppc */
+#define R_VAL(p) (((DATA8 *)(p))[3])
+#define G_VAL(p) (((DATA8 *)(p))[2])
+#define B_VAL(p) (((DATA8 *)(p))[1])
+#define A_VAL(p) (((DATA8 *)(p))[0])
+#define BA_VAL(p) ((DATA16 *)(p)[0])
+#define RG_VAL(p) ((DATA16 *)(p)[1])
+#endif
+
+//#define ARGB_JOIN(a,r,g,b) \
+// (((a) << 24) + ((r) << 16) + ((g) << 8) + (b))
+
+#define ARGB_JOIN(a,r,g,b) \
+ (((a) << 24) + ((b) << 16) + ((g) << 8) + (r))
+static unsigned char rg_etc_quant5_tab[256 + 16];
+
+static const int rg_etc1_inten_tables[cETC1IntenModifierValues][cETC1SelectorValues] = {
+ { -8, -2, 2, 8 },
+ { -17, -5, 5, 17 },
+ { -29, -9, 9, 29 },
+ { -42, -13, 13, 42 },
+ { -60, -18, 18, 60 },
+ { -80, -24, 24, 80 },
+ { -106, -33, 33, 106 },
+ { -183, -47, 47, 183 }
+};
+
+static const unsigned char rg_etc1_to_selector_index[cETC1SelectorValues] = { 2, 3, 1, 0 };
+static const unsigned char rg_etc_selector_index_to_etc1[cETC1SelectorValues] = { 3, 2, 0, 1 };
+
+// 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.
+static unsigned short rg_etc1_inverse_lookup[2*8*4][256]; // [diff/inten_table/selector][desired_color]
+
+// rg_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.
+// To pack: diff | (inten << 1) | (selector << 4) | (packed_c << 8)
+static const unsigned short rg_etc_color8_to_etc_block_config_0_255[2][33] = {
+ {
+ 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
+ },
+ {
+ 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
+ },
+};
+
+// Really only [254][11].
+static const unsigned short rg_etc_color8_to_etc_block_config_1_to_254[254][12] = {
+ { 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 },
+ { 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, 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, 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 },
+ { 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, 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, 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, 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 },
+ { 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 },
+ { 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, 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, 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, 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, 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, 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 },
+ { 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, 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 },
+ { 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, 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, 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 },
+ { 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, 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 },
+ { 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, 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, 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, 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 },
+ { 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, 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, 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 },
+ { 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, 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, 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, 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, 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, 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 },
+ { 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 },
+ { 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 },
+};
+
+typedef union
+{
+ struct comp {
+ unsigned char r;
+ unsigned char g;
+ unsigned char b;
+ unsigned char a;
+ } comp;
+
+ unsigned char c[4];
+
+ unsigned int m_u32;
+} color_quad_u8;
+
+static inline int
+rg_etc1_color_quad_u8_clamp(int v)
+{
+ if (v & 0xFFFFFF00U)
+ v = ((~v) >> 31) & 0xFF;
+ return v;
+}
+
+static inline void
+rg_etc1_color_quad_u8_init(color_quad_u8 *color, int r, int g, int b, int alpha)
+{
+ color->comp.r = rg_etc1_color_quad_u8_clamp(r);
+ color->comp.g = rg_etc1_color_quad_u8_clamp(g);
+ color->comp.b = rg_etc1_color_quad_u8_clamp(b);
+ color->comp.a = rg_etc1_color_quad_u8_clamp(alpha);
+}
+static inline void
+rg_etc1_color_quad_u8_copy(color_quad_u8 *dst, const color_quad_u8 *src)
+{
+ dst->m_u32 = src->m_u32;
+}
+
+static inline void
+rg_etc1_color_quad_u8_clear(color_quad_u8 *color)
+{
+ color->m_u32 = 0;
+}
+
+static inline unsigned int
+rg_etc1_color_quad_u8_rgb_squared_distance(color_quad_u8 color1, color_quad_u8 color2)
+{
+
+ return SQUARE((color1.comp.r - color2.comp.r)) + SQUARE((color1.comp.g - color2.comp.g)) + SQUARE((color1.comp.b - color2.comp.b));
+}
+
+static inline void
+rg_etc1_color_quad_u8_component_set(color_quad_u8 *color, unsigned char idx, unsigned char value)
+{
+
+ switch (idx)
+ {
+ case 0: color->comp.r = value; break;
+ case 1: color->comp.g = value; break;
+ case 2: color->comp.b = value; break;
+ case 3: color->comp.a = value; break;
+ default: abort();
+ }
+
+}
+
+static inline unsigned int
+rg_etc1_color_quad_duplicate_init(unsigned char y, unsigned char alpha)
+{
+ return ARGB_JOIN(alpha, y, y, y);
+}
+
+static inline unsigned int
+rg_etc1_color_quad_init(unsigned char r, unsigned char g, unsigned char b, unsigned char alpha)
+{
+ return ARGB_JOIN(alpha, r, g, b);
+}
+
+static inline unsigned int
+rg_etc1_color_quad_set(unsigned int old_color, unsigned int new_color, unsigned char preserve_alpha)
+{
+ if (preserve_alpha)
+ {
+ unsigned char r, g, b, a;
+
+ a = A_VAL(&old_color);
+ r = R_VAL(&new_color);
+ g = G_VAL(&new_color);
+ b = B_VAL(&new_color);
+
+ return ARGB_JOIN(a, r, g, b);
+ }
+ return new_color;
+}
+
+static inline void
+rg_etc1_color_quad_get(unsigned int color, unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *alpha)
+{
+ if (r) *r = R_VAL(&color);
+ if (g) *g = G_VAL(&color);
+ if (b) *b = B_VAL(&color);
+ if (alpha) *alpha = A_VAL(&color);
+}
+
+static inline unsigned char
+rg_etc1_color_quad_component_get(unsigned int color, unsigned char idx)
+{
+ switch (idx)
+ {
+ case 0: return R_VAL(&color);
+ case 1: return G_VAL(&color);
+ case 2: return B_VAL(&color);
+ case 3: return A_VAL(&color);
+ default: abort();
+ }
+ return 0;
+}
+
+static inline unsigned int
+rg_etc1_color_quad_component_set(unsigned int color, unsigned char idx, unsigned char value)
+{
+ unsigned char r, g, b, a;
+
+ rg_etc1_color_quad_get(color, &r, &g, &b, &a);
+
+ switch (idx)
+ {
+ case 0: r = value; break;
+ case 1: g = value; break;
+ case 2: b = value; break;
+ case 3: a = value; break;
+ default: abort();
+ }
+
+ return rg_etc1_color_quad_init(r, g, b, a);
+}
+
+static inline unsigned int
+rg_etc1_color_quad_grayscale_set(unsigned int color, unsigned char l)
+{
+ unsigned char a;
+
+ a = A_VAL(&color);
+
+ return rg_etc1_color_quad_init(l, l, l, a);
+}
+
+static inline unsigned int
+rg_etc1_color_quad_clamp(unsigned int color, unsigned int low, unsigned high)
+{
+ unsigned char *c = (unsigned char *)&color;
+ unsigned char *l = (unsigned char *)&low;
+ unsigned char *h = (unsigned char *)&high;
+ unsigned int i;
+
+ for (i = 0; i < 4; i++)
+ c[i] = clamp(c[i], l[i], h[i]);
+
+ return color;
+}
+
+static inline unsigned int
+rg_etc1_color_quad_component_clamp(unsigned int color, unsigned int low, unsigned high)
+{
+ unsigned char *c = (unsigned char *)&color;
+ unsigned int i;
+
+ for (i = 0; i < 4; i++)
+ c[i] = clamp(c[i], low, high);
+
+ return color;
+}
+
+// Returns CCIR 601 luma (consistent with color_utils::RGB_To_Y).
+static inline unsigned char
+rg_etc1_color_quad_luma601_get(unsigned int color)
+{
+ unsigned char r, g, b;
+ rg_etc1_color_quad_get(color, &r, &g, &b, NULL);
+ return ((19595U * r + 38470U * g + 7471U * b + 32768U) >> 16U);
+}
+
+// Returns REC 709 luma.
+static inline unsigned char
+rg_etc1_color_quad_luma709_get(unsigned int color)
+{
+ unsigned char r, g, b;
+ rg_etc1_color_quad_get(color, &r, &g, &b, NULL);
+ return ((13938U * r + 46869U * g + 4729U * b + 32768U) >> 16U);
+}
+
+static inline unsigned int
+rg_etc1_color_quad_rgb_squared_distance(unsigned int color1, unsigned int color2)
+{
+ unsigned char r1, g1, b1;
+ unsigned char r2, g2, b2;
+
+ rg_etc1_color_quad_get(color1, &r1, &g1, &b1, NULL);
+ rg_etc1_color_quad_get(color2, &r2, &g2, &b2, NULL);
+
+ return SQUARE(r1 - r2) + SQUARE(g1 - g2) + SQUARE(b1 - b2);
+}
+
+static inline unsigned int
+rg_etc1_color_quad_argb_squared_distance(unsigned int color1, unsigned int color2)
+{
+ unsigned char r1, g1, b1, a1;
+ unsigned char r2, g2, b2, a2;
+
+ rg_etc1_color_quad_get(color1, &r1, &g1, &b1, &a1);
+ rg_etc1_color_quad_get(color2, &r2, &g2, &b2, &a2);
+
+ return SQUARE(r1 - r2) + SQUARE(g1 - g2) + SQUARE(b1 - b2) + SQUARE(a1 - a1);
+}
+
+static inline unsigned char
+rg_etc1_color_quad_rgb_equals(unsigned int color1, unsigned int color2)
+{
+ A_VAL(&color1) = 0;
+ A_VAL(&color2) = 0;
+
+ return color1 == color2;
+}
+
+static inline unsigned int
+rg_etc1_color_quad_add(unsigned int color1, unsigned int color2)
+{
+ unsigned char *c1 = (unsigned char *)&color1;
+ unsigned char *c2 = (unsigned char *)&color2;
+ unsigned int i;
+
+ for (i = 0; i < 4; i++)
+ {
+ unsigned short t;
+
+ t = c1[i] + c2[i];
+ c1[i] = (unsigned char) (CLAMP(t, 0, 255));
+ }
+
+ return color1;
+}
+
+static inline unsigned int
+rg_etc1_color_quad_del(unsigned int color1, unsigned int color2)
+{
+ unsigned char *c1 = (unsigned char *)&color1;
+ unsigned char *c2 = (unsigned char *)&color2;
+ unsigned int i;
+
+ for (i = 0; i < 4; i++)
+ {
+ short t;
+
+ t = c1[i] - c2[i];
+ c1[i] = (unsigned char) (CLAMP(t, 0, 255));
+ }
+
+ return color1;
+}
+
+static inline void
+rg_etc1_vec_init(float v[3], float s)
+{
+ v[0] = s; v[1] = s; v[2] = s;
+}
+
+static inline void
+rg_etc1_vec_set(float v[3], float x, float y, float z)
+{
+ v[0] = x; v[1] = y; v[2] = z;
+}
+
+static inline void
+rg_etc1_vec_copy(float dst[3], float src[3])
+{
+ dst[0] = src[0]; dst[1] = src[1]; dst[2] = src[2];
+}
+
+static inline void
+rg_etc1_vec_add(float r[3], float a[3])
+{
+ unsigned int i;
+
+ //for (i = 0; i < RG_ETC1_ARRAY_SIZE(r); i++)
+ for (i = 0; i < 3; i++)
+ r[i] += a[i];
+}
+
+static inline void
+rg_etc1_vec_scale(float r[3], float s)
+{
+ unsigned int i;
+
+ //for (i = 0; i < RG_ETC1_ARRAY_SIZE(r); i++)
+ for (i = 0; i < 3; i++)
+ r[i] *= s;
+}
+
+static inline unsigned char
+rg_etc1_block_byte_bits_get(const unsigned char bytes[8], unsigned char offset, unsigned char num)
+{
+ const unsigned char byte_offset = 7 - (offset >> 3);
+ const unsigned char byte_bit_offset = offset & 7;
+
+ return (bytes[byte_offset] >> byte_bit_offset) & ((1 << num) - 1);
+}
+
+static inline void
+rg_etc1_block_byte_bits_set(unsigned char bytes[8], unsigned char offset, unsigned char num, unsigned char bits)
+{
+ const unsigned char byte_offset = 7 - (offset >> 3);
+ const unsigned char byte_bit_offset = offset & 7;
+ const unsigned char mask = (1 << num) - 1;
+ bytes[byte_offset] &= ~(mask << byte_bit_offset);
+ bytes[byte_offset] |= (((!!bits) & 0x1) << byte_bit_offset);
+}
+
+static inline unsigned char
+rg_etc1_block_flip_bit_get(const unsigned char bytes[8])
+{
+ return (bytes[3] & 1) != 0;
+}
+
+static inline void
+rg_etc1_block_flip_bit_set(unsigned char bytes[8], unsigned char flip)
+{
+ bytes[3] &= ~1;
+ bytes[3] |= (!!flip) & 0x1;
+}
+
+static inline unsigned char
+rg_etc1_block_diff_bit_get(const unsigned char bytes[8])
+{
+ return (bytes[3] & 2) != 0;
+}
+
+static inline void
+rg_etc1_block_diff_bit_set(unsigned char bytes[8], unsigned char diff)
+{
+ bytes[3] &= ~2;
+ bytes[3] |= ((!!diff) & 0x1) << 1;
+}
+
+static inline void
+rg_etc1_block_clear(unsigned char bytes[8])
+{
+ memset(bytes, 0, sizeof (bytes));
+}
+
+// Returns intensity modifier table (0-7) used by subblock subblock_id.
+// subblock_id=0 left/top (CW 1), 1=right/bottom (CW 2)
+static inline unsigned char
+rg_etc1_block_inten_table_get(const unsigned char bytes[8], unsigned char subblock_id)
+{
+ const unsigned char offset = subblock_id ? 2 : 5;
+ assert(subblock_id < 2);
+ return (bytes[3] >> offset) & 7;
+}
+
+// Sets intensity modifier table (0-7) used by subblock subblock_id (0 or 1)
+static inline void
+rg_etc1_block_inten_table_set(unsigned char bytes[8], unsigned char subblock_id, unsigned char t)
+{
+ const unsigned char offset = subblock_id ? 2 : 5;
+ assert(subblock_id < 2);
+ assert(t < 8);
+ bytes[3] &= ~(7 << offset);
+ bytes[3] |= (t << offset);
+}
+
+// Returned selector value ranges from 0-3 and is a direct index into g_etc1_inten_tables.
+static inline unsigned char
+rg_etc1_block_selector_get(const unsigned char bytes[8], unsigned char x, unsigned char y)
+{
+ assert((x | y) < 4);
+
+ const unsigned char bit_index = x * 4 + y;
+ const unsigned char byte_bit_offset = bit_index & 7;
+ const unsigned char *p = &bytes[7 - (bit_index >> 3)];
+ const unsigned char lsb = (p[0] >> byte_bit_offset) & 1;
+ const unsigned char msb = (p[-2] >> byte_bit_offset) & 1;
+ const unsigned char val = lsb | (msb << 1);
+
+ return rg_etc1_to_selector_index[val];
+}
+
+// Selector "val" ranges from 0-3 and is a direct index into g_etc1_inten_tables.
+static inline void
+rg_etc1_block_selector_set(unsigned char bytes[8], unsigned char x, unsigned char y, unsigned char val)
+{
+ assert((x | y) < 4);
+
+ const unsigned char bit_index = x * 4 + y;
+
+ unsigned char *p = &bytes[7 - (bit_index >> 3)];
+
+ const unsigned char byte_bit_offsets = bit_index & 7;
+ const unsigned char mask = 1 << byte_bit_offsets;
+ const unsigned char etc1_val = rg_etc_selector_index_to_etc1[val];
+
+ const unsigned char lsb = etc1_val & 1;
+ const unsigned char msb = etc1_val >> 1;
+
+ p[0] &= ~mask;
+ p[0] |= (lsb << byte_bit_offsets);
+
+ p[-2] &= ~mask;
+ p[-2] |= (msb << byte_bit_offsets);
+}
+
+static inline unsigned short
+rg_etc_block_base4_color_get(const unsigned char bytes[8], unsigned char idx)
+{
+ unsigned short r, g, b;
+
+ if (idx)
+ {
+ r = rg_etc1_block_byte_bits_get(bytes, cETC1AbsColor4R2BitOffset, 4);
+ g = rg_etc1_block_byte_bits_get(bytes, cETC1AbsColor4G2BitOffset, 4);
+ b = rg_etc1_block_byte_bits_get(bytes, cETC1AbsColor4B2BitOffset, 4);
+ }
+ else
+ {
+ r = rg_etc1_block_byte_bits_get(bytes, cETC1AbsColor4R1BitOffset, 4);
+ g = rg_etc1_block_byte_bits_get(bytes, cETC1AbsColor4G1BitOffset, 4);
+ b = rg_etc1_block_byte_bits_get(bytes, cETC1AbsColor4B1BitOffset, 4);
+ }
+
+ return b | (g << 4) | (r << 8);
+}
+
+static inline void
+rg_etc1_block_base4_color_set(unsigned char bytes[8], unsigned char idx, unsigned short c)
+{
+ if (idx)
+ {
+ rg_etc1_block_byte_bits_set(bytes, cETC1AbsColor4R2BitOffset, 4, (c >> 8) & 15);
+ rg_etc1_block_byte_bits_set(bytes, cETC1AbsColor4G2BitOffset, 4, (c >> 4) & 15);
+ rg_etc1_block_byte_bits_set(bytes, cETC1AbsColor4B2BitOffset, 4, c & 15);
+ }
+ else
+ {
+ rg_etc1_block_byte_bits_set(bytes, cETC1AbsColor4R1BitOffset, 4, (c >> 8) & 15);
+ rg_etc1_block_byte_bits_set(bytes, cETC1AbsColor4G1BitOffset, 4, (c >> 4) & 15);
+ rg_etc1_block_byte_bits_set(bytes, cETC1AbsColor4B1BitOffset, 4, c & 15);
+ }
+}
+
+static inline unsigned short
+rg_etc1_block_base5_color_get(const unsigned char bytes[8])
+{
+ unsigned short r, g, b;
+
+ r = rg_etc1_block_byte_bits_get(bytes, cETC1BaseColor5RBitOffset, 5);
+ g = rg_etc1_block_byte_bits_get(bytes, cETC1BaseColor5GBitOffset, 5);
+ b = rg_etc1_block_byte_bits_get(bytes, cETC1BaseColor5BBitOffset, 5);
+
+ return b | (g << 5) | (r << 10);
+}
+
+static inline void
+rg_etc1_block_base5_color_set(unsigned char bytes[8], unsigned short c)
+{
+ rg_etc1_block_byte_bits_set(bytes, cETC1BaseColor5RBitOffset, 5, (c >> 10) & 31);
+ rg_etc1_block_byte_bits_set(bytes, cETC1BaseColor5GBitOffset, 5, (c >> 5) & 31);
+ rg_etc1_block_byte_bits_set(bytes, cETC1BaseColor5BBitOffset, 5, c & 31);
+}
+
+static inline unsigned short
+rg_etc1_block_delta3_color_get(const unsigned char bytes[8])
+{
+ unsigned short r, g, b;
+
+ r = rg_etc1_block_byte_bits_get(bytes, cETC1DeltaColor3RBitOffset, 3);
+ g = rg_etc1_block_byte_bits_get(bytes, cETC1DeltaColor3GBitOffset, 3);
+ b = rg_etc1_block_byte_bits_get(bytes, cETC1DeltaColor3BBitOffset, 3);
+
+ return b | (g << 3) | (r << 6);
+}
+
+static inline void
+rg_etc1_block_delta3_color_set(unsigned char bytes[8], unsigned short c)
+{
+ rg_etc1_block_byte_bits_set(bytes, cETC1DeltaColor3RBitOffset, 3, (c >> 6) & 7);
+ rg_etc1_block_byte_bits_set(bytes, cETC1DeltaColor3GBitOffset, 3, (c >> 3) & 7);
+ rg_etc1_block_byte_bits_set(bytes, cETC1DeltaColor3BBitOffset, 3, c & 7);
+}
+
+static inline unsigned short
+rg_etc1_block_color5_component_pack(unsigned char r, unsigned char g, unsigned char b,
+ unsigned char scaled, unsigned char bias)
+{
+ if (scaled)
+ {
+ r = (r * 31 + bias) / 255U;
+ g = (g * 31 + bias) / 255U;
+ b = (b * 31 + bias) / 255U;
+ }
+
+ r = MIN(r, 31);
+ g = MIN(g, 31);
+ b = MIN(b, 31);
+
+ return b | (g << 5) | (r << 10);
+}
+
+static inline unsigned short
+rg_etc1_block_color5_pack(unsigned int c, unsigned char scaled, unsigned char bias)
+{
+ unsigned char r, g, b;
+
+ rg_etc1_color_quad_get(c, &r, &g, &b, NULL);
+ return rg_etc1_block_color5_component_pack(r, g, b, scaled, bias);
+}
+
+static inline void
+rg_etc1_block_color5_component_unpack(unsigned char *r, unsigned char *g, unsigned char *b,
+ unsigned short packed_color5, unsigned scaled)
+{
+ *r = (packed_color5 >> 10) & 31;
+ *g = (packed_color5 >> 5) & 31;
+ *b = packed_color5 & 31;
+
+ if (scaled)
+ {
+ *b = (*b << 3) | (*b >> 2);
+ *g = (*g << 3) | (*g >> 2);
+ *r = (*r << 3) | (*r >> 2);
+ }
+}
+
+static inline unsigned int
+rg_etc1_block_color5_unpack(unsigned short packed_color5, unsigned char scaled, unsigned char alpha)
+{
+ unsigned char r, g, b;
+
+ rg_etc1_block_color5_component_unpack(&r, &g, &b, packed_color5, scaled);
+
+ return rg_etc1_color_quad_init(r, g, b, MIN(alpha, 255));
+}
+
+// Inputs range from -4 to 3 (cETC1ColorDeltaMin to cETC1ColorDeltaMax)
+static inline unsigned int
+rg_etc1_block_delta3_pack(char r, char g, char b)
+{
+ assert((r >= cETC1ColorDeltaMin) && (r <= cETC1ColorDeltaMax));
+ assert((g >= cETC1ColorDeltaMin) && (g <= cETC1ColorDeltaMax));
+ assert((b >= cETC1ColorDeltaMin) && (b <= cETC1ColorDeltaMax));
+
+ if (r < 0) r += 8;
+ if (g < 0) g += 8;
+ if (b < 0) b += 8;
+
+ return b | (g << 3) | (r << 6);
+}
+
+// Results range from -4 to 3 (cETC1ColorDeltaMin to cETC1ColorDeltaMax)
+static inline void
+rg_etc1_block_delta3_unpack(char *r, char *g, char *b, unsigned short packed_delta3)
+{
+ *r = (packed_delta3 >> 6) & 7;
+ *g = (packed_delta3 >> 3) & 7;
+ *b = packed_delta3 & 7;
+
+ if (*r >= 4) *r -= 8;
+ if (*g >= 4) *g -= 8;
+ if (*b >= 4) *b -= 8;
+}
+
+static inline unsigned short
+rg_etc1_block_color4_component_pack(unsigned char r, unsigned char g, unsigned char b,
+ unsigned char scaled, unsigned char bias)
+{
+ if (scaled)
+ {
+ r = (r * 15 + bias) / 255;
+ g = (g * 15 + bias) / 255;
+ b = (b * 15 + bias) / 255;
+ }
+
+ r = MIN(r, 15);
+ g = MIN(g, 15);
+ b = MIN(b, 15);
+
+ return b | (g << 4) | (r << 8);
+}
+
+static inline unsigned short
+rg_etc1_block_color4_pack(unsigned int color, unsigned char scaled, unsigned char bias)
+{
+ unsigned char r, g, b;
+
+ rg_etc1_color_quad_get(color, &r, &g, &b, NULL);
+ return rg_etc1_block_color4_component_pack(r, g, b, scaled, bias);
+}
+
+static inline void
+rg_etc1_block_color4_component_unpack(unsigned char *r, unsigned char *g, unsigned char *b,
+ unsigned short packed_color4, bool scaled)
+{
+ *r = (packed_color4 >> 8) & 15;
+ *g = (packed_color4 >> 4) & 15;
+ *b = packed_color4 & 15;
+
+ if (scaled)
+ {
+ *b = (*b << 4) | *b;
+ *g = (*g << 4) | *g;
+ *r = (*r << 4) | *r;
+ }
+}
+
+static inline unsigned int
+rg_etc1_block_color4_unpack(unsigned short packed_color4, unsigned char scaled, unsigned char alpha)
+{
+ unsigned char r, g, b;
+
+ rg_etc1_block_color4_component_unpack(&r, &g, &b, packed_color4, scaled);
+
+ return rg_etc1_color_quad_init(r, g, b, 255);
+}
+
+
+static inline unsigned char
+rg_etc1_block_color5_delta3_component_unpack(unsigned char *r, unsigned char *g, unsigned char *b,
+ unsigned short packed_color5, unsigned short packed_delta3, bool scaled)
+{
+ unsigned char success = 1;
+ char dc_r, dc_g, dc_b;
+
+ rg_etc1_block_delta3_unpack(&dc_r, &dc_g, &dc_b, packed_delta3);
+
+ *r = ((packed_color5 >> 10) & 31) + dc_r;
+ *g = ((packed_color5 >> 5) & 31) + dc_g;
+ *b = (packed_color5 & 31) + dc_b;
+
+ if ((*r | *g | *b) > 31)
+ {
+ success = 0;
+ *r = CLAMP(*r, 0, 31);
+ *g = CLAMP(*g, 0, 31);
+ *b = CLAMP(*b, 0, 31);
+ }
+
+ if (scaled)
+ {
+ *r = (*r << 3) | (*r >> 2);
+ *g = (*g << 3) | (*g >> 2);
+ *b = (*b << 3) | (*b >> 2);
+ }
+
+ return success;
+}
+
+
+static inline unsigned char
+rg_etc1_block_color5_delta3_unpack(unsigned int *result,
+ unsigned short packed_color5, unsigned short packed_delta3,
+ bool scaled, unsigned char alpha)
+{
+ unsigned char success;
+ unsigned char r, g, b;
+
+ success = rg_etc1_block_color5_delta3_component_unpack(&r, &g, &b, packed_color5, packed_delta3, scaled);
+
+ *result = rg_etc1_color_quad_init(r, g, b, alpha);
+ return success;
+}
+
+static inline void
+rg_etc1_block_sublock_diff(unsigned int dst[4], const int *pInten_modifer_table,
+ unsigned char r, unsigned char g, unsigned char b)
+{
+ int i;
+
+ for (i = 0; i < 4; i++)
+ {
+ int y = pInten_modifer_table[i];
+
+ dst[i] = rg_etc1_color_quad_init(CLAMP((int)r + y, 0, 255),
+ CLAMP((int) g + y,0, 255),
+ CLAMP((int) b + y,0, 255),
+ 255);
+ }
+}
+
+static inline void
+rg_etc1_block_subblock_color5_diff_get(unsigned int dst[4], unsigned short packed_color5, unsigned char table_idx)
+{
+ const int *pInten_modifer_table;
+ unsigned char r, g, b;
+
+ assert(table_idx < cETC1IntenModifierValues);
+
+ rg_etc1_block_color5_component_unpack(&r, &g, &b, packed_color5, 1);
+
+ pInten_modifer_table = &rg_etc1_inten_tables[table_idx][0];
+ rg_etc1_block_sublock_diff(dst, pInten_modifer_table, r, g, b);
+}
+
+static inline unsigned char
+rg_etc1_block_subblock_color5_delta3_diff_get(unsigned int dst[4],
+ unsigned short packed_color5, unsigned short packed_delta3,
+ unsigned char table_idx)
+{
+ const int *pInten_modifer_table;
+ unsigned char r, g, b;
+ unsigned char success;
+
+ assert(table_idx < cETC1IntenModifierValues);
+
+ success = rg_etc1_block_color5_delta3_component_unpack(&r, &g, &b, packed_color5, packed_delta3, 1);
+
+ pInten_modifer_table = &rg_etc1_inten_tables[table_idx][0];
+ rg_etc1_block_sublock_diff(dst, pInten_modifer_table, r, g, b);
+
+ return success;
+}
+
+static inline void
+rg_etc1_block_subblock_color4_abs_get(unsigned int dst[4], unsigned short packed_color4, unsigned char table_idx)
+{
+ const int *pInten_modifer_table;
+ unsigned char r, g, b;
+
+ assert(table_idx < cETC1IntenModifierValues);
+
+ rg_etc1_block_color4_component_unpack(&r, &g, &b, packed_color4, 1);
+
+ pInten_modifer_table = &rg_etc1_inten_tables[table_idx][0];
+ rg_etc1_block_sublock_diff(dst, pInten_modifer_table, r, g, b);
+}
+
+// This is the exported function to unpack a block
+bool
+rg_etc1_unpack_block(const void *ETC1_block, unsigned int *pixels, bool preserve_alpha)
+{
+ unsigned char diff_flag, flip_flag, table_index0, table_index1;
+ unsigned int subblock_colors0[4];
+ unsigned int subblock_colors1[4];
+ unsigned char x, y;
+ unsigned char success = 1;
+
+ diff_flag = rg_etc1_block_diff_bit_get(ETC1_block);
+ flip_flag = rg_etc1_block_flip_bit_get(ETC1_block);
+ table_index0 = rg_etc1_block_inten_table_get(ETC1_block, 0);
+ table_index1 = rg_etc1_block_inten_table_get(ETC1_block, 1);
+
+ if (diff_flag)
+ {
+ unsigned short base_color5, delta_color3;
+
+ base_color5 = rg_etc1_block_base5_color_get(ETC1_block);
+ delta_color3 = rg_etc1_block_delta3_color_get(ETC1_block);
+
+ rg_etc1_block_subblock_color5_diff_get(subblock_colors0, base_color5, table_index0);
+ success = rg_etc1_block_subblock_color5_delta3_diff_get(subblock_colors1,
+ base_color5, delta_color3,
+ table_index1);
+ }
+ else
+ {
+ unsigned short base_color4_0, base_color4_1;
+
+ base_color4_0 = rg_etc_block_base4_color_get(ETC1_block, 0);
+ base_color4_1 = rg_etc_block_base4_color_get(ETC1_block, 1);
+
+ rg_etc1_block_subblock_color4_abs_get(subblock_colors0, base_color4_0, table_index0);
+ rg_etc1_block_subblock_color4_abs_get(subblock_colors1, base_color4_1, table_index1);
+ }
+
+ // FIXME: preserve_alpha and continue
+ // Block is either :
+ // 0000
+ // 0000
+ // 1111
+ // 1111
+ // or :
+ // 0011
+ // 0011
+ // 0011
+ // 0011
+ // Depending on flip_flag.
+
+ if (flip_flag)
+ {
+ for (y = 0; y < 2; y++)
+ {
+ for (x = 0; x < 4; x++)
+ pixels[x] = rg_etc1_color_quad_set(pixels[x],
+ subblock_colors0[rg_etc1_block_selector_get(ETC1_block, x, y)],
+ preserve_alpha);
+ pixels += 4;
+ }
+
+ for (y = 2; y < 4; y++)
+ {
+ for (x = 0; x < 4; x++)
+ pixels[x] = rg_etc1_color_quad_set(pixels[x],
+ subblock_colors1[rg_etc1_block_selector_get(ETC1_block, x, y)],
+ preserve_alpha);
+ pixels += 4;
+ }
+ }
+ else
+ {
+ for (y = 0; y < 4; y++)
+ {
+ for (x = 0; x < 2; x++)
+ pixels[x] = rg_etc1_color_quad_set(pixels[x],
+ subblock_colors0[rg_etc1_block_selector_get(ETC1_block, x, y)],
+ preserve_alpha);
+ for (; x < 4; x++)
+ pixels[x] = rg_etc1_color_quad_set(pixels[x],
+ subblock_colors1[rg_etc1_block_selector_get(ETC1_block, x, y)],
+ preserve_alpha);
+
+ pixels += 4;
+ }
+ }
+
+ return success;
+}
+
+// NOTE: Most of the following loop could be unrolled, but for sanity and readability, I did
+// prefer to stick to simpler solution.
+static inline unsigned int *
+rg_etc1_indirect_radix_sort(unsigned int num_indices, unsigned int pIndices0[8], unsigned int pIndices1[8],
+ const unsigned short pKeys[8], unsigned int key_ofs, unsigned char key_size,
+ unsigned char init_indices)
+{
+ unsigned int hist[256 * 4];
+ unsigned int *p;
+ unsigned int *q;
+ unsigned int *pCur;
+ unsigned int *pNew;
+ unsigned int key;
+ unsigned int pass;
+
+ assert((key_ofs >= 0) && (key_ofs < sizeof(pIndices0)));
+ assert((key_size >= 1) && (key_size <= 4));
+
+ if (init_indices)
+ {
+ unsigned int i;
+
+ p = pIndices0;
+ for (i = 0; i < num_indices; p++, i++)
+ *p = i;
+ }
+
+ memset(hist, 0, sizeof (hist));
+
+#define RG_ETC1_GET_KEY(p) (*(const unsigned int*)((const unsigned char*)(pKeys + *(p)) + key_ofs))
+#define RG_ETC1_GET_KEY_FROM_INDEX(i) (*(const unsigned int*)((const unsigned char*)(pKeys + (i)) + key_ofs))
+
+ switch (key_size)
+ {
+ case 4:
+ p = pIndices0;
+ q = pIndices0 + num_indices;
+
+ for (; p != q; p++)
+ {
+ key = RG_ETC1_GET_KEY(p);
+
+ hist[ key & 0xFF]++;
+ hist[256 + ((key >> 8) & 0xFF)]++;
+ hist[512 + ((key >> 16) & 0xFF)]++;
+ hist[768 + ((key >> 24) & 0xFF)]++;
+ }
+ break;
+ case 3:
+ p = pIndices0;
+ q = pIndices0 + num_indices;
+
+ for ( ; p != q; p++)
+ {
+ key = RG_ETC1_GET_KEY(p);
+
+ hist[ key & 0xFF]++;
+ hist[256 + ((key >> 8) & 0xFF)]++;
+ hist[512 + ((key >> 16) & 0xFF)]++;
+ }
+ break;
+ case 2:
+ p = pIndices0;
+ q = pIndices0 + num_indices;
+
+ for ( ; p != q; p++)
+ {
+ key = RG_ETC1_GET_KEY(p);
+
+ hist[ key & 0xFF]++;
+ hist[256 + ((key >> 8) & 0xFF)]++;
+ }
+ break;
+ case 1:
+ p = pIndices0;
+ q = pIndices0 + num_indices;
+
+ for ( ; p != q; p++)
+ {
+ key = RG_ETC1_GET_KEY(p);
+
+ hist[key & 0xFF]++;
+ }
+ break;
+ default:
+ abort();
+ }
+
+ pCur = pIndices0;
+ pNew = pIndices1;
+
+ for (pass = 0; pass < key_size; pass++)
+ {
+ unsigned int offsets[256];
+ const unsigned int *pHist = &hist[pass << 8];
+ unsigned int *t;
+ unsigned int cur_ofs = 0;
+ unsigned int i;
+ unsigned int pass_shift = pass << 3;
+
+ for (i = 0; i < 256; i++)
+ {
+ offsets[i] = cur_ofs;
+ cur_ofs += pHist[i];
+ }
+
+ q = pCur + num_indices;
+ for (p = pCur; p != q; p++)
+ {
+ unsigned int dst_offset;
+ unsigned int idx = p[0];
+ unsigned int c = (RG_ETC1_GET_KEY_FROM_INDEX(idx) >> pass_shift) & 0xFF;
+
+ dst_offset = offsets[c]++;
+ pNew[dst_offset] = idx;
+ }
+
+ t = pCur;
+ pCur = pNew;
+ pNew = t;
+ }
+
+ return pCur;
+}
+
+typedef struct _Etc1_Solution_Coordinates Etc1_Solution_Coordinates;
+struct _Etc1_Solution_Coordinates
+{
+ color_quad_u8 m_unscaled_color;
+ unsigned int m_inten_table;
+ unsigned char m_color4;
+};
+
+static inline void
+rg_etc1_solution_coordinates_component_set(Etc1_Solution_Coordinates *solution,
+ int r, int g, int b,
+ unsigned int inten_table, unsigned char color4)
+{
+ rg_etc1_color_quad_u8_init(&solution->m_unscaled_color, r, g, b, 255);
+ solution->m_inten_table = inten_table;
+ solution->m_color4 = color4;
+}
+
+static inline void
+rg_etc1_solution_coordinates_set(Etc1_Solution_Coordinates *solution,
+ color_quad_u8 unscaled_color, unsigned int inten_table, unsigned char color4)
+{
+ rg_etc1_color_quad_u8_copy(&solution->m_unscaled_color, &unscaled_color);
+ solution->m_inten_table = inten_table;
+ solution->m_color4 = color4;
+}
+
+static inline void
+rg_etc1_solution_coordinates_clear(Etc1_Solution_Coordinates *solution)
+{
+ memset(solution, 0, sizeof (Etc1_Solution_Coordinates));
+}
+
+static inline void
+rg_etc1_solution_coordinates_component_get(const Etc1_Solution_Coordinates *solution,
+ unsigned char *r, unsigned char *g, unsigned char *b)
+{
+ *r = solution->m_unscaled_color.comp.r;
+ *g = solution->m_unscaled_color.comp.g;
+ *b = solution->m_unscaled_color.comp.b;
+
+ if (solution->m_color4)
+ {
+ *r = *r | (*r << 4);
+ *g = *g | (*g << 4);
+ *b = *b | (*b << 4);
+ }
+ else
+ {
+ *r = (*r >> 2) | (*r << 3);
+ *g = (*g >> 2) | (*g << 3);
+ *b = (*b >> 2) | (*b << 3);
+ }
+}
+
+static inline void
+rg_etc1_solution_coordinates_get_scaled_color(color_quad_u8 *color, const Etc1_Solution_Coordinates *coords)
+{
+ unsigned char br, bg, bb;
+
+ rg_etc1_solution_coordinates_component_get(coords, &br, &bg, &bb);
+
+ rg_etc1_color_quad_u8_init(color,br, bg, bb, 255);
+
+}
+
+static inline void
+rg_etc1_solution_coordinates_block_colors_get(const Etc1_Solution_Coordinates *coords, color_quad_u8 colors[4])
+{
+ const int* pInten_table = rg_etc1_inten_tables[coords->m_inten_table];
+ unsigned char i;
+ unsigned char br, bg, bb;
+
+ rg_etc1_solution_coordinates_component_get(coords, &br, &bg, &bb);
+
+ for (i = 0; i < 4; i++)
+ rg_etc1_color_quad_u8_init(&colors[i], br + pInten_table[i], bg + pInten_table[i], bb + pInten_table[i], 255);
+}
+
+static inline void
+rg_etc1_pack_params_clear(rg_etc1_pack_params *params)
+{
+ params->m_quality = rg_etc1_high_quality;
+ params->m_dithering = false;
+}
+
+static const int rg_etc1_default_scan_delta[] = { 0 };
+
+typedef struct _rg_etc1_optimizer_params rg_etc1_optimizer_params;
+struct _rg_etc1_optimizer_params
+{
+ rg_etc1_pack_params *base_params;
+ uint m_num_src_pixels;
+ const color_quad_u8* m_pSrc_pixels;
+
+ bool m_use_color4;
+ const int* m_pScan_deltas;
+ uint m_scan_delta_size;
+
+ color_quad_u8 m_base_color5;
+ bool m_constrain_against_base_color5;
+};
+
+static inline void
+rg_etc1_optimizer_params_clean(rg_etc1_optimizer_params *params)
+{
+ params->m_num_src_pixels = 0;
+ params->m_pSrc_pixels = 0;
+
+ params->m_use_color4 = false;
+ params->m_pScan_deltas = rg_etc1_default_scan_delta;
+ params->m_scan_delta_size = 1;
+
+ rg_etc1_color_quad_u8_clear(¶ms->m_base_color5);
+ params->m_constrain_against_base_color5 = false;
+}
+
+static inline void
+rg_etc1_optimizer_params_base_clear(rg_etc1_optimizer_params *params)
+{
+ rg_etc1_pack_params_clear(params->base_params);
+ rg_etc1_optimizer_params_clean(params);
+}
+
+typedef struct
+{
+ uint64 m_error;
+ color_quad_u8 m_block_color_unscaled;
+ uint m_block_inten_table;
+ uint m_n;
+ uint8* m_pSelectors;
+ bool m_block_color4;
+} rg_etc1_optimizer_results;
+
+static inline void
+rg_etc1_optimizer_results_duplicate(rg_etc1_optimizer_results *dst, const rg_etc1_optimizer_results *src)
+{
+ rg_etc1_color_quad_u8_copy(&dst->m_block_color_unscaled,&src->m_block_color_unscaled);
+ dst->m_block_color4 = src->m_block_color4;
+ dst->m_block_inten_table = src->m_block_inten_table;
+ dst->m_error = src->m_error;
+ RG_ETC1_ASSERT(dst->m_n == src->m_n);
+ memcpy(dst->m_pSelectors, src->m_pSelectors, src->m_n);
+}
+
+typedef struct
+{
+ Etc1_Solution_Coordinates m_coords;
+ uint8 m_selectors[8];
+ uint64 m_error;
+ bool m_valid;
+} rg_etc1_potential_solution;
+
+static inline void
+rg_etc1_potential_solution_clear(rg_etc1_potential_solution *solution)
+{
+ rg_etc1_solution_coordinates_clear(&solution->m_coords);
+ solution->m_error = cUINT64_MAX;
+ solution->m_valid = false;
+}
+
+typedef struct
+{
+ const rg_etc1_optimizer_params* m_pParams;
+ rg_etc1_optimizer_results* m_pResult;
+
+ int m_limit;
+
+ float m_avg_color[3];
+ int m_br, m_bg, m_bb;
+ uint16 m_luma[8];
+ uint32 m_sorted_luma[2][8];
+ const uint32* m_pSorted_luma_indices;
+ uint32* m_pSorted_luma;
+
+ uint8 m_selectors[8];
+ uint8 m_best_selectors[8];
+
+ rg_etc1_potential_solution m_best_solution;
+ rg_etc1_potential_solution m_trial_solution;
+ uint8 m_temp_selectors[8];
+}rg_etc1_optimizer;
+
+static inline void
+rg_etc1_optimizer_clear(rg_etc1_optimizer *optimizer)
+{
+ optimizer->m_pParams = NULL;
+ optimizer->m_pResult = NULL;
+ optimizer->m_pSorted_luma = NULL;
+ optimizer->m_pSorted_luma_indices = NULL;
+ optimizer->m_br = optimizer->m_bg = optimizer->m_bb = 0;
+ rg_etc1_potential_solution_clear(&optimizer->m_best_solution);
+ rg_etc1_potential_solution_clear(&optimizer->m_trial_solution);
+}
+
+static bool rg_etc1_optimizer_evaluate_solution(rg_etc1_optimizer *optimizer, const Etc1_Solution_Coordinates* coords,
+ rg_etc1_potential_solution* trial_solution,
+ rg_etc1_potential_solution* pBest_solution);
+static bool rg_etc1_optimizer_evaluate_solution_fast(rg_etc1_optimizer *optimizer,const Etc1_Solution_Coordinates *coords,
+ rg_etc1_potential_solution *trial_solution,
+ rg_etc1_potential_solution *pBest_solution);
+
+static bool
+rg_etc1_optimizer_compute(rg_etc1_optimizer *optimizer)
+{
+ const uint n = optimizer->m_pParams->m_num_src_pixels;
+ const int scan_delta_size = optimizer->m_pParams->m_scan_delta_size;
+ int zdi;
+
+ // 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.
+ // 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.
+ for (zdi = 0; zdi < scan_delta_size; zdi++)
+ {
+ const int zd = optimizer->m_pParams->m_pScan_deltas[zdi];
+ const int mbb = optimizer->m_bb + zd;
+ int ydi;
+ if (mbb < 0) continue; else if (mbb > optimizer->m_limit) break;
+
+ for (ydi = 0; ydi < scan_delta_size; ydi++)
+ {
+ const int yd = optimizer->m_pParams->m_pScan_deltas[ydi];
+ const int mbg = optimizer->m_bg + yd;
+ int xdi;
+
+ if (mbg < 0) continue; else if (mbg > optimizer->m_limit) break;
+
+ for (xdi = 0; xdi < scan_delta_size; xdi++)
+ {
+ const int xd = optimizer->m_pParams->m_pScan_deltas[xdi];
+ const int mbr = optimizer->m_br + xd;
+ Etc1_Solution_Coordinates coords;
+ uint max_refinement_trials;
+ uint refinement_trial;
+
+ rg_etc1_solution_coordinates_component_set(&coords, mbr, mbg, mbb, 0, optimizer->m_pParams->m_use_color4);
+ if (mbr < 0) continue; else if (mbr > optimizer->m_limit) break;
+
+ if (optimizer->m_pParams->base_params->m_quality == rg_etc1_high_quality)
+ {
+ if (!rg_etc1_optimizer_evaluate_solution(optimizer, &coords, &optimizer->m_trial_solution, &optimizer->m_best_solution))
+ continue;
+ }
+ else
+ {
+ if (!rg_etc1_optimizer_evaluate_solution_fast(optimizer, &coords, &optimizer->m_trial_solution, &optimizer->m_best_solution))
+ continue;
+ }
+
+ // 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.
+ // Now, for each component, attempt to refine the current solution by solving a simple linear equation. For example, for 4 colors:
+ // The goal is:
+ // 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
+ // Rearranging this:
+ // (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
+ // (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
+ // (pixel0 + pixel1 + pixel2 + pixel3) - 4*block_color - inten_table[selector0] - inten_table[selector1] - inten_table[selector2] - inten_table[selector3] = 0
+ // (pixel0 + pixel1 + pixel2 + pixel3) - 4*block_color - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3]) = 0
+ // (pixel0 + pixel1 + pixel2 + pixel3)/4 - block_color - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3])/4 = 0
+ // block_color = (pixel0 + pixel1 + pixel2 + pixel3)/4 - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3])/4
+ // So what this means:
+ // optimal_block_color = avg_input - avg_inten_delta
+ // So the optimal block color can be computed by taking the average block color and subtracting the current average of the intensity delta.
+ // Unfortunately, optimal_block_color must then be quantized to 555 or 444 so it's not always possible to improve matters using this formula.
+ // Also, the above formula is for unclamped intensity deltas. The actual implementation takes into account clamping.
+
+ max_refinement_trials = (optimizer->m_pParams->base_params->m_quality == rg_etc1_low_quality) ? 2 : (((xd | yd | zd) == 0) ? 4 : 2);
+ for (refinement_trial = 0; refinement_trial < max_refinement_trials; refinement_trial++)
+ {
+ const uint8* pSelectors = optimizer->m_best_solution.m_selectors;
+ const int* pInten_table = rg_etc1_inten_tables[optimizer->m_best_solution.m_coords.m_inten_table];
+
+ int delta_sum_r = 0, delta_sum_g = 0, delta_sum_b = 0;
+ uint index;
+ color_quad_u8 base_color;
+ float avg_delta_r_f, avg_delta_g_f, avg_delta_b_f;
+ int br1, bg1, bb1;
+ bool skip;
+ Etc1_Solution_Coordinates coords1;
+ rg_etc1_solution_coordinates_get_scaled_color(&base_color, &optimizer->m_best_solution.m_coords);
+
+ for (index = 0; index < n; index++)
+ {
+ const uint s = *pSelectors++;
+ const int yd = pInten_table[s];
+ // Compute actual delta being applied to each pixel, taking into account clamping.
+ delta_sum_r += CLAMP(base_color.comp.r + yd, 0, 255) - base_color.comp.r;
+ delta_sum_g += CLAMP(base_color.comp.g + yd, 0, 255) - base_color.comp.g;
+ delta_sum_b += CLAMP(base_color.comp.b + yd, 0, 255) - base_color.comp.b;
+ }
+ if ((!delta_sum_r) && (!delta_sum_g) && (!delta_sum_b))
+ break;
+ avg_delta_r_f = (float)(delta_sum_r) / n;
+ avg_delta_g_f = (float)(delta_sum_g) / n;
+ avg_delta_b_f = (float)(delta_sum_b) / n;
+ br1 = (uint)CLAMP(((optimizer->m_avg_color[0] - avg_delta_r_f) * optimizer->m_limit / 255.0f + .5f),
+ 0, optimizer->m_limit);
+ bg1 = (uint)CLAMP(((optimizer->m_avg_color[1] - avg_delta_g_f) * optimizer->m_limit / 255.0f + .5f),
+ 0, optimizer->m_limit);
+ bb1 = (uint)CLAMP(((optimizer->m_avg_color[2] - avg_delta_b_f) * optimizer->m_limit / 255.0f + .5f),
+ 0, optimizer->m_limit);
+ skip = false;
+
+ if ((mbr == br1) && (mbg == bg1) && (mbb == bb1)) {
+ skip = true;
+ } else if ((br1 == optimizer->m_best_solution.m_coords.m_unscaled_color.comp.r) &&
+ (bg1 == optimizer->m_best_solution.m_coords.m_unscaled_color.comp.g) &&
+ (bb1 == optimizer->m_best_solution.m_coords.m_unscaled_color.comp.b)) {
+ skip = true;
+ } else if ((optimizer->m_br == br1) && (optimizer->m_bg == bg1) && (optimizer->m_bb == bb1)) {
+ skip = true;
+ }
+
+ if (skip)
+ break;
+
+ rg_etc1_solution_coordinates_component_set(&coords1, br1, bg1, bb1, 0, optimizer->m_pParams->m_use_color4);
+ if (optimizer->m_pParams->base_params->m_quality == rg_etc1_high_quality)
+ {
+ if (!rg_etc1_optimizer_evaluate_solution(optimizer, &coords1, &optimizer->m_trial_solution, &optimizer->m_best_solution))
+ break;
+ }
+ else
+ {
+ if (!rg_etc1_optimizer_evaluate_solution_fast(optimizer, &coords1, &optimizer->m_trial_solution, &optimizer->m_best_solution))
+ break;
+ }
+
+ } // refinement_trial
+
+ } // xdi
+ } // ydi
+ } // zdi
+
+ if (!optimizer->m_best_solution.m_valid)
+ {
+ optimizer->m_pResult->m_error = cUINT32_MAX;
+ return false;
+ }
+
+#ifdef RG_ETC1_BUILD_DEBUG
+ {
+ color_quad_u8 block_colors[4];
+ const color_quad_u8* pSrc_pixels;
+ uint64 actual_error=0;
+ uint i;
+ const uint8* pSelectors = optimizer->m_best_solution.m_selectors;
+
+ rg_etc1_solution_coordinates_block_colors_get(optimizer->m_best_solution., block_colors);
+ pSrc_pixels = optimizer->m_pParams->m_pSrc_pixels;
+ for (i = 0; i < n; i++)
+ actual_error += rg_etc1_color_quad_u8_rgb_squared_distance(pSrc_pixels[i], block_colors[pSelectors[i]]);
+
+ RG_ETC1_ASSERT(actual_error == optimizer->m_best_solution.m_error);
+ }
+#endif
+
+ optimizer->m_pResult->m_error = optimizer->m_best_solution.m_error;
+ rg_etc1_color_quad_u8_copy(&optimizer->m_pResult->m_block_color_unscaled,&optimizer->m_best_solution.m_coords.m_unscaled_color);
+ optimizer->m_pResult->m_block_color4 = optimizer->m_best_solution.m_coords.m_color4;
+ optimizer->m_pResult->m_block_inten_table = optimizer->m_best_solution.m_coords.m_inten_table;
+ memcpy(optimizer->m_pResult->m_pSelectors, optimizer->m_best_solution.m_selectors, n);
+ optimizer->m_pResult->m_n = n;
+
+ return true;
+}
+
+void
+rg_etc1_optimizer_init(rg_etc1_optimizer *optimizer, const rg_etc1_optimizer_params *params,
+ rg_etc1_optimizer_results *result)
+{
+ // This version is hardcoded for 8 pixel subblocks.
+ RG_ETC1_ASSERT(params->m_num_src_pixels == 8);
+
+ const uint n = 8;
+ uint i;
+ float avg_color[3];
+ float fc[3];
+
+ optimizer->m_pParams = params;
+ optimizer->m_pResult = result;
+
+ rg_etc1_vec_init(avg_color, 0.0f);
+ optimizer->m_limit = optimizer->m_pParams->m_use_color4 ? 15 : 31;
+
+ for ( i = 0; i < n; i++)
+ {
+ const color_quad_u8 *c = &optimizer->m_pParams->m_pSrc_pixels[i];
+ rg_etc1_vec_set(fc, c->comp.r, c->comp.g, c->comp.b);
+
+ rg_etc1_vec_add(avg_color,fc);
+
+ optimizer->m_luma[i] = (uint16)(c->comp.r + c->comp.g + c->comp.b);
+ optimizer->m_sorted_luma[0][i] = i;
+ }
+ rg_etc1_vec_scale(avg_color, (1.0f/(float)(n)));
+ rg_etc1_vec_copy(optimizer->m_avg_color,avg_color);
+
+ optimizer->m_br = CLAMP((uint)(optimizer->m_avg_color[0] * optimizer->m_limit / 255.0f + .5f), 0, optimizer->m_limit);
+ optimizer->m_bg = CLAMP((uint)(optimizer->m_avg_color[1] * optimizer->m_limit / 255.0f + .5f), 0, optimizer->m_limit);
+ optimizer->m_bb = CLAMP((uint)(optimizer->m_avg_color[2] * optimizer->m_limit / 255.0f + .5f), 0, optimizer->m_limit);
+
+ if (optimizer->m_pParams->base_params->m_quality <= rg_etc1_medium_quality)
+ {
+ optimizer->m_pSorted_luma_indices = rg_etc1_indirect_radix_sort(n, optimizer->m_sorted_luma[0],
+ optimizer->m_sorted_luma[1], optimizer->m_luma,
+ 0, sizeof(optimizer->m_luma[0]), false);
+ optimizer->m_pSorted_luma = optimizer->m_sorted_luma[0];
+
+ if (optimizer->m_pSorted_luma_indices == optimizer->m_sorted_luma[0])
+ optimizer->m_pSorted_luma = optimizer->m_sorted_luma[1];
+
+ for (i = 0; i < n; i++)
+ optimizer->m_pSorted_luma[i] = optimizer->m_luma[optimizer->m_pSorted_luma_indices[i]];
+ }
+
+ rg_etc1_solution_coordinates_clear(&optimizer->m_best_solution.m_coords);
+ optimizer->m_best_solution.m_valid = false;
+ optimizer->m_best_solution.m_error = cUINT64_MAX;
+}
+
+static bool
+rg_etc1_optimizer_evaluate_solution(rg_etc1_optimizer *optimizer, const Etc1_Solution_Coordinates* coords,
+ rg_etc1_potential_solution* trial_solution, rg_etc1_potential_solution* pBest_solution)
+{
+ color_quad_u8 base_color;
+ const uint n = 8;
+ uint inten_table;
+ bool success = false;
+
+ trial_solution->m_valid = false;
+
+ if (optimizer->m_pParams->m_constrain_against_base_color5)
+ {
+ int dr, dg, db;
+ dr = coords->m_unscaled_color.comp.r - optimizer->m_pParams->m_base_color5.comp.r;
+ dg = coords->m_unscaled_color.comp.g - optimizer->m_pParams->m_base_color5.comp.g;
+ db = coords->m_unscaled_color.comp.b - optimizer->m_pParams->m_base_color5.comp.b;
+
+ if ((MIN(MIN(dr,dg),db) < cETC1ColorDeltaMin) || (MAX(MAX(dr,dg),db) > cETC1ColorDeltaMax))
+ return false;
+ }
+
+ rg_etc1_solution_coordinates_get_scaled_color(&base_color, coords);
+ trial_solution->m_error = cUINT64_MAX;
+
+ for (inten_table = 0; inten_table < cETC1IntenModifierValues; inten_table++)
+ {
+ const int* pInten_table = rg_etc1_inten_tables[inten_table];
+ uint64 total_error = 0;
+ color_quad_u8 block_colors[4];
+ const color_quad_u8* pSrc_pixels = optimizer->m_pParams->m_pSrc_pixels;
+
+ uint c;
+ for (c = 0; c < 4; c++)
+ {
+ const int yd = pInten_table[c];
+ rg_etc1_color_quad_u8_init(&block_colors[c], base_color.comp.r+yd, base_color.comp.g+yd, base_color.comp.b+yd, 0);
+ }
+
+ for (c = 0; c < n; c++)
+ {
+ uint best_selector_index = 0, best_error, trial_error;
+ const color_quad_u8* src_pixel = pSrc_pixels++;
+
+ best_error = SQUARE((src_pixel->comp.r - block_colors[0].comp.r)) +
+ SQUARE((src_pixel->comp.g - block_colors[0].comp.g)) +
+ SQUARE((src_pixel->comp.b - block_colors[0].comp.b));
+ trial_error = SQUARE((src_pixel->comp.r - block_colors[1].comp.r)) +
+ SQUARE((src_pixel->comp.g - block_colors[1].comp.g)) +
+ SQUARE((src_pixel->comp.b - block_colors[1].comp.b));
+ if (trial_error < best_error)
+ {
+ best_error = trial_error;
+ best_selector_index = 1;
+ }
+
+ trial_error = SQUARE((src_pixel->comp.r - block_colors[2].comp.r)) +
+ SQUARE((src_pixel->comp.g - block_colors[2].comp.g)) +
+ SQUARE((src_pixel->comp.b - block_colors[2].comp.b));
+ if (trial_error < best_error)
+ {
+ best_error = trial_error;
+ best_selector_index = 2;
+ }
+
+ trial_error = SQUARE((src_pixel->comp.r - block_colors[3].comp.r)) +
+ SQUARE((src_pixel->comp.g - block_colors[3].comp.g)) +
+ SQUARE((src_pixel->comp.b - block_colors[3].comp.b));
+ if (trial_error < best_error)
+ {
+ best_error = trial_error;
+ best_selector_index = 3;
+ }
+
+ optimizer->m_temp_selectors[c] = (uint8)(best_selector_index);
+
+ total_error += best_error;
+ if (total_error >= trial_solution->m_error)
+ break;
+ }
+
+ if (total_error < trial_solution->m_error)
+ {
+ trial_solution->m_error = total_error;
+ trial_solution->m_coords.m_inten_table = inten_table;
+ memcpy(trial_solution->m_selectors, optimizer->m_temp_selectors, 8);
+ trial_solution->m_valid = true;
+ }
+ }
+ rg_etc1_color_quad_u8_copy(&trial_solution->m_coords.m_unscaled_color,&coords->m_unscaled_color);
+ trial_solution->m_coords.m_color4 = optimizer->m_pParams->m_use_color4;
+
+ if (pBest_solution)
+ {
+ if (trial_solution->m_error < pBest_solution->m_error)
+ {
+ memcpy(pBest_solution,trial_solution,sizeof(rg_etc1_potential_solution));
+ success = true;
+ }
+ }
+
+ return success;
+}
+
+static bool
+rg_etc1_optimizer_evaluate_solution_fast(rg_etc1_optimizer *optimizer, const Etc1_Solution_Coordinates *coords,
+ rg_etc1_potential_solution *trial_solution, rg_etc1_potential_solution *pBest_solution)
+{
+ color_quad_u8 base_color;
+ const uint n = 8;
+ int inten_table;
+ bool success = false;
+
+ if (optimizer->m_pParams->m_constrain_against_base_color5)
+ {
+ int dr, dg, db;
+ dr = coords->m_unscaled_color.comp.r - optimizer->m_pParams->m_base_color5.comp.r;
+ dg = coords->m_unscaled_color.comp.g - optimizer->m_pParams->m_base_color5.comp.g;
+ db = coords->m_unscaled_color.comp.b - optimizer->m_pParams->m_base_color5.comp.b;
+
+
+ if ((MIN(MIN(dr,dg),db) < cETC1ColorDeltaMin) || (MAX(MAX(dr,dg),db) > cETC1ColorDeltaMax))
+ {
+ trial_solution->m_valid = false;
+ return false;
+ }
+ }
+
+ rg_etc1_solution_coordinates_get_scaled_color(&base_color,coords);
+
+ trial_solution->m_error = cUINT64_MAX;
+
+ for (inten_table = cETC1IntenModifierValues - 1; inten_table >= 0; --inten_table)
+ {
+ const int* pInten_table = rg_etc1_inten_tables[inten_table];
+ uint block_inten[4];
+ color_quad_u8 block_colors[4];
+ uint block_inten_midpoints[3];
+ uint64 total_error = 0;
+ const color_quad_u8* pSrc_pixels = optimizer->m_pParams->m_pSrc_pixels;
+ uint s, c;
+
+ for (s = 0; s < 4; s++)
+ {
+ const int yd = pInten_table[s];
+ rg_etc1_color_quad_u8_init(&block_colors[s], base_color.comp.r+yd, base_color.comp.g+yd, base_color.comp.b+yd, 0);
+ block_inten[s] = block_colors[s].comp.r + block_colors[s].comp.g + block_colors[s].comp.b;
+ }
+
+ // evaluate_solution_fast() enforces/assumesd a total ordering of the input colors along the intensity (1,1,1) axis to more quickly classify the inputs to selectors.
+ // 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.
+ // 0 1 2 3
+ // 01 12 23
+ block_inten_midpoints[0] = block_inten[0] + block_inten[1];
+ block_inten_midpoints[1] = block_inten[1] + block_inten[2];
+ block_inten_midpoints[2] = block_inten[2] + block_inten[3];
+
+ if ((optimizer->m_pSorted_luma[n - 1] * 2) < block_inten_midpoints[0])
+ {
+ if (block_inten[0] > optimizer->m_pSorted_luma[n - 1])
+ {
+ const uint min_error = labs(block_inten[0] - optimizer->m_pSorted_luma[n - 1]);
+ if (min_error >= trial_solution->m_error)
+ continue;
+ }
+
+ memset(&optimizer->m_temp_selectors[0], 0, n);
+
+ for (c = 0; c < n; c++) {
+ total_error += rg_etc1_color_quad_u8_rgb_squared_distance(block_colors[0], pSrc_pixels[c]);
+ }
+ }
+ else if ((optimizer->m_pSorted_luma[0] * 2) >= block_inten_midpoints[2])
+ {
+ if (optimizer->m_pSorted_luma[0] > block_inten[3])
+ {
+ const uint min_error = labs(optimizer->m_pSorted_luma[0] - block_inten[3]);
+ if (min_error >= trial_solution->m_error)
+ continue;
+ }
+
+ memset(&optimizer->m_temp_selectors[0], 3, n);
+
+ for (c = 0; c < n; c++)
+ total_error += rg_etc1_color_quad_u8_rgb_squared_distance(block_colors[3], pSrc_pixels[c]);
+ }
+ else
+ {
+ uint cur_selector = 0;
+ for (c = 0; c < n; c++)
+ {
+ const uint y = optimizer->m_pSorted_luma[c];
+ while ((y * 2) >= block_inten_midpoints[cur_selector])
+ if (++cur_selector > 2)
+ goto done;
+ const uint sorted_pixel_index = optimizer->m_pSorted_luma_indices[c];
+ optimizer->m_temp_selectors[sorted_pixel_index] = (uint8)(cur_selector);
+ total_error += rg_etc1_color_quad_u8_rgb_squared_distance(block_colors[cur_selector],
+ pSrc_pixels[sorted_pixel_index]);
+ }
+ done:
+ while (c < n)
+ {
+ const uint sorted_pixel_index = optimizer->m_pSorted_luma_indices[c];
+ optimizer->m_temp_selectors[sorted_pixel_index] = 3;
+ total_error += rg_etc1_color_quad_u8_rgb_squared_distance(block_colors[3], pSrc_pixels[sorted_pixel_index]);
+ ++c;
+ }
+ }
+
+ if (total_error < trial_solution->m_error)
+ {
+ trial_solution->m_error = total_error;
+ trial_solution->m_coords.m_inten_table = inten_table;
+ memcpy(trial_solution->m_selectors, optimizer->m_temp_selectors, n);
+ trial_solution->m_valid = true;
+ if (!total_error)
+ break;
+ }
+ }
+ rg_etc1_color_quad_u8_copy(&trial_solution->m_coords.m_unscaled_color,&coords->m_unscaled_color);
+ trial_solution->m_coords.m_color4 = optimizer->m_pParams->m_use_color4;
+
+ if (pBest_solution)
+ {
+ if (trial_solution->m_error < pBest_solution->m_error)
+ {
+ memcpy(pBest_solution,trial_solution,sizeof(rg_etc1_potential_solution));
+ success = true;
+ }
+ }
+
+ return success;
+}
+
+static uint
+etc1_decode_value(uint diff, uint inten, uint selector, uint packed_c)
+{
+ const uint limit = diff ? 32 : 16;
+ RG_ETC1_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < limit));
+ int c;
+ if (diff)
+ c = (packed_c >> 2) | (packed_c << 3);
+ else
+ c = packed_c | (packed_c << 4);
+ c += rg_etc1_inten_tables[inten][selector];
+ c = CLAMP(c, 0, 255);
+ return c;
+}
+
+static inline int mul_8bit(int a, int b) { int t = a*b + 128; return (t + (t >> 8)) >> 8; }
+
+void rg_etc1_pack_block_init()
+{
+ uint diff;
+ uint expand5[32];
+ int i;
+ for (diff = 0; diff < 2; diff++)
+ {
+ const uint limit = diff ? 32 : 16;
+ uint inten;
+
+ for (inten = 0; inten < 8; inten++)
+ {
+ uint selector;
+ for (selector = 0; selector < 4; selector++)
+ {
+ const uint inverse_table_index = diff + (inten << 1) + (selector << 4);
+ uint color;
+ for (color = 0; color < 256; color++)
+ {
+ uint best_error = cUINT32_MAX, best_packed_c = 0;
+ uint packed_c;
+ for (packed_c = 0; packed_c < limit; packed_c++)
+ {
+ int v = etc1_decode_value(diff, inten, selector, packed_c);
+ uint err = labs(v - (int)color);
+ if (err < best_error)
+ {
+ best_error = err;
+ best_packed_c = packed_c;
+ if (!best_error)
+ break;
+ }
+ }
+ RG_ETC1_ASSERT(best_error <= 255);
+ rg_etc1_inverse_lookup[inverse_table_index][color] = (uint16)(best_packed_c | (best_error << 8));
+ }
+ }
+ }
+ }
+
+ for(i = 0; i < 32; i++)
+ expand5[i] = (i << 3) | (i >> 2);
+
+ for(i = 0; i < 256 + 16; i++)
+ {
+ int v = (int)CLAMP(i - 8, 0, 255);
+ rg_etc_quant5_tab[i] = (uint8)(expand5[mul_8bit(v,31)]);
+ }
+}
+
+// Packs solid color blocks efficiently using a set of small precomputed tables.
+// 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.
+static uint64
+rg_etc1_pack_block_solid_color(unsigned char *block, const uint8* pColor, rg_etc1_pack_params *pack_params)
+{
+ RG_ETC1_ASSERT(rg_etc1_inverse_lookup[0][255]);
+
+ static uint s_next_comp[4] = { 1, 2, 0, 1 };
+
+ uint best_error = cUINT32_MAX, best_i = 0;
+ int best_x = 0, best_packed_c1 = 0, best_packed_c2 = 0;
+ uint i;
+
+ // 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.
+ for (i = 0; i < 3; i++)
+ {
+ const uint c1 = pColor[s_next_comp[i]], c2 = pColor[s_next_comp[i + 1]];
+
+ const int delta_range = 1;
+ int delta;
+ for (delta = -delta_range; delta <= delta_range; delta++)
+ {
+ const int c_plus_delta = CLAMP(pColor[i] + delta, 0, 255);
+
+ uint16* pTable;
+ if (!c_plus_delta)
+ pTable = (uint16 *)rg_etc_color8_to_etc_block_config_0_255[0];
+ else if (c_plus_delta == 255)
+ pTable = (uint16 *)rg_etc_color8_to_etc_block_config_0_255[1];
+ else
+ pTable = (uint16 *)rg_etc_color8_to_etc_block_config_1_to_254[c_plus_delta - 1];
+
+ do
+ {
+ const uint x = *pTable++;
+ uint16* pInverse_table;
+ uint16 p1, p2;
+ uint trial_error;
+
+#ifdef RG_ETC1_BUILD_DEBUG
+ const uint diff = x & 1;
+ const uint inten = (x >> 1) & 7;
+ const uint selector = (x >> 4) & 3;
+ const uint p0 = (x >> 8) & 255;
+ RG_ETC1_ASSERT(etc1_decode_value(diff, inten, selector, p0) == (uint)c_plus_delta);
+#endif
+
+ pInverse_table = rg_etc1_inverse_lookup[x & 0xFF];
+ p1 = pInverse_table[c1];
+ p2 = pInverse_table[c2];
+ trial_error = SQUARE((c_plus_delta - pColor[i])) + SQUARE((p1 >> 8)) + SQUARE((p2 >> 8));
+ if (trial_error < best_error)
+ {
+ best_error = trial_error;
+ best_x = x;
+ best_packed_c1 = p1 & 0xFF;
+ best_packed_c2 = p2 & 0xFF;
+ best_i = i;
+ if (!best_error)
+ goto found_perfect_match;
+ }
+ } while (*pTable != 0xFFFF);
+ }
+ }
+ found_perfect_match:
+ {
+ const uint diff = best_x & 1;
+ const uint inten = (best_x >> 1) & 7;
+ uint etc1_selector;
+ uint best_packed_c0;
+ uint selector_val;
+
+ block[3] = (uint8)(((inten | (inten << 3)) << 2) | (diff << 1));
+
+ etc1_selector = rg_etc_selector_index_to_etc1[(best_x >> 4) & 3];
+ selector_val = (etc1_selector & 2) ? 0xFFFF : 0;
+ memcpy(&block[4], &selector_val, 2);
+ selector_val = (etc1_selector & 1) ? 0xFFFF : 0;
+ memcpy(&block[6], &selector_val, 2);
+
+ best_packed_c0 = (best_x >> 8) & 255;
+ if (diff)
+ {
+ block[best_i] = (uint8)(best_packed_c0 << 3);
+ block[s_next_comp[best_i]] = (uint8)(best_packed_c1 << 3);
+ block[s_next_comp[best_i+1]] = (uint8)(best_packed_c2 << 3);
+ }
+ else
+ {
+ block[best_i] = (uint8)(best_packed_c0 | (best_packed_c0 << 4));
+ block[s_next_comp[best_i]] = (uint8)(best_packed_c1 | (best_packed_c1 << 4));
+ block[s_next_comp[best_i+1]] = (uint8)(best_packed_c2 | (best_packed_c2 << 4));
+ }
+ }
+ return best_error;
+}
+
+static uint
+rg_etc1_pack_block_solid_color_constrained(rg_etc1_optimizer_results *results,uint num_colors,
+ const uint8* pColor, rg_etc1_pack_params *pack_params,
+ bool use_diff, const color_quad_u8* pBase_color5_unscaled)
+{
+ RG_ETC1_ASSERT(rg_etc1_inverse_lookup[0][255]);
+ static uint s_next_comp[4] = { 1, 2, 0, 1 };
+ uint best_error = cUINT32_MAX, best_i = 0;
+ int best_x = 0, best_packed_c1 = 0, best_packed_c2 = 0;
+ uint i;
+
+ // 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.
+ for (i = 0; i < 3; i++)
+ {
+ const uint c1 = pColor[s_next_comp[i]], c2 = pColor[s_next_comp[i + 1]];
+ const int delta_range = 1;
+ int delta;
+ for (delta = -delta_range; delta <= delta_range; delta++)
+ {
+ const int c_plus_delta = CLAMP(pColor[i] + delta, 0, 255);
+ const uint16* pTable;
+ if (!c_plus_delta)
+ pTable = rg_etc_color8_to_etc_block_config_0_255[0];
+ else if (c_plus_delta == 255)
+ pTable = rg_etc_color8_to_etc_block_config_0_255[1];
+ else
+ pTable = rg_etc_color8_to_etc_block_config_1_to_254[c_plus_delta - 1];
+
+ do
+ {
+ const uint x = *pTable++;
+ const uint diff = x & 1;
+ if (((uint)use_diff) != diff)
+ {
+ if (*pTable == 0xFFFF)
+ break;
+ continue;
+ }
+
+ if ((diff) && (pBase_color5_unscaled))
+ {
+ const int p0 = (x >> 8) & 255;
+ unsigned char c1 = rg_etc1_color_quad_component_get(pBase_color5_unscaled->m_u32,
+ i);
+ int delta = p0 - (int)(c1);
+ if ((delta < cETC1ColorDeltaMin) || (delta > cETC1ColorDeltaMax))
+ {
+ if (*pTable == 0xFFFF)
+ break;
+ continue;
+ }
+ }
+
+#ifdef RG_ETC1_BUILD_DEBUG
+ {
+ const uint inten = (x >> 1) & 7;
+ const uint selector = (x >> 4) & 3;
+ const uint p0 = (x >> 8) & 255;
+ RG_ETC1_ASSERT(etc1_decode_value(diff, inten, selector, p0) == (uint)c_plus_delta);
+ }
+#endif
+
+ const uint16* pInverse_table = rg_etc1_inverse_lookup[x & 0xFF];
+ uint16 p1 = pInverse_table[c1];
+ uint16 p2 = pInverse_table[c2];
+ uint trial_error;
+
+ if ((diff) && (pBase_color5_unscaled))
+ {
+ unsigned char c1 = rg_etc1_color_quad_component_get(pBase_color5_unscaled->m_u32,
+ s_next_comp[i]);
+ int delta1 = (p1 & 0xFF) - (int)(c1);
+ unsigned char c2 = rg_etc1_color_quad_component_get(pBase_color5_unscaled->m_u32,
+ s_next_comp[i + 1]);
+ int delta2 = (p2 & 0xFF) - (int)(c2);
+ if ((delta1 < cETC1ColorDeltaMin) || (delta1 > cETC1ColorDeltaMax)
+ || (delta2 < cETC1ColorDeltaMin) || (delta2 > cETC1ColorDeltaMax))
+ {
+ if (*pTable == 0xFFFF)
+ break;
+ continue;
+ }
+ }
+
+ trial_error = SQUARE((c_plus_delta - pColor[i])) + SQUARE((p1 >> 8)) + SQUARE((p2 >> 8));
+ if (trial_error < best_error)
+ {
+ best_error = trial_error;
+ best_x = x;
+ best_packed_c1 = p1 & 0xFF;
+ best_packed_c2 = p2 & 0xFF;
+ best_i = i;
+ if (!best_error)
+ goto found_perfect_match;
+ }
+ } while (*pTable != 0xFFFF);
+ }
+ }
+ found_perfect_match:
+
+ if (best_error == cUINT32_MAX)
+ return best_error;
+
+ best_error *= num_colors;
+
+ results->m_n = num_colors;
+ results->m_block_color4 = !(best_x & 1);
+ results->m_block_inten_table = (best_x >> 1) & 7;
+ memset(results->m_pSelectors, (best_x >> 4) & 3, num_colors);
+ {
+ const uint best_packed_c0 = (best_x >> 8) & 255;
+ rg_etc1_color_quad_u8_component_set(&results->m_block_color_unscaled, best_i, (uint8)best_packed_c0);
+ rg_etc1_color_quad_u8_component_set(&results->m_block_color_unscaled, s_next_comp[best_i], (uint8)best_packed_c1);
+ rg_etc1_color_quad_u8_component_set(&results->m_block_color_unscaled, s_next_comp[best_i+1], (uint8)best_packed_c2);
+ results->m_error = best_error;
+ }
+ return best_error;
+}
+
+// Function originally from RYG's public domain real-time DXT1 compressor, modified for 555.
+static void
+rg_etc1_dither_block_555(color_quad_u8* dest, color_quad_u8* block)
+{
+ int err[8],*ep1 = err,*ep2 = err+4;
+ uint8 *quant = rg_etc_quant5_tab+8;
+ int ch;
+
+ memset(dest, 0xFF, sizeof(color_quad_u8)*16);
+
+ // process channels seperately
+ for(ch=0;ch<3;ch++)
+ {
+ uint8* bp = (uint8*)block;
+ uint8* dp = (uint8*)dest;
+ int y;
+
+ bp += ch; dp += ch;
+
+ memset(err,0, sizeof(err));
+ for(y = 0; y < 4; y++)
+ {
+ int *tmp;
+ // pixel 0
+ dp[ 0] = quant[bp[ 0] + ((3*ep2[1] + 5*ep2[0]) >> 4)];
+ ep1[0] = bp[ 0] - dp[ 0];
+
+ // pixel 1
+ dp[ 4] = quant[bp[ 4] + ((7*ep1[0] + 3*ep2[2] + 5*ep2[1] + ep2[0]) >> 4)];
+ ep1[1] = bp[ 4] - dp[ 4];
+
+ // pixel 2
+ dp[ 8] = quant[bp[ 8] + ((7*ep1[1] + 3*ep2[3] + 5*ep2[2] + ep2[1]) >> 4)];
+ ep1[2] = bp[ 8] - dp[ 8];
+
+ // pixel 3
+ dp[12] = quant[bp[12] + ((7*ep1[2] + 5*ep2[3] + ep2[2]) >> 4)];
+ ep1[3] = bp[12] - dp[12];
+
+ // advance to next line
+ tmp = ep1; ep1 = ep2; ep2 = tmp;
+ bp += 16;
+ dp += 16;
+ }
+ }
+}
+
+unsigned int
+rg_etc1_pack_block(void* pETC1_block, const unsigned int* pSrc_pixels_rgba, rg_etc1_pack_params *pack_params)
+{
+ color_quad_u8* pSrc_pixels = (color_quad_u8 *)pSrc_pixels_rgba;
+ unsigned char *dst_block = (unsigned char *)pETC1_block;
+ unsigned int first_pixel_u32;
+ int r;
+ color_quad_u8 dithered_pixels[16], subblock_pixels[8];
+ uint64 best_error = cUINT64_MAX;
+ uint best_use_color4=false;
+ uint best_flip=false;
+ uint8 best_selectors[2][8];
+ rg_etc1_optimizer optimizer;
+ rg_etc1_optimizer_results best_results[2];
+ rg_etc1_optimizer_results results[3];
+ rg_etc1_optimizer_params params;
+ uint i, flip;
+ uint8 selectors[3][8];
+ int dr, dg, db;
+ uint selector0 = 0, selector1 = 0;
+ static const int s_scan_delta_0_to_4[] = { -4, -3, -2, -1, 0, 1, 2, 3, 4 };
+ static const int s_scan_delta_0_to_1[] = { -1, 0, 1 };
+ static const int s_scan_delta_0[] = { 0 };
+ first_pixel_u32= pSrc_pixels->m_u32;
+
+#ifdef RG_ETC1_BUILD_DEBUG
+ // Ensure all alpha values are 0xFF.
+ for (i = 0; i < 16; i++)
+ {
+ RG_ETC1_ASSERT(pSrc_pixels[i].comp.a == 255);
+ }
+#endif
+ rg_etc1_optimizer_clear(&optimizer);
+
+ // Check for solid block.
+ for (r = 15; r >= 1; --r)
+ if (pSrc_pixels[r].m_u32 != first_pixel_u32)
+ break;
+ if (!r)
+ return (unsigned int)(16 * rg_etc1_pack_block_solid_color(dst_block, &pSrc_pixels[0].comp.r, pack_params));
+ if (pack_params->m_dithering)
+ {
+ rg_etc1_dither_block_555(dithered_pixels, pSrc_pixels);
+ pSrc_pixels = dithered_pixels;
+ }
+
+ for (i = 0; i < 2; i++)
+ {
+ best_results[i].m_n = 8;
+ best_results[i].m_pSelectors = best_selectors[i];
+ }
+
+ for (i = 0; i < 3; i++)
+ {
+ results[i].m_n = 8;
+ results[i].m_pSelectors = selectors[i];
+ }
+
+ rg_etc1_optimizer_params_clean(¶ms);
+ params.base_params = pack_params;
+ params.m_num_src_pixels = 8;
+ params.m_pSrc_pixels = subblock_pixels;
+
+ for (flip = 0; flip < 2; flip++)
+ {
+ uint use_color4;
+ for (use_color4 = 0; use_color4 < 2; use_color4++)
+ {
+ uint64 trial_error = 0;
+
+ uint subblock;
+ for (subblock = 0; subblock < 2; subblock++)
+ {
+ if (flip)
+ memcpy(subblock_pixels, pSrc_pixels + subblock * 8, sizeof(color_quad_u8) * 8);
+ else
+ {
+ const color_quad_u8* pSrc_col = pSrc_pixels + subblock * 2;
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[0], &pSrc_col[0]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[1], &pSrc_col[4]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[2], &pSrc_col[8]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[3], &pSrc_col[12]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[4], &pSrc_col[1]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[5], &pSrc_col[5]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[6], &pSrc_col[9]);
+ rg_etc1_color_quad_u8_copy(&subblock_pixels[7], &pSrc_col[13]);
+ }
+
+ results[2].m_error = cUINT64_MAX;
+ if ((params.base_params->m_quality >= rg_etc1_medium_quality) && ((subblock) || (use_color4)))
+ {
+ const uint32 subblock_pixel0_u32 = subblock_pixels[0].m_u32;
+ for (r = 7; r >= 1; --r)
+ if (subblock_pixels[r].m_u32 != subblock_pixel0_u32)
+ break;
+ if (!r)
+ {
+ rg_etc1_pack_block_solid_color_constrained(&results[2], 8, &subblock_pixels[0].comp.r,
+ pack_params, !use_color4,
+ (subblock && !use_color4) ? &results[0].m_block_color_unscaled : NULL);
+ }
+ }
+
+ params.m_use_color4 = (use_color4 != 0);
+ params.m_constrain_against_base_color5 = false;
+
+ if ((!use_color4) && (subblock))
+ {
+ params.m_constrain_against_base_color5 = true;
+ rg_etc1_color_quad_u8_copy(¶ms.m_base_color5,&results[0].m_block_color_unscaled);
+ }
+
+ if (params.base_params->m_quality == rg_etc1_high_quality)
+ {
+ params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_0_to_4);
+ params.m_pScan_deltas = s_scan_delta_0_to_4;
+ }
+ else if (params.base_params->m_quality == rg_etc1_medium_quality)
+ {
+ params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_0_to_1);
+ params.m_pScan_deltas = s_scan_delta_0_to_1;
+ }
+ else
+ {
+ params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_0);
+ params.m_pScan_deltas = s_scan_delta_0;
+ }
+
+ rg_etc1_optimizer_init(&optimizer, ¶ms, &results[subblock]);
+ if (!rg_etc1_optimizer_compute(&optimizer))
+ break;
+
+ if (params.base_params->m_quality >= rg_etc1_medium_quality)
+ {
+ // TODO: Fix fairly arbitrary/unrefined thresholds that control how far away to scan for potentially better solutions.
+ const uint refinement_error_thresh0 = 3000;
+ const uint refinement_error_thresh1 = 6000;
+ if (results[subblock].m_error > refinement_error_thresh0)
+ {
+ if (params.base_params->m_quality == rg_etc1_medium_quality)
+ {
+ static const int s_scan_delta_2_to_3[] = { -3, -2, 2, 3 };
+ params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_2_to_3);
+ params.m_pScan_deltas = s_scan_delta_2_to_3;
+ }
+ else
+ {
+ static const int s_scan_delta_5_to_5[] = { -5, 5 };
+ static const int s_scan_delta_5_to_8[] = { -8, -7, -6, -5, 5, 6, 7, 8 };
+ if (results[subblock].m_error > refinement_error_thresh1)
+ {
+ params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_5_to_8);
+ params.m_pScan_deltas = s_scan_delta_5_to_8;
+ }
+ else
+ {
+ params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_5_to_5);
+ params.m_pScan_deltas = s_scan_delta_5_to_5;
+ }
+ }
+
+ if (!rg_etc1_optimizer_compute(&optimizer))
+ break;
+ }
+
+ if (results[2].m_error < results[subblock].m_error)
+ results[subblock] = results[2];
+ }
+
+ trial_error += results[subblock].m_error;
+ if (trial_error >= best_error)
+ break;
+ }
+
+ if (subblock < 2)
+ continue;
+
+ best_error = trial_error;
+ rg_etc1_optimizer_results_duplicate(&best_results[0], &results[0]);
+ rg_etc1_optimizer_results_duplicate(&best_results[1], &results[1]);
+ best_flip = flip;
+ best_use_color4 = use_color4;
+ } // use_color4
+ } // flip
+
+ dr = best_results[1].m_block_color_unscaled.comp.r - best_results[0].m_block_color_unscaled.comp.r;
+ dg = best_results[1].m_block_color_unscaled.comp.g - best_results[0].m_block_color_unscaled.comp.g;
+ db = best_results[1].m_block_color_unscaled.comp.b - best_results[0].m_block_color_unscaled.comp.b;
+ RG_ETC1_ASSERT(best_use_color4 || (MIN(MIN(dr, dg), db) >= cETC1ColorDeltaMin) && (MAX(MAX(dr, dg), db) <= cETC1ColorDeltaMax));
+
+ if (best_use_color4)
+ {
+ dst_block[0] = (uint8)(best_results[1].m_block_color_unscaled.comp.r |
+ (best_results[0].m_block_color_unscaled.comp.r << 4));
+ dst_block[1] = (uint8)(best_results[1].m_block_color_unscaled.comp.g |
+ (best_results[0].m_block_color_unscaled.comp.g << 4));
+ dst_block[2] = (uint8)(best_results[1].m_block_color_unscaled.comp.b |
+ (best_results[0].m_block_color_unscaled.comp.b << 4));
+ }
+ else
+ {
+ if (dr < 0) dr += 8; dst_block[0] = (uint8)((best_results[0].m_block_color_unscaled.comp.r << 3) | dr);
+ if (dg < 0) dg += 8; dst_block[1] = (uint8)((best_results[0].m_block_color_unscaled.comp.g << 3) | dg);
+ if (db < 0) db += 8; dst_block[2] = (uint8)((best_results[0].m_block_color_unscaled.comp.b << 3) | db);
+ }
+
+ dst_block[3] = (uint8)((best_results[1].m_block_inten_table << 2) |
+ (best_results[0].m_block_inten_table << 5) |
+ ((~best_use_color4 & 1) << 1) | best_flip );
+
+ if (best_flip)
+ {
+ // flipped:
+ // { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 },
+ // { 0, 1 }, { 1, 1 }, { 2, 1 }, { 3, 1 }
+ //
+ // { 0, 2 }, { 1, 2 }, { 2, 2 }, { 3, 2 },
+ // { 0, 3 }, { 1, 3 }, { 2, 3 }, { 3, 3 }
+ const uint8* pSelectors0 = best_results[0].m_pSelectors;
+ const uint8* pSelectors1 = best_results[1].m_pSelectors;
+ int x;
+ for (x = 3; x >= 0; --x)
+ {
+ uint b;
+ b = rg_etc_selector_index_to_etc1[pSelectors1[4 + x]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+
+ b = rg_etc_selector_index_to_etc1[pSelectors1[x]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+
+ b = rg_etc_selector_index_to_etc1[pSelectors0[4 + x]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+
+ b = rg_etc_selector_index_to_etc1[pSelectors0[x]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+ }
+ }
+ else
+ {
+ // non-flipped:
+ // { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
+ // { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }
+ //
+ // { 2, 0 }, { 2, 1 }, { 2, 2 }, { 2, 3 },
+ // { 3, 0 }, { 3, 1 }, { 3, 2 }, { 3, 3 }
+ int subblock;
+ for (subblock = 1; subblock >= 0; --subblock)
+ {
+ const uint8* pSelectors = best_results[subblock].m_pSelectors + 4;
+ uint i;
+ for (i = 0; i < 2; i++)
+ {
+ uint b;
+ b = rg_etc_selector_index_to_etc1[pSelectors[3]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+
+ b = rg_etc_selector_index_to_etc1[pSelectors[2]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+
+ b = rg_etc_selector_index_to_etc1[pSelectors[1]];
+ selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
+
+ b = rg_etc_selector_index_to_etc1[pSelectors[0]];
+ selector0 = (selector0 << 1) | (b & 1);selector1 = (selector1 << 1) | (b >> 1);
+
+ pSelectors -= 4;
+ }
+ }
+ }
+
+ dst_block[4] = (uint8)(selector1 >> 8); dst_block[5] = (uint8)(selector1 & 0xFF);
+ dst_block[6] = (uint8)(selector0 >> 8); dst_block[7] = (uint8)(selector0 & 0xFF);
+ return (unsigned int)(best_error);
+}
+++ /dev/null
-// File: rg_etc1.cpp - Fast, high quality ETC1 block packer/unpacker - Rich Geldreich <richgel99@gmail.com>
-// Please see ZLIB license at the end of rg_etc1.h.
-//
-// For more information Ericsson Texture Compression (ETC/ETC1), see:
-// http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt
-//
-// v1.04 - 5/15/14 - Fix signed vs. unsigned subtraction problem (noticed when compiled with gcc) in pack_etc1_block_init().
-// This issue would cause an assert when this func. was called in debug. (Note this module was developed/testing with MSVC,
-// I still need to test it throughly when compiled with gcc.)
-//
-// v1.03 - 5/12/13 - Initial public release
-#include "rg_etc1.h"
-
-#include <stdlib.h>
-#include <memory.h>
-#include <assert.h>
-//#include <stdio.h>
-#include <math.h>
-
-#pragma warning (disable: 4201) // nonstandard extension used : nameless struct/union
-
-#if defined(_DEBUG) || defined(DEBUG)
-#define RG_ETC1_BUILD_DEBUG
-#endif
-
-#define RG_ETC1_ASSERT assert
-
-namespace rg_etc1
-{
- typedef unsigned char uint8;
- typedef unsigned short uint16;
- typedef unsigned int uint;
- typedef unsigned int uint32;
- typedef long long int64;
- typedef unsigned long long uint64;
-
- const uint32 cUINT32_MAX = 0xFFFFFFFFU;
- const uint64 cUINT64_MAX = 0xFFFFFFFFFFFFFFFFULL; //0xFFFFFFFFFFFFFFFFui64;
-
- template<typename T> inline T minimum(T a, T b) { return (a < b) ? a : b; }
- template<typename T> inline T minimum(T a, T b, T c) { return minimum(minimum(a, b), c); }
- template<typename T> inline T maximum(T a, T b) { return (a > b) ? a : b; }
- template<typename T> inline T maximum(T a, T b, T c) { return maximum(maximum(a, b), c); }
- template<typename T> inline T clamp(T value, T low, T high) { return (value < low) ? low : ((value > high) ? high : value); }
- template<typename T> inline T square(T value) { return value * value; }
- template<typename T> inline void zero_object(T& obj) { memset((void*)&obj, 0, sizeof(obj)); }
- template<typename T> inline void zero_this(T* pObj) { memset((void*)pObj, 0, sizeof(*pObj)); }
-
- template<class T, size_t N> T decay_array_to_subtype(T (&a)[N]);
-
-#define RG_ETC1_ARRAY_SIZE(X) (sizeof(X) / sizeof(decay_array_to_subtype(X)))
-
- enum eNoClamp { cNoClamp };
-
- struct color_quad_u8
- {
- static inline int clamp(int v) { if (v & 0xFFFFFF00U) v = (~(static_cast<int>(v) >> 31)) & 0xFF; return v; }
-
- struct component_traits { enum { cSigned = false, cFloat = false, cMin = 0U, cMax = 255U }; };
-
- public:
- typedef unsigned char component_t;
- typedef int parameter_t;
-
- enum { cNumComps = 4 };
-
- union
- {
- struct
- {
- component_t r;
- component_t g;
- component_t b;
- component_t a;
- };
-
- component_t c[cNumComps];
-
- uint32 m_u32;
- };
-
- inline color_quad_u8()
- {
- }
-
- inline color_quad_u8(const color_quad_u8& other) : m_u32(other.m_u32)
- {
- }
-
- explicit inline color_quad_u8(parameter_t y, parameter_t alpha = component_traits::cMax)
- {
- set(y, alpha);
- }
-
- inline color_quad_u8(parameter_t red, parameter_t green, parameter_t blue, parameter_t alpha = component_traits::cMax)
- {
- set(red, green, blue, alpha);
- }
-
- explicit inline color_quad_u8(eNoClamp, parameter_t y, parameter_t alpha = component_traits::cMax)
- {
- set_noclamp_y_alpha(y, alpha);
- }
-
- inline color_quad_u8(eNoClamp, parameter_t red, parameter_t green, parameter_t blue, parameter_t alpha = component_traits::cMax)
- {
- set_noclamp_rgba(red, green, blue, alpha);
- }
-
- inline void clear()
- {
- m_u32 = 0;
- }
-
- inline color_quad_u8& operator= (const color_quad_u8& other)
- {
- m_u32 = other.m_u32;
- return *this;
- }
-
- inline color_quad_u8& set_rgb(const color_quad_u8& other)
- {
- r = other.r;
- g = other.g;
- b = other.b;
- return *this;
- }
-
- inline color_quad_u8& operator= (parameter_t y)
- {
- set(y, component_traits::cMax);
- return *this;
- }
-
- inline color_quad_u8& set(parameter_t y, parameter_t alpha = component_traits::cMax)
- {
- y = clamp(y);
- alpha = clamp(alpha);
- r = static_cast<component_t>(y);
- g = static_cast<component_t>(y);
- b = static_cast<component_t>(y);
- a = static_cast<component_t>(alpha);
- return *this;
- }
-
- inline color_quad_u8& set_noclamp_y_alpha(parameter_t y, parameter_t alpha = component_traits::cMax)
- {
- RG_ETC1_ASSERT( (y >= component_traits::cMin) && (y <= component_traits::cMax) );
- RG_ETC1_ASSERT( (alpha >= component_traits::cMin) && (alpha <= component_traits::cMax) );
-
- r = static_cast<component_t>(y);
- g = static_cast<component_t>(y);
- b = static_cast<component_t>(y);
- a = static_cast<component_t>(alpha);
- return *this;
- }
-
- inline color_quad_u8& set(parameter_t red, parameter_t green, parameter_t blue, parameter_t alpha = component_traits::cMax)
- {
- r = static_cast<component_t>(clamp(red));
- g = static_cast<component_t>(clamp(green));
- b = static_cast<component_t>(clamp(blue));
- a = static_cast<component_t>(clamp(alpha));
- return *this;
- }
-
- inline color_quad_u8& set_noclamp_rgba(parameter_t red, parameter_t green, parameter_t blue, parameter_t alpha)
- {
- RG_ETC1_ASSERT( (red >= component_traits::cMin) && (red <= component_traits::cMax) );
- RG_ETC1_ASSERT( (green >= component_traits::cMin) && (green <= component_traits::cMax) );
- RG_ETC1_ASSERT( (blue >= component_traits::cMin) && (blue <= component_traits::cMax) );
- RG_ETC1_ASSERT( (alpha >= component_traits::cMin) && (alpha <= component_traits::cMax) );
-
- r = static_cast<component_t>(red);
- g = static_cast<component_t>(green);
- b = static_cast<component_t>(blue);
- a = static_cast<component_t>(alpha);
- return *this;
- }
-
- inline color_quad_u8& set_noclamp_rgb(parameter_t red, parameter_t green, parameter_t blue)
- {
- RG_ETC1_ASSERT( (red >= component_traits::cMin) && (red <= component_traits::cMax) );
- RG_ETC1_ASSERT( (green >= component_traits::cMin) && (green <= component_traits::cMax) );
- RG_ETC1_ASSERT( (blue >= component_traits::cMin) && (blue <= component_traits::cMax) );
-
- r = static_cast<component_t>(red);
- g = static_cast<component_t>(green);
- b = static_cast<component_t>(blue);
- return *this;
- }
-
- static inline parameter_t get_min_comp() { return component_traits::cMin; }
- static inline parameter_t get_max_comp() { return component_traits::cMax; }
- static inline bool get_comps_are_signed() { return component_traits::cSigned; }
-
- inline component_t operator[] (uint i) const { RG_ETC1_ASSERT(i < cNumComps); return c[i]; }
- inline component_t& operator[] (uint i) { RG_ETC1_ASSERT(i < cNumComps); return c[i]; }
-
- inline color_quad_u8& set_component(uint i, parameter_t f)
- {
- RG_ETC1_ASSERT(i < cNumComps);
-
- c[i] = static_cast<component_t>(clamp(f));
-
- return *this;
- }
-
- inline color_quad_u8& set_grayscale(parameter_t l)
- {
- component_t x = static_cast<component_t>(clamp(l));
- c[0] = x;
- c[1] = x;
- c[2] = x;
- return *this;
- }
-
- inline color_quad_u8& clamp(const color_quad_u8& l, const color_quad_u8& h)
- {
- for (uint i = 0; i < cNumComps; i++)
- c[i] = static_cast<component_t>(rg_etc1::clamp<parameter_t>(c[i], l[i], h[i]));
- return *this;
- }
-
- inline color_quad_u8& clamp(parameter_t l, parameter_t h)
- {
- for (uint i = 0; i < cNumComps; i++)
- c[i] = static_cast<component_t>(rg_etc1::clamp<parameter_t>(c[i], l, h));
- return *this;
- }
-
- // Returns CCIR 601 luma (consistent with color_utils::RGB_To_Y).
- inline parameter_t get_luma() const
- {
- return static_cast<parameter_t>((19595U * r + 38470U * g + 7471U * b + 32768U) >> 16U);
- }
-
- // Returns REC 709 luma.
- inline parameter_t get_luma_rec709() const
- {
- return static_cast<parameter_t>((13938U * r + 46869U * g + 4729U * b + 32768U) >> 16U);
- }
-
- inline uint squared_distance_rgb(const color_quad_u8& c) const
- {
- return rg_etc1::square(r - c.r) + rg_etc1::square(g - c.g) + rg_etc1::square(b - c.b);
- }
-
- inline uint squared_distance_rgba(const color_quad_u8& c) const
- {
- return rg_etc1::square(r - c.r) + rg_etc1::square(g - c.g) + rg_etc1::square(b - c.b) + rg_etc1::square(a - c.a);
- }
-
- inline bool rgb_equals(const color_quad_u8& rhs) const
- {
- return (r == rhs.r) && (g == rhs.g) && (b == rhs.b);
- }
-
- inline bool operator== (const color_quad_u8& rhs) const
- {
- return m_u32 == rhs.m_u32;
- }
-
- color_quad_u8& operator+= (const color_quad_u8& other)
- {
- for (uint i = 0; i < 4; i++)
- c[i] = static_cast<component_t>(clamp(c[i] + other.c[i]));
- return *this;
- }
-
- color_quad_u8& operator-= (const color_quad_u8& other)
- {
- for (uint i = 0; i < 4; i++)
- c[i] = static_cast<component_t>(clamp(c[i] - other.c[i]));
- return *this;
- }
-
- friend color_quad_u8 operator+ (const color_quad_u8& lhs, const color_quad_u8& rhs)
- {
- color_quad_u8 result(lhs);
- result += rhs;
- return result;
- }
-
- friend color_quad_u8 operator- (const color_quad_u8& lhs, const color_quad_u8& rhs)
- {
- color_quad_u8 result(lhs);
- result -= rhs;
- return result;
- }
- }; // class color_quad_u8
-
- struct vec3F
- {
- float m_s[3];
-
- inline vec3F() { }
- inline vec3F(float s) { m_s[0] = s; m_s[1] = s; m_s[2] = s; }
- inline vec3F(float x, float y, float z) { m_s[0] = x; m_s[1] = y; m_s[2] = z; }
-
- inline float operator[] (uint i) const { RG_ETC1_ASSERT(i < 3); return m_s[i]; }
-
- inline vec3F& operator += (const vec3F& other) { for (uint i = 0; i < 3; i++) m_s[i] += other.m_s[i]; return *this; }
-
- inline vec3F& operator *= (float s) { for (uint i = 0; i < 3; i++) m_s[i] *= s; return *this; }
- };
-
- enum etc_constants
- {
- cETC1BytesPerBlock = 8U,
-
- cETC1SelectorBits = 2U,
- cETC1SelectorValues = 1U << cETC1SelectorBits,
- cETC1SelectorMask = cETC1SelectorValues - 1U,
-
- cETC1BlockShift = 2U,
- cETC1BlockSize = 1U << cETC1BlockShift,
-
- cETC1LSBSelectorIndicesBitOffset = 0,
- cETC1MSBSelectorIndicesBitOffset = 16,
-
- cETC1FlipBitOffset = 32,
- cETC1DiffBitOffset = 33,
-
- cETC1IntenModifierNumBits = 3,
- cETC1IntenModifierValues = 1 << cETC1IntenModifierNumBits,
- cETC1RightIntenModifierTableBitOffset = 34,
- cETC1LeftIntenModifierTableBitOffset = 37,
-
- // Base+Delta encoding (5 bit bases, 3 bit delta)
- cETC1BaseColorCompNumBits = 5,
- cETC1BaseColorCompMax = 1 << cETC1BaseColorCompNumBits,
-
- cETC1DeltaColorCompNumBits = 3,
- cETC1DeltaColorComp = 1 << cETC1DeltaColorCompNumBits,
- cETC1DeltaColorCompMax = 1 << cETC1DeltaColorCompNumBits,
-
- cETC1BaseColor5RBitOffset = 59,
- cETC1BaseColor5GBitOffset = 51,
- cETC1BaseColor5BBitOffset = 43,
-
- cETC1DeltaColor3RBitOffset = 56,
- cETC1DeltaColor3GBitOffset = 48,
- cETC1DeltaColor3BBitOffset = 40,
-
- // Absolute (non-delta) encoding (two 4-bit per component bases)
- cETC1AbsColorCompNumBits = 4,
- cETC1AbsColorCompMax = 1 << cETC1AbsColorCompNumBits,
-
- cETC1AbsColor4R1BitOffset = 60,
- cETC1AbsColor4G1BitOffset = 52,
- cETC1AbsColor4B1BitOffset = 44,
-
- cETC1AbsColor4R2BitOffset = 56,
- cETC1AbsColor4G2BitOffset = 48,
- cETC1AbsColor4B2BitOffset = 40,
-
- cETC1ColorDeltaMin = -4,
- cETC1ColorDeltaMax = 3,
-
- // Delta3:
- // 0 1 2 3 4 5 6 7
- // 000 001 010 011 100 101 110 111
- // 0 1 2 3 -4 -3 -2 -1
- };
-
- static uint8 g_quant5_tab[256+16];
-
- static const int g_etc1_inten_tables[cETC1IntenModifierValues][cETC1SelectorValues] =
- {
- { -8, -2, 2, 8 }, { -17, -5, 5, 17 }, { -29, -9, 9, 29 }, { -42, -13, 13, 42 },
- { -60, -18, 18, 60 }, { -80, -24, 24, 80 }, { -106, -33, 33, 106 }, { -183, -47, 47, 183 }
- };
-
- static const uint8 g_etc1_to_selector_index[cETC1SelectorValues] = { 2, 3, 1, 0 };
- static const uint8 g_selector_index_to_etc1[cETC1SelectorValues] = { 3, 2, 0, 1 };
-
- // 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.
- static uint16 g_etc1_inverse_lookup[2*8*4][256]; // [diff/inten_table/selector][desired_color]
-
- // 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.
- // To pack: diff | (inten << 1) | (selector << 4) | (packed_c << 8)
- static const uint16 g_color8_to_etc_block_config_0_255[2][33] =
- {
- { 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 },
- { 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 },
- };
-
- // Really only [254][11].
- static const uint16 g_color8_to_etc_block_config_1_to_254[254][12] =
- {
- { 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 }, {
- 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,
- 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,
- 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
- }, { 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,
- 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,
- 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,
- 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 }, {
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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 }, {
- 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,
- 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,
- 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,
- 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,
- 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,
- 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 }, {
- 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,
- 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 }, {
- 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,
- 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,
- 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 }, {
- 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,
- 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 }, {
- 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,
- 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,
- 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,
- 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
- }, { 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,
- 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,
- 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 }, {
- 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,
- 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,
- 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,
- 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,
- 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,
- 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 }, {
- 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 }, {
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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 },
- };
-
- struct etc1_block
- {
- // big endian uint64:
- // bit ofs: 56 48 40 32 24 16 8 0
- // byte ofs: b0, b1, b2, b3, b4, b5, b6, b7
- union
- {
- uint64 m_uint64;
- uint8 m_bytes[8];
- };
-
- uint8 m_low_color[2];
- uint8 m_high_color[2];
-
- enum { cNumSelectorBytes = 4 };
- uint8 m_selectors[cNumSelectorBytes];
-
- inline void clear()
- {
- zero_this(this);
- }
-
- inline uint get_byte_bits(uint ofs, uint num) const
- {
- RG_ETC1_ASSERT((ofs + num) <= 64U);
- RG_ETC1_ASSERT(num && (num <= 8U));
- RG_ETC1_ASSERT((ofs >> 3) == ((ofs + num - 1) >> 3));
- const uint byte_ofs = 7 - (ofs >> 3);
- const uint byte_bit_ofs = ofs & 7;
- return (m_bytes[byte_ofs] >> byte_bit_ofs) & ((1 << num) - 1);
- }
-
- inline void set_byte_bits(uint ofs, uint num, uint bits)
- {
- RG_ETC1_ASSERT((ofs + num) <= 64U);
- RG_ETC1_ASSERT(num && (num < 32U));
- RG_ETC1_ASSERT((ofs >> 3) == ((ofs + num - 1) >> 3));
- RG_ETC1_ASSERT(bits < (1U << num));
- const uint byte_ofs = 7 - (ofs >> 3);
- const uint byte_bit_ofs = ofs & 7;
- const uint mask = (1 << num) - 1;
- m_bytes[byte_ofs] &= ~(mask << byte_bit_ofs);
- m_bytes[byte_ofs] |= (bits << byte_bit_ofs);
- }
-
- // false = left/right subblocks
- // true = upper/lower subblocks
- inline bool get_flip_bit() const
- {
- return (m_bytes[3] & 1) != 0;
- }
-
- inline void set_flip_bit(bool flip)
- {
- m_bytes[3] &= ~1;
- m_bytes[3] |= static_cast<uint8>(flip);
- }
-
- inline bool get_diff_bit() const
- {
- return (m_bytes[3] & 2) != 0;
- }
-
- inline void set_diff_bit(bool diff)
- {
- m_bytes[3] &= ~2;
- m_bytes[3] |= (static_cast<uint>(diff) << 1);
- }
-
- // Returns intensity modifier table (0-7) used by subblock subblock_id.
- // subblock_id=0 left/top (CW 1), 1=right/bottom (CW 2)
- inline uint get_inten_table(uint subblock_id) const
- {
- RG_ETC1_ASSERT(subblock_id < 2);
- const uint ofs = subblock_id ? 2 : 5;
- return (m_bytes[3] >> ofs) & 7;
- }
-
- // Sets intensity modifier table (0-7) used by subblock subblock_id (0 or 1)
- inline void set_inten_table(uint subblock_id, uint t)
- {
- RG_ETC1_ASSERT(subblock_id < 2);
- RG_ETC1_ASSERT(t < 8);
- const uint ofs = subblock_id ? 2 : 5;
- m_bytes[3] &= ~(7 << ofs);
- m_bytes[3] |= (t << ofs);
- }
-
- // Returned selector value ranges from 0-3 and is a direct index into g_etc1_inten_tables.
- inline uint get_selector(uint x, uint y) const
- {
- RG_ETC1_ASSERT((x | y) < 4);
-
- const uint bit_index = x * 4 + y;
- const uint byte_bit_ofs = bit_index & 7;
- const uint8 *p = &m_bytes[7 - (bit_index >> 3)];
- const uint lsb = (p[0] >> byte_bit_ofs) & 1;
- const uint msb = (p[-2] >> byte_bit_ofs) & 1;
- const uint val = lsb | (msb << 1);
-
- return g_etc1_to_selector_index[val];
- }
-
- // Selector "val" ranges from 0-3 and is a direct index into g_etc1_inten_tables.
- inline void set_selector(uint x, uint y, uint val)
- {
- RG_ETC1_ASSERT((x | y | val) < 4);
- const uint bit_index = x * 4 + y;
-
- uint8 *p = &m_bytes[7 - (bit_index >> 3)];
-
- const uint byte_bit_ofs = bit_index & 7;
- const uint mask = 1 << byte_bit_ofs;
-
- const uint etc1_val = g_selector_index_to_etc1[val];
-
- const uint lsb = etc1_val & 1;
- const uint msb = etc1_val >> 1;
-
- p[0] &= ~mask;
- p[0] |= (lsb << byte_bit_ofs);
-
- p[-2] &= ~mask;
- p[-2] |= (msb << byte_bit_ofs);
- }
-
- inline void set_base4_color(uint idx, uint16 c)
- {
- if (idx)
- {
- set_byte_bits(cETC1AbsColor4R2BitOffset, 4, (c >> 8) & 15);
- set_byte_bits(cETC1AbsColor4G2BitOffset, 4, (c >> 4) & 15);
- set_byte_bits(cETC1AbsColor4B2BitOffset, 4, c & 15);
- }
- else
- {
- set_byte_bits(cETC1AbsColor4R1BitOffset, 4, (c >> 8) & 15);
- set_byte_bits(cETC1AbsColor4G1BitOffset, 4, (c >> 4) & 15);
- set_byte_bits(cETC1AbsColor4B1BitOffset, 4, c & 15);
- }
- }
-
- inline uint16 get_base4_color(uint idx) const
- {
- uint r, g, b;
- if (idx)
- {
- r = get_byte_bits(cETC1AbsColor4R2BitOffset, 4);
- g = get_byte_bits(cETC1AbsColor4G2BitOffset, 4);
- b = get_byte_bits(cETC1AbsColor4B2BitOffset, 4);
- }
- else
- {
- r = get_byte_bits(cETC1AbsColor4R1BitOffset, 4);
- g = get_byte_bits(cETC1AbsColor4G1BitOffset, 4);
- b = get_byte_bits(cETC1AbsColor4B1BitOffset, 4);
- }
- return static_cast<uint16>(b | (g << 4U) | (r << 8U));
- }
-
- inline void set_base5_color(uint16 c)
- {
- set_byte_bits(cETC1BaseColor5RBitOffset, 5, (c >> 10) & 31);
- set_byte_bits(cETC1BaseColor5GBitOffset, 5, (c >> 5) & 31);
- set_byte_bits(cETC1BaseColor5BBitOffset, 5, c & 31);
- }
-
- inline uint16 get_base5_color() const
- {
- const uint r = get_byte_bits(cETC1BaseColor5RBitOffset, 5);
- const uint g = get_byte_bits(cETC1BaseColor5GBitOffset, 5);
- const uint b = get_byte_bits(cETC1BaseColor5BBitOffset, 5);
- return static_cast<uint16>(b | (g << 5U) | (r << 10U));
- }
-
- void set_delta3_color(uint16 c)
- {
- set_byte_bits(cETC1DeltaColor3RBitOffset, 3, (c >> 6) & 7);
- set_byte_bits(cETC1DeltaColor3GBitOffset, 3, (c >> 3) & 7);
- set_byte_bits(cETC1DeltaColor3BBitOffset, 3, c & 7);
- }
-
- inline uint16 get_delta3_color() const
- {
- const uint r = get_byte_bits(cETC1DeltaColor3RBitOffset, 3);
- const uint g = get_byte_bits(cETC1DeltaColor3GBitOffset, 3);
- const uint b = get_byte_bits(cETC1DeltaColor3BBitOffset, 3);
- return static_cast<uint16>(b | (g << 3U) | (r << 6U));
- }
-
- // Base color 5
- static uint16 pack_color5(const color_quad_u8& color, bool scaled, uint bias = 127U);
- static uint16 pack_color5(uint r, uint g, uint b, bool scaled, uint bias = 127U);
-
- static color_quad_u8 unpack_color5(uint16 packed_color5, bool scaled, uint alpha = 255U);
- static void unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color, bool scaled);
-
- static bool unpack_color5(color_quad_u8& result, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha = 255U);
- static bool unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha = 255U);
-
- // Delta color 3
- // Inputs range from -4 to 3 (cETC1ColorDeltaMin to cETC1ColorDeltaMax)
- static uint16 pack_delta3(int r, int g, int b);
-
- // Results range from -4 to 3 (cETC1ColorDeltaMin to cETC1ColorDeltaMax)
- static void unpack_delta3(int& r, int& g, int& b, uint16 packed_delta3);
-
- // Abs color 4
- static uint16 pack_color4(const color_quad_u8& color, bool scaled, uint bias = 127U);
- static uint16 pack_color4(uint r, uint g, uint b, bool scaled, uint bias = 127U);
-
- static color_quad_u8 unpack_color4(uint16 packed_color4, bool scaled, uint alpha = 255U);
- static void unpack_color4(uint& r, uint& g, uint& b, uint16 packed_color4, bool scaled);
-
- // subblock colors
- static void get_diff_subblock_colors(color_quad_u8* pDst, uint16 packed_color5, uint table_idx);
- static bool get_diff_subblock_colors(color_quad_u8* pDst, uint16 packed_color5, uint16 packed_delta3, uint table_idx);
- static void get_abs_subblock_colors(color_quad_u8* pDst, uint16 packed_color4, uint table_idx);
-
- static inline void unscaled_to_scaled_color(color_quad_u8& dst, const color_quad_u8& src, bool color4)
- {
- if (color4)
- {
- dst.r = src.r | (src.r << 4);
- dst.g = src.g | (src.g << 4);
- dst.b = src.b | (src.b << 4);
- }
- else
- {
- dst.r = (src.r >> 2) | (src.r << 3);
- dst.g = (src.g >> 2) | (src.g << 3);
- dst.b = (src.b >> 2) | (src.b << 3);
- }
- dst.a = src.a;
- }
- };
-
- // Returns pointer to sorted array.
- template<typename T, typename Q>
- T* indirect_radix_sort(uint num_indices, T* pIndices0, T* pIndices1, const Q* pKeys, uint key_ofs, uint key_size, bool init_indices)
- {
- RG_ETC1_ASSERT((key_ofs >= 0) && (key_ofs < sizeof(T)));
- RG_ETC1_ASSERT((key_size >= 1) && (key_size <= 4));
-
- if (init_indices)
- {
- T* p = pIndices0;
- T* q = pIndices0 + (num_indices >> 1) * 2;
- uint i;
- for (i = 0; p != q; p += 2, i += 2)
- {
- p[0] = static_cast<T>(i);
- p[1] = static_cast<T>(i + 1);
- }
-
- if (num_indices & 1)
- *p = static_cast<T>(i);
- }
-
- uint hist[256 * 4];
-
- memset(hist, 0, sizeof(hist[0]) * 256 * key_size);
-
-#define RG_ETC1_GET_KEY(p) (*(const uint*)((const uint8*)(pKeys + *(p)) + key_ofs))
-#define RG_ETC1_GET_KEY_FROM_INDEX(i) (*(const uint*)((const uint8*)(pKeys + (i)) + key_ofs))
-
- if (key_size == 4)
- {
- T* p = pIndices0;
- T* q = pIndices0 + num_indices;
- for ( ; p != q; p++)
- {
- const uint key = RG_ETC1_GET_KEY(p);
-
- hist[ key & 0xFF]++;
- hist[256 + ((key >> 8) & 0xFF)]++;
- hist[512 + ((key >> 16) & 0xFF)]++;
- hist[768 + ((key >> 24) & 0xFF)]++;
- }
- }
- else if (key_size == 3)
- {
- T* p = pIndices0;
- T* q = pIndices0 + num_indices;
- for ( ; p != q; p++)
- {
- const uint key = RG_ETC1_GET_KEY(p);
-
- hist[ key & 0xFF]++;
- hist[256 + ((key >> 8) & 0xFF)]++;
- hist[512 + ((key >> 16) & 0xFF)]++;
- }
- }
- else if (key_size == 2)
- {
- T* p = pIndices0;
- T* q = pIndices0 + (num_indices >> 1) * 2;
-
- for ( ; p != q; p += 2)
- {
- const uint key0 = RG_ETC1_GET_KEY(p);
- const uint key1 = RG_ETC1_GET_KEY(p+1);
-
- hist[ key0 & 0xFF]++;
- hist[256 + ((key0 >> 8) & 0xFF)]++;
-
- hist[ key1 & 0xFF]++;
- hist[256 + ((key1 >> 8) & 0xFF)]++;
- }
-
- if (num_indices & 1)
- {
- const uint key = RG_ETC1_GET_KEY(p);
-
- hist[ key & 0xFF]++;
- hist[256 + ((key >> 8) & 0xFF)]++;
- }
- }
- else
- {
- RG_ETC1_ASSERT(key_size == 1);
- if (key_size != 1)
- return NULL;
-
- T* p = pIndices0;
- T* q = pIndices0 + (num_indices >> 1) * 2;
-
- for ( ; p != q; p += 2)
- {
- const uint key0 = RG_ETC1_GET_KEY(p);
- const uint key1 = RG_ETC1_GET_KEY(p+1);
-
- hist[key0 & 0xFF]++;
- hist[key1 & 0xFF]++;
- }
-
- if (num_indices & 1)
- {
- const uint key = RG_ETC1_GET_KEY(p);
-
- hist[key & 0xFF]++;
- }
- }
-
- T* pCur = pIndices0;
- T* pNew = pIndices1;
-
- for (uint pass = 0; pass < key_size; pass++)
- {
- const uint* pHist = &hist[pass << 8];
-
- uint offsets[256];
-
- uint cur_ofs = 0;
- for (uint i = 0; i < 256; i += 2)
- {
- offsets[i] = cur_ofs;
- cur_ofs += pHist[i];
-
- offsets[i+1] = cur_ofs;
- cur_ofs += pHist[i+1];
- }
-
- const uint pass_shift = pass << 3;
-
- T* p = pCur;
- T* q = pCur + (num_indices >> 1) * 2;
-
- for ( ; p != q; p += 2)
- {
- uint index0 = p[0];
- uint index1 = p[1];
-
- uint c0 = (RG_ETC1_GET_KEY_FROM_INDEX(index0) >> pass_shift) & 0xFF;
- uint c1 = (RG_ETC1_GET_KEY_FROM_INDEX(index1) >> pass_shift) & 0xFF;
-
- if (c0 == c1)
- {
- uint dst_offset0 = offsets[c0];
-
- offsets[c0] = dst_offset0 + 2;
-
- pNew[dst_offset0] = static_cast<T>(index0);
- pNew[dst_offset0 + 1] = static_cast<T>(index1);
- }
- else
- {
- uint dst_offset0 = offsets[c0]++;
- uint dst_offset1 = offsets[c1]++;
-
- pNew[dst_offset0] = static_cast<T>(index0);
- pNew[dst_offset1] = static_cast<T>(index1);
- }
- }
-
- if (num_indices & 1)
- {
- uint index = *p;
- uint c = (RG_ETC1_GET_KEY_FROM_INDEX(index) >> pass_shift) & 0xFF;
-
- uint dst_offset = offsets[c];
- offsets[c] = dst_offset + 1;
-
- pNew[dst_offset] = static_cast<T>(index);
- }
-
- T* t = pCur;
- pCur = pNew;
- pNew = t;
- }
-
- return pCur;
- }
-
-#undef RG_ETC1_GET_KEY
-#undef RG_ETC1_GET_KEY_FROM_INDEX
-
- uint16 etc1_block::pack_color5(const color_quad_u8& color, bool scaled, uint bias)
- {
- return pack_color5(color.r, color.g, color.b, scaled, bias);
- }
-
- uint16 etc1_block::pack_color5(uint r, uint g, uint b, bool scaled, uint bias)
- {
- if (scaled)
- {
- r = (r * 31U + bias) / 255U;
- g = (g * 31U + bias) / 255U;
- b = (b * 31U + bias) / 255U;
- }
-
- r = rg_etc1::minimum(r, 31U);
- g = rg_etc1::minimum(g, 31U);
- b = rg_etc1::minimum(b, 31U);
-
- return static_cast<uint16>(b | (g << 5U) | (r << 10U));
- }
-
- color_quad_u8 etc1_block::unpack_color5(uint16 packed_color5, bool scaled, uint alpha)
- {
- uint b = packed_color5 & 31U;
- uint g = (packed_color5 >> 5U) & 31U;
- uint r = (packed_color5 >> 10U) & 31U;
-
- if (scaled)
- {
- b = (b << 3U) | (b >> 2U);
- g = (g << 3U) | (g >> 2U);
- r = (r << 3U) | (r >> 2U);
- }
-
- return color_quad_u8(cNoClamp, r, g, b, rg_etc1::minimum(alpha, 255U));
- }
-
- void etc1_block::unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color5, bool scaled)
- {
- color_quad_u8 c(unpack_color5(packed_color5, scaled, 0));
- r = c.r;
- g = c.g;
- b = c.b;
- }
-
- bool etc1_block::unpack_color5(color_quad_u8& result, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha)
- {
- int dc_r, dc_g, dc_b;
- unpack_delta3(dc_r, dc_g, dc_b, packed_delta3);
-
- int b = (packed_color5 & 31U) + dc_b;
- int g = ((packed_color5 >> 5U) & 31U) + dc_g;
- int r = ((packed_color5 >> 10U) & 31U) + dc_r;
-
- bool success = true;
- if (static_cast<uint>(r | g | b) > 31U)
- {
- success = false;
- r = rg_etc1::clamp<int>(r, 0, 31);
- g = rg_etc1::clamp<int>(g, 0, 31);
- b = rg_etc1::clamp<int>(b, 0, 31);
- }
-
- if (scaled)
- {
- b = (b << 3U) | (b >> 2U);
- g = (g << 3U) | (g >> 2U);
- r = (r << 3U) | (r >> 2U);
- }
-
- result.set_noclamp_rgba(r, g, b, rg_etc1::minimum(alpha, 255U));
- return success;
- }
-
- bool etc1_block::unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha)
- {
- color_quad_u8 result;
- const bool success = unpack_color5(result, packed_color5, packed_delta3, scaled, alpha);
- r = result.r;
- g = result.g;
- b = result.b;
- return success;
- }
-
- uint16 etc1_block::pack_delta3(int r, int g, int b)
- {
- RG_ETC1_ASSERT((r >= cETC1ColorDeltaMin) && (r <= cETC1ColorDeltaMax));
- RG_ETC1_ASSERT((g >= cETC1ColorDeltaMin) && (g <= cETC1ColorDeltaMax));
- RG_ETC1_ASSERT((b >= cETC1ColorDeltaMin) && (b <= cETC1ColorDeltaMax));
- if (r < 0) r += 8;
- if (g < 0) g += 8;
- if (b < 0) b += 8;
- return static_cast<uint16>(b | (g << 3) | (r << 6));
- }
-
- void etc1_block::unpack_delta3(int& r, int& g, int& b, uint16 packed_delta3)
- {
- r = (packed_delta3 >> 6) & 7;
- g = (packed_delta3 >> 3) & 7;
- b = packed_delta3 & 7;
- if (r >= 4) r -= 8;
- if (g >= 4) g -= 8;
- if (b >= 4) b -= 8;
- }
-
- uint16 etc1_block::pack_color4(const color_quad_u8& color, bool scaled, uint bias)
- {
- return pack_color4(color.r, color.g, color.b, scaled, bias);
- }
-
- uint16 etc1_block::pack_color4(uint r, uint g, uint b, bool scaled, uint bias)
- {
- if (scaled)
- {
- r = (r * 15U + bias) / 255U;
- g = (g * 15U + bias) / 255U;
- b = (b * 15U + bias) / 255U;
- }
-
- r = rg_etc1::minimum(r, 15U);
- g = rg_etc1::minimum(g, 15U);
- b = rg_etc1::minimum(b, 15U);
-
- return static_cast<uint16>(b | (g << 4U) | (r << 8U));
- }
-
- color_quad_u8 etc1_block::unpack_color4(uint16 packed_color4, bool scaled, uint alpha)
- {
- uint b = packed_color4 & 15U;
- uint g = (packed_color4 >> 4U) & 15U;
- uint r = (packed_color4 >> 8U) & 15U;
-
- if (scaled)
- {
- b = (b << 4U) | b;
- g = (g << 4U) | g;
- r = (r << 4U) | r;
- }
-
- return color_quad_u8(cNoClamp, r, g, b, rg_etc1::minimum(alpha, 255U));
- }
-
- void etc1_block::unpack_color4(uint& r, uint& g, uint& b, uint16 packed_color4, bool scaled)
- {
- color_quad_u8 c(unpack_color4(packed_color4, scaled, 0));
- r = c.r;
- g = c.g;
- b = c.b;
- }
-
- void etc1_block::get_diff_subblock_colors(color_quad_u8* pDst, uint16 packed_color5, uint table_idx)
- {
- RG_ETC1_ASSERT(table_idx < cETC1IntenModifierValues);
- const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];
-
- uint r, g, b;
- unpack_color5(r, g, b, packed_color5, true);
-
- const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);
-
- const int y0 = pInten_modifer_table[0];
- pDst[0].set(ir + y0, ig + y0, ib + y0);
-
- const int y1 = pInten_modifer_table[1];
- pDst[1].set(ir + y1, ig + y1, ib + y1);
-
- const int y2 = pInten_modifer_table[2];
- pDst[2].set(ir + y2, ig + y2, ib + y2);
-
- const int y3 = pInten_modifer_table[3];
- pDst[3].set(ir + y3, ig + y3, ib + y3);
- }
-
- bool etc1_block::get_diff_subblock_colors(color_quad_u8* pDst, uint16 packed_color5, uint16 packed_delta3, uint table_idx)
- {
- RG_ETC1_ASSERT(table_idx < cETC1IntenModifierValues);
- const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];
-
- uint r, g, b;
- bool success = unpack_color5(r, g, b, packed_color5, packed_delta3, true);
-
- const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);
-
- const int y0 = pInten_modifer_table[0];
- pDst[0].set(ir + y0, ig + y0, ib + y0);
-
- const int y1 = pInten_modifer_table[1];
- pDst[1].set(ir + y1, ig + y1, ib + y1);
-
- const int y2 = pInten_modifer_table[2];
- pDst[2].set(ir + y2, ig + y2, ib + y2);
-
- const int y3 = pInten_modifer_table[3];
- pDst[3].set(ir + y3, ig + y3, ib + y3);
-
- return success;
- }
-
- void etc1_block::get_abs_subblock_colors(color_quad_u8* pDst, uint16 packed_color4, uint table_idx)
- {
- RG_ETC1_ASSERT(table_idx < cETC1IntenModifierValues);
- const int *pInten_modifer_table = &g_etc1_inten_tables[table_idx][0];
-
- uint r, g, b;
- unpack_color4(r, g, b, packed_color4, true);
-
- const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b);
-
- const int y0 = pInten_modifer_table[0];
- pDst[0].set(ir + y0, ig + y0, ib + y0);
-
- const int y1 = pInten_modifer_table[1];
- pDst[1].set(ir + y1, ig + y1, ib + y1);
-
- const int y2 = pInten_modifer_table[2];
- pDst[2].set(ir + y2, ig + y2, ib + y2);
-
- const int y3 = pInten_modifer_table[3];
- pDst[3].set(ir + y3, ig + y3, ib + y3);
- }
-
- bool unpack_etc1_block(const void* pETC1_block, unsigned int* pDst_pixels_rgba, bool preserve_alpha)
- {
- color_quad_u8* pDst = reinterpret_cast<color_quad_u8*>(pDst_pixels_rgba);
- const etc1_block& block = *static_cast<const etc1_block*>(pETC1_block);
-
- const bool diff_flag = block.get_diff_bit();
- const bool flip_flag = block.get_flip_bit();
- const uint table_index0 = block.get_inten_table(0);
- const uint table_index1 = block.get_inten_table(1);
-
- color_quad_u8 subblock_colors0[4];
- color_quad_u8 subblock_colors1[4];
- bool success = true;
-
- if (diff_flag)
- {
- const uint16 base_color5 = block.get_base5_color();
- const uint16 delta_color3 = block.get_delta3_color();
- etc1_block::get_diff_subblock_colors(subblock_colors0, base_color5, table_index0);
-
- if (!etc1_block::get_diff_subblock_colors(subblock_colors1, base_color5, delta_color3, table_index1))
- success = false;
- }
- else
- {
- const uint16 base_color4_0 = block.get_base4_color(0);
- etc1_block::get_abs_subblock_colors(subblock_colors0, base_color4_0, table_index0);
-
- const uint16 base_color4_1 = block.get_base4_color(1);
- etc1_block::get_abs_subblock_colors(subblock_colors1, base_color4_1, table_index1);
- }
-
- if (preserve_alpha)
- {
- if (flip_flag)
- {
- for (uint y = 0; y < 2; y++)
- {
- pDst[0].set_rgb(subblock_colors0[block.get_selector(0, y)]);
- pDst[1].set_rgb(subblock_colors0[block.get_selector(1, y)]);
- pDst[2].set_rgb(subblock_colors0[block.get_selector(2, y)]);
- pDst[3].set_rgb(subblock_colors0[block.get_selector(3, y)]);
- pDst += 4;
- }
-
- for (uint y = 2; y < 4; y++)
- {
- pDst[0].set_rgb(subblock_colors1[block.get_selector(0, y)]);
- pDst[1].set_rgb(subblock_colors1[block.get_selector(1, y)]);
- pDst[2].set_rgb(subblock_colors1[block.get_selector(2, y)]);
- pDst[3].set_rgb(subblock_colors1[block.get_selector(3, y)]);
- pDst += 4;
- }
- }
- else
- {
- for (uint y = 0; y < 4; y++)
- {
- pDst[0].set_rgb(subblock_colors0[block.get_selector(0, y)]);
- pDst[1].set_rgb(subblock_colors0[block.get_selector(1, y)]);
- pDst[2].set_rgb(subblock_colors1[block.get_selector(2, y)]);
- pDst[3].set_rgb(subblock_colors1[block.get_selector(3, y)]);
- pDst += 4;
- }
- }
- }
- else
- {
- if (flip_flag)
- {
- // 0000
- // 0000
- // 1111
- // 1111
- for (uint y = 0; y < 2; y++)
- {
- pDst[0] = subblock_colors0[block.get_selector(0, y)];
- pDst[1] = subblock_colors0[block.get_selector(1, y)];
- pDst[2] = subblock_colors0[block.get_selector(2, y)];
- pDst[3] = subblock_colors0[block.get_selector(3, y)];
- pDst += 4;
- }
-
- for (uint y = 2; y < 4; y++)
- {
- pDst[0] = subblock_colors1[block.get_selector(0, y)];
- pDst[1] = subblock_colors1[block.get_selector(1, y)];
- pDst[2] = subblock_colors1[block.get_selector(2, y)];
- pDst[3] = subblock_colors1[block.get_selector(3, y)];
- pDst += 4;
- }
- }
- else
- {
- // 0011
- // 0011
- // 0011
- // 0011
- for (uint y = 0; y < 4; y++)
- {
- pDst[0] = subblock_colors0[block.get_selector(0, y)];
- pDst[1] = subblock_colors0[block.get_selector(1, y)];
- pDst[2] = subblock_colors1[block.get_selector(2, y)];
- pDst[3] = subblock_colors1[block.get_selector(3, y)];
- pDst += 4;
- }
- }
- }
-
- return success;
- }
-
- struct etc1_solution_coordinates
- {
- inline etc1_solution_coordinates() :
- m_unscaled_color(0, 0, 0, 0),
- m_inten_table(0),
- m_color4(false)
- {
- }
-
- inline etc1_solution_coordinates(uint r, uint g, uint b, uint inten_table, bool color4) :
- m_unscaled_color(r, g, b, 255),
- m_inten_table(inten_table),
- m_color4(color4)
- {
- }
-
- inline etc1_solution_coordinates(const color_quad_u8& c, uint inten_table, bool color4) :
- m_unscaled_color(c),
- m_inten_table(inten_table),
- m_color4(color4)
- {
- }
-
- inline etc1_solution_coordinates(const etc1_solution_coordinates& other)
- {
- *this = other;
- }
-
- inline etc1_solution_coordinates& operator= (const etc1_solution_coordinates& rhs)
- {
- m_unscaled_color = rhs.m_unscaled_color;
- m_inten_table = rhs.m_inten_table;
- m_color4 = rhs.m_color4;
- return *this;
- }
-
- inline void clear()
- {
- m_unscaled_color.clear();
- m_inten_table = 0;
- m_color4 = false;
- }
-
- inline color_quad_u8 get_scaled_color() const
- {
- int br, bg, bb;
- if (m_color4)
- {
- br = m_unscaled_color.r | (m_unscaled_color.r << 4);
- bg = m_unscaled_color.g | (m_unscaled_color.g << 4);
- bb = m_unscaled_color.b | (m_unscaled_color.b << 4);
- }
- else
- {
- br = (m_unscaled_color.r >> 2) | (m_unscaled_color.r << 3);
- bg = (m_unscaled_color.g >> 2) | (m_unscaled_color.g << 3);
- bb = (m_unscaled_color.b >> 2) | (m_unscaled_color.b << 3);
- }
- return color_quad_u8(br, bg, bb);
- }
-
- inline void get_block_colors(color_quad_u8* pBlock_colors)
- {
- int br, bg, bb;
- if (m_color4)
- {
- br = m_unscaled_color.r | (m_unscaled_color.r << 4);
- bg = m_unscaled_color.g | (m_unscaled_color.g << 4);
- bb = m_unscaled_color.b | (m_unscaled_color.b << 4);
- }
- else
- {
- br = (m_unscaled_color.r >> 2) | (m_unscaled_color.r << 3);
- bg = (m_unscaled_color.g >> 2) | (m_unscaled_color.g << 3);
- bb = (m_unscaled_color.b >> 2) | (m_unscaled_color.b << 3);
- }
- const int* pInten_table = g_etc1_inten_tables[m_inten_table];
- pBlock_colors[0].set(br + pInten_table[0], bg + pInten_table[0], bb + pInten_table[0]);
- pBlock_colors[1].set(br + pInten_table[1], bg + pInten_table[1], bb + pInten_table[1]);
- pBlock_colors[2].set(br + pInten_table[2], bg + pInten_table[2], bb + pInten_table[2]);
- pBlock_colors[3].set(br + pInten_table[3], bg + pInten_table[3], bb + pInten_table[3]);
- }
-
- color_quad_u8 m_unscaled_color;
- uint m_inten_table;
- bool m_color4;
- };
-
- class etc1_optimizer
- {
- etc1_optimizer(const etc1_optimizer&);
- etc1_optimizer& operator= (const etc1_optimizer&);
-
- public:
- etc1_optimizer()
- {
- clear();
- }
-
- void clear()
- {
- m_pParams = NULL;
- m_pResult = NULL;
- m_pSorted_luma = NULL;
- m_pSorted_luma_indices = NULL;
- }
-
- struct params : etc1_pack_params
- {
- params()
- {
- clear();
- }
-
- params(const etc1_pack_params& base_params) :
- etc1_pack_params(base_params)
- {
- clear_optimizer_params();
- }
-
- void clear()
- {
- etc1_pack_params::clear();
- clear_optimizer_params();
- }
-
- void clear_optimizer_params()
- {
- m_num_src_pixels = 0;
- m_pSrc_pixels = 0;
-
- m_use_color4 = false;
- static const int s_default_scan_delta[] = { 0 };
- m_pScan_deltas = s_default_scan_delta;
- m_scan_delta_size = 1;
-
- m_base_color5.clear();
- m_constrain_against_base_color5 = false;
- }
-
- uint m_num_src_pixels;
- const color_quad_u8* m_pSrc_pixels;
-
- bool m_use_color4;
- const int* m_pScan_deltas;
- uint m_scan_delta_size;
-
- color_quad_u8 m_base_color5;
- bool m_constrain_against_base_color5;
- };
-
- struct results
- {
- uint64 m_error;
- color_quad_u8 m_block_color_unscaled;
- uint m_block_inten_table;
- uint m_n;
- uint8* m_pSelectors;
- bool m_block_color4;
-
- inline results& operator= (const results& rhs)
- {
- m_block_color_unscaled = rhs.m_block_color_unscaled;
- m_block_color4 = rhs.m_block_color4;
- m_block_inten_table = rhs.m_block_inten_table;
- m_error = rhs.m_error;
- RG_ETC1_ASSERT(m_n == rhs.m_n);
- memcpy(m_pSelectors, rhs.m_pSelectors, rhs.m_n);
- return *this;
- }
- };
-
- void init(const params& params, results& result);
- bool compute();
-
- private:
- struct potential_solution
- {
- potential_solution() : m_coords(), m_error(cUINT64_MAX), m_valid(false)
- {
- }
-
- etc1_solution_coordinates m_coords;
- uint8 m_selectors[8];
- uint64 m_error;
- bool m_valid;
-
- void clear()
- {
- m_coords.clear();
- m_error = cUINT64_MAX;
- m_valid = false;
- }
- };
-
- const params* m_pParams;
- results* m_pResult;
-
- int m_limit;
-
- vec3F m_avg_color;
- int m_br, m_bg, m_bb;
- uint16 m_luma[8];
- uint32 m_sorted_luma[2][8];
- const uint32* m_pSorted_luma_indices;
- uint32* m_pSorted_luma;
-
- uint8 m_selectors[8];
- uint8 m_best_selectors[8];
-
- potential_solution m_best_solution;
- potential_solution m_trial_solution;
- uint8 m_temp_selectors[8];
-
- bool evaluate_solution(const etc1_solution_coordinates& coords, potential_solution& trial_solution, potential_solution* pBest_solution);
- bool evaluate_solution_fast(const etc1_solution_coordinates& coords, potential_solution& trial_solution, potential_solution* pBest_solution);
- };
-
- bool etc1_optimizer::compute()
- {
- const uint n = m_pParams->m_num_src_pixels;
- const int scan_delta_size = m_pParams->m_scan_delta_size;
-
- // 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.
- // 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.
- for (int zdi = 0; zdi < scan_delta_size; zdi++)
- {
- const int zd = m_pParams->m_pScan_deltas[zdi];
- const int mbb = m_bb + zd;
- if (mbb < 0) continue; else if (mbb > m_limit) break;
-
- for (int ydi = 0; ydi < scan_delta_size; ydi++)
- {
- const int yd = m_pParams->m_pScan_deltas[ydi];
- const int mbg = m_bg + yd;
- if (mbg < 0) continue; else if (mbg > m_limit) break;
-
- for (int xdi = 0; xdi < scan_delta_size; xdi++)
- {
- const int xd = m_pParams->m_pScan_deltas[xdi];
- const int mbr = m_br + xd;
- if (mbr < 0) continue; else if (mbr > m_limit) break;
-
- etc1_solution_coordinates coords(mbr, mbg, mbb, 0, m_pParams->m_use_color4);
- if (m_pParams->m_quality == cHighQuality)
- {
- if (!evaluate_solution(coords, m_trial_solution, &m_best_solution))
- continue;
- }
- else
- {
- if (!evaluate_solution_fast(coords, m_trial_solution, &m_best_solution))
- continue;
- }
-
- // 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.
- // Now, for each component, attempt to refine the current solution by solving a simple linear equation. For example, for 4 colors:
- // The goal is:
- // 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
- // Rearranging this:
- // (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
- // (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
- // (pixel0 + pixel1 + pixel2 + pixel3) - 4*block_color - inten_table[selector0] - inten_table[selector1] - inten_table[selector2] - inten_table[selector3] = 0
- // (pixel0 + pixel1 + pixel2 + pixel3) - 4*block_color - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3]) = 0
- // (pixel0 + pixel1 + pixel2 + pixel3)/4 - block_color - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3])/4 = 0
- // block_color = (pixel0 + pixel1 + pixel2 + pixel3)/4 - (inten_table[selector0] + inten_table[selector1] + inten_table[selector2] + inten_table[selector3])/4
- // So what this means:
- // optimal_block_color = avg_input - avg_inten_delta
- // So the optimal block color can be computed by taking the average block color and subtracting the current average of the intensity delta.
- // Unfortunately, optimal_block_color must then be quantized to 555 or 444 so it's not always possible to improve matters using this formula.
- // Also, the above formula is for unclamped intensity deltas. The actual implementation takes into account clamping.
-
- const uint max_refinement_trials = (m_pParams->m_quality == cLowQuality) ? 2 : (((xd | yd | zd) == 0) ? 4 : 2);
- for (uint refinement_trial = 0; refinement_trial < max_refinement_trials; refinement_trial++)
- {
- const uint8* pSelectors = m_best_solution.m_selectors;
- const int* pInten_table = g_etc1_inten_tables[m_best_solution.m_coords.m_inten_table];
-
- int delta_sum_r = 0, delta_sum_g = 0, delta_sum_b = 0;
- const color_quad_u8 base_color(m_best_solution.m_coords.get_scaled_color());
- for (uint r = 0; r < n; r++)
- {
- const uint s = *pSelectors++;
- const int yd = pInten_table[s];
- // Compute actual delta being applied to each pixel, taking into account clamping.
- delta_sum_r += rg_etc1::clamp<int>(base_color.r + yd, 0, 255) - base_color.r;
- delta_sum_g += rg_etc1::clamp<int>(base_color.g + yd, 0, 255) - base_color.g;
- delta_sum_b += rg_etc1::clamp<int>(base_color.b + yd, 0, 255) - base_color.b;
- }
- if ((!delta_sum_r) && (!delta_sum_g) && (!delta_sum_b))
- break;
- const float avg_delta_r_f = static_cast<float>(delta_sum_r) / n;
- const float avg_delta_g_f = static_cast<float>(delta_sum_g) / n;
- const float avg_delta_b_f = static_cast<float>(delta_sum_b) / n;
- const int br1 = rg_etc1::clamp<int>(static_cast<uint>((m_avg_color[0] - avg_delta_r_f) * m_limit / 255.0f + .5f), 0, m_limit);
- const int bg1 = rg_etc1::clamp<int>(static_cast<uint>((m_avg_color[1] - avg_delta_g_f) * m_limit / 255.0f + .5f), 0, m_limit);
- const int bb1 = rg_etc1::clamp<int>(static_cast<uint>((m_avg_color[2] - avg_delta_b_f) * m_limit / 255.0f + .5f), 0, m_limit);
-
- bool skip = false;
-
- if ((mbr == br1) && (mbg == bg1) && (mbb == bb1))
- skip = true;
- else if ((br1 == m_best_solution.m_coords.m_unscaled_color.r) && (bg1 == m_best_solution.m_coords.m_unscaled_color.g) && (bb1 == m_best_solution.m_coords.m_unscaled_color.b))
- skip = true;
- else if ((m_br == br1) && (m_bg == bg1) && (m_bb == bb1))
- skip = true;
-
- if (skip)
- break;
-
- etc1_solution_coordinates coords1(br1, bg1, bb1, 0, m_pParams->m_use_color4);
- if (m_pParams->m_quality == cHighQuality)
- {
- if (!evaluate_solution(coords1, m_trial_solution, &m_best_solution))
- break;
- }
- else
- {
- if (!evaluate_solution_fast(coords1, m_trial_solution, &m_best_solution))
- break;
- }
-
- } // refinement_trial
-
- } // xdi
- } // ydi
- } // zdi
-
- if (!m_best_solution.m_valid)
- {
- m_pResult->m_error = cUINT32_MAX;
- return false;
- }
-
- const uint8* pSelectors = m_best_solution.m_selectors;
-
-#ifdef RG_ETC1_BUILD_DEBUG
- {
- color_quad_u8 block_colors[4];
- m_best_solution.m_coords.get_block_colors(block_colors);
-
- const color_quad_u8* pSrc_pixels = m_pParams->m_pSrc_pixels;
- uint64 actual_error = 0;
- for (uint i = 0; i < n; i++)
- actual_error += pSrc_pixels[i].squared_distance_rgb(block_colors[pSelectors[i]]);
-
- RG_ETC1_ASSERT(actual_error == m_best_solution.m_error);
- }
-#endif
-
- m_pResult->m_error = m_best_solution.m_error;
-
- m_pResult->m_block_color_unscaled = m_best_solution.m_coords.m_unscaled_color;
- m_pResult->m_block_color4 = m_best_solution.m_coords.m_color4;
-
- m_pResult->m_block_inten_table = m_best_solution.m_coords.m_inten_table;
- memcpy(m_pResult->m_pSelectors, pSelectors, n);
- m_pResult->m_n = n;
-
- return true;
- }
-
- void etc1_optimizer::init(const params& p, results& r)
- {
- // This version is hardcoded for 8 pixel subblocks.
- RG_ETC1_ASSERT(p.m_num_src_pixels == 8);
-
- m_pParams = &p;
- m_pResult = &r;
-
- const uint n = 8;
-
- m_limit = m_pParams->m_use_color4 ? 15 : 31;
-
- vec3F avg_color(0.0f);
-
- for (uint i = 0; i < n; i++)
- {
- const color_quad_u8& c = m_pParams->m_pSrc_pixels[i];
- const vec3F fc(c.r, c.g, c.b);
-
- avg_color += fc;
-
- m_luma[i] = static_cast<uint16>(c.r + c.g + c.b);
- m_sorted_luma[0][i] = i;
- }
- avg_color *= (1.0f / static_cast<float>(n));
- m_avg_color = avg_color;
-
- m_br = rg_etc1::clamp<int>(static_cast<uint>(m_avg_color[0] * m_limit / 255.0f + .5f), 0, m_limit);
- m_bg = rg_etc1::clamp<int>(static_cast<uint>(m_avg_color[1] * m_limit / 255.0f + .5f), 0, m_limit);
- m_bb = rg_etc1::clamp<int>(static_cast<uint>(m_avg_color[2] * m_limit / 255.0f + .5f), 0, m_limit);
-
- if (m_pParams->m_quality <= cMediumQuality)
- {
- m_pSorted_luma_indices = indirect_radix_sort(n, m_sorted_luma[0], m_sorted_luma[1], m_luma, 0, sizeof(m_luma[0]), false);
- m_pSorted_luma = m_sorted_luma[0];
- if (m_pSorted_luma_indices == m_sorted_luma[0])
- m_pSorted_luma = m_sorted_luma[1];
-
- for (uint i = 0; i < n; i++)
- m_pSorted_luma[i] = m_luma[m_pSorted_luma_indices[i]];
- }
-
- m_best_solution.m_coords.clear();
- m_best_solution.m_valid = false;
- m_best_solution.m_error = cUINT64_MAX;
- }
-
- bool etc1_optimizer::evaluate_solution(const etc1_solution_coordinates& coords, potential_solution& trial_solution, potential_solution* pBest_solution)
- {
- trial_solution.m_valid = false;
-
- if (m_pParams->m_constrain_against_base_color5)
- {
- const int dr = coords.m_unscaled_color.r - m_pParams->m_base_color5.r;
- const int dg = coords.m_unscaled_color.g - m_pParams->m_base_color5.g;
- const int db = coords.m_unscaled_color.b - m_pParams->m_base_color5.b;
-
- if ((rg_etc1::minimum(dr, dg, db) < cETC1ColorDeltaMin) || (rg_etc1::maximum(dr, dg, db) > cETC1ColorDeltaMax))
- return false;
- }
-
- const color_quad_u8 base_color(coords.get_scaled_color());
-
- const uint n = 8;
-
- trial_solution.m_error = cUINT64_MAX;
-
- for (uint inten_table = 0; inten_table < cETC1IntenModifierValues; inten_table++)
- {
- const int* pInten_table = g_etc1_inten_tables[inten_table];
-
- color_quad_u8 block_colors[4];
- for (uint s = 0; s < 4; s++)
- {
- const int yd = pInten_table[s];
- block_colors[s].set(base_color.r + yd, base_color.g + yd, base_color.b + yd, 0);
- }
-
- uint64 total_error = 0;
-
- const color_quad_u8* pSrc_pixels = m_pParams->m_pSrc_pixels;
- for (uint c = 0; c < n; c++)
- {
- const color_quad_u8& src_pixel = *pSrc_pixels++;
-
- uint best_selector_index = 0;
- uint best_error = rg_etc1::square(src_pixel.r - block_colors[0].r) + rg_etc1::square(src_pixel.g - block_colors[0].g) + rg_etc1::square(src_pixel.b - block_colors[0].b);
-
- uint trial_error = rg_etc1::square(src_pixel.r - block_colors[1].r) + rg_etc1::square(src_pixel.g - block_colors[1].g) + rg_etc1::square(src_pixel.b - block_colors[1].b);
- if (trial_error < best_error)
- {
- best_error = trial_error;
- best_selector_index = 1;
- }
-
- trial_error = rg_etc1::square(src_pixel.r - block_colors[2].r) + rg_etc1::square(src_pixel.g - block_colors[2].g) + rg_etc1::square(src_pixel.b - block_colors[2].b);
- if (trial_error < best_error)
- {
- best_error = trial_error;
- best_selector_index = 2;
- }
-
- trial_error = rg_etc1::square(src_pixel.r - block_colors[3].r) + rg_etc1::square(src_pixel.g - block_colors[3].g) + rg_etc1::square(src_pixel.b - block_colors[3].b);
- if (trial_error < best_error)
- {
- best_error = trial_error;
- best_selector_index = 3;
- }
-
- m_temp_selectors[c] = static_cast<uint8>(best_selector_index);
-
- total_error += best_error;
- if (total_error >= trial_solution.m_error)
- break;
- }
-
- if (total_error < trial_solution.m_error)
- {
- trial_solution.m_error = total_error;
- trial_solution.m_coords.m_inten_table = inten_table;
- memcpy(trial_solution.m_selectors, m_temp_selectors, 8);
- trial_solution.m_valid = true;
- }
- }
- trial_solution.m_coords.m_unscaled_color = coords.m_unscaled_color;
- trial_solution.m_coords.m_color4 = m_pParams->m_use_color4;
-
- bool success = false;
- if (pBest_solution)
- {
- if (trial_solution.m_error < pBest_solution->m_error)
- {
- *pBest_solution = trial_solution;
- success = true;
- }
- }
-
- return success;
- }
-
- bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coords, potential_solution& trial_solution, potential_solution* pBest_solution)
- {
- if (m_pParams->m_constrain_against_base_color5)
- {
- const int dr = coords.m_unscaled_color.r - m_pParams->m_base_color5.r;
- const int dg = coords.m_unscaled_color.g - m_pParams->m_base_color5.g;
- const int db = coords.m_unscaled_color.b - m_pParams->m_base_color5.b;
-
- if ((rg_etc1::minimum(dr, dg, db) < cETC1ColorDeltaMin) || (rg_etc1::maximum(dr, dg, db) > cETC1ColorDeltaMax))
- {
- trial_solution.m_valid = false;
- return false;
- }
- }
-
- const color_quad_u8 base_color(coords.get_scaled_color());
-
- const uint n = 8;
-
- trial_solution.m_error = cUINT64_MAX;
-
- for (int inten_table = cETC1IntenModifierValues - 1; inten_table >= 0; --inten_table)
- {
- const int* pInten_table = g_etc1_inten_tables[inten_table];
-
- uint block_inten[4];
- color_quad_u8 block_colors[4];
- for (uint s = 0; s < 4; s++)
- {
- const int yd = pInten_table[s];
- color_quad_u8 block_color(base_color.r + yd, base_color.g + yd, base_color.b + yd, 0);
- block_colors[s] = block_color;
- block_inten[s] = block_color.r + block_color.g + block_color.b;
- }
-
- // evaluate_solution_fast() enforces/assumesd a total ordering of the input colors along the intensity (1,1,1) axis to more quickly classify the inputs to selectors.
- // 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.
- // 0 1 2 3
- // 01 12 23
- const uint block_inten_midpoints[3] = { block_inten[0] + block_inten[1], block_inten[1] + block_inten[2], block_inten[2] + block_inten[3] };
-
- uint64 total_error = 0;
- const color_quad_u8* pSrc_pixels = m_pParams->m_pSrc_pixels;
- if ((m_pSorted_luma[n - 1] * 2) < block_inten_midpoints[0])
- {
- if (block_inten[0] > m_pSorted_luma[n - 1])
- {
- const uint min_error = labs(block_inten[0] - m_pSorted_luma[n - 1]);
- if (min_error >= trial_solution.m_error)
- continue;
- }
-
- memset(&m_temp_selectors[0], 0, n);
-
- for (uint c = 0; c < n; c++)
- total_error += block_colors[0].squared_distance_rgb(pSrc_pixels[c]);
- }
- else if ((m_pSorted_luma[0] * 2) >= block_inten_midpoints[2])
- {
- if (m_pSorted_luma[0] > block_inten[3])
- {
- const uint min_error = labs(m_pSorted_luma[0] - block_inten[3]);
- if (min_error >= trial_solution.m_error)
- continue;
- }
-
- memset(&m_temp_selectors[0], 3, n);
-
- for (uint c = 0; c < n; c++)
- total_error += block_colors[3].squared_distance_rgb(pSrc_pixels[c]);
- }
- else
- {
- uint cur_selector = 0, c;
- for (c = 0; c < n; c++)
- {
- const uint y = m_pSorted_luma[c];
- while ((y * 2) >= block_inten_midpoints[cur_selector])
- if (++cur_selector > 2)
- goto done;
- const uint sorted_pixel_index = m_pSorted_luma_indices[c];
- m_temp_selectors[sorted_pixel_index] = static_cast<uint8>(cur_selector);
- total_error += block_colors[cur_selector].squared_distance_rgb(pSrc_pixels[sorted_pixel_index]);
- }
-done:
- while (c < n)
- {
- const uint sorted_pixel_index = m_pSorted_luma_indices[c];
- m_temp_selectors[sorted_pixel_index] = 3;
- total_error += block_colors[3].squared_distance_rgb(pSrc_pixels[sorted_pixel_index]);
- ++c;
- }
- }
-
- if (total_error < trial_solution.m_error)
- {
- trial_solution.m_error = total_error;
- trial_solution.m_coords.m_inten_table = inten_table;
- memcpy(trial_solution.m_selectors, m_temp_selectors, n);
- trial_solution.m_valid = true;
- if (!total_error)
- break;
- }
- }
- trial_solution.m_coords.m_unscaled_color = coords.m_unscaled_color;
- trial_solution.m_coords.m_color4 = m_pParams->m_use_color4;
-
- bool success = false;
- if (pBest_solution)
- {
- if (trial_solution.m_error < pBest_solution->m_error)
- {
- *pBest_solution = trial_solution;
- success = true;
- }
- }
-
- return success;
- }
-
- static uint etc1_decode_value(uint diff, uint inten, uint selector, uint packed_c)
- {
- const uint limit = diff ? 32 : 16; limit;
- RG_ETC1_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < limit));
- int c;
- if (diff)
- c = (packed_c >> 2) | (packed_c << 3);
- else
- c = packed_c | (packed_c << 4);
- c += g_etc1_inten_tables[inten][selector];
- c = rg_etc1::clamp<int>(c, 0, 255);
- return c;
- }
-
- static inline int mul_8bit(int a, int b) { int t = a*b + 128; return (t + (t >> 8)) >> 8; }
-
- void pack_etc1_block_init()
- {
- for (uint diff = 0; diff < 2; diff++)
- {
- const uint limit = diff ? 32 : 16;
-
- for (uint inten = 0; inten < 8; inten++)
- {
- for (uint selector = 0; selector < 4; selector++)
- {
- const uint inverse_table_index = diff + (inten << 1) + (selector << 4);
- for (uint color = 0; color < 256; color++)
- {
- uint best_error = cUINT32_MAX, best_packed_c = 0;
- for (uint packed_c = 0; packed_c < limit; packed_c++)
- {
- int v = etc1_decode_value(diff, inten, selector, packed_c);
- uint err = labs(v - static_cast<int>(color));
- if (err < best_error)
- {
- best_error = err;
- best_packed_c = packed_c;
- if (!best_error)
- break;
- }
- }
- RG_ETC1_ASSERT(best_error <= 255);
- g_etc1_inverse_lookup[inverse_table_index][color] = static_cast<uint16>(best_packed_c | (best_error << 8));
- }
- }
- }
- }
-
- uint expand5[32];
- for(int i = 0; i < 32; i++)
- expand5[i] = (i << 3) | (i >> 2);
-
- for(int i = 0; i < 256 + 16; i++)
- {
- int v = clamp<int>(i - 8, 0, 255);
- g_quant5_tab[i] = static_cast<uint8>(expand5[mul_8bit(v,31)]);
- }
- }
-
- // Packs solid color blocks efficiently using a set of small precomputed tables.
- // 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.
- static uint64 pack_etc1_block_solid_color(etc1_block& block, const uint8* pColor, etc1_pack_params& pack_params)
- {
- pack_params;
- RG_ETC1_ASSERT(g_etc1_inverse_lookup[0][255]);
-
- static uint s_next_comp[4] = { 1, 2, 0, 1 };
-
- uint best_error = cUINT32_MAX, best_i = 0;
- int best_x = 0, best_packed_c1 = 0, best_packed_c2 = 0;
-
- // 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.
- for (uint i = 0; i < 3; i++)
- {
- const uint c1 = pColor[s_next_comp[i]], c2 = pColor[s_next_comp[i + 1]];
-
- const int delta_range = 1;
- for (int delta = -delta_range; delta <= delta_range; delta++)
- {
- const int c_plus_delta = rg_etc1::clamp<int>(pColor[i] + delta, 0, 255);
-
- const uint16* pTable;
- if (!c_plus_delta)
- pTable = g_color8_to_etc_block_config_0_255[0];
- else if (c_plus_delta == 255)
- pTable = g_color8_to_etc_block_config_0_255[1];
- else
- pTable = g_color8_to_etc_block_config_1_to_254[c_plus_delta - 1];
-
- do
- {
- const uint x = *pTable++;
-
-#ifdef RG_ETC1_BUILD_DEBUG
- const uint diff = x & 1;
- const uint inten = (x >> 1) & 7;
- const uint selector = (x >> 4) & 3;
- const uint p0 = (x >> 8) & 255;
- RG_ETC1_ASSERT(etc1_decode_value(diff, inten, selector, p0) == (uint)c_plus_delta);
-#endif
-
- const uint16* pInverse_table = g_etc1_inverse_lookup[x & 0xFF];
- uint16 p1 = pInverse_table[c1];
- uint16 p2 = pInverse_table[c2];
- const uint trial_error = rg_etc1::square(c_plus_delta - pColor[i]) + rg_etc1::square(p1 >> 8) + rg_etc1::square(p2 >> 8);
- if (trial_error < best_error)
- {
- best_error = trial_error;
- best_x = x;
- best_packed_c1 = p1 & 0xFF;
- best_packed_c2 = p2 & 0xFF;
- best_i = i;
- if (!best_error)
- goto found_perfect_match;
- }
- } while (*pTable != 0xFFFF);
- }
- }
-found_perfect_match:
-
- const uint diff = best_x & 1;
- const uint inten = (best_x >> 1) & 7;
-
- block.m_bytes[3] = static_cast<uint8>(((inten | (inten << 3)) << 2) | (diff << 1));
-
- const uint etc1_selector = g_selector_index_to_etc1[(best_x >> 4) & 3];
- *reinterpret_cast<uint16*>(&block.m_bytes[4]) = (etc1_selector & 2) ? 0xFFFF : 0;
- *reinterpret_cast<uint16*>(&block.m_bytes[6]) = (etc1_selector & 1) ? 0xFFFF : 0;
-
- const uint best_packed_c0 = (best_x >> 8) & 255;
- if (diff)
- {
- block.m_bytes[best_i] = static_cast<uint8>(best_packed_c0 << 3);
- block.m_bytes[s_next_comp[best_i]] = static_cast<uint8>(best_packed_c1 << 3);
- block.m_bytes[s_next_comp[best_i+1]] = static_cast<uint8>(best_packed_c2 << 3);
- }
- else
- {
- block.m_bytes[best_i] = static_cast<uint8>(best_packed_c0 | (best_packed_c0 << 4));
- block.m_bytes[s_next_comp[best_i]] = static_cast<uint8>(best_packed_c1 | (best_packed_c1 << 4));
- block.m_bytes[s_next_comp[best_i+1]] = static_cast<uint8>(best_packed_c2 | (best_packed_c2 << 4));
- }
-
- return best_error;
- }
-
- static uint pack_etc1_block_solid_color_constrained(
- etc1_optimizer::results& results,
- uint num_colors, const uint8* pColor,
- etc1_pack_params& pack_params,
- bool use_diff,
- const color_quad_u8* pBase_color5_unscaled)
- {
- RG_ETC1_ASSERT(g_etc1_inverse_lookup[0][255]);
-
- pack_params;
- static uint s_next_comp[4] = { 1, 2, 0, 1 };
-
- uint best_error = cUINT32_MAX, best_i = 0;
- int best_x = 0, best_packed_c1 = 0, best_packed_c2 = 0;
-
- // 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.
- for (uint i = 0; i < 3; i++)
- {
- const uint c1 = pColor[s_next_comp[i]], c2 = pColor[s_next_comp[i + 1]];
-
- const int delta_range = 1;
- for (int delta = -delta_range; delta <= delta_range; delta++)
- {
- const int c_plus_delta = rg_etc1::clamp<int>(pColor[i] + delta, 0, 255);
-
- const uint16* pTable;
- if (!c_plus_delta)
- pTable = g_color8_to_etc_block_config_0_255[0];
- else if (c_plus_delta == 255)
- pTable = g_color8_to_etc_block_config_0_255[1];
- else
- pTable = g_color8_to_etc_block_config_1_to_254[c_plus_delta - 1];
-
- do
- {
- const uint x = *pTable++;
- const uint diff = x & 1;
- if (static_cast<uint>(use_diff) != diff)
- {
- if (*pTable == 0xFFFF)
- break;
- continue;
- }
-
- if ((diff) && (pBase_color5_unscaled))
- {
- const int p0 = (x >> 8) & 255;
- int delta = p0 - static_cast<int>(pBase_color5_unscaled->c[i]);
- if ((delta < cETC1ColorDeltaMin) || (delta > cETC1ColorDeltaMax))
- {
- if (*pTable == 0xFFFF)
- break;
- continue;
- }
- }
-
-#ifdef RG_ETC1_BUILD_DEBUG
- {
- const uint inten = (x >> 1) & 7;
- const uint selector = (x >> 4) & 3;
- const uint p0 = (x >> 8) & 255;
- RG_ETC1_ASSERT(etc1_decode_value(diff, inten, selector, p0) == (uint)c_plus_delta);
- }
-#endif
-
- const uint16* pInverse_table = g_etc1_inverse_lookup[x & 0xFF];
- uint16 p1 = pInverse_table[c1];
- uint16 p2 = pInverse_table[c2];
-
- if ((diff) && (pBase_color5_unscaled))
- {
- int delta1 = (p1 & 0xFF) - static_cast<int>(pBase_color5_unscaled->c[s_next_comp[i]]);
- int delta2 = (p2 & 0xFF) - static_cast<int>(pBase_color5_unscaled->c[s_next_comp[i + 1]]);
- if ((delta1 < cETC1ColorDeltaMin) || (delta1 > cETC1ColorDeltaMax) || (delta2 < cETC1ColorDeltaMin) || (delta2 > cETC1ColorDeltaMax))
- {
- if (*pTable == 0xFFFF)
- break;
- continue;
- }
- }
-
- const uint trial_error = rg_etc1::square(c_plus_delta - pColor[i]) + rg_etc1::square(p1 >> 8) + rg_etc1::square(p2 >> 8);
- if (trial_error < best_error)
- {
- best_error = trial_error;
- best_x = x;
- best_packed_c1 = p1 & 0xFF;
- best_packed_c2 = p2 & 0xFF;
- best_i = i;
- if (!best_error)
- goto found_perfect_match;
- }
- } while (*pTable != 0xFFFF);
- }
- }
-found_perfect_match:
-
- if (best_error == cUINT32_MAX)
- return best_error;
-
- best_error *= num_colors;
-
- results.m_n = num_colors;
- results.m_block_color4 = !(best_x & 1);
- results.m_block_inten_table = (best_x >> 1) & 7;
- memset(results.m_pSelectors, (best_x >> 4) & 3, num_colors);
-
- const uint best_packed_c0 = (best_x >> 8) & 255;
- results.m_block_color_unscaled[best_i] = static_cast<uint8>(best_packed_c0);
- results.m_block_color_unscaled[s_next_comp[best_i]] = static_cast<uint8>(best_packed_c1);
- results.m_block_color_unscaled[s_next_comp[best_i + 1]] = static_cast<uint8>(best_packed_c2);
- results.m_error = best_error;
-
- return best_error;
- }
-
- // Function originally from RYG's public domain real-time DXT1 compressor, modified for 555.
- static void dither_block_555(color_quad_u8* dest, const color_quad_u8* block)
- {
- int err[8],*ep1 = err,*ep2 = err+4;
- uint8 *quant = g_quant5_tab+8;
-
- memset(dest, 0xFF, sizeof(color_quad_u8)*16);
-
- // process channels seperately
- for(int ch=0;ch<3;ch++)
- {
- uint8* bp = (uint8*)block;
- uint8* dp = (uint8*)dest;
-
- bp += ch; dp += ch;
-
- memset(err,0, sizeof(err));
- for(int y = 0; y < 4; y++)
- {
- // pixel 0
- dp[ 0] = quant[bp[ 0] + ((3*ep2[1] + 5*ep2[0]) >> 4)];
- ep1[0] = bp[ 0] - dp[ 0];
-
- // pixel 1
- dp[ 4] = quant[bp[ 4] + ((7*ep1[0] + 3*ep2[2] + 5*ep2[1] + ep2[0]) >> 4)];
- ep1[1] = bp[ 4] - dp[ 4];
-
- // pixel 2
- dp[ 8] = quant[bp[ 8] + ((7*ep1[1] + 3*ep2[3] + 5*ep2[2] + ep2[1]) >> 4)];
- ep1[2] = bp[ 8] - dp[ 8];
-
- // pixel 3
- dp[12] = quant[bp[12] + ((7*ep1[2] + 5*ep2[3] + ep2[2]) >> 4)];
- ep1[3] = bp[12] - dp[12];
-
- // advance to next line
- int* tmp = ep1; ep1 = ep2; ep2 = tmp;
- bp += 16;
- dp += 16;
- }
- }
- }
-
- unsigned int pack_etc1_block(void* pETC1_block, const unsigned int* pSrc_pixels_rgba, etc1_pack_params& pack_params)
- {
- const color_quad_u8* pSrc_pixels = reinterpret_cast<const color_quad_u8*>(pSrc_pixels_rgba);
- etc1_block& dst_block = *static_cast<etc1_block*>(pETC1_block);
-
-#ifdef RG_ETC1_BUILD_DEBUG
- // Ensure all alpha values are 0xFF.
- for (uint i = 0; i < 16; i++)
- {
- RG_ETC1_ASSERT(pSrc_pixels[i].a == 255);
- }
-#endif
-
- color_quad_u8 src_pixel0(pSrc_pixels[0]);
-
- // Check for solid block.
- const uint32 first_pixel_u32 = pSrc_pixels->m_u32;
- int r;
- for (r = 15; r >= 1; --r)
- if (pSrc_pixels[r].m_u32 != first_pixel_u32)
- break;
- if (!r)
- return static_cast<unsigned int>(16 * pack_etc1_block_solid_color(dst_block, &pSrc_pixels[0].r, pack_params));
-
- color_quad_u8 dithered_pixels[16];
- if (pack_params.m_dithering)
- {
- dither_block_555(dithered_pixels, pSrc_pixels);
- pSrc_pixels = dithered_pixels;
- }
-
- etc1_optimizer optimizer;
-
- uint64 best_error = cUINT64_MAX;
- uint best_flip = false, best_use_color4 = false;
-
- uint8 best_selectors[2][8];
- etc1_optimizer::results best_results[2];
- for (uint i = 0; i < 2; i++)
- {
- best_results[i].m_n = 8;
- best_results[i].m_pSelectors = best_selectors[i];
- }
-
- uint8 selectors[3][8];
- etc1_optimizer::results results[3];
-
- for (uint i = 0; i < 3; i++)
- {
- results[i].m_n = 8;
- results[i].m_pSelectors = selectors[i];
- }
-
- color_quad_u8 subblock_pixels[8];
-
- etc1_optimizer::params params(pack_params);
- params.m_num_src_pixels = 8;
- params.m_pSrc_pixels = subblock_pixels;
-
- for (uint flip = 0; flip < 2; flip++)
- {
- for (uint use_color4 = 0; use_color4 < 2; use_color4++)
- {
- uint64 trial_error = 0;
-
- uint subblock;
- for (subblock = 0; subblock < 2; subblock++)
- {
- if (flip)
- memcpy(subblock_pixels, pSrc_pixels + subblock * 8, sizeof(color_quad_u8) * 8);
- else
- {
- const color_quad_u8* pSrc_col = pSrc_pixels + subblock * 2;
- subblock_pixels[0] = pSrc_col[0]; subblock_pixels[1] = pSrc_col[4]; subblock_pixels[2] = pSrc_col[8]; subblock_pixels[3] = pSrc_col[12];
- subblock_pixels[4] = pSrc_col[1]; subblock_pixels[5] = pSrc_col[5]; subblock_pixels[6] = pSrc_col[9]; subblock_pixels[7] = pSrc_col[13];
- }
-
- results[2].m_error = cUINT64_MAX;
- if ((params.m_quality >= cMediumQuality) && ((subblock) || (use_color4)))
- {
- const uint32 subblock_pixel0_u32 = subblock_pixels[0].m_u32;
- for (r = 7; r >= 1; --r)
- if (subblock_pixels[r].m_u32 != subblock_pixel0_u32)
- break;
- if (!r)
- {
- pack_etc1_block_solid_color_constrained(results[2], 8, &subblock_pixels[0].r, pack_params, !use_color4, (subblock && !use_color4) ? &results[0].m_block_color_unscaled : NULL);
- }
- }
-
- params.m_use_color4 = (use_color4 != 0);
- params.m_constrain_against_base_color5 = false;
-
- if ((!use_color4) && (subblock))
- {
- params.m_constrain_against_base_color5 = true;
- params.m_base_color5 = results[0].m_block_color_unscaled;
- }
-
- if (params.m_quality == cHighQuality)
- {
- static const int s_scan_delta_0_to_4[] = { -4, -3, -2, -1, 0, 1, 2, 3, 4 };
- params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_0_to_4);
- params.m_pScan_deltas = s_scan_delta_0_to_4;
- }
- else if (params.m_quality == cMediumQuality)
- {
- static const int s_scan_delta_0_to_1[] = { -1, 0, 1 };
- params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_0_to_1);
- params.m_pScan_deltas = s_scan_delta_0_to_1;
- }
- else
- {
- static const int s_scan_delta_0[] = { 0 };
- params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_0);
- params.m_pScan_deltas = s_scan_delta_0;
- }
-
- optimizer.init(params, results[subblock]);
- if (!optimizer.compute())
- break;
-
- if (params.m_quality >= cMediumQuality)
- {
- // TODO: Fix fairly arbitrary/unrefined thresholds that control how far away to scan for potentially better solutions.
- const uint refinement_error_thresh0 = 3000;
- const uint refinement_error_thresh1 = 6000;
- if (results[subblock].m_error > refinement_error_thresh0)
- {
- if (params.m_quality == cMediumQuality)
- {
- static const int s_scan_delta_2_to_3[] = { -3, -2, 2, 3 };
- params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_2_to_3);
- params.m_pScan_deltas = s_scan_delta_2_to_3;
- }
- else
- {
- static const int s_scan_delta_5_to_5[] = { -5, 5 };
- static const int s_scan_delta_5_to_8[] = { -8, -7, -6, -5, 5, 6, 7, 8 };
- if (results[subblock].m_error > refinement_error_thresh1)
- {
- params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_5_to_8);
- params.m_pScan_deltas = s_scan_delta_5_to_8;
- }
- else
- {
- params.m_scan_delta_size = RG_ETC1_ARRAY_SIZE(s_scan_delta_5_to_5);
- params.m_pScan_deltas = s_scan_delta_5_to_5;
- }
- }
-
- if (!optimizer.compute())
- break;
- }
-
- if (results[2].m_error < results[subblock].m_error)
- results[subblock] = results[2];
- }
-
- trial_error += results[subblock].m_error;
- if (trial_error >= best_error)
- break;
- }
-
- if (subblock < 2)
- continue;
-
- best_error = trial_error;
- best_results[0] = results[0];
- best_results[1] = results[1];
- best_flip = flip;
- best_use_color4 = use_color4;
-
- } // use_color4
-
- } // flip
-
- int dr = best_results[1].m_block_color_unscaled.r - best_results[0].m_block_color_unscaled.r;
- int dg = best_results[1].m_block_color_unscaled.g - best_results[0].m_block_color_unscaled.g;
- int db = best_results[1].m_block_color_unscaled.b - best_results[0].m_block_color_unscaled.b;
- RG_ETC1_ASSERT(best_use_color4 || (rg_etc1::minimum(dr, dg, db) >= cETC1ColorDeltaMin) && (rg_etc1::maximum(dr, dg, db) <= cETC1ColorDeltaMax));
-
- if (best_use_color4)
- {
- dst_block.m_bytes[0] = static_cast<uint8>(best_results[1].m_block_color_unscaled.r | (best_results[0].m_block_color_unscaled.r << 4));
- dst_block.m_bytes[1] = static_cast<uint8>(best_results[1].m_block_color_unscaled.g | (best_results[0].m_block_color_unscaled.g << 4));
- dst_block.m_bytes[2] = static_cast<uint8>(best_results[1].m_block_color_unscaled.b | (best_results[0].m_block_color_unscaled.b << 4));
- }
- else
- {
- if (dr < 0) dr += 8; dst_block.m_bytes[0] = static_cast<uint8>((best_results[0].m_block_color_unscaled.r << 3) | dr);
- if (dg < 0) dg += 8; dst_block.m_bytes[1] = static_cast<uint8>((best_results[0].m_block_color_unscaled.g << 3) | dg);
- if (db < 0) db += 8; dst_block.m_bytes[2] = static_cast<uint8>((best_results[0].m_block_color_unscaled.b << 3) | db);
- }
-
- dst_block.m_bytes[3] = static_cast<uint8>( (best_results[1].m_block_inten_table << 2) | (best_results[0].m_block_inten_table << 5) | ((~best_use_color4 & 1) << 1) | best_flip );
-
- uint selector0 = 0, selector1 = 0;
- if (best_flip)
- {
- // flipped:
- // { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 },
- // { 0, 1 }, { 1, 1 }, { 2, 1 }, { 3, 1 }
- //
- // { 0, 2 }, { 1, 2 }, { 2, 2 }, { 3, 2 },
- // { 0, 3 }, { 1, 3 }, { 2, 3 }, { 3, 3 }
- const uint8* pSelectors0 = best_results[0].m_pSelectors;
- const uint8* pSelectors1 = best_results[1].m_pSelectors;
- for (int x = 3; x >= 0; --x)
- {
- uint b;
- b = g_selector_index_to_etc1[pSelectors1[4 + x]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
-
- b = g_selector_index_to_etc1[pSelectors1[x]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
-
- b = g_selector_index_to_etc1[pSelectors0[4 + x]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
-
- b = g_selector_index_to_etc1[pSelectors0[x]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
- }
- }
- else
- {
- // non-flipped:
- // { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
- // { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }
- //
- // { 2, 0 }, { 2, 1 }, { 2, 2 }, { 2, 3 },
- // { 3, 0 }, { 3, 1 }, { 3, 2 }, { 3, 3 }
- for (int subblock = 1; subblock >= 0; --subblock)
- {
- const uint8* pSelectors = best_results[subblock].m_pSelectors + 4;
- for (uint i = 0; i < 2; i++)
- {
- uint b;
- b = g_selector_index_to_etc1[pSelectors[3]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
-
- b = g_selector_index_to_etc1[pSelectors[2]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
-
- b = g_selector_index_to_etc1[pSelectors[1]];
- selector0 = (selector0 << 1) | (b & 1); selector1 = (selector1 << 1) | (b >> 1);
-
- b = g_selector_index_to_etc1[pSelectors[0]];
- selector0 = (selector0 << 1) | (b & 1);selector1 = (selector1 << 1) | (b >> 1);
-
- pSelectors -= 4;
- }
- }
- }
-
- dst_block.m_bytes[4] = static_cast<uint8>(selector1 >> 8); dst_block.m_bytes[5] = static_cast<uint8>(selector1 & 0xFF);
- dst_block.m_bytes[6] = static_cast<uint8>(selector0 >> 8); dst_block.m_bytes[7] = static_cast<uint8>(selector0 & 0xFF);
-
- return static_cast<unsigned int>(best_error);
- }
-
-} // namespace rg_etc1
projects / platform / upstream / efl.git / commitdiff