Line data Source code
1 :
2 : /*-------------------------------------------------------------*/
3 : /*--- Compression machinery (not incl block sorting) ---*/
4 : /*--- compress.c ---*/
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.8 of 13 July 2019
12 : Copyright (C) 1996-2019 Julian Seward <jseward@acm.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 : /* CHANGES
23 : 0.9.0 -- original version.
24 : 0.9.0a/b -- no changes in this file.
25 : 0.9.0c -- changed setting of nGroups in sendMTFValues()
26 : so as to do a bit better on small files
27 : */
28 :
29 : #include "bzlib_private.h"
30 :
31 :
32 : /*---------------------------------------------------*/
33 : /*--- Bit stream I/O ---*/
34 : /*---------------------------------------------------*/
35 :
36 : /*---------------------------------------------------*/
37 : void BZ2_bsInitWrite ( EState* s )
38 0 : {
39 0 : s->bsLive = 0;
40 0 : s->bsBuff = 0;
41 0 : }
42 :
43 :
44 : /*---------------------------------------------------*/
45 : static
46 : void bsFinishWrite ( EState* s )
47 0 : {
48 0 : while (s->bsLive > 0) {
49 0 : s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24);
50 0 : s->numZ++;
51 0 : s->bsBuff <<= 8;
52 0 : s->bsLive -= 8;
53 0 : }
54 0 : }
55 :
56 :
57 : /*---------------------------------------------------*/
58 0 : #define bsNEEDW(nz) \
59 0 : { \
60 0 : while (s->bsLive >= 8) { \
61 0 : s->zbits[s->numZ] \
62 0 : = (UChar)(s->bsBuff >> 24); \
63 0 : s->numZ++; \
64 0 : s->bsBuff <<= 8; \
65 0 : s->bsLive -= 8; \
66 0 : } \
67 0 : }
68 :
69 :
70 : /*---------------------------------------------------*/
71 : static
72 : __inline__
73 : void bsW ( EState* s, Int32 n, UInt32 v )
74 0 : {
75 0 : bsNEEDW ( n );
76 0 : s->bsBuff |= (v << (32 - s->bsLive - n));
77 0 : s->bsLive += n;
78 0 : }
79 :
80 :
81 : /*---------------------------------------------------*/
82 : static
83 : void bsPutUInt32 ( EState* s, UInt32 u )
84 0 : {
85 0 : bsW ( s, 8, (u >> 24) & 0xffL );
86 0 : bsW ( s, 8, (u >> 16) & 0xffL );
87 0 : bsW ( s, 8, (u >> 8) & 0xffL );
88 0 : bsW ( s, 8, u & 0xffL );
89 0 : }
90 :
91 :
92 : /*---------------------------------------------------*/
93 : static
94 : void bsPutUChar ( EState* s, UChar c )
95 0 : {
96 0 : bsW( s, 8, (UInt32)c );
97 0 : }
98 :
99 :
100 : /*---------------------------------------------------*/
101 : /*--- The back end proper ---*/
102 : /*---------------------------------------------------*/
103 :
104 : /*---------------------------------------------------*/
105 : static
106 : void makeMaps_e ( EState* s )
107 0 : {
108 0 : Int32 i;
109 0 : s->nInUse = 0;
110 0 : for (i = 0; i < 256; i++)
111 0 : if (s->inUse[i]) {
112 0 : s->unseqToSeq[i] = s->nInUse;
113 0 : s->nInUse++;
114 0 : }
115 0 : }
116 :
117 :
118 : /*---------------------------------------------------*/
119 : static
120 : void generateMTFValues ( EState* s )
121 0 : {
122 0 : UChar yy[256];
123 0 : Int32 i, j;
124 0 : Int32 zPend;
125 0 : Int32 wr;
126 0 : Int32 EOB;
127 :
128 : /*
129 : After sorting (eg, here),
130 : s->arr1 [ 0 .. s->nblock-1 ] holds sorted order,
131 : and
132 : ((UChar*)s->arr2) [ 0 .. s->nblock-1 ]
133 : holds the original block data.
134 :
135 : The first thing to do is generate the MTF values,
136 : and put them in
137 : ((UInt16*)s->arr1) [ 0 .. s->nblock-1 ].
138 : Because there are strictly fewer or equal MTF values
139 : than block values, ptr values in this area are overwritten
140 : with MTF values only when they are no longer needed.
141 :
142 : The final compressed bitstream is generated into the
143 : area starting at
144 : (UChar*) (&((UChar*)s->arr2)[s->nblock])
145 :
146 : These storage aliases are set up in bzCompressInit(),
147 : except for the last one, which is arranged in
148 : compressBlock().
149 : */
150 0 : UInt32* ptr = s->ptr;
151 0 : UChar* block = s->block;
152 0 : UInt16* mtfv = s->mtfv;
153 :
154 0 : makeMaps_e ( s );
155 0 : EOB = s->nInUse+1;
156 :
157 0 : for (i = 0; i <= EOB; i++) s->mtfFreq[i] = 0;
158 :
159 0 : wr = 0;
160 0 : zPend = 0;
161 0 : for (i = 0; i < s->nInUse; i++) yy[i] = (UChar) i;
162 :
163 0 : for (i = 0; i < s->nblock; i++) {
164 0 : UChar ll_i;
165 0 : AssertD ( wr <= i, "generateMTFValues(1)" );
166 0 : j = ptr[i]-1; if (j < 0) j += s->nblock;
167 0 : ll_i = s->unseqToSeq[block[j]];
168 0 : AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" );
169 :
170 0 : if (yy[0] == ll_i) {
171 0 : zPend++;
172 0 : } else {
173 :
174 0 : if (zPend > 0) {
175 0 : zPend--;
176 0 : while (True) {
177 0 : if (zPend & 1) {
178 0 : mtfv[wr] = BZ_RUNB; wr++;
179 0 : s->mtfFreq[BZ_RUNB]++;
180 0 : } else {
181 0 : mtfv[wr] = BZ_RUNA; wr++;
182 0 : s->mtfFreq[BZ_RUNA]++;
183 0 : }
184 0 : if (zPend < 2) break;
185 0 : zPend = (zPend - 2) / 2;
186 0 : };
187 0 : zPend = 0;
188 0 : }
189 0 : {
190 0 : register UChar rtmp;
191 0 : register UChar* ryy_j;
192 0 : register UChar rll_i;
193 0 : rtmp = yy[1];
194 0 : yy[1] = yy[0];
195 0 : ryy_j = &(yy[1]);
196 0 : rll_i = ll_i;
197 0 : while ( rll_i != rtmp ) {
198 0 : register UChar rtmp2;
199 0 : ryy_j++;
200 0 : rtmp2 = rtmp;
201 0 : rtmp = *ryy_j;
202 0 : *ryy_j = rtmp2;
203 0 : };
204 0 : yy[0] = rtmp;
205 0 : j = ryy_j - &(yy[0]);
206 0 : mtfv[wr] = j+1; wr++; s->mtfFreq[j+1]++;
207 0 : }
208 :
209 0 : }
210 0 : }
211 :
212 0 : if (zPend > 0) {
213 0 : zPend--;
214 0 : while (True) {
215 0 : if (zPend & 1) {
216 0 : mtfv[wr] = BZ_RUNB; wr++;
217 0 : s->mtfFreq[BZ_RUNB]++;
218 0 : } else {
219 0 : mtfv[wr] = BZ_RUNA; wr++;
220 0 : s->mtfFreq[BZ_RUNA]++;
221 0 : }
222 0 : if (zPend < 2) break;
223 0 : zPend = (zPend - 2) / 2;
224 0 : };
225 0 : zPend = 0;
226 0 : }
227 :
228 0 : mtfv[wr] = EOB; wr++; s->mtfFreq[EOB]++;
229 :
230 0 : s->nMTF = wr;
231 0 : }
232 :
233 :
234 : /*---------------------------------------------------*/
235 0 : #define BZ_LESSER_ICOST 0
236 0 : #define BZ_GREATER_ICOST 15
237 :
238 : static
239 : void sendMTFValues ( EState* s )
240 0 : {
241 0 : Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
242 0 : Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
243 0 : Int32 nGroups, nBytes;
244 :
245 : /*--
246 : UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
247 : is a global since the decoder also needs it.
248 :
249 : Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
250 : Int32 rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
251 : are also globals only used in this proc.
252 : Made global to keep stack frame size small.
253 : --*/
254 :
255 :
256 0 : UInt16 cost[BZ_N_GROUPS];
257 0 : Int32 fave[BZ_N_GROUPS];
258 :
259 0 : UInt16* mtfv = s->mtfv;
260 :
261 0 : if (s->verbosity >= 3)
262 0 : VPrintf3( " %d in block, %d after MTF & 1-2 coding, "
263 0 : "%d+2 syms in use\n",
264 0 : s->nblock, s->nMTF, s->nInUse );
265 :
266 0 : alphaSize = s->nInUse+2;
267 0 : for (t = 0; t < BZ_N_GROUPS; t++)
268 0 : for (v = 0; v < alphaSize; v++)
269 0 : s->len[t][v] = BZ_GREATER_ICOST;
270 :
271 : /*--- Decide how many coding tables to use ---*/
272 0 : AssertH ( s->nMTF > 0, 3001 );
273 0 : if (s->nMTF < 200) nGroups = 2; else
274 0 : if (s->nMTF < 600) nGroups = 3; else
275 0 : if (s->nMTF < 1200) nGroups = 4; else
276 0 : if (s->nMTF < 2400) nGroups = 5; else
277 0 : nGroups = 6;
278 :
279 : /*--- Generate an initial set of coding tables ---*/
280 0 : {
281 0 : Int32 nPart, remF, tFreq, aFreq;
282 :
283 0 : nPart = nGroups;
284 0 : remF = s->nMTF;
285 0 : gs = 0;
286 0 : while (nPart > 0) {
287 0 : tFreq = remF / nPart;
288 0 : ge = gs-1;
289 0 : aFreq = 0;
290 0 : while (aFreq < tFreq && ge < alphaSize-1) {
291 0 : ge++;
292 0 : aFreq += s->mtfFreq[ge];
293 0 : }
294 :
295 0 : if (ge > gs
296 0 : && nPart != nGroups && nPart != 1
297 0 : && ((nGroups-nPart) % 2 == 1)) {
298 0 : aFreq -= s->mtfFreq[ge];
299 0 : ge--;
300 0 : }
301 :
302 0 : if (s->verbosity >= 3)
303 0 : VPrintf5( " initial group %d, [%d .. %d], "
304 0 : "has %d syms (%4.1f%%)\n",
305 0 : nPart, gs, ge, aFreq,
306 0 : (100.0 * (float)aFreq) / (float)(s->nMTF) );
307 :
308 0 : for (v = 0; v < alphaSize; v++)
309 0 : if (v >= gs && v <= ge)
310 0 : s->len[nPart-1][v] = BZ_LESSER_ICOST; else
311 0 : s->len[nPart-1][v] = BZ_GREATER_ICOST;
312 :
313 0 : nPart--;
314 0 : gs = ge+1;
315 0 : remF -= aFreq;
316 0 : }
317 0 : }
318 :
319 : /*---
320 : Iterate up to BZ_N_ITERS times to improve the tables.
321 : ---*/
322 0 : for (iter = 0; iter < BZ_N_ITERS; iter++) {
323 :
324 0 : for (t = 0; t < nGroups; t++) fave[t] = 0;
325 :
326 0 : for (t = 0; t < nGroups; t++)
327 0 : for (v = 0; v < alphaSize; v++)
328 0 : s->rfreq[t][v] = 0;
329 :
330 : /*---
331 : Set up an auxiliary length table which is used to fast-track
332 : the common case (nGroups == 6).
333 : ---*/
334 0 : if (nGroups == 6) {
335 0 : for (v = 0; v < alphaSize; v++) {
336 0 : s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v];
337 0 : s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v];
338 0 : s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v];
339 0 : }
340 0 : }
341 :
342 0 : nSelectors = 0;
343 0 : totc = 0;
344 0 : gs = 0;
345 0 : while (True) {
346 :
347 : /*--- Set group start & end marks. --*/
348 0 : if (gs >= s->nMTF) break;
349 0 : ge = gs + BZ_G_SIZE - 1;
350 0 : if (ge >= s->nMTF) ge = s->nMTF-1;
351 :
352 : /*--
353 : Calculate the cost of this group as coded
354 : by each of the coding tables.
355 : --*/
356 0 : for (t = 0; t < nGroups; t++) cost[t] = 0;
357 :
358 0 : if (nGroups == 6 && 50 == ge-gs+1) {
359 : /*--- fast track the common case ---*/
360 0 : register UInt32 cost01, cost23, cost45;
361 0 : register UInt16 icv;
362 0 : cost01 = cost23 = cost45 = 0;
363 :
364 0 : # define BZ_ITER(nn) \
365 0 : icv = mtfv[gs+(nn)]; \
366 0 : cost01 += s->len_pack[icv][0]; \
367 0 : cost23 += s->len_pack[icv][1]; \
368 0 : cost45 += s->len_pack[icv][2]; \
369 0 :
370 0 : BZ_ITER(0); BZ_ITER(1); BZ_ITER(2); BZ_ITER(3); BZ_ITER(4);
371 0 : BZ_ITER(5); BZ_ITER(6); BZ_ITER(7); BZ_ITER(8); BZ_ITER(9);
372 0 : BZ_ITER(10); BZ_ITER(11); BZ_ITER(12); BZ_ITER(13); BZ_ITER(14);
373 0 : BZ_ITER(15); BZ_ITER(16); BZ_ITER(17); BZ_ITER(18); BZ_ITER(19);
374 0 : BZ_ITER(20); BZ_ITER(21); BZ_ITER(22); BZ_ITER(23); BZ_ITER(24);
375 0 : BZ_ITER(25); BZ_ITER(26); BZ_ITER(27); BZ_ITER(28); BZ_ITER(29);
376 0 : BZ_ITER(30); BZ_ITER(31); BZ_ITER(32); BZ_ITER(33); BZ_ITER(34);
377 0 : BZ_ITER(35); BZ_ITER(36); BZ_ITER(37); BZ_ITER(38); BZ_ITER(39);
378 0 : BZ_ITER(40); BZ_ITER(41); BZ_ITER(42); BZ_ITER(43); BZ_ITER(44);
379 0 : BZ_ITER(45); BZ_ITER(46); BZ_ITER(47); BZ_ITER(48); BZ_ITER(49);
380 :
381 0 : # undef BZ_ITER
382 :
383 0 : cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16;
384 0 : cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16;
385 0 : cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16;
386 :
387 0 : } else {
388 : /*--- slow version which correctly handles all situations ---*/
389 0 : for (i = gs; i <= ge; i++) {
390 0 : UInt16 icv = mtfv[i];
391 0 : for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv];
392 0 : }
393 0 : }
394 :
395 : /*--
396 : Find the coding table which is best for this group,
397 : and record its identity in the selector table.
398 : --*/
399 0 : bc = 999999999; bt = -1;
400 0 : for (t = 0; t < nGroups; t++)
401 0 : if (cost[t] < bc) { bc = cost[t]; bt = t; };
402 0 : totc += bc;
403 0 : fave[bt]++;
404 0 : s->selector[nSelectors] = bt;
405 0 : nSelectors++;
406 :
407 : /*--
408 : Increment the symbol frequencies for the selected table.
409 : --*/
410 0 : if (nGroups == 6 && 50 == ge-gs+1) {
411 : /*--- fast track the common case ---*/
412 :
413 0 : # define BZ_ITUR(nn) s->rfreq[bt][ mtfv[gs+(nn)] ]++
414 :
415 0 : BZ_ITUR(0); BZ_ITUR(1); BZ_ITUR(2); BZ_ITUR(3); BZ_ITUR(4);
416 0 : BZ_ITUR(5); BZ_ITUR(6); BZ_ITUR(7); BZ_ITUR(8); BZ_ITUR(9);
417 0 : BZ_ITUR(10); BZ_ITUR(11); BZ_ITUR(12); BZ_ITUR(13); BZ_ITUR(14);
418 0 : BZ_ITUR(15); BZ_ITUR(16); BZ_ITUR(17); BZ_ITUR(18); BZ_ITUR(19);
419 0 : BZ_ITUR(20); BZ_ITUR(21); BZ_ITUR(22); BZ_ITUR(23); BZ_ITUR(24);
420 0 : BZ_ITUR(25); BZ_ITUR(26); BZ_ITUR(27); BZ_ITUR(28); BZ_ITUR(29);
421 0 : BZ_ITUR(30); BZ_ITUR(31); BZ_ITUR(32); BZ_ITUR(33); BZ_ITUR(34);
422 0 : BZ_ITUR(35); BZ_ITUR(36); BZ_ITUR(37); BZ_ITUR(38); BZ_ITUR(39);
423 0 : BZ_ITUR(40); BZ_ITUR(41); BZ_ITUR(42); BZ_ITUR(43); BZ_ITUR(44);
424 0 : BZ_ITUR(45); BZ_ITUR(46); BZ_ITUR(47); BZ_ITUR(48); BZ_ITUR(49);
425 :
426 0 : # undef BZ_ITUR
427 :
428 0 : } else {
429 : /*--- slow version which correctly handles all situations ---*/
430 0 : for (i = gs; i <= ge; i++)
431 0 : s->rfreq[bt][ mtfv[i] ]++;
432 0 : }
433 :
434 0 : gs = ge+1;
435 0 : }
436 0 : if (s->verbosity >= 3) {
437 0 : VPrintf2 ( " pass %d: size is %d, grp uses are ",
438 0 : iter+1, totc/8 );
439 0 : for (t = 0; t < nGroups; t++)
440 0 : VPrintf1 ( "%d ", fave[t] );
441 0 : VPrintf0 ( "\n" );
442 0 : }
443 :
444 : /*--
445 : Recompute the tables based on the accumulated frequencies.
446 : --*/
447 : /* maxLen was changed from 20 to 17 in bzip2-1.0.3. See
448 : comment in huffman.c for details. */
449 0 : for (t = 0; t < nGroups; t++)
450 0 : BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
451 0 : alphaSize, 17 /*20*/ );
452 0 : }
453 :
454 :
455 0 : AssertH( nGroups < 8, 3002 );
456 0 : AssertH( nSelectors < 32768 &&
457 0 : nSelectors <= BZ_MAX_SELECTORS,
458 0 : 3003 );
459 :
460 :
461 : /*--- Compute MTF values for the selectors. ---*/
462 0 : {
463 0 : UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp;
464 0 : for (i = 0; i < nGroups; i++) pos[i] = i;
465 0 : for (i = 0; i < nSelectors; i++) {
466 0 : ll_i = s->selector[i];
467 0 : j = 0;
468 0 : tmp = pos[j];
469 0 : while ( ll_i != tmp ) {
470 0 : j++;
471 0 : tmp2 = tmp;
472 0 : tmp = pos[j];
473 0 : pos[j] = tmp2;
474 0 : };
475 0 : pos[0] = tmp;
476 0 : s->selectorMtf[i] = j;
477 0 : }
478 0 : };
479 :
480 : /*--- Assign actual codes for the tables. --*/
481 0 : for (t = 0; t < nGroups; t++) {
482 0 : minLen = 32;
483 0 : maxLen = 0;
484 0 : for (i = 0; i < alphaSize; i++) {
485 0 : if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
486 0 : if (s->len[t][i] < minLen) minLen = s->len[t][i];
487 0 : }
488 0 : AssertH ( !(maxLen > 17 /*20*/ ), 3004 );
489 0 : AssertH ( !(minLen < 1), 3005 );
490 0 : BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
491 0 : minLen, maxLen, alphaSize );
492 0 : }
493 :
494 : /*--- Transmit the mapping table. ---*/
495 0 : {
496 0 : Bool inUse16[16];
497 0 : for (i = 0; i < 16; i++) {
498 0 : inUse16[i] = False;
499 0 : for (j = 0; j < 16; j++)
500 0 : if (s->inUse[i * 16 + j]) inUse16[i] = True;
501 0 : }
502 :
503 0 : nBytes = s->numZ;
504 0 : for (i = 0; i < 16; i++)
505 0 : if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0);
506 :
507 0 : for (i = 0; i < 16; i++)
508 0 : if (inUse16[i])
509 0 : for (j = 0; j < 16; j++) {
510 0 : if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0);
511 0 : }
512 :
513 0 : if (s->verbosity >= 3)
514 0 : VPrintf1( " bytes: mapping %d, ", s->numZ-nBytes );
515 0 : }
516 :
517 : /*--- Now the selectors. ---*/
518 0 : nBytes = s->numZ;
519 0 : bsW ( s, 3, nGroups );
520 0 : bsW ( s, 15, nSelectors );
521 0 : for (i = 0; i < nSelectors; i++) {
522 0 : for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1);
523 0 : bsW(s,1,0);
524 0 : }
525 0 : if (s->verbosity >= 3)
526 0 : VPrintf1( "selectors %d, ", s->numZ-nBytes );
527 :
528 : /*--- Now the coding tables. ---*/
529 0 : nBytes = s->numZ;
530 :
531 0 : for (t = 0; t < nGroups; t++) {
532 0 : Int32 curr = s->len[t][0];
533 0 : bsW ( s, 5, curr );
534 0 : for (i = 0; i < alphaSize; i++) {
535 0 : while (curr < s->len[t][i]) { bsW(s,2,2); curr++; /* 10 */ };
536 0 : while (curr > s->len[t][i]) { bsW(s,2,3); curr--; /* 11 */ };
537 0 : bsW ( s, 1, 0 );
538 0 : }
539 0 : }
540 :
541 0 : if (s->verbosity >= 3)
542 0 : VPrintf1 ( "code lengths %d, ", s->numZ-nBytes );
543 :
544 : /*--- And finally, the block data proper ---*/
545 0 : nBytes = s->numZ;
546 0 : selCtr = 0;
547 0 : gs = 0;
548 0 : while (True) {
549 0 : if (gs >= s->nMTF) break;
550 0 : ge = gs + BZ_G_SIZE - 1;
551 0 : if (ge >= s->nMTF) ge = s->nMTF-1;
552 0 : AssertH ( s->selector[selCtr] < nGroups, 3006 );
553 :
554 0 : if (nGroups == 6 && 50 == ge-gs+1) {
555 : /*--- fast track the common case ---*/
556 0 : UInt16 mtfv_i;
557 0 : UChar* s_len_sel_selCtr
558 0 : = &(s->len[s->selector[selCtr]][0]);
559 0 : Int32* s_code_sel_selCtr
560 0 : = &(s->code[s->selector[selCtr]][0]);
561 :
562 0 : # define BZ_ITAH(nn) \
563 0 : mtfv_i = mtfv[gs+(nn)]; \
564 0 : bsW ( s, \
565 0 : s_len_sel_selCtr[mtfv_i], \
566 0 : s_code_sel_selCtr[mtfv_i] )
567 :
568 0 : BZ_ITAH(0); BZ_ITAH(1); BZ_ITAH(2); BZ_ITAH(3); BZ_ITAH(4);
569 0 : BZ_ITAH(5); BZ_ITAH(6); BZ_ITAH(7); BZ_ITAH(8); BZ_ITAH(9);
570 0 : BZ_ITAH(10); BZ_ITAH(11); BZ_ITAH(12); BZ_ITAH(13); BZ_ITAH(14);
571 0 : BZ_ITAH(15); BZ_ITAH(16); BZ_ITAH(17); BZ_ITAH(18); BZ_ITAH(19);
572 0 : BZ_ITAH(20); BZ_ITAH(21); BZ_ITAH(22); BZ_ITAH(23); BZ_ITAH(24);
573 0 : BZ_ITAH(25); BZ_ITAH(26); BZ_ITAH(27); BZ_ITAH(28); BZ_ITAH(29);
574 0 : BZ_ITAH(30); BZ_ITAH(31); BZ_ITAH(32); BZ_ITAH(33); BZ_ITAH(34);
575 0 : BZ_ITAH(35); BZ_ITAH(36); BZ_ITAH(37); BZ_ITAH(38); BZ_ITAH(39);
576 0 : BZ_ITAH(40); BZ_ITAH(41); BZ_ITAH(42); BZ_ITAH(43); BZ_ITAH(44);
577 0 : BZ_ITAH(45); BZ_ITAH(46); BZ_ITAH(47); BZ_ITAH(48); BZ_ITAH(49);
578 :
579 0 : # undef BZ_ITAH
580 :
581 0 : } else {
582 : /*--- slow version which correctly handles all situations ---*/
583 0 : for (i = gs; i <= ge; i++) {
584 0 : bsW ( s,
585 0 : s->len [s->selector[selCtr]] [mtfv[i]],
586 0 : s->code [s->selector[selCtr]] [mtfv[i]] );
587 0 : }
588 0 : }
589 :
590 :
591 0 : gs = ge+1;
592 0 : selCtr++;
593 0 : }
594 0 : AssertH( selCtr == nSelectors, 3007 );
595 :
596 0 : if (s->verbosity >= 3)
597 0 : VPrintf1( "codes %d\n", s->numZ-nBytes );
598 0 : }
599 :
600 :
601 : /*---------------------------------------------------*/
602 : void BZ2_compressBlock ( EState* s, Bool is_last_block )
603 0 : {
604 0 : if (s->nblock > 0) {
605 :
606 0 : BZ_FINALISE_CRC ( s->blockCRC );
607 0 : s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
608 0 : s->combinedCRC ^= s->blockCRC;
609 0 : if (s->blockNo > 1) s->numZ = 0;
610 :
611 0 : if (s->verbosity >= 2)
612 0 : VPrintf4( " block %d: crc = 0x%08x, "
613 0 : "combined CRC = 0x%08x, size = %d\n",
614 0 : s->blockNo, s->blockCRC, s->combinedCRC, s->nblock );
615 :
616 0 : BZ2_blockSort ( s );
617 0 : }
618 :
619 0 : s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]);
620 :
621 : /*-- If this is the first block, create the stream header. --*/
622 0 : if (s->blockNo == 1) {
623 0 : BZ2_bsInitWrite ( s );
624 0 : bsPutUChar ( s, BZ_HDR_B );
625 0 : bsPutUChar ( s, BZ_HDR_Z );
626 0 : bsPutUChar ( s, BZ_HDR_h );
627 0 : bsPutUChar ( s, (UChar)(BZ_HDR_0 + s->blockSize100k) );
628 0 : }
629 :
630 0 : if (s->nblock > 0) {
631 :
632 0 : bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 );
633 0 : bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 );
634 0 : bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 );
635 :
636 : /*-- Now the block's CRC, so it is in a known place. --*/
637 0 : bsPutUInt32 ( s, s->blockCRC );
638 :
639 : /*--
640 : Now a single bit indicating (non-)randomisation.
641 : As of version 0.9.5, we use a better sorting algorithm
642 : which makes randomisation unnecessary. So always set
643 : the randomised bit to 'no'. Of course, the decoder
644 : still needs to be able to handle randomised blocks
645 : so as to maintain backwards compatibility with
646 : older versions of bzip2.
647 : --*/
648 0 : bsW(s,1,0);
649 :
650 0 : bsW ( s, 24, s->origPtr );
651 0 : generateMTFValues ( s );
652 0 : sendMTFValues ( s );
653 0 : }
654 :
655 :
656 : /*-- If this is the last block, add the stream trailer. --*/
657 0 : if (is_last_block) {
658 :
659 0 : bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 );
660 0 : bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 );
661 0 : bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 );
662 0 : bsPutUInt32 ( s, s->combinedCRC );
663 0 : if (s->verbosity >= 2)
664 : VPrintf1( " final combined CRC = 0x%08x\n ", s->combinedCRC );
665 0 : bsFinishWrite ( s );
666 0 : }
667 0 : }
668 :
669 :
670 : /*-------------------------------------------------------------*/
671 : /*--- end compress.c ---*/
672 : /*-------------------------------------------------------------*/
|
