return error instead of assert on invalid predictions data.

src/lib.rs

@@ -92,7 +92,8 @@ pub fn decompress_deflate_stream(
         let mut cabac_decoder =
             PredictionDecoderCabac::new(VP8Reader::new(Cursor::new(&cabac_encoded)).unwrap());
 
-        let reread_params = PreflateParameters::read(&mut cabac_decoder);
+        let reread_params = PreflateParameters::read(&mut cabac_decoder)
+            .map_err(|e| PreflateError::InvalidPredictionData(e))?;
         assert_eq!(params, reread_params);
 
         let (recompressed, _recreated_blocks) =
@@ -115,12 +116,13 @@ pub fn decompress_deflate_stream(
 /// recompresses a deflate stream using the cabac_encoded data that was returned from decompress_deflate_stream
 pub fn recompress_deflate_stream(
     plain_text: &[u8],
-    cabac_encoded: &[u8],
+    prediction_corrections: &[u8],
 ) -> Result<Vec<u8>, PreflateError> {
     let mut cabac_decoder =
-        PredictionDecoderCabac::new(VP8Reader::new(Cursor::new(&cabac_encoded)).unwrap());
+        PredictionDecoderCabac::new(VP8Reader::new(Cursor::new(&prediction_corrections)).unwrap());
 
-    let params = PreflateParameters::read(&mut cabac_decoder);
+    let params = PreflateParameters::read(&mut cabac_decoder)
+        .map_err(|e| PreflateError::InvalidPredictionData(e))?;
     let (recompressed, _recreated_blocks) =
         decode_mispredictions(&params, plain_text, &mut cabac_decoder)?;
     Ok(recompressed)
@@ -152,7 +154,8 @@ pub fn decompress_deflate_stream_assert(
         let mut cabac_decoder =
             PredictionDecoderCabac::new(DebugReader::new(Cursor::new(&cabac_encoded)).unwrap());
 
-        let params = PreflateParameters::read(&mut cabac_decoder);
+        let params = PreflateParameters::read(&mut cabac_decoder)
+            .map_err(|e| PreflateError::InvalidPredictionData(e))?;
         let (recompressed, _recreated_blocks) =
             decode_mispredictions(&params, &contents.plain_text, &mut cabac_decoder)?;
 
@@ -174,12 +177,14 @@ pub fn decompress_deflate_stream_assert(
 /// This version uses DebugWriter and DebugReader, which are slower and don't compress but can be used to debug the cabac encoding errors.
 pub fn recompress_deflate_stream_assert(
     plain_text: &[u8],
-    cabac_encoded: &[u8],
+    prediction_corrections: &[u8],
 ) -> Result<Vec<u8>, PreflateError> {
-    let mut cabac_decoder =
-        PredictionDecoderCabac::new(DebugReader::new(Cursor::new(&cabac_encoded)).unwrap());
+    let mut cabac_decoder = PredictionDecoderCabac::new(
+        DebugReader::new(Cursor::new(&prediction_corrections)).unwrap(),
+    );
 
-    let params = PreflateParameters::read(&mut cabac_decoder);
+    let params = PreflateParameters::read(&mut cabac_decoder)
+        .map_err(|e| PreflateError::InvalidPredictionData(e))?;
 
     let (recompressed, _recreated_blocks) =
         decode_mispredictions(&params, plain_text, &mut cabac_decoder)?;

src/preflate_error.rs

@@ -10,6 +10,7 @@ use std::fmt::Display;
 #[derive(Debug)]
 pub enum PreflateError {
     ReadDeflate(anyhow::Error),
+    InvalidPredictionData(anyhow::Error),
     AnalyzeFailed(anyhow::Error),
     RecompressFailed(anyhow::Error),
     Mismatch(anyhow::Error),
@@ -24,6 +25,7 @@ pub enum PreflateError {
 impl Display for PreflateError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            PreflateError::InvalidPredictionData(e) => write!(f, "InvalidPredictionData: {}", e),
             PreflateError::ReadDeflate(e) => write!(f, "ReadDeflate: {}", e),
             PreflateError::Mismatch(e) => write!(f, "Mismatch: {}", e),
             PreflateError::ReadBlock(i, e) => write!(f, "ReadBlock[{}]: {}", i, e),

src/preflate_parameter_estimator.rs

@@ -4,6 +4,8 @@
  *  This software incorporates material from third parties. See NOTICE.txt for details.
  *--------------------------------------------------------------------------------------------*/
 
+use anyhow::Result;
+
 use crate::{
     bit_helper::bit_length,
     complevel_estimator::estimate_preflate_comp_level,
@@ -60,7 +62,7 @@ pub struct PreflateParameters {
 const FILE_VERSION: u16 = 1;
 
 impl PreflateParameters {
-    pub fn read<D: PredictionDecoder>(decoder: &mut D) -> Self {
+    pub fn read<D: PredictionDecoder>(decoder: &mut D) -> Result<Self> {
         assert_eq!(FILE_VERSION, decoder.decode_value(8));
         let strategy = decoder.decode_value(4);
         let huff_strategy = decoder.decode_value(4);
@@ -93,7 +95,7 @@ impl PreflateParameters {
         const HASH_ALGORITHM_MINIZ_FAST: u16 = HashAlgorithm::MiniZFast as u16;
         const HASH_ALGORITHM_LIBDEFLATE4: u16 = HashAlgorithm::Libdeflate4 as u16;
 
-        PreflateParameters {
+        Ok(PreflateParameters {
             strategy: match strategy {
                 STRATEGY_DEFAULT => PreflateStrategy::Default,
                 STRATEGY_RLE_ONLY => PreflateStrategy::RleOnly,
@@ -127,7 +129,7 @@ impl PreflateParameters {
                 HASH_ALGORITHM_LIBDEFLATE4 => HashAlgorithm::Libdeflate4,
                 _ => panic!("invalid hash algorithm"),
             },
-        }
+        })
     }
 
     pub fn write<E: PredictionEncoder>(&self, encoder: &mut E) {

src/process.rs

@@ -241,7 +241,7 @@ fn analyze_compressed_data_fast(
     let mut cabac_decoder =
         PredictionDecoderCabac::new(VP8Reader::new(Cursor::new(&buffer)).unwrap());
 
-    let params = PreflateParameters::read(&mut cabac_decoder);
+    let params = PreflateParameters::read(&mut cabac_decoder).unwrap();
 
     let (recompressed, _recreated_blocks) =
         decode_mispredictions(&params, &contents.plain_text, &mut cabac_decoder).unwrap();
@@ -309,7 +309,7 @@ fn analyze_compressed_data_verify(
 
     let mut combined_decoder = (debug_decoder, cabac_decoder);
 
-    let params_reread = PreflateParameters::read(&mut combined_decoder);
+    let params_reread = PreflateParameters::read(&mut combined_decoder).unwrap();
     assert_eq!(params, params_reread);
 
     let (recompressed, recreated_blocks) =