use super::tables::{RANGE_TAB_LPS, TRANS_IDX_LPS, TRANS_IDX_MPS};
use crate::bitstream::BitWriter;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CtxModel {
pub state: u8,
pub mps: u8,
}
impl CtxModel {
pub fn init(init_value: u8, slice_qp: i32) -> Self {
let slope_idx = (init_value >> 4) as i32;
let offset_idx = (init_value & 0x0F) as i32;
let m = slope_idx * 5 - 45;
let n = (offset_idx << 3) - 16;
let qp = slice_qp.clamp(0, 51);
let pre = ((m * qp) >> 4) + n;
let pre = pre.clamp(1, 126);
if pre <= 63 {
CtxModel {
state: (63 - pre) as u8,
mps: 0,
}
} else {
CtxModel {
state: (pre - 64) as u8,
mps: 1,
}
}
}
pub fn from_state(state: u8, mps: u8) -> Self {
debug_assert!(state < 64);
CtxModel {
state,
mps: mps & 1,
}
}
}
#[derive(Clone)]
pub struct CabacEncoder {
low: u32,
range: u32,
bits_outstanding: u32,
first_bit: bool,
out: BitWriter,
}
impl Default for CabacEncoder {
fn default() -> Self {
Self::new()
}
}
impl CabacEncoder {
pub fn new() -> Self {
Self {
low: 0,
range: 510,
bits_outstanding: 0,
first_bit: true,
out: BitWriter::new(),
}
}
#[inline]
fn put_bit(&mut self, b: u32) {
if self.first_bit {
self.first_bit = false;
} else {
self.out.write_bit(b);
}
while self.bits_outstanding > 0 {
self.out.write_bit(1 - (b & 1));
self.bits_outstanding -= 1;
}
}
#[inline]
fn renorm(&mut self) {
while self.range < 256 {
if self.low < 256 {
self.put_bit(0);
} else if self.low >= 512 {
self.low -= 512;
self.put_bit(1);
} else {
self.low -= 256;
self.bits_outstanding += 1;
}
self.range <<= 1;
self.low <<= 1;
}
}
pub fn encode_bin(&mut self, ctx: &mut CtxModel, bin: u32) {
let q = ((self.range >> 6) & 3) as usize;
let lps = RANGE_TAB_LPS[ctx.state as usize][q] as u32;
self.range -= lps;
if (bin & 1) != ctx.mps as u32 {
self.low += self.range;
self.range = lps;
if ctx.state == 0 {
ctx.mps = 1 - ctx.mps;
}
ctx.state = TRANS_IDX_LPS[ctx.state as usize];
} else {
ctx.state = TRANS_IDX_MPS[ctx.state as usize];
}
self.renorm();
}
pub fn encode_bypass(&mut self, bin: u32) {
self.low <<= 1;
if (bin & 1) != 0 {
self.low += self.range;
}
if self.low >= 1024 {
self.put_bit(1);
self.low -= 1024;
} else if self.low < 512 {
self.put_bit(0);
} else {
self.low -= 512;
self.bits_outstanding += 1;
}
}
pub fn encode_bypass_bits(&mut self, value: u32, n: u32) {
for i in (0..n).rev() {
self.encode_bypass((value >> i) & 1);
}
}
pub fn encode_terminate(&mut self, bin: u32) {
self.range -= 2;
if (bin & 1) != 0 {
self.low += self.range;
self.flush();
} else {
self.renorm();
}
}
fn flush(&mut self) {
self.range = 2;
self.renorm();
self.put_bit((self.low >> 9) & 1);
self.out.write_bits(((self.low >> 7) & 3) | 1, 2);
}
pub fn probe(&self) -> Self {
Self {
low: self.low,
range: self.range,
bits_outstanding: self.bits_outstanding,
first_bit: self.first_bit,
out: BitWriter::new(),
}
}
pub fn bit_len(&self) -> usize {
self.out.bit_len()
}
pub fn writer_mut(&mut self) -> &mut BitWriter {
&mut self.out
}
pub fn reinit(&mut self) {
self.low = 0;
self.range = 510;
self.bits_outstanding = 0;
self.first_bit = true;
}
pub fn finish(self) -> Vec<u8> {
self.out.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
struct BitReader<'a> {
bytes: &'a [u8],
pos: usize,
}
impl<'a> BitReader<'a> {
fn new(bytes: &'a [u8]) -> Self {
Self { bytes, pos: 0 }
}
fn read_bit(&mut self) -> u32 {
let byte = self.pos >> 3;
let bit = 7 - (self.pos & 7);
self.pos += 1;
if byte < self.bytes.len() {
((self.bytes[byte] >> bit) & 1) as u32
} else {
0
}
}
fn read_bits(&mut self, n: u32) -> u32 {
let mut v = 0;
for _ in 0..n {
v = (v << 1) | self.read_bit();
}
v
}
}
struct CabacDecoder<'a> {
range: u32,
offset: u32,
r: BitReader<'a>,
}
impl<'a> CabacDecoder<'a> {
fn new(bytes: &'a [u8]) -> Self {
let mut r = BitReader::new(bytes);
let offset = r.read_bits(9);
Self {
range: 510,
offset,
r,
}
}
fn renorm(&mut self) {
while self.range < 256 {
self.range <<= 1;
self.offset = (self.offset << 1) | self.r.read_bit();
}
}
fn decode_bin(&mut self, ctx: &mut CtxModel) -> u32 {
let q = ((self.range >> 6) & 3) as usize;
let lps = RANGE_TAB_LPS[ctx.state as usize][q] as u32;
self.range -= lps;
let bin;
if self.offset >= self.range {
bin = 1 - ctx.mps as u32;
self.offset -= self.range;
self.range = lps;
if ctx.state == 0 {
ctx.mps = 1 - ctx.mps;
}
ctx.state = TRANS_IDX_LPS[ctx.state as usize];
} else {
bin = ctx.mps as u32;
ctx.state = TRANS_IDX_MPS[ctx.state as usize];
}
self.renorm();
bin
}
fn decode_bypass(&mut self) -> u32 {
self.offset = (self.offset << 1) | self.r.read_bit();
if self.offset >= self.range {
self.offset -= self.range;
1
} else {
0
}
}
fn decode_terminate(&mut self) -> u32 {
self.range -= 2;
if self.offset >= self.range {
1
} else {
self.renorm();
0
}
}
}
struct Rng(u32);
impl Rng {
fn next(&mut self) -> u32 {
let mut x = self.0;
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
self.0 = x;
x
}
fn bit(&mut self) -> u32 {
self.next() & 1
}
}
#[derive(Clone, Copy, Debug)]
enum Op {
Regular(usize, u32),
Bypass(u32),
Terminate(u32),
}
#[test]
fn ctx_init_matches_spec_examples() {
assert_eq!(CtxModel::init(154, 26), CtxModel { state: 0, mps: 1 });
assert_eq!(CtxModel::init(0, 26), CtxModel { state: 62, mps: 0 });
}
fn run_roundtrip(ops: &[Op], ctx_seed: &[CtxModel]) {
let mut enc = CabacEncoder::new();
let mut ectx: Vec<CtxModel> = ctx_seed.to_vec();
for &op in ops {
match op {
Op::Regular(c, b) => enc.encode_bin(&mut ectx[c], b),
Op::Bypass(b) => enc.encode_bypass(b),
Op::Terminate(b) => enc.encode_terminate(b),
}
}
let bytes = enc.finish();
let mut dec = CabacDecoder::new(&bytes);
let mut dctx: Vec<CtxModel> = ctx_seed.to_vec();
for (i, &op) in ops.iter().enumerate() {
match op {
Op::Regular(c, b) => {
assert_eq!(dec.decode_bin(&mut dctx[c]), b, "regular bin #{i}");
}
Op::Bypass(b) => assert_eq!(dec.decode_bypass(), b, "bypass bin #{i}"),
Op::Terminate(b) => assert_eq!(dec.decode_terminate(), b, "terminate bin #{i}"),
}
}
}
#[test]
fn roundtrip_simple() {
let seed = vec![CtxModel::from_state(0, 0), CtxModel::from_state(31, 1)];
let ops = vec![
Op::Regular(0, 1),
Op::Regular(0, 0),
Op::Regular(1, 1),
Op::Bypass(1),
Op::Bypass(0),
Op::Regular(1, 0),
Op::Terminate(0),
Op::Regular(0, 1),
Op::Terminate(1),
];
run_roundtrip(&ops, &seed);
}
#[test]
fn roundtrip_randomized() {
for trial in 0..200u32 {
let mut rng = Rng(0x9E37_79B9 ^ trial.wrapping_mul(2654435761));
let seed = vec![
CtxModel::init((rng.next() & 0xFF) as u8, (rng.next() % 52) as i32),
CtxModel::init((rng.next() & 0xFF) as u8, (rng.next() % 52) as i32),
CtxModel::init((rng.next() & 0xFF) as u8, (rng.next() % 52) as i32),
CtxModel::init((rng.next() & 0xFF) as u8, (rng.next() % 52) as i32),
];
let len = 20 + (rng.next() % 400) as usize;
let mut ops = Vec::with_capacity(len + 1);
for _ in 0..len {
match rng.next() % 10 {
0..=6 => ops.push(Op::Regular((rng.next() % 4) as usize, rng.bit())),
7..=8 => ops.push(Op::Bypass(rng.bit())),
_ => ops.push(Op::Terminate(0)),
}
}
ops.push(Op::Terminate(1)); run_roundtrip(&ops, &seed);
}
}
#[test]
fn roundtrip_all_bypass() {
let seed = vec![CtxModel::from_state(0, 0)];
let mut rng = Rng(0x1234_5678);
let mut ops: Vec<Op> = (0..500).map(|_| Op::Bypass(rng.bit())).collect();
ops.push(Op::Terminate(1));
run_roundtrip(&ops, &seed);
}
}