mikunyan 3.9.4 → 3.9.5

data/ext/decoders/native/astc.h

@@ -0,0 +1,8 @@
+#ifndef ASTC_H
+#define ASTC_H
+
+#include <stdint.h>
+
+void decode_astc(const uint8_t*, const int, const int, const int, const int, uint32_t*);
+
+#endif /* end of include guard: ASTC_H */

data/ext/decoders/native/dxtc.c

@@ -0,0 +1,104 @@
+#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;
+}
+
+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) };
+    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);
+    }
+    uint_fast32_t d = *data >> 32;
+    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);
+        }
+    }
+}
+
+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] };
+    if (a[0] > a[1]) {
+        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;
+    } else {
+        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[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];
+}
+
+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);
+        }
+    }
+}

data/ext/decoders/native/dxtc.h

@@ -0,0 +1,9 @@
+#ifndef DXTC_H
+#define DXTC_H
+
+#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*);
+
+#endif /* end of include guard: DXTC_H */

data/ext/decoders/native/etc.c

@@ -0,0 +1,271 @@
+#include <stdint.h>
+#include <string.h>
+#include "etc.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;
+}
+
+static inline uint_fast8_t clamp(const int n) {
+    return n < 0 ? 0 : n > 255 ? 255 : n;
+}
+
+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_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];
+    uint_fast8_t c[2][3];
+    if (data[3] & 2) {
+        c[0][0] = data[0] & 0xf8;
+        c[0][1] = data[1] & 0xf8;
+        c[0][2] = data[2] & 0xf8;
+        c[1][0] = c[0][0] + (data[0] << 3 & 0x18) - (data[0] << 3 & 0x20);
+        c[1][1] = c[0][1] + (data[1] << 3 & 0x18) - (data[1] << 3 & 0x20);
+        c[1][2] = c[0][2] + (data[2] << 3 & 0x18) - (data[2] << 3 & 0x20);
+        c[0][0] |= c[0][0] >> 5;
+        c[0][1] |= c[0][1] >> 5;
+        c[0][2] |= c[0][2] >> 5;
+        c[1][0] |= c[1][0] >> 5;
+        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;
+    }
+
+    uint_fast16_t j = data[6] << 8 | data[7];
+    uint_fast16_t k = data[4] << 8 | data[5];
+    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];
+        outbuf[WriteOrderTable[i]] = applicate_color(c[s], k & 1 ? -m : m);
+    }
+}
+
+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];
+    uint_fast8_t c[3][3] = {};
+
+    if (data[3] & 2) {
+        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;
+            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)
+            };
+            for (int i = 0; i < 16; i++, j >>= 1, k >>= 1)
+                outbuf[WriteOrderTable[i]] = color_set[k << 1 & 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][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)
+            };
+            for (int i = 0; i < 16; i++, j >>= 1, k >>= 1)
+                outbuf[WriteOrderTable[i]] = color_set[k << 1 & 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][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 x = 3, i = 0; x >= 0; x--) {
+                for (int y = 3; y >= 0; y--, 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
+            uint_fast8_t code[2] = { data[3] >> 5, data[3] >> 2 & 7 };
+            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 = Etc1ModifierTable[code[s]][j & 1];
+                outbuf[WriteOrderTable[i]] = applicate_color(c[s], k & 1 ? -m : m);
+            }
+        }
+    } 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;
+        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];
+            outbuf[WriteOrderTable[i]] = applicate_color(c[s], k & 1 ? -m : m);
+        }
+    }
+}
+
+static inline 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;
+        for (int i = 0; i < 16; i++, l >>= 3)
+            ((uint8_t*)(outbuf + WriteOrderTableRev[i]))[3] = clamp(data[0] + mult * table[l & 7]);
+    } else {
+        for (int i = 0; i < 16; i++)
+            ((uint8_t*)(outbuf + i))[3] = data[0];
+    }
+}
+
+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);
+        }
+    }
+}
+
+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);
+        }
+    }
+}
+
+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);
+        }
+    }
+}

data/ext/decoders/native/etc.h

@@ -0,0 +1,11 @@
+#ifndef ETC_H
+#define ETC_H
+
+#include <stdint.h>
+
+void decode_etc1(const void*, const int, const int, uint32_t*);
+void decode_etc2(const void*, const int, const int, uint32_t*);
+void decode_etc2a1(const void*, const int, const int, uint32_t*);
+void decode_etc2a8(const void*, const int, const int, uint32_t*);
+
+#endif /* end of include guard: ETC_H */

data/ext/decoders/native/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+append_cppflags('-std=c11')
+append_cppflags('-O3')
+append_cppflags('-Wall')
+append_cppflags('-Wextra')
+append_cppflags('-Wvla')
+create_makefile('mikunyan/decoders/native')

data/ext/decoders/native/main.c

@@ -0,0 +1,167 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <ruby.h>
+#include "rgb.h"
+#include "etc.h"
+#include "astc.h"
+#include "dxtc.h"
+
+/*
+ * Decode image from RGB565 binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] size width * height
+ * @param [Boolean] big whether input data are big endian
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_rgb565(VALUE self, VALUE rb_data, VALUE size, VALUE big) {
+    if (RSTRING_LEN(rb_data) < FIX2LONG(size) * 2)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint8_t *image = (uint8_t*)malloc(FIX2LONG(size) * 4);
+    decode_rgb565((uint16_t*)RSTRING_PTR(rb_data), FIX2INT(size), RTEST(big), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(size) * 4);
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from ETC1 compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_etc1(VALUE self, VALUE rb_data, VALUE w, VALUE h) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + 3) / 4) * ((FIX2LONG(h) + 3) / 4) * 8)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_etc1((uint64_t*)RSTRING_PTR(rb_data), FIX2INT(w), FIX2INT(h), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from ETC2 compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_etc2(VALUE self, VALUE rb_data, VALUE w, VALUE h) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + 3) / 4) * ((FIX2LONG(h) + 3) / 4) * 8)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_etc2((uint64_t*)RSTRING_PTR(rb_data), FIX2INT(w), FIX2INT(h), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from ETC2 Alpha1 compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_etc2a1(VALUE self, VALUE rb_data, VALUE w, VALUE h) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + 3) / 4) * ((FIX2LONG(h) + 3) / 4) * 9)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_etc2a8((uint64_t*)RSTRING_PTR(rb_data), FIX2INT(w), FIX2INT(h), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from ETC2 Alpha8 compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_etc2a8(VALUE self, VALUE rb_data, VALUE w, VALUE h) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + 3) / 4) * ((FIX2LONG(h) + 3) / 4) * 16)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_etc2a8((uint64_t*)RSTRING_PTR(rb_data), FIX2INT(w), FIX2INT(h), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from ASTC compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @param [Integer] bw block width
+ * @param [Integer] bh block height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_astc(VALUE self, VALUE rb_data, VALUE w, VALUE h, VALUE bw, VALUE bh) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + FIX2LONG(bw) - 1) / FIX2LONG(bw)) * ((FIX2LONG(h) + FIX2LONG(bh) - 1) / FIX2LONG(bh)) * 16)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    const uint8_t *data = (uint8_t*)RSTRING_PTR(rb_data);
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_astc(data, FIX2INT(w), FIX2INT(h), FIX2INT(bw), FIX2INT(bh), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from DXT1 compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_dxt1(VALUE self, VALUE rb_data, VALUE w, VALUE h) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + 3) / 4) * ((FIX2LONG(h) + 3) / 4) * 8)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_dxt1((uint64_t*)RSTRING_PTR(rb_data), FIX2INT(w), FIX2INT(h), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+/*
+ * Decode image from DXT5 compressed binary
+ *
+ * @param [String] rb_data binary to decode
+ * @param [Integer] w image width
+ * @param [Integer] h image height
+ * @return [String] decoded rgba binary
+ */
+static VALUE rb_decode_dxt5(VALUE self, VALUE rb_data, VALUE w, VALUE h) {
+    if (RSTRING_LEN(rb_data) < ((FIX2LONG(w) + 3) / 4) * ((FIX2LONG(h) + 3) / 4) * 16)
+        rb_raise(rb_eStandardError, "Data size is not enough.");
+    uint32_t *image = (uint32_t*)calloc(FIX2LONG(w) * FIX2LONG(h), sizeof(uint32_t));
+    decode_dxt5((uint64_t*)RSTRING_PTR(rb_data), FIX2INT(w), FIX2INT(h), image);
+    VALUE ret = rb_str_new((char*)image, FIX2LONG(w) * FIX2LONG(h) * sizeof(uint32_t));
+    free(image);
+    return ret;
+}
+
+void Init_native() {
+    VALUE mMikunyan = rb_define_module("Mikunyan");
+    VALUE mDecodeHelper = rb_define_module_under(mMikunyan, "DecodeHelper");
+    rb_define_module_function(mDecodeHelper, "decode_rgb565", rb_decode_rgb565, 3);
+    rb_define_module_function(mDecodeHelper, "decode_etc1", rb_decode_etc1, 3);
+    rb_define_module_function(mDecodeHelper, "decode_etc2", rb_decode_etc2, 3);
+    rb_define_module_function(mDecodeHelper, "decode_etc2a1", rb_decode_etc2a1, 3);
+    rb_define_module_function(mDecodeHelper, "decode_etc2a8", rb_decode_etc2a8, 3);
+	rb_define_module_function(mDecodeHelper, "decode_astc", rb_decode_astc, 5);
+    rb_define_module_function(mDecodeHelper, "decode_dxt1", rb_decode_dxt1, 3);
+    rb_define_module_function(mDecodeHelper, "decode_dxt5", rb_decode_dxt5, 3);
+}