external/bz2/compress.c

   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 /*---------------------------------------------------*/
  37 void BZ2_bsInitWrite ( EState* s )
  38 {
  39    s->bsLive = 0;
  40    s->bsBuff = 0;
  41 }
  42
  43
  44 /*---------------------------------------------------*/
  45 static
  46 void 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 /*---------------------------------------------------*/
  71 static
  72 __inline__
  73 void 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 /*---------------------------------------------------*/
  82 static
  83 void 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 /*---------------------------------------------------*/
  93 static
  94 void bsPutUChar ( EState* s, UChar c )
  95 {
  96    bsW( s, 8, (UInt32)c );
  97 }
  98
  99
 100 /*---------------------------------------------------*/
 101 /*--- The back end proper                         ---*/
 102 /*---------------------------------------------------*/
 103
 104 /*---------------------------------------------------*/
 105 static
 106 void 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 /*---------------------------------------------------*/
 119 static
 120 void 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
 238 static
 239 void 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 #ifdef BZ_NO_STDIO
 600    (void)nBytes; // Unused when stdio is disabled
 601 #endif
 602 }
 603
 604
 605 /*---------------------------------------------------*/
 606 void BZ2_compressBlock ( EState* s, Bool is_last_block )
 607 {
 608    if (s->nblock > 0) {
 609
 610       BZ_FINALISE_CRC ( s->blockCRC );
 611       s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
 612       s->combinedCRC ^= s->blockCRC;
 613       if (s->blockNo > 1) s->numZ = 0;
 614
 615       if (s->verbosity >= 2)
 616          VPrintf4( "    block %d: crc = 0x%08x, "
 617                    "combined CRC = 0x%08x, size = %d\n",
 618                    s->blockNo, s->blockCRC, s->combinedCRC, s->nblock );
 619
 620       BZ2_blockSort ( s );
 621    }
 622
 623    s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]);
 624
 625    /*-- If this is the first block, create the stream header. --*/
 626    if (s->blockNo == 1) {
 627       BZ2_bsInitWrite ( s );
 628       bsPutUChar ( s, BZ_HDR_B );
 629       bsPutUChar ( s, BZ_HDR_Z );
 630       bsPutUChar ( s, BZ_HDR_h );
 631       bsPutUChar ( s, (UChar)(BZ_HDR_0 + s->blockSize100k) );
 632    }
 633
 634    if (s->nblock > 0) {
 635
 636       bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 );
 637       bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 );
 638       bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 );
 639
 640       /*-- Now the block's CRC, so it is in a known place. --*/
 641       bsPutUInt32 ( s, s->blockCRC );
 642
 643       /*--
 644          Now a single bit indicating (non-)randomisation.
 645          As of version 0.9.5, we use a better sorting algorithm
 646          which makes randomisation unnecessary.  So always set
 647          the randomised bit to 'no'.  Of course, the decoder
 648          still needs to be able to handle randomised blocks
 649          so as to maintain backwards compatibility with
 650          older versions of bzip2.
 651       --*/
 652       bsW(s,1,0);
 653
 654       bsW ( s, 24, s->origPtr );
 655       generateMTFValues ( s );
 656       sendMTFValues ( s );
 657    }
 658
 659
 660    /*-- If this is the last block, add the stream trailer. --*/
 661    if (is_last_block) {
 662
 663       bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 );
 664       bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 );
 665       bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 );
 666       bsPutUInt32 ( s, s->combinedCRC );
 667       if (s->verbosity >= 2)
 668          VPrintf1( "    final combined CRC = 0x%08x\n   ", s->combinedCRC );
 669       bsFinishWrite ( s );
 670    }
 671 }
 672
 673
 674 /*-------------------------------------------------------------*/
 675 /*--- end                                        compress.c ---*/
 676 /*-------------------------------------------------------------*/