@woosh/meep-engine 3.8.0 → 3.10.0

package/src/avif/native/av1/obu/parse_frame_header.js

@@ -0,0 +1,841 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import {
+    ALTREF2_FRAME,
+    ALTREF_FRAME,
+    GOLDEN_FRAME,
+    INTRA_FRAME,
+    KEY_FRAME,
+    MAX_SEGMENTS,
+    MAX_TILE_AREA,
+    MAX_TILE_COLS,
+    MAX_TILE_ROWS,
+    MAX_TILE_WIDTH,
+    ONLY_4X4,
+    PRIMARY_REF_NONE,
+    RESTORATION_TILESIZE_MAX,
+    RESTORE_NONE,
+    SEG_LVL_ALT_Q,
+    SEG_LVL_MAX,
+    SEG_LVL_REF_FRAME,
+    SELECT_INTEGER_MV,
+    SELECT_SCREEN_CONTENT_TOOLS,
+    SUPERRES_DENOM_BITS,
+    SUPERRES_DENOM_MIN,
+    SUPERRES_NUM,
+    TOTAL_REFS_PER_FRAME,
+    TX_MODE_LARGEST,
+    TX_MODE_SELECT
+} from "../tables/av1_symbols.js";
+import {
+    SEGMENTATION_FEATURE_BITS,
+    SEGMENTATION_FEATURE_MAX,
+    SEGMENTATION_FEATURE_SIGNED
+} from "../tables/segmentation_tables.js";
+import { REMAP_LR_TYPE } from "../tables/filter_tables.js";
+import { tile_log2 } from "../util/tile_log2.js";
+
+/**
+ * Parse an uncompressed frame header.
+ *
+ * Only key frames are accepted. An inter frame is rejected as soon as its type is known rather than
+ * parsed into a header that nothing downstream could act on: this decoder has no reference frames,
+ * so an inter frame is not a degraded case but an impossible one.
+ *
+ * @param {BitReader} reader positioned at the start of the frame header payload
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header filled in place
+ * @returns {FrameHeader} `header`
+ * @see AV1 spec 5.9.2 "Uncompressed header syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function parse_frame_header(reader, sequence, header) {
+    const id_length = sequence.frame_id_numbers_present_flag === 1
+        ? sequence.additional_frame_id_length_minus_1 + sequence.delta_frame_id_length_minus_2 + 3
+        : 0;
+
+    if (sequence.reduced_still_picture_header === 1) {
+        header.show_existing_frame = 0;
+        header.frame_type = KEY_FRAME;
+        header.frame_is_intra = 1;
+        header.show_frame = 1;
+        header.showable_frame = 0;
+        header.error_resilient_mode = 1;
+    } else {
+        header.show_existing_frame = reader.f(1);
+
+        if (header.show_existing_frame === 1) {
+            throw new Error("show_existing_frame is not decodable without a reference frame buffer");
+        }
+
+        header.frame_type = reader.f(2);
+
+        if (header.frame_type !== KEY_FRAME) {
+            throw new Error(`frame_type ${header.frame_type} is an inter or intra-only frame; this decoder handles key frames only`);
+        }
+
+        header.frame_is_intra = 1;
+        header.show_frame = reader.f(1);
+
+        if (header.show_frame === 1 && sequence.decoder_model_info_present_flag === 1 && sequence.equal_picture_interval === 0) {
+            // frame_presentation_time, read and discarded: it describes output timing, which a
+            // still image has none of
+            reader.f(sequence.frame_presentation_time_length_minus_1 + 1);
+        }
+
+        header.showable_frame = header.show_frame === 1 ? 0 : reader.f(1);
+
+        // a shown key frame is implicitly error resilient and codes no flag for it
+        header.error_resilient_mode = header.show_frame === 1 ? 1 : reader.f(1);
+    }
+
+    header.disable_cdf_update = reader.f(1);
+
+    header.allow_screen_content_tools = sequence.seq_force_screen_content_tools === SELECT_SCREEN_CONTENT_TOOLS
+        ? reader.f(1)
+        : sequence.seq_force_screen_content_tools;
+
+    if (header.allow_screen_content_tools !== 0 && sequence.seq_force_integer_mv === SELECT_INTEGER_MV) {
+        // force_integer_mv, immediately overridden to 1 below because the frame is intra. Read
+        // because the bit is present, not because the value is used.
+        reader.f(1);
+    }
+
+    header.force_integer_mv = 1;
+
+    if (sequence.frame_id_numbers_present_flag === 1) {
+        header.current_frame_id = reader.f(id_length);
+    } else {
+        header.current_frame_id = 0;
+    }
+
+    header.frame_size_override_flag = sequence.reduced_still_picture_header === 1 ? 0 : reader.f(1);
+
+    header.order_hint = reader.f(sequence.order_hint_bits);
+
+    header.primary_ref_frame = PRIMARY_REF_NONE;
+
+    if (sequence.decoder_model_info_present_flag === 1) {
+        const buffer_removal_time_present_flag = reader.f(1);
+
+        if (buffer_removal_time_present_flag === 1) {
+            for (let op = 0; op <= sequence.operating_points_cnt_minus_1; op++) {
+                if (sequence.decoder_model_present_for_this_op[op] === 0) {
+                    continue;
+                }
+
+                const idc = sequence.operating_point_idc[op];
+
+                // the OBU extension header's ids are not tracked here; a still image carries a
+                // single operating point, so the layer test the specification applies is vacuous
+                // and every present buffer removal time is read
+                if (idc === 0 || true) {
+                    reader.f(sequence.buffer_removal_time_length_minus_1 + 1);
+                }
+            }
+        }
+    }
+
+    // a shown key frame refreshes every reference slot; the flags are not coded
+    header.refresh_frame_flags = header.show_frame === 1 ? 255 : reader.f(8);
+
+    if (header.refresh_frame_flags !== 255 && header.error_resilient_mode === 1 && sequence.enable_order_hint === 1) {
+        for (let i = 0; i < 8; i++) {
+            reader.f(sequence.order_hint_bits);
+        }
+    }
+
+    parse_frame_size(reader, sequence, header);
+    parse_render_size(reader, header);
+
+    header.allow_intrabc = header.allow_screen_content_tools !== 0 && header.upscaled_width === header.frame_width
+        ? reader.f(1)
+        : 0;
+
+    header.disable_frame_end_update_cdf = sequence.reduced_still_picture_header === 1 || header.disable_cdf_update === 1
+        ? 1
+        : reader.f(1);
+
+    parse_tile_info(reader, sequence, header);
+    parse_quantization_params(reader, sequence, header);
+    parse_segmentation_params(reader, header);
+    parse_delta_q_params(reader, header);
+    parse_delta_lf_params(reader, header);
+
+    compute_losslessness(header);
+
+    parse_loop_filter_params(reader, sequence, header);
+    parse_cdef_params(reader, sequence, header);
+    parse_lr_params(reader, sequence, header);
+
+    header.tx_mode = header.coded_lossless === 1
+        ? ONLY_4X4
+        : (reader.f(1) === 1 ? TX_MODE_SELECT : TX_MODE_LARGEST);
+
+    // frame_reference_mode, skip_mode_params and allow_warped_motion all code nothing for an intra
+    // frame, and global_motion_params codes nothing for a key frame
+
+    header.reduced_tx_set = reader.f(1);
+
+    parse_film_grain_params(reader, sequence, header);
+
+    return header;
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.5 "Frame size syntax"
+ */
+function parse_frame_size(reader, sequence, header) {
+    if (header.frame_size_override_flag === 1) {
+        header.frame_width = reader.f(sequence.frame_width_bits_minus_1 + 1) + 1;
+        header.frame_height = reader.f(sequence.frame_height_bits_minus_1 + 1) + 1;
+    } else {
+        header.frame_width = sequence.max_frame_width_minus_1 + 1;
+        header.frame_height = sequence.max_frame_height_minus_1 + 1;
+    }
+
+    parse_superres_params(reader, sequence, header);
+
+    header.mi_cols = 2 * ((header.frame_width + 7) >> 3);
+    header.mi_rows = 2 * ((header.frame_height + 7) >> 3);
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.8 "Superres params syntax"
+ */
+function parse_superres_params(reader, sequence, header) {
+    header.use_superres = sequence.enable_superres === 1 ? reader.f(1) : 0;
+
+    header.superres_denom = header.use_superres === 1
+        ? reader.f(SUPERRES_DENOM_BITS) + SUPERRES_DENOM_MIN
+        : SUPERRES_NUM;
+
+    header.upscaled_width = header.frame_width;
+
+    header.frame_width = Math.floor(
+        (header.upscaled_width * SUPERRES_NUM + Math.floor(header.superres_denom / 2)) / header.superres_denom
+    );
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.6 "Render size syntax"
+ */
+function parse_render_size(reader, header) {
+    header.render_and_frame_size_different = reader.f(1);
+
+    if (header.render_and_frame_size_different === 1) {
+        header.render_width = reader.f(16) + 1;
+        header.render_height = reader.f(16) + 1;
+    } else {
+        header.render_width = header.upscaled_width;
+        header.render_height = header.frame_height;
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.15 "Tile info syntax"
+ */
+function parse_tile_info(reader, sequence, header) {
+    const sb_shift = sequence.use_128x128_superblock === 1 ? 5 : 4;
+    const sb_size = sb_shift + 2;
+
+    const sb_cols = sequence.use_128x128_superblock === 1
+        ? (header.mi_cols + 31) >> 5
+        : (header.mi_cols + 15) >> 4;
+    const sb_rows = sequence.use_128x128_superblock === 1
+        ? (header.mi_rows + 31) >> 5
+        : (header.mi_rows + 15) >> 4;
+
+    const max_tile_width_sb = MAX_TILE_WIDTH >> sb_size;
+    let max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size);
+
+    const min_log2_tile_cols = tile_log2(max_tile_width_sb, sb_cols);
+    const max_log2_tile_cols = tile_log2(1, Math.min(sb_cols, MAX_TILE_COLS));
+    const max_log2_tile_rows = tile_log2(1, Math.min(sb_rows, MAX_TILE_ROWS));
+    const min_log2_tiles = Math.max(min_log2_tile_cols, tile_log2(max_tile_area_sb, sb_rows * sb_cols));
+
+    header.uniform_tile_spacing_flag = reader.f(1);
+
+    if (header.uniform_tile_spacing_flag === 1) {
+        header.tile_cols_log2 = min_log2_tile_cols;
+
+        while (header.tile_cols_log2 < max_log2_tile_cols) {
+            if (reader.f(1) === 1) {
+                header.tile_cols_log2++;
+            } else {
+                break;
+            }
+        }
+
+        const tile_width_sb = (sb_cols + (1 << header.tile_cols_log2) - 1) >> header.tile_cols_log2;
+
+        let i = 0;
+
+        for (let start_sb = 0; start_sb < sb_cols; start_sb += tile_width_sb) {
+            header.mi_col_starts[i] = start_sb << sb_shift;
+            i++;
+        }
+
+        header.mi_col_starts[i] = header.mi_cols;
+        header.tile_cols = i;
+
+        const min_log2_tile_rows = Math.max(min_log2_tiles - header.tile_cols_log2, 0);
+
+        header.tile_rows_log2 = min_log2_tile_rows;
+
+        while (header.tile_rows_log2 < max_log2_tile_rows) {
+            if (reader.f(1) === 1) {
+                header.tile_rows_log2++;
+            } else {
+                break;
+            }
+        }
+
+        const tile_height_sb = (sb_rows + (1 << header.tile_rows_log2) - 1) >> header.tile_rows_log2;
+
+        i = 0;
+
+        for (let start_sb = 0; start_sb < sb_rows; start_sb += tile_height_sb) {
+            header.mi_row_starts[i] = start_sb << sb_shift;
+            i++;
+        }
+
+        header.mi_row_starts[i] = header.mi_rows;
+        header.tile_rows = i;
+    } else {
+        let widest_tile_sb = 0;
+        let start_sb = 0;
+        let i = 0;
+
+        for (; start_sb < sb_cols; i++) {
+            if (i >= MAX_TILE_COLS) {
+                throw new Error("tile info declares more columns than the format allows");
+            }
+
+            header.mi_col_starts[i] = start_sb << sb_shift;
+
+            const max_width = Math.min(sb_cols - start_sb, max_tile_width_sb);
+            const size_sb = reader.ns(max_width) + 1;
+
+            widest_tile_sb = Math.max(size_sb, widest_tile_sb);
+            start_sb += size_sb;
+        }
+
+        header.mi_col_starts[i] = header.mi_cols;
+        header.tile_cols = i;
+        header.tile_cols_log2 = tile_log2(1, header.tile_cols);
+
+        max_tile_area_sb = min_log2_tiles > 0
+            ? (sb_rows * sb_cols) >> (min_log2_tiles + 1)
+            : sb_rows * sb_cols;
+
+        const max_tile_height_sb = Math.max(Math.floor(max_tile_area_sb / widest_tile_sb), 1);
+
+        start_sb = 0;
+        i = 0;
+
+        for (; start_sb < sb_rows; i++) {
+            if (i >= MAX_TILE_ROWS) {
+                throw new Error("tile info declares more rows than the format allows");
+            }
+
+            header.mi_row_starts[i] = start_sb << sb_shift;
+
+            const max_height = Math.min(sb_rows - start_sb, max_tile_height_sb);
+            const size_sb = reader.ns(max_height) + 1;
+
+            start_sb += size_sb;
+        }
+
+        header.mi_row_starts[i] = header.mi_rows;
+        header.tile_rows = i;
+        header.tile_rows_log2 = tile_log2(1, header.tile_rows);
+    }
+
+    if (header.tile_cols_log2 > 0 || header.tile_rows_log2 > 0) {
+        header.context_update_tile_id = reader.f(header.tile_rows_log2 + header.tile_cols_log2);
+        header.tile_size_bytes = reader.f(2) + 1;
+    } else {
+        header.context_update_tile_id = 0;
+        header.tile_size_bytes = 1;
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @returns {number}
+ * @see AV1 spec 5.9.13 "Delta quantizer syntax"
+ */
+function read_delta_q(reader) {
+    return reader.f(1) === 1 ? reader.su(7) : 0;
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.12 "Quantization params syntax"
+ */
+function parse_quantization_params(reader, sequence, header) {
+    header.base_q_idx = reader.f(8);
+    header.delta_q_y_dc = read_delta_q(reader);
+
+    if (sequence.num_planes > 1) {
+        header.diff_uv_delta = sequence.separate_uv_delta_q === 1 ? reader.f(1) : 0;
+
+        header.delta_q_u_dc = read_delta_q(reader);
+        header.delta_q_u_ac = read_delta_q(reader);
+
+        if (header.diff_uv_delta === 1) {
+            header.delta_q_v_dc = read_delta_q(reader);
+            header.delta_q_v_ac = read_delta_q(reader);
+        } else {
+            header.delta_q_v_dc = header.delta_q_u_dc;
+            header.delta_q_v_ac = header.delta_q_u_ac;
+        }
+    } else {
+        header.diff_uv_delta = 0;
+        header.delta_q_u_dc = 0;
+        header.delta_q_u_ac = 0;
+        header.delta_q_v_dc = 0;
+        header.delta_q_v_ac = 0;
+    }
+
+    header.using_qmatrix = reader.f(1);
+
+    if (header.using_qmatrix === 1) {
+        header.qm_y = reader.f(4);
+        header.qm_u = reader.f(4);
+        header.qm_v = sequence.separate_uv_delta_q === 1 ? reader.f(4) : header.qm_u;
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.14 "Segmentation params syntax"
+ */
+function parse_segmentation_params(reader, header) {
+    header.feature_enabled.fill(0);
+    header.feature_data.fill(0);
+
+    header.segmentation_enabled = reader.f(1);
+
+    if (header.segmentation_enabled === 1) {
+        // a key frame has no primary reference frame, so the map and data are always coded in full
+        header.segmentation_update_map = 1;
+        header.segmentation_temporal_update = 0;
+        header.segmentation_update_data = 1;
+
+        for (let i = 0; i < MAX_SEGMENTS; i++) {
+            for (let j = 0; j < SEG_LVL_MAX; j++) {
+                const enabled = reader.f(1);
+
+                header.feature_enabled[i * SEG_LVL_MAX + j] = enabled;
+
+                let clipped = 0;
+
+                if (enabled === 1) {
+                    const bits = SEGMENTATION_FEATURE_BITS[j];
+                    const limit = SEGMENTATION_FEATURE_MAX[j];
+
+                    if (SEGMENTATION_FEATURE_SIGNED[j] === 1) {
+                        clipped = clamp(reader.su(1 + bits), -limit, limit);
+                    } else {
+                        clipped = clamp(reader.f(bits), 0, limit);
+                    }
+                }
+
+                header.feature_data[i * SEG_LVL_MAX + j] = clipped;
+            }
+        }
+    }
+
+    header.seg_id_pre_skip = 0;
+    header.last_active_seg_id = 0;
+
+    for (let i = 0; i < MAX_SEGMENTS; i++) {
+        for (let j = 0; j < SEG_LVL_MAX; j++) {
+            if (header.feature_enabled[i * SEG_LVL_MAX + j] !== 0) {
+                header.last_active_seg_id = i;
+
+                if (j >= SEG_LVL_REF_FRAME) {
+                    header.seg_id_pre_skip = 1;
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.17 "Quantizer index delta parameters syntax"
+ */
+function parse_delta_q_params(reader, header) {
+    header.delta_q_res = 0;
+    header.delta_q_present = header.base_q_idx > 0 ? reader.f(1) : 0;
+
+    if (header.delta_q_present === 1) {
+        header.delta_q_res = reader.f(2);
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.18 "Loop filter delta parameters syntax"
+ */
+function parse_delta_lf_params(reader, header) {
+    header.delta_lf_present = 0;
+    header.delta_lf_res = 0;
+    header.delta_lf_multi = 0;
+
+    if (header.delta_q_present === 1) {
+        if (header.allow_intrabc === 0) {
+            header.delta_lf_present = reader.f(1);
+        }
+
+        if (header.delta_lf_present === 1) {
+            header.delta_lf_res = reader.f(2);
+            header.delta_lf_multi = reader.f(1);
+        }
+    }
+}
+
+/**
+ * Derive `CodedLossless`, `AllLossless` and the per-segment quantizer matrix levels.
+ *
+ * A segment is lossless only when its quantizer index is zero *and* every delta is zero: a non-zero
+ * delta on any plane reintroduces quantization even at index zero.
+ *
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.2 "Uncompressed header syntax"
+ */
+function compute_losslessness(header) {
+    header.coded_lossless = 1;
+
+    const deltas_zero = header.delta_q_y_dc === 0
+        && header.delta_q_u_ac === 0
+        && header.delta_q_u_dc === 0
+        && header.delta_q_v_ac === 0
+        && header.delta_q_v_dc === 0;
+
+    for (let segment = 0; segment < MAX_SEGMENTS; segment++) {
+        const qindex = get_qindex_ignoring_delta(header, segment);
+
+        const lossless = qindex === 0 && deltas_zero ? 1 : 0;
+
+        header.lossless_array[segment] = lossless;
+
+        if (lossless === 0) {
+            header.coded_lossless = 0;
+        }
+
+        if (header.using_qmatrix === 1) {
+            if (lossless === 1) {
+                header.seg_qm_level[0 * MAX_SEGMENTS + segment] = 15;
+                header.seg_qm_level[1 * MAX_SEGMENTS + segment] = 15;
+                header.seg_qm_level[2 * MAX_SEGMENTS + segment] = 15;
+            } else {
+                header.seg_qm_level[0 * MAX_SEGMENTS + segment] = header.qm_y;
+                header.seg_qm_level[1 * MAX_SEGMENTS + segment] = header.qm_u;
+                header.seg_qm_level[2 * MAX_SEGMENTS + segment] = header.qm_v;
+            }
+        }
+    }
+
+    header.all_lossless = header.coded_lossless === 1 && header.frame_width === header.upscaled_width ? 1 : 0;
+}
+
+/**
+ * `get_qindex( 1, segmentId )`: the segment's quantizer index, ignoring any per-block delta.
+ *
+ * @param {FrameHeader} header
+ * @param {number} segment
+ * @returns {number}
+ * @see AV1 spec 7.12.2 "Dequantization functions"
+ */
+function get_qindex_ignoring_delta(header, segment) {
+    if (header.segmentation_enabled === 1 && header.feature_enabled[segment * SEG_LVL_MAX + SEG_LVL_ALT_Q] !== 0) {
+        return clamp(header.base_q_idx + header.feature_data[segment * SEG_LVL_MAX + SEG_LVL_ALT_Q], 0, 255);
+    }
+
+    return header.base_q_idx;
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.11 "Loop filter params syntax"
+ */
+function parse_loop_filter_params(reader, sequence, header) {
+    header.loop_filter_level.fill(0);
+    header.loop_filter_mode_deltas.fill(0);
+
+    header.loop_filter_ref_deltas[INTRA_FRAME] = 1;
+    header.loop_filter_ref_deltas[1] = 0;
+    header.loop_filter_ref_deltas[2] = 0;
+    header.loop_filter_ref_deltas[3] = 0;
+    header.loop_filter_ref_deltas[GOLDEN_FRAME] = -1;
+    header.loop_filter_ref_deltas[5] = 0;
+    header.loop_filter_ref_deltas[ALTREF2_FRAME] = -1;
+    header.loop_filter_ref_deltas[ALTREF_FRAME] = -1;
+
+    if (header.coded_lossless === 1 || header.allow_intrabc === 1) {
+        return;
+    }
+
+    header.loop_filter_level[0] = reader.f(6);
+    header.loop_filter_level[1] = reader.f(6);
+
+    if (sequence.num_planes > 1 && (header.loop_filter_level[0] !== 0 || header.loop_filter_level[1] !== 0)) {
+        header.loop_filter_level[2] = reader.f(6);
+        header.loop_filter_level[3] = reader.f(6);
+    }
+
+    header.loop_filter_sharpness = reader.f(3);
+    header.loop_filter_delta_enabled = reader.f(1);
+
+    if (header.loop_filter_delta_enabled === 1) {
+        header.loop_filter_delta_update = reader.f(1);
+
+        if (header.loop_filter_delta_update === 1) {
+            for (let i = 0; i < TOTAL_REFS_PER_FRAME; i++) {
+                if (reader.f(1) === 1) {
+                    header.loop_filter_ref_deltas[i] = reader.su(7);
+                }
+            }
+
+            for (let i = 0; i < 2; i++) {
+                if (reader.f(1) === 1) {
+                    header.loop_filter_mode_deltas[i] = reader.su(7);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.19 "CDEF params syntax"
+ */
+function parse_cdef_params(reader, sequence, header) {
+    header.cdef_y_pri_strength.fill(0);
+    header.cdef_y_sec_strength.fill(0);
+    header.cdef_uv_pri_strength.fill(0);
+    header.cdef_uv_sec_strength.fill(0);
+
+    if (header.coded_lossless === 1 || header.allow_intrabc === 1 || sequence.enable_cdef === 0) {
+        header.cdef_bits = 0;
+        header.cdef_damping = 3;
+
+        return;
+    }
+
+    header.cdef_damping = reader.f(2) + 3;
+    header.cdef_bits = reader.f(2);
+
+    for (let i = 0; i < (1 << header.cdef_bits); i++) {
+        header.cdef_y_pri_strength[i] = reader.f(4);
+        header.cdef_y_sec_strength[i] = reader.f(2);
+
+        // strength 3 is coded but means 4; the gap at 3 is deliberate in the format
+        if (header.cdef_y_sec_strength[i] === 3) {
+            header.cdef_y_sec_strength[i] = 4;
+        }
+
+        if (sequence.num_planes > 1) {
+            header.cdef_uv_pri_strength[i] = reader.f(4);
+            header.cdef_uv_sec_strength[i] = reader.f(2);
+
+            if (header.cdef_uv_sec_strength[i] === 3) {
+                header.cdef_uv_sec_strength[i] = 4;
+            }
+        }
+    }
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.20 "Loop restoration params syntax"
+ */
+function parse_lr_params(reader, sequence, header) {
+    header.frame_restoration_type[0] = RESTORE_NONE;
+    header.frame_restoration_type[1] = RESTORE_NONE;
+    header.frame_restoration_type[2] = RESTORE_NONE;
+    header.uses_lr = 0;
+    header.lr_unit_shift = 0;
+    header.lr_uv_shift = 0;
+
+    if (header.all_lossless === 1 || header.allow_intrabc === 1 || sequence.enable_restoration === 0) {
+        return;
+    }
+
+    let uses_chroma_lr = 0;
+
+    for (let i = 0; i < sequence.num_planes; i++) {
+        const lr_type = reader.f(2);
+
+        header.frame_restoration_type[i] = REMAP_LR_TYPE[lr_type];
+
+        if (header.frame_restoration_type[i] !== RESTORE_NONE) {
+            header.uses_lr = 1;
+
+            if (i > 0) {
+                uses_chroma_lr = 1;
+            }
+        }
+    }
+
+    if (header.uses_lr === 0) {
+        return;
+    }
+
+    if (sequence.use_128x128_superblock === 1) {
+        header.lr_unit_shift = reader.f(1) + 1;
+    } else {
+        header.lr_unit_shift = reader.f(1);
+
+        if (header.lr_unit_shift !== 0) {
+            header.lr_unit_shift += reader.f(1);
+        }
+    }
+
+    header.loop_restoration_size[0] = RESTORATION_TILESIZE_MAX >> (2 - header.lr_unit_shift);
+
+    header.lr_uv_shift = sequence.subsampling_x === 1 && sequence.subsampling_y === 1 && uses_chroma_lr === 1
+        ? reader.f(1)
+        : 0;
+
+    header.loop_restoration_size[1] = header.loop_restoration_size[0] >> header.lr_uv_shift;
+    header.loop_restoration_size[2] = header.loop_restoration_size[0] >> header.lr_uv_shift;
+}
+
+/**
+ * @param {BitReader} reader
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header
+ * @see AV1 spec 5.9.30 "Film grain params syntax"
+ */
+function parse_film_grain_params(reader, sequence, header) {
+    header.apply_grain = 0;
+
+    if (sequence.film_grain_params_present === 0 || (header.show_frame === 0 && header.showable_frame === 0)) {
+        return;
+    }
+
+    header.apply_grain = reader.f(1);
+
+    if (header.apply_grain === 0) {
+        return;
+    }
+
+    header.grain_seed = reader.f(16);
+
+    // update_grain is only coded for inter frames, and this decoder has none
+
+    header.num_y_points = reader.f(4);
+
+    if (header.num_y_points > 14) {
+        throw new Error(`film grain declares ${header.num_y_points} luma points, beyond the 14 the format allows`);
+    }
+
+    for (let i = 0; i < header.num_y_points; i++) {
+        header.point_y_value[i] = reader.f(8);
+        header.point_y_scaling[i] = reader.f(8);
+    }
+
+    header.chroma_scaling_from_luma = sequence.mono_chrome === 1 ? 0 : reader.f(1);
+
+    if (sequence.mono_chrome === 1
+        || header.chroma_scaling_from_luma === 1
+        || (sequence.subsampling_x === 1 && sequence.subsampling_y === 1 && header.num_y_points === 0)) {
+        header.num_cb_points = 0;
+        header.num_cr_points = 0;
+    } else {
+        header.num_cb_points = reader.f(4);
+
+        if (header.num_cb_points > 10) {
+            throw new Error(`film grain declares ${header.num_cb_points} Cb points, beyond the 10 the format allows`);
+        }
+
+        for (let i = 0; i < header.num_cb_points; i++) {
+            header.point_cb_value[i] = reader.f(8);
+            header.point_cb_scaling[i] = reader.f(8);
+        }
+
+        header.num_cr_points = reader.f(4);
+
+        if (header.num_cr_points > 10) {
+            throw new Error(`film grain declares ${header.num_cr_points} Cr points, beyond the 10 the format allows`);
+        }
+
+        for (let i = 0; i < header.num_cr_points; i++) {
+            header.point_cr_value[i] = reader.f(8);
+            header.point_cr_scaling[i] = reader.f(8);
+        }
+    }
+
+    header.grain_scaling_minus_8 = reader.f(2);
+    header.ar_coeff_lag = reader.f(2);
+
+    const num_pos_luma = 2 * header.ar_coeff_lag * (header.ar_coeff_lag + 1);
+
+    let num_pos_chroma = num_pos_luma;
+
+    if (header.num_y_points !== 0) {
+        num_pos_chroma = num_pos_luma + 1;
+
+        for (let i = 0; i < num_pos_luma; i++) {
+            header.ar_coeffs_y_plus_128[i] = reader.f(8);
+        }
+    }
+
+    if (header.chroma_scaling_from_luma === 1 || header.num_cb_points !== 0) {
+        for (let i = 0; i < num_pos_chroma; i++) {
+            header.ar_coeffs_cb_plus_128[i] = reader.f(8);
+        }
+    }
+
+    if (header.chroma_scaling_from_luma === 1 || header.num_cr_points !== 0) {
+        for (let i = 0; i < num_pos_chroma; i++) {
+            header.ar_coeffs_cr_plus_128[i] = reader.f(8);
+        }
+    }
+
+    header.ar_coeff_shift_minus_6 = reader.f(2);
+    header.grain_scale_shift = reader.f(2);
+
+    if (header.num_cb_points !== 0) {
+        header.cb_mult = reader.f(8);
+        header.cb_luma_mult = reader.f(8);
+        header.cb_offset = reader.f(9);
+    }
+
+    if (header.num_cr_points !== 0) {
+        header.cr_mult = reader.f(8);
+        header.cr_luma_mult = reader.f(8);
+        header.cr_offset = reader.f(9);
+    }
+
+    header.overlap_flag = reader.f(1);
+    header.clip_to_restricted_range = reader.f(1);
+}