// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT

// --------

// ETC1 / ETC2 is a lossy, fixed-rate texture compression format. ETC1 uses 8
// bytes per 4×4 pixel block, 0.5 bytes per pixel (after rounding image
// dimensions up to a multiple of 4). The ETC1 specification is at:
// http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt
//
// That's the raw format for uploading to GPUs. The iPACKMAN file format (*.pkm
// files) prepends a 16-byte header, stating width, height and pixel format.
//
// Android v2.2 Froyo (2010) and its OpenGL ES shipped with ETC1 / PKM support.
// AOSP has a software implementation, used by its etc1tool program:
// https://cs.android.com/android/platform/superproject/main/+/main:frameworks/native/opengl/libs/ETC1/etc1.cpp;l=200;drc=efb735f4d5a2f04550e33e8aa9485f906018fe4e
//
// ETC2 (mandatory in OpenGL ES 3.0; see the 3.0 spec Appendix C.1 or the 3.2
// spec Appendix C.2 "ETC Compressed Texture Image Formats") extends ETC1 in a
// backwards-compatible way by re-purposing bit patterns that well-behaved
// encoders wouldn't emit. It also uses 8 bytes per 4×4 block (0.5 bytes per
// pixel), unless producing 8-bit alpha (instead of no alpha or 1-bit alpha),
// in which case it's doubled to 16 bytes per 4×4 block (1 byte per pixel).
//
// https://registry.khronos.org/OpenGL/specs/es/3.0/es_spec_3.0.pdf
// https://registry.khronos.org/OpenGL/specs/es/3.2/es_spec_3.2.pdf
// https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html#ETC1
// https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html#ETC1S
// https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html#ETC2
// https://www.khronos.org/assets/uploads/developers/library/2012-siggraph-opengl-es-bof/Ericsson-ETC2-SIGGRAPH_Aug12.pdf
// https://www.graphicshardware.org/previous/www_2007/presentations/strom-etc2-gh07.pdf
// https://github.com/Ericsson/ETCPACK
// https://en.wikipedia.org/wiki/Ericsson_Texture_Compression

pub status "#bad header"
pub status "#truncated input"

pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0

pub struct decoder? implements base.image_decoder(
        pixfmt : base.u32,
        width  : base.u32[..= 0xFFFF],
        height : base.u32[..= 0xFFFF],

        // The call sequence state machine is discussed in
        // (/doc/std/image-decoders-call-sequence.md).
        call_sequence : base.u8,

        srgb : base.bool,

        num_buffered_blocks : base.u32[..= 64],

        dst_x : base.u32,
        dst_y : base.u32,

        swizzler : base.pixel_swizzler,
        util     : base.utility,
) + (
        // Usually, with 8 (instead of 16) bytes per block, colors[0] is unused
        // and colors[1] holds color codes.
        //
        // For RGBA8, colors[0] and colors[1] hold alpha and color codes.
        //
        // For RG11U / RG11S, colors[0] and colors[1] hold red and green codes.
        colors : array[2] array[64] base.u64,

        // buffer holds 64 blocks. Each block is 4×4 pixels, 64 bytes.
        buffer : array[4096] base.u8,
)

pub func decoder.get_quirk(key: base.u32) base.u64 {
    return 0
}

pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
    return base."#unsupported option"
}

pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
    var status : base.status

    while true {
        status =? this.do_decode_image_config?(dst: args.dst, src: args.src)
        if (status == base."$short read") and args.src.is_closed() {
            return "#truncated input"
        }
        yield? status
    }
}

pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
    var c32               : base.u32
    var i                 : base.u32
    var rounded_up_width  : base.u16
    var rounded_up_height : base.u16

    if this.call_sequence <> 0x00 {
        return base."#bad call sequence"
    }

    c32 = args.src.read_u32le?()
    if c32 <> 'PKM 'le {
        return "#bad header"
    }

    c32 = args.src.read_u32le?()
    if (c32 == '10\x00\x00'le) or  //        ETC1.
            (c32 == '20\x00\x01'le) or  //   ETC2  RGB.
            (c32 == '20\x00\x09'le) {  //    ETC2 sRGB.
        this.pixfmt = base.PIXEL_FORMAT__BGRX
    } else if (c32 == '20\x00\x03'le) or  // ETC2  RGBA8.
            (c32 == '20\x00\x0A'le) {  //    ETC2 sRGBA8.
        this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
    } else if (c32 == '20\x00\x04'le) or  // ETC2  RGBA1.
            (c32 == '20\x00\x0B'le) {  //    ETC2 sRGBA1.
        this.pixfmt = base.PIXEL_FORMAT__BGRA_BINARY
    } else if (c32 == '20\x00\x05'le) {  //  ETC2  R11U.
        this.pixfmt = base.PIXEL_FORMAT__Y_16LE
        choose from_colors_to_buffer = [from_colors_to_buffer_r11u]
    } else if (c32 == '20\x00\x06'le) {  //  ETC2  RG11U.
        this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
        choose from_colors_to_buffer = [from_colors_to_buffer_rg11u]
    } else if (c32 == '20\x00\x07'le) {  //  ETC2  R11S.
        this.pixfmt = base.PIXEL_FORMAT__Y_16LE
        choose from_colors_to_buffer = [from_colors_to_buffer_r11s]
    } else if (c32 == '20\x00\x08'le) {  //  ETC2  RG11S.
        this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
        choose from_colors_to_buffer = [from_colors_to_buffer_rg11s]
    } else {
        return "#bad header"
    }
    this.srgb = (c32 >> 24) >= 0x09

    if this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE {
        i = 0
        while i <= (4096 - 8) {
            this.buffer[i + 0] = 0x00
            this.buffer[i + 1] = 0x00
            this.buffer[i + 6] = 0xFF
            this.buffer[i + 7] = 0xFF
            i += 8
        }
    }

    rounded_up_width = args.src.read_u16be?()
    rounded_up_height = args.src.read_u16be?()

    c32 = args.src.read_u16be_as_u32?()
    if ((c32 + 3) & 0xFFFF_FFFC) <> (rounded_up_width as base.u32) {
        return "#bad header"
    }
    this.width = c32

    c32 = args.src.read_u16be_as_u32?()
    if ((c32 + 3) & 0xFFFF_FFFC) <> (rounded_up_height as base.u32) {
        return "#bad header"
    }
    this.height = c32

    if args.dst <> nullptr {
        args.dst.set!(
                pixfmt: this.pixfmt,
                pixsub: 0,
                width: this.width,
                height: this.height,
                first_frame_io_position: 16,
                first_frame_is_opaque: this.pixfmt == base.PIXEL_FORMAT__BGRX)
    }

    this.call_sequence = 0x20
}

pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
    var status : base.status

    while true {
        status =? this.do_decode_frame_config?(dst: args.dst, src: args.src)
        if (status == base."$short read") and args.src.is_closed() {
            return "#truncated input"
        }
        yield? status
    }
}

pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
    var pixfmt : base.pixel_format

    if this.call_sequence == 0x20 {
        // No-op.
    } else if this.call_sequence < 0x20 {
        this.do_decode_image_config?(dst: nullptr, src: args.src)
    } else if this.call_sequence == 0x28 {
        if 16 <> args.src.position() {
            return base."#bad restart"
        }
    } else if this.call_sequence == 0x40 {
        this.call_sequence = 0x60
        return base."@end of data"
    } else {
        return base."@end of data"
    }

    if args.dst <> nullptr {
        pixfmt = this.util.make_pixel_format(repr: this.pixfmt)
        args.dst.set!(bounds: this.util.make_rect_ie_u32(
                min_incl_x: 0,
                min_incl_y: 0,
                max_excl_x: this.width,
                max_excl_y: this.height),
                duration: 0,
                index: 0,
                io_position: 16,
                disposal: 0,
                opaque_within_bounds: this.pixfmt == base.PIXEL_FORMAT__BGRX,
                overwrite_instead_of_blend: false,
                background_color: pixfmt.default_background_color())
    }

    this.call_sequence = 0x40
}

pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
    var status : base.status

    while true {
        status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
        if (status == base."$short read") and args.src.is_closed() {
            return "#truncated input"
        }
        yield? status
    }
}

pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
    var remaining : base.u32[..= 0x1000_0000]
    var max_nbb   : base.u32[..= 64]
    var status    : base.status

    if this.call_sequence == 0x40 {
        // No-op.
    } else if this.call_sequence < 0x40 {
        this.do_decode_frame_config?(dst: nullptr, src: args.src)
    } else {
        return base."@end of data"
    }

    status = this.swizzler.prepare!(
            dst_pixfmt: args.dst.pixel_format(),
            dst_palette: args.dst.palette(),
            src_pixfmt: this.util.make_pixel_format(repr: this.pixfmt),
            src_palette: this.util.empty_slice_u8(),
            blend: args.blend)
    if not status.is_ok() {
        return status
    }

    this.dst_x = 0
    this.dst_y = 0

    remaining = ((this.width + 3) / 4) * ((this.height + 3) / 4)
    while remaining > 0 {
        max_nbb = 64
        if ((this.pixfmt == base.PIXEL_FORMAT__Y_16LE)) or
                (this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE) {
            max_nbb = 32
        }
        this.num_buffered_blocks = remaining.min(no_more_than: max_nbb)
        if remaining < this.num_buffered_blocks {
            return base."#too much data"
        }
        remaining -= this.num_buffered_blocks

        this.from_src_to_colors?(src: args.src)
        this.from_colors_to_buffer!()
        if this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL {
            this.from_alphas_to_buffer!()
        }
        status = this.from_buffer_to_dst!(dst: args.dst)
        if not status.is_ok() {
            return status
        }
    }

    this.call_sequence = 0x60
}

pri func decoder.from_src_to_colors?(src: base.io_reader) {
    var bi : base.u32[..= 64]

    while bi < this.num_buffered_blocks {
        assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks)
        if (this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL) or
                (this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE) {
            this.colors[0][bi] = args.src.read_u64be?()
        }
        this.colors[1][bi] = args.src.read_u64be?()
        bi += 1
    }
}

pri func decoder.from_colors_to_buffer!(),
        choosy,
{
    var bi    : base.u32[..= 64]
    var color : base.u64
    var r0    : base.u32
    var r1    : base.u32
    var g0    : base.u32
    var g1    : base.u32
    var b0    : base.u32
    var b1    : base.u32
    var diff  : base.bool
    var tran  : base.bool
    var flip  : base.bool

    while bi < this.num_buffered_blocks {
        assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks)
        color = this.colors[1][bi]

        diff = (color & 0x2_0000_0000) <> 0
        tran = (not diff) and (this.pixfmt == base.PIXEL_FORMAT__BGRA_BINARY)
        if (not diff) and (this.pixfmt <> base.PIXEL_FORMAT__BGRA_BINARY) {
            // The high 32 bits of color:
            //
            // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32  dec
            // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20  hex
            // R0 r0 r0 r0 R1 r1 r1 r1 G0 g0 g0 g0 G1 g1 g1 g1 B0 b0 b0 b0 B1 b1 b1 b1 W0 w0 w0 W1 w1 w1 00 Fl

            r0 = (0x0F & (color >> 0x3C)) as base.u32
            r0 = (r0 << 4) | r0
            r1 = (0x0F & (color >> 0x38)) as base.u32
            r1 = (r1 << 4) | r1

            g0 = (0x0F & (color >> 0x34)) as base.u32
            g0 = (g0 << 4) | g0
            g1 = (0x0F & (color >> 0x30)) as base.u32
            g1 = (g1 << 4) | g1

            b0 = (0x0F & (color >> 0x2C)) as base.u32
            b0 = (b0 << 4) | b0
            b1 = (0x0F & (color >> 0x28)) as base.u32
            b1 = (b1 << 4) | b1

        } else {
            // The high 32 bits of color (unless ETC2's T / H / Planar modes):
            //
            // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32  dec
            // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20  hex
            // R0 r0 r0 r0 r0 R1 r1 r1 G0 g0 g0 g0 g0 G1 g1 g1 B0 b0 b0 b0 b0 B1 b1 b1 W0 w0 w0 W1 w1 w1 .. Fl

            r0 = (0x1F & (color >> 0x3B)) as base.u32
            r1 = r0 ~mod+ DIFFS[0x07 & (color >> 0x38)]
            if (r1 >> 5) <> 0 {
                this.decode_t_mode!(
                        bits: color,
                        offset: 16 * bi,
                        transparent: tran)
                bi += 1
                continue
            }
            r0 = (r0 ~mod<< 3) | (r0 >> 2)
            r1 = (r1 ~mod<< 3) | (r1 >> 2)

            g0 = (0x1F & (color >> 0x33)) as base.u32
            g1 = g0 ~mod+ DIFFS[0x07 & (color >> 0x30)]
            if (g1 >> 5) <> 0 {
                this.decode_h_mode!(
                        bits: color,
                        offset: 16 * bi,
                        transparent: tran)
                bi += 1
                continue
            }
            g0 = (g0 ~mod<< 3) | (g0 >> 2)
            g1 = (g1 ~mod<< 3) | (g1 >> 2)

            b0 = (0x1F & (color >> 0x2B)) as base.u32
            b1 = b0 ~mod+ DIFFS[0x07 & (color >> 0x28)]
            if (b1 >> 5) <> 0 {
                this.decode_planar_mode!(
                        bits: color,
                        offset: 16 * bi)
                bi += 1
                continue
            }
            b0 = (b0 ~mod<< 3) | (b0 >> 2)
            b1 = (b1 ~mod<< 3) | (b1 >> 2)
        }

        flip = (color & 0x1_0000_0000) <> 0
        this.decode_half_block!(
                bits: (color & 0xFFFF_FFFF) as base.u32,
                offset: 16 * bi,
                which: ((color >> 0x25) & 7) as base.u32,
                r: r0,
                g: g0,
                b: b0,
                flip: flip,
                transparent: tran,
                second: false)
        this.decode_half_block!(
                bits: (color & 0xFFFF_FFFF) as base.u32,
                offset: 16 * bi,
                which: ((color >> 0x22) & 7) as base.u32,
                r: r1,
                g: g1,
                b: b1,
                flip: flip,
                transparent: tran,
                second: true)

        bi += 1
    }
}

pri func decoder.decode_t_mode!(
        bits: base.u64,
        offset: base.u32[..= 1008],
        transparent: base.bool) {
    var r : array[4] base.u8
    var g : array[4] base.u8
    var b : array[4] base.u8
    var a : array[4] base.u8

    var which : base.u32[..= 7]
    var delta : base.u32

    var y     : base.u32
    var x     : base.u32
    var x4y   : base.u32[..= 15]
    var index : base.u32[..= 3]
    var o     : base.u32[..= 4092]

    // Unjumble T-mode's 59 bits and convert from RGB444 to RGB888.
    //
    // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32  dec
    // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20  hex
    // .. .. .. R0 r0 .. r0 r0 G0 g0 g0 g0 B0 b0 b0 b0 R2 r2 r2 r2 G2 g2 g2 g2 B2 b2 b2 b2 Wh wh .. wh
    //
    // The low 32 bits hold "2 bits per pixel" indexes into the r, g, b arrays.

    r[0] = ((0x0C & (args.bits >> 0x39)) as base.u8) |
            ((0x03 & (args.bits >> 0x38)) as base.u8)
    r[0] = (r[0] << 4) | r[0]
    g[0] = (0x0F & (args.bits >> 0x34)) as base.u8
    g[0] = (g[0] << 4) | g[0]
    b[0] = (0x0F & (args.bits >> 0x30)) as base.u8
    b[0] = (b[0] << 4) | b[0]
    a[0] = 0xFF

    r[2] = (0x0F & (args.bits >> 0x2C)) as base.u8
    r[2] = (r[2] << 4) | r[2]
    g[2] = (0x0F & (args.bits >> 0x28)) as base.u8
    g[2] = (g[2] << 4) | g[2]
    b[2] = (0x0F & (args.bits >> 0x24)) as base.u8
    b[2] = (b[2] << 4) | b[2]
    a[2] = 0xFF

    // Modulate and apply transparency.

    which = ((0x06 & (args.bits >> 0x21)) as base.u32) |
            ((0x01 & (args.bits >> 0x20)) as base.u32)
    delta = T_H_MODIFIERS[which] as base.u32

    r[1] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023]
    g[1] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023]
    b[1] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023]
    a[1] = 0xFF

    r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023]
    g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023]
    b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023]
    a[3] = 0xFF

    if args.transparent {
        r[2] = 0
        g[2] = 0
        b[2] = 0
        a[2] = 0
    }

    // Paint the 4×4 block.

    while y < 4 {
        x = 0
        while x < 4,
                inv y < 4,
        {
            x4y = (x * 4) | y
            index = (((args.bits >> x4y) & 1) as base.u32) |
                    (((args.bits >> (x4y + 15)) & 2) as base.u32)
            o = args.offset + (x * 4) + (y * 1024)
            this.buffer[o + 0] = b[index]
            this.buffer[o + 1] = g[index]
            this.buffer[o + 2] = r[index]
            this.buffer[o + 3] = a[index]
            x += 1
        }
        y += 1
    }
}

pri func decoder.decode_h_mode!(
        bits: base.u64,
        offset: base.u32[..= 1008],
        transparent: base.bool) {
    var r : array[4] base.u8
    var g : array[4] base.u8
    var b : array[4] base.u8
    var a : array[4] base.u8

    var rgb0  : base.u32
    var rgb2  : base.u32
    var which : base.u32[..= 7]
    var delta : base.u32

    var y     : base.u32
    var x     : base.u32
    var x4y   : base.u32[..= 15]
    var index : base.u32[..= 3]
    var o     : base.u32[..= 4092]

    // Unjumble H-mode's 58 bits (one of the 'which' bits is implied by order)
    // and convert from RGB444 to RGB888.
    //
    // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32  dec
    // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20  hex
    // .. R0 r0 r0 r0 G0 g0 g0 .. .. .. g0 B0 .. b0 b0 b0 R2 r2 r2 r2 G2 g2 g2 g2 B2 b2 b2 b2 Wh .. wh
    //
    // The low 32 bits hold "2 bits per pixel" indexes into the r, g, b arrays.

    r[0] = (0x0F & (args.bits >> 0x3B)) as base.u8
    r[0] = (r[0] << 4) | r[0]
    g[0] = ((0x0E & (args.bits >> 0x37)) as base.u8) |
            ((0x01 & (args.bits >> 0x34)) as base.u8)
    g[0] = (g[0] << 4) | g[0]
    b[0] = ((0x08 & (args.bits >> 0x30)) as base.u8) |
            ((0x07 & (args.bits >> 0x2F)) as base.u8)
    b[0] = (b[0] << 4) | b[0]

    r[2] = (0x0F & (args.bits >> 0x2B)) as base.u8
    r[2] = (r[2] << 4) | r[2]
    g[2] = (0x0F & (args.bits >> 0x27)) as base.u8
    g[2] = (g[2] << 4) | g[2]
    b[2] = (0x0F & (args.bits >> 0x23)) as base.u8
    b[2] = (b[2] << 4) | b[2]

    // Modulate and apply transparency.

    rgb0 = ((r[0] as base.u32) << 0x10) |
            ((g[0] as base.u32) << 0x08) |
            ((b[0] as base.u32) << 0x00)
    rgb2 = ((r[2] as base.u32) << 0x10) |
            ((g[2] as base.u32) << 0x08) |
            ((b[2] as base.u32) << 0x00)
    which = ((0x04 & (args.bits >> 0x20)) as base.u32) |
            ((0x02 & (args.bits >> 0x1F)) as base.u32)
    if rgb0 >= rgb2 {
        which |= 1
    }
    delta = T_H_MODIFIERS[which] as base.u32

    r[1] = CLAMP[((r[0] as base.u32) ~mod- delta) & 1023]
    g[1] = CLAMP[((g[0] as base.u32) ~mod- delta) & 1023]
    b[1] = CLAMP[((b[0] as base.u32) ~mod- delta) & 1023]
    a[1] = 0xFF

    r[0] = CLAMP[((r[0] as base.u32) ~mod+ delta) & 1023]
    g[0] = CLAMP[((g[0] as base.u32) ~mod+ delta) & 1023]
    b[0] = CLAMP[((b[0] as base.u32) ~mod+ delta) & 1023]
    a[0] = 0xFF

    r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023]
    g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023]
    b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023]
    a[3] = 0xFF

    r[2] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023]
    g[2] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023]
    b[2] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023]
    a[2] = 0xFF

    if args.transparent {
        r[2] = 0
        g[2] = 0
        b[2] = 0
        a[2] = 0
    }

    // Paint the 4×4 block.

    while y < 4 {
        x = 0
        while x < 4,
                inv y < 4,
        {
            x4y = (x * 4) | y
            index = (((args.bits >> x4y) & 1) as base.u32) |
                    (((args.bits >> (x4y + 15)) & 2) as base.u32)
            o = args.offset + (x * 4) + (y * 1024)
            this.buffer[o + 0] = b[index]
            this.buffer[o + 1] = g[index]
            this.buffer[o + 2] = r[index]
            this.buffer[o + 3] = a[index]
            x += 1
        }
        y += 1
    }
}

pri func decoder.decode_planar_mode!(
        bits: base.u64,
        offset: base.u32[..= 1008]) {
    var ro : base.u32
    var go : base.u32
    var bo : base.u32
    var rh : base.u32
    var gh : base.u32
    var bh : base.u32
    var rv : base.u32
    var gv : base.u32
    var bv : base.u32

    var y  : base.u32
    var x  : base.u32
    var o  : base.u32[..= 4092]
    var rp : base.u32
    var gp : base.u32
    var bp : base.u32

    // Unjumble Planar-mode's 57 bits and convert from RGB676 to RGB888.
    //
    // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32  dec
    // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20  hex
    // .. Ro ro ro ro ro ro Go .. go go go go go go Bo .. .. .. bo bo .. bo bo bo Rh rh rh rh rh .. rh
    //
    // 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0  dec
    // 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00  hex
    // Gh gh gh gh gh gh gh Bh bh bh bh bh bh Rv rv rv rv rv rv Gv gv gv gv gv gv gv Bv bv bv bv bv bv

    ro = (0x3F & (args.bits >> 0x39)) as base.u32
    ro = (ro ~mod<< 2) | (ro >> 4)
    go = ((0x40 & (args.bits >> 0x32)) as base.u32) |
            ((0x3F & (args.bits >> 0x31)) as base.u32)
    go = (go ~mod<< 1) | (go >> 6)
    bo = ((0x20 & (args.bits >> 0x2B)) as base.u32) |
            ((0x18 & (args.bits >> 0x28)) as base.u32) |
            ((0x07 & (args.bits >> 0x27)) as base.u32)
    bo = (bo ~mod<< 2) | (bo >> 4)

    rh = ((0x3E & (args.bits >> 0x21)) as base.u32) |
            ((0x01 & (args.bits >> 0x20)) as base.u32)
    rh = (rh ~mod<< 2) | (rh >> 4)
    gh = (0x7F & (args.bits >> 0x19)) as base.u32
    gh = (gh ~mod<< 1) | (gh >> 6)
    bh = (0x3F & (args.bits >> 0x13)) as base.u32
    bh = (bh ~mod<< 2) | (bh >> 4)

    rv = (0x3F & (args.bits >> 0x0D)) as base.u32
    rv = (rv ~mod<< 2) | (rv >> 4)
    gv = (0x7F & (args.bits >> 0x06)) as base.u32
    gv = (gv ~mod<< 1) | (gv >> 6)
    bv = (0x3F & (args.bits >> 0x00)) as base.u32
    bv = (bv ~mod<< 2) | (bv >> 4)

    // Convert h and v colors from absolute to relative.

    rh ~mod-= ro
    gh ~mod-= go
    bh ~mod-= bo

    rv ~mod-= ro
    gv ~mod-= go
    bv ~mod-= bo

    // Prepare to linearly interpolate (which involves dividing by 4).

    ro ~mod*= 4
    go ~mod*= 4
    bo ~mod*= 4

    // Paint the 4×4 block.

    while y < 4 {
        x = 0
        while x < 4,
                inv y < 4,
        {
            o = args.offset + (x * 4) + (y * 1024)
            bp = ((x ~mod* bh) ~mod+ (y ~mod* bv)) ~mod+ bo
            this.buffer[o + 0] = CLAMP[((bp ~mod+ 2) / 4) & 1023]
            gp = ((x ~mod* gh) ~mod+ (y ~mod* gv)) ~mod+ go
            this.buffer[o + 1] = CLAMP[((gp ~mod+ 2) / 4) & 1023]
            rp = ((x ~mod* rh) ~mod+ (y ~mod* rv)) ~mod+ ro
            this.buffer[o + 2] = CLAMP[((rp ~mod+ 2) / 4) & 1023]
            x += 1
            this.buffer[o + 3] = 0xFF
        }
        y += 1
    }
}

pri func decoder.decode_half_block!(
        bits: base.u32,
        offset: base.u32[..= 1008],
        which: base.u32[..= 7],
        r: base.u32,
        g: base.u32,
        b: base.u32,
        flip: base.bool,
        transparent: base.bool,
        second: base.bool) {
    var which : base.u32[..= 15]
    var x0    : base.u32[..= 2]
    var y0    : base.u32[..= 2]
    var x     : base.u32[..= 3]
    var y     : base.u32[..= 3]
    var i     : base.u32
    var x4y   : base.u32[..= 15]
    var index : base.u32[..= 3]
    var modif : base.u32
    var o     : base.u32[..= 4092]

    which = args.which
    if args.transparent {
        which |= 8
    }

    if not args.second {
        // No-op.
    } else if args.flip {
        y0 = 2
    } else {
        x0 = 2
    }

    while i < 8 {
        if args.flip {
            x = (x0 + (i / 2)) & 3
            y = (y0 + (i & 1))
        } else {
            x = (x0 + (i / 4))
            y = (y0 + i) & 3
        }

        x4y = (x * 4) | y
        index = ((args.bits >> x4y) & 1) |
                ((args.bits >> (x4y + 15)) & 2)
        modif = MODIFIERS[which][index]

        o = args.offset + (x * 4) + (y * 1024)
        if args.transparent and (index == 2) {
            this.buffer[o + 0] = 0
            this.buffer[o + 1] = 0
            this.buffer[o + 2] = 0
            this.buffer[o + 3] = 0
        } else {
            this.buffer[o + 0] = CLAMP[(args.b ~mod+ modif) & 1023]
            this.buffer[o + 1] = CLAMP[(args.g ~mod+ modif) & 1023]
            this.buffer[o + 2] = CLAMP[(args.r ~mod+ modif) & 1023]
            this.buffer[o + 3] = 0xFF
        }

        i += 1
    }
}

pri func decoder.from_alphas_to_buffer!() {
    var bi         : base.u32[..= 64]
    var alpha      : base.u64
    var a0         : base.u32
    var multiplier : base.u32[..= 15]
    var which      : base.u32[..= 15]
    var offset     : base.u32[..= 1008]
    var y          : base.u32
    var x          : base.u32
    var shift      : base.u32[..= 45]
    var delta      : base.u32
    var o          : base.u32[..= 4092]

    while bi < this.num_buffered_blocks {
        assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks)
        alpha = this.colors[0][bi]

        a0 = (alpha >> 56) as base.u32
        multiplier = ((alpha >> 52) & 0x0F) as base.u32
        which = ((alpha >> 48) & 0x0F) as base.u32

        offset = 16 * bi
        y = 0
        while y < 4,
                inv bi < 64,
        {
            x = 0
            while x < 4,
                    inv bi < 64,
                    inv y < 4,
            {
                shift = (((x ^ 3) * 4) | (y ^ 3)) * 3
                delta = multiplier ~mod* ALPHA_MODIFIERS[which][7 & (alpha >> shift)]
                o = offset + (x * 4) + (y * 1024)
                this.buffer[o + 3] = CLAMP[(a0 ~mod+ delta) & 1023]
                x += 1
            }
            y += 1
        }

        bi += 1
    }
}

pri func decoder.from_colors_to_buffer_r11u!() {
    this.from_colors_to_buffer_unsigned!(input: 1, dst_bytes_per_pixel: 2, offset_adjustment: 0)
}

pri func decoder.from_colors_to_buffer_r11s!() {
    this.from_colors_to_buffer_signed!(input: 1, dst_bytes_per_pixel: 2, offset_adjustment: 0)
}

pri func decoder.from_colors_to_buffer_rg11u!() {
    this.from_colors_to_buffer_unsigned!(input: 0, dst_bytes_per_pixel: 8, offset_adjustment: 4)
    this.from_colors_to_buffer_unsigned!(input: 1, dst_bytes_per_pixel: 8, offset_adjustment: 2)
}

pri func decoder.from_colors_to_buffer_rg11s!() {
    this.from_colors_to_buffer_signed!(input: 0, dst_bytes_per_pixel: 8, offset_adjustment: 4)
    this.from_colors_to_buffer_signed!(input: 1, dst_bytes_per_pixel: 8, offset_adjustment: 2)
}

pri func decoder.from_colors_to_buffer_unsigned!(input: base.u32[..= 1], dst_bytes_per_pixel: base.u32[..= 8], offset_adjustment: base.u32[..= 4]) {
    var nbb        : base.u32[..= 32]
    var bi         : base.u32[..= 32]
    var color      : base.u64
    var c0         : base.u32
    var multiplier : base.u32[..= 120]
    var which      : base.u32[..= 15]
    var offset     : base.u32[..= 996]
    var y          : base.u32
    var x          : base.u32
    var shift      : base.u32[..= 45]
    var delta      : base.u32
    var c11        : base.u32
    var c16        : base.u32
    var o          : base.u32[..= 4092]

    nbb = this.num_buffered_blocks.min(no_more_than: 32)
    while bi < nbb {
        assert bi < 32 via "a < b: a < c; c <= b"(c: nbb)
        color = this.colors[args.input][bi]

        c0 = (((color >> 56) as base.u32) * 8) + 4
        multiplier = ((color >> 52) & 0x0F) as base.u32
        multiplier *= 8
        if multiplier == 0 {
            multiplier = 1
        }
        which = ((color >> 48) & 0x0F) as base.u32

        offset = (4 * args.dst_bytes_per_pixel * bi) + args.offset_adjustment
        y = 0
        while y < 4,
                inv bi < 32,
        {
            x = 0
            while x < 4,
                    inv bi < 32,
                    inv y < 4,
            {
                shift = (((x ^ 3) * 4) | (y ^ 3)) * 3
                delta = multiplier ~mod* ALPHA_MODIFIERS[which][7 & (color >> shift)]
                c11 = c0 ~mod+ delta
                if c11 >= 0x8000_0000 {
                    c11 = 0
                    assert c11 <= 2047
                } else if c11 > 2047 {
                    c11 = 2047
                    assert c11 <= 2047
                }
                c16 = (c11 << 5) | (c11 >> 6)
                o = offset + (x * args.dst_bytes_per_pixel) + (y * 1024)
                this.buffer[o + 0] = ((c16 >> 0) & 0xFF) as base.u8
                this.buffer[o + 1] = ((c16 >> 8) & 0xFF) as base.u8
                x += 1
            }
            y += 1
        }

        bi += 1
    }
}

pri func decoder.from_colors_to_buffer_signed!(input: base.u32[..= 1], dst_bytes_per_pixel: base.u32[..= 8], offset_adjustment: base.u32[..= 4]) {
    var nbb        : base.u32[..= 32]
    var bi         : base.u32[..= 32]
    var color      : base.u64
    var c0         : base.u32
    var multiplier : base.u32[..= 120]
    var which      : base.u32[..= 15]
    var offset     : base.u32[..= 996]
    var y          : base.u32
    var x          : base.u32
    var shift      : base.u32[..= 45]
    var delta      : base.u32
    var c11        : base.u32
    var c16        : base.u32
    var o          : base.u32[..= 4092]

    nbb = this.num_buffered_blocks.min(no_more_than: 32)
    while bi < nbb {
        assert bi < 32 via "a < b: a < c; c <= b"(c: nbb)
        color = this.colors[args.input][bi]

        c0 = ((color >> 56) as base.u32) * 8
        if c0 < (0x80 * 8) {
            // No-op.
        } else if c0 == (0x80 * 8) {
            c0 = 0xFFFF_FC08
        } else {
            c0 ~mod-= (0x100 * 8)
        }
        multiplier = ((color >> 52) & 0x0F) as base.u32
        multiplier *= 8
        if multiplier == 0 {
            multiplier = 1
        }
        which = ((color >> 48) & 0x0F) as base.u32

        offset = (4 * args.dst_bytes_per_pixel * bi) + args.offset_adjustment
        y = 0
        while y < 4,
                inv bi < 32,
        {
            x = 0
            while x < 4,
                    inv bi < 32,
                    inv y < 4,
            {
                shift = (((x ^ 3) * 4) | (y ^ 3)) * 3
                delta = multiplier ~mod* ALPHA_MODIFIERS[which][7 & (color >> shift)]
                c11 = c0 ~mod+ delta
                if c11 <= 0x0000_03FF {  //       0x0000_03FF is +1023.
                    // No-op.
                } else if c11 < 0x8000_0000 {
                    c11 = 0x0000_03FF
                } else if c11 < 0xFFFF_FC01 {  // 0xFFFF_FC01 is -1023.
                    c11 = 0xFFFF_FC01
                }
                if c11 < 0x8000_0000 {
                    c16 = (c11 ~mod<< 5) | (c11 >> 5)
                } else {
                    c11 = 0 ~mod- c11
                    c16 = (c11 ~mod<< 5) | (c11 >> 5)
                    c16 = 0 ~mod- c16
                }
                c16 ^= 0x8000
                o = offset + (x * args.dst_bytes_per_pixel) + (y * 1024)
                this.buffer[o + 0] = ((c16 >> 0) & 0xFF) as base.u8
                this.buffer[o + 1] = ((c16 >> 8) & 0xFF) as base.u8
                x += 1
            }
            y += 1
        }

        bi += 1
    }
}

pri func decoder.from_buffer_to_dst!(dst: ptr base.pixel_buffer) base.status {
    var src_bytes_per_pixel : base.u32[..= 8]
    var dst_pixfmt          : base.pixel_format
    var dst_bits_per_pixel  : base.u32[..= 256]
    var dst_bytes_per_pixel : base.u32[..= 32]
    var dst_bytes_per_row   : base.u64
    var tab                 : table base.u8
    var bi                  : base.u32
    var rem_x               : base.u32[..= 0xFFFF]
    var dy                  : base.u32[..= 4]
    var dst                 : slice base.u8
    var src                 : slice base.u8
    var si                  : base.u32[..= 4080]
    var sj                  : base.u32[..= 4096]
    var i                   : base.u64
    var num_src_pixels      : base.u32

    if this.pixfmt == base.PIXEL_FORMAT__Y_16LE {
        src_bytes_per_pixel = 2
        assert src_bytes_per_pixel > 0
    } else if this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE {
        src_bytes_per_pixel = 8
        assert src_bytes_per_pixel > 0
    } else {
        src_bytes_per_pixel = 4
        assert src_bytes_per_pixel > 0
    }

    // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able
    // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
    dst_pixfmt = args.dst.pixel_format()
    dst_bits_per_pixel = dst_pixfmt.bits_per_pixel()
    if (dst_bits_per_pixel & 7) <> 0 {
        return base."#unsupported option"
    }
    dst_bytes_per_pixel = dst_bits_per_pixel / 8
    dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64
    tab = args.dst.plane(p: 0)

    while bi < this.num_buffered_blocks,
            inv src_bytes_per_pixel > 0,
    {
        assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks)

        if this.width <= this.dst_x {
            this.dst_x = 0
            this.dst_y ~mod+= 4
            if this.dst_y >= this.height {
                break
            }
            rem_x = this.width
        } else {
            rem_x = this.width - this.dst_x
        }

        dy = 0
        while dy < 4,
                inv src_bytes_per_pixel > 0,
                inv bi < 64,
        {
            if src_bytes_per_pixel == 4 {
                si = (1024 * dy) + (16 * bi)
                sj = (1024 * dy) + (16 * 64)  // 64 is max_nbb.
            } else if src_bytes_per_pixel < 4 {
                si = (1024 * dy) + (8 * bi)
                sj = (1024 * dy) + (8 * 32)  //  32 is max_nbb.
            } else {
                si = (1024 * dy) + (32 * (bi & 31))
                sj = (1024 * dy) + (32 * 32)  // 32 is max_nbb.
            }
            if si < sj {
                src = this.buffer[si .. sj]
            }
            if ((src_bytes_per_pixel * rem_x) as base.u64) < src.length() {
                src = src[.. (src_bytes_per_pixel * rem_x) as base.u64]
            }

            if (this.dst_y ~mod+ dy) >= this.height {
                break
            }
            dst = tab.row_u32(y: this.dst_y ~mod+ dy)
            if dst_bytes_per_row < dst.length() {
                dst = dst[.. dst_bytes_per_row]
            }

            i = (this.dst_x as base.u64) * (dst_bytes_per_pixel as base.u64)
            if i < dst.length() {
                this.swizzler.swizzle_interleaved_from_slice!(
                        dst: dst[i ..],
                        dst_palette: args.dst.palette(),
                        src: src)
            }

            dy += 1
        }

        num_src_pixels = ((src.length() & 0xFFFF_FFFF) as base.u32) / src_bytes_per_pixel
        this.dst_x ~mod+= num_src_pixels
        bi ~mod+= (num_src_pixels ~mod+ 3) / 4
    }

    return ok
}

pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
    return this.util.make_rect_ie_u32(
            min_incl_x: 0,
            min_incl_y: 0,
            max_excl_x: this.width,
            max_excl_y: this.height)
}

pub func decoder.num_animation_loops() base.u32 {
    return 0
}

pub func decoder.num_decoded_frame_configs() base.u64 {
    if this.call_sequence > 0x20 {
        return 1
    }
    return 0
}

pub func decoder.num_decoded_frames() base.u64 {
    if this.call_sequence > 0x40 {
        return 1
    }
    return 0
}

pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
    if this.call_sequence < 0x20 {
        return base."#bad call sequence"
    }
    if (args.index <> 0) or (args.io_position <> 16) {
        return base."#bad argument"
    }
    this.call_sequence = 0x28
    return ok
}

pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
    // No-op. ETC2 doesn't support metadata.
}

pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
    return base."#no more information"
}

pub func decoder.workbuf_len() base.range_ii_u64 {
    return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0)
}

pri const DIFFS : roarray[8] base.u32 = [
        0x0000_0000,
        0x0000_0001,
        0x0000_0002,
        0x0000_0003,
        0xFFFF_FFFC,
        0xFFFF_FFFD,
        0xFFFF_FFFE,
        0xFFFF_FFFF,
]

pri const MODIFIERS : roarray[16] roarray[4] base.u32 = [
        [0x0000_0002, 0x0000_0008, 0xFFFF_FFFE, 0xFFFF_FFF8],  // [  -8,  -2,  +2,   +8] re-ordered.
        [0x0000_0005, 0x0000_0011, 0xFFFF_FFFB, 0xFFFF_FFEF],  // [ -17,  -5,  +5,  +17] re-ordered.
        [0x0000_0009, 0x0000_001D, 0xFFFF_FFF7, 0xFFFF_FFE3],  // [ -29,  -9,  +9,  +29] re-ordered.
        [0x0000_000D, 0x0000_002A, 0xFFFF_FFF3, 0xFFFF_FFD6],  // [ -42, -13, +13,  +42] re-ordered.
        [0x0000_0012, 0x0000_003C, 0xFFFF_FFEE, 0xFFFF_FFC4],  // [ -60, -18, +18,  +60] re-ordered.
        [0x0000_0018, 0x0000_0050, 0xFFFF_FFE8, 0xFFFF_FFB0],  // [ -80, -24, +24,  +80] re-ordered.
        [0x0000_0021, 0x0000_006A, 0xFFFF_FFDF, 0xFFFF_FF96],  // [-106, -33, +33, +106] re-ordered.
        [0x0000_002F, 0x0000_00B7, 0xFFFF_FFD1, 0xFFFF_FF49],  // [-183, -47, +47, +183] re-ordered.

        [0x0000_0000, 0x0000_0008, 0x0000_0000, 0xFFFF_FFF8],  // [  -8,   0,   0,   +8] re-ordered.
        [0x0000_0000, 0x0000_0011, 0x0000_0000, 0xFFFF_FFEF],  // [ -17,   0,   0,  +17] re-ordered.
        [0x0000_0000, 0x0000_001D, 0x0000_0000, 0xFFFF_FFE3],  // [ -29,   0,   0,  +29] re-ordered.
        [0x0000_0000, 0x0000_002A, 0x0000_0000, 0xFFFF_FFD6],  // [ -42,   0,   0,  +42] re-ordered.
        [0x0000_0000, 0x0000_003C, 0x0000_0000, 0xFFFF_FFC4],  // [ -60,   0,   0,  +60] re-ordered.
        [0x0000_0000, 0x0000_0050, 0x0000_0000, 0xFFFF_FFB0],  // [ -80,   0,   0,  +80] re-ordered.
        [0x0000_0000, 0x0000_006A, 0x0000_0000, 0xFFFF_FF96],  // [-106,   0,   0, +106] re-ordered.
        [0x0000_0000, 0x0000_00B7, 0x0000_0000, 0xFFFF_FF49],  // [-183,   0,   0, +183] re-ordered.
]

pri const T_H_MODIFIERS : roarray[8] base.u8 = [3, 6, 11, 16, 23, 32, 41, 64]

pri const ALPHA_MODIFIERS : roarray[16] roarray[8] base.u32 = [
        [0xFFFF_FFFD, 0xFFFF_FFFA, 0xFFFF_FFF7, 0xFFFF_FFF1, 0x0000_0002, 0x0000_0005, 0x0000_0008, 0x0000_000E],  // [-3, -6,  -9, -15, +2, +5, +8, +14]
        [0xFFFF_FFFD, 0xFFFF_FFF9, 0xFFFF_FFF6, 0xFFFF_FFF3, 0x0000_0002, 0x0000_0006, 0x0000_0009, 0x0000_000C],  // [-3, -7, -10, -13, +2, +6, +9, +12]
        [0xFFFF_FFFE, 0xFFFF_FFFB, 0xFFFF_FFF8, 0xFFFF_FFF3, 0x0000_0001, 0x0000_0004, 0x0000_0007, 0x0000_000C],  // [-2, -5,  -8, -13, +1, +4, +7, +12]
        [0xFFFF_FFFE, 0xFFFF_FFFC, 0xFFFF_FFFA, 0xFFFF_FFF3, 0x0000_0001, 0x0000_0003, 0x0000_0005, 0x0000_000C],  // [-2, -4,  -6, -13, +1, +3, +5, +12]
        [0xFFFF_FFFD, 0xFFFF_FFFA, 0xFFFF_FFF8, 0xFFFF_FFF4, 0x0000_0002, 0x0000_0005, 0x0000_0007, 0x0000_000B],  // [-3, -6,  -8, -12, +2, +5, +7, +11]
        [0xFFFF_FFFD, 0xFFFF_FFF9, 0xFFFF_FFF7, 0xFFFF_FFF5, 0x0000_0002, 0x0000_0006, 0x0000_0008, 0x0000_000A],  // [-3, -7,  -9, -11, +2, +6, +8, +10]
        [0xFFFF_FFFC, 0xFFFF_FFF9, 0xFFFF_FFF8, 0xFFFF_FFF5, 0x0000_0003, 0x0000_0006, 0x0000_0007, 0x0000_000A],  // [-4, -7,  -8, -11, +3, +6, +7, +10]
        [0xFFFF_FFFD, 0xFFFF_FFFB, 0xFFFF_FFF8, 0xFFFF_FFF5, 0x0000_0002, 0x0000_0004, 0x0000_0007, 0x0000_000A],  // [-3, -5,  -8, -11, +2, +4, +7, +10]
        [0xFFFF_FFFE, 0xFFFF_FFFA, 0xFFFF_FFF8, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0005, 0x0000_0007, 0x0000_0009],  // [-2, -6,  -8, -10, +1, +5, +7,  +9]
        [0xFFFF_FFFE, 0xFFFF_FFFB, 0xFFFF_FFF8, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0004, 0x0000_0007, 0x0000_0009],  // [-2, -5,  -8, -10, +1, +4, +7,  +9]
        [0xFFFF_FFFE, 0xFFFF_FFFC, 0xFFFF_FFF8, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0003, 0x0000_0007, 0x0000_0009],  // [-2, -4,  -8, -10, +1, +3, +7,  +9]
        [0xFFFF_FFFE, 0xFFFF_FFFB, 0xFFFF_FFF9, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0004, 0x0000_0006, 0x0000_0009],  // [-2, -5,  -7, -10, +1, +4, +6,  +9]
        [0xFFFF_FFFD, 0xFFFF_FFFC, 0xFFFF_FFF9, 0xFFFF_FFF6, 0x0000_0002, 0x0000_0003, 0x0000_0006, 0x0000_0009],  // [-3, -4,  -7, -10, +2, +3, +6,  +9]
        [0xFFFF_FFFF, 0xFFFF_FFFE, 0xFFFF_FFFD, 0xFFFF_FFF6, 0x0000_0000, 0x0000_0001, 0x0000_0002, 0x0000_0009],  // [-1, -2,  -3, -10, +0, +1, +2,  +9]
        [0xFFFF_FFFC, 0xFFFF_FFFA, 0xFFFF_FFF8, 0xFFFF_FFF7, 0x0000_0003, 0x0000_0005, 0x0000_0007, 0x0000_0008],  // [-4, -6,  -8,  -9, +3, +5, +7,  +8]
        [0xFFFF_FFFD, 0xFFFF_FFFB, 0xFFFF_FFF9, 0xFFFF_FFF7, 0x0000_0002, 0x0000_0004, 0x0000_0006, 0x0000_0008],  // [-3, -5,  -7,  -9, +2, +4, +6,  +8]
]

pri const CLAMP : roarray[1024] base.u8 = [
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
        0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
        0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
        0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
        0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,

        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
        0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
        0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
        0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
        0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
        0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
        0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,

        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]