mikunyan 3.9.6 → 3.9.7

data/ext/decoders/native/astc.h

@@ -3,6 +3,6 @@
 
 #include <stdint.h>
 
-void decode_astc(const uint8_t*, const int, const int, const int, const int, uint32_t*);
+int decode_astc(const uint8_t *, const long, const long, const int, const int, uint32_t *);
 
 #endif /* end of include guard: ASTC_H */

data/ext/decoders/native/color.h

@@ -0,0 +1,87 @@
+#ifndef COLOR_H
+#define COLOR_H
+
+#include <stdint.h>
+#include <string.h>
+#include "endianness.h"
+
+#ifdef __LITTLE_ENDIAN__
+static const uint_fast32_t TRANSPARENT_MASK = 0x00ffffff;
+#else
+static const uint_fast32_t TRANSPARENT_MASK = 0xffffff00;
+#endif
+
+static inline uint_fast32_t color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+#ifdef __LITTLE_ENDIAN__
+    return r | g << 8 | b << 16 | a << 24;
+#else
+    return a | b << 8 | g << 16 | r << 24;
+#endif
+}
+
+static inline uint_fast32_t alpha_mask(uint8_t a) {
+#ifdef __LITTLE_ENDIAN__
+    return TRANSPARENT_MASK | a << 24;
+#else
+    return TRANSPARENT_MASK | a;
+#endif
+}
+
+static inline void rgb565_le(const uint16_t d, uint8_t *r, uint8_t *g, uint8_t *b) {
+#ifdef __LITTLE_ENDIAN__
+    *r = (d >> 8 & 0xf8) | (d >> 13);
+    *g = (d >> 3 & 0xfc) | (d >> 9 & 3);
+    *b = (d << 3) | (d >> 2 & 7);
+#else
+    *r = (d & 0xf8) | (d >> 5 & 7);
+    *g = (d << 5 & 0xe0) | (d >> 11 & 0x1c) | (d >> 1 & 3);
+    *b = (d >> 5 & 0xf8) | (d >> 10 & 0x7);
+#endif
+}
+
+static inline void rgb565_be(const uint16_t d, uint8_t *r, uint8_t *g, uint8_t *b) {
+#ifdef __BIG_ENDIAN__
+    *r = (d >> 8 & 0xf8) | (d >> 13);
+    *g = (d >> 3 & 0xfc) | (d >> 9 & 3);
+    *b = (d << 3) | (d >> 2 & 7);
+#else
+    *r = (d & 0xf8) | (d >> 5 & 7);
+    *g = (d << 5 & 0xe0) | (d >> 11 & 0x1c) | (d >> 1 & 3);
+    *b = (d >> 5 & 0xf8) | (d >> 10 & 0x7);
+#endif
+}
+
+static inline void rgb565_lep(const uint16_t d, uint8_t *c) {
+#ifdef __LITTLE_ENDIAN__
+    *(c++) = (d >> 8 & 0xf8) | (d >> 13);
+    *(c++) = (d >> 3 & 0xfc) | (d >> 9 & 3);
+    *(c++) = (d << 3) | (d >> 2 & 7);
+#else
+    *(c++) = (d & 0xf8) | (d >> 5 & 7);
+    *(c++) = (d << 5 & 0xe0) | (d >> 11 & 0x1c) | (d >> 1 & 3);
+    *(c++) = (d >> 5 & 0xf8) | (d >> 10 & 0x7);
+#endif
+}
+
+static inline void rgb565_bep(const uint16_t d, uint8_t *c) {
+#ifdef __BIG_ENDIAN__
+    *(c++) = (d >> 8 & 0xf8) | (d >> 13);
+    *(c++) = (d >> 3 & 0xfc) | (d >> 9 & 3);
+    *(c++) = (d << 3) | (d >> 2 & 7);
+#else
+    *(c++) = (d & 0xf8) | (d >> 5 & 7);
+    *(c++) = (d << 5 & 0xe0) | (d >> 11 & 0x1c) | (d >> 1 & 3);
+    *(c++) = (d >> 5 & 0xf8) | (d >> 10 & 0x7);
+#endif
+}
+
+static inline void copy_block_buffer(const long bx, const long by, const long w, const long h, const long bw,
+                                     const long bh, const uint32_t *buffer, uint32_t *image) {
+    long x = bw * bx;
+    long xl = (bw * (bx + 1) > w ? w - bw * bx : bw) * 4;
+    const uint32_t *buffer_end = buffer + bw * bh;
+    for (long y = h - by * bh; buffer < buffer_end && y-- > 0; buffer += bw)
+        memcpy(image + y * w + x, buffer, xl);
+}
+
+#endif /* end of include guard: COLOR_H */

data/ext/decoders/native/dxtc.c

@@ -1,104 +1,77 @@
+#include "dxtc.h"
 #include <stdint.h>
 #include <string.h>
-#include "dxtc.h"
-
-static inline uint_fast32_t color(uint_fast32_t r, uint_fast32_t g, uint_fast32_t b, uint_fast32_t a) {
-    return r | g << 8 | b << 16 | a << 24;
-}
-
-static inline void rgb565(const uint_fast16_t c, int *r, int *g, int *b) {
-    *r = (c & 0xf800) >> 8;
-    *g = (c & 0x07e0) >> 3;
-    *b = (c & 0x001f) << 3;
-    *r |= *r >> 5;
-    *g |= *g >> 6;
-    *b |= *b >> 5;
-}
+#include "color.h"
+#include "endianness.h"
 
-static inline void decode_dxt1_block(const uint64_t *data, uint32_t *outbuf) {
-    int r0, g0, b0, r1, g1, b1;
-    int q0 = ((uint16_t*)data)[0];
-    int q1 = ((uint16_t*)data)[1];
-    rgb565(q0, &r0, &g0, &b0);
-    rgb565(q1, &r1, &g1, &b1);
-    uint_fast32_t c[4] = { color(r0, g0, b0, 255), color(r1, g1, b1, 255) };
+static inline void decode_dxt1_block(const uint8_t *data, uint32_t *outbuf) {
+    uint8_t r0, g0, b0, r1, g1, b1;
+    int q0 = *(uint16_t *)(data);
+    int q1 = *(uint16_t *)(data + 2);
+    rgb565_le(q0, &r0, &g0, &b0);
+    rgb565_le(q1, &r1, &g1, &b1);
+    uint_fast32_t c[4] = {color(r0, g0, b0, 255), color(r1, g1, b1, 255)};
     if (q0 > q1) {
         c[2] = color((r0 * 2 + r1) / 3, (g0 * 2 + g1) / 3, (b0 * 2 + b1) / 3, 255);
         c[3] = color((r0 + r1 * 2) / 3, (g0 + g1 * 2) / 3, (b0 + b1 * 2) / 3, 255);
     } else {
         c[2] = color((r0 + r1) / 2, (g0 + g1) / 2, (b0 + b1) / 2, 255);
+        c[3] = color(0, 0, 0, 255);
     }
-    uint_fast32_t d = *data >> 32;
+    uint_fast32_t d = lton32(*(uint32_t *)(data + 4));
     for (int i = 0; i < 16; i++, d >>= 2)
         outbuf[i] = c[d & 3];
 }
 
-void decode_dxt1(const uint64_t *data, const int w, const int h, uint32_t *image) {
-    int bcw = (w + 3) / 4;
-    int bch = (h + 3) / 4;
-    int clen_last = (w + 3) % 4 + 1;
-    uint32_t buf[16];
-    const uint64_t *d = data;
-    for (int t = 0; t < bch; t++) {
-        for (int s = 0; s < bcw; s++, d++) {
-            decode_dxt1_block(d, buf);
-            int clen = (s < bcw - 1 ? 4 : clen_last) * 4;
-            for (int i = 0, y = h - t * 4 - 1; i < 4 && y >= 0; i++, y--)
-                memcpy(image + y * w + s * 4, buf + i * 4, clen);
+int decode_dxt1(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    const uint8_t *d = data;
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, d += 8) {
+            decode_dxt1_block(d, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
         }
     }
+    return 1;
 }
 
-static inline void decode_dxt5_block(const uint64_t *data, uint32_t *outbuf) {
-    uint_fast32_t a[8] = { ((uint8_t*)data)[0], ((uint8_t*)data)[1] };
+static inline void decode_dxt5_block(const uint8_t *data, uint32_t *outbuf) {
+    uint_fast32_t a[8] = {data[0], data[1]};
     if (a[0] > a[1]) {
-        a[2] = (a[0] * 6 + a[1]    ) / 7;
+        a[2] = (a[0] * 6 + a[1]) / 7;
         a[3] = (a[0] * 5 + a[1] * 2) / 7;
         a[4] = (a[0] * 4 + a[1] * 3) / 7;
         a[5] = (a[0] * 3 + a[1] * 4) / 7;
         a[6] = (a[0] * 2 + a[1] * 5) / 7;
-        a[7] = (a[0]     + a[1] * 6) / 7;
+        a[7] = (a[0] + a[1] * 6) / 7;
     } else {
-        a[2] = (a[0] * 4 + a[1]    ) / 5;
+        a[2] = (a[0] * 4 + a[1]) / 5;
         a[3] = (a[0] * 3 + a[1] * 2) / 5;
         a[4] = (a[0] * 2 + a[1] * 3) / 5;
-        a[5] = (a[0]     + a[1] * 4) / 5;
+        a[5] = (a[0] + a[1] * 4) / 5;
+        a[6] = 0;
         a[7] = 255;
     }
     for (int i = 0; i < 8; i++)
-        a[i] <<= 24;
-
-    int r0, g0, b0, r1, g1, b1;
-    int q0 = ((uint16_t*)(data + 1))[0];
-    int q1 = ((uint16_t*)(data + 1))[1];
-    rgb565(q0, &r0, &g0, &b0);
-    rgb565(q1, &r1, &g1, &b1);
-    uint_fast32_t c[4] = { color(r0, g0, b0, 0), color(r1, g1, b1, 0) };
-    if (q0 > q1) {
-        c[2] = color((r0 * 2 + r1) / 3, (g0 * 2 + g1) / 3, (b0 * 2 + b1) / 3, 0);
-        c[3] = color((r0 + r1 * 2) / 3, (g0 + g1 * 2) / 3, (b0 + b1 * 2) / 3, 0);
-    } else {
-        c[2] = color((r0 + r1) / 2, (g0 + g1) / 2, (b0 + b1) / 2, 0);
-    }
-
-    uint_fast64_t da = *data >> 16;
-    uint_fast32_t dc = *(data + 1) >> 32;
-    for (int i = 0; i < 16; i++, da >>= 3, dc >>= 2)
-        outbuf[i] = a[da & 7] | c[dc & 3];
+        a[i] = alpha_mask(a[i]);
+    decode_dxt1_block(data + 8, outbuf);
+    uint_fast64_t d = lton64(*(uint64_t *)data) >> 16;
+    for (int i = 0; i < 16; i++, d >>= 3)
+        outbuf[i] &= a[d & 7];
 }
 
-void decode_dxt5(const uint64_t *data, const int w, const int h, uint32_t *image) {
-    int bcw = (w + 3) / 4;
-    int bch = (h + 3) / 4;
-    int clen_last = (w + 3) % 4 + 1;
-    uint32_t buf[16];
-    const uint64_t *d = data;
-    for (int t = 0; t < bch; t++) {
-        for (int s = 0; s < bcw; s++, d += 2) {
-            decode_dxt5_block(d, buf);
-            int clen = (s < bcw - 1 ? 4 : clen_last) * 4;
-            for (int i = 0, y = h - t * 4 - 1; i < 4 && y >= 0; i++, y--)
-                memcpy(image + y * w + s * 4, buf + i * 4, clen);
+int decode_dxt5(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    const uint8_t *d = data;
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, d += 16) {
+            decode_dxt5_block(d, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
         }
     }
+    return 1;
 }

data/ext/decoders/native/dxtc.h

@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-void decode_dxt1(const uint64_t*, const int, const int, uint32_t*);
-void decode_dxt5(const uint64_t*, const int, const int, uint32_t*);
+int decode_dxt1(const uint8_t *, const long, const long, uint32_t *);
+int decode_dxt5(const uint8_t *, const long, const long, uint32_t *);
 
 #endif /* end of include guard: DXTC_H */

data/ext/decoders/native/endianness.h

@@ -0,0 +1,180 @@
+/*
+ *
+ * License Information
+ *
+ * endianness.h is derived from https://gist.github.com/jtbr/7a43e6281e6cca353b33ee501421860c
+ * The file is licensed under the MIT License shown below.
+ *
+ *
+ * The MIT License (MIT)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef _ENDIANNESS_H
+#define _ENDIANNESS_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+/* Detect platform endianness at compile time */
+
+// If boost were available on all platforms, could use this instead to detect endianness
+// #include <boost/predef/endian.h>
+
+// When available, these headers can improve platform endianness detection
+#ifdef __has_include  // C++17, supported as extension to C++11 in clang, GCC 5+, vs2015
+#if __has_include(<endian.h>)
+#include <endian.h>  // gnu libc normally provides, linux
+#elif __has_include(<machine/endian.h>)
+#include <machine/endian.h>  //open bsd, macos
+#elif __has_include(<sys/param.h>)
+#include <sys/param.h>  // mingw, some bsd (not open/macos)
+#elif __has_include(<sys/isadefs.h>)
+#include <sys/isadefs.h>  // solaris
+#endif
+#endif
+
+#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ||                                            \
+  (defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN) || (defined(_BYTE_ORDER) && _BYTE_ORDER == _BIG_ENDIAN) ||  \
+  (defined(BYTE_ORDER) && BYTE_ORDER == BIG_ENDIAN) || (defined(__sun) && defined(__SVR4) && defined(_BIG_ENDIAN)) || \
+  defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || defined(_MIBSEB) || defined(__MIBSEB) ||    \
+  defined(__MIBSEB__) || defined(_M_PPC)
+#define __BIG_ENDIAN__
+#elif (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || /* gcc */                           \
+  (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) /* linux header */ ||                                  \
+  (defined(_BYTE_ORDER) && _BYTE_ORDER == _LITTLE_ENDIAN) ||                                                        \
+  (defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN) /* mingw header */ ||                                        \
+  (defined(__sun) && defined(__SVR4) && defined(_LITTLE_ENDIAN)) || /* solaris */                                   \
+  defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || defined(_MIPSEL) || defined(__MIPSEL) ||  \
+  defined(__MIPSEL__) || defined(_M_IX86) || defined(_M_X64) || defined(_M_IA64) || /* msvc for intel processors */ \
+  defined(_M_ARM) /* msvc code on arm executes in little endian mode */
+#define __LITTLE_ENDIAN__
+#endif
+#endif
+
+#ifdef bswap16
+#undef bswap16
+#endif
+#ifdef bswap32
+#undef bswap32
+#endif
+#ifdef bswap64
+#undef bswap64
+#endif
+
+/* Define byte-swap functions, using fast processor-native built-ins where possible */
+// needs to be first because msvc doesn't short-circuit after failing defined(__has_builtin)
+#if defined(_MSC_VER)
+#define bswap16(x) _byteswap_ushort((x))
+#define bswap32(x) _byteswap_ulong((x))
+#define bswap64(x) _byteswap_uint64((x))
+#elif (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+#define bswap16(x) __builtin_bswap16((x))
+#define bswap32(x) __builtin_bswap32((x))
+#define bswap64(x) __builtin_bswap64((x))
+#elif defined(__has_builtin) && __has_builtin(__builtin_bswap64)
+/* for clang; gcc 5 fails on this and && shortcircuit fails; must be after GCC check */
+#define bswap16(x) __builtin_bswap16((x))
+#define bswap32(x) __builtin_bswap32((x))
+#define bswap64(x) __builtin_bswap64((x))
+#else
+/* even in this case, compilers often optimize by using native instructions */
+static inline uint16_t bswap16(uint16_t x) {
+    return (((x >> 8) & 0xffu) | ((x & 0xffu) << 8));
+}
+static inline uint32_t bswap32(uint32_t x) {
+    return (((x & 0xff000000u) >> 24) | ((x & 0x00ff0000u) >> 8) | ((x & 0x0000ff00u) << 8) |
+            ((x & 0x000000ffu) << 24));
+}
+static inline uint64_t bswap64(uint64_t x) {
+    return (((x & 0xff00000000000000ull) >> 56) | ((x & 0x00ff000000000000ull) >> 40) |
+            ((x & 0x0000ff0000000000ull) >> 24) | ((x & 0x000000ff00000000ull) >> 8) |
+            ((x & 0x00000000ff000000ull) << 8) | ((x & 0x0000000000ff0000ull) << 24) |
+            ((x & 0x000000000000ff00ull) << 40) | ((x & 0x00000000000000ffull) << 56));
+}
+#endif
+
+
+/* Defines network - host byte swaps as needed depending upon platform endianness */
+// note that network order is big endian)
+
+#if defined(__LITTLE_ENDIAN__)
+#define ntoh16(x) bswap16((x))
+#define hton16(x) bswap16((x))
+#define ntoh32(x) bswap32((x))
+#define hton32(x) bswap32((x))
+#define ntoh64(x) bswap64((x))
+#define hton64(x) bswap64((x))
+#define lton16(x) (x)
+#define lton32(x) (x)
+#define lton64(x) (x)
+#define ltonf(x) (x)
+#define ltond(x) (x)
+#define bton16(x) bswap16((x))
+#define bton32(x) bswap32((x))
+#define bton64(x) bswap64((x))
+#define btonf(x) htonf((x))
+#define btond(x) htond((x))
+#elif defined(__BIG_ENDIAN__)
+#define ntoh16(x) (x)
+#define hton16(x) (x)
+#define ntoh32(x) (x)
+#define hton32(x) (x)
+#define ntoh64(x) (x)
+#define hton64(x) (x)
+#define bton16(x) (x)
+#define bton32(x) (x)
+#define bton64(x) (x)
+#define btonf(x) (x)
+#define btond(x) (x)
+#define lton16(x) bswap16((x))
+#define lton32(x) bswap32((x))
+#define lton64(x) bswap64((x))
+#define ltonf(x) htonf((x))
+#define ltond(x) htond((x))
+#else
+#warning "UNKNOWN Platform / endianness; network / host byte swaps not defined."
+#endif
+
+
+//! Convert 32-bit float from host to network byte order
+static inline float htonf(float f) {
+#ifdef __cplusplus
+    static_assert(sizeof(float) == sizeof(uint32_t), "Unexpected float format");
+    uint32_t val = hton32(*(reinterpret_cast<const uint32_t *>(&f)));
+    return *(reinterpret_cast<float *>(&val));
+#else
+    uint32_t val = hton32(*(const uint32_t *)(&f));
+    return *((float *)(&val));
+#endif
+}
+#define ntohf(x) htonf((x))
+
+//! Convert 64-bit double from host to network byte order
+static inline double htond(double f) {
+#ifdef __cplusplus
+    static_assert(sizeof(double) == sizeof(uint64_t), "Unexpected double format");
+    uint64_t val = hton64(*(reinterpret_cast<const uint64_t *>(&f)));
+    return *(reinterpret_cast<double *>(&val));
+#else
+    uint64_t val = hton64(*(const uint64_t *)(&f));
+    return *((double *)(&val));
+#endif
+}
+#define ntohd(x) htond((x))
+
+#endif  //_ENDIANNESS_H

data/ext/decoders/native/etc.c

@@ -1,34 +1,25 @@
+#include "etc.h"
 #include <stdint.h>
 #include <string.h>
-#include "etc.h"
+#include "color.h"
 
-uint_fast8_t WriteOrderTable[16] = { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 };
-uint_fast8_t WriteOrderTableRev[16] = { 15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0 };
-uint_fast8_t Etc1ModifierTable[8][2] = {{2, 8}, {5, 17}, {9, 29}, {13, 42}, {18, 60}, {24, 80}, {33, 106}, {47, 183}};
-uint_fast8_t Etc1SubblockTable[2][16] = {{0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1}, {0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1}};
-uint_fast8_t Etc2DistanceTable[8] = {3, 6, 11, 16, 23, 32, 41, 64};
-int_fast8_t Etc2AlphaModTable[16][8] = {
-    {-3, -6,  -9, -15, 2, 5, 8, 14},
-    {-3, -7, -10, -13, 2, 6, 9, 12},
-    {-2, -5,  -8, -13, 1, 4, 7, 12},
-    {-2, -4,  -6, -13, 1, 3, 5, 12},
-    {-3, -6,  -8, -12, 2, 5, 7, 11},
-    {-3, -7,  -9, -11, 2, 6, 8, 10},
-    {-4, -7,  -8, -11, 3, 6, 7, 10},
-    {-3, -5,  -8, -11, 2, 4, 7, 10},
-    {-2, -6,  -8, -10, 1, 5, 7,  9},
-    {-2, -5,  -8, -10, 1, 4, 7,  9},
-    {-2, -4,  -8, -10, 1, 3, 7,  9},
-    {-2, -5,  -7, -10, 1, 4, 6,  9},
-    {-3, -4,  -7, -10, 2, 3, 6,  9},
-    {-1, -2,  -3, -10, 0, 1, 2,  9},
-    {-4, -6,  -8,  -9, 3, 5, 7,  8},
-    {-3, -5,  -7,  -9, 2, 4, 6,  8}
-};
-
-static inline uint_fast32_t color(uint_fast32_t r, uint_fast32_t g, uint_fast32_t b, uint_fast32_t a) {
-    return r | g << 8 | b << 16 | a << 24;
-}
+const uint_fast8_t WriteOrderTable[16] = {0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15};
+const uint_fast8_t WriteOrderTableRev[16] = {15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0};
+const uint_fast8_t Etc1ModifierTable[8][2] = {{2, 8},   {5, 17},  {9, 29},   {13, 42},
+                                              {18, 60}, {24, 80}, {33, 106}, {47, 183}};
+const uint_fast8_t Etc2aModifierTable[2][8][2] = {
+  {{0, 8}, {0, 17}, {0, 29}, {0, 42}, {0, 60}, {0, 80}, {0, 106}, {0, 183}},
+  {{2, 8}, {5, 17}, {9, 29}, {13, 42}, {18, 60}, {24, 80}, {33, 106}, {47, 183}}};
+const uint_fast8_t Etc1SubblockTable[2][16] = {{0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
+                                               {0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1}};
+const uint_fast8_t Etc2DistanceTable[8] = {3, 6, 11, 16, 23, 32, 41, 64};
+const int_fast8_t Etc2AlphaModTable[16][8] = {
+  {-3, -6, -9, -15, 2, 5, 8, 14}, {-3, -7, -10, -13, 2, 6, 9, 12}, {-2, -5, -8, -13, 1, 4, 7, 12},
+  {-2, -4, -6, -13, 1, 3, 5, 12}, {-3, -6, -8, -12, 2, 5, 7, 11},  {-3, -7, -9, -11, 2, 6, 8, 10},
+  {-4, -7, -8, -11, 3, 6, 7, 10}, {-3, -5, -8, -11, 2, 4, 7, 10},  {-2, -6, -8, -10, 1, 5, 7, 9},
+  {-2, -5, -8, -10, 1, 4, 7, 9},  {-2, -4, -8, -10, 1, 3, 7, 9},   {-2, -5, -7, -10, 1, 4, 6, 9},
+  {-3, -4, -7, -10, 2, 3, 6, 9},  {-1, -2, -3, -10, 0, 1, 2, 9},   {-4, -6, -8, -9, 3, 5, 7, 8},
+  {-3, -5, -7, -9, 2, 4, 6, 8}};
 
 static inline uint_fast8_t clamp(const int n) {
     return n < 0 ? 0 : n > 255 ? 255 : n;
@@ -38,15 +29,20 @@ static inline uint32_t applicate_color(uint_fast8_t c[3], int_fast16_t m) {
     return color(clamp(c[0] + m), clamp(c[1] + m), clamp(c[2] + m), 255);
 }
 
+static inline uint32_t applicate_color_alpha(uint_fast8_t c[3], int_fast16_t m, int transparent) {
+    return color(clamp(c[0] + m), clamp(c[1] + m), clamp(c[2] + m), transparent ? 0 : 255);
+}
+
 static inline uint32_t applicate_color_raw(uint_fast8_t c[3]) {
     return color(c[0], c[1], c[2], 255);
 }
 
-static inline void decode_etc1_block(const uint8_t *data, uint32_t *outbuf) {
-    uint_fast8_t code[2] = { data[3] >> 5, data[3] >> 2 & 7 };
-    uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
+static void decode_etc1_block(const uint8_t *data, uint32_t *outbuf) {
+    const uint_fast8_t code[2] = {data[3] >> 5, data[3] >> 2 & 7};  // Table codewords
+    const uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
     uint_fast8_t c[2][3];
     if (data[3] & 2) {
+        // diff bit == 1
         c[0][0] = data[0] & 0xf8;
         c[0][1] = data[1] & 0xf8;
         c[0][2] = data[2] & 0xf8;
@@ -60,16 +56,17 @@ static inline void decode_etc1_block(const uint8_t *data, uint32_t *outbuf) {
         c[1][1] |= c[1][1] >> 5;
         c[1][2] |= c[1][2] >> 5;
     } else {
-        c[0][0] = data[0] & 0xf0 | data[0] >> 4;
-        c[1][0] = data[0] & 0x0f | data[0] << 4;
-        c[0][1] = data[1] & 0xf0 | data[1] >> 4;
-        c[1][1] = data[1] & 0x0f | data[1] << 4;
-        c[0][2] = data[2] & 0xf0 | data[2] >> 4;
-        c[1][2] = data[2] & 0x0f | data[2] << 4;
+        // diff bit == 0
+        c[0][0] = (data[0] & 0xf0) | data[0] >> 4;
+        c[1][0] = (data[0] & 0x0f) | data[0] << 4;
+        c[0][1] = (data[1] & 0xf0) | data[1] >> 4;
+        c[1][1] = (data[1] & 0x0f) | data[1] << 4;
+        c[0][2] = (data[2] & 0xf0) | data[2] >> 4;
+        c[1][2] = (data[2] & 0x0f) | data[2] << 4;
     }
 
-    uint_fast16_t j = data[6] << 8 | data[7];
-    uint_fast16_t k = data[4] << 8 | data[5];
+    uint_fast16_t j = data[6] << 8 | data[7];  // less significant pixel index bits
+    uint_fast16_t k = data[4] << 8 | data[5];  // more significant pixel index bits
     for (int i = 0; i < 16; i++, j >>= 1, k >>= 1) {
         uint_fast8_t s = table[i];
         uint_fast8_t m = Etc1ModifierTable[code[s]][j & 1];
@@ -77,28 +74,13 @@ static inline void decode_etc1_block(const uint8_t *data, uint32_t *outbuf) {
     }
 }
 
-void decode_etc1(const void *data, const int w, const int h, uint32_t *image) {
-    int bcw = (w + 3) / 4;
-    int bch = (h + 3) / 4;
-    int clen_last = (w + 3) % 4 + 1;
-    uint32_t buf[16];
-    const uint8_t *d = (uint8_t*)data;
-    for (int t = 0; t < bch; t++) {
-        for (int s = 0; s < bcw; s++, d += 8) {
-            decode_etc1_block(d, buf);
-            int clen = (s < bcw - 1 ? 4 : clen_last) * 4;
-            for (int i = 0, y = h - t * 4 - 1; i < 4 && y >= 0; i++, y--)
-                memcpy(image + y * w + s * 4, buf + i * 4, clen);
-        }
-    }
-}
-
-static inline void decode_etc2_block(const uint8_t *data, uint32_t *outbuf) {
-    uint_fast16_t j = data[6] << 8 | data[7];
-    uint_fast16_t k = data[4] << 8 | data[5];
+static void decode_etc2_block(const uint8_t *data, uint32_t *outbuf) {
+    uint_fast16_t j = data[6] << 8 | data[7];  // 15 -> 0
+    uint_fast32_t k = data[4] << 8 | data[5];  // 31 -> 16
     uint_fast8_t c[3][3] = {};
 
     if (data[3] & 2) {
+        // diff bit == 1
         uint_fast8_t r = data[0] & 0xf8;
         int_fast16_t dr = (data[0] << 3 & 0x18) - (data[0] << 3 & 0x20);
         uint_fast8_t g = data[1] & 0xf8;
@@ -107,57 +89,52 @@ static inline void decode_etc2_block(const uint8_t *data, uint32_t *outbuf) {
         int_fast16_t db = (data[2] << 3 & 0x18) - (data[2] << 3 & 0x20);
         if (r + dr < 0 || r + dr > 255) {
             // T
-            c[0][0] = data[0] << 3 & 0xc0 | data[0] << 4 & 0x30 | data[0] >> 1 & 0xc | data[0] & 3;
-            c[0][1] = data[1] & 0xf0 | data[1] >> 4;
-            c[0][2] = data[1] & 0x0f | data[1] << 4;
-            c[1][0] = data[2] & 0xf0 | data[2] >> 4;
-            c[1][1] = data[2] & 0x0f | data[2] << 4;
-            c[1][2] = data[3] & 0xf0 | data[3] >> 4;
-            uint_fast8_t d = Etc2DistanceTable[data[3] >> 1 & 6 | data[3] & 1];
-            uint_fast32_t color_set[4] = {
-                applicate_color_raw(c[0]),
-                applicate_color(c[1], d),
-                applicate_color_raw(c[1]),
-                applicate_color(c[1], -d)
-            };
+            c[0][0] = (data[0] << 3 & 0xc0) | (data[0] << 4 & 0x30) | (data[0] >> 1 & 0xc) | (data[0] & 3);
+            c[0][1] = (data[1] & 0xf0) | data[1] >> 4;
+            c[0][2] = (data[1] & 0x0f) | data[1] << 4;
+            c[1][0] = (data[2] & 0xf0) | data[2] >> 4;
+            c[1][1] = (data[2] & 0x0f) | data[2] << 4;
+            c[1][2] = (data[3] & 0xf0) | data[3] >> 4;
+            const uint_fast8_t d = Etc2DistanceTable[(data[3] >> 1 & 6) | (data[3] & 1)];
+            uint_fast32_t color_set[4] = {applicate_color_raw(c[0]), applicate_color(c[1], d),
+                                          applicate_color_raw(c[1]), applicate_color(c[1], -d)};
+            k <<= 1;
             for (int i = 0; i < 16; i++, j >>= 1, k >>= 1)
-                outbuf[WriteOrderTable[i]] = color_set[k << 1 & 2 | j & 1];
+                outbuf[WriteOrderTable[i]] = color_set[(k & 2) | (j & 1)];
         } else if (g + dg < 0 || g + dg > 255) {
             // H
-            c[0][0] = data[0] << 1 & 0xf0 | data[0] >> 3 & 0xf;
-            c[0][1] = data[0] << 5 & 0xe0 | data[1] & 0x10;
+            c[0][0] = (data[0] << 1 & 0xf0) | (data[0] >> 3 & 0xf);
+            c[0][1] = (data[0] << 5 & 0xe0) | (data[1] & 0x10);
             c[0][1] |= c[0][1] >> 4;
-            c[0][2] = data[1] & 8 | data[1] << 1 & 6 | data[2] >> 7;
+            c[0][2] = (data[1] & 8) | (data[1] << 1 & 6) | data[2] >> 7;
             c[0][2] |= c[0][2] << 4;
-            c[1][0] = data[2] << 1 & 0xf0 | data[2] >> 3 & 0xf;
-            c[1][1] = data[2] << 5 & 0xe0 | data[3] >> 3 & 0x10;
+            c[1][0] = (data[2] << 1 & 0xf0) | (data[2] >> 3 & 0xf);
+            c[1][1] = (data[2] << 5 & 0xe0) | (data[3] >> 3 & 0x10);
             c[1][1] |= c[1][1] >> 4;
-            c[1][2] = data[3] << 1 & 0xf0 | data[3] >> 3 & 0xf;
-            uint_fast8_t d = data[3] & 4 | data[3] << 1 & 2;
-            if (c[0][0] > c[1][0] || (c[0][0] == c[1][0] && (c[0][1] > c[1][1] || (c[0][1] == c[1][1] && c[0][2] >= c[1][2]))))
+            c[1][2] = (data[3] << 1 & 0xf0) | (data[3] >> 3 & 0xf);
+            uint_fast8_t d = (data[3] & 4) | (data[3] << 1 & 2);
+            if (c[0][0] > c[1][0] ||
+                (c[0][0] == c[1][0] && (c[0][1] > c[1][1] || (c[0][1] == c[1][1] && c[0][2] >= c[1][2]))))
                 ++d;
             d = Etc2DistanceTable[d];
-            uint_fast32_t color_set[4] = {
-                applicate_color(c[0], d),
-                applicate_color(c[0], -d),
-                applicate_color(c[1], d),
-                applicate_color(c[1], -d)
-            };
+            uint_fast32_t color_set[4] = {applicate_color(c[0], d), applicate_color(c[0], -d), applicate_color(c[1], d),
+                                          applicate_color(c[1], -d)};
+            k <<= 1;
             for (int i = 0; i < 16; i++, j >>= 1, k >>= 1)
-                outbuf[WriteOrderTable[i]] = color_set[k << 1 & 2 | j & 1];
+                outbuf[WriteOrderTable[i]] = color_set[(k & 2) | (j & 1)];
         } else if (b + db < 0 || b + db > 255) {
             // planar
-            c[0][0] = data[0] << 1 & 0xfc | data[0] >> 5 & 3;
-            c[0][1] = data[0] << 7 & 0x80 | data[1] & 0x7e | data[0] & 1;
-            c[0][2] = data[1] << 7 & 0x80 | data[2] << 2 & 0x60 | data[2] << 3 & 0x18 | data[3] >> 5 & 4;
+            c[0][0] = (data[0] << 1 & 0xfc) | (data[0] >> 5 & 3);
+            c[0][1] = (data[0] << 7 & 0x80) | (data[1] & 0x7e) | (data[0] & 1);
+            c[0][2] = (data[1] << 7 & 0x80) | (data[2] << 2 & 0x60) | (data[2] << 3 & 0x18) | (data[3] >> 5 & 4);
             c[0][2] |= c[0][2] >> 6;
-            c[1][0] = data[3] << 1 & 0xf8 | data[3] << 2 & 4 | data[3] >> 5 & 3;
-            c[1][1] = data[4] & 0xfe | data[4] >> 7;
-            c[1][2] = data[4] << 7 & 0x80 | data[5] >> 1 & 0x7c;
+            c[1][0] = (data[3] << 1 & 0xf8) | (data[3] << 2 & 4) | (data[3] >> 5 & 3);
+            c[1][1] = (data[4] & 0xfe) | data[4] >> 7;
+            c[1][2] = (data[4] << 7 & 0x80) | (data[5] >> 1 & 0x7c);
             c[1][2] |= c[1][2] >> 6;
-            c[2][0] = data[5] << 5 & 0xe0 | data[6] >> 3 & 0x1c | data[5] >> 1 & 3;
-            c[2][1] = data[6] << 3 & 0xf8 | data[7] >> 5 & 0x6 | data[6] >> 4 & 1;
-            c[2][2] = data[7] << 2 | data[7] >> 4 & 3;
+            c[2][0] = (data[5] << 5 & 0xe0) | (data[6] >> 3 & 0x1c) | (data[5] >> 1 & 3);
+            c[2][1] = (data[6] << 3 & 0xf8) | (data[7] >> 5 & 0x6) | (data[6] >> 4 & 1);
+            c[2][2] = data[7] << 2 | (data[7] >> 4 & 3);
             for (int y = 0, i = 0; y < 4; y++) {
                 for (int x = 0; x < 4; x++, i++) {
                     uint8_t r = clamp((x * (c[1][0] - c[0][0]) + y * (c[2][0] - c[0][0]) + 4 * c[0][0] + 2) >> 2);
@@ -168,8 +145,8 @@ static inline void decode_etc2_block(const uint8_t *data, uint32_t *outbuf) {
             }
         } else {
             // differential
-            uint_fast8_t code[2] = { data[3] >> 5, data[3] >> 2 & 7 };
-            uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
+            const uint_fast8_t code[2] = {data[3] >> 5, data[3] >> 2 & 7};
+            const uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
             c[0][0] = r | r >> 5;
             c[0][1] = g | g >> 5;
             c[0][2] = b | b >> 5;
@@ -186,15 +163,15 @@ static inline void decode_etc2_block(const uint8_t *data, uint32_t *outbuf) {
             }
         }
     } else {
-        // individual
-        uint_fast8_t code[2] = { data[3] >> 5, data[3] >> 2 & 7 };
-        uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
-        c[0][0] = data[0] & 0xf0 | data[0] >> 4;
-        c[1][0] = data[0] & 0x0f | data[0] << 4;
-        c[0][1] = data[1] & 0xf0 | data[1] >> 4;
-        c[1][1] = data[1] & 0x0f | data[1] << 4;
-        c[0][2] = data[2] & 0xf0 | data[2] >> 4;
-        c[1][2] = data[2] & 0x0f | data[2] << 4;
+        // individual (diff bit == 0)
+        const uint_fast8_t code[2] = {data[3] >> 5, data[3] >> 2 & 7};
+        const uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
+        c[0][0] = (data[0] & 0xf0) | data[0] >> 4;
+        c[1][0] = (data[0] & 0x0f) | data[0] << 4;
+        c[0][1] = (data[1] & 0xf0) | data[1] >> 4;
+        c[1][1] = (data[1] & 0x0f) | data[1] << 4;
+        c[0][2] = (data[2] & 0xf0) | data[2] >> 4;
+        c[1][2] = (data[2] & 0x0f) | data[2] << 4;
         for (int i = 0; i < 16; i++, j >>= 1, k >>= 1) {
             uint_fast8_t s = table[i];
             uint_fast8_t m = Etc1ModifierTable[code[s]][j & 1];
@@ -203,69 +180,264 @@ static inline void decode_etc2_block(const uint8_t *data, uint32_t *outbuf) {
     }
 }
 
-static inline void decode_etc2a8_block(const uint8_t *data, uint32_t *outbuf) {
+static void decode_etc2a1_block(const uint8_t *data, uint32_t *outbuf) {
+    uint_fast16_t j = data[6] << 8 | data[7];  // 15 -> 0
+    uint_fast32_t k = data[4] << 8 | data[5];  // 31 -> 16
+    uint_fast8_t c[3][3] = {};
+
+    int obaq = data[3] >> 1 & 1;
+
+    // diff bit == 1
+    uint_fast8_t r = data[0] & 0xf8;
+    int_fast16_t dr = (data[0] << 3 & 0x18) - (data[0] << 3 & 0x20);
+    uint_fast8_t g = data[1] & 0xf8;
+    int_fast16_t dg = (data[1] << 3 & 0x18) - (data[1] << 3 & 0x20);
+    uint_fast8_t b = data[2] & 0xf8;
+    int_fast16_t db = (data[2] << 3 & 0x18) - (data[2] << 3 & 0x20);
+    if (r + dr < 0 || r + dr > 255) {
+        // T
+        c[0][0] = (data[0] << 3 & 0xc0) | (data[0] << 4 & 0x30) | (data[0] >> 1 & 0xc) | (data[0] & 3);
+        c[0][1] = (data[1] & 0xf0) | data[1] >> 4;
+        c[0][2] = (data[1] & 0x0f) | data[1] << 4;
+        c[1][0] = (data[2] & 0xf0) | data[2] >> 4;
+        c[1][1] = (data[2] & 0x0f) | data[2] << 4;
+        c[1][2] = (data[3] & 0xf0) | data[3] >> 4;
+        const uint_fast8_t d = Etc2DistanceTable[(data[3] >> 1 & 6) | (data[3] & 1)];
+        uint_fast32_t color_set[4] = {applicate_color_raw(c[0]), applicate_color(c[1], d), applicate_color_raw(c[1]),
+                                      applicate_color(c[1], -d)};
+        k <<= 1;
+        for (int i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+            int index = (k & 2) | (j & 1);
+            outbuf[WriteOrderTable[i]] = color_set[index];
+            if (!obaq && index == 2)
+                outbuf[WriteOrderTable[i]] &= TRANSPARENT_MASK;
+        }
+    } else if (g + dg < 0 || g + dg > 255) {
+        // H
+        c[0][0] = (data[0] << 1 & 0xf0) | (data[0] >> 3 & 0xf);
+        c[0][1] = (data[0] << 5 & 0xe0) | (data[1] & 0x10);
+        c[0][1] |= c[0][1] >> 4;
+        c[0][2] = (data[1] & 8) | (data[1] << 1 & 6) | data[2] >> 7;
+        c[0][2] |= c[0][2] << 4;
+        c[1][0] = (data[2] << 1 & 0xf0) | (data[2] >> 3 & 0xf);
+        c[1][1] = (data[2] << 5 & 0xe0) | (data[3] >> 3 & 0x10);
+        c[1][1] |= c[1][1] >> 4;
+        c[1][2] = (data[3] << 1 & 0xf0) | (data[3] >> 3 & 0xf);
+        uint_fast8_t d = (data[3] & 4) | (data[3] << 1 & 2);
+        if (c[0][0] > c[1][0] ||
+            (c[0][0] == c[1][0] && (c[0][1] > c[1][1] || (c[0][1] == c[1][1] && c[0][2] >= c[1][2]))))
+            ++d;
+        d = Etc2DistanceTable[d];
+        uint_fast32_t color_set[4] = {applicate_color(c[0], d), applicate_color(c[0], -d), applicate_color(c[1], d),
+                                      applicate_color(c[1], -d)};
+        k <<= 1;
+        for (int i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+            int index = (k & 2) | (j & 1);
+            outbuf[WriteOrderTable[i]] = color_set[index];
+            if (!obaq && index == 2)
+                outbuf[WriteOrderTable[i]] &= TRANSPARENT_MASK;
+        }
+    } else if (b + db < 0 || b + db > 255) {
+        // planar
+        c[0][0] = (data[0] << 1 & 0xfc) | (data[0] >> 5 & 3);
+        c[0][1] = (data[0] << 7 & 0x80) | (data[1] & 0x7e) | (data[0] & 1);
+        c[0][2] = (data[1] << 7 & 0x80) | (data[2] << 2 & 0x60) | (data[2] << 3 & 0x18) | (data[3] >> 5 & 4);
+        c[0][2] |= c[0][2] >> 6;
+        c[1][0] = (data[3] << 1 & 0xf8) | (data[3] << 2 & 4) | (data[3] >> 5 & 3);
+        c[1][1] = (data[4] & 0xfe) | data[4] >> 7;
+        c[1][2] = (data[4] << 7 & 0x80) | (data[5] >> 1 & 0x7c);
+        c[1][2] |= c[1][2] >> 6;
+        c[2][0] = (data[5] << 5 & 0xe0) | (data[6] >> 3 & 0x1c) | (data[5] >> 1 & 3);
+        c[2][1] = (data[6] << 3 & 0xf8) | (data[7] >> 5 & 0x6) | (data[6] >> 4 & 1);
+        c[2][2] = data[7] << 2 | (data[7] >> 4 & 3);
+        for (int y = 0, i = 0; y < 4; y++) {
+            for (int x = 0; x < 4; x++, i++) {
+                uint8_t r = clamp((x * (c[1][0] - c[0][0]) + y * (c[2][0] - c[0][0]) + 4 * c[0][0] + 2) >> 2);
+                uint8_t g = clamp((x * (c[1][1] - c[0][1]) + y * (c[2][1] - c[0][1]) + 4 * c[0][1] + 2) >> 2);
+                uint8_t b = clamp((x * (c[1][2] - c[0][2]) + y * (c[2][2] - c[0][2]) + 4 * c[0][2] + 2) >> 2);
+                outbuf[i] = color(r, g, b, 255);
+            }
+        }
+    } else {
+        // differential
+        const uint_fast8_t code[2] = {data[3] >> 5, data[3] >> 2 & 7};
+        const uint_fast8_t *table = Etc1SubblockTable[data[3] & 1];
+        c[0][0] = r | r >> 5;
+        c[0][1] = g | g >> 5;
+        c[0][2] = b | b >> 5;
+        c[1][0] = r + dr;
+        c[1][1] = g + dg;
+        c[1][2] = b + db;
+        c[1][0] |= c[1][0] >> 5;
+        c[1][1] |= c[1][1] >> 5;
+        c[1][2] |= c[1][2] >> 5;
+        for (int i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+            uint_fast8_t s = table[i];
+            uint_fast8_t m = Etc2aModifierTable[obaq][code[s]][j & 1];
+            outbuf[WriteOrderTable[i]] = applicate_color_alpha(c[s], k & 1 ? -m : m, !obaq && (k & 1) && !(j & 1));
+        }
+    }
+}
+
+static void decode_etc2a8_block(const uint8_t *data, uint32_t *outbuf) {
     if (data[1] & 0xf0) {
-        uint_fast8_t mult = data[1] >> 4;
-        int_fast8_t *table = Etc2AlphaModTable[data[1] & 0xf];
-        uint_fast64_t l =
-            data[7] | (uint_fast16_t)data[6] << 8 |
-            (uint_fast32_t)data[5] << 16 | (uint_fast32_t)data[4] << 24 |
-            (uint_fast64_t)data[3] << 32 | (uint_fast64_t)data[2] << 40;
+        // multiplier != 0
+        const uint_fast8_t multiplier = data[1] >> 4;
+        const int_fast8_t *table = Etc2AlphaModTable[data[1] & 0xf];
+        uint_fast64_t l = bton64(*(uint64_t*)data);
         for (int i = 0; i < 16; i++, l >>= 3)
-            ((uint8_t*)(outbuf + WriteOrderTableRev[i]))[3] = clamp(data[0] + mult * table[l & 7]);
+            ((uint8_t *)(outbuf + WriteOrderTableRev[i]))[3] = clamp(data[0] + multiplier * table[l & 7]);
     } else {
-        for (int i = 0; i < 16; i++)
-            ((uint8_t*)(outbuf + i))[3] = data[0];
+        // multiplier == 0 (always same as base codeword)
+        for (int i = 0; i < 16; i++, outbuf++)
+            ((uint8_t *)outbuf)[3] = data[0];
+    }
+}
+
+static void decode_eac_block(const uint8_t *data, int color, uint32_t *outbuf) {
+    uint_fast8_t multiplier = data[1] >> 1 & 0x78;
+    if (multiplier == 0)
+        multiplier = 1;
+    const int_fast8_t *table = Etc2AlphaModTable[data[1] & 0xf];
+    uint_fast64_t l = bton64(*(uint64_t*)data);
+    for (int i = 0; i < 16; i++, l >>= 3) {
+        int_fast16_t val = data[0] * 8 + multiplier * table[l & 7] + 4;
+        ((uint8_t *)(outbuf + WriteOrderTableRev[i]))[color] = val < 0 ? 0 : val >= 2048 ? 0xff : val >> 3;
+    }
+}
+
+static void decode_eac_signed_block(const uint8_t *data, int color, uint32_t *outbuf) {
+    int8_t base = (int8_t)data[0];
+    uint_fast8_t multiplier = data[1] >> 1 & 0x78;
+    if (multiplier == 0)
+        multiplier = 1;
+    const int_fast8_t *table = Etc2AlphaModTable[data[1] & 0xf];
+    uint_fast64_t l = bton64(*(uint64_t*)data);
+    for (int i = 0; i < 16; i++, l >>= 3) {
+        int_fast16_t val = base * 8 + multiplier * table[l & 7] + 1023;
+        ((uint8_t *)(outbuf + WriteOrderTableRev[i]))[color] = val < 0 ? 0 : val >= 2048 ? 0xff : val >> 3;
+    }
+}
+
+int decode_etc1(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 8) {
+            decode_etc1_block(data, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
+        }
+    }
+    return 1;
+}
+
+int decode_etc2(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 8) {
+            decode_etc2_block(data, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
+        }
+    }
+    return 1;
+}
+
+int decode_etc2a1(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 8) {
+            decode_etc2a1_block(data, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
+        }
+    }
+    return 1;
+}
+
+int decode_etc2a8(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 16) {
+            decode_etc2_block(data + 8, buffer);
+            decode_etc2a8_block(data, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
+        }
+    }
+    return 1;
+}
+
+int decode_eacr(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    uint32_t base_buffer[16];
+    for (int i = 0; i < 16; i++)
+        base_buffer[i] = color(0, 0, 0, 255);
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 8) {
+            memcpy(buffer, base_buffer, sizeof(buffer));
+            decode_eac_block(data, 0, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
+        }
     }
+    return 1;
 }
 
-void decode_etc2(const void *data, const int w, const int h, uint32_t *image) {
-    int bcw = (w + 3) / 4;
-    int bch = (h + 3) / 4;
-    int clen_last = (w + 3) % 4 + 1;
-    uint32_t buf[16];
-    const uint8_t *d = (uint8_t*)data;
-    for (int t = 0; t < bch; t++) {
-        for (int s = 0; s < bcw; s++, d += 8) {
-            decode_etc2_block(d, buf);
-            int clen = (s < bcw - 1 ? 4 : clen_last) * 4;
-            for (int i = 0, y = h - t * 4 - 1; i < 4 && y >= 0; i++, y--)
-                memcpy(image + y * w + s * 4, buf + i * 4, clen);
+int decode_eacr_signed(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    uint32_t base_buffer[16];
+    for (int i = 0; i < 16; i++)
+        base_buffer[i] = color(0, 0, 0, 255);
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 8) {
+            memcpy(buffer, base_buffer, sizeof(buffer));
+            decode_eac_signed_block(data, 0, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
         }
     }
+    return 1;
 }
 
-void decode_etc2a1(const void *data, const int w, const int h, uint32_t *image) {
-    int bcw = (w + 3) / 4;
-    int bch = (h + 3) / 4;
-    int clen_last = (w + 3) % 4 + 1;
-    uint32_t buf[16];
-    const uint8_t *d = (uint8_t*)data;
-    for (int t = 0; t < bch; t++) {
-        for (int s = 0; s < bcw; s++, d += 9) {
-            decode_etc2_block(d + 1, buf);
-            for (int i = 0; i < 16; i++)
-                ((uint8_t*)(buf + i))[3] = d[0];
-            int clen = (s < bcw - 1 ? 4 : clen_last) * 4;
-            for (int i = 0, y = h - t * 4 - 1; i < 4 && y >= 0; i++, y--)
-                memcpy(image + y * w + s * 4, buf + i * 4, clen);
+int decode_eacrg(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    uint32_t base_buffer[16];
+    for (int i = 0; i < 16; i++)
+        base_buffer[i] = color(0, 0, 0, 255);
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 16) {
+            memcpy(buffer, base_buffer, sizeof(buffer));
+            decode_eac_block(data, 0, buffer);
+            decode_eac_block(data + 8, 1, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
         }
     }
+    return 1;
 }
 
-void decode_etc2a8(const void *data, const int w, const int h, uint32_t *image) {
-    int bcw = (w + 3) / 4;
-    int bch = (h + 3) / 4;
-    int clen_last = (w + 3) % 4 + 1;
-    uint32_t buf[16];
-    const uint8_t *d = (uint8_t*)data;
-    for (int t = 0; t < bch; t++) {
-        for (int s = 0; s < bcw; s++, d += 16) {
-            decode_etc2_block(d + 8, buf);
-            decode_etc2a8_block(d, buf);
-            int clen = (s < bcw - 1 ? 4 : clen_last) * 4;
-            for (int i = 0, y = h - t * 4 - 1; i < 4 && y >= 0; i++, y--)
-                memcpy(image + y * w + s * 4, buf + i * 4, clen);
+int decode_eacrg_signed(const uint8_t *data, const long w, const long h, uint32_t *image) {
+    long num_blocks_x = (w + 3) / 4;
+    long num_blocks_y = (h + 3) / 4;
+    uint32_t buffer[16];
+    uint32_t base_buffer[16];
+    for (int i = 0; i < 16; i++)
+        base_buffer[i] = color(0, 0, 0, 255);
+    for (long by = 0; by < num_blocks_y; by++) {
+        for (long bx = 0; bx < num_blocks_x; bx++, data += 16) {
+            memcpy(buffer, base_buffer, sizeof(buffer));
+            decode_eac_signed_block(data, 0, buffer);
+            decode_eac_signed_block(data + 8, 1, buffer);
+            copy_block_buffer(bx, by, w, h, 4, 4, buffer, image);
         }
     }
+    return 1;
 }