From 866d57a91a326118bccfcd2447646ccb44fc6bf1 Mon Sep 17 00:00:00 2001 From: Gunwoo Kim Date: Sun, 8 Nov 2026 18:07:45 +0900 Subject: [PATCH] perf(h264): reduce residual coding work Signed-off-by: Gunwoo Kim --- crates/coreav-h264-encoder/src/bits.rs | 96 ++++++++++++++++++---- crates/coreav-h264-encoder/src/cavlc.rs | 104 ++++++++++++++---------- 2 files changed, 142 insertions(+), 58 deletions(-) diff --git a/crates/coreav-h264-encoder/src/bits.rs b/crates/coreav-h264-encoder/src/bits.rs index 897343560..5977c3a0a 100644 --- a/crates/coreav-h264-encoder/src/bits.rs +++ b/crates/coreav-h264-encoder/src/bits.rs @@ -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(()) } @@ -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<()> { @@ -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])); + } +} diff --git a/crates/coreav-h264-encoder/src/cavlc.rs b/crates/coreav-h264-encoder/src/cavlc.rs index 96b8d6726..cff369401 100644 --- a/crates/coreav-h264-encoder/src/cavlc.rs +++ b/crates/coreav-h264-encoder/src/cavlc.rs @@ -23,24 +23,7 @@ pub(crate) struct Cost { impl Cost { pub(crate) fn new(coefficients: &[i32], nc: i32) -> Result { - 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 { @@ -57,6 +40,10 @@ impl Cost { } pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result { + Ok(block(w, coefficients, nc)?.total) +} + +fn block(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result { if !matches!(coefficients.len(), 4 | 15 | 16) { return Err(Error::Internal); } @@ -84,9 +71,12 @@ pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result 10 && trailing < 3); for (i, &level) in values.iter().rev().enumerate().skip(trailing) { let abs = u64::from(level.unsigned_abs()); @@ -94,28 +84,8 @@ pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result= 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; @@ -153,7 +123,35 @@ pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result 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)] @@ -161,6 +159,28 @@ pub(crate) fn residual(w: &mut Bits, coefficients: &[i32], nc: i32) -> Result> 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;