PageRenderTime 98ms CodeModel.GetById 13ms app.highlight 77ms RepoModel.GetById 2ms app.codeStats 0ms

/src/FreeImage/Source/LibJPEG/jcarith.c

https://bitbucket.org/cabalistic/ogredeps/
C | 937 lines | 614 code | 104 blank | 219 comment | 181 complexity | 17885405a5bc109794dd92c11bd85c78 MD5 | raw file
  1/*
  2 * jcarith.c
  3 *
  4 * Developed 1997-2011 by Guido Vollbeding.
  5 * This file is part of the Independent JPEG Group's software.
  6 * For conditions of distribution and use, see the accompanying README file.
  7 *
  8 * This file contains portable arithmetic entropy encoding routines for JPEG
  9 * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81).
 10 *
 11 * Both sequential and progressive modes are supported in this single module.
 12 *
 13 * Suspension is not currently supported in this module.
 14 */
 15
 16#define JPEG_INTERNALS
 17#include "jinclude.h"
 18#include "jpeglib.h"
 19
 20
 21/* Expanded entropy encoder object for arithmetic encoding. */
 22
 23typedef struct {
 24  struct jpeg_entropy_encoder pub; /* public fields */
 25
 26  INT32 c; /* C register, base of coding interval, layout as in sec. D.1.3 */
 27  INT32 a;               /* A register, normalized size of coding interval */
 28  INT32 sc;        /* counter for stacked 0xFF values which might overflow */
 29  INT32 zc;          /* counter for pending 0x00 output values which might *
 30                          * be discarded at the end ("Pacman" termination) */
 31  int ct;  /* bit shift counter, determines when next byte will be written */
 32  int buffer;                /* buffer for most recent output byte != 0xFF */
 33
 34  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
 35  int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
 36
 37  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
 38  int next_restart_num;		/* next restart number to write (0-7) */
 39
 40  /* Pointers to statistics areas (these workspaces have image lifespan) */
 41  unsigned char * dc_stats[NUM_ARITH_TBLS];
 42  unsigned char * ac_stats[NUM_ARITH_TBLS];
 43
 44  /* Statistics bin for coding with fixed probability 0.5 */
 45  unsigned char fixed_bin[4];
 46} arith_entropy_encoder;
 47
 48typedef arith_entropy_encoder * arith_entropy_ptr;
 49
 50/* The following two definitions specify the allocation chunk size
 51 * for the statistics area.
 52 * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
 53 * 49 statistics bins for DC, and 245 statistics bins for AC coding.
 54 *
 55 * We use a compact representation with 1 byte per statistics bin,
 56 * thus the numbers directly represent byte sizes.
 57 * This 1 byte per statistics bin contains the meaning of the MPS
 58 * (more probable symbol) in the highest bit (mask 0x80), and the
 59 * index into the probability estimation state machine table
 60 * in the lower bits (mask 0x7F).
 61 */
 62
 63#define DC_STAT_BINS 64
 64#define AC_STAT_BINS 256
 65
 66/* NOTE: Uncomment the following #define if you want to use the
 67 * given formula for calculating the AC conditioning parameter Kx
 68 * for spectral selection progressive coding in section G.1.3.2
 69 * of the spec (Kx = Kmin + SRL (8 + Se - Kmin) 4).
 70 * Although the spec and P&M authors claim that this "has proven
 71 * to give good results for 8 bit precision samples", I'm not
 72 * convinced yet that this is really beneficial.
 73 * Early tests gave only very marginal compression enhancements
 74 * (a few - around 5 or so - bytes even for very large files),
 75 * which would turn out rather negative if we'd suppress the
 76 * DAC (Define Arithmetic Conditioning) marker segments for
 77 * the default parameters in the future.
 78 * Note that currently the marker writing module emits 12-byte
 79 * DAC segments for a full-component scan in a color image.
 80 * This is not worth worrying about IMHO. However, since the
 81 * spec defines the default values to be used if the tables
 82 * are omitted (unlike Huffman tables, which are required
 83 * anyway), one might optimize this behaviour in the future,
 84 * and then it would be disadvantageous to use custom tables if
 85 * they don't provide sufficient gain to exceed the DAC size.
 86 *
 87 * On the other hand, I'd consider it as a reasonable result
 88 * that the conditioning has no significant influence on the
 89 * compression performance. This means that the basic
 90 * statistical model is already rather stable.
 91 *
 92 * Thus, at the moment, we use the default conditioning values
 93 * anyway, and do not use the custom formula.
 94 *
 95#define CALCULATE_SPECTRAL_CONDITIONING
 96 */
 97
 98/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
 99 * We assume that int right shift is unsigned if INT32 right shift is,
100 * which should be safe.
101 */
102
103#ifdef RIGHT_SHIFT_IS_UNSIGNED
104#define ISHIFT_TEMPS	int ishift_temp;
105#define IRIGHT_SHIFT(x,shft)  \
106	((ishift_temp = (x)) < 0 ? \
107	 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
108	 (ishift_temp >> (shft)))
109#else
110#define ISHIFT_TEMPS
111#define IRIGHT_SHIFT(x,shft)	((x) >> (shft))
112#endif
113
114
115LOCAL(void)
116emit_byte (int val, j_compress_ptr cinfo)
117/* Write next output byte; we do not support suspension in this module. */
118{
119  struct jpeg_destination_mgr * dest = cinfo->dest;
120
121  *dest->next_output_byte++ = (JOCTET) val;
122  if (--dest->free_in_buffer == 0)
123    if (! (*dest->empty_output_buffer) (cinfo))
124      ERREXIT(cinfo, JERR_CANT_SUSPEND);
125}
126
127
128/*
129 * Finish up at the end of an arithmetic-compressed scan.
130 */
131
132METHODDEF(void)
133finish_pass (j_compress_ptr cinfo)
134{
135  arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
136  INT32 temp;
137
138  /* Section D.1.8: Termination of encoding */
139
140  /* Find the e->c in the coding interval with the largest
141   * number of trailing zero bits */
142  if ((temp = (e->a - 1 + e->c) & 0xFFFF0000L) < e->c)
143    e->c = temp + 0x8000L;
144  else
145    e->c = temp;
146  /* Send remaining bytes to output */
147  e->c <<= e->ct;
148  if (e->c & 0xF8000000L) {
149    /* One final overflow has to be handled */
150    if (e->buffer >= 0) {
151      if (e->zc)
152	do emit_byte(0x00, cinfo);
153	while (--e->zc);
154      emit_byte(e->buffer + 1, cinfo);
155      if (e->buffer + 1 == 0xFF)
156	emit_byte(0x00, cinfo);
157    }
158    e->zc += e->sc;  /* carry-over converts stacked 0xFF bytes to 0x00 */
159    e->sc = 0;
160  } else {
161    if (e->buffer == 0)
162      ++e->zc;
163    else if (e->buffer >= 0) {
164      if (e->zc)
165	do emit_byte(0x00, cinfo);
166	while (--e->zc);
167      emit_byte(e->buffer, cinfo);
168    }
169    if (e->sc) {
170      if (e->zc)
171	do emit_byte(0x00, cinfo);
172	while (--e->zc);
173      do {
174	emit_byte(0xFF, cinfo);
175	emit_byte(0x00, cinfo);
176      } while (--e->sc);
177    }
178  }
179  /* Output final bytes only if they are not 0x00 */
180  if (e->c & 0x7FFF800L) {
181    if (e->zc)  /* output final pending zero bytes */
182      do emit_byte(0x00, cinfo);
183      while (--e->zc);
184    emit_byte((e->c >> 19) & 0xFF, cinfo);
185    if (((e->c >> 19) & 0xFF) == 0xFF)
186      emit_byte(0x00, cinfo);
187    if (e->c & 0x7F800L) {
188      emit_byte((e->c >> 11) & 0xFF, cinfo);
189      if (((e->c >> 11) & 0xFF) == 0xFF)
190	emit_byte(0x00, cinfo);
191    }
192  }
193}
194
195
196/*
197 * The core arithmetic encoding routine (common in JPEG and JBIG).
198 * This needs to go as fast as possible.
199 * Machine-dependent optimization facilities
200 * are not utilized in this portable implementation.
201 * However, this code should be fairly efficient and
202 * may be a good base for further optimizations anyway.
203 *
204 * Parameter 'val' to be encoded may be 0 or 1 (binary decision).
205 *
206 * Note: I've added full "Pacman" termination support to the
207 * byte output routines, which is equivalent to the optional
208 * Discard_final_zeros procedure (Figure D.15) in the spec.
209 * Thus, we always produce the shortest possible output
210 * stream compliant to the spec (no trailing zero bytes,
211 * except for FF stuffing).
212 *
213 * I've also introduced a new scheme for accessing
214 * the probability estimation state machine table,
215 * derived from Markus Kuhn's JBIG implementation.
216 */
217
218LOCAL(void)
219arith_encode (j_compress_ptr cinfo, unsigned char *st, int val) 
220{
221  register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
222  register unsigned char nl, nm;
223  register INT32 qe, temp;
224  register int sv;
225
226  /* Fetch values from our compact representation of Table D.3(D.2):
227   * Qe values and probability estimation state machine
228   */
229  sv = *st;
230  qe = jpeg_aritab[sv & 0x7F];	/* => Qe_Value */
231  nl = qe & 0xFF; qe >>= 8;	/* Next_Index_LPS + Switch_MPS */
232  nm = qe & 0xFF; qe >>= 8;	/* Next_Index_MPS */
233
234  /* Encode & estimation procedures per sections D.1.4 & D.1.5 */
235  e->a -= qe;
236  if (val != (sv >> 7)) {
237    /* Encode the less probable symbol */
238    if (e->a >= qe) {
239      /* If the interval size (qe) for the less probable symbol (LPS)
240       * is larger than the interval size for the MPS, then exchange
241       * the two symbols for coding efficiency, otherwise code the LPS
242       * as usual: */
243      e->c += e->a;
244      e->a = qe;
245    }
246    *st = (sv & 0x80) ^ nl;	/* Estimate_after_LPS */
247  } else {
248    /* Encode the more probable symbol */
249    if (e->a >= 0x8000L)
250      return;  /* A >= 0x8000 -> ready, no renormalization required */
251    if (e->a < qe) {
252      /* If the interval size (qe) for the less probable symbol (LPS)
253       * is larger than the interval size for the MPS, then exchange
254       * the two symbols for coding efficiency: */
255      e->c += e->a;
256      e->a = qe;
257    }
258    *st = (sv & 0x80) ^ nm;	/* Estimate_after_MPS */
259  }
260
261  /* Renormalization & data output per section D.1.6 */
262  do {
263    e->a <<= 1;
264    e->c <<= 1;
265    if (--e->ct == 0) {
266      /* Another byte is ready for output */
267      temp = e->c >> 19;
268      if (temp > 0xFF) {
269	/* Handle overflow over all stacked 0xFF bytes */
270	if (e->buffer >= 0) {
271	  if (e->zc)
272	    do emit_byte(0x00, cinfo);
273	    while (--e->zc);
274	  emit_byte(e->buffer + 1, cinfo);
275	  if (e->buffer + 1 == 0xFF)
276	    emit_byte(0x00, cinfo);
277	}
278	e->zc += e->sc;  /* carry-over converts stacked 0xFF bytes to 0x00 */
279	e->sc = 0;
280	/* Note: The 3 spacer bits in the C register guarantee
281	 * that the new buffer byte can't be 0xFF here
282	 * (see page 160 in the P&M JPEG book). */
283	e->buffer = temp & 0xFF;  /* new output byte, might overflow later */
284      } else if (temp == 0xFF) {
285	++e->sc;  /* stack 0xFF byte (which might overflow later) */
286      } else {
287	/* Output all stacked 0xFF bytes, they will not overflow any more */
288	if (e->buffer == 0)
289	  ++e->zc;
290	else if (e->buffer >= 0) {
291	  if (e->zc)
292	    do emit_byte(0x00, cinfo);
293	    while (--e->zc);
294	  emit_byte(e->buffer, cinfo);
295	}
296	if (e->sc) {
297	  if (e->zc)
298	    do emit_byte(0x00, cinfo);
299	    while (--e->zc);
300	  do {
301	    emit_byte(0xFF, cinfo);
302	    emit_byte(0x00, cinfo);
303	  } while (--e->sc);
304	}
305	e->buffer = temp & 0xFF;  /* new output byte (can still overflow) */
306      }
307      e->c &= 0x7FFFFL;
308      e->ct += 8;
309    }
310  } while (e->a < 0x8000L);
311}
312
313
314/*
315 * Emit a restart marker & resynchronize predictions.
316 */
317
318LOCAL(void)
319emit_restart (j_compress_ptr cinfo, int restart_num)
320{
321  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
322  int ci;
323  jpeg_component_info * compptr;
324
325  finish_pass(cinfo);
326
327  emit_byte(0xFF, cinfo);
328  emit_byte(JPEG_RST0 + restart_num, cinfo);
329
330  /* Re-initialize statistics areas */
331  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
332    compptr = cinfo->cur_comp_info[ci];
333    /* DC needs no table for refinement scan */
334    if (cinfo->Ss == 0 && cinfo->Ah == 0) {
335      MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS);
336      /* Reset DC predictions to 0 */
337      entropy->last_dc_val[ci] = 0;
338      entropy->dc_context[ci] = 0;
339    }
340    /* AC needs no table when not present */
341    if (cinfo->Se) {
342      MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS);
343    }
344  }
345
346  /* Reset arithmetic encoding variables */
347  entropy->c = 0;
348  entropy->a = 0x10000L;
349  entropy->sc = 0;
350  entropy->zc = 0;
351  entropy->ct = 11;
352  entropy->buffer = -1;  /* empty */
353}
354
355
356/*
357 * MCU encoding for DC initial scan (either spectral selection,
358 * or first pass of successive approximation).
359 */
360
361METHODDEF(boolean)
362encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
363{
364  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
365  JBLOCKROW block;
366  unsigned char *st;
367  int blkn, ci, tbl;
368  int v, v2, m;
369  ISHIFT_TEMPS
370
371  /* Emit restart marker if needed */
372  if (cinfo->restart_interval) {
373    if (entropy->restarts_to_go == 0) {
374      emit_restart(cinfo, entropy->next_restart_num);
375      entropy->restarts_to_go = cinfo->restart_interval;
376      entropy->next_restart_num++;
377      entropy->next_restart_num &= 7;
378    }
379    entropy->restarts_to_go--;
380  }
381
382  /* Encode the MCU data blocks */
383  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
384    block = MCU_data[blkn];
385    ci = cinfo->MCU_membership[blkn];
386    tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
387
388    /* Compute the DC value after the required point transform by Al.
389     * This is simply an arithmetic right shift.
390     */
391    m = IRIGHT_SHIFT((int) ((*block)[0]), cinfo->Al);
392
393    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
394
395    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
396    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
397
398    /* Figure F.4: Encode_DC_DIFF */
399    if ((v = m - entropy->last_dc_val[ci]) == 0) {
400      arith_encode(cinfo, st, 0);
401      entropy->dc_context[ci] = 0;	/* zero diff category */
402    } else {
403      entropy->last_dc_val[ci] = m;
404      arith_encode(cinfo, st, 1);
405      /* Figure F.6: Encoding nonzero value v */
406      /* Figure F.7: Encoding the sign of v */
407      if (v > 0) {
408	arith_encode(cinfo, st + 1, 0);	/* Table F.4: SS = S0 + 1 */
409	st += 2;			/* Table F.4: SP = S0 + 2 */
410	entropy->dc_context[ci] = 4;	/* small positive diff category */
411      } else {
412	v = -v;
413	arith_encode(cinfo, st + 1, 1);	/* Table F.4: SS = S0 + 1 */
414	st += 3;			/* Table F.4: SN = S0 + 3 */
415	entropy->dc_context[ci] = 8;	/* small negative diff category */
416      }
417      /* Figure F.8: Encoding the magnitude category of v */
418      m = 0;
419      if (v -= 1) {
420	arith_encode(cinfo, st, 1);
421	m = 1;
422	v2 = v;
423	st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
424	while (v2 >>= 1) {
425	  arith_encode(cinfo, st, 1);
426	  m <<= 1;
427	  st += 1;
428	}
429      }
430      arith_encode(cinfo, st, 0);
431      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
432      if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
433	entropy->dc_context[ci] = 0;	/* zero diff category */
434      else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
435	entropy->dc_context[ci] += 8;	/* large diff category */
436      /* Figure F.9: Encoding the magnitude bit pattern of v */
437      st += 14;
438      while (m >>= 1)
439	arith_encode(cinfo, st, (m & v) ? 1 : 0);
440    }
441  }
442
443  return TRUE;
444}
445
446
447/*
448 * MCU encoding for AC initial scan (either spectral selection,
449 * or first pass of successive approximation).
450 */
451
452METHODDEF(boolean)
453encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
454{
455  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
456  JBLOCKROW block;
457  unsigned char *st;
458  int tbl, k, ke;
459  int v, v2, m;
460  const int * natural_order;
461
462  /* Emit restart marker if needed */
463  if (cinfo->restart_interval) {
464    if (entropy->restarts_to_go == 0) {
465      emit_restart(cinfo, entropy->next_restart_num);
466      entropy->restarts_to_go = cinfo->restart_interval;
467      entropy->next_restart_num++;
468      entropy->next_restart_num &= 7;
469    }
470    entropy->restarts_to_go--;
471  }
472
473  natural_order = cinfo->natural_order;
474
475  /* Encode the MCU data block */
476  block = MCU_data[0];
477  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
478
479  /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
480
481  /* Establish EOB (end-of-block) index */
482  for (ke = cinfo->Se; ke > 0; ke--)
483    /* We must apply the point transform by Al.  For AC coefficients this
484     * is an integer division with rounding towards 0.  To do this portably
485     * in C, we shift after obtaining the absolute value.
486     */
487    if ((v = (*block)[natural_order[ke]]) >= 0) {
488      if (v >>= cinfo->Al) break;
489    } else {
490      v = -v;
491      if (v >>= cinfo->Al) break;
492    }
493
494  /* Figure F.5: Encode_AC_Coefficients */
495  for (k = cinfo->Ss; k <= ke; k++) {
496    st = entropy->ac_stats[tbl] + 3 * (k - 1);
497    arith_encode(cinfo, st, 0);		/* EOB decision */
498    for (;;) {
499      if ((v = (*block)[natural_order[k]]) >= 0) {
500	if (v >>= cinfo->Al) {
501	  arith_encode(cinfo, st + 1, 1);
502	  arith_encode(cinfo, entropy->fixed_bin, 0);
503	  break;
504	}
505      } else {
506	v = -v;
507	if (v >>= cinfo->Al) {
508	  arith_encode(cinfo, st + 1, 1);
509	  arith_encode(cinfo, entropy->fixed_bin, 1);
510	  break;
511	}
512      }
513      arith_encode(cinfo, st + 1, 0); st += 3; k++;
514    }
515    st += 2;
516    /* Figure F.8: Encoding the magnitude category of v */
517    m = 0;
518    if (v -= 1) {
519      arith_encode(cinfo, st, 1);
520      m = 1;
521      v2 = v;
522      if (v2 >>= 1) {
523	arith_encode(cinfo, st, 1);
524	m <<= 1;
525	st = entropy->ac_stats[tbl] +
526	     (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
527	while (v2 >>= 1) {
528	  arith_encode(cinfo, st, 1);
529	  m <<= 1;
530	  st += 1;
531	}
532      }
533    }
534    arith_encode(cinfo, st, 0);
535    /* Figure F.9: Encoding the magnitude bit pattern of v */
536    st += 14;
537    while (m >>= 1)
538      arith_encode(cinfo, st, (m & v) ? 1 : 0);
539  }
540  /* Encode EOB decision only if k <= cinfo->Se */
541  if (k <= cinfo->Se) {
542    st = entropy->ac_stats[tbl] + 3 * (k - 1);
543    arith_encode(cinfo, st, 1);
544  }
545
546  return TRUE;
547}
548
549
550/*
551 * MCU encoding for DC successive approximation refinement scan.
552 */
553
554METHODDEF(boolean)
555encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
556{
557  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
558  unsigned char *st;
559  int Al, blkn;
560
561  /* Emit restart marker if needed */
562  if (cinfo->restart_interval) {
563    if (entropy->restarts_to_go == 0) {
564      emit_restart(cinfo, entropy->next_restart_num);
565      entropy->restarts_to_go = cinfo->restart_interval;
566      entropy->next_restart_num++;
567      entropy->next_restart_num &= 7;
568    }
569    entropy->restarts_to_go--;
570  }
571
572  st = entropy->fixed_bin;	/* use fixed probability estimation */
573  Al = cinfo->Al;
574
575  /* Encode the MCU data blocks */
576  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
577    /* We simply emit the Al'th bit of the DC coefficient value. */
578    arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1);
579  }
580
581  return TRUE;
582}
583
584
585/*
586 * MCU encoding for AC successive approximation refinement scan.
587 */
588
589METHODDEF(boolean)
590encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
591{
592  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
593  JBLOCKROW block;
594  unsigned char *st;
595  int tbl, k, ke, kex;
596  int v;
597  const int * natural_order;
598
599  /* Emit restart marker if needed */
600  if (cinfo->restart_interval) {
601    if (entropy->restarts_to_go == 0) {
602      emit_restart(cinfo, entropy->next_restart_num);
603      entropy->restarts_to_go = cinfo->restart_interval;
604      entropy->next_restart_num++;
605      entropy->next_restart_num &= 7;
606    }
607    entropy->restarts_to_go--;
608  }
609
610  natural_order = cinfo->natural_order;
611
612  /* Encode the MCU data block */
613  block = MCU_data[0];
614  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
615
616  /* Section G.1.3.3: Encoding of AC coefficients */
617
618  /* Establish EOB (end-of-block) index */
619  for (ke = cinfo->Se; ke > 0; ke--)
620    /* We must apply the point transform by Al.  For AC coefficients this
621     * is an integer division with rounding towards 0.  To do this portably
622     * in C, we shift after obtaining the absolute value.
623     */
624    if ((v = (*block)[natural_order[ke]]) >= 0) {
625      if (v >>= cinfo->Al) break;
626    } else {
627      v = -v;
628      if (v >>= cinfo->Al) break;
629    }
630
631  /* Establish EOBx (previous stage end-of-block) index */
632  for (kex = ke; kex > 0; kex--)
633    if ((v = (*block)[natural_order[kex]]) >= 0) {
634      if (v >>= cinfo->Ah) break;
635    } else {
636      v = -v;
637      if (v >>= cinfo->Ah) break;
638    }
639
640  /* Figure G.10: Encode_AC_Coefficients_SA */
641  for (k = cinfo->Ss; k <= ke; k++) {
642    st = entropy->ac_stats[tbl] + 3 * (k - 1);
643    if (k > kex)
644      arith_encode(cinfo, st, 0);	/* EOB decision */
645    for (;;) {
646      if ((v = (*block)[natural_order[k]]) >= 0) {
647	if (v >>= cinfo->Al) {
648	  if (v >> 1)			/* previously nonzero coef */
649	    arith_encode(cinfo, st + 2, (v & 1));
650	  else {			/* newly nonzero coef */
651	    arith_encode(cinfo, st + 1, 1);
652	    arith_encode(cinfo, entropy->fixed_bin, 0);
653	  }
654	  break;
655	}
656      } else {
657	v = -v;
658	if (v >>= cinfo->Al) {
659	  if (v >> 1)			/* previously nonzero coef */
660	    arith_encode(cinfo, st + 2, (v & 1));
661	  else {			/* newly nonzero coef */
662	    arith_encode(cinfo, st + 1, 1);
663	    arith_encode(cinfo, entropy->fixed_bin, 1);
664	  }
665	  break;
666	}
667      }
668      arith_encode(cinfo, st + 1, 0); st += 3; k++;
669    }
670  }
671  /* Encode EOB decision only if k <= cinfo->Se */
672  if (k <= cinfo->Se) {
673    st = entropy->ac_stats[tbl] + 3 * (k - 1);
674    arith_encode(cinfo, st, 1);
675  }
676
677  return TRUE;
678}
679
680
681/*
682 * Encode and output one MCU's worth of arithmetic-compressed coefficients.
683 */
684
685METHODDEF(boolean)
686encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
687{
688  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
689  jpeg_component_info * compptr;
690  JBLOCKROW block;
691  unsigned char *st;
692  int blkn, ci, tbl, k, ke;
693  int v, v2, m;
694  const int * natural_order;
695
696  /* Emit restart marker if needed */
697  if (cinfo->restart_interval) {
698    if (entropy->restarts_to_go == 0) {
699      emit_restart(cinfo, entropy->next_restart_num);
700      entropy->restarts_to_go = cinfo->restart_interval;
701      entropy->next_restart_num++;
702      entropy->next_restart_num &= 7;
703    }
704    entropy->restarts_to_go--;
705  }
706
707  natural_order = cinfo->natural_order;
708
709  /* Encode the MCU data blocks */
710  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
711    block = MCU_data[blkn];
712    ci = cinfo->MCU_membership[blkn];
713    compptr = cinfo->cur_comp_info[ci];
714
715    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
716
717    tbl = compptr->dc_tbl_no;
718
719    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
720    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
721
722    /* Figure F.4: Encode_DC_DIFF */
723    if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) {
724      arith_encode(cinfo, st, 0);
725      entropy->dc_context[ci] = 0;	/* zero diff category */
726    } else {
727      entropy->last_dc_val[ci] = (*block)[0];
728      arith_encode(cinfo, st, 1);
729      /* Figure F.6: Encoding nonzero value v */
730      /* Figure F.7: Encoding the sign of v */
731      if (v > 0) {
732	arith_encode(cinfo, st + 1, 0);	/* Table F.4: SS = S0 + 1 */
733	st += 2;			/* Table F.4: SP = S0 + 2 */
734	entropy->dc_context[ci] = 4;	/* small positive diff category */
735      } else {
736	v = -v;
737	arith_encode(cinfo, st + 1, 1);	/* Table F.4: SS = S0 + 1 */
738	st += 3;			/* Table F.4: SN = S0 + 3 */
739	entropy->dc_context[ci] = 8;	/* small negative diff category */
740      }
741      /* Figure F.8: Encoding the magnitude category of v */
742      m = 0;
743      if (v -= 1) {
744	arith_encode(cinfo, st, 1);
745	m = 1;
746	v2 = v;
747	st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
748	while (v2 >>= 1) {
749	  arith_encode(cinfo, st, 1);
750	  m <<= 1;
751	  st += 1;
752	}
753      }
754      arith_encode(cinfo, st, 0);
755      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
756      if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
757	entropy->dc_context[ci] = 0;	/* zero diff category */
758      else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
759	entropy->dc_context[ci] += 8;	/* large diff category */
760      /* Figure F.9: Encoding the magnitude bit pattern of v */
761      st += 14;
762      while (m >>= 1)
763	arith_encode(cinfo, st, (m & v) ? 1 : 0);
764    }
765
766    /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
767
768    if ((ke = cinfo->lim_Se) == 0) continue;
769    tbl = compptr->ac_tbl_no;
770
771    /* Establish EOB (end-of-block) index */
772    do {
773      if ((*block)[natural_order[ke]]) break;
774    } while (--ke);
775
776    /* Figure F.5: Encode_AC_Coefficients */
777    for (k = 0; k < ke;) {
778      st = entropy->ac_stats[tbl] + 3 * k;
779      arith_encode(cinfo, st, 0);	/* EOB decision */
780      while ((v = (*block)[natural_order[++k]]) == 0) {
781	arith_encode(cinfo, st + 1, 0);
782	st += 3;
783      }
784      arith_encode(cinfo, st + 1, 1);
785      /* Figure F.6: Encoding nonzero value v */
786      /* Figure F.7: Encoding the sign of v */
787      if (v > 0) {
788	arith_encode(cinfo, entropy->fixed_bin, 0);
789      } else {
790	v = -v;
791	arith_encode(cinfo, entropy->fixed_bin, 1);
792      }
793      st += 2;
794      /* Figure F.8: Encoding the magnitude category of v */
795      m = 0;
796      if (v -= 1) {
797	arith_encode(cinfo, st, 1);
798	m = 1;
799	v2 = v;
800	if (v2 >>= 1) {
801	  arith_encode(cinfo, st, 1);
802	  m <<= 1;
803	  st = entropy->ac_stats[tbl] +
804	       (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
805	  while (v2 >>= 1) {
806	    arith_encode(cinfo, st, 1);
807	    m <<= 1;
808	    st += 1;
809	  }
810	}
811      }
812      arith_encode(cinfo, st, 0);
813      /* Figure F.9: Encoding the magnitude bit pattern of v */
814      st += 14;
815      while (m >>= 1)
816	arith_encode(cinfo, st, (m & v) ? 1 : 0);
817    }
818    /* Encode EOB decision only if k < cinfo->lim_Se */
819    if (k < cinfo->lim_Se) {
820      st = entropy->ac_stats[tbl] + 3 * k;
821      arith_encode(cinfo, st, 1);
822    }
823  }
824
825  return TRUE;
826}
827
828
829/*
830 * Initialize for an arithmetic-compressed scan.
831 */
832
833METHODDEF(void)
834start_pass (j_compress_ptr cinfo, boolean gather_statistics)
835{
836  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
837  int ci, tbl;
838  jpeg_component_info * compptr;
839
840  if (gather_statistics)
841    /* Make sure to avoid that in the master control logic!
842     * We are fully adaptive here and need no extra
843     * statistics gathering pass!
844     */
845    ERREXIT(cinfo, JERR_NOT_COMPILED);
846
847  /* We assume jcmaster.c already validated the progressive scan parameters. */
848
849  /* Select execution routines */
850  if (cinfo->progressive_mode) {
851    if (cinfo->Ah == 0) {
852      if (cinfo->Ss == 0)
853	entropy->pub.encode_mcu = encode_mcu_DC_first;
854      else
855	entropy->pub.encode_mcu = encode_mcu_AC_first;
856    } else {
857      if (cinfo->Ss == 0)
858	entropy->pub.encode_mcu = encode_mcu_DC_refine;
859      else
860	entropy->pub.encode_mcu = encode_mcu_AC_refine;
861    }
862  } else
863    entropy->pub.encode_mcu = encode_mcu;
864
865  /* Allocate & initialize requested statistics areas */
866  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
867    compptr = cinfo->cur_comp_info[ci];
868    /* DC needs no table for refinement scan */
869    if (cinfo->Ss == 0 && cinfo->Ah == 0) {
870      tbl = compptr->dc_tbl_no;
871      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
872	ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
873      if (entropy->dc_stats[tbl] == NULL)
874	entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
875	  ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS);
876      MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
877      /* Initialize DC predictions to 0 */
878      entropy->last_dc_val[ci] = 0;
879      entropy->dc_context[ci] = 0;
880    }
881    /* AC needs no table when not present */
882    if (cinfo->Se) {
883      tbl = compptr->ac_tbl_no;
884      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
885	ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
886      if (entropy->ac_stats[tbl] == NULL)
887	entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
888	  ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS);
889      MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
890#ifdef CALCULATE_SPECTRAL_CONDITIONING
891      if (cinfo->progressive_mode)
892	/* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */
893	cinfo->arith_ac_K[tbl] = cinfo->Ss + ((8 + cinfo->Se - cinfo->Ss) >> 4);
894#endif
895    }
896  }
897
898  /* Initialize arithmetic encoding variables */
899  entropy->c = 0;
900  entropy->a = 0x10000L;
901  entropy->sc = 0;
902  entropy->zc = 0;
903  entropy->ct = 11;
904  entropy->buffer = -1;  /* empty */
905
906  /* Initialize restart stuff */
907  entropy->restarts_to_go = cinfo->restart_interval;
908  entropy->next_restart_num = 0;
909}
910
911
912/*
913 * Module initialization routine for arithmetic entropy encoding.
914 */
915
916GLOBAL(void)
917jinit_arith_encoder (j_compress_ptr cinfo)
918{
919  arith_entropy_ptr entropy;
920  int i;
921
922  entropy = (arith_entropy_ptr)
923    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
924				SIZEOF(arith_entropy_encoder));
925  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
926  entropy->pub.start_pass = start_pass;
927  entropy->pub.finish_pass = finish_pass;
928
929  /* Mark tables unallocated */
930  for (i = 0; i < NUM_ARITH_TBLS; i++) {
931    entropy->dc_stats[i] = NULL;
932    entropy->ac_stats[i] = NULL;
933  }
934
935  /* Initialize index for fixed probability estimation */
936  entropy->fixed_bin[0] = 113;
937}