ranger-compiler 3.5.1 → 3.5.2

package/dist/lib/image/WebPDecoder.rgr

@@ -0,0 +1,433 @@
+; SPDX-License-Identifier: MIT
+
+; WebPDecoder.rgr - WebP (RFC 9649) -> RGBA ImageBuffer, no third-party code.
+;
+;   def dec (new WebPDecoder())
+;   def img:ImageBuffer (dec.decodeBytes(bytes))
+;   if dec.ok { ... img.width, img.height, img.pixels (RGBA, 4 bytes a pixel) }
+;
+; Supported: the simple lossy ('VP8 ') and lossless ('VP8L') formats, and the
+; extended format ('VP8X') with an ALPH chunk (uncompressed or VP8L
+; compressed, all four filters, the pre-processing flag accepted) beside a
+; 'VP8 ' frame, or a 'VP8L' frame. Unknown chunks (ICCP, EXIF, XMP, ...) are
+; skipped. An animation ('ANIM' / 'ANMF') decodes to its first frame, placed
+; at its offset on a transparent canvas of the animation's size, which is
+; what libwebp's animation decoder returns for frame one.
+;
+; A malformed, truncated or oversized file never throws or reads out of
+; bounds: decodeBytes returns a 1x1 image with `ok` false and the reason in
+; `error`. Each side is capped by maxDimension (16384) and the area by
+; maxPixels.
+;
+; The decoding logic follows libwebp (Copyright Google Inc., BSD-3-Clause);
+; see WebPLossy.rgr and WebPLossless.rgr. The output matches libwebp's RGBA
+; (and simplewebp's) byte for byte. This port is MIT like the rest of lib/image.
+
+Import "Buffer.rgr"
+Import "ImageBuffer.rgr"
+Import "VP8BoolDecoder.rgr"
+Import "WebPLossless.rgr"
+Import "WebPLossy.rgr"
+
+class WebPDecoder {
+    def ok:boolean false
+    def error:string ""
+    def quiet:boolean true
+
+    ; what the last decode found
+    def width:int 0
+    def height:int 0
+    def hasAlpha:boolean false
+    def isLossless:boolean false
+    def isAnimated:boolean false
+    def frameCount:int 0
+    def alphaMethod:int -1
+    def alphaFilter:int -1
+    def alphaPreprocessing:int -1
+
+    def maxDimension:int 16384
+    def maxPixels:int 100000000
+
+    def lossless:VP8LDecoder (new VP8LDecoder())
+    def lossy:VP8Decoder (new VP8Decoder())
+
+    ; the frame decoded by decodeFrameChunks
+    def frame:ImageBuffer (new ImageBuffer())
+
+    Constructor () {
+    }
+
+    sfn u16le:int (b:buffer p:int) {
+        return (bit_or (buffer_get b p) (bit_shl (buffer_get b (p + 1)) 8))
+    }
+
+    sfn u24le:int (b:buffer p:int) {
+        return (bit_or (WebPDecoder.u16le(b p)) (bit_shl (buffer_get b (p + 2)) 16))
+    }
+
+    ; a chunk size; sizes of 2^31 and more come out negative and are rejected
+    sfn u32le:int (b:buffer p:int) {
+        return (bit_or (WebPDecoder.u24le(b p)) (bit_shl (buffer_get b (p + 3)) 24))
+    }
+
+    sfn tagIs:boolean (b:buffer p:int tag:string) {
+        def i:int 0
+        while (i < 4) {
+            if ((buffer_get b (p + i)) != (charAt tag i)) {
+                return false
+            }
+            i = i + 1
+        }
+        return true
+    }
+
+    ; True when the bytes start like a WebP file (RIFF....WEBP).
+    sfn isWebP:boolean (b:buffer) {
+        if ((buffer_length b) < 12) {
+            return false
+        }
+        if ((WebPDecoder.tagIs(b 0 "RIFF")) == false) {
+            return false
+        }
+        return (WebPDecoder.tagIs(b 8 "WEBP"))
+    }
+
+    fn fail:boolean (msg:string) {
+        if ((strlen error) == 0) {
+            error = msg
+        }
+        return false
+    }
+
+    fn decode:ImageBuffer (dir:string fileName:string) {
+        def bytes:buffer (buffer_read_file dir fileName)
+        return (this.decodeBytes(bytes))
+    }
+
+    ; Decodes a WebP file held in memory. Check `ok` afterwards.
+    fn decodeBytes:ImageBuffer (bytes:buffer) {
+        ok = false
+        error = ""
+        width = 0
+        height = 0
+        hasAlpha = false
+        isLossless = false
+        isAnimated = false
+        frameCount = 0
+        alphaMethod = -1
+        alphaFilter = -1
+        alphaPreprocessing = -1
+        lossless.maxPixels = maxPixels
+        lossy.maxPixels = maxPixels
+        def img:ImageBuffer (new ImageBuffer())
+        if (this.parse(bytes)) {
+            img = frame
+            ok = true
+        } {
+            img.init(1 1)
+            if (quiet == false) {
+                print ("[webp_decoder] " + error)
+            }
+        }
+        frame = (new ImageBuffer())
+        return img
+    }
+
+    fn parse:boolean (b:buffer) {
+        def len:int (buffer_length b)
+        if (len < 12) {
+            return (this.fail("not a WebP file: too small"))
+        }
+        if (((WebPDecoder.tagIs(b 0 "RIFF")) == false) || ((WebPDecoder.tagIs(b 8 "WEBP")) == false)) {
+            return (this.fail("not a WebP file: bad RIFF header"))
+        }
+        def riffSize:int (WebPDecoder.u32le(b 4))
+        if (riffSize < 12) {
+            return (this.fail("bad RIFF size"))
+        }
+        if (riffSize > (len - 8)) {
+            return (this.fail("truncated file"))
+        }
+        def end:int (8 + riffSize)
+        if ((12 + 8) > end) {
+            return (this.fail("no chunks"))
+        }
+        if (WebPDecoder.tagIs(b 12 "VP8X")) {
+            return (this.parseExtended(b end))
+        }
+        return (this.decodeFrameChunks(b 12 end 0 0))
+    }
+
+    ; the bounds of the chunk at p inside [p, end): payload size, or -1
+    fn chunkSize:int (b:buffer p:int end:int) {
+        if ((p + 8) > end) {
+            this.fail("truncated chunk header")
+            return -1
+        }
+        def size:int (WebPDecoder.u32le(b (p + 4)))
+        if ((size < 0) || (size > ((end - p) - 8))) {
+            this.fail("truncated chunk")
+            return -1
+        }
+        return size
+    }
+
+    sfn nextChunk:int (p:int size:int) {
+        return (((p + 8) + size) + (bit_and size 1))
+    }
+
+    fn parseExtended:boolean (b:buffer end:int) {
+        def size:int (this.chunkSize(b 12 end))
+        if (size < 0) {
+            return false
+        }
+        if (size != 10) {
+            return (this.fail("bad VP8X chunk size"))
+        }
+        def flags:int (buffer_get b 20)
+        def canvasW:int ((WebPDecoder.u24le(b 24)) + 1)
+        def canvasH:int ((WebPDecoder.u24le(b 27)) + 1)
+        if ((canvasW > maxDimension) || (canvasH > maxDimension) || (((to_double canvasW) * (to_double canvasH)) > (to_double maxPixels))) {
+            return (this.fail("image too large"))
+        }
+        def p:int (WebPDecoder.nextChunk(12 size))
+        if ((bit_and flags 2) == 0) {
+            if ((this.decodeFrameChunks(b p end canvasW canvasH)) == false) {
+                return false
+            }
+            return true
+        }
+        ; animation: the first ANMF frame on a transparent canvas
+        isAnimated = true
+        def firstFrame:int -1
+        def firstSize:int 0
+        while (p < end) {
+            def cs:int (this.chunkSize(b p end))
+            if (cs < 0) {
+                return false
+            }
+            if (WebPDecoder.tagIs(b p "ANMF")) {
+                frameCount = frameCount + 1
+                if (firstFrame < 0) {
+                    firstFrame = p
+                    firstSize = cs
+                }
+            }
+            p = (WebPDecoder.nextChunk(p cs))
+        }
+        if (firstFrame < 0) {
+            return (this.fail("animation without frames"))
+        }
+        if (firstSize < 16) {
+            return (this.fail("bad ANMF chunk"))
+        }
+        def fp:int (firstFrame + 8)
+        def fx:int ((WebPDecoder.u24le(b fp)) * 2)
+        def fy:int ((WebPDecoder.u24le(b (fp + 3))) * 2)
+        def fw:int ((WebPDecoder.u24le(b (fp + 6))) + 1)
+        def fh:int ((WebPDecoder.u24le(b (fp + 9))) + 1)
+        if (((fx + fw) > canvasW) || ((fy + fh) > canvasH)) {
+            return (this.fail("frame outside the canvas"))
+        }
+        if ((this.decodeFrameChunks(b (fp + 16) ((fp + firstSize)) fw fh)) == false) {
+            return false
+        }
+        def canvas:ImageBuffer (new ImageBuffer())
+        canvas.initClear(canvasW canvasH)
+        canvas.fillTransparent()
+        def row:int 0
+        while (row < fh) {
+            buffer_copy canvas.pixels ((((fy + row) * canvasW) + fx) * 4) frame.pixels ((row * fw) * 4) (fw * 4)
+            row = row + 1
+        }
+        frame = canvas
+        width = canvasW
+        height = canvasH
+        hasAlpha = true
+        return true
+    }
+
+    ; Walks the chunks in [p, end) up to the first 'VP8 ' or 'VP8L' and decodes
+    ; that frame into `frame`, with the ALPH chunk before it. expectW / expectH,
+    ; when not 0, is the size the container announced.
+    fn decodeFrameChunks:boolean (b:buffer start:int end:int expectW:int expectH:int) {
+        def alphStart:int -1
+        def alphSize:int 0
+        def p:int start
+        while (p < end) {
+            def cs:int (this.chunkSize(b p end))
+            if (cs < 0) {
+                return false
+            }
+            if (WebPDecoder.tagIs(b p "ALPH")) {
+                alphStart = p + 8
+                alphSize = cs
+            }
+            if (WebPDecoder.tagIs(b p "VP8L")) {
+                return (this.decodeLossless(b (p + 8) cs expectW expectH))
+            }
+            if (WebPDecoder.tagIs(b p "VP8 ")) {
+                return (this.decodeLossy(b (p + 8) cs expectW expectH alphStart alphSize))
+            }
+            p = (WebPDecoder.nextChunk(p cs))
+        }
+        return (this.fail("no image data"))
+    }
+
+    fn checkSize:boolean (w:int h:int expectW:int expectH:int) {
+        if ((expectW > 0) && ((w != expectW) || (h != expectH))) {
+            return (this.fail("frame size does not match the canvas"))
+        }
+        return true
+    }
+
+    fn decodeLossless:boolean (b:buffer start:int size:int expectW:int expectH:int) {
+        isLossless = true
+        if ((lossless.decode(b start size maxDimension)) == false) {
+            return (this.fail(lossless.error))
+        }
+        def w:int lossless.width
+        def h:int lossless.height
+        if ((this.checkSize(w h expectW expectH)) == false) {
+            return false
+        }
+        width = w
+        height = h
+        hasAlpha = lossless.hasAlpha
+        frame = (new ImageBuffer())
+        frame.initClear(w h)
+        def n:int (w * h)
+        def i:int 0
+        while (i < n) {
+            def p:int (int_buffer_get lossless.argb i)
+            def o:int (i * 4)
+            buffer_set frame.pixels o (bit_and (bit_shr p 16) 255)
+            buffer_set frame.pixels (o + 1) (bit_and (bit_shr p 8) 255)
+            buffer_set frame.pixels (o + 2) (bit_and p 255)
+            buffer_set frame.pixels (o + 3) (bit_and (bit_shr p 24) 255)
+            i = i + 1
+        }
+        lossless.argb = (int_buffer_alloc 0)
+        return true
+    }
+
+    fn decodeLossy:boolean (b:buffer start:int size:int expectW:int expectH:int alphStart:int alphSize:int) {
+        if ((lossy.decodeHeader(b start size maxDimension)) == false) {
+            return (this.fail(lossy.error))
+        }
+        def w:int lossy.width
+        def h:int lossy.height
+        if ((this.checkSize(w h expectW expectH)) == false) {
+            return false
+        }
+        if ((lossy.decodeFrame()) == false) {
+            return (this.fail(lossy.error))
+        }
+        width = w
+        height = h
+        def alpha:buffer (buffer_alloc 0)
+        def withAlpha:boolean false
+        if (alphStart >= 0) {
+            alpha = (this.decodeAlpha(b alphStart alphSize w h))
+            if ((strlen error) > 0) {
+                return false
+            }
+            withAlpha = true
+        }
+        hasAlpha = withAlpha
+        frame = (new ImageBuffer())
+        lossy.toRGBA(frame alpha withAlpha)
+        lossy.yPlane = (buffer_alloc 0)
+        lossy.uPlane = (buffer_alloc 0)
+        lossy.vPlane = (buffer_alloc 0)
+        return true
+    }
+
+    ; The alpha plane of an ALPH chunk (RFC 9649 section 2.7.1.2).
+    fn decodeAlpha:buffer (b:buffer start:int size:int w:int h:int) {
+        def empty:buffer (buffer_alloc 0)
+        if (size <= 1) {
+            this.fail("ALPH chunk too small")
+            return empty
+        }
+        def hdr:int (buffer_get b start)
+        def method:int (bit_and hdr 3)
+        def filter:int (bit_and (bit_shr hdr 2) 3)
+        def pre:int (bit_and (bit_shr hdr 4) 3)
+        alphaMethod = method
+        alphaFilter = filter
+        alphaPreprocessing = pre
+        if ((method > 1) || (pre > 1) || ((bit_shr hdr 6) != 0)) {
+            this.fail("bad ALPH header")
+            return empty
+        }
+        def n:int (w * h)
+        def a:buffer (buffer_alloc n)
+        if (method == 0) {
+            if ((size - 1) < n) {
+                this.fail("ALPH data too short")
+                return empty
+            }
+            buffer_copy a 0 b (start + 1) n
+        } {
+            if ((lossless.decodeAlphaStream(b (start + 1) (size - 1) w h)) == false) {
+                this.fail(("alpha: " + lossless.error))
+                return empty
+            }
+            def i:int 0
+            while (i < n) {
+                buffer_set a i (bit_and (bit_shr (int_buffer_get lossless.argb i) 8) 255)
+                i = i + 1
+            }
+            lossless.argb = (int_buffer_alloc 0)
+        }
+        WebPDecoder.unfilterAlpha(a w h filter)
+        return a
+    }
+
+    ; Undoes the alpha filtering in place: 1 horizontal, 2 vertical, 3 gradient.
+    ; The first row always predicts from the left, the first column from above.
+    sfn unfilterAlpha:void (a:buffer w:int h:int filter:int) {
+        if (filter == 0) {
+            return
+        }
+        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 = (buffer_get a (i - 1))
+                    }
+                } {
+                    if (x == 0) {
+                        pred = (buffer_get a (i - w))
+                    } {
+                        if (filter == 1) {
+                            pred = (buffer_get a (i - 1))
+                        }
+                        if (filter == 2) {
+                            pred = (buffer_get a (i - w))
+                        }
+                        if (filter == 3) {
+                            def g:int (((buffer_get a (i - 1)) + (buffer_get a (i - w))) - (buffer_get a ((i - w) - 1)))
+                            if (g < 0) {
+                                g = 0
+                            }
+                            if (g > 255) {
+                                g = 255
+                            }
+                            pred = g
+                        }
+                    }
+                }
+                buffer_set a i (bit_and ((buffer_get a i) + pred) 255)
+                x = x + 1
+            }
+            y = y + 1
+        }
+    }
+}