1#![doc(html_root_url = "https://docs.rs/lzip-sys/")]
2
3extern crate libc;
4
5use libc::{c_char, c_int, c_uint, c_ulonglong};
6
7pub const LZ_API_VERSION: u32 = 1013;
8pub const LZ_VERSION_STRING: &[u8; 5usize] = b"1.13\0";
9
10pub const LZ_ERRNO_LZ_OK: LzErrno = 0;
11pub const LZ_ERRNO_LZ_BAD_ARGUMENT: LzErrno = 1;
12pub const LZ_ERRNO_LZ_MEM_ERROR: LzErrno = 2;
13pub const LZ_ERRNO_LZ_SEQUENCE_ERROR: LzErrno = 3;
14pub const LZ_ERRNO_LZ_HEADER_ERROR: LzErrno = 4;
15pub const LZ_ERRNO_LZ_UNEXPECTED_EOF: LzErrno = 5;
16pub const LZ_ERRNO_LZ_DATA_ERROR: LzErrno = 6;
17pub const LZ_ERRNO_LZ_LIBRARY_ERROR: LzErrno = 7;
18
19pub type BitModel = c_int;
20pub type LzErrno = c_uint;
21pub type LzipHeader = [u8; 6usize];
22pub type State = c_int;
23
24#[repr(C)]
25#[derive(Debug, Copy, Clone)]
26pub struct LzmaOptions {
27 pub dictionary_size: c_int,
28 pub match_len_limit: c_int,
29}
30
31#[repr(C)]
32#[derive(Debug, Copy, Clone)]
33pub struct LenModel {
34 pub choice1: BitModel,
35 pub choice2: BitModel,
36 pub bm_low: [[BitModel; 8usize]; 4usize],
37 pub bm_mid: [[BitModel; 8usize]; 4usize],
38 pub bm_high: [BitModel; 256usize],
39}
40
41#[repr(C)]
42#[derive(Debug, Copy, Clone)]
43pub struct CircularBuffer {
44 pub buffer: *mut u8,
45 pub buffer_size: c_uint,
46 pub get: c_uint,
47 pub put: c_uint,
48}
49
50#[repr(C)]
51#[derive(Debug, Copy, Clone)]
52pub struct RangeDecoder {
53 pub cb: CircularBuffer,
54 pub member_position: c_ulonglong,
55 pub code: u32,
56 pub range: u32,
57 pub at_stream_end: bool,
58 pub reload_pending: bool,
59}
60
61#[repr(C)]
62#[derive(Debug, Copy, Clone)]
63pub struct LZ_decoder {
64 pub cb: CircularBuffer,
65 pub partial_data_pos: c_ulonglong,
66 pub rdec: *mut RangeDecoder,
67 pub dictionary_size: c_uint,
68 pub crc: u32,
69 pub member_finished: bool,
70 pub verify_trailer_pending: bool,
71 pub pos_wrapped: bool,
72 pub rep0: c_uint,
73 pub rep1: c_uint,
74 pub rep2: c_uint,
75 pub rep3: c_uint,
76 pub state: State,
77 pub bm_literal: [[BitModel; 768usize]; 8usize],
78 pub bm_match: [[BitModel; 4usize]; 12usize],
79 pub bm_rep: [BitModel; 12usize],
80 pub bm_rep0: [BitModel; 12usize],
81 pub bm_rep1: [BitModel; 12usize],
82 pub bm_rep2: [BitModel; 12usize],
83 pub bm_len: [[BitModel; 4usize]; 12usize],
84 pub bm_dis_slot: [[BitModel; 64usize]; 4usize],
85 pub bm_dis: [BitModel; 115usize],
86 pub bm_align: [BitModel; 16usize],
87 pub match_len_model: LenModel,
88 pub rep_len_model: LenModel,
89}
90
91#[repr(C)]
92#[derive(Debug, Copy, Clone)]
93pub struct MatchfinderBase {
94 pub partial_data_pos: c_ulonglong,
95 pub buffer: *mut u8,
96 pub prev_positions: *mut i32,
97 pub pos_array: *mut i32,
98 pub before_size: c_int,
99 pub after_size: c_int,
100 pub buffer_size: c_int,
101 pub dictionary_size: c_int,
102 pub pos: c_int,
103 pub cyclic_pos: c_int,
104 pub stream_pos: c_int,
105 pub pos_limit: c_int,
106 pub key4_mask: c_int,
107 pub num_prev_positions23: c_int,
108 pub num_prev_positions: c_int,
109 pub pos_array_size: c_int,
110 pub saved_dictionary_size: c_int,
111 pub at_stream_end: bool,
112 pub sync_flush_pending: bool,
113}
114
115#[repr(C)]
116#[derive(Debug, Copy, Clone)]
117pub struct RangeEncoder {
118 pub cb: CircularBuffer,
119 pub min_free_bytes: c_uint,
120 pub low: u64,
121 pub partial_member_pos: c_ulonglong,
122 pub range: u32,
123 pub ff_count: c_uint,
124 pub cache: u8,
125 pub header: LzipHeader,
126}
127
128#[repr(C)]
129#[derive(Debug, Copy, Clone)]
130pub struct LzEncoderBase {
131 pub mb: MatchfinderBase,
132 pub member_size_limit: c_ulonglong,
133 pub crc: u32,
134 pub bm_literal: [[BitModel; 768usize]; 8usize],
135 pub bm_match: [[BitModel; 4usize]; 12usize],
136 pub bm_rep: [BitModel; 12usize],
137 pub bm_rep0: [BitModel; 12usize],
138 pub bm_rep1: [BitModel; 12usize],
139 pub bm_rep2: [BitModel; 12usize],
140 pub bm_len: [[BitModel; 4usize]; 12usize],
141 pub bm_dis_slot: [[BitModel; 64usize]; 4usize],
142 pub bm_dis: [BitModel; 115usize],
143 pub bm_align: [BitModel; 16usize],
144 pub match_len_model: LenModel,
145 pub rep_len_model: LenModel,
146 pub renc: RangeEncoder,
147 pub reps: [c_int; 4usize],
148 pub state: State,
149 pub member_finished: bool,
150}
151
152#[repr(C)]
153#[derive(Debug, Copy, Clone)]
154pub struct LenPrices {
155 pub lm: *const LenModel,
156 pub len_symbols: c_int,
157 pub count: c_int,
158 pub prices: [[c_int; 272usize]; 4usize],
159 pub counters: [c_int; 4usize],
160}
161
162#[repr(C)]
163#[derive(Debug, Copy, Clone)]
164pub struct Pair {
165 pub dis: c_int,
166 pub len: c_int,
167}
168
169#[repr(C)]
170#[derive(Debug, Copy, Clone)]
171pub struct Trial {
172 pub state: State,
173 pub price: c_int,
174 pub dis4: c_int,
175 pub prev_index: c_int,
176 pub prev_index2: c_int,
177 pub reps: [c_int; 4usize],
178}
179
180#[repr(C)]
181#[derive(Debug, Copy, Clone)]
182pub struct LZ_encoder {
183 pub eb: LzEncoderBase,
184 pub cycles: c_int,
185 pub match_len_limit: c_int,
186 pub match_len_prices: LenPrices,
187 pub rep_len_prices: LenPrices,
188 pub pending_num_pairs: c_int,
189 pub pairs: [Pair; 274usize],
190 pub trials: [Trial; 8192usize],
191 pub dis_slot_prices: [[c_int; 58usize]; 4usize],
192 pub dis_prices: [[c_int; 128usize]; 4usize],
193 pub align_prices: [c_int; 16usize],
194 pub num_dis_slots: c_int,
195 pub price_counter: c_int,
196 pub dis_price_counter: c_int,
197 pub align_price_counter: c_int,
198 pub been_flushed: bool,
199}
200
201#[repr(C)]
202#[derive(Debug, Copy, Clone)]
203pub struct FlzEncoder {
204 pub eb: LzEncoderBase,
205 pub key4: c_uint,
206}
207
208#[repr(C)]
209#[derive(Debug, Copy, Clone)]
210pub struct LZ_Encoder {
211 pub partial_in_size: c_ulonglong,
212 pub partial_out_size: c_ulonglong,
213 pub lz_encoder_base: *mut LzEncoderBase,
214 pub lz_encoder: *mut LZ_encoder,
215 pub flz_encoder: *mut FlzEncoder,
216 pub lz_errno: LzErrno,
217 pub fatal: bool,
218}
219
220#[repr(C)]
221#[derive(Debug, Copy, Clone)]
222pub struct LZ_Decoder {
223 pub partial_in_size: c_ulonglong,
224 pub partial_out_size: c_ulonglong,
225 pub rdec: *mut RangeDecoder,
226 pub lz_decoder: *mut LZ_decoder,
227 pub lz_errno: LzErrno,
228 pub member_header: LzipHeader,
229 pub fatal: bool,
230 pub first_header: bool,
231 pub seeking: bool,
232}
233
234extern "C" {
235 pub fn LZ_api_version() -> c_int;
236 pub fn LZ_version() -> *const c_char;
237
238 pub fn LZ_strerror(lz_errno: LzErrno) -> *const c_char;
239 pub fn LZ_min_dictionary_bits() -> c_int;
240 pub fn LZ_min_dictionary_size() -> c_int;
241 pub fn LZ_max_dictionary_bits() -> c_int;
242 pub fn LZ_max_dictionary_size() -> c_int;
243 pub fn LZ_min_match_len_limit() -> c_int;
244 pub fn LZ_max_match_len_limit() -> c_int;
245
246 pub fn LZ_compress_open(
247 dictionary_size: c_int,
248 match_len_limit: c_int,
249 member_size: c_ulonglong,
250 ) -> *mut LZ_Encoder;
251 pub fn LZ_compress_close(encoder: *mut LZ_Encoder) -> c_int;
252 pub fn LZ_compress_finish(encoder: *mut LZ_Encoder) -> c_int;
253 pub fn LZ_compress_restart_member(encoder: *mut LZ_Encoder, member_size: c_ulonglong) -> c_int;
254 pub fn LZ_compress_sync_flush(encoder: *mut LZ_Encoder) -> c_int;
255 pub fn LZ_compress_read(encoder: *mut LZ_Encoder, buffer: *mut u8, size: c_int) -> c_int;
256 pub fn LZ_compress_write(encoder: *mut LZ_Encoder, buffer: *const u8, size: c_int) -> c_int;
257 pub fn LZ_compress_write_size(encoder: *mut LZ_Encoder) -> c_int;
258 pub fn LZ_compress_errno(encoder: *mut LZ_Encoder) -> LzErrno;
259 pub fn LZ_compress_finished(encoder: *mut LZ_Encoder) -> c_int;
260 pub fn LZ_compress_member_finished(encoder: *mut LZ_Encoder) -> c_int;
261 pub fn LZ_compress_data_position(encoder: *mut LZ_Encoder) -> c_ulonglong;
262 pub fn LZ_compress_member_position(encoder: *mut LZ_Encoder) -> c_ulonglong;
263 pub fn LZ_compress_total_in_size(encoder: *mut LZ_Encoder) -> c_ulonglong;
264 pub fn LZ_compress_total_out_size(encoder: *mut LZ_Encoder) -> c_ulonglong;
265
266 pub fn LZ_decompress_open() -> *mut LZ_Decoder;
267 pub fn LZ_decompress_close(decoder: *mut LZ_Decoder) -> c_int;
268 pub fn LZ_decompress_finish(decoder: *mut LZ_Decoder) -> c_int;
269 pub fn LZ_decompress_reset(decoder: *mut LZ_Decoder) -> c_int;
270 pub fn LZ_decompress_sync_to_member(decoder: *mut LZ_Decoder) -> c_int;
271 pub fn LZ_decompress_read(decoder: *mut LZ_Decoder, buffer: *mut u8, size: c_int) -> c_int;
272 pub fn LZ_decompress_write(decoder: *mut LZ_Decoder, buffer: *const u8, size: c_int) -> c_int;
273 pub fn LZ_decompress_write_size(decoder: *mut LZ_Decoder) -> c_int;
274 pub fn LZ_decompress_errno(decoder: *mut LZ_Decoder) -> LzErrno;
275 pub fn LZ_decompress_finished(decoder: *mut LZ_Decoder) -> c_int;
276 pub fn LZ_decompress_member_finished(decoder: *mut LZ_Decoder) -> c_int;
277 pub fn LZ_decompress_member_version(decoder: *mut LZ_Decoder) -> c_int;
278 pub fn LZ_decompress_dictionary_size(decoder: *mut LZ_Decoder) -> c_int;
279 pub fn LZ_decompress_data_crc(decoder: *mut LZ_Decoder) -> c_uint;
280 pub fn LZ_decompress_data_position(decoder: *mut LZ_Decoder) -> c_ulonglong;
281 pub fn LZ_decompress_member_position(decoder: *mut LZ_Decoder) -> c_ulonglong;
282 pub fn LZ_decompress_total_in_size(decoder: *mut LZ_Decoder) -> c_ulonglong;
283 pub fn LZ_decompress_total_out_size(decoder: *mut LZ_Decoder) -> c_ulonglong;
284}