pub use self::imp::*;
#[cfg(feature = "zlib")]
#[allow(bad_style)]
mod imp {
extern crate libz_sys as z;
use std::mem;
use std::ops::{Deref, DerefMut};
use libc::{c_int, size_t, c_ulong, c_uint, c_char};
pub use self::z::*;
pub use self::z::deflateEnd as mz_deflateEnd;
pub use self::z::inflateEnd as mz_inflateEnd;
pub use self::z::deflateReset as mz_deflateReset;
pub use self::z::deflate as mz_deflate;
pub use self::z::inflate as mz_inflate;
pub use self::z::z_stream as mz_stream;
pub use self::z::Z_BLOCK as MZ_BLOCK;
pub use self::z::Z_BUF_ERROR as MZ_BUF_ERROR;
pub use self::z::Z_DATA_ERROR as MZ_DATA_ERROR;
pub use self::z::Z_DEFAULT_STRATEGY as MZ_DEFAULT_STRATEGY;
pub use self::z::Z_DEFLATED as MZ_DEFLATED;
pub use self::z::Z_FINISH as MZ_FINISH;
pub use self::z::Z_FULL_FLUSH as MZ_FULL_FLUSH;
pub use self::z::Z_NO_FLUSH as MZ_NO_FLUSH;
pub use self::z::Z_OK as MZ_OK;
pub use self::z::Z_PARTIAL_FLUSH as MZ_PARTIAL_FLUSH;
pub use self::z::Z_STREAM_END as MZ_STREAM_END;
pub use self::z::Z_SYNC_FLUSH as MZ_SYNC_FLUSH;
pub use self::z::Z_STREAM_ERROR as MZ_STREAM_ERROR;
pub const MZ_DEFAULT_WINDOW_BITS: c_int = 15;
pub unsafe extern fn mz_crc32(crc: c_ulong,
ptr: *const u8,
len: size_t) -> c_ulong {
z::crc32(crc, ptr, len as c_uint)
}
pub unsafe extern fn mz_crc32_combine(crc1: c_ulong,
crc2: c_ulong,
len2: z_off_t) -> c_ulong {
z::crc32_combine(crc1, crc2, len2)
}
const ZLIB_VERSION: &'static str = "1.2.8\0";
pub unsafe extern fn mz_deflateInit2(stream: *mut mz_stream,
level: c_int,
method: c_int,
window_bits: c_int,
mem_level: c_int,
strategy: c_int) -> c_int {
z::deflateInit2_(stream, level, method, window_bits, mem_level,
strategy,
ZLIB_VERSION.as_ptr() as *const c_char,
mem::size_of::<mz_stream>() as c_int)
}
pub unsafe extern fn mz_inflateInit2(stream: *mut mz_stream,
window_bits: c_int)
-> c_int {
z::inflateInit2_(stream, window_bits,
ZLIB_VERSION.as_ptr() as *const c_char,
mem::size_of::<mz_stream>() as c_int)
}
pub struct StreamWrapper{
inner: Box<mz_stream>,
}
impl ::std::fmt::Debug for StreamWrapper{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error>{
write!(f, "StreamWrapper")
}
}
impl Default for StreamWrapper {
fn default() -> StreamWrapper {
StreamWrapper {
inner: Box::new(unsafe{ mem::zeroed() })
}
}
}
impl Deref for StreamWrapper {
type Target = mz_stream;
fn deref(&self) -> &Self::Target {
& *self.inner
}
}
impl DerefMut for StreamWrapper {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut *self.inner
}
}
}
#[cfg(all(not(feature = "zlib"), feature = "rust_backend"))]
mod imp {
extern crate miniz_oxide_c_api;
use std::ops::{Deref, DerefMut};
pub use ffi::crc_imp::*;
pub use self::miniz_oxide_c_api::*;
pub use self::miniz_oxide_c_api::lib_oxide::*;
#[derive(Debug, Default)]
pub struct StreamWrapper {
inner: mz_stream,
}
impl Deref for StreamWrapper {
type Target = mz_stream;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl DerefMut for StreamWrapper {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
}
#[cfg(all(not(feature = "zlib"), not(feature = "rust_backend")))]
mod imp {
extern crate miniz_sys;
use std::mem;
use std::ops::{Deref, DerefMut};
pub use self::miniz_sys::*;
pub use ffi::crc_imp::*;
pub struct StreamWrapper {
inner: mz_stream,
}
impl ::std::fmt::Debug for StreamWrapper{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error>{
write!(f, "StreamWrapper")
}
}
impl Default for StreamWrapper {
fn default() -> StreamWrapper {
StreamWrapper {
inner : unsafe{ mem::zeroed() }
}
}
}
impl Deref for StreamWrapper {
type Target = mz_stream;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl DerefMut for StreamWrapper {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
}
#[cfg(not(feature = "zlib"))]
mod crc_imp {
use libc::{c_ulong, off_t};
pub unsafe extern fn mz_crc32_combine(crc1: c_ulong,
crc2: c_ulong,
len2: off_t) -> c_ulong {
crc32_combine_(crc1, crc2, len2)
}
fn gf2_matrix_times(mat: &[c_ulong; 32], mut vec: c_ulong) -> c_ulong {
let mut sum = 0;
let mut mat_pos = 0;
while vec != 0 {
if vec & 1 == 1 {
sum ^= mat[mat_pos];
}
vec >>= 1;
mat_pos += 1;
}
sum
}
fn gf2_matrix_square(square: &mut [c_ulong; 32], mat: &[c_ulong; 32]) {
for n in 0..32 {
square[n] = gf2_matrix_times(mat, mat[n]);
}
}
fn crc32_combine_(mut crc1: c_ulong, crc2: c_ulong, mut len2: off_t) -> c_ulong {
let mut row;
let mut even = [0; 32];
let mut odd = [0; 32];
if len2 <= 0 {
return crc1;
}
odd[0] = 0xedb88320;
row = 1;
for n in 1..32 {
odd[n] = row;
row <<= 1;
}
gf2_matrix_square(&mut even, &odd);
gf2_matrix_square(&mut odd, &even);
loop {
gf2_matrix_square(&mut even, &odd);
if len2 & 1 == 1 {
crc1 = gf2_matrix_times(&even, crc1);
}
len2 >>= 1;
if len2 == 0 {
break;
}
gf2_matrix_square(&mut odd, &even);
if len2 & 1 == 1 {
crc1 = gf2_matrix_times(&odd, crc1);
}
len2 >>= 1;
if len2 == 0 {
break;
}
}
crc1 ^= crc2;
crc1
}
}
#[test]
fn crc32_combine() {
let crc32 = unsafe {
imp::mz_crc32_combine(1, 2, 3)
};
assert_eq!(crc32, 29518389);
}