brotli-decompressor 6.2.0

A brotli decompressor that with an interface avoiding the rust stdlib. This makes it suitable for embedded devices and kernels. It is designed with a pluggable allocator so that the standard lib's allocator may be employed. The default build also includes a stdlib allocator and stream interface. Disable this with --features=no-stdlib. Alternatively, --features=unsafe turns off array bounds checks and memory initialization but provides a safe interface for the caller. Without adding the --features=unsafe argument, all included code is safe. For compression in addition to this library, download https://github.com/dropbox/rust-brotli
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use ::BrotliResult;
#[allow(non_camel_case_types)]
#[repr(u8)]
pub enum c_void{
    _Nothing = 0,
}

// Defined with BrotliState::set_parameter, which the C API wraps.
pub use ::state::BrotliDecoderParameter;


#[repr(C)]
#[allow(dead_code)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum BrotliSharedDictionaryType {
    // Raw LZ77 prefix dictionary.
    BROTLI_SHARED_DICTIONARY_RAW = 0,
    // Serialized shared dictionary in the 0x91 0x00 shared-brotli container.
    BROTLI_SHARED_DICTIONARY_SERIALIZED = 1,
}

#[repr(C)]
pub enum BrotliDecoderResult {
    BROTLI_DECODER_RESULT_ERROR = 0,
    BROTLI_DECODER_RESULT_SUCCESS = 1,
    BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2,
    BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3,
}

pub type brotli_decoder_metadata_start_func = Option<extern "C" fn(opaque: *mut c_void, size: usize) -> ()>;
pub type brotli_decoder_metadata_chunk_func = Option<extern "C" fn(opaque: *mut c_void, data: *const u8, size: usize) -> ()>;

#[derive(Clone, Copy)]
pub(crate) struct CBrotliMetadataCallback {
    start: brotli_decoder_metadata_start_func,
    chunk: brotli_decoder_metadata_chunk_func,
    opaque: *mut c_void,
}

impl CBrotliMetadataCallback {
    pub(crate) fn new(
        start: brotli_decoder_metadata_start_func,
        chunk: brotli_decoder_metadata_chunk_func,
        opaque: *mut c_void,
    ) -> CBrotliMetadataCallback {
        CBrotliMetadataCallback {
            start, chunk, opaque
        }
    }
}

impl ::state::BrotliMetadataCallback for CBrotliMetadataCallback {
    fn start(&mut self, size: usize) {
        if let Some(callback) = self.start {
            callback(self.opaque, size);
        }
    }
    fn chunk(&mut self, data: &[u8]) {
        if let Some(callback) = self.chunk {
            callback(self.opaque, data.as_ptr(), data.len());
        }
    }
}


impl From<BrotliResult> for BrotliDecoderResult {
  fn from(r: BrotliResult) -> Self {
    match r {
      BrotliResult::ResultSuccess => BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS,
      BrotliResult::ResultFailure => BrotliDecoderResult::BROTLI_DECODER_RESULT_ERROR,
      BrotliResult::NeedsMoreInput => BrotliDecoderResult::BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT ,
      BrotliResult::NeedsMoreOutput => BrotliDecoderResult::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT ,
    }
  }
}
pub type brotli_alloc_func = Option<extern "C" fn(data: *mut c_void, size: usize) -> *mut c_void>;

pub type brotli_free_func = Option<extern "C" fn(data: *mut c_void, ptr: *mut c_void) -> ()>;


#[repr(C)]
#[derive(Clone)]
pub struct CAllocator {
    pub alloc_func: brotli_alloc_func,
    pub free_func: brotli_free_func,
    pub opaque: *mut c_void,
}

unsafe impl Send for CAllocator {
}