@blamnetwork/blf 1.0.0-alpha.1

package/dist-cjs/bitstream/reader.js

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_bitstream_reader = void 0;
+const enum_1 = require("./enum");
+const enums_1 = require("./enums");
+const errors_1 = require("./errors");
+const math_1 = require("./math");
+const { _bitstream_byte_fill_direction_msb_to_lsb, _bitstream_byte_fill_direction_lsb_to_msb, } = enums_1.e_bitstream_byte_fill_direction;
+class c_bitstream_reader {
+    m_data;
+    m_data_size_bytes;
+    m_state;
+    m_byte_order;
+    m_packed_byte_order;
+    m_byte_pack_direction;
+    m_byte_unpack_direction;
+    current_stream_bit_position;
+    current_stream_byte_position;
+    static new(data, byte_order) {
+        return new c_bitstream_reader(data, byte_order, {
+            packed_byte_order: byte_order,
+            byte_pack_direction: enums_1.e_bitstream_byte_fill_direction._bitstream_byte_fill_direction_msb_to_lsb,
+            byte_unpack_direction: enums_1.e_bitstream_byte_fill_direction._bitstream_byte_fill_direction_msb_to_lsb,
+        });
+    }
+    /** Use this when dealing with bitstream data from the Halo 3 Beta or prior. */
+    static new_with_legacy_settings(data, byte_order) {
+        return new c_bitstream_reader(data, byte_order, {
+            packed_byte_order: enums_1.e_bitstream_byte_order.swap(byte_order),
+            byte_pack_direction: _bitstream_byte_fill_direction_lsb_to_msb,
+            byte_unpack_direction: _bitstream_byte_fill_direction_lsb_to_msb,
+        });
+    }
+    static new_from_instance(data, instance) {
+        return new c_bitstream_reader(data, instance.get_byte_order(), {
+            packed_byte_order: instance.m_packed_byte_order,
+            byte_pack_direction: instance.m_byte_pack_direction,
+            byte_unpack_direction: instance.m_byte_unpack_direction,
+        });
+    }
+    constructor(data, byte_order, options) {
+        this.m_data = data;
+        this.m_data_size_bytes = data.length;
+        this.m_state = enums_1.e_bitstream_state._bitstream_state_initial;
+        this.m_byte_order = byte_order;
+        this.m_packed_byte_order = options.packed_byte_order;
+        this.m_byte_pack_direction = options.byte_pack_direction;
+        this.m_byte_unpack_direction = options.byte_unpack_direction;
+        this.current_stream_bit_position = 0;
+        this.current_stream_byte_position = 0;
+    }
+    get_byte_order() {
+        return this.m_packed_byte_order;
+    }
+    seek_relative(bits) {
+        const current_bit_position = this.current_stream_byte_position * 8 + this.current_stream_bit_position;
+        const new_bit_position = current_bit_position + bits;
+        (0, errors_1.assert_ok)(new_bit_position / 8 < this.m_data_size_bytes);
+        this.current_stream_bit_position = new_bit_position % 8;
+        this.current_stream_byte_position = Math.floor(new_bit_position / 8);
+    }
+    seek(byte) {
+        (0, errors_1.assert_ok)(byte < this.m_data_size_bytes);
+        this.current_stream_byte_position = byte;
+        this.current_stream_bit_position = 0;
+    }
+    seek_bit(byte, bit) {
+        (0, errors_1.assert_ok)(bit < 8);
+        this.seek(byte);
+        this.current_stream_bit_position = bit;
+    }
+    get_current_offset() {
+        return [
+            this.current_stream_byte_position,
+            this.current_stream_bit_position,
+        ];
+    }
+    read_raw_data(size_in_bits) {
+        const buffer = new Uint8Array(Math.ceil(size_in_bits / 8));
+        this.read_bits_internal(buffer, size_in_bits);
+        return buffer;
+    }
+    read_bool(_name) {
+        return this.read_integer(_name, 1) === 1;
+    }
+    read_bits_internal(output, size_in_bits) {
+        const end_memory_position = output.length;
+        const end_stream_position = this.m_data.length;
+        const remaining_stream_bytes = end_stream_position - (this.current_stream_byte_position + 1);
+        const remaining_stream_bits = 8 - this.current_stream_bit_position + remaining_stream_bytes * 8;
+        const size_in_bytes = Math.ceil(size_in_bits / 8);
+        if (end_memory_position < size_in_bytes) {
+            throw new errors_1.BitstreamError(`Tried to read ${size_in_bytes} bytes (${size_in_bits} bits) into a ${end_memory_position} byte buffer!`);
+        }
+        if (remaining_stream_bits < size_in_bits) {
+            throw new errors_1.BitstreamError(`Tried to read ${size_in_bits} bits but the stream only has ${remaining_stream_bits} bits left!`);
+        }
+        if (size_in_bits === 0) {
+            throw new errors_1.BitstreamError("Tried to read zero bits.");
+        }
+        let remaining_bits_to_read = size_in_bits;
+        let output_byte_index = 0;
+        while (remaining_bits_to_read > 0) {
+            let output_byte = 0;
+            let bits_read = 0;
+            if (this.current_stream_bit_position !== 0) {
+                const remaining_bits_at_position = 8 - this.current_stream_bit_position;
+                const reading_bits_at_position = Math.min(remaining_bits_at_position, remaining_bits_to_read);
+                let bits = this.m_data[this.current_stream_byte_position];
+                switch (this.m_byte_pack_direction) {
+                    case _bitstream_byte_fill_direction_msb_to_lsb:
+                        bits = (bits << this.current_stream_bit_position) & 0xff;
+                        break;
+                    case _bitstream_byte_fill_direction_lsb_to_msb:
+                        bits =
+                            (bits <<
+                                (remaining_bits_at_position - reading_bits_at_position)) &
+                                0xff;
+                        break;
+                }
+                bits &= (0xff << (8 - reading_bits_at_position)) & 0xff;
+                if (this.m_byte_unpack_direction ===
+                    _bitstream_byte_fill_direction_lsb_to_msb) {
+                    bits = (bits >> (8 - reading_bits_at_position)) & 0xff;
+                }
+                output_byte = bits;
+                bits_read += reading_bits_at_position;
+                if (reading_bits_at_position > remaining_bits_at_position) {
+                    throw new errors_1.BitstreamError("bitstream reader believes it has read more bits than available. This should never happen.");
+                }
+                if (reading_bits_at_position === remaining_bits_at_position) {
+                    this.current_stream_bit_position = 0;
+                    this.current_stream_byte_position += 1;
+                }
+                else {
+                    this.current_stream_bit_position += reading_bits_at_position;
+                }
+                remaining_bits_to_read -= reading_bits_at_position;
+            }
+            if (remaining_bits_to_read > 0) {
+                const reading_bits_at_position = Math.min(8 - bits_read, remaining_bits_to_read);
+                let bits = this.m_data[this.current_stream_byte_position];
+                if (this.m_byte_pack_direction ===
+                    _bitstream_byte_fill_direction_lsb_to_msb) {
+                    bits = (bits << (8 - reading_bits_at_position)) & 0xff;
+                }
+                bits &= (0xff << (8 - reading_bits_at_position)) & 0xff;
+                switch (this.m_byte_unpack_direction) {
+                    case _bitstream_byte_fill_direction_msb_to_lsb:
+                        bits = (bits >> bits_read) & 0xff;
+                        break;
+                    case _bitstream_byte_fill_direction_lsb_to_msb:
+                        bits =
+                            (bits >> (8 - (bits_read + reading_bits_at_position))) & 0xff;
+                        break;
+                }
+                output_byte = (output_byte | bits) & 0xff;
+                bits_read += reading_bits_at_position;
+                remaining_bits_to_read -= reading_bits_at_position;
+                if (reading_bits_at_position === 8) {
+                    this.current_stream_bit_position = 0;
+                    this.current_stream_byte_position += 1;
+                }
+                else {
+                    this.current_stream_bit_position += reading_bits_at_position;
+                }
+            }
+            if (bits_read < 8 &&
+                this.m_byte_unpack_direction ===
+                    _bitstream_byte_fill_direction_lsb_to_msb) {
+                output_byte = (output_byte << (8 - bits_read)) & 0xff;
+            }
+            switch (this.m_packed_byte_order) {
+                case enums_1.e_bitstream_byte_order._bitstream_byte_order_big_endian: {
+                    const surplus_bits = (8 - (size_in_bits % 8)) % 8;
+                    const shifted = ((output_byte & 0xff) << (8 - surplus_bits)) & 0xffff;
+                    const left_output = (shifted >> 8) & 0xff;
+                    const right_output = shifted & 0xff;
+                    output[output_byte_index] |= left_output;
+                    if (right_output !== 0) {
+                        output[output_byte_index + 1] |= right_output;
+                    }
+                    output_byte_index += 1;
+                    break;
+                }
+                case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian: {
+                    if (bits_read < 8) {
+                        output_byte = (output_byte >>> (8 - bits_read)) & 0xff;
+                    }
+                    output[output_byte_index] = output_byte;
+                    output_byte_index += 1;
+                    break;
+                }
+            }
+        }
+    }
+    read_enum(name, size_in_bits, enumObjOrParser, options) {
+        const integer = this.read_integer(name, size_in_bits);
+        if (typeof enumObjOrParser === "function") {
+            const value = enumObjOrParser(integer);
+            if (value === undefined) {
+                throw new errors_1.BitstreamError(`Unexpected enum value for ${name}: ${integer}`);
+            }
+            return value;
+        }
+        if (options?.within_bits) {
+            (0, enum_1.assertFitsInBits)(name, integer, size_in_bits);
+            return integer;
+        }
+        if (!(0, enum_1.isNumericEnumValue)(enumObjOrParser, integer)) {
+            throw new errors_1.BitstreamError(`Unexpected enum value for ${name}: ${integer}`);
+        }
+        return integer;
+    }
+    read_integer(_name, size_in_bits) {
+        (0, errors_1.assert_ok)(size_in_bits > 0);
+        (0, errors_1.assert_ok)(size_in_bits <= 32);
+        const size_in_bytes = Math.ceil(size_in_bits / 8);
+        const bytes_vec = new Uint8Array(size_in_bytes);
+        this.read_bits_internal(bytes_vec, size_in_bits);
+        const byte_array = new Uint8Array(4);
+        switch (this.m_packed_byte_order) {
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian: {
+                byte_array.set(bytes_vec, 0);
+                const view = new DataView(byte_array.buffer);
+                return view.getUint32(0, true);
+            }
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_big_endian: {
+                byte_array.set(bytes_vec, 4 - bytes_vec.length);
+                const view = new DataView(byte_array.buffer);
+                return view.getUint32(0, false);
+            }
+        }
+    }
+    read_index(name, max, size_in_bits) {
+        if (this.read_bool("index-exists")) {
+            return -1;
+        }
+        const value = this.read_integer(name, size_in_bits);
+        (0, errors_1.assert_ok)(value < max);
+        return value;
+    }
+    read_quantized_real(min_value, max_value, size_in_bits, exact_midpoint, exact_endpoints) {
+        const quantized = this.read_integer("quantized-real", size_in_bits);
+        return (0, math_1.dequantize_real)(quantized, min_value, max_value, 1 << size_in_bits, exact_midpoint, exact_endpoints);
+    }
+    read_float(_name, size_in_bits) {
+        (0, errors_1.assert_ok)(size_in_bits > 0);
+        (0, errors_1.assert_ok)(size_in_bits <= 32);
+        const bytes = new Uint8Array(4);
+        this.read_bits_internal(bytes, size_in_bits);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                return view.getFloat32(0, true);
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                return view.getFloat32(0, false);
+        }
+    }
+    read_i16(size_in_bits) {
+        (0, errors_1.assert_ok)(size_in_bits > 0);
+        (0, errors_1.assert_ok)(size_in_bits <= 16);
+        const bytes = new Uint8Array(2);
+        this.read_bits_internal(bytes, size_in_bits);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                return view.getInt16(0, true);
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                return view.getInt16(0, false);
+        }
+    }
+    read_signed_integer(_name, size_in_bits) {
+        let result = this.read_integer(_name, size_in_bits);
+        if (size_in_bits < 32 && (result & (1 << (size_in_bits - 1))) !== 0) {
+            result |= ~((1 << size_in_bits) - 1);
+        }
+        return result | 0;
+    }
+    read_qword(size_in_bits) {
+        (0, errors_1.assert_ok)(size_in_bits > 0);
+        (0, errors_1.assert_ok)(size_in_bits <= 64);
+        const bytes = new Uint8Array(8);
+        this.read_bits_internal(bytes, size_in_bits);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                return view.getBigUint64(0, true);
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                return view.getBigUint64(0, false);
+        }
+    }
+    read_identifier(_identifier) {
+        throw new Error("unimplemented");
+    }
+    read_point3d(point, axis_encoding_size_in_bits) {
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits > 0 && axis_encoding_size_in_bits <= 32);
+        point.x = this.read_integer("???", axis_encoding_size_in_bits);
+        point.y = this.read_integer("???", axis_encoding_size_in_bits);
+        point.z = this.read_integer("???", axis_encoding_size_in_bits);
+    }
+    read_point3d_efficient(point, axis_encoding_size_in_bits) {
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits.x > 0 && axis_encoding_size_in_bits.x <= 32);
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits.y > 0 && axis_encoding_size_in_bits.y <= 32);
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits.z > 0 && axis_encoding_size_in_bits.z <= 32);
+        point.x = this.read_integer("???", axis_encoding_size_in_bits.x);
+        point.y = this.read_integer("???", axis_encoding_size_in_bits.y);
+        point.z = this.read_integer("???", axis_encoding_size_in_bits.z);
+    }
+    read_qword_internal(_size_in_bits) {
+        throw new Error("unimplemented");
+    }
+    read_secure_address(_address) {
+        throw new Error("unimplemented");
+    }
+    angle_to_axes_internal(up, angle, forward) {
+        (0, math_1.angle_to_axes_internal)(up, angle, forward);
+    }
+    read_string(_string, _max_string_size) {
+        throw new Error("unimplemented");
+    }
+    read_string_utf8(max_string_size) {
+        (0, errors_1.assert_ok)(this.reading());
+        (0, errors_1.assert_ok)(max_string_size > 0);
+        const bytes = new Uint8Array(max_string_size);
+        for (let i = 0; i < max_string_size; i++) {
+            const byte = this.read_integer("???", 8);
+            bytes[i] = byte;
+            if (byte === 0) {
+                return String.fromCharCode(...Array.from(bytes.subarray(0, i)));
+            }
+        }
+        throw new errors_1.BitstreamError("Exceeded max string size reading utf8 string.");
+    }
+    read_string_extended_ascii(max_string_size) {
+        (0, errors_1.assert_ok)(this.reading());
+        (0, errors_1.assert_ok)(max_string_size > 0);
+        const bytes = new Uint8Array(max_string_size);
+        for (let i = 0; i < max_string_size; i++) {
+            const byte = this.read_integer("???", 8);
+            bytes[i] = byte;
+            if (byte === 0) {
+                return String.fromCharCode(...Array.from(bytes.subarray(0, i)));
+            }
+        }
+        throw new errors_1.BitstreamError("Exceeded max string size reading utf8 string.");
+    }
+    read_string_wchar(max_string_size) {
+        (0, errors_1.assert_ok)(this.reading());
+        (0, errors_1.assert_ok)(max_string_size > 0);
+        const characters = [];
+        for (let i = 0; i < max_string_size; i++) {
+            const character = this.read_integer("???", 16);
+            if (character === 0) {
+                return characters.join("");
+            }
+            characters.push(String.fromCharCode(character));
+        }
+        throw new errors_1.BitstreamError("Exceeded max string size reading wchar string.");
+    }
+    read_unit_vector(_unit_vector, _size_in_bits) {
+        throw new Error("unimplemented");
+    }
+    read_vector(_vector, _min_value, _max_value, _step_count_size_in_bits, _size_in_bits) {
+        throw new Error("unimplemented");
+    }
+    begin_reading() {
+        this.reset(enums_1.e_bitstream_state._bitstream_state_reading);
+    }
+    reading() {
+        return (this.m_state === enums_1.e_bitstream_state._bitstream_state_reading ||
+            this.m_state ===
+                enums_1.e_bitstream_state._bitstream_state_read_only_for_consistency);
+    }
+    finish_reading() {
+        this.m_state = enums_1.e_bitstream_state._bitstream_state_read_finished;
+    }
+    get_data() {
+        return [this.m_data, this.m_data_size_bytes];
+    }
+    reset(state) {
+        this.m_state = state;
+        this.current_stream_bit_position = 0;
+        this.current_stream_byte_position = 0;
+    }
+    set_data(data) {
+        this.m_data = data;
+        this.m_data_size_bytes = data.length;
+        this.reset(enums_1.e_bitstream_state._bitstream_state_initial);
+    }
+    skip(_bits_to_skip) {
+        throw new Error("unimplemented");
+    }
+    would_overflow(_size_in_bits) {
+        throw new Error("unimplemented");
+    }
+    static axes_compute_reference_internal(up, forward_reference, left_reference) {
+        (0, math_1.axes_compute_reference_internal)(up, forward_reference, left_reference);
+    }
+    static axes_to_angle_internal(forward, up) {
+        return (0, math_1.axes_to_angle_internal)(forward, up);
+    }
+}
+exports.c_bitstream_reader = c_bitstream_reader;