atmos/os_lib/

h264.rs

// h264.rs - no_std H.264 / AVC (MPEG-4 Part 10) Video Decoder for AtmOS
//
// 段階実装中の「本物」デコーダの基盤レイヤ（ビットストリーム〜変換・予測の純関数）。
// スライス/マクロブロック層・CAVLC 残差・再構成は h264_decode.rs にある。
// 完成済みレイヤ（h264::selftest / h264_decode::golden_test で検証）:
//   [x] BitReader（MSB-first）+ Exp-Golomb ue(v)/se(v)
//   [x] RBSP 抽出（emulation-prevention 0x03 除去）
//   [x] NAL 分割（Annex-B スタートコード / AVCC 長さ前置の両対応）
//   [x] SPS / PPS パース（実解像度 + フレームクロップ。avcC 抽出）
//   [x] 逆量子化 + 4x4 整数 IDCT、イントラ予測（輝度 4x4/16x16・クロマ 8x8）
// 互換 API の decode_nal / decode_slice は段階移行用（pixel 再構成は h264_decode.rs 側）。
// 未実装（次段）: I_4x4 全体経路 / nC≥2 の coeff_token / インター予測 / 動き補償 / デブロッキング。
#![allow(dead_code, clippy::needless_range_loop)]

use alloc::string::String;
use alloc::vec::Vec;

// ===================== ビットストリーム読み取り =====================

/// MSB-first のビットリーダ。H.264 の RBSP を読むための最小実装。
pub struct BitReader<'a> {
    data: &'a [u8],
    byte_pos: usize,
    bit_pos: u8, // 0..=7、現在バイト内の次に読むビット（MSB=0）
}

impl<'a> BitReader<'a> {
    pub fn new(data: &'a [u8]) -> Self {
        Self {
            data,
            byte_pos: 0,
            bit_pos: 0,
        }
    }

    /// 残ビットが無い場合に true。
    pub fn is_eof(&self) -> bool {
        self.byte_pos >= self.data.len()
    }

    /// `more_rbsp_data()`（7.2）: 末尾の rbsp_stop_one_bit より前に未読のビットが残っているか。
    /// 停止ビットは「最後の 0 でないバイトの最下位の 1」（後ろの 0 バイトは cabac_zero_word 等）。
    /// 複数スライスのフレームで、スライスの終わりを知るのに使う（2026-10-17）。
    pub fn more_rbsp_data(&self) -> bool {
        let Some(last) = self.data.iter().rposition(|&b| b != 0) else {
            return false;
        };
        let tz = self.data.get(last).map_or(0, |b| b.trailing_zeros() as usize);
        let stop_bit = last * 8 + (7 - tz);
        self.byte_pos * 8 + (self.bit_pos as usize) < stop_bit
    }

    /// 1 ビット読む。EOF 後は 0 を返す（呼び出し側で長さ管理する前提）。
    pub fn read_bit(&mut self) -> u32 {
        if self.byte_pos >= self.data.len() {
            return 0;
        }
        let byte = self.data[self.byte_pos];
        let bit = (byte >> (7 - self.bit_pos)) & 1;
        self.bit_pos += 1;
        if self.bit_pos == 8 {
            self.bit_pos = 0;
            self.byte_pos += 1;
        }
        bit as u32
    }

    /// 先頭からのビット位置（CABAC の slice_data の開始位置を渡すのに使う）。
    pub fn bit_position(&self) -> usize {
        self.byte_pos * 8 + self.bit_pos as usize
    }

    /// バイト境界まで進める（I_PCM の pcm_alignment_zero_bits 用）。
    pub fn byte_align(&mut self) {
        if self.bit_pos != 0 {
            self.bit_pos = 0;
            self.byte_pos += 1;
        }
    }

    /// n ビット読み（n <= 32）、無符号整数として返す。
    pub fn read_bits(&mut self, n: u32) -> u32 {
        let mut v = 0u32;
        // 不正データ由来の巨大ビット数によるハングを防ぐ（u32 に収まる範囲に制限）。
        for _ in 0..n.min(32) {
            v = (v << 1) | self.read_bit();
        }
        v
    }

    /// 符号なし Exp-Golomb ue(v)。
    /// 仕様: 先行ゼロ数 leadingZeroBits を数え、`2^lzb - 1 + read_bits(lzb)`。
    pub fn read_ue(&mut self) -> u32 {
        let mut leading_zeros = 0u32;
        while !self.is_eof() && self.read_bit() == 0 {
            leading_zeros += 1;
            if leading_zeros > 31 {
                break;
            } // 異常データの暴走防止
        }
        if leading_zeros == 0 {
            return 0;
        }
        let suffix = self.read_bits(leading_zeros);
        (1u32 << leading_zeros) - 1 + suffix
    }

    /// 符号付き Exp-Golomb se(v)。ue を ±へマップ: 0->0, 1->1, 2->-1, 3->2, 4->-2 ...
    pub fn read_se(&mut self) -> i32 {
        let k = self.read_ue();
        if k == 0 {
            0
        } else if k & 1 == 1 {
            (k.div_ceil(2)) as i32
        } else {
            -((k / 2) as i32)
        }
    }
}

/// RBSP 抽出: NAL ペイロードから emulation_prevention_three_byte(0x03) を除去する。
/// 0x00 0x00 0x03 のシーケンスで 0x03 を落とす（0x000000/0x000001 の誤検出回避用バイト）。
pub fn extract_rbsp(payload: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(payload.len());
    let mut zeros = 0usize;
    let mut i = 0;
    while i < payload.len() {
        let b = payload[i];
        if zeros >= 2 && b == 0x03 {
            // 0x03 を除去。直後のバイトは通常通り処理させるため zeros をリセット。
            zeros = 0;
            i += 1;
            continue;
        }
        out.push(b);
        if b == 0x00 {
            zeros += 1;
        } else {
            zeros = 0;
        }
        i += 1;
    }
    out
}

// ===================== NAL 分割 =====================

#[derive(Clone)]
pub struct NalUnit {
    pub ref_idc: u8,
    pub unit_type: u8,
    pub rbsp: Vec<u8>, // ヘッダ1バイトを除いた RBSP（脱エミュレーション済み）
}

impl NalUnit {
    fn from_ebsp(ebsp: &[u8]) -> Option<NalUnit> {
        if ebsp.is_empty() {
            return None;
        }
        let header = ebsp[0];
        if (header >> 7) & 1 != 0 {
            return None;
        } // forbidden_zero_bit
        Some(NalUnit {
            ref_idc: (header >> 5) & 3,
            unit_type: header & 0x1F,
            rbsp: extract_rbsp(&ebsp[1..]),
        })
    }
}

/// Annex-B（00 00 01 / 00 00 00 01 区切り）のバイト列を NAL 群に分割。
pub fn split_annexb(data: &[u8]) -> Vec<NalUnit> {
    let mut nals = Vec::new();
    let mut i = 0;
    let n = data.len();
    // 最初のスタートコードを探す
    let mut start = None;
    while i + 3 <= n {
        if data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1 {
            start = Some(i + 3);
            i += 3;
            break;
        }
        i += 1;
    }
    let mut s = match start {
        Some(s) => s,
        None => return nals,
    };
    while i + 3 <= n {
        if data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1 {
            // 直前に 0x00 があれば 4 バイトスタートコード。末尾の余分な 0 を含めない。
            let mut end = i;
            if end > s && data[end - 1] == 0 {
                end -= 1;
            }
            if let Some(nu) = NalUnit::from_ebsp(&data[s..end]) {
                nals.push(nu);
            }
            s = i + 3;
            i += 3;
        } else {
            i += 1;
        }
    }
    if s < n {
        if let Some(nu) = NalUnit::from_ebsp(&data[s..n]) {
            nals.push(nu);
        }
    }
    nals
}

/// AVCC（長さ前置）の1サンプルを NAL 群に分割。length_size は 1/2/4。
pub fn split_avcc(data: &[u8], length_size: usize) -> Vec<NalUnit> {
    let mut nals = Vec::new();
    let mut i = 0;
    while i + length_size <= data.len() {
        let mut len = 0usize;
        for _ in 0..length_size {
            len = (len << 8) | data[i] as usize;
            i += 1;
        }
        if len == 0 || i + len > data.len() {
            break;
        }
        if let Some(nu) = NalUnit::from_ebsp(&data[i..i + len]) {
            nals.push(nu);
        }
        i += len;
    }
    nals
}

// ===================== パラメータセット =====================

#[derive(Default, Clone)]
pub struct Sps {
    pub profile_idc: u8,
    pub level_idc: u8,
    pub seq_parameter_set_id: u32,
    pub log2_max_frame_num: u32,
    pub pic_order_cnt_type: u32,
    pub log2_max_pic_order_cnt_lsb: u32,
    pub width: u32,
    pub height: u32,
    pub frame_mbs_only_flag: u32,
    /// 横マクロブロック数 = width/16（クロップ前の MB 数）。
    pub width_mbs: u32,
    pub height_mbs: u32,
    /// 参照フレームの最大数（DPB のスライディングウィンドウの幅）。
    pub max_num_ref_frames: u32,
    /// B の空間ダイレクトで、8x8 ごとに角の 4x4 の co-located を使う（8.4.1.2.1）。
    pub direct_8x8_inference_flag: bool,
    /// 表示領域（frame_cropping）の左上（画素）。幅・高さは `width`/`height`。
    pub crop_x: u32,
    pub crop_y: u32,
}

/// SPS RBSP をパースして解像度等を得る（baseline/main で必要な範囲）。
pub fn parse_sps(rbsp: &[u8]) -> Result<Sps, &'static str> {
    let mut r = BitReader::new(rbsp);
    let mut sps = Sps {
        profile_idc: r.read_bits(8) as u8,
        ..Default::default()
    };
    let _constraint_flags = r.read_bits(8); // constraint_set flags + reserved
    sps.level_idc = r.read_bits(8) as u8;
    sps.seq_parameter_set_id = r.read_ue();

    // high profile 系のクロマ情報（baseline/main では無いが安全のため分岐）
    if matches!(
        sps.profile_idc,
        100 | 110 | 122 | 244 | 44 | 83 | 86 | 118 | 128 | 138 | 139 | 134 | 135
    ) {
        // デコーダは 4:2:0・8 ビット・平坦なスケーリング行列だけ扱う。それ以外は黙って誤復号
        // せずに失敗させる（2026-10-17。従来は読み捨てていた。スケーリング行列は存在フラグだけ
        // 立って中身が無い場合も既定の非平坦行列＝フォールバック規則 A になるので未対応扱い）。
        let chroma_format_idc = r.read_ue();
        if chroma_format_idc != 1 {
            return Err("chroma format other than 4:2:0 not supported");
        }
        if r.read_ue() != 0 || r.read_ue() != 0 {
            return Err("bit depth other than 8 not supported");
        }
        if r.read_bit() == 1 {
            return Err("qpprime_y_zero_transform_bypass not supported");
        }
        if r.read_bit() == 1 {
            return Err("SPS scaling matrix not supported");
        }
    }

    sps.log2_max_frame_num = r.read_ue() + 4;
    sps.pic_order_cnt_type = r.read_ue();
    if sps.pic_order_cnt_type == 0 {
        sps.log2_max_pic_order_cnt_lsb = r.read_ue() + 4;
    } else if sps.pic_order_cnt_type == 1 {
        let _delta_pic_order_always_zero_flag = r.read_bit();
        let _offset_for_non_ref_pic = r.read_se();
        let _offset_for_top_to_bottom_field = r.read_se();
        // 不正データ由来の巨大値によるハングを防ぐ（規格上限 255）。
        let num_ref_frames_in_pic_order_cnt_cycle = r.read_ue().min(256);
        for _ in 0..num_ref_frames_in_pic_order_cnt_cycle {
            let _ = r.read_se();
        }
    }
    sps.max_num_ref_frames = r.read_ue().min(16);
    let _gaps_in_frame_num_value_allowed_flag = r.read_bit();

    let pic_width_in_mbs_minus1 = r.read_ue();
    let pic_height_in_map_units_minus1 = r.read_ue();
    sps.frame_mbs_only_flag = r.read_bit();
    if sps.frame_mbs_only_flag == 0 {
        let _mb_adaptive_frame_field_flag = r.read_bit();
    }
    sps.direct_8x8_inference_flag = r.read_bit() == 1;

    let mut crop_left = 0u32;
    let mut crop_right = 0u32;
    let mut crop_top = 0u32;
    let mut crop_bottom = 0u32;
    let frame_cropping_flag = r.read_bit();
    if frame_cropping_flag == 1 {
        crop_left = r.read_ue();
        crop_right = r.read_ue();
        crop_top = r.read_ue();
        crop_bottom = r.read_ue();
    }

    let width_mbs = pic_width_in_mbs_minus1 + 1;
    let height_map_units = pic_height_in_map_units_minus1 + 1;
    sps.width_mbs = width_mbs;
    sps.height_mbs = height_map_units * (2 - sps.frame_mbs_only_flag);
    let raw_width = width_mbs * 16;
    let raw_height = height_map_units * 16 * (2 - sps.frame_mbs_only_flag);

    // クロマ 4:2:0 を前提に crop 単位は水平2/垂直(2*(2-frame_mbs_only)) 画素。
    let crop_unit_x = 2u32;
    let crop_unit_y = 2u32 * (2 - sps.frame_mbs_only_flag);
    sps.width = raw_width.saturating_sub((crop_left + crop_right) * crop_unit_x);
    sps.height = raw_height.saturating_sub((crop_top + crop_bottom) * crop_unit_y);
    sps.crop_x = crop_left * crop_unit_x;
    sps.crop_y = crop_top * crop_unit_y;
    if sps.width == 0 || sps.height == 0 {
        return Err("SPS produced zero dimensions");
    }
    Ok(sps)
}

#[derive(Default, Clone)]
pub struct Pps {
    pub pic_parameter_set_id: u32,
    pub seq_parameter_set_id: u32,
    pub entropy_coding_mode_flag: u32, // 0=CAVLC, 1=CABAC
    pub bottom_field_pic_order_in_frame_present_flag: u32, // = pic_order_present_flag
    pub pic_init_qp: i32,              // 26 + pic_init_qp_minus26
    pub deblocking_filter_control_present_flag: u32,
    pub constrained_intra_pred_flag: u32,
    pub redundant_pic_cnt_present_flag: u32,
    pub chroma_qp_index_offset: i32,
    /// `num_ref_idx_l0_default_active_minus1 + 1`（スライスヘッダで上書きされうる）。
    pub num_ref_idx_l0_default_active: u32,
    /// 重み付き予測（P）。1 ならスライスヘッダに pred_weight_table がある。
    pub weighted_pred_flag: u32,
    /// `num_ref_idx_l1_default_active_minus1 + 1`（B）。
    pub num_ref_idx_l1_default_active: u32,
    /// 重み付き双予測（B）。0=無し、1=明示、2=暗黙。
    pub weighted_bipred_idc: u32,
    /// 8x8 変換を使ってよいか（High。MB ごとに transform_size_8x8_flag がある）。
    pub transform_8x8_mode_flag: bool,
    /// Cr の QP オフセット（High。無ければ `chroma_qp_index_offset` と同じ）。
    pub second_chroma_qp_index_offset: i32,
}

impl Pps {
    /// [Cb, Cr] の QP オフセット。
    pub fn chroma_qp_offsets(&self) -> [i32; 2] {
        [self.chroma_qp_index_offset, self.second_chroma_qp_index_offset]
    }
}

pub fn parse_pps(rbsp: &[u8]) -> Result<Pps, &'static str> {
    let mut r = BitReader::new(rbsp);
    let mut pps = Pps {
        pic_parameter_set_id: r.read_ue(),
        seq_parameter_set_id: r.read_ue(),
        entropy_coding_mode_flag: r.read_bit(),
        ..Default::default()
    };
    pps.bottom_field_pic_order_in_frame_present_flag = r.read_bit();
    let num_slice_groups_minus1 = r.read_ue();
    if num_slice_groups_minus1 > 0 {
        // FMO（スライスグループ）は未対応。ベースライン単一グループのみ。
        return Err("slice groups not supported");
    }
    pps.num_ref_idx_l0_default_active = r.read_ue().min(31) + 1;
    pps.num_ref_idx_l1_default_active = r.read_ue().min(31) + 1;
    pps.weighted_pred_flag = r.read_bit();
    pps.weighted_bipred_idc = r.read_bits(2);
    let pic_init_qp_minus26 = r.read_se();
    pps.pic_init_qp = 26 + pic_init_qp_minus26;
    let _pic_init_qs_minus26 = r.read_se();
    pps.chroma_qp_index_offset = r.read_se();
    pps.deblocking_filter_control_present_flag = r.read_bit();
    pps.constrained_intra_pred_flag = r.read_bit();
    pps.redundant_pic_cnt_present_flag = r.read_bit();
    // High 以上の拡張（7.3.2.2）。スケーリング行列は未対応なので明示的に失敗させる。
    pps.second_chroma_qp_index_offset = pps.chroma_qp_index_offset;
    if r.more_rbsp_data() {
        pps.transform_8x8_mode_flag = r.read_bit() == 1;
        if r.read_bit() == 1 {
            return Err("PPS scaling matrix not supported");
        }
        pps.second_chroma_qp_index_offset = r.read_se();
    }
    Ok(pps)
}

/// avcC（AVCDecoderConfigurationRecord）から SPS/PPS と length_size を抽出。
/// 返り値: (length_size, sps_nal_payloads, pps_nal_payloads)。各 payload は NAL ヘッダ込み。
pub fn parse_avcc(avcc: &[u8]) -> Option<(usize, Vec<Vec<u8>>, Vec<Vec<u8>>)> {
    if avcc.len() < 7 || avcc[0] != 1 {
        return None;
    }
    let length_size = (avcc[4] & 0x03) as usize + 1;
    let num_sps = (avcc[5] & 0x1F) as usize;
    let mut i = 6;
    let mut sps_list = Vec::new();
    for _ in 0..num_sps {
        if i + 2 > avcc.len() {
            return None;
        }
        let len = ((avcc[i] as usize) << 8) | avcc[i + 1] as usize;
        i += 2;
        if i + len > avcc.len() {
            return None;
        }
        sps_list.push(avcc[i..i + len].to_vec());
        i += len;
    }
    if i >= avcc.len() {
        return None;
    }
    let num_pps = avcc[i] as usize;
    i += 1;
    let mut pps_list = Vec::new();
    for _ in 0..num_pps {
        if i + 2 > avcc.len() {
            return None;
        }
        let len = ((avcc[i] as usize) << 8) | avcc[i + 1] as usize;
        i += 2;
        if i + len > avcc.len() {
            return None;
        }
        pps_list.push(avcc[i..i + len].to_vec());
        i += len;
    }
    Some((length_size, sps_list, pps_list))
}

// ===================== デコーダ本体 =====================

pub struct DecodedVideoFrame {
    pub width: u32,
    pub height: u32,
    pub rgb_data: Vec<u8>,
}

pub struct H264Decoder {
    sps: Option<Sps>,
    pps: Option<Pps>,
    width: u32,
    height: u32,
}

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

impl H264Decoder {
    pub fn new() -> Self {
        Self {
            sps: None,
            pps: None,
            width: 0,
            height: 0,
        }
    }

    /// avcC 由来の SPS/PPS を事前登録する（MP4 経路用）。
    pub fn set_parameter_sets(&mut self, sps_payloads: &[Vec<u8>], pps_payloads: &[Vec<u8>]) {
        for p in sps_payloads {
            if let Some(nu) = NalUnit::from_ebsp(p) {
                if nu.unit_type == 7 {
                    if let Ok(s) = parse_sps(&nu.rbsp) {
                        self.width = s.width;
                        self.height = s.height;
                        self.sps = Some(s);
                    }
                }
            }
        }
        for p in pps_payloads {
            if let Some(nu) = NalUnit::from_ebsp(p) {
                if nu.unit_type == 8 {
                    if let Ok(pp) = parse_pps(&nu.rbsp) {
                        self.pps = Some(pp);
                    }
                }
            }
        }
    }

    /// 1つの NAL（Annex-B でも AVCC 単体でも、先頭にスタートコードがあれば剥がす）を処理。
    /// 互換性のため従来シグネチャを維持。
    pub fn decode_nal(&mut self, nal_data: &[u8]) -> Result<DecodedVideoFrame, &'static str> {
        // Annex-B スタートコードを剥がして単一 NAL とみなす。
        let nals = if has_start_code(nal_data) {
            split_annexb(nal_data)
        } else {
            // 先頭がヘッダバイトの裸 NAL とみなす
            match NalUnit::from_ebsp(nal_data) {
                Some(nu) => alloc::vec![nu],
                None => return Err("invalid NAL"),
            }
        };

        let mut produced: Option<DecodedVideoFrame> = None;
        for nu in &nals {
            match nu.unit_type {
                7 => {
                    let s = parse_sps(&nu.rbsp)?;
                    self.width = s.width;
                    self.height = s.height;
                    self.sps = Some(s);
                }
                8 => {
                    self.pps = Some(parse_pps(&nu.rbsp)?);
                }
                1 | 5 => {
                    produced = Some(self.decode_slice(&nu.rbsp, nu.unit_type == 5)?);
                }
                _ => {}
            }
        }
        produced.ok_or("no picture in NAL (parameter set only)")
    }

    /// AVCC（長さ前置）の1サンプル＝アクセスユニットを処理し、含まれる picture を返す。
    /// MP4 経路ではこちらを使う（SPS/PPS は事前に set_parameter_sets 済みが前提だが、
    /// in-band の SPS/PPS が来た場合もここで取り込む）。
    pub fn decode_access_unit_avcc(
        &mut self,
        sample: &[u8],
        length_size: usize,
    ) -> Option<DecodedVideoFrame> {
        let nals = split_avcc(sample, length_size);
        let mut produced = None;
        for nu in &nals {
            match nu.unit_type {
                7 => {
                    if let Ok(s) = parse_sps(&nu.rbsp) {
                        self.width = s.width;
                        self.height = s.height;
                        self.sps = Some(s);
                    }
                }
                8 => {
                    if let Ok(pp) = parse_pps(&nu.rbsp) {
                        self.pps = Some(pp);
                    }
                }
                1 | 5 => {
                    if let Ok(f) = self.decode_slice(&nu.rbsp, nu.unit_type == 5) {
                        produced = Some(f);
                    }
                }
                _ => {}
            }
        }
        produced
    }

    fn decode_slice(
        &mut self,
        _rbsp: &[u8],
        _is_idr: bool,
    ) -> Result<DecodedVideoFrame, &'static str> {
        // 解像度が未確定ならデフォルト（SPS 未受信時のフォールバック）。
        let w = if self.width == 0 { 320 } else { self.width };
        let h = if self.height == 0 { 180 } else { self.height };

        // 次段で CAVLC 残差 / イントラ予測 / IDCT を実装する。
        // 現状は実解像度のニュートラルなグレーフレームを返す（偽色生成は撤去済み）。
        let rgb_data = alloc::vec![0x20u8; (w * h * 3) as usize];
        Ok(DecodedVideoFrame {
            width: w,
            height: h,
            rgb_data,
        })
    }
}

fn has_start_code(d: &[u8]) -> bool {
    d.len() >= 3
        && d[0] == 0
        && d[1] == 0
        && (d[2] == 1 || (d.len() >= 4 && d[2] == 0 && d[3] == 1))
}

// ===================== 残差: 逆量子化 + 4x4 逆整数変換 =====================
//
// H.264 baseline の残差復元の数学コア。スケーリングリスト無し（flat、weightScale=16）。
// 仕様 8.5.12（逆量子化）+ 8.5.12.2（4x4 逆変換）に基づく。

/// normAdjust4x4(m, class)。class: 0=偶偶, 1=奇奇, 2=その他。
pub(crate) const NORM_ADJUST_4X4: [[i32; 3]; 6] = [
    [10, 16, 13],
    [11, 18, 14],
    [13, 20, 16],
    [14, 23, 18],
    [16, 25, 20],
    [18, 29, 23],
];

#[allow(clippy::manual_is_multiple_of)]
fn pos_class_4x4(i: usize, j: usize) -> usize {
    if i % 2 == 0 && j % 2 == 0 {
        0
    } else if i % 2 == 1 && j % 2 == 1 {
        1
    } else {
        2
    }
}

/// 4x4 残差ブロックの逆量子化（in-place、raster 順）。qp は 0..=51。
/// LevelScale = weightScale(=16) * normAdjust4x4(qp%6, class)。
pub fn dequant_4x4(block: &mut [i32; 16], qp: i32) {
    let m = (qp % 6) as usize;
    let shift = qp / 6;
    for i in 0..4 {
        for j in 0..4 {
            let idx = i * 4 + j;
            let level_scale = 16 * NORM_ADJUST_4X4[m][pos_class_4x4(i, j)];
            let c = block[idx];
            block[idx] = if qp >= 24 {
                (c * level_scale) << (shift - 4)
            } else {
                (c * level_scale + (1 << (3 - shift))) >> (4 - shift)
            };
        }
    }
}

/// 4x4 逆整数変換（in-place、raster 順）。最後に (x + 32) >> 6 で正規化。
pub fn inverse_transform_4x4(block: &mut [i32; 16]) {
    // 水平（行）変換
    for i in 0..4 {
        let o = i * 4;
        let (d0, d1, d2, d3) = (block[o], block[o + 1], block[o + 2], block[o + 3]);
        let e0 = d0 + d2;
        let e1 = d0 - d2;
        let e2 = (d1 >> 1) - d3;
        let e3 = d1 + (d3 >> 1);
        block[o] = e0 + e3;
        block[o + 1] = e1 + e2;
        block[o + 2] = e1 - e2;
        block[o + 3] = e0 - e3;
    }
    // 垂直（列）変換 + 正規化
    for j in 0..4 {
        let (d0, d1, d2, d3) = (block[j], block[4 + j], block[8 + j], block[12 + j]);
        let e0 = d0 + d2;
        let e1 = d0 - d2;
        let e2 = (d1 >> 1) - d3;
        let e3 = d1 + (d3 >> 1);
        block[j] = (e0 + e3 + 32) >> 6;
        block[4 + j] = (e1 + e2 + 32) >> 6;
        block[8 + j] = (e1 - e2 + 32) >> 6;
        block[12 + j] = (e0 - e3 + 32) >> 6;
    }
}

// ===================== イントラ予測（輝度） =====================
//
// 仕様 8.3.1（Intra_4x4）/ 8.3.3（Intra_16x16）。近傍は再構成済み輝度サンプル。
// 返り値は raster 順（idx = y*W + x）の予測サンプル。

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

/// Intra_4x4 予測（9 モード）。
/// top: p[x,-1] x=0..7（上 + 右上）, corner: p[-1,-1], left: p[-1,y] y=0..3。
/// DC モードのみ可用性で式が変わるため top_avail/left_avail を渡す。
pub fn intra_4x4_predict(
    mode: u8,
    top: &[i32; 8],
    corner: i32,
    left: &[i32; 4],
    top_avail: bool,
    left_avail: bool,
) -> [i32; 16] {
    let mut pred = [0i32; 16];
    // top をインデックス -1（corner）込みで参照
    let pt = |i: i32| -> i32 {
        if i < 0 {
            corner
        } else {
            top[i as usize]
        }
    };
    let pl = |i: i32| -> i32 {
        if i < 0 {
            corner
        } else {
            left[i as usize]
        }
    };
    let put = |x: usize, y: usize, v: i32, p: &mut [i32; 16]| {
        p[y * 4 + x] = v;
    };

    match mode {
        0 => {
            // Vertical
            for y in 0..4 {
                for x in 0..4 {
                    put(x, y, top[x], &mut pred);
                }
            }
        }
        1 => {
            // Horizontal
            for y in 0..4 {
                for x in 0..4 {
                    put(x, y, left[y], &mut pred);
                }
            }
        }
        2 => {
            // DC
            let dc = match (top_avail, left_avail) {
                (true, true) => {
                    (top[0] + top[1] + top[2] + top[3] + left[0] + left[1] + left[2] + left[3] + 4)
                        >> 3
                }
                (true, false) => (top[0] + top[1] + top[2] + top[3] + 2) >> 2,
                (false, true) => (left[0] + left[1] + left[2] + left[3] + 2) >> 2,
                (false, false) => 128,
            };
            for v in pred.iter_mut() {
                *v = dc;
            }
        }
        3 => {
            // Diagonal Down-Left
            for y in 0..4i32 {
                for x in 0..4i32 {
                    let v = if x == 3 && y == 3 {
                        (pt(6) + 3 * pt(7) + 2) >> 2
                    } else {
                        (pt(x + y) + 2 * pt(x + y + 1) + pt(x + y + 2) + 2) >> 2
                    };
                    put(x as usize, y as usize, v, &mut pred);
                }
            }
        }
        4 => {
            // Diagonal Down-Right
            for y in 0..4i32 {
                for x in 0..4i32 {
                    let v = if x > y {
                        (pt(x - y - 2) + 2 * pt(x - y - 1) + pt(x - y) + 2) >> 2
                    } else if x < y {
                        (pl(y - x - 2) + 2 * pl(y - x - 1) + pl(y - x) + 2) >> 2
                    } else {
                        (pt(0) + 2 * corner + pl(0) + 2) >> 2
                    };
                    put(x as usize, y as usize, v, &mut pred);
                }
            }
        }
        5 => {
            // Vertical-Right
            for y in 0..4i32 {
                for x in 0..4i32 {
                    let z = 2 * x - y;
                    let v = if z >= 0 && z % 2 == 0 {
                        (pt(x - (y >> 1) - 1) + pt(x - (y >> 1)) + 1) >> 1
                    } else if z >= 0 {
                        (pt(x - (y >> 1) - 2) + 2 * pt(x - (y >> 1) - 1) + pt(x - (y >> 1)) + 2)
                            >> 2
                    } else if z == -1 {
                        (pl(0) + 2 * corner + pt(0) + 2) >> 2
                    } else {
                        (pl(y - 1) + 2 * pl(y - 2) + pl(y - 3) + 2) >> 2
                    };
                    put(x as usize, y as usize, v, &mut pred);
                }
            }
        }
        6 => {
            // Horizontal-Down
            for y in 0..4i32 {
                for x in 0..4i32 {
                    let z = 2 * y - x;
                    let v = if z >= 0 && z % 2 == 0 {
                        (pl(y - (x >> 1) - 1) + pl(y - (x >> 1)) + 1) >> 1
                    } else if z >= 0 {
                        (pl(y - (x >> 1) - 2) + 2 * pl(y - (x >> 1) - 1) + pl(y - (x >> 1)) + 2)
                            >> 2
                    } else if z == -1 {
                        (pl(0) + 2 * corner + pt(0) + 2) >> 2
                    } else {
                        (pt(x - 1) + 2 * pt(x - 2) + pt(x - 3) + 2) >> 2
                    };
                    put(x as usize, y as usize, v, &mut pred);
                }
            }
        }
        7 => {
            // Vertical-Left
            for y in 0..4i32 {
                for x in 0..4i32 {
                    let v = if y % 2 == 0 {
                        (pt(x + (y >> 1)) + pt(x + (y >> 1) + 1) + 1) >> 1
                    } else {
                        (pt(x + (y >> 1)) + 2 * pt(x + (y >> 1) + 1) + pt(x + (y >> 1) + 2) + 2)
                            >> 2
                    };
                    put(x as usize, y as usize, v, &mut pred);
                }
            }
        }
        8 => {
            // Horizontal-Up
            for y in 0..4i32 {
                for x in 0..4i32 {
                    let z = x + 2 * y;
                    let v = if z < 5 && z % 2 == 0 {
                        (pl(y + (x >> 1)) + pl(y + (x >> 1) + 1) + 1) >> 1
                    } else if z < 5 {
                        (pl(y + (x >> 1)) + 2 * pl(y + (x >> 1) + 1) + pl(y + (x >> 1) + 2) + 2)
                            >> 2
                    } else if z == 5 {
                        (pl(2) + 3 * pl(3) + 2) >> 2
                    } else {
                        pl(3)
                    };
                    put(x as usize, y as usize, v, &mut pred);
                }
            }
        }
        _ => {}
    }
    pred
}

/// Intra_16x16 予測（4 モード: 0=Vertical, 1=Horizontal, 2=DC, 3=Plane）。
/// top: p[x,-1] x=0..15, corner: p[-1,-1], left: p[-1,y] y=0..15。
pub fn intra_16x16_predict(
    mode: u8,
    top: &[i32; 16],
    corner: i32,
    left: &[i32; 16],
    top_avail: bool,
    left_avail: bool,
) -> [i32; 256] {
    let mut pred = [0i32; 256];
    match mode {
        0 => {
            for y in 0..16 {
                for x in 0..16 {
                    pred[y * 16 + x] = top[x];
                }
            }
        }
        1 => {
            for y in 0..16 {
                for x in 0..16 {
                    pred[y * 16 + x] = left[y];
                }
            }
        }
        2 => {
            let st: i32 = top.iter().sum();
            let sl: i32 = left.iter().sum();
            let dc = match (top_avail, left_avail) {
                (true, true) => (st + sl + 16) >> 5,
                (true, false) => (st + 8) >> 4,
                (false, true) => (sl + 8) >> 4,
                (false, false) => 128,
            };
            for v in pred.iter_mut() {
                *v = dc;
            }
        }
        3 => {
            // Plane
            let mut h = 0i32;
            let mut v = 0i32;
            for i in 0..8i32 {
                // H: x'=0..7, p[8+x',-1] - p[6-x',-1]; corner for index -1
                let pt = |k: i32| -> i32 {
                    if k < 0 {
                        corner
                    } else {
                        top[k as usize]
                    }
                };
                let pl = |k: i32| -> i32 {
                    if k < 0 {
                        corner
                    } else {
                        left[k as usize]
                    }
                };
                h += (i + 1) * (pt(8 + i) - pt(6 - i));
                v += (i + 1) * (pl(8 + i) - pl(6 - i));
            }
            let b = (5 * h + 32) >> 6;
            let c = (5 * v + 32) >> 6;
            let a = 16 * (top[15] + left[15]);
            for y in 0..16i32 {
                for x in 0..16i32 {
                    let val = (a + b * (x - 7) + c * (y - 7) + 16) >> 5;
                    pred[(y * 16 + x) as usize] = clip1(val);
                }
            }
        }
        _ => {}
    }
    pred
}

/// Intra chroma 8x8 予測（4:2:0、4 モード: 0=DC, 1=Horizontal, 2=Vertical, 3=Plane）。
/// 仕様 8.3.4。top: p[x,-1] x=0..7, corner: p[-1,-1], left: p[-1,y] y=0..7。
pub fn intra_chroma_predict(
    mode: u8,
    top: &[i32; 8],
    corner: i32,
    left: &[i32; 8],
    top_avail: bool,
    left_avail: bool,
) -> [i32; 64] {
    let mut pred = [0i32; 64];
    match mode {
        0 => {
            // DC（4 つの 4x4 ブロックごとに規則が異なる）
            let t0: i32 = top[0..4].iter().sum();
            let t1: i32 = top[4..8].iter().sum();
            let l0: i32 = left[0..4].iter().sum();
            let l1: i32 = left[4..8].iter().sum();
            // 各 4x4 ブロックの DC
            let dc00 = match (top_avail, left_avail) {
                (true, true) => (t0 + l0 + 4) >> 3,
                (true, false) => (t0 + 2) >> 2,
                (false, true) => (l0 + 2) >> 2,
                (false, false) => 128,
            };
            let dc10 = if top_avail {
                (t1 + 2) >> 2
            } else if left_avail {
                (l0 + 2) >> 2
            } else {
                128
            };
            let dc01 = if left_avail {
                (l1 + 2) >> 2
            } else if top_avail {
                (t0 + 2) >> 2
            } else {
                128
            };
            let dc11 = match (top_avail, left_avail) {
                (true, true) => (t1 + l1 + 4) >> 3,
                (true, false) => (t1 + 2) >> 2,
                (false, true) => (l1 + 2) >> 2,
                (false, false) => 128,
            };
            for y in 0..8 {
                for x in 0..8 {
                    let dc = match (x < 4, y < 4) {
                        (true, true) => dc00,
                        (false, true) => dc10,
                        (true, false) => dc01,
                        (false, false) => dc11,
                    };
                    pred[y * 8 + x] = dc;
                }
            }
        }
        1 => {
            for y in 0..8 {
                for x in 0..8 {
                    pred[y * 8 + x] = left[y];
                }
            }
        }
        2 => {
            for y in 0..8 {
                for x in 0..8 {
                    pred[y * 8 + x] = top[x];
                }
            }
        }
        3 => {
            // Plane
            let pt = |k: i32| -> i32 {
                if k < 0 {
                    corner
                } else {
                    top[k as usize]
                }
            };
            let pl = |k: i32| -> i32 {
                if k < 0 {
                    corner
                } else {
                    left[k as usize]
                }
            };
            let mut h = 0i32;
            let mut v = 0i32;
            for i in 0..4i32 {
                h += (i + 1) * (pt(4 + i) - pt(2 - i));
                v += (i + 1) * (pl(4 + i) - pl(2 - i));
            }
            let b = (17 * h + 16) >> 5;
            let c = (17 * v + 16) >> 5;
            let a = 16 * (top[7] + left[7]);
            for y in 0..8i32 {
                for x in 0..8i32 {
                    pred[(y * 8 + x) as usize] = clip1((a + b * (x - 3) + c * (y - 3) + 16) >> 5);
                }
            }
        }
        _ => {}
    }
    pred
}

// ===================== 自己テスト =====================

/// 既知解ベクタによる検証（起動時に実行）。
pub fn selftest() -> (usize, usize) {
    let mut passed = 0usize;
    let mut total = 0usize;
    let mut check = |cond: bool, label: &str| {
        total += 1;
        if cond {
            passed += 1;
        } else {
            crate::println!("H264_SELFTEST FAIL: {}", label);
        }
    };

    // read_bits: 0b1011_0010 = 0xB2
    {
        let data = [0xB2u8];
        let mut r = BitReader::new(&data);
        check(r.read_bits(4) == 0b1011, "read_bits hi nibble");
        check(r.read_bits(4) == 0b0010, "read_bits lo nibble");
    }

    // Exp-Golomb ue(v) の既知マッピング:
    //  "1"=0, "010"=1, "011"=2, "00100"=3, "00101"=4, "00110"=5, "00111"=6
    // ビット列 1 010 011 00100 を 1 バイト目に詰める: 1 0 1 0 0 1 1 0 = 0xA6
    //  続き 0100... → 次バイト 0100_0000 = 0x40
    {
        let data = [0xA6u8, 0x40u8];
        let mut r = BitReader::new(&data);
        check(r.read_ue() == 0, "ue=0");
        check(r.read_ue() == 1, "ue=1");
        check(r.read_ue() == 2, "ue=2");
        check(r.read_ue() == 3, "ue=3");
    }

    // se(v): ue 0->0,1->1,2->-1,3->2,4->-2
    // ue 列 0,1,2,3,4 を se で読む。上と同じ先頭 + "00101"(=4)。
    // 1 010 011 00100 00101 → byte0=0xA6, byte1=0b0100_0010_1.. = 0x42 さらに 1 ビット
    {
        let data = [0xA6u8, 0x42u8, 0x80u8];
        let mut r = BitReader::new(&data);
        check(r.read_se() == 0, "se=0");
        check(r.read_se() == 1, "se=1");
        check(r.read_se() == -1, "se=-1");
        check(r.read_se() == 2, "se=2");
        check(r.read_se() == -2, "se=-2");
    }

    // RBSP de-emulation: 00 00 03 01 -> 00 00 01
    {
        let inb = [0x00u8, 0x00, 0x03, 0x01, 0x00, 0x00, 0x03, 0x03];
        let out = extract_rbsp(&inb);
        check(
            out == alloc::vec![0x00, 0x00, 0x01, 0x00, 0x00, 0x03],
            "rbsp de-emulation",
        );
    }

    // Annex-B 分割: 2 つの NAL（type 7 と 5）
    {
        let stream = [
            0x00, 0x00, 0x00, 0x01, 0x67, 0xAA, 0xBB, // SPS(7)
            0x00, 0x00, 0x01, 0x65, 0xCC, // IDR slice(5)
        ];
        let nals = split_annexb(&stream);
        check(nals.len() == 2, "annexb count");
        check(
            nals.first().map(|n| n.unit_type == 7).unwrap_or(false),
            "annexb nal0 type7",
        );
        check(
            nals.get(1).map(|n| n.unit_type == 5).unwrap_or(false),
            "annexb nal1 type5",
        );
    }

    // AVCC 分割: [len=3][67 AA BB][len=2][65 CC]
    {
        let stream = [0, 0, 0, 3, 0x67, 0xAA, 0xBB, 0, 0, 0, 2, 0x65, 0xCC];
        let nals = split_avcc(&stream, 4);
        check(nals.len() == 2, "avcc count");
        check(
            nals.get(1)
                .map(|n| n.unit_type == 5 && n.rbsp == alloc::vec![0xCC])
                .unwrap_or(false),
            "avcc nal1",
        );
    }

    // SPS パース（実 bitstream）: baseline 160x144。
    // このバイト列は手計算でエンコードした検証済みベクタ:
    //   profile=66, level=30, sps_id=0, log2_max_frame_num=4, poc_type=0,
    //   max_num_ref=1, pic_width_in_mbs_minus1=9(=>160), height_map_units_minus1=8,
    //   frame_mbs_only=1, no cropping。
    {
        let sps = [0x42u8, 0x00, 0x1e, 0xF4, 0x14, 0x26, 0x20];
        match parse_sps(&sps) {
            Ok(s) => {
                check(s.profile_idc == 66, "sps profile baseline");
                check(s.frame_mbs_only_flag == 1, "sps frame_mbs_only");
                check(s.width == 160 && s.height == 144, "sps 160x144");
            }
            Err(_) => check(false, "sps parse ok"),
        }
    }

    // 4x4 逆変換: 純 DC 入力は平坦ブロック (X+32)>>6 を生成。
    {
        let mut b = [0i32; 16];
        b[0] = 64;
        inverse_transform_4x4(&mut b);
        check(b.iter().all(|&v| v == 1), "idct pure DC=64 -> 1");

        let mut b2 = [0i32; 16];
        b2[0] = 4096;
        inverse_transform_4x4(&mut b2);
        check(b2.iter().all(|&v| v == 64), "idct pure DC=4096 -> 64");
    }

    // 4x4 逆変換: AC 係数 d(0,1)=64 の手計算結果（各行 [1,1,0,-1]）。
    {
        let mut b = [0i32; 16];
        b[1] = 64;
        inverse_transform_4x4(&mut b);
        let expected = [1, 1, 0, -1, 1, 1, 0, -1, 1, 1, 0, -1, 1, 1, 0, -1];
        check(b == expected, "idct AC d(0,1)=64");
    }

    // 逆量子化 + 逆変換の連鎖: c(0,0)=1, QP=24 -> dequant 160 -> 平坦 3。
    {
        let mut b = [0i32; 16];
        b[0] = 1;
        dequant_4x4(&mut b, 24);
        check(b[0] == 160, "dequant DC c=1 qp=24 -> 160");
        inverse_transform_4x4(&mut b);
        check(b.iter().all(|&v| v == 3), "dequant+idct -> flat 3");
    }

    // 逆量子化の QP+6 倍化特性（ステップサイズが2倍）。
    {
        let mut a = [0i32; 16];
        a[5] = 1; // (1,1) class1
        let mut c = [0i32; 16];
        c[5] = 1;
        dequant_4x4(&mut a, 24);
        dequant_4x4(&mut c, 30);
        check(c[5] == a[5] * 2, "dequant qp+6 doubles");
    }

    // イントラ 4x4: 定数近傍不変条件 — 全近傍が c なら全モードの全画素が c。
    // 重み付き平均の係数和とインデックス範囲を全 9 モードで検証する強力な不変条件。
    {
        let c = 100i32;
        let top = [c; 8];
        let left = [c; 4];
        let mut all_ok = true;
        for mode in 0..9u8 {
            let p = intra_4x4_predict(mode, &top, c, &left, true, true);
            if !p.iter().all(|&v| v == c) {
                all_ok = false;
                crate::println!("  intra4x4 mode {} broke constant", mode);
            }
        }
        check(all_ok, "intra4x4 constant invariant all modes");
    }

    // イントラ 4x4 Vertical: 上ランプ [10,20,30,40] が各列にコピーされる。
    {
        let top = [10, 20, 30, 40, 50, 60, 70, 80];
        let left = [0; 4];
        let p = intra_4x4_predict(0, &top, 0, &left, true, true);
        check(
            p[0] == 10 && p[1] == 20 && p[2] == 30 && p[3] == 40 && p[12] == 10 && p[15] == 40,
            "intra4x4 vertical ramp",
        );
    }

    // イントラ 4x4 Horizontal: 左ランプ [10,20,30,40] が各行にコピーされる。
    {
        let top = [0; 8];
        let left = [10, 20, 30, 40];
        let p = intra_4x4_predict(1, &top, 0, &left, true, true);
        check(
            p[0] == 10 && p[1] == 10 && p[4] == 20 && p[8] == 30 && p[12] == 40 && p[15] == 40,
            "intra4x4 horizontal ramp",
        );
    }

    // イントラ 4x4 DC: top=[8,8,8,8], left=[16,16,16,16] -> (32+64+4)>>3 = 12。
    {
        let top = [8, 8, 8, 8, 8, 8, 8, 8];
        let left = [16, 16, 16, 16];
        let p = intra_4x4_predict(2, &top, 0, &left, true, true);
        check(p.iter().all(|&v| v == 12), "intra4x4 DC both avail");
    }

    // イントラ 16x16: 定数近傍不変条件（全 4 モード、Plane 含む）。
    {
        let c = 77i32;
        let top = [c; 16];
        let left = [c; 16];
        let mut all_ok = true;
        for mode in 0..4u8 {
            let p = intra_16x16_predict(mode, &top, c, &left, true, true);
            if !p.iter().all(|&v| v == c) {
                all_ok = false;
                crate::println!("  intra16x16 mode {} broke constant", mode);
            }
        }
        check(all_ok, "intra16x16 constant invariant all modes");
    }

    // イントラ 16x16 DC: top 全 40, left 全 80 -> (640+1280+16)>>5 = 60。
    {
        let top = [40; 16];
        let left = [80; 16];
        let p = intra_16x16_predict(2, &top, 0, &left, true, true);
        check(p.iter().all(|&v| v == 60), "intra16x16 DC value");
    }

    // 実 x264 が出力した SPS（16x16, baseline）の EBSP を脱エミュレーション→パース。
    // 合成ベクタだけでなく実エンコーダ出力で SPS パーサを検証する。
    {
        let ebsp = [
            0x42u8, 0xc0, 0x0a, 0xdd, 0xec, 0x04, 0x40, 0x00, 0x00, 0x03, 0x00, 0x40, 0x00, 0x00,
            0x03, 0x00, 0x83, 0xc4, 0x89, 0xe0,
        ];
        let rbsp = extract_rbsp(&ebsp);
        match parse_sps(&rbsp) {
            Ok(s) => {
                check(s.profile_idc == 66, "real x264 SPS profile=66");
                check(s.width == 16 && s.height == 16, "real x264 SPS 16x16");
            }
            Err(_) => check(false, "real x264 SPS parse ok"),
        }
    }

    // クロマ 8x8: 定数近傍不変条件（全 4 モード、Plane 含む）。
    {
        let c = 55i32;
        let top = [c; 8];
        let left = [c; 8];
        let mut all_ok = true;
        for mode in 0..4u8 {
            let p = intra_chroma_predict(mode, &top, c, &left, true, true);
            if !p.iter().all(|&v| v == c) {
                all_ok = false;
                crate::println!("  chroma mode {} broke constant", mode);
            }
        }
        check(all_ok, "chroma constant invariant all modes");
    }

    // クロマ DC: 4 ブロックで別々の DC を計算する規則の検証。
    // top=[8,8,8,8, 40,40,40,40], left=[16,16,16,16, 60,60,60,60], 両可用。
    // t0=32,t1=160,l0=64,l1=240。
    // dc00=(32+64+4)>>3=12, dc10=(160+2)>>2=40, dc01=(240+2)>>2=60, dc11=(160+240+4)>>3=50。
    {
        let top = [8, 8, 8, 8, 40, 40, 40, 40];
        let left = [16, 16, 16, 16, 60, 60, 60, 60];
        let p = intra_chroma_predict(0, &top, 0, &left, true, true);
        check(p[0] == 12, "chroma DC block(0,0)=12");
        check(p[4] == 40, "chroma DC block(4,0)=40");
        check(p[32] == 60, "chroma DC block(0,4)=60");
        check(p[36] == 50, "chroma DC block(4,4)=50");
    }

    (passed, total)
}

/// デバッグ用の文字列表現。
pub fn describe_sps(s: &Sps) -> String {
    alloc::format!(
        "SPS profile={} level={} {}x{} mbs_only={}",
        s.profile_idc,
        s.level_idc,
        s.width,
        s.height,
        s.frame_mbs_only_flag
    )
}