Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
96 changes: 80 additions & 16 deletions crates/coreav-h264-encoder/src/bits.rs
Original file line number Diff line number Diff line change
Expand Up @@ -43,25 +43,26 @@ impl Bits {

#[inline(never)]
fn write(&mut self, width: u32, value: u64, end: usize) -> Result<()> {
if width == 0 {
return Ok(());
}
if let Some(bytes) = &mut self.bytes {
bytes
.try_reserve(end.div_ceil(8).saturating_sub(bytes.len()))
.map_err(|_| Error::Allocation)?;
let mut remaining = width;
while remaining != 0 {
let used = (self.len % 8) as u32;
if used == 0 {
bytes.push(0);
}
let take = remaining.min(8 - used);
let chunk = ((value >> (remaining - take)) & ((1 << take) - 1)) as u8;
*bytes.last_mut().ok_or(Error::Internal)? |= chunk << (8 - used - take);
self.len += take as usize;
remaining -= take;
}
} else {
self.len = end;
let used = self.len % 8;
let encoded = (u128::from(value) << (128 - used - width as usize)).to_be_bytes();
let count = (used + width as usize).div_ceil(8);
let start = if used == 0 {
0
} else {
*bytes.last_mut().ok_or(Error::Internal)? |=
*encoded.first().ok_or(Error::Internal)?;
1
};
bytes.extend_from_slice(encoded.get(start..count).ok_or(Error::Internal)?);
}
self.len = end;
Ok(())
}

Expand All @@ -72,8 +73,12 @@ impl Bits {
pub(crate) fn ue(&mut self, value: u32) -> Result<()> {
let number = u64::from(value) + 1;
let width = 64 - number.leading_zeros();
self.u(width - 1, 0)?;
self.u(width, number)
if width == 33 {
self.u(width - 1, 0)?;
self.u(width, number)
} else {
self.u(width * 2 - 1, number)
}
}

pub(crate) fn se(&mut self, value: i32) -> Result<()> {
Expand Down Expand Up @@ -119,3 +124,62 @@ impl Bits {
Ok(output)
}
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::indexing_slicing)]
mod tests {
use super::*;

#[test]
fn wide_writes_match_individual_bits_at_every_alignment() {
let mut state = 1u64;
for offset in 0..8 {
for width in 0..=64 {
for _ in 0..32 {
state = state.wrapping_mul(6364136223846793005).wrapping_add(1);
let value = if width == 64 {
state
} else {
state & ((1u64 << width) - 1)
};
let mut wide = Bits::new(64);
let mut reference = Bits::new(64);
wide.u(offset, (1 << offset) - 1).unwrap();
reference.u(offset, (1 << offset) - 1).unwrap();
wide.u(width, value).unwrap();
for bit in (0..width).rev() {
reference.u(1, (value >> bit) & 1).unwrap();
}
assert_eq!(wide.len, reference.len);
assert_eq!(wide.bytes, reference.bytes);
wide.u(7, 85).unwrap();
reference.u(7, 85).unwrap();
assert_eq!(wide.nal(1).unwrap(), reference.nal(1).unwrap());
}
}
}
}

#[test]
fn golomb_codes_and_refusals_keep_exact_bits() {
for value in [0, 1, 2, 3, 255, 256, u32::MAX - 1, u32::MAX] {
let mut packed = Bits::new(64);
let mut reference = Bits::new(64);
packed.ue(value).unwrap();
let number = u64::from(value) + 1;
let width = 64 - number.leading_zeros();
reference.u(width - 1, 0).unwrap();
reference.u(width, number).unwrap();
assert_eq!(packed.len, reference.len);
assert_eq!(packed.bytes, reference.bytes);
}
let mut writer = Bits::new(1);
writer.u(7, 127).unwrap();
assert_eq!(writer.u(2, 0), Err(Error::Limit));
assert_eq!(writer.u(1, 2), Err(Error::Syntax));
assert_eq!(writer.u(65, 0), Err(Error::Syntax));
assert_eq!(writer.len, 7);
writer.u(1, 1).unwrap();
assert_eq!(writer.bytes, Some(vec![255]));
}
}
104 changes: 62 additions & 42 deletions crates/coreav-h264-encoder/src/cavlc.rs
Original file line number Diff line number Diff line change
Expand Up @@ -23,24 +23,7 @@ pub(crate) struct Cost {

impl Cost {
pub(crate) fn new(coefficients: &[i32], nc: i32) -> Result<Self> {
let mut counter = Bits::count();
let total = residual(&mut counter, coefficients, nc)?;
let trailing = coefficients
.iter()
.rev()
.filter(|&&level| level != 0)
.take(3)
.take_while(|level| level.unsigned_abs() == 1)
.count();
let tokens = TOKENS
.get(usize::from(total) * 4 + trailing)
.ok_or(Error::Internal)?;
let fixed = counter.len - (*tokens.get(column(nc)?).ok_or(Error::Internal)? & 31) as usize;
Ok(Self {
fixed,
token: (usize::from(total) * 4 + trailing) as u8,
total,
})
block(&mut Bits::count(), coefficients, nc)
}

pub(crate) fn bits(self, nc: i32) -> Result<usize> {
Expand All @@ -57,6 +40,10 @@ impl Cost {
}

pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result<u8> {
Ok(block(w, coefficients, nc)?.total)
}

fn block(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result<Cost> {
if !matches!(coefficients.len(), 4 | 15 | 16) {
return Err(Error::Internal);
}
Expand Down Expand Up @@ -84,38 +71,21 @@ pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result<u8
.and_then(|row| row.get(column))
.ok_or(Error::Internal)?;
w.code(*token)?;
let fixed_start = w.len;
let mut signs = 0;
for &level in values.iter().rev().take(trailing) {
w.flag(level < 0)?;
signs = (signs << 1) | u64::from(level < 0);
}
w.u(trailing as u32, signs)?;
let mut suffix = u32::from(total > 10 && trailing < 3);
for (i, &level) in values.iter().rev().enumerate().skip(trailing) {
let abs = u64::from(level.unsigned_abs());
let mut code = abs * 2 - 2 + u64::from(level < 0);
if i == trailing && trailing < 3 {
code = code.checked_sub(2).ok_or(Error::Syntax)?;
}
let mut found = false;
for prefix in 0..=15u32 {
let size = if prefix == 14 && suffix == 0 {
4
} else if prefix == 15 {
12
} else {
suffix
};
let base =
(u64::from(prefix) << suffix) + if prefix == 15 && suffix == 0 { 15 } else { 0 };
if code >= base && code - base < 1u64 << size {
w.u(prefix, 0)?;
w.flag(true)?;
w.u(size, code - base)?;
found = true;
break;
}
}
if !found {
return Err(Error::Coefficient);
}
let (width, value) = level_code(code, suffix)?;
w.u(width, value)?;
suffix = suffix.max(1);
if suffix < 6 && abs > 3u64 << (suffix - 1) {
suffix += 1;
Expand Down Expand Up @@ -153,14 +123,64 @@ pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result<u8
left -= run;
}
}
Ok(total as u8)
Ok(Cost {
fixed: w.len - fixed_start,
token: (total * 4 + trailing) as u8,
total: total as u8,
})
}

fn level_code(code: u64, suffix: u32) -> Result<(u32, u64)> {
let (prefix, size, base) = if suffix == 0 {
if code < 14 {
(code as u32, 0, code)
} else if code < 30 {
(14, 4, 14)
} else {
(15, 12, 30)
}
} else {
let prefix = (code >> suffix).min(15) as u32;
(
prefix,
if prefix == 15 { 12 } else { suffix },
u64::from(prefix) << suffix,
)
};
let remainder = code - base;
if remainder >= 1 << size {
return Err(Error::Coefficient);
}
Ok((prefix + 1 + size, (1 << size) | remainder))
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::indexing_slicing)]
mod cost_tests {
use super::*;

#[test]
fn direct_level_codes_match_every_prefix_and_escape_boundary() {
for suffix in 0..=6 {
for code in (0..8192).chain([u32::MAX as u64, u64::MAX >> 1]) {
let expected = (0..=15u32).find_map(|prefix| {
let size = if prefix == 14 && suffix == 0 {
4
} else if prefix == 15 {
12
} else {
suffix
};
let base = (u64::from(prefix) << suffix)
+ if prefix == 15 && suffix == 0 { 15 } else { 0 };
(code >= base && code - base < 1u64 << size)
.then(|| (prefix + 1 + size, (1 << size) | (code - base)))
});
assert_eq!(level_code(code, suffix).ok(), expected, "{code}/{suffix}");
}
}
}

#[test]
fn cached_cost_matches_the_writer_for_every_context_and_residual_shape() {
let mut state = 1u32;
Expand Down
Loading