ReactOS  0.4.15-dev-341-g17c5fb8
jdhuff.c File Reference
#include "jinclude.h"
#include "jpeglib.h"
Include dependency graph for jdhuff.c:

Go to the source code of this file.

Classes

struct  d_derived_tbl
 
struct  bitread_perm_state
 
struct  bitread_working_state
 
struct  savable_state
 
struct  huff_entropy_decoder
 

Macros

#define JPEG_INTERNALS
 
#define HUFF_LOOKAHEAD   8 /* # of bits of lookahead */
 
#define BIT_BUF_SIZE   32 /* size of buffer in bits */
 
#define BITREAD_STATE_VARS
 
#define BITREAD_LOAD_STATE(cinfop, permstate)
 
#define BITREAD_SAVE_STATE(cinfop, permstate)
 
#define CHECK_BIT_BUFFER(state, nbits, action)
 
#define GET_BITS(nbits)   (((int) (get_buffer >> (bits_left -= (nbits)))) & BIT_MASK(nbits))
 
#define PEEK_BITS(nbits)   (((int) (get_buffer >> (bits_left - (nbits)))) & BIT_MASK(nbits))
 
#define DROP_BITS(nbits)   (bits_left -= (nbits))
 
#define HUFF_DECODE(result, state, htbl, failaction, slowlabel)
 
#define ASSIGN_STATE(dest, src)   ((dest) = (src))
 
#define MIN_GET_BITS   (BIT_BUF_SIZE-7)
 
#define BIT_MASK(nbits)   bmask[nbits]
 
#define HUFF_EXTEND(x, s)   ((x) <= bmask[(s) - 1] ? (x) - bmask[s] : (x))
 

Typedefs

typedef INT32 bit_buf_type
 
typedef huff_entropy_decoderhuff_entropy_ptr
 

Functions

 jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno, d_derived_tbl **pdtbl)
 
 jpeg_fill_bit_buffer (bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, int nbits)
 
 jpeg_huff_decode (bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, d_derived_tbl *htbl, int min_bits)
 
 finish_pass_huff (j_decompress_ptr cinfo)
 
 process_restart (j_decompress_ptr cinfo)
 
 decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 start_pass_huff_decoder (j_decompress_ptr cinfo)
 
 jinit_huff_decoder (j_decompress_ptr cinfo)
 

Variables

static const int jpeg_zigzag_order [8][8]
 
static const int jpeg_zigzag_order7 [7][7]
 
static const int jpeg_zigzag_order6 [6][6]
 
static const int jpeg_zigzag_order5 [5][5]
 
static const int jpeg_zigzag_order4 [4][4]
 
static const int jpeg_zigzag_order3 [3][3]
 
static const int jpeg_zigzag_order2 [2][2]
 
static const int bmask [16]
 

Macro Definition Documentation

◆ ASSIGN_STATE

#define ASSIGN_STATE (   dest,
  src 
)    ((dest) = (src))

Definition at line 209 of file jdhuff.c.

◆ BIT_BUF_SIZE

#define BIT_BUF_SIZE   32 /* size of buffer in bits */

Definition at line 70 of file jdhuff.c.

◆ BIT_MASK

#define BIT_MASK (   nbits)    bmask[nbits]

Definition at line 576 of file jdhuff.c.

◆ BITREAD_LOAD_STATE

#define BITREAD_LOAD_STATE (   cinfop,
  permstate 
)
Value:
br_state.cinfo = cinfop; \
br_state.next_input_byte = cinfop->src->next_input_byte; \
br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
get_buffer = permstate.get_buffer; \
bits_left = permstate.bits_left;

Definition at line 104 of file jdhuff.c.

◆ BITREAD_SAVE_STATE

#define BITREAD_SAVE_STATE (   cinfop,
  permstate 
)
Value:
cinfop->src->next_input_byte = br_state.next_input_byte; \
cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
permstate.get_buffer = get_buffer; \
permstate.bits_left = bits_left
NTSTATUS get_buffer(LPWSTR *buffer, SIZE_T needed, PUNICODE_STRING CallerBuffer, BOOLEAN bAllocateBuffer)
Definition: libsupp.c:688

Definition at line 111 of file jdhuff.c.

◆ BITREAD_STATE_VARS

#define BITREAD_STATE_VARS
Value:
register int bits_left; \
bitread_working_state br_state
NTSTATUS get_buffer(LPWSTR *buffer, SIZE_T needed, PUNICODE_STRING CallerBuffer, BOOLEAN bAllocateBuffer)
Definition: libsupp.c:688
INT32 bit_buf_type
Definition: jdhuff.c:69

Definition at line 99 of file jdhuff.c.

◆ CHECK_BIT_BUFFER

#define CHECK_BIT_BUFFER (   state,
  nbits,
  action 
)
Value:
{ if (bits_left < (nbits)) { \
if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \
{ action; } \
get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }
static int state
Definition: maze.c:121
jpeg_fill_bit_buffer(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, int nbits)
Definition: jdhuff.c:464
const WCHAR * action
Definition: action.c:7783
NTSTATUS get_buffer(LPWSTR *buffer, SIZE_T needed, PUNICODE_STRING CallerBuffer, BOOLEAN bAllocateBuffer)
Definition: libsupp.c:688

Definition at line 135 of file jdhuff.c.

◆ DROP_BITS

#define DROP_BITS (   nbits)    (bits_left -= (nbits))

Definition at line 147 of file jdhuff.c.

◆ GET_BITS

#define GET_BITS (   nbits)    (((int) (get_buffer >> (bits_left -= (nbits)))) & BIT_MASK(nbits))

Definition at line 141 of file jdhuff.c.

◆ HUFF_DECODE

#define HUFF_DECODE (   result,
  state,
  htbl,
  failaction,
  slowlabel 
)
Value:
{ register int nb, look; \
if (bits_left < HUFF_LOOKAHEAD) { \
if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
get_buffer = state.get_buffer; bits_left = state.bits_left; \
if (bits_left < HUFF_LOOKAHEAD) { \
nb = 1; goto slowlabel; \
} \
} \
if ((nb = htbl->look_nbits[look]) != 0) { \
DROP_BITS(nb); \
result = htbl->look_sym[look]; \
} else { \
nb = HUFF_LOOKAHEAD+1; \
slowlabel: \
if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
{ failaction; } \
get_buffer = state.get_buffer; bits_left = state.bits_left; \
} \
}
jpeg_huff_decode(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, d_derived_tbl *htbl, int min_bits)
Definition: jdhuff.c:591
#define HUFF_LOOKAHEAD
Definition: jdhuff.c:26
static int state
Definition: maze.c:121
jpeg_fill_bit_buffer(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, int nbits)
Definition: jdhuff.c:464
#define PEEK_BITS(nbits)
Definition: jdhuff.c:144
NTSTATUS get_buffer(LPWSTR *buffer, SIZE_T needed, PUNICODE_STRING CallerBuffer, BOOLEAN bAllocateBuffer)
Definition: libsupp.c:688
GLuint64EXT * result
Definition: glext.h:11304

Definition at line 168 of file jdhuff.c.

◆ HUFF_EXTEND

#define HUFF_EXTEND (   x,
  s 
)    ((x) <= bmask[(s) - 1] ? (x) - bmask[s] : (x))

Definition at line 577 of file jdhuff.c.

◆ HUFF_LOOKAHEAD

#define HUFF_LOOKAHEAD   8 /* # of bits of lookahead */

Definition at line 26 of file jdhuff.c.

◆ JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 19 of file jdhuff.c.

◆ MIN_GET_BITS

#define MIN_GET_BITS   (BIT_BUF_SIZE-7)

Definition at line 459 of file jdhuff.c.

◆ PEEK_BITS

#define PEEK_BITS (   nbits)    (((int) (get_buffer >> (bits_left - (nbits)))) & BIT_MASK(nbits))

Definition at line 144 of file jdhuff.c.

Typedef Documentation

◆ bit_buf_type

Definition at line 69 of file jdhuff.c.

◆ huff_entropy_ptr

Definition at line 257 of file jdhuff.c.

Function Documentation

◆ decode_mcu()

decode_mcu ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 1204 of file jdhuff.c.

1205 {
1206  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1207  int blkn;
1210 
1211  /* Process restart marker if needed; may have to suspend */
1212  if (cinfo->restart_interval) {
1213  if (entropy->restarts_to_go == 0)
1214  if (! process_restart(cinfo))
1215  return FALSE;
1216  }
1217 
1218  /* If we've run out of data, just leave the MCU set to zeroes.
1219  * This way, we return uniform gray for the remainder of the segment.
1220  */
1221  if (! entropy->insufficient_data) {
1222 
1223  /* Load up working state */
1224  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
1225  ASSIGN_STATE(state, entropy->saved);
1226 
1227  /* Outer loop handles each block in the MCU */
1228 
1229  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
1230  JBLOCKROW block = MCU_data[blkn];
1231  d_derived_tbl * htbl;
1232  register int s, k, r;
1233  int coef_limit, ci;
1234 
1235  /* Decode a single block's worth of coefficients */
1236 
1237  /* Section F.2.2.1: decode the DC coefficient difference */
1238  htbl = entropy->dc_cur_tbls[blkn];
1239  HUFF_DECODE(s, br_state, htbl, return FALSE, label1);
1240 
1241  htbl = entropy->ac_cur_tbls[blkn];
1242  k = 1;
1243  coef_limit = entropy->coef_limit[blkn];
1244  if (coef_limit) {
1245  /* Convert DC difference to actual value, update last_dc_val */
1246  if (s) {
1247  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1248  r = GET_BITS(s);
1249  s = HUFF_EXTEND(r, s);
1250  }
1251  ci = cinfo->MCU_membership[blkn];
1252  s += state.last_dc_val[ci];
1253  state.last_dc_val[ci] = s;
1254  /* Output the DC coefficient */
1255  (*block)[0] = (JCOEF) s;
1256 
1257  /* Section F.2.2.2: decode the AC coefficients */
1258  /* Since zeroes are skipped, output area must be cleared beforehand */
1259  for (; k < coef_limit; k++) {
1260  HUFF_DECODE(s, br_state, htbl, return FALSE, label2);
1261 
1262  r = s >> 4;
1263  s &= 15;
1264 
1265  if (s) {
1266  k += r;
1267  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1268  r = GET_BITS(s);
1269  s = HUFF_EXTEND(r, s);
1270  /* Output coefficient in natural (dezigzagged) order.
1271  * Note: the extra entries in jpeg_natural_order[] will save us
1272  * if k >= DCTSIZE2, which could happen if the data is corrupted.
1273  */
1274  (*block)[jpeg_natural_order[k]] = (JCOEF) s;
1275  } else {
1276  if (r != 15)
1277  goto EndOfBlock;
1278  k += 15;
1279  }
1280  }
1281  } else {
1282  if (s) {
1283  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1284  DROP_BITS(s);
1285  }
1286  }
1287 
1288  /* Section F.2.2.2: decode the AC coefficients */
1289  /* In this path we just discard the values */
1290  for (; k < DCTSIZE2; k++) {
1291  HUFF_DECODE(s, br_state, htbl, return FALSE, label3);
1292 
1293  r = s >> 4;
1294  s &= 15;
1295 
1296  if (s) {
1297  k += r;
1298  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1299  DROP_BITS(s);
1300  } else {
1301  if (r != 15)
1302  break;
1303  k += 15;
1304  }
1305  }
1306 
1307  EndOfBlock: ;
1308  }
1309 
1310  /* Completed MCU, so update state */
1311  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
1312  ASSIGN_STATE(entropy->saved, state);
1313  }
1314 
1315  /* Account for restart interval if using restarts */
1316  if (cinfo->restart_interval)
1317  entropy->restarts_to_go--;
1318 
1319  return TRUE;
1320 }
static unsigned int block
Definition: xmlmemory.c:118
#define TRUE
Definition: types.h:120
#define HUFF_EXTEND(x, s)
Definition: jdhuff.c:577
static const WCHAR label2[]
Definition: itemdlg.c:1547
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
short JCOEF
Definition: jmorecfg.h:151
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
#define DROP_BITS(nbits)
Definition: jdhuff.c:147
#define DCTSIZE2
Definition: jpeglib.h:51
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
static int state
Definition: maze.c:121
GLdouble s
Definition: gl.h:2039
#define ASSIGN_STATE(dest, src)
Definition: jdhuff.c:209
const int jpeg_natural_order[DCTSIZE2+16]
Definition: jutils.c:54
process_restart(j_decompress_ptr cinfo)
Definition: jdhuff.c:651
#define HUFF_DECODE(result, state, htbl, failaction, slowlabel)
Definition: jdhuff.c:168
#define BITREAD_SAVE_STATE(cinfop, permstate)
Definition: jdhuff.c:111
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
#define GET_BITS(nbits)
Definition: jdhuff.c:141
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369
#define BITREAD_LOAD_STATE(cinfop, permstate)
Definition: jdhuff.c:104
#define BITREAD_STATE_VARS
Definition: jdhuff.c:99

Referenced by start_pass_huff_decoder().

◆ decode_mcu_AC_first()

decode_mcu_AC_first ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 779 of file jdhuff.c.

780 {
781  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
782  register int s, k, r;
783  unsigned int EOBRUN;
784  int Se, Al;
785  const int * natural_order;
788  d_derived_tbl * tbl;
789 
790  /* Process restart marker if needed; may have to suspend */
791  if (cinfo->restart_interval) {
792  if (entropy->restarts_to_go == 0)
793  if (! process_restart(cinfo))
794  return FALSE;
795  }
796 
797  /* If we've run out of data, just leave the MCU set to zeroes.
798  * This way, we return uniform gray for the remainder of the segment.
799  */
800  if (! entropy->insufficient_data) {
801 
802  /* Load up working state.
803  * We can avoid loading/saving bitread state if in an EOB run.
804  */
805  EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
806 
807  /* There is always only one block per MCU */
808 
809  if (EOBRUN) /* if it's a band of zeroes... */
810  EOBRUN--; /* ...process it now (we do nothing) */
811  else {
812  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
813  Se = cinfo->Se;
814  Al = cinfo->Al;
815  natural_order = cinfo->natural_order;
816  block = MCU_data[0];
817  tbl = entropy->ac_derived_tbl;
818 
819  for (k = cinfo->Ss; k <= Se; k++) {
820  HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
821  r = s >> 4;
822  s &= 15;
823  if (s) {
824  k += r;
825  CHECK_BIT_BUFFER(br_state, s, return FALSE);
826  r = GET_BITS(s);
827  s = HUFF_EXTEND(r, s);
828  /* Scale and output coefficient in natural (dezigzagged) order */
829  (*block)[natural_order[k]] = (JCOEF) (s << Al);
830  } else {
831  if (r != 15) { /* EOBr, run length is 2^r + appended bits */
832  if (r) { /* EOBr, r > 0 */
833  EOBRUN = 1 << r;
834  CHECK_BIT_BUFFER(br_state, r, return FALSE);
835  r = GET_BITS(r);
836  EOBRUN += r;
837  EOBRUN--; /* this band is processed at this moment */
838  }
839  break; /* force end-of-band */
840  }
841  k += 15; /* ZRL: skip 15 zeroes in band */
842  }
843  }
844 
845  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
846  }
847 
848  /* Completed MCU, so update state */
849  entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
850  }
851 
852  /* Account for restart interval if using restarts */
853  if (cinfo->restart_interval)
854  entropy->restarts_to_go--;
855 
856  return TRUE;
857 }
static unsigned int block
Definition: xmlmemory.c:118
#define TRUE
Definition: types.h:120
#define HUFF_EXTEND(x, s)
Definition: jdhuff.c:577
static const WCHAR label2[]
Definition: itemdlg.c:1547
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
short JCOEF
Definition: jmorecfg.h:151
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
GLdouble s
Definition: gl.h:2039
const int * natural_order
Definition: jpeglib.h:666
process_restart(j_decompress_ptr cinfo)
Definition: jdhuff.c:651
#define HUFF_DECODE(result, state, htbl, failaction, slowlabel)
Definition: jdhuff.c:168
#define BITREAD_SAVE_STATE(cinfop, permstate)
Definition: jdhuff.c:111
unsigned int EOBRUN
Definition: jdhuff.c:199
#define GET_BITS(nbits)
Definition: jdhuff.c:141
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369
#define BITREAD_LOAD_STATE(cinfop, permstate)
Definition: jdhuff.c:104
#define BITREAD_STATE_VARS
Definition: jdhuff.c:99

Referenced by start_pass_huff_decoder().

◆ decode_mcu_AC_refine()

decode_mcu_AC_refine ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 916 of file jdhuff.c.

917 {
918  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
919  register int s, k, r;
920  unsigned int EOBRUN;
921  int Se;
922  JCOEF p1, m1;
923  const int * natural_order;
925  JCOEFPTR thiscoef;
927  d_derived_tbl * tbl;
928  int num_newnz;
929  int newnz_pos[DCTSIZE2];
930 
931  /* Process restart marker if needed; may have to suspend */
932  if (cinfo->restart_interval) {
933  if (entropy->restarts_to_go == 0)
934  if (! process_restart(cinfo))
935  return FALSE;
936  }
937 
938  /* If we've run out of data, don't modify the MCU.
939  */
940  if (! entropy->insufficient_data) {
941 
942  Se = cinfo->Se;
943  p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
944  m1 = -p1; /* -1 in the bit position being coded */
945  natural_order = cinfo->natural_order;
946 
947  /* Load up working state */
948  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
949  EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
950 
951  /* There is always only one block per MCU */
952  block = MCU_data[0];
953  tbl = entropy->ac_derived_tbl;
954 
955  /* If we are forced to suspend, we must undo the assignments to any newly
956  * nonzero coefficients in the block, because otherwise we'd get confused
957  * next time about which coefficients were already nonzero.
958  * But we need not undo addition of bits to already-nonzero coefficients;
959  * instead, we can test the current bit to see if we already did it.
960  */
961  num_newnz = 0;
962 
963  /* initialize coefficient loop counter to start of band */
964  k = cinfo->Ss;
965 
966  if (EOBRUN == 0) {
967  do {
968  HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
969  r = s >> 4;
970  s &= 15;
971  if (s) {
972  if (s != 1) /* size of new coef should always be 1 */
973  WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
974  CHECK_BIT_BUFFER(br_state, 1, goto undoit);
975  if (GET_BITS(1))
976  s = p1; /* newly nonzero coef is positive */
977  else
978  s = m1; /* newly nonzero coef is negative */
979  } else {
980  if (r != 15) {
981  EOBRUN = 1 << r; /* EOBr, run length is 2^r + appended bits */
982  if (r) {
983  CHECK_BIT_BUFFER(br_state, r, goto undoit);
984  r = GET_BITS(r);
985  EOBRUN += r;
986  }
987  break; /* rest of block is handled by EOB logic */
988  }
989  /* note s = 0 for processing ZRL */
990  }
991  /* Advance over already-nonzero coefs and r still-zero coefs,
992  * appending correction bits to the nonzeroes. A correction bit is 1
993  * if the absolute value of the coefficient must be increased.
994  */
995  do {
996  thiscoef = *block + natural_order[k];
997  if (*thiscoef) {
998  CHECK_BIT_BUFFER(br_state, 1, goto undoit);
999  if (GET_BITS(1)) {
1000  if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
1001  if (*thiscoef >= 0)
1002  *thiscoef += p1;
1003  else
1004  *thiscoef += m1;
1005  }
1006  }
1007  } else {
1008  if (--r < 0)
1009  break; /* reached target zero coefficient */
1010  }
1011  k++;
1012  } while (k <= Se);
1013  if (s) {
1014  int pos = natural_order[k];
1015  /* Output newly nonzero coefficient */
1016  (*block)[pos] = (JCOEF) s;
1017  /* Remember its position in case we have to suspend */
1018  newnz_pos[num_newnz++] = pos;
1019  }
1020  k++;
1021  } while (k <= Se);
1022  }
1023 
1024  if (EOBRUN) {
1025  /* Scan any remaining coefficient positions after the end-of-band
1026  * (the last newly nonzero coefficient, if any). Append a correction
1027  * bit to each already-nonzero coefficient. A correction bit is 1
1028  * if the absolute value of the coefficient must be increased.
1029  */
1030  do {
1031  thiscoef = *block + natural_order[k];
1032  if (*thiscoef) {
1033  CHECK_BIT_BUFFER(br_state, 1, goto undoit);
1034  if (GET_BITS(1)) {
1035  if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
1036  if (*thiscoef >= 0)
1037  *thiscoef += p1;
1038  else
1039  *thiscoef += m1;
1040  }
1041  }
1042  }
1043  k++;
1044  } while (k <= Se);
1045  /* Count one block completed in EOB run */
1046  EOBRUN--;
1047  }
1048 
1049  /* Completed MCU, so update state */
1050  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
1051  entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
1052  }
1053 
1054  /* Account for restart interval if using restarts */
1055  if (cinfo->restart_interval)
1056  entropy->restarts_to_go--;
1057 
1058  return TRUE;
1059 
1060 undoit:
1061  /* Re-zero any output coefficients that we made newly nonzero */
1062  while (num_newnz)
1063  (*block)[newnz_pos[--num_newnz]] = 0;
1064 
1065  return FALSE;
1066 }
static unsigned int block
Definition: xmlmemory.c:118
#define TRUE
Definition: types.h:120
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
short JCOEF
Definition: jmorecfg.h:151
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
#define DCTSIZE2
Definition: jpeglib.h:51
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
#define WARNMS(cinfo, code)
Definition: jerror.h:251
JCOEF FAR * JCOEFPTR
Definition: jpeglib.h:84
GLdouble s
Definition: gl.h:2039
const int * natural_order
Definition: jpeglib.h:666
process_restart(j_decompress_ptr cinfo)
Definition: jdhuff.c:651
#define HUFF_DECODE(result, state, htbl, failaction, slowlabel)
Definition: jdhuff.c:168
#define BITREAD_SAVE_STATE(cinfop, permstate)
Definition: jdhuff.c:111
unsigned int EOBRUN
Definition: jdhuff.c:199
#define GET_BITS(nbits)
Definition: jdhuff.c:141
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369
#define BITREAD_LOAD_STATE(cinfop, permstate)
Definition: jdhuff.c:104
#define BITREAD_STATE_VARS
Definition: jdhuff.c:99

Referenced by start_pass_huff_decoder().

◆ decode_mcu_DC_first()

decode_mcu_DC_first ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 707 of file jdhuff.c.

708 {
709  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
710  int Al = cinfo->Al;
711  register int s, r;
712  int blkn, ci;
716  d_derived_tbl * tbl;
718 
719  /* Process restart marker if needed; may have to suspend */
720  if (cinfo->restart_interval) {
721  if (entropy->restarts_to_go == 0)
722  if (! process_restart(cinfo))
723  return FALSE;
724  }
725 
726  /* If we've run out of data, just leave the MCU set to zeroes.
727  * This way, we return uniform gray for the remainder of the segment.
728  */
729  if (! entropy->insufficient_data) {
730 
731  /* Load up working state */
732  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
733  ASSIGN_STATE(state, entropy->saved);
734 
735  /* Outer loop handles each block in the MCU */
736 
737  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
738  block = MCU_data[blkn];
739  ci = cinfo->MCU_membership[blkn];
740  compptr = cinfo->cur_comp_info[ci];
741  tbl = entropy->derived_tbls[compptr->dc_tbl_no];
742 
743  /* Decode a single block's worth of coefficients */
744 
745  /* Section F.2.2.1: decode the DC coefficient difference */
746  HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
747  if (s) {
748  CHECK_BIT_BUFFER(br_state, s, return FALSE);
749  r = GET_BITS(s);
750  s = HUFF_EXTEND(r, s);
751  }
752 
753  /* Convert DC difference to actual value, update last_dc_val */
754  s += state.last_dc_val[ci];
755  state.last_dc_val[ci] = s;
756  /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
757  (*block)[0] = (JCOEF) (s << Al);
758  }
759 
760  /* Completed MCU, so update state */
761  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
762  ASSIGN_STATE(entropy->saved, state);
763  }
764 
765  /* Account for restart interval if using restarts */
766  if (cinfo->restart_interval)
767  entropy->restarts_to_go--;
768 
769  return TRUE;
770 }
static unsigned int block
Definition: xmlmemory.c:118
#define TRUE
Definition: types.h:120
#define HUFF_EXTEND(x, s)
Definition: jdhuff.c:577
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
short JCOEF
Definition: jmorecfg.h:151
jpeg_component_info * compptr
Definition: jdct.h:238
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
static int state
Definition: maze.c:121
GLdouble s
Definition: gl.h:2039
#define ASSIGN_STATE(dest, src)
Definition: jdhuff.c:209
process_restart(j_decompress_ptr cinfo)
Definition: jdhuff.c:651
#define HUFF_DECODE(result, state, htbl, failaction, slowlabel)
Definition: jdhuff.c:168
#define BITREAD_SAVE_STATE(cinfop, permstate)
Definition: jdhuff.c:111
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
#define GET_BITS(nbits)
Definition: jdhuff.c:141
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
#define BITREAD_LOAD_STATE(cinfop, permstate)
Definition: jdhuff.c:104
#define BITREAD_STATE_VARS
Definition: jdhuff.c:99

Referenced by start_pass_huff_decoder().

◆ decode_mcu_DC_refine()

decode_mcu_DC_refine ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 867 of file jdhuff.c.

868 {
869  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
870  JCOEF p1;
871  int blkn;
873 
874  /* Process restart marker if needed; may have to suspend */
875  if (cinfo->restart_interval) {
876  if (entropy->restarts_to_go == 0)
877  if (! process_restart(cinfo))
878  return FALSE;
879  }
880 
881  /* Not worth the cycles to check insufficient_data here,
882  * since we will not change the data anyway if we read zeroes.
883  */
884 
885  /* Load up working state */
886  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
887 
888  p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
889 
890  /* Outer loop handles each block in the MCU */
891 
892  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
893  /* Encoded data is simply the next bit of the two's-complement DC value */
894  CHECK_BIT_BUFFER(br_state, 1, return FALSE);
895  if (GET_BITS(1))
896  MCU_data[blkn][0][0] |= p1;
897  /* Note: since we use |=, repeating the assignment later is safe */
898  }
899 
900  /* Completed MCU, so update state */
901  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
902 
903  /* Account for restart interval if using restarts */
904  if (cinfo->restart_interval)
905  entropy->restarts_to_go--;
906 
907  return TRUE;
908 }
#define TRUE
Definition: types.h:120
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
short JCOEF
Definition: jmorecfg.h:151
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
process_restart(j_decompress_ptr cinfo)
Definition: jdhuff.c:651
#define BITREAD_SAVE_STATE(cinfop, permstate)
Definition: jdhuff.c:111
#define GET_BITS(nbits)
Definition: jdhuff.c:141
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
#define BITREAD_LOAD_STATE(cinfop, permstate)
Definition: jdhuff.c:104
#define BITREAD_STATE_VARS
Definition: jdhuff.c:99

Referenced by start_pass_huff_decoder().

◆ decode_mcu_sub()

decode_mcu_sub ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 1075 of file jdhuff.c.

1076 {
1077  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1078  const int * natural_order;
1079  int Se, blkn;
1082 
1083  /* Process restart marker if needed; may have to suspend */
1084  if (cinfo->restart_interval) {
1085  if (entropy->restarts_to_go == 0)
1086  if (! process_restart(cinfo))
1087  return FALSE;
1088  }
1089 
1090  /* If we've run out of data, just leave the MCU set to zeroes.
1091  * This way, we return uniform gray for the remainder of the segment.
1092  */
1093  if (! entropy->insufficient_data) {
1094 
1095  natural_order = cinfo->natural_order;
1096  Se = cinfo->lim_Se;
1097 
1098  /* Load up working state */
1099  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
1100  ASSIGN_STATE(state, entropy->saved);
1101 
1102  /* Outer loop handles each block in the MCU */
1103 
1104  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
1105  JBLOCKROW block = MCU_data[blkn];
1106  d_derived_tbl * htbl;
1107  register int s, k, r;
1108  int coef_limit, ci;
1109 
1110  /* Decode a single block's worth of coefficients */
1111 
1112  /* Section F.2.2.1: decode the DC coefficient difference */
1113  htbl = entropy->dc_cur_tbls[blkn];
1114  HUFF_DECODE(s, br_state, htbl, return FALSE, label1);
1115 
1116  htbl = entropy->ac_cur_tbls[blkn];
1117  k = 1;
1118  coef_limit = entropy->coef_limit[blkn];
1119  if (coef_limit) {
1120  /* Convert DC difference to actual value, update last_dc_val */
1121  if (s) {
1122  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1123  r = GET_BITS(s);
1124  s = HUFF_EXTEND(r, s);
1125  }
1126  ci = cinfo->MCU_membership[blkn];
1127  s += state.last_dc_val[ci];
1128  state.last_dc_val[ci] = s;
1129  /* Output the DC coefficient */
1130  (*block)[0] = (JCOEF) s;
1131 
1132  /* Section F.2.2.2: decode the AC coefficients */
1133  /* Since zeroes are skipped, output area must be cleared beforehand */
1134  for (; k < coef_limit; k++) {
1135  HUFF_DECODE(s, br_state, htbl, return FALSE, label2);
1136 
1137  r = s >> 4;
1138  s &= 15;
1139 
1140  if (s) {
1141  k += r;
1142  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1143  r = GET_BITS(s);
1144  s = HUFF_EXTEND(r, s);
1145  /* Output coefficient in natural (dezigzagged) order.
1146  * Note: the extra entries in natural_order[] will save us
1147  * if k > Se, which could happen if the data is corrupted.
1148  */
1149  (*block)[natural_order[k]] = (JCOEF) s;
1150  } else {
1151  if (r != 15)
1152  goto EndOfBlock;
1153  k += 15;
1154  }
1155  }
1156  } else {
1157  if (s) {
1158  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1159  DROP_BITS(s);
1160  }
1161  }
1162 
1163  /* Section F.2.2.2: decode the AC coefficients */
1164  /* In this path we just discard the values */
1165  for (; k <= Se; k++) {
1166  HUFF_DECODE(s, br_state, htbl, return FALSE, label3);
1167 
1168  r = s >> 4;
1169  s &= 15;
1170 
1171  if (s) {
1172  k += r;
1173  CHECK_BIT_BUFFER(br_state, s, return FALSE);
1174  DROP_BITS(s);
1175  } else {
1176  if (r != 15)
1177  break;
1178  k += 15;
1179  }
1180  }
1181 
1182  EndOfBlock: ;
1183  }
1184 
1185  /* Completed MCU, so update state */
1186  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
1187  ASSIGN_STATE(entropy->saved, state);
1188  }
1189 
1190  /* Account for restart interval if using restarts */
1191  if (cinfo->restart_interval)
1192  entropy->restarts_to_go--;
1193 
1194  return TRUE;
1195 }
static unsigned int block
Definition: xmlmemory.c:118
#define TRUE
Definition: types.h:120
#define HUFF_EXTEND(x, s)
Definition: jdhuff.c:577
static const WCHAR label2[]
Definition: itemdlg.c:1547
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
short JCOEF
Definition: jmorecfg.h:151
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
#define DROP_BITS(nbits)
Definition: jdhuff.c:147
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
static int state
Definition: maze.c:121
GLdouble s
Definition: gl.h:2039
#define ASSIGN_STATE(dest, src)
Definition: jdhuff.c:209
const int * natural_order
Definition: jpeglib.h:666
process_restart(j_decompress_ptr cinfo)
Definition: jdhuff.c:651
#define HUFF_DECODE(result, state, htbl, failaction, slowlabel)
Definition: jdhuff.c:168
#define BITREAD_SAVE_STATE(cinfop, permstate)
Definition: jdhuff.c:111
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
#define GET_BITS(nbits)
Definition: jdhuff.c:141
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369
#define BITREAD_LOAD_STATE(cinfop, permstate)
Definition: jdhuff.c:104
#define BITREAD_STATE_VARS
Definition: jdhuff.c:99

Referenced by start_pass_huff_decoder().

◆ finish_pass_huff()

finish_pass_huff ( j_decompress_ptr  cinfo)

Definition at line 634 of file jdhuff.c.

635 {
636  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
637 
638  /* Throw away any unused bits remaining in bit buffer; */
639  /* include any full bytes in next_marker's count of discarded bytes */
640  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
641  entropy->bitstate.bits_left = 0;
642 }
struct jpeg_marker_reader * marker
Definition: jpeglib.h:683
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684

Referenced by jinit_huff_decoder(), and process_restart().

◆ jinit_huff_decoder()

jinit_huff_decoder ( j_decompress_ptr  cinfo)

Definition at line 1527 of file jdhuff.c.

1528 {
1529  huff_entropy_ptr entropy;
1530  int i;
1531 
1532  entropy = (huff_entropy_ptr) (*cinfo->mem->alloc_small)
1534  cinfo->entropy = &entropy->pub;
1535  entropy->pub.start_pass = start_pass_huff_decoder;
1536  entropy->pub.finish_pass = finish_pass_huff;
1537 
1538  if (cinfo->progressive_mode) {
1539  /* Create progression status table */
1540  int *coef_bit_ptr, ci;
1541  cinfo->coef_bits = (int (*)[DCTSIZE2]) (*cinfo->mem->alloc_small)
1542  ((j_common_ptr) cinfo, JPOOL_IMAGE,
1543  cinfo->num_components * DCTSIZE2 * SIZEOF(int));
1544  coef_bit_ptr = & cinfo->coef_bits[0][0];
1545  for (ci = 0; ci < cinfo->num_components; ci++)
1546  for (i = 0; i < DCTSIZE2; i++)
1547  *coef_bit_ptr++ = -1;
1548 
1549  /* Mark derived tables unallocated */
1550  for (i = 0; i < NUM_HUFF_TBLS; i++) {
1551  entropy->derived_tbls[i] = NULL;
1552  }
1553  } else {
1554  /* Mark derived tables unallocated */
1555  for (i = 0; i < NUM_HUFF_TBLS; i++) {
1556  entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
1557  }
1558  }
1559 }
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define NUM_HUFF_TBLS
Definition: jpeglib.h:53
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
finish_pass_huff(j_decompress_ptr cinfo)
Definition: jdhuff.c:634
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]
Definition: jchuff.c:92
smooth NULL
Definition: ftsmooth.c:416
#define DCTSIZE2
Definition: jpeglib.h:51
struct jpeg_entropy_encoder pub
Definition: jchuff.c:82
start_pass_huff_decoder(j_decompress_ptr cinfo)
Definition: jdhuff.c:1328
boolean progressive_mode
Definition: jpeglib.h:587
int(* coef_bits)[DCTSIZE2]
Definition: jpeglib.h:559
c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]
Definition: jchuff.c:91
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by master_selection(), and transdecode_master_selection().

◆ jpeg_fill_bit_buffer()

jpeg_fill_bit_buffer ( bitread_working_state state,
register bit_buf_type  get_buffer,
register int  bits_left,
int  nbits 
)

Definition at line 464 of file jdhuff.c.

468 {
469  /* Copy heavily used state fields into locals (hopefully registers) */
470  register const JOCTET * next_input_byte = state->next_input_byte;
471  register size_t bytes_in_buffer = state->bytes_in_buffer;
472  j_decompress_ptr cinfo = state->cinfo;
473 
474  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
475  /* (It is assumed that no request will be for more than that many bits.) */
476  /* We fail to do so only if we hit a marker or are forced to suspend. */
477 
478  if (cinfo->unread_marker == 0) { /* cannot advance past a marker */
479  while (bits_left < MIN_GET_BITS) {
480  register int c;
481 
482  /* Attempt to read a byte */
483  if (bytes_in_buffer == 0) {
484  if (! (*cinfo->src->fill_input_buffer) (cinfo))
485  return FALSE;
486  next_input_byte = cinfo->src->next_input_byte;
487  bytes_in_buffer = cinfo->src->bytes_in_buffer;
488  }
489  bytes_in_buffer--;
490  c = GETJOCTET(*next_input_byte++);
491 
492  /* If it's 0xFF, check and discard stuffed zero byte */
493  if (c == 0xFF) {
494  /* Loop here to discard any padding FF's on terminating marker,
495  * so that we can save a valid unread_marker value. NOTE: we will
496  * accept multiple FF's followed by a 0 as meaning a single FF data
497  * byte. This data pattern is not valid according to the standard.
498  */
499  do {
500  if (bytes_in_buffer == 0) {
501  if (! (*cinfo->src->fill_input_buffer) (cinfo))
502  return FALSE;
503  next_input_byte = cinfo->src->next_input_byte;
504  bytes_in_buffer = cinfo->src->bytes_in_buffer;
505  }
506  bytes_in_buffer--;
507  c = GETJOCTET(*next_input_byte++);
508  } while (c == 0xFF);
509 
510  if (c == 0) {
511  /* Found FF/00, which represents an FF data byte */
512  c = 0xFF;
513  } else {
514  /* Oops, it's actually a marker indicating end of compressed data.
515  * Save the marker code for later use.
516  * Fine point: it might appear that we should save the marker into
517  * bitread working state, not straight into permanent state. But
518  * once we have hit a marker, we cannot need to suspend within the
519  * current MCU, because we will read no more bytes from the data
520  * source. So it is OK to update permanent state right away.
521  */
522  cinfo->unread_marker = c;
523  /* See if we need to insert some fake zero bits. */
524  goto no_more_bytes;
525  }
526  }
527 
528  /* OK, load c into get_buffer */
529  get_buffer = (get_buffer << 8) | c;
530  bits_left += 8;
531  } /* end while */
532  } else {
533  no_more_bytes:
534  /* We get here if we've read the marker that terminates the compressed
535  * data segment. There should be enough bits in the buffer register
536  * to satisfy the request; if so, no problem.
537  */
538  if (nbits > bits_left) {
539  /* Uh-oh. Report corrupted data to user and stuff zeroes into
540  * the data stream, so that we can produce some kind of image.
541  * We use a nonvolatile flag to ensure that only one warning message
542  * appears per data segment.
543  */
544  if (! ((huff_entropy_ptr) cinfo->entropy)->insufficient_data) {
545  WARNMS(cinfo, JWRN_HIT_MARKER);
546  ((huff_entropy_ptr) cinfo->entropy)->insufficient_data = TRUE;
547  }
548  /* Fill the buffer with zero bits */
549  get_buffer <<= MIN_GET_BITS - bits_left;
550  bits_left = MIN_GET_BITS;
551  }
552  }
553 
554  /* Unload the local registers */
555  state->next_input_byte = next_input_byte;
556  state->bytes_in_buffer = bytes_in_buffer;
557  state->get_buffer = get_buffer;
558  state->bits_left = bits_left;
559 
560  return TRUE;
561 }
#define TRUE
Definition: types.h:120
#define MIN_GET_BITS
Definition: jdhuff.c:459
#define GETJOCTET(value)
Definition: jmorecfg.h:171
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
const GLubyte * c
Definition: glext.h:8905
#define WARNMS(cinfo, code)
Definition: jerror.h:251
static int state
Definition: maze.c:121
struct jpeg_source_mgr * src
Definition: jpeglib.h:463
#define c
Definition: ke_i.h:80
NTSTATUS get_buffer(LPWSTR *buffer, SIZE_T needed, PUNICODE_STRING CallerBuffer, BOOLEAN bAllocateBuffer)
Definition: libsupp.c:688
char JOCTET
Definition: jmorecfg.h:167
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684

◆ jpeg_huff_decode()

jpeg_huff_decode ( bitread_working_state state,
register bit_buf_type  get_buffer,
register int  bits_left,
d_derived_tbl htbl,
int  min_bits 
)

Definition at line 591 of file jdhuff.c.

594 {
595  register int l = min_bits;
596  register INT32 code;
597 
598  /* HUFF_DECODE has determined that the code is at least min_bits */
599  /* bits long, so fetch that many bits in one swoop. */
600 
601  CHECK_BIT_BUFFER(*state, l, return -1);
602  code = GET_BITS(l);
603 
604  /* Collect the rest of the Huffman code one bit at a time. */
605  /* This is per Figure F.16 in the JPEG spec. */
606 
607  while (code > htbl->maxcode[l]) {
608  code <<= 1;
609  CHECK_BIT_BUFFER(*state, 1, return -1);
610  code |= GET_BITS(1);
611  l++;
612  }
613 
614  /* Unload the local registers */
615  state->get_buffer = get_buffer;
616  state->bits_left = bits_left;
617 
618  /* With garbage input we may reach the sentinel value l = 17. */
619 
620  if (l > 16) {
621  WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
622  return 0; /* fake a zero as the safest result */
623  }
624 
625  return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
626 }
INT32 valoffset[17]
Definition: jdhuff.c:32
UINT8 huffval[256]
Definition: jpeglib.h:113
#define CHECK_BIT_BUFFER(state, nbits, action)
Definition: jdhuff.c:135
r l[0]
Definition: byte_order.h:167
#define WARNMS(cinfo, code)
Definition: jerror.h:251
INT32 maxcode[18]
Definition: jdhuff.c:30
static int state
Definition: maze.c:121
int code
Definition: i386-dis.c:3591
#define GET_BITS(nbits)
Definition: jdhuff.c:141
NTSTATUS get_buffer(LPWSTR *buffer, SIZE_T needed, PUNICODE_STRING CallerBuffer, BOOLEAN bAllocateBuffer)
Definition: libsupp.c:688
signed int INT32
JHUFF_TBL * pub
Definition: jdhuff.c:39
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

◆ jpeg_make_d_derived_tbl()

jpeg_make_d_derived_tbl ( j_decompress_ptr  cinfo,
boolean  isDC,
int  tblno,
d_derived_tbl **  pdtbl 
)

Definition at line 323 of file jdhuff.c.

325 {
326  JHUFF_TBL *htbl;
327  d_derived_tbl *dtbl;
328  int p, i, l, si, numsymbols;
329  int lookbits, ctr;
330  char huffsize[257];
331  unsigned int huffcode[257];
332  unsigned int code;
333 
334  /* Note that huffsize[] and huffcode[] are filled in code-length order,
335  * paralleling the order of the symbols themselves in htbl->huffval[].
336  */
337 
338  /* Find the input Huffman table */
339  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
340  ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
341  htbl =
342  isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
343  if (htbl == NULL)
344  htbl = jpeg_std_huff_table((j_common_ptr) cinfo, isDC, tblno);
345 
346  /* Allocate a workspace if we haven't already done so. */
347  if (*pdtbl == NULL)
348  *pdtbl = (d_derived_tbl *) (*cinfo->mem->alloc_small)
350  dtbl = *pdtbl;
351  dtbl->pub = htbl; /* fill in back link */
352 
353  /* Figure C.1: make table of Huffman code length for each symbol */
354 
355  p = 0;
356  for (l = 1; l <= 16; l++) {
357  i = (int) htbl->bits[l];
358  if (i < 0 || p + i > 256) /* protect against table overrun */
359  ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
360  while (i--)
361  huffsize[p++] = (char) l;
362  }
363  huffsize[p] = 0;
364  numsymbols = p;
365 
366  /* Figure C.2: generate the codes themselves */
367  /* We also validate that the counts represent a legal Huffman code tree. */
368 
369  code = 0;
370  si = huffsize[0];
371  p = 0;
372  while (huffsize[p]) {
373  while (((int) huffsize[p]) == si) {
374  huffcode[p++] = code;
375  code++;
376  }
377  /* code is now 1 more than the last code used for codelength si; but
378  * it must still fit in si bits, since no code is allowed to be all ones.
379  */
380  if (((INT32) code) >= (((INT32) 1) << si))
381  ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
382  code <<= 1;
383  si++;
384  }
385 
386  /* Figure F.15: generate decoding tables for bit-sequential decoding */
387 
388  p = 0;
389  for (l = 1; l <= 16; l++) {
390  if (htbl->bits[l]) {
391  /* valoffset[l] = huffval[] index of 1st symbol of code length l,
392  * minus the minimum code of length l
393  */
394  dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
395  p += htbl->bits[l];
396  dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
397  } else {
398  dtbl->maxcode[l] = -1; /* -1 if no codes of this length */
399  }
400  }
401  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
402 
403  /* Compute lookahead tables to speed up decoding.
404  * First we set all the table entries to 0, indicating "too long";
405  * then we iterate through the Huffman codes that are short enough and
406  * fill in all the entries that correspond to bit sequences starting
407  * with that code.
408  */
409 
410  MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
411 
412  p = 0;
413  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
414  for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
415  /* l = current code's length, p = its index in huffcode[] & huffval[]. */
416  /* Generate left-justified code followed by all possible bit sequences */
417  lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
418  for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
419  dtbl->look_nbits[lookbits] = l;
420  dtbl->look_sym[lookbits] = htbl->huffval[p];
421  lookbits++;
422  }
423  }
424  }
425 
426  /* Validate symbols as being reasonable.
427  * For AC tables, we make no check, but accept all byte values 0..255.
428  * For DC tables, we require the symbols to be in range 0..15.
429  * (Tighter bounds could be applied depending on the data depth and mode,
430  * but this is sufficient to ensure safe decoding.)
431  */
432  if (isDC) {
433  for (i = 0; i < numsymbols; i++) {
434  int sym = htbl->huffval[i];
435  if (sym < 0 || sym > 15)
436  ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
437  }
438  }
439 }
UINT8 look_sym[1<< HUFF_LOOKAHEAD]
Definition: jdhuff.c:47
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
INT32 valoffset[17]
Definition: jdhuff.c:32
UINT8 huffval[256]
Definition: jpeglib.h:113
int look_nbits[1<< HUFF_LOOKAHEAD]
Definition: jdhuff.c:46
JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]
Definition: jpeglib.h:573
boolean int tblno
Definition: jpeglib.h:1010
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define NUM_HUFF_TBLS
Definition: jpeglib.h:53
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324
#define HUFF_LOOKAHEAD
Definition: jdhuff.c:26
UINT8 bits[17]
Definition: jpeglib.h:111
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
r l[0]
Definition: byte_order.h:167
jpeg_std_huff_table(j_common_ptr cinfo, boolean isDC, int tblno)
Definition: jcomapi.c:117
if(!(yy_init))
Definition: macro.lex.yy.c:714
INT32 maxcode[18]
Definition: jdhuff.c:30
boolean isDC
Definition: jpeglib.h:1010
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]
Definition: jpeglib.h:574
int code
Definition: i386-dis.c:3591
signed int INT32
JHUFF_TBL * pub
Definition: jdhuff.c:39
GLfloat GLfloat p
Definition: glext.h:8902
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by start_pass_huff_decoder().

◆ process_restart()

process_restart ( j_decompress_ptr  cinfo)

Definition at line 651 of file jdhuff.c.

652 {
653  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
654  int ci;
655 
656  finish_pass_huff(cinfo);
657 
658  /* Advance past the RSTn marker */
659  if (! (*cinfo->marker->read_restart_marker) (cinfo))
660  return FALSE;
661 
662  /* Re-initialize DC predictions to 0 */
663  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
664  entropy->saved.last_dc_val[ci] = 0;
665  /* Re-init EOB run count, too */
666  entropy->saved.EOBRUN = 0;
667 
668  /* Reset restart counter */
669  entropy->restarts_to_go = cinfo->restart_interval;
670 
671  /* Reset out-of-data flag, unless read_restart_marker left us smack up
672  * against a marker. In that case we will end up treating the next data
673  * segment as empty, and we can avoid producing bogus output pixels by
674  * leaving the flag set.
675  */
676  if (cinfo->unread_marker == 0)
677  entropy->insufficient_data = FALSE;
678 
679  return TRUE;
680 }
#define TRUE
Definition: types.h:120
struct jpeg_marker_reader * marker
Definition: jpeglib.h:683
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
finish_pass_huff(j_decompress_ptr cinfo)
Definition: jdhuff.c:634
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
unsigned int EOBRUN
Definition: jdhuff.c:199
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jchuff.c:58
unsigned int restarts_to_go
Definition: jchuff.c:87
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684

Referenced by decode_mcu(), decode_mcu_AC_first(), decode_mcu_AC_refine(), decode_mcu_DC_first(), decode_mcu_DC_refine(), and decode_mcu_sub().

◆ start_pass_huff_decoder()

start_pass_huff_decoder ( j_decompress_ptr  cinfo)

Definition at line 1328 of file jdhuff.c.

1329 {
1330  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
1331  int ci, blkn, tbl, i;
1333 
1334  if (cinfo->progressive_mode) {
1335  /* Validate progressive scan parameters */
1336  if (cinfo->Ss == 0) {
1337  if (cinfo->Se != 0)
1338  goto bad;
1339  } else {
1340  /* need not check Ss/Se < 0 since they came from unsigned bytes */
1341  if (cinfo->Se < cinfo->Ss || cinfo->Se > cinfo->lim_Se)
1342  goto bad;
1343  /* AC scans may have only one component */
1344  if (cinfo->comps_in_scan != 1)
1345  goto bad;
1346  }
1347  if (cinfo->Ah != 0) {
1348  /* Successive approximation refinement scan: must have Al = Ah-1. */
1349  if (cinfo->Ah-1 != cinfo->Al)
1350  goto bad;
1351  }
1352  if (cinfo->Al > 13) { /* need not check for < 0 */
1353  /* Arguably the maximum Al value should be less than 13 for 8-bit
1354  * precision, but the spec doesn't say so, and we try to be liberal
1355  * about what we accept. Note: large Al values could result in
1356  * out-of-range DC coefficients during early scans, leading to bizarre
1357  * displays due to overflows in the IDCT math. But we won't crash.
1358  */
1359  bad:
1360  ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
1361  cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
1362  }
1363  /* Update progression status, and verify that scan order is legal.
1364  * Note that inter-scan inconsistencies are treated as warnings
1365  * not fatal errors ... not clear if this is right way to behave.
1366  */
1367  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1368  int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
1369  int *coef_bit_ptr = & cinfo->coef_bits[cindex][0];
1370  if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
1371  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
1372  for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
1373  int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
1374  if (cinfo->Ah != expected)
1375  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
1376  coef_bit_ptr[coefi] = cinfo->Al;
1377  }
1378  }
1379 
1380  /* Select MCU decoding routine */
1381  if (cinfo->Ah == 0) {
1382  if (cinfo->Ss == 0)
1383  entropy->pub.decode_mcu = decode_mcu_DC_first;
1384  else
1385  entropy->pub.decode_mcu = decode_mcu_AC_first;
1386  } else {
1387  if (cinfo->Ss == 0)
1388  entropy->pub.decode_mcu = decode_mcu_DC_refine;
1389  else
1390  entropy->pub.decode_mcu = decode_mcu_AC_refine;
1391  }
1392 
1393  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1394  compptr = cinfo->cur_comp_info[ci];
1395  /* Make sure requested tables are present, and compute derived tables.
1396  * We may build same derived table more than once, but it's not expensive.
1397  */
1398  if (cinfo->Ss == 0) {
1399  if (cinfo->Ah == 0) { /* DC refinement needs no table */
1400  tbl = compptr->dc_tbl_no;
1401  jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
1402  & entropy->derived_tbls[tbl]);
1403  }
1404  } else {
1405  tbl = compptr->ac_tbl_no;
1406  jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
1407  & entropy->derived_tbls[tbl]);
1408  /* remember the single active table */
1409  entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
1410  }
1411  /* Initialize DC predictions to 0 */
1412  entropy->saved.last_dc_val[ci] = 0;
1413  }
1414 
1415  /* Initialize private state variables */
1416  entropy->saved.EOBRUN = 0;
1417  } else {
1418  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
1419  * This ought to be an error condition, but we make it a warning because
1420  * there are some baseline files out there with all zeroes in these bytes.
1421  */
1422  if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 ||
1423  ((cinfo->is_baseline || cinfo->Se < DCTSIZE2) &&
1424  cinfo->Se != cinfo->lim_Se))
1425  WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
1426 
1427  /* Select MCU decoding routine */
1428  /* We retain the hard-coded case for full-size blocks.
1429  * This is not necessary, but it appears that this version is slightly
1430  * more performant in the given implementation.
1431  * With an improved implementation we would prefer a single optimized
1432  * function.
1433  */
1434  if (cinfo->lim_Se != DCTSIZE2-1)
1435  entropy->pub.decode_mcu = decode_mcu_sub;
1436  else
1437  entropy->pub.decode_mcu = decode_mcu;
1438 
1439  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1440  compptr = cinfo->cur_comp_info[ci];
1441  /* Compute derived values for Huffman tables */
1442  /* We may do this more than once for a table, but it's not expensive */
1443  tbl = compptr->dc_tbl_no;
1444  jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
1445  & entropy->dc_derived_tbls[tbl]);
1446  if (cinfo->lim_Se) { /* AC needs no table when not present */
1447  tbl = compptr->ac_tbl_no;
1448  jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
1449  & entropy->ac_derived_tbls[tbl]);
1450  }
1451  /* Initialize DC predictions to 0 */
1452  entropy->saved.last_dc_val[ci] = 0;
1453  }
1454 
1455  /* Precalculate decoding info for each block in an MCU of this scan */
1456  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
1457  ci = cinfo->MCU_membership[blkn];
1458  compptr = cinfo->cur_comp_info[ci];
1459  /* Precalculate which table to use for each block */
1460  entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
1461  entropy->ac_cur_tbls[blkn] = /* AC needs no table when not present */
1462  cinfo->lim_Se ? entropy->ac_derived_tbls[compptr->ac_tbl_no] : NULL;
1463  /* Decide whether we really care about the coefficient values */
1464  if (compptr->component_needed) {
1465  ci = compptr->DCT_v_scaled_size;
1467  switch (cinfo->lim_Se) {
1468  case (1*1-1):
1469  entropy->coef_limit[blkn] = 1;
1470  break;
1471  case (2*2-1):
1472  if (ci <= 0 || ci > 2) ci = 2;
1473  if (i <= 0 || i > 2) i = 2;
1474  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order2[ci - 1][i - 1];
1475  break;
1476  case (3*3-1):
1477  if (ci <= 0 || ci > 3) ci = 3;
1478  if (i <= 0 || i > 3) i = 3;
1479  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order3[ci - 1][i - 1];
1480  break;
1481  case (4*4-1):
1482  if (ci <= 0 || ci > 4) ci = 4;
1483  if (i <= 0 || i > 4) i = 4;
1484  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order4[ci - 1][i - 1];
1485  break;
1486  case (5*5-1):
1487  if (ci <= 0 || ci > 5) ci = 5;
1488  if (i <= 0 || i > 5) i = 5;
1489  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order5[ci - 1][i - 1];
1490  break;
1491  case (6*6-1):
1492  if (ci <= 0 || ci > 6) ci = 6;
1493  if (i <= 0 || i > 6) i = 6;
1494  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order6[ci - 1][i - 1];
1495  break;
1496  case (7*7-1):
1497  if (ci <= 0 || ci > 7) ci = 7;
1498  if (i <= 0 || i > 7) i = 7;
1499  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order7[ci - 1][i - 1];
1500  break;
1501  default:
1502  if (ci <= 0 || ci > 8) ci = 8;
1503  if (i <= 0 || i > 8) i = 8;
1504  entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order[ci - 1][i - 1];
1505  }
1506  } else {
1507  entropy->coef_limit[blkn] = 0;
1508  }
1509  }
1510  }
1511 
1512  /* Initialize bitread state variables */
1513  entropy->bitstate.bits_left = 0;
1514  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
1515  entropy->insufficient_data = FALSE;
1516 
1517  /* Initialize restart counter */
1518  entropy->restarts_to_go = cinfo->restart_interval;
1519 }
#define TRUE
Definition: types.h:120
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
savable_state saved
Definition: jchuff.c:84
huff_entropy_decoder * huff_entropy_ptr
Definition: jdhuff.c:257
boolean component_needed
Definition: jpeglib.h:174
decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdhuff.c:707
jpeg_component_info * compptr
Definition: jdct.h:238
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define WARNMS2(cinfo, code, p1, p2)
Definition: jerror.h:258
static const int jpeg_zigzag_order4[4][4]
Definition: jdhuff.c:298
decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdhuff.c:867
c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]
Definition: jchuff.c:92
#define ERREXIT4(cinfo, code, p1, p2, p3, p4)
Definition: jerror.h:227
static const int jpeg_zigzag_order3[3][3]
Definition: jdhuff.c:305
smooth NULL
Definition: ftsmooth.c:416
jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno, d_derived_tbl **pdtbl)
Definition: jdhuff.c:323
static const int jpeg_zigzag_order7[7][7]
Definition: jdhuff.c:271
#define DCTSIZE2
Definition: jpeglib.h:51
unsigned int restart_interval
Definition: jpeglib.h:594
decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdhuff.c:1204
if(!(yy_init))
Definition: macro.lex.yy.c:714
struct jpeg_entropy_encoder pub
Definition: jchuff.c:82
decode_mcu_sub(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdhuff.c:1075
static const int jpeg_zigzag_order2[2][2]
Definition: jdhuff.c:311
#define WARNMS(cinfo, code)
Definition: jerror.h:251
static const int jpeg_zigzag_order6[6][6]
Definition: jdhuff.c:281
decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdhuff.c:916
static const int jpeg_zigzag_order[8][8]
Definition: jdhuff.c:260
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
unsigned int EOBRUN
Definition: jdhuff.c:199
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jchuff.c:58
boolean progressive_mode
Definition: jpeglib.h:587
static const int jpeg_zigzag_order5[5][5]
Definition: jdhuff.c:290
unsigned int restarts_to_go
Definition: jchuff.c:87
int(* coef_bits)[DCTSIZE2]
Definition: jpeglib.h:559
c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]
Definition: jchuff.c:91
decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdhuff.c:779
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
BOOL expected
Definition: store.c:2063

Referenced by jinit_huff_decoder().

Variable Documentation

◆ bmask

const int bmask[16]
static
Initial value:
=
{ 0, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF,
0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF }

Definition at line 579 of file jdhuff.c.

◆ jpeg_zigzag_order

const int jpeg_zigzag_order[8][8]
static
Initial value:
= {
{ 0, 1, 5, 6, 14, 15, 27, 28 },
{ 2, 4, 7, 13, 16, 26, 29, 42 },
{ 3, 8, 12, 17, 25, 30, 41, 43 },
{ 9, 11, 18, 24, 31, 40, 44, 53 },
{ 10, 19, 23, 32, 39, 45, 52, 54 },
{ 20, 22, 33, 38, 46, 51, 55, 60 },
{ 21, 34, 37, 47, 50, 56, 59, 61 },
{ 35, 36, 48, 49, 57, 58, 62, 63 }
}

Definition at line 260 of file jdhuff.c.

Referenced by start_pass_huff_decoder().

◆ jpeg_zigzag_order2

const int jpeg_zigzag_order2[2][2]
static
Initial value:
= {
{ 0, 1 },
{ 2, 3 }
}

Definition at line 311 of file jdhuff.c.

Referenced by start_pass_huff_decoder().

◆ jpeg_zigzag_order3

const int jpeg_zigzag_order3[3][3]
static
Initial value:
= {
{ 0, 1, 5 },
{ 2, 4, 6 },
{ 3, 7, 8 }
}

Definition at line 305 of file jdhuff.c.

Referenced by start_pass_huff_decoder().

◆ jpeg_zigzag_order4

const int jpeg_zigzag_order4[4][4]
static
Initial value:
= {
{ 0, 1, 5, 6 },
{ 2, 4, 7, 12 },
{ 3, 8, 11, 13 },
{ 9, 10, 14, 15 }
}

Definition at line 298 of file jdhuff.c.

Referenced by start_pass_huff_decoder().

◆ jpeg_zigzag_order5

const int jpeg_zigzag_order5[5][5]
static
Initial value:
= {
{ 0, 1, 5, 6, 14 },
{ 2, 4, 7, 13, 15 },
{ 3, 8, 12, 16, 21 },
{ 9, 11, 17, 20, 22 },
{ 10, 18, 19, 23, 24 }
}

Definition at line 290 of file jdhuff.c.

Referenced by start_pass_huff_decoder().

◆ jpeg_zigzag_order6

const int jpeg_zigzag_order6[6][6]
static
Initial value:
= {
{ 0, 1, 5, 6, 14, 15 },
{ 2, 4, 7, 13, 16, 25 },
{ 3, 8, 12, 17, 24, 26 },
{ 9, 11, 18, 23, 27, 32 },
{ 10, 19, 22, 28, 31, 33 },
{ 20, 21, 29, 30, 34, 35 }
}

Definition at line 281 of file jdhuff.c.

Referenced by start_pass_huff_decoder().

◆ jpeg_zigzag_order7

const int jpeg_zigzag_order7[7][7]
static
Initial value:
= {
{ 0, 1, 5, 6, 14, 15, 27 },
{ 2, 4, 7, 13, 16, 26, 28 },
{ 3, 8, 12, 17, 25, 29, 38 },
{ 9, 11, 18, 24, 30, 37, 39 },
{ 10, 19, 23, 31, 36, 40, 45 },
{ 20, 22, 32, 35, 41, 44, 46 },
{ 21, 33, 34, 42, 43, 47, 48 }
}

Definition at line 271 of file jdhuff.c.

Referenced by start_pass_huff_decoder().