diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/bzip2/bzlib_private.h')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/bzip2/bzlib_private.h | 509 |
1 files changed, 509 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/bzip2/bzlib_private.h b/libraries/irrlicht-1.8/source/Irrlicht/bzip2/bzlib_private.h new file mode 100644 index 0000000..5d0217f --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/bzip2/bzlib_private.h | |||
@@ -0,0 +1,509 @@ | |||
1 | |||
2 | /*-------------------------------------------------------------*/ | ||
3 | /*--- Private header file for the library. ---*/ | ||
4 | /*--- bzlib_private.h ---*/ | ||
5 | /*-------------------------------------------------------------*/ | ||
6 | |||
7 | /* ------------------------------------------------------------------ | ||
8 | This file is part of bzip2/libbzip2, a program and library for | ||
9 | lossless, block-sorting data compression. | ||
10 | |||
11 | bzip2/libbzip2 version 1.0.6 of 6 September 2010 | ||
12 | Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org> | ||
13 | |||
14 | Please read the WARNING, DISCLAIMER and PATENTS sections in the | ||
15 | README file. | ||
16 | |||
17 | This program is released under the terms of the license contained | ||
18 | in the file LICENSE. | ||
19 | ------------------------------------------------------------------ */ | ||
20 | |||
21 | |||
22 | #ifndef _BZLIB_PRIVATE_H | ||
23 | #define _BZLIB_PRIVATE_H | ||
24 | |||
25 | #include <stdlib.h> | ||
26 | |||
27 | #ifndef BZ_NO_STDIO | ||
28 | #include <stdio.h> | ||
29 | #include <ctype.h> | ||
30 | #include <string.h> | ||
31 | #endif | ||
32 | |||
33 | #include "bzlib.h" | ||
34 | |||
35 | |||
36 | |||
37 | /*-- General stuff. --*/ | ||
38 | |||
39 | #define BZ_VERSION "1.0.6, 6-Sept-2010" | ||
40 | |||
41 | typedef char Char; | ||
42 | typedef unsigned char Bool; | ||
43 | typedef unsigned char UChar; | ||
44 | typedef int Int32; | ||
45 | typedef unsigned int UInt32; | ||
46 | typedef short Int16; | ||
47 | typedef unsigned short UInt16; | ||
48 | |||
49 | #define True ((Bool)1) | ||
50 | #define False ((Bool)0) | ||
51 | |||
52 | #ifndef __GNUC__ | ||
53 | #define __inline__ /* */ | ||
54 | #endif | ||
55 | |||
56 | #ifndef BZ_NO_STDIO | ||
57 | |||
58 | extern void BZ2_bz__AssertH__fail ( int errcode ); | ||
59 | #define AssertH(cond,errcode) \ | ||
60 | { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); } | ||
61 | |||
62 | #if BZ_DEBUG | ||
63 | #define AssertD(cond,msg) \ | ||
64 | { if (!(cond)) { \ | ||
65 | fprintf ( stderr, \ | ||
66 | "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\ | ||
67 | exit(1); \ | ||
68 | }} | ||
69 | #else | ||
70 | #define AssertD(cond,msg) /* */ | ||
71 | #endif | ||
72 | |||
73 | #define VPrintf0(zf) \ | ||
74 | fprintf(stderr,zf) | ||
75 | #define VPrintf1(zf,za1) \ | ||
76 | fprintf(stderr,zf,za1) | ||
77 | #define VPrintf2(zf,za1,za2) \ | ||
78 | fprintf(stderr,zf,za1,za2) | ||
79 | #define VPrintf3(zf,za1,za2,za3) \ | ||
80 | fprintf(stderr,zf,za1,za2,za3) | ||
81 | #define VPrintf4(zf,za1,za2,za3,za4) \ | ||
82 | fprintf(stderr,zf,za1,za2,za3,za4) | ||
83 | #define VPrintf5(zf,za1,za2,za3,za4,za5) \ | ||
84 | fprintf(stderr,zf,za1,za2,za3,za4,za5) | ||
85 | |||
86 | #else | ||
87 | |||
88 | extern void bz_internal_error ( int errcode ); | ||
89 | #define AssertH(cond,errcode) \ | ||
90 | { if (!(cond)) bz_internal_error ( errcode ); } | ||
91 | #define AssertD(cond,msg) do { } while (0) | ||
92 | #define VPrintf0(zf) do { } while (0) | ||
93 | #define VPrintf1(zf,za1) do { } while (0) | ||
94 | #define VPrintf2(zf,za1,za2) do { } while (0) | ||
95 | #define VPrintf3(zf,za1,za2,za3) do { } while (0) | ||
96 | #define VPrintf4(zf,za1,za2,za3,za4) do { } while (0) | ||
97 | #define VPrintf5(zf,za1,za2,za3,za4,za5) do { } while (0) | ||
98 | |||
99 | #endif | ||
100 | |||
101 | |||
102 | #define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1) | ||
103 | #define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp)) | ||
104 | |||
105 | |||
106 | /*-- Header bytes. --*/ | ||
107 | |||
108 | #define BZ_HDR_B 0x42 /* 'B' */ | ||
109 | #define BZ_HDR_Z 0x5a /* 'Z' */ | ||
110 | #define BZ_HDR_h 0x68 /* 'h' */ | ||
111 | #define BZ_HDR_0 0x30 /* '0' */ | ||
112 | |||
113 | /*-- Constants for the back end. --*/ | ||
114 | |||
115 | #define BZ_MAX_ALPHA_SIZE 258 | ||
116 | #define BZ_MAX_CODE_LEN 23 | ||
117 | |||
118 | #define BZ_RUNA 0 | ||
119 | #define BZ_RUNB 1 | ||
120 | |||
121 | #define BZ_N_GROUPS 6 | ||
122 | #define BZ_G_SIZE 50 | ||
123 | #define BZ_N_ITERS 4 | ||
124 | |||
125 | #define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE)) | ||
126 | |||
127 | |||
128 | |||
129 | /*-- Stuff for randomising repetitive blocks. --*/ | ||
130 | |||
131 | extern Int32 BZ2_rNums[512]; | ||
132 | |||
133 | #define BZ_RAND_DECLS \ | ||
134 | Int32 rNToGo; \ | ||
135 | Int32 rTPos \ | ||
136 | |||
137 | #define BZ_RAND_INIT_MASK \ | ||
138 | s->rNToGo = 0; \ | ||
139 | s->rTPos = 0 \ | ||
140 | |||
141 | #define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0) | ||
142 | |||
143 | #define BZ_RAND_UPD_MASK \ | ||
144 | if (s->rNToGo == 0) { \ | ||
145 | s->rNToGo = BZ2_rNums[s->rTPos]; \ | ||
146 | s->rTPos++; \ | ||
147 | if (s->rTPos == 512) s->rTPos = 0; \ | ||
148 | } \ | ||
149 | s->rNToGo--; | ||
150 | |||
151 | |||
152 | |||
153 | /*-- Stuff for doing CRCs. --*/ | ||
154 | |||
155 | extern UInt32 BZ2_crc32Table[256]; | ||
156 | |||
157 | #define BZ_INITIALISE_CRC(crcVar) \ | ||
158 | { \ | ||
159 | crcVar = 0xffffffffL; \ | ||
160 | } | ||
161 | |||
162 | #define BZ_FINALISE_CRC(crcVar) \ | ||
163 | { \ | ||
164 | crcVar = ~(crcVar); \ | ||
165 | } | ||
166 | |||
167 | #define BZ_UPDATE_CRC(crcVar,cha) \ | ||
168 | { \ | ||
169 | crcVar = (crcVar << 8) ^ \ | ||
170 | BZ2_crc32Table[(crcVar >> 24) ^ \ | ||
171 | ((UChar)cha)]; \ | ||
172 | } | ||
173 | |||
174 | |||
175 | |||
176 | /*-- States and modes for compression. --*/ | ||
177 | |||
178 | #define BZ_M_IDLE 1 | ||
179 | #define BZ_M_RUNNING 2 | ||
180 | #define BZ_M_FLUSHING 3 | ||
181 | #define BZ_M_FINISHING 4 | ||
182 | |||
183 | #define BZ_S_OUTPUT 1 | ||
184 | #define BZ_S_INPUT 2 | ||
185 | |||
186 | #define BZ_N_RADIX 2 | ||
187 | #define BZ_N_QSORT 12 | ||
188 | #define BZ_N_SHELL 18 | ||
189 | #define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2) | ||
190 | |||
191 | |||
192 | |||
193 | |||
194 | /*-- Structure holding all the compression-side stuff. --*/ | ||
195 | |||
196 | typedef | ||
197 | struct { | ||
198 | /* pointer back to the struct bz_stream */ | ||
199 | bz_stream* strm; | ||
200 | |||
201 | /* mode this stream is in, and whether inputting */ | ||
202 | /* or outputting data */ | ||
203 | Int32 mode; | ||
204 | Int32 state; | ||
205 | |||
206 | /* remembers avail_in when flush/finish requested */ | ||
207 | UInt32 avail_in_expect; | ||
208 | |||
209 | /* for doing the block sorting */ | ||
210 | UInt32* arr1; | ||
211 | UInt32* arr2; | ||
212 | UInt32* ftab; | ||
213 | Int32 origPtr; | ||
214 | |||
215 | /* aliases for arr1 and arr2 */ | ||
216 | UInt32* ptr; | ||
217 | UChar* block; | ||
218 | UInt16* mtfv; | ||
219 | UChar* zbits; | ||
220 | |||
221 | /* for deciding when to use the fallback sorting algorithm */ | ||
222 | Int32 workFactor; | ||
223 | |||
224 | /* run-length-encoding of the input */ | ||
225 | UInt32 state_in_ch; | ||
226 | Int32 state_in_len; | ||
227 | BZ_RAND_DECLS; | ||
228 | |||
229 | /* input and output limits and current posns */ | ||
230 | Int32 nblock; | ||
231 | Int32 nblockMAX; | ||
232 | Int32 numZ; | ||
233 | Int32 state_out_pos; | ||
234 | |||
235 | /* map of bytes used in block */ | ||
236 | Int32 nInUse; | ||
237 | Bool inUse[256]; | ||
238 | UChar unseqToSeq[256]; | ||
239 | |||
240 | /* the buffer for bit stream creation */ | ||
241 | UInt32 bsBuff; | ||
242 | Int32 bsLive; | ||
243 | |||
244 | /* block and combined CRCs */ | ||
245 | UInt32 blockCRC; | ||
246 | UInt32 combinedCRC; | ||
247 | |||
248 | /* misc administratium */ | ||
249 | Int32 verbosity; | ||
250 | Int32 blockNo; | ||
251 | Int32 blockSize100k; | ||
252 | |||
253 | /* stuff for coding the MTF values */ | ||
254 | Int32 nMTF; | ||
255 | Int32 mtfFreq [BZ_MAX_ALPHA_SIZE]; | ||
256 | UChar selector [BZ_MAX_SELECTORS]; | ||
257 | UChar selectorMtf[BZ_MAX_SELECTORS]; | ||
258 | |||
259 | UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
260 | Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
261 | Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
262 | /* second dimension: only 3 needed; 4 makes index calculations faster */ | ||
263 | UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4]; | ||
264 | |||
265 | } | ||
266 | EState; | ||
267 | |||
268 | |||
269 | |||
270 | /*-- externs for compression. --*/ | ||
271 | |||
272 | extern void | ||
273 | BZ2_blockSort ( EState* ); | ||
274 | |||
275 | extern void | ||
276 | BZ2_compressBlock ( EState*, Bool ); | ||
277 | |||
278 | extern void | ||
279 | BZ2_bsInitWrite ( EState* ); | ||
280 | |||
281 | extern void | ||
282 | BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 ); | ||
283 | |||
284 | extern void | ||
285 | BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 ); | ||
286 | |||
287 | |||
288 | |||
289 | /*-- states for decompression. --*/ | ||
290 | |||
291 | #define BZ_X_IDLE 1 | ||
292 | #define BZ_X_OUTPUT 2 | ||
293 | |||
294 | #define BZ_X_MAGIC_1 10 | ||
295 | #define BZ_X_MAGIC_2 11 | ||
296 | #define BZ_X_MAGIC_3 12 | ||
297 | #define BZ_X_MAGIC_4 13 | ||
298 | #define BZ_X_BLKHDR_1 14 | ||
299 | #define BZ_X_BLKHDR_2 15 | ||
300 | #define BZ_X_BLKHDR_3 16 | ||
301 | #define BZ_X_BLKHDR_4 17 | ||
302 | #define BZ_X_BLKHDR_5 18 | ||
303 | #define BZ_X_BLKHDR_6 19 | ||
304 | #define BZ_X_BCRC_1 20 | ||
305 | #define BZ_X_BCRC_2 21 | ||
306 | #define BZ_X_BCRC_3 22 | ||
307 | #define BZ_X_BCRC_4 23 | ||
308 | #define BZ_X_RANDBIT 24 | ||
309 | #define BZ_X_ORIGPTR_1 25 | ||
310 | #define BZ_X_ORIGPTR_2 26 | ||
311 | #define BZ_X_ORIGPTR_3 27 | ||
312 | #define BZ_X_MAPPING_1 28 | ||
313 | #define BZ_X_MAPPING_2 29 | ||
314 | #define BZ_X_SELECTOR_1 30 | ||
315 | #define BZ_X_SELECTOR_2 31 | ||
316 | #define BZ_X_SELECTOR_3 32 | ||
317 | #define BZ_X_CODING_1 33 | ||
318 | #define BZ_X_CODING_2 34 | ||
319 | #define BZ_X_CODING_3 35 | ||
320 | #define BZ_X_MTF_1 36 | ||
321 | #define BZ_X_MTF_2 37 | ||
322 | #define BZ_X_MTF_3 38 | ||
323 | #define BZ_X_MTF_4 39 | ||
324 | #define BZ_X_MTF_5 40 | ||
325 | #define BZ_X_MTF_6 41 | ||
326 | #define BZ_X_ENDHDR_2 42 | ||
327 | #define BZ_X_ENDHDR_3 43 | ||
328 | #define BZ_X_ENDHDR_4 44 | ||
329 | #define BZ_X_ENDHDR_5 45 | ||
330 | #define BZ_X_ENDHDR_6 46 | ||
331 | #define BZ_X_CCRC_1 47 | ||
332 | #define BZ_X_CCRC_2 48 | ||
333 | #define BZ_X_CCRC_3 49 | ||
334 | #define BZ_X_CCRC_4 50 | ||
335 | |||
336 | |||
337 | |||
338 | /*-- Constants for the fast MTF decoder. --*/ | ||
339 | |||
340 | #define MTFA_SIZE 4096 | ||
341 | #define MTFL_SIZE 16 | ||
342 | |||
343 | |||
344 | |||
345 | /*-- Structure holding all the decompression-side stuff. --*/ | ||
346 | |||
347 | typedef | ||
348 | struct { | ||
349 | /* pointer back to the struct bz_stream */ | ||
350 | bz_stream* strm; | ||
351 | |||
352 | /* state indicator for this stream */ | ||
353 | Int32 state; | ||
354 | |||
355 | /* for doing the final run-length decoding */ | ||
356 | UChar state_out_ch; | ||
357 | Int32 state_out_len; | ||
358 | Bool blockRandomised; | ||
359 | BZ_RAND_DECLS; | ||
360 | |||
361 | /* the buffer for bit stream reading */ | ||
362 | UInt32 bsBuff; | ||
363 | Int32 bsLive; | ||
364 | |||
365 | /* misc administratium */ | ||
366 | Int32 blockSize100k; | ||
367 | Bool smallDecompress; | ||
368 | Int32 currBlockNo; | ||
369 | Int32 verbosity; | ||
370 | |||
371 | /* for undoing the Burrows-Wheeler transform */ | ||
372 | Int32 origPtr; | ||
373 | UInt32 tPos; | ||
374 | Int32 k0; | ||
375 | Int32 unzftab[256]; | ||
376 | Int32 nblock_used; | ||
377 | Int32 cftab[257]; | ||
378 | Int32 cftabCopy[257]; | ||
379 | |||
380 | /* for undoing the Burrows-Wheeler transform (FAST) */ | ||
381 | UInt32 *tt; | ||
382 | |||
383 | /* for undoing the Burrows-Wheeler transform (SMALL) */ | ||
384 | UInt16 *ll16; | ||
385 | UChar *ll4; | ||
386 | |||
387 | /* stored and calculated CRCs */ | ||
388 | UInt32 storedBlockCRC; | ||
389 | UInt32 storedCombinedCRC; | ||
390 | UInt32 calculatedBlockCRC; | ||
391 | UInt32 calculatedCombinedCRC; | ||
392 | |||
393 | /* map of bytes used in block */ | ||
394 | Int32 nInUse; | ||
395 | Bool inUse[256]; | ||
396 | Bool inUse16[16]; | ||
397 | UChar seqToUnseq[256]; | ||
398 | |||
399 | /* for decoding the MTF values */ | ||
400 | UChar mtfa [MTFA_SIZE]; | ||
401 | Int32 mtfbase[256 / MTFL_SIZE]; | ||
402 | UChar selector [BZ_MAX_SELECTORS]; | ||
403 | UChar selectorMtf[BZ_MAX_SELECTORS]; | ||
404 | UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
405 | |||
406 | Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
407 | Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
408 | Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; | ||
409 | Int32 minLens[BZ_N_GROUPS]; | ||
410 | |||
411 | /* save area for scalars in the main decompress code */ | ||
412 | Int32 save_i; | ||
413 | Int32 save_j; | ||
414 | Int32 save_t; | ||
415 | Int32 save_alphaSize; | ||
416 | Int32 save_nGroups; | ||
417 | Int32 save_nSelectors; | ||
418 | Int32 save_EOB; | ||
419 | Int32 save_groupNo; | ||
420 | Int32 save_groupPos; | ||
421 | Int32 save_nextSym; | ||
422 | Int32 save_nblockMAX; | ||
423 | Int32 save_nblock; | ||
424 | Int32 save_es; | ||
425 | Int32 save_N; | ||
426 | Int32 save_curr; | ||
427 | Int32 save_zt; | ||
428 | Int32 save_zn; | ||
429 | Int32 save_zvec; | ||
430 | Int32 save_zj; | ||
431 | Int32 save_gSel; | ||
432 | Int32 save_gMinlen; | ||
433 | Int32* save_gLimit; | ||
434 | Int32* save_gBase; | ||
435 | Int32* save_gPerm; | ||
436 | |||
437 | } | ||
438 | DState; | ||
439 | |||
440 | |||
441 | |||
442 | /*-- Macros for decompression. --*/ | ||
443 | |||
444 | #define BZ_GET_FAST(cccc) \ | ||
445 | /* c_tPos is unsigned, hence test < 0 is pointless. */ \ | ||
446 | if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \ | ||
447 | s->tPos = s->tt[s->tPos]; \ | ||
448 | cccc = (UChar)(s->tPos & 0xff); \ | ||
449 | s->tPos >>= 8; | ||
450 | |||
451 | #define BZ_GET_FAST_C(cccc) \ | ||
452 | /* c_tPos is unsigned, hence test < 0 is pointless. */ \ | ||
453 | if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \ | ||
454 | c_tPos = c_tt[c_tPos]; \ | ||
455 | cccc = (UChar)(c_tPos & 0xff); \ | ||
456 | c_tPos >>= 8; | ||
457 | |||
458 | #define SET_LL4(i,n) \ | ||
459 | { if (((i) & 0x1) == 0) \ | ||
460 | s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \ | ||
461 | s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \ | ||
462 | } | ||
463 | |||
464 | #define GET_LL4(i) \ | ||
465 | ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF) | ||
466 | |||
467 | #define SET_LL(i,n) \ | ||
468 | { s->ll16[i] = (UInt16)(n & 0x0000ffff); \ | ||
469 | SET_LL4(i, n >> 16); \ | ||
470 | } | ||
471 | |||
472 | #define GET_LL(i) \ | ||
473 | (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16)) | ||
474 | |||
475 | #define BZ_GET_SMALL(cccc) \ | ||
476 | /* c_tPos is unsigned, hence test < 0 is pointless. */ \ | ||
477 | if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \ | ||
478 | cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \ | ||
479 | s->tPos = GET_LL(s->tPos); | ||
480 | |||
481 | |||
482 | /*-- externs for decompression. --*/ | ||
483 | |||
484 | extern Int32 | ||
485 | BZ2_indexIntoF ( Int32, Int32* ); | ||
486 | |||
487 | extern Int32 | ||
488 | BZ2_decompress ( DState* ); | ||
489 | |||
490 | extern void | ||
491 | BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*, | ||
492 | Int32, Int32, Int32 ); | ||
493 | |||
494 | |||
495 | #endif | ||
496 | |||
497 | |||
498 | /*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/ | ||
499 | |||
500 | #ifdef BZ_NO_STDIO | ||
501 | #ifndef NULL | ||
502 | #define NULL 0 | ||
503 | #endif | ||
504 | #endif | ||
505 | |||
506 | |||
507 | /*-------------------------------------------------------------*/ | ||
508 | /*--- end bzlib_private.h ---*/ | ||
509 | /*-------------------------------------------------------------*/ | ||