diff --git a/basisu_enc.cpp b/basisu_enc.cpp
index e5c63f5..7057c65 100644
--- a/basisu_enc.cpp
+++ b/basisu_enc.cpp
@@ -53,7 +53,6 @@
 	// Encoder library initialization (just call once at startup)
 	void basisu_encoder_init()
 	{
-		pack_etc1_block_init();
 		basist::basisu_transcoder_init();
 	}
 
diff --git a/basisu_etc.cpp b/basisu_etc.cpp
index 4ccb3a0..244f1d2 100644
--- a/basisu_etc.cpp
+++ b/basisu_etc.cpp
@@ -117,135 +117,6 @@
 		}
 	};
 
-	// 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_t 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_t 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_t 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 },
-	};
-
 	uint16_t etc_block::pack_color5(const color_rgba& color, bool scaled, uint32_t bias)
 	{
 		return pack_color5(color.r, color.g, color.b, scaled, bias);
@@ -1200,770 +1071,4 @@
 		return success;
 	}
 
-	static uint32_t etc1_decode_value(uint32_t diff, uint32_t inten, uint32_t selector, uint32_t packed_c)
-	{
-		const uint32_t limit = diff ? 32 : 16; limit;
-		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 = clamp<int>(c, 0, 255);
-		return c;
-	}
-
-	void pack_etc1_block_init()
-	{
-		for (uint32_t diff = 0; diff < 2; diff++)
-		{
-			const uint32_t limit = diff ? 32 : 16;
-
-			for (uint32_t inten = 0; inten < 8; inten++)
-			{
-				for (uint32_t selector = 0; selector < 4; selector++)
-				{
-					const uint32_t inverse_table_index = diff + (inten << 1) + (selector << 4);
-					for (uint32_t color = 0; color < 256; color++)
-					{
-						uint32_t best_error = UINT32_MAX, best_packed_c = 0;
-						for (uint32_t packed_c = 0; packed_c < limit; packed_c++)
-						{
-							int v = etc1_decode_value(diff, inten, selector, packed_c);
-							uint32_t err = iabs(v - static_cast<int>(color));
-							if (err < best_error)
-							{
-								best_error = err;
-								best_packed_c = packed_c;
-								if (!best_error)
-									break;
-							}
-						}
-						assert(best_error <= 255);
-						g_etc1_inverse_lookup[inverse_table_index][color] = static_cast<uint16_t>(best_packed_c | (best_error << 8));
-					}
-				}
-			}
-		}
-	}
-
-	// 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.
-	uint64_t pack_etc1_block_solid_color(etc_block& block, const uint8_t* pColor, bool diff_only)
-	{
-		assert(g_etc1_inverse_lookup[0][255]);
-
-		static uint32_t s_next_comp[4] = { 1, 2, 0, 1 };
-
-		uint32_t best_error = UINT32_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 (uint32_t i = 0; i < 3; i++)
-		{
-			const uint32_t 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 = clamp<int>(pColor[i] + delta, 0, 255);
-
-				const uint16_t* 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 uint32_t x = *pTable++;
-					
-					const bool diff = (x & 1) != 0;
-					if ((diff_only) && (!diff))
-						continue;
-
-#ifdef BASISU_BUILD_DEBUG
-					const uint32_t diff = x & 1;
-					const uint32_t inten = (x >> 1) & 7;
-					const uint32_t selector = (x >> 4) & 3;
-					const uint32_t p0 = (x >> 8) & 255;
-					assert(etc1_decode_value(diff, inten, selector, p0) == (uint32_t)c_plus_delta);
-#endif
-
-					const uint16_t* pInverse_table = g_etc1_inverse_lookup[x & 0xFF];
-					uint16_t p1 = pInverse_table[c1];
-					uint16_t p2 = pInverse_table[c2];
-					const uint32_t 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 == UINT32_MAX)
-			return UINT64_MAX;
-
-		const uint32_t diff = best_x & 1;
-		const uint32_t inten = (best_x >> 1) & 7;
-
-		block.m_bytes[3] = static_cast<uint8_t>(((inten | (inten << 3)) << 2) | (diff << 1));
-
-		const uint32_t etc1_selector = g_selector_index_to_etc1[(best_x >> 4) & 3];
-		*reinterpret_cast<uint16_t*>(&block.m_bytes[4]) = (etc1_selector & 2) ? 0xFFFF : 0;
-		*reinterpret_cast<uint16_t*>(&block.m_bytes[6]) = (etc1_selector & 1) ? 0xFFFF : 0;
-
-		const uint32_t best_packed_c0 = (best_x >> 8) & 255;
-		if (diff)
-		{
-			block.m_bytes[best_i] = static_cast<uint8_t>(best_packed_c0 << 3);
-			block.m_bytes[s_next_comp[best_i]] = static_cast<uint8_t>(best_packed_c1 << 3);
-			block.m_bytes[s_next_comp[best_i + 1]] = static_cast<uint8_t>(best_packed_c2 << 3);
-		}
-		else
-		{
-			block.m_bytes[best_i] = static_cast<uint8_t>(best_packed_c0 | (best_packed_c0 << 4));
-			block.m_bytes[s_next_comp[best_i]] = static_cast<uint8_t>(best_packed_c1 | (best_packed_c1 << 4));
-			block.m_bytes[s_next_comp[best_i + 1]] = static_cast<uint8_t>(best_packed_c2 | (best_packed_c2 << 4));
-		}
-
-		return best_error;
-	}
-
-	static uint32_t pack_etc1_block_solid_color_constrained(
-		etc1_optimizer::results& results,
-		uint32_t num_colors, const uint8_t *pColor,
-		bool use_diff,
-		const color_rgba* pBase_color5_unscaled)
-	{
-		assert(g_etc1_inverse_lookup[0][255]);
-
-		static uint32_t s_next_comp[4] = { 1, 2, 0, 1 };
-
-		uint32_t best_error = UINT32_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 (uint32_t i = 0; i < 3; i++)
-		{
-			const uint32_t 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 = clamp<int>(pColor[i] + delta, 0, 255);
-
-				const uint16_t* 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 uint32_t x = *pTable++;
-					const uint32_t diff = x & 1;
-					if (static_cast<uint32_t>(use_diff) != diff)
-					{
-						if (*pTable == 0xFFFF)
-							break;
-						continue;
-					}
-
-					if ((diff) && (pBase_color5_unscaled))
-					{
-						const int p0 = (x >> 8) & 255;
-						int delta_temp = p0 - static_cast<int>(pBase_color5_unscaled->m_comps[i]);
-						if ((delta_temp < cETC1ColorDeltaMin) || (delta_temp > cETC1ColorDeltaMax))
-						{
-							if (*pTable == 0xFFFF)
-								break;
-							continue;
-						}
-					}
-
-#ifdef BASISU_BUILD_DEBUG
-					{
-						const uint32_t inten = (x >> 1) & 7;
-						const uint32_t selector = (x >> 4) & 3;
-						const uint32_t p0 = (x >> 8) & 255;
-						assert(etc1_decode_value(diff, inten, selector, p0) == (uint32_t)c_plus_delta);
-					}
-#endif
-
-					const uint16_t* pInverse_table = g_etc1_inverse_lookup[x & 0xFF];
-					uint16_t p1 = pInverse_table[c1];
-					uint16_t p2 = pInverse_table[c2];
-
-					if ((diff) && (pBase_color5_unscaled))
-					{
-						int delta1 = (p1 & 0xFF) - static_cast<int>(pBase_color5_unscaled->m_comps[s_next_comp[i]]);
-						int delta2 = (p2 & 0xFF) - static_cast<int>(pBase_color5_unscaled->m_comps[s_next_comp[i + 1]]);
-						if ((delta1 < cETC1ColorDeltaMin) || (delta1 > cETC1ColorDeltaMax) || (delta2 < cETC1ColorDeltaMin) || (delta2 > cETC1ColorDeltaMax))
-						{
-							if (*pTable == 0xFFFF)
-								break;
-							continue;
-						}
-					}
-
-					const uint32_t 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 == UINT32_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 uint32_t best_packed_c0 = (best_x >> 8) & 255;
-		results.m_block_color_unscaled[best_i] = static_cast<uint8_t>(best_packed_c0);
-		results.m_block_color_unscaled[s_next_comp[best_i]] = static_cast<uint8_t>(best_packed_c1);
-		results.m_block_color_unscaled[s_next_comp[best_i + 1]] = static_cast<uint8_t>(best_packed_c2);
-		results.m_error = best_error;
-
-		return best_error;
-	}
-
-	static bool invoke_optimizer(etc1_optimizer::results &results, pack_etc1_block_context &context, etc1_optimizer::params &params, const basis_etc1_pack_params &pack_params)
-	{
-		if (!pack_params.m_cluster_fit)
-		{
-			if (params.m_quality >= cETCQualitySlow)
-			{
-				static const int s_scan_delta_0_to_4[] = { -4, -3, -2, -1, 0, 1, 2, 3, 4 };
-				params.m_scan_delta_size = BASISU_ARRAY_SIZE(s_scan_delta_0_to_4);
-				params.m_pScan_deltas = s_scan_delta_0_to_4;
-			}
-			else if (params.m_quality == cETCQualityMedium)
-			{
-				static const int s_scan_delta_0_to_1[] = { -1, 0, 1 };
-				params.m_scan_delta_size = BASISU_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 = BASISU_ARRAY_SIZE(s_scan_delta_0);
-				params.m_pScan_deltas = s_scan_delta_0;
-			}
-		}
-
-		context.m_optimizer.init(params, results);
-
-		bool optimizer_succeeded = context.m_optimizer.compute();
-
-#if BASISU_DEBUG_ETC_ENCODER
-		printf("Optimizer succeeded: %u, First optimization pass error: %I64u\n", optimizer_succeeded, results);
-#endif
-
-		if (!pack_params.m_cluster_fit)
-		{
-			// Fairly arbitrary/unrefined thresholds that control how far away to scan for potentially better solutions.
-			const uint32_t refinement_error_thresh0 = 3000 * (results.m_n / 8);
-			const uint32_t refinement_error_thresh1 = 6000 * (results.m_n / 8);
-			if ((params.m_quality >= cETCQualityMedium) && ((results.m_error > refinement_error_thresh0) || (!optimizer_succeeded)))
-			{
-				if (params.m_quality == cETCQualityMedium)
-				{
-					static const int s_scan_delta_2_to_3[] = { -3, -2, 2, 3 };
-					params.m_scan_delta_size = BASISU_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.m_error > refinement_error_thresh1)
-					{
-						params.m_scan_delta_size = BASISU_ARRAY_SIZE(s_scan_delta_5_to_8);
-						params.m_pScan_deltas = s_scan_delta_5_to_8;
-					}
-					else
-					{
-						params.m_scan_delta_size = BASISU_ARRAY_SIZE(s_scan_delta_5_to_5);
-						params.m_pScan_deltas = s_scan_delta_5_to_5;
-					}
-				}
-
-				if (context.m_optimizer.compute())
-					optimizer_succeeded = true;
-
-#if BASISU_DEBUG_ETC_ENCODER
-				printf("Second optimization pass error: %I64u\n", results.m_error);
-#endif
-			}
-		}
-
-		return optimizer_succeeded;
-	}
-
-	static vec3F color_quad_u8_to_f(const color_rgba& c)
-	{
-		return vec3F(static_cast<float>(c.r), static_cast<float>(c.g), static_cast<float>(c.b));
-	}
-
-	// Returns distance from color c to the gray line going through color d.
-	static inline float gray_distance2(const color_rgba& c, const vec3F& d)
-	{
-		float gray_dist = static_cast<float>(((c.r - d[0]) + (c.g - d[1]) + (c.b - d[2]))) * (1.0f / 3.0f);
-
-		// Project onto the gray line
-		float gray_point_r = clamp(d[0] + gray_dist, 0.0f, 255.0f);
-		float gray_point_g = clamp(d[1] + gray_dist, 0.0f, 255.0f);
-		float gray_point_b = clamp(d[2] + gray_dist, 0.0f, 255.0f);
-
-		// Compute distance^2
-		float dist_to_gray_point_r = static_cast<float>(c.r) - gray_point_r;
-		float dist_to_gray_point_g = static_cast<float>(c.g) - gray_point_g;
-		float dist_to_gray_point_b = static_cast<float>(c.b) - gray_point_b;
-
-		return dist_to_gray_point_r * dist_to_gray_point_r + dist_to_gray_point_g * dist_to_gray_point_g + dist_to_gray_point_b * dist_to_gray_point_b;
-	}
-
-	bool pack_etc1_estimate_flipped(const color_rgba* pSrc_pixels)
-	{
-		vec3F sums[2][2];
-
-#define GET_XY(x, y) color_quad_u8_to_f(pSrc_pixels[(x) + ((y) * 4)])
-
-		sums[0][0] = GET_XY(0, 0) + GET_XY(0, 1) + GET_XY(1, 0) + GET_XY(1, 1);
-		sums[1][0] = GET_XY(2, 0) + GET_XY(2, 1) + GET_XY(3, 0) + GET_XY(3, 1);
-		sums[0][1] = GET_XY(0, 2) + GET_XY(0, 3) + GET_XY(1, 2) + GET_XY(1, 3);
-		sums[1][1] = GET_XY(2, 2) + GET_XY(2, 3) + GET_XY(3, 2) + GET_XY(3, 3);
-
-		vec3F upper_avg((sums[0][0] + sums[1][0]) * (1.0f / 8.0f));
-		vec3F lower_avg((sums[0][1] + sums[1][1]) * (1.0f / 8.0f));
-		vec3F left_avg((sums[0][0] + sums[0][1]) * (1.0f / 8.0f));
-		vec3F right_avg((sums[1][0] + sums[1][1]) * (1.0f / 8.0f));
-
-#undef GET_XY
-#define GET_XY(x, y, a) gray_distance2(pSrc_pixels[(x) + ((y) * 4)], a)
-
-		float upper_gray_dist = 0.0f, lower_gray_dist = 0.0f, left_gray_dist = 0.0f, right_gray_dist = 0.0f;
-		for (uint32_t i = 0; i < 4; i++)
-		{
-			for (uint32_t j = 0; j < 2; j++)
-			{
-				upper_gray_dist += GET_XY(i, j, upper_avg);
-				lower_gray_dist += GET_XY(i, 2 + j, lower_avg);
-				left_gray_dist += GET_XY(j, i, left_avg);
-				right_gray_dist += GET_XY(2 + j, i, right_avg);
-			}
-		}
-
-#undef GET_XY
-
-		float upper_lower_sum = upper_gray_dist + lower_gray_dist;
-		float left_right_sum = left_gray_dist + right_gray_dist;
-
-		return upper_lower_sum < left_right_sum;
-	}
-		
-	uint64_t pack_etc1_block(etc_block& dst_block, const color_rgba* pSrc_pixels, basis_etc1_pack_params& pack_params, pack_etc1_block_context& context, const uint8_t* pForce_selectors)
-	{
-#if BASISU_DEBUG_ETC_ENCODER
-		printf("** Start of block\n");
-#endif
-
-		color_rgba src_pixel0(pSrc_pixels[0]);
-
-		if (!pForce_selectors)
-		{
-			int r;
-			for (r = 15; r >= 1; --r)
-				if ((pSrc_pixels[r].r != src_pixel0.r) || (pSrc_pixels[r].g != src_pixel0.g) || (pSrc_pixels[r].b != src_pixel0.b))
-					break;
-			if (!r)
-			{
-#if BASISU_DEBUG_ETC_ENCODER
-				printf("** Block is a single solid color\n");
-#endif
-				uint64_t err = 16 * pack_etc1_block_solid_color(dst_block, &pSrc_pixels[0].r);
-				dst_block.set_flip_bit(true);
-				return err;
-			}
-		}
-				
-		uint64_t best_error = UINT64_MAX;
-		uint32_t best_flip = false, best_use_color4 = false, best_is_subset = false;
-
-		uint8_t best_selectors[2][8];
-		etc1_optimizer::results best_results[2];
-		for (uint32_t i = 0; i < 2; i++)
-		{
-			best_results[i].m_n = 8;
-			best_results[i].m_pSelectors = best_selectors[i];
-			best_results[i].m_block_color_unscaled.set(0, 0, 0, 255);
-			best_results[i].m_block_inten_table = 0;
-			best_results[i].m_error = 0;
-			best_results[i].m_block_color4 = false;
-		}
-
-		uint8_t best_subset_selectors[16];
-		etc1_optimizer::results best_subset_results;
-		best_subset_results.m_n = 16;
-		best_subset_results.m_pSelectors = best_subset_selectors;
-
-		if (((pForce_selectors) && (pack_params.m_quality >= cETCQualitySlow)) || (pack_params.m_force_etc1s))
-		{
-			// TODO: This may only be useful in force selector mode.
-			uint8_t subset_selectors[16];
-
-			etc1_optimizer::params subset_params(pack_params);
-			subset_params.m_num_src_pixels = 16;
-			subset_params.m_pSrc_pixels = pSrc_pixels;
-			subset_params.m_pForce_selectors = pForce_selectors;
-
-			etc1_optimizer::results subset_results;
-			subset_results.m_n = 16;
-			subset_results.m_pSelectors = subset_selectors;
-
-			for (uint32_t use_color4 = 0; use_color4 < (uint32_t)(pack_params.m_use_color4 ? 2 : 1); use_color4++)
-			{
-				subset_params.m_use_color4 = (use_color4 != 0);
-
-				if (!invoke_optimizer(subset_results, context, subset_params, subset_params))
-					break;
-
-				if (subset_results.m_error < best_error)
-				{
-					best_error = subset_results.m_error;
-					best_flip = true;
-					best_use_color4 = use_color4;
-					best_subset_results = subset_results;
-					best_results[0] = subset_results;
-					best_results[1] = subset_results;
-					best_is_subset = true;
-				}
-			}
-		}
-
-		if ((best_error > 0) && (!pack_params.m_force_etc1s))
-		{
-			uint8_t selectors[3][8];
-			etc1_optimizer::results results[3];
-
-			for (uint32_t i = 0; i < 3; i++)
-			{
-				results[i].m_n = 8;
-				results[i].m_pSelectors = selectors[i];
-			}
-
-			color_rgba subblock_pixels[8];
-
-			etc1_optimizer::params params(pack_params);
-			params.m_num_src_pixels = 8;
-			params.m_pSrc_pixels = subblock_pixels;
-
-			uint8_t forced_selectors[8];
-			params.m_pForce_selectors = pForce_selectors ? forced_selectors : nullptr;
-
-			uint32_t first_flip = 0;
-			uint32_t last_flip = 2;
-			if (pack_params.m_quality < cETCQualitySlow)
-			{
-				const bool should_flip = pack_etc1_estimate_flipped(pSrc_pixels);
-
-				first_flip = should_flip;
-				last_flip = first_flip + 1;
-			}
-
-			for (uint32_t flip = first_flip; flip < last_flip; flip++)
-			{
-				for (uint32_t use_color4 = 0; use_color4 < (uint32_t)(pack_params.m_use_color4 ? 2 : 1); use_color4++)
-				{
-					uint64_t trial_error = 0;
-
-					uint32_t subblock;
-					for (subblock = 0; subblock < 2; subblock++)
-					{
-#if BASISU_DEBUG_ETC_ENCODER
-						printf("** Flip: %u, Color4: %u, Subblock: %u, Best error so far: %I64u\n", flip, use_color4, subblock, best_error);
-#endif
-
-						if (flip)
-						{
-							memcpy(subblock_pixels, pSrc_pixels + subblock * 8, sizeof(color_rgba) * 8);
-
-							if (pForce_selectors)
-								memcpy(forced_selectors, pForce_selectors + subblock * 8, 8);
-						}
-						else
-						{
-							const color_rgba* 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];
-
-							if (pForce_selectors)
-							{
-								const uint8_t* pSrc_sel = pForce_selectors + subblock * 2;
-								forced_selectors[0] = pSrc_sel[0]; forced_selectors[1] = pSrc_sel[4]; forced_selectors[2] = pSrc_sel[8]; forced_selectors[3] = pSrc_sel[12];
-								forced_selectors[4] = pSrc_sel[1]; forced_selectors[5] = pSrc_sel[5]; forced_selectors[6] = pSrc_sel[9]; forced_selectors[7] = pSrc_sel[13];
-							}
-						}
-
-						results[2].m_error = UINT64_MAX;
-						if ((params.m_quality >= cETCQualityMedium) && ((subblock) || (use_color4)) && (pForce_selectors == nullptr))
-						{
-							color_rgba subblock_pixel0(subblock_pixels[0]);
-							int r;
-							for (r = 7; r >= 1; --r)
-								if ((subblock_pixels[r].r != subblock_pixel0.r) || (subblock_pixels[r].g != subblock_pixel0.g) || (subblock_pixels[r].b != subblock_pixel0.b))
-									break;
-							if (!r)
-							{
-								pack_etc1_block_solid_color_constrained(results[2], 8, &subblock_pixel0.r, !use_color4, (subblock && !use_color4) ? &results[0].m_block_color_unscaled : nullptr);
-							}
-						}
-
-						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 (!invoke_optimizer(results[subblock], context, params, pack_params))
-						{
-#if BASISU_DEBUG_ETC_ENCODER
-							printf("Optimizer failed\n");
-#endif
-							break;
-
-#if 0
-							if (!pack_params.m_cluster_fit)
-								break;
-
-							// TODO: Test this, is it worth it?								
-							basis_etc1_pack_params temp_pack_params(pack_params);
-							
-							temp_pack_params.m_cluster_fit = false;
-
-							if (!invoke_optimizer(results[subblock], context, params, temp_pack_params))
-							{
-#if BASISU_DEBUG_ETC_ENCODER
-								printf("Optimizer failed again\n");
-#endif
-								break;
-							}
-							else
-							{
-#if BASISU_DEBUG_ETC_ENCODER
-								printf("Optimizer succeeded once cluster fit was disabled\n");
-#endif
-							}
-#endif
-							
-						}
-
-#if BASISU_DEBUG_ETC_ENCODER
-						printf("First optimization pass error: %I64u\n", results[subblock].m_error);
-#endif
-
-						if (results[2].m_error < results[subblock].m_error)
-						{
-#if BASISU_DEBUG_ETC_ENCODER
-							printf("Switching to solid block results for sublock (%I64u vs. %I64u error)\n", results[2].m_error, results[subblock].m_error);
-#endif
-							results[subblock] = results[2];
-						}
-
-						trial_error += results[subblock].m_error;
-						if (trial_error >= best_error)
-						{
-#if BASISU_DEBUG_ETC_ENCODER
-							printf("Early out, trial error %I64u vs. current best error %I64u\n", trial_error, best_error);
-#endif
-							break;
-						}
-					} // subblock
-
-					if (subblock < 2)
-						continue;
-
-					if ((pack_params.m_flip_bias > 0.0f) && (flip) && (pack_params.m_quality >= cETCQualitySlow))
-					{
-						uint64_t nonflip_error = best_error;
-						uint64_t flip_error = trial_error;
-
-						if (!(flip_error < nonflip_error * pack_params.m_flip_bias))
-							continue;
-					}
-
-					best_error = trial_error;
-					best_results[0] = results[0];
-					best_results[1] = results[1];
-					best_flip = flip;
-					best_use_color4 = use_color4;
-					best_is_subset = false;
-
-				} // use_color4
-
-			} // flip
-		}
-
-#if BASISU_DEBUG_ETC_ENCODER
-		printf("Best error: %I64u\n", best_error);
-#endif
-
-		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;
-		if (!best_use_color4)
-		{
-			if ((minimum(dr, dg, db) < cETC1ColorDeltaMin) || (maximum(dr, dg, db) > cETC1ColorDeltaMax))
-			{
-				assert(0);
-#if 0
-				printf("%i %i %i, %i %i %i\n", 
-					best_results[0].m_block_color_unscaled.r,
-					best_results[0].m_block_color_unscaled.g,
-					best_results[0].m_block_color_unscaled.b,
-					best_results[1].m_block_color_unscaled.r,
-					best_results[1].m_block_color_unscaled.g,
-					best_results[1].m_block_color_unscaled.b);
-#endif											
-				// Shouldn't ever happen!
-			}
-		}
-
-		if (best_use_color4)
-		{
-			dst_block.m_bytes[0] = static_cast<uint8_t>(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_t>(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_t>(best_results[1].m_block_color_unscaled.b | (best_results[0].m_block_color_unscaled.b << 4));
-		}
-		else
-		{
-			if (dr < 0) dr += 8;
-			if (dg < 0) dg += 8;
-			if (db < 0) db += 8;
-			dst_block.m_bytes[0] = static_cast<uint8_t>((best_results[0].m_block_color_unscaled.r << 3) | dr);
-			dst_block.m_bytes[1] = static_cast<uint8_t>((best_results[0].m_block_color_unscaled.g << 3) | dg);
-			dst_block.m_bytes[2] = static_cast<uint8_t>((best_results[0].m_block_color_unscaled.b << 3) | db);
-		}
-
-		dst_block.m_bytes[3] = static_cast<uint8_t>((best_results[1].m_block_inten_table << 2) | (best_results[0].m_block_inten_table << 5) | ((~best_use_color4 & 1) << 1) | best_flip);
-
-		uint32_t selector0 = 0, selector1 = 0;
-		if (best_is_subset)
-		{
-			const uint8_t* pSelectors0 = best_subset_results.m_pSelectors;
-			const uint8_t* pSelectors1 = best_subset_results.m_pSelectors + 8;
-			for (int x = 3; x >= 0; --x)
-			{
-				uint32_t 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 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_t* pSelectors0 = best_results[0].m_pSelectors;
-			const uint8_t* pSelectors1 = best_results[1].m_pSelectors;
-			for (int x = 3; x >= 0; --x)
-			{
-				uint32_t 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_t* pSelectors = best_results[subblock].m_pSelectors + 4;
-				for (uint32_t i = 0; i < 2; i++)
-				{
-					uint32_t 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_t>(selector1 >> 8);
-		dst_block.m_bytes[5] = static_cast<uint8_t>(selector1 & 0xFF);
-		dst_block.m_bytes[6] = static_cast<uint8_t>(selector0 >> 8);
-		dst_block.m_bytes[7] = static_cast<uint8_t>(selector0 & 0xFF);
-
-		return best_error;
-	}
-	
-			
 } // namespace basisu
diff --git a/basisu_etc.h b/basisu_etc.h
index 7ed1317..a202d01 100644
--- a/basisu_etc.h
+++ b/basisu_etc.h
@@ -1043,12 +1043,4 @@
 		etc1_optimizer m_optimizer;
 	};
 
-	void pack_etc1_block_init();
-
-	uint64_t pack_etc1_block(etc_block& block, const color_rgba* pSrc_pixels, basis_etc1_pack_params& pack_params, pack_etc1_block_context& context, const uint8_t *pForce_selectors = nullptr);
-
-	bool pack_etc1_estimate_flipped(const color_rgba* pSrc_pixels);
-		
-	uint64_t pack_etc1_block_solid_color(etc_block& block, const uint8_t* pColor, bool diff_only = true);
-
 } // namespace basisu