Make State::prev_length u16

Author: brianpane

zlib-rs/src/deflate.rs

@@ -378,6 +378,7 @@ pub fn init(stream: &mut z_stream, config: DeflateConfig) -> ReturnCode {
         _padding_1: 0,
         _padding_2: 0,
         _padding_3: [0; 6],
+        _padding_4: [0; 6],
     };
 
     unsafe { state_allocation.as_ptr().write(state) }; // FIXME: write is stable for NonNull since 1.80.0
@@ -684,6 +685,7 @@ pub fn copy<'a>(
         _padding_1: source_state._padding_1,
         _padding_2: source_state._padding_2,
         _padding_3: source_state._padding_3,
+        _padding_4: source_state._padding_4,
     };
 
     // write the cloned state into state_ptr
@@ -1264,7 +1266,9 @@ pub(crate) struct State<'a> {
 
     /// Length of the best match at previous step. Matches not greater than this
     /// are discarded. This is used in the lazy match evaluation.
-    pub(crate) prev_length: usize,
+    pub(crate) prev_length: u16,
+
+    _padding_4: [u8; 6],
 
     /// To speed up deflation, hash chains are never searched beyond this length.
     /// A higher limit improves compression ratio but degrades the speed.

zlib-rs/src/deflate/algorithm/slow.rs

@@ -54,7 +54,7 @@ pub fn deflate_slow(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSta
         dist = state.strstart as isize - hash_head as isize;
 
         if valid_distance_range.contains(&dist)
-            && state.prev_length < state.max_lazy_match as usize
+            && state.prev_length < state.max_lazy_match
             && hash_head != 0
         {
             // To simplify the code, we prevent matches with the string
@@ -76,15 +76,15 @@ pub fn deflate_slow(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSta
 
         // If there was a match at the previous step and the current
         // match is not better, output the previous match:
-        if state.prev_length >= STD_MIN_MATCH && match_len <= state.prev_length {
+        if state.prev_length as usize >= STD_MIN_MATCH && match_len <= state.prev_length as usize {
             let max_insert = state.strstart + state.lookahead - STD_MIN_MATCH;
             /* Do not insert strings in hash table beyond this. */
 
             // check_match(s, state.strstart-1, state.prev_match, state.prev_length);
 
             bflush = state.tally_dist(
                 state.strstart - 1 - state.prev_match as usize,
-                state.prev_length - STD_MIN_MATCH,
+                state.prev_length as usize - STD_MIN_MATCH,
             );
 
             /* Insert in hash table all strings up to the end of the match.
@@ -93,9 +93,9 @@ pub fn deflate_slow(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSta
              * the hash table.
              */
             state.prev_length -= 1;
-            state.lookahead -= state.prev_length;
+            state.lookahead -= state.prev_length as usize;
 
-            let mov_fwd = state.prev_length - 1;
+            let mov_fwd = state.prev_length as usize - 1;
             if max_insert > state.strstart {
                 let insert_cnt = Ord::min(mov_fwd, max_insert - state.strstart);
                 state.insert_string(state.strstart + 1, insert_cnt);
@@ -118,7 +118,7 @@ pub fn deflate_slow(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSta
                 flush_block_only(stream, false);
             }
 
-            stream.state.prev_length = match_len;
+            stream.state.prev_length = match_len as u16;
             stream.state.strstart += 1;
             stream.state.lookahead -= 1;
             if stream.avail_out == 0 {
@@ -127,7 +127,7 @@ pub fn deflate_slow(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSta
         } else {
             // There is no previous match to compare with, wait for
             // the next step to decide.
-            state.prev_length = match_len;
+            state.prev_length = match_len as u16;
             state.match_available = true;
             match_available = true;
             state.strstart += 1;

zlib-rs/src/deflate/longest_match.rs

@@ -52,7 +52,7 @@ fn longest_match_help<const SLOW: bool>(
 
     // length of the previous match (if any), hence <= STD_MAX_MATCH
     best_len = if state.prev_length > 0 {
-        state.prev_length
+        state.prev_length as usize
     } else {
         STD_MIN_MATCH - 1
     };