atmos/os_lib/

h264_decode.rs

// h264_decode.rs - H.264 baseline スライス/マクロブロック層 + CAVLC 残差復号 + 再構成。
//
// h264.rs（BitReader / SPS-PPS / イントラ予測 / IDCT）の上に、I スライスの
// 画素復元を実装する。検証はゴールデン素材（h264_golden.rs）で行う。
// 現状の対応: I スライス、I_16x16 と I_4x4、CAVLC、4:2:0。
// 未対応: P/B、デブロッキング、CABAC、スライスグループ。
#![allow(dead_code, clippy::needless_range_loop)]

use super::h264::{
    dequant_4x4, extract_rbsp, intra_16x16_predict, intra_4x4_predict, intra_chroma_predict,
    inverse_transform_4x4, parse_avcc, parse_pps, parse_sps, split_annexb, split_avcc, BitReader,
    Pps, Sps, NORM_ADJUST_4X4,
};
use super::h264_cabac::CabacEngine;
use super::h264_slice::{parse_slice_header, PocState, PredWeightTable, SliceKind};
use alloc::vec::Vec;

// 4x4 ジグザグスキャン（スキャン位置 -> ラスタ index）。
const ZIGZAG_4X4: [usize; 16] = [0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15];

// 1 MB 内の 16 個の輝度 4x4 ブロックのラスタ左上座標（画素）。
// ブロック index は標準の 4x4 luma block 走査順（8x8 ごとに z スキャン）。
const LUMA_4X4_BLOCK_XY: [(usize, usize); 16] = [
    (0, 0),
    (4, 0),
    (0, 4),
    (4, 4),
    (8, 0),
    (12, 0),
    (8, 4),
    (12, 4),
    (0, 8),
    (4, 8),
    (0, 12),
    (4, 12),
    (8, 8),
    (12, 8),
    (8, 12),
    (12, 12),
];

fn clip1(v: i32) -> i32 {
    v.clamp(0, 255)
}

// ===================== CAVLC テーブル =====================
// 各エントリ: (len, code, total_coeff, trailing_ones)。プレフィックスフリーなので
// ビットを1つずつ読みながら (len, code) 完全一致で確定する。

type TokEntry = (u8, u16, u8, u8);

// Table 9-5: 0 <= nC < 2
const COEFF_TOKEN_0: &[TokEntry] = &[
    (1, 0b1, 0, 0),
    (6, 0b000101, 1, 0),
    (2, 0b01, 1, 1),
    (8, 0b00000111, 2, 0),
    (6, 0b000100, 2, 1),
    (3, 0b001, 2, 2),
    (9, 0b000000111, 3, 0),
    (8, 0b00000110, 3, 1),
    (7, 0b0000101, 3, 2),
    (5, 0b00011, 3, 3),
    (10, 0b0000000111, 4, 0),
    (9, 0b000000110, 4, 1),
    (8, 0b00000101, 4, 2),
    (6, 0b000011, 4, 3),
    (11, 0b00000000111, 5, 0),
    (10, 0b0000000110, 5, 1),
    (9, 0b000000101, 5, 2),
    (7, 0b0000100, 5, 3),
    (13, 0b0000000001111, 6, 0),
    (11, 0b00000000110, 6, 1),
    (10, 0b0000000101, 6, 2),
    (8, 0b00000100, 6, 3),
    (13, 0b0000000001011, 7, 0),
    (13, 0b0000000001110, 7, 1),
    (11, 0b00000000101, 7, 2),
    (9, 0b000000100, 7, 3),
    (13, 0b0000000001000, 8, 0),
    (13, 0b0000000001010, 8, 1),
    (13, 0b0000000001101, 8, 2),
    (10, 0b0000000100, 8, 3),
    (14, 0b00000000001111, 9, 0),
    (14, 0b00000000001110, 9, 1),
    (13, 0b0000000001001, 9, 2),
    (11, 0b00000000100, 9, 3),
    (14, 0b00000000001011, 10, 0),
    (14, 0b00000000001010, 10, 1),
    (14, 0b00000000001101, 10, 2),
    (13, 0b0000000001100, 10, 3),
    (15, 0b000000000001111, 11, 0),
    (15, 0b000000000001110, 11, 1),
    (14, 0b00000000001001, 11, 2),
    (14, 0b00000000001100, 11, 3),
    (15, 0b000000000001011, 12, 0),
    (15, 0b000000000001010, 12, 1),
    (15, 0b000000000001101, 12, 2),
    (14, 0b00000000001000, 12, 3),
    (16, 0b0000000000001111, 13, 0),
    (15, 0b000000000000001, 13, 1),
    (15, 0b000000000001001, 13, 2),
    (15, 0b000000000001100, 13, 3),
    (16, 0b0000000000001011, 14, 0),
    (16, 0b0000000000001110, 14, 1),
    (16, 0b0000000000001101, 14, 2),
    (15, 0b000000000001000, 14, 3),
    (16, 0b0000000000000111, 15, 0),
    (16, 0b0000000000001010, 15, 1),
    (16, 0b0000000000001001, 15, 2),
    (16, 0b0000000000001100, 15, 3),
    (16, 0b0000000000000100, 16, 0),
    (16, 0b0000000000000110, 16, 1),
    (16, 0b0000000000000101, 16, 2),
    (16, 0b0000000000001000, 16, 3),
];

// Table 9-5: chroma DC, 4:2:0（nC == -1）
const COEFF_TOKEN_CHROMA_DC: &[TokEntry] = &[
    (2, 0b01, 0, 0),
    (6, 0b000111, 1, 0),
    (1, 0b1, 1, 1),
    (6, 0b000100, 2, 0),
    (6, 0b000110, 2, 1),
    (3, 0b001, 2, 2),
    (6, 0b000011, 3, 0),
    (7, 0b0000011, 3, 1),
    (7, 0b0000010, 3, 2),
    (6, 0b000101, 3, 3),
    (6, 0b000010, 4, 0),
    (8, 0b00000011, 4, 1),
    (8, 0b00000010, 4, 2),
    (7, 0b0000000, 4, 3),
];

/// coeff_token を読み (total_coeff, trailing_ones) を返す。table は上記のいずれか。
fn read_coeff_token(r: &mut BitReader, table: &[TokEntry]) -> Option<(u8, u8)> {
    let mut code: u16 = 0;
    for len in 1..=16u8 {
        code = (code << 1) | (r.read_bit() as u16);
        for &(l, c, tc, t1) in table {
            if l == len && c == code {
                return Some((tc, t1));
            }
        }
    }
    None
}

// Table 9-5: 2 <= nC < 4
const COEFF_TOKEN_2: &[TokEntry] = &[
    (2, 0b11, 0, 0),
    (6, 0b001011, 1, 0),
    (2, 0b10, 1, 1),
    (6, 0b000111, 2, 0),
    (5, 0b00111, 2, 1),
    (3, 0b011, 2, 2),
    (7, 0b0000111, 3, 0),
    (6, 0b001010, 3, 1),
    (6, 0b001001, 3, 2),
    (4, 0b0101, 3, 3),
    (8, 0b00000111, 4, 0),
    (6, 0b000110, 4, 1),
    (6, 0b000101, 4, 2),
    (4, 0b0100, 4, 3),
    (8, 0b00000100, 5, 0),
    (7, 0b0000110, 5, 1),
    (7, 0b0000101, 5, 2),
    (5, 0b00110, 5, 3),
    (9, 0b000000111, 6, 0),
    (8, 0b00000110, 6, 1),
    (8, 0b00000101, 6, 2),
    (6, 0b001000, 6, 3),
    (11, 0b00000001111, 7, 0),
    (9, 0b000000110, 7, 1),
    (9, 0b000000101, 7, 2),
    (6, 0b000100, 7, 3),
    (11, 0b00000001011, 8, 0),
    (11, 0b00000001110, 8, 1),
    (11, 0b00000001101, 8, 2),
    (7, 0b0000100, 8, 3),
    (12, 0b000000001111, 9, 0),
    (11, 0b00000001010, 9, 1),
    (11, 0b00000001001, 9, 2),
    (9, 0b000000100, 9, 3),
    (12, 0b000000001011, 10, 0),
    (12, 0b000000001110, 10, 1),
    (12, 0b000000001101, 10, 2),
    (11, 0b00000001100, 10, 3),
    (12, 0b000000001000, 11, 0),
    (12, 0b000000001010, 11, 1),
    (12, 0b000000001001, 11, 2),
    (11, 0b00000001000, 11, 3),
    (13, 0b0000000001111, 12, 0),
    (13, 0b0000000001110, 12, 1),
    (13, 0b0000000001101, 12, 2),
    (12, 0b000000001100, 12, 3),
    (13, 0b0000000001011, 13, 0),
    (13, 0b0000000001010, 13, 1),
    (13, 0b0000000001001, 13, 2),
    (13, 0b0000000001100, 13, 3),
    (13, 0b0000000000111, 14, 0),
    (14, 0b00000000001011, 14, 1),
    (13, 0b0000000000110, 14, 2),
    (13, 0b0000000001000, 14, 3),
    (14, 0b00000000001001, 15, 0),
    (14, 0b00000000001000, 15, 1),
    (14, 0b00000000001010, 15, 2),
    (13, 0b0000000000001, 15, 3),
    (14, 0b00000000000111, 16, 0),
    (14, 0b00000000000110, 16, 1),
    (14, 0b00000000000101, 16, 2),
    (14, 0b00000000000100, 16, 3),
];

// Table 9-5: 4 <= nC < 8
const COEFF_TOKEN_4: &[TokEntry] = &[
    (4, 0b1111, 0, 0),
    (6, 0b001111, 1, 0),
    (4, 0b1110, 1, 1),
    (6, 0b001011, 2, 0),
    (5, 0b01111, 2, 1),
    (4, 0b1101, 2, 2),
    (6, 0b001000, 3, 0),
    (5, 0b01100, 3, 1),
    (5, 0b01110, 3, 2),
    (4, 0b1100, 3, 3),
    (7, 0b0001111, 4, 0),
    (5, 0b01010, 4, 1),
    (5, 0b01011, 4, 2),
    (4, 0b1011, 4, 3),
    (7, 0b0001011, 5, 0),
    (5, 0b01000, 5, 1),
    (5, 0b01001, 5, 2),
    (4, 0b1010, 5, 3),
    (7, 0b0001001, 6, 0),
    (6, 0b001110, 6, 1),
    (6, 0b001101, 6, 2),
    (4, 0b1001, 6, 3),
    (7, 0b0001000, 7, 0),
    (6, 0b001010, 7, 1),
    (6, 0b001001, 7, 2),
    (4, 0b1000, 7, 3),
    (8, 0b00001111, 8, 0),
    (7, 0b0001110, 8, 1),
    (7, 0b0001101, 8, 2),
    (5, 0b01101, 8, 3),
    (8, 0b00001011, 9, 0),
    (8, 0b00001110, 9, 1),
    (7, 0b0001010, 9, 2),
    (6, 0b001100, 9, 3),
    (9, 0b000001111, 10, 0),
    (8, 0b00001010, 10, 1),
    (8, 0b00001101, 10, 2),
    (7, 0b0001100, 10, 3),
    (9, 0b000001011, 11, 0),
    (9, 0b000001110, 11, 1),
    (8, 0b00001001, 11, 2),
    (8, 0b00001100, 11, 3),
    (9, 0b000001000, 12, 0),
    (9, 0b000001010, 12, 1),
    (9, 0b000001101, 12, 2),
    (8, 0b00001000, 12, 3),
    (10, 0b0000001101, 13, 0),
    (9, 0b000000111, 13, 1),
    (9, 0b000001001, 13, 2),
    (9, 0b000001100, 13, 3),
    (10, 0b0000001001, 14, 0),
    (10, 0b0000001100, 14, 1),
    (10, 0b0000001011, 14, 2),
    (10, 0b0000001010, 14, 3),
    (10, 0b0000000101, 15, 0),
    (10, 0b0000001000, 15, 1),
    (10, 0b0000000111, 15, 2),
    (10, 0b0000000110, 15, 3),
    (10, 0b0000000001, 16, 0),
    (10, 0b0000000100, 16, 1),
    (10, 0b0000000011, 16, 2),
    (10, 0b0000000010, 16, 3),
];

/// coeff_token を nC に応じて復号。nC>=8 は 6bit FLC、nC==-1 はクロマ DC 表。
fn read_coeff_token_nc(r: &mut BitReader, n_c: i32) -> Option<(u8, u8)> {
    if n_c == -1 {
        return read_coeff_token(r, COEFF_TOKEN_CHROMA_DC);
    }
    if n_c >= 8 {
        let code = r.read_bits(6);
        if code == 3 {
            return Some((0, 0));
        }
        return Some(((code >> 2) as u8 + 1, (code & 3) as u8));
    }
    let table = if n_c < 2 {
        COEFF_TOKEN_0
    } else if n_c < 4 {
        COEFF_TOKEN_2
    } else {
        COEFF_TOKEN_4
    };
    read_coeff_token(r, table)
}

// Table 9-4: coded_block_pattern の me(v) 復号。codeNum -> cbp（Intra_4x4, ChromaArrayType=1/2）。
const CBP_INTRA_MAP: [u8; 48] = [
    47, 31, 15, 0, 23, 27, 29, 30, 7, 11, 13, 14, 39, 43, 45, 46, 16, 3, 5, 10, 12, 19, 21, 26, 28,
    35, 37, 42, 44, 1, 2, 4, 8, 17, 18, 20, 24, 6, 9, 22, 25, 32, 33, 34, 36, 40, 38, 41,
];

// Table 9-4: coded_block_pattern の me(v) 復号（インター MB 用、ffmpeg golomb_to_inter_cbp）。
const CBP_INTER_MAP: [u8; 48] = [
    0, 16, 1, 2, 4, 8, 32, 3, 5, 10, 12, 15, 47, 7, 11, 13, 14, 6, 9, 31, 35, 37, 42, 44, 33, 34,
    36, 40, 39, 43, 45, 46, 17, 18, 20, 24, 19, 21, 26, 28, 23, 27, 29, 30, 22, 25, 38, 41,
];

// デブロッキング閾値（Table 8-16 / 8-17、ffmpeg の値から生成）。
const ALPHA_TABLE: [u8; 52] = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 5, 6, 7, 8, 9, 10, 12, 13, 15, 17, 20,
    22, 25, 28, 32, 36, 40, 45, 50, 56, 63, 71, 80, 90, 101, 113, 127, 144, 162, 182, 203, 226,
    255, 255,
];
const BETA_TABLE: [u8; 52] = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 6, 6, 7, 7, 8, 8,
    9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
];
// TC0_TABLE[indexA][bS-1]（bS=1,2,3）。
const TC0_TABLE: [[u8; 3]; 52] = [
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 1],
    [0, 0, 1],
    [0, 0, 1],
    [0, 0, 1],
    [0, 1, 1],
    [0, 1, 1],
    [1, 1, 1],
    [1, 1, 1],
    [1, 1, 1],
    [1, 1, 1],
    [1, 1, 2],
    [1, 1, 2],
    [1, 1, 2],
    [1, 1, 2],
    [1, 2, 3],
    [1, 2, 3],
    [2, 2, 3],
    [2, 2, 4],
    [2, 3, 4],
    [2, 3, 4],
    [3, 3, 5],
    [3, 4, 6],
    [3, 4, 6],
    [4, 5, 7],
    [4, 5, 8],
    [4, 6, 9],
    [5, 7, 10],
    [6, 8, 11],
    [6, 8, 13],
    [7, 10, 14],
    [8, 11, 16],
    [9, 12, 18],
    [10, 13, 20],
    [11, 15, 23],
    [13, 17, 25],
];

// Table 9-7/9-8: total_zeros（maxNumCoeff=16）。行 = total_coeff(1..15)、
// 各行 entry: (len, code) を total_zeros=0,1,2,... の順で並べる。
const TOTAL_ZEROS_16: &[&[(u8, u16)]] = &[
    &[
        (1, 0b1),
        (3, 0b011),
        (3, 0b010),
        (4, 0b0011),
        (4, 0b0010),
        (5, 0b00011),
        (5, 0b00010),
        (6, 0b000011),
        (6, 0b000010),
        (7, 0b0000011),
        (7, 0b0000010),
        (8, 0b00000011),
        (8, 0b00000010),
        (9, 0b000000011),
        (9, 0b000000010),
        (9, 0b000000001),
    ],
    &[
        (3, 0b111),
        (3, 0b110),
        (3, 0b101),
        (3, 0b100),
        (3, 0b011),
        (4, 0b0101),
        (4, 0b0100),
        (4, 0b0011),
        (4, 0b0010),
        (5, 0b00011),
        (5, 0b00010),
        (6, 0b000011),
        (6, 0b000010),
        (6, 0b000001),
        (6, 0b000000),
    ],
    &[
        (4, 0b0101),
        (3, 0b111),
        (3, 0b110),
        (3, 0b101),
        (4, 0b0100),
        (4, 0b0011),
        (3, 0b100),
        (3, 0b011),
        (4, 0b0010),
        (5, 0b00011),
        (5, 0b00010),
        (6, 0b000001),
        (5, 0b00001),
        (6, 0b000000),
    ],
    &[
        (5, 0b00011),
        (3, 0b111),
        (4, 0b0101),
        (4, 0b0100),
        (3, 0b110),
        (3, 0b101),
        (3, 0b100),
        (4, 0b0011),
        (3, 0b011),
        (4, 0b0010),
        (5, 0b00010),
        (5, 0b00001),
        (5, 0b00000),
    ],
    &[
        (4, 0b0101),
        (4, 0b0100),
        (4, 0b0011),
        (3, 0b111),
        (3, 0b110),
        (3, 0b101),
        (3, 0b100),
        (3, 0b011),
        (4, 0b0010),
        (5, 0b00001),
        (4, 0b0001),
        (5, 0b00000),
    ],
    &[
        (6, 0b000001),
        (5, 0b00001),
        (3, 0b111),
        (3, 0b110),
        (3, 0b101),
        (3, 0b100),
        (3, 0b011),
        (3, 0b010),
        (4, 0b0001),
        (3, 0b001),
        (6, 0b000000),
    ],
    &[
        (6, 0b000001),
        (5, 0b00001),
        (3, 0b101),
        (3, 0b100),
        (3, 0b011),
        (2, 0b11),
        (3, 0b010),
        (4, 0b0001),
        (3, 0b001),
        (6, 0b000000),
    ],
    &[
        (6, 0b000001),
        (4, 0b0001),
        (5, 0b00001),
        (3, 0b011),
        (2, 0b11),
        (2, 0b10),
        (3, 0b010),
        (3, 0b001),
        (6, 0b000000),
    ],
    &[
        (6, 0b000001),
        (6, 0b000000),
        (4, 0b0001),
        (2, 0b11),
        (2, 0b10),
        (3, 0b001),
        (2, 0b01),
        (5, 0b00001),
    ],
    &[
        (5, 0b00001),
        (5, 0b00000),
        (3, 0b001),
        (2, 0b11),
        (2, 0b10),
        (2, 0b01),
        (4, 0b0001),
    ],
    &[
        (4, 0b0000),
        (4, 0b0001),
        (3, 0b001),
        (3, 0b010),
        (1, 0b1),
        (3, 0b011),
    ],
    &[(4, 0b0000), (4, 0b0001), (2, 0b01), (1, 0b1), (3, 0b001)],
    &[(3, 0b000), (3, 0b001), (1, 0b1), (2, 0b01)],
    &[(2, 0b00), (2, 0b01), (1, 0b1)],
    &[(1, 0b0), (1, 0b1)],
];

// Table 9-9(a): total_zeros for chroma DC（maxNumCoeff=4）。行 = total_coeff(1..3)。
const TOTAL_ZEROS_CHROMA: &[&[(u8, u16)]] = &[
    &[(1, 0b1), (2, 0b01), (3, 0b001), (3, 0b000)],
    &[(1, 0b1), (2, 0b01), (2, 0b00)],
    &[(1, 0b1), (1, 0b0)],
];

fn read_total_zeros(r: &mut BitReader, total_coeff: u8, tables: &[&[(u8, u16)]]) -> u8 {
    let row = tables[(total_coeff - 1) as usize];
    let mut code: u16 = 0;
    for len in 1..=9u8 {
        code = (code << 1) | (r.read_bit() as u16);
        for (tz, &(l, c)) in row.iter().enumerate() {
            if l == len && c == code {
                return tz as u8;
            }
        }
    }
    0
}

// Table 9-10: run_before。index = min(zerosLeft,7)-1、entry order = run_before 0,1,2,...
const RUN_BEFORE: &[&[(u8, u16)]] = &[
    &[(1, 0b1), (1, 0b0)],
    &[(1, 0b1), (2, 0b01), (2, 0b00)],
    &[(2, 0b11), (2, 0b10), (2, 0b01), (2, 0b00)],
    &[(2, 0b11), (2, 0b10), (2, 0b01), (3, 0b001), (3, 0b000)],
    &[
        (2, 0b11),
        (2, 0b10),
        (3, 0b011),
        (3, 0b010),
        (3, 0b001),
        (3, 0b000),
    ],
    &[
        (2, 0b11),
        (3, 0b000),
        (3, 0b001),
        (3, 0b011),
        (3, 0b010),
        (3, 0b101),
        (3, 0b100),
    ],
    &[
        (3, 0b111),
        (3, 0b110),
        (3, 0b101),
        (3, 0b100),
        (3, 0b011),
        (3, 0b010),
        (3, 0b001),
        (4, 0b0001),
        (5, 0b00001),
        (6, 0b000001),
        (7, 0b0000001),
        (8, 0b00000001),
        (9, 0b000000001),
        (10, 0b0000000001),
        (11, 0b00000000001),
    ],
];

fn read_run_before(r: &mut BitReader, zeros_left: i32) -> i32 {
    let idx = (zeros_left.min(7) - 1).max(0) as usize;
    let row = RUN_BEFORE[idx];
    let mut code: u16 = 0;
    for len in 1..=11u8 {
        code = (code << 1) | (r.read_bit() as u16);
        for (run, &(l, c)) in row.iter().enumerate() {
            if l == len && c == code {
                return run as i32;
            }
        }
    }
    0
}

/// CAVLC で 1 残差ブロックを復号。スキャン順の係数配列と total_coeff を返す。
/// n_c: 近傍係数数（-1=chroma DC, >=8=FLC）。tz_tables: total_zeros VLC 群。
fn residual_block_cavlc(
    r: &mut BitReader,
    max_num_coeff: usize,
    n_c: i32,
    tz_tables: &[&[(u8, u16)]],
) -> ([i32; 16], u8) {
    let mut coeff = [0i32; 16];
    let (total_coeff, trailing_ones) = match read_coeff_token_nc(r, n_c) {
        Some(v) => v,
        None => return (coeff, 0),
    };
    let ret_total = total_coeff;
    if total_coeff == 0 {
        return (coeff, 0);
    }
    let total_coeff = total_coeff as usize;
    let trailing_ones = trailing_ones as usize;

    // レベル復号（高周波から）
    let mut level = [0i32; 16];
    for i in 0..trailing_ones {
        level[i] = if r.read_bit() == 1 { -1 } else { 1 };
    }
    let mut suffix_length: u32 = if total_coeff > 10 && trailing_ones < 3 {
        1
    } else {
        0
    };
    for i in trailing_ones..total_coeff {
        let mut level_prefix = 0u32;
        while r.read_bit() == 0 {
            level_prefix += 1;
            if level_prefix > 31 {
                break;
            }
        }
        let mut suffix_size = suffix_length;
        if level_prefix == 14 && suffix_length == 0 {
            suffix_size = 4;
        } else if level_prefix >= 15 {
            suffix_size = level_prefix - 3;
        }
        let level_suffix = if suffix_size > 0 {
            r.read_bits(suffix_size) as i32
        } else {
            0
        };
        let mut level_code = ((level_prefix.min(15) << suffix_length) as i32) + level_suffix;
        if level_prefix >= 15 && suffix_length == 0 {
            level_code += 15;
        }
        if level_prefix >= 16 {
            level_code += (1 << (level_prefix - 3)) - 4096;
        }
        if i == trailing_ones && trailing_ones < 3 {
            level_code += 2;
        }
        level[i] = if level_code % 2 == 0 {
            (level_code + 2) >> 1
        } else {
            (-level_code - 1) >> 1
        };
        if suffix_length == 0 {
            suffix_length = 1;
        }
        if level[i].unsigned_abs() > (3u32 << (suffix_length - 1)) && suffix_length < 6 {
            suffix_length += 1;
        }
    }

    // total_zeros
    let total_zeros = if total_coeff < max_num_coeff {
        read_total_zeros(r, total_coeff as u8, tz_tables) as i32
    } else {
        0
    };

    // run_before
    let mut run = [0i32; 16];
    let mut zeros_left = total_zeros;
    for i in 0..total_coeff {
        if i < total_coeff - 1 && zeros_left > 0 {
            let rb = read_run_before(r, zeros_left);
            run[i] = rb;
            zeros_left -= rb;
        } else if i == total_coeff - 1 {
            run[i] = zeros_left;
        } else {
            run[i] = 0;
        }
    }

    // スキャン順へ配置（高周波 level[0] を高 index に）
    let mut coeff_ctr: i32 = -1;
    for i in (0..total_coeff).rev() {
        coeff_ctr += run[i] + 1;
        if (coeff_ctr as usize) < 16 {
            coeff[coeff_ctr as usize] = level[i];
        }
    }
    (coeff, ret_total)
}

// ===================== 変換（DC 用 Hadamard） =====================

/// I_16x16 輝度 DC の 4x4 逆 Hadamard 変換（in-place、raster）。丸め無し。
fn inverse_hadamard_4x4(b: &mut [i32; 16]) {
    for i in 0..4 {
        let o = i * 4;
        let (a0, a1, a2, a3) = (
            b[o] + b[o + 2],
            b[o] - b[o + 2],
            b[o + 1] - b[o + 3],
            b[o + 1] + b[o + 3],
        );
        b[o] = a0 + a3;
        b[o + 1] = a1 + a2;
        b[o + 2] = a1 - a2;
        b[o + 3] = a0 - a3;
    }
    for j in 0..4 {
        let (a0, a1, a2, a3) = (
            b[j] + b[8 + j],
            b[j] - b[8 + j],
            b[4 + j] - b[12 + j],
            b[4 + j] + b[12 + j],
        );
        b[j] = a0 + a3;
        b[4 + j] = a1 + a2;
        b[8 + j] = a1 - a2;
        b[12 + j] = a0 - a3;
    }
}

/// I_16x16 輝度 DC のスケーリング（8.5.10）。
fn scale_luma_dc(f: &mut [i32; 16], qp: i32) {
    let m = (qp % 6) as usize;
    let ls = 16 * NORM_ADJUST_4X4[m][0];
    let shift = qp / 6;
    for v in f.iter_mut() {
        *v = if qp >= 36 {
            (*v * ls) << (shift - 6)
        } else {
            (*v * ls + (1 << (5 - shift))) >> (6 - shift)
        };
    }
}

// ===================== スライス/MB 復号 =====================

pub struct DecodedYuv {
    pub width: u32,
    pub height: u32,
    pub y: Vec<u8>,
    pub u: Vec<u8>,
    pub v: Vec<u8>,
}

/// YUV420 → RGB24（BT.601、各画素 [R,G,B]）。描画経路用。
pub fn yuv_to_rgb(yuv: &DecodedYuv) -> Vec<u8> {
    let w = yuv.width as usize;
    let h = yuv.height as usize;
    let cw = (yuv.width / 2) as usize;
    let mut rgb = alloc::vec![0u8; w * h * 3];
    let mut oi = 0usize;
    for y in 0..h {
        let yrow = y * w;
        let crow = (y >> 1) * cw;
        for x in 0..w {
            let yy = yuv.y[yrow + x] as i32;
            let ci = crow + (x >> 1);
            let cu = yuv.u[ci] as i32 - 128;
            let cv = yuv.v[ci] as i32 - 128;
            let r = yy + ((91881 * cv) >> 16);
            let g = yy - ((22554 * cu + 46802 * cv) >> 16);
            let b = yy + ((116130 * cu) >> 16);
            rgb[oi] = r.clamp(0, 255) as u8;
            rgb[oi + 1] = g.clamp(0, 255) as u8;
            rgb[oi + 2] = b.clamp(0, 255) as u8;
            oi += 3;
        }
    }
    rgb
}

/// 参照ピクチャの動き情報（輝度 4x4 ブロック単位）。B の空間ダイレクトの co-located に使う。
/// `refi` が L0/L1 とも -1 のブロックはイントラ。
#[derive(Clone)]
pub struct Motion {
    blk_w: usize,
    mv: [Vec<[i16; 2]>; 2],
    refi: [Vec<i8>; 2],
}

/// DPB の 1 枚（短期参照フレーム）。
pub struct RefPic {
    pub yuv: DecodedYuv,
    pub poc: i32,
    frame_num: u32,
    motion: Motion,
}

/// 参照リストの 1 要素。`id` は参照ピクチャの識別子（POC）で、デブロックの bS 判定で
/// 「同じ参照ピクチャか」を refIdx ではなくピクチャそのもので比べるのに使う（8.7.2.1）。
#[derive(Clone, Copy)]
pub struct RefEntry<'a> {
    yuv: &'a DecodedYuv,
    id: i32,
    /// PicNum（= FrameNumWrap、8.2.4.1）。参照リストの並べ替えで指す番号。
    pic_num: i32,
    motion: Option<&'a Motion>,
}

/// FrameNumWrap（= フレームの PicNum、8.2.4.1）。現在の frame_num より大きいものは前の周回。
fn pic_num(frame_num: u32, cur_frame_num: u32, max_frame_num: i32) -> i32 {
    if frame_num > cur_frame_num {
        frame_num as i32 - max_frame_num
    } else {
        frame_num as i32
    }
}

/// 参照リストの並べ替え（8.2.4.3.1、短期参照のみ）。`list` は初期リスト（num_active で切ったもの）、
/// `all` は短期参照のすべて。指された PicNum のピクチャを refIdx の位置へ入れ、後ろの重複を除く。
fn modify_ref_list<'a>(
    list: &mut Vec<RefEntry<'a>>,
    mods: &[(u32, u32)],
    all: &[RefEntry<'a>],
    cur_frame_num: u32,
    max_frame_num: i32,
    num_active: usize,
) -> Result<(), &'static str> {
    let cur = cur_frame_num as i32;
    let mut pred = cur;
    for (ref_idx, &(idc, abs_diff_minus1)) in mods.iter().enumerate() {
        let d = abs_diff_minus1 as i32 + 1;
        let mut no_wrap = if idc == 0 { pred - d } else { pred + d };
        if no_wrap < 0 {
            no_wrap += max_frame_num;
        } else if no_wrap >= max_frame_num {
            no_wrap -= max_frame_num;
        }
        pred = no_wrap;
        let target = if no_wrap > cur { no_wrap - max_frame_num } else { no_wrap };
        let pic = *all.iter().find(|e| e.pic_num == target).ok_or("ref_pic_list_modification: no such picture")?;
        if let Some(pos) = list.iter().skip(ref_idx).position(|e| e.pic_num == target) {
            list.remove(ref_idx + pos);
        }
        list.insert(ref_idx.min(list.len()), pic);
        list.truncate(num_active);
    }
    Ok(())
}

/// スライスの種別ごとの初期参照リスト（並べ替え無し、8.2.4.2）。
/// `p` は P の RefPicList0（復号の新しい順）、`b` は B の RefPicList0/1（POC 順）。
struct RefLists<'a> {
    p: Vec<RefEntry<'a>>,
    b: [Vec<RefEntry<'a>>; 2],
    /// 現在のピクチャの POC（暗黙の重み付き双予測の距離計算用）。
    cur_poc: i32,
}

/// 短期参照フレームのスライディングウィンドウ（8.2.5.3）と POC の状態。**復号の新しい順**に持つ。
/// IDR で空にする。長期参照・MMCO は未対応（スライスヘッダの解析で失敗を返す）。
/// 【2026-10-17】B スライス対応で POC と動き情報を持つようにした。B の参照リストは POC の
/// 大小で組み（8.2.4.2.3）、空間ダイレクトは RefPicList1[0] の co-located の動きを見る。
#[derive(Default)]
pub struct RefFrames {
    frames: Vec<RefPic>,
    poc: PocState,
}

impl RefFrames {
    pub fn new() -> Self {
        Self::default()
    }

    /// 現在のピクチャ（POC = `cur_poc`、frame_num = `cur_frame_num`）から見た初期参照リスト。
    fn lists(&self, cur_poc: i32, cur_frame_num: u32, max_frame_num: i32) -> RefLists<'_> {
        fn entry_of(f: &RefPic, cur_frame_num: u32, max_frame_num: i32) -> RefEntry<'_> {
            let pn = pic_num(f.frame_num, cur_frame_num, max_frame_num);
            RefEntry { yuv: &f.yuv, id: f.poc, pic_num: pn, motion: Some(&f.motion) }
        }
        let entry = |f| entry_of(f, cur_frame_num, max_frame_num);
        let p: Vec<RefEntry> = self.frames.iter().map(entry).collect();
        // L0: POC が小さいもの（近い順＝降順）→ 大きいもの（昇順）。L1 はその逆（8.2.4.2.3）。
        let mut before: Vec<&RefPic> = self.frames.iter().filter(|f| f.poc < cur_poc).collect();
        let mut after: Vec<&RefPic> = self.frames.iter().filter(|f| f.poc > cur_poc).collect();
        before.sort_by_key(|f| core::cmp::Reverse(f.poc));
        after.sort_by_key(|f| f.poc);
        let l0: Vec<RefEntry> = before.iter().chain(after.iter()).map(|f| entry(f)).collect();
        let mut l1: Vec<RefEntry> = after.iter().chain(before.iter()).map(|f| entry(f)).collect();
        // L1 が 2 枚以上で L0 と同じ並びなら、L1 の先頭 2 枚を入れ替える。
        if l1.len() > 1 && l1.iter().zip(&l0).all(|(a, b)| a.id == b.id) {
            l1.swap(0, 1);
        }
        RefLists { p, b: [l0, l1], cur_poc }
    }

    /// 1 フレーム（同じピクチャのスライス群）を復号して DPB を更新する。戻り値は (フレーム, POC)。
    /// フレームは**復号順**に返るので、B を含むストリームの表示は POC 順に並べ替えること。
    pub fn decode(
        &mut self,
        sps: &Sps,
        pps: &Pps,
        slices: &[&[u8]],
        is_idr: bool,
        nal_ref_idc: u8,
    ) -> Result<(DecodedYuv, i32), &'static str> {
        let first = slices.first().ok_or("no slices")?;
        let h = parse_slice_header(&mut BitReader::new(first), sps, pps, is_idr, nal_ref_idc)?;
        if is_idr {
            self.frames.clear();
        }
        let poc = self.poc.compute(sps, &h, is_idr, nal_ref_idc);
        let max_frame_num = 1i32 << sps.log2_max_frame_num;
        let (yuv, motion) = {
            let lists = self.lists(poc, h.frame_num, max_frame_num);
            decode_picture_lists(sps, pps, slices, is_idr, nal_ref_idc, &lists)?
        };
        if nal_ref_idc != 0 {
            // 参照ピクチャの記録（8.2.5）。MMCO 1 は PicNum = CurrPicNum - (diff + 1) の短期参照を外す。
            for &diff in &h.mmco_unmark {
                let target = h.frame_num as i32 - (diff as i32 + 1);
                self.frames.retain(|f| pic_num(f.frame_num, h.frame_num, max_frame_num) != target);
            }
            let copy = DecodedYuv {
                width: yuv.width,
                height: yuv.height,
                y: yuv.y.clone(),
                u: yuv.u.clone(),
                v: yuv.v.clone(),
            };
            // スライディングウィンドウ（MMCO の無いとき）。MMCO のときも DPB があふれないよう切る。
            let max = sps.max_num_ref_frames.max(1) as usize;
            if !h.adaptive_marking && self.frames.len() >= max {
                self.frames.truncate(max - 1);
            }
            self.frames.insert(0, RefPic { yuv: copy, poc, frame_num: h.frame_num, motion });
            self.frames.truncate(max);
        }
        Ok((yuv, poc))
    }
}

/// RGB24 のフレーム（`fw`x`fh`）から表示領域（frame_cropping）を切り出す。
/// 領域が不正なら切り出さずに返す。例: 640x360 は 640x368（MB 単位）を復号して下 8 行を落とす。
fn crop_rgb(rgb: Vec<u8>, fw: u32, fh: u32, x: u32, y: u32, w: u32, h: u32) -> (u32, u32, Vec<u8>) {
    if w == 0 || h == 0 || x + w > fw || y + h > fh || (w == fw && h == fh) {
        return (fw, fh, rgb);
    }
    let mut out = Vec::with_capacity((w * h * 3) as usize);
    for row in y..y + h {
        let o = ((row * fw + x) * 3) as usize;
        out.extend_from_slice(&rgb[o..o + (w * 3) as usize]);
    }
    (w, h, out)
}

/// MP4/AVCC 経路用のステートフルなビデオデコーダ。参照フレームを保持して P/B を復号し、
/// B による並べ替えを POC 順に戻して返す。
pub struct VideoDecoder {
    sps: Option<Sps>,
    pps: Option<Pps>,
    length_size: usize,
    refs: RefFrames,
    /// 表示待ちのフレーム（(IDR の通し番号, POC), フレーム）。
    reorder: Vec<((u32, i32), DecodedYuv)>,
    idr_count: u32,
}

impl Default for VideoDecoder {
    fn default() -> Self {
        Self::new()
    }
}

impl VideoDecoder {
    pub fn new() -> Self {
        Self {
            sps: None,
            pps: None,
            length_size: 4,
            refs: RefFrames::new(),
            reorder: Vec::new(),
            idr_count: 0,
        }
    }

    /// avcC から SPS/PPS と NAL 長さフィールドサイズを取り込む。
    pub fn init_avcc(&mut self, avcc: &[u8]) {
        if let Some((ls, sps_list, pps_list)) = parse_avcc(avcc) {
            self.length_size = ls;
            if let Some(p) = sps_list.first() {
                if p.len() > 1 {
                    self.sps = parse_sps(&extract_rbsp(&p[1..])).ok();
                }
            }
            if let Some(p) = pps_list.first() {
                if p.len() > 1 {
                    self.pps = parse_pps(&extract_rbsp(&p[1..])).ok();
                }
            }
        }
    }

    /// AVCC の 1 サンプル（= 1 アクセスユニット）を復号し、RGB フレームを返す。
    pub fn decode_sample_rgb(&mut self, sample: &[u8]) -> Option<(u32, u32, Vec<u8>)> {
        let nals = split_avcc(sample, self.length_size);
        // 1 サンプル = 1 アクセスユニット。中のスライスをまとめて 1 フレームとして組む。
        let mut slices: Vec<&[u8]> = Vec::new();
        let mut is_idr = false;
        let mut ref_idc = 0u8;
        for nu in &nals {
            match nu.unit_type {
                7 => self.sps = parse_sps(&nu.rbsp).ok(),
                8 => self.pps = parse_pps(&nu.rbsp).ok(),
                1 | 5 => {
                    slices.push(&nu.rbsp);
                    is_idr = nu.unit_type == 5;
                    ref_idc = nu.ref_idc;
                }
                _ => {}
            }
        }
        let (s, p) = match (self.sps.clone(), self.pps.clone()) {
            (Some(s), Some(p)) => (s, p),
            _ => return None,
        };
        if slices.is_empty() {
            return None;
        }
        let (frame, poc) = self.refs.decode(&s, &p, &slices, is_idr, ref_idc).ok()?;
        if is_idr {
            self.idr_count = self.idr_count.wrapping_add(1);
        }
        self.reorder.push(((self.idr_count, poc), frame));
        // 並べ替えの深さ: Baseline（B 無し）は 0。それ以外は参照枚数ぶん待つ（VUI の
        // max_num_reorder_frames は未解析なので控えめな上限で代用。表示がその枚数ぶん遅れる）。
        let depth = if s.profile_idc == 66 { 0 } else { s.max_num_ref_frames.clamp(1, 4) as usize };
        if self.reorder.len() <= depth {
            return None;
        }
        let (idx, _) = self.reorder.iter().enumerate().min_by_key(|(_, (k, _))| *k)?;
        let (_, frame) = self.reorder.remove(idx);
        let rgb = yuv_to_rgb(&frame);
        Some(crop_rgb(rgb, frame.width, frame.height, s.crop_x, s.crop_y, s.width, s.height))
    }
}

/// デコーダ状態。YUV 平面に加え、4x4 ブロック単位の近傍情報グリッドを持つ。
struct DecState {
    yuv: DecodedYuv,
    blk_w: usize,             // 輝度 4x4 ブロック数（横）= width/4
    nnz_luma: Vec<u8>,        // 各輝度 4x4 ブロックの total_coeff（nC 計算用）
    mode_luma: Vec<i8>,       // 各輝度 4x4 ブロックの Intra4x4 モード（-1=非I4x4/不可用）
    decoded: Vec<bool>,       // 各輝度 4x4 ブロックが再構成済みか（top-right 可用性用）
    cblk_w: usize,            // クロマ 4x4 ブロック数（横）= (width/2)/4
    nnz_chroma: [Vec<u8>; 2], // Cb/Cr の各クロマ 4x4 ブロックの total_coeff
    mb_w: usize,              // MB 数（横）
    mb_qp: Vec<i32>,          // 各 MB の QPy（デブロッキング用）
    mv: [Vec<[i16; 2]>; 2],   // 各輝度 4x4 ブロックの動きベクトル（1/4 画素単位）[L0, L1]
    is_inter: Vec<bool>,      // 各輝度 4x4 ブロックがインター予測か（MV 予測・デブロック用）
    blk_h: usize,             // 輝度 4x4 ブロック数（縦）
    refi: [Vec<i8>; 2],       // 各輝度 4x4 ブロックの refIdxL0/L1（-1 = そのリストを使わない/イントラ）
    refp: [Vec<i32>; 2],      // 各輝度 4x4 ブロックの参照ピクチャ識別子（POC。デブロックの bS 判定用）
    num_ref: [u32; 2],        // このスライスの num_ref_idx_l0/l1_active
    mb_slice: Vec<u32>,       // 各 MB の所属スライス番号（0 = 未復号）。可用性の判定に使う
    cur_slice: u32,           // 復号中のスライス番号（1 始まり）
    mb_db: Vec<MbDeblock>,    // 各 MB のデブロック設定（所属スライスのヘッダ値）
    mb_t8: Vec<bool>,         // 各 MB が 8x8 変換か（transform_size_8x8_flag）
    wp: WpMode,               // このスライスの重み付き予測
    cur_poc: i32,             // 現在のピクチャの POC
}

/// 重み付き予測のモード（8.4.2.3）。
enum WpMode {
    /// 既定（単方向はそのまま、双予測は平均）。
    Off,
    /// 明示（スライスヘッダの pred_weight_table）。
    Explicit(PredWeightTable),
    /// 暗黙（B の weighted_bipred_idc = 2。双予測だけ POC の距離で重み付け）。
    Implicit,
}

/// 近傍 2 ブロックの nnz から nC を求める（-1 は不可用）。
fn combine_nc(na: i32, nb: i32) -> i32 {
    if na >= 0 && nb >= 0 {
        (na + nb + 1) >> 1
    } else if na >= 0 {
        na
    } else if nb >= 0 {
        nb
    } else {
        0
    }
}

impl DecState {
    fn li(&self, bx4: usize, by4: usize) -> usize {
        by4 * self.blk_w + bx4
    }

    /// 4x4 ブロック `li` を含む変換ブロックに 0 でない係数があるか（デブロックの bS = 2）。
    /// 8x8 変換の MB では 8x8 単位で見る（8.7.2.1）。
    fn has_coeffs(&self, li: usize) -> bool {
        let (bx, by) = (li % self.blk_w, li / self.blk_w);
        if self.mb_t8[(by / 4) * self.mb_w + bx / 4] {
            let (x0, y0) = (bx & !1, by & !1);
            [(0, 0), (1, 0), (0, 1), (1, 1)].iter().any(|&(dx, dy)| self.nnz_luma[self.li(x0 + dx, y0 + dy)] > 0)
        } else {
            self.nnz_luma[li] > 0
        }
    }

    /// 輝度画素 (x, y) を含む MB が画面内にあり、復号中のスライスに属するか（6.4 の可用性）。
    /// 【2026-10-17】複数スライス対応。従来は画面内かどうかだけで判定しており、前のスライスの
    /// MB まで予測（イントラ・MV・nC）に使っていた。
    fn avail_px(&self, x: isize, y: isize) -> bool {
        if x < 0 || y < 0 || x >= self.yuv.width as isize || y >= self.yuv.height as isize {
            return false;
        }
        let mb = (y as usize / 16) * self.mb_w + x as usize / 16;
        self.mb_slice.get(mb).is_some_and(|&s| s == self.cur_slice)
    }

    /// 輝度 4x4 ブロック (bx4,by4) が可用か（所属 MB が同じスライス）。
    fn avail_blk(&self, bx4: isize, by4: isize) -> bool {
        self.avail_px(bx4 * 4, by4 * 4)
    }

    /// 輝度 4x4 ブロック (bx4,by4) の nC（左/上ブロックの nnz から）。
    fn luma_nc(&self, bx4: usize, by4: usize) -> i32 {
        let na = if self.avail_blk(bx4 as isize - 1, by4 as isize) {
            self.nnz_luma[self.li(bx4 - 1, by4)] as i32
        } else {
            -1
        };
        let nb = if self.avail_blk(bx4 as isize, by4 as isize - 1) {
            self.nnz_luma[self.li(bx4, by4 - 1)] as i32
        } else {
            -1
        };
        combine_nc(na, nb)
    }

    /// Intra4x4 予測モードの予測値（左/上ブロックのモードの min）。
    fn pred_i4x4_mode(&self, bx4: usize, by4: usize) -> i32 {
        if !self.avail_blk(bx4 as isize - 1, by4 as isize) || !self.avail_blk(bx4 as isize, by4 as isize - 1) {
            return 2;
        } // どちらか不可用 -> DC
        let ma = self.mode_luma[self.li(bx4 - 1, by4)];
        let mb = self.mode_luma[self.li(bx4, by4 - 1)];
        let ma = if ma >= 0 { ma as i32 } else { 2 };
        let mb = if mb >= 0 { mb as i32 } else { 2 };
        ma.min(mb)
    }

    /// 輝度 4x4 ブロックの近傍サンプルを収集し intra_4x4_predict で予測を返す。
    /// px,py はフレーム画素座標（ブロック左上）。
    fn predict_luma_4x4(&self, px: usize, py: usize, mode: u8) -> [i32; 16] {
        let w = self.yuv.width as usize;
        let top_avail = self.avail_px(px as isize, py as isize - 1);
        let left_avail = self.avail_px(px as isize - 1, py as isize);
        let bx4 = px / 4;
        let by4 = py / 4;
        let mut top = [0i32; 8];
        let mut left = [0i32; 4];
        let mut corner = 0i32;
        if top_avail {
            for x in 0..4 {
                top[x] = self.yuv.y[(py - 1) * w + px + x] as i32;
            }
            // top-right: 右上 4x4 ブロックが再構成済みかつフレーム内なら使用、無ければ top[3] を複製
            let tr_ok = by4 > 0
                && bx4 + 1 < self.blk_w
                && self.decoded[self.li(bx4 + 1, by4 - 1)]
                && self.avail_blk(bx4 as isize + 1, by4 as isize - 1);
            if tr_ok {
                for x in 0..4 {
                    top[4 + x] = self.yuv.y[(py - 1) * w + px + 4 + x] as i32;
                }
            } else {
                for x in 0..4 {
                    top[4 + x] = top[3];
                }
            }
        }
        if left_avail {
            for y in 0..4 {
                left[y] = self.yuv.y[(py + y) * w + px - 1] as i32;
            }
        }
        if top_avail && left_avail {
            corner = self.yuv.y[(py - 1) * w + px - 1] as i32;
        }
        intra_4x4_predict(mode, &top, corner, &left, top_avail, left_avail)
    }
}

/// 単一スライス（I または P、IDR/非IDR、4:2:0、CAVLC）をデコードして YUV 平面を返す。
/// reference は P スライスの動き補償に使う直前のフレーム。
pub fn decode_slice(
    sps: &Sps,
    pps: &Pps,
    rbsp: &[u8],
    is_idr: bool,
    reference: Option<&DecodedYuv>,
) -> Result<DecodedYuv, &'static str> {
    let refs: Vec<&DecodedYuv> = reference.into_iter().collect();
    decode_slice_refs(sps, pps, rbsp, is_idr, 1, &refs)
}

/// 1 スライス＝1 フレームのときの簡易版（`decode_picture` に 1 スライスを渡す）。
pub fn decode_slice_refs(
    sps: &Sps,
    pps: &Pps,
    rbsp: &[u8],
    is_idr: bool,
    nal_ref_idc: u8,
    refs: &[&DecodedYuv],
) -> Result<DecodedYuv, &'static str> {
    decode_picture(sps, pps, &[rbsp], is_idr, nal_ref_idc, refs)
}

/// スライスの `first_mb_in_slice`（先頭の ue(v)）。0 なら新しいフレームの始まり。
pub fn slice_first_mb(rbsp: &[u8]) -> u32 {
    BitReader::new(rbsp).read_ue()
}

/// MB ごとのデブロック設定（スライスヘッダの値）。
#[derive(Clone, Copy, Default)]
struct MbDeblock {
    disable_idc: u32,
    alpha_off: i32,
    beta_off: i32,
}

/// 1 フレーム（1 つ以上のスライス）を復号する。`slices` は同じフレームのスライスの RBSP を
/// 並び順に渡す。`refs` は RefPicList0（先頭が refIdx 0）。並べ替え無しの P では短期参照を
/// PicNum の降順＝**新しい順**に並べたもの（8.2.4.2.1）。呼び出し側が DPB を持つ（`RefFrames`）。
/// `nal_ref_idc` が 0 なら dec_ref_pic_marking は無い（7.3.3）。
/// 【2026-10-17】複数スライスに対応。従来は 1 スライス＝1 フレーム前提で、2 枚目以降のスライスが
/// 別フレームとして組まれていた（`first_mb_in_slice` も読み捨て）。
pub fn decode_picture(
    sps: &Sps,
    pps: &Pps,
    slices: &[&[u8]],
    is_idr: bool,
    nal_ref_idc: u8,
    refs: &[&DecodedYuv],
) -> Result<DecodedYuv, &'static str> {
    // 識別子は並び順から作る（POC を持たない呼び出し側用。B は `RefFrames::decode` を使う）。
    let p: Vec<RefEntry> = refs
        .iter()
        .enumerate()
        .map(|(i, f)| RefEntry { yuv: f, id: -(i as i32) - 1, pic_num: -(i as i32) - 1, motion: None })
        .collect();
    let lists = RefLists { b: [p.clone(), Vec::new()], p, cur_poc: 0 };
    Ok(decode_picture_lists(sps, pps, slices, is_idr, nal_ref_idc, &lists)?.0)
}

/// `decode_picture` の本体。復号したフレームと、その動き情報（次の B の co-located 用）を返す。
fn decode_picture_lists(
    sps: &Sps,
    pps: &Pps,
    slices: &[&[u8]],
    is_idr: bool,
    nal_ref_idc: u8,
    lists: &RefLists,
) -> Result<(DecodedYuv, Motion), &'static str> {
    // 不正/巨大 SPS による OOM・範囲外を防ぐ寸法サニティ（1080p=120x68 MB なので 300 で十分）。
    if sps.width_mbs == 0 || sps.height_mbs == 0 || sps.width_mbs > 300 || sps.height_mbs > 300 {
        return Err("invalid frame dimensions");
    }
    let width = sps.width_mbs * 16;
    let height = sps.height_mbs * 16;
    let cw = width / 2;
    let ch = height / 2;
    let yuv = DecodedYuv {
        width,
        height,
        y: alloc::vec![0u8; (width * height) as usize],
        u: alloc::vec![128u8; (cw * ch) as usize],
        v: alloc::vec![128u8; (cw * ch) as usize],
    };
    let blk_w = (width / 4) as usize;
    let blk_h = (height / 4) as usize;
    let cblk_w = (cw / 4) as usize;
    let cblk_h = (ch / 4) as usize;
    let mut st = DecState {
        yuv,
        blk_w,
        nnz_luma: alloc::vec![0u8; blk_w * blk_h],
        mode_luma: alloc::vec![-1i8; blk_w * blk_h],
        decoded: alloc::vec![false; blk_w * blk_h],
        cblk_w,
        nnz_chroma: [
            alloc::vec![0u8; cblk_w * cblk_h],
            alloc::vec![0u8; cblk_w * cblk_h],
        ],
        mb_w: sps.width_mbs as usize,
        mb_qp: alloc::vec![0i32; (sps.width_mbs * sps.height_mbs) as usize],
        mv: [alloc::vec![[0i16; 2]; blk_w * blk_h], alloc::vec![[0i16; 2]; blk_w * blk_h]],
        is_inter: alloc::vec![false; blk_w * blk_h],
        blk_h,
        refi: [alloc::vec![-1i8; blk_w * blk_h], alloc::vec![-1i8; blk_w * blk_h]],
        refp: [alloc::vec![0i32; blk_w * blk_h], alloc::vec![0i32; blk_w * blk_h]],
        num_ref: [1, 1],
        mb_slice: alloc::vec![0u32; (sps.width_mbs * sps.height_mbs) as usize],
        cur_slice: 0,
        mb_db: alloc::vec![MbDeblock::default(); (sps.width_mbs * sps.height_mbs) as usize],
        mb_t8: alloc::vec![false; (sps.width_mbs * sps.height_mbs) as usize],
        wp: WpMode::Off,
        cur_poc: lists.cur_poc,
    };
    if slices.is_empty() {
        return Err("no slices");
    }
    for (i, rbsp) in slices.iter().enumerate() {
        // スライスごとに番号を振り、隣のスライスの MB は予測に使わない（可用性は `mb_slice`）。
        st.cur_slice = i as u32 + 1;
        st.decoded.fill(false);
        decode_slice_into(&mut st, sps, pps, rbsp, is_idr, nal_ref_idc, lists)?;
    }
    // ---- デブロッキングフィルタ（全スライスを組み終えてから。設定は MB ごと）----
    deblock_frame(
        &mut st,
        sps.width_mbs as usize,
        sps.height_mbs as usize,
        pps.chroma_qp_offsets(),
    );
    let motion = Motion { blk_w: st.blk_w, mv: st.mv, refi: st.refi };
    Ok((st.yuv, motion))
}

/// 1 スライスを `st` へ組み込む（`first_mb_in_slice` から `more_rbsp_data()` が尽きるまで）。
#[allow(clippy::too_many_arguments)]
fn decode_slice_into(
    st: &mut DecState,
    sps: &Sps,
    pps: &Pps,
    rbsp: &[u8],
    is_idr: bool,
    nal_ref_idc: u8,
    lists: &RefLists,
) -> Result<(), &'static str> {
    let width = st.yuv.width;
    let height = st.yuv.height;

    let mut r = BitReader::new(rbsp);

    // ---- スライスヘッダ（`h264_slice::parse_slice_header`）----
    let h = parse_slice_header(&mut r, sps, pps, is_idr, nal_ref_idc)?;
    let first_mb = h.first_mb as usize;
    let is_i = h.kind == SliceKind::I;
    // このスライスの参照リスト: 初期リストを num_ref_idx_active で切り、並べ替えを当てる。
    let max_frame_num = 1i32 << sps.log2_max_frame_num;
    let mut l0: Vec<RefEntry> = if h.kind == SliceKind::B { lists.b[0].clone() } else { lists.p.clone() };
    let mut l1: Vec<RefEntry> = lists.b[1].clone();
    for (list, l) in [&mut l0, &mut l1].into_iter().enumerate() {
        let n = h.num_ref_idx_active[list] as usize;
        l.truncate(n);
        if !h.list_mod[list].is_empty() {
            modify_ref_list(l, &h.list_mod[list], &lists.p, h.frame_num, max_frame_num, n)?;
        }
    }
    let refs: &[RefEntry] = &l0;
    let refs_l1: &[RefEntry] = &l1;
    if h.kind == SliceKind::B {
        if !h.direct_spatial_mv_pred {
            return Err("temporal direct not supported");
        }
        if refs.is_empty() || refs_l1.is_empty() {
            return Err("B slice without reference frames");
        }
        // 空間ダイレクトは RefPicList1[0] の動き情報を見る。
        if refs_l1[0].motion.is_none() {
            return Err("B slice needs co-located motion");
        }
    }
    if h.kind != SliceKind::I {
        // 参照フレームが存在し、解像度が一致していることを検証する（パニック防止）。
        if refs.is_empty() {
            return Err("P slice without reference frame");
        }
        if refs.iter().chain(refs_l1.iter()).any(|f| f.yuv.width != width || f.yuv.height != height) {
            return Err("reference dimension mismatch");
        }
        st.num_ref = h.num_ref_idx_active;
        if h.kind == SliceKind::P && st.num_ref[0] as usize > refs.len() {
            return Err("not enough reference frames");
        }
    }
    st.wp = match (&h.pwt, h.kind) {
        (Some(t), _) => WpMode::Explicit(t.clone()),
        (None, SliceKind::B) if pps.weighted_bipred_idc == 2 => WpMode::Implicit,
        _ => WpMode::Off,
    };
    let slice_qp = h.slice_qp;
    let disable_deblock_idc = h.disable_deblocking_filter_idc;
    let alpha_off = h.slice_alpha_c0_offset;
    let beta_off = h.slice_beta_offset;

    // ---- マクロブロック ----
    let mb_w = sps.width_mbs;
    let mb_h = sps.height_mbs;
    let total_mb = (mb_w * mb_h) as usize;
    if first_mb >= total_mb {
        return Err("first_mb_in_slice out of range");
    }
    let mut qp = slice_qp;
    let db = MbDeblock { disable_idc: disable_deblock_idc, alpha_off, beta_off };
    let slice_id = st.cur_slice;
    // MB の復号を始める前に、所属スライスとデブロック設定を記録する。
    let begin_mb = |st: &mut DecState, mb_idx: usize| {
        if let Some(m) = st.mb_slice.get_mut(mb_idx) {
            *m = slice_id;
        }
        if let Some(m) = st.mb_db.get_mut(mb_idx) {
            *m = db;
        }
    };

    if pps.entropy_coding_mode_flag != 0 {
        // ---- CABAC（9.3）: MB ごとに（mb_skip_flag）→ MB → end_of_slice_flag ----
        let init = if is_i { None } else { Some(h.cabac_init_idc) };
        let engine = CabacEngine::new(rbsp, r.bit_position(), slice_qp, init);
        let mut cr = CabacReader::new(engine, st);
        let ctx = BCtx { l: [refs, refs_l1], direct_8x8: sps.direct_8x8_inference_flag };
        let mut mb_idx = first_mb;
        while mb_idx < total_mb {
            let mb_x = (mb_idx as u32 % mb_w) * 16;
            let mb_y = (mb_idx as u32 / mb_w) * 16;
            begin_mb(st, mb_idx);
            cr.start_mb(mb_idx);
            let res = if !is_i && cr.mb_skip(st, mb_x, mb_y, h.kind) {
                if h.kind == SliceKind::B {
                    cr.mark_direct(mb_x as usize, mb_y as usize, 16, 16);
                    let r = decode_b_direct_mb(st, mb_x, mb_y, &ctx);
                    st.mb_qp[mb_idx] = qp;
                    r
                } else {
                    decode_pskip(st, mb_x, mb_y, qp, refs);
                    Ok(())
                }
            } else {
                match h.kind {
                    SliceKind::I => decode_mb(&mut cr, st, mb_x, mb_y, &mut qp, pps),
                    SliceKind::P => decode_mb_p(&mut cr, st, mb_x, mb_y, &mut qp, pps, refs),
                    SliceKind::B => decode_mb_b(&mut cr, st, mb_x, mb_y, &mut qp, pps, &ctx),
                }
            };
            if let Err(e) = res {
                crate::println!("  H264 CABAC decode stopped at mb {} (of {}): {}", mb_idx, total_mb, e);
                return Err(e);
            }
            mb_idx += 1;
            if cr.e.terminate() == 1 {
                break;
            }
        }
    } else if is_i {
        let mut mb_idx = first_mb;
        while mb_idx < total_mb {
            let mb_x = (mb_idx as u32 % mb_w) * 16;
            let mb_y = (mb_idx as u32 / mb_w) * 16;
            begin_mb(st, mb_idx);
            if let Err(e) = decode_mb(&mut r, st, mb_x, mb_y, &mut qp, pps) {
                crate::println!(
                    "  H264 decode stopped at mb {} (of {}): {}",
                    mb_idx,
                    total_mb,
                    e
                );
                return Err(e);
            }
            mb_idx += 1;
            if !r.more_rbsp_data() {
                break;
            }
        }
    } else if h.kind == SliceKind::B {
        // B スライス: P と同じく mb_skip_run（B_Skip）→ 符号化 MB。
        let ctx = BCtx { l: [refs, refs_l1], direct_8x8: sps.direct_8x8_inference_flag };
        let mut mb_idx = first_mb;
        while mb_idx < total_mb {
            let skip_run = r.read_ue() as usize;
            for _ in 0..skip_run {
                if mb_idx >= total_mb {
                    break;
                }
                let mb_x = (mb_idx as u32 % mb_w) * 16;
                let mb_y = (mb_idx as u32 / mb_w) * 16;
                begin_mb(st, mb_idx);
                decode_b_direct_mb(st, mb_x, mb_y, &ctx)?;
                st.mb_qp[mb_idx] = qp;
                mb_idx += 1;
            }
            if mb_idx >= total_mb || !r.more_rbsp_data() {
                break;
            }
            let mb_x = (mb_idx as u32 % mb_w) * 16;
            let mb_y = (mb_idx as u32 / mb_w) * 16;
            begin_mb(st, mb_idx);
            if let Err(e) = decode_mb_b(&mut r, st, mb_x, mb_y, &mut qp, pps, &ctx) {
                crate::println!("  H264 B decode stopped at mb {} (of {}): {}", mb_idx, total_mb, e);
                return Err(e);
            }
            mb_idx += 1;
            if !r.more_rbsp_data() {
                break;
            }
        }
    } else {
        // P スライス: mb_skip_run で連続スキップ、その後 1 つの符号化 MB。
        // アンラップを安全な ok_or と ? 演算子に置き換え、参照フレーム不足時に早期エラー返却します。
        let mut mb_idx = first_mb;
        while mb_idx < total_mb {
            let skip_run = r.read_ue() as usize;
            for _ in 0..skip_run {
                if mb_idx >= total_mb {
                    break;
                }
                let mb_x = (mb_idx as u32 % mb_w) * 16;
                let mb_y = (mb_idx as u32 / mb_w) * 16;
                begin_mb(st, mb_idx);
                decode_pskip(st, mb_x, mb_y, qp, refs);
                mb_idx += 1;
            }
            // スキップの後にデータが無ければスライス終わり（7.3.4）。
            if mb_idx >= total_mb || !r.more_rbsp_data() {
                break;
            }
            let mb_x = (mb_idx as u32 % mb_w) * 16;
            let mb_y = (mb_idx as u32 / mb_w) * 16;
            begin_mb(st, mb_idx);
            if let Err(e) = decode_mb_p(&mut r, st, mb_x, mb_y, &mut qp, pps, refs) {
                crate::println!(
                    "  H264 P decode stopped at mb {} (of {}): {}",
                    mb_idx,
                    total_mb,
                    e
                );
                return Err(e);
            }
            mb_idx += 1;
            if !r.more_rbsp_data() {
                break;
            }
        }
    }
    Ok(())

}

// ===================== MB 層の構文要素の読み手 =====================
//
// 【2026-10-17】CABAC 対応のため、MB 層の読み取りをトレイトにまとめた。予測・再構成のコードは
// CAVLC（`BitReader`）と CABAC（`CabacReader`）で共通。CABAC は近傍の情報で文脈を選ぶので、
// 各メソッドは `DecState`（可用性・nnz・refIdx）と位置を受け取る。

/// 残差ブロックの種類と位置（CAVLC は nC、CABAC は coded_block_flag の文脈に使う）。
#[derive(Clone, Copy)]
enum ResBlock {
    /// Intra16x16 の輝度 DC（MB 左上の 4x4 位置）。
    LumaDc { bx4: usize, by4: usize },
    /// Intra16x16 の輝度 AC（15 係数）。
    LumaAc { bx4: usize, by4: usize },
    /// 輝度 4x4（16 係数）。
    Luma4x4 { bx4: usize, by4: usize },
    /// クロマ DC（2x2、MB 左上の輝度画素位置）。
    ChromaDc { comp: usize, mb_x: u32, mb_y: u32 },
    /// クロマ AC（15 係数、クロマ 4x4 位置）。
    ChromaAc { comp: usize, cbx4: usize, cby4: usize },
}

/// MB 層の構文要素の読み手。値の番号付けは CAVLC（表 7-11/7-13/7-14/7-17/7-18）に揃える。
#[allow(clippy::too_many_arguments)]
trait MbSyntax {
    fn mb_type(&mut self, st: &DecState, mb_x: u32, mb_y: u32, kind: SliceKind) -> Result<u32, &'static str>;
    fn sub_mb_type(&mut self, kind: SliceKind) -> Result<u32, &'static str>;
    /// prev_intra4x4_pred_mode_flag が 1 なら None、0 なら rem_intra4x4_pred_mode。
    fn intra4x4_rem(&mut self) -> Option<i32>;
    fn intra_chroma_mode(&mut self, st: &DecState, mb_x: u32, mb_y: u32) -> Result<u8, &'static str>;
    fn cbp(&mut self, st: &DecState, mb_x: u32, mb_y: u32, intra: bool) -> Result<u32, &'static str>;
    fn qp_delta(&mut self) -> Result<i32, &'static str>;
    /// パーティション (px, py, pw, ph) の ref_idx_lX。
    fn ref_idx(&mut self, st: &DecState, list: usize, px: usize, py: usize, pw: usize, ph: usize, num_ref: u32) -> Result<i8, &'static str>;
    /// パーティション (px, py, pw, ph) の mvd_lX。
    fn mvd(&mut self, st: &DecState, list: usize, px: usize, py: usize, pw: usize, ph: usize) -> Result<[i16; 2], &'static str>;
    /// 残差 1 ブロック（走査順の係数, 非ゼロ係数の数）。
    fn residual(&mut self, st: &DecState, blk: ResBlock) -> Result<([i32; 16], u8), &'static str>;
    /// I_PCM の 384 バイト（Y 256・Cb 64・Cr 64）。
    fn pcm(&mut self, out: &mut [u8; 384]);
    /// transform_size_8x8_flag。
    fn transform_8x8(&mut self, st: &DecState, mb_x: u32, mb_y: u32) -> bool;
    /// 輝度 8x8 の残差（左上の 4x4 位置）。（8x8 走査順の係数 64 個, 4 つの 4x4 ごとの係数の数）。
    fn residual8x8(&mut self, st: &DecState, bx4: usize, by4: usize) -> Result<([i32; 64], [u8; 4]), &'static str>;
    /// B_Skip / B_Direct の領域を記録する（CABAC の ref_idx の文脈用）。
    fn mark_direct(&mut self, _px: usize, _py: usize, _pw: usize, _ph: usize) {}
}

impl MbSyntax for BitReader<'_> {
    fn mb_type(&mut self, _st: &DecState, _mb_x: u32, _mb_y: u32, _kind: SliceKind) -> Result<u32, &'static str> {
        Ok(self.read_ue())
    }
    fn sub_mb_type(&mut self, _kind: SliceKind) -> Result<u32, &'static str> {
        Ok(self.read_ue())
    }
    fn intra4x4_rem(&mut self) -> Option<i32> {
        if self.read_bit() == 1 {
            None
        } else {
            Some(self.read_bits(3) as i32)
        }
    }
    fn intra_chroma_mode(&mut self, _st: &DecState, _mb_x: u32, _mb_y: u32) -> Result<u8, &'static str> {
        let m = self.read_ue();
        if m > 3 {
            return Err("bad intra_chroma_pred_mode");
        }
        Ok(m as u8)
    }
    fn cbp(&mut self, _st: &DecState, _mb_x: u32, _mb_y: u32, intra: bool) -> Result<u32, &'static str> {
        let codenum = self.read_ue() as usize;
        let map = if intra { &CBP_INTRA_MAP } else { &CBP_INTER_MAP };
        Ok(*map.get(codenum).ok_or("cbp codeNum out of range")? as u32)
    }
    fn qp_delta(&mut self) -> Result<i32, &'static str> {
        Ok(self.read_se())
    }
    fn ref_idx(&mut self, _st: &DecState, _list: usize, _px: usize, _py: usize, _pw: usize, _ph: usize, num_ref: u32) -> Result<i8, &'static str> {
        read_ref_idx(self, num_ref)
    }
    fn mvd(&mut self, _st: &DecState, _list: usize, _px: usize, _py: usize, _pw: usize, _ph: usize) -> Result<[i16; 2], &'static str> {
        Ok([self.read_se() as i16, self.read_se() as i16])
    }
    fn residual(&mut self, st: &DecState, blk: ResBlock) -> Result<([i32; 16], u8), &'static str> {
        Ok(match blk {
            ResBlock::LumaDc { bx4, by4 } => residual_block_cavlc(self, 16, st.luma_nc(bx4, by4), TOTAL_ZEROS_16),
            ResBlock::LumaAc { bx4, by4 } => residual_block_cavlc(self, 15, st.luma_nc(bx4, by4), TOTAL_ZEROS_16),
            ResBlock::Luma4x4 { bx4, by4 } => residual_block_cavlc(self, 16, st.luma_nc(bx4, by4), TOTAL_ZEROS_16),
            ResBlock::ChromaDc { .. } => residual_block_cavlc(self, 4, -1, TOTAL_ZEROS_CHROMA),
            ResBlock::ChromaAc { comp, cbx4, cby4 } => {
                residual_block_cavlc(self, 15, chroma_nc(st, comp, cbx4, cby4), TOTAL_ZEROS_16)
            }
        })
    }
    fn pcm(&mut self, out: &mut [u8; 384]) {
        self.byte_align();
        for o in out.iter_mut() {
            *o = self.read_bits(8) as u8;
        }
    }
    fn transform_8x8(&mut self, _st: &DecState, _mb_x: u32, _mb_y: u32) -> bool {
        self.read_bit() == 1
    }
    /// CAVLC の 8x8 は 4x4 の residual_block を 4 回読み、係数を交互に並べる（7.3.5.3.2:
    /// level8x8[4 * k + i] = level4x4_i[k]）。nC は 4x4 ごとで、同じ 8x8 の先に読んだ 4x4 の
    /// total_coeff も使う。
    fn residual8x8(&mut self, st: &DecState, bx4: usize, by4: usize) -> Result<([i32; 64], [u8; 4]), &'static str> {
        let mut coeff = [0i32; 64];
        let mut cnt = [0u8; 4];
        for i in 0..4 {
            let (x, y) = ((bx4 + i % 2) as isize, (by4 + i / 2) as isize);
            let nnz_at = |xx: isize, yy: isize, cnt: &[u8; 4]| -> i32 {
                if xx >= bx4 as isize && yy >= by4 as isize {
                    cnt[(yy as usize - by4) * 2 + (xx as usize - bx4)] as i32
                } else if st.avail_blk(xx, yy) {
                    st.nnz_luma[st.li(xx as usize, yy as usize)] as i32
                } else {
                    -1
                }
            };
            let nc = combine_nc(nnz_at(x - 1, y, &cnt), nnz_at(x, y - 1, &cnt));
            let (scan, tc) = residual_block_cavlc(self, 16, nc, TOTAL_ZEROS_16);
            cnt[i] = tc;
            for k in 0..16 {
                coeff[4 * k + i] = scan[k];
            }
        }
        Ok((coeff, cnt))
    }
}

// MB の種類のフラグ（CABAC の文脈選択用）。
const MBF_INTRA: u8 = 1;
const MBF_I16: u8 = 2;
const MBF_PCM: u8 = 4;
const MBF_DIRECT16: u8 = 8;
const MBF_SKIP: u8 = 16;

/// CABAC の MB 層の読み手（9.3.2 二値化・9.3.3.1.1 文脈選択）。近傍の情報は同じスライスの
/// MB だけを見る（可用性は `DecState::avail_px`）。スライスごとに作り直す。
struct CabacReader<'a> {
    e: CabacEngine<'a>,
    blk_w: usize,
    mb_w: usize,
    cur_mb: usize,
    cur_intra: bool,
    /// MB ごと: MBF_* フラグ・coded_block_pattern・DC の coded_block_flag（bit0 輝度, bit1 Cb, bit2 Cr）・
    /// intra_chroma_pred_mode。
    mb_flags: Vec<u8>,
    mb_cbp: Vec<u8>,
    mb_dc: Vec<u8>,
    mb_cpm: Vec<u8>,
    prev_dqp: i32,
    cur_dqp: i32,
    /// 4x4 ごと: |mvd|（成分ごと、70 で頭打ち）・refIdx > 0 か・ダイレクト予測か。
    mvd: [Vec<[u8; 2]>; 2],
    ref_gt0: [Vec<bool>; 2],
    direct: Vec<bool>,
}

impl<'a> CabacReader<'a> {
    fn new(e: CabacEngine<'a>, st: &DecState) -> Self {
        let n_mb = st.mb_slice.len();
        let n_blk = st.blk_w * st.blk_h;
        Self {
            e,
            blk_w: st.blk_w,
            mb_w: st.mb_w,
            cur_mb: 0,
            cur_intra: false,
            mb_flags: alloc::vec![0; n_mb],
            mb_cbp: alloc::vec![0; n_mb],
            mb_dc: alloc::vec![0; n_mb],
            mb_cpm: alloc::vec![0; n_mb],
            prev_dqp: 0,
            cur_dqp: 0,
            mvd: [alloc::vec![[0; 2]; n_blk], alloc::vec![[0; 2]; n_blk]],
            ref_gt0: [alloc::vec![false; n_blk], alloc::vec![false; n_blk]],
            direct: alloc::vec![false; n_blk],
        }
    }

    /// MB の復号を始める（mb_qp_delta の文脈は直前の MB の値）。
    fn start_mb(&mut self, mb_idx: usize) {
        self.cur_mb = mb_idx;
        self.prev_dqp = self.cur_dqp;
        self.cur_dqp = 0;
        self.cur_intra = false;
    }

    /// 左（A）・上（B）の MB 番号（同じスライスで可用なときだけ）。
    fn nb_mbs(&self, st: &DecState, mb_x: u32, mb_y: u32) -> (Option<usize>, Option<usize>) {
        let a = st.avail_px(mb_x as isize - 1, mb_y as isize).then(|| self.cur_mb - 1);
        let b = st.avail_px(mb_x as isize, mb_y as isize - 1).then(|| self.cur_mb - self.mb_w);
        (a, b)
    }

    /// mb_skip_flag（P: ctxIdx 11..13、B: 24..26）。真なら P_Skip / B_Skip として記録する。
    fn mb_skip(&mut self, st: &DecState, mb_x: u32, mb_y: u32, kind: SliceKind) -> bool {
        let (a, b) = self.nb_mbs(st, mb_x, mb_y);
        let cond = |m: Option<usize>| m.is_some_and(|m| self.mb_flags[m] & MBF_SKIP == 0) as usize;
        let base = if kind == SliceKind::B { 24 } else { 11 };
        let skip = self.e.decision(base + cond(a) + cond(b)) == 1;
        if skip {
            self.mb_flags[self.cur_mb] = MBF_SKIP | if kind == SliceKind::B { MBF_DIRECT16 } else { 0 };
            self.mb_cbp[self.cur_mb] = 0;
        }
        skip
    }

    /// イントラの mb_type（表 9-36）。`base` は I スライスで 3、P で 17、B で 32。
    fn intra_mb_type(&mut self, base: usize, intra_slice: bool, inc: usize) -> u32 {
        let mut b = base;
        if intra_slice {
            if self.e.decision(base + inc) == 0 {
                return 0;
            }
            b += 2;
        } else if self.e.decision(base) == 0 {
            return 0;
        }
        if self.e.terminate() == 1 {
            return 25;
        }
        let is = intra_slice as usize;
        let mut t = 1 + 12 * self.e.decision(b + 1);
        if self.e.decision(b + 2) == 1 {
            t += 4 + 4 * self.e.decision(b + 2 + is);
        }
        t += 2 * self.e.decision(b + 3 + is);
        t += self.e.decision(b + 3 + 2 * is);
        t
    }

    /// 1 つの mvd 成分（UEG3、uCoff = 9、符号付き）。`base` は x で 40、y で 47。
    fn mvd_comp(&mut self, base: usize, amvd: u32) -> Result<(i16, u8), &'static str> {
        let inc = if amvd < 3 { 0 } else if amvd > 32 { 2 } else { 1 };
        if self.e.decision(base + inc) == 0 {
            return Ok((0, 0));
        }
        let mut mvd: u32 = 1;
        let mut ctx = base + 3;
        while mvd < 9 && self.e.decision(ctx) == 1 {
            if mvd < 4 {
                ctx += 1;
            }
            mvd += 1;
        }
        if mvd >= 9 {
            let mut k = 3;
            while self.e.bypass() == 1 {
                mvd += 1 << k;
                k += 1;
                if k > 24 {
                    return Err("mvd overflow");
                }
            }
            while k > 0 {
                k -= 1;
                mvd += self.e.bypass() << k;
            }
        }
        let abs = mvd.min(70) as u8;
        let v = mvd.min(i16::MAX as u32) as i16;
        Ok((if self.e.bypass() == 1 { -v } else { v }, abs))
    }

    /// 4x4 ブロック (bx4, by4) が同じスライスで可用か。
    fn blk_ok(st: &DecState, bx4: isize, by4: isize) -> bool {
        bx4 >= 0 && by4 >= 0 && st.avail_blk(bx4, by4)
    }
}

impl MbSyntax for CabacReader<'_> {
    fn mb_type(&mut self, st: &DecState, mb_x: u32, mb_y: u32, kind: SliceKind) -> Result<u32, &'static str> {
        let (a, b) = self.nb_mbs(st, mb_x, mb_y);
        let t = match kind {
            SliceKind::I => {
                let c = |m: Option<usize>| m.is_some_and(|m| self.mb_flags[m] & (MBF_I16 | MBF_PCM) != 0) as usize;
                let inc = c(a) + c(b);
                self.intra_mb_type(3, true, inc)
            }
            SliceKind::P => {
                if self.e.decision(14) == 0 {
                    if self.e.decision(15) == 0 {
                        3 * self.e.decision(16)
                    } else {
                        2 - self.e.decision(17)
                    }
                } else {
                    5 + self.intra_mb_type(17, false, 0)
                }
            }
            SliceKind::B => {
                let c = |m: Option<usize>| m.is_some_and(|m| self.mb_flags[m] & MBF_DIRECT16 == 0) as usize;
                let inc = c(a) + c(b);
                if self.e.decision(27 + inc) == 0 {
                    0
                } else if self.e.decision(27 + 3) == 0 {
                    1 + self.e.decision(27 + 5)
                } else {
                    let mut bits = self.e.decision(27 + 4) << 3;
                    bits |= self.e.decision(27 + 5) << 2;
                    bits |= self.e.decision(27 + 5) << 1;
                    bits |= self.e.decision(27 + 5);
                    match bits {
                        0..=7 => bits + 3,
                        13 => 23 + self.intra_mb_type(32, false, 0),
                        14 => 11,
                        15 => 22,
                        _ => ((bits << 1) | self.e.decision(27 + 5)) - 4,
                    }
                }
            }
        };
        // 記録（イントラの種類・I16x16 の cbp・B_Direct_16x16）。
        let it = match kind {
            SliceKind::I => Some(t),
            SliceKind::P => t.checked_sub(5),
            SliceKind::B => t.checked_sub(23),
        };
        let m = self.cur_mb;
        self.mb_flags[m] = 0;
        if let Some(it) = it {
            self.cur_intra = true;
            self.mb_flags[m] = MBF_INTRA;
            if it == 25 {
                self.mb_flags[m] |= MBF_PCM;
                self.mb_cbp[m] = 0x2f;
                self.mb_dc[m] = 7;
            } else if it >= 1 {
                self.mb_flags[m] |= MBF_I16;
                let m1 = it - 1;
                self.mb_cbp[m] = ((if m1 >= 12 { 15 } else { 0 }) | (((m1 / 4) % 3) << 4)) as u8;
            }
        } else if kind == SliceKind::B && t == 0 {
            self.mb_flags[m] = MBF_DIRECT16;
        }
        Ok(t)
    }

    fn sub_mb_type(&mut self, kind: SliceKind) -> Result<u32, &'static str> {
        let e = &mut self.e;
        Ok(if kind == SliceKind::B {
            if e.decision(36) == 0 {
                0
            } else if e.decision(37) == 0 {
                1 + e.decision(39)
            } else {
                let mut t = 3;
                if e.decision(38) == 1 {
                    if e.decision(39) == 1 {
                        return Ok(11 + e.decision(39));
                    }
                    t += 4;
                }
                t += 2 * e.decision(39);
                t + e.decision(39)
            }
        } else if e.decision(21) == 1 {
            0
        } else if e.decision(22) == 0 {
            1
        } else if e.decision(23) == 1 {
            2
        } else {
            3
        })
    }

    fn intra4x4_rem(&mut self) -> Option<i32> {
        if self.e.decision(68) == 1 {
            return None;
        }
        let b0 = self.e.decision(69);
        let b1 = self.e.decision(69);
        let b2 = self.e.decision(69);
        Some((b0 | (b1 << 1) | (b2 << 2)) as i32)
    }

    fn intra_chroma_mode(&mut self, st: &DecState, mb_x: u32, mb_y: u32) -> Result<u8, &'static str> {
        let (a, b) = self.nb_mbs(st, mb_x, mb_y);
        let c = |m: Option<usize>| m.is_some_and(|m| self.mb_cpm[m] != 0) as usize;
        let inc = c(a) + c(b);
        let mode = if self.e.decision(64 + inc) == 0 {
            0
        } else if self.e.decision(67) == 0 {
            1
        } else if self.e.decision(67) == 0 {
            2
        } else {
            3
        };
        self.mb_cpm[self.cur_mb] = mode;
        Ok(mode)
    }

    fn cbp(&mut self, st: &DecState, mb_x: u32, mb_y: u32, _intra: bool) -> Result<u32, &'static str> {
        let (a, b) = self.nb_mbs(st, mb_x, mb_y);
        // 不可用の近傍は輝度ビットが立っている扱い（condTermFlag = 0）、クロマは 0。
        let ca = a.map_or(0x0f, |m| self.mb_cbp[m] as u32);
        let cb = b.map_or(0x0f, |m| self.mb_cbp[m] as u32);
        let nz = |v: u32, bit: u32| (v & bit == 0) as usize;
        let mut cbp = 0u32;
        cbp |= self.e.decision(73 + nz(ca, 2) + 2 * nz(cb, 4));
        cbp |= self.e.decision(73 + nz(cbp, 1) + 2 * nz(cb, 8)) << 1;
        cbp |= self.e.decision(73 + nz(ca, 8) + 2 * nz(cbp, 1)) << 2;
        cbp |= self.e.decision(73 + nz(cbp, 4) + 2 * nz(cbp, 2)) << 3;
        let (cha, chb) = ((ca >> 4) & 3, (cb >> 4) & 3);
        let inc = (cha > 0) as usize + 2 * (chb > 0) as usize;
        if self.e.decision(77 + inc) == 1 {
            let inc2 = 4 + (cha == 2) as usize + 2 * (chb == 2) as usize;
            cbp |= (1 + self.e.decision(77 + inc2)) << 4;
        }
        self.mb_cbp[self.cur_mb] = cbp as u8;
        Ok(cbp)
    }

    fn qp_delta(&mut self) -> Result<i32, &'static str> {
        let mut v = 0i32;
        if self.e.decision(60 + (self.prev_dqp != 0) as usize) == 1 {
            v = 1;
            let mut ctx = 2;
            while self.e.decision(60 + ctx) == 1 {
                ctx = 3;
                v += 1;
                if v > 104 {
                    return Err("bad mb_qp_delta");
                }
            }
            v = if v & 1 == 1 { (v + 1) >> 1 } else { -((v + 1) >> 1) };
        }
        self.cur_dqp = v;
        Ok(v)
    }

    fn ref_idx(&mut self, st: &DecState, list: usize, px: usize, py: usize, pw: usize, ph: usize, num_ref: u32) -> Result<i8, &'static str> {
        if num_ref <= 1 {
            return Ok(0);
        }
        let (bx, by) = ((px / 4) as isize, (py / 4) as isize);
        let cond = |x: isize, y: isize| -> usize {
            if !Self::blk_ok(st, x, y) {
                return 0;
            }
            let li = y as usize * self.blk_w + x as usize;
            (self.ref_gt0[list][li] && !self.direct[li]) as usize
        };
        let mut ctx = cond(bx - 1, by) + 2 * cond(bx, by - 1);
        let mut v = 0u32;
        while self.e.decision(54 + ctx) == 1 {
            v += 1;
            ctx = if ctx < 4 { 4 } else { 5 };
            if v >= 32 {
                return Err("ref_idx overflow");
            }
        }
        if v >= num_ref {
            return Err("ref_idx out of range");
        }
        for y in py / 4..(py + ph) / 4 {
            for x in px / 4..(px + pw) / 4 {
                self.ref_gt0[list][y * self.blk_w + x] = v > 0;
            }
        }
        Ok(v as i8)
    }

    fn mvd(&mut self, st: &DecState, list: usize, px: usize, py: usize, pw: usize, ph: usize) -> Result<[i16; 2], &'static str> {
        let (bx, by) = ((px / 4) as isize, (py / 4) as isize);
        let get = |x: isize, y: isize| -> [u32; 2] {
            if !Self::blk_ok(st, x, y) {
                return [0, 0];
            }
            let m = self.mvd[list][y as usize * self.blk_w + x as usize];
            [m[0] as u32, m[1] as u32]
        };
        let (a, b) = (get(bx - 1, by), get(bx, by - 1));
        let (mx, ax) = self.mvd_comp(40, a[0] + b[0])?;
        let (my, ay) = self.mvd_comp(47, a[1] + b[1])?;
        for y in py / 4..(py + ph) / 4 {
            for x in px / 4..(px + pw) / 4 {
                self.mvd[list][y * self.blk_w + x] = [ax, ay];
            }
        }
        Ok([mx, my])
    }

    fn residual(&mut self, st: &DecState, blk: ResBlock) -> Result<([i32; 16], u8), &'static str> {
        // (cat, 係数の数, coded_block_flag の文脈 inc)
        let intra = self.cur_intra as usize;
        let mb_cond = |rd: &Self, avail: bool, m: usize, bit: u8| -> usize {
            if !avail {
                intra
            } else if rd.mb_flags[m] & MBF_PCM != 0 {
                1
            } else {
                (rd.mb_dc[m] & bit != 0) as usize
            }
        };
        let blk_cond = |avail: bool, nnz: u8| -> usize { if !avail { intra } else { (nnz > 0) as usize } };
        let (cat, max, inc) = match blk {
            ResBlock::LumaDc { bx4, by4 } => {
                let (mx, my) = ((bx4 * 4) as u32, (by4 * 4) as u32);
                let (a, b) = self.nb_mbs(st, mx, my);
                let ia = mb_cond(self, a.is_some(), a.unwrap_or(0), 1);
                let ib = mb_cond(self, b.is_some(), b.unwrap_or(0), 1);
                (0usize, 16usize, ia + 2 * ib)
            }
            ResBlock::LumaAc { bx4, by4 } | ResBlock::Luma4x4 { bx4, by4 } => {
                let (x, y) = (bx4 as isize, by4 as isize);
                let ao = Self::blk_ok(st, x - 1, y);
                let bo = Self::blk_ok(st, x, y - 1);
                let ia = blk_cond(ao, if ao { st.nnz_luma[st.li(bx4 - 1, by4)] } else { 0 });
                let ib = blk_cond(bo, if bo { st.nnz_luma[st.li(bx4, by4 - 1)] } else { 0 });
                if matches!(blk, ResBlock::LumaAc { .. }) {
                    (1, 15, ia + 2 * ib)
                } else {
                    (2, 16, ia + 2 * ib)
                }
            }
            ResBlock::ChromaDc { comp, mb_x, mb_y } => {
                let (a, b) = self.nb_mbs(st, mb_x, mb_y);
                let bit = 2 << comp;
                let ia = mb_cond(self, a.is_some(), a.unwrap_or(0), bit);
                let ib = mb_cond(self, b.is_some(), b.unwrap_or(0), bit);
                (3, 4, ia + 2 * ib)
            }
            ResBlock::ChromaAc { comp, cbx4, cby4 } => {
                let ao = st.avail_px(cbx4 as isize * 8 - 1, cby4 as isize * 8);
                let bo = st.avail_px(cbx4 as isize * 8, cby4 as isize * 8 - 1);
                let ia = blk_cond(ao, if ao { st.nnz_chroma[comp][cby4 * st.cblk_w + cbx4 - 1] } else { 0 });
                let ib = blk_cond(bo, if bo { st.nnz_chroma[comp][(cby4 - 1) * st.cblk_w + cbx4] } else { 0 });
                (4, 15, ia + 2 * ib)
            }
        };
        let mut coeff = [0i32; 16];
        if self.e.decision(85 + cat * 4 + inc) == 0 {
            return Ok((coeff, 0));
        }
        match blk {
            ResBlock::LumaDc { .. } => self.mb_dc[self.cur_mb] |= 1,
            ResBlock::ChromaDc { comp, .. } => self.mb_dc[self.cur_mb] |= 2 << comp,
            _ => {}
        }
        // 有意係数マップ（9.3.3.1.3）。
        const SIG_OFF: [usize; 5] = [0, 15, 29, 44, 47];
        const ABS_OFF: [usize; 5] = [0, 10, 20, 30, 39];
        let sig = 105 + SIG_OFF[cat];
        let last = 166 + SIG_OFF[cat];
        let mut pos = [0usize; 16];
        let mut n = 0usize;
        let mut ended = false;
        for i in 0..max - 1 {
            let inc = if cat == 3 { i.min(2) } else { i };
            if self.e.decision(sig + inc) == 1 {
                pos[n] = i;
                n += 1;
                if self.e.decision(last + inc) == 1 {
                    ended = true;
                    break;
                }
            }
        }
        if !ended {
            pos[n] = max - 1;
            n += 1;
        }
        // 係数の大きさ（逆順、UEG0・uCoff = 14）と符号。
        let abs_base = 227 + ABS_OFF[cat];
        let (mut eq1, mut gt1) = (0usize, 0usize);
        for k in (0..n).rev() {
            let inc0 = if gt1 != 0 { 0 } else { (1 + eq1).min(4) };
            let mut abs: u32 = 1;
            if self.e.decision(abs_base + inc0) == 1 {
                let inc = 5 + gt1.min(4 - (cat == 3) as usize);
                abs = 2;
                while abs < 15 && self.e.decision(abs_base + inc) == 1 {
                    abs += 1;
                }
                if abs >= 15 {
                    let mut j = 0;
                    while self.e.bypass() == 1 && j < 23 {
                        j += 1;
                    }
                    let mut v: u32 = 1;
                    for _ in 0..j {
                        v = 2 * v + self.e.bypass();
                    }
                    abs = v + 14;
                }
            }
            if abs == 1 {
                eq1 += 1;
            } else {
                gt1 += 1;
            }
            let v = abs.min(i32::MAX as u32) as i32;
            coeff[pos[k]] = if self.e.bypass() == 1 { -v } else { v };
        }
        Ok((coeff, n as u8))
    }

    fn pcm(&mut self, out: &mut [u8; 384]) {
        self.e.read_pcm(out);
    }

    fn transform_8x8(&mut self, st: &DecState, mb_x: u32, mb_y: u32) -> bool {
        let (a, b) = self.nb_mbs(st, mb_x, mb_y);
        let c = |m: Option<usize>| m.is_some_and(|m| st.mb_t8[m]) as usize;
        self.e.decision(399 + c(a) + c(b)) == 1
    }

    /// 輝度 8x8（cat 5）。4:2:0 では coded_block_flag は無く常に 1（7.4.5.3.3）。
    fn residual8x8(&mut self, _st: &DecState, _bx4: usize, _by4: usize) -> Result<([i32; 64], [u8; 4]), &'static str> {
        let mut coeff = [0i32; 64];
        let mut pos = [0usize; 64];
        let mut n = 0usize;
        let mut ended = false;
        for i in 0..63 {
            if self.e.decision(402 + SIG_CTX_8X8_FRAME[i] as usize) == 1 {
                pos[n] = i;
                n += 1;
                if self.e.decision(417 + LAST_CTX_8X8[i] as usize) == 1 {
                    ended = true;
                    break;
                }
            }
        }
        if !ended {
            pos[n] = 63;
            n += 1;
        }
        let (mut eq1, mut gt1) = (0usize, 0usize);
        for k in (0..n).rev() {
            let inc0 = if gt1 != 0 { 0 } else { (1 + eq1).min(4) };
            let mut abs: u32 = 1;
            if self.e.decision(426 + inc0) == 1 {
                let inc = 5 + gt1.min(4);
                abs = 2;
                while abs < 15 && self.e.decision(426 + inc) == 1 {
                    abs += 1;
                }
                if abs >= 15 {
                    let mut j = 0;
                    while self.e.bypass() == 1 && j < 23 {
                        j += 1;
                    }
                    let mut v: u32 = 1;
                    for _ in 0..j {
                        v = 2 * v + self.e.bypass();
                    }
                    abs = v + 14;
                }
            }
            if abs == 1 {
                eq1 += 1;
            } else {
                gt1 += 1;
            }
            let v = abs.min(i32::MAX as u32) as i32;
            coeff[pos[k]] = if self.e.bypass() == 1 { -v } else { v };
        }
        Ok((coeff, [n as u8; 4]))
    }

    fn mark_direct(&mut self, px: usize, py: usize, pw: usize, ph: usize) {
        for y in py / 4..(py + ph) / 4 {
            for x in px / 4..(px + pw) / 4 {
                self.direct[y * self.blk_w + x] = true;
            }
        }
    }
}

#[allow(clippy::too_many_arguments)]
fn decode_mb<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
) -> Result<(), &'static str> {
    let mb_type = r.mb_type(st, mb_x, mb_y, SliceKind::I)?;
    if mb_type == 25 {
        return decode_mb_ipcm(r, st, mb_x, mb_y);
    }
    if mb_type == 0 {
        decode_mb_i4x4(r, st, mb_x, mb_y, qp, pps)
    } else if (1..=24).contains(&mb_type) {
        decode_mb_i16x16(r, st, mb_x, mb_y, qp, mb_type, pps)
    } else {
        Err("unsupported mb_type (non-I)")
    }
}

/// I_PCM マクロブロック: 生の画素値をそのまま格納（予測・変換なし）。
fn decode_mb_ipcm<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
) -> Result<(), &'static str> {
    let mut buf = [0u8; 384];
    r.pcm(&mut buf);
    let w = st.yuv.width as usize;
    let cw = (st.yuv.width / 2) as usize;
    let (mx, my) = (mb_x as usize, mb_y as usize);
    for by in 0..16 {
        for bx in 0..16 {
            st.yuv.y[(my + by) * w + mx + bx] = buf[by * 16 + bx];
        }
    }
    let (cmx, cmy) = (mx / 2, my / 2);
    for by in 0..8 {
        for bx in 0..8 {
            st.yuv.u[(cmy + by) * cw + cmx + bx] = buf[256 + by * 8 + bx];
            st.yuv.v[(cmy + by) * cw + cmx + bx] = buf[320 + by * 8 + bx];
        }
    }
    // 近傍情報: I_PCM ブロックは nC 計算上 totalCoeff=16 扱い、モードは非I4x4(-1)。
    let bx0 = mx / 4;
    let by0 = my / 4;
    for dy in 0..4 {
        for dx in 0..4 {
            let li = st.li(bx0 + dx, by0 + dy);
            st.nnz_luma[li] = 16;
            st.mode_luma[li] = -1;
            st.decoded[li] = true;
        }
    }
    let cbx0 = cmx / 4;
    let cby0 = cmy / 4;
    for comp in 0..2 {
        for dy in 0..2 {
            for dx in 0..2 {
                st.nnz_chroma[comp][(cby0 + dy) * st.cblk_w + cbx0 + dx] = 16;
            }
        }
    }
    // I_PCM の QPy はデブロッキング上 0 とみなす（8.7.2）。
    st.mb_qp[(my / 16) * st.mb_w + (mx / 16)] = 0;
    Ok(())
}

fn median3(a: i16, b: i16, c: i16) -> i16 {
    a + b + c - a.min(b).min(c) - a.max(b).max(c)
}

/// 16x16 パーティションの明示的 MV 予測（8.4.1.3、単一参照 refIdx=0 前提）。
/// 重要: 「利用可能（デコード済み・画面内）」と「一致（インターで refIdx=0）」を区別する。
/// C（右上）の D 代用は C が *利用不可* のときのみ（イントラで利用可能なら代用しない）。
fn mv_predict_16x16(st: &DecState, mb_x: u32, mb_y: u32) -> [i16; 2] {
    let bx0 = (mb_x / 4) as i32;
    let by0 = (mb_y / 4) as i32;
    // (利用可能, 一致, MV)。一致 = インターで refIdx=0。イントラは利用可能だが不一致(mv=0)。
    let getn = |bx: i32, by: i32| -> (bool, bool, [i16; 2]) {
        if bx >= 0 && by >= 0 && (bx as usize) < st.blk_w && (by as usize) < st.blk_h {
            let li = (by as usize) * st.blk_w + bx as usize;
            if st.decoded[li] {
                if st.is_inter[li] {
                    return (true, true, st.mv[0][li]);
                }
                return (true, false, [0, 0]); // イントラ: 利用可能・不一致
            }
        }
        (false, false, [0, 0])
    };
    let (_a_av, a_m, mva) = getn(bx0 - 1, by0); // 左
    let (_b_av, b_m, mvb) = getn(bx0, by0 - 1); // 上
    let (c_av, c_m0, mvc0) = getn(bx0 + 4, by0 - 1); // 右上
    let (mut c_m, mut mvc) = (c_m0, mvc0);
    if !c_av {
        // C が *利用不可* のときのみ D（左上）で代用。
        let (_d_av, d_m, mvd) = getn(bx0 - 1, by0 - 1);
        c_m = d_m;
        mvc = mvd;
    }
    // mbB と mbC が（画面位置として）不可用で mbA 可用なら mvp=mvA。
    let b_mb_avail = mb_y > 0;
    let c_mb_avail = mb_y > 0 && (bx0 + 4 < st.blk_w as i32 || mb_x > 0);
    if !b_mb_avail && !c_mb_avail && mb_x > 0 {
        return mva;
    }
    let matches = a_m as i32 + b_m as i32 + c_m as i32;
    if matches == 1 {
        if a_m {
            return mva;
        }
        if b_m {
            return mvb;
        }
        return mvc;
    }
    [
        median3(mva[0], mvb[0], mvc[0]),
        median3(mva[1], mvb[1], mvc[1]),
    ]
}

/// P_Skip の動きベクトル導出（8.4.1.1）。
fn predict_pskip_mv(st: &DecState, mb_x: u32, mb_y: u32) -> [i16; 2] {
    let bx0 = (mb_x / 4) as usize;
    let by0 = (mb_y / 4) as usize;
    let a_avail = st.avail_px(mb_x as isize - 1, mb_y as isize);
    let b_avail = st.avail_px(mb_x as isize, mb_y as isize - 1);
    if !a_avail || !b_avail {
        return [0, 0];
    }
    let a_li = by0 * st.blk_w + bx0 - 1;
    let b_li = (by0 - 1) * st.blk_w + bx0;
    // 「refIdxLXA が 0 かつ mvLXA が (0,0)」（B も同様）なら 0（8.4.1.1）。refIdx は単一参照で
    // 0 前提だが、**イントラの隣は refIdx = -1** なので該当しない。
    // 【2026-10-17】従来は MV だけを見ており、イントラの隣（MV は 0 と記録）でも 0 にしていた。
    // 実ストリーム（x264 Baseline）で 1 画素ずれ、以降の参照で広がる元になっていた。
    let zero_inter = |li: usize| st.is_inter[li] && st.refi[0][li] == 0 && st.mv[0][li] == [0, 0];
    if zero_inter(a_li) || zero_inter(b_li) {
        return [0, 0];
    }
    let _ = (bx0, by0);
    mv_predict(st, mb_x as usize, mb_y as usize, 16, MvDir::None, 0)
}

/// 6タップ補間のコア（8.4.2.2.1）。get(dx,dy) でサンプル取得（クランプ有無は呼び出し側）。
fn interp_luma_core<F: Fn(isize, isize) -> i32>(get: F, fx: i32, fy: i32) -> i32 {
    let tap =
        |a: i32, b: i32, c: i32, d: i32, e: i32, f: i32| a - 5 * b + 20 * c + 20 * d - 5 * e + f;
    if fx == 0 && fy == 0 {
        return get(0, 0);
    }
    // 水平半画素（行 dy）, 垂直半画素（列 dx）
    let hh = |dy: isize| -> i32 {
        clip1(
            (tap(
                get(-2, dy),
                get(-1, dy),
                get(0, dy),
                get(1, dy),
                get(2, dy),
                get(3, dy),
            ) + 16)
                >> 5,
        )
    };
    let vh = |dx: isize| -> i32 {
        clip1(
            (tap(
                get(dx, -2),
                get(dx, -1),
                get(dx, 0),
                get(dx, 1),
                get(dx, 2),
                get(dx, 3),
            ) + 16)
                >> 5,
        )
    };
    let jj = || -> i32 {
        let vi = |dx: isize| {
            tap(
                get(dx, -2),
                get(dx, -1),
                get(dx, 0),
                get(dx, 1),
                get(dx, 2),
                get(dx, 3),
            )
        };
        clip1((tap(vi(-2), vi(-1), vi(0), vi(1), vi(2), vi(3)) + 512) >> 10)
    };
    match (fx, fy) {
        (1, 0) => (get(0, 0) + hh(0) + 1) >> 1,
        (2, 0) => hh(0),
        (3, 0) => (get(1, 0) + hh(0) + 1) >> 1,
        (0, 1) => (get(0, 0) + vh(0) + 1) >> 1,
        (0, 2) => vh(0),
        (0, 3) => (get(0, 1) + vh(0) + 1) >> 1,
        (2, 2) => jj(),
        (1, 1) => (hh(0) + vh(0) + 1) >> 1,
        (3, 1) => (hh(0) + vh(1) + 1) >> 1,
        (1, 3) => (vh(0) + hh(1) + 1) >> 1,
        (3, 3) => (vh(1) + hh(1) + 1) >> 1,
        (2, 1) => (hh(0) + jj() + 1) >> 1,
        (1, 2) => (vh(0) + jj() + 1) >> 1,
        (3, 2) => (jj() + vh(1) + 1) >> 1,
        (2, 3) => (jj() + hh(1) + 1) >> 1,
        _ => get(0, 0),
    }
}

/// 端のクランプ付きで 1 サンプル補間（フレーム境界をまたぐパーティション用）。
fn interp_luma_sample(refr: &DecodedYuv, x: isize, y: isize, fx: i32, fy: i32) -> i32 {
    let w = refr.width as isize;
    let h = refr.height as isize;
    interp_luma_core(
        |dx, dy| {
            let sx = (x + dx).clamp(0, w - 1);
            let sy = (y + dy).clamp(0, h - 1);
            refr.y[(sy * w + sx) as usize] as i32
        },
        fx,
        fy,
    )
}

/// 輝度パーティション pw×ph @ (px,py) の動き補償（サブ画素対応）。
fn mc_part_luma(
    st: &mut DecState,
    px: usize,
    py: usize,
    pw: usize,
    ph: usize,
    mv: [i16; 2],
    refr: &DecodedYuv,
) {
    let w = st.yuv.width as usize;
    let h = st.yuv.height as usize;
    let fx = (mv[0] & 3) as i32;
    let fy = (mv[1] & 3) as i32;
    let ix = (mv[0] >> 2) as isize;
    let iy = (mv[1] >> 2) as isize;
    // 高速パス: 整数 MV かつフットプリントが完全に範囲内なら行コピー（クランプ・補間不要）。
    if fx == 0 && fy == 0 {
        let sx0 = px as isize + ix;
        let sy0 = py as isize + iy;
        if sx0 >= 0
            && sy0 >= 0
            && sx0 + pw as isize <= w as isize
            && sy0 + ph as isize <= h as isize
        {
            let (sx0, sy0) = (sx0 as usize, sy0 as usize);
            for y in 0..ph {
                let s = (sy0 + y) * w + sx0;
                let d = (py + y) * w + px;
                st.yuv.y[d..d + pw].copy_from_slice(&refr.y[s..s + pw]);
            }
            return;
        }
    }
    // 高速パス: フットプリント + 6タップのハロー(±2/+3)が範囲内ならクランプ無しで補間。
    let wi = w as isize;
    let hi = h as isize;
    let halo_ok = px as isize + ix - 2 >= 0
        && py as isize + iy - 2 >= 0
        && px as isize + ix + pw as isize + 2 < wi
        && py as isize + iy + ph as isize + 2 < hi;
    if halo_ok {
        // separable 高速パス: 中央(j)を使う位置は垂直6タップ中間値を行ごとに 1 回だけ計算し
        // 水平方向で再利用する（per-pixel の 7×6タップ → 約 2×6タップ/画素）。
        let needs_j = matches!((fx, fy), (2, 2) | (2, 1) | (2, 3) | (1, 2) | (3, 2));
        if needs_j {
            let base_x = px as isize + ix;
            let base_y = py as isize + iy;
            let tap = |a: i32, b: i32, c: i32, d: i32, e: i32, f: i32| {
                a - 5 * b + 20 * c + 20 * d - 5 * e + f
            };
            let g = |rx: isize, ry: isize| refr.y[(ry * wi + rx) as usize] as i32;
            let mut vrow = [0i32; 21]; // pw≤16, +5 列分の垂直中間値（未丸め）
            for y in 0..ph {
                let ry = base_y + y as isize;
                for c in 0..pw + 5 {
                    let rx = base_x + c as isize - 2;
                    vrow[c] = tap(
                        g(rx, ry - 2),
                        g(rx, ry - 1),
                        g(rx, ry),
                        g(rx, ry + 1),
                        g(rx, ry + 2),
                        g(rx, ry + 3),
                    );
                }
                for x in 0..pw {
                    let j = clip1(
                        (tap(
                            vrow[x],
                            vrow[x + 1],
                            vrow[x + 2],
                            vrow[x + 3],
                            vrow[x + 4],
                            vrow[x + 5],
                        ) + 512)
                            >> 10,
                    );
                    let rx = base_x + x as isize;
                    let val = match (fx, fy) {
                        (2, 2) => j,
                        (2, 1) => {
                            let b = clip1(
                                (tap(
                                    g(rx - 2, ry),
                                    g(rx - 1, ry),
                                    g(rx, ry),
                                    g(rx + 1, ry),
                                    g(rx + 2, ry),
                                    g(rx + 3, ry),
                                ) + 16)
                                    >> 5,
                            );
                            (b + j + 1) >> 1
                        }
                        (2, 3) => {
                            let s = clip1(
                                (tap(
                                    g(rx - 2, ry + 1),
                                    g(rx - 1, ry + 1),
                                    g(rx, ry + 1),
                                    g(rx + 1, ry + 1),
                                    g(rx + 2, ry + 1),
                                    g(rx + 3, ry + 1),
                                ) + 16)
                                    >> 5,
                            );
                            (j + s + 1) >> 1
                        }
                        (1, 2) => {
                            let hp = clip1(
                                (tap(
                                    g(rx, ry - 2),
                                    g(rx, ry - 1),
                                    g(rx, ry),
                                    g(rx, ry + 1),
                                    g(rx, ry + 2),
                                    g(rx, ry + 3),
                                ) + 16)
                                    >> 5,
                            );
                            (hp + j + 1) >> 1
                        }
                        (3, 2) => {
                            let m = clip1(
                                (tap(
                                    g(rx + 1, ry - 2),
                                    g(rx + 1, ry - 1),
                                    g(rx + 1, ry),
                                    g(rx + 1, ry + 1),
                                    g(rx + 1, ry + 2),
                                    g(rx + 1, ry + 3),
                                ) + 16)
                                    >> 5,
                            );
                            (j + m + 1) >> 1
                        }
                        _ => j,
                    };
                    st.yuv.y[(py + y) * w + px + x] = val as u8;
                }
            }
            return;
        }
        for y in 0..ph {
            for x in 0..pw {
                let bx = px as isize + x as isize + ix;
                let by = py as isize + y as isize + iy;
                let v = interp_luma_core(
                    |dx, dy| refr.y[((by + dy) * wi + bx + dx) as usize] as i32,
                    fx,
                    fy,
                );
                st.yuv.y[(py + y) * w + px + x] = v as u8;
            }
        }
        return;
    }
    // フレーム境界をまたぐ低速パス。needs_j 位置（jj() が絡む）は per-pixel だと
    // 縦6タップ×横6タップ=36タップに膨らむため、halo_ok 分岐と同じ「行ごとに縦の中間値を
    // 1回だけ計算し横方向で使い回す」separable 手法をクランプ付きで適用する。
    let needs_j = matches!((fx, fy), (2, 2) | (2, 1) | (2, 3) | (1, 2) | (3, 2));
    if needs_j {
        let base_x = px as isize + ix;
        let base_y = py as isize + iy;
        let tap =
            |a: i32, b: i32, c: i32, d: i32, e: i32, f: i32| a - 5 * b + 20 * c + 20 * d - 5 * e + f;
        let g = |rx: isize, ry: isize| {
            let cx = rx.clamp(0, wi - 1);
            let cy = ry.clamp(0, hi - 1);
            refr.y[(cy * wi + cx) as usize] as i32
        };
        let mut vrow = [0i32; 21]; // pw≤16, +5 列分の垂直中間値（未丸め）
        for y in 0..ph {
            let ry = base_y + y as isize;
            for c in 0..pw + 5 {
                let rx = base_x + c as isize - 2;
                vrow[c] = tap(
                    g(rx, ry - 2),
                    g(rx, ry - 1),
                    g(rx, ry),
                    g(rx, ry + 1),
                    g(rx, ry + 2),
                    g(rx, ry + 3),
                );
            }
            for x in 0..pw {
                let j = clip1(
                    (tap(
                        vrow[x],
                        vrow[x + 1],
                        vrow[x + 2],
                        vrow[x + 3],
                        vrow[x + 4],
                        vrow[x + 5],
                    ) + 512)
                        >> 10,
                );
                let rx = base_x + x as isize;
                let val = match (fx, fy) {
                    (2, 2) => j,
                    (2, 1) => {
                        let b = clip1(
                            (tap(
                                g(rx - 2, ry),
                                g(rx - 1, ry),
                                g(rx, ry),
                                g(rx + 1, ry),
                                g(rx + 2, ry),
                                g(rx + 3, ry),
                            ) + 16)
                                >> 5,
                        );
                        (b + j + 1) >> 1
                    }
                    (2, 3) => {
                        let s = clip1(
                            (tap(
                                g(rx - 2, ry + 1),
                                g(rx - 1, ry + 1),
                                g(rx, ry + 1),
                                g(rx + 1, ry + 1),
                                g(rx + 2, ry + 1),
                                g(rx + 3, ry + 1),
                            ) + 16)
                                >> 5,
                        );
                        (j + s + 1) >> 1
                    }
                    (1, 2) => {
                        let hp = clip1(
                            (tap(
                                g(rx, ry - 2),
                                g(rx, ry - 1),
                                g(rx, ry),
                                g(rx, ry + 1),
                                g(rx, ry + 2),
                                g(rx, ry + 3),
                            ) + 16)
                                >> 5,
                        );
                        (hp + j + 1) >> 1
                    }
                    (3, 2) => {
                        let m = clip1(
                            (tap(
                                g(rx + 1, ry - 2),
                                g(rx + 1, ry - 1),
                                g(rx + 1, ry),
                                g(rx + 1, ry + 1),
                                g(rx + 1, ry + 2),
                                g(rx + 1, ry + 3),
                            ) + 16)
                                >> 5,
                        );
                        (j + m + 1) >> 1
                    }
                    _ => j,
                };
                st.yuv.y[(py + y) * w + px + x] = val as u8;
            }
        }
        return;
    }
    for y in 0..ph {
        for x in 0..pw {
            let bx = px as isize + x as isize + ix;
            let by = py as isize + y as isize + iy;
            st.yuv.y[(py + y) * w + px + x] = interp_luma_sample(refr, bx, by, fx, fy) as u8;
        }
    }
}

/// クロマのサブ画素補間（8.4.2.2.2、双線形 1/8 画素）。
fn interp_chroma_sample(
    plane: &[u8],
    cw: isize,
    ch: isize,
    x: isize,
    y: isize,
    fx: i32,
    fy: i32,
) -> i32 {
    let get = |dx: isize, dy: isize| -> i32 {
        let sx = (x + dx).clamp(0, cw - 1);
        let sy = (y + dy).clamp(0, ch - 1);
        plane[(sy * cw + sx) as usize] as i32
    };
    let a = get(0, 0);
    let b = get(1, 0);
    let c = get(0, 1);
    let d = get(1, 1);
    ((8 - fx) * (8 - fy) * a + fx * (8 - fy) * b + (8 - fx) * fy * c + fx * fy * d + 32) >> 6
}

/// クロマパーティション（輝度 pw×ph @ (px,py) に対応）の動き補償（サブ画素 1/8）。
fn mc_part_chroma(
    st: &mut DecState,
    px: usize,
    py: usize,
    pw: usize,
    ph: usize,
    mv: [i16; 2],
    refr: &DecodedYuv,
) {
    let cw = (st.yuv.width / 2) as isize;
    let chh = (st.yuv.height / 2) as isize;
    let cx = px / 2;
    let cy = py / 2;
    let cpw = pw / 2;
    let cph = ph / 2;
    let fx = (mv[0] & 7) as i32;
    let fy = (mv[1] & 7) as i32;
    let ix = (mv[0] >> 3) as isize;
    let iy = (mv[1] >> 3) as isize;
    let cwz = cw as usize;
    let integer = fx == 0 && fy == 0;
    let sx0 = cx as isize + ix;
    let sy0 = cy as isize + iy;
    let in_bounds = sx0 >= 0 && sy0 >= 0 && sx0 + cpw as isize <= cw && sy0 + cph as isize <= chh;
    for comp in 0..2 {
        let (dst, src) = if comp == 0 {
            (&mut st.yuv.u, &refr.u)
        } else {
            (&mut st.yuv.v, &refr.v)
        };
        if integer && in_bounds {
            let (sx0, sy0) = (sx0 as usize, sy0 as usize);
            for y in 0..cph {
                let s = (sy0 + y) * cwz + sx0;
                let d = (cy + y) * cwz + cx;
                dst[d..d + cpw].copy_from_slice(&src[s..s + cpw]);
            }
            continue;
        }
        for y in 0..cph {
            for x in 0..cpw {
                let bx = cx as isize + x as isize + ix;
                let by = cy as isize + y as isize + iy;
                dst[(cy + y) * cwz + cx + x] =
                    interp_chroma_sample(src, cw, chh, bx, by, fx, fy) as u8;
            }
        }
    }
}

/// パーティションの MC（輝度 + クロマ）。
fn mc_part(
    st: &mut DecState,
    px: usize,
    py: usize,
    pw: usize,
    ph: usize,
    mv: [i16; 2],
    refr: &DecodedYuv,
) {
    mc_part_luma(st, px, py, pw, ph, mv, refr);
    mc_part_chroma(st, px, py, pw, ph, mv, refr);
}

/// L0 だけのパーティション（P）の MV をグリッドへ格納する。`id` は参照ピクチャの識別子。
#[allow(clippy::too_many_arguments)]
fn store_part_mv(st: &mut DecState, px: usize, py: usize, pw: usize, ph: usize, mv: [i16; 2], ref_idx: i8, id: i32) {
    store_part(st, px, py, pw, ph, [mv, [0, 0]], [ref_idx, -1], [id, 0]);
}

/// パーティションの MV・refIdx（L0/L1）をグリッドへ格納（後続パーティション/MB の予測・
/// デブロック・次のピクチャの co-located 用）。使わないリストは refIdx = -1・MV = 0。
#[allow(clippy::too_many_arguments)]
fn store_part(
    st: &mut DecState,
    px: usize,
    py: usize,
    pw: usize,
    ph: usize,
    mv: [[i16; 2]; 2],
    ref_idx: [i8; 2],
    id: [i32; 2],
) {
    let bx0 = px / 4;
    let by0 = py / 4;
    for dy in 0..ph / 4 {
        for dx in 0..pw / 4 {
            let li = (by0 + dy) * st.blk_w + bx0 + dx;
            for l in 0..2 {
                st.mv[l][li] = mv[l];
                st.refi[l][li] = ref_idx[l];
                st.refp[l][li] = id[l];
            }
            st.is_inter[li] = true;
            st.mode_luma[li] = -1;
            st.nnz_luma[li] = 0;
            st.decoded[li] = true;
        }
    }
}

/// MV 予測の方向ヒント（16x8/8x16 の特例）。
#[derive(Clone, Copy, PartialEq)]
enum MvDir {
    None,
    A,
    B,
    C,
}

/// パーティション (px,py,pw) の近傍 A/B/C を返す: ((一致,mv) x3)。
/// 一致 = インターで refIdx=0。C は利用不可なら D（左上）で代用。
/// 動きベクトル予測の近傍（8.4.1.3.2）。可用か・refIdxL0（イントラ/不可用は -1）・MV。
#[derive(Clone, Copy)]
struct MvNeighbor {
    avail: bool,
    ref_idx: i8,
    mv: [i16; 2],
}

fn part_neighbors(st: &DecState, px: usize, py: usize, pw: usize, list: usize) -> (MvNeighbor, MvNeighbor, MvNeighbor) {
    let bx0 = (px / 4) as i32;
    let by0 = (py / 4) as i32;
    let getn = |bx: i32, by: i32| -> MvNeighbor {
        if bx >= 0 && by >= 0 && (bx as usize) < st.blk_w && (by as usize) < st.blk_h && st.avail_blk(bx as isize, by as isize) {
            let li = (by as usize) * st.blk_w + bx as usize;
            if st.decoded[li] {
                if st.is_inter[li] {
                    // そのリストを使わないブロック（refIdx = -1）の MV は 0 として扱う（8.4.1.3.2）。
                    let ri = st.refi[list][li];
                    let mv = if ri >= 0 { st.mv[list][li] } else { [0, 0] };
                    return MvNeighbor { avail: true, ref_idx: ri, mv };
                }
                return MvNeighbor { avail: true, ref_idx: -1, mv: [0, 0] };
            }
        }
        MvNeighbor { avail: false, ref_idx: -1, mv: [0, 0] }
    };
    let a = getn(bx0 - 1, by0);
    let b = getn(bx0, by0 - 1);
    let mut c = getn(bx0 + (pw / 4) as i32, by0 - 1);
    if !c.avail {
        // C が不可用（画面外・未復号）のときだけ D（左上）で代用。
        c = getn(bx0 - 1, by0 - 1);
    }
    (a, b, c)
}

/// パーティションの MV 予測（8.4.1.3、単一参照 refIdx=0、方向ヒント対応）。
/// `ref_idx` はこのパーティションの refIdxL0。
/// 【2026-10-17】複数参照に対応。従来は「インターの隣＝一致」とみなしており（単一参照前提）、
/// 「B・C が不可用で A 可用なら A」も画面上の位置で近似していた。8.4.1.3 どおり refIdx の一致と
/// 実際の可用性（画面外・未復号）で判定する。
fn mv_predict(st: &DecState, px: usize, py: usize, pw: usize, dir: MvDir, ref_idx: i8) -> [i16; 2] {
    mv_predict_l(st, px, py, pw, dir, ref_idx, 0)
}

/// `mv_predict` のリスト指定版（B の L1 用）。
#[allow(clippy::too_many_arguments)]
fn mv_predict_l(st: &DecState, px: usize, py: usize, pw: usize, dir: MvDir, ref_idx: i8, list: usize) -> [i16; 2] {
    let (a, mut b, mut c) = part_neighbors(st, px, py, pw, list);
    match dir {
        MvDir::A if a.ref_idx == ref_idx => return a.mv,
        MvDir::B if b.ref_idx == ref_idx => return b.mv,
        MvDir::C if c.ref_idx == ref_idx => return c.mv,
        _ => {}
    }
    // 8.4.1.3.1: B と C がともに不可用で A が可用なら、B・C を A で置き換える。
    if !b.avail && !c.avail && a.avail {
        b = a;
        c = a;
    }
    let hits = [a, b, c].iter().filter(|n| n.ref_idx == ref_idx).count();
    if hits == 1 {
        for n in [a, b, c] {
            if n.ref_idx == ref_idx {
                return n.mv;
            }
        }
    }
    [median3(a.mv[0], b.mv[0], c.mv[0]), median3(a.mv[1], b.mv[1], c.mv[1])]
}

/// インター MB（P_Skip 含む）の近傍グリッドを更新。
fn set_mb_inter_grids(st: &mut DecState, mb_x: u32, mb_y: u32, mv: [i16; 2], qp: i32) {
    let bx0 = (mb_x / 4) as usize;
    let by0 = (mb_y / 4) as usize;
    for dy in 0..4 {
        for dx in 0..4 {
            let li = (by0 + dy) * st.blk_w + bx0 + dx;
            st.mv[0][li] = mv;
            st.nnz_luma[li] = 0;
            st.mode_luma[li] = -1;
            st.is_inter[li] = true;
            st.decoded[li] = true;
        }
    }
    let cbx0 = (mb_x / 8) as usize;
    let cby0 = (mb_y / 8) as usize;
    for comp in 0..2 {
        for dy in 0..2 {
            for dx in 0..2 {
                st.nnz_chroma[comp][(cby0 + dy) * st.cblk_w + cbx0 + dx] = 0;
            }
        }
    }
    st.mb_qp[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = qp;
}

/// P_Skip マクロブロックのデコード。
fn decode_pskip(st: &mut DecState, mb_x: u32, mb_y: u32, qp: i32, refs: &[RefEntry]) {
    let mv = predict_pskip_mv(st, mb_x, mb_y);
    let (px, py) = (mb_x as usize, mb_y as usize);
    // P_Skip は refIdxL0 = 0（RefPicList0 の先頭）。
    let id = mc_pred(st, px, py, 16, 16, [mv, [0, 0]], [0, -1], [refs, &[]]).map_or(0, |ids| ids[0]);
    store_part_mv(st, px, py, 16, 16, mv, 0, id);
    st.mb_qp[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = qp;
}

/// インター MB の輝度残差を MC 予測へ加算（4x4 ブロックごと）。
fn add_inter_luma_residual<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    cbp_luma: u32,
    qp: i32,
    t8: bool,
) -> Result<(), &'static str> {
    let w = st.yuv.width as usize;
    let bx0 = (mb_x / 4) as usize;
    if t8 {
        let by0 = (mb_y / 4) as usize;
        for i in 0..4 {
            let (bx4, by4) = (bx0 + (i % 2) * 2, by0 + (i / 2) * 2);
            let mut cnt = [0u8; 4];
            if cbp_luma & (1 << i) != 0 {
                let (scan, c) = r.residual8x8(st, bx4, by4)?;
                cnt = c;
                let res = residual_8x8_to_pixels(&scan, qp);
                let (px, py) = (bx4 * 4, by4 * 4);
                for y in 0..8 {
                    for x in 0..8 {
                        let o = (py + y) * w + px + x;
                        st.yuv.y[o] = clip1(st.yuv.y[o] as i32 + res[y * 8 + x]) as u8;
                    }
                }
            }
            for (k, (dx, dy)) in [(0, 0), (1, 0), (0, 1), (1, 1)].into_iter().enumerate() {
                let li = st.li(bx4 + dx, by4 + dy);
                st.nnz_luma[li] = cnt[k];
            }
        }
        return Ok(());
    }
    let by0 = (mb_y / 4) as usize;
    for blk in 0..16 {
        let (bx, by) = LUMA_4X4_BLOCK_XY[blk];
        let bx4 = bx0 + bx / 4;
        let by4 = by0 + by / 4;
        let li = by4 * st.blk_w + bx4;
        if cbp_luma & (1 << (blk / 4)) != 0 {
            let (scan, tc) = r.residual(st, ResBlock::Luma4x4 { bx4, by4 })?;
            st.nnz_luma[li] = tc;
            let mut block = [0i32; 16];
            for k in 0..16 {
                block[ZIGZAG_4X4[k]] = scan[k];
            }
            dequant_4x4(&mut block, qp);
            inverse_transform_4x4(&mut block);
            for yy in 0..4 {
                for xx in 0..4 {
                    let px = mb_x as usize + bx + xx;
                    let py = mb_y as usize + by + yy;
                    let cur = st.yuv.y[py * w + px] as i32;
                    st.yuv.y[py * w + px] = clip1(cur + block[yy * 4 + xx]) as u8;
                }
            }
        } else {
            st.nnz_luma[li] = 0;
        }
    }
    Ok(())
}

/// インター MB のクロマ残差を MC 予測へ加算（DC 2x2 Hadamard + AC）。
fn add_inter_chroma_residual<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    cbp_chroma: u32,
    qp_y: i32,
    chroma_qp_off: [i32; 2],
) -> Result<(), &'static str> {
    let cw = (st.yuv.width / 2) as usize;
    let cmb_x = (mb_x / 2) as usize;
    let cmb_y = (mb_y / 2) as usize;
    let cbx0 = cmb_x / 4;
    let cby0 = cmb_y / 4;
    let qpcs = [chroma_qp(qp_y, chroma_qp_off[0]), chroma_qp(qp_y, chroma_qp_off[1])];
    let mut dc = [[0i32; 4]; 2];
    if cbp_chroma != 0 {
        for comp in 0..2 {
            let (scan, _) = r.residual(st, ResBlock::ChromaDc { comp, mb_x, mb_y })?;
            let f = inverse_hadamard_2x2([scan[0], scan[1], scan[2], scan[3]]);
            for i in 0..4 {
                dc[comp][i] = scale_chroma_dc(f[i], qpcs[comp]);
            }
        }
    }
    let mut ac = [[[0i32; 16]; 4]; 2];
    if cbp_chroma == 2 {
        for comp in 0..2 {
            for blk in 0..4 {
                let bx = (blk % 2) * 4;
                let by = (blk / 2) * 4;
                let cbx4 = cbx0 + bx / 4;
                let cby4 = cby0 + by / 4;
                let (scan, tc) = r.residual(st, ResBlock::ChromaAc { comp, cbx4, cby4 })?;
                for k in 0..15 {
                    ac[comp][blk][ZIGZAG_4X4[k + 1]] = scan[k];
                }
                st.nnz_chroma[comp][cby4 * st.cblk_w + cbx4] = tc;
            }
        }
    }
    if cbp_chroma == 0 {
        return Ok(());
    }
    for comp in 0..2 {
        let plane: &mut Vec<u8> = if comp == 0 {
            &mut st.yuv.u
        } else {
            &mut st.yuv.v
        };
        for blk in 0..4 {
            let bx = (blk % 2) * 4;
            let by = (blk / 2) * 4;
            let mut block = ac[comp][blk];
            dequant_4x4(&mut block, qpcs[comp]);
            block[0] = dc[comp][blk];
            inverse_transform_4x4(&mut block);
            for yy in 0..4 {
                for xx in 0..4 {
                    let px = cmb_x + bx + xx;
                    let py = cmb_y + by + yy;
                    let cur = plane[py * cw + px] as i32;
                    plane[py * cw + px] = clip1(cur + block[yy * 4 + xx]) as u8;
                }
            }
        }
    }
    Ok(())
}

/// P スライスの符号化 MB。intra MB（mb_type>=5）は intra デコーダへ委譲。
/// P_8x8 / P_8x8ref0: 4 つの 8x8 サブ MB、各 sub_mb_type でさらに分割。
/// `ref_idx_l0`（te(v)、7.4.5.1）。値域が 0..=1 のときだけ 1 ビットの反転、それ以外は ue(v)。
/// 参照が 1 枚なら読まずに 0。
fn read_ref_idx(r: &mut BitReader, num_ref: u32) -> Result<i8, &'static str> {
    if num_ref <= 1 {
        return Ok(0);
    }
    let v = if num_ref == 2 { 1 - r.read_bit() } else { r.read_ue() };
    if v >= num_ref {
        return Err("ref_idx out of range");
    }
    Ok(v as i8)
}

fn decode_p8x8<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    px: usize,
    py: usize,
    refs: &[RefEntry],
    ref0_only: bool,
) -> Result<bool, &'static str> {
    let mut sub_types = [0u32; 4];
    for s in sub_types.iter_mut() {
        *s = r.sub_mb_type(SliceKind::P)?;
        if *s > 3 {
            return Err("bad sub_mb_type");
        }
    }
    // ref_idx は 4 つの 8x8 ぶんを先に読む（P_8x8ref0 は全部 0）。
    let mut ref_idx = [0i8; 4];
    if !ref0_only {
        for (i, ri) in ref_idx.iter_mut().enumerate() {
            *ri = r.ref_idx(st, 0, px + (i % 2) * 8, py + (i / 2) * 8, 8, 8, st.num_ref[0])?;
        }
    }
    for (i, &stype) in sub_types.iter().enumerate() {
        let ri = ref_idx[i];
        let refr: RefEntry = *refs.get(ri as usize).ok_or("missing reference frame")?;
        let sx = px + (i % 2) * 8;
        let sy = py + (i / 2) * 8;
        let parts: &[(usize, usize, usize, usize)] = match stype {
            0 => &[(0, 0, 8, 8)],
            1 => &[(0, 0, 8, 4), (0, 4, 8, 4)],
            2 => &[(0, 0, 4, 8), (4, 0, 4, 8)],
            _ => &[(0, 0, 4, 4), (4, 0, 4, 4), (0, 4, 4, 4), (4, 4, 4, 4)],
        };
        for &(ox, oy, pw, ph) in parts {
            let ppx = sx + ox;
            let ppy = sy + oy;
            let [mvd_x, mvd_y] = r.mvd(st, 0, ppx, ppy, pw, ph)?;
            let mvp = mv_predict(st, ppx, ppy, pw, MvDir::None, ri);
            let mv = [mvp[0].wrapping_add(mvd_x), mvp[1].wrapping_add(mvd_y)];
            mc_pred(st, ppx, ppy, pw, ph, [mv, [0, 0]], [ri, -1], [refs, &[]])?;
            store_part_mv(st, ppx, ppy, pw, ph, mv, ri, refr.id);
        }
    }
    // 8x8 変換は全サブパーティションが 8x8 のときだけ。
    Ok(sub_types.iter().all(|&t| t == 0))
}

/// インター: mb_type 0=16x16, 1=16x8, 2=8x16, 3/4=P_8x8。
#[allow(clippy::too_many_arguments)]
fn decode_mb_p<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
    refs: &[RefEntry],
) -> Result<(), &'static str> {
    let mb_type = r.mb_type(st, mb_x, mb_y, SliceKind::P)?;
    if mb_type >= 5 {
        let it = mb_type - 5;
        if it == 25 {
            return decode_mb_ipcm(r, st, mb_x, mb_y);
        }
        if it == 0 {
            return decode_mb_i4x4(r, st, mb_x, mb_y, qp, pps);
        }
        if (1..=24).contains(&it) {
            return decode_mb_i16x16(r, st, mb_x, mb_y, qp, it, pps);
        }
        return Err("bad intra mb_type in P slice");
    }
    let px = mb_x as usize;
    let py = mb_y as usize;
    // 1 パーティション分の mvd を読み、MV 予測 + MC + 格納を行う。
    // mb_pred() の並びは「全パーティションの ref_idx_l0 → 全パーティションの mvd_l0」（7.3.5.1）。
    let do_part = |r: &mut R,
                   st: &mut DecState,
                   ppx: usize,
                   ppy: usize,
                   pw: usize,
                   ph: usize,
                   dir: MvDir,
                   ri: i8|
     -> Result<(), &'static str> {
        let refr: RefEntry = *refs.get(ri as usize).ok_or("missing reference frame")?;
        let [mvd_x, mvd_y] = r.mvd(st, 0, ppx, ppy, pw, ph)?;
        let mvp = mv_predict(st, ppx, ppy, pw, dir, ri);
        let mv = [mvp[0].wrapping_add(mvd_x), mvp[1].wrapping_add(mvd_y)];
        mc_pred(st, ppx, ppy, pw, ph, [mv, [0, 0]], [ri, -1], [refs, &[]])?;
        store_part_mv(st, ppx, ppy, pw, ph, mv, ri, refr.id);
        Ok(())
    };
    let mut t8_ok = true;
    match mb_type {
        0 => {
            // P_L0_16x16
            let r0 = r.ref_idx(st, 0, px, py, 16, 16, st.num_ref[0])?;
            do_part(r, st, px, py, 16, 16, MvDir::None, r0)?;
        }
        1 => {
            // P_L0_L0_16x8（上→下）。上=Prefer B, 下=Prefer A。
            let r0 = r.ref_idx(st, 0, px, py, 16, 8, st.num_ref[0])?;
            let r1 = r.ref_idx(st, 0, px, py + 8, 16, 8, st.num_ref[0])?;
            do_part(r, st, px, py, 16, 8, MvDir::B, r0)?;
            do_part(r, st, px, py + 8, 16, 8, MvDir::A, r1)?;
        }
        2 => {
            // P_L0_L0_8x16（左→右）。左=Prefer A, 右=Prefer C。
            let r0 = r.ref_idx(st, 0, px, py, 8, 16, st.num_ref[0])?;
            let r1 = r.ref_idx(st, 0, px + 8, py, 8, 16, st.num_ref[0])?;
            do_part(r, st, px, py, 8, 16, MvDir::A, r0)?;
            do_part(r, st, px + 8, py, 8, 16, MvDir::C, r1)?;
        }
        3 | 4 => {
            // P_8x8 / P_8x8ref0（ref0 は ref_idx を読まず全部 0）
            t8_ok = decode_p8x8(r, st, px, py, refs, mb_type == 4)?;
        }
        _ => return Err("unknown P mb_type"),
    }
    decode_inter_residual(r, st, mb_x, mb_y, qp, pps, t8_ok)
}

/// インター MB（P/B の符号化 MB）の coded_block_pattern・mb_qp_delta・残差。
fn decode_inter_residual<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
    t8_allowed: bool,
) -> Result<(), &'static str> {
    let cbp = r.cbp(st, mb_x, mb_y, false)?;
    let cbp_luma = cbp & 0xf;
    let cbp_chroma = cbp >> 4;
    // transform_size_8x8_flag（7.3.5）: 8x8 未満のパーティションや、8x8 推論の無いダイレクトでは無い。
    let t8 = t8_allowed && cbp_luma != 0 && pps.transform_8x8_mode_flag && r.transform_8x8(st, mb_x, mb_y);
    st.mb_t8[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = t8;
    let cur_qp = if cbp != 0 {
        let d = r.qp_delta()?;
        if !(-26..=25).contains(&d) {
            return Err("mb_qp_delta out of range");
        }
        *qp = (*qp + d + 52) % 52;
        *qp
    } else {
        *qp
    };
    st.mb_qp[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = cur_qp;

    add_inter_luma_residual(r, st, mb_x, mb_y, cbp_luma, cur_qp, t8)?;
    add_inter_chroma_residual(
        r,
        st,
        mb_x,
        mb_y,
        cbp_chroma,
        cur_qp,
        pps.chroma_qp_offsets(),
    )
}

// ===================== B スライス =====================
//
// 【2026-10-17】B スライス（CAVLC、空間ダイレクト、既定の双予測平均）。時間ダイレクト・
// 重み付き予測（明示/暗黙）は未対応で、スライスヘッダの段階で失敗を返す。

/// B の MB が使う参照リストと、空間ダイレクトの co-located の取り方。
struct BCtx<'a> {
    l: [&'a [RefEntry<'a>]; 2],
    direct_8x8: bool,
}

/// パーティションの予測リスト（ビット 0 = L0、ビット 1 = L1、3 = 双予測）。
const PRED_L0: u8 = 1;
const PRED_L1: u8 = 2;
const PRED_BI: u8 = 3;

/// B_x_y_16x8 / 8x16（mb_type 4..=21）の 2 パーティションの予測リスト（表 7-14、2 つずつ同じ組）。
const B_PART_PAIRS: [(u8, u8); 9] = [
    (PRED_L0, PRED_L0),
    (PRED_L1, PRED_L1),
    (PRED_L0, PRED_L1),
    (PRED_L1, PRED_L0),
    (PRED_L0, PRED_BI),
    (PRED_L1, PRED_BI),
    (PRED_BI, PRED_L0),
    (PRED_BI, PRED_L1),
    (PRED_BI, PRED_BI),
];

/// B_8x8 の sub_mb_type（表 7-18）→ (予測リスト, 幅, 高さ)。0 は B_Direct_8x8。
const B_SUB_MB: [(u8, usize, usize); 13] = [
    (0, 8, 8),
    (PRED_L0, 8, 8),
    (PRED_L1, 8, 8),
    (PRED_BI, 8, 8),
    (PRED_L0, 8, 4),
    (PRED_L0, 4, 8),
    (PRED_L1, 8, 4),
    (PRED_L1, 4, 8),
    (PRED_BI, 8, 4),
    (PRED_BI, 4, 8),
    (PRED_L0, 4, 4),
    (PRED_L1, 4, 4),
    (PRED_BI, 4, 4),
];

/// 幅×高さのサブパーティションの左上オフセット（8x8 の中）。
fn sub_part_offsets(w: usize, h: usize) -> &'static [(usize, usize)] {
    match (w, h) {
        (8, 8) => &[(0, 0)],
        (8, 4) => &[(0, 0), (0, 4)],
        (4, 8) => &[(0, 0), (4, 0)],
        _ => &[(0, 0), (4, 0), (0, 4), (4, 4)],
    }
}

/// 予測リストに応じた動き補償（8.4.2）。双予測は L0・L1 の予測の平均 (a + b + 1) >> 1
/// （重み無しの既定、8.4.2.3.1）。戻り値は各リストの参照ピクチャ識別子（使わないリストは 0）。
#[allow(clippy::too_many_arguments)]
fn mc_pred(
    st: &mut DecState,
    px: usize,
    py: usize,
    pw: usize,
    ph: usize,
    mv: [[i16; 2]; 2],
    ref_idx: [i8; 2],
    l: [&[RefEntry]; 2],
) -> Result<[i32; 2], &'static str> {
    let mut ent: [Option<RefEntry>; 2] = [None, None];
    for list in 0..2 {
        if ref_idx[list] >= 0 {
            ent[list] = Some(*l[list].get(ref_idx[list] as usize).ok_or("missing reference frame")?);
        }
    }
    match (ent[0], ent[1]) {
        (Some(a), None) => {
            mc_part(st, px, py, pw, ph, mv[0], a.yuv);
            weight_single(st, px, py, pw, ph, 0, ref_idx[0]);
        }
        (None, Some(b)) => {
            mc_part(st, px, py, pw, ph, mv[1], b.yuv);
            weight_single(st, px, py, pw, ph, 1, ref_idx[1]);
        }
        (Some(a), Some(b)) => {
            let w = st.yuv.width as usize;
            let cw = w / 2;
            let (cx, cy, cpw, cph) = (px / 2, py / 2, pw / 2, ph / 2);
            mc_part(st, px, py, pw, ph, mv[0], a.yuv);
            // L0 の予測を退避（輝度は最大 16x16、クロマは 8x8）。
            let mut sy = [0u8; 256];
            let mut su = [0u8; 64];
            let mut sv = [0u8; 64];
            for y in 0..ph {
                sy[y * pw..(y + 1) * pw].copy_from_slice(&st.yuv.y[(py + y) * w + px..(py + y) * w + px + pw]);
            }
            for y in 0..cph {
                let o = (cy + y) * cw + cx;
                su[y * cpw..(y + 1) * cpw].copy_from_slice(&st.yuv.u[o..o + cpw]);
                sv[y * cpw..(y + 1) * cpw].copy_from_slice(&st.yuv.v[o..o + cpw]);
            }
            mc_part(st, px, py, pw, ph, mv[1], b.yuv);
            // 成分ごとの (logWD, w0, w1, (o0 + o1 + 1) >> 1)。None は既定の平均。
            let wts: Option<[(i32, i32, i32, i32); 3]> = match &st.wp {
                WpMode::Off => None,
                WpMode::Explicit(t) => {
                    let e0 = t.w[0].get(ref_idx[0] as usize).ok_or("missing weight entry")?;
                    let e1 = t.w[1].get(ref_idx[1] as usize).ok_or("missing weight entry")?;
                    let lw = [t.luma_log2_denom as i32, t.chroma_log2_denom as i32, t.chroma_log2_denom as i32];
                    Some(core::array::from_fn(|c| (lw[c], e0[c].0, e1[c].0, (e0[c].1 + e1[c].1 + 1) >> 1)))
                }
                WpMode::Implicit => {
                    let (w0, w1) = implicit_weights(st.cur_poc, a.id, b.id);
                    Some([(5, w0, w1, 0); 3])
                }
            };
            let comb = |c: usize, p0: u8, p1: u8| -> u8 {
                match wts {
                    None => ((p0 as u16 + p1 as u16 + 1) >> 1) as u8,
                    Some(wt) => {
                        let (lw, w0, w1, o) = wt[c];
                        let v = ((p0 as i32 * w0 + p1 as i32 * w1 + (1 << lw)) >> (lw + 1)) + o;
                        v.clamp(0, 255) as u8
                    }
                }
            };
            for y in 0..ph {
                for x in 0..pw {
                    let o = (py + y) * w + px + x;
                    st.yuv.y[o] = comb(0, sy[y * pw + x], st.yuv.y[o]);
                }
            }
            for y in 0..cph {
                for x in 0..cpw {
                    let o = (cy + y) * cw + cx + x;
                    st.yuv.u[o] = comb(1, su[y * cpw + x], st.yuv.u[o]);
                    st.yuv.v[o] = comb(2, sv[y * cpw + x], st.yuv.v[o]);
                }
            }
        }
        (None, None) => return Err("partition without prediction list"),
    }
    Ok([ent[0].map_or(0, |e| e.id), ent[1].map_or(0, |e| e.id)])
}

/// 単方向予測の明示的な重み付け（8.4.2.3.2）。明示モード以外は何もしない（暗黙モードの
/// 単方向は既定）。予測済みの領域をその場で置き換える。
#[allow(clippy::too_many_arguments)]
fn weight_single(st: &mut DecState, px: usize, py: usize, pw: usize, ph: usize, list: usize, ref_idx: i8) {
    let WpMode::Explicit(t) = &st.wp else { return };
    let Some(e) = t.w[list].get(ref_idx as usize).copied() else { return };
    let lw = [t.luma_log2_denom as i32, t.chroma_log2_denom as i32, t.chroma_log2_denom as i32];
    let f = |c: usize, p: u8| -> u8 {
        let (w, o) = e[c];
        let v = if lw[c] >= 1 {
            ((p as i32 * w + (1 << (lw[c] - 1))) >> lw[c]) + o
        } else {
            p as i32 * w + o
        };
        v.clamp(0, 255) as u8
    };
    let w = st.yuv.width as usize;
    let cw = w / 2;
    for y in 0..ph {
        for x in 0..pw {
            let o = (py + y) * w + px + x;
            st.yuv.y[o] = f(0, st.yuv.y[o]);
        }
    }
    for y in 0..ph / 2 {
        for x in 0..pw / 2 {
            let o = (py / 2 + y) * cw + px / 2 + x;
            st.yuv.u[o] = f(1, st.yuv.u[o]);
            st.yuv.v[o] = f(2, st.yuv.v[o]);
        }
    }
}

/// 暗黙の重み付き双予測の重み (w0, w1)（8.4.2.3.1、logWD = 5）。POC の距離の比から求め、
/// 範囲外・同じ距離なら等分（32, 32）。
fn implicit_weights(cur_poc: i32, poc0: i32, poc1: i32) -> (i32, i32) {
    let td = (poc1 - poc0).clamp(-128, 127);
    if td == 0 {
        return (32, 32);
    }
    let tb = (cur_poc - poc0).clamp(-128, 127);
    let tx = (16384 + (td / 2).abs()) / td;
    let dsf = ((tb * tx + 32) >> 6).clamp(-1024, 1023);
    let w1 = dsf >> 2;
    if !(-64..=128).contains(&w1) {
        return (32, 32);
    }
    (64 - w1, w1)
}

/// 空間ダイレクトの MB 単位の導出結果（8.4.1.2.2）。
struct SpatialDirect {
    ref_idx: [i8; 2],
    mvp: [[i16; 2]; 2],
    /// 近傍がどちらのリストも使っていない（directZeroPredictionFlag）。
    zero: bool,
}

/// MinPositive(x, y)（8.4.1.2.2）。
fn min_positive(x: i8, y: i8) -> i8 {
    if x >= 0 && y >= 0 {
        x.min(y)
    } else {
        x.max(y)
    }
}

/// 空間ダイレクトの refIdx と MV 予測を MB の近傍 A/B/C（16x16 として）から求める。
/// MB 内のパーティションを 1 つも格納する前に呼ぶこと。
fn spatial_direct(st: &DecState, mb_x: u32, mb_y: u32) -> SpatialDirect {
    let (px, py) = (mb_x as usize, mb_y as usize);
    let mut ref_idx = [-1i8; 2];
    for (list, ri) in ref_idx.iter_mut().enumerate() {
        let (a, b, c) = part_neighbors(st, px, py, 16, list);
        *ri = min_positive(a.ref_idx, min_positive(b.ref_idx, c.ref_idx));
    }
    if ref_idx[0] < 0 && ref_idx[1] < 0 {
        return SpatialDirect { ref_idx: [0, 0], mvp: [[0, 0]; 2], zero: true };
    }
    let mut mvp = [[0i16; 2]; 2];
    for list in 0..2 {
        if ref_idx[list] >= 0 {
            mvp[list] = mv_predict_l(st, px, py, 16, MvDir::None, ref_idx[list], list);
        }
    }
    SpatialDirect { ref_idx, mvp, zero: false }
}

/// co-located（RefPicList1[0] の同じ位置）の 4x4 ブロックが「ほぼ静止」か（colZeroFlag、8.4.1.2.2）。
/// `(bx, by)` は MB 内の 4x4 位置。direct_8x8_inference では 8x8 の外側の角を使う（8.4.1.2.1）。
fn col_zero(col: &Motion, mb_x: u32, mb_y: u32, bx: usize, by: usize, direct_8x8: bool) -> bool {
    let (cx, cy) = if direct_8x8 {
        (if bx < 2 { 0 } else { 3 }, if by < 2 { 0 } else { 3 })
    } else {
        (bx, by)
    };
    let li = (mb_y as usize / 4 + cy) * col.blk_w + mb_x as usize / 4 + cx;
    let (ri, mv) = if col.refi[0].get(li).is_some_and(|&r| r >= 0) {
        (col.refi[0][li], col.mv[0][li])
    } else if col.refi[1].get(li).is_some_and(|&r| r >= 0) {
        (col.refi[1][li], col.mv[1][li])
    } else {
        return false; // イントラ
    };
    ri == 0 && (-1..=1).contains(&mv[0]) && (-1..=1).contains(&mv[1])
}

/// 空間ダイレクトの 8x8（`i` 番目）を予測・格納する。direct_8x8_inference が無ければ 4x4 ごと。
fn direct_8x8(st: &mut DecState, d: &SpatialDirect, mb_x: u32, mb_y: u32, i: usize, ctx: &BCtx) -> Result<(), &'static str> {
    let col = ctx.l[1].first().and_then(|e| e.motion).ok_or("B slice needs co-located motion")?;
    let (sx, sy) = ((i % 2) * 8, (i / 2) * 8);
    let (bs, offs): (usize, &[(usize, usize)]) = if ctx.direct_8x8 {
        (8, &[(0, 0)])
    } else {
        (4, &[(0, 0), (4, 0), (0, 4), (4, 4)])
    };
    for &(ox, oy) in offs {
        let (bx, by) = ((sx + ox) / 4, (sy + oy) / 4);
        let mut mv = [[0i16; 2]; 2];
        if !d.zero {
            let cz = col_zero(col, mb_x, mb_y, bx, by, ctx.direct_8x8);
            for list in 0..2 {
                if d.ref_idx[list] >= 0 && !(d.ref_idx[list] == 0 && cz) {
                    mv[list] = d.mvp[list];
                }
            }
        }
        let (px, py) = (mb_x as usize + sx + ox, mb_y as usize + sy + oy);
        let ids = mc_pred(st, px, py, bs, bs, mv, d.ref_idx, ctx.l)?;
        store_part(st, px, py, bs, bs, mv, d.ref_idx, ids);
    }
    Ok(())
}

/// B_Skip / B_Direct_16x16 の予測（残差は呼び出し側）。
fn decode_b_direct_mb(st: &mut DecState, mb_x: u32, mb_y: u32, ctx: &BCtx) -> Result<(), &'static str> {
    let d = spatial_direct(st, mb_x, mb_y);
    for i in 0..4 {
        direct_8x8(st, &d, mb_x, mb_y, i, ctx)?;
    }
    Ok(())
}

/// B スライスの符号化 MB（mb_type: 0 = B_Direct_16x16、1..=21 = 16x16/16x8/8x16、22 = B_8x8、
/// 23 以上 = イントラ）。mb_pred の並びは ref_idx_l0 → ref_idx_l1 → mvd_l0 → mvd_l1（7.3.5.1）。
#[allow(clippy::too_many_arguments)]
fn decode_mb_b<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
    ctx: &BCtx,
) -> Result<(), &'static str> {
    let mb_type = r.mb_type(st, mb_x, mb_y, SliceKind::B)?;
    if mb_type >= 23 {
        let it = mb_type - 23;
        if it == 25 {
            return decode_mb_ipcm(r, st, mb_x, mb_y);
        }
        if it == 0 {
            return decode_mb_i4x4(r, st, mb_x, mb_y, qp, pps);
        }
        if (1..=24).contains(&it) {
            return decode_mb_i16x16(r, st, mb_x, mb_y, qp, it, pps);
        }
        return Err("bad intra mb_type in B slice");
    }
    let (px, py) = (mb_x as usize, mb_y as usize);
    let mut t8_ok = true;
    match mb_type {
        0 => {
            r.mark_direct(px, py, 16, 16);
            decode_b_direct_mb(st, mb_x, mb_y, ctx)?;
            t8_ok = ctx.direct_8x8;
        }
        22 => t8_ok = decode_b8x8(r, st, mb_x, mb_y, ctx)?,
        _ => {
            // (x, y, w, h, 予測リスト, MV 予測の方向)
            let mut parts = [(0usize, 0usize, 16usize, 16usize, 0u8, MvDir::None); 2];
            let n = if mb_type <= 3 {
                parts[0].4 = mb_type as u8; // 1 = L0, 2 = L1, 3 = Bi
                1
            } else {
                let k = (mb_type - 4) as usize;
                let (m0, m1) = B_PART_PAIRS[k / 2];
                if k.is_multiple_of(2) {
                    parts = [(0, 0, 16, 8, m0, MvDir::B), (0, 8, 16, 8, m1, MvDir::A)];
                } else {
                    parts = [(0, 0, 8, 16, m0, MvDir::A), (8, 0, 8, 16, m1, MvDir::C)];
                }
                2
            };
            let mut ri = [[-1i8; 2]; 2];
            let mut mvd = [[[0i16; 2]; 2]; 2];
            for list in 0..2 {
                for i in 0..n {
                    if parts[i].4 & (1 << list) != 0 {
                        let (ox, oy, pw, ph, _, _) = parts[i];
                        ri[i][list] = r.ref_idx(st, list, px + ox, py + oy, pw, ph, st.num_ref[list])?;
                    }
                }
            }
            for list in 0..2 {
                for i in 0..n {
                    if parts[i].4 & (1 << list) != 0 {
                        let (ox, oy, pw, ph, _, _) = parts[i];
                        mvd[i][list] = r.mvd(st, list, px + ox, py + oy, pw, ph)?;
                    }
                }
            }
            for i in 0..n {
                let (ox, oy, pw, ph, _, dir) = parts[i];
                let (ppx, ppy) = (px + ox, py + oy);
                let mut mv = [[0i16; 2]; 2];
                for list in 0..2 {
                    if ri[i][list] >= 0 {
                        let p = mv_predict_l(st, ppx, ppy, pw, dir, ri[i][list], list);
                        mv[list] = [p[0].wrapping_add(mvd[i][list][0]), p[1].wrapping_add(mvd[i][list][1])];
                    }
                }
                let ids = mc_pred(st, ppx, ppy, pw, ph, mv, ri[i], ctx.l)?;
                store_part(st, ppx, ppy, pw, ph, mv, ri[i], ids);
            }
        }
    }
    decode_inter_residual(r, st, mb_x, mb_y, qp, pps, t8_ok)
}

/// B_8x8: 4 つの sub_mb_type（表 7-18）。B_Direct_8x8 の 8x8 は空間ダイレクト。
fn decode_b8x8<R: MbSyntax>(r: &mut R, st: &mut DecState, mb_x: u32, mb_y: u32, ctx: &BCtx) -> Result<bool, &'static str> {
    let mut sub = [0usize; 4];
    for s in sub.iter_mut() {
        *s = r.sub_mb_type(SliceKind::B)? as usize;
        if *s >= B_SUB_MB.len() {
            return Err("bad B sub_mb_type");
        }
    }
    let (mx, my) = (mb_x as usize, mb_y as usize);
    for (i, &t) in sub.iter().enumerate() {
        if t == 0 {
            r.mark_direct(mx + (i % 2) * 8, my + (i / 2) * 8, 8, 8);
        }
    }
    let mut ri = [[-1i8; 2]; 4];
    for list in 0..2 {
        for i in 0..4 {
            if B_SUB_MB[sub[i]].0 & (1 << list) != 0 {
                ri[i][list] = r.ref_idx(st, list, mx + (i % 2) * 8, my + (i / 2) * 8, 8, 8, st.num_ref[list])?;
            }
        }
    }
    let mut mvd = [[[[0i16; 2]; 4]; 2]; 4];
    for list in 0..2 {
        for i in 0..4 {
            let (mode, w, h) = B_SUB_MB[sub[i]];
            if mode & (1 << list) != 0 {
                for (k, &(ox, oy)) in sub_part_offsets(w, h).iter().enumerate() {
                    let (ppx, ppy) = (mx + (i % 2) * 8 + ox, my + (i / 2) * 8 + oy);
                    mvd[i][list][k] = r.mvd(st, list, ppx, ppy, w, h)?;
                }
            }
        }
    }
    // ダイレクトの導出は MB の近傍だけを見るので、MB 内を格納する前に 1 度だけ求める。
    let direct = if sub.contains(&0) { Some(spatial_direct(st, mb_x, mb_y)) } else { None };
    for i in 0..4 {
        if sub[i] == 0 {
            if let Some(d) = &direct {
                direct_8x8(st, d, mb_x, mb_y, i, ctx)?;
            }
            continue;
        }
        let (_, w, h) = B_SUB_MB[sub[i]];
        let sx = mb_x as usize + (i % 2) * 8;
        let sy = mb_y as usize + (i / 2) * 8;
        for (k, &(ox, oy)) in sub_part_offsets(w, h).iter().enumerate() {
            let (ppx, ppy) = (sx + ox, sy + oy);
            let mut mv = [[0i16; 2]; 2];
            for list in 0..2 {
                if ri[i][list] >= 0 {
                    let p = mv_predict_l(st, ppx, ppy, w, MvDir::None, ri[i][list], list);
                    mv[list] = [p[0].wrapping_add(mvd[i][list][k][0]), p[1].wrapping_add(mvd[i][list][k][1])];
                }
            }
            let ids = mc_pred(st, ppx, ppy, w, h, mv, ri[i], ctx.l)?;
            store_part(st, ppx, ppy, w, h, mv, ri[i], ids);
        }
    }
    // 8x8 変換は全サブ MB が 8x8（ダイレクトは 8x8 推論のとき）のときだけ。
    Ok(sub.iter().all(|&t| (1..=3).contains(&t) || (t == 0 && ctx.direct_8x8)))
}

// ===================== 8x8 変換（High） =====================
//
// 【2026-10-17】High プロファイル（avc1.64xxxx）のため新設。スケーリング行列は平坦（16）のみ。

/// 8x8 のジグザグ走査（フレーム）: 走査位置 → ラスタ位置。
const ZIGZAG_8X8: [usize; 64] = [
    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14,
    21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53,
    60, 61, 54, 47, 55, 62, 63,
];

/// CABAC の 8x8（cat 5、フレーム）の significant_coeff_flag の ctxIdxInc（表 9-43）。
const SIG_CTX_8X8_FRAME: [u8; 63] = [
    0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9, 10, 9, 8, 7, 7, 6, 11, 12,
    13, 11, 6, 7, 8, 9, 14, 10, 9, 8, 6, 11, 12, 13, 11, 6, 9, 14, 10, 9, 11, 12, 13, 11, 14, 10, 12,
];

/// CABAC の 8x8 の last_significant_coeff_flag の ctxIdxInc（表 9-43）。
const LAST_CTX_8X8: [u8; 63] = [
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
    3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8,
];

/// normAdjust8x8 の 6 つの値（8.5.9、qP % 6 ごと）。
const NORM_ADJUST_8X8: [[i32; 6]; 6] = [
    [20, 18, 32, 19, 25, 24],
    [22, 19, 35, 21, 28, 26],
    [26, 23, 42, 24, 33, 31],
    [28, 25, 45, 26, 35, 33],
    [32, 28, 51, 30, 40, 38],
    [36, 32, 58, 34, 46, 43],
];

/// 8x8 の係数位置 (i, j) が normAdjust8x8 のどの値を使うか。
fn norm8_class(i: usize, j: usize) -> usize {
    match (i & 3, j & 3) {
        (0, 0) => 0,
        (1 | 3, 1 | 3) => 1,
        (2, 2) => 2,
        (0, 1 | 3) | (1 | 3, 0) => 3,
        (0, 2) | (2, 0) => 4,
        _ => 5,
    }
}

/// 8x8 の逆量子化（8.5.13.1、平坦な weightScale = 16）。`b` はラスタ順。
fn dequant_8x8(b: &mut [i32; 64], qp: i32) {
    let m = (qp % 6) as usize;
    let sh = qp / 6;
    for (k, c) in b.iter_mut().enumerate() {
        if *c == 0 {
            continue;
        }
        let ls = 16 * NORM_ADJUST_8X8[m][norm8_class(k / 8, k % 8)];
        *c = if sh >= 6 { (*c * ls) << (sh - 6) } else { (*c * ls + (1 << (5 - sh))) >> (6 - sh) };
    }
}

/// 8x8 の 1 次元逆変換（8.5.13.2）。
fn idct8_1d(d: [i32; 8]) -> [i32; 8] {
    let a0 = d[0] + d[4];
    let a4 = d[0] - d[4];
    let a2 = (d[2] >> 1) - d[6];
    let a6 = d[2] + (d[6] >> 1);
    let b0 = a0 + a6;
    let b2 = a4 + a2;
    let b4 = a4 - a2;
    let b6 = a0 - a6;
    let a1 = -d[3] + d[5] - d[7] - (d[7] >> 1);
    let a3 = d[1] + d[7] - d[3] - (d[3] >> 1);
    let a5 = -d[1] + d[7] + d[5] + (d[5] >> 1);
    let a7 = d[3] + d[5] + d[1] + (d[1] >> 1);
    let b1 = a1 + (a7 >> 2);
    let b7 = a7 - (a1 >> 2);
    let b3 = a3 + (a5 >> 2);
    let b5 = (a3 >> 2) - a5;
    [b0 + b7, b2 + b5, b4 + b3, b6 + b1, b6 - b1, b4 - b3, b2 - b5, b0 - b7]
}

/// 8x8 の逆変換（行 → 列、最後に (x + 32) >> 6）。`b` はラスタ順で、残差に置き換える。
fn inverse_transform_8x8(b: &mut [i32; 64]) {
    for r in 0..8 {
        let row: [i32; 8] = core::array::from_fn(|c| b[r * 8 + c]);
        let o = idct8_1d(row);
        b[r * 8..r * 8 + 8].copy_from_slice(&o);
    }
    for c in 0..8 {
        let col: [i32; 8] = core::array::from_fn(|r| b[r * 8 + c]);
        let o = idct8_1d(col);
        for r in 0..8 {
            b[r * 8 + c] = (o[r] + 32) >> 6;
        }
    }
}

/// 8x8 の係数（走査順）→ 逆量子化・逆変換済みの残差（ラスタ順）。
fn residual_8x8_to_pixels(scan: &[i32; 64], qp: i32) -> [i32; 64] {
    let mut b = [0i32; 64];
    for k in 0..64 {
        b[ZIGZAG_8X8[k]] = scan[k];
    }
    dequant_8x8(&mut b, qp);
    inverse_transform_8x8(&mut b);
    b
}

impl DecState {
    /// Intra8x8 予測（8.3.2.2）。参照画素を [1, 2, 1] で平滑化してから 9 モードで予測する。
    fn predict_luma_8x8(&self, px: usize, py: usize, mode: u8) -> [i32; 64] {
        let w = self.yuv.width as usize;
        let (bx4, by4) = (px / 4, py / 4);
        let top = self.avail_px(px as isize, py as isize - 1);
        let left = self.avail_px(px as isize - 1, py as isize);
        let tl = self.avail_px(px as isize - 1, py as isize - 1);
        let tr = top
            && px + 8 < w
            && by4 > 0
            && self.avail_blk(bx4 as isize + 2, by4 as isize - 1)
            && self.decoded[self.li(bx4 + 2, by4 - 1)];
        let pix = |x: isize, y: isize| self.yuv.y[(py as isize + y) as usize * w + (px as isize + x) as usize] as i32;
        let mut t = [0i32; 16];
        let mut l = [0i32; 8];
        if top {
            let mut tp = [0i32; 16];
            for (x, v) in tp.iter_mut().enumerate() {
                *v = if x < 8 || tr { pix(x as isize, -1) } else { pix(7, -1) };
            }
            t[0] = ((if tl { pix(-1, -1) } else { tp[0] }) + 2 * tp[0] + tp[1] + 2) >> 2;
            for x in 1..15 {
                t[x] = (tp[x - 1] + 2 * tp[x] + tp[x + 1] + 2) >> 2;
            }
            t[15] = (tp[14] + 3 * tp[15] + 2) >> 2;
        }
        if left {
            let lp: [i32; 8] = core::array::from_fn(|y| pix(-1, y as isize));
            l[0] = ((if tl { pix(-1, -1) } else { lp[0] }) + 2 * lp[0] + lp[1] + 2) >> 2;
            for y in 1..7 {
                l[y] = (lp[y - 1] + 2 * lp[y] + lp[y + 1] + 2) >> 2;
            }
            l[7] = (lp[6] + 3 * lp[7] + 2) >> 2;
        }
        let mut q = 0;
        if tl {
            let c = pix(-1, -1);
            q = match (top, left) {
                (true, true) => (pix(0, -1) + 2 * c + pix(-1, 0) + 2) >> 2,
                (true, false) => (3 * c + pix(0, -1) + 2) >> 2,
                (false, true) => (3 * c + pix(-1, 0) + 2) >> 2,
                _ => c,
            };
        }
        // 添字 -1 は左上の角 Q。
        let tt = |i: i32| if i < 0 { q } else { t[i as usize] };
        let ll = |i: i32| if i < 0 { q } else { l[i as usize] };
        let mut pred = [0i32; 64];
        for y in 0..8i32 {
            for x in 0..8i32 {
                let v = match mode {
                    0 => tt(x),
                    1 => ll(y),
                    2 => match (top, left) {
                        (true, true) => (t[..8].iter().sum::<i32>() + l.iter().sum::<i32>() + 8) >> 4,
                        (false, true) => (l.iter().sum::<i32>() + 4) >> 3,
                        (true, false) => (t[..8].iter().sum::<i32>() + 4) >> 3,
                        _ => 128,
                    },
                    3 => {
                        if x == 7 && y == 7 {
                            (tt(14) + 3 * tt(15) + 2) >> 2
                        } else {
                            (tt(x + y) + 2 * tt(x + y + 1) + tt(x + y + 2) + 2) >> 2
                        }
                    }
                    4 => {
                        if x > y {
                            (tt(x - y - 2) + 2 * tt(x - y - 1) + tt(x - y) + 2) >> 2
                        } else if x < y {
                            (ll(y - x - 2) + 2 * ll(y - x - 1) + ll(y - x) + 2) >> 2
                        } else {
                            (tt(0) + 2 * q + ll(0) + 2) >> 2
                        }
                    }
                    5 => {
                        let z = 2 * x - y;
                        if z >= 0 && z % 2 == 0 {
                            (tt(x - (y >> 1) - 1) + tt(x - (y >> 1)) + 1) >> 1
                        } else if z >= 0 {
                            (tt(x - (y >> 1) - 2) + 2 * tt(x - (y >> 1) - 1) + tt(x - (y >> 1)) + 2) >> 2
                        } else if z == -1 {
                            (ll(0) + 2 * q + tt(0) + 2) >> 2
                        } else {
                            (ll(y - 2 * x - 1) + 2 * ll(y - 2 * x - 2) + ll(y - 2 * x - 3) + 2) >> 2
                        }
                    }
                    6 => {
                        let z = 2 * y - x;
                        if z >= 0 && z % 2 == 0 {
                            (ll(y - (x >> 1) - 1) + ll(y - (x >> 1)) + 1) >> 1
                        } else if z >= 0 {
                            (ll(y - (x >> 1) - 2) + 2 * ll(y - (x >> 1) - 1) + ll(y - (x >> 1)) + 2) >> 2
                        } else if z == -1 {
                            (ll(0) + 2 * q + tt(0) + 2) >> 2
                        } else {
                            (tt(x - 2 * y - 1) + 2 * tt(x - 2 * y - 2) + tt(x - 2 * y - 3) + 2) >> 2
                        }
                    }
                    7 => {
                        if y % 2 == 0 {
                            (tt(x + (y >> 1)) + tt(x + (y >> 1) + 1) + 1) >> 1
                        } else {
                            (tt(x + (y >> 1)) + 2 * tt(x + (y >> 1) + 1) + tt(x + (y >> 1) + 2) + 2) >> 2
                        }
                    }
                    _ => {
                        let z = x + 2 * y;
                        if z > 13 {
                            ll(7)
                        } else if z == 13 {
                            (ll(6) + 3 * ll(7) + 2) >> 2
                        } else if z % 2 == 0 {
                            (ll(y + (x >> 1)) + ll(y + (x >> 1) + 1) + 1) >> 1
                        } else {
                            (ll(y + (x >> 1)) + 2 * ll(y + (x >> 1) + 1) + ll(y + (x >> 1) + 2) + 2) >> 2
                        }
                    }
                };
                pred[(y * 8 + x) as usize] = v;
            }
        }
        pred
    }
}

/// 輝度 4x4 ブロックの再構成（予測 + 残差）を行い、グリッドを更新する。
fn reconstruct_luma_4x4(st: &mut DecState, px: usize, py: usize, mode: u8, residual: &[i32; 16]) {
    let pred = st.predict_luma_4x4(px, py, mode);
    let w = st.yuv.width as usize;
    for yy in 0..4 {
        for xx in 0..4 {
            let v = clip1(pred[yy * 4 + xx] + residual[yy * 4 + xx]);
            st.yuv.y[(py + yy) * w + px + xx] = v as u8;
        }
    }
    let di = st.li(px / 4, py / 4);
    st.decoded[di] = true;
}

fn decode_mb_i16x16<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    mb_type: u32,
    pps: &Pps,
) -> Result<(), &'static str> {
    let m1 = mb_type - 1;
    let i16_pred = (m1 % 4) as u8;
    let cbp_chroma = (m1 / 4) % 3;
    let cbp_luma = if m1 / 12 != 0 { 15 } else { 0 };

    let intra_chroma_pred_mode = r.intra_chroma_mode(st, mb_x, mb_y)?;
    let mb_qp_delta = r.qp_delta()?;
    if !(-26..=25).contains(&mb_qp_delta) {
        return Err("mb_qp_delta out of range");
    }
    *qp = (*qp + mb_qp_delta + 52) % 52;
    let cur_qp = *qp;
    st.mb_qp[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = cur_qp;

    // 輝度 DC（16 係数, Hadamard）。nC は近傍 4x4 ブロックの nnz から。
    let bx0 = (mb_x / 4) as usize;
    let by0 = (mb_y / 4) as usize;
    let (dc_scan, _) = r.residual(st, ResBlock::LumaDc { bx4: bx0, by4: by0 })?;
    let mut dc_block = [0i32; 16];
    for k in 0..16 {
        dc_block[ZIGZAG_4X4[k]] = dc_scan[k];
    }
    inverse_hadamard_4x4(&mut dc_block);
    scale_luma_dc(&mut dc_block, cur_qp);

    // 輝度 AC（cbp_luma のとき各 4x4）。
    let mut luma_ac = [[0i32; 16]; 16];
    for blk in 0..16 {
        let (bx, by) = LUMA_4X4_BLOCK_XY[blk];
        let bx4 = bx0 + bx / 4;
        let by4 = by0 + by / 4;
        let li = st.li(bx4, by4);
        if cbp_luma != 0 {
            let (ac_scan, tc) = r.residual(st, ResBlock::LumaAc { bx4, by4 })?;
            for k in 0..15 {
                luma_ac[blk][ZIGZAG_4X4[k + 1]] = ac_scan[k];
            }
            st.nnz_luma[li] = tc;
        } else {
            st.nnz_luma[li] = 0;
        }
    }

    // 輝度予測（I_16x16、MB 全体）。
    let w = st.yuv.width as usize;
    let mut top = [0i32; 16];
    let mut left = [0i32; 16];
    let top_avail = st.avail_px(mb_x as isize, mb_y as isize - 1);
    let left_avail = st.avail_px(mb_x as isize - 1, mb_y as isize);
    if top_avail {
        for x in 0..16 {
            top[x] = st.yuv.y[(mb_y as usize - 1) * w + mb_x as usize + x] as i32;
        }
    }
    if left_avail {
        for y in 0..16 {
            left[y] = st.yuv.y[(mb_y as usize + y) * w + mb_x as usize - 1] as i32;
        }
    }
    let corner = if top_avail && left_avail {
        st.yuv.y[(mb_y as usize - 1) * w + mb_x as usize - 1] as i32
    } else {
        0
    };
    let pred = intra_16x16_predict(i16_pred, &top, corner, &left, top_avail, left_avail);

    // 輝度再構成。
    for blk in 0..16 {
        let (bx, by) = LUMA_4X4_BLOCK_XY[blk];
        let dc_idx = (by / 4) * 4 + (bx / 4);
        let mut block = luma_ac[blk];
        dequant_4x4(&mut block, cur_qp);
        block[0] = dc_block[dc_idx];
        inverse_transform_4x4(&mut block);
        for yy in 0..4 {
            for xx in 0..4 {
                let px = mb_x as usize + bx + xx;
                let py = mb_y as usize + by + yy;
                let p = pred[(by + yy) * 16 + (bx + xx)];
                st.yuv.y[py * w + px] = clip1(p + block[yy * 4 + xx]) as u8;
            }
        }
        let di = st.li((mb_x as usize + bx) / 4, (mb_y as usize + by) / 4);
        st.decoded[di] = true;
    }

    decode_chroma(
        r,
        st,
        mb_x,
        mb_y,
        cbp_chroma,
        intra_chroma_pred_mode,
        cur_qp,
        pps.chroma_qp_offsets(),
    )
}

fn decode_mb_i4x4<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
) -> Result<(), &'static str> {
    let bx0 = (mb_x / 4) as usize;
    let by0 = (mb_y / 4) as usize;
    if pps.transform_8x8_mode_flag && r.transform_8x8(st, mb_x, mb_y) {
        return decode_mb_i8x8(r, st, mb_x, mb_y, qp, pps);
    }

    // 16 個の Intra4x4 予測モードを読む。
    let mut modes = [0u8; 16];
    for blk in 0..16 {
        let (bx, by) = LUMA_4X4_BLOCK_XY[blk];
        let bx4 = bx0 + bx / 4;
        let by4 = by0 + by / 4;
        let pred_mode = st.pred_i4x4_mode(bx4, by4);
        let mode = match r.intra4x4_rem() {
            None => pred_mode,
            Some(rem) if rem < pred_mode => rem,
            Some(rem) => rem + 1,
        };
        modes[blk] = mode as u8;
        let li = st.li(bx4, by4);
        st.mode_luma[li] = mode as i8;
    }

    let intra_chroma_pred_mode = r.intra_chroma_mode(st, mb_x, mb_y)?;
    let cbp = r.cbp(st, mb_x, mb_y, true)?;
    let cbp_luma = cbp & 0xf;
    let cbp_chroma = cbp >> 4;

    let cur_qp = if cbp != 0 {
        let mb_qp_delta = r.qp_delta()?;
        if !(-26..=25).contains(&mb_qp_delta) {
            return Err("mb_qp_delta out of range");
        }
        *qp = (*qp + mb_qp_delta + 52) % 52;
        *qp
    } else {
        *qp
    };
    st.mb_qp[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = cur_qp;

    // ブロックごとに残差を読み、予測 + 再構成。
    for blk in 0..16 {
        let (bx, by) = LUMA_4X4_BLOCK_XY[blk];
        let bx4 = bx0 + bx / 4;
        let by4 = by0 + by / 4;
        let mut block = [0i32; 16];
        let li = st.li(bx4, by4);
        if cbp_luma & (1 << (blk / 4)) != 0 {
            let (scan, tc) = r.residual(st, ResBlock::Luma4x4 { bx4, by4 })?;
            for k in 0..16 {
                block[ZIGZAG_4X4[k]] = scan[k];
            }
            st.nnz_luma[li] = tc;
        } else {
            st.nnz_luma[li] = 0;
        }
        dequant_4x4(&mut block, cur_qp);
        inverse_transform_4x4(&mut block);
        reconstruct_luma_4x4(
            st,
            mb_x as usize + bx,
            mb_y as usize + by,
            modes[blk],
            &block,
        );
    }

    decode_chroma(
        r,
        st,
        mb_x,
        mb_y,
        cbp_chroma,
        intra_chroma_pred_mode,
        cur_qp,
        pps.chroma_qp_offsets(),
    )
}

/// I_NxN で transform_size_8x8_flag = 1（Intra8x8）。4 つの 8x8 の予測モード → クロマ予測モード
/// → cbp → mb_qp_delta → 8x8 ごとの残差（7.3.5）。
fn decode_mb_i8x8<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
) -> Result<(), &'static str> {
    let bx0 = (mb_x / 4) as usize;
    let by0 = (mb_y / 4) as usize;
    st.mb_t8[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = true;
    let mut modes = [0u8; 4];
    for (i, m) in modes.iter_mut().enumerate() {
        let (bx4, by4) = (bx0 + (i % 2) * 2, by0 + (i / 2) * 2);
        // 予測モードの予測は 8x8 の左上 4x4 の左・上（4x4 の MB でも 8x8 の MB でも同じ位置関係）。
        let pred_mode = st.pred_i4x4_mode(bx4, by4);
        let mode = match r.intra4x4_rem() {
            None => pred_mode,
            Some(rem) if rem < pred_mode => rem,
            Some(rem) => rem + 1,
        };
        *m = mode as u8;
        for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] {
            let li = st.li(bx4 + dx, by4 + dy);
            st.mode_luma[li] = mode as i8;
        }
    }
    let intra_chroma_pred_mode = r.intra_chroma_mode(st, mb_x, mb_y)?;
    let cbp = r.cbp(st, mb_x, mb_y, true)?;
    let cur_qp = if cbp != 0 {
        let d = r.qp_delta()?;
        if !(-26..=25).contains(&d) {
            return Err("mb_qp_delta out of range");
        }
        *qp = (*qp + d + 52) % 52;
        *qp
    } else {
        *qp
    };
    st.mb_qp[(mb_y / 16) as usize * st.mb_w + (mb_x / 16) as usize] = cur_qp;
    let w = st.yuv.width as usize;
    for i in 0..4 {
        let (bx4, by4) = (bx0 + (i % 2) * 2, by0 + (i / 2) * 2);
        let (px, py) = (bx4 * 4, by4 * 4);
        let mut res = [0i32; 64];
        let mut cnt = [0u8; 4];
        if cbp & (1 << i) != 0 {
            let (scan, c) = r.residual8x8(st, bx4, by4)?;
            res = residual_8x8_to_pixels(&scan, cur_qp);
            cnt = c;
        }
        let pred = st.predict_luma_8x8(px, py, modes[i]);
        for y in 0..8 {
            for x in 0..8 {
                st.yuv.y[(py + y) * w + px + x] = clip1(pred[y * 8 + x] + res[y * 8 + x]) as u8;
            }
        }
        for (k, (dx, dy)) in [(0, 0), (1, 0), (0, 1), (1, 1)].into_iter().enumerate() {
            let li = st.li(bx4 + dx, by4 + dy);
            st.nnz_luma[li] = cnt[k];
            st.decoded[li] = true;
        }
    }
    decode_chroma(r, st, mb_x, mb_y, cbp >> 4, intra_chroma_pred_mode, cur_qp, pps.chroma_qp_offsets())
}

/// 輝度 QP -> クロマ QP（Table 8-15、qPi>=30 の写像）。
fn chroma_qp(qp_y: i32, offset: i32) -> i32 {
    let qpi = (qp_y + offset).clamp(0, 51);
    if qpi < 30 {
        qpi
    } else {
        const MAP: [i32; 22] = [
            29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 39, 39, 39, 39,
        ];
        MAP[(qpi - 30) as usize]
    }
}

/// 2x2 クロマ DC の逆 Hadamard 変換（raster 2x2、c[0..3]）。
fn inverse_hadamard_2x2(c: [i32; 4]) -> [i32; 4] {
    [
        c[0] + c[1] + c[2] + c[3],
        c[0] - c[1] + c[2] - c[3],
        c[0] + c[1] - c[2] - c[3],
        c[0] - c[1] - c[2] + c[3],
    ]
}

/// クロマ DC のスケーリング（8.5.11.1）: dcC = ((f * LevelScale(qPc%6,0,0)) << (qPc/6)) >> 5。
fn scale_chroma_dc(f: i32, qpc: i32) -> i32 {
    let ls = 16 * NORM_ADJUST_4X4[(qpc % 6) as usize][0];
    ((f * ls) << (qpc / 6)) >> 5
}

/// クロマ 4x4 ブロックの nC（クロマプレーン内の左/上 nnz から）。
fn chroma_nc(st: &DecState, comp: usize, cbx4: usize, cby4: usize) -> i32 {
    let na = if st.avail_px(cbx4 as isize * 8 - 1, cby4 as isize * 8) {
        st.nnz_chroma[comp][cby4 * st.cblk_w + cbx4 - 1] as i32
    } else {
        -1
    };
    let nb = if st.avail_px(cbx4 as isize * 8, cby4 as isize * 8 - 1) {
        st.nnz_chroma[comp][(cby4 - 1) * st.cblk_w + cbx4] as i32
    } else {
        -1
    };
    combine_nc(na, nb)
}

/// クロマ復号（4:2:0）。予測 + 残差（DC: 2x2 Hadamard、AC: cbp_chroma==2 のとき）。
fn decode_chroma<R: MbSyntax>(
    r: &mut R,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    cbp_chroma: u32,
    chroma_pred_mode: u8,
    qp_y: i32,
    chroma_qp_offset: [i32; 2],
) -> Result<(), &'static str> {
    let cw = (st.yuv.width / 2) as usize;
    let cmb_x = (mb_x / 2) as usize;
    let cmb_y = (mb_y / 2) as usize;
    let cbx0 = cmb_x / 4;
    let cby0 = cmb_y / 4;
    let qpcs = [chroma_qp(qp_y, chroma_qp_offset[0]), chroma_qp(qp_y, chroma_qp_offset[1])];

    // 各成分の DC（2x2）と AC（4 ブロック）を読む。
    // 残差は raster 順: 成分0(Cb) DC, 成分1(Cr) DC, 次に AC（cbp_chroma==2）。
    let mut dc = [[0i32; 4]; 2];
    if cbp_chroma != 0 {
        for comp in 0..2 {
            let (scan, _) = r.residual(st, ResBlock::ChromaDc { comp, mb_x, mb_y })?;
            // chroma DC スキャン順は raster（2x2）そのまま
            let raw = [scan[0], scan[1], scan[2], scan[3]];
            let f = inverse_hadamard_2x2(raw);
            for i in 0..4 {
                dc[comp][i] = scale_chroma_dc(f[i], qpcs[comp]);
            }
        }
    }
    let mut ac = [[[0i32; 16]; 4]; 2]; // [comp][block][coeff(raster)]
    if cbp_chroma == 2 {
        for comp in 0..2 {
            for blk in 0..4 {
                let bx = (blk % 2) * 4;
                let by = (blk / 2) * 4;
                let cbx4 = cbx0 + bx / 4;
                let cby4 = cby0 + by / 4;
                let (scan, tc) = r.residual(st, ResBlock::ChromaAc { comp, cbx4, cby4 })?;
                for k in 0..15 {
                    ac[comp][blk][ZIGZAG_4X4[k + 1]] = scan[k];
                }
                st.nnz_chroma[comp][cby4 * st.cblk_w + cbx4] = tc;
            }
        }
    }

    // 予測 + 再構成（成分ごと）。
    let ca_t = st.avail_px(cmb_x as isize * 2, cmb_y as isize * 2 - 1);
    let ca_l = st.avail_px(cmb_x as isize * 2 - 1, cmb_y as isize * 2);
    for comp in 0..2 {
        let plane: &mut Vec<u8> = if comp == 0 {
            &mut st.yuv.u
        } else {
            &mut st.yuv.v
        };
        let mut ct = [0i32; 8];
        let mut cl = [0i32; 8];
        if ca_t {
            for x in 0..8 {
                ct[x] = plane[(cmb_y - 1) * cw + cmb_x + x] as i32;
            }
        }
        if ca_l {
            for y in 0..8 {
                cl[y] = plane[(cmb_y + y) * cw + cmb_x - 1] as i32;
            }
        }
        let corner = if ca_t && ca_l {
            plane[(cmb_y - 1) * cw + cmb_x - 1] as i32
        } else {
            0
        };
        let cpred = intra_chroma_predict(chroma_pred_mode, &ct, corner, &cl, ca_t, ca_l);

        for blk in 0..4 {
            let bx = (blk % 2) * 4;
            let by = (blk / 2) * 4;
            let mut block = ac[comp][blk];
            dequant_4x4(&mut block, qpcs[comp]);
            block[0] = dc[comp][blk]; // DC は別経路
            inverse_transform_4x4(&mut block);
            for yy in 0..4 {
                for xx in 0..4 {
                    let px = cmb_x + bx + xx;
                    let py = cmb_y + by + yy;
                    let p = cpred[(by + yy) * 8 + (bx + xx)];
                    plane[py * cw + px] = clip1(p + block[yy * 4 + xx]) as u8;
                }
            }
        }
    }
    Ok(())
}

// ===================== デブロッキングフィルタ =====================

fn iclip(v: i32, lo: i32, hi: i32) -> i32 {
    v.clamp(lo, hi)
}

/// indexA/indexB から (alpha, beta, tc0) を引く。
fn deblock_thresh(qpav: i32, alpha_off: i32, beta_off: i32, bs: u8) -> (i32, i32, i32) {
    let ia = iclip(qpav + alpha_off, 0, 51) as usize;
    let ib = iclip(qpav + beta_off, 0, 51) as usize;
    // bS=4 は強フィルタで tc0 を使わない（TC0_TABLE は bS=1..3 のみ）。
    let tc0 = if (1..=3).contains(&bs) {
        TC0_TABLE[ia][(bs - 1) as usize] as i32
    } else {
        0
    };
    (ALPHA_TABLE[ia] as i32, BETA_TABLE[ib] as i32, tc0)
}

/// 輝度 1 エッジ（長さ len）をフィルタ。vert: 垂直エッジ。(ex,ey)=q 側左上（フレーム座標）。
#[allow(clippy::too_many_arguments)]
fn deblock_luma_edge(
    plane: &mut [u8],
    w: usize,
    vert: bool,
    ex: usize,
    ey: usize,
    len: usize,
    bs: u8,
    alpha: i32,
    beta: i32,
    tc0: i32,
) {
    if bs == 0 || alpha == 0 {
        return;
    }
    let across: isize = if vert { 1 } else { w as isize };
    for i in 0..len {
        let p0i: isize = if vert {
            ((ey + i) * w + (ex - 1)) as isize
        } else {
            ((ey - 1) * w + (ex + i)) as isize
        };
        let idx = |o: isize| -> usize { (p0i + o * across) as usize };
        let p0 = plane[idx(0)] as i32;
        let p1 = plane[idx(-1)] as i32;
        let p2 = plane[idx(-2)] as i32;
        let p3 = plane[idx(-3)] as i32;
        let q0 = plane[idx(1)] as i32;
        let q1 = plane[idx(2)] as i32;
        let q2 = plane[idx(3)] as i32;
        if (p0 - q0).abs() >= alpha || (p1 - p0).abs() >= beta || (q1 - q0).abs() >= beta {
            continue;
        }
        let ap = (p2 - p0).abs();
        let aq = (q2 - q0).abs();
        if bs < 4 {
            let mut tc = tc0;
            if ap < beta {
                tc += 1;
            }
            if aq < beta {
                tc += 1;
            }
            let delta = iclip(((q0 - p0) * 4 + (p1 - q1) + 4) >> 3, -tc, tc);
            plane[idx(0)] = clip1(p0 + delta) as u8;
            plane[idx(1)] = clip1(q0 - delta) as u8;
            if ap < beta {
                let d = iclip((p2 + ((p0 + q0 + 1) >> 1) - 2 * p1) >> 1, -tc0, tc0);
                plane[idx(-1)] = clip1(p1 + d) as u8;
            }
            if aq < beta {
                let d = iclip((q2 + ((p0 + q0 + 1) >> 1) - 2 * q1) >> 1, -tc0, tc0);
                plane[idx(2)] = clip1(q1 + d) as u8;
            }
        } else {
            let strong = (p0 - q0).abs() < (alpha >> 2) + 2;
            if ap < beta && strong {
                plane[idx(0)] = clip1((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3) as u8;
                plane[idx(-1)] = clip1((p2 + p1 + p0 + q0 + 2) >> 2) as u8;
                plane[idx(-2)] = clip1((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3) as u8;
            } else {
                plane[idx(0)] = clip1((2 * p1 + p0 + q1 + 2) >> 2) as u8;
            }
            if aq < beta && strong {
                let q3 = plane[idx(4)] as i32;
                plane[idx(1)] = clip1((q2 + 2 * q1 + 2 * q0 + 2 * p0 + p1 + 4) >> 3) as u8;
                plane[idx(2)] = clip1((q2 + q1 + q0 + p0 + 2) >> 2) as u8;
                plane[idx(3)] = clip1((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3) as u8;
            } else {
                plane[idx(1)] = clip1((2 * q1 + q0 + p1 + 2) >> 2) as u8;
            }
        }
    }
}

/// クロマ 1 エッジ（4:2:0、p0/q0 のみ修正）。
#[allow(clippy::too_many_arguments)]
fn deblock_chroma_edge(
    plane: &mut [u8],
    cw: usize,
    vert: bool,
    ex: usize,
    ey: usize,
    len: usize,
    bs: u8,
    alpha: i32,
    beta: i32,
    tc0: i32,
) {
    if bs == 0 || alpha == 0 {
        return;
    }
    let across: isize = if vert { 1 } else { cw as isize };
    for i in 0..len {
        let p0i: isize = if vert {
            ((ey + i) * cw + (ex - 1)) as isize
        } else {
            ((ey - 1) * cw + (ex + i)) as isize
        };
        let idx = |o: isize| -> usize { (p0i + o * across) as usize };
        let p0 = plane[idx(0)] as i32;
        let p1 = plane[idx(-1)] as i32;
        let q0 = plane[idx(1)] as i32;
        let q1 = plane[idx(2)] as i32;
        if (p0 - q0).abs() >= alpha || (p1 - p0).abs() >= beta || (q1 - q0).abs() >= beta {
            continue;
        }
        if bs < 4 {
            let tc = tc0 + 1;
            let delta = iclip(((q0 - p0) * 4 + (p1 - q1) + 4) >> 3, -tc, tc);
            plane[idx(0)] = clip1(p0 + delta) as u8;
            plane[idx(1)] = clip1(q0 - delta) as u8;
        } else {
            plane[idx(0)] = clip1((2 * p1 + p0 + q1 + 2) >> 2) as u8;
            plane[idx(1)] = clip1((2 * q1 + q0 + p1 + 2) >> 2) as u8;
        }
    }
}

/// フレーム全体にデブロッキングを適用（I スライス: MB 境界 bS=4、内部 bS=3）。
/// 2 つの 4x4 ブロック間の境界強度（8.7.2.1）。I/P 両対応。
/// p_li/q_li: 輝度 4x4 ブロックの線形 index。is_mb_edge: MB 境界エッジか。
fn boundary_strength(st: &DecState, p_li: usize, q_li: usize, is_mb_edge: bool) -> u8 {
    let p_intra = !st.is_inter[p_li];
    let q_intra = !st.is_inter[q_li];
    if p_intra || q_intra {
        return if is_mb_edge { 4 } else { 3 };
    }
    if st.has_coeffs(p_li) || st.has_coeffs(q_li) {
        return 2;
    }
    // 参照ピクチャ（refIdx ではなくピクチャそのもの）や MV の本数が違えば 1。同じなら、
    // 同じ参照ピクチャどうしの MV の差が 4（1 画素）以上で 1（8.7.2.1）。
    let far = |m: [i16; 2], n: [i16; 2]| (m[0] - n[0]).abs() >= 4 || (m[1] - n[1]).abs() >= 4;
    let used = |li: usize| [st.refi[0][li] >= 0, st.refi[1][li] >= 0];
    let (pu, qu) = (used(p_li), used(q_li));
    let pn = pu.iter().filter(|&&u| u).count();
    let qn = qu.iter().filter(|&&u| u).count();
    if pn != qn {
        return 1;
    }
    if pn == 1 {
        let pl = if pu[0] { 0 } else { 1 };
        let ql = if qu[0] { 0 } else { 1 };
        if st.refp[pl][p_li] != st.refp[ql][q_li] {
            return 1;
        }
        return far(st.mv[pl][p_li], st.mv[ql][q_li]) as u8;
    }
    let (p0, p1) = (st.refp[0][p_li], st.refp[1][p_li]);
    let (q0, q1) = (st.refp[0][q_li], st.refp[1][q_li]);
    if !((p0 == q0 && p1 == q1) || (p0 == q1 && p1 == q0)) {
        return 1;
    }
    let (pm0, pm1) = (st.mv[0][p_li], st.mv[1][p_li]);
    let (qm0, qm1) = (st.mv[0][q_li], st.mv[1][q_li]);
    let straight = far(pm0, qm0) || far(pm1, qm1);
    let crossed = far(pm0, qm1) || far(pm1, qm0);
    let bs = if p0 != p1 {
        // 2 枚の別々の参照ピクチャ: 同じピクチャどうしを比べる。
        if p0 == q0 { straight } else { crossed }
    } else {
        // 同じピクチャを 2 回: どちらの組み合わせでも離れているときだけ 1。
        straight && crossed
    };
    bs as u8
}

fn deblock_frame(st: &mut DecState, mb_w: usize, mb_h: usize, chroma_qp_off: [i32; 2]) {
    let w = st.yuv.width as usize;
    let cw = (st.yuv.width / 2) as usize;
    let blk_w = st.blk_w;
    for mby in 0..mb_h {
        for mbx in 0..mb_w {
            // デブロック設定はこの MB の所属スライスのもの（8.7）。idc=1 はこの MB を飛ばし、
            // idc=2 は別スライスとの境界（左・上の MB エッジ）を飛ばす。
            let mb_idx = mby * mb_w + mbx;
            let MbDeblock { disable_idc, alpha_off, beta_off } = st.mb_db[mb_idx];
            if disable_idc == 1 {
                continue;
            }
            let same_slice = |other: usize| disable_idc != 2 || st.mb_slice[other] == st.mb_slice[mb_idx];
            let filter_left = mbx > 0 && same_slice(mb_idx - 1);
            let filter_top = mby > 0 && same_slice(mb_idx - mb_w);
            let qp = st.mb_qp[mby * mb_w + mbx];
            let qp_left = if mbx > 0 {
                st.mb_qp[mby * mb_w + mbx - 1]
            } else {
                qp
            };
            let qp_top = if mby > 0 {
                st.mb_qp[(mby - 1) * mb_w + mbx]
            } else {
                qp
            };
            let qbx = mbx * 4; // この MB の左上 4x4 ブロック座標
            let qby = mby * 4;

            // 8x8 変換の MB は輝度の 4x4 の内側エッジ（4, 12）を飛ばす（8.7）。
            let t8 = st.mb_t8[mb_idx];
            // 輝度 垂直エッジ（xe=0,4,8,12）: 4 行セグメントごとに bS。
            for k in 0..4usize {
                if t8 && k % 2 == 1 {
                    continue;
                }
                let xe = k * 4;
                if xe == 0 && !filter_left {
                    continue;
                }
                let is_mb_edge = xe == 0;
                let qp2 = if is_mb_edge { qp_left } else { qp };
                let qpav = (qp + qp2 + 1) >> 1;
                for seg in 0..4usize {
                    let qx = qbx + k;
                    let qy = qby + seg;
                    let q_li = qy * blk_w + qx;
                    let p_li = qy * blk_w + qx - 1;
                    let bs = boundary_strength(st, p_li, q_li, is_mb_edge);
                    if bs == 0 {
                        continue;
                    }
                    let (a, b, t) = deblock_thresh(qpav, alpha_off, beta_off, bs);
                    deblock_luma_edge(
                        &mut st.yuv.y,
                        w,
                        true,
                        mbx * 16 + xe,
                        mby * 16 + seg * 4,
                        4,
                        bs,
                        a,
                        b,
                        t,
                    );
                }
            }
            // 輝度 水平エッジ（ye=0,4,8,12）
            for k in 0..4usize {
                if t8 && k % 2 == 1 {
                    continue;
                }
                let ye = k * 4;
                if ye == 0 && !filter_top {
                    continue;
                }
                let is_mb_edge = ye == 0;
                let qp2 = if is_mb_edge { qp_top } else { qp };
                let qpav = (qp + qp2 + 1) >> 1;
                for seg in 0..4usize {
                    let qx = qbx + seg;
                    let qy = qby + k;
                    let q_li = qy * blk_w + qx;
                    let p_li = (qy - 1) * blk_w + qx;
                    let bs = boundary_strength(st, p_li, q_li, is_mb_edge);
                    if bs == 0 {
                        continue;
                    }
                    let (a, b, t) = deblock_thresh(qpav, alpha_off, beta_off, bs);
                    deblock_luma_edge(
                        &mut st.yuv.y,
                        w,
                        false,
                        mbx * 16 + seg * 4,
                        mby * 16 + ye,
                        4,
                        bs,
                        a,
                        b,
                        t,
                    );
                }
            }
            // クロマ: 輝度 x=0,8（垂直）/ y=0,8（水平）の bS を流用。クロマ 2 行/列セグメント。
            for comp in 0..2usize {
                // Cb と Cr で QP オフセットが違いうる（High の second_chroma_qp_index_offset）。
                let qpc = chroma_qp(qp, chroma_qp_off[comp]);
                let qpc_left = chroma_qp(qp_left, chroma_qp_off[comp]);
                let qpc_top = chroma_qp(qp_top, chroma_qp_off[comp]);
                // 垂直エッジ cxe=0,4（輝度 luma_xe=0,8）
                for ck in 0..2usize {
                    let cxe = ck * 4;
                    let luma_k = ck * 2; // 輝度ブロック列オフセット（0 or 2）
                    if cxe == 0 && !filter_left {
                        continue;
                    }
                    let is_mb_edge = cxe == 0;
                    let qpav = (qpc + if is_mb_edge { qpc_left } else { qpc } + 1) >> 1;
                    for seg in 0..4usize {
                        let qx = qbx + luma_k;
                        let qy = qby + seg;
                        let q_li = qy * blk_w + qx;
                        let p_li = qy * blk_w + qx - 1;
                        let bs = boundary_strength(st, p_li, q_li, is_mb_edge);
                        if bs == 0 {
                            continue;
                        }
                        let (a, b, t) = deblock_thresh(qpav, alpha_off, beta_off, bs);
                        let plane = if comp == 0 {
                            &mut st.yuv.u
                        } else {
                            &mut st.yuv.v
                        };
                        deblock_chroma_edge(
                            plane,
                            cw,
                            true,
                            mbx * 8 + cxe,
                            mby * 8 + seg * 2,
                            2,
                            bs,
                            a,
                            b,
                            t,
                        );
                    }
                }
                // 水平エッジ cye=0,4（輝度 luma_ye=0,8）
                for ck in 0..2usize {
                    let cye = ck * 4;
                    let luma_k = ck * 2;
                    if cye == 0 && !filter_top {
                        continue;
                    }
                    let is_mb_edge = cye == 0;
                    let qpav = ((qpc + if is_mb_edge { qpc_top } else { qpc }) + 1) >> 1;
                    for seg in 0..4usize {
                        let qx = qbx + seg;
                        let qy = qby + luma_k;
                        let q_li = qy * blk_w + qx;
                        let p_li = (qy - 1) * blk_w + qx;
                        let bs = boundary_strength(st, p_li, q_li, is_mb_edge);
                        if bs == 0 {
                            continue;
                        }
                        let (a, b, t) = deblock_thresh(qpav, alpha_off, beta_off, bs);
                        let plane = if comp == 0 {
                            &mut st.yuv.u
                        } else {
                            &mut st.yuv.v
                        };
                        deblock_chroma_edge(
                            plane,
                            cw,
                            false,
                            mbx * 8 + seg * 2,
                            mby * 8 + cye,
                            2,
                            bs,
                            a,
                            b,
                            t,
                        );
                    }
                }
            }
        }
    }
}

// ===================== テーブル健全性チェック =====================

/// (len, code) 群が prefix-free か検査。衝突する組を見つけたら false。
fn is_prefix_free(entries: &[(u8, u16)], label: &str) -> bool {
    let mut ok = true;
    for i in 0..entries.len() {
        for j in 0..entries.len() {
            if i == j {
                continue;
            }
            let (la, ca) = entries[i];
            let (lb, cb) = entries[j];
            if la <= lb && (cb >> (lb - la)) == ca {
                crate::println!(
                    "  PREFIX-CONFLICT in {}: ({},{:b}) is prefix of ({},{:b})",
                    label,
                    la,
                    ca,
                    lb,
                    cb
                );
                ok = false;
            }
        }
    }
    ok
}

/// coeff_token テーブルに有効な (tc, t1) 組が漏れなく 1 回ずつあるか検査。
/// max_tc までの全組（tc=0:(0,0)、tc>=1: t1=0..min(tc,3)）を期待。
fn check_token_complete(t: &[TokEntry], max_tc: u8, label: &str) -> bool {
    let mut ok = true;
    for tc in 0..=max_tc {
        let max_t1 = if tc == 0 { 0 } else { tc.min(3) };
        for t1 in 0..=max_t1 {
            let count = t.iter().filter(|&&(_, _, c, o)| c == tc && o == t1).count();
            if count != 1 {
                crate::println!(
                    "  TOKEN {} ({},{}) appears {} times (want 1)",
                    label,
                    tc,
                    t1,
                    count
                );
                ok = false;
            }
        }
    }
    ok
}

/// 全 CAVLC VLC テーブルの prefix-free 性 + coeff_token の完全性を検査。
pub fn tables_selftest() {
    let mut ok = true;
    let toks: [(&str, &[TokEntry]); 4] = [
        ("coeff_token_0", COEFF_TOKEN_0),
        ("coeff_token_2", COEFF_TOKEN_2),
        ("coeff_token_4", COEFF_TOKEN_4),
        ("coeff_token_cdc", COEFF_TOKEN_CHROMA_DC),
    ];
    for (name, t) in toks {
        let e: Vec<(u8, u16)> = t.iter().map(|&(l, c, _, _)| (l, c)).collect();
        if !is_prefix_free(&e, name) {
            ok = false;
        }
    }
    if !check_token_complete(COEFF_TOKEN_0, 16, "tok0") {
        ok = false;
    }
    if !check_token_complete(COEFF_TOKEN_2, 16, "tok2") {
        ok = false;
    }
    if !check_token_complete(COEFF_TOKEN_4, 16, "tok4") {
        ok = false;
    }
    if !check_token_complete(COEFF_TOKEN_CHROMA_DC, 4, "tokCDC") {
        ok = false;
    }
    // total_zeros の行 tc は total_zeros=0..(16-tc) の 17-tc エントリを持つはず。
    for (i, row) in TOTAL_ZEROS_16.iter().enumerate() {
        let tc = i + 1;
        if row.len() != 17 - tc {
            crate::println!(
                "  TZ16 row tc={} has {} entries (want {})",
                tc,
                row.len(),
                17 - tc
            );
            ok = false;
        }
    }
    for (i, row) in TOTAL_ZEROS_16.iter().enumerate() {
        if !is_prefix_free(row, "tz16") {
            crate::println!("   (tz16 row tc={})", i + 1);
            ok = false;
        }
    }
    for row in TOTAL_ZEROS_CHROMA.iter() {
        if !is_prefix_free(row, "tzC") {
            ok = false;
        }
    }
    for row in RUN_BEFORE.iter() {
        if !is_prefix_free(row, "run_before") {
            ok = false;
        }
    }
    // 正常時は無音（バッファ節約）。コンフリクト時のみ出す。
    if !ok {
        crate::println!("H264_TABLES: CONFLICTS FOUND");
    }
}

// ===================== ゴールデンテスト =====================

/// ゴールデン素材 1 本をデコードし、Y 面の一致画素数を返す。
fn run_golden(
    clip: &[u8],
    ref_yuv: &[u8],
) -> Result<(usize, usize, usize, usize, usize), &'static str> {
    let nals = split_annexb(clip);
    let mut sps: Option<Sps> = None;
    let mut pps: Option<Pps> = None;
    let mut reference: Option<DecodedYuv> = None;
    for nu in &nals {
        match nu.unit_type {
            7 => {
                sps = Some(parse_sps(&nu.rbsp)?);
            }
            8 => {
                pps = Some(parse_pps(&nu.rbsp)?);
            }
            1 | 5 => {
                let s = sps.as_ref().ok_or("no SPS")?;
                let p = pps.as_ref().ok_or("no PPS")?;
                let frame = decode_slice(s, p, &nu.rbsp, nu.unit_type == 5, reference.as_ref())?;
                reference = Some(frame);
            }
            _ => {}
        }
    }
    let yuv = reference.ok_or("no slice decoded")?;
    let yn = (yuv.width * yuv.height) as usize;
    let cn = yuv.u.len();
    // ref_yuv が複数フレームのとき、デコード結果は最後のフレーム。最後のフレームと比較。
    let fsize = yn + 2 * cn;
    let nframes = ref_yuv.len() / fsize;
    let off = (nframes.saturating_sub(1)) * fsize;
    let mut ym = 0;
    for i in 0..yn {
        if yuv.y[i] == ref_yuv[off + i] {
            ym += 1;
        }
    }
    let mut um = 0;
    for i in 0..cn {
        if yuv.u[i] == ref_yuv[off + yn + i] {
            um += 1;
        }
    }
    let mut vm = 0;
    for i in 0..cn {
        if yuv.v[i] == ref_yuv[off + yn + cn + i] {
            vm += 1;
        }
    }
    Ok((ym, um, vm, yn, cn))
}

/// 不一致を 16x16 MB 単位で集計してデバッグ出力（複数フレーム対応、最後のフレームを比較）。
fn run_golden_debug(clip: &[u8], ref_yuv: &[u8]) {
    let nals = split_annexb(clip);
    let mut sps: Option<Sps> = None;
    let mut pps: Option<Pps> = None;
    let mut reference: Option<DecodedYuv> = None;
    for nu in &nals {
        match nu.unit_type {
            7 => sps = parse_sps(&nu.rbsp).ok(),
            8 => pps = parse_pps(&nu.rbsp).ok(),
            1 | 5 => {
                if let (Some(s), Some(p)) = (sps.as_ref(), pps.as_ref()) {
                    if let Ok(f) =
                        decode_slice(s, p, &nu.rbsp, nu.unit_type == 5, reference.as_ref())
                    {
                        reference = Some(f);
                    }
                }
            }
            _ => {}
        }
    }
    if let Some(yuv) = reference {
        let w = yuv.width as usize;
        let h = yuv.height as usize;
        let fsize = w * h + 2 * yuv.u.len();
        let off = (ref_yuv.len() / fsize).saturating_sub(1) * fsize;
        let mut shown = 0;
        'outer: for mby in (0..h).step_by(16) {
            for mbx in (0..w).step_by(16) {
                let mut bad = 0;
                let mut first = (0u8, 0u8, 0usize, 0usize);
                for yy in 0..16 {
                    for xx in 0..16 {
                        let i = (mby + yy) * w + mbx + xx;
                        if yuv.y[i] != ref_yuv[off + i] {
                            if bad == 0 {
                                first = (yuv.y[i], ref_yuv[off + i], mbx + xx, mby + yy);
                            }
                            bad += 1;
                        }
                    }
                }
                if bad > 0 {
                    crate::println!(
                        "  MB({},{}) bad={}/256 first@({},{}) got={} exp={}",
                        mbx,
                        mby,
                        bad,
                        first.2,
                        first.3,
                        first.0,
                        first.1
                    );
                    shown += 1;
                    if shown >= 8 {
                        break 'outer;
                    }
                }
            }
        }
    }
}

/// 起動時に呼ぶゴールデン検証。結果をログ出力する。
pub fn golden_test() -> bool {
    use super::h264_golden::*;
    tables_selftest();
    let mut pass = 0usize;
    let mut total = 0usize;
    for (name, clip, refy) in [
        ("flat", FLAT_H264.as_slice(), FLAT_YUV.as_slice()),
        ("clip", CLIP_H264.as_slice(), CLIP_YUV.as_slice()),
        ("big", BIG_H264.as_slice(), BIG_YUV.as_slice()),
        ("dbclip", DBCLIP_H264.as_slice(), DBCLIP_YUV.as_slice()),
        ("dbbig", DBBIG_H264.as_slice(), DBBIG_YUV.as_slice()),
        ("pskip", PSKIP_H264.as_slice(), PSKIP_YUV.as_slice()),
        ("pint16", PINT16_H264.as_slice(), PINT16_YUV.as_slice()),
        ("psub", PSUB_H264.as_slice(), PSUB_YUV.as_slice()),
        ("ppart", PPART_H264.as_slice(), PPART_YUV.as_slice()),
        ("dbp", DBP_H264.as_slice(), DBP_YUV.as_slice()),
    ] {
        match run_golden(clip, refy) {
            Ok((ym, um, vm, yn, cn)) => {
                total += 1;
                if ym == yn && um == cn && vm == cn {
                    pass += 1;
                } else {
                    // 不一致のケースだけ詳細を出す（バッファを食わないため正常時は無音）。
                    crate::println!(
                        "H264_GOLDEN {}: MISMATCH Y {}/{} U {}/{} V {}/{}",
                        name,
                        ym,
                        yn,
                        um,
                        cn,
                        vm,
                        cn
                    );
                    if ym != yn {
                        run_golden_debug(clip, refy);
                    }
                }
            }
            Err(e) => {
                total += 1;
                crate::println!("H264_GOLDEN {}: ERROR {}", name, e);
            }
        }
    }
    // テスト詳細はサイレントモードで実行されるため、mismatch時以外は出力されない
    crate::info!("[H264] Golden test pass: {}/{}", pass, total);
    pass == total
}