don't return errors on too large requests on a reversed bitreader

benches/reversedbitreader_bench.rs

@@ -5,7 +5,7 @@ use ruzstd::decoding::bit_reader_reverse::BitReaderReversed;
 fn do_all_accesses(br: &mut BitReaderReversed, accesses: &[u8]) -> u64 {
  let mut sum = 0;
  for x in accesses {
- sum += br.get_bits(*x).unwrap();
+ sum += br.get_bits(*x);
  }
  let _ = black_box(br);
  sum
@@ -24,7 +24,7 @@ fn criterion_benchmark(c: &mut Criterion) {
  let mut br = BitReaderReversed::new(&rand_vec);
  while br.bits_remaining() > 0 {
  let x = rng.gen_range(0..20);
- br.get_bits(x).unwrap();
+ br.get_bits(x);
  access_vec.push(x);
  }
 

src/decoding/bit_reader_reverse.rs

@@ -103,40 +103,33 @@ impl<'s> BitReaderReversed<'s> {
  }
 
  #[inline(always)]
- pub fn get_bits(&mut self, n: u8) -> Result<u64, GetBitsError> {
+ pub fn get_bits(&mut self, n: u8) -> u64 {
  if n == 0 {
- return Ok(0);
+ return 0;
  }
  if self.bits_in_container >= n {
- return Ok(self.get_bits_unchecked(n));
+ return self.get_bits_unchecked(n);
  }
 
  self.get_bits_cold(n)
  }
 
  #[cold]
- fn get_bits_cold(&mut self, n: u8) -> Result<u64, GetBitsError> {
- if n > 56 {
- return Err(GetBitsError::TooManyBits {
- num_requested_bits: usize::from(n),
- limit: 56,
- });
- }
-
+ fn get_bits_cold(&mut self, n: u8) -> u64 {
  let signed_n = n as isize;
 
  if self.bits_remaining() <= 0 {
  self.idx -= signed_n;
- return Ok(0);
+ return 0;
  }
 
  if self.bits_remaining() < signed_n {
  let emulated_read_shift = signed_n - self.bits_remaining();
- let v = self.get_bits(self.bits_remaining() as u8)?;
+ let v = self.get_bits(self.bits_remaining() as u8);
  debug_assert!(self.idx == 0);
  let value = v << emulated_read_shift;
  self.idx -= emulated_read_shift;
- return Ok(value);
+ return value;
  }
 
  while (self.bits_in_container < n) && self.idx > 0 {
@@ -147,23 +140,18 @@ impl<'s> BitReaderReversed<'s> {
 
  //if we reach this point there are enough bits in the container
 
- Ok(self.get_bits_unchecked(n))
+ self.get_bits_unchecked(n)
  }
 
  #[inline(always)]
- pub fn get_bits_triple(
- &mut self,
- n1: u8,
- n2: u8,
- n3: u8,
- ) -> Result<(u64, u64, u64), GetBitsError> {
+ pub fn get_bits_triple(&mut self, n1: u8, n2: u8, n3: u8) -> (u64, u64, u64) {
  let sum = n1 as usize + n2 as usize + n3 as usize;
  if sum == 0 {
- return Ok((0, 0, 0));
+ return (0, 0, 0);
  }
  if sum > 56 {
  // try and get the values separatly
- return Ok((self.get_bits(n1)?, self.get_bits(n2)?, self.get_bits(n3)?));
+ return (self.get_bits(n1), self.get_bits(n2), self.get_bits(n3));
  }
  let sum = sum as u8;
 
@@ -184,29 +172,23 @@ impl<'s> BitReaderReversed<'s> {
  self.get_bits_unchecked(n3)
  };
 
- return Ok((v1, v2, v3));
+ return (v1, v2, v3);
  }
 
  self.get_bits_triple_cold(n1, n2, n3, sum)
  }
 
  #[cold]
- fn get_bits_triple_cold(
- &mut self,
- n1: u8,
- n2: u8,
- n3: u8,
- sum: u8,
- ) -> Result<(u64, u64, u64), GetBitsError> {
+ fn get_bits_triple_cold(&mut self, n1: u8, n2: u8, n3: u8, sum: u8) -> (u64, u64, u64) {
  let sum_signed = sum as isize;
 
  if self.bits_remaining() <= 0 {
  self.idx -= sum_signed;
- return Ok((0, 0, 0));
+ return (0, 0, 0);
  }
 
  if self.bits_remaining() < sum_signed {
- return Ok((self.get_bits(n1)?, self.get_bits(n2)?, self.get_bits(n3)?));
+ return (self.get_bits(n1), self.get_bits(n2), self.get_bits(n3));
  }
 
  while (self.bits_in_container < sum) && self.idx > 0 {
@@ -233,7 +215,7 @@ impl<'s> BitReaderReversed<'s> {
  self.get_bits_unchecked(n3)
  };
 
- Ok((v1, v2, v3))
+ (v1, v2, v3)
  }
 
  #[inline(always)]

src/decoding/literals_section_decoder.rs

@@ -126,7 +126,7 @@ fn decompress_literals(
  //skip the 0 padding at the end of the last byte of the bit stream and throw away the first 1 found
  let mut skipped_bits = 0;
  loop {
- let val = br.get_bits(1)?;
+ let val = br.get_bits(1);
  skipped_bits += 1;
  if val == 1 || skipped_bits > 8 {
  break;
@@ -136,11 +136,11 @@ fn decompress_literals(
  //if more than 7 bits are 0, this is not the correct end of the bitstream. Either a bug or corrupted data
  return Err(DecompressLiteralsError::ExtraPadding { skipped_bits });
  }
- decoder.init_state(&mut br)?;
+ decoder.init_state(&mut br);
 
  while br.bits_remaining() > -(scratch.table.max_num_bits as isize) {
  target.push(decoder.decode_symbol());
- decoder.next_state(&mut br)?;
+ decoder.next_state(&mut br);
  }
  if br.bits_remaining() != -(scratch.table.max_num_bits as isize) {
  return Err(DecompressLiteralsError::BitstreamReadMismatch {
@@ -158,7 +158,7 @@ fn decompress_literals(
  let mut br = BitReaderReversed::new(source);
  let mut skipped_bits = 0;
  loop {
- let val = br.get_bits(1)?;
+ let val = br.get_bits(1);
  skipped_bits += 1;
  if val == 1 || skipped_bits > 8 {
  break;
@@ -168,10 +168,10 @@ fn decompress_literals(
  //if more than 7 bits are 0, this is not the correct end of the bitstream. Either a bug or corrupted data
  return Err(DecompressLiteralsError::ExtraPadding { skipped_bits });
  }
- decoder.init_state(&mut br)?;
+ decoder.init_state(&mut br);
  while br.bits_remaining() > -(scratch.table.max_num_bits as isize) {
  target.push(decoder.decode_symbol());
- decoder.next_state(&mut br)?;
+ decoder.next_state(&mut br);
  }
  bytes_read += source.len() as u32;
  }

src/decoding/sequence_section_decoder.rs

@@ -58,7 +58,7 @@ pub fn decode_sequences(
  //skip the 0 padding at the end of the last byte of the bit stream and throw away the first 1 found
  let mut skipped_bits = 0;
  loop {
- let val = br.get_bits(1)?;
+ let val = br.get_bits(1);
  skipped_bits += 1;
  if val == 1 || skipped_bits > 8 {
  break;
@@ -137,7 +137,7 @@ fn decode_sequences_with_rle(
  });
  }
 
- let (obits, ml_add, ll_add) = br.get_bits_triple(of_code, ml_num_bits, ll_num_bits)?;
+ let (obits, ml_add, ll_add) = br.get_bits_triple(of_code, ml_num_bits, ll_num_bits);
  let offset = obits as u32 + (1u32 << of_code);
 
  if offset == 0 {
@@ -157,13 +157,13 @@ fn decode_sequences_with_rle(
  // br.bits_remaining() / 8,
  //);
  if scratch.ll_rle.is_none() {
- ll_dec.update_state(br)?;
+ ll_dec.update_state(br);
  }
  if scratch.ml_rle.is_none() {
- ml_dec.update_state(br)?;
+ ml_dec.update_state(br);
  }
  if scratch.of_rle.is_none() {
- of_dec.update_state(br)?;
+ of_dec.update_state(br);
  }
  }
 
@@ -212,7 +212,7 @@ fn decode_sequences_without_rle(
  });
  }
 
- let (obits, ml_add, ll_add) = br.get_bits_triple(of_code, ml_num_bits, ll_num_bits)?;
+ let (obits, ml_add, ll_add) = br.get_bits_triple(of_code, ml_num_bits, ll_num_bits);
  let offset = obits as u32 + (1u32 << of_code);
 
  if offset == 0 {
@@ -231,9 +231,9 @@ fn decode_sequences_without_rle(
  // br.bits_remaining(),
  // br.bits_remaining() / 8,
  //);
- ll_dec.update_state(br)?;
- ml_dec.update_state(br)?;
- of_dec.update_state(br)?;
+ ll_dec.update_state(br);
+ ml_dec.update_state(br);
+ of_dec.update_state(br);
  }
 
  if br.bits_remaining() < 0 {

src/fse/fse_decoder.rs

@@ -89,23 +89,19 @@ impl<'t> FSEDecoder<'t> {
  if self.table.accuracy_log == 0 {
  return Err(FSEDecoderError::TableIsUninitialized);
  }
- self.state = self.table.decode[bits.get_bits(self.table.accuracy_log)? as usize];
+ self.state = self.table.decode[bits.get_bits(self.table.accuracy_log) as usize];
 
  Ok(())
  }
 
- pub fn update_state(
- &mut self,
- bits: &mut BitReaderReversed<'_>,
- ) -> Result<(), FSEDecoderError> {
+ pub fn update_state(&mut self, bits: &mut BitReaderReversed<'_>) {
  let num_bits = self.state.num_bits;
- let add = bits.get_bits(num_bits)?;
+ let add = bits.get_bits(num_bits);
  let base_line = self.state.base_line;
  let new_state = base_line + add as u32;
  self.state = self.table.decode[new_state as usize];
 
  //println!("Update: {}, {} -> {}", base_line, add, self.state);
- Ok(())
  }
 }
 

src/huff0/huff0_decoder.rs

@@ -109,26 +109,20 @@ impl<'t> HuffmanDecoder<'t> {
  self.table.decode[self.state as usize].symbol
  }
 
- pub fn init_state(
- &mut self,
- br: &mut BitReaderReversed<'_>,
- ) -> Result<u8, HuffmanDecoderError> {
+ pub fn init_state(&mut self, br: &mut BitReaderReversed<'_>) -> u8 {
  let num_bits = self.table.max_num_bits;
- let new_bits = br.get_bits(num_bits)?;
+ let new_bits = br.get_bits(num_bits);
  self.state = new_bits;
- Ok(num_bits)
+ num_bits
  }
 
- pub fn next_state(
- &mut self,
- br: &mut BitReaderReversed<'_>,
- ) -> Result<u8, HuffmanDecoderError> {
+ pub fn next_state(&mut self, br: &mut BitReaderReversed<'_>) -> u8 {
  let num_bits = self.table.decode[self.state as usize].num_bits;
- let new_bits = br.get_bits(num_bits)?;
+ let new_bits = br.get_bits(num_bits);
  self.state <<= num_bits;
  self.state &= self.table.decode.len() as u64 - 1;
  self.state |= new_bits;
- Ok(num_bits)
+ num_bits
  }
 }
 
@@ -235,7 +229,7 @@ impl HuffmanTable {
  //skip the 0 padding at the end of the last byte of the bit stream and throw away the first 1 found
  let mut skipped_bits = 0;
  loop {
- let val = br.get_bits(1)?;
+ let val = br.get_bits(1);
  skipped_bits += 1;
  if val == 1 || skipped_bits > 8 {
  break;
@@ -254,7 +248,7 @@ impl HuffmanTable {
  loop {
  let w = dec1.decode_symbol();
  self.weights.push(w);
- dec1.update_state(&mut br)?;
+ dec1.update_state(&mut br);
 
  if br.bits_remaining() <= -1 {
  //collect final states
@@ -264,7 +258,7 @@ impl HuffmanTable {
 
  let w = dec2.decode_symbol();
  self.weights.push(w);
- dec2.update_state(&mut br)?;
+ dec2.update_state(&mut br);
 
  if br.bits_remaining() <= -1 {
  //collect final states

src/tests/bit_reader.rs

@@ -22,7 +22,7 @@ fn test_bitreader_reversed() {
  num_bits = 128 - bits_read;
  }
 
- let bits = br.get_bits(num_bits).unwrap();
+ let bits = br.get_bits(num_bits);
  bits_read += num_bits;
  accumulator |= u128::from(bits) << (128 - bits_read);
  if bits_read >= 128 {