123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766 |
- // SPDX-FileCopyrightText: fabian "ryg" giesen
- // SPDX-License-Identifier: MIT
- // stb_dxt.h - v1.12 - DXT1/DXT5 compressor
- #include <stb_dxt.h>
- #include <stdlib.h>
- #include <string.h>
- #if !defined(STBD_FABS)
- #include <math.h>
- #endif
- #ifndef STBD_FABS
- #define STBD_FABS(x) fabs(x)
- #endif
- static const unsigned char stb__OMatch5[256][2] = {
- {0, 0}, {0, 0}, {0, 1}, {0, 1}, {1, 0}, {1, 0}, {1, 0}, {1, 1}, {1, 1},
- {1, 1}, {1, 2}, {0, 4}, {2, 1}, {2, 1}, {2, 1}, {2, 2}, {2, 2}, {2, 2},
- {2, 3}, {1, 5}, {3, 2}, {3, 2}, {4, 0}, {3, 3}, {3, 3}, {3, 3}, {3, 4},
- {3, 4}, {3, 4}, {3, 5}, {4, 3}, {4, 3}, {5, 2}, {4, 4}, {4, 4}, {4, 5},
- {4, 5}, {5, 4}, {5, 4}, {5, 4}, {6, 3}, {5, 5}, {5, 5}, {5, 6}, {4, 8},
- {6, 5}, {6, 5}, {6, 5}, {6, 6}, {6, 6}, {6, 6}, {6, 7}, {5, 9}, {7, 6},
- {7, 6}, {8, 4}, {7, 7}, {7, 7}, {7, 7}, {7, 8}, {7, 8}, {7, 8}, {7, 9},
- {8, 7}, {8, 7}, {9, 6}, {8, 8}, {8, 8}, {8, 9}, {8, 9}, {9, 8}, {9, 8},
- {9, 8}, {10, 7}, {9, 9}, {9, 9}, {9, 10}, {8, 12}, {10, 9}, {10, 9}, {10, 9},
- {10, 10}, {10, 10}, {10, 10}, {10, 11}, {9, 13}, {11, 10}, {11, 10}, {12, 8}, {11, 11},
- {11, 11}, {11, 11}, {11, 12}, {11, 12}, {11, 12}, {11, 13}, {12, 11}, {12, 11}, {13, 10},
- {12, 12}, {12, 12}, {12, 13}, {12, 13}, {13, 12}, {13, 12}, {13, 12}, {14, 11}, {13, 13},
- {13, 13}, {13, 14}, {12, 16}, {14, 13}, {14, 13}, {14, 13}, {14, 14}, {14, 14}, {14, 14},
- {14, 15}, {13, 17}, {15, 14}, {15, 14}, {16, 12}, {15, 15}, {15, 15}, {15, 15}, {15, 16},
- {15, 16}, {15, 16}, {15, 17}, {16, 15}, {16, 15}, {17, 14}, {16, 16}, {16, 16}, {16, 17},
- {16, 17}, {17, 16}, {17, 16}, {17, 16}, {18, 15}, {17, 17}, {17, 17}, {17, 18}, {16, 20},
- {18, 17}, {18, 17}, {18, 17}, {18, 18}, {18, 18}, {18, 18}, {18, 19}, {17, 21}, {19, 18},
- {19, 18}, {20, 16}, {19, 19}, {19, 19}, {19, 19}, {19, 20}, {19, 20}, {19, 20}, {19, 21},
- {20, 19}, {20, 19}, {21, 18}, {20, 20}, {20, 20}, {20, 21}, {20, 21}, {21, 20}, {21, 20},
- {21, 20}, {22, 19}, {21, 21}, {21, 21}, {21, 22}, {20, 24}, {22, 21}, {22, 21}, {22, 21},
- {22, 22}, {22, 22}, {22, 22}, {22, 23}, {21, 25}, {23, 22}, {23, 22}, {24, 20}, {23, 23},
- {23, 23}, {23, 23}, {23, 24}, {23, 24}, {23, 24}, {23, 25}, {24, 23}, {24, 23}, {25, 22},
- {24, 24}, {24, 24}, {24, 25}, {24, 25}, {25, 24}, {25, 24}, {25, 24}, {26, 23}, {25, 25},
- {25, 25}, {25, 26}, {24, 28}, {26, 25}, {26, 25}, {26, 25}, {26, 26}, {26, 26}, {26, 26},
- {26, 27}, {25, 29}, {27, 26}, {27, 26}, {28, 24}, {27, 27}, {27, 27}, {27, 27}, {27, 28},
- {27, 28}, {27, 28}, {27, 29}, {28, 27}, {28, 27}, {29, 26}, {28, 28}, {28, 28}, {28, 29},
- {28, 29}, {29, 28}, {29, 28}, {29, 28}, {30, 27}, {29, 29}, {29, 29}, {29, 30}, {29, 30},
- {30, 29}, {30, 29}, {30, 29}, {30, 30}, {30, 30}, {30, 30}, {30, 31}, {30, 31}, {31, 30},
- {31, 30}, {31, 30}, {31, 31}, {31, 31},
- };
- static const unsigned char stb__OMatch6[256][2] = {
- {0, 0}, {0, 1}, {1, 0}, {1, 1}, {1, 1}, {1, 2}, {2, 1}, {2, 2}, {2, 2},
- {2, 3}, {3, 2}, {3, 3}, {3, 3}, {3, 4}, {4, 3}, {4, 4}, {4, 4}, {4, 5},
- {5, 4}, {5, 5}, {5, 5}, {5, 6}, {6, 5}, {6, 6}, {6, 6}, {6, 7}, {7, 6},
- {7, 7}, {7, 7}, {7, 8}, {8, 7}, {8, 8}, {8, 8}, {8, 9}, {9, 8}, {9, 9},
- {9, 9}, {9, 10}, {10, 9}, {10, 10}, {10, 10}, {10, 11}, {11, 10}, {8, 16}, {11, 11},
- {11, 12}, {12, 11}, {9, 17}, {12, 12}, {12, 13}, {13, 12}, {11, 16}, {13, 13}, {13, 14},
- {14, 13}, {12, 17}, {14, 14}, {14, 15}, {15, 14}, {14, 16}, {15, 15}, {15, 16}, {16, 14},
- {16, 15}, {17, 14}, {16, 16}, {16, 17}, {17, 16}, {18, 15}, {17, 17}, {17, 18}, {18, 17},
- {20, 14}, {18, 18}, {18, 19}, {19, 18}, {21, 15}, {19, 19}, {19, 20}, {20, 19}, {20, 20},
- {20, 20}, {20, 21}, {21, 20}, {21, 21}, {21, 21}, {21, 22}, {22, 21}, {22, 22}, {22, 22},
- {22, 23}, {23, 22}, {23, 23}, {23, 23}, {23, 24}, {24, 23}, {24, 24}, {24, 24}, {24, 25},
- {25, 24}, {25, 25}, {25, 25}, {25, 26}, {26, 25}, {26, 26}, {26, 26}, {26, 27}, {27, 26},
- {24, 32}, {27, 27}, {27, 28}, {28, 27}, {25, 33}, {28, 28}, {28, 29}, {29, 28}, {27, 32},
- {29, 29}, {29, 30}, {30, 29}, {28, 33}, {30, 30}, {30, 31}, {31, 30}, {30, 32}, {31, 31},
- {31, 32}, {32, 30}, {32, 31}, {33, 30}, {32, 32}, {32, 33}, {33, 32}, {34, 31}, {33, 33},
- {33, 34}, {34, 33}, {36, 30}, {34, 34}, {34, 35}, {35, 34}, {37, 31}, {35, 35}, {35, 36},
- {36, 35}, {36, 36}, {36, 36}, {36, 37}, {37, 36}, {37, 37}, {37, 37}, {37, 38}, {38, 37},
- {38, 38}, {38, 38}, {38, 39}, {39, 38}, {39, 39}, {39, 39}, {39, 40}, {40, 39}, {40, 40},
- {40, 40}, {40, 41}, {41, 40}, {41, 41}, {41, 41}, {41, 42}, {42, 41}, {42, 42}, {42, 42},
- {42, 43}, {43, 42}, {40, 48}, {43, 43}, {43, 44}, {44, 43}, {41, 49}, {44, 44}, {44, 45},
- {45, 44}, {43, 48}, {45, 45}, {45, 46}, {46, 45}, {44, 49}, {46, 46}, {46, 47}, {47, 46},
- {46, 48}, {47, 47}, {47, 48}, {48, 46}, {48, 47}, {49, 46}, {48, 48}, {48, 49}, {49, 48},
- {50, 47}, {49, 49}, {49, 50}, {50, 49}, {52, 46}, {50, 50}, {50, 51}, {51, 50}, {53, 47},
- {51, 51}, {51, 52}, {52, 51}, {52, 52}, {52, 52}, {52, 53}, {53, 52}, {53, 53}, {53, 53},
- {53, 54}, {54, 53}, {54, 54}, {54, 54}, {54, 55}, {55, 54}, {55, 55}, {55, 55}, {55, 56},
- {56, 55}, {56, 56}, {56, 56}, {56, 57}, {57, 56}, {57, 57}, {57, 57}, {57, 58}, {58, 57},
- {58, 58}, {58, 58}, {58, 59}, {59, 58}, {59, 59}, {59, 59}, {59, 60}, {60, 59}, {60, 60},
- {60, 60}, {60, 61}, {61, 60}, {61, 61}, {61, 61}, {61, 62}, {62, 61}, {62, 62}, {62, 62},
- {62, 63}, {63, 62}, {63, 63}, {63, 63},
- };
- static int stb__Mul8Bit(int a, int b) {
- int t = a * b + 128;
- return (t + (t >> 8)) >> 8;
- }
- static void stb__From16Bit(unsigned char* out, unsigned short v) {
- int rv = (v & 0xf800) >> 11;
- int gv = (v & 0x07e0) >> 5;
- int bv = (v & 0x001f) >> 0;
- // expand to 8 bits via bit replication
- out[0] = static_cast<unsigned char>((rv * 33) >> 2);
- out[1] = static_cast<unsigned char>((gv * 65) >> 4);
- out[2] = static_cast<unsigned char>((bv * 33) >> 2);
- out[3] = 0;
- }
- static unsigned short stb__As16Bit(int r, int g, int b) {
- return (unsigned short)((stb__Mul8Bit(r, 31) << 11) + (stb__Mul8Bit(g, 63) << 5) +
- stb__Mul8Bit(b, 31));
- }
- // linear interpolation at 1/3 point between a and b, using desired rounding
- // type
- static int stb__Lerp13(int a, int b) {
- #ifdef STB_DXT_USE_ROUNDING_BIAS
- // with rounding bias
- return a + stb__Mul8Bit(b - a, 0x55);
- #else
- // without rounding bias
- // replace "/ 3" by "* 0xaaab) >> 17" if your compiler sucks or you really
- // need every ounce of speed.
- return (2 * a + b) / 3;
- #endif
- }
- // linear interpolation at 1/2 point between a and b
- static int stb__Lerp12(int a, int b) {
- return (a + b) / 2;
- }
- // lerp RGB color
- static void stb__Lerp13RGB(unsigned char* out, unsigned char* p1, unsigned char* p2) {
- out[0] = (unsigned char)stb__Lerp13(p1[0], p2[0]);
- out[1] = (unsigned char)stb__Lerp13(p1[1], p2[1]);
- out[2] = (unsigned char)stb__Lerp13(p1[2], p2[2]);
- }
- static void stb__Lerp12RGB(unsigned char* out, unsigned char* p1, unsigned char* p2) {
- out[0] = (unsigned char)stb__Lerp12(p1[0], p2[0]);
- out[1] = (unsigned char)stb__Lerp12(p1[1], p2[1]);
- out[2] = (unsigned char)stb__Lerp12(p1[2], p2[2]);
- }
- /****************************************************************************/
- static void stb__Eval4Colors(unsigned char* color, unsigned short c0, unsigned short c1) {
- stb__From16Bit(color + 0, c0);
- stb__From16Bit(color + 4, c1);
- stb__Lerp13RGB(color + 8, color + 0, color + 4);
- stb__Lerp13RGB(color + 12, color + 4, color + 0);
- }
- static void stb__Eval3Colors(unsigned char* color, unsigned short c0, unsigned short c1) {
- stb__From16Bit(color + 0, c0);
- stb__From16Bit(color + 4, c1);
- stb__Lerp12RGB(color + 8, color + 0, color + 4);
- }
- // The color matching function
- static unsigned int stb__MatchColorsBlock(unsigned char* block, unsigned char* color) {
- unsigned int mask = 0;
- int dirr = color[0 * 4 + 0] - color[1 * 4 + 0];
- int dirg = color[0 * 4 + 1] - color[1 * 4 + 1];
- int dirb = color[0 * 4 + 2] - color[1 * 4 + 2];
- int dots[16];
- int stops[4];
- int i;
- int c0Point, halfPoint, c3Point;
- for (i = 0; i < 16; i++)
- dots[i] = block[i * 4 + 0] * dirr + block[i * 4 + 1] * dirg + block[i * 4 + 2] * dirb;
- for (i = 0; i < 4; i++)
- stops[i] = color[i * 4 + 0] * dirr + color[i * 4 + 1] * dirg + color[i * 4 + 2] * dirb;
- // think of the colors as arranged on a line; project point onto that line,
- // then choose next color out of available ones. we compute the crossover
- // points for "best color in top half"/"best in bottom half" and then the same
- // inside that subinterval.
- //
- // relying on this 1d approximation isn't always optimal in terms of euclidean
- // distance, but it's very close and a lot faster.
- // http://cbloomrants.blogspot.com/2008/12/12-08-08-dxtc-summary.html
- c0Point = (stops[1] + stops[3]);
- halfPoint = (stops[3] + stops[2]);
- c3Point = (stops[2] + stops[0]);
- for (i = 15; i >= 0; i--) {
- int dot = dots[i] * 2;
- mask <<= 2;
- if (dot < halfPoint)
- mask |= (dot < c0Point) ? 1 : 3;
- else
- mask |= (dot < c3Point) ? 2 : 0;
- }
- return mask;
- }
- static unsigned int stb__MatchColorsAlphaBlock(unsigned char* block, unsigned char* color) {
- unsigned int mask = 0;
- int dirr = color[0 * 4 + 0] - color[1 * 4 + 0];
- int dirg = color[0 * 4 + 1] - color[1 * 4 + 1];
- int dirb = color[0 * 4 + 2] - color[1 * 4 + 2];
- int dots[16];
- int stops[3];
- int i;
- int c0Point, c2Point;
- for (i = 0; i < 16; i++)
- dots[i] = block[i * 4 + 0] * dirr + block[i * 4 + 1] * dirg + block[i * 4 + 2] * dirb;
- for (i = 0; i < 3; i++)
- stops[i] = color[i * 4 + 0] * dirr + color[i * 4 + 1] * dirg + color[i * 4 + 2] * dirb;
- c0Point = (stops[1] + stops[2]);
- c2Point = (stops[2] + stops[0]);
- for (i = 15; i >= 0; i--) {
- int dot = dots[i] * 2;
- mask <<= 2;
- if (block[i * 4 + 3] == 0)
- mask |= 3;
- else if (dot < c2Point)
- mask |= (dot < c0Point) ? 0 : 2;
- else
- mask |= (dot < c0Point) ? 1 : 0;
- }
- return mask;
- }
- static void stb__ReorderColors(unsigned short* pmax16, unsigned short* pmin16) {
- if (*pmin16 < *pmax16) {
- unsigned short t = *pmin16;
- *pmin16 = *pmax16;
- *pmax16 = t;
- }
- }
- static void stb__FinalizeColors(unsigned short* pmax16, unsigned short* pmin16,
- unsigned int* pmask) {
- if (*pmax16 < *pmin16) {
- unsigned short t = *pmin16;
- *pmin16 = *pmax16;
- *pmax16 = t;
- *pmask ^= 0x55555555;
- }
- }
- // The color optimization function. (Clever code, part 1)
- static void stb__OptimizeColorsBlock(unsigned char* block, unsigned short* pmax16,
- unsigned short* pmin16) {
- int mind, maxd;
- unsigned char *minp, *maxp;
- double magn;
- int v_r, v_g, v_b;
- static const int nIterPower = 4;
- float covf[6], vfr, vfg, vfb;
- // determine color distribution
- int cov[6];
- int mu[3], min[3], max[3];
- int ch, i, iter;
- for (ch = 0; ch < 3; ch++) {
- const unsigned char* bp = ((const unsigned char*)block) + ch;
- int muv, minv, maxv;
- muv = minv = maxv = bp[0];
- for (i = 4; i < 64; i += 4) {
- muv += bp[i];
- if (bp[i] < minv)
- minv = bp[i];
- else if (bp[i] > maxv)
- maxv = bp[i];
- }
- mu[ch] = (muv + 8) >> 4;
- min[ch] = minv;
- max[ch] = maxv;
- }
- // determine covariance matrix
- for (i = 0; i < 6; i++)
- cov[i] = 0;
- for (i = 0; i < 16; i++) {
- int r = block[i * 4 + 0] - mu[0];
- int g = block[i * 4 + 1] - mu[1];
- int b = block[i * 4 + 2] - mu[2];
- cov[0] += r * r;
- cov[1] += r * g;
- cov[2] += r * b;
- cov[3] += g * g;
- cov[4] += g * b;
- cov[5] += b * b;
- }
- // convert covariance matrix to float, find principal axis via power iter
- for (i = 0; i < 6; i++)
- covf[i] = static_cast<float>(cov[i]) / 255.0f;
- vfr = (float)(max[0] - min[0]);
- vfg = (float)(max[1] - min[1]);
- vfb = (float)(max[2] - min[2]);
- for (iter = 0; iter < nIterPower; iter++) {
- float r = vfr * covf[0] + vfg * covf[1] + vfb * covf[2];
- float g = vfr * covf[1] + vfg * covf[3] + vfb * covf[4];
- float b = vfr * covf[2] + vfg * covf[4] + vfb * covf[5];
- vfr = r;
- vfg = g;
- vfb = b;
- }
- magn = STBD_FABS(vfr);
- if (STBD_FABS(vfg) > magn)
- magn = STBD_FABS(vfg);
- if (STBD_FABS(vfb) > magn)
- magn = STBD_FABS(vfb);
- if (magn < 4.0f) { // too small, default to luminance
- v_r = 299; // JPEG YCbCr luma coefs, scaled by 1000.
- v_g = 587;
- v_b = 114;
- } else {
- magn = 512.0 / magn;
- v_r = (int)(vfr * magn);
- v_g = (int)(vfg * magn);
- v_b = (int)(vfb * magn);
- }
- minp = maxp = block;
- mind = maxd = block[0] * v_r + block[1] * v_g + block[2] * v_b;
- // Pick colors at extreme points
- for (i = 1; i < 16; i++) {
- int dot = block[i * 4 + 0] * v_r + block[i * 4 + 1] * v_g + block[i * 4 + 2] * v_b;
- if (dot < mind) {
- mind = dot;
- minp = block + i * 4;
- }
- if (dot > maxd) {
- maxd = dot;
- maxp = block + i * 4;
- }
- }
- *pmax16 = stb__As16Bit(maxp[0], maxp[1], maxp[2]);
- *pmin16 = stb__As16Bit(minp[0], minp[1], minp[2]);
- stb__ReorderColors(pmax16, pmin16);
- }
- static void stb__OptimizeColorsAlphaBlock(unsigned char* block, unsigned short* pmax16,
- unsigned short* pmin16) {
- int mind, maxd;
- unsigned char *minp, *maxp;
- double magn;
- int v_r, v_g, v_b;
- static const int nIterPower = 4;
- float covf[6], vfr, vfg, vfb;
- // determine color distribution
- int cov[6];
- int mu[3], min[3], max[3];
- int ch, i, iter;
- for (ch = 0; ch < 3; ch++) {
- const unsigned char* bp = ((const unsigned char*)block) + ch;
- int muv = 0, minv = 256, maxv = -1;
- int num = 0;
- for (i = 0; i < 64; i += 4) {
- if (bp[3 - ch] == 0) {
- continue;
- }
- muv += bp[i];
- if (bp[i] < minv)
- minv = bp[i];
- else if (bp[i] > maxv)
- maxv = bp[i];
- num++;
- }
- mu[ch] = num > 0 ? (muv + 8) / num : 0;
- min[ch] = minv;
- max[ch] = maxv;
- }
- // determine covariance matrix
- for (i = 0; i < 6; i++)
- cov[i] = 0;
- for (i = 0; i < 16; i++) {
- if (block[i * 4 + 3] == 0) {
- continue;
- }
- int r = block[i * 4 + 0] - mu[0];
- int g = block[i * 4 + 1] - mu[1];
- int b = block[i * 4 + 2] - mu[2];
- cov[0] += r * r;
- cov[1] += r * g;
- cov[2] += r * b;
- cov[3] += g * g;
- cov[4] += g * b;
- cov[5] += b * b;
- }
- // convert covariance matrix to float, find principal axis via power iter
- for (i = 0; i < 6; i++)
- covf[i] = static_cast<float>(cov[i]) / 255.0f;
- vfr = (float)(max[0] - min[0]);
- vfg = (float)(max[1] - min[1]);
- vfb = (float)(max[2] - min[2]);
- for (iter = 0; iter < nIterPower; iter++) {
- float r = vfr * covf[0] + vfg * covf[1] + vfb * covf[2];
- float g = vfr * covf[1] + vfg * covf[3] + vfb * covf[4];
- float b = vfr * covf[2] + vfg * covf[4] + vfb * covf[5];
- vfr = r;
- vfg = g;
- vfb = b;
- }
- magn = STBD_FABS(vfr);
- if (STBD_FABS(vfg) > magn)
- magn = STBD_FABS(vfg);
- if (STBD_FABS(vfb) > magn)
- magn = STBD_FABS(vfb);
- if (magn < 4.0f) { // too small, default to luminance
- v_r = 299; // JPEG YCbCr luma coefs, scaled by 1000.
- v_g = 587;
- v_b = 114;
- } else {
- magn = 512.0 / magn;
- v_r = (int)(vfr * magn);
- v_g = (int)(vfg * magn);
- v_b = (int)(vfb * magn);
- }
- minp = maxp = NULL;
- mind = 0x7fffffff;
- maxd = -0x80000000;
- // Pick colors at extreme points
- for (i = 0; i < 16; i++) {
- if (block[i * 4 + 3] == 0) {
- continue;
- }
- int dot = block[i * 4 + 0] * v_r + block[i * 4 + 1] * v_g + block[i * 4 + 2] * v_b;
- if (dot < mind) {
- mind = dot;
- minp = block + i * 4;
- }
- if (dot > maxd) {
- maxd = dot;
- maxp = block + i * 4;
- }
- }
- if (!maxp) {
- // all alpha, no color
- *pmin16 = 0xffff;
- *pmax16 = 0;
- } else {
- // endpoint colors found
- *pmax16 = stb__As16Bit(maxp[0], maxp[1], maxp[2]);
- *pmin16 = stb__As16Bit(minp[0], minp[1], minp[2]);
- if (*pmax16 == *pmin16) {
- // modify the endpoints to indicate presence of an alpha block
- if (*pmax16 > 0) {
- (*pmax16)--;
- } else {
- (*pmin16)++;
- }
- }
- stb__ReorderColors(pmax16, pmin16);
- }
- }
- static const float stb__midpoints5[32] = {
- 0.015686f, 0.047059f, 0.078431f, 0.111765f, 0.145098f, 0.176471f, 0.207843f, 0.241176f,
- 0.274510f, 0.305882f, 0.337255f, 0.370588f, 0.403922f, 0.435294f, 0.466667f, 0.5f,
- 0.533333f, 0.564706f, 0.596078f, 0.629412f, 0.662745f, 0.694118f, 0.725490f, 0.758824f,
- 0.792157f, 0.823529f, 0.854902f, 0.888235f, 0.921569f, 0.952941f, 0.984314f, 1.0f};
- static const float stb__midpoints6[64] = {
- 0.007843f, 0.023529f, 0.039216f, 0.054902f, 0.070588f, 0.086275f, 0.101961f, 0.117647f,
- 0.133333f, 0.149020f, 0.164706f, 0.180392f, 0.196078f, 0.211765f, 0.227451f, 0.245098f,
- 0.262745f, 0.278431f, 0.294118f, 0.309804f, 0.325490f, 0.341176f, 0.356863f, 0.372549f,
- 0.388235f, 0.403922f, 0.419608f, 0.435294f, 0.450980f, 0.466667f, 0.482353f, 0.500000f,
- 0.517647f, 0.533333f, 0.549020f, 0.564706f, 0.580392f, 0.596078f, 0.611765f, 0.627451f,
- 0.643137f, 0.658824f, 0.674510f, 0.690196f, 0.705882f, 0.721569f, 0.737255f, 0.754902f,
- 0.772549f, 0.788235f, 0.803922f, 0.819608f, 0.835294f, 0.850980f, 0.866667f, 0.882353f,
- 0.898039f, 0.913725f, 0.929412f, 0.945098f, 0.960784f, 0.976471f, 0.992157f, 1.0f};
- static unsigned short stb__Quantize5(float x) {
- unsigned short q;
- x = x < 0 ? 0 : x > 1 ? 1 : x; // saturate
- q = (unsigned short)(x * 31);
- q += (x > stb__midpoints5[q]);
- return q;
- }
- static unsigned short stb__Quantize6(float x) {
- unsigned short q;
- x = x < 0 ? 0 : x > 1 ? 1 : x; // saturate
- q = (unsigned short)(x * 63);
- q += (x > stb__midpoints6[q]);
- return q;
- }
- // The refinement function. (Clever code, part 2)
- // Tries to optimize colors to suit block contents better.
- // (By solving a least squares system via normal equations+Cramer's rule)
- static int stb__RefineBlock(unsigned char* block, unsigned short* pmax16, unsigned short* pmin16,
- unsigned int mask) {
- static const int w1Tab[4] = {3, 0, 2, 1};
- static const int prods[4] = {0x090000, 0x000900, 0x040102, 0x010402};
- // ^some magic to save a lot of multiplies in the accumulating loop...
- // (precomputed products of weights for least squares system, accumulated
- // inside one 32-bit register)
- float f;
- unsigned short oldMin, oldMax, min16, max16;
- int i, akku = 0, xx, xy, yy;
- int At1_r, At1_g, At1_b;
- int At2_r, At2_g, At2_b;
- unsigned int cm = mask;
- oldMin = *pmin16;
- oldMax = *pmax16;
- if ((mask ^ (mask << 2)) < 4) // all pixels have the same index?
- {
- // yes, linear system would be singular; solve using optimal
- // single-color match on average color
- int r = 8, g = 8, b = 8;
- for (i = 0; i < 16; ++i) {
- r += block[i * 4 + 0];
- g += block[i * 4 + 1];
- b += block[i * 4 + 2];
- }
- r >>= 4;
- g >>= 4;
- b >>= 4;
- max16 = static_cast<unsigned short>((stb__OMatch5[r][0] << 11) | (stb__OMatch6[g][0] << 5) |
- stb__OMatch5[b][0]);
- min16 = static_cast<unsigned short>((stb__OMatch5[r][1] << 11) | (stb__OMatch6[g][1] << 5) |
- stb__OMatch5[b][1]);
- } else {
- At1_r = At1_g = At1_b = 0;
- At2_r = At2_g = At2_b = 0;
- for (i = 0; i < 16; ++i, cm >>= 2) {
- int step = cm & 3;
- int w1 = w1Tab[step];
- int r = block[i * 4 + 0];
- int g = block[i * 4 + 1];
- int b = block[i * 4 + 2];
- akku += prods[step];
- At1_r += w1 * r;
- At1_g += w1 * g;
- At1_b += w1 * b;
- At2_r += r;
- At2_g += g;
- At2_b += b;
- }
- At2_r = 3 * At2_r - At1_r;
- At2_g = 3 * At2_g - At1_g;
- At2_b = 3 * At2_b - At1_b;
- // extract solutions and decide solvability
- xx = akku >> 16;
- yy = (akku >> 8) & 0xff;
- xy = (akku >> 0) & 0xff;
- f = 3.0f / 255.0f / static_cast<float>(xx * yy - xy * xy);
- max16 = static_cast<unsigned short>(
- stb__Quantize5(static_cast<float>(At1_r * yy - At2_r * xy) * f) << 11);
- max16 |= static_cast<unsigned short>(
- stb__Quantize6(static_cast<float>(At1_g * yy - At2_g * xy) * f) << 5);
- max16 |= static_cast<unsigned short>(
- stb__Quantize5(static_cast<float>(At1_b * yy - At2_b * xy) * f) << 0);
- min16 = static_cast<unsigned short>(
- stb__Quantize5(static_cast<float>(At2_r * xx - At1_r * xy) * f) << 11);
- min16 |= static_cast<unsigned short>(
- stb__Quantize6(static_cast<float>(At2_g * xx - At1_g * xy) * f) << 5);
- min16 |= static_cast<unsigned short>(
- stb__Quantize5(static_cast<float>(At2_b * xx - At1_b * xy) * f) << 0);
- }
- *pmin16 = min16;
- *pmax16 = max16;
- stb__ReorderColors(pmax16, pmin16);
- return oldMin != min16 || oldMax != max16;
- }
- // Color block compression
- static void stb__CompressColorBlock(unsigned char* dest, unsigned char* block, int alpha,
- int mode) {
- unsigned int mask;
- int i;
- int refinecount;
- unsigned short max16, min16;
- unsigned char color[4 * 4];
- refinecount = (mode & STB_DXT_HIGHQUAL) ? 2 : 1;
- // check if block is constant
- for (i = 1; i < 16; i++)
- if (((unsigned int*)block)[i] != ((unsigned int*)block)[0])
- break;
- if (i == 16 && block[3] == 0 && alpha) { // constant alpha
- mask = 0xffffffff;
- max16 = 0;
- min16 = 0xffff;
- } else if (i == 16) { // constant color
- int r = block[0], g = block[1], b = block[2];
- mask = 0xaaaaaaaa;
- max16 = static_cast<unsigned short>((stb__OMatch5[r][0] << 11) | (stb__OMatch6[g][0] << 5) |
- stb__OMatch5[b][0]);
- min16 = static_cast<unsigned short>((stb__OMatch5[r][1] << 11) | (stb__OMatch6[g][1] << 5) |
- stb__OMatch5[b][1]);
- } else if (alpha) {
- stb__OptimizeColorsAlphaBlock(block, &max16, &min16);
- stb__Eval3Colors(color, max16, min16);
- mask = stb__MatchColorsAlphaBlock(block, color);
- } else {
- // first step: PCA+map along principal axis
- stb__OptimizeColorsBlock(block, &max16, &min16);
- if (max16 != min16) {
- stb__Eval4Colors(color, max16, min16);
- mask = stb__MatchColorsBlock(block, color);
- } else
- mask = 0;
- // third step: refine (multiple times if requested)
- for (i = 0; i < refinecount; i++) {
- unsigned int lastmask = mask;
- if (stb__RefineBlock(block, &max16, &min16, mask)) {
- if (max16 != min16) {
- stb__Eval4Colors(color, max16, min16);
- mask = stb__MatchColorsBlock(block, color);
- } else {
- mask = 0;
- break;
- }
- }
- if (mask == lastmask)
- break;
- }
- }
- // write the color block
- if (!alpha)
- stb__FinalizeColors(&max16, &min16, &mask);
- dest[0] = (unsigned char)(max16);
- dest[1] = (unsigned char)(max16 >> 8);
- dest[2] = (unsigned char)(min16);
- dest[3] = (unsigned char)(min16 >> 8);
- dest[4] = (unsigned char)(mask);
- dest[5] = (unsigned char)(mask >> 8);
- dest[6] = (unsigned char)(mask >> 16);
- dest[7] = (unsigned char)(mask >> 24);
- }
- // Alpha block compression (this is easy for a change)
- static void stb__CompressAlphaBlock(unsigned char* dest, unsigned char* src, int stride) {
- int i, dist, bias, dist4, dist2, bits, mask;
- // find min/max color
- int mn, mx;
- mn = mx = src[0];
- for (i = 1; i < 16; i++) {
- if (src[i * stride] < mn)
- mn = src[i * stride];
- else if (src[i * stride] > mx)
- mx = src[i * stride];
- }
- // encode them
- dest[0] = (unsigned char)mx;
- dest[1] = (unsigned char)mn;
- dest += 2;
- // determine bias and emit color indices
- // given the choice of mx/mn, these indices are optimal:
- // http://fgiesen.wordpress.com/2009/12/15/dxt5-alpha-block-index-determination/
- dist = mx - mn;
- dist4 = dist * 4;
- dist2 = dist * 2;
- bias = (dist < 8) ? (dist - 1) : (dist / 2 + 2);
- bias -= mn * 7;
- bits = 0, mask = 0;
- for (i = 0; i < 16; i++) {
- int a = src[i * stride] * 7 + bias;
- int ind, t;
- // select index. this is a "linear scale" lerp factor between 0 (val=min)
- // and 7 (val=max).
- t = (a >= dist4) ? -1 : 0;
- ind = t & 4;
- a -= dist4 & t;
- t = (a >= dist2) ? -1 : 0;
- ind += t & 2;
- a -= dist2 & t;
- ind += (a >= dist);
- // turn linear scale into DXT index (0/1 are extremal pts)
- ind = -ind & 7;
- ind ^= (2 > ind);
- // write index
- mask |= ind << bits;
- if ((bits += 3) >= 8) {
- *dest++ = (unsigned char)mask;
- mask >>= 8;
- bits -= 8;
- }
- }
- }
- void stb_compress_bc1_block(unsigned char* dest, const unsigned char* src, int alpha, int mode) {
- stb__CompressColorBlock(dest, (unsigned char*)src, alpha, mode);
- }
- void stb_compress_bc3_block(unsigned char* dest, const unsigned char* src, int mode) {
- unsigned char data[16][4];
- int i;
- stb__CompressAlphaBlock(dest, (unsigned char*)src + 3, 4);
- dest += 8;
- // make a new copy of the data in which alpha is opaque,
- // because code uses a fast test for color constancy
- memcpy(data, src, 4 * 16);
- for (i = 0; i < 16; ++i)
- data[i][3] = 255;
- src = &data[0][0];
- stb__CompressColorBlock(dest, (unsigned char*)src, 0, mode);
- }
|