ReactOS 0.4.16-dev-91-g764881a
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}
signed int INT32
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define get_byte()
Definition: iccvid.c:89
const INT32 jpeg_aritab[113+1]
Definition: jaricom.c:31
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
#define e
Definition: ke_i.h:82
static calc_node_t temp
Definition: rpn_ieee.c:38
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{
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}
#define TRUE
Definition: types.h:120
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
const GLdouble * v
Definition: gl.h:2040
const GLfloat * m
Definition: glext.h:10848
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
jpeg_component_info * compptr
Definition: jdct.h:238
#define WARNMS(cinfo, code)
Definition: jerror.h:251
short JCOEF
Definition: jmorecfg.h:151
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
if(dx< 0)
Definition: linetemp.h:194
#define sign(x)
Definition: mapdesc.cc:613
int k
Definition: mpi.c:3369
unsigned char fixed_bin[4]
Definition: jcarith.c:45
int dc_context[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:35
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:34
unsigned int restarts_to_go
Definition: jcarith.c:37
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
const int * natural_order
Definition: jpeglib.h:666
UINT8 arith_dc_L[NUM_ARITH_TBLS]
Definition: jpeglib.h:590
unsigned int restart_interval
Definition: jpeglib.h:594
UINT8 arith_ac_K[NUM_ARITH_TBLS]
Definition: jpeglib.h:592
jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:650
int MCU_membership[D_MAX_BLOCKS_IN_MCU]
Definition: jpeglib.h:657
UINT8 arith_dc_U[NUM_ARITH_TBLS]
Definition: jpeglib.h:591
static unsigned int block
Definition: xmlmemory.c:101

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{
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}

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{
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}
JCOEF FAR * JCOEFPTR
Definition: jpeglib.h:84

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{
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}

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{
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}

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}
GLenum src
Definition: glext.h:6340
#define GETJOCTET(value)
Definition: jmorecfg.h:171
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
struct jpeg_source_mgr * src
Definition: jpeglib.h:463

◆ 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}
#define SIZEOF(_ar)
Definition: calc.h:97
#define NULL
Definition: types.h:112
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
start_pass(j_decompress_ptr cinfo)
Definition: jdarith.c:644
finish_pass(j_decompress_ptr cinfo)
Definition: jdarith.c:754
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define DCTSIZE2
Definition: jpeglib.h:51
struct jpeg_entropy_encoder pub
Definition: jcarith.c:24
int(* coef_bits)[DCTSIZE2]
Definition: jpeglib.h:559
boolean progressive_mode
Definition: jpeglib.h:587

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{
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 AC_STAT_BINS
Definition: jdarith.c:61
#define DC_STAT_BINS
Definition: jdarith.c:60
struct jpeg_marker_reader * marker
Definition: jpeglib.h:683
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324

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{
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}
decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:403
decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:512
decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:437
decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:321
decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:242
#define WARNMS2(cinfo, code, p1, p2)
Definition: jerror.h:258
#define ERREXIT4(cinfo, code, p1, p2, p3, p4)
Definition: jerror.h:227
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
BOOL expected
Definition: store.c:2063

Referenced by jinit_arith_decoder().