The Tor Browser / file comparison

comparison: modules/libbz2/src/bzlib_private.h

modules/libbz2/src/bzlib_private.h

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:aca660157fa3
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.4 of 20 December 2006
12 Copyright (C) 1996-2006 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.4, 20-Dec-2006"
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 s->tPos = s->tt[s->tPos]; \
446 cccc = (UChar)(s->tPos & 0xff); \
447 s->tPos >>= 8;
448
449 #define BZ_GET_FAST_C(cccc) \
450 c_tPos = c_tt[c_tPos]; \
451 cccc = (UChar)(c_tPos & 0xff); \
452 c_tPos >>= 8;
453
454 #define SET_LL4(i,n) \
455 { if (((i) & 0x1) == 0) \
456 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \
457 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \
458 }
459
460 #define GET_LL4(i) \
461 ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF)
462
463 #define SET_LL(i,n) \
464 { s->ll16[i] = (UInt16)(n & 0x0000ffff); \
465 SET_LL4(i, n >> 16); \
466 }
467
468 #define GET_LL(i) \
469 (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16))
470
471 #define BZ_GET_SMALL(cccc) \
472 cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \
473 s->tPos = GET_LL(s->tPos);
474
475
476 /*-- externs for decompression. --*/
477
478 extern Int32
479 BZ2_indexIntoF ( Int32, Int32* );
480
481 extern Int32
482 BZ2_decompress ( DState* );
483
484 extern void
485 BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
486 Int32, Int32, Int32 );
487
488
489 #endif
490
491
492 /*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
493
494 #ifdef BZ_NO_STDIO
495 #ifndef NULL
496 #define NULL 0
497 #endif
498 #endif
499
500
501 /*-------------------------------------------------------------*/
502 /*--- end bzlib_private.h ---*/
503 /*-------------------------------------------------------------*/

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial