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

/// MP4/AVCC 経路用のステートフルなビデオデコーダ。参照フレームを保持して P を復号する。
pub struct VideoDecoder {
    sps: Option<Sps>,
    pps: Option<Pps>,
    length_size: usize,
    reference: Option<DecodedYuv>,
}

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

impl VideoDecoder {
    pub fn new() -> Self {
        Self {
            sps: None,
            pps: None,
            length_size: 4,
            reference: None,
        }
    }

    /// 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);
        let mut out = None;
        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 => {
                    let (s, p) = match (self.sps.clone(), self.pps.clone()) {
                        (Some(s), Some(p)) => (s, p),
                        _ => continue,
                    };
                    if let Ok(frame) =
                        decode_slice(&s, &p, &nu.rbsp, nu.unit_type == 5, self.reference.as_ref())
                    {
                        out = Some((frame.width, frame.height, yuv_to_rgb(&frame)));
                        self.reference = Some(frame);
                    }
                }
                _ => {}
            }
        }
        out
    }
}

/// デコーダ状態。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_l0: Vec<[i16; 2]>,     // 各輝度 4x4 ブロックの動きベクトル（1/4 画素単位、P 用）
    is_inter: Vec<bool>,      // 各輝度 4x4 ブロックがインター予測か（MV 予測・デブロック用）
    blk_h: usize,             // 輝度 4x4 ブロック数（縦）
}

/// 近傍 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 ブロック (bx4,by4) の nC（左/上ブロックの nnz から）。
    fn luma_nc(&self, bx4: usize, by4: usize) -> i32 {
        let na = if bx4 > 0 {
            self.nnz_luma[self.li(bx4 - 1, by4)] as i32
        } else {
            -1
        };
        let nb = if by4 > 0 {
            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 bx4 == 0 || by4 == 0 {
            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 = py > 0;
        let left_avail = px > 0;
        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)];
            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> {
    if pps.entropy_coding_mode_flag != 0 {
        return Err("CABAC not supported");
    }
    // 不正/巨大 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_l0: alloc::vec![[0i16; 2]; blk_w * blk_h],
        is_inter: alloc::vec![false; blk_w * blk_h],
        blk_h,
    };

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

    // ---- スライスヘッダ ----
    let _first_mb_in_slice = r.read_ue();
    let slice_type = r.read_ue();
    let is_i = slice_type % 5 == 2 || slice_type % 5 == 4;
    let is_p = slice_type.is_multiple_of(5);
    if !is_i && !is_p {
        return Err("only I/P slices supported");
    }
    if is_p {
        // P スライスの場合、事前に参照フレーム（reference）が存在し、
        // かつ解像度が一致していることを安全に検証し、パニックを防止します。
        match reference {
            None => return Err("P slice without reference frame"),
            Some(r) if r.width != width || r.height != height => {
                return Err("reference dimension mismatch")
            }
            _ => {}
        }
    }
    let _pps_id = r.read_ue();
    let _frame_num = r.read_bits(sps.log2_max_frame_num);
    if is_idr {
        let _idr_pic_id = r.read_ue();
    }
    if sps.pic_order_cnt_type == 0 {
        let _pic_order_cnt_lsb = r.read_bits(sps.log2_max_pic_order_cnt_lsb);
        if pps.bottom_field_pic_order_in_frame_present_flag != 0 {
            let _delta = r.read_se();
        }
    }
    if pps.redundant_pic_cnt_present_flag != 0 {
        let _redundant_pic_cnt = r.read_ue();
    }
    // P スライス: 参照リスト関連
    if is_p {
        let num_ref_idx_override = r.read_bit();
        if num_ref_idx_override == 1 {
            let _num_ref_idx_l0_active_minus1 = r.read_ue();
        }
        // ref_pic_list_modification（truncated データでの無限ループ防止に上限付き）。
        if r.read_bit() == 1 {
            for _ in 0..64 {
                let idc = r.read_ue();
                if idc == 3 || r.is_eof() {
                    break;
                }
                let _ = r.read_ue();
            }
        }
    }
    // dec_ref_pic_marking
    if is_idr {
        let _no_output_of_prior_pics = r.read_bit();
        let _long_term_reference = r.read_bit();
    } else {
        let adaptive = r.read_bit();
        if adaptive == 1 {
            for _ in 0..64 {
                let mmco = r.read_ue();
                if mmco == 0 || r.is_eof() {
                    break;
                }
                if mmco == 1 || mmco == 3 {
                    let _ = r.read_ue();
                }
                if mmco == 2 {
                    let _ = r.read_ue();
                }
                if mmco == 3 || mmco == 6 {
                    let _ = r.read_ue();
                }
                if mmco == 4 {
                    let _ = r.read_ue();
                }
            }
        }
    }
    let slice_qp_delta = r.read_se();
    let slice_qp = pps.pic_init_qp + slice_qp_delta;
    let mut disable_deblock_idc = 0u32;
    let mut alpha_off = 0i32;
    let mut beta_off = 0i32;
    if pps.deblocking_filter_control_present_flag != 0 {
        disable_deblock_idc = r.read_ue();
        if disable_deblock_idc != 1 {
            alpha_off = r.read_se() * 2;
            beta_off = r.read_se() * 2;
        }
    }

    // ---- マクロブロック ----
    let mb_w = sps.width_mbs;
    let mb_h = sps.height_mbs;
    let total_mb = (mb_w * mb_h) as usize;
    let mut qp = slice_qp;

    if is_i {
        for mb_idx in 0..total_mb {
            let mb_x = (mb_idx as u32 % mb_w) * 16;
            let mb_y = (mb_idx as u32 / mb_w) * 16;
            if let Err(e) = decode_mb(&mut r, &mut st, mb_x, mb_y, &mut qp, pps) {
                crate::println!(
                    "  H264 decode stopped at mb {} (of {}): {}",
                    mb_idx,
                    total_mb,
                    e
                );
                return Err(e);
            }
        }
    } else {
        // P スライス: mb_skip_run で連続スキップ、その後 1 つの符号化 MB。
        // アンラップを安全な ok_or と ? 演算子に置き換え、参照フレーム不足時に早期エラー返却します。
        let refr = reference.ok_or("P slice without reference frame")?;
        let mut mb_idx = 0usize;
        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;
                decode_pskip(&mut st, mb_x, mb_y, qp, refr);
                mb_idx += 1;
            }
            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;
            if let Err(e) = decode_mb_p(&mut r, &mut st, mb_x, mb_y, &mut qp, pps, refr) {
                crate::println!(
                    "  H264 P decode stopped at mb {} (of {}): {}",
                    mb_idx,
                    total_mb,
                    e
                );
                return Err(e);
            }
            mb_idx += 1;
        }
    }

    // ---- デブロッキングフィルタ（disable_idc != 1 のとき）----
    if disable_deblock_idc != 1 {
        deblock_frame(
            &mut st,
            mb_w as usize,
            mb_h as usize,
            alpha_off,
            beta_off,
            pps.chroma_qp_index_offset,
        );
    }

    Ok(st.yuv)
}

#[allow(clippy::too_many_arguments)]
fn decode_mb(
    r: &mut BitReader,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
) -> Result<(), &'static str> {
    let mb_type = r.read_ue();
    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: &mut BitReader,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
) -> Result<(), &'static str> {
    r.byte_align();
    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] = r.read_bits(8) as u8;
        }
    }
    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] = r.read_bits(8) as u8;
        }
    }
    for by in 0..8 {
        for bx in 0..8 {
            st.yuv.v[(cmy + by) * cw + cmx + bx] = r.read_bits(8) as u8;
        }
    }
    // 近傍情報: 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_l0[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 = mb_x > 0;
    let b_avail = mb_y > 0;
    if !a_avail || !b_avail {
        return [0, 0];
    }
    let mva = st.mv_l0[by0 * st.blk_w + bx0 - 1];
    let mvb = st.mv_l0[(by0 - 1) * st.blk_w + bx0];
    // refIdx は単一参照で 0 前提。いずれかが zero-MV なら 0。
    if mva == [0, 0] || mvb == [0, 0] {
        return [0, 0];
    }
    let _ = (bx0, by0);
    mv_predict(st, mb_x as usize, mb_y as usize, 16, MvDir::None)
}

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

/// パーティションの MV をグリッドへ格納（後続パーティション/MB の予測用）。
fn store_part_mv(st: &mut DecState, px: usize, py: usize, pw: usize, ph: usize, mv: [i16; 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;
            st.mv_l0[li] = mv;
            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（左上）で代用。
fn part_neighbors(
    st: &DecState,
    px: usize,
    py: usize,
    pw: usize,
) -> ((bool, [i16; 2]), (bool, [i16; 2]), (bool, [i16; 2])) {
    let bx0 = (px / 4) as i32;
    let by0 = (py / 4) as i32;
    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_l0[li]);
                }
                return (true, false, [0, 0]);
            }
        }
        (false, false, [0, 0])
    };
    let (_a, am, mva) = getn(bx0 - 1, by0);
    let (_b, bm, mvb) = getn(bx0, by0 - 1);
    let (cav, cm0, mvc0) = getn(bx0 + (pw / 4) as i32, by0 - 1);
    let (mut cm, mut mvc) = (cm0, mvc0);
    if !cav {
        let (_d, dm, mvd) = getn(bx0 - 1, by0 - 1);
        cm = dm;
        mvc = mvd;
    }
    ((am, mva), (bm, mvb), (cm, mvc))
}

/// パーティションの MV 予測（8.4.1.3、単一参照 refIdx=0、方向ヒント対応）。
fn mv_predict(st: &DecState, px: usize, py: usize, pw: usize, dir: MvDir) -> [i16; 2] {
    let ((am, mva), (bm, mvb), (cm, mvc)) = part_neighbors(st, px, py, pw);
    match dir {
        MvDir::A if am => return mva,
        MvDir::B if bm => return mvb,
        MvDir::C if cm => return mvc,
        _ => {}
    }
    // mbB と mbC が画面位置として不可用で mbA 可用なら mvp=mvA。
    let bx0 = (px / 4) as i32;
    let b_pic = (py / 4) > 0;
    let c_pic = (py / 4) > 0 && ((bx0 + (pw / 4) as i32) < st.blk_w as i32 || (px / 4) > 0);
    if !b_pic && !c_pic && (px / 4) > 0 {
        return mva;
    }
    let matches = am as i32 + bm as i32 + cm as i32;
    if matches == 1 {
        if am {
            return mva;
        }
        if bm {
            return mvb;
        }
        return mvc;
    }
    [
        median3(mva[0], mvb[0], mvc[0]),
        median3(mva[1], mvb[1], mvc[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_l0[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, refr: &DecodedYuv) {
    let mv = predict_pskip_mv(st, mb_x, mb_y);
    let (px, py) = (mb_x as usize, mb_y as usize);
    mc_part(st, px, py, 16, 16, mv, refr);
    store_part_mv(st, px, py, 16, 16, mv);
    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: &mut BitReader,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    cbp_luma: u32,
    qp: i32,
) {
    let w = st.yuv.width as usize;
    let bx0 = (mb_x / 4) as usize;
    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 nc = st.luma_nc(bx4, by4);
            let (scan, tc) = residual_block_cavlc(r, 16, nc, TOTAL_ZEROS_16);
            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;
        }
    }
}

/// インター MB のクロマ残差を MC 予測へ加算（DC 2x2 Hadamard + AC）。
fn add_inter_chroma_residual(
    r: &mut BitReader,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    cbp_chroma: u32,
    qp_y: i32,
    chroma_qp_off: i32,
) {
    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 qpc = chroma_qp(qp_y, chroma_qp_off);
    let mut dc = [[0i32; 4]; 2];
    if cbp_chroma != 0 {
        for comp in 0..2 {
            let (scan, _) = residual_block_cavlc(r, 4, -1, TOTAL_ZEROS_CHROMA);
            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], qpc);
            }
        }
    }
    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 nc = chroma_nc(st, comp, cbx4, cby4);
                let (scan, tc) = residual_block_cavlc(r, 15, nc, TOTAL_ZEROS_16);
                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;
    }
    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, qpc);
            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;
                }
            }
        }
    }
}

/// P スライスの符号化 MB。intra MB（mb_type>=5）は intra デコーダへ委譲。
/// P_8x8 / P_8x8ref0: 4 つの 8x8 サブ MB、各 sub_mb_type でさらに分割。
fn decode_p8x8(
    r: &mut BitReader,
    st: &mut DecState,
    px: usize,
    py: usize,
    refr: &DecodedYuv,
) -> Result<(), &'static str> {
    let mut sub_types = [0u32; 4];
    for s in sub_types.iter_mut() {
        *s = r.read_ue();
        if *s > 3 {
            return Err("bad sub_mb_type");
        }
    }
    // ref_idx: 単一参照のため読まない。
    for (i, &stype) in sub_types.iter().enumerate() {
        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 = r.read_se() as i16;
            let mvd_y = r.read_se() as i16;
            let mvp = mv_predict(st, ppx, ppy, pw, MvDir::None);
            let mv = [mvp[0].wrapping_add(mvd_x), mvp[1].wrapping_add(mvd_y)];
            mc_part(st, ppx, ppy, pw, ph, mv, refr);
            store_part_mv(st, ppx, ppy, pw, ph, mv);
        }
    }
    Ok(())
}

/// インター: mb_type 0=16x16, 1=16x8, 2=8x16, 3/4=P_8x8。
#[allow(clippy::too_many_arguments)]
fn decode_mb_p(
    r: &mut BitReader,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    qp: &mut i32,
    pps: &Pps,
    refr: &DecodedYuv,
) -> Result<(), &'static str> {
    let mb_type = r.read_ue();
    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");
    }
    // インター: 単一参照 (refIdx=0) 前提なので ref_idx_l0 は読まない。
    let px = mb_x as usize;
    let py = mb_y as usize;
    // 1 パーティション分の mvd を読み、MV 予測 + MC + 格納を行うクロージャ的処理。
    let do_part = |r: &mut BitReader,
                   st: &mut DecState,
                   ppx: usize,
                   ppy: usize,
                   pw: usize,
                   ph: usize,
                   dir: MvDir| {
        let mvd_x = r.read_se() as i16;
        let mvd_y = r.read_se() as i16;
        let mvp = mv_predict(st, ppx, ppy, pw, dir);
        let mv = [mvp[0].wrapping_add(mvd_x), mvp[1].wrapping_add(mvd_y)];
        mc_part(st, ppx, ppy, pw, ph, mv, refr);
        store_part_mv(st, ppx, ppy, pw, ph, mv);
    };
    match mb_type {
        0 => {
            // P_L0_16x16
            do_part(r, st, px, py, 16, 16, MvDir::None);
        }
        1 => {
            // P_L0_L0_16x8（上→下）。mvd は両パートを順に読む。
            // 16x8 は上=Prefer B, 下=Prefer A。
            do_part(r, st, px, py, 16, 8, MvDir::B);
            do_part(r, st, px, py + 8, 16, 8, MvDir::A);
        }
        2 => {
            // P_L0_L0_8x16（左→右）。左=Prefer A, 右=Prefer C。
            do_part(r, st, px, py, 8, 16, MvDir::A);
            do_part(r, st, px + 8, py, 8, 16, MvDir::C);
        }
        3 | 4 => {
            // P_8x8 / P_8x8ref0
            decode_p8x8(r, st, px, py, refr)?;
        }
        _ => return Err("unknown P mb_type"),
    }

    let codenum = r.read_ue() as usize;
    if codenum >= 48 {
        return Err("inter cbp codeNum out of range");
    }
    let cbp = CBP_INTER_MAP[codenum] as u32;
    let cbp_luma = cbp & 0xf;
    let cbp_chroma = cbp >> 4;
    let cur_qp = if cbp != 0 {
        let d = r.read_se();
        *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);
    add_inter_chroma_residual(
        r,
        st,
        mb_x,
        mb_y,
        cbp_chroma,
        cur_qp,
        pps.chroma_qp_index_offset,
    );
    Ok(())
}

/// 輝度 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: &mut BitReader,
    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.read_ue() as u8;
    let mb_qp_delta = r.read_se();
    *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_nc = st.luma_nc(bx0, by0);
    let (dc_scan, _) = residual_block_cavlc(r, 16, dc_nc, TOTAL_ZEROS_16);
    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 nc = st.luma_nc(bx4, by4);
            let (ac_scan, tc) = residual_block_cavlc(r, 15, nc, TOTAL_ZEROS_16);
            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 = mb_y > 0;
    let left_avail = mb_x > 0;
    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_index_offset,
    )
}

fn decode_mb_i4x4(
    r: &mut BitReader,
    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;

    // 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 = if r.read_bit() == 1 {
            pred_mode
        } else {
            let rem = r.read_bits(3) as i32;
            if rem < pred_mode {
                rem
            } else {
                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.read_ue() as u8;
    let codenum = r.read_ue() as usize;
    if codenum >= 48 {
        return Err("cbp codeNum out of range");
    }
    let cbp = CBP_INTRA_MAP[codenum] as u32;
    let cbp_luma = cbp & 0xf;
    let cbp_chroma = cbp >> 4;

    let cur_qp = if cbp != 0 {
        let mb_qp_delta = r.read_se();
        *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 nc = st.luma_nc(bx4, by4);
            let (scan, tc) = residual_block_cavlc(r, 16, nc, TOTAL_ZEROS_16);
            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_index_offset,
    )
}

/// 輝度 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 cbx4 > 0 {
        st.nnz_chroma[comp][cby4 * st.cblk_w + cbx4 - 1] as i32
    } else {
        -1
    };
    let nb = if cby4 > 0 {
        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: &mut BitReader,
    st: &mut DecState,
    mb_x: u32,
    mb_y: u32,
    cbp_chroma: u32,
    chroma_pred_mode: u8,
    qp_y: i32,
    chroma_qp_offset: i32,
) -> 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 qpc = chroma_qp(qp_y, chroma_qp_offset);

    // 各成分の 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, _) = residual_block_cavlc(r, 4, -1, TOTAL_ZEROS_CHROMA);
            // 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], qpc);
            }
        }
    }
    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 nc = chroma_nc(st, comp, cbx4, cby4);
                let (scan, tc) = residual_block_cavlc(r, 15, nc, TOTAL_ZEROS_16);
                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 = cmb_y > 0;
    let ca_l = cmb_x > 0;
    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, qpc);
            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.nnz_luma[p_li] > 0 || st.nnz_luma[q_li] > 0 {
        return 2;
    }
    // 単一参照前提: 参照差・MV 本数差は発生せず、MV 差のみ。
    let m = st.mv_l0[p_li];
    let n = st.mv_l0[q_li];
    if (m[0] - n[0]).abs() >= 4 || (m[1] - n[1]).abs() >= 4 {
        return 1;
    }
    0
}

fn deblock_frame(
    st: &mut DecState,
    mb_w: usize,
    mb_h: usize,
    alpha_off: i32,
    beta_off: i32,
    chroma_qp_off: i32,
) {
    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 {
            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;

            // 輝度 垂直エッジ（xe=0,4,8,12）: 4 行セグメントごとに bS。
            for k in 0..4usize {
                let xe = k * 4;
                if xe == 0 && mbx == 0 {
                    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 {
                let ye = k * 4;
                if ye == 0 && mby == 0 {
                    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 行/列セグメント。
            let qpc = chroma_qp(qp, chroma_qp_off);
            let qpc_left = chroma_qp(qp_left, chroma_qp_off);
            let qpc_top = chroma_qp(qp_top, chroma_qp_off);
            for comp in 0..2usize {
                // 垂直エッジ 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 && mbx == 0 {
                        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 && mby == 0 {
                        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
}