ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/image/WebPLossless.rgr

@@ -0,0 +1,1035 @@
+; SPDX-License-Identifier: MIT
+
+; WebPLossless.rgr - the VP8L lossless bitstream of WebP (RFC 9649 section 3).
+;
+; Prefix codes (simple and normal), the color cache, backward references
+; with the distance map, meta prefix codes and the four transforms
+; (predictor with its 14 modes, cross-color, subtract-green, color indexing
+; with pixel bundling). Also decodes the headerless VP8L stream that carries
+; a compressed ALPH chunk.
+;
+; The decoding logic follows libwebp (src/dec/vp8l_dec.c,
+; src/utils/huffman_utils.c, src/dsp/lossless.c), Copyright Google Inc.,
+; BSD-3-Clause; this port is MIT like the rest of lib/image.
+;
+; Pixels are packed ARGB in one int each: (a << 24) | (r << 16) | (g << 8) | b,
+; so a pixel with alpha >= 128 is negative. Every packed value is built and
+; taken apart with bit operations only, which agree between the 32-bit
+; integers of JavaScript and of the C++ target.
+
+class VP8LDecoder {
+    ; ---- bit reader: least significant bit first, at most 24 bits buffered
+    def data:buffer (buffer_alloc 0)
+    def dataLen:int 0
+    def pos:int 0
+    def bitBuf:int 0
+    def bitCnt:int 0
+    def padBits:int 0
+    def eos:boolean false
+
+    ; ---- prefix code tables of the image level being decoded
+    ; Each code is a root table of 2^rootBits entries followed by its second
+    ; level tables. An entry is (length << 16) | symbol, or for a root entry
+    ; that continues in a second level table ((16 + subBits) << 16) | offset.
+    def tables:int_buffer (int_buffer_alloc 4096)
+    def tablesUsed:int 0
+    def maxTableEntries:int 16777216
+
+    def error:string ""
+    def width:int 0
+    def height:int 0
+    def hasAlpha:boolean false
+    def argb:int_buffer (int_buffer_alloc 0)
+    def maxPixels:int 100000000
+
+    ; ---- what the last stream used (read by the tests)
+    def statTransforms:int 0
+    def statPredModes:int 0
+    def statCacheBits:int 0
+    def statGroups:int 0
+    def statSimpleCodes:int 0
+    def statNormalCodes:int 0
+    def statBackRefs:int 0
+    def statCacheHits:int 0
+    def statBundleBits:int -1
+
+    Constructor () {
+    }
+
+    fn fail:boolean (msg:string) {
+        if ((strlen error) == 0) {
+            error = msg
+        }
+        return false
+    }
+
+    ; ======================================================================
+    ; Bit reader
+    ; ======================================================================
+
+    fn initBits:void (src:buffer start:int size:int) {
+        def srcLen:int (buffer_length src)
+        def s:int start
+        if (s < 0) {
+            s = 0
+        }
+        if (s > srcLen) {
+            s = srcLen
+        }
+        def e:int (s + size)
+        if (size < 0) {
+            e = s
+        }
+        if (e > srcLen) {
+            e = srcLen
+        }
+        data = (buffer_slice src s e)
+        dataLen = (e - s)
+        pos = 0
+        bitBuf = 0
+        bitCnt = 0
+        padBits = 0
+        eos = false
+    }
+
+    fn fill:void () {
+        while (bitCnt <= 16) {
+            def b:int 0
+            if (pos < dataLen) {
+                b = (buffer_get data pos)
+                pos = pos + 1
+            } {
+                padBits = padBits + 8
+            }
+            bitBuf = (bit_or bitBuf (bit_shl b bitCnt))
+            bitCnt = bitCnt + 8
+        }
+    }
+
+    fn readBits16:int (n:int) {
+        if (bitCnt < n) {
+            this.fill()
+        }
+        def v:int (bit_and bitBuf ((bit_shl 1 n) - 1))
+        bitBuf = (bit_shr bitBuf n)
+        bitCnt = bitCnt - n
+        if (bitCnt < padBits) {
+            eos = true
+        }
+        return v
+    }
+
+    ; n bits, 0 <= n <= 24
+    fn readBits:int (n:int) {
+        if (n <= 16) {
+            return (this.readBits16(n))
+        }
+        def lo:int (this.readBits16(16))
+        def hi:int (this.readBits16((n - 16)))
+        return (bit_or lo (bit_shl hi 16))
+    }
+
+    ; ======================================================================
+    ; Prefix codes
+    ; ======================================================================
+
+    fn reserveTables:boolean (n:int) {
+        def need:int (tablesUsed + n)
+        if (need > maxTableEntries) {
+            return (this.fail("prefix code tables too large"))
+        }
+        def cap:int (int_buffer_length tables)
+        if (need <= cap) {
+            return true
+        }
+        def newCap:int (cap * 2)
+        while (newCap < need) {
+            newCap = newCap * 2
+        }
+        def grown:int_buffer (int_buffer_alloc newCap)
+        int_buffer_copy grown 0 tables 0 tablesUsed
+        tables = grown
+        return true
+    }
+
+    sfn reverseBits:int (code:int len:int) {
+        def r:int 0
+        def i:int 0
+        def c:int code
+        while (i < len) {
+            r = (bit_or (bit_shl r 1) (bit_and c 1))
+            c = (bit_shr c 1)
+            i = i + 1
+        }
+        return r
+    }
+
+    ; Builds the decoding table for code lengths[0..n-1] and returns
+    ; (offset << 4) | rootBits, or -1 when the lengths do not form a complete
+    ; prefix code. A code with one used symbol reads zero bits.
+    fn buildCode:int (lengths:int_buffer n:int) {
+        def count:int_buffer (int_buffer_alloc 16)
+        def s:int 0
+        def used:int 0
+        def lastSym:int 0
+        def maxLen:int 0
+        while (s < n) {
+            def l:int (int_buffer_get lengths s)
+            if ((l < 0) || (l > 15)) {
+                return -1
+            }
+            if (l > 0) {
+                int_buffer_set count l ((int_buffer_get count l) + 1)
+                used = used + 1
+                lastSym = s
+                if (l > maxLen) {
+                    maxLen = l
+                }
+            }
+            s = s + 1
+        }
+        if (used == 0) {
+            return -1
+        }
+        if (used == 1) {
+            if ((this.reserveTables(1)) == false) {
+                return -1
+            }
+            def one:int tablesUsed
+            int_buffer_set tables one lastSym
+            tablesUsed = tablesUsed + 1
+            return (bit_shl one 4)
+        }
+        ; complete and not over-subscribed
+        def open:int 1
+        def len:int 1
+        while (len <= 15) {
+            open = (open * 2) - (int_buffer_get count len)
+            if (open < 0) {
+                return -1
+            }
+            len = len + 1
+        }
+        if (open != 0) {
+            return -1
+        }
+        ; canonical first code of each length
+        def nextCode:int_buffer (int_buffer_alloc 16)
+        def code:int 0
+        len = 1
+        while (len <= 15) {
+            code = (bit_shl (code + (int_buffer_get count (len - 1))) 1)
+            if (len == 1) {
+                code = 0
+            }
+            int_buffer_set nextCode len code
+            len = len + 1
+        }
+        def rootBits:int maxLen
+        if (rootBits > 8) {
+            rootBits = 8
+        }
+        def rootSize:int (bit_shl 1 rootBits)
+        def rootMask:int (rootSize - 1)
+        ; bit-reversed code per symbol, and the depth of each second level table
+        def rev:int_buffer (int_buffer_alloc n)
+        def subBits:int_buffer (int_buffer_alloc rootSize)
+        s = 0
+        while (s < n) {
+            def l:int (int_buffer_get lengths s)
+            if (l > 0) {
+                def c:int (int_buffer_get nextCode l)
+                int_buffer_set nextCode l (c + 1)
+                def r:int (VP8LDecoder.reverseBits(c l))
+                int_buffer_set rev s r
+                if (l > rootBits) {
+                    def p:int (bit_and r rootMask)
+                    if ((l - rootBits) > (int_buffer_get subBits p)) {
+                        int_buffer_set subBits p (l - rootBits)
+                    }
+                }
+            }
+            s = s + 1
+        }
+        def total:int rootSize
+        def p:int 0
+        while (p < rootSize) {
+            def sb:int (int_buffer_get subBits p)
+            if (sb > 0) {
+                total = total + (bit_shl 1 sb)
+            }
+            p = p + 1
+        }
+        if ((this.reserveTables(total)) == false) {
+            return -1
+        }
+        def base:int tablesUsed
+        tablesUsed = tablesUsed + total
+        def subOffset:int_buffer (int_buffer_alloc rootSize)
+        def off:int rootSize
+        p = 0
+        while (p < rootSize) {
+            def sb:int (int_buffer_get subBits p)
+            if (sb > 0) {
+                int_buffer_set subOffset p off
+                int_buffer_set tables (base + p) (bit_or (bit_shl (16 + sb) 16) off)
+                off = off + (bit_shl 1 sb)
+            }
+            p = p + 1
+        }
+        s = 0
+        while (s < n) {
+            def l:int (int_buffer_get lengths s)
+            if (l > 0) {
+                def r:int (int_buffer_get rev s)
+                def entry:int (bit_or (bit_shl l 16) s)
+                if (l <= rootBits) {
+                    def step:int (bit_shl 1 l)
+                    def i:int r
+                    while (i < rootSize) {
+                        int_buffer_set tables (base + i) entry
+                        i = i + step
+                    }
+                } {
+                    def pfx:int (bit_and r rootMask)
+                    def sb:int (int_buffer_get subBits pfx)
+                    def sub:int (base + (int_buffer_get subOffset pfx))
+                    def step:int (bit_shl 1 (l - rootBits))
+                    def subSize:int (bit_shl 1 sb)
+                    def i:int (bit_shr r rootBits)
+                    while (i < subSize) {
+                        int_buffer_set tables (sub + i) entry
+                        i = i + step
+                    }
+                }
+            }
+            s = s + 1
+        }
+        return (bit_or (bit_shl base 4) rootBits)
+    }
+
+    ; Reads one symbol with the code built by buildCode.
+    fn readSymbol:int (code:int) {
+        def base:int (bit_shr code 4)
+        def rootBits:int (bit_and code 15)
+        if (rootBits == 0) {
+            return (int_buffer_get tables base)
+        }
+        if (bitCnt < 15) {
+            this.fill()
+        }
+        def e:int (int_buffer_get tables (base + (bit_and bitBuf ((bit_shl 1 rootBits) - 1))))
+        def l:int (bit_shr e 16)
+        if (l > 15) {
+            def sb:int (l - 16)
+            def idx:int (bit_and (bit_shr bitBuf rootBits) ((bit_shl 1 sb) - 1))
+            e = (int_buffer_get tables (base + (bit_and e 65535) + idx))
+            l = (bit_shr e 16)
+        }
+        bitBuf = (bit_shr bitBuf l)
+        bitCnt = bitCnt - l
+        if (bitCnt < padBits) {
+            eos = true
+        }
+        return (bit_and e 65535)
+    }
+
+    ; Reads one prefix code over an alphabet of alphabetSize symbols.
+    fn readCode:int (alphabetSize:int) {
+        def size:int alphabetSize
+        if (size < 256) {
+            size = 256
+        }
+        def lengths:int_buffer (int_buffer_alloc size)
+        def simple:int (this.readBits(1))
+        if (simple == 1) {
+            statSimpleCodes = statSimpleCodes + 1
+            def numSymbols:int ((this.readBits(1)) + 1)
+            def firstBits:int (this.readBits(1))
+            def s0:int 0
+            if (firstBits == 0) {
+                s0 = (this.readBits(1))
+            } {
+                s0 = (this.readBits(8))
+            }
+            int_buffer_set lengths s0 1
+            if (numSymbols == 2) {
+                def s1:int (this.readBits(8))
+                int_buffer_set lengths s1 1
+            }
+        } {
+            statNormalCodes = statNormalCodes + 1
+            if ((this.readCodeLengths(lengths alphabetSize)) == false) {
+                return -1
+            }
+        }
+        if eos {
+            this.fail("truncated prefix code")
+            return -1
+        }
+        def c:int (this.buildCode(lengths alphabetSize))
+        if (c < 0) {
+            this.fail("invalid prefix code")
+        }
+        return c
+    }
+
+    fn readCodeLengths:boolean (lengths:int_buffer numSymbols:int) {
+        def order:[int] ([] _:int (17 18 0 1 2 3 4 5 16 6 7 8 9 10 11 12 13 14 15))
+        def clen:int_buffer (int_buffer_alloc 19)
+        def numCodes:int ((this.readBits(4)) + 4)
+        def i:int 0
+        while (i < numCodes) {
+            int_buffer_set clen (itemAt order i) (this.readBits(3))
+            i = i + 1
+        }
+        def lenCode:int (this.buildCode(clen 19))
+        if (lenCode < 0) {
+            return (this.fail("invalid code length code"))
+        }
+        def maxSymbol:int numSymbols
+        if ((this.readBits(1)) == 1) {
+            def nbits:int (2 + (2 * (this.readBits(3))))
+            maxSymbol = 2 + (this.readBits(nbits))
+            if (maxSymbol > numSymbols) {
+                return (this.fail("code length count out of range"))
+            }
+        }
+        def prevLen:int 8
+        def symbol:int 0
+        while (symbol < numSymbols) {
+            if (maxSymbol == 0) {
+                break
+            }
+            maxSymbol = maxSymbol - 1
+            def codeLen:int (this.readSymbol(lenCode))
+            if eos {
+                return (this.fail("truncated code lengths"))
+            }
+            if (codeLen < 16) {
+                int_buffer_set lengths symbol codeLen
+                symbol = symbol + 1
+                if (codeLen != 0) {
+                    prevLen = codeLen
+                }
+            } {
+                def repeat:int 0
+                def fillLen:int 0
+                if (codeLen == 16) {
+                    repeat = (this.readBits(2)) + 3
+                    fillLen = prevLen
+                }
+                if (codeLen == 17) {
+                    repeat = (this.readBits(3)) + 3
+                }
+                if (codeLen == 18) {
+                    repeat = (this.readBits(7)) + 11
+                }
+                if ((symbol + repeat) > numSymbols) {
+                    return (this.fail("code length repeat out of range"))
+                }
+                while (repeat > 0) {
+                    int_buffer_set lengths symbol fillLen
+                    symbol = symbol + 1
+                    repeat = repeat - 1
+                }
+            }
+        }
+        return true
+    }
+
+    ; ======================================================================
+    ; Entropy-coded image
+    ; ======================================================================
+
+    sfn subSampleSize:int (size:int bits:int) {
+        return (bit_shr (size + (bit_shl 1 bits) - 1) bits)
+    }
+
+    ; (0x1e35a7bd * argb) mod 2^32 >> (32 - bits), in pieces that stay
+    ; below 2^31 on a 32-bit int.
+    sfn hashPixel:int (argb:int bits:int) {
+        def lo:int (bit_and argb 65535)
+        def hi:int (bit_and (bit_ushr argb 16) 65535)
+        ; K = 0x1e35a7bd: high half 7733, low half 42941 = 167 * 256 + 189
+        def carry:int (bit_shr ((lo * 167) + (bit_shr (lo * 189) 8)) 8)
+        def mid:int ((bit_and (lo * 7733) 65535) + (bit_and ((bit_shl (bit_and (hi * 167) 255) 8) + (hi * 189)) 65535))
+        def top:int (bit_and (carry + mid) 65535)
+        return (bit_shr top (16 - bits))
+    }
+
+    ; distance / length prefix coding: symbol -> value (1-based)
+    fn copyDistance:int (sym:int) {
+        if (sym < 4) {
+            return (sym + 1)
+        }
+        def extra:int (bit_shr (sym - 2) 1)
+        def offset:int (bit_shl (2 + (bit_and sym 1)) extra)
+        return (offset + (this.readBits(extra)) + 1)
+    }
+
+    sfn planeCodeToDistance:int (xsize:int planeCode:int) {
+        if (planeCode > 120) {
+            return (planeCode - 120)
+        }
+        def codes:[int] ([] _:int (24 7 23 25 40 6 39 41 22 26 38 42 56 5 55 57 21 27 54 58 37 43 72 4 71 73 20 28 53 59 70 74 36 44 88 69 75 52 60 3 87 89 19 29 86 90 35 45 68 76 85 91 51 61 104 2 103 105 18 30 102 106 34 46 84 92 67 77 101 107 50 62 120 1 119 121 83 93 17 31 100 108 66 78 118 122 33 47 117 123 49 63 99 109 82 94 0 116 124 65 79 16 32 98 110 48 115 125 81 95 64 114 126 97 111 80 113 127 96 112))
+        def distCode:int (itemAt codes (planeCode - 1))
+        def yoffset:int (bit_shr distCode 4)
+        def xoffset:int (8 - (bit_and distCode 15))
+        def dist:int ((yoffset * xsize) + xoffset)
+        if (dist >= 1) {
+            return dist
+        }
+        return 1
+    }
+
+    ; Decodes one entropy-coded image of w x h pixels. The main image (the
+    ; last one of a level 0 stream) may carry meta prefix codes.
+    fn decodeImageData:int_buffer (w:int h:int isMain:boolean) {
+        def empty:int_buffer (int_buffer_alloc 0)
+        if ((w <= 0) || (h <= 0) || (((to_double w) * (to_double h)) > (to_double maxPixels))) {
+            this.fail("bad image size")
+            return empty
+        }
+        def total:int (w * h)
+        if (total <= 0) {
+            this.fail("bad image size")
+            return empty
+        }
+        ; color cache
+        def cacheBits:int 0
+        def cacheSize:int 0
+        if ((this.readBits(1)) == 1) {
+            cacheBits = (this.readBits(4))
+            if ((cacheBits < 1) || (cacheBits > 11)) {
+                this.fail("bad color cache size")
+                return empty
+            }
+            cacheSize = (bit_shl 1 cacheBits)
+            if (cacheBits > statCacheBits) {
+                statCacheBits = cacheBits
+            }
+        }
+        def cache:int_buffer (int_buffer_alloc (cacheSize + 1))
+        ; meta prefix codes
+        def metaBits:int 0
+        def metaW:int 0
+        def numGroups:int 1
+        def entropy:int_buffer (int_buffer_alloc 0)
+        if isMain {
+            if ((this.readBits(1)) == 1) {
+                metaBits = (this.readBits(3)) + 2
+                metaW = (VP8LDecoder.subSampleSize(w metaBits))
+                def metaH:int (VP8LDecoder.subSampleSize(h metaBits))
+                entropy = (this.decodeImageData(metaW metaH false))
+                if ((strlen error) > 0) {
+                    return empty
+                }
+                def n:int (metaW * metaH)
+                def k:int 0
+                while (k < n) {
+                    def g:int (bit_and (bit_shr (int_buffer_get entropy k) 8) 65535)
+                    int_buffer_set entropy k g
+                    if (g >= numGroups) {
+                        numGroups = g + 1
+                    }
+                    k = k + 1
+                }
+            }
+        }
+        if eos {
+            this.fail("truncated image header")
+            return empty
+        }
+        if (numGroups > statGroups) {
+            statGroups = numGroups
+        }
+        ; the prefix codes of this image; earlier levels are done with theirs
+        tablesUsed = 0
+        def codes:int_buffer (int_buffer_alloc (numGroups * 5))
+        def gi:int 0
+        while (gi < numGroups) {
+            def k:int 0
+            while (k < 5) {
+                def alphabet:int 256
+                if (k == 0) {
+                    alphabet = 280 + cacheSize
+                }
+                if (k == 4) {
+                    alphabet = 40
+                }
+                def c:int (this.readCode(alphabet))
+                if (c < 0) {
+                    return empty
+                }
+                int_buffer_set codes ((gi * 5) + k) c
+                k = k + 1
+            }
+            gi = gi + 1
+        }
+        ; pixels
+        def out:int_buffer (int_buffer_alloc total)
+        def i:int 0
+        def x:int 0
+        def y:int 0
+        def gbase:int 0
+        def colorLimit:int (280 + cacheSize)
+        def hasMeta:boolean (metaBits > 0)
+        while (i < total) {
+            if hasMeta {
+                gbase = (int_buffer_get entropy (((bit_shr y metaBits) * metaW) + (bit_shr x metaBits))) * 5
+            }
+            def code:int (this.readSymbol((int_buffer_get codes gbase)))
+            if (code < 256) {
+                def r:int (this.readSymbol((int_buffer_get codes (gbase + 1))))
+                def b:int (this.readSymbol((int_buffer_get codes (gbase + 2))))
+                def a:int (this.readSymbol((int_buffer_get codes (gbase + 3))))
+                def px:int (bit_or (bit_or (bit_shl a 24) (bit_shl r 16)) (bit_or (bit_shl code 8) b))
+                int_buffer_set out i px
+                if (cacheBits > 0) {
+                    int_buffer_set cache (VP8LDecoder.hashPixel(px cacheBits)) px
+                }
+                i = i + 1
+                x = x + 1
+                if (x >= w) {
+                    x = 0
+                    y = y + 1
+                }
+            } {
+                if (code < 280) {
+                    statBackRefs = statBackRefs + 1
+                    def length:int (this.copyDistance((code - 256)))
+                    def distSym:int (this.readSymbol((int_buffer_get codes (gbase + 4))))
+                    def distCode:int (this.copyDistance(distSym))
+                    def dist:int (VP8LDecoder.planeCodeToDistance(w distCode))
+                    if eos {
+                        this.fail("truncated image data")
+                        return empty
+                    }
+                    if ((i < dist) || ((total - i) < length)) {
+                        this.fail("backward reference out of range")
+                        return empty
+                    }
+                    def k:int 0
+                    while (k < length) {
+                        def px:int (int_buffer_get out (i - dist))
+                        int_buffer_set out i px
+                        if (cacheBits > 0) {
+                            int_buffer_set cache (VP8LDecoder.hashPixel(px cacheBits)) px
+                        }
+                        i = i + 1
+                        k = k + 1
+                    }
+                    x = x + length
+                    while (x >= w) {
+                        x = x - w
+                        y = y + 1
+                    }
+                } {
+                    if (code >= colorLimit) {
+                        this.fail("bad symbol")
+                        return empty
+                    }
+                    statCacheHits = statCacheHits + 1
+                    int_buffer_set out i (int_buffer_get cache (code - 280))
+                    i = i + 1
+                    x = x + 1
+                    if (x >= w) {
+                        x = 0
+                        y = y + 1
+                    }
+                }
+            }
+            if eos {
+                this.fail("truncated image data")
+                return empty
+            }
+        }
+        return out
+    }
+
+    ; ======================================================================
+    ; Transforms
+    ; ======================================================================
+
+    sfn addPixels:int (a:int b:int) {
+        def ag:int ((bit_and (bit_ushr a 8) 16711935) + (bit_and (bit_ushr b 8) 16711935))
+        def rb:int ((bit_and a 16711935) + (bit_and b 16711935))
+        return (bit_or (bit_shl (bit_and ag 16711935) 8) (bit_and rb 16711935))
+    }
+
+    sfn average2:int (a:int b:int) {
+        def ag:int ((bit_and (bit_ushr a 8) 16711935) + (bit_and (bit_ushr b 8) 16711935))
+        def rb:int ((bit_and a 16711935) + (bit_and b 16711935))
+        return (bit_or (bit_shl (bit_and (bit_shr ag 1) 16711935) 8) (bit_and (bit_shr rb 1) 16711935))
+    }
+
+    sfn clip255:int (v:int) {
+        if (v < 0) {
+            return 0
+        }
+        if (v > 255) {
+            return 255
+        }
+        return v
+    }
+
+    sfn absInt:int (v:int) {
+        if (v < 0) {
+            return (0 - v)
+        }
+        return v
+    }
+
+    ; the channel of packed pixel p at bit offset sh
+    sfn ch:int (p:int sh:int) {
+        return (bit_and (bit_shr p sh) 255)
+    }
+
+    sfn pack:int (a:int r:int g:int b:int) {
+        return (bit_or (bit_or (bit_shl a 24) (bit_shl r 16)) (bit_or (bit_shl g 8) b))
+    }
+
+    sfn select:int (t:int l:int tl:int) {
+        def d:int 0
+        def sh:int 0
+        while (sh < 32) {
+            def ct:int (VP8LDecoder.ch(t sh))
+            def cl:int (VP8LDecoder.ch(l sh))
+            def ctl:int (VP8LDecoder.ch(tl sh))
+            d = d + ((VP8LDecoder.absInt((cl - ctl))) - (VP8LDecoder.absInt((ct - ctl))))
+            sh = sh + 8
+        }
+        if (d <= 0) {
+            return t
+        }
+        return l
+    }
+
+    sfn clampAddSubtractFull:int (a:int b:int c:int) {
+        def al:int (VP8LDecoder.clip255(((VP8LDecoder.ch(a 24)) + (VP8LDecoder.ch(b 24)) - (VP8LDecoder.ch(c 24)))))
+        def r:int (VP8LDecoder.clip255(((VP8LDecoder.ch(a 16)) + (VP8LDecoder.ch(b 16)) - (VP8LDecoder.ch(c 16)))))
+        def g:int (VP8LDecoder.clip255(((VP8LDecoder.ch(a 8)) + (VP8LDecoder.ch(b 8)) - (VP8LDecoder.ch(c 8)))))
+        def bl:int (VP8LDecoder.clip255(((VP8LDecoder.ch(a 0)) + (VP8LDecoder.ch(b 0)) - (VP8LDecoder.ch(c 0)))))
+        return (VP8LDecoder.pack(al r g bl))
+    }
+
+    sfn halfChannel:int (a:int b:int) {
+        return (VP8LDecoder.clip255((a + (idiv (a - b) 2))))
+    }
+
+    sfn clampAddSubtractHalf:int (a:int b:int) {
+        def al:int (VP8LDecoder.halfChannel((VP8LDecoder.ch(a 24)) (VP8LDecoder.ch(b 24))))
+        def r:int (VP8LDecoder.halfChannel((VP8LDecoder.ch(a 16)) (VP8LDecoder.ch(b 16))))
+        def g:int (VP8LDecoder.halfChannel((VP8LDecoder.ch(a 8)) (VP8LDecoder.ch(b 8))))
+        def bl:int (VP8LDecoder.halfChannel((VP8LDecoder.ch(a 0)) (VP8LDecoder.ch(b 0))))
+        return (VP8LDecoder.pack(al r g bl))
+    }
+
+    ; The 14 predictors of the predictor transform (14 and 15 predict black,
+    ; as in libwebp).
+    sfn predict:int (mode:int l:int t:int tl:int tr:int) {
+        if (mode == 1) {
+            return l
+        }
+        if (mode == 2) {
+            return t
+        }
+        if (mode == 3) {
+            return tr
+        }
+        if (mode == 4) {
+            return tl
+        }
+        if (mode == 5) {
+            return (VP8LDecoder.average2((VP8LDecoder.average2(l tr)) t))
+        }
+        if (mode == 6) {
+            return (VP8LDecoder.average2(l tl))
+        }
+        if (mode == 7) {
+            return (VP8LDecoder.average2(l t))
+        }
+        if (mode == 8) {
+            return (VP8LDecoder.average2(tl t))
+        }
+        if (mode == 9) {
+            return (VP8LDecoder.average2(t tr))
+        }
+        if (mode == 10) {
+            return (VP8LDecoder.average2((VP8LDecoder.average2(l tl)) (VP8LDecoder.average2(t tr))))
+        }
+        if (mode == 11) {
+            return (VP8LDecoder.select(t l tl))
+        }
+        if (mode == 12) {
+            return (VP8LDecoder.clampAddSubtractFull(l t tl))
+        }
+        if (mode == 13) {
+            return (VP8LDecoder.clampAddSubtractHalf((VP8LDecoder.average2(l t)) tl))
+        }
+        return -16777216
+    }
+
+    fn inversePredictor:void (px:int_buffer w:int h:int bits:int modes:int_buffer) {
+        def tilesPerRow:int (VP8LDecoder.subSampleSize(w bits))
+        def y:int 0
+        while (y < h) {
+            def row:int (y * w)
+            def x:int 0
+            while (x < w) {
+                def i:int (row + x)
+                def pred:int 0
+                if (y == 0) {
+                    if (x == 0) {
+                        pred = -16777216
+                    } {
+                        pred = (int_buffer_get px (i - 1))
+                    }
+                } {
+                    if (x == 0) {
+                        pred = (int_buffer_get px (i - w))
+                    } {
+                        def mode:int (bit_and (bit_shr (int_buffer_get modes (((bit_shr y bits) * tilesPerRow) + (bit_shr x bits))) 8) 15)
+                        statPredModes = (bit_or statPredModes (bit_shl 1 mode))
+                        pred = (VP8LDecoder.predict(mode (int_buffer_get px (i - 1)) (int_buffer_get px (i - w)) (int_buffer_get px ((i - w) - 1)) (int_buffer_get px ((i - w) + 1))))
+                    }
+                }
+                int_buffer_set px i (VP8LDecoder.addPixels((int_buffer_get px i) pred))
+                x = x + 1
+            }
+            y = y + 1
+        }
+    }
+
+    sfn toInt8:int (v:int) {
+        if (v >= 128) {
+            return (v - 256)
+        }
+        return v
+    }
+
+    sfn colorDelta:int (pred:int color:int) {
+        return (bit_shr ((VP8LDecoder.toInt8(pred)) * (VP8LDecoder.toInt8(color))) 5)
+    }
+
+    fn inverseCrossColor:void (px:int_buffer w:int h:int bits:int mult:int_buffer) {
+        def tilesPerRow:int (VP8LDecoder.subSampleSize(w bits))
+        def y:int 0
+        while (y < h) {
+            def row:int (y * w)
+            def tileRow:int ((bit_shr y bits) * tilesPerRow)
+            def x:int 0
+            while (x < w) {
+                def m:int (int_buffer_get mult (tileRow + (bit_shr x bits)))
+                def g2r:int (bit_and m 255)
+                def g2b:int (bit_and (bit_shr m 8) 255)
+                def r2b:int (bit_and (bit_shr m 16) 255)
+                def p:int (int_buffer_get px (row + x))
+                def green:int (bit_and (bit_shr p 8) 255)
+                def red:int (bit_and ((bit_and (bit_shr p 16) 255) + (VP8LDecoder.colorDelta(g2r green))) 255)
+                def blue:int (bit_and p 255)
+                blue = (bit_and (blue + (VP8LDecoder.colorDelta(g2b green)) + (VP8LDecoder.colorDelta(r2b red))) 255)
+                int_buffer_set px (row + x) (bit_or (bit_and p -16711936) (bit_or (bit_shl red 16) blue))
+                x = x + 1
+            }
+            y = y + 1
+        }
+    }
+
+    fn inverseSubtractGreen:void (px:int_buffer n:int) {
+        def i:int 0
+        while (i < n) {
+            def p:int (int_buffer_get px i)
+            def green:int (bit_and (bit_shr p 8) 255)
+            def red:int (bit_and ((bit_and (bit_shr p 16) 255) + green) 255)
+            def blue:int (bit_and ((bit_and p 255) + green) 255)
+            int_buffer_set px i (bit_or (bit_and p -16711936) (bit_or (bit_shl red 16) blue))
+            i = i + 1
+        }
+    }
+
+    ; packed indices (width packedW) -> colors (width w)
+    fn inverseColorIndex:int_buffer (px:int_buffer w:int h:int bits:int palette:int_buffer) {
+        def out:int_buffer (int_buffer_alloc (w * h))
+        def packedW:int (VP8LDecoder.subSampleSize(w bits))
+        def bitsPerPixel:int (bit_shr 8 bits)
+        def countMask:int ((bit_shl 1 bits) - 1)
+        def bitMask:int ((bit_shl 1 bitsPerPixel) - 1)
+        def y:int 0
+        while (y < h) {
+            def src:int (y * packedW)
+            def dst:int (y * w)
+            def packed:int 0
+            def x:int 0
+            while (x < w) {
+                if ((bit_and x countMask) == 0) {
+                    packed = (bit_and (bit_shr (int_buffer_get px src) 8) 255)
+                    src = src + 1
+                }
+                int_buffer_set out (dst + x) (int_buffer_get palette (bit_and packed bitMask))
+                packed = (bit_shr packed bitsPerPixel)
+                x = x + 1
+            }
+            y = y + 1
+        }
+        return out
+    }
+
+    ; ======================================================================
+    ; Streams
+    ; ======================================================================
+
+    ; A level 0 image: transforms, then the main entropy-coded image, then the
+    ; transforms undone in reverse order. Returns w * h ARGB pixels.
+    fn decodeLevel0:int_buffer (w:int h:int) {
+        def empty:int_buffer (int_buffer_alloc 0)
+        def types:int_buffer (int_buffer_alloc 4)
+        def tbits:int_buffer (int_buffer_alloc 4)
+        def widths:int_buffer (int_buffer_alloc 4)
+        def data0:int_buffer (int_buffer_alloc 0)
+        def data1:int_buffer (int_buffer_alloc 0)
+        def data3:int_buffer (int_buffer_alloc 0)
+        def seen:int 0
+        def count:int 0
+        def xsize:int w
+        while ((this.readBits(1)) == 1) {
+            def t:int (this.readBits(2))
+            if ((bit_and seen (bit_shl 1 t)) != 0) {
+                this.fail("transform repeated")
+                return empty
+            }
+            seen = (bit_or seen (bit_shl 1 t))
+            statTransforms = (bit_or statTransforms (bit_shl 1 t))
+            int_buffer_set types count t
+            int_buffer_set widths count xsize
+            if ((t == 0) || (t == 1)) {
+                def b:int ((this.readBits(3)) + 2)
+                int_buffer_set tbits count b
+                def sub:int_buffer (this.decodeImageData((VP8LDecoder.subSampleSize(xsize b)) (VP8LDecoder.subSampleSize(h b)) false))
+                if ((strlen error) > 0) {
+                    return empty
+                }
+                if (t == 0) {
+                    data0 = sub
+                } {
+                    data1 = sub
+                }
+            }
+            if (t == 3) {
+                def numColors:int ((this.readBits(8)) + 1)
+                def b:int 0
+                if (numColors <= 16) {
+                    b = 1
+                }
+                if (numColors <= 4) {
+                    b = 2
+                }
+                if (numColors <= 2) {
+                    b = 3
+                }
+                int_buffer_set tbits count b
+                statBundleBits = b
+                def pal:int_buffer (this.decodeImageData(numColors 1 false))
+                if ((strlen error) > 0) {
+                    return empty
+                }
+                ; the palette is delta coded; entries past it are transparent black
+                def palSize:int (bit_shl 1 (bit_shr 8 b))
+                def full:int_buffer (int_buffer_alloc palSize)
+                def prev:int 0
+                def k:int 0
+                while (k < numColors) {
+                    prev = (VP8LDecoder.addPixels(prev (int_buffer_get pal k)))
+                    int_buffer_set full k prev
+                    k = k + 1
+                }
+                data3 = full
+                xsize = (VP8LDecoder.subSampleSize(xsize b))
+            }
+            count = count + 1
+        }
+        if eos {
+            this.fail("truncated transforms")
+            return empty
+        }
+        def px:int_buffer (this.decodeImageData(xsize h true))
+        if ((strlen error) > 0) {
+            return empty
+        }
+        def j:int (count - 1)
+        while (j >= 0) {
+            def t:int (int_buffer_get types j)
+            def tw:int (int_buffer_get widths j)
+            if (t == 0) {
+                this.inversePredictor(px tw h (int_buffer_get tbits j) data0)
+            }
+            if (t == 1) {
+                this.inverseCrossColor(px tw h (int_buffer_get tbits j) data1)
+            }
+            if (t == 2) {
+                this.inverseSubtractGreen(px (tw * h))
+            }
+            if (t == 3) {
+                px = (this.inverseColorIndex(px tw h (int_buffer_get tbits j) data3))
+            }
+            j = j - 1
+        }
+        return px
+    }
+
+    fn resetStats:void () {
+        statTransforms = 0
+        statPredModes = 0
+        statCacheBits = 0
+        statGroups = 0
+        statSimpleCodes = 0
+        statNormalCodes = 0
+        statBackRefs = 0
+        statCacheHits = 0
+        statBundleBits = -1
+    }
+
+    ; Decodes a VP8L chunk payload (signature byte and header included).
+    ; On success `argb`, `width`, `height` and `hasAlpha` are set.
+    fn decode:boolean (src:buffer start:int size:int maxDim:int) {
+        error = ""
+        this.resetStats()
+        if (size < 5) {
+            return (this.fail("VP8L chunk too small"))
+        }
+        this.initBits(src start size)
+        if ((this.readBits(8)) != 47) {
+            return (this.fail("bad VP8L signature"))
+        }
+        width = (this.readBits(14)) + 1
+        height = (this.readBits(14)) + 1
+        hasAlpha = ((this.readBits(1)) == 1)
+        if ((this.readBits(3)) != 0) {
+            return (this.fail("unsupported VP8L version"))
+        }
+        if ((width > maxDim) || (height > maxDim) || (((to_double width) * (to_double height)) > (to_double maxPixels))) {
+            return (this.fail("image too large"))
+        }
+        argb = (this.decodeLevel0(width height))
+        if ((strlen error) > 0) {
+            return false
+        }
+        return true
+    }
+
+    ; Decodes the headerless VP8L stream of a compressed ALPH chunk; `argb`
+    ; then holds w * h pixels whose green channel is the alpha value.
+    fn decodeAlphaStream:boolean (src:buffer start:int size:int w:int h:int) {
+        error = ""
+        this.resetStats()
+        this.initBits(src start size)
+        width = w
+        height = h
+        argb = (this.decodeLevel0(w h))
+        if ((strlen error) > 0) {
+            return false
+        }
+        return true
+    }
+}