ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/image/README.md

@@ -0,0 +1,33 @@
+# `image` — the codecs
+
+The JPEG, PNG and WebP decoders, the PNG encoder, and the byte and pixel buffers
+they read and write. EVG decodes `<img>` sources through them, the PDF
+tools embed images through them, and the raster painters draw into
+`RasterBuffer`.
+
+| File | |
+| --- | --- |
+| `Buffer.rgr` | growable byte buffer with the readers the decoders need |
+| `ImageBuffer.rgr` | RGBA pixels with width and height |
+| `RasterBuffer.rgr` | the raster target the painters write, over `ImageBuffer` |
+| `JPEGDecoder.rgr`, `ProgressiveJPEGDecoder.rgr` | baseline and progressive JPEG, with `BitReader`, `HuffmanDecoder`, `DCT` |
+| `PNGDecoder.rgr` | PNG, over `pkg:zip/Inflate.rgr` |
+| `WebPDecoder.rgr` | WebP: lossy (`VP8BoolDecoder`, `WebPLossy`), lossless (`WebPLossless`), alpha, first frame of an animation; a port of libwebp's decoder logic, tested against libwebp in `tests/` |
+| `PNGEncoder.rgr`, `Deflate.rgr` | PNG out, with its own DEFLATE compressor |
+| `PPMImage.rgr` | PPM, for the decoder tests |
+
+Import from another package as `Import "pkg:image/JPEGDecoder.rgr"` with
+`"image": { "path": "…/lib/image" }` in `ranger.json`; the `zip` package it
+needs is a sibling path dependency and comes along.
+
+`WebPDecoder` returns an RGBA `ImageBuffer` that matches libwebp byte for
+byte and never throws on bad input: check `ok` (and `error`) after
+`decodeBytes`. Its tests run on JavaScript and C++ with
+`bash lib/image/tests/run_webp_tests.sh`; the fixtures and their expected
+checksums are regenerated by `testdata/webp/gen_fixtures.py`.
+
+**License: MIT.** These are published formats and generic utilities —
+the same rule that put `lib/zip` on the MIT side. The WebP decoder follows
+the decoding logic of libwebp (Copyright Google Inc., BSD-3-Clause), as its
+file headers say. See
+[LICENSING.md](../../LICENSING.md).

package/dist/lib/image/RasterBuffer.rgr

@@ -0,0 +1,294 @@
+; SPDX-License-Identifier: MIT
+
+; RasterBuffer - Core pixel buffer for EVG raster rendering
+; Provides RGBA pixel storage with basic operations
+; Compatible with ImageBuffer from JPEG encoder
+
+Import "Buffer.rgr"
+Import "ImageBuffer.rgr"
+
+; A single RGBA pixel
+class RasterPixel {
+    def r:int 0
+    def g:int 0
+    def b:int 0
+    def a:int 255
+    
+    fn init:void (red:int green:int blue:int alpha:int) {
+        r = red
+        g = green
+        b = blue
+        a = alpha
+    }
+    
+    fn initRGB:void (red:int green:int blue:int) {
+        r = red
+        g = green
+        b = blue
+        a = 255
+    }
+    
+    fn clone:RasterPixel () {
+        def p:RasterPixel (new RasterPixel())
+        p.r = r
+        p.g = g
+        p.b = b
+        p.a = a
+        return p
+    }
+}
+
+; Main raster buffer class - uses native binary buffer for efficiency
+; Compatible with ImageBuffer used by JPEGEncoder
+class RasterBuffer {
+    def width:int 0
+    def height:int 0
+    def pixels:buffer (buffer_alloc 0)
+    
+    ; Create a new buffer with given dimensions
+    fn create:void (w:int h:int) {
+        width = w
+        height = h
+        def size:int (w * h * 4)
+        pixels = (buffer_alloc size)
+        buffer_fill pixels 0 0 size
+    }
+    
+    ; Create and fill with a color
+    fn createWithColor:void (w:int h:int r:int g:int b:int a:int) {
+        this.create(w h)
+        this.fill(r g b a)
+    }
+    
+    ; Get pixel index in flat array
+    fn getIndex:int (x:int y:int) {
+        return ((y * width + x) * 4)
+    }
+    
+    ; Check if coordinates are in bounds
+    fn inBounds:boolean (x:int y:int) {
+        if (x < 0) {
+            return false
+        }
+        if (y < 0) {
+            return false
+        }
+        if (x >= width) {
+            return false
+        }
+        if (y >= height) {
+            return false
+        }
+        return true
+    }
+    
+    ; Set pixel at x,y with RGBA values (0-255)
+    fn setPixel:void (x:int y:int r:int g:int b:int a:int) {
+        if ((this.inBounds(x y)) == false) {
+            return
+        }
+        def idx:int (this.getIndex(x y))
+        buffer_set pixels idx r
+        buffer_set pixels (idx + 1) g
+        buffer_set pixels (idx + 2) b
+        buffer_set pixels (idx + 3) a
+    }
+    
+    ; Set pixel from RasterPixel object
+    fn setPixelObj:void (x:int y:int p:RasterPixel) {
+        this.setPixel(x y p.r p.g p.b p.a)
+    }
+    
+    ; Get pixel at x,y - returns RasterPixel
+    fn getPixel:RasterPixel (x:int y:int) {
+        def p:RasterPixel (new RasterPixel())
+        if ((this.inBounds(x y)) == false) {
+            return p
+        }
+        def idx:int (this.getIndex(x y))
+        p.r = (buffer_get pixels idx)
+        p.g = (buffer_get pixels (idx + 1))
+        p.b = (buffer_get pixels (idx + 2))
+        p.a = (buffer_get pixels (idx + 3))
+        return p
+    }
+    
+    ; Get individual color component
+    fn getR:int (x:int y:int) {
+        if ((this.inBounds(x y)) == false) {
+            return 0
+        }
+        def idx:int (this.getIndex(x y))
+        return (buffer_get pixels idx)
+    }
+    
+    fn getG:int (x:int y:int) {
+        if ((this.inBounds(x y)) == false) {
+            return 0
+        }
+        def idx:int (this.getIndex(x y))
+        return (buffer_get pixels (idx + 1))
+    }
+    
+    fn getB:int (x:int y:int) {
+        if ((this.inBounds(x y)) == false) {
+            return 0
+        }
+        def idx:int (this.getIndex(x y))
+        return (buffer_get pixels (idx + 2))
+    }
+    
+    fn getA:int (x:int y:int) {
+        if ((this.inBounds(x y)) == false) {
+            return 0
+        }
+        def idx:int (this.getIndex(x y))
+        return (buffer_get pixels (idx + 3))
+    }
+    
+    ; Fill entire buffer with a color
+    fn fill:void (r:int g:int b:int a:int) {
+        def size:int (width * height)
+        def i:int 0
+        while (i < size) {
+            def idx:int (i * 4)
+            buffer_set pixels idx r
+            buffer_set pixels (idx + 1) g
+            buffer_set pixels (idx + 2) b
+            buffer_set pixels (idx + 3) a
+            i = i + 1
+        }
+    }
+    
+    ; Clear buffer to transparent black
+    fn clear:void () {
+        this.fill(0 0 0 0)
+    }
+    
+    ; Clear buffer to opaque white
+    fn clearWhite:void () {
+        this.fill(255 255 255 255)
+    }
+    
+    ; Fill a rectangular region
+    fn fillRect:void (x:int y:int w:int h:int r:int g:int b:int a:int) {
+        def endX:int (x + w)
+        def endY:int (y + h)
+        
+        ; Clamp to bounds
+        if (x < 0) {
+            x = 0
+        }
+        if (y < 0) {
+            y = 0
+        }
+        if (endX > width) {
+            endX = width
+        }
+        if (endY > height) {
+            endY = height
+        }
+        
+        def py:int y
+        while (py < endY) {
+            def px:int x
+            while (px < endX) {
+                this.setPixel(px py r g b a)
+                px = px + 1
+            }
+            py = py + 1
+        }
+    }
+    
+    ; Copy a region from another buffer
+    fn copyFrom:void (src:RasterBuffer srcX:int srcY:int dstX:int dstY:int w:int h:int) {
+        def sy:int 0
+        while (sy < h) {
+            def sx:int 0
+            while (sx < w) {
+                def p:RasterPixel (src.getPixel((srcX + sx) (srcY + sy)))
+                this.setPixel((dstX + sx) (dstY + sy) p.r p.g p.b p.a)
+                sx = sx + 1
+            }
+            sy = sy + 1
+        }
+    }
+    
+    ; Create a copy of this buffer
+    fn clone:RasterBuffer () {
+        def copy:RasterBuffer (new RasterBuffer())
+        copy.create(width height)
+        def size:int (width * height * 4)
+        buffer_copy copy.pixels 0 pixels 0 size
+        return copy
+    }
+    
+    ; Get total number of pixels
+    fn getPixelCount:int () {
+        return (width * height)
+    }
+    
+    ; Get total size in bytes
+    fn getByteSize:int () {
+        return (width * height * 4)
+    }
+    
+    ; ============================================================
+    ; JPEG Encoder Compatibility - Convert to/from ImageBuffer
+    ; ============================================================
+    
+    ; Convert to ImageBuffer for JPEG encoding
+    fn toImageBuffer:ImageBuffer () {
+        def img:ImageBuffer (new ImageBuffer())
+        img.init(width height)
+        
+        def size:int (width * height * 4)
+        def i:int 0
+        while (i < size) {
+            def r:int (buffer_get pixels i)
+            def g:int (buffer_get pixels (i + 1))
+            def b:int (buffer_get pixels (i + 2))
+            def a:int (buffer_get pixels (i + 3))
+            
+            ; If pixel has alpha < 255, blend with white background
+            ; (JPEG doesn't support alpha)
+            if (a < 255) {
+                def alpha:double ((to_double a) / 255.0)
+                def invAlpha:double (1.0 - alpha)
+                r = (to_int (((to_double r) * alpha) + (255.0 * invAlpha)))
+                g = (to_int (((to_double g) * alpha) + (255.0 * invAlpha)))
+                b = (to_int (((to_double b) * alpha) + (255.0 * invAlpha)))
+            }
+            
+            buffer_set img.pixels i r
+            buffer_set img.pixels (i + 1) g
+            buffer_set img.pixels (i + 2) b
+            buffer_set img.pixels (i + 3) 255
+            
+            i = i + 4
+        }
+        
+        return img
+    }
+    
+    ; Load from ImageBuffer (sets alpha to 255)
+    fn fromImageBuffer:void (img:ImageBuffer) {
+        this.create(img.width img.height)
+        
+        def size:int (img.width * img.height * 4)
+        def i:int 0
+        while (i < size) {
+            buffer_set pixels i (buffer_get img.pixels i)
+            buffer_set pixels (i + 1) (buffer_get img.pixels (i + 1))
+            buffer_set pixels (i + 2) (buffer_get img.pixels (i + 2))
+            buffer_set pixels (i + 3) 255  ; ImageBuffer stores alpha but often unused
+            i = i + 4
+        }
+    }
+    
+    ; Direct access to raw pixel buffer (for advanced use)
+    fn getRawBuffer:buffer () {
+        return pixels
+    }
+}
+

package/dist/lib/image/VP8BoolDecoder.rgr

@@ -0,0 +1,163 @@
+; SPDX-License-Identifier: MIT
+
+; VP8BoolDecoder.rgr - the boolean entropy decoder of VP8 (RFC 6386 section 7),
+; used by the lossy half of the WebP decoder (WebPLossy.rgr).
+;
+; A port of the bit reader in libwebp (src/utils/bit_reader_*), by way of
+; simplewebp: the same 24-bit refill, the same end-of-data behaviour and the
+; same shortcut for sign bits, so a stream decodes to exactly the bits
+; libwebp reads from it. libwebp is Copyright Google Inc., BSD-3-Clause;
+; this port is MIT like the rest of lib/image.
+;
+; `range` holds range - 1, as in libwebp. `value` holds up to 31 bits, so the
+; arithmetic stays inside a 32-bit int on every target: a valid stream never
+; has more than 7 bits pending when the next bytes come in, and the masks on
+; the refills only matter for corrupt data, where they keep the value in range
+; instead of overflowing.
+
+class VP8BoolDecoder {
+    def data:buffer (buffer_alloc 0)
+    def bufEnd:int 0
+    def bufMax:int 0
+    def pos:int 0
+    def value:int 0
+    def range:int 254
+    def bits:int -8
+    def eof:boolean false
+    def log2tab:int_buffer (int_buffer_alloc 256)
+
+    Constructor () {
+        ; floor(log2(n)) for 1..255
+        def n:int 1
+        while (n < 256) {
+            def l:int 0
+            def v:int n
+            while (v > 1) {
+                v = (bit_shr v 1)
+                l = l + 1
+            }
+            int_buffer_set log2tab n l
+            n = n + 1
+        }
+    }
+
+    ; Start reading `size` bytes of `src` at `start`. The bytes are copied, so
+    ; the decoder does not depend on the caller's buffer afterwards. A range
+    ; that runs past the end of `src` is clipped to it.
+    fn init: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)
+        bufEnd = (e - s)
+        bufMax = 0
+        if (bufEnd >= 4) {
+            bufMax = (bufEnd - 3)
+        }
+        pos = 0
+        value = 0
+        range = 254
+        bits = -8
+        eof = false
+        this.load()
+    }
+
+    fn load:void () {
+        if (pos < bufMax) {
+            def b0:int (buffer_get data pos)
+            def b1:int (buffer_get data (pos + 1))
+            def b2:int (buffer_get data (pos + 2))
+            pos = pos + 3
+            value = (bit_or (bit_or (bit_or b2 (bit_shl b1 8)) (bit_shl b0 16)) (bit_shl (bit_and value 127) 24))
+            bits = bits + 24
+            return
+        }
+        if (pos < bufEnd) {
+            bits = bits + 8
+            value = (bit_or (buffer_get data pos) (bit_shl (bit_and value 8388607) 8))
+            pos = pos + 1
+            return
+        }
+        if (eof == false) {
+            value = (bit_shl (bit_and value 8388607) 8)
+            bits = bits + 8
+            eof = true
+            return
+        }
+        bits = 0
+    }
+
+    ; One bit with probability prob/256 of being zero.
+    fn getBit:int (prob:int) {
+        def rng:int range
+        if (bits < 0) {
+            this.load()
+        }
+        def p:int bits
+        def split:int (bit_shr (rng * prob) 8)
+        def v:int (bit_and (bit_shr value p) 255)
+        def bit:int 0
+        if (v > split) {
+            rng = rng - split
+            value = value - (bit_shl (split + 1) p)
+            bit = 1
+        } {
+            rng = split + 1
+        }
+        def shift:int (7 - (int_buffer_get log2tab rng))
+        rng = (bit_shl rng shift)
+        bits = bits - shift
+        range = rng - 1
+        return bit
+    }
+
+    ; An unsigned value of n bits, most significant bit first.
+    fn getValue:int (n:int) {
+        def v:int 0
+        def k:int n
+        while (k > 0) {
+            k = k - 1
+            v = (bit_or v (bit_shl (this.getBit(128)) k))
+        }
+        return v
+    }
+
+    ; n bits of magnitude followed by a sign bit.
+    fn getSignedValue:int (n:int) {
+        def v:int (this.getValue(n))
+        if ((this.getValue(1)) == 1) {
+            return (0 - v)
+        }
+        return v
+    }
+
+    ; v with a sign read at probability one half (libwebp VP8GetSigned).
+    fn getSigned:int (v:int) {
+        if (bits < 0) {
+            this.load()
+        }
+        def p:int bits
+        def split:int (bit_shr range 1)
+        def val:int (bit_shr value p)
+        bits = bits - 1
+        if (val > split) {
+            range = (bit_or (bit_and (range + 255) 255) 1)
+            value = value - (bit_shl (split + 1) p)
+            return (0 - v)
+        }
+        range = (bit_or range 1)
+        return v
+    }
+}