PageRenderTime 80ms CodeModel.GetById 13ms app.highlight 61ms RepoModel.GetById 1ms app.codeStats 0ms

/contrib/bzip2/compress.c

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