miniz_oxide/deflate/
mod.rs

Help
1//! This module contains functionality for compression.
2
3use crate::alloc::vec;
4use crate::alloc::vec::Vec;
5
6mod buffer;
7pub mod core;
8mod stored;
9pub mod stream;
10mod zlib;
11use self::core::*;
12
13/// How much processing the compressor should do to compress the data.
14/// `NoCompression` and `Bestspeed` have special meanings, the other levels determine the number
15/// of checks for matches in the hash chains and whether to use lazy or greedy parsing.
16#[repr(i32)]
17#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
18pub enum CompressionLevel {
19    /// Don't do any compression, only output uncompressed blocks.
20    NoCompression = 0,
21    /// Fast compression. Uses a special compression routine that is optimized for speed.
22    BestSpeed = 1,
23    /// Slow/high compression. Do a lot of checks to try to find good matches.
24    BestCompression = 9,
25    /// Even more checks, can be very slow.
26    UberCompression = 10,
27    /// Default compromise between speed and compression.
28    DefaultLevel = 6,
29    /// Use the default compression level.
30    DefaultCompression = -1,
31}
32
33// Missing safe rust analogue (this and mem-to-mem are quite similar)
34/*
35fn tdefl_compress(
36    d: Option<&mut CompressorOxide>,
37    in_buf: *const c_void,
38    in_size: Option<&mut usize>,
39    out_buf: *mut c_void,
40    out_size: Option<&mut usize>,
41    flush: TDEFLFlush,
42) -> TDEFLStatus {
43    let res = match d {
44        None => {
45            in_size.map(|size| *size = 0);
46            out_size.map(|size| *size = 0);
47            (TDEFLStatus::BadParam, 0, 0)
48        },
49        Some(compressor) => {
50            let callback_res = CallbackOxide::new(
51                compressor.callback_func.clone(),
52                in_buf,
53                in_size,
54                out_buf,
55                out_size,
56            );
57
58            if let Ok(mut callback) = callback_res {
59                let res = compress(compressor, &mut callback, flush);
60                callback.update_size(Some(res.1), Some(res.2));
61                res
62            } else {
63                (TDEFLStatus::BadParam, 0, 0)
64            }
65        }
66    };
67    res.0
68}*/
69
70// Missing safe rust analogue
71/*
72fn tdefl_init(
73    d: Option<&mut CompressorOxide>,
74    put_buf_func: PutBufFuncPtr,
75    put_buf_user: *mut c_void,
76    flags: c_int,
77) -> TDEFLStatus {
78    if let Some(d) = d {
79        *d = CompressorOxide::new(
80            put_buf_func.map(|func|
81                CallbackFunc { put_buf_func: func, put_buf_user: put_buf_user }
82            ),
83            flags as u32,
84        );
85        TDEFLStatus::Okay
86    } else {
87        TDEFLStatus::BadParam
88    }
89}*/
90
91// Missing safe rust analogue (though maybe best served by flate2 front-end instead)
92/*
93fn tdefl_compress_mem_to_output(
94    buf: *const c_void,
95    buf_len: usize,
96    put_buf_func: PutBufFuncPtr,
97    put_buf_user: *mut c_void,
98    flags: c_int,
99) -> bool*/
100
101// Missing safe Rust analogue
102/*
103fn tdefl_compress_mem_to_mem(
104    out_buf: *mut c_void,
105    out_buf_len: usize,
106    src_buf: *const c_void,
107    src_buf_len: usize,
108    flags: c_int,
109) -> usize*/
110
111/// Compress the input data to a vector, using the specified compression level (0-10).
112pub fn compress_to_vec(input: &[u8], level: u8) -> Vec<u8> {
113    compress_to_vec_inner(input, level, 0, 0)
114}
115
116/// Compress the input data to a vector, using the specified compression level (0-10), and with a
117/// zlib wrapper.
118pub fn compress_to_vec_zlib(input: &[u8], level: u8) -> Vec<u8> {
119    compress_to_vec_inner(input, level, 1, 0)
120}
121
122/// Simple function to compress data to a vec.
123fn compress_to_vec_inner(mut input: &[u8], level: u8, window_bits: i32, strategy: i32) -> Vec<u8> {
124    // The comp flags function sets the zlib flag if the window_bits parameter is > 0.
125    let flags = create_comp_flags_from_zip_params(level.into(), window_bits, strategy);
126    let mut compressor = CompressorOxide::new(flags);
127    let mut output = vec![0; ::core::cmp::max(input.len() / 2, 2)];
128
129    let mut out_pos = 0;
130    loop {
131        let (status, bytes_in, bytes_out) = compress(
132            &mut compressor,
133            input,
134            &mut output[out_pos..],
135            TDEFLFlush::Finish,
136        );
137        out_pos += bytes_out;
138
139        match status {
140            TDEFLStatus::Done => {
141                output.truncate(out_pos);
142                break;
143            }
144            TDEFLStatus::Okay if bytes_in <= input.len() => {
145                input = &input[bytes_in..];
146
147                // We need more space, so resize the vector.
148                if output.len().saturating_sub(out_pos) < 30 {
149                    output.resize(output.len() * 2, 0)
150                }
151            }
152            // Not supposed to happen unless there is a bug.
153            _ => panic!("Bug! Unexpectedly failed to compress!"),
154        }
155    }
156
157    output
158}
159
160#[cfg(test)]
161mod test {
162    use super::{compress_to_vec, compress_to_vec_inner, CompressionStrategy};
163    use crate::inflate::decompress_to_vec;
164    use alloc::vec;
165
166    /// Test deflate example.
167    ///
168    /// Check if the encoder produces the same code as the example given by Mark Adler here:
169    /// https://stackoverflow.com/questions/17398931/deflate-encoding-with-static-huffman-codes/17415203
170    #[test]
171    fn compress_small() {
172        let test_data = b"Deflate late";
173        let check = [
174            0x73, 0x49, 0x4d, 0xcb, 0x49, 0x2c, 0x49, 0x55, 0x00, 0x11, 0x00,
175        ];
176
177        let res = compress_to_vec(test_data, 1);
178        assert_eq!(&check[..], res.as_slice());
179
180        let res = compress_to_vec(test_data, 9);
181        assert_eq!(&check[..], res.as_slice());
182    }
183
184    #[test]
185    fn compress_huff_only() {
186        let test_data = b"Deflate late";
187
188        let res = compress_to_vec_inner(test_data, 1, 0, CompressionStrategy::HuffmanOnly as i32);
189        let d = decompress_to_vec(res.as_slice()).expect("Failed to decompress!");
190        assert_eq!(test_data, d.as_slice());
191    }
192
193    #[test]
194    fn compress_rle() {
195        let test_data = b"Deflate late";
196
197        let res = compress_to_vec_inner(test_data, 1, 0, CompressionStrategy::RLE as i32);
198        let d = decompress_to_vec(res.as_slice()).expect("Failed to decompress!");
199        assert_eq!(test_data, d.as_slice());
200    }
201
202    /// Test that a raw block compresses fine.
203    #[test]
204    fn compress_raw() {
205        let text = b"Hello, zlib!";
206        let encoded = {
207            let len = text.len();
208            let notlen = !len;
209            let mut encoded = vec![
210                1,
211                len as u8,
212                (len >> 8) as u8,
213                notlen as u8,
214                (notlen >> 8) as u8,
215            ];
216            encoded.extend_from_slice(&text[..]);
217            encoded
218        };
219
220        let res = compress_to_vec(text, 0);
221        assert_eq!(encoded, res.as_slice());
222    }
223
224    #[test]
225    fn short() {
226        let test_data = [10, 10, 10, 10, 10, 55];
227        let c = compress_to_vec(&test_data, 9);
228
229        let d = decompress_to_vec(c.as_slice()).expect("Failed to decompress!");
230        assert_eq!(&test_data, d.as_slice());
231        // Check that a static block is used here, rather than a raw block
232        // , so the data is actually compressed.
233        // (The optimal compressed length would be 5, but neither miniz nor zlib manages that either
234        // as neither checks matches against the byte at index 0.)
235        assert!(c.len() <= 6);
236    }
237}
miniz_oxide/deflate/mod.rs

miniz_oxide/deflate/
mod.rs
