mikunyan 3.9.4 → 3.9.5

data/ext/decoders/native/rgb.c

@@ -0,0 +1,26 @@
+#include <stdint.h>
+
+static inline int is_system_little() {
+    int x = 1;
+    return *(char*)&x == 1;
+}
+
+void decode_rgb565(const uint16_t* data, const int size, const int is_big_endian, uint8_t* image) {
+    const uint16_t *d = data;
+    if (is_big_endian == is_system_little()) {
+        uint8_t *p = image;
+        for (int i = 0; i < size; i++, d++, p += 4) {
+            uint_fast8_t r = *d & 0x00f8;
+            uint_fast8_t g = (*d & 0x0007) << 5 | (*d & 0xe000) >> 11;
+            uint_fast8_t b = (*d & 0x1f00) >> 5;
+            p[0] = r | r >> 5;
+            p[1] = g | g >> 6;
+            p[2] = b | b >> 5;
+            p[3] = 255;
+        }
+    } else {
+        uint32_t *p = (uint32_t*)image;
+        for (int i = 0; i < size; i++, d++, p++)
+            *p = (*d & 0xf800) >> 8 | *d >> 13 | (*d & 0x7e0) << 5 | (*d & 0x60) << 3 | *d << 19 | (*d & 0x1c) << 14 | 0xff000000;
+    }
+}

data/ext/decoders/native/rgb.h

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

data/lib/mikunyan/asset.rb

@@ -226,19 +226,25 @@ module Mikunyan
             children = type_tree[:children]
 
             if node.array?
-                data = []
-                size = parse_object_private(br, children.find{|e| e[:name] == 'size'})
+                data = nil
+                size = parse_object_private(br, children.find{|e| e[:name] == 'size'}).value
                 data_type_tree = children.find{|e| e[:name] == 'data'}
-                size.value.times do |i|
-                    data << parse_object_private(br, data_type_tree)
+                if node.type == 'TypelessData'
+                    data = br.read(size * data_type_tree[:node].size)
+                else
+                    data = size.times.map{ parse_object_private(br, data_type_tree) }
                 end
-                data = data.map{|e| e.value}.pack('C*') if node.type == 'TypelessData'
                 r = ObjectValue.new(node.name, node.type, br.endian, data)
             elsif node.size == -1
                 r = ObjectValue.new(node.name, node.type, br.endian)
                 if children.size == 1 && children[0][:name] == 'Array' && children[0][:node].type == 'Array' && children[0][:node].array?
-                    r.value = parse_object_private(br, children[0]).value
-                    r.value = r.value.map{|e| e.value}.pack('C*').force_encoding("utf-8") if node.type == 'string'
+                    if node.type == 'string'
+                        size = parse_object_private(br, children[0][:children].find{|e| e[:name] == 'size'}).value
+                        r.value = br.read(size * children[0][:children].find{|e| e[:name] == 'data'}[:node].size).force_encoding("utf-8")
+                        br.align(4) if children[0][:node].flags & 0x4000 != 0
+                    else
+                        r.value = parse_object_private(br, children[0]).value
+                    end
                 else
                     children.each do |child|
                         r[child[:name]] = parse_object_private(br, child)

data/lib/mikunyan/decoders/image_decoder.rb

@@ -1,7 +1,6 @@
 begin; require 'oily_png'; rescue LoadError; require 'chunky_png'; end
 require 'bin_utils'
-require 'fiddle'
-require 'mikunyan/decoders/astc_block_decoder'
+require 'mikunyan/decoders/native'
 
 module Mikunyan
     # Class for image decoding tools
@@ -39,6 +38,10 @@ module Mikunyan
                 decode_rgb565(width, height, bin, endian)
             when 9
                 decode_r16(width, height, bin)
+            when 10
+                decode_dxt1(width, height, bin)
+            when 12
+                decode_dxt5(width, height, bin)
             when 13
                 decode_rgba4444(width, height, bin, endian)
             when 14
@@ -61,6 +64,8 @@ module Mikunyan
                 decode_etc1(width, height, bin)
             when 45
                 decode_etc2rgb(width, height, bin)
+            when 46
+                decode_etc2rgba1(width, height, bin)
             when 47
                 decode_etc2rgba8(width, height, bin)
             when 48, 54
@@ -123,15 +128,7 @@ module Mikunyan
         # @param [Symbol] endian endianness of binary
         # @return [ChunkyPNG::Image] decoded image
         def self.decode_rgb565(width, height, bin, endian = :big)
-            mem = String.new(capacity: width * height * 3)
-            (width * height).times do |i|
-                c = endian == :little ? BinUtils.get_int16_le(bin, i*2) : BinUtils.get_int16_be(bin, i*2)
-                r = (c & 0xf800) >> 8
-                g = (c & 0x07e0) >> 3
-                b = (c & 0x001f) << 3
-                BinUtils.append_int8!(mem, r | r >> 5, g | g >> 6, b | b >> 5)
-            end
-            ChunkyPNG::Image.from_rgb_stream(width, height, mem).flip
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_rgb565(bin, width * height, endian == :big)).flip
         end
 
         # Decode image from A8 binary
@@ -154,7 +151,7 @@ module Mikunyan
         # @param [String] bin binary to decode
         # @return [ChunkyPNG::Image] decoded image
         def self.decode_r8(width, height, bin)
-            decode_a8(width, height, bin).flip
+            decode_a8(width, height, bin)
         end
 
         # Decode image from RG16 binary
@@ -351,22 +348,31 @@ module Mikunyan
             ChunkyPNG::Image.from_rgba_stream(width, height, mem).flip
         end
 
+        # Decode image from DXT1 compressed binary
+        # @param [Integer] width image width
+        # @param [Integer] height image height
+        # @param [String] bin binary to decode
+        # @return [ChunkyPNG::Image] decoded image
+        def self.decode_dxt1(width, height, bin)
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_dxt1(bin, width, height))
+        end
+
+        # Decode image from DXT5 compressed binary
+        # @param [Integer] width image width
+        # @param [Integer] height image height
+        # @param [String] bin binary to decode
+        # @return [ChunkyPNG::Image] decoded image
+        def self.decode_dxt5(width, height, bin)
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_dxt5(bin, width, height))
+        end
+
         # Decode image from ETC1 compressed binary
         # @param [Integer] width image width
         # @param [Integer] height image height
         # @param [String] bin binary to decode
         # @return [ChunkyPNG::Image] decoded image
         def self.decode_etc1(width, height, bin)
-            bw = (width + 3) / 4
-            bh = (height + 3) / 4
-            ret = ChunkyPNG::Image.new(bh * 4, bw * 4)
-            bh.times do |by|
-                bw.times do |bx|
-                    block = decode_etc1_block(BinUtils.get_sint64_be(bin, (bx + by * bw) * 8))
-                    ret.replace!(ChunkyPNG::Image.from_rgb_stream(4, 4, block), by * 4, bx * 4)
-                end
-            end
-            ret.crop(0, 0, height, width).rotate_left
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_etc1(bin, width, height))
         end
 
         # Decode image from ETC2 compressed binary
@@ -375,16 +381,16 @@ module Mikunyan
         # @param [String] bin binary to decode
         # @return [ChunkyPNG::Image] decoded image
         def self.decode_etc2rgb(width, height, bin)
-            bw = (width + 3) / 4
-            bh = (height + 3) / 4
-            ret = ChunkyPNG::Image.new(bh * 4, bw * 4)
-            bh.times do |by|
-                bw.times do |bx|
-                    block = decode_etc2_block(BinUtils.get_sint64_be(bin, (bx + by * bw) * 8))
-                    ret.replace!(ChunkyPNG::Image.from_rgb_stream(4, 4, block.join), by * 4, bx * 4)
-                end
-            end
-            ret.crop(0, 0, height, width).rotate_left
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_etc2(bin, width, height))
+        end
+
+        # Decode image from ETC2 Alpha1 compressed binary
+        # @param [Integer] width image width
+        # @param [Integer] height image height
+        # @param [String] bin binary to decode
+        # @return [ChunkyPNG::Image] decoded image
+        def self.decode_etc2rgba1(width, height, bin)
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_etc2a1(bin, width, height))
         end
 
         # Decode image from ETC2 Alpha8 compressed binary
@@ -393,19 +399,7 @@ module Mikunyan
         # @param [String] bin binary to decode
         # @return [ChunkyPNG::Image] decoded image
         def self.decode_etc2rgba8(width, height, bin)
-            bw = (width + 3) / 4
-            bh = (height + 3) / 4
-            ret = ChunkyPNG::Image.new(bh * 4, bw * 4)
-            bh.times do |by|
-                bw.times do |bx|
-                    alpha = decode_etc2alpha_block(BinUtils.get_int64_be(bin, (bx + by * bw) * 16))
-                    block = decode_etc2_block(BinUtils.get_int64_be(bin, (bx + by * bw) * 16 + 8))
-                    mem = String.new(capacity: 64)
-                    16.times{|i| mem << block[i] + alpha[i]}
-                    ret.replace!(ChunkyPNG::Image.from_rgba_stream(4, 4, mem), by * 4, bx * 4)
-                end
-            end
-            ret.crop(0, 0, height, width).rotate_left
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_etc2a8(bin, width, height))
         end
 
         # Decode image from ASTC compressed binary
@@ -415,16 +409,7 @@ module Mikunyan
         # @param [String] bin binary to decode
         # @return [ChunkyPNG::Image] decoded image
         def self.decode_astc(width, height, blocksize, bin)
-            bw = (width + blocksize - 1) / blocksize
-            bh = (height + blocksize - 1) / blocksize
-            ret = ChunkyPNG::Image.new(bw * blocksize, bh * blocksize)
-            bh.times do |by|
-                bw.times do |bx|
-                    block = DecodeHelper::AstcBlockDecoder.new(bin.byteslice((by * bw + bx) * 16, 16), blocksize, blocksize).data
-                    ret.replace!(ChunkyPNG::Image.from_rgba_stream(blocksize, blocksize, block), bx * blocksize, by * blocksize)
-                end
-            end
-            ret.crop(0, 0, width, height).flip
+            ChunkyPNG::Image.from_rgba_stream(width, height, DecodeHelper.decode_astc(bin, width, height, blocksize, blocksize))
         end
 
         # Create ASTC file data from ObjectValue
@@ -457,152 +442,6 @@ module Mikunyan
 
         private
 
-        Etc1ModifierTable = [[2, 8], [5, 17], [9, 29], [13, 42], [18, 60], [24, 80], [33, 106], [47, 183]]
-        Etc1SubblockTable = [[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]]
-        Etc2DistanceTable = [3, 6, 11, 16, 23, 32, 41, 64]
-        Etc2AlphaModTable = [
-            [-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]
-        ]
-
-        def self.decode_etc1_block(bin)
-            colors = []
-            codes = [bin >> 37 & 7, bin >> 34 & 7]
-            subblocks = Etc1SubblockTable[bin[32]]
-            if bin[33] == 0
-                colors[0] = bin >> 40 & 0xf0f0f0
-                colors[0] = colors[0] | colors[0] >> 4
-                colors[1] = bin >> 36 & 0xf0f0f0
-                colors[1] = colors[1] | colors[1] >> 4
-            else
-                colors[0] = bin >> 40 & 0xf8f8f8
-                dr = (bin >> 56 & 3) - (bin >> 56 & 4)
-                dg = (bin >> 48 & 3) - (bin >> 48 & 4)
-                db = (bin >> 40 & 3) - (bin >> 40 & 4)
-                colors[1] = colors[0] + (dr << 19) + (dg << 11) + (db << 3)
-                colors[0] = colors[0] | (colors[0] >> 5 & 0x70707)
-                colors[1] = colors[1] | (colors[1] >> 5 & 0x70707)
-            end
-
-            mem = Fiddle::Pointer.malloc(48)
-            16.times do |i|
-                modifier = Etc1ModifierTable[codes[subblocks[i]]][bin[i]]
-                mem[i * 3, 3] = etc1colormod(colors[subblocks[i]], bin[i + 16] == 0 ? modifier : -modifier)
-            end
-            mem.to_str
-        end
-
-        def self.etc1colormod(color, modifier)
-            r = (color >> 16 & 0xff) + modifier
-            g = (color >> 8 & 0xff) + modifier
-            b = (color & 0xff) + modifier
-            r.clamp(0, 255).chr + g.clamp(0, 255).chr + b.clamp(0, 255).chr
-        end
-
-        def self.decode_etc2_block(bin)
-            if bin[33] == 0
-                # individual
-                colors = [0, 0]
-                colors[0] = bin >> 40 & 0xf0f0f0
-                colors[0] = colors[0] | colors[0] >> 4
-                colors[1] = bin >> 36 & 0xf0f0f0
-                colors[1] = colors[1] | colors[1] >> 4
-                codes = [bin >> 37 & 7, bin >> 34 & 7]
-                subblocks = Etc1SubblockTable[bin[32]]
-                (0...16).map do |i|
-                    modifier = Etc1ModifierTable[codes[subblocks[i]]][bin[i]]
-                    etc1colormod(colors[subblocks[i]], bin[i + 16] == 0 ? modifier : -modifier)
-                end
-            else
-                r = bin >> 59
-                dr = (bin >> 56 & 3) - (bin >> 56 & 4)
-                g = bin >> 51 & 0x1f
-                dg = (bin >> 48 & 3) - (bin >> 48 & 4)
-                b = bin >> 43 & 0x1f
-                db = (bin >> 40 & 3) - (bin >> 40 & 4)
-                if r + dr < 0 || r + dr > 31
-                    # T mode
-                    base1 = (bin >> 49 & 0xc00) | (bin >> 48 & 0x3ff)
-                    base1 = (base1 & 0xf00) << 8 | (base1 & 0xf0) << 4 | (base1 & 0xf)
-                    base1 = (base1 << 4) | base1
-                    base2 = bin >> 36 & 0xfff
-                    base2 = (base2 & 0xf00) << 8 | (base2 & 0xf0) << 4 | (base2 & 0xf)
-                    base2 = (base2 << 4) | base2
-                    d = Etc2DistanceTable[(bin >> 33 & 6) + bin[32]]
-                    colors = [[base1].pack('N')[1,3], etc1colormod(base2, d), [base2].pack('N')[1,3], etc1colormod(base2, -d)]
-                    (0...16).map{|i| colors[bin[i] + bin[i + 16] * 2]}
-                elsif g + dg < 0 || g + dg > 31
-                    # H mode
-                    base1 = (bin >> 51 & 0xfe0) | (bin >> 48 & 0x18) | (bin >> 47 & 7)
-                    base1 = (base1 & 0xf00) << 8 | (base1 & 0xf0) << 4 | (base1 & 0xf)
-                    base1 = (base1 << 4) | base1
-                    base2 = bin >> 35 & 0xfff
-                    base2 = (base2 & 0xf00) << 8 | (base2 & 0xf0) << 4 | (base2 & 0xf)
-                    base2 = (base2 << 4) | base2
-                    d = Etc2DistanceTable[bin[34] * 2 + bin[32]]
-                    colors = [etc1colormod(base1, d), etc1colormod(base1, -d), etc1colormod(base2, d), etc1colormod(base2, -d)]
-                    (0...16).map{|i| colors[bin[i] + bin[i + 16] * 2]}
-                elsif b + db < 0 || b + db > 31
-                    # planar mode
-                    color_or = (bin >> 55 & 0xfc) | (bin >> 61 & 0x03)
-                    color_og = (bin >> 49 & 0x80) | (bin >> 48 & 0x7e) | bin[56]
-                    color_ob = (bin >> 41 & 0x80) | (bin >> 38 & 0x60) | (bin >> 37 & 0x1c) | (bin >> 47 & 2) | bin[44]
-                    color_hr = (bin >> 31 & 0xf8) | (bin >> 30 & 0x04) | (bin >> 37 & 0x03)
-                    color_hg = (bin >> 24 & 0xfe) | bin[31]
-                    color_hb = (bin >> 17 & 0xfc) | (bin >> 23 & 0x03)
-                    color_vr = (bin >> 11 & 0xfc) | (bin >> 17 & 0x03)
-                    color_vg = (bin >>  5 & 0xfe) | bin[12]
-                    color_vb = (bin <<  2 & 0xfc) | (bin >>  4 & 0x03)
-                    (0...16).map do |i|
-                        x = i / 4
-                        y = i % 4
-                        r = (x * (color_hr - color_or) + y * (color_vr - color_or) + 4 * color_or + 2) >> 2
-                        g = (x * (color_hg - color_og) + y * (color_vg - color_og) + 4 * color_og + 2) >> 2
-                        b = (x * (color_hb - color_ob) + y * (color_vb - color_ob) + 4 * color_ob + 2) >> 2
-                        r.clamp(0, 255).chr + g.clamp(0, 255).chr + b.clamp(0, 255).chr
-                    end
-                else
-                    # differential mode
-                    colors = [0, 0]
-                    colors[0] = bin >> 40 & 0xf8f8f8
-                    colors[1] = colors[0] + (dr << 19) + (dg << 11) + (db << 3)
-                    colors[0] = colors[0] | (colors[0] >> 5 & 0x70707)
-                    colors[1] = colors[1] | (colors[1] >> 5 & 0x70707)
-                    codes = [bin >> 37 & 7, bin >> 34 & 7]
-                    subblocks = Etc1SubblockTable[bin[32]]
-                    (0...16).map do |i|
-                        modifier = Etc1ModifierTable[codes[subblocks[i]]][bin[i]]
-                        etc1colormod(colors[subblocks[i]], bin[i + 16] == 0 ? modifier : -modifier)
-                    end
-                end
-            end
-        end
-
-        def self.decode_etc2alpha_block(bin)
-            if bin & 0xf0000000000000 == 0
-                Array.new(16, (bin >> 56).chr)
-            else
-                base = bin >> 56
-                mult = bin >> 52 & 0xf
-                table = Etc2AlphaModTable[bin >> 48 & 0xf]
-                (0...16).map{|i| (base + table[bin >> i*3 & 7] * mult).clamp(0, 255).chr}
-            end
-        end
-
         # convert 16bit float
         def self.n2f(n)
             case n