Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(424)

Side by Side Diff: jcarith.c

Issue 1953443002: Update to libjpeg_turbo 1.4.90 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/libjpeg_turbo.git@master
Patch Set: Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « jcapistd.c ('k') | jccoefct.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * jcarith.c 2 * jcarith.c
3 * 3 *
4 * This file was part of the Independent JPEG Group's software:
4 * Developed 1997-2009 by Guido Vollbeding. 5 * Developed 1997-2009 by Guido Vollbeding.
5 * This file is part of the Independent JPEG Group's software. 6 * libjpeg-turbo Modifications:
6 * For conditions of distribution and use, see the accompanying README file. 7 * Copyright (C) 2015, D. R. Commander.
8 * For conditions of distribution and use, see the accompanying README.ijg
9 * file.
7 * 10 *
8 * This file contains portable arithmetic entropy encoding routines for JPEG 11 * This file contains portable arithmetic entropy encoding routines for JPEG
9 * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81). 12 * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81).
10 * 13 *
11 * Both sequential and progressive modes are supported in this single module. 14 * Both sequential and progressive modes are supported in this single module.
12 * 15 *
13 * Suspension is not currently supported in this module. 16 * Suspension is not currently supported in this module.
14 */ 17 */
15 18
16 #define JPEG_INTERNALS 19 #define JPEG_INTERNALS
17 #include "jinclude.h" 20 #include "jinclude.h"
18 #include "jpeglib.h" 21 #include "jpeglib.h"
19 22
20 23
21 /* Expanded entropy encoder object for arithmetic encoding. */ 24 /* Expanded entropy encoder object for arithmetic encoding. */
22 25
23 typedef struct { 26 typedef struct {
24 struct jpeg_entropy_encoder pub; /* public fields */ 27 struct jpeg_entropy_encoder pub; /* public fields */
25 28
26 INT32 c; /* C register, base of coding interval, layout as in sec. D.1.3 */ 29 JLONG c; /* C register, base of coding interval, layout as in sec. D.1.3 */
27 INT32 a; /* A register, normalized size of coding interval */ 30 JLONG a; /* A register, normalized size of coding interval */
28 INT32 sc; /* counter for stacked 0xFF values which might overflow */ 31 JLONG sc; /* counter for stacked 0xFF values which might overflow */
29 INT32 zc; /* counter for pending 0x00 output values which might * 32 JLONG zc; /* counter for pending 0x00 output values which might *
30 * be discarded at the end ("Pacman" termination) */ 33 * be discarded at the end ("Pacman" termination) */
31 int ct; /* bit shift counter, determines when next byte will be written */ 34 int ct; /* bit shift counter, determines when next byte will be written */
32 int buffer; /* buffer for most recent output byte != 0xFF */ 35 int buffer; /* buffer for most recent output byte != 0xFF */
33 36
34 int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ 37 int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
35 int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */ 38 int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
36 39
37 unsigned int restarts_to_go;» /* MCUs left in this restart interval */ 40 unsigned int restarts_to_go; /* MCUs left in this restart interval */
38 int next_restart_num;»» /* next restart number to write (0-7) */ 41 int next_restart_num; /* next restart number to write (0-7) */
39 42
40 /* Pointers to statistics areas (these workspaces have image lifespan) */ 43 /* Pointers to statistics areas (these workspaces have image lifespan) */
41 unsigned char * dc_stats[NUM_ARITH_TBLS]; 44 unsigned char *dc_stats[NUM_ARITH_TBLS];
42 unsigned char * ac_stats[NUM_ARITH_TBLS]; 45 unsigned char *ac_stats[NUM_ARITH_TBLS];
43 46
44 /* Statistics bin for coding with fixed probability 0.5 */ 47 /* Statistics bin for coding with fixed probability 0.5 */
45 unsigned char fixed_bin[4]; 48 unsigned char fixed_bin[4];
46 } arith_entropy_encoder; 49 } arith_entropy_encoder;
47 50
48 typedef arith_entropy_encoder * arith_entropy_ptr; 51 typedef arith_entropy_encoder *arith_entropy_ptr;
49 52
50 /* The following two definitions specify the allocation chunk size 53 /* The following two definitions specify the allocation chunk size
51 * for the statistics area. 54 * for the statistics area.
52 * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least 55 * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
53 * 49 statistics bins for DC, and 245 statistics bins for AC coding. 56 * 49 statistics bins for DC, and 245 statistics bins for AC coding.
54 * 57 *
55 * We use a compact representation with 1 byte per statistics bin, 58 * We use a compact representation with 1 byte per statistics bin,
56 * thus the numbers directly represent byte sizes. 59 * thus the numbers directly represent byte sizes.
57 * This 1 byte per statistics bin contains the meaning of the MPS 60 * This 1 byte per statistics bin contains the meaning of the MPS
58 * (more probable symbol) in the highest bit (mask 0x80), and the 61 * (more probable symbol) in the highest bit (mask 0x80), and the
(...skipping 29 matching lines...) Expand all
88 * that the conditioning has no significant influence on the 91 * that the conditioning has no significant influence on the
89 * compression performance. This means that the basic 92 * compression performance. This means that the basic
90 * statistical model is already rather stable. 93 * statistical model is already rather stable.
91 * 94 *
92 * Thus, at the moment, we use the default conditioning values 95 * Thus, at the moment, we use the default conditioning values
93 * anyway, and do not use the custom formula. 96 * anyway, and do not use the custom formula.
94 * 97 *
95 #define CALCULATE_SPECTRAL_CONDITIONING 98 #define CALCULATE_SPECTRAL_CONDITIONING
96 */ 99 */
97 100
98 /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32. 101 /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than JLONG.
99 * We assume that int right shift is unsigned if INT32 right shift is, 102 * We assume that int right shift is unsigned if JLONG right shift is,
100 * which should be safe. 103 * which should be safe.
101 */ 104 */
102 105
103 #ifdef RIGHT_SHIFT_IS_UNSIGNED 106 #ifdef RIGHT_SHIFT_IS_UNSIGNED
104 #define ISHIFT_TEMPS» int ishift_temp; 107 #define ISHIFT_TEMPS int ishift_temp;
105 #define IRIGHT_SHIFT(x,shft) \ 108 #define IRIGHT_SHIFT(x,shft) \
106 » ((ishift_temp = (x)) < 0 ? \ 109 ((ishift_temp = (x)) < 0 ? \
107 » (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \ 110 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
108 » (ishift_temp >> (shft))) 111 (ishift_temp >> (shft)))
109 #else 112 #else
110 #define ISHIFT_TEMPS 113 #define ISHIFT_TEMPS
111 #define IRIGHT_SHIFT(x,shft)» ((x) >> (shft)) 114 #define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
112 #endif 115 #endif
113 116
114 117
115 LOCAL(void) 118 LOCAL(void)
116 emit_byte (int val, j_compress_ptr cinfo) 119 emit_byte (int val, j_compress_ptr cinfo)
117 /* Write next output byte; we do not support suspension in this module. */ 120 /* Write next output byte; we do not support suspension in this module. */
118 { 121 {
119 struct jpeg_destination_mgr * dest = cinfo->dest; 122 struct jpeg_destination_mgr *dest = cinfo->dest;
120 123
121 *dest->next_output_byte++ = (JOCTET) val; 124 *dest->next_output_byte++ = (JOCTET) val;
122 if (--dest->free_in_buffer == 0) 125 if (--dest->free_in_buffer == 0)
123 if (! (*dest->empty_output_buffer) (cinfo)) 126 if (! (*dest->empty_output_buffer) (cinfo))
124 ERREXIT(cinfo, JERR_CANT_SUSPEND); 127 ERREXIT(cinfo, JERR_CANT_SUSPEND);
125 } 128 }
126 129
127 130
128 /* 131 /*
129 * Finish up at the end of an arithmetic-compressed scan. 132 * Finish up at the end of an arithmetic-compressed scan.
130 */ 133 */
131 134
132 METHODDEF(void) 135 METHODDEF(void)
133 finish_pass (j_compress_ptr cinfo) 136 finish_pass (j_compress_ptr cinfo)
134 { 137 {
135 arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; 138 arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
136 INT32 temp; 139 JLONG temp;
137 140
138 /* Section D.1.8: Termination of encoding */ 141 /* Section D.1.8: Termination of encoding */
139 142
140 /* Find the e->c in the coding interval with the largest 143 /* Find the e->c in the coding interval with the largest
141 * number of trailing zero bits */ 144 * number of trailing zero bits */
142 if ((temp = (e->a - 1 + e->c) & 0xFFFF0000L) < e->c) 145 if ((temp = (e->a - 1 + e->c) & 0xFFFF0000L) < e->c)
143 e->c = temp + 0x8000L; 146 e->c = temp + 0x8000L;
144 else 147 else
145 e->c = temp; 148 e->c = temp;
146 /* Send remaining bytes to output */ 149 /* Send remaining bytes to output */
147 e->c <<= e->ct; 150 e->c <<= e->ct;
148 if (e->c & 0xF8000000L) { 151 if (e->c & 0xF8000000L) {
149 /* One final overflow has to be handled */ 152 /* One final overflow has to be handled */
150 if (e->buffer >= 0) { 153 if (e->buffer >= 0) {
151 if (e->zc) 154 if (e->zc)
152 » do emit_byte(0x00, cinfo); 155 do emit_byte(0x00, cinfo);
153 » while (--e->zc); 156 while (--e->zc);
154 emit_byte(e->buffer + 1, cinfo); 157 emit_byte(e->buffer + 1, cinfo);
155 if (e->buffer + 1 == 0xFF) 158 if (e->buffer + 1 == 0xFF)
156 » emit_byte(0x00, cinfo); 159 emit_byte(0x00, cinfo);
157 } 160 }
158 e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ 161 e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */
159 e->sc = 0; 162 e->sc = 0;
160 } else { 163 } else {
161 if (e->buffer == 0) 164 if (e->buffer == 0)
162 ++e->zc; 165 ++e->zc;
163 else if (e->buffer >= 0) { 166 else if (e->buffer >= 0) {
164 if (e->zc) 167 if (e->zc)
165 » do emit_byte(0x00, cinfo); 168 do emit_byte(0x00, cinfo);
166 » while (--e->zc); 169 while (--e->zc);
167 emit_byte(e->buffer, cinfo); 170 emit_byte(e->buffer, cinfo);
168 } 171 }
169 if (e->sc) { 172 if (e->sc) {
170 if (e->zc) 173 if (e->zc)
171 » do emit_byte(0x00, cinfo); 174 do emit_byte(0x00, cinfo);
172 » while (--e->zc); 175 while (--e->zc);
173 do { 176 do {
174 » emit_byte(0xFF, cinfo); 177 emit_byte(0xFF, cinfo);
175 » emit_byte(0x00, cinfo); 178 emit_byte(0x00, cinfo);
176 } while (--e->sc); 179 } while (--e->sc);
177 } 180 }
178 } 181 }
179 /* Output final bytes only if they are not 0x00 */ 182 /* Output final bytes only if they are not 0x00 */
180 if (e->c & 0x7FFF800L) { 183 if (e->c & 0x7FFF800L) {
181 if (e->zc) /* output final pending zero bytes */ 184 if (e->zc) /* output final pending zero bytes */
182 do emit_byte(0x00, cinfo); 185 do emit_byte(0x00, cinfo);
183 while (--e->zc); 186 while (--e->zc);
184 emit_byte((e->c >> 19) & 0xFF, cinfo); 187 emit_byte((e->c >> 19) & 0xFF, cinfo);
185 if (((e->c >> 19) & 0xFF) == 0xFF) 188 if (((e->c >> 19) & 0xFF) == 0xFF)
186 emit_byte(0x00, cinfo); 189 emit_byte(0x00, cinfo);
187 if (e->c & 0x7F800L) { 190 if (e->c & 0x7F800L) {
188 emit_byte((e->c >> 11) & 0xFF, cinfo); 191 emit_byte((e->c >> 11) & 0xFF, cinfo);
189 if (((e->c >> 11) & 0xFF) == 0xFF) 192 if (((e->c >> 11) & 0xFF) == 0xFF)
190 » emit_byte(0x00, cinfo); 193 emit_byte(0x00, cinfo);
191 } 194 }
192 } 195 }
193 } 196 }
194 197
195 198
196 /* 199 /*
197 * The core arithmetic encoding routine (common in JPEG and JBIG). 200 * The core arithmetic encoding routine (common in JPEG and JBIG).
198 * This needs to go as fast as possible. 201 * This needs to go as fast as possible.
199 * Machine-dependent optimization facilities 202 * Machine-dependent optimization facilities
200 * are not utilized in this portable implementation. 203 * are not utilized in this portable implementation.
201 * However, this code should be fairly efficient and 204 * However, this code should be fairly efficient and
202 * may be a good base for further optimizations anyway. 205 * may be a good base for further optimizations anyway.
203 * 206 *
204 * Parameter 'val' to be encoded may be 0 or 1 (binary decision). 207 * Parameter 'val' to be encoded may be 0 or 1 (binary decision).
205 * 208 *
206 * Note: I've added full "Pacman" termination support to the 209 * Note: I've added full "Pacman" termination support to the
207 * byte output routines, which is equivalent to the optional 210 * byte output routines, which is equivalent to the optional
208 * Discard_final_zeros procedure (Figure D.15) in the spec. 211 * Discard_final_zeros procedure (Figure D.15) in the spec.
209 * Thus, we always produce the shortest possible output 212 * Thus, we always produce the shortest possible output
210 * stream compliant to the spec (no trailing zero bytes, 213 * stream compliant to the spec (no trailing zero bytes,
211 * except for FF stuffing). 214 * except for FF stuffing).
212 * 215 *
213 * I've also introduced a new scheme for accessing 216 * I've also introduced a new scheme for accessing
214 * the probability estimation state machine table, 217 * the probability estimation state machine table,
215 * derived from Markus Kuhn's JBIG implementation. 218 * derived from Markus Kuhn's JBIG implementation.
216 */ 219 */
217 220
218 LOCAL(void) 221 LOCAL(void)
219 arith_encode (j_compress_ptr cinfo, unsigned char *st, int val) 222 arith_encode (j_compress_ptr cinfo, unsigned char *st, int val)
220 { 223 {
221 register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; 224 register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
222 register unsigned char nl, nm; 225 register unsigned char nl, nm;
223 register INT32 qe, temp; 226 register JLONG qe, temp;
224 register int sv; 227 register int sv;
225 228
226 /* Fetch values from our compact representation of Table D.2: 229 /* Fetch values from our compact representation of Table D.2:
227 * Qe values and probability estimation state machine 230 * Qe values and probability estimation state machine
228 */ 231 */
229 sv = *st; 232 sv = *st;
230 qe = jpeg_aritab[sv & 0x7F];» /* => Qe_Value */ 233 qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */
231 nl = qe & 0xFF; qe >>= 8;» /* Next_Index_LPS + Switch_MPS */ 234 nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */
232 nm = qe & 0xFF; qe >>= 8;» /* Next_Index_MPS */ 235 nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */
233 236
234 /* Encode & estimation procedures per sections D.1.4 & D.1.5 */ 237 /* Encode & estimation procedures per sections D.1.4 & D.1.5 */
235 e->a -= qe; 238 e->a -= qe;
236 if (val != (sv >> 7)) { 239 if (val != (sv >> 7)) {
237 /* Encode the less probable symbol */ 240 /* Encode the less probable symbol */
238 if (e->a >= qe) { 241 if (e->a >= qe) {
239 /* If the interval size (qe) for the less probable symbol (LPS) 242 /* If the interval size (qe) for the less probable symbol (LPS)
240 * is larger than the interval size for the MPS, then exchange 243 * is larger than the interval size for the MPS, then exchange
241 * the two symbols for coding efficiency, otherwise code the LPS 244 * the two symbols for coding efficiency, otherwise code the LPS
242 * as usual: */ 245 * as usual: */
243 e->c += e->a; 246 e->c += e->a;
244 e->a = qe; 247 e->a = qe;
245 } 248 }
246 *st = (sv & 0x80) ^ nl;» /* Estimate_after_LPS */ 249 *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */
247 } else { 250 } else {
248 /* Encode the more probable symbol */ 251 /* Encode the more probable symbol */
249 if (e->a >= 0x8000L) 252 if (e->a >= 0x8000L)
250 return; /* A >= 0x8000 -> ready, no renormalization required */ 253 return; /* A >= 0x8000 -> ready, no renormalization required */
251 if (e->a < qe) { 254 if (e->a < qe) {
252 /* If the interval size (qe) for the less probable symbol (LPS) 255 /* If the interval size (qe) for the less probable symbol (LPS)
253 * is larger than the interval size for the MPS, then exchange 256 * is larger than the interval size for the MPS, then exchange
254 * the two symbols for coding efficiency: */ 257 * the two symbols for coding efficiency: */
255 e->c += e->a; 258 e->c += e->a;
256 e->a = qe; 259 e->a = qe;
257 } 260 }
258 *st = (sv & 0x80) ^ nm;» /* Estimate_after_MPS */ 261 *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */
259 } 262 }
260 263
261 /* Renormalization & data output per section D.1.6 */ 264 /* Renormalization & data output per section D.1.6 */
262 do { 265 do {
263 e->a <<= 1; 266 e->a <<= 1;
264 e->c <<= 1; 267 e->c <<= 1;
265 if (--e->ct == 0) { 268 if (--e->ct == 0) {
266 /* Another byte is ready for output */ 269 /* Another byte is ready for output */
267 temp = e->c >> 19; 270 temp = e->c >> 19;
268 if (temp > 0xFF) { 271 if (temp > 0xFF) {
269 » /* Handle overflow over all stacked 0xFF bytes */ 272 /* Handle overflow over all stacked 0xFF bytes */
270 » if (e->buffer >= 0) { 273 if (e->buffer >= 0) {
271 » if (e->zc) 274 if (e->zc)
272 » do emit_byte(0x00, cinfo); 275 do emit_byte(0x00, cinfo);
273 » while (--e->zc); 276 while (--e->zc);
274 » emit_byte(e->buffer + 1, cinfo); 277 emit_byte(e->buffer + 1, cinfo);
275 » if (e->buffer + 1 == 0xFF) 278 if (e->buffer + 1 == 0xFF)
276 » emit_byte(0x00, cinfo); 279 emit_byte(0x00, cinfo);
277 » } 280 }
278 » e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ 281 e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */
279 » e->sc = 0; 282 e->sc = 0;
280 » /* Note: The 3 spacer bits in the C register guarantee 283 /* Note: The 3 spacer bits in the C register guarantee
281 » * that the new buffer byte can't be 0xFF here 284 * that the new buffer byte can't be 0xFF here
282 » * (see page 160 in the P&M JPEG book). */ 285 * (see page 160 in the P&M JPEG book). */
283 » e->buffer = temp & 0xFF; /* new output byte, might overflow later */ 286 e->buffer = temp & 0xFF; /* new output byte, might overflow later */
284 } else if (temp == 0xFF) { 287 } else if (temp == 0xFF) {
285 » ++e->sc; /* stack 0xFF byte (which might overflow later) */ 288 ++e->sc; /* stack 0xFF byte (which might overflow later) */
286 } else { 289 } else {
287 » /* Output all stacked 0xFF bytes, they will not overflow any more */ 290 /* Output all stacked 0xFF bytes, they will not overflow any more */
288 » if (e->buffer == 0) 291 if (e->buffer == 0)
289 » ++e->zc; 292 ++e->zc;
290 » else if (e->buffer >= 0) { 293 else if (e->buffer >= 0) {
291 » if (e->zc) 294 if (e->zc)
292 » do emit_byte(0x00, cinfo); 295 do emit_byte(0x00, cinfo);
293 » while (--e->zc); 296 while (--e->zc);
294 » emit_byte(e->buffer, cinfo); 297 emit_byte(e->buffer, cinfo);
295 » } 298 }
296 » if (e->sc) { 299 if (e->sc) {
297 » if (e->zc) 300 if (e->zc)
298 » do emit_byte(0x00, cinfo); 301 do emit_byte(0x00, cinfo);
299 » while (--e->zc); 302 while (--e->zc);
300 » do { 303 do {
301 » emit_byte(0xFF, cinfo); 304 emit_byte(0xFF, cinfo);
302 » emit_byte(0x00, cinfo); 305 emit_byte(0x00, cinfo);
303 » } while (--e->sc); 306 } while (--e->sc);
304 » } 307 }
305 » e->buffer = temp & 0xFF; /* new output byte (can still overflow) */ 308 e->buffer = temp & 0xFF; /* new output byte (can still overflow) */
306 } 309 }
307 e->c &= 0x7FFFFL; 310 e->c &= 0x7FFFFL;
308 e->ct += 8; 311 e->ct += 8;
309 } 312 }
310 } while (e->a < 0x8000L); 313 } while (e->a < 0x8000L);
311 } 314 }
312 315
313 316
314 /* 317 /*
315 * Emit a restart marker & resynchronize predictions. 318 * Emit a restart marker & resynchronize predictions.
316 */ 319 */
317 320
318 LOCAL(void) 321 LOCAL(void)
319 emit_restart (j_compress_ptr cinfo, int restart_num) 322 emit_restart (j_compress_ptr cinfo, int restart_num)
320 { 323 {
321 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 324 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
322 int ci; 325 int ci;
323 jpeg_component_info * compptr; 326 jpeg_component_info *compptr;
324 327
325 finish_pass(cinfo); 328 finish_pass(cinfo);
326 329
327 emit_byte(0xFF, cinfo); 330 emit_byte(0xFF, cinfo);
328 emit_byte(JPEG_RST0 + restart_num, cinfo); 331 emit_byte(JPEG_RST0 + restart_num, cinfo);
329 332
330 /* Re-initialize statistics areas */ 333 /* Re-initialize statistics areas */
331 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 334 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
332 compptr = cinfo->cur_comp_info[ci]; 335 compptr = cinfo->cur_comp_info[ci];
333 /* DC needs no table for refinement scan */ 336 /* DC needs no table for refinement scan */
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
391 m = IRIGHT_SHIFT((int) ((*block)[0]), cinfo->Al); 394 m = IRIGHT_SHIFT((int) ((*block)[0]), cinfo->Al);
392 395
393 /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ 396 /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
394 397
395 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ 398 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
396 st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; 399 st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
397 400
398 /* Figure F.4: Encode_DC_DIFF */ 401 /* Figure F.4: Encode_DC_DIFF */
399 if ((v = m - entropy->last_dc_val[ci]) == 0) { 402 if ((v = m - entropy->last_dc_val[ci]) == 0) {
400 arith_encode(cinfo, st, 0); 403 arith_encode(cinfo, st, 0);
401 entropy->dc_context[ci] = 0;» /* zero diff category */ 404 entropy->dc_context[ci] = 0; /* zero diff category */
402 } else { 405 } else {
403 entropy->last_dc_val[ci] = m; 406 entropy->last_dc_val[ci] = m;
404 arith_encode(cinfo, st, 1); 407 arith_encode(cinfo, st, 1);
405 /* Figure F.6: Encoding nonzero value v */ 408 /* Figure F.6: Encoding nonzero value v */
406 /* Figure F.7: Encoding the sign of v */ 409 /* Figure F.7: Encoding the sign of v */
407 if (v > 0) { 410 if (v > 0) {
408 » arith_encode(cinfo, st + 1, 0);»/* Table F.4: SS = S0 + 1 */ 411 arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */
409 » st += 2;» » » /* Table F.4: SP = S0 + 2 */ 412 st += 2; /* Table F.4: SP = S0 + 2 */
410 » entropy->dc_context[ci] = 4;» /* small positive diff category */ 413 entropy->dc_context[ci] = 4; /* small positive diff category */
411 } else { 414 } else {
412 » v = -v; 415 v = -v;
413 » arith_encode(cinfo, st + 1, 1);»/* Table F.4: SS = S0 + 1 */ 416 arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */
414 » st += 3;» » » /* Table F.4: SN = S0 + 3 */ 417 st += 3; /* Table F.4: SN = S0 + 3 */
415 » entropy->dc_context[ci] = 8;» /* small negative diff category */ 418 entropy->dc_context[ci] = 8; /* small negative diff category */
416 } 419 }
417 /* Figure F.8: Encoding the magnitude category of v */ 420 /* Figure F.8: Encoding the magnitude category of v */
418 m = 0; 421 m = 0;
419 if (v -= 1) { 422 if (v -= 1) {
420 » arith_encode(cinfo, st, 1); 423 arith_encode(cinfo, st, 1);
421 » m = 1; 424 m = 1;
422 » v2 = v; 425 v2 = v;
423 » st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ 426 st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
424 » while (v2 >>= 1) { 427 while (v2 >>= 1) {
425 » arith_encode(cinfo, st, 1); 428 arith_encode(cinfo, st, 1);
426 » m <<= 1; 429 m <<= 1;
427 » st += 1; 430 st += 1;
428 » } 431 }
429 } 432 }
430 arith_encode(cinfo, st, 0); 433 arith_encode(cinfo, st, 0);
431 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ 434 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
432 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) 435 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
433 » entropy->dc_context[ci] = 0;» /* zero diff category */ 436 entropy->dc_context[ci] = 0; /* zero diff category */
434 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) 437 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
435 » entropy->dc_context[ci] += 8;» /* large diff category */ 438 entropy->dc_context[ci] += 8; /* large diff category */
436 /* Figure F.9: Encoding the magnitude bit pattern of v */ 439 /* Figure F.9: Encoding the magnitude bit pattern of v */
437 st += 14; 440 st += 14;
438 while (m >>= 1) 441 while (m >>= 1)
439 » arith_encode(cinfo, st, (m & v) ? 1 : 0); 442 arith_encode(cinfo, st, (m & v) ? 1 : 0);
440 } 443 }
441 } 444 }
442 445
443 return TRUE; 446 return TRUE;
444 } 447 }
445 448
446 449
447 /* 450 /*
448 * MCU encoding for AC initial scan (either spectral selection, 451 * MCU encoding for AC initial scan (either spectral selection,
449 * or first pass of successive approximation). 452 * or first pass of successive approximation).
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
484 if ((v = (*block)[jpeg_natural_order[ke]]) >= 0) { 487 if ((v = (*block)[jpeg_natural_order[ke]]) >= 0) {
485 if (v >>= cinfo->Al) break; 488 if (v >>= cinfo->Al) break;
486 } else { 489 } else {
487 v = -v; 490 v = -v;
488 if (v >>= cinfo->Al) break; 491 if (v >>= cinfo->Al) break;
489 } 492 }
490 493
491 /* Figure F.5: Encode_AC_Coefficients */ 494 /* Figure F.5: Encode_AC_Coefficients */
492 for (k = cinfo->Ss; k <= ke; k++) { 495 for (k = cinfo->Ss; k <= ke; k++) {
493 st = entropy->ac_stats[tbl] + 3 * (k - 1); 496 st = entropy->ac_stats[tbl] + 3 * (k - 1);
494 arith_encode(cinfo, st, 0);»» /* EOB decision */ 497 arith_encode(cinfo, st, 0); /* EOB decision */
495 for (;;) { 498 for (;;) {
496 if ((v = (*block)[jpeg_natural_order[k]]) >= 0) { 499 if ((v = (*block)[jpeg_natural_order[k]]) >= 0) {
497 » if (v >>= cinfo->Al) { 500 if (v >>= cinfo->Al) {
498 » arith_encode(cinfo, st + 1, 1); 501 arith_encode(cinfo, st + 1, 1);
499 » arith_encode(cinfo, entropy->fixed_bin, 0); 502 arith_encode(cinfo, entropy->fixed_bin, 0);
500 » break; 503 break;
501 » } 504 }
502 } else { 505 } else {
503 » v = -v; 506 v = -v;
504 » if (v >>= cinfo->Al) { 507 if (v >>= cinfo->Al) {
505 » arith_encode(cinfo, st + 1, 1); 508 arith_encode(cinfo, st + 1, 1);
506 » arith_encode(cinfo, entropy->fixed_bin, 1); 509 arith_encode(cinfo, entropy->fixed_bin, 1);
507 » break; 510 break;
508 » } 511 }
509 } 512 }
510 arith_encode(cinfo, st + 1, 0); st += 3; k++; 513 arith_encode(cinfo, st + 1, 0); st += 3; k++;
511 } 514 }
512 st += 2; 515 st += 2;
513 /* Figure F.8: Encoding the magnitude category of v */ 516 /* Figure F.8: Encoding the magnitude category of v */
514 m = 0; 517 m = 0;
515 if (v -= 1) { 518 if (v -= 1) {
516 arith_encode(cinfo, st, 1); 519 arith_encode(cinfo, st, 1);
517 m = 1; 520 m = 1;
518 v2 = v; 521 v2 = v;
519 if (v2 >>= 1) { 522 if (v2 >>= 1) {
520 » arith_encode(cinfo, st, 1); 523 arith_encode(cinfo, st, 1);
521 » m <<= 1; 524 m <<= 1;
522 » st = entropy->ac_stats[tbl] + 525 st = entropy->ac_stats[tbl] +
523 » (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); 526 (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
524 » while (v2 >>= 1) { 527 while (v2 >>= 1) {
525 » arith_encode(cinfo, st, 1); 528 arith_encode(cinfo, st, 1);
526 » m <<= 1; 529 m <<= 1;
527 » st += 1; 530 st += 1;
528 » } 531 }
529 } 532 }
530 } 533 }
531 arith_encode(cinfo, st, 0); 534 arith_encode(cinfo, st, 0);
532 /* Figure F.9: Encoding the magnitude bit pattern of v */ 535 /* Figure F.9: Encoding the magnitude bit pattern of v */
533 st += 14; 536 st += 14;
534 while (m >>= 1) 537 while (m >>= 1)
535 arith_encode(cinfo, st, (m & v) ? 1 : 0); 538 arith_encode(cinfo, st, (m & v) ? 1 : 0);
536 } 539 }
537 /* Encode EOB decision only if k <= cinfo->Se */ 540 /* Encode EOB decision only if k <= cinfo->Se */
538 if (k <= cinfo->Se) { 541 if (k <= cinfo->Se) {
(...skipping 20 matching lines...) Expand all
559 if (cinfo->restart_interval) { 562 if (cinfo->restart_interval) {
560 if (entropy->restarts_to_go == 0) { 563 if (entropy->restarts_to_go == 0) {
561 emit_restart(cinfo, entropy->next_restart_num); 564 emit_restart(cinfo, entropy->next_restart_num);
562 entropy->restarts_to_go = cinfo->restart_interval; 565 entropy->restarts_to_go = cinfo->restart_interval;
563 entropy->next_restart_num++; 566 entropy->next_restart_num++;
564 entropy->next_restart_num &= 7; 567 entropy->next_restart_num &= 7;
565 } 568 }
566 entropy->restarts_to_go--; 569 entropy->restarts_to_go--;
567 } 570 }
568 571
569 st = entropy->fixed_bin;» /* use fixed probability estimation */ 572 st = entropy->fixed_bin; /* use fixed probability estimation */
570 Al = cinfo->Al; 573 Al = cinfo->Al;
571 574
572 /* Encode the MCU data blocks */ 575 /* Encode the MCU data blocks */
573 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { 576 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
574 /* We simply emit the Al'th bit of the DC coefficient value. */ 577 /* We simply emit the Al'th bit of the DC coefficient value. */
575 arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1); 578 arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1);
576 } 579 }
577 580
578 return TRUE; 581 return TRUE;
579 } 582 }
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
628 if (v >>= cinfo->Ah) break; 631 if (v >>= cinfo->Ah) break;
629 } else { 632 } else {
630 v = -v; 633 v = -v;
631 if (v >>= cinfo->Ah) break; 634 if (v >>= cinfo->Ah) break;
632 } 635 }
633 636
634 /* Figure G.10: Encode_AC_Coefficients_SA */ 637 /* Figure G.10: Encode_AC_Coefficients_SA */
635 for (k = cinfo->Ss; k <= ke; k++) { 638 for (k = cinfo->Ss; k <= ke; k++) {
636 st = entropy->ac_stats[tbl] + 3 * (k - 1); 639 st = entropy->ac_stats[tbl] + 3 * (k - 1);
637 if (k > kex) 640 if (k > kex)
638 arith_encode(cinfo, st, 0);» /* EOB decision */ 641 arith_encode(cinfo, st, 0); /* EOB decision */
639 for (;;) { 642 for (;;) {
640 if ((v = (*block)[jpeg_natural_order[k]]) >= 0) { 643 if ((v = (*block)[jpeg_natural_order[k]]) >= 0) {
641 » if (v >>= cinfo->Al) { 644 if (v >>= cinfo->Al) {
642 » if (v >> 1)» » » /* previously nonzero coef */ 645 if (v >> 1) /* previously nonzero coef */
643 » arith_encode(cinfo, st + 2, (v & 1)); 646 arith_encode(cinfo, st + 2, (v & 1));
644 » else {» » » /* newly nonzero coef */ 647 else { /* newly nonzero coef */
645 » arith_encode(cinfo, st + 1, 1); 648 arith_encode(cinfo, st + 1, 1);
646 » arith_encode(cinfo, entropy->fixed_bin, 0); 649 arith_encode(cinfo, entropy->fixed_bin, 0);
647 » } 650 }
648 » break; 651 break;
649 » } 652 }
650 } else { 653 } else {
651 » v = -v; 654 v = -v;
652 » if (v >>= cinfo->Al) { 655 if (v >>= cinfo->Al) {
653 » if (v >> 1)» » » /* previously nonzero coef */ 656 if (v >> 1) /* previously nonzero coef */
654 » arith_encode(cinfo, st + 2, (v & 1)); 657 arith_encode(cinfo, st + 2, (v & 1));
655 » else {» » » /* newly nonzero coef */ 658 else { /* newly nonzero coef */
656 » arith_encode(cinfo, st + 1, 1); 659 arith_encode(cinfo, st + 1, 1);
657 » arith_encode(cinfo, entropy->fixed_bin, 1); 660 arith_encode(cinfo, entropy->fixed_bin, 1);
658 » } 661 }
659 » break; 662 break;
660 » } 663 }
661 } 664 }
662 arith_encode(cinfo, st + 1, 0); st += 3; k++; 665 arith_encode(cinfo, st + 1, 0); st += 3; k++;
663 } 666 }
664 } 667 }
665 /* Encode EOB decision only if k <= cinfo->Se */ 668 /* Encode EOB decision only if k <= cinfo->Se */
666 if (k <= cinfo->Se) { 669 if (k <= cinfo->Se) {
667 st = entropy->ac_stats[tbl] + 3 * (k - 1); 670 st = entropy->ac_stats[tbl] + 3 * (k - 1);
668 arith_encode(cinfo, st, 1); 671 arith_encode(cinfo, st, 1);
669 } 672 }
670 673
671 return TRUE; 674 return TRUE;
672 } 675 }
673 676
674 677
675 /* 678 /*
676 * Encode and output one MCU's worth of arithmetic-compressed coefficients. 679 * Encode and output one MCU's worth of arithmetic-compressed coefficients.
677 */ 680 */
678 681
679 METHODDEF(boolean) 682 METHODDEF(boolean)
680 encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 683 encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
681 { 684 {
682 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 685 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
683 jpeg_component_info * compptr; 686 jpeg_component_info *compptr;
684 JBLOCKROW block; 687 JBLOCKROW block;
685 unsigned char *st; 688 unsigned char *st;
686 int blkn, ci, tbl, k, ke; 689 int blkn, ci, tbl, k, ke;
687 int v, v2, m; 690 int v, v2, m;
688 691
689 /* Emit restart marker if needed */ 692 /* Emit restart marker if needed */
690 if (cinfo->restart_interval) { 693 if (cinfo->restart_interval) {
691 if (entropy->restarts_to_go == 0) { 694 if (entropy->restarts_to_go == 0) {
692 emit_restart(cinfo, entropy->next_restart_num); 695 emit_restart(cinfo, entropy->next_restart_num);
693 entropy->restarts_to_go = cinfo->restart_interval; 696 entropy->restarts_to_go = cinfo->restart_interval;
(...skipping 12 matching lines...) Expand all
706 /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ 709 /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
707 710
708 tbl = compptr->dc_tbl_no; 711 tbl = compptr->dc_tbl_no;
709 712
710 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ 713 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
711 st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; 714 st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
712 715
713 /* Figure F.4: Encode_DC_DIFF */ 716 /* Figure F.4: Encode_DC_DIFF */
714 if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) { 717 if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) {
715 arith_encode(cinfo, st, 0); 718 arith_encode(cinfo, st, 0);
716 entropy->dc_context[ci] = 0;» /* zero diff category */ 719 entropy->dc_context[ci] = 0; /* zero diff category */
717 } else { 720 } else {
718 entropy->last_dc_val[ci] = (*block)[0]; 721 entropy->last_dc_val[ci] = (*block)[0];
719 arith_encode(cinfo, st, 1); 722 arith_encode(cinfo, st, 1);
720 /* Figure F.6: Encoding nonzero value v */ 723 /* Figure F.6: Encoding nonzero value v */
721 /* Figure F.7: Encoding the sign of v */ 724 /* Figure F.7: Encoding the sign of v */
722 if (v > 0) { 725 if (v > 0) {
723 » arith_encode(cinfo, st + 1, 0);»/* Table F.4: SS = S0 + 1 */ 726 arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */
724 » st += 2;» » » /* Table F.4: SP = S0 + 2 */ 727 st += 2; /* Table F.4: SP = S0 + 2 */
725 » entropy->dc_context[ci] = 4;» /* small positive diff category */ 728 entropy->dc_context[ci] = 4; /* small positive diff category */
726 } else { 729 } else {
727 » v = -v; 730 v = -v;
728 » arith_encode(cinfo, st + 1, 1);»/* Table F.4: SS = S0 + 1 */ 731 arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */
729 » st += 3;» » » /* Table F.4: SN = S0 + 3 */ 732 st += 3; /* Table F.4: SN = S0 + 3 */
730 » entropy->dc_context[ci] = 8;» /* small negative diff category */ 733 entropy->dc_context[ci] = 8; /* small negative diff category */
731 } 734 }
732 /* Figure F.8: Encoding the magnitude category of v */ 735 /* Figure F.8: Encoding the magnitude category of v */
733 m = 0; 736 m = 0;
734 if (v -= 1) { 737 if (v -= 1) {
735 » arith_encode(cinfo, st, 1); 738 arith_encode(cinfo, st, 1);
736 » m = 1; 739 m = 1;
737 » v2 = v; 740 v2 = v;
738 » st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ 741 st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
739 » while (v2 >>= 1) { 742 while (v2 >>= 1) {
740 » arith_encode(cinfo, st, 1); 743 arith_encode(cinfo, st, 1);
741 » m <<= 1; 744 m <<= 1;
742 » st += 1; 745 st += 1;
743 » } 746 }
744 } 747 }
745 arith_encode(cinfo, st, 0); 748 arith_encode(cinfo, st, 0);
746 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ 749 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
747 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) 750 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
748 » entropy->dc_context[ci] = 0;» /* zero diff category */ 751 entropy->dc_context[ci] = 0; /* zero diff category */
749 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) 752 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
750 » entropy->dc_context[ci] += 8;» /* large diff category */ 753 entropy->dc_context[ci] += 8; /* large diff category */
751 /* Figure F.9: Encoding the magnitude bit pattern of v */ 754 /* Figure F.9: Encoding the magnitude bit pattern of v */
752 st += 14; 755 st += 14;
753 while (m >>= 1) 756 while (m >>= 1)
754 » arith_encode(cinfo, st, (m & v) ? 1 : 0); 757 arith_encode(cinfo, st, (m & v) ? 1 : 0);
755 } 758 }
756 759
757 /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ 760 /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
758 761
759 tbl = compptr->ac_tbl_no; 762 tbl = compptr->ac_tbl_no;
760 763
761 /* Establish EOB (end-of-block) index */ 764 /* Establish EOB (end-of-block) index */
762 for (ke = DCTSIZE2 - 1; ke > 0; ke--) 765 for (ke = DCTSIZE2 - 1; ke > 0; ke--)
763 if ((*block)[jpeg_natural_order[ke]]) break; 766 if ((*block)[jpeg_natural_order[ke]]) break;
764 767
765 /* Figure F.5: Encode_AC_Coefficients */ 768 /* Figure F.5: Encode_AC_Coefficients */
766 for (k = 1; k <= ke; k++) { 769 for (k = 1; k <= ke; k++) {
767 st = entropy->ac_stats[tbl] + 3 * (k - 1); 770 st = entropy->ac_stats[tbl] + 3 * (k - 1);
768 arith_encode(cinfo, st, 0);» /* EOB decision */ 771 arith_encode(cinfo, st, 0); /* EOB decision */
769 while ((v = (*block)[jpeg_natural_order[k]]) == 0) { 772 while ((v = (*block)[jpeg_natural_order[k]]) == 0) {
770 » arith_encode(cinfo, st + 1, 0); st += 3; k++; 773 arith_encode(cinfo, st + 1, 0); st += 3; k++;
771 } 774 }
772 arith_encode(cinfo, st + 1, 1); 775 arith_encode(cinfo, st + 1, 1);
773 /* Figure F.6: Encoding nonzero value v */ 776 /* Figure F.6: Encoding nonzero value v */
774 /* Figure F.7: Encoding the sign of v */ 777 /* Figure F.7: Encoding the sign of v */
775 if (v > 0) { 778 if (v > 0) {
776 » arith_encode(cinfo, entropy->fixed_bin, 0); 779 arith_encode(cinfo, entropy->fixed_bin, 0);
777 } else { 780 } else {
778 » v = -v; 781 v = -v;
779 » arith_encode(cinfo, entropy->fixed_bin, 1); 782 arith_encode(cinfo, entropy->fixed_bin, 1);
780 } 783 }
781 st += 2; 784 st += 2;
782 /* Figure F.8: Encoding the magnitude category of v */ 785 /* Figure F.8: Encoding the magnitude category of v */
783 m = 0; 786 m = 0;
784 if (v -= 1) { 787 if (v -= 1) {
785 » arith_encode(cinfo, st, 1); 788 arith_encode(cinfo, st, 1);
786 » m = 1; 789 m = 1;
787 » v2 = v; 790 v2 = v;
788 » if (v2 >>= 1) { 791 if (v2 >>= 1) {
789 » arith_encode(cinfo, st, 1); 792 arith_encode(cinfo, st, 1);
790 » m <<= 1; 793 m <<= 1;
791 » st = entropy->ac_stats[tbl] + 794 st = entropy->ac_stats[tbl] +
792 » (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); 795 (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
793 » while (v2 >>= 1) { 796 while (v2 >>= 1) {
794 » arith_encode(cinfo, st, 1); 797 arith_encode(cinfo, st, 1);
795 » m <<= 1; 798 m <<= 1;
796 » st += 1; 799 st += 1;
797 » } 800 }
798 » } 801 }
799 } 802 }
800 arith_encode(cinfo, st, 0); 803 arith_encode(cinfo, st, 0);
801 /* Figure F.9: Encoding the magnitude bit pattern of v */ 804 /* Figure F.9: Encoding the magnitude bit pattern of v */
802 st += 14; 805 st += 14;
803 while (m >>= 1) 806 while (m >>= 1)
804 » arith_encode(cinfo, st, (m & v) ? 1 : 0); 807 arith_encode(cinfo, st, (m & v) ? 1 : 0);
805 } 808 }
806 /* Encode EOB decision only if k <= DCTSIZE2 - 1 */ 809 /* Encode EOB decision only if k <= DCTSIZE2 - 1 */
807 if (k <= DCTSIZE2 - 1) { 810 if (k <= DCTSIZE2 - 1) {
808 st = entropy->ac_stats[tbl] + 3 * (k - 1); 811 st = entropy->ac_stats[tbl] + 3 * (k - 1);
809 arith_encode(cinfo, st, 1); 812 arith_encode(cinfo, st, 1);
810 } 813 }
811 } 814 }
812 815
813 return TRUE; 816 return TRUE;
814 } 817 }
815 818
816 819
817 /* 820 /*
818 * Initialize for an arithmetic-compressed scan. 821 * Initialize for an arithmetic-compressed scan.
819 */ 822 */
820 823
821 METHODDEF(void) 824 METHODDEF(void)
822 start_pass (j_compress_ptr cinfo, boolean gather_statistics) 825 start_pass (j_compress_ptr cinfo, boolean gather_statistics)
823 { 826 {
824 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 827 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
825 int ci, tbl; 828 int ci, tbl;
826 jpeg_component_info * compptr; 829 jpeg_component_info *compptr;
827 830
828 if (gather_statistics) 831 if (gather_statistics)
829 /* Make sure to avoid that in the master control logic! 832 /* Make sure to avoid that in the master control logic!
830 * We are fully adaptive here and need no extra 833 * We are fully adaptive here and need no extra
831 * statistics gathering pass! 834 * statistics gathering pass!
832 */ 835 */
833 ERREXIT(cinfo, JERR_NOT_COMPILED); 836 ERREXIT(cinfo, JERR_NOT_COMPILED);
834 837
835 /* We assume jcmaster.c already validated the progressive scan parameters. */ 838 /* We assume jcmaster.c already validated the progressive scan parameters. */
836 839
837 /* Select execution routines */ 840 /* Select execution routines */
838 if (cinfo->progressive_mode) { 841 if (cinfo->progressive_mode) {
839 if (cinfo->Ah == 0) { 842 if (cinfo->Ah == 0) {
840 if (cinfo->Ss == 0) 843 if (cinfo->Ss == 0)
841 » entropy->pub.encode_mcu = encode_mcu_DC_first; 844 entropy->pub.encode_mcu = encode_mcu_DC_first;
842 else 845 else
843 » entropy->pub.encode_mcu = encode_mcu_AC_first; 846 entropy->pub.encode_mcu = encode_mcu_AC_first;
844 } else { 847 } else {
845 if (cinfo->Ss == 0) 848 if (cinfo->Ss == 0)
846 » entropy->pub.encode_mcu = encode_mcu_DC_refine; 849 entropy->pub.encode_mcu = encode_mcu_DC_refine;
847 else 850 else
848 » entropy->pub.encode_mcu = encode_mcu_AC_refine; 851 entropy->pub.encode_mcu = encode_mcu_AC_refine;
849 } 852 }
850 } else 853 } else
851 entropy->pub.encode_mcu = encode_mcu; 854 entropy->pub.encode_mcu = encode_mcu;
852 855
853 /* Allocate & initialize requested statistics areas */ 856 /* Allocate & initialize requested statistics areas */
854 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 857 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
855 compptr = cinfo->cur_comp_info[ci]; 858 compptr = cinfo->cur_comp_info[ci];
856 /* DC needs no table for refinement scan */ 859 /* DC needs no table for refinement scan */
857 if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) { 860 if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
858 tbl = compptr->dc_tbl_no; 861 tbl = compptr->dc_tbl_no;
859 if (tbl < 0 || tbl >= NUM_ARITH_TBLS) 862 if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
860 » ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); 863 ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
861 if (entropy->dc_stats[tbl] == NULL) 864 if (entropy->dc_stats[tbl] == NULL)
862 » entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) 865 entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
863 » ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS); 866 ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS);
864 MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS); 867 MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
865 /* Initialize DC predictions to 0 */ 868 /* Initialize DC predictions to 0 */
866 entropy->last_dc_val[ci] = 0; 869 entropy->last_dc_val[ci] = 0;
867 entropy->dc_context[ci] = 0; 870 entropy->dc_context[ci] = 0;
868 } 871 }
869 /* AC needs no table when not present */ 872 /* AC needs no table when not present */
870 if (cinfo->progressive_mode == 0 || cinfo->Se) { 873 if (cinfo->progressive_mode == 0 || cinfo->Se) {
871 tbl = compptr->ac_tbl_no; 874 tbl = compptr->ac_tbl_no;
872 if (tbl < 0 || tbl >= NUM_ARITH_TBLS) 875 if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
873 » ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); 876 ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
874 if (entropy->ac_stats[tbl] == NULL) 877 if (entropy->ac_stats[tbl] == NULL)
875 » entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) 878 entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
876 » ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS); 879 ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS);
877 MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS); 880 MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
878 #ifdef CALCULATE_SPECTRAL_CONDITIONING 881 #ifdef CALCULATE_SPECTRAL_CONDITIONING
879 if (cinfo->progressive_mode) 882 if (cinfo->progressive_mode)
880 » /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */ 883 /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */
881 » cinfo->arith_ac_K[tbl] = cinfo->Ss + ((8 + cinfo->Se - cinfo->Ss) >> 4); 884 cinfo->arith_ac_K[tbl] = cinfo->Ss + ((8 + cinfo->Se - cinfo->Ss) >> 4);
882 #endif 885 #endif
883 } 886 }
884 } 887 }
885 888
886 /* Initialize arithmetic encoding variables */ 889 /* Initialize arithmetic encoding variables */
887 entropy->c = 0; 890 entropy->c = 0;
888 entropy->a = 0x10000L; 891 entropy->a = 0x10000L;
889 entropy->sc = 0; 892 entropy->sc = 0;
890 entropy->zc = 0; 893 entropy->zc = 0;
891 entropy->ct = 11; 894 entropy->ct = 11;
(...skipping 10 matching lines...) Expand all
902 */ 905 */
903 906
904 GLOBAL(void) 907 GLOBAL(void)
905 jinit_arith_encoder (j_compress_ptr cinfo) 908 jinit_arith_encoder (j_compress_ptr cinfo)
906 { 909 {
907 arith_entropy_ptr entropy; 910 arith_entropy_ptr entropy;
908 int i; 911 int i;
909 912
910 entropy = (arith_entropy_ptr) 913 entropy = (arith_entropy_ptr)
911 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 914 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
912 » » » » SIZEOF(arith_entropy_encoder)); 915 sizeof(arith_entropy_encoder));
913 cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; 916 cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
914 entropy->pub.start_pass = start_pass; 917 entropy->pub.start_pass = start_pass;
915 entropy->pub.finish_pass = finish_pass; 918 entropy->pub.finish_pass = finish_pass;
916 919
917 /* Mark tables unallocated */ 920 /* Mark tables unallocated */
918 for (i = 0; i < NUM_ARITH_TBLS; i++) { 921 for (i = 0; i < NUM_ARITH_TBLS; i++) {
919 entropy->dc_stats[i] = NULL; 922 entropy->dc_stats[i] = NULL;
920 entropy->ac_stats[i] = NULL; 923 entropy->ac_stats[i] = NULL;
921 } 924 }
922 925
923 /* Initialize index for fixed probability estimation */ 926 /* Initialize index for fixed probability estimation */
924 entropy->fixed_bin[0] = 113; 927 entropy->fixed_bin[0] = 113;
925 } 928 }
OLDNEW
« no previous file with comments | « jcapistd.c ('k') | jccoefct.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698