// Copyright 2025 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

// --------

// Handsum is a very lossy format for very small thumbnails.
//
// See the lib/handsum Go implementation for more about the file format.

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(
        width   : base.u32[..= 16],
        height  : base.u32[..= 16],
        color   : base.u32[..= 3],  // 0=gray, 2=rgb, 3=rgba.
        quality : base.u32[..= 3],  // 0=worst, 3=best.

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

        bit_offset : base.u16,

        coeffs : array[25] base.u16,

        swizzler : base.pixel_swizzler,
        util     : base.utility,
) + (
        bits    : array[256] base.u8,
        buffers : array[2] array[16] array[64] 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 pixfmt : base.u32

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

    c32 = args.src.read_u24be_as_u32?()
    if (c32 >> 9) <> 0x7F6B {
        return "#bad header"
    }
    this.color = (c32 >> 7) & 3
    if this.color == 1 {
        return "#bad header"
    }
    this.quality = (c32 >> 5) & 3

    if (c32 & 0x1F) == 0x1F {  // Reserved for future expansion.
        return "#bad header"
    } else if (c32 & 0x10) == 0x00 {  // Landscape.
        this.width = 16
        this.height = (c32 & 0x0F) + 1
    } else {  // Portrait.
        this.width = (c32 & 0x0F) + 1
        this.height = 16
    }

    if args.dst <> nullptr {
        pixfmt = base.PIXEL_FORMAT__Y
        if this.color == 2 {
            pixfmt = base.PIXEL_FORMAT__BGRX
        } else if this.color > 2 {
            pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
        }

        args.dst.set!(
                pixfmt: pixfmt,
                pixsub: 0,
                width: this.width,
                height: this.height,
                first_frame_io_position: 3,
                first_frame_is_opaque: true)
    }

    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 opaque_within_bounds : base.bool
    var background_color     : base.u32

    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 3 <> 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 {
        opaque_within_bounds = false
        background_color = 0x0000_0000
        if this.color < 3 {
            opaque_within_bounds = true
            background_color = 0xFF00_0000
        }

        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: 3,
                disposal: 0,
                opaque_within_bounds: opaque_within_bounds,
                overwrite_instead_of_blend: false,
                background_color: 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 pixfmt       : base.u32
    var status       : base.status
    var num_read     : base.u32
    var payload_size : base.u32[..= 171]
    var which        : base.u32[..= 1]

    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"
    }

    pixfmt = base.PIXEL_FORMAT__Y
    if this.color == 2 {
        pixfmt = base.PIXEL_FORMAT__BGRX
    } else if this.color > 2 {
        pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
    }

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

    while true {
        payload_size = PAYLOAD_SIZES[this.color][this.quality] as base.u32
        if num_read >= payload_size {
            break
        }
        assert num_read < 256 via "a < b: a < c; c <= b"(c: payload_size)
        assert payload_size > num_read via "a > b: b < a"()
        num_read ~mod+= args.src.limited_copy_u32_to_slice!(
                up_to: payload_size - num_read,
                s: this.bits[num_read ..])
        if num_read < payload_size {
            yield? base."$short read"
        }
    }

    this.bit_offset = 0
    if this.quality == 0 {
        this.decode_block_q0!(which: 0, y_offset: 0, x_offset: 4 * 0)
        this.decode_block_q0!(which: 0, y_offset: 0, x_offset: 4 * 8)
        this.decode_block_q0!(which: 0, y_offset: 8, x_offset: 4 * 0)
        this.decode_block_q0!(which: 0, y_offset: 8, x_offset: 4 * 8)
        if this.color <> 0 {
            this.decode_block_q0!(which: 1, y_offset: 0, x_offset: 1)
            this.decode_block_q0!(which: 1, y_offset: 0, x_offset: 2)
        }

    } else if this.quality < 3 {
        this.decode_block_q1!(which: 0, y_offset: 0, x_offset: 4 * 0)
        this.decode_block_q1!(which: 0, y_offset: 0, x_offset: 4 * 8)
        this.decode_block_q1!(which: 0, y_offset: 8, x_offset: 4 * 0)
        this.decode_block_q1!(which: 0, y_offset: 8, x_offset: 4 * 8)
        if this.color <> 0 {
            this.decode_block_q1!(which: 1, y_offset: 0, x_offset: 1)
            this.decode_block_q1!(which: 1, y_offset: 0, x_offset: 2)
        }

    } else {
        this.decode_block_q3!(which: 0, y_offset: 0, x_offset: 4 * 0)
        this.decode_block_q3!(which: 0, y_offset: 0, x_offset: 4 * 8)
        this.decode_block_q3!(which: 0, y_offset: 8, x_offset: 4 * 0)
        this.decode_block_q3!(which: 0, y_offset: 8, x_offset: 4 * 8)
        if this.color <> 0 {
            this.decode_block_q3!(which: 1, y_offset: 0, x_offset: 1)
            this.decode_block_q3!(which: 1, y_offset: 0, x_offset: 2)
        }
    }

    if this.color < 3 {
        this.set_block_0xff!(which: 1, y_offset: 0, x_offset: 3)
    } else {
        this.decode_block_q3!(which: 1, y_offset: 0, x_offset: 3)
    }

    this.smooth_seams_16x16!()

    if this.color <> 0 {
        this.scale_and_bias_chroma_down!()
        this.upsample_chroma_and_alpha!()
        this.convert_ycca_to_bgra!()
    }

    which = 0
    if this.width < 16 {
        which = 1
        this.scale_horizontal!()
    } else if this.height < 16 {
        which = 1
        this.scale_vertical!()
    }

    if this.color == 0 {
        this.convert_yxxx_to_y!(which: which)
    }

    status = this.from_pixels_to_dst!(dst: args.dst, which: which)
    if not status.is_ok() {
        return status
    }

    this.call_sequence = 0x60
}

pri func decoder.decode_zigzag_coeffs!() {
    var dcm : base.u16
    var dcn : base.u16
    var acm : base.u16
    var acn : base.u16
    var z   : base.u32[..= 1]

    var num_coeffs : base.u32[..= 15]

    var bo     : base.u32
    var nibble : base.u8[..= 15]
    var i      : base.u32

    dcm = 0x88
    dcn = 1024
    acm = 64
    acn = 512
    z = 0
    if this.quality <> 0 {
        dcm = 0x44
        dcn = 512
        acm = 32
        acn = 256
        z = 1
    }

    num_coeffs = NUM_COEFFS[this.quality]

    bo = this.bit_offset as base.u32

    nibble = (this.bits[(bo >> 3) & 255] >> (bo & 4)) & 15
    this.coeffs[0] = ((nibble as base.u16) ~mod* dcm) ~mod- dcn
    bo ~mod+= 4

    i = 1
    while i < num_coeffs {
        assert i < 15 via "a < b: a < c; c <= b"(c: num_coeffs)
        nibble = (this.bits[(bo >> 3) & 255] >> (bo & 4)) & 15
        this.coeffs[ZIGZAG[z][i]] = ((nibble as base.u16) ~mod* acm) ~mod- acn
        bo ~mod+= 4

        i += 1
    }

    this.bit_offset = (bo & 0xFFFF) as base.u16
}

pri func decoder.decode_block_q0!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
    var y : base.u32
    var x : base.u32
    var v : base.u32
    var u : base.u32

    var alphas_sum_32   : base.u64
    var half_alpha_v_16 : base.u64
    var half_alpha_u_16 : base.u64
    var alphas_16       : base.u64
    var c_32            : base.u64
    var c_16            : base.u64
    var result_0        : base.u64

    this.decode_zigzag_coeffs!()

    // This IDCT (Inverse Discrete Cosine Transform) algorithm is equivalent to
    // the lowleveljpeg Go package's BlockU8.InverseDCTFrom code, although
    // Handsum only needs to go up to (5, 5) in DCT space, instead of (8, 8).

    y = 0
    while y < 8 {
        x = 0
        while x < 8,
                inv y < 8,
        {
            alphas_sum_32 = 0

            v = 0
            while v < 5,
                    inv y < 8,
                    inv x < 8,
            {
                half_alpha_v_16 = FIXED_POINT_INV_2_SQRT_2 as base.u64
                if v <> 0 {
                    half_alpha_v_16 = FIXED_POINT_HALF as base.u64
                }

                u = 0
                while u < 5,
                        inv y < 8,
                        inv x < 8,
                        inv v < 5,
                {
                    half_alpha_u_16 = FIXED_POINT_INV_2_SQRT_2 as base.u64
                    if u <> 0 {
                        half_alpha_u_16 = FIXED_POINT_HALF as base.u64
                    }

                    alphas_16 = this.util.sign_extend_rshift_u64(
                            a: (half_alpha_v_16 ~mod* half_alpha_u_16) ~mod+ (1 << 15),
                            n: 16)

                    c_32 = this.util.sign_extend_convert_u32_u64(a: COSINES[(((2 * x) + 1) * u) & 31]) ~mod*
                            this.util.sign_extend_convert_u32_u64(a: COSINES[(((2 * y) + 1) * v) & 31])

                    c_16 = this.util.sign_extend_rshift_u64(
                            a: c_32 ~mod+ (1 << 15),
                            n: 16)

                    alphas_sum_32 ~mod+= (alphas_16 ~mod* c_16) ~mod*
                            this.util.sign_extend_convert_u16_u64(
                            a: this.coeffs[(5 * v) + u])

                    u += 1
                }
                v += 1
            }

            result_0 = this.util.sign_extend_rshift_u64(
                    a: alphas_sum_32 ~mod+ (1 << 31),
                    n: 32)

            this.buffers[args.which][args.y_offset + y][args.x_offset + (4 * x)] =
                    BIAS_AND_CLAMP[result_0 & 1023]

            x += 1
        }
        y += 1
    }
}

pri func decoder.decode_block_q1!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
    var i : base.u32

    i = 0
    while i < 4 {
        this.decode_zigzag_coeffs!()
        this.decode_tile_q1!(
                which: args.which,
                y_offset: args.y_offset + ((i & 2) << 1),
                x_offset: args.x_offset + ((i & 1) << 4))

        i += 1
    }

    this.smooth_seams_8x8!(
            which: args.which,
            y_offset: args.y_offset,
            x_offset: args.x_offset)
}

pri func decoder.decode_tile_q1!(which: base.u32[..= 1], y_offset: base.u32[..= 12], x_offset: base.u32[..= 48]) {
    var y : base.u32
    var x : base.u32
    var v : base.u32
    var u : base.u32

    var alphas_sum_32   : base.u64
    var half_alpha_v_16 : base.u64
    var half_alpha_u_16 : base.u64
    var alphas_16       : base.u64
    var c_32            : base.u64
    var c_16            : base.u64
    var result_0        : base.u64

    // IDCT but for 4×4 tiles instead of 8×8.

    y = 0
    while y < 4 {
        x = 0
        while x < 4,
                inv y < 4,
        {
            alphas_sum_32 = 0

            v = 0
            while v < 4,
                    inv y < 4,
                    inv x < 4,
            {
                half_alpha_v_16 = FIXED_POINT_HALF as base.u64
                if v <> 0 {
                    half_alpha_v_16 = FIXED_POINT_INV_SQRT_2 as base.u64
                }

                u = 0
                while u < 4,
                        inv y < 4,
                        inv x < 4,
                        inv v < 4,
                {
                    half_alpha_u_16 = FIXED_POINT_HALF as base.u64
                    if u <> 0 {
                        half_alpha_u_16 = FIXED_POINT_INV_SQRT_2 as base.u64
                    }

                    alphas_16 = this.util.sign_extend_rshift_u64(
                            a: (half_alpha_v_16 ~mod* half_alpha_u_16) ~mod+ (1 << 15),
                            n: 16)

                    c_32 = this.util.sign_extend_convert_u32_u64(a: COSINES[(((4 * x) + 2) * u) & 31]) ~mod*
                            this.util.sign_extend_convert_u32_u64(a: COSINES[(((4 * y) + 2) * v) & 31])

                    c_16 = this.util.sign_extend_rshift_u64(
                            a: c_32 ~mod+ (1 << 15),
                            n: 16)

                    alphas_sum_32 ~mod+= (alphas_16 ~mod* c_16) ~mod*
                            this.util.sign_extend_convert_u16_u64(
                            a: this.coeffs[(4 * v) + u])

                    u += 1
                }
                v += 1
            }

            result_0 = this.util.sign_extend_rshift_u64(
                    a: alphas_sum_32 ~mod+ (1 << 31),
                    n: 32)

            this.buffers[args.which][args.y_offset + y][args.x_offset + (4 * x)] =
                    BIAS_AND_CLAMP[result_0 & 1023]

            x += 1
        }
        y += 1
    }
}

pri func decoder.decode_block_q3!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
    var bo : base.u32

    var y : base.u32
    var x : base.u32

    var dct0 : base.u32
    var dct1 : base.u32
    var dct2 : base.u32

    var v00 : base.u8
    var v01 : base.u8
    var v10 : base.u8
    var v11 : base.u8

    var v0 : base.u32
    var v1 : base.u32
    var v8 : base.u32
    var v9 : base.u32

    bo = this.bit_offset as base.u32

    y = 0
    while y < 7 {
        x = 0
        while x < 7,
                inv y < 7,
        {
            dct0 = ((((this.bits[(bo >> 3) & 255] >> (bo & 4)) & 15) as base.u32) ~mod* 0x22) ~mod- 0x100
            bo ~mod+= 4
            dct1 = ((((this.bits[(bo >> 3) & 255] >> (bo & 4)) & 15) as base.u32) ~mod* 0x10) ~mod- 0x080
            bo ~mod+= 4
            dct2 = ((((this.bits[(bo >> 3) & 255] >> (bo & 4)) & 15) as base.u32) ~mod* 0x10) ~mod- 0x080
            bo ~mod+= 4

            // IDCT but for 2×2 tiles instead of 8×8.

            v00 = BIAS_AND_CLAMP[((((dct0 ~mod+ dct1) ~mod+ dct2) ~mod+ 1) >> 1) & 1023]
            v01 = BIAS_AND_CLAMP[((((dct0 ~mod- dct1) ~mod+ dct2) ~mod+ 1) >> 1) & 1023]
            v10 = BIAS_AND_CLAMP[((((dct0 ~mod+ dct1) ~mod- dct2) ~mod+ 1) >> 1) & 1023]
            v11 = BIAS_AND_CLAMP[((((dct0 ~mod- dct1) ~mod- dct2) ~mod+ 1) >> 1) & 1023]

            this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * x) + 0] = v00
            this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * x) + 4] = v01
            this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * x) + 0] = v10
            this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * x) + 4] = v11

            x += 2
        }
        y += 2
    }

    this.bit_offset = (bo & 0xFFFF) as base.u16

    // Smooth the seams between adjacent 2×2 tiles.

    y = 1
    while y < 7 {
        x = 1
        while x < 7,
                inv y < 7,
        {

            v0 = this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * x) + 0] as base.u32
            v1 = this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * x) + 4] as base.u32
            v9 = this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * x) + 4] as base.u32
            v8 = this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * x) + 0] as base.u32

            this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * x) + 0] =
                    (((((((9 ~mod* v0) ~mod+ (3 ~mod* v1)) ~mod+ v9) ~mod+ (3 ~mod* v8)) ~mod+ 8) / 16) & 0xFF) as base.u8
            this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * x) + 4] =
                    (((((((9 ~mod* v1) ~mod+ (3 ~mod* v9)) ~mod+ v8) ~mod+ (3 ~mod* v0)) ~mod+ 8) / 16) & 0xFF) as base.u8
            this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * x) + 4] =
                    (((((((9 ~mod* v9) ~mod+ (3 ~mod* v8)) ~mod+ v0) ~mod+ (3 ~mod* v1)) ~mod+ 8) / 16) & 0xFF) as base.u8
            this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * x) + 0] =
                    (((((((9 ~mod* v8) ~mod+ (3 ~mod* v0)) ~mod+ v1) ~mod+ (3 ~mod* v9)) ~mod+ 8) / 16) & 0xFF) as base.u8

            x += 2
        }

        v0 = this.buffers[args.which][args.y_offset + 0 + 0][args.x_offset + (4 * y) + 0] as base.u32
        v1 = this.buffers[args.which][args.y_offset + 0 + 0][args.x_offset + (4 * y) + 4] as base.u32
        this.buffers[args.which][args.y_offset + 0 + 0][args.x_offset + (4 * y) + 0] =
                (((((3 ~mod* v0) ~mod+ v1) ~mod+ 2) / 4) & 0xFF) as base.u8
        this.buffers[args.which][args.y_offset + 0 + 0][args.x_offset + (4 * y) + 4] =
                (((((3 ~mod* v1) ~mod+ v0) ~mod+ 2) / 4) & 0xFF) as base.u8

        v0 = this.buffers[args.which][args.y_offset + 7 + 0][args.x_offset + (4 * y) + 0] as base.u32
        v1 = this.buffers[args.which][args.y_offset + 7 + 0][args.x_offset + (4 * y) + 4] as base.u32
        this.buffers[args.which][args.y_offset + 7 + 0][args.x_offset + (4 * y) + 0] =
                (((((3 ~mod* v0) ~mod+ v1) ~mod+ 2) / 4) & 0xFF) as base.u8
        this.buffers[args.which][args.y_offset + 7 + 0][args.x_offset + (4 * y) + 4] =
                (((((3 ~mod* v1) ~mod+ v0) ~mod+ 2) / 4) & 0xFF) as base.u8

        v0 = this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * 0) + 0] as base.u32
        v1 = this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * 0) + 0] as base.u32
        this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * 0) + 0] =
                (((((3 ~mod* v0) ~mod+ v1) ~mod+ 2) / 4) & 0xFF) as base.u8
        this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * 0) + 0] =
                (((((3 ~mod* v1) ~mod+ v0) ~mod+ 2) / 4) & 0xFF) as base.u8

        v0 = this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * 7) + 0] as base.u32
        v1 = this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * 7) + 0] as base.u32
        this.buffers[args.which][args.y_offset + y + 0][args.x_offset + (4 * 7) + 0] =
                (((((3 ~mod* v0) ~mod+ v1) ~mod+ 2) / 4) & 0xFF) as base.u8
        this.buffers[args.which][args.y_offset + y + 1][args.x_offset + (4 * 7) + 0] =
                (((((3 ~mod* v1) ~mod+ v0) ~mod+ 2) / 4) & 0xFF) as base.u8

        y += 2
    }
}

pri func decoder.set_block_0xff!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
    var y : base.u32
    var x : base.u32

    y = 0
    while y < 7 {
        x = 0
        while x < 7,
                inv y < 7,
        {
            this.buffers[args.which][args.y_offset + y][args.x_offset + (4 * x)] = 0xFF

            x += 1
        }
        y += 1
    }
}

pri func decoder.smooth_seams_16x16!() {
    var i  : base.u32
    var p0 : base.u8
    var p1 : base.u8
    var y0 : base.u32[..= 15]
    var y1 : base.u32[..= 15]
    var x0 : base.u32[..= 60]
    var x1 : base.u32[..= 60]

    var v0 : base.u32[..= 255]
    var v1 : base.u32[..= 255]

    var w0 : base.u32[..= 255]
    var w1 : base.u32[..= 255]

    var v77 : base.u32[..= 255]
    var v78 : base.u32[..= 255]
    var v88 : base.u32[..= 255]
    var v87 : base.u32[..= 255]

    var w77 : base.u32[..= 255]
    var w78 : base.u32[..= 255]
    var w88 : base.u32[..= 255]
    var w87 : base.u32[..= 255]

    i = 0
    while i <= 54 {
        p0 = SMOOTHING_PAIRS_16X16[i + 0]
        p1 = SMOOTHING_PAIRS_16X16[i + 1]
        y0 = (p0 >> 4) as base.u32
        y1 = (p1 >> 4) as base.u32
        x0 = ((p0 & 15) as base.u32) << 2
        x1 = ((p1 & 15) as base.u32) << 2

        v0 = this.buffers[0][y0][x0] as base.u32
        v1 = this.buffers[0][y1][x1] as base.u32

        w0 = ((3 * v0) + v1 + 2) / 4
        w1 = ((3 * v1) + v0 + 2) / 4

        this.buffers[0][y0][x0] = w0 as base.u8
        this.buffers[0][y1][x1] = w1 as base.u8

        i += 2
    }

    v77 = this.buffers[0][7][28] as base.u32
    v78 = this.buffers[0][7][32] as base.u32
    v88 = this.buffers[0][8][32] as base.u32
    v87 = this.buffers[0][8][28] as base.u32

    w77 = ((9 * v77) + (3 * v78) + v88 + (3 * v87) + 8) / 16
    w78 = ((9 * v78) + (3 * v88) + v87 + (3 * v77) + 8) / 16
    w88 = ((9 * v88) + (3 * v87) + v77 + (3 * v78) + 8) / 16
    w87 = ((9 * v87) + (3 * v77) + v78 + (3 * v88) + 8) / 16

    this.buffers[0][7][28] = w77 as base.u8
    this.buffers[0][7][32] = w78 as base.u8
    this.buffers[0][8][32] = w88 as base.u8
    this.buffers[0][8][28] = w87 as base.u8
}

pri func decoder.smooth_seams_8x8!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
    var i  : base.u32
    var p0 : base.u8
    var p1 : base.u8
    var y0 : base.u32[..= 15]
    var y1 : base.u32[..= 15]
    var x0 : base.u32[..= 60]
    var x1 : base.u32[..= 60]

    var v0 : base.u32[..= 255]
    var v1 : base.u32[..= 255]

    var w0 : base.u32[..= 255]
    var w1 : base.u32[..= 255]

    var v33 : base.u32[..= 255]
    var v34 : base.u32[..= 255]
    var v44 : base.u32[..= 255]
    var v43 : base.u32[..= 255]

    var w33 : base.u32[..= 255]
    var w34 : base.u32[..= 255]
    var w44 : base.u32[..= 255]
    var w43 : base.u32[..= 255]

    i = 0
    while i <= 22 {
        p0 = SMOOTHING_PAIRS_8X8[i + 0]
        p1 = SMOOTHING_PAIRS_8X8[i + 1]
        y0 = args.y_offset + ((p0 >> 3) as base.u32)
        y1 = args.y_offset + ((p1 >> 3) as base.u32)
        x0 = args.x_offset + (((p0 & 7) as base.u32) << 2)
        x1 = args.x_offset + (((p1 & 7) as base.u32) << 2)

        v0 = this.buffers[args.which][y0][x0] as base.u32
        v1 = this.buffers[args.which][y1][x1] as base.u32

        w0 = ((3 * v0) + v1 + 2) / 4
        w1 = ((3 * v1) + v0 + 2) / 4

        this.buffers[args.which][y0][x0] = w0 as base.u8
        this.buffers[args.which][y1][x1] = w1 as base.u8

        i += 2
    }

    v33 = this.buffers[args.which][args.y_offset + 3][args.x_offset + 12] as base.u32
    v34 = this.buffers[args.which][args.y_offset + 3][args.x_offset + 16] as base.u32
    v44 = this.buffers[args.which][args.y_offset + 4][args.x_offset + 16] as base.u32
    v43 = this.buffers[args.which][args.y_offset + 4][args.x_offset + 12] as base.u32

    w33 = ((9 * v33) + (3 * v34) + v44 + (3 * v43) + 8) / 16
    w34 = ((9 * v34) + (3 * v44) + v43 + (3 * v33) + 8) / 16
    w44 = ((9 * v44) + (3 * v43) + v33 + (3 * v34) + 8) / 16
    w43 = ((9 * v43) + (3 * v33) + v34 + (3 * v44) + 8) / 16

    this.buffers[args.which][args.y_offset + 3][args.x_offset + 12] = w33 as base.u8
    this.buffers[args.which][args.y_offset + 3][args.x_offset + 16] = w34 as base.u8
    this.buffers[args.which][args.y_offset + 4][args.x_offset + 16] = w44 as base.u8
    this.buffers[args.which][args.y_offset + 4][args.x_offset + 12] = w43 as base.u8
}

// scale_and_bias_chroma_down transforms the 8×8 Chroma samples in
// this.buffers[1].
pri func decoder.scale_and_bias_chroma_down!() {
    var y : base.u32
    var x : base.u32

    y = 0
    while y < 8 {
        x = 0
        while x < 8,
                inv y < 8,
        {
            this.buffers[1][y][(4 * x) + 1] = 0x3C + (this.buffers[1][y][(4 * x) + 1] >> 1)
            this.buffers[1][y][(4 * x) + 2] = 0x3C + (this.buffers[1][y][(4 * x) + 2] >> 1)

            x += 1
        }
        y += 1
    }
}

// upsample_chroma_and_alpha converts the 8×8 Chroma and Alpha samples in
// this.buffers[1] to 16×16 samples in this.buffers[0], adjacent to the
// existing 16×16 Luma samples in this.buffers[0].
pri func decoder.upsample_chroma_and_alpha!() {
    var y  : base.u32
    var dy : base.u32
    var y0 : base.u32[..= 7]
    var y1 : base.u32[..= 7]
    var x  : base.u32
    var dx : base.u32
    var x0 : base.u32[..= 7]
    var x1 : base.u32[..= 7]

    y = 0
    while y < 16 {
        dy = (((y & 1) * 2) ~mod- 1)
        y0 = y >> 1
        y1 = CLAMP_7[(y0 ~mod+ dy) & 31] as base.u32

        x = 0
        while x < 16,
                inv y < 16,
        {
            dx = (((x & 1) * 2) ~mod- 1)
            x0 = x >> 1
            x1 = CLAMP_7[(x0 ~mod+ dx) & 31] as base.u32

            this.buffers[0][y][(4 * x) + 1] = ((
                    ((this.buffers[1][y0][(4 * x0) + 1] as base.u32) * 9) +
                    ((this.buffers[1][y0][(4 * x1) + 1] as base.u32) * 3) +
                    ((this.buffers[1][y1][(4 * x0) + 1] as base.u32) * 3) +
                    (this.buffers[1][y1][(4 * x1) + 1] as base.u32) + 8) / 16) as base.u8

            this.buffers[0][y][(4 * x) + 2] = ((
                    ((this.buffers[1][y0][(4 * x0) + 2] as base.u32) * 9) +
                    ((this.buffers[1][y0][(4 * x1) + 2] as base.u32) * 3) +
                    ((this.buffers[1][y1][(4 * x0) + 2] as base.u32) * 3) +
                    (this.buffers[1][y1][(4 * x1) + 2] as base.u32) + 8) / 16) as base.u8

            this.buffers[0][y][(4 * x) + 3] = ((
                    ((this.buffers[1][y0][(4 * x0) + 3] as base.u32) * 9) +
                    ((this.buffers[1][y0][(4 * x1) + 3] as base.u32) * 3) +
                    ((this.buffers[1][y1][(4 * x0) + 3] as base.u32) * 3) +
                    (this.buffers[1][y1][(4 * x1) + 3] as base.u32) + 8) / 16) as base.u8

            x += 1
        }
        y += 1
    }

    if this.color < 3 {
        return nothing
    }

    y = 0
    while y < 16 {
        x = 0
        while x < 16,
                inv y < 16,
        {
            this.buffers[0][y][(4 * x) + 3] = CUBE_ROOT[
                    this.buffers[0][y][(4 * x) + 3]]

            x += 1
        }
        y += 1
    }
}

pri func decoder.convert_yxxx_to_y!(which: base.u32[..= 1]) {
    var y : base.u32
    var x : base.u32

    y = 0
    while y < 16 {
        x = 1
        while x < 16,
                inv y < 16,
        {
            this.buffers[args.which][y][x] = this.buffers[args.which][y][4 * x]

            x += 1
        }
        y += 1
    }
}

pri func decoder.convert_ycca_to_bgra!() {
    var y   : base.u32
    var x   : base.u32
    var yy1 : base.u32
    var cb1 : base.u32
    var cr1 : base.u32
    var r   : base.u32
    var g   : base.u32
    var b   : base.u32

    y = 0
    while y < 16 {
        x = 0
        while x < 16,
                inv y < 16,
        {
            // This conversion algorithm is the same as the one used by
            // src/image/color/ycbcr.go in Go's standard library.

            yy1 = (this.buffers[0][y][(4 * x) + 0] as base.u32) * 0x1_0101
            cb1 = (this.buffers[0][y][(4 * x) + 1] as base.u32) ~mod- 0x80
            cr1 = (this.buffers[0][y][(4 * x) + 2] as base.u32) ~mod- 0x80

            r = yy1 ~mod+ (91881 ~mod* cr1)
            if (r & 0xFF00_0000) == 0 {
                r >>= 16
            } else {
                r = 0xFFFF_FFFF ^ this.util.sign_extend_rshift_u32(a: r, n: 31)
            }

            g = yy1 ~mod- ((22554 ~mod* cb1) ~mod+ (46802 ~mod* cr1))
            if (g & 0xFF00_0000) == 0 {
                g >>= 16
            } else {
                g = 0xFFFF_FFFF ^ this.util.sign_extend_rshift_u32(a: g, n: 31)
            }

            b = yy1 ~mod+ (116130 ~mod* cb1)
            if (b & 0xFF00_0000) == 0 {
                b >>= 16
            } else {
                b = 0xFFFF_FFFF ^ this.util.sign_extend_rshift_u32(a: b, n: 31)
            }

            this.buffers[0][y][(4 * x) + 0] = (b & 0xFF) as base.u8
            this.buffers[0][y][(4 * x) + 1] = (g & 0xFF) as base.u8
            this.buffers[0][y][(4 * x) + 2] = (r & 0xFF) as base.u8

            x += 1
        }
        y += 1
    }
}

pri func decoder.scale_horizontal!() {
    var y         : base.u32
    var dstx      : base.u32[..= 15]
    var srcx      : base.u32
    var acc0      : base.u32
    var acc1      : base.u32
    var acc2      : base.u32
    var acc3      : base.u32
    var s0        : base.u32[..= 0xFF]
    var s1        : base.u32[..= 0xFF]
    var s2        : base.u32[..= 0xFF]
    var s3        : base.u32[..= 0xFF]
    var remainder : base.u32[..= 16]
    var partial   : base.u32[..= 16]

    y = 0
    while y < 16 {
        dstx = 0
        srcx = 0
        acc0 = 0
        acc1 = 0
        acc2 = 0
        acc3 = 0
        remainder = 16
        while srcx < 16,
                inv y < 16,
        {
            s0 = this.buffers[0][y][(4 * srcx) + 0] as base.u32
            s1 = this.buffers[0][y][(4 * srcx) + 1] as base.u32
            s2 = this.buffers[0][y][(4 * srcx) + 2] as base.u32
            s3 = this.buffers[0][y][(4 * srcx) + 3] as base.u32

            if remainder > this.width {
                remainder -= this.width
                acc0 ~mod+= this.width * s0
                acc1 ~mod+= this.width * s1
                acc2 ~mod+= this.width * s2
                acc3 ~mod+= this.width * s3

            } else {
                assert this.width >= remainder via "a >= b: b <= a"()

                acc0 ~mod+= remainder * s0
                acc1 ~mod+= remainder * s1
                acc2 ~mod+= remainder * s2
                acc3 ~mod+= remainder * s3

                this.buffers[1][y][(4 * dstx) + 0] = (((acc0 ~mod+ 8) / 16) & 0xFF) as base.u8
                this.buffers[1][y][(4 * dstx) + 1] = (((acc1 ~mod+ 8) / 16) & 0xFF) as base.u8
                this.buffers[1][y][(4 * dstx) + 2] = (((acc2 ~mod+ 8) / 16) & 0xFF) as base.u8
                this.buffers[1][y][(4 * dstx) + 3] = (((acc3 ~mod+ 8) / 16) & 0xFF) as base.u8
                dstx = (dstx + 1) & 15

                partial = this.width - remainder

                acc0 = partial * s0
                acc1 = partial * s1
                acc2 = partial * s2
                acc3 = partial * s3

                remainder = 16 - partial
            }

            srcx += 1
        }
        y += 1
    }
}

pri func decoder.scale_vertical!() {
    var x         : base.u32
    var dsty      : base.u32[..= 15]
    var srcy      : base.u32
    var acc0      : base.u32
    var acc1      : base.u32
    var acc2      : base.u32
    var acc3      : base.u32
    var s0        : base.u32[..= 0xFF]
    var s1        : base.u32[..= 0xFF]
    var s2        : base.u32[..= 0xFF]
    var s3        : base.u32[..= 0xFF]
    var remainder : base.u32[..= 16]
    var partial   : base.u32[..= 16]

    x = 0
    while x < 16 {
        dsty = 0
        srcy = 0
        acc0 = 0
        acc1 = 0
        acc2 = 0
        acc3 = 0
        remainder = 16
        while srcy < 16,
                inv x < 16,
        {
            s0 = this.buffers[0][srcy][(4 * x) + 0] as base.u32
            s1 = this.buffers[0][srcy][(4 * x) + 1] as base.u32
            s2 = this.buffers[0][srcy][(4 * x) + 2] as base.u32
            s3 = this.buffers[0][srcy][(4 * x) + 3] as base.u32

            if remainder > this.height {
                remainder -= this.height
                acc0 ~mod+= this.height * s0
                acc1 ~mod+= this.height * s1
                acc2 ~mod+= this.height * s2
                acc3 ~mod+= this.height * s3

            } else {
                assert this.height >= remainder via "a >= b: b <= a"()

                acc0 ~mod+= remainder * s0
                acc1 ~mod+= remainder * s1
                acc2 ~mod+= remainder * s2
                acc3 ~mod+= remainder * s3

                this.buffers[1][dsty][(4 * x) + 0] = (((acc0 ~mod+ 8) / 16) & 0xFF) as base.u8
                this.buffers[1][dsty][(4 * x) + 1] = (((acc1 ~mod+ 8) / 16) & 0xFF) as base.u8
                this.buffers[1][dsty][(4 * x) + 2] = (((acc2 ~mod+ 8) / 16) & 0xFF) as base.u8
                this.buffers[1][dsty][(4 * x) + 3] = (((acc3 ~mod+ 8) / 16) & 0xFF) as base.u8
                dsty = (dsty + 1) & 15

                partial = this.height - remainder

                acc0 = partial * s0
                acc1 = partial * s1
                acc2 = partial * s2
                acc3 = partial * s3

                remainder = 16 - partial
            }

            srcy += 1
        }
        x += 1
    }
}

pri func decoder.from_pixels_to_dst!(dst: ptr base.pixel_buffer, which: base.u32[..= 1]) base.status {
    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 y                   : base.u32
    var dst                 : slice base.u8
    var src_bytes_per_pixel : base.u32[..= 4]
    var src                 : slice base.u8

    // 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)

    src_bytes_per_pixel = 1
    if this.color <> 0 {
        src_bytes_per_pixel = 4
    }

    while y < this.height {
        assert y < 16 via "a < b: a < c; c <= b"(c: this.height)
        src = this.buffers[args.which][y][.. this.width * src_bytes_per_pixel]

        dst = tab.row_u32(y: y)
        if dst_bytes_per_row < dst.length() {
            dst = dst[.. dst_bytes_per_row]
        }

        this.swizzler.swizzle_interleaved_from_slice!(
                dst: dst,
                dst_palette: args.dst.palette(),
                src: src)

        y += 1
    }

    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 <> 3) {
        return base."#bad argument"
    }
    this.call_sequence = 0x28
    return ok
}

pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
    // No-op. Handsum 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 PAYLOAD_SIZES : roarray[4] roarray[4] base.u8[..= 171] = [[
        30, 48, 80, 96,
],[
        0, 0, 0, 0,
],[
        45, 72, 120, 144,
],[
        69, 96, 144, 168,
]]

pri const NUM_COEFFS : roarray[4] base.u32[..= 15] = [
        15, 6, 10, 3,
]

pri const CLAMP_7 : roarray[32] base.u8[..= 7] = [
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]

// For commentary on these constants below, see the lib/handsum and
// lib/lowleveljpeg Go packages.

pri const ZIGZAG : roarray[2] roarray[15] base.u8[..= 24] = [[
        0, 1, 5, 10, 6, 2, 3, 7, 11, 15, 20, 16, 12, 8, 4,
],[
        0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 0, 0, 0, 0, 0,
]]

pri const CUBE_ROOT : roarray[256] base.u8 = [
        0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05,
        0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B,
        0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12,
        0x13, 0x13, 0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17, 0x17, 0x18, 0x18, 0x19, 0x19, 0x1A,
        0x1A, 0x1B, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23,
        0x24, 0x24, 0x25, 0x26, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2A, 0x2B, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
        0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3F,
        0x40, 0x41, 0x43, 0x44, 0x46, 0x48, 0x49, 0x4B, 0x4D, 0x4F, 0x52, 0x55, 0x58, 0x5B, 0x60, 0x67,

        0x80, 0x99, 0xA0, 0xA5, 0xA8, 0xAB, 0xAE, 0xB1, 0xB3, 0xB5, 0xB7, 0xB8, 0xBA, 0xBC, 0xBD, 0xBF,
        0xC0, 0xC1, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
        0xD1, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD5, 0xD6, 0xD7, 0xD8, 0xD8, 0xD9, 0xDA, 0xDA, 0xDB, 0xDC,
        0xDC, 0xDD, 0xDE, 0xDE, 0xDF, 0xDF, 0xE0, 0xE1, 0xE1, 0xE2, 0xE2, 0xE3, 0xE3, 0xE4, 0xE5, 0xE5,
        0xE6, 0xE6, 0xE7, 0xE7, 0xE8, 0xE8, 0xE9, 0xE9, 0xEA, 0xEA, 0xEB, 0xEB, 0xEC, 0xEC, 0xED, 0xED,
        0xED, 0xEE, 0xEE, 0xEF, 0xEF, 0xF0, 0xF0, 0xF1, 0xF1, 0xF1, 0xF2, 0xF2, 0xF3, 0xF3, 0xF3, 0xF4,
        0xF4, 0xF5, 0xF5, 0xF5, 0xF6, 0xF6, 0xF7, 0xF7, 0xF7, 0xF8, 0xF8, 0xF9, 0xF9, 0xF9, 0xFA, 0xFA,
        0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF,
]

pri const SMOOTHING_PAIRS_16X16 : roarray[56] base.u8 = [
        0x07, 0x08,
        0x17, 0x18,
        0x27, 0x28,
        0x37, 0x38,
        0x47, 0x48,
        0x57, 0x58,
        0x67, 0x68,

        0x70, 0x80,
        0x71, 0x81,
        0x72, 0x82,
        0x73, 0x83,
        0x74, 0x84,
        0x75, 0x85,
        0x76, 0x86,

        0x79, 0x89,
        0x7A, 0x8A,
        0x7B, 0x8B,
        0x7C, 0x8C,
        0x7D, 0x8D,
        0x7E, 0x8E,
        0x7F, 0x8F,

        0x97, 0x98,
        0xA7, 0xA8,
        0xB7, 0xB8,
        0xC7, 0xC8,
        0xD7, 0xD8,
        0xE7, 0xE8,
        0xF7, 0xF8,
]

pri const SMOOTHING_PAIRS_8X8 : roarray[24] base.u8[..= 0x3F] = [
        0x03, 0x04,
        0x0B, 0x0C,
        0x13, 0x14,

        0x18, 0x20,
        0x19, 0x21,
        0x1A, 0x22,

        0x1D, 0x25,
        0x1E, 0x26,
        0x1F, 0x27,

        0x2B, 0x2C,
        0x33, 0x34,
        0x3B, 0x3C,
]

pri const FIXED_POINT_INV_SQRT_2   : base.u16 = 0xB505
pri const FIXED_POINT_HALF         : base.u16 = 0x8000
pri const FIXED_POINT_INV_2_SQRT_2 : base.u16 = 0x5A82

pri const COSINES : roarray[32] base.u32 = [
        0x0001_0000,
        0x0000_FB15,
        0x0000_EC83,
        0x0000_D4DB,
        0x0000_B505,
        0x0000_8E3A,
        0x0000_61F8,
        0x0000_31F1,
        0x0000_0000,
        0xFFFF_CE0F,
        0xFFFF_9E08,
        0xFFFF_71C6,
        0xFFFF_4AFB,
        0xFFFF_2B25,
        0xFFFF_137D,
        0xFFFF_04EB,
        0xFFFF_0000,
        0xFFFF_04EB,
        0xFFFF_137D,
        0xFFFF_2B25,
        0xFFFF_4AFB,
        0xFFFF_71C6,
        0xFFFF_9E08,
        0xFFFF_CE0F,
        0x0000_0000,
        0x0000_31F1,
        0x0000_61F8,
        0x0000_8E3A,
        0x0000_B505,
        0x0000_D4DB,
        0x0000_EC83,
        0x0000_FB15,
]

pri const BIAS_AND_CLAMP : roarray[1024] base.u8 = [
        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,

        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, 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,
]