better parity contexts integration for literal length

src/greedy_packer.rs

@@ -12,6 +12,8 @@ pub fn pack(
     let mut rans_coder = RansCoder::new(config);
     let mut state = lz::CoderState::new(config);
 
+    let mut literal = vec![];
+
     let mut pos = 0;
     while pos < data.len() {
         if let Some(ref mut cb) = progress_callback {
@@ -22,6 +24,10 @@ pub fn pack(
             let max_offset = config.max_offset.min(1 << (m.length * 3 - 1).min(31));
             let offset = pos - m.pos;
             if offset < max_offset && m.length >= config.min_length() {
+                if !literal.is_empty() {
+                    lz::Op::Literal(literal).encode(&mut rans_coder, &mut state, config);
+                    literal = vec![];
+                }
                 let length = m.length.min(config.max_length);
                 lz::Op::Match {
                     offset: offset as u32,
@@ -43,6 +49,10 @@ pub fn pack(
                     .count()
                     .min(config.max_length);
                 if length >= config.min_length() {
+                    if !literal.is_empty() {
+                        lz::Op::Literal(literal).encode(&mut rans_coder, &mut state, config);
+                        literal = vec![];
+                    }
                     lz::Op::Match {
                         offset: offset as u32,
                         len: length as u32,
@@ -55,11 +65,14 @@ pub fn pack(
         }
 
         if !encoded_match {
-            lz::Op::Literal(data[pos]).encode(&mut rans_coder, &mut state, config);
+            literal.push(data[pos]);
             pos += 1;
         }
     }
 
+    if !literal.is_empty() {
+        lz::Op::Literal(literal).encode(&mut rans_coder, &mut state, config);
+    }
     lz::encode_eof(&mut rans_coder, &mut state, config);
     rans_coder.finish()
 }

src/lz.rs

@@ -3,36 +3,53 @@ use crate::rans::{EntropyCoder, RansDecoder};
 use crate::Config;
 use thiserror::Error;
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Clone, Debug)]
 pub enum Op {
-    Literal(u8),
+    Literal(Vec<u8>),
     Match { offset: u32, len: u32 },
 }
 
 impl Op {
     pub fn encode(&self, coder: &mut dyn EntropyCoder, state: &mut CoderState, config: &Config) {
-        let literal_base = state.pos % state.parity_contexts * 256;
         match self {
-            &Op::Literal(lit) => {
-                encode_bit(coder, state, literal_base, !config.is_match_bit);
+            &Op::Literal(ref lit) => {
+                assert!(state.prev_was_match);
+                encode_length(
+                    coder,
+                    state,
+                    256 + state.pos % state.parity_contexts * 320,
+                    lit.len() as u32 + 1,
+                    config,
+                );
+                for lit in lit {
+                    let literal_base = state.pos % state.parity_contexts * 320;
                     let mut context_index = 1;
                     for i in (0..8).rev() {
                         let bit = (lit >> i) & 1 != 0;
                         encode_bit(coder, state, literal_base + context_index, bit);
                         context_index = (context_index << 1) | bit as usize;
                     }
-                state.prev_was_match = false;
                     state.pos += 1;
                 }
+                state.prev_was_match = false;
+            }
             &Op::Match { offset, len } => {
-                encode_bit(coder, state, literal_base, config.is_match_bit);
+                if state.prev_was_match {
+                    encode_length(
+                        coder,
+                        state,
+                        256 + state.pos % state.parity_contexts * 320,
+                        1,
+                        config,
+                    );
+                }
                 let mut new_offset = true;
                 if !state.prev_was_match && !config.no_repeated_offsets {
                     new_offset = offset != state.last_offset;
                     encode_bit(
                         coder,
                         state,
-                        256 * state.parity_contexts,
+                        320 * state.parity_contexts,
                         new_offset == config.new_offset_bit,
                     );
                 }
@@ -41,14 +58,14 @@ impl Op {
                     encode_length(
                         coder,
                         state,
-                        256 * state.parity_contexts + 1,
+                        320 * state.parity_contexts + 1,
                         offset + if config.eof_in_length { 0 } else { 1 },
                         config,
                     );
                     state.last_offset = offset;
                 }
                 assert!(len as usize >= config.min_length() && len as usize <= config.max_length);
-                encode_length(coder, state, 256 * state.parity_contexts + 65, len, config);
+                encode_length(coder, state, 320 * state.parity_contexts + 65, len, config);
                 state.prev_was_match = true;
                 state.pos += len as usize;
             }
@@ -57,25 +74,28 @@ impl Op {
 }
 
 pub fn encode_eof(coder: &mut dyn EntropyCoder, state: &mut CoderState, config: &Config) {
-    encode_bit(
+    if state.prev_was_match {
+        encode_length(
             coder,
             state,
-        state.pos % state.parity_contexts * 256,
-        config.is_match_bit,
+            256 + state.pos % state.parity_contexts * 320,
+            1,
+            config,
         );
+    }
     if !state.prev_was_match && !config.no_repeated_offsets {
         encode_bit(
             coder,
             state,
-            256 * state.parity_contexts,
+            320 * state.parity_contexts,
             config.new_offset_bit ^ config.eof_in_length,
         );
     }
     if !config.eof_in_length || state.prev_was_match || config.no_repeated_offsets {
-        encode_length(coder, state, 256 * state.parity_contexts + 1, 1, config);
+        encode_length(coder, state, 320 * state.parity_contexts + 1, 1, config);
     }
     if config.eof_in_length {
-        encode_length(coder, state, 256 * state.parity_contexts + 65, 1, config);
+        encode_length(coder, state, 320 * state.parity_contexts + 65, 1, config);
     }
 }
 
@@ -119,9 +139,9 @@ pub struct CoderState {
 impl CoderState {
     pub fn new(config: &Config) -> CoderState {
         CoderState {
-            contexts: ContextState::new((1 + 255) * config.parity_contexts + 1 + 64 + 64, config),
+            contexts: ContextState::new((64 + 256) * config.parity_contexts + 1 + 64 + 64, config),
             last_offset: 0,
-            prev_was_match: false,
+            prev_was_match: true,
             pos: 0,
             parity_contexts: config.parity_contexts,
         }
@@ -168,7 +188,8 @@ pub fn unpack_internal(
     max_size: usize,
 ) -> Result<isize, UnpackError> {
     let mut decoder = RansDecoder::new(packed_data, &config);
-    let mut contexts = ContextState::new((1 + 255) * config.parity_contexts + 1 + 64 + 64, &config);
+    let mut contexts =
+        ContextState::new((64 + 256) * config.parity_contexts + 1 + 64 + 64, &config);
     let mut offset = usize::MAX;
     let mut position = 0usize;
     let mut prev_was_match = false;
@@ -199,20 +220,41 @@ pub fn unpack_internal(
 
     loop {
         margin = margin.max(position as isize - decoder.pos() as isize);
-        let literal_base = position % config.parity_contexts * 256;
-        if decoder.decode_with_context(&mut contexts.context_mut(literal_base))?
-            == config.is_match_bit
-        {
+        let literal_length = decode_length(
+            &mut decoder,
+            &mut contexts,
+            256 + position % config.parity_contexts * 320,
+            config,
+        )? - 1;
+        for _ in 0..literal_length {
+            let literal_base = position % config.parity_contexts * 320;
+            let mut context_index = 1;
+            let mut byte = 0;
+            for i in (0..8).rev() {
+                let bit = decoder
+                    .decode_with_context(&mut contexts.context_mut(literal_base + context_index))?;
+                context_index = (context_index << 1) | bit as usize;
+                byte |= (bit as u8) << i;
+            }
+            if let Some(ref mut result) = result {
+                if result.len() < max_size {
+                    result.push(byte);
+                }
+            }
+            position += 1;
+            prev_was_match = false;
+        }
+
         if config.no_repeated_offsets
             || prev_was_match
             || decoder
-                    .decode_with_context(&mut contexts.context_mut(256 * config.parity_contexts))?
+                .decode_with_context(&mut contexts.context_mut(320 * config.parity_contexts))?
                 == config.new_offset_bit
         {
             offset = decode_length(
                 &mut decoder,
                 &mut contexts,
-                    256 * config.parity_contexts + 1,
+                320 * config.parity_contexts + 1,
                 &config,
             )? - if config.eof_in_length { 0 } else { 1 };
             if offset == 0 {
@@ -222,7 +264,7 @@ pub fn unpack_internal(
         let length = decode_length(
             &mut decoder,
             &mut contexts,
-                256 * config.parity_contexts + 65,
+            320 * config.parity_contexts + 65,
             &config,
         )?;
         if config.eof_in_length && length == 1 {
@@ -242,23 +284,6 @@ pub fn unpack_internal(
         }
         position += length;
         prev_was_match = true;
-        } else {
-            let mut context_index = 1;
-            let mut byte = 0;
-            for i in (0..8).rev() {
-                let bit = decoder
-                    .decode_with_context(&mut contexts.context_mut(literal_base + context_index))?;
-                context_index = (context_index << 1) | bit as usize;
-                byte |= (bit as u8) << i;
-            }
-            if let Some(ref mut result) = result {
-                if result.len() < max_size {
-                    result.push(byte);
-                }
-            }
-            position += 1;
-            prev_was_match = false;
-        }
     }
 
     if position > max_size {

src/parsing_packer.rs

@@ -15,7 +15,7 @@ pub fn pack(
     let mut parse = parse(data, Config::from_level(level), config, progress_cb);
     let mut ops = vec![];
     while let Some(link) = parse {
-        ops.push(link.op);
+        ops.push(link.op.clone());
         parse = link.prev.clone();
     }
     let mut state = lz::CoderState::new(config);
@@ -32,9 +32,15 @@ struct Parse {
     op: lz::Op,
 }
 
+struct LiteralPrefix {
+    arrival: Arrival,
+    prefix: Vec<u8>,
+}
+
 struct Arrival {
     parse: Option<Rc<Parse>>,
     state: lz::CoderState,
+    literal_prefix: Option<Box<LiteralPrefix>>,
     cost: f64,
 }
 
@@ -130,6 +136,7 @@ fn parse(
                     op,
                 })),
                 state,
+                literal_prefix: None,
                 cost: arrival.cost + cost_counter.cost(),
             },
             max_arrivals,
@@ -141,6 +148,7 @@ fn parse(
         Arrival {
             parse: None,
             state: lz::CoderState::new(encoding_config),
+            literal_prefix: None,
             cost: 0.0,
         },
         max_arrivals,
@@ -252,19 +260,26 @@ fn parse(
             }
 
             cost_counter.reset();
-            let mut state = arrival.state;
-            let op = lz::Op::Literal(data[pos]);
+            let (arrival, mut prefix) = if let Some(prefix) = arrival.literal_prefix {
+                (prefix.arrival, prefix.prefix)
+            } else {
+                (arrival, vec![])
+            };
+            let mut state = arrival.state.clone();
+            prefix.push(data[pos]);
+            let op = lz::Op::Literal(prefix.clone());
             op.encode(cost_counter, &mut state, encoding_config);
             add_arrival(
                 &mut arrivals,
                 pos + 1,
                 Arrival {
                     parse: Some(Rc::new(Parse {
-                        prev: arrival.parse,
+                        prev: arrival.parse.clone(),
                         op,
                     })),
                     state,
                     cost: arrival.cost + cost_counter.cost(),
+                    literal_prefix: Some(Box::new(LiteralPrefix { arrival, prefix })),
                 },
                 max_arrivals,
             );