use super::ctx::{INIT_VALUES, NUM_CTX};
use super::tables::{RANGE_TAB_LPS, TRANS_IDX_LPS, TRANS_IDX_MPS};
use crate::hevc::error::{Error, Result};
const OVERREAD_SLACK: usize = 16;
#[derive(Clone)]
pub struct Cabac<'a> {
data: &'a [u8],
next: usize,
pos: usize,
range: u32,
value: u32,
bits_needed: i32,
pub ctx: [u8; NUM_CTX],
}
pub fn initial_contexts(qp: i32) -> [u8; NUM_CTX] {
let q = qp.clamp(0, 51);
let mut out = [0u8; NUM_CTX];
for (o, &init) in out.iter_mut().zip(INIT_VALUES.iter()) {
let slope = (init >> 4) as i32 * 5 - 45;
let offset = ((init & 15) as i32) * 8 - 16;
let pre = (((slope * q) >> 4) + offset).clamp(1, 126);
let mps = u8::from(pre > 63);
let state = if mps == 1 { pre - 64 } else { 63 - pre };
*o = ((state as u8) << 1) | mps;
}
out
}
impl<'a> Cabac<'a> {
pub fn new(data: &'a [u8], byte_off: usize, qp: i32) -> Result<Cabac<'a>> {
let mut c = Cabac {
data,
next: byte_off,
pos: byte_off * 8,
range: 510,
value: 0,
bits_needed: -8,
ctx: [0; NUM_CTX],
};
c.init_contexts(qp);
c.init_engine()?;
Ok(c)
}
pub fn init_contexts(&mut self, qp: i32) {
self.ctx = initial_contexts(qp);
}
pub fn init_engine(&mut self) -> Result<()> {
self.pos = (self.pos + 7) & !7;
self.next = self.pos >> 3;
self.range = 510;
let hi = self.fetch();
let lo = self.fetch();
self.value = (hi << 8) | lo;
self.bits_needed = -8;
if self.value >> 7 >= 510 {
return Err(Error::InvalidData("CABAC ivlOffset is 510 or 511"));
}
self.check_overread()
}
pub fn restart_at(&mut self, byte_off: usize) -> Result<()> {
self.pos = byte_off * 8;
self.init_engine()
}
pub fn aligned_pos(&self) -> usize {
(self.bit_pos() + 7) >> 3
}
#[inline]
fn bit_pos(&self) -> usize {
self.next * 8 - (-self.bits_needed - 1) as usize
}
#[inline]
fn check_overread(&self) -> Result<()> {
if self.next > self.data.len() + OVERREAD_SLACK {
return Err(Error::Truncated);
}
Ok(())
}
#[inline(always)]
fn fetch(&mut self) -> u32 {
let b = self.data.get(self.next).copied().unwrap_or(0);
self.next += 1;
u32::from(b)
}
#[inline(always)]
fn shift_one(&mut self) {
self.value <<= 1;
self.bits_needed += 1;
if self.bits_needed == 0 {
self.bits_needed = -8;
self.value |= self.fetch();
}
}
#[inline(always)]
pub fn decision(&mut self, ctx_idx: usize) -> u32 {
let s = self.ctx[ctx_idx];
let state = ((s >> 1) & 63) as usize;
let mps = u32::from(s & 1);
let lps = u32::from(RANGE_TAB_LPS[state][((self.range >> 6) & 3) as usize]);
let range = self.range - lps;
let scaled = range << 7;
if self.value < scaled {
self.ctx[ctx_idx] = (TRANS_IDX_MPS[state] << 1) | (s & 1);
if range < 256 {
self.range = range << 1;
self.shift_one();
} else {
self.range = range;
}
mps
} else {
self.value -= scaled;
let shift = lps.leading_zeros() - 23;
self.range = lps << shift;
self.value <<= shift;
self.bits_needed += shift as i32;
if self.bits_needed >= 0 {
let b = self.fetch();
self.value |= b << self.bits_needed;
self.bits_needed -= 8;
}
let new_mps = if state == 0 { 1 - mps } else { mps };
self.ctx[ctx_idx] = (TRANS_IDX_LPS[state] << 1) | new_mps as u8;
1 - mps
}
}
#[inline(always)]
pub fn bypass(&mut self) -> u32 {
self.shift_one();
let scaled = self.range << 7;
let bit = u32::from(self.value >= scaled);
self.value -= scaled & bit.wrapping_neg();
bit
}
#[inline]
pub fn bypass_bits(&mut self, n: u32) -> u32 {
let mut v = 0u32;
for _ in 0..n {
v = (v << 1) | self.bypass();
}
v
}
#[inline]
pub fn terminate(&mut self) -> Result<u32> {
self.check_overread()?;
self.range -= 2;
let scaled = self.range << 7;
if self.value >= scaled {
return Ok(1);
}
if self.range < 256 {
self.range <<= 1;
self.shift_one();
}
Ok(0)
}
pub fn align_after_terminate(&mut self) {
self.pos = self.aligned_pos() << 3;
}
pub fn raw_bits(&mut self, n: u32) -> Result<u32> {
let mut v = 0u32;
for _ in 0..n {
let byte_idx = self.pos >> 3;
if byte_idx > self.data.len() + OVERREAD_SLACK {
return Err(Error::Truncated);
}
let b = self.data.get(byte_idx).copied().unwrap_or(0);
v = (v << 1) | u32::from((b >> (7 - (self.pos & 7))) & 1);
self.pos += 1;
}
Ok(v)
}
}