ReactOS  0.4.15-dev-509-g96a357b
jdarith.c File Reference
#include "jinclude.h"
#include "jpeglib.h"
Include dependency graph for jdarith.c:

Go to the source code of this file.

Classes

struct  arith_entropy_decoder
 

Macros

#define JPEG_INTERNALS
 
#define DC_STAT_BINS   64
 
#define AC_STAT_BINS   256
 

Typedefs

typedef arith_entropy_decoderarith_entropy_ptr
 

Functions

 get_byte (j_decompress_ptr cinfo)
 
 arith_decode (j_decompress_ptr cinfo, unsigned char *st)
 
 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 (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
 start_pass (j_decompress_ptr cinfo)
 
 finish_pass (j_decompress_ptr cinfo)
 
 jinit_arith_decoder (j_decompress_ptr cinfo)
 

Macro Definition Documentation

◆ AC_STAT_BINS

#define AC_STAT_BINS   256

Definition at line 61 of file jdarith.c.

◆ DC_STAT_BINS

#define DC_STAT_BINS   64

Definition at line 60 of file jdarith.c.

◆ JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 16 of file jdarith.c.

Typedef Documentation

◆ arith_entropy_ptr

Definition at line 45 of file jdarith.c.

Function Documentation

◆ arith_decode()

arith_decode ( j_decompress_ptr  cinfo,
unsigned char st 
)

Definition at line 106 of file jdarith.c.

107 {
108  register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
109  register unsigned char nl, nm;
110  register INT32 qe, temp;
111  register int sv, data;
112 
113  /* Renormalization & data input per section D.2.6 */
114  while (e->a < 0x8000L) {
115  if (--e->ct < 0) {
116  /* Need to fetch next data byte */
117  if (cinfo->unread_marker)
118  data = 0; /* stuff zero data */
119  else {
120  data = get_byte(cinfo); /* read next input byte */
121  if (data == 0xFF) { /* zero stuff or marker code */
122  do data = get_byte(cinfo);
123  while (data == 0xFF); /* swallow extra 0xFF bytes */
124  if (data == 0)
125  data = 0xFF; /* discard stuffed zero byte */
126  else {
127  /* Note: Different from the Huffman decoder, hitting
128  * a marker while processing the compressed data
129  * segment is legal in arithmetic coding.
130  * The convention is to supply zero data
131  * then until decoding is complete.
132  */
133  cinfo->unread_marker = data;
134  data = 0;
135  }
136  }
137  }
138  e->c = (e->c << 8) | data; /* insert data into C register */
139  if ((e->ct += 8) < 0) /* update bit shift counter */
140  /* Need more initial bytes */
141  if (++e->ct == 0)
142  /* Got 2 initial bytes -> re-init A and exit loop */
143  e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */
144  }
145  e->a <<= 1;
146  }
147 
148  /* Fetch values from our compact representation of Table D.3(D.2):
149  * Qe values and probability estimation state machine
150  */
151  sv = *st;
152  qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */
153  nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */
154  nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */
155 
156  /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
157  temp = e->a - qe;
158  e->a = temp;
159  temp <<= e->ct;
160  if (e->c >= temp) {
161  e->c -= temp;
162  /* Conditional LPS (less probable symbol) exchange */
163  if (e->a < qe) {
164  e->a = qe;
165  *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */
166  } else {
167  e->a = qe;
168  *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */
169  sv ^= 0x80; /* Exchange LPS/MPS */
170  }
171  } else if (e->a < 0x8000L) {
172  /* Conditional MPS (more probable symbol) exchange */
173  if (e->a < qe) {
174  *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */
175  sv ^= 0x80; /* Exchange LPS/MPS */
176  } else {
177  *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */
178  }
179  }
180 
181  return sv >> 7;
182 }
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
while(1)
Definition: macro.lex.yy.c:740
#define e
Definition: ke_i.h:82
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static const WCHAR L[]
Definition: oid.c:1250
static calc_node_t temp
Definition: rpn_ieee.c:38
get_byte(j_decompress_ptr cinfo)
Definition: jdarith.c:65
signed int INT32
const INT32 jpeg_aritab[113+1]
Definition: jaricom.c:31
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(), and decode_mcu_DC_refine().

◆ decode_mcu()

decode_mcu ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 512 of file jdarith.c.

513 {
514  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
517  unsigned char *st;
518  int blkn, ci, tbl, sign, k;
519  int v, m;
520  const int * natural_order;
521 
522  /* Process restart marker if needed */
523  if (cinfo->restart_interval) {
524  if (entropy->restarts_to_go == 0)
525  process_restart(cinfo);
526  entropy->restarts_to_go--;
527  }
528 
529  if (entropy->ct == -1) return TRUE; /* if error do nothing */
530 
531  natural_order = cinfo->natural_order;
532 
533  /* Outer loop handles each block in the MCU */
534 
535  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
536  block = MCU_data[blkn];
537  ci = cinfo->MCU_membership[blkn];
538  compptr = cinfo->cur_comp_info[ci];
539 
540  /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
541 
542  tbl = compptr->dc_tbl_no;
543 
544  /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
545  st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
546 
547  /* Figure F.19: Decode_DC_DIFF */
548  if (arith_decode(cinfo, st) == 0)
549  entropy->dc_context[ci] = 0;
550  else {
551  /* Figure F.21: Decoding nonzero value v */
552  /* Figure F.22: Decoding the sign of v */
553  sign = arith_decode(cinfo, st + 1);
554  st += 2; st += sign;
555  /* Figure F.23: Decoding the magnitude category of v */
556  if ((m = arith_decode(cinfo, st)) != 0) {
557  st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
558  while (arith_decode(cinfo, st)) {
559  if ((m <<= 1) == (int) 0x8000U) {
560  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
561  entropy->ct = -1; /* magnitude overflow */
562  return TRUE;
563  }
564  st += 1;
565  }
566  }
567  /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
568  if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
569  entropy->dc_context[ci] = 0; /* zero diff category */
570  else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
571  entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
572  else
573  entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */
574  v = m;
575  /* Figure F.24: Decoding the magnitude bit pattern of v */
576  st += 14;
577  while (m >>= 1)
578  if (arith_decode(cinfo, st)) v |= m;
579  v += 1; if (sign) v = -v;
580  entropy->last_dc_val[ci] += v;
581  }
582 
583  (*block)[0] = (JCOEF) entropy->last_dc_val[ci];
584 
585  /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
586 
587  if (cinfo->lim_Se == 0) continue;
588  tbl = compptr->ac_tbl_no;
589  k = 0;
590 
591  /* Figure F.20: Decode_AC_coefficients */
592  do {
593  st = entropy->ac_stats[tbl] + 3 * k;
594  if (arith_decode(cinfo, st)) break; /* EOB flag */
595  for (;;) {
596  k++;
597  if (arith_decode(cinfo, st + 1)) break;
598  st += 3;
599  if (k >= cinfo->lim_Se) {
600  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
601  entropy->ct = -1; /* spectral overflow */
602  return TRUE;
603  }
604  }
605  /* Figure F.21: Decoding nonzero value v */
606  /* Figure F.22: Decoding the sign of v */
607  sign = arith_decode(cinfo, entropy->fixed_bin);
608  st += 2;
609  /* Figure F.23: Decoding the magnitude category of v */
610  if ((m = arith_decode(cinfo, st)) != 0) {
611  if (arith_decode(cinfo, st)) {
612  m <<= 1;
613  st = entropy->ac_stats[tbl] +
614  (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
615  while (arith_decode(cinfo, st)) {
616  if ((m <<= 1) == (int) 0x8000U) {
617  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
618  entropy->ct = -1; /* magnitude overflow */
619  return TRUE;
620  }
621  st += 1;
622  }
623  }
624  }
625  v = m;
626  /* Figure F.24: Decoding the magnitude bit pattern of v */
627  st += 14;
628  while (m >>= 1)
629  if (arith_decode(cinfo, st)) v |= m;
630  v += 1; if (sign) v = -v;
631  (*block)[natural_order[k]] = (JCOEF) v;
632  } while (k < cinfo->lim_Se);
633  }
634 
635  return TRUE;
636 }
static unsigned int block
Definition: xmlmemory.c:118
static size_t double int int int * sign
Definition: printf.c:69
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
#define TRUE
Definition: types.h:120
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
UINT8 arith_dc_U[NUM_ARITH_TBLS]
Definition: jpeglib.h:591
unsigned char fixed_bin[4]
Definition: jcarith.c:45
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
short JCOEF
Definition: jmorecfg.h:151
const GLfloat * m
Definition: glext.h:10848
jpeg_component_info * compptr
Definition: jdct.h:238
UINT8 arith_dc_L[NUM_ARITH_TBLS]
Definition: jpeglib.h:590
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
UINT8 arith_ac_K[NUM_ARITH_TBLS]
Definition: jpeglib.h:592
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
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
unsigned int restarts_to_go
Definition: jcarith.c:37
static const WCHAR L[]
Definition: oid.c:1250
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:34
const int * natural_order
Definition: jpeglib.h:666
const GLdouble * v
Definition: gl.h:2040
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
int dc_context[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:35
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by start_pass().

◆ decode_mcu_AC_first()

decode_mcu_AC_first ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 321 of file jdarith.c.

322 {
323  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
325  unsigned char *st;
326  int tbl, sign, k;
327  int v, m;
328  const int * natural_order;
329 
330  /* Process restart marker if needed */
331  if (cinfo->restart_interval) {
332  if (entropy->restarts_to_go == 0)
333  process_restart(cinfo);
334  entropy->restarts_to_go--;
335  }
336 
337  if (entropy->ct == -1) return TRUE; /* if error do nothing */
338 
339  natural_order = cinfo->natural_order;
340 
341  /* There is always only one block per MCU */
342  block = MCU_data[0];
343  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
344 
345  /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
346 
347  /* Figure F.20: Decode_AC_coefficients */
348  k = cinfo->Ss - 1;
349  do {
350  st = entropy->ac_stats[tbl] + 3 * k;
351  if (arith_decode(cinfo, st)) break; /* EOB flag */
352  for (;;) {
353  k++;
354  if (arith_decode(cinfo, st + 1)) break;
355  st += 3;
356  if (k >= cinfo->Se) {
357  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
358  entropy->ct = -1; /* spectral overflow */
359  return TRUE;
360  }
361  }
362  /* Figure F.21: Decoding nonzero value v */
363  /* Figure F.22: Decoding the sign of v */
364  sign = arith_decode(cinfo, entropy->fixed_bin);
365  st += 2;
366  /* Figure F.23: Decoding the magnitude category of v */
367  if ((m = arith_decode(cinfo, st)) != 0) {
368  if (arith_decode(cinfo, st)) {
369  m <<= 1;
370  st = entropy->ac_stats[tbl] +
371  (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
372  while (arith_decode(cinfo, st)) {
373  if ((m <<= 1) == (int) 0x8000U) {
374  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
375  entropy->ct = -1; /* magnitude overflow */
376  return TRUE;
377  }
378  st += 1;
379  }
380  }
381  }
382  v = m;
383  /* Figure F.24: Decoding the magnitude bit pattern of v */
384  st += 14;
385  while (m >>= 1)
386  if (arith_decode(cinfo, st)) v |= m;
387  v += 1; if (sign) v = -v;
388  /* Scale and output coefficient in natural (dezigzagged) order */
389  (*block)[natural_order[k]] = (JCOEF) (v << cinfo->Al);
390  } while (k < cinfo->Se);
391 
392  return TRUE;
393 }
static unsigned int block
Definition: xmlmemory.c:118
static size_t double int int int * sign
Definition: printf.c:69
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
#define TRUE
Definition: types.h:120
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
unsigned char fixed_bin[4]
Definition: jcarith.c:45
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
short JCOEF
Definition: jmorecfg.h:151
const GLfloat * m
Definition: glext.h:10848
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
UINT8 arith_ac_K[NUM_ARITH_TBLS]
Definition: jpeglib.h:592
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
unsigned int restarts_to_go
Definition: jcarith.c:37
const int * natural_order
Definition: jpeglib.h:666
const GLdouble * v
Definition: gl.h:2040
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by start_pass().

◆ decode_mcu_AC_refine()

decode_mcu_AC_refine ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 437 of file jdarith.c.

438 {
439  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
441  JCOEFPTR thiscoef;
442  unsigned char *st;
443  int tbl, k, kex;
444  JCOEF p1, m1;
445  const int * natural_order;
446 
447  /* Process restart marker if needed */
448  if (cinfo->restart_interval) {
449  if (entropy->restarts_to_go == 0)
450  process_restart(cinfo);
451  entropy->restarts_to_go--;
452  }
453 
454  if (entropy->ct == -1) return TRUE; /* if error do nothing */
455 
456  natural_order = cinfo->natural_order;
457 
458  /* There is always only one block per MCU */
459  block = MCU_data[0];
460  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
461 
462  p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
463  m1 = -p1; /* -1 in the bit position being coded */
464 
465  /* Establish EOBx (previous stage end-of-block) index */
466  kex = cinfo->Se;
467  do {
468  if ((*block)[natural_order[kex]]) break;
469  } while (--kex);
470 
471  k = cinfo->Ss - 1;
472  do {
473  st = entropy->ac_stats[tbl] + 3 * k;
474  if (k >= kex)
475  if (arith_decode(cinfo, st)) break; /* EOB flag */
476  for (;;) {
477  thiscoef = *block + natural_order[++k];
478  if (*thiscoef) { /* previously nonzero coef */
479  if (arith_decode(cinfo, st + 2)) {
480  if (*thiscoef < 0)
481  *thiscoef += m1;
482  else
483  *thiscoef += p1;
484  }
485  break;
486  }
487  if (arith_decode(cinfo, st + 1)) { /* newly nonzero coef */
488  if (arith_decode(cinfo, entropy->fixed_bin))
489  *thiscoef = m1;
490  else
491  *thiscoef = p1;
492  break;
493  }
494  st += 3;
495  if (k >= cinfo->Se) {
496  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
497  entropy->ct = -1; /* spectral overflow */
498  return TRUE;
499  }
500  }
501  } while (k < cinfo->Se);
502 
503  return TRUE;
504 }
static unsigned int block
Definition: xmlmemory.c:118
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
#define TRUE
Definition: types.h:120
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
unsigned char fixed_bin[4]
Definition: jcarith.c:45
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
short JCOEF
Definition: jmorecfg.h:151
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
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
unsigned int restarts_to_go
Definition: jcarith.c:37
const int * natural_order
Definition: jpeglib.h:666
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
int k
Definition: mpi.c:3369

Referenced by start_pass().

◆ decode_mcu_DC_first()

decode_mcu_DC_first ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 242 of file jdarith.c.

243 {
244  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
246  unsigned char *st;
247  int blkn, ci, tbl, sign;
248  int v, m;
249 
250  /* Process restart marker if needed */
251  if (cinfo->restart_interval) {
252  if (entropy->restarts_to_go == 0)
253  process_restart(cinfo);
254  entropy->restarts_to_go--;
255  }
256 
257  if (entropy->ct == -1) return TRUE; /* if error do nothing */
258 
259  /* Outer loop handles each block in the MCU */
260 
261  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
262  block = MCU_data[blkn];
263  ci = cinfo->MCU_membership[blkn];
264  tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
265 
266  /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
267 
268  /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
269  st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
270 
271  /* Figure F.19: Decode_DC_DIFF */
272  if (arith_decode(cinfo, st) == 0)
273  entropy->dc_context[ci] = 0;
274  else {
275  /* Figure F.21: Decoding nonzero value v */
276  /* Figure F.22: Decoding the sign of v */
277  sign = arith_decode(cinfo, st + 1);
278  st += 2; st += sign;
279  /* Figure F.23: Decoding the magnitude category of v */
280  if ((m = arith_decode(cinfo, st)) != 0) {
281  st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
282  while (arith_decode(cinfo, st)) {
283  if ((m <<= 1) == (int) 0x8000U) {
284  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
285  entropy->ct = -1; /* magnitude overflow */
286  return TRUE;
287  }
288  st += 1;
289  }
290  }
291  /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
292  if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
293  entropy->dc_context[ci] = 0; /* zero diff category */
294  else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
295  entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
296  else
297  entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */
298  v = m;
299  /* Figure F.24: Decoding the magnitude bit pattern of v */
300  st += 14;
301  while (m >>= 1)
302  if (arith_decode(cinfo, st)) v |= m;
303  v += 1; if (sign) v = -v;
304  entropy->last_dc_val[ci] += v;
305  }
306 
307  /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
308  (*block)[0] = (JCOEF) (entropy->last_dc_val[ci] << cinfo->Al);
309  }
310 
311  return TRUE;
312 }
static unsigned int block
Definition: xmlmemory.c:118
static size_t double int int int * sign
Definition: printf.c:69
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
#define TRUE
Definition: types.h:120
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
UINT8 arith_dc_U[NUM_ARITH_TBLS]
Definition: jpeglib.h:591
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
short JCOEF
Definition: jmorecfg.h:151
const GLfloat * m
Definition: glext.h:10848
UINT8 arith_dc_L[NUM_ARITH_TBLS]
Definition: jpeglib.h:590
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
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
unsigned int restarts_to_go
Definition: jcarith.c:37
static const WCHAR L[]
Definition: oid.c:1250
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:34
const GLdouble * v
Definition: gl.h:2040
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
int dc_context[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:35
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684

Referenced by start_pass().

◆ decode_mcu_DC_refine()

decode_mcu_DC_refine ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 403 of file jdarith.c.

404 {
405  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
406  unsigned char *st;
407  JCOEF p1;
408  int blkn;
409 
410  /* Process restart marker if needed */
411  if (cinfo->restart_interval) {
412  if (entropy->restarts_to_go == 0)
413  process_restart(cinfo);
414  entropy->restarts_to_go--;
415  }
416 
417  st = entropy->fixed_bin; /* use fixed probability estimation */
418  p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
419 
420  /* Outer loop handles each block in the MCU */
421 
422  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
423  /* Encoded data is simply the next bit of the two's-complement DC value */
424  if (arith_decode(cinfo, st))
425  MCU_data[blkn][0][0] |= p1;
426  }
427 
428  return TRUE;
429 }
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
#define TRUE
Definition: types.h:120
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
unsigned char fixed_bin[4]
Definition: jcarith.c:45
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
short JCOEF
Definition: jmorecfg.h:151
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
unsigned int restarts_to_go
Definition: jcarith.c:37
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684

Referenced by start_pass().

◆ finish_pass()

finish_pass ( j_decompress_ptr  cinfo)

Definition at line 754 of file jdarith.c.

755 {
756  /* no work necessary here */
757 }

Referenced by jinit_arith_decoder().

◆ get_byte()

get_byte ( j_decompress_ptr  cinfo)

Definition at line 65 of file jdarith.c.

67 {
68  struct jpeg_source_mgr * src = cinfo->src;
69 
70  if (src->bytes_in_buffer == 0)
71  if (! (*src->fill_input_buffer) (cinfo))
72  ERREXIT(cinfo, JERR_CANT_SUSPEND);
73  src->bytes_in_buffer--;
74  return GETJOCTET(*src->next_input_byte++);
75 }
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define GETJOCTET(value)
Definition: jmorecfg.h:171
GLenum src
Definition: glext.h:6340
struct jpeg_source_mgr * src
Definition: jpeglib.h:463

Referenced by arith_decode().

◆ jinit_arith_decoder()

jinit_arith_decoder ( j_decompress_ptr  cinfo)

Definition at line 765 of file jdarith.c.

766 {
767  arith_entropy_ptr entropy;
768  int i;
769 
770  entropy = (arith_entropy_ptr) (*cinfo->mem->alloc_small)
772  cinfo->entropy = &entropy->pub;
773  entropy->pub.start_pass = start_pass;
774  entropy->pub.finish_pass = finish_pass;
775 
776  /* Mark tables unallocated */
777  for (i = 0; i < NUM_ARITH_TBLS; i++) {
778  entropy->dc_stats[i] = NULL;
779  entropy->ac_stats[i] = NULL;
780  }
781 
782  /* Initialize index for fixed probability estimation */
783  entropy->fixed_bin[0] = 113;
784 
785  if (cinfo->progressive_mode) {
786  /* Create progression status table */
787  int *coef_bit_ptr, ci;
788  cinfo->coef_bits = (int (*)[DCTSIZE2]) (*cinfo->mem->alloc_small)
789  ((j_common_ptr) cinfo, JPOOL_IMAGE,
790  cinfo->num_components * DCTSIZE2 * SIZEOF(int));
791  coef_bit_ptr = & cinfo->coef_bits[0][0];
792  for (ci = 0; ci < cinfo->num_components; ci++)
793  for (i = 0; i < DCTSIZE2; i++)
794  *coef_bit_ptr++ = -1;
795  }
796 }
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
unsigned char fixed_bin[4]
Definition: jcarith.c:45
struct jpeg_entropy_encoder pub
Definition: jcarith.c:24
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
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
finish_pass(j_decompress_ptr cinfo)
Definition: jdarith.c:754
#define JPOOL_IMAGE
Definition: jpeglib.h:808
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
smooth NULL
Definition: ftsmooth.c:416
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
#define DCTSIZE2
Definition: jpeglib.h:51
start_pass(j_decompress_ptr cinfo)
Definition: jdarith.c:644
boolean progressive_mode
Definition: jpeglib.h:587
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
int(* coef_bits)[DCTSIZE2]
Definition: jpeglib.h:559
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().

◆ process_restart()

process_restart ( j_decompress_ptr  cinfo)

Definition at line 190 of file jdarith.c.

191 {
192  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
193  int ci;
195 
196  /* Advance past the RSTn marker */
197  if (! (*cinfo->marker->read_restart_marker) (cinfo))
198  ERREXIT(cinfo, JERR_CANT_SUSPEND);
199 
200  /* Re-initialize statistics areas */
201  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
202  compptr = cinfo->cur_comp_info[ci];
203  if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
205  /* Reset DC predictions to 0 */
206  entropy->last_dc_val[ci] = 0;
207  entropy->dc_context[ci] = 0;
208  }
209  if ((! cinfo->progressive_mode && cinfo->lim_Se) ||
210  (cinfo->progressive_mode && cinfo->Ss)) {
212  }
213  }
214 
215  /* Reset arithmetic decoding variables */
216  entropy->c = 0;
217  entropy->a = 0;
218  entropy->ct = -16; /* force reading 2 initial bytes to fill C */
219 
220  /* Reset restart counter */
221  entropy->restarts_to_go = cinfo->restart_interval;
222 }
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
struct jpeg_marker_reader * marker
Definition: jpeglib.h:683
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
jpeg_component_info * compptr
Definition: jdct.h:238
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
unsigned int restarts_to_go
Definition: jcarith.c:37
#define DC_STAT_BINS
Definition: jdarith.c:60
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:34
int dc_context[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:35
boolean progressive_mode
Definition: jpeglib.h:587
#define AC_STAT_BINS
Definition: jdarith.c:61
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(), and decode_mcu_DC_refine().

◆ start_pass()

start_pass ( j_decompress_ptr  cinfo)

Definition at line 644 of file jdarith.c.

645 {
646  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
647  int ci, tbl;
649 
650  if (cinfo->progressive_mode) {
651  /* Validate progressive scan parameters */
652  if (cinfo->Ss == 0) {
653  if (cinfo->Se != 0)
654  goto bad;
655  } else {
656  /* need not check Ss/Se < 0 since they came from unsigned bytes */
657  if (cinfo->Se < cinfo->Ss || cinfo->Se > cinfo->lim_Se)
658  goto bad;
659  /* AC scans may have only one component */
660  if (cinfo->comps_in_scan != 1)
661  goto bad;
662  }
663  if (cinfo->Ah != 0) {
664  /* Successive approximation refinement scan: must have Al = Ah-1. */
665  if (cinfo->Ah-1 != cinfo->Al)
666  goto bad;
667  }
668  if (cinfo->Al > 13) { /* need not check for < 0 */
669  bad:
670  ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
671  cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
672  }
673  /* Update progression status, and verify that scan order is legal.
674  * Note that inter-scan inconsistencies are treated as warnings
675  * not fatal errors ... not clear if this is right way to behave.
676  */
677  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
678  int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
679  int *coef_bit_ptr = & cinfo->coef_bits[cindex][0];
680  if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
681  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
682  for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
683  int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
684  if (cinfo->Ah != expected)
685  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
686  coef_bit_ptr[coefi] = cinfo->Al;
687  }
688  }
689  /* Select MCU decoding routine */
690  if (cinfo->Ah == 0) {
691  if (cinfo->Ss == 0)
692  entropy->pub.decode_mcu = decode_mcu_DC_first;
693  else
694  entropy->pub.decode_mcu = decode_mcu_AC_first;
695  } else {
696  if (cinfo->Ss == 0)
697  entropy->pub.decode_mcu = decode_mcu_DC_refine;
698  else
699  entropy->pub.decode_mcu = decode_mcu_AC_refine;
700  }
701  } else {
702  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
703  * This ought to be an error condition, but we make it a warning.
704  */
705  if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 ||
706  (cinfo->Se < DCTSIZE2 && cinfo->Se != cinfo->lim_Se))
707  WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
708  /* Select MCU decoding routine */
709  entropy->pub.decode_mcu = decode_mcu;
710  }
711 
712  /* Allocate & initialize requested statistics areas */
713  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
714  compptr = cinfo->cur_comp_info[ci];
715  if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
716  tbl = compptr->dc_tbl_no;
717  if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
718  ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
719  if (entropy->dc_stats[tbl] == NULL)
720  entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
722  MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
723  /* Initialize DC predictions to 0 */
724  entropy->last_dc_val[ci] = 0;
725  entropy->dc_context[ci] = 0;
726  }
727  if ((! cinfo->progressive_mode && cinfo->lim_Se) ||
728  (cinfo->progressive_mode && cinfo->Ss)) {
729  tbl = compptr->ac_tbl_no;
730  if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
731  ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
732  if (entropy->ac_stats[tbl] == NULL)
733  entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
735  MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
736  }
737  }
738 
739  /* Initialize arithmetic decoding variables */
740  entropy->c = 0;
741  entropy->a = 0;
742  entropy->ct = -16; /* force reading 2 initial bytes to fill C */
743 
744  /* Initialize restart counter */
745  entropy->restarts_to_go = cinfo->restart_interval;
746 }
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:321
decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:403
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
struct jpeg_entropy_encoder pub
Definition: jcarith.c:24
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
jpeg_component_info * compptr
Definition: jdct.h:238
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define WARNMS2(cinfo, code, p1, p2)
Definition: jerror.h:258
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
#define ERREXIT4(cinfo, code, p1, p2, p3, p4)
Definition: jerror.h:227
smooth NULL
Definition: ftsmooth.c:416
decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:437
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
#define DCTSIZE2
Definition: jpeglib.h:51
unsigned int restart_interval
Definition: jpeglib.h:594
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define WARNMS(cinfo, code)
Definition: jerror.h:251
decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:242
unsigned int restarts_to_go
Definition: jcarith.c:37
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
#define DC_STAT_BINS
Definition: jdarith.c:60
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:34
int dc_context[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:35
boolean progressive_mode
Definition: jpeglib.h:587
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
#define AC_STAT_BINS
Definition: jdarith.c:61
int(* coef_bits)[DCTSIZE2]
Definition: jpeglib.h:559
struct jpeg_entropy_decoder * entropy
Definition: jpeglib.h:684
decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:512
BOOL expected
Definition: store.c:2063

Referenced by jinit_arith_decoder().