* Modified 2006-2009 by Guido Vollbeding.

 * Both sequential and progressive modes are supported in this single module.

 *

 * We do not support output suspension for the progressive JPEG mode, since

 * the library currently does not allow multiple-scan files to be written

 * with output suspension.

/* The legal range of a DCT coefficient is

 *  -1024 .. +1023  for 8-bit data;

 * -16384 .. +16383 for 12-bit data.

 * Hence the magnitude should always fit in 10 or 14 bits respectively.

 */

#if BITS_IN_JSAMPLE == 8

#define MAX_COEF_BITS 10

#else

#define MAX_COEF_BITS 14

#endif

/* Derived data constructed for each Huffman table */

typedef struct {

  unsigned int ehufco[256];	/* code for each symbol */

  char ehufsi[256];		/* length of code for each symbol */

  /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */

} c_derived_tbl;

  /* Statistics tables for optimization */

  /* Following fields used only in progressive mode */

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

  boolean gather_statistics;

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

   */

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

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

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

  /* Coding status for AC components */

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

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

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

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

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

/* Working state while writing an MCU (sequential mode).

/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit

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

 * 1000 is already well into the realm of overkill.

 * The minimum safe size is 64 bits.

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

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

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

 * which should be safe.

 */

#ifdef RIGHT_SHIFT_IS_UNSIGNED

#define ISHIFT_TEMPS	int ishift_temp;

#define IRIGHT_SHIFT(x,shft)  \

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

	 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \

	 (ishift_temp >> (shft)))

#else

#define ISHIFT_TEMPS

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

LOCAL(void)

/* Outputting bytes to the file.

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

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

 */

#define emit_byte_s(state,val,action)  \

	    if (! dump_buffer_s(state))  \

/* Emit a byte */

#define emit_byte_e(entropy,val)  \

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

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

	    dump_buffer_e(entropy); }

dump_buffer_s (working_state * state)

LOCAL(void)

dump_buffer_e (huff_entropy_ptr entropy)

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

{

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

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

    ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);

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

  entropy->next_output_byte = dest->next_output_byte;

  entropy->free_in_buffer = dest->free_in_buffer;

}

emit_bits_s (working_state * state, unsigned int code, int size)

    emit_byte_s(state, c, return FALSE);

      emit_byte_s(state, 0, return FALSE);

INLINE

LOCAL(void)

emit_bits_e (huff_entropy_ptr entropy, unsigned int code, int size)

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

{

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

  register INT32 put_buffer = (INT32) code;

  register int put_bits = entropy->saved.put_bits;

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

  if (size == 0)

    ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);

  if (entropy->gather_statistics)

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

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

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

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

  /* and merge with old buffer contents */

  put_buffer |= entropy->saved.put_buffer;

  while (put_bits >= 8) {

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

    emit_byte_e(entropy, c);

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

      emit_byte_e(entropy, 0);

    }

    put_buffer <<= 8;

    put_bits -= 8;

  }

  entropy->saved.put_buffer = put_buffer; /* update variables */

  entropy->saved.put_bits = put_bits;

}

flush_bits_s (working_state * state)

{

  if (! emit_bits_s(state, 0x7F, 7)) /* fill any partial byte with ones */

    return FALSE;

  state->cur.put_buffer = 0;	     /* and reset bit-buffer to empty */

  state->cur.put_bits = 0;

  return TRUE;

}

LOCAL(void)

flush_bits_e (huff_entropy_ptr entropy)

{

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

  entropy->saved.put_buffer = 0; /* and reset bit-buffer to empty */

  entropy->saved.put_bits = 0;

}

/*

 * Emit (or just count) a Huffman symbol.

 */

INLINE

LOCAL(void)

emit_dc_symbol (huff_entropy_ptr entropy, int tbl_no, int symbol)

{

  if (entropy->gather_statistics)

    entropy->dc_count_ptrs[tbl_no][symbol]++;

  else {

    c_derived_tbl * tbl = entropy->dc_derived_tbls[tbl_no];

    emit_bits_e(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);

  }

}

INLINE

LOCAL(void)

emit_ac_symbol (huff_entropy_ptr entropy, int tbl_no, int symbol)

{

  if (entropy->gather_statistics)

    entropy->ac_count_ptrs[tbl_no][symbol]++;

  else {

    c_derived_tbl * tbl = entropy->ac_derived_tbls[tbl_no];

    emit_bits_e(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);

  }

}

/*

 * Emit bits from a correction bit buffer.

 */

LOCAL(void)

emit_buffered_bits (huff_entropy_ptr entropy, char * bufstart,

		    unsigned int nbits)

{

  if (entropy->gather_statistics)

    return;			/* no real work */

  while (nbits > 0) {

    emit_bits_e(entropy, (unsigned int) (*bufstart), 1);

    bufstart++;

    nbits--;

  }

}

/*

 * Emit any pending EOBRUN symbol.

 */

LOCAL(void)

emit_eobrun (huff_entropy_ptr entropy)

{

  register int temp, nbits;

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

    temp = entropy->EOBRUN;

    nbits = 0;

    while ((temp >>= 1))

      nbits++;

    /* safety check: shouldn't happen given limited correction-bit buffer */

    if (nbits > 14)

      ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);

    emit_ac_symbol(entropy, entropy->ac_tbl_no, nbits << 4);

    if (nbits)

      emit_bits_e(entropy, entropy->EOBRUN, nbits);

    entropy->EOBRUN = 0;

    /* Emit any buffered correction bits */

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

    entropy->BE = 0;

  }

}

/*

 * Emit a restart marker & resynchronize predictions.

 */

LOCAL(boolean)

emit_restart_s (working_state * state, int restart_num)

{

  int ci;

  if (! flush_bits_s(state))

    return FALSE;

  emit_byte_s(state, 0xFF, return FALSE);

  emit_byte_s(state, JPEG_RST0 + restart_num, return FALSE);

  /* Re-initialize DC predictions to 0 */

  for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)

    state->cur.last_dc_val[ci] = 0;

  /* The restart counter is not updated until we successfully write the MCU. */

  return TRUE;

}