src/libflate/lib.rs

   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.
   4 //
   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.
  10
  11 //! Simple [DEFLATE][def]-based compression. This is a wrapper around the
  12 //! [`miniz`][mz] library, which is a one-file pure-C implementation of zlib.
  13 //!
  14 //! [def]: https://en.wikipedia.org/wiki/DEFLATE
  15 //! [mz]: https://code.google.com/p/miniz/
  16
  17 #![crate_name = "flate"]
  18 #![experimental]
  19 #![crate_type = "rlib"]
  20 #![crate_type = "dylib"]
  21 #![license = "MIT/ASL2"]
  22 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
  23        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
  24        html_root_url = "http://doc.rust-lang.org/nightly/")]
  25 #![feature(phase)]
  26
  27 #[cfg(test)] #[phase(plugin, link)] extern crate log;
  28
  29 extern crate libc;
  30
  31 use std::c_vec::CVec;
  32 use libc::{c_void, size_t, c_int};
  33
  34 #[link(name = "miniz", kind = "static")]
  35 extern {
  36     /// Raw miniz compression function.
  37     fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
  38                                   src_buf_len: size_t,
  39                                   pout_len: *mut size_t,
  40                                   flags: c_int)
  41                                   -> *mut c_void;
  42
  43     /// Raw miniz decompression function.
  44     fn tinfl_decompress_mem_to_heap(psrc_buf: *const c_void,
  45                                     src_buf_len: size_t,
  46                                     pout_len: *mut size_t,
  47                                     flags: c_int)
  48                                     -> *mut c_void;
  49 }
  50
  51 static LZ_NORM : c_int = 0x80;  // LZ with 128 probes, "normal"
  52 static TINFL_FLAG_PARSE_ZLIB_HEADER : c_int = 0x1; // parse zlib header and adler32 checksum
  53 static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum
  54
  55 fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> Option<CVec<u8>> {
  56     unsafe {
  57         let mut outsz : size_t = 0;
  58         let res = tdefl_compress_mem_to_heap(bytes.as_ptr() as *const _,
  59                                              bytes.len() as size_t,
  60                                              &mut outsz,
  61                                              flags);
  62         if !res.is_null() {
  63             Some(CVec::new_with_dtor(res as *mut u8, outsz as uint, proc() libc::free(res)))
  64         } else {
  65             None
  66         }
  67     }
  68 }
  69
  70 /// Compress a buffer, without writing any sort of header on the output.
  71 pub fn deflate_bytes(bytes: &[u8]) -> Option<CVec<u8>> {
  72     deflate_bytes_internal(bytes, LZ_NORM)
  73 }
  74
  75 /// Compress a buffer, using a header that zlib can understand.
  76 pub fn deflate_bytes_zlib(bytes: &[u8]) -> Option<CVec<u8>> {
  77     deflate_bytes_internal(bytes, LZ_NORM | TDEFL_WRITE_ZLIB_HEADER)
  78 }
  79
  80 fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> Option<CVec<u8>> {
  81     unsafe {
  82         let mut outsz : size_t = 0;
  83         let res = tinfl_decompress_mem_to_heap(bytes.as_ptr() as *const _,
  84                                                bytes.len() as size_t,
  85                                                &mut outsz,
  86                                                flags);
  87         if !res.is_null() {
  88             Some(CVec::new_with_dtor(res as *mut u8, outsz as uint, proc() libc::free(res)))
  89         } else {
  90             None
  91         }
  92     }
  93 }
  94
  95 /// Decompress a buffer, without parsing any sort of header on the input.
  96 pub fn inflate_bytes(bytes: &[u8]) -> Option<CVec<u8>> {
  97     inflate_bytes_internal(bytes, 0)
  98 }
  99
 100 /// Decompress a buffer that starts with a zlib header.
 101 pub fn inflate_bytes_zlib(bytes: &[u8]) -> Option<CVec<u8>> {
 102     inflate_bytes_internal(bytes, TINFL_FLAG_PARSE_ZLIB_HEADER)
 103 }
 104
 105 #[cfg(test)]
 106 mod tests {
 107     use super::{inflate_bytes, deflate_bytes};
 108     use std::rand;
 109     use std::rand::Rng;
 110
 111     #[test]
 112     fn test_flate_round_trip() {
 113         let mut r = rand::task_rng();
 114         let mut words = vec!();
 115         for _ in range(0u, 20) {
 116             let range = r.gen_range(1u, 10);
 117             let v = r.gen_iter::<u8>().take(range).collect::<Vec<u8>>();
 118             words.push(v);
 119         }
 120         for _ in range(0u, 20) {
 121             let mut input = vec![];
 122             for _ in range(0u, 2000) {
 123                 input.push_all(r.choose(words.as_slice()).unwrap().as_slice());
 124             }
 125             debug!("de/inflate of {} bytes of random word-sequences",
 126                    input.len());
 127             let cmp = deflate_bytes(input.as_slice()).expect("deflation failed");
 128             let out = inflate_bytes(cmp.as_slice()).expect("inflation failed");
 129             debug!("{} bytes deflated to {} ({:.1}% size)",
 130                    input.len(), cmp.len(),
 131                    100.0 * ((cmp.len() as f64) / (input.len() as f64)));
 132             assert_eq!(input.as_slice(), out.as_slice());
 133         }
 134     }
 135
 136     #[test]
 137     fn test_zlib_flate() {
 138         let bytes = vec!(1, 2, 3, 4, 5);
 139         let deflated = deflate_bytes(bytes.as_slice()).expect("deflation failed");
 140         let inflated = inflate_bytes(deflated.as_slice()).expect("inflation failed");
 141         assert_eq!(inflated.as_slice(), bytes.as_slice());
 142     }
 143 }