1  /********************************************************************** <BR>


2  This file is part of Crack dot Com's free source code release of


3  Golgotha. <a href="http://www.crack.com/golgotha_release"> <BR> for


4  information about compiling & licensing issues visit this URL</a>


5  <PRE> If that doesn't help, contact Jonathan Clark at


6  golgotha_source@usa.net (Subject should have "GOLG" in it)


7  ***********************************************************************/


8 


9  /* 

10  * jcphuff.c 

11  * 

12  * Copyright (C) 19951996, Thomas G. Lane. 

13  * This file is part of the Independent JPEG Group's software. 

14  * For conditions of distribution and use, see the accompanying README file. 

15  * 

16  * This file contains Huffman entropy encoding routines for progressive JPEG. 

17  * 

18  * We do not support output suspension in this module, since the library 

19  * currently does not allow multiplescan files to be written with output 

20  * suspension. 

21  */ 

22  

23  #define JPEG_INTERNALS 

24  #include "loaders/jpg/jinclude.h" 

25  #include "loaders/jpg/jpeglib.h" 

26  #include "loaders/jpg/jchuff.h" /* Declarations shared with jchuff.c */ 

27  

28  #ifdef C_PROGRESSIVE_SUPPORTED 

29  

30  /* Expanded entropy encoder object for progressive Huffman encoding. */ 

31  

32  typedef struct { 

33  struct jpeg_entropy_encoder pub; /* public fields */ 

34  

35  /* Mode flag: TRUE for optimization, FALSE for actual data output */ 

36  boolean gather_statistics; 

37  

38  /* Bitlevel coding status. 

39  * next_output_byte/free_in_buffer are local copies of cinfo>dest fields. 

40  */ 

41  JOCTET * next_output_byte; /* => next byte to write in buffer */ 

42  size_t free_in_buffer; /* # of byte spaces remaining in buffer */ 

43  INT32 put_buffer; /* current bitaccumulation buffer */ 

44  int put_bits; /* # of bits now in it */ 

45  j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */ 

46  

47  /* Coding status for DC components */ 

48  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ 

49  

50  /* Coding status for AC components */ 

51  int ac_tbl_no; /* the table number of the single component */ 

52  unsigned int EOBRUN; /* run length of EOBs */ 

53  unsigned int BE; /* # of buffered correction bits before MCU */ 

54  char * bit_buffer; /* buffer for correction bits (1 per char) */ 

55  /* packing correction bits tightly would save some space but cost time... */ 

56  

57  unsigned int restarts_to_go; /* MCUs left in this restart interval */ 

58  int next_restart_num; /* next restart number to write (07) */ 

59  

60  /* Pointers to derived tables (these workspaces have image lifespan). 

61  * Since any one scan codes only DC or only AC, we only need one set 

62  * of tables, not one for DC and one for AC. 

63  */ 

64  c_derived_tbl * derived_tbls[NUM_HUFF_TBLS]; 

65  

66  /* Statistics tables for optimization; again, one set is enough */ 

67  long * count_ptrs[NUM_HUFF_TBLS]; 

68  } phuff_entropy_encoder; 

69  

70  typedef phuff_entropy_encoder * phuff_entropy_ptr; 

71  

72  /* MAX_CORR_BITS is the number of bits the AC refinement correctionbit 

73  * buffer can hold. Larger sizes may slightly improve compression, but 

74  * 1000 is already well into the realm of overkill. 

75  * The minimum safe size is 64 bits. 

76  */ 

77  

78  #define MAX_CORR_BITS 1000 /* Max # of correction bits I can buffer */ 

79  

80  /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32. 

81  * We assume that int right shift is unsigned if INT32 right shift is, 

82  * which should be safe. 

83  */ 

84  

85  #ifdef RIGHT_SHIFT_IS_UNSIGNED 

86  #define ISHIFT_TEMPS int ishift_temp; 

87  #define IRIGHT_SHIFT(x,shft) \ 

88  ((ishift_temp = (x)) < 0 ? \ 

89  (ishift_temp >> (shft))  ((~0) << (16(shft))) : \ 

90  (ishift_temp >> (shft))) 

91  #else 

92  #define ISHIFT_TEMPS 

93  #define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) 

94  #endif 

95  

96  /* Forward declarations */ 

97  METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo, 

98  JBLOCKROW *MCU_data)); 

99  METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo, 

100  JBLOCKROW *MCU_data)); 

101  METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo, 

102  JBLOCKROW *MCU_data)); 

103  METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo, 

104  JBLOCKROW *MCU_data)); 

105  METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo)); 

106  METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo)); 

107  

108  

109  /* 

110  * Initialize for a Huffmancompressed scan using progressive JPEG. 

111  */ 

112  

113  METHODDEF(void) 

114  start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics) 

115  { 

116  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

117  boolean is_DC_band; 

118  int ci, tbl; 

119  jpeg_component_info * compptr; 

120  

121  entropy>cinfo = cinfo; 

122  entropy>gather_statistics = gather_statistics; 

123  

124  is_DC_band = (cinfo>Ss == 0); 

125  

126  /* We assume jcmaster.c already validated the scan parameters. */ 

127  

128  /* Select execution routines */ 

129  if (cinfo>Ah == 0) { 

130  if (is_DC_band) 

131  entropy>pub.encode_mcu = encode_mcu_DC_first; 

132  else 

133  entropy>pub.encode_mcu = encode_mcu_AC_first; 

134  } else { 

135  if (is_DC_band) 

136  entropy>pub.encode_mcu = encode_mcu_DC_refine; 

137  else { 

138  entropy>pub.encode_mcu = encode_mcu_AC_refine; 

139  /* AC refinement needs a correction bit buffer */ 

140  if (entropy>bit_buffer == NULL) 

141  entropy>bit_buffer = (char *) 

142  (*cinfo>mem>alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 

143  MAX_CORR_BITS * SIZEOF(char)); 

144  } 

145  } 

146  if (gather_statistics) 

147  entropy>pub.finish_pass = finish_pass_gather_phuff; 

148  else 

149  entropy>pub.finish_pass = finish_pass_phuff; 

150  

151  /* Only DC coefficients may be interleaved, so cinfo>comps_in_scan = 1 

152  * for AC coefficients. 

153  */ 

154  for (ci = 0; ci < cinfo>comps_in_scan; ci++) { 

155  compptr = cinfo>cur_comp_info[ci]; 

156  /* Initialize DC predictions to 0 */ 

157  entropy>last_dc_val[ci] = 0; 

158  /* Make sure requested tables are present */ 

159  /* (In gather mode, tables need not be allocated yet) */ 

160  if (is_DC_band) { 

161  if (cinfo>Ah != 0) /* DC refinement needs no table */ 

162  continue; 

163  tbl = compptr>dc_tbl_no; 

164  if (tbl < 0  tbl >= NUM_HUFF_TBLS  

165  (cinfo>dc_huff_tbl_ptrs[tbl] == NULL && !gather_statistics)) 

166  ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl); 

167  } else { 

168  entropy>ac_tbl_no = tbl = compptr>ac_tbl_no; 

169  if (tbl < 0  tbl >= NUM_HUFF_TBLS  

170  (cinfo>ac_huff_tbl_ptrs[tbl] == NULL && !gather_statistics)) 

171  ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl); 

172  } 

173  if (gather_statistics) { 

174  /* Allocate and zero the statistics tables */ 

175  /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */ 

176  if (entropy>count_ptrs[tbl] == NULL) 

177  entropy>count_ptrs[tbl] = (long *) 

178  (*cinfo>mem>alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 

179  257 * SIZEOF(long)); 

180  MEMZERO(entropy>count_ptrs[tbl], 257 * SIZEOF(long)); 

181  } else { 

182  /* Compute derived values for Huffman tables */ 

183  /* We may do this more than once for a table, but it's not expensive */ 

184  if (is_DC_band) 

185  jpeg_make_c_derived_tbl(cinfo, cinfo>dc_huff_tbl_ptrs[tbl], 

186  & entropy>derived_tbls[tbl]); 

187  else 

188  jpeg_make_c_derived_tbl(cinfo, cinfo>ac_huff_tbl_ptrs[tbl], 

189  & entropy>derived_tbls[tbl]); 

190  } 

191  } 

192  

193  /* Initialize AC stuff */ 

194  entropy>EOBRUN = 0; 

195  entropy>BE = 0; 

196  

197  /* Initialize bit buffer to empty */ 

198  entropy>put_buffer = 0; 

199  entropy>put_bits = 0; 

200  

201  /* Initialize restart stuff */ 

202  entropy>restarts_to_go = cinfo>restart_interval; 

203  entropy>next_restart_num = 0; 

204  } 

205  

206  

207  /* Outputting bytes to the file. 

208  * NB: these must be called only when actually outputting, 

209  * that is, entropy>gather_statistics == FALSE. 

210  */ 

211  

212  /* Emit a byte */ 

213  #define emit_byte(entropy,val) \ 

214  { *(entropy)>next_output_byte++ = (JOCTET) (val); \ 

215  if ((entropy)>free_in_buffer == 0) \ 

216  dump_buffer(entropy); } 

217  

218  

219  LOCAL(void) 

220  dump_buffer (phuff_entropy_ptr entropy) 

221  /* Empty the output buffer; we do not support suspension in this module. */ 

222  { 

223  struct jpeg_destination_mgr * dest = entropy>cinfo>dest; 

224  

225  if (! (*dest>empty_output_buffer) (entropy>cinfo)) 

226  ERREXIT(entropy>cinfo, JERR_CANT_SUSPEND); 

227  /* After a successful buffer dump, must reset buffer pointers */ 

228  entropy>next_output_byte = dest>next_output_byte; 

229  entropy>free_in_buffer = dest>free_in_buffer; 

230  } 

231  

232  

233  /* Outputting bits to the file */ 

234  

235  /* Only the right 24 bits of put_buffer are used; the valid bits are 

236  * leftjustified in this part. At most 16 bits can be passed to emit_bits 

237  * in one call, and we never retain more than 7 bits in put_buffer 

238  * between calls, so 24 bits are sufficient. 

239  */ 

240  

241  INLINE 

242  LOCAL(void) 

243  emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size) 

244  /* Emit some bits, unless we are in gather mode */ 

245  { 

246  /* This routine is heavily used, so it's worth coding tightly. */ 

247  register INT32 put_buffer = (INT32) code; 

248  register int put_bits = entropy>put_bits; 

249  

250  /* if size is 0, caller used an invalid Huffman table entry */ 

251  if (size == 0) 

252  ERREXIT(entropy>cinfo, JERR_HUFF_MISSING_CODE); 

253  

254  if (entropy>gather_statistics) 

255  return; /* do nothing if we're only getting stats */ 

256  

257  put_buffer &= (((INT32) 1)<<size)  1; /* mask off any extra bits in code */ 

258  

259  put_bits += size; /* new number of bits in buffer */ 

260  

261  put_buffer <<= 24  put_bits; /* align incoming bits */ 

262  

263  put_buffer = entropy>put_buffer; /* and merge with old buffer contents */ 

264  

265  while (put_bits >= 8) { 

266  int c = (int) ((put_buffer >> 16) & 0xFF); 

267  

268  emit_byte(entropy, c); 

269  if (c == 0xFF) { /* need to stuff a zero byte? */ 

270  emit_byte(entropy, 0); 

271  } 

272  put_buffer <<= 8; 

273  put_bits = 8; 

274  } 

275  

276  entropy>put_buffer = put_buffer; /* update variables */ 

277  entropy>put_bits = put_bits; 

278  } 

279  

280  

281  LOCAL(void) 

282  flush_bits (phuff_entropy_ptr entropy) 

283  { 

284  emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */ 

285  entropy>put_buffer = 0; /* and reset bitbuffer to empty */ 

286  entropy>put_bits = 0; 

287  } 

288  

289  

290  /* 

291  * Emit (or just count) a Huffman symbol. 

292  */ 

293  

294  INLINE 

295  LOCAL(void) 

296  emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol) 

297  { 

298  if (entropy>gather_statistics) 

299  entropy>count_ptrs[tbl_no][symbol]++; 

300  else { 

301  c_derived_tbl * tbl = entropy>derived_tbls[tbl_no]; 

302  emit_bits(entropy, tbl>ehufco[symbol], tbl>ehufsi[symbol]); 

303  } 

304  } 

305  

306  

307  /* 

308  * Emit bits from a correction bit buffer. 

309  */ 

310  

311  LOCAL(void) 

312  emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart, 

313  unsigned int nbits) 

314  { 

315  if (entropy>gather_statistics) 

316  return; /* no real work */ 

317  

318  while (nbits > 0) { 

319  emit_bits(entropy, (unsigned int) (*bufstart), 1); 

320  bufstart++; 

321  nbits; 

322  } 

323  } 

324  

325  

326  /* 

327  * Emit any pending EOBRUN symbol. 

328  */ 

329  

330  LOCAL(void) 

331  emit_eobrun (phuff_entropy_ptr entropy) 

332  { 

333  register int temp, nbits; 

334  

335  if (entropy>EOBRUN > 0) { /* if there is any pending EOBRUN */ 

336  temp = entropy>EOBRUN; 

337  nbits = 0; 

338  while ((temp >>= 1)) 

339  nbits++; 

340  

341  emit_symbol(entropy, entropy>ac_tbl_no, nbits << 4); 

342  if (nbits) 

343  emit_bits(entropy, entropy>EOBRUN, nbits); 

344  

345  entropy>EOBRUN = 0; 

346  

347  /* Emit any buffered correction bits */ 

348  emit_buffered_bits(entropy, entropy>bit_buffer, entropy>BE); 

349  entropy>BE = 0; 

350  } 

351  } 

352  

353  

354  /* 

355  * Emit a restart marker & resynchronize predictions. 

356  */ 

357  

358  LOCAL(void) 

359  emit_restart (phuff_entropy_ptr entropy, int restart_num) 

360  { 

361  int ci; 

362  

363  emit_eobrun(entropy); 

364  

365  if (! entropy>gather_statistics) { 

366  flush_bits(entropy); 

367  emit_byte(entropy, 0xFF); 

368  emit_byte(entropy, JPEG_RST0 + restart_num); 

369  } 

370  

371  if (entropy>cinfo>Ss == 0) { 

372  /* Reinitialize DC predictions to 0 */ 

373  for (ci = 0; ci < entropy>cinfo>comps_in_scan; ci++) 

374  entropy>last_dc_val[ci] = 0; 

375  } else { 

376  /* Reinitialize all ACrelated fields to 0 */ 

377  entropy>EOBRUN = 0; 

378  entropy>BE = 0; 

379  } 

380  } 

381  

382  

383  /* 

384  * MCU encoding for DC initial scan (either spectral selection, 

385  * or first pass of successive approximation). 

386  */ 

387  

388  METHODDEF(boolean) 

389  encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 

390  { 

391  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

392  register int temp, temp2; 

393  register int nbits; 

394  int blkn, ci; 

395  int Al = cinfo>Al; 

396  JBLOCKROW block; 

397  jpeg_component_info * compptr; 

398  ISHIFT_TEMPS 

399  

400  entropy>next_output_byte = cinfo>dest>next_output_byte; 

401  entropy>free_in_buffer = cinfo>dest>free_in_buffer; 

402  

403  /* Emit restart marker if needed */ 

404  if (cinfo>restart_interval) 

405  if (entropy>restarts_to_go == 0) 

406  emit_restart(entropy, entropy>next_restart_num); 

407  

408  /* Encode the MCU data blocks */ 

409  for (blkn = 0; blkn < cinfo>blocks_in_MCU; blkn++) { 

410  block = MCU_data[blkn]; 

411  ci = cinfo>MCU_membership[blkn]; 

412  compptr = cinfo>cur_comp_info[ci]; 

413  

414  /* Compute the DC value after the required point transform by Al. 

415  * This is simply an arithmetic right shift. 

416  */ 

417  temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al); 

418  

419  /* DC differences are figured on the pointtransformed values. */ 

420  temp = temp2  entropy>last_dc_val[ci]; 

421  entropy>last_dc_val[ci] = temp2; 

422  

423  /* Encode the DC coefficient difference per section G.1.2.1 */ 

424  temp2 = temp; 

425  if (temp < 0) { 

426  temp = temp; /* temp is abs value of input */ 

427  /* For a negative input, want temp2 = bitwise complement of abs(input) */ 

428  /* This code assumes we are on a two's complement machine */ 

429  temp2; 

430  } 

431  

432  /* Find the number of bits needed for the magnitude of the coefficient */ 

433  nbits = 0; 

434  while (temp) { 

435  nbits++; 

436  temp >>= 1; 

437  } 

438  

439  /* Count/emit the Huffmancoded symbol for the number of bits */ 

440  emit_symbol(entropy, compptr>dc_tbl_no, nbits); 

441  

442  /* Emit that number of bits of the value, if positive, */ 

443  /* or the complement of its magnitude, if negative. */ 

444  if (nbits) /* emit_bits rejects calls with size 0 */ 

445  emit_bits(entropy, (unsigned int) temp2, nbits); 

446  } 

447  

448  cinfo>dest>next_output_byte = entropy>next_output_byte; 

449  cinfo>dest>free_in_buffer = entropy>free_in_buffer; 

450  

451  /* Update restartinterval state too */ 

452  if (cinfo>restart_interval) { 

453  if (entropy>restarts_to_go == 0) { 

454  entropy>restarts_to_go = cinfo>restart_interval; 

455  entropy>next_restart_num++; 

456  entropy>next_restart_num &= 7; 

457  } 

458  entropy>restarts_to_go; 

459  } 

460  

461  return TRUE; 

462  } 

463  

464  

465  /* 

466  * MCU encoding for AC initial scan (either spectral selection, 

467  * or first pass of successive approximation). 

468  */ 

469  

470  METHODDEF(boolean) 

471  encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 

472  { 

473  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

474  register int temp, temp2; 

475  register int nbits; 

476  register int r, k; 

477  int Se = cinfo>Se; 

478  int Al = cinfo>Al; 

479  JBLOCKROW block; 

480  

481  entropy>next_output_byte = cinfo>dest>next_output_byte; 

482  entropy>free_in_buffer = cinfo>dest>free_in_buffer; 

483  

484  /* Emit restart marker if needed */ 

485  if (cinfo>restart_interval) 

486  if (entropy>restarts_to_go == 0) 

487  emit_restart(entropy, entropy>next_restart_num); 

488  

489  /* Encode the MCU data block */ 

490  block = MCU_data[0]; 

491  

492  /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */ 

493  

494  r = 0; /* r = run length of zeros */ 

495  

496  for (k = cinfo>Ss; k <= Se; k++) { 

497  if ((temp = (*block)[jpeg_natural_order[k]]) == 0) { 

498  r++; 

499  continue; 

500  } 

501  /* We must apply the point transform by Al. For AC coefficients this 

502  * is an integer division with rounding towards 0. To do this portably 

503  * in C, we shift after obtaining the absolute value; so the code is 

504  * interwoven with finding the abs value (temp) and output bits (temp2). 

505  */ 

506  if (temp < 0) { 

507  temp = temp; /* temp is abs value of input */ 

508  temp >>= Al; /* apply the point transform */ 

509  /* For a negative coef, want temp2 = bitwise complement of abs(coef) */ 

510  temp2 = ~temp; 

511  } else { 

512  temp >>= Al; /* apply the point transform */ 

513  temp2 = temp; 

514  } 

515  /* Watch out for case that nonzero coef is zero after point transform */ 

516  if (temp == 0) { 

517  r++; 

518  continue; 

519  } 

520  

521  /* Emit any pending EOBRUN */ 

522  if (entropy>EOBRUN > 0) 

523  emit_eobrun(entropy); 

524  /* if run length > 15, must emit special runlength16 codes (0xF0) */ 

525  while (r > 15) { 

526  emit_symbol(entropy, entropy>ac_tbl_no, 0xF0); 

527  r = 16; 

528  } 

529  

530  /* Find the number of bits needed for the magnitude of the coefficient */ 

531  nbits = 1; /* there must be at least one 1 bit */ 

532  while ((temp >>= 1)) 

533  nbits++; 

534  

535  /* Count/emit Huffman symbol for run length / number of bits */ 

536  emit_symbol(entropy, entropy>ac_tbl_no, (r << 4) + nbits); 

537  

538  /* Emit that number of bits of the value, if positive, */ 

539  /* or the complement of its magnitude, if negative. */ 

540  emit_bits(entropy, (unsigned int) temp2, nbits); 

541  

542  r = 0; /* reset zero run length */ 

543  } 

544  

545  if (r > 0) { /* If there are trailing zeroes, */ 

546  entropy>EOBRUN++; /* count an EOB */ 

547  if (entropy>EOBRUN == 0x7FFF) 

548  emit_eobrun(entropy); /* force it out to avoid overflow */ 

549  } 

550  

551  cinfo>dest>next_output_byte = entropy>next_output_byte; 

552  cinfo>dest>free_in_buffer = entropy>free_in_buffer; 

553  

554  /* Update restartinterval state too */ 

555  if (cinfo>restart_interval) { 

556  if (entropy>restarts_to_go == 0) { 

557  entropy>restarts_to_go = cinfo>restart_interval; 

558  entropy>next_restart_num++; 

559  entropy>next_restart_num &= 7; 

560  } 

561  entropy>restarts_to_go; 

562  } 

563  

564  return TRUE; 

565  } 

566  

567  

568  /* 

569  * MCU encoding for DC successive approximation refinement scan. 

570  * Note: we assume such scans can be multicomponent, although the spec 

571  * is not very clear on the point. 

572  */ 

573  

574  METHODDEF(boolean) 

575  encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 

576  { 

577  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

578  register int temp; 

579  int blkn; 

580  int Al = cinfo>Al; 

581  JBLOCKROW block; 

582  

583  entropy>next_output_byte = cinfo>dest>next_output_byte; 

584  entropy>free_in_buffer = cinfo>dest>free_in_buffer; 

585  

586  /* Emit restart marker if needed */ 

587  if (cinfo>restart_interval) 

588  if (entropy>restarts_to_go == 0) 

589  emit_restart(entropy, entropy>next_restart_num); 

590  

591  /* Encode the MCU data blocks */ 

592  for (blkn = 0; blkn < cinfo>blocks_in_MCU; blkn++) { 

593  block = MCU_data[blkn]; 

594  

595  /* We simply emit the Al'th bit of the DC coefficient value. */ 

596  temp = (*block)[0]; 

597  emit_bits(entropy, (unsigned int) (temp >> Al), 1); 

598  } 

599  

600  cinfo>dest>next_output_byte = entropy>next_output_byte; 

601  cinfo>dest>free_in_buffer = entropy>free_in_buffer; 

602  

603  /* Update restartinterval state too */ 

604  if (cinfo>restart_interval) { 

605  if (entropy>restarts_to_go == 0) { 

606  entropy>restarts_to_go = cinfo>restart_interval; 

607  entropy>next_restart_num++; 

608  entropy>next_restart_num &= 7; 

609  } 

610  entropy>restarts_to_go; 

611  } 

612  

613  return TRUE; 

614  } 

615  

616  

617  /* 

618  * MCU encoding for AC successive approximation refinement scan. 

619  */ 

620  

621  METHODDEF(boolean) 

622  encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 

623  { 

624  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

625  register int temp; 

626  register int r, k; 

627  int EOB; 

628  char *BR_buffer; 

629  unsigned int BR; 

630  int Se = cinfo>Se; 

631  int Al = cinfo>Al; 

632  JBLOCKROW block; 

633  int absvalues[DCTSIZE2]; 

634  

635  entropy>next_output_byte = cinfo>dest>next_output_byte; 

636  entropy>free_in_buffer = cinfo>dest>free_in_buffer; 

637  

638  /* Emit restart marker if needed */ 

639  if (cinfo>restart_interval) 

640  if (entropy>restarts_to_go == 0) 

641  emit_restart(entropy, entropy>next_restart_num); 

642  

643  /* Encode the MCU data block */ 

644  block = MCU_data[0]; 

645  

646  /* It is convenient to make a prepass to determine the transformed 

647  * coefficients' absolute values and the EOB position. 

648  */ 

649  EOB = 0; 

650  for (k = cinfo>Ss; k <= Se; k++) { 

651  temp = (*block)[jpeg_natural_order[k]]; 

652  /* We must apply the point transform by Al. For AC coefficients this 

653  * is an integer division with rounding towards 0. To do this portably 

654  * in C, we shift after obtaining the absolute value. 

655  */ 

656  if (temp < 0) 

657  temp = temp; /* temp is abs value of input */ 

658  temp >>= Al; /* apply the point transform */ 

659  absvalues[k] = temp; /* save abs value for main pass */ 

660  if (temp == 1) 

661  EOB = k; /* EOB = index of last newlynonzero coef */ 

662  } 

663  

664  /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */ 

665  

666  r = 0; /* r = run length of zeros */ 

667  BR = 0; /* BR = count of buffered bits added now */ 

668  BR_buffer = entropy>bit_buffer + entropy>BE; /* Append bits to buffer */ 

669  

670  for (k = cinfo>Ss; k <= Se; k++) { 

671  if ((temp = absvalues[k]) == 0) { 

672  r++; 

673  continue; 

674  } 

675  

676  /* Emit any required ZRLs, but not if they can be folded into EOB */ 

677  while (r > 15 && k <= EOB) { 

678  /* emit any pending EOBRUN and the BE correction bits */ 

679  emit_eobrun(entropy); 

680  /* Emit ZRL */ 

681  emit_symbol(entropy, entropy>ac_tbl_no, 0xF0); 

682  r = 16; 

683  /* Emit buffered correction bits that must be associated with ZRL */ 

684  emit_buffered_bits(entropy, BR_buffer, BR); 

685  BR_buffer = entropy>bit_buffer; /* BE bits are gone now */ 

686  BR = 0; 

687  } 

688  

689  /* If the coef was previously nonzero, it only needs a correction bit. 

690  * NOTE: a straight translation of the spec's figure G.7 would suggest 

691  * that we also need to test r > 15. But if r > 15, we can only get here 

692  * if k > EOB, which implies that this coefficient is not 1. 

693  */ 

694  if (temp > 1) { 

695  /* The correction bit is the next bit of the absolute value. */ 

696  BR_buffer[BR++] = (char) (temp & 1); 

697  continue; 

698  } 

699  

700  /* Emit any pending EOBRUN and the BE correction bits */ 

701  emit_eobrun(entropy); 

702  

703  /* Count/emit Huffman symbol for run length / number of bits */ 

704  emit_symbol(entropy, entropy>ac_tbl_no, (r << 4) + 1); 

705  

706  /* Emit output bit for newlynonzero coef */ 

707  temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1; 

708  emit_bits(entropy, (unsigned int) temp, 1); 

709  

710  /* Emit buffered correction bits that must be associated with this code */ 

711  emit_buffered_bits(entropy, BR_buffer, BR); 

712  BR_buffer = entropy>bit_buffer; /* BE bits are gone now */ 

713  BR = 0; 

714  r = 0; /* reset zero run length */ 

715  } 

716  

717  if (r > 0  BR > 0) { /* If there are trailing zeroes, */ 

718  entropy>EOBRUN++; /* count an EOB */ 

719  entropy>BE += BR; /* concat my correction bits to older ones */ 

720  /* We force out the EOB if we risk either: 

721  * 1. overflow of the EOB counter; 

722  * 2. overflow of the correction bit buffer during the next MCU. 

723  */ 

724  if (entropy>EOBRUN == 0x7FFF  entropy>BE > (MAX_CORR_BITSDCTSIZE2+1)) 

725  emit_eobrun(entropy); 

726  } 

727  

728  cinfo>dest>next_output_byte = entropy>next_output_byte; 

729  cinfo>dest>free_in_buffer = entropy>free_in_buffer; 

730  

731  /* Update restartinterval state too */ 

732  if (cinfo>restart_interval) { 

733  if (entropy>restarts_to_go == 0) { 

734  entropy>restarts_to_go = cinfo>restart_interval; 

735  entropy>next_restart_num++; 

736  entropy>next_restart_num &= 7; 

737  } 

738  entropy>restarts_to_go; 

739  } 

740  

741  return TRUE; 

742  } 

743  

744  

745  /* 

746  * Finish up at the end of a Huffmancompressed progressive scan. 

747  */ 

748  

749  METHODDEF(void) 

750  finish_pass_phuff (j_compress_ptr cinfo) 

751  { 

752  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

753  

754  entropy>next_output_byte = cinfo>dest>next_output_byte; 

755  entropy>free_in_buffer = cinfo>dest>free_in_buffer; 

756  

757  /* Flush out any buffered data */ 

758  emit_eobrun(entropy); 

759  flush_bits(entropy); 

760  

761  cinfo>dest>next_output_byte = entropy>next_output_byte; 

762  cinfo>dest>free_in_buffer = entropy>free_in_buffer; 

763  } 

764  

765  

766  /* 

767  * Finish up a statisticsgathering pass and create the new Huffman tables. 

768  */ 

769  

770  METHODDEF(void) 

771  finish_pass_gather_phuff (j_compress_ptr cinfo) 

772  { 

773  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo>entropy; 

774  boolean is_DC_band; 

775  int ci, tbl; 

776  jpeg_component_info * compptr; 

777  JHUFF_TBL **htblptr; 

778  boolean did[NUM_HUFF_TBLS]; 

779  

780  /* Flush out buffered data (all we care about is counting the EOB symbol) */ 

781  emit_eobrun(entropy); 

782  

783  is_DC_band = (cinfo>Ss == 0); 

784  

785  /* It's important not to apply jpeg_gen_optimal_table more than once 

786  * per table, because it clobbers the input frequency counts! 

787  */ 

788  MEMZERO(did, SIZEOF(did)); 

789  

790  for (ci = 0; ci < cinfo>comps_in_scan; ci++) { 

791  compptr = cinfo>cur_comp_info[ci]; 

792  if (is_DC_band) { 

793  if (cinfo>Ah != 0) /* DC refinement needs no table */ 

794  continue; 

795  tbl = compptr>dc_tbl_no; 

796  } else { 

797  tbl = compptr>ac_tbl_no; 

798  } 

799  if (! did[tbl]) { 

800  if (is_DC_band) 

801  htblptr = & cinfo>dc_huff_tbl_ptrs[tbl]; 

802  else 

803  htblptr = & cinfo>ac_huff_tbl_ptrs[tbl]; 

804  if (*htblptr == NULL) 

805  *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 

806  jpeg_gen_optimal_table(cinfo, *htblptr, entropy>count_ptrs[tbl]); 

807  did[tbl] = TRUE; 

808  } 

809  } 

810  } 

811  

812  

813  /* 

814  * Module initialization routine for progressive Huffman entropy encoding. 

815  */ 

816  

817  GLOBAL(void) 

818  jinit_phuff_encoder (j_compress_ptr cinfo) 

819  { 

820  phuff_entropy_ptr entropy; 

821  int i; 

822  

823  entropy = (phuff_entropy_ptr) 

824  (*cinfo>mem>alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 

825  SIZEOF(phuff_entropy_encoder)); 

826  cinfo>entropy = (struct jpeg_entropy_encoder *) entropy; 

827  entropy>pub.start_pass = start_pass_phuff; 

828  

829  /* Mark tables unallocated */ 

830  for (i = 0; i < NUM_HUFF_TBLS; i++) { 

831  entropy>derived_tbls[i] = NULL; 

832  entropy>count_ptrs[i] = NULL; 

833  } 

834  entropy>bit_buffer = NULL; /* needed only in AC refinement scan */ 

835  } 

836  

837  #endif /* C_PROGRESSIVE_SUPPORTED */ 
