Commit | Line | Data |
---|---|---|
bc22c17e AK |
1 | /* vi: set sw = 4 ts = 4: */ |
2 | /* Small bzip2 deflate implementation, by Rob Landley (rob@landley.net). | |
3 | ||
4 | Based on bzip2 decompression code by Julian R Seward (jseward@acm.org), | |
5 | which also acknowledges contributions by Mike Burrows, David Wheeler, | |
6 | Peter Fenwick, Alistair Moffat, Radford Neal, Ian H. Witten, | |
7 | Robert Sedgewick, and Jon L. Bentley. | |
8 | ||
9 | This code is licensed under the LGPLv2: | |
10 | LGPL (http://www.gnu.org/copyleft/lgpl.html | |
11 | */ | |
12 | ||
13 | /* | |
14 | Size and speed optimizations by Manuel Novoa III (mjn3@codepoet.org). | |
15 | ||
16 | More efficient reading of Huffman codes, a streamlined read_bunzip() | |
17 | function, and various other tweaks. In (limited) tests, approximately | |
18 | 20% faster than bzcat on x86 and about 10% faster on arm. | |
19 | ||
20 | Note that about 2/3 of the time is spent in read_unzip() reversing | |
21 | the Burrows-Wheeler transformation. Much of that time is delay | |
22 | resulting from cache misses. | |
23 | ||
24 | I would ask that anyone benefiting from this work, especially those | |
25 | using it in commercial products, consider making a donation to my local | |
26 | non-profit hospice organization in the name of the woman I loved, who | |
27 | passed away Feb. 12, 2003. | |
28 | ||
29 | In memory of Toni W. Hagan | |
30 | ||
31 | Hospice of Acadiana, Inc. | |
32 | 2600 Johnston St., Suite 200 | |
33 | Lafayette, LA 70503-3240 | |
34 | ||
35 | Phone (337) 232-1234 or 1-800-738-2226 | |
36 | Fax (337) 232-1297 | |
37 | ||
38 | http://www.hospiceacadiana.com/ | |
39 | ||
40 | Manuel | |
41 | */ | |
42 | ||
43 | /* | |
44 | Made it fit for running in Linux Kernel by Alain Knaff (alain@knaff.lu) | |
45 | */ | |
46 | ||
47 | ||
48 | #ifndef STATIC | |
49 | #include <linux/decompress/bunzip2.h> | |
50 | #endif /* !STATIC */ | |
51 | ||
52 | #include <linux/decompress/mm.h> | |
53 | ||
54 | #ifndef INT_MAX | |
55 | #define INT_MAX 0x7fffffff | |
56 | #endif | |
57 | ||
58 | /* Constants for Huffman coding */ | |
59 | #define MAX_GROUPS 6 | |
60 | #define GROUP_SIZE 50 /* 64 would have been more efficient */ | |
61 | #define MAX_HUFCODE_BITS 20 /* Longest Huffman code allowed */ | |
62 | #define MAX_SYMBOLS 258 /* 256 literals + RUNA + RUNB */ | |
63 | #define SYMBOL_RUNA 0 | |
64 | #define SYMBOL_RUNB 1 | |
65 | ||
66 | /* Status return values */ | |
67 | #define RETVAL_OK 0 | |
68 | #define RETVAL_LAST_BLOCK (-1) | |
69 | #define RETVAL_NOT_BZIP_DATA (-2) | |
70 | #define RETVAL_UNEXPECTED_INPUT_EOF (-3) | |
71 | #define RETVAL_UNEXPECTED_OUTPUT_EOF (-4) | |
72 | #define RETVAL_DATA_ERROR (-5) | |
73 | #define RETVAL_OUT_OF_MEMORY (-6) | |
74 | #define RETVAL_OBSOLETE_INPUT (-7) | |
75 | ||
76 | /* Other housekeeping constants */ | |
77 | #define BZIP2_IOBUF_SIZE 4096 | |
78 | ||
79 | /* This is what we know about each Huffman coding group */ | |
80 | struct group_data { | |
81 | /* We have an extra slot at the end of limit[] for a sentinal value. */ | |
82 | int limit[MAX_HUFCODE_BITS+1]; | |
83 | int base[MAX_HUFCODE_BITS]; | |
84 | int permute[MAX_SYMBOLS]; | |
85 | int minLen, maxLen; | |
86 | }; | |
87 | ||
88 | /* Structure holding all the housekeeping data, including IO buffers and | |
89 | memory that persists between calls to bunzip */ | |
90 | struct bunzip_data { | |
91 | /* State for interrupting output loop */ | |
92 | int writeCopies, writePos, writeRunCountdown, writeCount, writeCurrent; | |
93 | /* I/O tracking data (file handles, buffers, positions, etc.) */ | |
94 | int (*fill)(void*, unsigned int); | |
95 | int inbufCount, inbufPos /*, outbufPos*/; | |
96 | unsigned char *inbuf /*,*outbuf*/; | |
97 | unsigned int inbufBitCount, inbufBits; | |
98 | /* The CRC values stored in the block header and calculated from the | |
99 | data */ | |
100 | unsigned int crc32Table[256], headerCRC, totalCRC, writeCRC; | |
101 | /* Intermediate buffer and its size (in bytes) */ | |
102 | unsigned int *dbuf, dbufSize; | |
103 | /* These things are a bit too big to go on the stack */ | |
104 | unsigned char selectors[32768]; /* nSelectors = 15 bits */ | |
105 | struct group_data groups[MAX_GROUPS]; /* Huffman coding tables */ | |
106 | int io_error; /* non-zero if we have IO error */ | |
107 | }; | |
108 | ||
109 | ||
110 | /* Return the next nnn bits of input. All reads from the compressed input | |
111 | are done through this function. All reads are big endian */ | |
112 | static unsigned int INIT get_bits(struct bunzip_data *bd, char bits_wanted) | |
113 | { | |
114 | unsigned int bits = 0; | |
115 | ||
116 | /* If we need to get more data from the byte buffer, do so. | |
117 | (Loop getting one byte at a time to enforce endianness and avoid | |
118 | unaligned access.) */ | |
119 | while (bd->inbufBitCount < bits_wanted) { | |
120 | /* If we need to read more data from file into byte buffer, do | |
121 | so */ | |
122 | if (bd->inbufPos == bd->inbufCount) { | |
123 | if (bd->io_error) | |
124 | return 0; | |
125 | bd->inbufCount = bd->fill(bd->inbuf, BZIP2_IOBUF_SIZE); | |
126 | if (bd->inbufCount <= 0) { | |
127 | bd->io_error = RETVAL_UNEXPECTED_INPUT_EOF; | |
128 | return 0; | |
129 | } | |
130 | bd->inbufPos = 0; | |
131 | } | |
132 | /* Avoid 32-bit overflow (dump bit buffer to top of output) */ | |
133 | if (bd->inbufBitCount >= 24) { | |
134 | bits = bd->inbufBits&((1 << bd->inbufBitCount)-1); | |
135 | bits_wanted -= bd->inbufBitCount; | |
136 | bits <<= bits_wanted; | |
137 | bd->inbufBitCount = 0; | |
138 | } | |
139 | /* Grab next 8 bits of input from buffer. */ | |
140 | bd->inbufBits = (bd->inbufBits << 8)|bd->inbuf[bd->inbufPos++]; | |
141 | bd->inbufBitCount += 8; | |
142 | } | |
143 | /* Calculate result */ | |
144 | bd->inbufBitCount -= bits_wanted; | |
145 | bits |= (bd->inbufBits >> bd->inbufBitCount)&((1 << bits_wanted)-1); | |
146 | ||
147 | return bits; | |
148 | } | |
149 | ||
150 | /* Unpacks the next block and sets up for the inverse burrows-wheeler step. */ | |
151 | ||
152 | static int INIT get_next_block(struct bunzip_data *bd) | |
153 | { | |
154 | struct group_data *hufGroup = NULL; | |
155 | int *base = NULL; | |
156 | int *limit = NULL; | |
157 | int dbufCount, nextSym, dbufSize, groupCount, selector, | |
158 | i, j, k, t, runPos, symCount, symTotal, nSelectors, | |
159 | byteCount[256]; | |
160 | unsigned char uc, symToByte[256], mtfSymbol[256], *selectors; | |
161 | unsigned int *dbuf, origPtr; | |
162 | ||
163 | dbuf = bd->dbuf; | |
164 | dbufSize = bd->dbufSize; | |
165 | selectors = bd->selectors; | |
166 | ||
167 | /* Read in header signature and CRC, then validate signature. | |
168 | (last block signature means CRC is for whole file, return now) */ | |
169 | i = get_bits(bd, 24); | |
170 | j = get_bits(bd, 24); | |
171 | bd->headerCRC = get_bits(bd, 32); | |
172 | if ((i == 0x177245) && (j == 0x385090)) | |
173 | return RETVAL_LAST_BLOCK; | |
174 | if ((i != 0x314159) || (j != 0x265359)) | |
175 | return RETVAL_NOT_BZIP_DATA; | |
176 | /* We can add support for blockRandomised if anybody complains. | |
177 | There was some code for this in busybox 1.0.0-pre3, but nobody ever | |
178 | noticed that it didn't actually work. */ | |
179 | if (get_bits(bd, 1)) | |
180 | return RETVAL_OBSOLETE_INPUT; | |
181 | origPtr = get_bits(bd, 24); | |
182 | if (origPtr > dbufSize) | |
183 | return RETVAL_DATA_ERROR; | |
184 | /* mapping table: if some byte values are never used (encoding things | |
185 | like ascii text), the compression code removes the gaps to have fewer | |
186 | symbols to deal with, and writes a sparse bitfield indicating which | |
187 | values were present. We make a translation table to convert the | |
188 | symbols back to the corresponding bytes. */ | |
189 | t = get_bits(bd, 16); | |
190 | symTotal = 0; | |
191 | for (i = 0; i < 16; i++) { | |
192 | if (t&(1 << (15-i))) { | |
193 | k = get_bits(bd, 16); | |
194 | for (j = 0; j < 16; j++) | |
195 | if (k&(1 << (15-j))) | |
196 | symToByte[symTotal++] = (16*i)+j; | |
197 | } | |
198 | } | |
199 | /* How many different Huffman coding groups does this block use? */ | |
200 | groupCount = get_bits(bd, 3); | |
201 | if (groupCount < 2 || groupCount > MAX_GROUPS) | |
202 | return RETVAL_DATA_ERROR; | |
203 | /* nSelectors: Every GROUP_SIZE many symbols we select a new | |
204 | Huffman coding group. Read in the group selector list, | |
205 | which is stored as MTF encoded bit runs. (MTF = Move To | |
206 | Front, as each value is used it's moved to the start of the | |
207 | list.) */ | |
208 | nSelectors = get_bits(bd, 15); | |
209 | if (!nSelectors) | |
210 | return RETVAL_DATA_ERROR; | |
211 | for (i = 0; i < groupCount; i++) | |
212 | mtfSymbol[i] = i; | |
213 | for (i = 0; i < nSelectors; i++) { | |
214 | /* Get next value */ | |
215 | for (j = 0; get_bits(bd, 1); j++) | |
216 | if (j >= groupCount) | |
217 | return RETVAL_DATA_ERROR; | |
218 | /* Decode MTF to get the next selector */ | |
219 | uc = mtfSymbol[j]; | |
220 | for (; j; j--) | |
221 | mtfSymbol[j] = mtfSymbol[j-1]; | |
222 | mtfSymbol[0] = selectors[i] = uc; | |
223 | } | |
224 | /* Read the Huffman coding tables for each group, which code | |
225 | for symTotal literal symbols, plus two run symbols (RUNA, | |
226 | RUNB) */ | |
227 | symCount = symTotal+2; | |
228 | for (j = 0; j < groupCount; j++) { | |
229 | unsigned char length[MAX_SYMBOLS], temp[MAX_HUFCODE_BITS+1]; | |
230 | int minLen, maxLen, pp; | |
231 | /* Read Huffman code lengths for each symbol. They're | |
232 | stored in a way similar to mtf; record a starting | |
233 | value for the first symbol, and an offset from the | |
234 | previous value for everys symbol after that. | |
235 | (Subtracting 1 before the loop and then adding it | |
236 | back at the end is an optimization that makes the | |
237 | test inside the loop simpler: symbol length 0 | |
238 | becomes negative, so an unsigned inequality catches | |
239 | it.) */ | |
240 | t = get_bits(bd, 5)-1; | |
241 | for (i = 0; i < symCount; i++) { | |
242 | for (;;) { | |
243 | if (((unsigned)t) > (MAX_HUFCODE_BITS-1)) | |
244 | return RETVAL_DATA_ERROR; | |
245 | ||
246 | /* If first bit is 0, stop. Else | |
247 | second bit indicates whether to | |
248 | increment or decrement the value. | |
249 | Optimization: grab 2 bits and unget | |
250 | the second if the first was 0. */ | |
251 | ||
252 | k = get_bits(bd, 2); | |
253 | if (k < 2) { | |
254 | bd->inbufBitCount++; | |
255 | break; | |
256 | } | |
257 | /* Add one if second bit 1, else | |
258 | * subtract 1. Avoids if/else */ | |
259 | t += (((k+1)&2)-1); | |
260 | } | |
261 | /* Correct for the initial -1, to get the | |
262 | * final symbol length */ | |
263 | length[i] = t+1; | |
264 | } | |
265 | /* Find largest and smallest lengths in this group */ | |
266 | minLen = maxLen = length[0]; | |
267 | ||
268 | for (i = 1; i < symCount; i++) { | |
269 | if (length[i] > maxLen) | |
270 | maxLen = length[i]; | |
271 | else if (length[i] < minLen) | |
272 | minLen = length[i]; | |
273 | } | |
274 | ||
275 | /* Calculate permute[], base[], and limit[] tables from | |
276 | * length[]. | |
277 | * | |
278 | * permute[] is the lookup table for converting | |
279 | * Huffman coded symbols into decoded symbols. base[] | |
280 | * is the amount to subtract from the value of a | |
281 | * Huffman symbol of a given length when using | |
282 | * permute[]. | |
283 | * | |
284 | * limit[] indicates the largest numerical value a | |
285 | * symbol with a given number of bits can have. This | |
286 | * is how the Huffman codes can vary in length: each | |
287 | * code with a value > limit[length] needs another | |
288 | * bit. | |
289 | */ | |
290 | hufGroup = bd->groups+j; | |
291 | hufGroup->minLen = minLen; | |
292 | hufGroup->maxLen = maxLen; | |
293 | /* Note that minLen can't be smaller than 1, so we | |
294 | adjust the base and limit array pointers so we're | |
295 | not always wasting the first entry. We do this | |
296 | again when using them (during symbol decoding).*/ | |
297 | base = hufGroup->base-1; | |
298 | limit = hufGroup->limit-1; | |
299 | /* Calculate permute[]. Concurently, initialize | |
300 | * temp[] and limit[]. */ | |
301 | pp = 0; | |
302 | for (i = minLen; i <= maxLen; i++) { | |
303 | temp[i] = limit[i] = 0; | |
304 | for (t = 0; t < symCount; t++) | |
305 | if (length[t] == i) | |
306 | hufGroup->permute[pp++] = t; | |
307 | } | |
308 | /* Count symbols coded for at each bit length */ | |
309 | for (i = 0; i < symCount; i++) | |
310 | temp[length[i]]++; | |
311 | /* Calculate limit[] (the largest symbol-coding value | |
312 | *at each bit length, which is (previous limit << | |
313 | *1)+symbols at this level), and base[] (number of | |
314 | *symbols to ignore at each bit length, which is limit | |
315 | *minus the cumulative count of symbols coded for | |
316 | *already). */ | |
317 | pp = t = 0; | |
318 | for (i = minLen; i < maxLen; i++) { | |
319 | pp += temp[i]; | |
320 | /* We read the largest possible symbol size | |
321 | and then unget bits after determining how | |
322 | many we need, and those extra bits could be | |
323 | set to anything. (They're noise from | |
324 | future symbols.) At each level we're | |
325 | really only interested in the first few | |
326 | bits, so here we set all the trailing | |
327 | to-be-ignored bits to 1 so they don't | |
328 | affect the value > limit[length] | |
329 | comparison. */ | |
330 | limit[i] = (pp << (maxLen - i)) - 1; | |
331 | pp <<= 1; | |
332 | base[i+1] = pp-(t += temp[i]); | |
333 | } | |
334 | limit[maxLen+1] = INT_MAX; /* Sentinal value for | |
335 | * reading next sym. */ | |
336 | limit[maxLen] = pp+temp[maxLen]-1; | |
337 | base[minLen] = 0; | |
338 | } | |
339 | /* We've finished reading and digesting the block header. Now | |
340 | read this block's Huffman coded symbols from the file and | |
341 | undo the Huffman coding and run length encoding, saving the | |
342 | result into dbuf[dbufCount++] = uc */ | |
343 | ||
344 | /* Initialize symbol occurrence counters and symbol Move To | |
345 | * Front table */ | |
346 | for (i = 0; i < 256; i++) { | |
347 | byteCount[i] = 0; | |
348 | mtfSymbol[i] = (unsigned char)i; | |
349 | } | |
350 | /* Loop through compressed symbols. */ | |
351 | runPos = dbufCount = symCount = selector = 0; | |
352 | for (;;) { | |
353 | /* Determine which Huffman coding group to use. */ | |
354 | if (!(symCount--)) { | |
355 | symCount = GROUP_SIZE-1; | |
356 | if (selector >= nSelectors) | |
357 | return RETVAL_DATA_ERROR; | |
358 | hufGroup = bd->groups+selectors[selector++]; | |
359 | base = hufGroup->base-1; | |
360 | limit = hufGroup->limit-1; | |
361 | } | |
362 | /* Read next Huffman-coded symbol. */ | |
363 | /* Note: It is far cheaper to read maxLen bits and | |
364 | back up than it is to read minLen bits and then an | |
365 | additional bit at a time, testing as we go. | |
366 | Because there is a trailing last block (with file | |
367 | CRC), there is no danger of the overread causing an | |
368 | unexpected EOF for a valid compressed file. As a | |
369 | further optimization, we do the read inline | |
370 | (falling back to a call to get_bits if the buffer | |
371 | runs dry). The following (up to got_huff_bits:) is | |
372 | equivalent to j = get_bits(bd, hufGroup->maxLen); | |
373 | */ | |
374 | while (bd->inbufBitCount < hufGroup->maxLen) { | |
375 | if (bd->inbufPos == bd->inbufCount) { | |
376 | j = get_bits(bd, hufGroup->maxLen); | |
377 | goto got_huff_bits; | |
378 | } | |
379 | bd->inbufBits = | |
380 | (bd->inbufBits << 8)|bd->inbuf[bd->inbufPos++]; | |
381 | bd->inbufBitCount += 8; | |
382 | }; | |
383 | bd->inbufBitCount -= hufGroup->maxLen; | |
384 | j = (bd->inbufBits >> bd->inbufBitCount)& | |
385 | ((1 << hufGroup->maxLen)-1); | |
386 | got_huff_bits: | |
387 | /* Figure how how many bits are in next symbol and | |
388 | * unget extras */ | |
389 | i = hufGroup->minLen; | |
390 | while (j > limit[i]) | |
391 | ++i; | |
392 | bd->inbufBitCount += (hufGroup->maxLen - i); | |
393 | /* Huffman decode value to get nextSym (with bounds checking) */ | |
394 | if ((i > hufGroup->maxLen) | |
395 | || (((unsigned)(j = (j>>(hufGroup->maxLen-i))-base[i])) | |
396 | >= MAX_SYMBOLS)) | |
397 | return RETVAL_DATA_ERROR; | |
398 | nextSym = hufGroup->permute[j]; | |
399 | /* We have now decoded the symbol, which indicates | |
400 | either a new literal byte, or a repeated run of the | |
401 | most recent literal byte. First, check if nextSym | |
402 | indicates a repeated run, and if so loop collecting | |
403 | how many times to repeat the last literal. */ | |
404 | if (((unsigned)nextSym) <= SYMBOL_RUNB) { /* RUNA or RUNB */ | |
405 | /* If this is the start of a new run, zero out | |
406 | * counter */ | |
407 | if (!runPos) { | |
408 | runPos = 1; | |
409 | t = 0; | |
410 | } | |
411 | /* Neat trick that saves 1 symbol: instead of | |
412 | or-ing 0 or 1 at each bit position, add 1 | |
413 | or 2 instead. For example, 1011 is 1 << 0 | |
414 | + 1 << 1 + 2 << 2. 1010 is 2 << 0 + 2 << 1 | |
415 | + 1 << 2. You can make any bit pattern | |
416 | that way using 1 less symbol than the basic | |
417 | or 0/1 method (except all bits 0, which | |
418 | would use no symbols, but a run of length 0 | |
419 | doesn't mean anything in this context). | |
420 | Thus space is saved. */ | |
421 | t += (runPos << nextSym); | |
422 | /* +runPos if RUNA; +2*runPos if RUNB */ | |
423 | ||
424 | runPos <<= 1; | |
425 | continue; | |
426 | } | |
427 | /* When we hit the first non-run symbol after a run, | |
428 | we now know how many times to repeat the last | |
429 | literal, so append that many copies to our buffer | |
430 | of decoded symbols (dbuf) now. (The last literal | |
431 | used is the one at the head of the mtfSymbol | |
432 | array.) */ | |
433 | if (runPos) { | |
434 | runPos = 0; | |
435 | if (dbufCount+t >= dbufSize) | |
436 | return RETVAL_DATA_ERROR; | |
437 | ||
438 | uc = symToByte[mtfSymbol[0]]; | |
439 | byteCount[uc] += t; | |
440 | while (t--) | |
441 | dbuf[dbufCount++] = uc; | |
442 | } | |
443 | /* Is this the terminating symbol? */ | |
444 | if (nextSym > symTotal) | |
445 | break; | |
446 | /* At this point, nextSym indicates a new literal | |
447 | character. Subtract one to get the position in the | |
448 | MTF array at which this literal is currently to be | |
449 | found. (Note that the result can't be -1 or 0, | |
450 | because 0 and 1 are RUNA and RUNB. But another | |
451 | instance of the first symbol in the mtf array, | |
452 | position 0, would have been handled as part of a | |
453 | run above. Therefore 1 unused mtf position minus 2 | |
454 | non-literal nextSym values equals -1.) */ | |
455 | if (dbufCount >= dbufSize) | |
456 | return RETVAL_DATA_ERROR; | |
457 | i = nextSym - 1; | |
458 | uc = mtfSymbol[i]; | |
459 | /* Adjust the MTF array. Since we typically expect to | |
460 | *move only a small number of symbols, and are bound | |
461 | *by 256 in any case, using memmove here would | |
462 | *typically be bigger and slower due to function call | |
463 | *overhead and other assorted setup costs. */ | |
464 | do { | |
465 | mtfSymbol[i] = mtfSymbol[i-1]; | |
466 | } while (--i); | |
467 | mtfSymbol[0] = uc; | |
468 | uc = symToByte[uc]; | |
469 | /* We have our literal byte. Save it into dbuf. */ | |
470 | byteCount[uc]++; | |
471 | dbuf[dbufCount++] = (unsigned int)uc; | |
472 | } | |
473 | /* At this point, we've read all the Huffman-coded symbols | |
474 | (and repeated runs) for this block from the input stream, | |
475 | and decoded them into the intermediate buffer. There are | |
476 | dbufCount many decoded bytes in dbuf[]. Now undo the | |
477 | Burrows-Wheeler transform on dbuf. See | |
478 | http://dogma.net/markn/articles/bwt/bwt.htm | |
479 | */ | |
480 | /* Turn byteCount into cumulative occurrence counts of 0 to n-1. */ | |
481 | j = 0; | |
482 | for (i = 0; i < 256; i++) { | |
483 | k = j+byteCount[i]; | |
484 | byteCount[i] = j; | |
485 | j = k; | |
486 | } | |
487 | /* Figure out what order dbuf would be in if we sorted it. */ | |
488 | for (i = 0; i < dbufCount; i++) { | |
489 | uc = (unsigned char)(dbuf[i] & 0xff); | |
490 | dbuf[byteCount[uc]] |= (i << 8); | |
491 | byteCount[uc]++; | |
492 | } | |
493 | /* Decode first byte by hand to initialize "previous" byte. | |
494 | Note that it doesn't get output, and if the first three | |
495 | characters are identical it doesn't qualify as a run (hence | |
496 | writeRunCountdown = 5). */ | |
497 | if (dbufCount) { | |
498 | if (origPtr >= dbufCount) | |
499 | return RETVAL_DATA_ERROR; | |
500 | bd->writePos = dbuf[origPtr]; | |
501 | bd->writeCurrent = (unsigned char)(bd->writePos&0xff); | |
502 | bd->writePos >>= 8; | |
503 | bd->writeRunCountdown = 5; | |
504 | } | |
505 | bd->writeCount = dbufCount; | |
506 | ||
507 | return RETVAL_OK; | |
508 | } | |
509 | ||
510 | /* Undo burrows-wheeler transform on intermediate buffer to produce output. | |
511 | If start_bunzip was initialized with out_fd =-1, then up to len bytes of | |
512 | data are written to outbuf. Return value is number of bytes written or | |
513 | error (all errors are negative numbers). If out_fd!=-1, outbuf and len | |
514 | are ignored, data is written to out_fd and return is RETVAL_OK or error. | |
515 | */ | |
516 | ||
517 | static int INIT read_bunzip(struct bunzip_data *bd, char *outbuf, int len) | |
518 | { | |
519 | const unsigned int *dbuf; | |
520 | int pos, xcurrent, previous, gotcount; | |
521 | ||
522 | /* If last read was short due to end of file, return last block now */ | |
523 | if (bd->writeCount < 0) | |
524 | return bd->writeCount; | |
525 | ||
526 | gotcount = 0; | |
527 | dbuf = bd->dbuf; | |
528 | pos = bd->writePos; | |
529 | xcurrent = bd->writeCurrent; | |
530 | ||
531 | /* We will always have pending decoded data to write into the output | |
532 | buffer unless this is the very first call (in which case we haven't | |
533 | Huffman-decoded a block into the intermediate buffer yet). */ | |
534 | ||
535 | if (bd->writeCopies) { | |
536 | /* Inside the loop, writeCopies means extra copies (beyond 1) */ | |
537 | --bd->writeCopies; | |
538 | /* Loop outputting bytes */ | |
539 | for (;;) { | |
540 | /* If the output buffer is full, snapshot | |
541 | * state and return */ | |
542 | if (gotcount >= len) { | |
543 | bd->writePos = pos; | |
544 | bd->writeCurrent = xcurrent; | |
545 | bd->writeCopies++; | |
546 | return len; | |
547 | } | |
548 | /* Write next byte into output buffer, updating CRC */ | |
549 | outbuf[gotcount++] = xcurrent; | |
550 | bd->writeCRC = (((bd->writeCRC) << 8) | |
551 | ^bd->crc32Table[((bd->writeCRC) >> 24) | |
552 | ^xcurrent]); | |
553 | /* Loop now if we're outputting multiple | |
554 | * copies of this byte */ | |
555 | if (bd->writeCopies) { | |
556 | --bd->writeCopies; | |
557 | continue; | |
558 | } | |
559 | decode_next_byte: | |
560 | if (!bd->writeCount--) | |
561 | break; | |
562 | /* Follow sequence vector to undo | |
563 | * Burrows-Wheeler transform */ | |
564 | previous = xcurrent; | |
565 | pos = dbuf[pos]; | |
566 | xcurrent = pos&0xff; | |
567 | pos >>= 8; | |
568 | /* After 3 consecutive copies of the same | |
569 | byte, the 4th is a repeat count. We count | |
570 | down from 4 instead *of counting up because | |
571 | testing for non-zero is faster */ | |
572 | if (--bd->writeRunCountdown) { | |
573 | if (xcurrent != previous) | |
574 | bd->writeRunCountdown = 4; | |
575 | } else { | |
576 | /* We have a repeated run, this byte | |
577 | * indicates the count */ | |
578 | bd->writeCopies = xcurrent; | |
579 | xcurrent = previous; | |
580 | bd->writeRunCountdown = 5; | |
581 | /* Sometimes there are just 3 bytes | |
582 | * (run length 0) */ | |
583 | if (!bd->writeCopies) | |
584 | goto decode_next_byte; | |
585 | /* Subtract the 1 copy we'd output | |
586 | * anyway to get extras */ | |
587 | --bd->writeCopies; | |
588 | } | |
589 | } | |
590 | /* Decompression of this block completed successfully */ | |
591 | bd->writeCRC = ~bd->writeCRC; | |
592 | bd->totalCRC = ((bd->totalCRC << 1) | | |
593 | (bd->totalCRC >> 31)) ^ bd->writeCRC; | |
594 | /* If this block had a CRC error, force file level CRC error. */ | |
595 | if (bd->writeCRC != bd->headerCRC) { | |
596 | bd->totalCRC = bd->headerCRC+1; | |
597 | return RETVAL_LAST_BLOCK; | |
598 | } | |
599 | } | |
600 | ||
601 | /* Refill the intermediate buffer by Huffman-decoding next | |
602 | * block of input */ | |
603 | /* (previous is just a convenient unused temp variable here) */ | |
604 | previous = get_next_block(bd); | |
605 | if (previous) { | |
606 | bd->writeCount = previous; | |
607 | return (previous != RETVAL_LAST_BLOCK) ? previous : gotcount; | |
608 | } | |
609 | bd->writeCRC = 0xffffffffUL; | |
610 | pos = bd->writePos; | |
611 | xcurrent = bd->writeCurrent; | |
612 | goto decode_next_byte; | |
613 | } | |
614 | ||
615 | static int INIT nofill(void *buf, unsigned int len) | |
616 | { | |
617 | return -1; | |
618 | } | |
619 | ||
620 | /* Allocate the structure, read file header. If in_fd ==-1, inbuf must contain | |
621 | a complete bunzip file (len bytes long). If in_fd!=-1, inbuf and len are | |
622 | ignored, and data is read from file handle into temporary buffer. */ | |
623 | static int INIT start_bunzip(struct bunzip_data **bdp, void *inbuf, int len, | |
624 | int (*fill)(void*, unsigned int)) | |
625 | { | |
626 | struct bunzip_data *bd; | |
627 | unsigned int i, j, c; | |
628 | const unsigned int BZh0 = | |
629 | (((unsigned int)'B') << 24)+(((unsigned int)'Z') << 16) | |
630 | +(((unsigned int)'h') << 8)+(unsigned int)'0'; | |
631 | ||
632 | /* Figure out how much data to allocate */ | |
633 | i = sizeof(struct bunzip_data); | |
634 | ||
635 | /* Allocate bunzip_data. Most fields initialize to zero. */ | |
636 | bd = *bdp = malloc(i); | |
637 | memset(bd, 0, sizeof(struct bunzip_data)); | |
638 | /* Setup input buffer */ | |
639 | bd->inbuf = inbuf; | |
640 | bd->inbufCount = len; | |
641 | if (fill != NULL) | |
642 | bd->fill = fill; | |
643 | else | |
644 | bd->fill = nofill; | |
645 | ||
646 | /* Init the CRC32 table (big endian) */ | |
647 | for (i = 0; i < 256; i++) { | |
648 | c = i << 24; | |
649 | for (j = 8; j; j--) | |
650 | c = c&0x80000000 ? (c << 1)^0x04c11db7 : (c << 1); | |
651 | bd->crc32Table[i] = c; | |
652 | } | |
653 | ||
654 | /* Ensure that file starts with "BZh['1'-'9']." */ | |
655 | i = get_bits(bd, 32); | |
656 | if (((unsigned int)(i-BZh0-1)) >= 9) | |
657 | return RETVAL_NOT_BZIP_DATA; | |
658 | ||
659 | /* Fourth byte (ascii '1'-'9'), indicates block size in units of 100k of | |
660 | uncompressed data. Allocate intermediate buffer for block. */ | |
661 | bd->dbufSize = 100000*(i-BZh0); | |
662 | ||
663 | bd->dbuf = large_malloc(bd->dbufSize * sizeof(int)); | |
664 | return RETVAL_OK; | |
665 | } | |
666 | ||
667 | /* Example usage: decompress src_fd to dst_fd. (Stops at end of bzip2 data, | |
668 | not end of file.) */ | |
669 | STATIC int INIT bunzip2(unsigned char *buf, int len, | |
670 | int(*fill)(void*, unsigned int), | |
671 | int(*flush)(void*, unsigned int), | |
672 | unsigned char *outbuf, | |
673 | int *pos, | |
674 | void(*error_fn)(char *x)) | |
675 | { | |
676 | struct bunzip_data *bd; | |
677 | int i = -1; | |
678 | unsigned char *inbuf; | |
679 | ||
680 | set_error_fn(error_fn); | |
681 | if (flush) | |
682 | outbuf = malloc(BZIP2_IOBUF_SIZE); | |
683 | else | |
684 | len -= 4; /* Uncompressed size hack active in pre-boot | |
685 | environment */ | |
686 | if (!outbuf) { | |
687 | error("Could not allocate output bufer"); | |
688 | return -1; | |
689 | } | |
690 | if (buf) | |
691 | inbuf = buf; | |
692 | else | |
693 | inbuf = malloc(BZIP2_IOBUF_SIZE); | |
694 | if (!inbuf) { | |
695 | error("Could not allocate input bufer"); | |
696 | goto exit_0; | |
697 | } | |
698 | i = start_bunzip(&bd, inbuf, len, fill); | |
699 | if (!i) { | |
700 | for (;;) { | |
701 | i = read_bunzip(bd, outbuf, BZIP2_IOBUF_SIZE); | |
702 | if (i <= 0) | |
703 | break; | |
704 | if (!flush) | |
705 | outbuf += i; | |
706 | else | |
707 | if (i != flush(outbuf, i)) { | |
708 | i = RETVAL_UNEXPECTED_OUTPUT_EOF; | |
709 | break; | |
710 | } | |
711 | } | |
712 | } | |
713 | /* Check CRC and release memory */ | |
714 | if (i == RETVAL_LAST_BLOCK) { | |
715 | if (bd->headerCRC != bd->totalCRC) | |
716 | error("Data integrity error when decompressing."); | |
717 | else | |
718 | i = RETVAL_OK; | |
719 | } else if (i == RETVAL_UNEXPECTED_OUTPUT_EOF) { | |
720 | error("Compressed file ends unexpectedly"); | |
721 | } | |
722 | if (bd->dbuf) | |
723 | large_free(bd->dbuf); | |
724 | if (pos) | |
725 | *pos = bd->inbufPos; | |
726 | free(bd); | |
727 | if (!buf) | |
728 | free(inbuf); | |
729 | exit_0: | |
730 | if (flush) | |
731 | free(outbuf); | |
732 | return i; | |
733 | } | |
734 | ||
735 | #define decompress bunzip2 |