@woosh/meep-engine 3.17.2 → 3.18.0

package/src/core/binary/meshopt/meshopt_encode_vertex_buffer.js

@@ -0,0 +1,700 @@
+import { assert } from "../../assert.js";
+import { MESHOPT_GROUP_SIZE } from "./MESHOPT_GROUP_SIZE.js";
+import {
+    MESHOPT_BITS_BY_CONTROL,
+    MESHOPT_BITS_VERSION_0,
+    MESHOPT_MAX_BLOCK_BYTES,
+    MESHOPT_MAX_BLOCK_ELEMENTS,
+    MESHOPT_MAX_BYTE_STRIDE,
+    MESHOPT_TAIL_MIN_BY_VERSION,
+    MESHOPT_VERTEX_HEADER,
+    meshopt_max_block_elements
+} from "./MESHOPT_VERTEX_BLOCK.js";
+import { meshopt_choose_data_block, meshopt_encode_data_block } from "./meshopt_encode_data_block.js";
+
+/**
+ * The most groups one block can hold, which bounds the per-block bookkeeping below.
+ * @type {number}
+ */
+const MAX_GROUPS = MESHOPT_MAX_BLOCK_ELEMENTS / MESHOPT_GROUP_SIZE;
+
+/**
+ * Control mode 2 stores nothing at all, and can only carry a byte position whose deltas are every
+ * one zero.
+ * @type {number}
+ */
+const CONTROL_ZERO = 2;
+
+/**
+ * Control mode 3 stores the deltas verbatim, with no group header in front of them. It is the
+ * fallback that always fits, and the ceiling every other mode is measured against.
+ * @type {number}
+ */
+const CONTROL_LITERAL = 3;
+
+/**
+ * One block's delta bytes, laid out per byte position exactly as the decoder's scratch is: position
+ * `k`'s deltas are `group_count * 16` bytes at `k * aligned_count`.
+ *
+ * Module-static, because encoding is synchronous and there is one caller. So are the four below.
+ *
+ * @type {Uint8Array}
+ */
+const delta_scratch = new Uint8Array(MESHOPT_MAX_BLOCK_BYTES);
+
+/**
+ * Where a candidate channel mode's deltas go while it is being priced, so that the incumbent's stay
+ * where the writer expects them.
+ * @type {Uint8Array}
+ */
+const candidate_scratch = new Uint8Array(MESHOPT_MAX_BLOCK_BYTES);
+
+/**
+ * The element each block's first delta is taken against — the stream's first element for the first
+ * block, and the previous block's last element after that.
+ * @type {Uint8Array}
+ */
+const baseline = new Uint8Array(MESHOPT_MAX_BYTE_STRIDE);
+
+/**
+ * The group header value chosen for each `(byte position, group)` of the block in hand.
+ * @type {Uint8Array}
+ */
+const group_choice = new Uint8Array(MESHOPT_MAX_BYTE_STRIDE * MAX_GROUPS);
+
+/**
+ * The same, for the control mode currently being priced against the incumbent.
+ * @type {Uint8Array}
+ */
+const group_choice_candidate = new Uint8Array(MAX_GROUPS);
+
+/**
+ * Somewhere for {@link price_channel} to throw away the choices it is not going to keep. Its own,
+ * because it is measuring a byte position whose incumbent choices must survive the measurement.
+ * @type {Uint8Array}
+ */
+const group_choice_discard = new Uint8Array(MAX_GROUPS);
+
+/**
+ * The baseline a candidate channel mode is priced against, kept apart from {@link baseline} for the
+ * same reason.
+ * @type {Uint8Array}
+ */
+const candidate_baseline = new Uint8Array(MESHOPT_MAX_BYTE_STRIDE);
+
+/**
+ * The control mode chosen for each byte position of the block in hand. Version 1 only; version 0
+ * has no control header and every byte position is a data block.
+ * @type {Uint8Array}
+ */
+const control_choice = new Uint8Array(MESHOPT_MAX_BYTE_STRIDE);
+
+/**
+ * Encode an attribute stream — the `"ATTRIBUTES"` mode of both meshopt extensions, and the inverse
+ * of {@link meshopt_decode_vertex_buffer}.
+ *
+ * Elements are delta-coded against the element before them, byte position by byte position. What
+ * the encoder gets to decide, and does:
+ *
+ * - **per group of sixteen deltas**, the width they are packed at, out of the four the block's
+ *   control mode admits — including "all zero", which stores nothing;
+ * - **per byte position** (version 1), whether the groups carry a header at all: a position that
+ *   never changes costs nothing, and one that is pure noise skips the header and is written
+ *   verbatim rather than paying two bits a group to be told so;
+ * - **per channel of four byte positions** (version 1), whether its deltas are 8-bit, 16-bit, or a
+ *   rotated 32-bit exclusive-or — see {@link choose_channel_mode}.
+ *
+ * Every one of those is priced against the alternatives on the data in hand rather than guessed at,
+ * so the output is never larger than the verbatim form and is usually a fraction of it.
+ *
+ * Version 0 is what `EXT_meshopt_compression` admits and is the default. Version 1 is
+ * `KHR_meshopt_compression` only, and buys the last two decisions above.
+ *
+ * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
+ *
+ * @param {Uint8Array} source `count * byte_stride` bytes
+ * @param {number} count elements
+ * @param {number} byte_stride divisible by 4, at most 256
+ * @param {Object} [options]
+ * @param {number} [options.version] 0 or 1, defaulting to 0
+ * @param {number[]|Uint8Array} [options.channel_modes] one mode byte per channel — low nibble the
+ *   mode, high nibble the rotation — imposed rather than chosen. Version 1 only, and the caller
+ *   owns the consequences: a mode that suits the data less well than the one this would have picked
+ *   makes a larger stream, not a wrong one.
+ * @returns {Uint8Array} the whole compressed stream, tail included
+ * @throws {Error} if the arguments do not describe an encodable buffer
+ */
+export function meshopt_encode_vertex_buffer(source, count, byte_stride, options = {}) {
+    assert.isNonNegativeInteger(count, 'count');
+    assert.isPositiveInteger(byte_stride, 'byte_stride');
+    assert.equal(byte_stride % 4, 0, `byte_stride(=${byte_stride}) must be divisible by 4`);
+    assert.ok(byte_stride <= MESHOPT_MAX_BYTE_STRIDE, `byte_stride(=${byte_stride}) must be at most ${MESHOPT_MAX_BYTE_STRIDE}`);
+    assert.equal(
+        source.length, count * byte_stride,
+        `source(=${source.length} bytes) must hold count(=${count}) * byte_stride(=${byte_stride})`
+    );
+
+    const version = options.version ?? 0;
+
+    assert.isOneOf(version, [0, 1], 'version');
+
+    const channel_count = byte_stride >> 2;
+    const max_block_elements = meshopt_max_block_elements(byte_stride);
+
+    const channel_modes = resolve_channel_modes(source, count, byte_stride, version, options.channel_modes);
+
+    /*
+     Two tail sizes, as in the decoder: the tail block sits flush against the end of the stream and
+     is `tail_size` long, and the padding in front of it brings the pair up to `tail_size_pad`. The
+     padding is what gives the decoder's per-group bounds check its slack.
+    */
+    const tail_size = byte_stride + (version === 1 ? channel_count : 0);
+    const tail_min = MESHOPT_TAIL_MIN_BY_VERSION[version];
+    const tail_size_pad = tail_size < tail_min ? tail_min : tail_size;
+
+    const destination = new Uint8Array(
+        upper_bound(count, byte_stride, channel_count, version, max_block_elements) + tail_size_pad
+    );
+
+    destination[0] = MESHOPT_VERTEX_HEADER | version;
+
+    // the first block deltas against the first element, which is also what goes in the tail block
+    for (let k = 0; k < byte_stride; k++) {
+        baseline[k] = count > 0 ? source[k] : 0;
+    }
+
+    let offset = 1;
+    let element = 0;
+
+    while (element < count) {
+        const block_elements = Math.min(count - element, max_block_elements);
+
+        offset = encode_block(
+            destination, offset,
+            source, element, block_elements,
+            byte_stride, channel_count, version, channel_modes
+        );
+
+        element += block_elements;
+    }
+
+    // the padding goes IN FRONT of the tail block, which sits flush against the end of the stream
+    const end = offset + tail_size_pad;
+    const tail = end - tail_size;
+
+    destination.fill(0, offset, tail);
+
+    for (let k = 0; k < byte_stride; k++) {
+        destination[tail + k] = count > 0 ? source[k] : 0;
+    }
+
+    if (version === 1) {
+        for (let c = 0; c < channel_count; c++) {
+            destination[tail + byte_stride + c] = channel_modes[c];
+        }
+    }
+
+    return destination.slice(0, end);
+}
+
+/**
+ * The largest stream the encoder could possibly produce for this shape, blocks only — every byte
+ * position of every block written verbatim, with a group header it would not actually pay for.
+ *
+ * Bounding it up front is what lets the whole stream be written into one exactly-sized buffer:
+ * every decision is made from the deltas, so nothing here has to look at the data.
+ *
+ * @param {number} count
+ * @param {number} byte_stride
+ * @param {number} channel_count
+ * @param {number} version
+ * @param {number} max_block_elements
+ * @returns {number} bytes, the stream header included and the tail excluded
+ */
+function upper_bound(count, byte_stride, channel_count, version, max_block_elements) {
+    let bound = 1;
+
+    for (let element = 0; element < count; element += max_block_elements) {
+        const block_elements = Math.min(count - element, max_block_elements);
+        const group_count = Math.ceil(block_elements / MESHOPT_GROUP_SIZE);
+
+        bound += (version === 1 ? channel_count : 0)
+            + byte_stride * (((group_count + 3) >> 2) + group_count * MESHOPT_GROUP_SIZE);
+    }
+
+    return bound;
+}
+
+/**
+ * Settle on a mode byte per channel: what the caller imposed, or nothing at all under version 0,
+ * or {@link choose_channel_mode}'s reading of the data.
+ *
+ * @param {Uint8Array} source
+ * @param {number} count
+ * @param {number} byte_stride
+ * @param {number} version
+ * @param {number[]|Uint8Array} [imposed]
+ * @returns {Uint8Array} one mode byte per channel
+ * @throws {Error} if the caller imposed modes that are not modes, or imposed any under version 0
+ */
+function resolve_channel_modes(source, count, byte_stride, version, imposed) {
+    const channel_count = byte_stride >> 2;
+    const modes = new Uint8Array(channel_count);
+
+    if (version === 0) {
+        assert.ok(
+            imposed === undefined,
+            'channel modes are a version 1 feature, and this stream is version 0'
+        );
+
+        return modes;
+    }
+
+    if (imposed !== undefined) {
+        assert.equal(
+            imposed.length, channel_count,
+            `channel_modes(=${imposed.length}) must have one entry per channel(=${channel_count})`
+        );
+
+        for (let c = 0; c < channel_count; c++) {
+            const mode_byte = imposed[c];
+            const mode = mode_byte & 0x0f;
+
+            assert.isOneOf(mode, [0, 1, 2], `channel_modes[${c}] mode`);
+            assert.ok(
+                mode === 2 || (mode_byte >> 4) === 0,
+                `channel_modes[${c}] carries a rotation in mode ${mode}, which has none`
+            );
+
+            modes[c] = mode_byte;
+        }
+
+        return modes;
+    }
+
+    for (let c = 0; c < channel_count; c++) {
+        modes[c] = choose_channel_mode(source, count, byte_stride, c);
+    }
+
+    return modes;
+}
+
+/**
+ * Pick the mode byte for one channel, by pricing the candidates on the stream's first block.
+ *
+ * The mode is a property of the whole stream — the decoder reads it once, out of the tail — so it
+ * cannot be revisited per block, and pricing every candidate against every block to choose it once
+ * would cost more than the choice is worth. The first block is what gets measured, and for the
+ * data this format carries (vertex attributes, laid out one way for their whole run) it is
+ * representative. A caller who knows better passes `channel_modes` and skips this.
+ *
+ * Mode 2's rotation is not searched exhaustively either. Every bit that ever changes between
+ * consecutive elements is collected into one mask, and the rotation that gathers those bits into
+ * the fewest whole bytes is the one tried — which is the whole point of the rotation, and reduces
+ * thirty-two candidates to one.
+ *
+ * @param {Uint8Array} source
+ * @param {number} count
+ * @param {number} byte_stride
+ * @param {number} channel
+ * @returns {number} the mode byte: low nibble the mode, high nibble the rotation
+ */
+function choose_channel_mode(source, count, byte_stride, channel) {
+    const sample = Math.min(count, meshopt_max_block_elements(byte_stride));
+
+    if (sample === 0) {
+        return 0;
+    }
+
+    const k0 = channel * 4;
+
+    // every bit that changes anywhere in the sample, so the rotation is chosen from all of them
+    let mask = 0;
+    let previous = read_le_32(source, k0);
+
+    for (let i = 0; i < sample; i++) {
+        const value = read_le_32(source, i * byte_stride + k0);
+
+        mask = (mask | (value ^ previous)) >>> 0;
+        previous = value;
+    }
+
+    let rotation = 0;
+    let fewest = 5;
+
+    for (let r = 0; r < 32; r++) {
+        const rotated = rotate_left_32(mask, (32 - r) & 31);
+        const bytes = (rotated & 0xff ? 1 : 0)
+            + ((rotated >>> 8) & 0xff ? 1 : 0)
+            + ((rotated >>> 16) & 0xff ? 1 : 0)
+            + ((rotated >>> 24) & 0xff ? 1 : 0);
+
+        if (bytes < fewest) {
+            rotation = r;
+            fewest = bytes;
+        }
+    }
+
+    const candidates = [0, 1, 2 | (rotation << 4)];
+
+    let best = 0;
+    let best_size = Number.POSITIVE_INFINITY;
+
+    for (const mode_byte of candidates) {
+        const size = price_channel(source, 0, sample, byte_stride, channel, mode_byte);
+
+        if (size < best_size) {
+            best = mode_byte;
+            best_size = size;
+        }
+    }
+
+    return best;
+}
+
+/**
+ * What one channel's four byte positions cost over a block under a given mode, version 1 rules.
+ *
+ * The deltas go into {@link candidate_scratch} rather than {@link delta_scratch}, because this runs
+ * before the block loop and must not disturb what the block loop is holding.
+ *
+ * @param {Uint8Array} source
+ * @param {number} element_offset
+ * @param {number} block_elements
+ * @param {number} byte_stride
+ * @param {number} channel
+ * @param {number} mode_byte
+ * @returns {number} bytes, the share of the control header included
+ */
+function price_channel(source, element_offset, block_elements, byte_stride, channel, mode_byte) {
+    const group_count = Math.ceil(block_elements / MESHOPT_GROUP_SIZE);
+    const aligned_count = group_count * MESHOPT_GROUP_SIZE;
+
+    // the sample's own baseline, which is the first element, exactly as the real encode will see it
+    const first = element_offset * byte_stride;
+
+    for (let j = 0; j < 4; j++) {
+        candidate_baseline[channel * 4 + j] = source[first + channel * 4 + j];
+    }
+
+    write_channel_deltas(
+        candidate_scratch, candidate_baseline, source, element_offset, block_elements,
+        byte_stride, aligned_count, channel, mode_byte
+    );
+
+    let size = 1; // the channel's byte of the block's control header
+
+    for (let j = 0; j < 4; j++) {
+        const k = channel * 4 + j;
+
+        size += price_byte_position(
+            candidate_scratch, k * aligned_count, group_count, aligned_count,
+            group_choice_discard, 0
+        ).size;
+    }
+
+    return size;
+}
+
+/**
+ * The cheapest way to store one byte position's deltas, and what it costs.
+ *
+ * Version 1's four control modes are not four widths — two of them are answers to questions the
+ * group header cannot ask. A position that never changes is free, and one whose every group would
+ * have to be stored raw anyway is cheaper without the header that says so.
+ *
+ * @param {Uint8Array} deltas
+ * @param {number} deltas_offset
+ * @param {number} group_count
+ * @param {number} aligned_count
+ * @param {Uint8Array} choices `group_count` header values are written here, for whichever data
+ *   block control mode won — untouched if neither did
+ * @param {number} choices_offset
+ * @returns {{control: number, size: number}}
+ */
+function price_byte_position(deltas, deltas_offset, group_count, aligned_count, choices, choices_offset) {
+    let all_zero = true;
+
+    for (let i = 0; i < aligned_count; i++) {
+        if (deltas[deltas_offset + i] !== 0) {
+            all_zero = false;
+            break;
+        }
+    }
+
+    if (all_zero) {
+        return { control: CONTROL_ZERO, size: 0 };
+    }
+
+    let control = CONTROL_LITERAL;
+    let size = aligned_count;
+
+    const size_0 = meshopt_choose_data_block(
+        deltas, deltas_offset, group_count, MESHOPT_BITS_BY_CONTROL[0], choices, choices_offset
+    );
+
+    if (size_0 < size) {
+        control = 0;
+        size = size_0;
+    }
+
+    const size_1 = meshopt_choose_data_block(
+        deltas, deltas_offset, group_count, MESHOPT_BITS_BY_CONTROL[1], group_choice_candidate, 0
+    );
+
+    if (size_1 < size) {
+        control = 1;
+        size = size_1;
+
+        for (let g = 0; g < group_count; g++) {
+            choices[choices_offset + g] = group_choice_candidate[g];
+        }
+    }
+
+    return { control, size };
+}
+
+/**
+ * Encode one block: its control header if it has one, then every byte position in turn.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} offset
+ * @param {Uint8Array} source
+ * @param {number} element_offset first element of this block, counted in the whole stream
+ * @param {number} block_elements
+ * @param {number} byte_stride
+ * @param {number} channel_count
+ * @param {number} version
+ * @param {Uint8Array} channel_modes
+ * @returns {number} the offset just past the block
+ */
+function encode_block(
+    destination, offset,
+    source, element_offset, block_elements,
+    byte_stride, channel_count, version, channel_modes
+) {
+    const group_count = Math.ceil(block_elements / MESHOPT_GROUP_SIZE);
+    const aligned_count = group_count * MESHOPT_GROUP_SIZE;
+
+    for (let c = 0; c < channel_count; c++) {
+        write_channel_deltas(
+            delta_scratch, baseline, source, element_offset, block_elements,
+            byte_stride, aligned_count, c, channel_modes[c]
+        );
+    }
+
+    if (version === 0) {
+        // no control header stands between the choosing and the writing, so they are one pass
+        for (let k = 0; k < byte_stride; k++) {
+            meshopt_choose_data_block(
+                delta_scratch, k * aligned_count, group_count,
+                MESHOPT_BITS_VERSION_0, group_choice, 0
+            );
+
+            offset = meshopt_encode_data_block(
+                destination, offset,
+                delta_scratch, k * aligned_count,
+                group_count, MESHOPT_BITS_VERSION_0,
+                group_choice, 0
+            );
+        }
+    } else {
+        const control_offset = offset;
+
+        destination.fill(0, control_offset, control_offset + channel_count);
+        offset += channel_count;
+
+        for (let k = 0; k < byte_stride; k++) {
+            const chosen = price_byte_position(
+                delta_scratch, k * aligned_count, group_count, aligned_count,
+                group_choice, k * MAX_GROUPS
+            );
+
+            control_choice[k] = chosen.control;
+
+            destination[control_offset + (k >> 2)] |= chosen.control << ((k & 3) * 2);
+        }
+
+        for (let k = 0; k < byte_stride; k++) {
+            const control = control_choice[k];
+            const deltas_offset = k * aligned_count;
+
+            if (control === CONTROL_ZERO) {
+                continue;
+            }
+
+            if (control === CONTROL_LITERAL) {
+                for (let i = 0; i < aligned_count; i++) {
+                    destination[offset + i] = delta_scratch[deltas_offset + i];
+                }
+
+                offset += aligned_count;
+
+                continue;
+            }
+
+            offset = meshopt_encode_data_block(
+                destination, offset,
+                delta_scratch, deltas_offset,
+                group_count, MESHOPT_BITS_BY_CONTROL[control],
+                group_choice, k * MAX_GROUPS
+            );
+        }
+    }
+
+    const last = (element_offset + block_elements - 1) * byte_stride;
+
+    for (let k = 0; k < byte_stride; k++) {
+        baseline[k] = source[last + k];
+    }
+
+    return offset;
+}
+
+/**
+ * Turn one channel's values into the delta bytes the decoder will reconstruct them from — the
+ * inverse of `reconstruct_channel`, and the only place the three modes differ.
+ *
+ * The deltas past `block_elements` are the group alignment's padding. They are written as zero
+ * because zero is what costs least, and the decoder discards them.
+ *
+ * @param {Uint8Array} deltas
+ * @param {Uint8Array} from the element the block's first delta is taken against
+ * @param {Uint8Array} source
+ * @param {number} element_offset
+ * @param {number} block_elements
+ * @param {number} byte_stride
+ * @param {number} aligned_count stride of `deltas`, per byte position
+ * @param {number} channel
+ * @param {number} mode_byte low nibble the mode, high nibble the rotation
+ */
+function write_channel_deltas(
+    deltas, from, source, element_offset, block_elements,
+    byte_stride, aligned_count, channel, mode_byte
+) {
+    const k0 = channel * 4;
+    const mode = mode_byte & 0x0f;
+
+    for (let j = 0; j < 4; j++) {
+        const k = k0 + j;
+
+        deltas.fill(0, k * aligned_count + block_elements, (k + 1) * aligned_count);
+    }
+
+    if (mode === 0) {
+        for (let j = 0; j < 4; j++) {
+            const k = k0 + j;
+            const out = k * aligned_count;
+
+            let previous = from[k];
+            let read = element_offset * byte_stride + k;
+
+            for (let i = 0; i < block_elements; i++) {
+                const value = source[read];
+
+                deltas[out + i] = zigzag_8(previous, value);
+
+                previous = value;
+                read += byte_stride;
+            }
+        }
+
+        return;
+    }
+
+    if (mode === 1) {
+        for (let h = 0; h < 2; h++) {
+            const k = k0 + h * 2;
+            const out_low = k * aligned_count;
+            const out_high = (k + 1) * aligned_count;
+
+            let previous = from[k] | (from[k + 1] << 8);
+            let read = element_offset * byte_stride + k;
+
+            for (let i = 0; i < block_elements; i++) {
+                const value = source[read] | (source[read + 1] << 8);
+                const zigzag = zigzag_16(previous, value);
+
+                deltas[out_low + i] = zigzag & 0xff;
+                deltas[out_high + i] = zigzag >>> 8;
+
+                previous = value;
+                read += byte_stride;
+            }
+        }
+
+        return;
+    }
+
+    const rotation = mode_byte >> 4;
+
+    const out_0 = k0 * aligned_count;
+    const out_1 = (k0 + 1) * aligned_count;
+    const out_2 = (k0 + 2) * aligned_count;
+    const out_3 = (k0 + 3) * aligned_count;
+
+    let previous = read_le_32(from, k0);
+    let read = element_offset * byte_stride + k0;
+
+    for (let i = 0; i < block_elements; i++) {
+        const value = read_le_32(source, read);
+
+        // the decoder rotates left by `rotation`, so this rotates back by the same amount
+        const delta = rotate_left_32((value ^ previous) >>> 0, (32 - rotation) & 31);
+
+        deltas[out_0 + i] = delta & 0xff;
+        deltas[out_1 + i] = (delta >>> 8) & 0xff;
+        deltas[out_2 + i] = (delta >>> 16) & 0xff;
+        deltas[out_3 + i] = delta >>> 24;
+
+        previous = value;
+        read += byte_stride;
+    }
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @returns {number} the little-endian 32-bit word there, unsigned
+ */
+function read_le_32(data, offset) {
+    return (
+        data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24)
+    ) >>> 0;
+}
+
+/**
+ * @param {number} value
+ * @param {number} amount
+ * @returns {number} unsigned
+ */
+function rotate_left_32(value, amount) {
+    return ((value << amount) | (value >>> (32 - amount))) >>> 0;
+}
+
+/**
+ * Zigzag one 8-bit delta, so that a small step either way is a small number: the difference is
+ * taken modulo 256, and its sign bit folded into bit 0.
+ *
+ * @param {number} previous
+ * @param {number} current
+ * @returns {number}
+ */
+function zigzag_8(previous, current) {
+    const delta = (current - previous) & 0xff;
+
+    return ((delta & 0x80) !== 0 ? ~(delta << 1) : (delta << 1)) & 0xff;
+}
+
+/**
+ * The same, over sixteen bits.
+ *
+ * @param {number} previous
+ * @param {number} current
+ * @returns {number}
+ */
+function zigzag_16(previous, current) {
+    const delta = (current - previous) & 0xffff;
+
+    return ((delta & 0x8000) !== 0 ? ~(delta << 1) : (delta << 1)) & 0xffff;
+}