use super::scaling;
use crate::hevc::bits::BitReader;
use crate::hevc::error::{Error, Result};
use alloc::vec::Vec;
#[derive(Debug, Clone, Default)]
pub struct Pps {
pub id: u32,
pub sps_id: u32,
pub dependent_slices: bool,
pub output_flag_present: bool,
pub extra_slice_header_bits: u32,
pub sign_data_hiding: bool,
pub cabac_init_present: bool,
pub init_qp: i32,
pub constrained_intra_pred: bool,
pub transform_skip: bool,
pub cu_qp_delta_enabled: bool,
pub diff_cu_qp_delta_depth: u32,
pub cb_qp_offset: i32,
pub cr_qp_offset: i32,
pub slice_chroma_qp_offsets_present: bool,
pub transquant_bypass: bool,
pub tiles_enabled: bool,
pub wpp_enabled: bool,
pub num_tile_cols: usize,
pub num_tile_rows: usize,
pub uniform_spacing: bool,
pub column_widths: Vec<usize>,
pub row_heights: Vec<usize>,
pub across_tiles: bool,
pub across_slices: bool,
pub deblock_override_enabled: bool,
pub deblock_disabled: bool,
pub beta_offset_div2: i32,
pub tc_offset_div2: i32,
pub scaling: Option<scaling::ScalingListData>,
pub slice_header_extension: bool,
pub log2_max_transform_skip: usize,
pub chroma_qp_offset_list_enabled: bool,
pub diff_cu_chroma_qp_offset_depth: u32,
pub cb_qp_offset_list: Vec<i32>,
pub cr_qp_offset_list: Vec<i32>,
pub sao_offset_scale_luma: u32,
pub sao_offset_scale_chroma: u32,
}
pub fn parse(data: &[u8]) -> Result<Pps> {
let r = &mut BitReader::new(data);
let mut p = Pps {
num_tile_cols: 1,
num_tile_rows: 1,
uniform_spacing: true,
across_tiles: true,
log2_max_transform_skip: 2,
..Default::default()
};
p.id = r.ue()?;
p.sps_id = r.ue()?;
p.dependent_slices = r.u1()? != 0;
p.output_flag_present = r.u1()? != 0;
p.extra_slice_header_bits = r.u(3)?;
p.sign_data_hiding = r.u1()? != 0;
p.cabac_init_present = r.u1()? != 0;
r.ue()?; r.ue()?; p.init_qp = r
.se()?
.checked_add(26)
.filter(|qp| (-48..=51).contains(qp))
.ok_or(Error::InvalidData("init_qp out of range"))?;
p.constrained_intra_pred = r.u1()? != 0;
p.transform_skip = r.u1()? != 0;
p.cu_qp_delta_enabled = r.u1()? != 0;
if p.cu_qp_delta_enabled {
p.diff_cu_qp_delta_depth = r.ue()?;
}
p.cb_qp_offset = r.se()?;
p.cr_qp_offset = r.se()?;
p.slice_chroma_qp_offsets_present = r.u1()? != 0;
r.skip(2)?; p.transquant_bypass = r.u1()? != 0;
p.tiles_enabled = r.u1()? != 0;
p.wpp_enabled = r.u1()? != 0;
if p.tiles_enabled {
p.num_tile_cols = r.ue()? as usize + 1;
p.num_tile_rows = r.ue()? as usize + 1;
if p.num_tile_cols > 1024 || p.num_tile_rows > 1024 {
return Err(Error::InvalidData("implausible tile count"));
}
p.uniform_spacing = r.u1()? != 0;
if !p.uniform_spacing {
for _ in 0..p.num_tile_cols - 1 {
p.column_widths.push(r.ue()? as usize + 1);
}
for _ in 0..p.num_tile_rows - 1 {
p.row_heights.push(r.ue()? as usize + 1);
}
}
p.across_tiles = r.u1()? != 0;
}
p.across_slices = r.u1()? != 0;
if r.u1()? != 0 {
p.deblock_override_enabled = r.u1()? != 0;
p.deblock_disabled = r.u1()? != 0;
if !p.deblock_disabled {
p.beta_offset_div2 = r.se()?;
p.tc_offset_div2 = r.se()?;
}
}
if r.u1()? != 0 {
let mut d = scaling::ScalingListData::default();
scaling::parse(r, &mut d)?;
p.scaling = Some(d);
}
r.u1()?; r.ue()?; p.slice_header_extension = r.u1()? != 0;
if r.more_rbsp_data() && r.u1()? != 0 {
parse_extensions(r, &mut p)?;
}
Ok(p)
}
fn parse_extensions(r: &mut BitReader<'_>, p: &mut Pps) -> Result<()> {
let range_ext = r.u1()? != 0;
let other = r.u(3)? != 0;
r.skip(4)?; if range_ext {
if p.transform_skip {
p.log2_max_transform_skip = r.ue()? as usize + 2;
}
if r.u1()? != 0 {
return Err(Error::Unsupported(
"cross_component_prediction_enabled_flag",
));
}
p.chroma_qp_offset_list_enabled = r.u1()? != 0;
if p.chroma_qp_offset_list_enabled {
p.diff_cu_chroma_qp_offset_depth = r.ue()?;
let len = r.ue()? as usize + 1;
if len > 6 {
return Err(Error::InvalidData("chroma_qp_offset_list_len_minus1 > 5"));
}
for _ in 0..len {
p.cb_qp_offset_list.push(r.se()?);
p.cr_qp_offset_list.push(r.se()?);
}
}
p.sao_offset_scale_luma = r.ue()?;
p.sao_offset_scale_chroma = r.ue()?;
}
if other {
return Err(Error::Unsupported("PPS multilayer, 3D or SCC extension"));
}
Ok(())
}