diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcarith.c')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcarith.c | 1874 |
1 files changed, 937 insertions, 937 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcarith.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcarith.c index 60c0ed7..033f670 100644 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcarith.c +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcarith.c | |||
@@ -1,937 +1,937 @@ | |||
1 | /* | 1 | /* |
2 | * jcarith.c | 2 | * jcarith.c |
3 | * | 3 | * |
4 | * Developed 1997-2011 by Guido Vollbeding. | 4 | * Developed 1997-2011 by Guido Vollbeding. |
5 | * This file is part of the Independent JPEG Group's software. | 5 | * This file is part of the Independent JPEG Group's software. |
6 | * For conditions of distribution and use, see the accompanying README file. | 6 | * For conditions of distribution and use, see the accompanying README file. |
7 | * | 7 | * |
8 | * This file contains portable arithmetic entropy encoding routines for JPEG | 8 | * 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). | 9 | * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81). |
10 | * | 10 | * |
11 | * Both sequential and progressive modes are supported in this single module. | 11 | * Both sequential and progressive modes are supported in this single module. |
12 | * | 12 | * |
13 | * Suspension is not currently supported in this module. | 13 | * Suspension is not currently supported in this module. |
14 | */ | 14 | */ |
15 | 15 | ||
16 | #define JPEG_INTERNALS | 16 | #define JPEG_INTERNALS |
17 | #include "jinclude.h" | 17 | #include "jinclude.h" |
18 | #include "jpeglib.h" | 18 | #include "jpeglib.h" |
19 | 19 | ||
20 | 20 | ||
21 | /* Expanded entropy encoder object for arithmetic encoding. */ | 21 | /* Expanded entropy encoder object for arithmetic encoding. */ |
22 | 22 | ||
23 | typedef struct { | 23 | typedef struct { |
24 | struct jpeg_entropy_encoder pub; /* public fields */ | 24 | struct jpeg_entropy_encoder pub; /* public fields */ |
25 | 25 | ||
26 | INT32 c; /* C register, base of coding interval, layout as in sec. D.1.3 */ | 26 | INT32 c; /* C register, base of coding interval, layout as in sec. D.1.3 */ |
27 | INT32 a; /* A register, normalized size of coding interval */ | 27 | INT32 a; /* A register, normalized size of coding interval */ |
28 | INT32 sc; /* counter for stacked 0xFF values which might overflow */ | 28 | INT32 sc; /* counter for stacked 0xFF values which might overflow */ |
29 | INT32 zc; /* counter for pending 0x00 output values which might * | 29 | INT32 zc; /* counter for pending 0x00 output values which might * |
30 | * be discarded at the end ("Pacman" termination) */ | 30 | * be discarded at the end ("Pacman" termination) */ |
31 | int ct; /* bit shift counter, determines when next byte will be written */ | 31 | int ct; /* bit shift counter, determines when next byte will be written */ |
32 | int buffer; /* buffer for most recent output byte != 0xFF */ | 32 | int buffer; /* buffer for most recent output byte != 0xFF */ |
33 | 33 | ||
34 | int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ | 34 | 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 */ | 35 | int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */ |
36 | 36 | ||
37 | unsigned int restarts_to_go; /* MCUs left in this restart interval */ | 37 | unsigned int restarts_to_go; /* MCUs left in this restart interval */ |
38 | int next_restart_num; /* next restart number to write (0-7) */ | 38 | int next_restart_num; /* next restart number to write (0-7) */ |
39 | 39 | ||
40 | /* Pointers to statistics areas (these workspaces have image lifespan) */ | 40 | /* Pointers to statistics areas (these workspaces have image lifespan) */ |
41 | unsigned char * dc_stats[NUM_ARITH_TBLS]; | 41 | unsigned char * dc_stats[NUM_ARITH_TBLS]; |
42 | unsigned char * ac_stats[NUM_ARITH_TBLS]; | 42 | unsigned char * ac_stats[NUM_ARITH_TBLS]; |
43 | 43 | ||
44 | /* Statistics bin for coding with fixed probability 0.5 */ | 44 | /* Statistics bin for coding with fixed probability 0.5 */ |
45 | unsigned char fixed_bin[4]; | 45 | unsigned char fixed_bin[4]; |
46 | } arith_entropy_encoder; | 46 | } arith_entropy_encoder; |
47 | 47 | ||
48 | typedef arith_entropy_encoder * arith_entropy_ptr; | 48 | typedef arith_entropy_encoder * arith_entropy_ptr; |
49 | 49 | ||
50 | /* The following two definitions specify the allocation chunk size | 50 | /* The following two definitions specify the allocation chunk size |
51 | * for the statistics area. | 51 | * for the statistics area. |
52 | * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least | 52 | * 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. | 53 | * 49 statistics bins for DC, and 245 statistics bins for AC coding. |
54 | * | 54 | * |
55 | * We use a compact representation with 1 byte per statistics bin, | 55 | * We use a compact representation with 1 byte per statistics bin, |
56 | * thus the numbers directly represent byte sizes. | 56 | * thus the numbers directly represent byte sizes. |
57 | * This 1 byte per statistics bin contains the meaning of the MPS | 57 | * This 1 byte per statistics bin contains the meaning of the MPS |
58 | * (more probable symbol) in the highest bit (mask 0x80), and the | 58 | * (more probable symbol) in the highest bit (mask 0x80), and the |
59 | * index into the probability estimation state machine table | 59 | * index into the probability estimation state machine table |
60 | * in the lower bits (mask 0x7F). | 60 | * in the lower bits (mask 0x7F). |
61 | */ | 61 | */ |
62 | 62 | ||
63 | #define DC_STAT_BINS 64 | 63 | #define DC_STAT_BINS 64 |
64 | #define AC_STAT_BINS 256 | 64 | #define AC_STAT_BINS 256 |
65 | 65 | ||
66 | /* NOTE: Uncomment the following #define if you want to use the | 66 | /* NOTE: Uncomment the following #define if you want to use the |
67 | * given formula for calculating the AC conditioning parameter Kx | 67 | * given formula for calculating the AC conditioning parameter Kx |
68 | * for spectral selection progressive coding in section G.1.3.2 | 68 | * for spectral selection progressive coding in section G.1.3.2 |
69 | * of the spec (Kx = Kmin + SRL (8 + Se - Kmin) 4). | 69 | * of the spec (Kx = Kmin + SRL (8 + Se - Kmin) 4). |
70 | * Although the spec and P&M authors claim that this "has proven | 70 | * Although the spec and P&M authors claim that this "has proven |
71 | * to give good results for 8 bit precision samples", I'm not | 71 | * to give good results for 8 bit precision samples", I'm not |
72 | * convinced yet that this is really beneficial. | 72 | * convinced yet that this is really beneficial. |
73 | * Early tests gave only very marginal compression enhancements | 73 | * Early tests gave only very marginal compression enhancements |
74 | * (a few - around 5 or so - bytes even for very large files), | 74 | * (a few - around 5 or so - bytes even for very large files), |
75 | * which would turn out rather negative if we'd suppress the | 75 | * which would turn out rather negative if we'd suppress the |
76 | * DAC (Define Arithmetic Conditioning) marker segments for | 76 | * DAC (Define Arithmetic Conditioning) marker segments for |
77 | * the default parameters in the future. | 77 | * the default parameters in the future. |
78 | * Note that currently the marker writing module emits 12-byte | 78 | * Note that currently the marker writing module emits 12-byte |
79 | * DAC segments for a full-component scan in a color image. | 79 | * DAC segments for a full-component scan in a color image. |
80 | * This is not worth worrying about IMHO. However, since the | 80 | * This is not worth worrying about IMHO. However, since the |
81 | * spec defines the default values to be used if the tables | 81 | * spec defines the default values to be used if the tables |
82 | * are omitted (unlike Huffman tables, which are required | 82 | * are omitted (unlike Huffman tables, which are required |
83 | * anyway), one might optimize this behaviour in the future, | 83 | * anyway), one might optimize this behaviour in the future, |
84 | * and then it would be disadvantageous to use custom tables if | 84 | * and then it would be disadvantageous to use custom tables if |
85 | * they don't provide sufficient gain to exceed the DAC size. | 85 | * they don't provide sufficient gain to exceed the DAC size. |
86 | * | 86 | * |
87 | * On the other hand, I'd consider it as a reasonable result | 87 | * On the other hand, I'd consider it as a reasonable result |
88 | * that the conditioning has no significant influence on the | 88 | * that the conditioning has no significant influence on the |
89 | * compression performance. This means that the basic | 89 | * compression performance. This means that the basic |
90 | * statistical model is already rather stable. | 90 | * statistical model is already rather stable. |
91 | * | 91 | * |
92 | * Thus, at the moment, we use the default conditioning values | 92 | * Thus, at the moment, we use the default conditioning values |
93 | * anyway, and do not use the custom formula. | 93 | * anyway, and do not use the custom formula. |
94 | * | 94 | * |
95 | #define CALCULATE_SPECTRAL_CONDITIONING | 95 | #define CALCULATE_SPECTRAL_CONDITIONING |
96 | */ | 96 | */ |
97 | 97 | ||
98 | /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32. | 98 | /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32. |
99 | * We assume that int right shift is unsigned if INT32 right shift is, | 99 | * We assume that int right shift is unsigned if INT32 right shift is, |
100 | * which should be safe. | 100 | * which should be safe. |
101 | */ | 101 | */ |
102 | 102 | ||
103 | #ifdef RIGHT_SHIFT_IS_UNSIGNED | 103 | #ifdef RIGHT_SHIFT_IS_UNSIGNED |
104 | #define ISHIFT_TEMPS int ishift_temp; | 104 | #define ISHIFT_TEMPS int ishift_temp; |
105 | #define IRIGHT_SHIFT(x,shft) \ | 105 | #define IRIGHT_SHIFT(x,shft) \ |
106 | ((ishift_temp = (x)) < 0 ? \ | 106 | ((ishift_temp = (x)) < 0 ? \ |
107 | (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \ | 107 | (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \ |
108 | (ishift_temp >> (shft))) | 108 | (ishift_temp >> (shft))) |
109 | #else | 109 | #else |
110 | #define ISHIFT_TEMPS | 110 | #define ISHIFT_TEMPS |
111 | #define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) | 111 | #define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) |
112 | #endif | 112 | #endif |
113 | 113 | ||
114 | 114 | ||
115 | LOCAL(void) | 115 | LOCAL(void) |
116 | emit_byte (int val, j_compress_ptr cinfo) | 116 | emit_byte (int val, j_compress_ptr cinfo) |
117 | /* Write next output byte; we do not support suspension in this module. */ | 117 | /* Write next output byte; we do not support suspension in this module. */ |
118 | { | 118 | { |
119 | struct jpeg_destination_mgr * dest = cinfo->dest; | 119 | struct jpeg_destination_mgr * dest = cinfo->dest; |
120 | 120 | ||
121 | *dest->next_output_byte++ = (JOCTET) val; | 121 | *dest->next_output_byte++ = (JOCTET) val; |
122 | if (--dest->free_in_buffer == 0) | 122 | if (--dest->free_in_buffer == 0) |
123 | if (! (*dest->empty_output_buffer) (cinfo)) | 123 | if (! (*dest->empty_output_buffer) (cinfo)) |
124 | ERREXIT(cinfo, JERR_CANT_SUSPEND); | 124 | ERREXIT(cinfo, JERR_CANT_SUSPEND); |
125 | } | 125 | } |
126 | 126 | ||
127 | 127 | ||
128 | /* | 128 | /* |
129 | * Finish up at the end of an arithmetic-compressed scan. | 129 | * Finish up at the end of an arithmetic-compressed scan. |
130 | */ | 130 | */ |
131 | 131 | ||
132 | METHODDEF(void) | 132 | METHODDEF(void) |
133 | finish_pass (j_compress_ptr cinfo) | 133 | finish_pass (j_compress_ptr cinfo) |
134 | { | 134 | { |
135 | arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; | 135 | arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; |
136 | INT32 temp; | 136 | INT32 temp; |
137 | 137 | ||
138 | /* Section D.1.8: Termination of encoding */ | 138 | /* Section D.1.8: Termination of encoding */ |
139 | 139 | ||
140 | /* Find the e->c in the coding interval with the largest | 140 | /* Find the e->c in the coding interval with the largest |
141 | * number of trailing zero bits */ | 141 | * number of trailing zero bits */ |
142 | if ((temp = (e->a - 1 + e->c) & 0xFFFF0000L) < e->c) | 142 | if ((temp = (e->a - 1 + e->c) & 0xFFFF0000L) < e->c) |
143 | e->c = temp + 0x8000L; | 143 | e->c = temp + 0x8000L; |
144 | else | 144 | else |
145 | e->c = temp; | 145 | e->c = temp; |
146 | /* Send remaining bytes to output */ | 146 | /* Send remaining bytes to output */ |
147 | e->c <<= e->ct; | 147 | e->c <<= e->ct; |
148 | if (e->c & 0xF8000000L) { | 148 | if (e->c & 0xF8000000L) { |
149 | /* One final overflow has to be handled */ | 149 | /* One final overflow has to be handled */ |
150 | if (e->buffer >= 0) { | 150 | if (e->buffer >= 0) { |
151 | if (e->zc) | 151 | if (e->zc) |
152 | do emit_byte(0x00, cinfo); | 152 | do emit_byte(0x00, cinfo); |
153 | while (--e->zc); | 153 | while (--e->zc); |
154 | emit_byte(e->buffer + 1, cinfo); | 154 | emit_byte(e->buffer + 1, cinfo); |
155 | if (e->buffer + 1 == 0xFF) | 155 | if (e->buffer + 1 == 0xFF) |
156 | emit_byte(0x00, cinfo); | 156 | emit_byte(0x00, cinfo); |
157 | } | 157 | } |
158 | e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ | 158 | e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ |
159 | e->sc = 0; | 159 | e->sc = 0; |
160 | } else { | 160 | } else { |
161 | if (e->buffer == 0) | 161 | if (e->buffer == 0) |
162 | ++e->zc; | 162 | ++e->zc; |
163 | else if (e->buffer >= 0) { | 163 | else if (e->buffer >= 0) { |
164 | if (e->zc) | 164 | if (e->zc) |
165 | do emit_byte(0x00, cinfo); | 165 | do emit_byte(0x00, cinfo); |
166 | while (--e->zc); | 166 | while (--e->zc); |
167 | emit_byte(e->buffer, cinfo); | 167 | emit_byte(e->buffer, cinfo); |
168 | } | 168 | } |
169 | if (e->sc) { | 169 | if (e->sc) { |
170 | if (e->zc) | 170 | if (e->zc) |
171 | do emit_byte(0x00, cinfo); | 171 | do emit_byte(0x00, cinfo); |
172 | while (--e->zc); | 172 | while (--e->zc); |
173 | do { | 173 | do { |
174 | emit_byte(0xFF, cinfo); | 174 | emit_byte(0xFF, cinfo); |
175 | emit_byte(0x00, cinfo); | 175 | emit_byte(0x00, cinfo); |
176 | } while (--e->sc); | 176 | } while (--e->sc); |
177 | } | 177 | } |
178 | } | 178 | } |
179 | /* Output final bytes only if they are not 0x00 */ | 179 | /* Output final bytes only if they are not 0x00 */ |
180 | if (e->c & 0x7FFF800L) { | 180 | if (e->c & 0x7FFF800L) { |
181 | if (e->zc) /* output final pending zero bytes */ | 181 | if (e->zc) /* output final pending zero bytes */ |
182 | do emit_byte(0x00, cinfo); | 182 | do emit_byte(0x00, cinfo); |
183 | while (--e->zc); | 183 | while (--e->zc); |
184 | emit_byte((e->c >> 19) & 0xFF, cinfo); | 184 | emit_byte((e->c >> 19) & 0xFF, cinfo); |
185 | if (((e->c >> 19) & 0xFF) == 0xFF) | 185 | if (((e->c >> 19) & 0xFF) == 0xFF) |
186 | emit_byte(0x00, cinfo); | 186 | emit_byte(0x00, cinfo); |
187 | if (e->c & 0x7F800L) { | 187 | if (e->c & 0x7F800L) { |
188 | emit_byte((e->c >> 11) & 0xFF, cinfo); | 188 | emit_byte((e->c >> 11) & 0xFF, cinfo); |
189 | if (((e->c >> 11) & 0xFF) == 0xFF) | 189 | if (((e->c >> 11) & 0xFF) == 0xFF) |
190 | emit_byte(0x00, cinfo); | 190 | emit_byte(0x00, cinfo); |
191 | } | 191 | } |
192 | } | 192 | } |
193 | } | 193 | } |
194 | 194 | ||
195 | 195 | ||
196 | /* | 196 | /* |
197 | * The core arithmetic encoding routine (common in JPEG and JBIG). | 197 | * The core arithmetic encoding routine (common in JPEG and JBIG). |
198 | * This needs to go as fast as possible. | 198 | * This needs to go as fast as possible. |
199 | * Machine-dependent optimization facilities | 199 | * Machine-dependent optimization facilities |
200 | * are not utilized in this portable implementation. | 200 | * are not utilized in this portable implementation. |
201 | * However, this code should be fairly efficient and | 201 | * However, this code should be fairly efficient and |
202 | * may be a good base for further optimizations anyway. | 202 | * may be a good base for further optimizations anyway. |
203 | * | 203 | * |
204 | * Parameter 'val' to be encoded may be 0 or 1 (binary decision). | 204 | * Parameter 'val' to be encoded may be 0 or 1 (binary decision). |
205 | * | 205 | * |
206 | * Note: I've added full "Pacman" termination support to the | 206 | * Note: I've added full "Pacman" termination support to the |
207 | * byte output routines, which is equivalent to the optional | 207 | * byte output routines, which is equivalent to the optional |
208 | * Discard_final_zeros procedure (Figure D.15) in the spec. | 208 | * Discard_final_zeros procedure (Figure D.15) in the spec. |
209 | * Thus, we always produce the shortest possible output | 209 | * Thus, we always produce the shortest possible output |
210 | * stream compliant to the spec (no trailing zero bytes, | 210 | * stream compliant to the spec (no trailing zero bytes, |
211 | * except for FF stuffing). | 211 | * except for FF stuffing). |
212 | * | 212 | * |
213 | * I've also introduced a new scheme for accessing | 213 | * I've also introduced a new scheme for accessing |
214 | * the probability estimation state machine table, | 214 | * the probability estimation state machine table, |
215 | * derived from Markus Kuhn's JBIG implementation. | 215 | * derived from Markus Kuhn's JBIG implementation. |
216 | */ | 216 | */ |
217 | 217 | ||
218 | LOCAL(void) | 218 | LOCAL(void) |
219 | arith_encode (j_compress_ptr cinfo, unsigned char *st, int val) | 219 | arith_encode (j_compress_ptr cinfo, unsigned char *st, int val) |
220 | { | 220 | { |
221 | register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; | 221 | register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; |
222 | register unsigned char nl, nm; | 222 | register unsigned char nl, nm; |
223 | register INT32 qe, temp; | 223 | register INT32 qe, temp; |
224 | register int sv; | 224 | register int sv; |
225 | 225 | ||
226 | /* Fetch values from our compact representation of Table D.3(D.2): | 226 | /* Fetch values from our compact representation of Table D.3(D.2): |
227 | * Qe values and probability estimation state machine | 227 | * Qe values and probability estimation state machine |
228 | */ | 228 | */ |
229 | sv = *st; | 229 | sv = *st; |
230 | qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */ | 230 | qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */ |
231 | nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */ | 231 | nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */ |
232 | nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */ | 232 | nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */ |
233 | 233 | ||
234 | /* Encode & estimation procedures per sections D.1.4 & D.1.5 */ | 234 | /* Encode & estimation procedures per sections D.1.4 & D.1.5 */ |
235 | e->a -= qe; | 235 | e->a -= qe; |
236 | if (val != (sv >> 7)) { | 236 | if (val != (sv >> 7)) { |
237 | /* Encode the less probable symbol */ | 237 | /* Encode the less probable symbol */ |
238 | if (e->a >= qe) { | 238 | if (e->a >= qe) { |
239 | /* If the interval size (qe) for the less probable symbol (LPS) | 239 | /* If the interval size (qe) for the less probable symbol (LPS) |
240 | * is larger than the interval size for the MPS, then exchange | 240 | * is larger than the interval size for the MPS, then exchange |
241 | * the two symbols for coding efficiency, otherwise code the LPS | 241 | * the two symbols for coding efficiency, otherwise code the LPS |
242 | * as usual: */ | 242 | * as usual: */ |
243 | e->c += e->a; | 243 | e->c += e->a; |
244 | e->a = qe; | 244 | e->a = qe; |
245 | } | 245 | } |
246 | *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */ | 246 | *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */ |
247 | } else { | 247 | } else { |
248 | /* Encode the more probable symbol */ | 248 | /* Encode the more probable symbol */ |
249 | if (e->a >= 0x8000L) | 249 | if (e->a >= 0x8000L) |
250 | return; /* A >= 0x8000 -> ready, no renormalization required */ | 250 | return; /* A >= 0x8000 -> ready, no renormalization required */ |
251 | if (e->a < qe) { | 251 | if (e->a < qe) { |
252 | /* If the interval size (qe) for the less probable symbol (LPS) | 252 | /* If the interval size (qe) for the less probable symbol (LPS) |
253 | * is larger than the interval size for the MPS, then exchange | 253 | * is larger than the interval size for the MPS, then exchange |
254 | * the two symbols for coding efficiency: */ | 254 | * the two symbols for coding efficiency: */ |
255 | e->c += e->a; | 255 | e->c += e->a; |
256 | e->a = qe; | 256 | e->a = qe; |
257 | } | 257 | } |
258 | *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */ | 258 | *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */ |
259 | } | 259 | } |
260 | 260 | ||
261 | /* Renormalization & data output per section D.1.6 */ | 261 | /* Renormalization & data output per section D.1.6 */ |
262 | do { | 262 | do { |
263 | e->a <<= 1; | 263 | e->a <<= 1; |
264 | e->c <<= 1; | 264 | e->c <<= 1; |
265 | if (--e->ct == 0) { | 265 | if (--e->ct == 0) { |
266 | /* Another byte is ready for output */ | 266 | /* Another byte is ready for output */ |
267 | temp = e->c >> 19; | 267 | temp = e->c >> 19; |
268 | if (temp > 0xFF) { | 268 | if (temp > 0xFF) { |
269 | /* Handle overflow over all stacked 0xFF bytes */ | 269 | /* Handle overflow over all stacked 0xFF bytes */ |
270 | if (e->buffer >= 0) { | 270 | if (e->buffer >= 0) { |
271 | if (e->zc) | 271 | if (e->zc) |
272 | do emit_byte(0x00, cinfo); | 272 | do emit_byte(0x00, cinfo); |
273 | while (--e->zc); | 273 | while (--e->zc); |
274 | emit_byte(e->buffer + 1, cinfo); | 274 | emit_byte(e->buffer + 1, cinfo); |
275 | if (e->buffer + 1 == 0xFF) | 275 | if (e->buffer + 1 == 0xFF) |
276 | emit_byte(0x00, cinfo); | 276 | emit_byte(0x00, cinfo); |
277 | } | 277 | } |
278 | e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ | 278 | e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ |
279 | e->sc = 0; | 279 | e->sc = 0; |
280 | /* Note: The 3 spacer bits in the C register guarantee | 280 | /* Note: The 3 spacer bits in the C register guarantee |
281 | * that the new buffer byte can't be 0xFF here | 281 | * that the new buffer byte can't be 0xFF here |
282 | * (see page 160 in the P&M JPEG book). */ | 282 | * (see page 160 in the P&M JPEG book). */ |
283 | e->buffer = temp & 0xFF; /* new output byte, might overflow later */ | 283 | e->buffer = temp & 0xFF; /* new output byte, might overflow later */ |
284 | } else if (temp == 0xFF) { | 284 | } else if (temp == 0xFF) { |
285 | ++e->sc; /* stack 0xFF byte (which might overflow later) */ | 285 | ++e->sc; /* stack 0xFF byte (which might overflow later) */ |
286 | } else { | 286 | } else { |
287 | /* Output all stacked 0xFF bytes, they will not overflow any more */ | 287 | /* Output all stacked 0xFF bytes, they will not overflow any more */ |
288 | if (e->buffer == 0) | 288 | if (e->buffer == 0) |
289 | ++e->zc; | 289 | ++e->zc; |
290 | else if (e->buffer >= 0) { | 290 | else if (e->buffer >= 0) { |
291 | if (e->zc) | 291 | if (e->zc) |
292 | do emit_byte(0x00, cinfo); | 292 | do emit_byte(0x00, cinfo); |
293 | while (--e->zc); | 293 | while (--e->zc); |
294 | emit_byte(e->buffer, cinfo); | 294 | emit_byte(e->buffer, cinfo); |
295 | } | 295 | } |
296 | if (e->sc) { | 296 | if (e->sc) { |
297 | if (e->zc) | 297 | if (e->zc) |
298 | do emit_byte(0x00, cinfo); | 298 | do emit_byte(0x00, cinfo); |
299 | while (--e->zc); | 299 | while (--e->zc); |
300 | do { | 300 | do { |
301 | emit_byte(0xFF, cinfo); | 301 | emit_byte(0xFF, cinfo); |
302 | emit_byte(0x00, cinfo); | 302 | emit_byte(0x00, cinfo); |
303 | } while (--e->sc); | 303 | } while (--e->sc); |
304 | } | 304 | } |
305 | e->buffer = temp & 0xFF; /* new output byte (can still overflow) */ | 305 | e->buffer = temp & 0xFF; /* new output byte (can still overflow) */ |
306 | } | 306 | } |
307 | e->c &= 0x7FFFFL; | 307 | e->c &= 0x7FFFFL; |
308 | e->ct += 8; | 308 | e->ct += 8; |
309 | } | 309 | } |
310 | } while (e->a < 0x8000L); | 310 | } while (e->a < 0x8000L); |
311 | } | 311 | } |
312 | 312 | ||
313 | 313 | ||
314 | /* | 314 | /* |
315 | * Emit a restart marker & resynchronize predictions. | 315 | * Emit a restart marker & resynchronize predictions. |
316 | */ | 316 | */ |
317 | 317 | ||
318 | LOCAL(void) | 318 | LOCAL(void) |
319 | emit_restart (j_compress_ptr cinfo, int restart_num) | 319 | emit_restart (j_compress_ptr cinfo, int restart_num) |
320 | { | 320 | { |
321 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 321 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
322 | int ci; | 322 | int ci; |
323 | jpeg_component_info * compptr; | 323 | jpeg_component_info * compptr; |
324 | 324 | ||
325 | finish_pass(cinfo); | 325 | finish_pass(cinfo); |
326 | 326 | ||
327 | emit_byte(0xFF, cinfo); | 327 | emit_byte(0xFF, cinfo); |
328 | emit_byte(JPEG_RST0 + restart_num, cinfo); | 328 | emit_byte(JPEG_RST0 + restart_num, cinfo); |
329 | 329 | ||
330 | /* Re-initialize statistics areas */ | 330 | /* Re-initialize statistics areas */ |
331 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { | 331 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
332 | compptr = cinfo->cur_comp_info[ci]; | 332 | compptr = cinfo->cur_comp_info[ci]; |
333 | /* DC needs no table for refinement scan */ | 333 | /* DC needs no table for refinement scan */ |
334 | if (cinfo->Ss == 0 && cinfo->Ah == 0) { | 334 | if (cinfo->Ss == 0 && cinfo->Ah == 0) { |
335 | MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS); | 335 | MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS); |
336 | /* Reset DC predictions to 0 */ | 336 | /* Reset DC predictions to 0 */ |
337 | entropy->last_dc_val[ci] = 0; | 337 | entropy->last_dc_val[ci] = 0; |
338 | entropy->dc_context[ci] = 0; | 338 | entropy->dc_context[ci] = 0; |
339 | } | 339 | } |
340 | /* AC needs no table when not present */ | 340 | /* AC needs no table when not present */ |
341 | if (cinfo->Se) { | 341 | if (cinfo->Se) { |
342 | MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS); | 342 | MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS); |
343 | } | 343 | } |
344 | } | 344 | } |
345 | 345 | ||
346 | /* Reset arithmetic encoding variables */ | 346 | /* Reset arithmetic encoding variables */ |
347 | entropy->c = 0; | 347 | entropy->c = 0; |
348 | entropy->a = 0x10000L; | 348 | entropy->a = 0x10000L; |
349 | entropy->sc = 0; | 349 | entropy->sc = 0; |
350 | entropy->zc = 0; | 350 | entropy->zc = 0; |
351 | entropy->ct = 11; | 351 | entropy->ct = 11; |
352 | entropy->buffer = -1; /* empty */ | 352 | entropy->buffer = -1; /* empty */ |
353 | } | 353 | } |
354 | 354 | ||
355 | 355 | ||
356 | /* | 356 | /* |
357 | * MCU encoding for DC initial scan (either spectral selection, | 357 | * MCU encoding for DC initial scan (either spectral selection, |
358 | * or first pass of successive approximation). | 358 | * or first pass of successive approximation). |
359 | */ | 359 | */ |
360 | 360 | ||
361 | METHODDEF(boolean) | 361 | METHODDEF(boolean) |
362 | encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) | 362 | encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
363 | { | 363 | { |
364 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 364 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
365 | JBLOCKROW block; | 365 | JBLOCKROW block; |
366 | unsigned char *st; | 366 | unsigned char *st; |
367 | int blkn, ci, tbl; | 367 | int blkn, ci, tbl; |
368 | int v, v2, m; | 368 | int v, v2, m; |
369 | ISHIFT_TEMPS | 369 | ISHIFT_TEMPS |
370 | 370 | ||
371 | /* Emit restart marker if needed */ | 371 | /* Emit restart marker if needed */ |
372 | if (cinfo->restart_interval) { | 372 | if (cinfo->restart_interval) { |
373 | if (entropy->restarts_to_go == 0) { | 373 | if (entropy->restarts_to_go == 0) { |
374 | emit_restart(cinfo, entropy->next_restart_num); | 374 | emit_restart(cinfo, entropy->next_restart_num); |
375 | entropy->restarts_to_go = cinfo->restart_interval; | 375 | entropy->restarts_to_go = cinfo->restart_interval; |
376 | entropy->next_restart_num++; | 376 | entropy->next_restart_num++; |
377 | entropy->next_restart_num &= 7; | 377 | entropy->next_restart_num &= 7; |
378 | } | 378 | } |
379 | entropy->restarts_to_go--; | 379 | entropy->restarts_to_go--; |
380 | } | 380 | } |
381 | 381 | ||
382 | /* Encode the MCU data blocks */ | 382 | /* Encode the MCU data blocks */ |
383 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { | 383 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { |
384 | block = MCU_data[blkn]; | 384 | block = MCU_data[blkn]; |
385 | ci = cinfo->MCU_membership[blkn]; | 385 | ci = cinfo->MCU_membership[blkn]; |
386 | tbl = cinfo->cur_comp_info[ci]->dc_tbl_no; | 386 | tbl = cinfo->cur_comp_info[ci]->dc_tbl_no; |
387 | 387 | ||
388 | /* Compute the DC value after the required point transform by Al. | 388 | /* Compute the DC value after the required point transform by Al. |
389 | * This is simply an arithmetic right shift. | 389 | * This is simply an arithmetic right shift. |
390 | */ | 390 | */ |
391 | m = IRIGHT_SHIFT((int) ((*block)[0]), cinfo->Al); | 391 | m = IRIGHT_SHIFT((int) ((*block)[0]), cinfo->Al); |
392 | 392 | ||
393 | /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ | 393 | /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ |
394 | 394 | ||
395 | /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ | 395 | /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ |
396 | st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; | 396 | st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; |
397 | 397 | ||
398 | /* Figure F.4: Encode_DC_DIFF */ | 398 | /* Figure F.4: Encode_DC_DIFF */ |
399 | if ((v = m - entropy->last_dc_val[ci]) == 0) { | 399 | if ((v = m - entropy->last_dc_val[ci]) == 0) { |
400 | arith_encode(cinfo, st, 0); | 400 | arith_encode(cinfo, st, 0); |
401 | entropy->dc_context[ci] = 0; /* zero diff category */ | 401 | entropy->dc_context[ci] = 0; /* zero diff category */ |
402 | } else { | 402 | } else { |
403 | entropy->last_dc_val[ci] = m; | 403 | entropy->last_dc_val[ci] = m; |
404 | arith_encode(cinfo, st, 1); | 404 | arith_encode(cinfo, st, 1); |
405 | /* Figure F.6: Encoding nonzero value v */ | 405 | /* Figure F.6: Encoding nonzero value v */ |
406 | /* Figure F.7: Encoding the sign of v */ | 406 | /* Figure F.7: Encoding the sign of v */ |
407 | if (v > 0) { | 407 | if (v > 0) { |
408 | arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */ | 408 | arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */ |
409 | st += 2; /* Table F.4: SP = S0 + 2 */ | 409 | st += 2; /* Table F.4: SP = S0 + 2 */ |
410 | entropy->dc_context[ci] = 4; /* small positive diff category */ | 410 | entropy->dc_context[ci] = 4; /* small positive diff category */ |
411 | } else { | 411 | } else { |
412 | v = -v; | 412 | v = -v; |
413 | arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */ | 413 | arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */ |
414 | st += 3; /* Table F.4: SN = S0 + 3 */ | 414 | st += 3; /* Table F.4: SN = S0 + 3 */ |
415 | entropy->dc_context[ci] = 8; /* small negative diff category */ | 415 | entropy->dc_context[ci] = 8; /* small negative diff category */ |
416 | } | 416 | } |
417 | /* Figure F.8: Encoding the magnitude category of v */ | 417 | /* Figure F.8: Encoding the magnitude category of v */ |
418 | m = 0; | 418 | m = 0; |
419 | if (v -= 1) { | 419 | if (v -= 1) { |
420 | arith_encode(cinfo, st, 1); | 420 | arith_encode(cinfo, st, 1); |
421 | m = 1; | 421 | m = 1; |
422 | v2 = v; | 422 | v2 = v; |
423 | st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ | 423 | st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ |
424 | while (v2 >>= 1) { | 424 | while (v2 >>= 1) { |
425 | arith_encode(cinfo, st, 1); | 425 | arith_encode(cinfo, st, 1); |
426 | m <<= 1; | 426 | m <<= 1; |
427 | st += 1; | 427 | st += 1; |
428 | } | 428 | } |
429 | } | 429 | } |
430 | arith_encode(cinfo, st, 0); | 430 | arith_encode(cinfo, st, 0); |
431 | /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ | 431 | /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ |
432 | if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) | 432 | if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) |
433 | entropy->dc_context[ci] = 0; /* zero diff category */ | 433 | entropy->dc_context[ci] = 0; /* zero diff category */ |
434 | else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) | 434 | else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) |
435 | entropy->dc_context[ci] += 8; /* large diff category */ | 435 | entropy->dc_context[ci] += 8; /* large diff category */ |
436 | /* Figure F.9: Encoding the magnitude bit pattern of v */ | 436 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
437 | st += 14; | 437 | st += 14; |
438 | while (m >>= 1) | 438 | while (m >>= 1) |
439 | arith_encode(cinfo, st, (m & v) ? 1 : 0); | 439 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
440 | } | 440 | } |
441 | } | 441 | } |
442 | 442 | ||
443 | return TRUE; | 443 | return TRUE; |
444 | } | 444 | } |
445 | 445 | ||
446 | 446 | ||
447 | /* | 447 | /* |
448 | * MCU encoding for AC initial scan (either spectral selection, | 448 | * MCU encoding for AC initial scan (either spectral selection, |
449 | * or first pass of successive approximation). | 449 | * or first pass of successive approximation). |
450 | */ | 450 | */ |
451 | 451 | ||
452 | METHODDEF(boolean) | 452 | METHODDEF(boolean) |
453 | encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) | 453 | encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
454 | { | 454 | { |
455 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 455 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
456 | JBLOCKROW block; | 456 | JBLOCKROW block; |
457 | unsigned char *st; | 457 | unsigned char *st; |
458 | int tbl, k, ke; | 458 | int tbl, k, ke; |
459 | int v, v2, m; | 459 | int v, v2, m; |
460 | const int * natural_order; | 460 | const int * natural_order; |
461 | 461 | ||
462 | /* Emit restart marker if needed */ | 462 | /* Emit restart marker if needed */ |
463 | if (cinfo->restart_interval) { | 463 | if (cinfo->restart_interval) { |
464 | if (entropy->restarts_to_go == 0) { | 464 | if (entropy->restarts_to_go == 0) { |
465 | emit_restart(cinfo, entropy->next_restart_num); | 465 | emit_restart(cinfo, entropy->next_restart_num); |
466 | entropy->restarts_to_go = cinfo->restart_interval; | 466 | entropy->restarts_to_go = cinfo->restart_interval; |
467 | entropy->next_restart_num++; | 467 | entropy->next_restart_num++; |
468 | entropy->next_restart_num &= 7; | 468 | entropy->next_restart_num &= 7; |
469 | } | 469 | } |
470 | entropy->restarts_to_go--; | 470 | entropy->restarts_to_go--; |
471 | } | 471 | } |
472 | 472 | ||
473 | natural_order = cinfo->natural_order; | 473 | natural_order = cinfo->natural_order; |
474 | 474 | ||
475 | /* Encode the MCU data block */ | 475 | /* Encode the MCU data block */ |
476 | block = MCU_data[0]; | 476 | block = MCU_data[0]; |
477 | tbl = cinfo->cur_comp_info[0]->ac_tbl_no; | 477 | tbl = cinfo->cur_comp_info[0]->ac_tbl_no; |
478 | 478 | ||
479 | /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ | 479 | /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ |
480 | 480 | ||
481 | /* Establish EOB (end-of-block) index */ | 481 | /* Establish EOB (end-of-block) index */ |
482 | for (ke = cinfo->Se; ke > 0; ke--) | 482 | for (ke = cinfo->Se; ke > 0; ke--) |
483 | /* We must apply the point transform by Al. For AC coefficients this | 483 | /* We must apply the point transform by Al. For AC coefficients this |
484 | * is an integer division with rounding towards 0. To do this portably | 484 | * is an integer division with rounding towards 0. To do this portably |
485 | * in C, we shift after obtaining the absolute value. | 485 | * in C, we shift after obtaining the absolute value. |
486 | */ | 486 | */ |
487 | if ((v = (*block)[natural_order[ke]]) >= 0) { | 487 | if ((v = (*block)[natural_order[ke]]) >= 0) { |
488 | if (v >>= cinfo->Al) break; | 488 | if (v >>= cinfo->Al) break; |
489 | } else { | 489 | } else { |
490 | v = -v; | 490 | v = -v; |
491 | if (v >>= cinfo->Al) break; | 491 | if (v >>= cinfo->Al) break; |
492 | } | 492 | } |
493 | 493 | ||
494 | /* Figure F.5: Encode_AC_Coefficients */ | 494 | /* Figure F.5: Encode_AC_Coefficients */ |
495 | for (k = cinfo->Ss; k <= ke; k++) { | 495 | for (k = cinfo->Ss; k <= ke; k++) { |
496 | st = entropy->ac_stats[tbl] + 3 * (k - 1); | 496 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
497 | arith_encode(cinfo, st, 0); /* EOB decision */ | 497 | arith_encode(cinfo, st, 0); /* EOB decision */ |
498 | for (;;) { | 498 | for (;;) { |
499 | if ((v = (*block)[natural_order[k]]) >= 0) { | 499 | if ((v = (*block)[natural_order[k]]) >= 0) { |
500 | if (v >>= cinfo->Al) { | 500 | if (v >>= cinfo->Al) { |
501 | arith_encode(cinfo, st + 1, 1); | 501 | arith_encode(cinfo, st + 1, 1); |
502 | arith_encode(cinfo, entropy->fixed_bin, 0); | 502 | arith_encode(cinfo, entropy->fixed_bin, 0); |
503 | break; | 503 | break; |
504 | } | 504 | } |
505 | } else { | 505 | } else { |
506 | v = -v; | 506 | v = -v; |
507 | if (v >>= cinfo->Al) { | 507 | if (v >>= cinfo->Al) { |
508 | arith_encode(cinfo, st + 1, 1); | 508 | arith_encode(cinfo, st + 1, 1); |
509 | arith_encode(cinfo, entropy->fixed_bin, 1); | 509 | arith_encode(cinfo, entropy->fixed_bin, 1); |
510 | break; | 510 | break; |
511 | } | 511 | } |
512 | } | 512 | } |
513 | arith_encode(cinfo, st + 1, 0); st += 3; k++; | 513 | arith_encode(cinfo, st + 1, 0); st += 3; k++; |
514 | } | 514 | } |
515 | st += 2; | 515 | st += 2; |
516 | /* Figure F.8: Encoding the magnitude category of v */ | 516 | /* Figure F.8: Encoding the magnitude category of v */ |
517 | m = 0; | 517 | m = 0; |
518 | if (v -= 1) { | 518 | if (v -= 1) { |
519 | arith_encode(cinfo, st, 1); | 519 | arith_encode(cinfo, st, 1); |
520 | m = 1; | 520 | m = 1; |
521 | v2 = v; | 521 | v2 = v; |
522 | if (v2 >>= 1) { | 522 | if (v2 >>= 1) { |
523 | arith_encode(cinfo, st, 1); | 523 | arith_encode(cinfo, st, 1); |
524 | m <<= 1; | 524 | m <<= 1; |
525 | st = entropy->ac_stats[tbl] + | 525 | st = entropy->ac_stats[tbl] + |
526 | (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); | 526 | (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); |
527 | while (v2 >>= 1) { | 527 | while (v2 >>= 1) { |
528 | arith_encode(cinfo, st, 1); | 528 | arith_encode(cinfo, st, 1); |
529 | m <<= 1; | 529 | m <<= 1; |
530 | st += 1; | 530 | st += 1; |
531 | } | 531 | } |
532 | } | 532 | } |
533 | } | 533 | } |
534 | arith_encode(cinfo, st, 0); | 534 | arith_encode(cinfo, st, 0); |
535 | /* Figure F.9: Encoding the magnitude bit pattern of v */ | 535 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
536 | st += 14; | 536 | st += 14; |
537 | while (m >>= 1) | 537 | while (m >>= 1) |
538 | arith_encode(cinfo, st, (m & v) ? 1 : 0); | 538 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
539 | } | 539 | } |
540 | /* Encode EOB decision only if k <= cinfo->Se */ | 540 | /* Encode EOB decision only if k <= cinfo->Se */ |
541 | if (k <= cinfo->Se) { | 541 | if (k <= cinfo->Se) { |
542 | st = entropy->ac_stats[tbl] + 3 * (k - 1); | 542 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
543 | arith_encode(cinfo, st, 1); | 543 | arith_encode(cinfo, st, 1); |
544 | } | 544 | } |
545 | 545 | ||
546 | return TRUE; | 546 | return TRUE; |
547 | } | 547 | } |
548 | 548 | ||
549 | 549 | ||
550 | /* | 550 | /* |
551 | * MCU encoding for DC successive approximation refinement scan. | 551 | * MCU encoding for DC successive approximation refinement scan. |
552 | */ | 552 | */ |
553 | 553 | ||
554 | METHODDEF(boolean) | 554 | METHODDEF(boolean) |
555 | encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) | 555 | encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
556 | { | 556 | { |
557 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 557 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
558 | unsigned char *st; | 558 | unsigned char *st; |
559 | int Al, blkn; | 559 | int Al, blkn; |
560 | 560 | ||
561 | /* Emit restart marker if needed */ | 561 | /* Emit restart marker if needed */ |
562 | if (cinfo->restart_interval) { | 562 | if (cinfo->restart_interval) { |
563 | if (entropy->restarts_to_go == 0) { | 563 | if (entropy->restarts_to_go == 0) { |
564 | emit_restart(cinfo, entropy->next_restart_num); | 564 | emit_restart(cinfo, entropy->next_restart_num); |
565 | entropy->restarts_to_go = cinfo->restart_interval; | 565 | entropy->restarts_to_go = cinfo->restart_interval; |
566 | entropy->next_restart_num++; | 566 | entropy->next_restart_num++; |
567 | entropy->next_restart_num &= 7; | 567 | entropy->next_restart_num &= 7; |
568 | } | 568 | } |
569 | entropy->restarts_to_go--; | 569 | entropy->restarts_to_go--; |
570 | } | 570 | } |
571 | 571 | ||
572 | st = entropy->fixed_bin; /* use fixed probability estimation */ | 572 | st = entropy->fixed_bin; /* use fixed probability estimation */ |
573 | Al = cinfo->Al; | 573 | Al = cinfo->Al; |
574 | 574 | ||
575 | /* Encode the MCU data blocks */ | 575 | /* Encode the MCU data blocks */ |
576 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { | 576 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { |
577 | /* 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. */ |
578 | arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1); | 578 | arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1); |
579 | } | 579 | } |
580 | 580 | ||
581 | return TRUE; | 581 | return TRUE; |
582 | } | 582 | } |
583 | 583 | ||
584 | 584 | ||
585 | /* | 585 | /* |
586 | * MCU encoding for AC successive approximation refinement scan. | 586 | * MCU encoding for AC successive approximation refinement scan. |
587 | */ | 587 | */ |
588 | 588 | ||
589 | METHODDEF(boolean) | 589 | METHODDEF(boolean) |
590 | encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) | 590 | encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
591 | { | 591 | { |
592 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 592 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
593 | JBLOCKROW block; | 593 | JBLOCKROW block; |
594 | unsigned char *st; | 594 | unsigned char *st; |
595 | int tbl, k, ke, kex; | 595 | int tbl, k, ke, kex; |
596 | int v; | 596 | int v; |
597 | const int * natural_order; | 597 | const int * natural_order; |
598 | 598 | ||
599 | /* Emit restart marker if needed */ | 599 | /* Emit restart marker if needed */ |
600 | if (cinfo->restart_interval) { | 600 | if (cinfo->restart_interval) { |
601 | if (entropy->restarts_to_go == 0) { | 601 | if (entropy->restarts_to_go == 0) { |
602 | emit_restart(cinfo, entropy->next_restart_num); | 602 | emit_restart(cinfo, entropy->next_restart_num); |
603 | entropy->restarts_to_go = cinfo->restart_interval; | 603 | entropy->restarts_to_go = cinfo->restart_interval; |
604 | entropy->next_restart_num++; | 604 | entropy->next_restart_num++; |
605 | entropy->next_restart_num &= 7; | 605 | entropy->next_restart_num &= 7; |
606 | } | 606 | } |
607 | entropy->restarts_to_go--; | 607 | entropy->restarts_to_go--; |
608 | } | 608 | } |
609 | 609 | ||
610 | natural_order = cinfo->natural_order; | 610 | natural_order = cinfo->natural_order; |
611 | 611 | ||
612 | /* Encode the MCU data block */ | 612 | /* Encode the MCU data block */ |
613 | block = MCU_data[0]; | 613 | block = MCU_data[0]; |
614 | tbl = cinfo->cur_comp_info[0]->ac_tbl_no; | 614 | tbl = cinfo->cur_comp_info[0]->ac_tbl_no; |
615 | 615 | ||
616 | /* Section G.1.3.3: Encoding of AC coefficients */ | 616 | /* Section G.1.3.3: Encoding of AC coefficients */ |
617 | 617 | ||
618 | /* Establish EOB (end-of-block) index */ | 618 | /* Establish EOB (end-of-block) index */ |
619 | for (ke = cinfo->Se; ke > 0; ke--) | 619 | for (ke = cinfo->Se; ke > 0; ke--) |
620 | /* We must apply the point transform by Al. For AC coefficients this | 620 | /* We must apply the point transform by Al. For AC coefficients this |
621 | * is an integer division with rounding towards 0. To do this portably | 621 | * is an integer division with rounding towards 0. To do this portably |
622 | * in C, we shift after obtaining the absolute value. | 622 | * in C, we shift after obtaining the absolute value. |
623 | */ | 623 | */ |
624 | if ((v = (*block)[natural_order[ke]]) >= 0) { | 624 | if ((v = (*block)[natural_order[ke]]) >= 0) { |
625 | if (v >>= cinfo->Al) break; | 625 | if (v >>= cinfo->Al) break; |
626 | } else { | 626 | } else { |
627 | v = -v; | 627 | v = -v; |
628 | if (v >>= cinfo->Al) break; | 628 | if (v >>= cinfo->Al) break; |
629 | } | 629 | } |
630 | 630 | ||
631 | /* Establish EOBx (previous stage end-of-block) index */ | 631 | /* Establish EOBx (previous stage end-of-block) index */ |
632 | for (kex = ke; kex > 0; kex--) | 632 | for (kex = ke; kex > 0; kex--) |
633 | if ((v = (*block)[natural_order[kex]]) >= 0) { | 633 | if ((v = (*block)[natural_order[kex]]) >= 0) { |
634 | if (v >>= cinfo->Ah) break; | 634 | if (v >>= cinfo->Ah) break; |
635 | } else { | 635 | } else { |
636 | v = -v; | 636 | v = -v; |
637 | if (v >>= cinfo->Ah) break; | 637 | if (v >>= cinfo->Ah) break; |
638 | } | 638 | } |
639 | 639 | ||
640 | /* Figure G.10: Encode_AC_Coefficients_SA */ | 640 | /* Figure G.10: Encode_AC_Coefficients_SA */ |
641 | for (k = cinfo->Ss; k <= ke; k++) { | 641 | for (k = cinfo->Ss; k <= ke; k++) { |
642 | st = entropy->ac_stats[tbl] + 3 * (k - 1); | 642 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
643 | if (k > kex) | 643 | if (k > kex) |
644 | arith_encode(cinfo, st, 0); /* EOB decision */ | 644 | arith_encode(cinfo, st, 0); /* EOB decision */ |
645 | for (;;) { | 645 | for (;;) { |
646 | if ((v = (*block)[natural_order[k]]) >= 0) { | 646 | if ((v = (*block)[natural_order[k]]) >= 0) { |
647 | if (v >>= cinfo->Al) { | 647 | if (v >>= cinfo->Al) { |
648 | if (v >> 1) /* previously nonzero coef */ | 648 | if (v >> 1) /* previously nonzero coef */ |
649 | arith_encode(cinfo, st + 2, (v & 1)); | 649 | arith_encode(cinfo, st + 2, (v & 1)); |
650 | else { /* newly nonzero coef */ | 650 | else { /* newly nonzero coef */ |
651 | arith_encode(cinfo, st + 1, 1); | 651 | arith_encode(cinfo, st + 1, 1); |
652 | arith_encode(cinfo, entropy->fixed_bin, 0); | 652 | arith_encode(cinfo, entropy->fixed_bin, 0); |
653 | } | 653 | } |
654 | break; | 654 | break; |
655 | } | 655 | } |
656 | } else { | 656 | } else { |
657 | v = -v; | 657 | v = -v; |
658 | if (v >>= cinfo->Al) { | 658 | if (v >>= cinfo->Al) { |
659 | if (v >> 1) /* previously nonzero coef */ | 659 | if (v >> 1) /* previously nonzero coef */ |
660 | arith_encode(cinfo, st + 2, (v & 1)); | 660 | arith_encode(cinfo, st + 2, (v & 1)); |
661 | else { /* newly nonzero coef */ | 661 | else { /* newly nonzero coef */ |
662 | arith_encode(cinfo, st + 1, 1); | 662 | arith_encode(cinfo, st + 1, 1); |
663 | arith_encode(cinfo, entropy->fixed_bin, 1); | 663 | arith_encode(cinfo, entropy->fixed_bin, 1); |
664 | } | 664 | } |
665 | break; | 665 | break; |
666 | } | 666 | } |
667 | } | 667 | } |
668 | arith_encode(cinfo, st + 1, 0); st += 3; k++; | 668 | arith_encode(cinfo, st + 1, 0); st += 3; k++; |
669 | } | 669 | } |
670 | } | 670 | } |
671 | /* Encode EOB decision only if k <= cinfo->Se */ | 671 | /* Encode EOB decision only if k <= cinfo->Se */ |
672 | if (k <= cinfo->Se) { | 672 | if (k <= cinfo->Se) { |
673 | st = entropy->ac_stats[tbl] + 3 * (k - 1); | 673 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
674 | arith_encode(cinfo, st, 1); | 674 | arith_encode(cinfo, st, 1); |
675 | } | 675 | } |
676 | 676 | ||
677 | return TRUE; | 677 | return TRUE; |
678 | } | 678 | } |
679 | 679 | ||
680 | 680 | ||
681 | /* | 681 | /* |
682 | * Encode and output one MCU's worth of arithmetic-compressed coefficients. | 682 | * Encode and output one MCU's worth of arithmetic-compressed coefficients. |
683 | */ | 683 | */ |
684 | 684 | ||
685 | METHODDEF(boolean) | 685 | METHODDEF(boolean) |
686 | encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data) | 686 | encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
687 | { | 687 | { |
688 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 688 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
689 | jpeg_component_info * compptr; | 689 | jpeg_component_info * compptr; |
690 | JBLOCKROW block; | 690 | JBLOCKROW block; |
691 | unsigned char *st; | 691 | unsigned char *st; |
692 | int blkn, ci, tbl, k, ke; | 692 | int blkn, ci, tbl, k, ke; |
693 | int v, v2, m; | 693 | int v, v2, m; |
694 | const int * natural_order; | 694 | const int * natural_order; |
695 | 695 | ||
696 | /* Emit restart marker if needed */ | 696 | /* Emit restart marker if needed */ |
697 | if (cinfo->restart_interval) { | 697 | if (cinfo->restart_interval) { |
698 | if (entropy->restarts_to_go == 0) { | 698 | if (entropy->restarts_to_go == 0) { |
699 | emit_restart(cinfo, entropy->next_restart_num); | 699 | emit_restart(cinfo, entropy->next_restart_num); |
700 | entropy->restarts_to_go = cinfo->restart_interval; | 700 | entropy->restarts_to_go = cinfo->restart_interval; |
701 | entropy->next_restart_num++; | 701 | entropy->next_restart_num++; |
702 | entropy->next_restart_num &= 7; | 702 | entropy->next_restart_num &= 7; |
703 | } | 703 | } |
704 | entropy->restarts_to_go--; | 704 | entropy->restarts_to_go--; |
705 | } | 705 | } |
706 | 706 | ||
707 | natural_order = cinfo->natural_order; | 707 | natural_order = cinfo->natural_order; |
708 | 708 | ||
709 | /* Encode the MCU data blocks */ | 709 | /* Encode the MCU data blocks */ |
710 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { | 710 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { |
711 | block = MCU_data[blkn]; | 711 | block = MCU_data[blkn]; |
712 | ci = cinfo->MCU_membership[blkn]; | 712 | ci = cinfo->MCU_membership[blkn]; |
713 | compptr = cinfo->cur_comp_info[ci]; | 713 | compptr = cinfo->cur_comp_info[ci]; |
714 | 714 | ||
715 | /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ | 715 | /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ |
716 | 716 | ||
717 | tbl = compptr->dc_tbl_no; | 717 | tbl = compptr->dc_tbl_no; |
718 | 718 | ||
719 | /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ | 719 | /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ |
720 | st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; | 720 | st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; |
721 | 721 | ||
722 | /* Figure F.4: Encode_DC_DIFF */ | 722 | /* Figure F.4: Encode_DC_DIFF */ |
723 | if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) { | 723 | if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) { |
724 | arith_encode(cinfo, st, 0); | 724 | arith_encode(cinfo, st, 0); |
725 | entropy->dc_context[ci] = 0; /* zero diff category */ | 725 | entropy->dc_context[ci] = 0; /* zero diff category */ |
726 | } else { | 726 | } else { |
727 | entropy->last_dc_val[ci] = (*block)[0]; | 727 | entropy->last_dc_val[ci] = (*block)[0]; |
728 | arith_encode(cinfo, st, 1); | 728 | arith_encode(cinfo, st, 1); |
729 | /* Figure F.6: Encoding nonzero value v */ | 729 | /* Figure F.6: Encoding nonzero value v */ |
730 | /* Figure F.7: Encoding the sign of v */ | 730 | /* Figure F.7: Encoding the sign of v */ |
731 | if (v > 0) { | 731 | if (v > 0) { |
732 | arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */ | 732 | arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */ |
733 | st += 2; /* Table F.4: SP = S0 + 2 */ | 733 | st += 2; /* Table F.4: SP = S0 + 2 */ |
734 | entropy->dc_context[ci] = 4; /* small positive diff category */ | 734 | entropy->dc_context[ci] = 4; /* small positive diff category */ |
735 | } else { | 735 | } else { |
736 | v = -v; | 736 | v = -v; |
737 | arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */ | 737 | arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */ |
738 | st += 3; /* Table F.4: SN = S0 + 3 */ | 738 | st += 3; /* Table F.4: SN = S0 + 3 */ |
739 | entropy->dc_context[ci] = 8; /* small negative diff category */ | 739 | entropy->dc_context[ci] = 8; /* small negative diff category */ |
740 | } | 740 | } |
741 | /* Figure F.8: Encoding the magnitude category of v */ | 741 | /* Figure F.8: Encoding the magnitude category of v */ |
742 | m = 0; | 742 | m = 0; |
743 | if (v -= 1) { | 743 | if (v -= 1) { |
744 | arith_encode(cinfo, st, 1); | 744 | arith_encode(cinfo, st, 1); |
745 | m = 1; | 745 | m = 1; |
746 | v2 = v; | 746 | v2 = v; |
747 | st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ | 747 | st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ |
748 | while (v2 >>= 1) { | 748 | while (v2 >>= 1) { |
749 | arith_encode(cinfo, st, 1); | 749 | arith_encode(cinfo, st, 1); |
750 | m <<= 1; | 750 | m <<= 1; |
751 | st += 1; | 751 | st += 1; |
752 | } | 752 | } |
753 | } | 753 | } |
754 | arith_encode(cinfo, st, 0); | 754 | arith_encode(cinfo, st, 0); |
755 | /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ | 755 | /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ |
756 | if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) | 756 | if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) |
757 | entropy->dc_context[ci] = 0; /* zero diff category */ | 757 | entropy->dc_context[ci] = 0; /* zero diff category */ |
758 | else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) | 758 | else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) |
759 | entropy->dc_context[ci] += 8; /* large diff category */ | 759 | entropy->dc_context[ci] += 8; /* large diff category */ |
760 | /* Figure F.9: Encoding the magnitude bit pattern of v */ | 760 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
761 | st += 14; | 761 | st += 14; |
762 | while (m >>= 1) | 762 | while (m >>= 1) |
763 | arith_encode(cinfo, st, (m & v) ? 1 : 0); | 763 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
764 | } | 764 | } |
765 | 765 | ||
766 | /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ | 766 | /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ |
767 | 767 | ||
768 | if ((ke = cinfo->lim_Se) == 0) continue; | 768 | if ((ke = cinfo->lim_Se) == 0) continue; |
769 | tbl = compptr->ac_tbl_no; | 769 | tbl = compptr->ac_tbl_no; |
770 | 770 | ||
771 | /* Establish EOB (end-of-block) index */ | 771 | /* Establish EOB (end-of-block) index */ |
772 | do { | 772 | do { |
773 | if ((*block)[natural_order[ke]]) break; | 773 | if ((*block)[natural_order[ke]]) break; |
774 | } while (--ke); | 774 | } while (--ke); |
775 | 775 | ||
776 | /* Figure F.5: Encode_AC_Coefficients */ | 776 | /* Figure F.5: Encode_AC_Coefficients */ |
777 | for (k = 0; k < ke;) { | 777 | for (k = 0; k < ke;) { |
778 | st = entropy->ac_stats[tbl] + 3 * k; | 778 | st = entropy->ac_stats[tbl] + 3 * k; |
779 | arith_encode(cinfo, st, 0); /* EOB decision */ | 779 | arith_encode(cinfo, st, 0); /* EOB decision */ |
780 | while ((v = (*block)[natural_order[++k]]) == 0) { | 780 | while ((v = (*block)[natural_order[++k]]) == 0) { |
781 | arith_encode(cinfo, st + 1, 0); | 781 | arith_encode(cinfo, st + 1, 0); |
782 | st += 3; | 782 | st += 3; |
783 | } | 783 | } |
784 | arith_encode(cinfo, st + 1, 1); | 784 | arith_encode(cinfo, st + 1, 1); |
785 | /* Figure F.6: Encoding nonzero value v */ | 785 | /* Figure F.6: Encoding nonzero value v */ |
786 | /* Figure F.7: Encoding the sign of v */ | 786 | /* Figure F.7: Encoding the sign of v */ |
787 | if (v > 0) { | 787 | if (v > 0) { |
788 | arith_encode(cinfo, entropy->fixed_bin, 0); | 788 | arith_encode(cinfo, entropy->fixed_bin, 0); |
789 | } else { | 789 | } else { |
790 | v = -v; | 790 | v = -v; |
791 | arith_encode(cinfo, entropy->fixed_bin, 1); | 791 | arith_encode(cinfo, entropy->fixed_bin, 1); |
792 | } | 792 | } |
793 | st += 2; | 793 | st += 2; |
794 | /* Figure F.8: Encoding the magnitude category of v */ | 794 | /* Figure F.8: Encoding the magnitude category of v */ |
795 | m = 0; | 795 | m = 0; |
796 | if (v -= 1) { | 796 | if (v -= 1) { |
797 | arith_encode(cinfo, st, 1); | 797 | arith_encode(cinfo, st, 1); |
798 | m = 1; | 798 | m = 1; |
799 | v2 = v; | 799 | v2 = v; |
800 | if (v2 >>= 1) { | 800 | if (v2 >>= 1) { |
801 | arith_encode(cinfo, st, 1); | 801 | arith_encode(cinfo, st, 1); |
802 | m <<= 1; | 802 | m <<= 1; |
803 | st = entropy->ac_stats[tbl] + | 803 | st = entropy->ac_stats[tbl] + |
804 | (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); | 804 | (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); |
805 | while (v2 >>= 1) { | 805 | while (v2 >>= 1) { |
806 | arith_encode(cinfo, st, 1); | 806 | arith_encode(cinfo, st, 1); |
807 | m <<= 1; | 807 | m <<= 1; |
808 | st += 1; | 808 | st += 1; |
809 | } | 809 | } |
810 | } | 810 | } |
811 | } | 811 | } |
812 | arith_encode(cinfo, st, 0); | 812 | arith_encode(cinfo, st, 0); |
813 | /* Figure F.9: Encoding the magnitude bit pattern of v */ | 813 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
814 | st += 14; | 814 | st += 14; |
815 | while (m >>= 1) | 815 | while (m >>= 1) |
816 | arith_encode(cinfo, st, (m & v) ? 1 : 0); | 816 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
817 | } | 817 | } |
818 | /* Encode EOB decision only if k < cinfo->lim_Se */ | 818 | /* Encode EOB decision only if k < cinfo->lim_Se */ |
819 | if (k < cinfo->lim_Se) { | 819 | if (k < cinfo->lim_Se) { |
820 | st = entropy->ac_stats[tbl] + 3 * k; | 820 | st = entropy->ac_stats[tbl] + 3 * k; |
821 | arith_encode(cinfo, st, 1); | 821 | arith_encode(cinfo, st, 1); |
822 | } | 822 | } |
823 | } | 823 | } |
824 | 824 | ||
825 | return TRUE; | 825 | return TRUE; |
826 | } | 826 | } |
827 | 827 | ||
828 | 828 | ||
829 | /* | 829 | /* |
830 | * Initialize for an arithmetic-compressed scan. | 830 | * Initialize for an arithmetic-compressed scan. |
831 | */ | 831 | */ |
832 | 832 | ||
833 | METHODDEF(void) | 833 | METHODDEF(void) |
834 | start_pass (j_compress_ptr cinfo, boolean gather_statistics) | 834 | start_pass (j_compress_ptr cinfo, boolean gather_statistics) |
835 | { | 835 | { |
836 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; | 836 | arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; |
837 | int ci, tbl; | 837 | int ci, tbl; |
838 | jpeg_component_info * compptr; | 838 | jpeg_component_info * compptr; |
839 | 839 | ||
840 | if (gather_statistics) | 840 | if (gather_statistics) |
841 | /* Make sure to avoid that in the master control logic! | 841 | /* Make sure to avoid that in the master control logic! |
842 | * We are fully adaptive here and need no extra | 842 | * We are fully adaptive here and need no extra |
843 | * statistics gathering pass! | 843 | * statistics gathering pass! |
844 | */ | 844 | */ |
845 | ERREXIT(cinfo, JERR_NOT_COMPILED); | 845 | ERREXIT(cinfo, JERR_NOT_COMPILED); |
846 | 846 | ||
847 | /* We assume jcmaster.c already validated the progressive scan parameters. */ | 847 | /* We assume jcmaster.c already validated the progressive scan parameters. */ |
848 | 848 | ||
849 | /* Select execution routines */ | 849 | /* Select execution routines */ |
850 | if (cinfo->progressive_mode) { | 850 | if (cinfo->progressive_mode) { |
851 | if (cinfo->Ah == 0) { | 851 | if (cinfo->Ah == 0) { |
852 | if (cinfo->Ss == 0) | 852 | if (cinfo->Ss == 0) |
853 | entropy->pub.encode_mcu = encode_mcu_DC_first; | 853 | entropy->pub.encode_mcu = encode_mcu_DC_first; |
854 | else | 854 | else |
855 | entropy->pub.encode_mcu = encode_mcu_AC_first; | 855 | entropy->pub.encode_mcu = encode_mcu_AC_first; |
856 | } else { | 856 | } else { |
857 | if (cinfo->Ss == 0) | 857 | if (cinfo->Ss == 0) |
858 | entropy->pub.encode_mcu = encode_mcu_DC_refine; | 858 | entropy->pub.encode_mcu = encode_mcu_DC_refine; |
859 | else | 859 | else |
860 | entropy->pub.encode_mcu = encode_mcu_AC_refine; | 860 | entropy->pub.encode_mcu = encode_mcu_AC_refine; |
861 | } | 861 | } |
862 | } else | 862 | } else |
863 | entropy->pub.encode_mcu = encode_mcu; | 863 | entropy->pub.encode_mcu = encode_mcu; |
864 | 864 | ||
865 | /* Allocate & initialize requested statistics areas */ | 865 | /* Allocate & initialize requested statistics areas */ |
866 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { | 866 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
867 | compptr = cinfo->cur_comp_info[ci]; | 867 | compptr = cinfo->cur_comp_info[ci]; |
868 | /* DC needs no table for refinement scan */ | 868 | /* DC needs no table for refinement scan */ |
869 | if (cinfo->Ss == 0 && cinfo->Ah == 0) { | 869 | if (cinfo->Ss == 0 && cinfo->Ah == 0) { |
870 | tbl = compptr->dc_tbl_no; | 870 | tbl = compptr->dc_tbl_no; |
871 | if (tbl < 0 || tbl >= NUM_ARITH_TBLS) | 871 | if (tbl < 0 || tbl >= NUM_ARITH_TBLS) |
872 | ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); | 872 | ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); |
873 | if (entropy->dc_stats[tbl] == NULL) | 873 | if (entropy->dc_stats[tbl] == NULL) |
874 | entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) | 874 | entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) |
875 | ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS); | 875 | ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS); |
876 | MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS); | 876 | MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS); |
877 | /* Initialize DC predictions to 0 */ | 877 | /* Initialize DC predictions to 0 */ |
878 | entropy->last_dc_val[ci] = 0; | 878 | entropy->last_dc_val[ci] = 0; |
879 | entropy->dc_context[ci] = 0; | 879 | entropy->dc_context[ci] = 0; |
880 | } | 880 | } |
881 | /* AC needs no table when not present */ | 881 | /* AC needs no table when not present */ |
882 | if (cinfo->Se) { | 882 | if (cinfo->Se) { |
883 | tbl = compptr->ac_tbl_no; | 883 | tbl = compptr->ac_tbl_no; |
884 | if (tbl < 0 || tbl >= NUM_ARITH_TBLS) | 884 | if (tbl < 0 || tbl >= NUM_ARITH_TBLS) |
885 | ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); | 885 | ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); |
886 | if (entropy->ac_stats[tbl] == NULL) | 886 | if (entropy->ac_stats[tbl] == NULL) |
887 | entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) | 887 | entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) |
888 | ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS); | 888 | ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS); |
889 | MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS); | 889 | MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS); |
890 | #ifdef CALCULATE_SPECTRAL_CONDITIONING | 890 | #ifdef CALCULATE_SPECTRAL_CONDITIONING |
891 | if (cinfo->progressive_mode) | 891 | if (cinfo->progressive_mode) |
892 | /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */ | 892 | /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */ |
893 | cinfo->arith_ac_K[tbl] = cinfo->Ss + ((8 + cinfo->Se - cinfo->Ss) >> 4); | 893 | cinfo->arith_ac_K[tbl] = cinfo->Ss + ((8 + cinfo->Se - cinfo->Ss) >> 4); |
894 | #endif | 894 | #endif |
895 | } | 895 | } |
896 | } | 896 | } |
897 | 897 | ||
898 | /* Initialize arithmetic encoding variables */ | 898 | /* Initialize arithmetic encoding variables */ |
899 | entropy->c = 0; | 899 | entropy->c = 0; |
900 | entropy->a = 0x10000L; | 900 | entropy->a = 0x10000L; |
901 | entropy->sc = 0; | 901 | entropy->sc = 0; |
902 | entropy->zc = 0; | 902 | entropy->zc = 0; |
903 | entropy->ct = 11; | 903 | entropy->ct = 11; |
904 | entropy->buffer = -1; /* empty */ | 904 | entropy->buffer = -1; /* empty */ |
905 | 905 | ||
906 | /* Initialize restart stuff */ | 906 | /* Initialize restart stuff */ |
907 | entropy->restarts_to_go = cinfo->restart_interval; | 907 | entropy->restarts_to_go = cinfo->restart_interval; |
908 | entropy->next_restart_num = 0; | 908 | entropy->next_restart_num = 0; |
909 | } | 909 | } |
910 | 910 | ||
911 | 911 | ||
912 | /* | 912 | /* |
913 | * Module initialization routine for arithmetic entropy encoding. | 913 | * Module initialization routine for arithmetic entropy encoding. |
914 | */ | 914 | */ |
915 | 915 | ||
916 | GLOBAL(void) | 916 | GLOBAL(void) |
917 | jinit_arith_encoder (j_compress_ptr cinfo) | 917 | jinit_arith_encoder (j_compress_ptr cinfo) |
918 | { | 918 | { |
919 | arith_entropy_ptr entropy; | 919 | arith_entropy_ptr entropy; |
920 | int i; | 920 | int i; |
921 | 921 | ||
922 | entropy = (arith_entropy_ptr) | 922 | entropy = (arith_entropy_ptr) |
923 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | 923 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
924 | SIZEOF(arith_entropy_encoder)); | 924 | SIZEOF(arith_entropy_encoder)); |
925 | cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; | 925 | cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; |
926 | entropy->pub.start_pass = start_pass; | 926 | entropy->pub.start_pass = start_pass; |
927 | entropy->pub.finish_pass = finish_pass; | 927 | entropy->pub.finish_pass = finish_pass; |
928 | 928 | ||
929 | /* Mark tables unallocated */ | 929 | /* Mark tables unallocated */ |
930 | for (i = 0; i < NUM_ARITH_TBLS; i++) { | 930 | for (i = 0; i < NUM_ARITH_TBLS; i++) { |
931 | entropy->dc_stats[i] = NULL; | 931 | entropy->dc_stats[i] = NULL; |
932 | entropy->ac_stats[i] = NULL; | 932 | entropy->ac_stats[i] = NULL; |
933 | } | 933 | } |
934 | 934 | ||
935 | /* Initialize index for fixed probability estimation */ | 935 | /* Initialize index for fixed probability estimation */ |
936 | entropy->fixed_bin[0] = 113; | 936 | entropy->fixed_bin[0] = 113; |
937 | } | 937 | } |