fix bug in inflate_fast when refilling

the logic assumed a certain number of bits would be available; this was false in general.

zlib-rs/src/inflate.rs

@@ -1594,7 +1594,20 @@ fn inflate_fast_help(state: &mut State, _start: usize) -> ReturnCode {
     }
 
     'outer: loop {
-        let mut here = bit_reader.refill_and(|hold| lcode[(hold & lmask) as usize]);
+        let mut here = {
+            let bits = bit_reader.bits_in_buffer();
+            let hold = bit_reader.hold();
+
+            bit_reader.refill();
+
+            // in most cases, the read can be interleaved with the logic
+            // based on benchmarks this matters in practice. wild.
+            if bits as usize >= state.len_table.bits {
+                lcode[(hold & lmask) as usize]
+            } else {
+                lcode[(bit_reader.hold() & lmask) as usize]
+            }
+        };
 
         if here.op == 0 {
             writer.push(here.val as u8);

zlib-rs/src/inflate/bitreader.rs

@@ -115,26 +115,6 @@ impl<'a> BitReader<'a> {
         self.bits_used |= 56;
     }
 
-    #[inline(always)]
-    pub fn refill_and<T>(&mut self, f: impl Fn(u64) -> T) -> T {
-        debug_assert!(self.bytes_remaining() >= 8);
-
-        // the trick of this function is that the read can happen concurrently
-        // with the arithmetic below. That makes the read effectively free.
-        let read = unsafe { core::ptr::read_unaligned(self.ptr.cast::<u64>()) }.to_le();
-        let next_bit_buffer = self.bit_buffer | read << self.bits_used;
-
-        let increment = (63 - self.bits_used) >> 3;
-        self.ptr = self.ptr.wrapping_add(increment as usize);
-        self.bits_used |= 56;
-
-        let result = f(self.bit_buffer);
-
-        self.bit_buffer = next_bit_buffer;
-
-        result
-    }
-
     #[inline(always)]
     pub fn bits(&mut self, n: usize) -> u64 {
         // debug_assert!( n <= self.bits_used, "{n} bits requested, but only {} avaliable", self.bits_used);