1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 Simple [DEFLATE][def]-based compression. This is a wrapper around the
14 [`miniz`][mz] library, which is a one-file pure-C implementation of zlib.
16 [def]: https://en.wikipedia.org/wiki/DEFLATE
17 [mz]: https://code.google.com/p/miniz/
21 #![crate_id = "flate#0.11.0-pre"]
23 #![crate_type = "rlib"]
24 #![crate_type = "dylib"]
25 #![license = "MIT/ASL2"]
26 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
27 html_favicon_url = "http://www.rust-lang.org/favicon.ico",
28 html_root_url = "http://doc.rust-lang.org/")]
31 #[cfg(test)] #[phase(plugin, link)] extern crate log;
36 use libc::{c_void, size_t, c_int};
38 #[link(name = "miniz", kind = "static")]
40 /// Raw miniz compression function.
41 fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
43 pout_len: *mut size_t,
47 /// Raw miniz decompression function.
48 fn tinfl_decompress_mem_to_heap(psrc_buf: *const c_void,
50 pout_len: *mut size_t,
55 static LZ_NORM : c_int = 0x80; // LZ with 128 probes, "normal"
56 static TINFL_FLAG_PARSE_ZLIB_HEADER : c_int = 0x1; // parse zlib header and adler32 checksum
57 static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum
59 fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> Option<CVec<u8>> {
61 let mut outsz : size_t = 0;
62 let res = tdefl_compress_mem_to_heap(bytes.as_ptr() as *const _,
63 bytes.len() as size_t,
67 Some(CVec::new_with_dtor(res as *mut u8, outsz as uint, proc() libc::free(res)))
74 /// Compress a buffer, without writing any sort of header on the output.
75 pub fn deflate_bytes(bytes: &[u8]) -> Option<CVec<u8>> {
76 deflate_bytes_internal(bytes, LZ_NORM)
79 /// Compress a buffer, using a header that zlib can understand.
80 pub fn deflate_bytes_zlib(bytes: &[u8]) -> Option<CVec<u8>> {
81 deflate_bytes_internal(bytes, LZ_NORM | TDEFL_WRITE_ZLIB_HEADER)
84 fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> Option<CVec<u8>> {
86 let mut outsz : size_t = 0;
87 let res = tinfl_decompress_mem_to_heap(bytes.as_ptr() as *const _,
88 bytes.len() as size_t,
92 Some(CVec::new_with_dtor(res as *mut u8, outsz as uint, proc() libc::free(res)))
99 /// Decompress a buffer, without parsing any sort of header on the input.
100 pub fn inflate_bytes(bytes: &[u8]) -> Option<CVec<u8>> {
101 inflate_bytes_internal(bytes, 0)
104 /// Decompress a buffer that starts with a zlib header.
105 pub fn inflate_bytes_zlib(bytes: &[u8]) -> Option<CVec<u8>> {
106 inflate_bytes_internal(bytes, TINFL_FLAG_PARSE_ZLIB_HEADER)
111 use super::{inflate_bytes, deflate_bytes};
116 fn test_flate_round_trip() {
117 let mut r = rand::task_rng();
118 let mut words = vec!();
119 for _ in range(0u, 20) {
120 let range = r.gen_range(1u, 10);
121 let v = r.gen_iter::<u8>().take(range).collect::<Vec<u8>>();
124 for _ in range(0u, 20) {
125 let mut input = vec![];
126 for _ in range(0u, 2000) {
127 input.push_all(r.choose(words.as_slice()).unwrap().as_slice());
129 debug!("de/inflate of {} bytes of random word-sequences",
131 let cmp = deflate_bytes(input.as_slice()).expect("deflation failed");
132 let out = inflate_bytes(cmp.as_slice()).expect("inflation failed");
133 debug!("{} bytes deflated to {} ({:.1f}% size)",
134 input.len(), cmp.len(),
135 100.0 * ((cmp.len() as f64) / (input.len() as f64)));
136 assert_eq!(input.as_slice(), out.as_slice());
141 fn test_zlib_flate() {
142 let bytes = vec!(1, 2, 3, 4, 5);
143 let deflated = deflate_bytes(bytes.as_slice()).expect("deflation failed");
144 let inflated = inflate_bytes(deflated.as_slice()).expect("inflation failed");
145 assert_eq!(inflated.as_slice(), bytes.as_slice());