1 /*
2 * jchuff.c
3 *
4 * Copyright (C) 1991-1997, Thomas G. Lane.
5 * Modified 2006-2013 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
8 *
9 * This file contains Huffman entropy encoding routines.
10 * Both sequential and progressive modes are supported in this single module.
11 *
12 * Much of the complexity here has to do with supporting output suspension.
13 * If the data destination module demands suspension, we want to be able to
14 * back up to the start of the current MCU. To do this, we copy state
15 * variables into local working storage, and update them back to the
16 * permanent JPEG objects only upon successful completion of an MCU.
17 *
18 * We do not support output suspension for the progressive JPEG mode, since
19 * the library currently does not allow multiple-scan files to be written
20 * with output suspension.
21 */
22
23 #define JPEG_INTERNALS
24 #include "jinclude.h"
25 #include "jpeglib.h"
26
27
28 /* The legal range of a DCT coefficient is
29 * -1024 .. +1023 for 8-bit data;
30 * -16384 .. +16383 for 12-bit data.
31 * Hence the magnitude should always fit in 10 or 14 bits respectively.
32 */
33
34 #if BITS_IN_JSAMPLE == 8
35 #define MAX_COEF_BITS 10
36 #else
37 #define MAX_COEF_BITS 14
38 #endif
39
40 /* Derived data constructed for each Huffman table */
41
42 typedef struct {
43 unsigned int ehufco[256]; /* code for each symbol */
44 char ehufsi[256]; /* length of code for each symbol */
45 /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
46 } c_derived_tbl;
47
48
49 /* Expanded entropy encoder object for Huffman encoding.
50 *
51 * The savable_state subrecord contains fields that change within an MCU,
52 * but must not be updated permanently until we complete the MCU.
53 */
54
55 typedef struct {
56 INT32 put_buffer; /* current bit-accumulation buffer */
57 int put_bits; /* # of bits now in it */
58 int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
59 } savable_state;
60
61 /* This macro is to work around compilers with missing or broken
62 * structure assignment. You'll need to fix this code if you have
63 * such a compiler and you change MAX_COMPS_IN_SCAN.
64 */
65
66 #ifndef NO_STRUCT_ASSIGN
67 #define ASSIGN_STATE(dest,src) ((dest) = (src))
68 #else
69 #if MAX_COMPS_IN_SCAN == 4
70 #define ASSIGN_STATE(dest,src) \
71 ((dest).put_buffer = (src).put_buffer, \
72 (dest).put_bits = (src).put_bits, \
73 (dest).last_dc_val[0] = (src).last_dc_val[0], \
74 (dest).last_dc_val[1] = (src).last_dc_val[1], \
75 (dest).last_dc_val[2] = (src).last_dc_val[2], \
76 (dest).last_dc_val[3] = (src).last_dc_val[3])
77 #endif
78 #endif
79
80
81 typedef struct {
82 struct jpeg_entropy_encoder pub; /* public fields */
83
84 savable_state saved; /* Bit buffer & DC state at start of MCU */
85
86 /* These fields are NOT loaded into local working state. */
87 unsigned int restarts_to_go; /* MCUs left in this restart interval */
88 int next_restart_num; /* next restart number to write (0-7) */
89
90 /* Pointers to derived tables (these workspaces have image lifespan) */
91 c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
92 c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
93
94 /* Statistics tables for optimization */
95 long * dc_count_ptrs[NUM_HUFF_TBLS];
96 long * ac_count_ptrs[NUM_HUFF_TBLS];
97
98 /* Following fields used only in progressive mode */
99
100 /* Mode flag: TRUE for optimization, FALSE for actual data output */
101 boolean gather_statistics;
102
103 /* next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
104 */
105 JOCTET * next_output_byte; /* => next byte to write in buffer */
106 size_t free_in_buffer; /* # of byte spaces remaining in buffer */
107 j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */
108
109 /* Coding status for AC components */
110 int ac_tbl_no; /* the table number of the single component */
111 unsigned int EOBRUN; /* run length of EOBs */
112 unsigned int BE; /* # of buffered correction bits before MCU */
113 char * bit_buffer; /* buffer for correction bits (1 per char) */
114 /* packing correction bits tightly would save some space but cost time... */
115 } huff_entropy_encoder;
116
117 typedef huff_entropy_encoder * huff_entropy_ptr;
118
119 /* Working state while writing an MCU (sequential mode).
120 * This struct contains all the fields that are needed by subroutines.
121 */
122
123 typedef struct {
124 JOCTET * next_output_byte; /* => next byte to write in buffer */
125 size_t free_in_buffer; /* # of byte spaces remaining in buffer */
126 savable_state cur; /* Current bit buffer & DC state */
127 j_compress_ptr cinfo; /* dump_buffer needs access to this */
128 } working_state;
129
130 /* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
131 * buffer can hold. Larger sizes may slightly improve compression, but
132 * 1000 is already well into the realm of overkill.
133 * The minimum safe size is 64 bits.
134 */
135
136 #define MAX_CORR_BITS 1000 /* Max # of correction bits I can buffer */
137
138 /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
139 * We assume that int right shift is unsigned if INT32 right shift is,
140 * which should be safe.
141 */
142
143 #ifdef RIGHT_SHIFT_IS_UNSIGNED
144 #define ISHIFT_TEMPS int ishift_temp;
145 #define IRIGHT_SHIFT(x,shft) \
146 ((ishift_temp = (x)) < 0 ? \
147 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
148 (ishift_temp >> (shft)))
149 #else
150 #define ISHIFT_TEMPS
151 #define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
152 #endif
153
154
155 /*
156 * Compute the derived values for a Huffman table.
157 * This routine also performs some validation checks on the table.
158 */
159
160 LOCAL(void)
jpeg_make_c_derived_tbl(j_compress_ptr cinfo,boolean isDC,int tblno,c_derived_tbl ** pdtbl)161 jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
162 c_derived_tbl ** pdtbl)
163 {
164 JHUFF_TBL *htbl;
165 c_derived_tbl *dtbl;
166 int p, i, l, lastp, si, maxsymbol;
167 char huffsize[257];
168 unsigned int huffcode[257];
169 unsigned int code;
170
171 /* Note that huffsize[] and huffcode[] are filled in code-length order,
172 * paralleling the order of the symbols themselves in htbl->huffval[].
173 */
174
175 /* Find the input Huffman table */
176 if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
177 ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
178 htbl =
179 isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
180 if (htbl == NULL)
181 ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
182
183 /* Allocate a workspace if we haven't already done so. */
184 if (*pdtbl == NULL)
185 *pdtbl = (c_derived_tbl *)
186 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
187 SIZEOF(c_derived_tbl));
188 dtbl = *pdtbl;
189
190 /* Figure C.1: make table of Huffman code length for each symbol */
191
192 p = 0;
193 for (l = 1; l <= 16; l++) {
194 i = (int) htbl->bits[l];
195 if (i < 0 || p + i > 256) /* protect against table overrun */
196 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
197 while (i--)
198 huffsize[p++] = (char) l;
199 }
200 huffsize[p] = 0;
201 lastp = p;
202
203 /* Figure C.2: generate the codes themselves */
204 /* We also validate that the counts represent a legal Huffman code tree. */
205
206 code = 0;
207 si = huffsize[0];
208 p = 0;
209 while (huffsize[p]) {
210 while (((int) huffsize[p]) == si) {
211 huffcode[p++] = code;
212 code++;
213 }
214 /* code is now 1 more than the last code used for codelength si; but
215 * it must still fit in si bits, since no code is allowed to be all ones.
216 */
217 if (((INT32) code) >= (((INT32) 1) << si))
218 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
219 code <<= 1;
220 si++;
221 }
222
223 /* Figure C.3: generate encoding tables */
224 /* These are code and size indexed by symbol value */
225
226 /* Set all codeless symbols to have code length 0;
227 * this lets us detect duplicate VAL entries here, and later
228 * allows emit_bits to detect any attempt to emit such symbols.
229 */
230 MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));
231
232 /* This is also a convenient place to check for out-of-range
233 * and duplicated VAL entries. We allow 0..255 for AC symbols
234 * but only 0..15 for DC. (We could constrain them further
235 * based on data depth and mode, but this seems enough.)
236 */
237 maxsymbol = isDC ? 15 : 255;
238
239 for (p = 0; p < lastp; p++) {
240 i = htbl->huffval[p];
241 if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
242 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
243 dtbl->ehufco[i] = huffcode[p];
244 dtbl->ehufsi[i] = huffsize[p];
245 }
246 }
247
248
249 /* Outputting bytes to the file.
250 * NB: these must be called only when actually outputting,
251 * that is, entropy->gather_statistics == FALSE.
252 */
253
254 /* Emit a byte, taking 'action' if must suspend. */
255 #define emit_byte_s(state,val,action) \
256 { *(state)->next_output_byte++ = (JOCTET) (val); \
257 if (--(state)->free_in_buffer == 0) \
258 if (! dump_buffer_s(state)) \
259 { action; } }
260
261 /* Emit a byte */
262 #define emit_byte_e(entropy,val) \
263 { *(entropy)->next_output_byte++ = (JOCTET) (val); \
264 if (--(entropy)->free_in_buffer == 0) \
265 dump_buffer_e(entropy); }
266
267
268 LOCAL(boolean)
dump_buffer_s(working_state * state)269 dump_buffer_s (working_state * state)
270 /* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
271 {
272 struct jpeg_destination_mgr * dest = state->cinfo->dest;
273
274 if (! (*dest->empty_output_buffer) (state->cinfo))
275 return FALSE;
276 /* After a successful buffer dump, must reset buffer pointers */
277 state->next_output_byte = dest->next_output_byte;
278 state->free_in_buffer = dest->free_in_buffer;
279 return TRUE;
280 }
281
282
283 LOCAL(void)
dump_buffer_e(huff_entropy_ptr entropy)284 dump_buffer_e (huff_entropy_ptr entropy)
285 /* Empty the output buffer; we do not support suspension in this case. */
286 {
287 struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
288
289 if (! (*dest->empty_output_buffer) (entropy->cinfo))
290 ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
291 /* After a successful buffer dump, must reset buffer pointers */
292 entropy->next_output_byte = dest->next_output_byte;
293 entropy->free_in_buffer = dest->free_in_buffer;
294 }
295
296
297 /* Outputting bits to the file */
298
299 /* Only the right 24 bits of put_buffer are used; the valid bits are
300 * left-justified in this part. At most 16 bits can be passed to emit_bits
301 * in one call, and we never retain more than 7 bits in put_buffer
302 * between calls, so 24 bits are sufficient.
303 */
304
305 INLINE
LOCAL(boolean)306 LOCAL(boolean)
307 emit_bits_s (working_state * state, unsigned int code, int size)
308 /* Emit some bits; return TRUE if successful, FALSE if must suspend */
309 {
310 /* This routine is heavily used, so it's worth coding tightly. */
311 register INT32 put_buffer;
312 register int put_bits;
313
314 /* if size is 0, caller used an invalid Huffman table entry */
315 if (size == 0)
316 ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
317
318 /* mask off any extra bits in code */
319 put_buffer = ((INT32) code) & ((((INT32) 1) << size) - 1);
320
321 /* new number of bits in buffer */
322 put_bits = size + state->cur.put_bits;
323
324 put_buffer <<= 24 - put_bits; /* align incoming bits */
325
326 /* and merge with old buffer contents */
327 put_buffer |= state->cur.put_buffer;
328
329 while (put_bits >= 8) {
330 int c = (int) ((put_buffer >> 16) & 0xFF);
331
332 emit_byte_s(state, c, return FALSE);
333 if (c == 0xFF) { /* need to stuff a zero byte? */
334 emit_byte_s(state, 0, return FALSE);
335 }
336 put_buffer <<= 8;
337 put_bits -= 8;
338 }
339
340 state->cur.put_buffer = put_buffer; /* update state variables */
341 state->cur.put_bits = put_bits;
342
343 return TRUE;
344 }
345
346
347 INLINE
LOCAL(void)348 LOCAL(void)
349 emit_bits_e (huff_entropy_ptr entropy, unsigned int code, int size)
350 /* Emit some bits, unless we are in gather mode */
351 {
352 /* This routine is heavily used, so it's worth coding tightly. */
353 register INT32 put_buffer;
354 register int put_bits;
355
356 /* if size is 0, caller used an invalid Huffman table entry */
357 if (size == 0)
358 ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
359
360 if (entropy->gather_statistics)
361 return; /* do nothing if we're only getting stats */
362
363 /* mask off any extra bits in code */
364 put_buffer = ((INT32) code) & ((((INT32) 1) << size) - 1);
365
366 /* new number of bits in buffer */
367 put_bits = size + entropy->saved.put_bits;
368
369 put_buffer <<= 24 - put_bits; /* align incoming bits */
370
371 /* and merge with old buffer contents */
372 put_buffer |= entropy->saved.put_buffer;
373
374 while (put_bits >= 8) {
375 int c = (int) ((put_buffer >> 16) & 0xFF);
376
377 emit_byte_e(entropy, c);
378 if (c == 0xFF) { /* need to stuff a zero byte? */
379 emit_byte_e(entropy, 0);
380 }
381 put_buffer <<= 8;
382 put_bits -= 8;
383 }
384
385 entropy->saved.put_buffer = put_buffer; /* update variables */
386 entropy->saved.put_bits = put_bits;
387 }
388
389
390 LOCAL(boolean)
flush_bits_s(working_state * state)391 flush_bits_s (working_state * state)
392 {
393 if (! emit_bits_s(state, 0x7F, 7)) /* fill any partial byte with ones */
394 return FALSE;
395 state->cur.put_buffer = 0; /* and reset bit-buffer to empty */
396 state->cur.put_bits = 0;
397 return TRUE;
398 }
399
400
401 LOCAL(void)
flush_bits_e(huff_entropy_ptr entropy)402 flush_bits_e (huff_entropy_ptr entropy)
403 {
404 emit_bits_e(entropy, 0x7F, 7); /* fill any partial byte with ones */
405 entropy->saved.put_buffer = 0; /* and reset bit-buffer to empty */
406 entropy->saved.put_bits = 0;
407 }
408
409
410 /*
411 * Emit (or just count) a Huffman symbol.
412 */
413
414 INLINE
LOCAL(void)415 LOCAL(void)
416 emit_dc_symbol (huff_entropy_ptr entropy, int tbl_no, int symbol)
417 {
418 if (entropy->gather_statistics)
419 entropy->dc_count_ptrs[tbl_no][symbol]++;
420 else {
421 c_derived_tbl * tbl = entropy->dc_derived_tbls[tbl_no];
422 emit_bits_e(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
423 }
424 }
425
426
427 INLINE
LOCAL(void)428 LOCAL(void)
429 emit_ac_symbol (huff_entropy_ptr entropy, int tbl_no, int symbol)
430 {
431 if (entropy->gather_statistics)
432 entropy->ac_count_ptrs[tbl_no][symbol]++;
433 else {
434 c_derived_tbl * tbl = entropy->ac_derived_tbls[tbl_no];
435 emit_bits_e(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
436 }
437 }
438
439
440 /*
441 * Emit bits from a correction bit buffer.
442 */
443
444 LOCAL(void)
emit_buffered_bits(huff_entropy_ptr entropy,char * bufstart,unsigned int nbits)445 emit_buffered_bits (huff_entropy_ptr entropy, char * bufstart,
446 unsigned int nbits)
447 {
448 if (entropy->gather_statistics)
449 return; /* no real work */
450
451 while (nbits > 0) {
452 emit_bits_e(entropy, (unsigned int) (*bufstart), 1);
453 bufstart++;
454 nbits--;
455 }
456 }
457
458
459 /*
460 * Emit any pending EOBRUN symbol.
461 */
462
463 LOCAL(void)
emit_eobrun(huff_entropy_ptr entropy)464 emit_eobrun (huff_entropy_ptr entropy)
465 {
466 register int temp, nbits;
467
468 if (entropy->EOBRUN > 0) { /* if there is any pending EOBRUN */
469 temp = entropy->EOBRUN;
470 nbits = 0;
471 while ((temp >>= 1))
472 nbits++;
473 /* safety check: shouldn't happen given limited correction-bit buffer */
474 if (nbits > 14)
475 ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
476
477 emit_ac_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
478 if (nbits)
479 emit_bits_e(entropy, entropy->EOBRUN, nbits);
480
481 entropy->EOBRUN = 0;
482
483 /* Emit any buffered correction bits */
484 emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
485 entropy->BE = 0;
486 }
487 }
488
489
490 /*
491 * Emit a restart marker & resynchronize predictions.
492 */
493
494 LOCAL(boolean)
emit_restart_s(working_state * state,int restart_num)495 emit_restart_s (working_state * state, int restart_num)
496 {
497 int ci;
498
499 if (! flush_bits_s(state))
500 return FALSE;
501
502 emit_byte_s(state, 0xFF, return FALSE);
503 emit_byte_s(state, JPEG_RST0 + restart_num, return FALSE);
504
505 /* Re-initialize DC predictions to 0 */
506 for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
507 state->cur.last_dc_val[ci] = 0;
508
509 /* The restart counter is not updated until we successfully write the MCU. */
510
511 return TRUE;
512 }
513
514
515 LOCAL(void)
emit_restart_e(huff_entropy_ptr entropy,int restart_num)516 emit_restart_e (huff_entropy_ptr entropy, int restart_num)
517 {
518 int ci;
519
520 emit_eobrun(entropy);
521
522 if (! entropy->gather_statistics) {
523 flush_bits_e(entropy);
524 emit_byte_e(entropy, 0xFF);
525 emit_byte_e(entropy, JPEG_RST0 + restart_num);
526 }
527
528 if (entropy->cinfo->Ss == 0) {
529 /* Re-initialize DC predictions to 0 */
530 for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
531 entropy->saved.last_dc_val[ci] = 0;
532 } else {
533 /* Re-initialize all AC-related fields to 0 */
534 entropy->EOBRUN = 0;
535 entropy->BE = 0;
536 }
537 }
538
539
540 /*
541 * MCU encoding for DC initial scan (either spectral selection,
542 * or first pass of successive approximation).
543 */
544
545 METHODDEF(boolean)
encode_mcu_DC_first(j_compress_ptr cinfo,JBLOCKROW * MCU_data)546 encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
547 {
548 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
549 register int temp, temp2;
550 register int nbits;
551 int blkn, ci, tbl;
552 ISHIFT_TEMPS
553
554 entropy->next_output_byte = cinfo->dest->next_output_byte;
555 entropy->free_in_buffer = cinfo->dest->free_in_buffer;
556
557 /* Emit restart marker if needed */
558 if (cinfo->restart_interval)
559 if (entropy->restarts_to_go == 0)
560 emit_restart_e(entropy, entropy->next_restart_num);
561
562 /* Encode the MCU data blocks */
563 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
564 ci = cinfo->MCU_membership[blkn];
565 tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
566
567 /* Compute the DC value after the required point transform by Al.
568 * This is simply an arithmetic right shift.
569 */
570 temp = IRIGHT_SHIFT((int) (MCU_data[blkn][0][0]), cinfo->Al);
571
572 /* DC differences are figured on the point-transformed values. */
573 temp2 = temp - entropy->saved.last_dc_val[ci];
574 entropy->saved.last_dc_val[ci] = temp;
575
576 /* Encode the DC coefficient difference per section G.1.2.1 */
577 temp = temp2;
578 if (temp < 0) {
579 temp = -temp; /* temp is abs value of input */
580 /* For a negative input, want temp2 = bitwise complement of abs(input) */
581 /* This code assumes we are on a two's complement machine */
582 temp2--;
583 }
584
585 /* Find the number of bits needed for the magnitude of the coefficient */
586 nbits = 0;
587 while (temp) {
588 nbits++;
589 temp >>= 1;
590 }
591 /* Check for out-of-range coefficient values.
592 * Since we're encoding a difference, the range limit is twice as much.
593 */
594 if (nbits > MAX_COEF_BITS+1)
595 ERREXIT(cinfo, JERR_BAD_DCT_COEF);
596
597 /* Count/emit the Huffman-coded symbol for the number of bits */
598 emit_dc_symbol(entropy, tbl, nbits);
599
600 /* Emit that number of bits of the value, if positive, */
601 /* or the complement of its magnitude, if negative. */
602 if (nbits) /* emit_bits rejects calls with size 0 */
603 emit_bits_e(entropy, (unsigned int) temp2, nbits);
604 }
605
606 cinfo->dest->next_output_byte = entropy->next_output_byte;
607 cinfo->dest->free_in_buffer = entropy->free_in_buffer;
608
609 /* Update restart-interval state too */
610 if (cinfo->restart_interval) {
611 if (entropy->restarts_to_go == 0) {
612 entropy->restarts_to_go = cinfo->restart_interval;
613 entropy->next_restart_num++;
614 entropy->next_restart_num &= 7;
615 }
616 entropy->restarts_to_go--;
617 }
618
619 return TRUE;
620 }
621
622
623 /*
624 * MCU encoding for AC initial scan (either spectral selection,
625 * or first pass of successive approximation).
626 */
627
628 METHODDEF(boolean)
encode_mcu_AC_first(j_compress_ptr cinfo,JBLOCKROW * MCU_data)629 encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
630 {
631 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
632 const int * natural_order;
633 JBLOCKROW block;
634 register int temp, temp2;
635 register int nbits;
636 register int r, k;
637 int Se, Al;
638
639 entropy->next_output_byte = cinfo->dest->next_output_byte;
640 entropy->free_in_buffer = cinfo->dest->free_in_buffer;
641
642 /* Emit restart marker if needed */
643 if (cinfo->restart_interval)
644 if (entropy->restarts_to_go == 0)
645 emit_restart_e(entropy, entropy->next_restart_num);
646
647 Se = cinfo->Se;
648 Al = cinfo->Al;
649 natural_order = cinfo->natural_order;
650
651 /* Encode the MCU data block */
652 block = MCU_data[0];
653
654 /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
655
656 r = 0; /* r = run length of zeros */
657
658 for (k = cinfo->Ss; k <= Se; k++) {
659 if ((temp = (*block)[natural_order[k]]) == 0) {
660 r++;
661 continue;
662 }
663 /* We must apply the point transform by Al. For AC coefficients this
664 * is an integer division with rounding towards 0. To do this portably
665 * in C, we shift after obtaining the absolute value; so the code is
666 * interwoven with finding the abs value (temp) and output bits (temp2).
667 */
668 if (temp < 0) {
669 temp = -temp; /* temp is abs value of input */
670 temp >>= Al; /* apply the point transform */
671 /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
672 temp2 = ~temp;
673 } else {
674 temp >>= Al; /* apply the point transform */
675 temp2 = temp;
676 }
677 /* Watch out for case that nonzero coef is zero after point transform */
678 if (temp == 0) {
679 r++;
680 continue;
681 }
682
683 /* Emit any pending EOBRUN */
684 if (entropy->EOBRUN > 0)
685 emit_eobrun(entropy);
686 /* if run length > 15, must emit special run-length-16 codes (0xF0) */
687 while (r > 15) {
688 emit_ac_symbol(entropy, entropy->ac_tbl_no, 0xF0);
689 r -= 16;
690 }
691
692 /* Find the number of bits needed for the magnitude of the coefficient */
693 nbits = 1; /* there must be at least one 1 bit */
694 while ((temp >>= 1))
695 nbits++;
696 /* Check for out-of-range coefficient values */
697 if (nbits > MAX_COEF_BITS)
698 ERREXIT(cinfo, JERR_BAD_DCT_COEF);
699
700 /* Count/emit Huffman symbol for run length / number of bits */
701 emit_ac_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
702
703 /* Emit that number of bits of the value, if positive, */
704 /* or the complement of its magnitude, if negative. */
705 emit_bits_e(entropy, (unsigned int) temp2, nbits);
706
707 r = 0; /* reset zero run length */
708 }
709
710 if (r > 0) { /* If there are trailing zeroes, */
711 entropy->EOBRUN++; /* count an EOB */
712 if (entropy->EOBRUN == 0x7FFF)
713 emit_eobrun(entropy); /* force it out to avoid overflow */
714 }
715
716 cinfo->dest->next_output_byte = entropy->next_output_byte;
717 cinfo->dest->free_in_buffer = entropy->free_in_buffer;
718
719 /* Update restart-interval state too */
720 if (cinfo->restart_interval) {
721 if (entropy->restarts_to_go == 0) {
722 entropy->restarts_to_go = cinfo->restart_interval;
723 entropy->next_restart_num++;
724 entropy->next_restart_num &= 7;
725 }
726 entropy->restarts_to_go--;
727 }
728
729 return TRUE;
730 }
731
732
733 /*
734 * MCU encoding for DC successive approximation refinement scan.
735 * Note: we assume such scans can be multi-component,
736 * although the spec is not very clear on the point.
737 */
738
739 METHODDEF(boolean)
encode_mcu_DC_refine(j_compress_ptr cinfo,JBLOCKROW * MCU_data)740 encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
741 {
742 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
743 int Al, blkn;
744
745 entropy->next_output_byte = cinfo->dest->next_output_byte;
746 entropy->free_in_buffer = cinfo->dest->free_in_buffer;
747
748 /* Emit restart marker if needed */
749 if (cinfo->restart_interval)
750 if (entropy->restarts_to_go == 0)
751 emit_restart_e(entropy, entropy->next_restart_num);
752
753 Al = cinfo->Al;
754
755 /* Encode the MCU data blocks */
756 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
757 /* We simply emit the Al'th bit of the DC coefficient value. */
758 emit_bits_e(entropy, (unsigned int) (MCU_data[blkn][0][0] >> Al), 1);
759 }
760
761 cinfo->dest->next_output_byte = entropy->next_output_byte;
762 cinfo->dest->free_in_buffer = entropy->free_in_buffer;
763
764 /* Update restart-interval state too */
765 if (cinfo->restart_interval) {
766 if (entropy->restarts_to_go == 0) {
767 entropy->restarts_to_go = cinfo->restart_interval;
768 entropy->next_restart_num++;
769 entropy->next_restart_num &= 7;
770 }
771 entropy->restarts_to_go--;
772 }
773
774 return TRUE;
775 }
776
777
778 /*
779 * MCU encoding for AC successive approximation refinement scan.
780 */
781
782 METHODDEF(boolean)
encode_mcu_AC_refine(j_compress_ptr cinfo,JBLOCKROW * MCU_data)783 encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
784 {
785 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
786 const int * natural_order;
787 JBLOCKROW block;
788 register int temp;
789 register int r, k;
790 int Se, Al;
791 int EOB;
792 char *BR_buffer;
793 unsigned int BR;
794 int absvalues[DCTSIZE2];
795
796 entropy->next_output_byte = cinfo->dest->next_output_byte;
797 entropy->free_in_buffer = cinfo->dest->free_in_buffer;
798
799 /* Emit restart marker if needed */
800 if (cinfo->restart_interval)
801 if (entropy->restarts_to_go == 0)
802 emit_restart_e(entropy, entropy->next_restart_num);
803
804 Se = cinfo->Se;
805 Al = cinfo->Al;
806 natural_order = cinfo->natural_order;
807
808 /* Encode the MCU data block */
809 block = MCU_data[0];
810
811 /* It is convenient to make a pre-pass to determine the transformed
812 * coefficients' absolute values and the EOB position.
813 */
814 EOB = 0;
815 for (k = cinfo->Ss; k <= Se; k++) {
816 temp = (*block)[natural_order[k]];
817 /* We must apply the point transform by Al. For AC coefficients this
818 * is an integer division with rounding towards 0. To do this portably
819 * in C, we shift after obtaining the absolute value.
820 */
821 if (temp < 0)
822 temp = -temp; /* temp is abs value of input */
823 temp >>= Al; /* apply the point transform */
824 absvalues[k] = temp; /* save abs value for main pass */
825 if (temp == 1)
826 EOB = k; /* EOB = index of last newly-nonzero coef */
827 }
828
829 /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
830
831 r = 0; /* r = run length of zeros */
832 BR = 0; /* BR = count of buffered bits added now */
833 BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
834
835 for (k = cinfo->Ss; k <= Se; k++) {
836 if ((temp = absvalues[k]) == 0) {
837 r++;
838 continue;
839 }
840
841 /* Emit any required ZRLs, but not if they can be folded into EOB */
842 while (r > 15 && k <= EOB) {
843 /* emit any pending EOBRUN and the BE correction bits */
844 emit_eobrun(entropy);
845 /* Emit ZRL */
846 emit_ac_symbol(entropy, entropy->ac_tbl_no, 0xF0);
847 r -= 16;
848 /* Emit buffered correction bits that must be associated with ZRL */
849 emit_buffered_bits(entropy, BR_buffer, BR);
850 BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
851 BR = 0;
852 }
853
854 /* If the coef was previously nonzero, it only needs a correction bit.
855 * NOTE: a straight translation of the spec's figure G.7 would suggest
856 * that we also need to test r > 15. But if r > 15, we can only get here
857 * if k > EOB, which implies that this coefficient is not 1.
858 */
859 if (temp > 1) {
860 /* The correction bit is the next bit of the absolute value. */
861 BR_buffer[BR++] = (char) (temp & 1);
862 continue;
863 }
864
865 /* Emit any pending EOBRUN and the BE correction bits */
866 emit_eobrun(entropy);
867
868 /* Count/emit Huffman symbol for run length / number of bits */
869 emit_ac_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
870
871 /* Emit output bit for newly-nonzero coef */
872 temp = ((*block)[natural_order[k]] < 0) ? 0 : 1;
873 emit_bits_e(entropy, (unsigned int) temp, 1);
874
875 /* Emit buffered correction bits that must be associated with this code */
876 emit_buffered_bits(entropy, BR_buffer, BR);
877 BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
878 BR = 0;
879 r = 0; /* reset zero run length */
880 }
881
882 if (r > 0 || BR > 0) { /* If there are trailing zeroes, */
883 entropy->EOBRUN++; /* count an EOB */
884 entropy->BE += BR; /* concat my correction bits to older ones */
885 /* We force out the EOB if we risk either:
886 * 1. overflow of the EOB counter;
887 * 2. overflow of the correction bit buffer during the next MCU.
888 */
889 if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
890 emit_eobrun(entropy);
891 }
892
893 cinfo->dest->next_output_byte = entropy->next_output_byte;
894 cinfo->dest->free_in_buffer = entropy->free_in_buffer;
895
896 /* Update restart-interval state too */
897 if (cinfo->restart_interval) {
898 if (entropy->restarts_to_go == 0) {
899 entropy->restarts_to_go = cinfo->restart_interval;
900 entropy->next_restart_num++;
901 entropy->next_restart_num &= 7;
902 }
903 entropy->restarts_to_go--;
904 }
905
906 return TRUE;
907 }
908
909
910 /* Encode a single block's worth of coefficients */
911
912 LOCAL(boolean)
encode_one_block(working_state * state,JCOEFPTR block,int last_dc_val,c_derived_tbl * dctbl,c_derived_tbl * actbl)913 encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
914 c_derived_tbl *dctbl, c_derived_tbl *actbl)
915 {
916 register int temp, temp2;
917 register int nbits;
918 register int r, k;
919 int Se = state->cinfo->lim_Se;
920 const int * natural_order = state->cinfo->natural_order;
921
922 /* Encode the DC coefficient difference per section F.1.2.1 */
923
924 temp = temp2 = block[0] - last_dc_val;
925
926 if (temp < 0) {
927 temp = -temp; /* temp is abs value of input */
928 /* For a negative input, want temp2 = bitwise complement of abs(input) */
929 /* This code assumes we are on a two's complement machine */
930 temp2--;
931 }
932
933 /* Find the number of bits needed for the magnitude of the coefficient */
934 nbits = 0;
935 while (temp) {
936 nbits++;
937 temp >>= 1;
938 }
939 /* Check for out-of-range coefficient values.
940 * Since we're encoding a difference, the range limit is twice as much.
941 */
942 if (nbits > MAX_COEF_BITS+1)
943 ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
944
945 /* Emit the Huffman-coded symbol for the number of bits */
946 if (! emit_bits_s(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
947 return FALSE;
948
949 /* Emit that number of bits of the value, if positive, */
950 /* or the complement of its magnitude, if negative. */
951 if (nbits) /* emit_bits rejects calls with size 0 */
952 if (! emit_bits_s(state, (unsigned int) temp2, nbits))
953 return FALSE;
954
955 /* Encode the AC coefficients per section F.1.2.2 */
956
957 r = 0; /* r = run length of zeros */
958
959 for (k = 1; k <= Se; k++) {
960 if ((temp2 = block[natural_order[k]]) == 0) {
961 r++;
962 } else {
963 /* if run length > 15, must emit special run-length-16 codes (0xF0) */
964 while (r > 15) {
965 if (! emit_bits_s(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
966 return FALSE;
967 r -= 16;
968 }
969
970 temp = temp2;
971 if (temp < 0) {
972 temp = -temp; /* temp is abs value of input */
973 /* This code assumes we are on a two's complement machine */
974 temp2--;
975 }
976
977 /* Find the number of bits needed for the magnitude of the coefficient */
978 nbits = 1; /* there must be at least one 1 bit */
979 while ((temp >>= 1))
980 nbits++;
981 /* Check for out-of-range coefficient values */
982 if (nbits > MAX_COEF_BITS)
983 ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
984
985 /* Emit Huffman symbol for run length / number of bits */
986 temp = (r << 4) + nbits;
987 if (! emit_bits_s(state, actbl->ehufco[temp], actbl->ehufsi[temp]))
988 return FALSE;
989
990 /* Emit that number of bits of the value, if positive, */
991 /* or the complement of its magnitude, if negative. */
992 if (! emit_bits_s(state, (unsigned int) temp2, nbits))
993 return FALSE;
994
995 r = 0;
996 }
997 }
998
999 /* If the last coef(s) were zero, emit an end-of-block code */
1000 if (r > 0)
1001 if (! emit_bits_s(state, actbl->ehufco[0], actbl->ehufsi[0]))
1002 return FALSE;
1003
1004 return TRUE;
1005 }
1006
1007
1008 /*
1009 * Encode and output one MCU's worth of Huffman-compressed coefficients.
1010 */
1011
1012 METHODDEF(boolean)
encode_mcu_huff(j_compress_ptr cinfo,JBLOCKROW * MCU_data)1013 encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
1014 {
1015 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1016 working_state state;
1017 int blkn, ci;
1018 jpeg_component_info * compptr;
1019
1020 /* Load up working state */
1021 state.next_output_byte = cinfo->dest->next_output_byte;
1022 state.free_in_buffer = cinfo->dest->free_in_buffer;
1023 ASSIGN_STATE(state.cur, entropy->saved);
1024 state.cinfo = cinfo;
1025
1026 /* Emit restart marker if needed */
1027 if (cinfo->restart_interval) {
1028 if (entropy->restarts_to_go == 0)
1029 if (! emit_restart_s(&state, entropy->next_restart_num))
1030 return FALSE;
1031 }
1032
1033 /* Encode the MCU data blocks */
1034 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
1035 ci = cinfo->MCU_membership[blkn];
1036 compptr = cinfo->cur_comp_info[ci];
1037 if (! encode_one_block(&state,
1038 MCU_data[blkn][0], state.cur.last_dc_val[ci],
1039 entropy->dc_derived_tbls[compptr->dc_tbl_no],
1040 entropy->ac_derived_tbls[compptr->ac_tbl_no]))
1041 return FALSE;
1042 /* Update last_dc_val */
1043 state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
1044 }
1045
1046 /* Completed MCU, so update state */
1047 cinfo->dest->next_output_byte = state.next_output_byte;
1048 cinfo->dest->free_in_buffer = state.free_in_buffer;
1049 ASSIGN_STATE(entropy->saved, state.cur);
1050
1051 /* Update restart-interval state too */
1052 if (cinfo->restart_interval) {
1053 if (entropy->restarts_to_go == 0) {
1054 entropy->restarts_to_go = cinfo->restart_interval;
1055 entropy->next_restart_num++;
1056 entropy->next_restart_num &= 7;
1057 }
1058 entropy->restarts_to_go--;
1059 }
1060
1061 return TRUE;
1062 }
1063
1064
1065 /*
1066 * Finish up at the end of a Huffman-compressed scan.
1067 */
1068
1069 METHODDEF(void)
finish_pass_huff(j_compress_ptr cinfo)1070 finish_pass_huff (j_compress_ptr cinfo)
1071 {
1072 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1073 working_state state;
1074
1075 if (cinfo->progressive_mode) {
1076 entropy->next_output_byte = cinfo->dest->next_output_byte;
1077 entropy->free_in_buffer = cinfo->dest->free_in_buffer;
1078
1079 /* Flush out any buffered data */
1080 emit_eobrun(entropy);
1081 flush_bits_e(entropy);
1082
1083 cinfo->dest->next_output_byte = entropy->next_output_byte;
1084 cinfo->dest->free_in_buffer = entropy->free_in_buffer;
1085 } else {
1086 /* Load up working state ... flush_bits needs it */
1087 state.next_output_byte = cinfo->dest->next_output_byte;
1088 state.free_in_buffer = cinfo->dest->free_in_buffer;
1089 ASSIGN_STATE(state.cur, entropy->saved);
1090 state.cinfo = cinfo;
1091
1092 /* Flush out the last data */
1093 if (! flush_bits_s(&state))
1094 ERREXIT(cinfo, JERR_CANT_SUSPEND);
1095
1096 /* Update state */
1097 cinfo->dest->next_output_byte = state.next_output_byte;
1098 cinfo->dest->free_in_buffer = state.free_in_buffer;
1099 ASSIGN_STATE(entropy->saved, state.cur);
1100 }
1101 }
1102
1103
1104 /*
1105 * Huffman coding optimization.
1106 *
1107 * We first scan the supplied data and count the number of uses of each symbol
1108 * that is to be Huffman-coded. (This process MUST agree with the code above.)
1109 * Then we build a Huffman coding tree for the observed counts.
1110 * Symbols which are not needed at all for the particular image are not
1111 * assigned any code, which saves space in the DHT marker as well as in
1112 * the compressed data.
1113 */
1114
1115
1116 /* Process a single block's worth of coefficients */
1117
1118 LOCAL(void)
htest_one_block(j_compress_ptr cinfo,JCOEFPTR block,int last_dc_val,long dc_counts[],long ac_counts[])1119 htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
1120 long dc_counts[], long ac_counts[])
1121 {
1122 register int temp;
1123 register int nbits;
1124 register int r, k;
1125 int Se = cinfo->lim_Se;
1126 const int * natural_order = cinfo->natural_order;
1127
1128 /* Encode the DC coefficient difference per section F.1.2.1 */
1129
1130 temp = block[0] - last_dc_val;
1131 if (temp < 0)
1132 temp = -temp;
1133
1134 /* Find the number of bits needed for the magnitude of the coefficient */
1135 nbits = 0;
1136 while (temp) {
1137 nbits++;
1138 temp >>= 1;
1139 }
1140 /* Check for out-of-range coefficient values.
1141 * Since we're encoding a difference, the range limit is twice as much.
1142 */
1143 if (nbits > MAX_COEF_BITS+1)
1144 ERREXIT(cinfo, JERR_BAD_DCT_COEF);
1145
1146 /* Count the Huffman symbol for the number of bits */
1147 dc_counts[nbits]++;
1148
1149 /* Encode the AC coefficients per section F.1.2.2 */
1150
1151 r = 0; /* r = run length of zeros */
1152
1153 for (k = 1; k <= Se; k++) {
1154 if ((temp = block[natural_order[k]]) == 0) {
1155 r++;
1156 } else {
1157 /* if run length > 15, must emit special run-length-16 codes (0xF0) */
1158 while (r > 15) {
1159 ac_counts[0xF0]++;
1160 r -= 16;
1161 }
1162
1163 /* Find the number of bits needed for the magnitude of the coefficient */
1164 if (temp < 0)
1165 temp = -temp;
1166
1167 /* Find the number of bits needed for the magnitude of the coefficient */
1168 nbits = 1; /* there must be at least one 1 bit */
1169 while ((temp >>= 1))
1170 nbits++;
1171 /* Check for out-of-range coefficient values */
1172 if (nbits > MAX_COEF_BITS)
1173 ERREXIT(cinfo, JERR_BAD_DCT_COEF);
1174
1175 /* Count Huffman symbol for run length / number of bits */
1176 ac_counts[(r << 4) + nbits]++;
1177
1178 r = 0;
1179 }
1180 }
1181
1182 /* If the last coef(s) were zero, emit an end-of-block code */
1183 if (r > 0)
1184 ac_counts[0]++;
1185 }
1186
1187
1188 /*
1189 * Trial-encode one MCU's worth of Huffman-compressed coefficients.
1190 * No data is actually output, so no suspension return is possible.
1191 */
1192
1193 METHODDEF(boolean)
encode_mcu_gather(j_compress_ptr cinfo,JBLOCKROW * MCU_data)1194 encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
1195 {
1196 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1197 int blkn, ci;
1198 jpeg_component_info * compptr;
1199
1200 /* Take care of restart intervals if needed */
1201 if (cinfo->restart_interval) {
1202 if (entropy->restarts_to_go == 0) {
1203 /* Re-initialize DC predictions to 0 */
1204 for (ci = 0; ci < cinfo->comps_in_scan; ci++)
1205 entropy->saved.last_dc_val[ci] = 0;
1206 /* Update restart state */
1207 entropy->restarts_to_go = cinfo->restart_interval;
1208 }
1209 entropy->restarts_to_go--;
1210 }
1211
1212 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
1213 ci = cinfo->MCU_membership[blkn];
1214 compptr = cinfo->cur_comp_info[ci];
1215 htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
1216 entropy->dc_count_ptrs[compptr->dc_tbl_no],
1217 entropy->ac_count_ptrs[compptr->ac_tbl_no]);
1218 entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
1219 }
1220
1221 return TRUE;
1222 }
1223
1224
1225 /*
1226 * Generate the best Huffman code table for the given counts, fill htbl.
1227 *
1228 * The JPEG standard requires that no symbol be assigned a codeword of all
1229 * one bits (so that padding bits added at the end of a compressed segment
1230 * can't look like a valid code). Because of the canonical ordering of
1231 * codewords, this just means that there must be an unused slot in the
1232 * longest codeword length category. Section K.2 of the JPEG spec suggests
1233 * reserving such a slot by pretending that symbol 256 is a valid symbol
1234 * with count 1. In theory that's not optimal; giving it count zero but
1235 * including it in the symbol set anyway should give a better Huffman code.
1236 * But the theoretically better code actually seems to come out worse in
1237 * practice, because it produces more all-ones bytes (which incur stuffed
1238 * zero bytes in the final file). In any case the difference is tiny.
1239 *
1240 * The JPEG standard requires Huffman codes to be no more than 16 bits long.
1241 * If some symbols have a very small but nonzero probability, the Huffman tree
1242 * must be adjusted to meet the code length restriction. We currently use
1243 * the adjustment method suggested in JPEG section K.2. This method is *not*
1244 * optimal; it may not choose the best possible limited-length code. But
1245 * typically only very-low-frequency symbols will be given less-than-optimal
1246 * lengths, so the code is almost optimal. Experimental comparisons against
1247 * an optimal limited-length-code algorithm indicate that the difference is
1248 * microscopic --- usually less than a hundredth of a percent of total size.
1249 * So the extra complexity of an optimal algorithm doesn't seem worthwhile.
1250 */
1251
1252 LOCAL(void)
jpeg_gen_optimal_table(j_compress_ptr cinfo,JHUFF_TBL * htbl,long freq[])1253 jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
1254 {
1255 #define MAX_CLEN 32 /* assumed maximum initial code length */
1256 UINT8 bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */
1257 int codesize[257]; /* codesize[k] = code length of symbol k */
1258 int others[257]; /* next symbol in current branch of tree */
1259 int c1, c2;
1260 int p, i, j;
1261 long v;
1262
1263 /* This algorithm is explained in section K.2 of the JPEG standard */
1264
1265 MEMZERO(bits, SIZEOF(bits));
1266 MEMZERO(codesize, SIZEOF(codesize));
1267 for (i = 0; i < 257; i++)
1268 others[i] = -1; /* init links to empty */
1269
1270 freq[256] = 1; /* make sure 256 has a nonzero count */
1271 /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
1272 * that no real symbol is given code-value of all ones, because 256
1273 * will be placed last in the largest codeword category.
1274 */
1275
1276 /* Huffman's basic algorithm to assign optimal code lengths to symbols */
1277
1278 for (;;) {
1279 /* Find the smallest nonzero frequency, set c1 = its symbol */
1280 /* In case of ties, take the larger symbol number */
1281 c1 = -1;
1282 v = 1000000000L;
1283 for (i = 0; i <= 256; i++) {
1284 if (freq[i] && freq[i] <= v) {
1285 v = freq[i];
1286 c1 = i;
1287 }
1288 }
1289
1290 /* Find the next smallest nonzero frequency, set c2 = its symbol */
1291 /* In case of ties, take the larger symbol number */
1292 c2 = -1;
1293 v = 1000000000L;
1294 for (i = 0; i <= 256; i++) {
1295 if (freq[i] && freq[i] <= v && i != c1) {
1296 v = freq[i];
1297 c2 = i;
1298 }
1299 }
1300
1301 /* Done if we've merged everything into one frequency */
1302 if (c2 < 0)
1303 break;
1304
1305 /* Else merge the two counts/trees */
1306 freq[c1] += freq[c2];
1307 freq[c2] = 0;
1308
1309 /* Increment the codesize of everything in c1's tree branch */
1310 codesize[c1]++;
1311 while (others[c1] >= 0) {
1312 c1 = others[c1];
1313 codesize[c1]++;
1314 }
1315
1316 others[c1] = c2; /* chain c2 onto c1's tree branch */
1317
1318 /* Increment the codesize of everything in c2's tree branch */
1319 codesize[c2]++;
1320 while (others[c2] >= 0) {
1321 c2 = others[c2];
1322 codesize[c2]++;
1323 }
1324 }
1325
1326 /* Now count the number of symbols of each code length */
1327 for (i = 0; i <= 256; i++) {
1328 if (codesize[i]) {
1329 /* The JPEG standard seems to think that this can't happen, */
1330 /* but I'm paranoid... */
1331 if (codesize[i] > MAX_CLEN)
1332 ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
1333
1334 bits[codesize[i]]++;
1335 }
1336 }
1337
1338 /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
1339 * Huffman procedure assigned any such lengths, we must adjust the coding.
1340 * Here is what the JPEG spec says about how this next bit works:
1341 * Since symbols are paired for the longest Huffman code, the symbols are
1342 * removed from this length category two at a time. The prefix for the pair
1343 * (which is one bit shorter) is allocated to one of the pair; then,
1344 * skipping the BITS entry for that prefix length, a code word from the next
1345 * shortest nonzero BITS entry is converted into a prefix for two code words
1346 * one bit longer.
1347 */
1348
1349 for (i = MAX_CLEN; i > 16; i--) {
1350 while (bits[i] > 0) {
1351 j = i - 2; /* find length of new prefix to be used */
1352 while (bits[j] == 0)
1353 j--;
1354
1355 bits[i] -= 2; /* remove two symbols */
1356 bits[i-1]++; /* one goes in this length */
1357 bits[j+1] += 2; /* two new symbols in this length */
1358 bits[j]--; /* symbol of this length is now a prefix */
1359 }
1360 }
1361
1362 /* Remove the count for the pseudo-symbol 256 from the largest codelength */
1363 while (bits[i] == 0) /* find largest codelength still in use */
1364 i--;
1365 bits[i]--;
1366
1367 /* Return final symbol counts (only for lengths 0..16) */
1368 MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
1369
1370 /* Return a list of the symbols sorted by code length */
1371 /* It's not real clear to me why we don't need to consider the codelength
1372 * changes made above, but the JPEG spec seems to think this works.
1373 */
1374 p = 0;
1375 for (i = 1; i <= MAX_CLEN; i++) {
1376 for (j = 0; j <= 255; j++) {
1377 if (codesize[j] == i) {
1378 htbl->huffval[p] = (UINT8) j;
1379 p++;
1380 }
1381 }
1382 }
1383
1384 /* Set sent_table FALSE so updated table will be written to JPEG file. */
1385 htbl->sent_table = FALSE;
1386 }
1387
1388
1389 /*
1390 * Finish up a statistics-gathering pass and create the new Huffman tables.
1391 */
1392
1393 METHODDEF(void)
finish_pass_gather(j_compress_ptr cinfo)1394 finish_pass_gather (j_compress_ptr cinfo)
1395 {
1396 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1397 int ci, tbl;
1398 jpeg_component_info * compptr;
1399 JHUFF_TBL **htblptr;
1400 boolean did_dc[NUM_HUFF_TBLS];
1401 boolean did_ac[NUM_HUFF_TBLS];
1402
1403 /* It's important not to apply jpeg_gen_optimal_table more than once
1404 * per table, because it clobbers the input frequency counts!
1405 */
1406 if (cinfo->progressive_mode)
1407 /* Flush out buffered data (all we care about is counting the EOB symbol) */
1408 emit_eobrun(entropy);
1409
1410 MEMZERO(did_dc, SIZEOF(did_dc));
1411 MEMZERO(did_ac, SIZEOF(did_ac));
1412
1413 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1414 compptr = cinfo->cur_comp_info[ci];
1415 /* DC needs no table for refinement scan */
1416 if (cinfo->Ss == 0 && cinfo->Ah == 0) {
1417 tbl = compptr->dc_tbl_no;
1418 if (! did_dc[tbl]) {
1419 htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
1420 if (*htblptr == NULL)
1421 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
1422 jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[tbl]);
1423 did_dc[tbl] = TRUE;
1424 }
1425 }
1426 /* AC needs no table when not present */
1427 if (cinfo->Se) {
1428 tbl = compptr->ac_tbl_no;
1429 if (! did_ac[tbl]) {
1430 htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
1431 if (*htblptr == NULL)
1432 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
1433 jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[tbl]);
1434 did_ac[tbl] = TRUE;
1435 }
1436 }
1437 }
1438 }
1439
1440
1441 /*
1442 * Initialize for a Huffman-compressed scan.
1443 * If gather_statistics is TRUE, we do not output anything during the scan,
1444 * just count the Huffman symbols used and generate Huffman code tables.
1445 */
1446
1447 METHODDEF(void)
start_pass_huff(j_compress_ptr cinfo,boolean gather_statistics)1448 start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
1449 {
1450 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1451 int ci, tbl;
1452 jpeg_component_info * compptr;
1453
1454 if (gather_statistics)
1455 entropy->pub.finish_pass = finish_pass_gather;
1456 else
1457 entropy->pub.finish_pass = finish_pass_huff;
1458
1459 if (cinfo->progressive_mode) {
1460 entropy->cinfo = cinfo;
1461 entropy->gather_statistics = gather_statistics;
1462
1463 /* We assume jcmaster.c already validated the scan parameters. */
1464
1465 /* Select execution routine */
1466 if (cinfo->Ah == 0) {
1467 if (cinfo->Ss == 0)
1468 entropy->pub.encode_mcu = encode_mcu_DC_first;
1469 else
1470 entropy->pub.encode_mcu = encode_mcu_AC_first;
1471 } else {
1472 if (cinfo->Ss == 0)
1473 entropy->pub.encode_mcu = encode_mcu_DC_refine;
1474 else {
1475 entropy->pub.encode_mcu = encode_mcu_AC_refine;
1476 /* AC refinement needs a correction bit buffer */
1477 if (entropy->bit_buffer == NULL)
1478 entropy->bit_buffer = (char *)
1479 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1480 MAX_CORR_BITS * SIZEOF(char));
1481 }
1482 }
1483
1484 /* Initialize AC stuff */
1485 entropy->ac_tbl_no = cinfo->cur_comp_info[0]->ac_tbl_no;
1486 entropy->EOBRUN = 0;
1487 entropy->BE = 0;
1488 } else {
1489 if (gather_statistics)
1490 entropy->pub.encode_mcu = encode_mcu_gather;
1491 else
1492 entropy->pub.encode_mcu = encode_mcu_huff;
1493 }
1494
1495 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1496 compptr = cinfo->cur_comp_info[ci];
1497 /* DC needs no table for refinement scan */
1498 if (cinfo->Ss == 0 && cinfo->Ah == 0) {
1499 tbl = compptr->dc_tbl_no;
1500 if (gather_statistics) {
1501 /* Check for invalid table index */
1502 /* (make_c_derived_tbl does this in the other path) */
1503 if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
1504 ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
1505 /* Allocate and zero the statistics tables */
1506 /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
1507 if (entropy->dc_count_ptrs[tbl] == NULL)
1508 entropy->dc_count_ptrs[tbl] = (long *)
1509 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1510 257 * SIZEOF(long));
1511 MEMZERO(entropy->dc_count_ptrs[tbl], 257 * SIZEOF(long));
1512 } else {
1513 /* Compute derived values for Huffman tables */
1514 /* We may do this more than once for a table, but it's not expensive */
1515 jpeg_make_c_derived_tbl(cinfo, TRUE, tbl,
1516 & entropy->dc_derived_tbls[tbl]);
1517 }
1518 /* Initialize DC predictions to 0 */
1519 entropy->saved.last_dc_val[ci] = 0;
1520 }
1521 /* AC needs no table when not present */
1522 if (cinfo->Se) {
1523 tbl = compptr->ac_tbl_no;
1524 if (gather_statistics) {
1525 if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
1526 ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
1527 if (entropy->ac_count_ptrs[tbl] == NULL)
1528 entropy->ac_count_ptrs[tbl] = (long *)
1529 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1530 257 * SIZEOF(long));
1531 MEMZERO(entropy->ac_count_ptrs[tbl], 257 * SIZEOF(long));
1532 } else {
1533 jpeg_make_c_derived_tbl(cinfo, FALSE, tbl,
1534 & entropy->ac_derived_tbls[tbl]);
1535 }
1536 }
1537 }
1538
1539 /* Initialize bit buffer to empty */
1540 entropy->saved.put_buffer = 0;
1541 entropy->saved.put_bits = 0;
1542
1543 /* Initialize restart stuff */
1544 entropy->restarts_to_go = cinfo->restart_interval;
1545 entropy->next_restart_num = 0;
1546 }
1547
1548
1549 /*
1550 * Module initialization routine for Huffman entropy encoding.
1551 */
1552
1553 GLOBAL(void)
jinit_huff_encoder(j_compress_ptr cinfo)1554 jinit_huff_encoder (j_compress_ptr cinfo)
1555 {
1556 huff_entropy_ptr entropy;
1557 int i;
1558
1559 entropy = (huff_entropy_ptr)
1560 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1561 SIZEOF(huff_entropy_encoder));
1562 cinfo->entropy = &entropy->pub;
1563 entropy->pub.start_pass = start_pass_huff;
1564
1565 /* Mark tables unallocated */
1566 for (i = 0; i < NUM_HUFF_TBLS; i++) {
1567 entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
1568 entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
1569 }
1570
1571 if (cinfo->progressive_mode)
1572 entropy->bit_buffer = NULL; /* needed only in AC refinement scan */
1573 }
1574