Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4758 | right-hear | 1 | /* |
2 | * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium |
||
3 | * Copyright (c) 2002-2007, Professor Benoit Macq |
||
4 | * Copyright (c) 2001-2003, David Janssens |
||
5 | * Copyright (c) 2002-2003, Yannick Verschueren |
||
6 | * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe |
||
7 | * Copyright (c) 2005, Herve Drolon, FreeImage Team |
||
8 | * All rights reserved. |
||
9 | * |
||
10 | * Redistribution and use in source and binary forms, with or without |
||
11 | * modification, are permitted provided that the following conditions |
||
12 | * are met: |
||
13 | * 1. Redistributions of source code must retain the above copyright |
||
14 | * notice, this list of conditions and the following disclaimer. |
||
15 | * 2. Redistributions in binary form must reproduce the above copyright |
||
16 | * notice, this list of conditions and the following disclaimer in the |
||
17 | * documentation and/or other materials provided with the distribution. |
||
18 | * |
||
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' |
||
20 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||
21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||
22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
||
23 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
||
24 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
||
25 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
||
26 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
||
27 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||
28 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
||
29 | * POSSIBILITY OF SUCH DAMAGE. |
||
30 | */ |
||
31 | |||
32 | #include "opj_includes.h" |
||
33 | |||
34 | /** @defgroup MQC MQC - Implementation of an MQ-Coder */ |
||
35 | /*@{*/ |
||
36 | |||
37 | /** @name Local static functions */ |
||
38 | /*@{*/ |
||
39 | |||
40 | /** |
||
41 | Output a byte, doing bit-stuffing if necessary. |
||
42 | After a 0xff byte, the next byte must be smaller than 0x90. |
||
43 | @param mqc MQC handle |
||
44 | */ |
||
45 | static void mqc_byteout(opj_mqc_t *mqc); |
||
46 | /** |
||
47 | Renormalize mqc->a and mqc->c while encoding, so that mqc->a stays between 0x8000 and 0x10000 |
||
48 | @param mqc MQC handle |
||
49 | */ |
||
50 | static void mqc_renorme(opj_mqc_t *mqc); |
||
51 | /** |
||
52 | Encode the most probable symbol |
||
53 | @param mqc MQC handle |
||
54 | */ |
||
55 | static void mqc_codemps(opj_mqc_t *mqc); |
||
56 | /** |
||
57 | Encode the most least symbol |
||
58 | @param mqc MQC handle |
||
59 | */ |
||
60 | static void mqc_codelps(opj_mqc_t *mqc); |
||
61 | /** |
||
62 | Fill mqc->c with 1's for flushing |
||
63 | @param mqc MQC handle |
||
64 | */ |
||
65 | static void mqc_setbits(opj_mqc_t *mqc); |
||
66 | /** |
||
67 | FIXME: documentation ??? |
||
68 | @param mqc MQC handle |
||
69 | @return |
||
70 | */ |
||
71 | static INLINE int mqc_mpsexchange(opj_mqc_t *const mqc); |
||
72 | /** |
||
73 | FIXME: documentation ??? |
||
74 | @param mqc MQC handle |
||
75 | @return |
||
76 | */ |
||
77 | static INLINE int mqc_lpsexchange(opj_mqc_t *const mqc); |
||
78 | /** |
||
79 | Input a byte |
||
80 | @param mqc MQC handle |
||
81 | */ |
||
82 | static INLINE void mqc_bytein(opj_mqc_t *const mqc); |
||
83 | /** |
||
84 | Renormalize mqc->a and mqc->c while decoding |
||
85 | @param mqc MQC handle |
||
86 | */ |
||
87 | static INLINE void mqc_renormd(opj_mqc_t *const mqc); |
||
88 | /*@}*/ |
||
89 | |||
90 | /*@}*/ |
||
91 | |||
92 | /* |
||
93 | /* This array defines all the possible states for a context. */ |
||
94 | /* */ |
||
95 | static opj_mqc_state_t mqc_states[47 * 2] = { |
||
96 | {0x5601, 0, &mqc_states[2], &mqc_states[3]}, |
||
97 | {0x5601, 1, &mqc_states[3], &mqc_states[2]}, |
||
98 | {0x3401, 0, &mqc_states[4], &mqc_states[12]}, |
||
99 | {0x3401, 1, &mqc_states[5], &mqc_states[13]}, |
||
100 | {0x1801, 0, &mqc_states[6], &mqc_states[18]}, |
||
101 | {0x1801, 1, &mqc_states[7], &mqc_states[19]}, |
||
102 | {0x0ac1, 0, &mqc_states[8], &mqc_states[24]}, |
||
103 | {0x0ac1, 1, &mqc_states[9], &mqc_states[25]}, |
||
104 | {0x0521, 0, &mqc_states[10], &mqc_states[58]}, |
||
105 | {0x0521, 1, &mqc_states[11], &mqc_states[59]}, |
||
106 | {0x0221, 0, &mqc_states[76], &mqc_states[66]}, |
||
107 | {0x0221, 1, &mqc_states[77], &mqc_states[67]}, |
||
108 | {0x5601, 0, &mqc_states[14], &mqc_states[13]}, |
||
109 | {0x5601, 1, &mqc_states[15], &mqc_states[12]}, |
||
110 | {0x5401, 0, &mqc_states[16], &mqc_states[28]}, |
||
111 | {0x5401, 1, &mqc_states[17], &mqc_states[29]}, |
||
112 | {0x4801, 0, &mqc_states[18], &mqc_states[28]}, |
||
113 | {0x4801, 1, &mqc_states[19], &mqc_states[29]}, |
||
114 | {0x3801, 0, &mqc_states[20], &mqc_states[28]}, |
||
115 | {0x3801, 1, &mqc_states[21], &mqc_states[29]}, |
||
116 | {0x3001, 0, &mqc_states[22], &mqc_states[34]}, |
||
117 | {0x3001, 1, &mqc_states[23], &mqc_states[35]}, |
||
118 | {0x2401, 0, &mqc_states[24], &mqc_states[36]}, |
||
119 | {0x2401, 1, &mqc_states[25], &mqc_states[37]}, |
||
120 | {0x1c01, 0, &mqc_states[26], &mqc_states[40]}, |
||
121 | {0x1c01, 1, &mqc_states[27], &mqc_states[41]}, |
||
122 | {0x1601, 0, &mqc_states[58], &mqc_states[42]}, |
||
123 | {0x1601, 1, &mqc_states[59], &mqc_states[43]}, |
||
124 | {0x5601, 0, &mqc_states[30], &mqc_states[29]}, |
||
125 | {0x5601, 1, &mqc_states[31], &mqc_states[28]}, |
||
126 | {0x5401, 0, &mqc_states[32], &mqc_states[28]}, |
||
127 | {0x5401, 1, &mqc_states[33], &mqc_states[29]}, |
||
128 | {0x5101, 0, &mqc_states[34], &mqc_states[30]}, |
||
129 | {0x5101, 1, &mqc_states[35], &mqc_states[31]}, |
||
130 | {0x4801, 0, &mqc_states[36], &mqc_states[32]}, |
||
131 | {0x4801, 1, &mqc_states[37], &mqc_states[33]}, |
||
132 | {0x3801, 0, &mqc_states[38], &mqc_states[34]}, |
||
133 | {0x3801, 1, &mqc_states[39], &mqc_states[35]}, |
||
134 | {0x3401, 0, &mqc_states[40], &mqc_states[36]}, |
||
135 | {0x3401, 1, &mqc_states[41], &mqc_states[37]}, |
||
136 | {0x3001, 0, &mqc_states[42], &mqc_states[38]}, |
||
137 | {0x3001, 1, &mqc_states[43], &mqc_states[39]}, |
||
138 | {0x2801, 0, &mqc_states[44], &mqc_states[38]}, |
||
139 | {0x2801, 1, &mqc_states[45], &mqc_states[39]}, |
||
140 | {0x2401, 0, &mqc_states[46], &mqc_states[40]}, |
||
141 | {0x2401, 1, &mqc_states[47], &mqc_states[41]}, |
||
142 | {0x2201, 0, &mqc_states[48], &mqc_states[42]}, |
||
143 | {0x2201, 1, &mqc_states[49], &mqc_states[43]}, |
||
144 | {0x1c01, 0, &mqc_states[50], &mqc_states[44]}, |
||
145 | {0x1c01, 1, &mqc_states[51], &mqc_states[45]}, |
||
146 | {0x1801, 0, &mqc_states[52], &mqc_states[46]}, |
||
147 | {0x1801, 1, &mqc_states[53], &mqc_states[47]}, |
||
148 | {0x1601, 0, &mqc_states[54], &mqc_states[48]}, |
||
149 | {0x1601, 1, &mqc_states[55], &mqc_states[49]}, |
||
150 | {0x1401, 0, &mqc_states[56], &mqc_states[50]}, |
||
151 | {0x1401, 1, &mqc_states[57], &mqc_states[51]}, |
||
152 | {0x1201, 0, &mqc_states[58], &mqc_states[52]}, |
||
153 | {0x1201, 1, &mqc_states[59], &mqc_states[53]}, |
||
154 | {0x1101, 0, &mqc_states[60], &mqc_states[54]}, |
||
155 | {0x1101, 1, &mqc_states[61], &mqc_states[55]}, |
||
156 | {0x0ac1, 0, &mqc_states[62], &mqc_states[56]}, |
||
157 | {0x0ac1, 1, &mqc_states[63], &mqc_states[57]}, |
||
158 | {0x09c1, 0, &mqc_states[64], &mqc_states[58]}, |
||
159 | {0x09c1, 1, &mqc_states[65], &mqc_states[59]}, |
||
160 | {0x08a1, 0, &mqc_states[66], &mqc_states[60]}, |
||
161 | {0x08a1, 1, &mqc_states[67], &mqc_states[61]}, |
||
162 | {0x0521, 0, &mqc_states[68], &mqc_states[62]}, |
||
163 | {0x0521, 1, &mqc_states[69], &mqc_states[63]}, |
||
164 | {0x0441, 0, &mqc_states[70], &mqc_states[64]}, |
||
165 | {0x0441, 1, &mqc_states[71], &mqc_states[65]}, |
||
166 | {0x02a1, 0, &mqc_states[72], &mqc_states[66]}, |
||
167 | {0x02a1, 1, &mqc_states[73], &mqc_states[67]}, |
||
168 | {0x0221, 0, &mqc_states[74], &mqc_states[68]}, |
||
169 | {0x0221, 1, &mqc_states[75], &mqc_states[69]}, |
||
170 | {0x0141, 0, &mqc_states[76], &mqc_states[70]}, |
||
171 | {0x0141, 1, &mqc_states[77], &mqc_states[71]}, |
||
172 | {0x0111, 0, &mqc_states[78], &mqc_states[72]}, |
||
173 | {0x0111, 1, &mqc_states[79], &mqc_states[73]}, |
||
174 | {0x0085, 0, &mqc_states[80], &mqc_states[74]}, |
||
175 | {0x0085, 1, &mqc_states[81], &mqc_states[75]}, |
||
176 | {0x0049, 0, &mqc_states[82], &mqc_states[76]}, |
||
177 | {0x0049, 1, &mqc_states[83], &mqc_states[77]}, |
||
178 | {0x0025, 0, &mqc_states[84], &mqc_states[78]}, |
||
179 | {0x0025, 1, &mqc_states[85], &mqc_states[79]}, |
||
180 | {0x0015, 0, &mqc_states[86], &mqc_states[80]}, |
||
181 | {0x0015, 1, &mqc_states[87], &mqc_states[81]}, |
||
182 | {0x0009, 0, &mqc_states[88], &mqc_states[82]}, |
||
183 | {0x0009, 1, &mqc_states[89], &mqc_states[83]}, |
||
184 | {0x0005, 0, &mqc_states[90], &mqc_states[84]}, |
||
185 | {0x0005, 1, &mqc_states[91], &mqc_states[85]}, |
||
186 | {0x0001, 0, &mqc_states[90], &mqc_states[86]}, |
||
187 | {0x0001, 1, &mqc_states[91], &mqc_states[87]}, |
||
188 | {0x5601, 0, &mqc_states[92], &mqc_states[92]}, |
||
189 | {0x5601, 1, &mqc_states[93], &mqc_states[93]}, |
||
190 | }; |
||
191 | |||
192 | /* |
||
193 | ========================================================== |
||
194 | local functions |
||
195 | ========================================================== |
||
196 | */ |
||
197 | |||
198 | static void mqc_byteout(opj_mqc_t *mqc) { |
||
199 | if (*mqc->bp == 0xff) { |
||
200 | mqc->bp++; |
||
201 | *mqc->bp = mqc->c >> 20; |
||
202 | mqc->c &= 0xfffff; |
||
203 | mqc->ct = 7; |
||
204 | } else { |
||
205 | if ((mqc->c & 0x8000000) == 0) { /* ((mqc->c&0x8000000)==0) CHANGE */ |
||
206 | mqc->bp++; |
||
207 | *mqc->bp = mqc->c >> 19; |
||
208 | mqc->c &= 0x7ffff; |
||
209 | mqc->ct = 8; |
||
210 | } else { |
||
211 | (*mqc->bp)++; |
||
212 | if (*mqc->bp == 0xff) { |
||
213 | mqc->c &= 0x7ffffff; |
||
214 | mqc->bp++; |
||
215 | *mqc->bp = mqc->c >> 20; |
||
216 | mqc->c &= 0xfffff; |
||
217 | mqc->ct = 7; |
||
218 | } else { |
||
219 | mqc->bp++; |
||
220 | *mqc->bp = mqc->c >> 19; |
||
221 | mqc->c &= 0x7ffff; |
||
222 | mqc->ct = 8; |
||
223 | } |
||
224 | } |
||
225 | } |
||
226 | } |
||
227 | |||
228 | static void mqc_renorme(opj_mqc_t *mqc) { |
||
229 | do { |
||
230 | mqc->a <<= 1; |
||
231 | mqc->c <<= 1; |
||
232 | mqc->ct--; |
||
233 | if (mqc->ct == 0) { |
||
234 | mqc_byteout(mqc); |
||
235 | } |
||
236 | } while ((mqc->a & 0x8000) == 0); |
||
237 | } |
||
238 | |||
239 | static void mqc_codemps(opj_mqc_t *mqc) { |
||
240 | mqc->a -= (*mqc->curctx)->qeval; |
||
241 | if ((mqc->a & 0x8000) == 0) { |
||
242 | if (mqc->a < (*mqc->curctx)->qeval) { |
||
243 | mqc->a = (*mqc->curctx)->qeval; |
||
244 | } else { |
||
245 | mqc->c += (*mqc->curctx)->qeval; |
||
246 | } |
||
247 | *mqc->curctx = (*mqc->curctx)->nmps; |
||
248 | mqc_renorme(mqc); |
||
249 | } else { |
||
250 | mqc->c += (*mqc->curctx)->qeval; |
||
251 | } |
||
252 | } |
||
253 | |||
254 | static void mqc_codelps(opj_mqc_t *mqc) { |
||
255 | mqc->a -= (*mqc->curctx)->qeval; |
||
256 | if (mqc->a < (*mqc->curctx)->qeval) { |
||
257 | mqc->c += (*mqc->curctx)->qeval; |
||
258 | } else { |
||
259 | mqc->a = (*mqc->curctx)->qeval; |
||
260 | } |
||
261 | *mqc->curctx = (*mqc->curctx)->nlps; |
||
262 | mqc_renorme(mqc); |
||
263 | } |
||
264 | |||
265 | static void mqc_setbits(opj_mqc_t *mqc) { |
||
266 | unsigned int tempc = mqc->c + mqc->a; |
||
267 | mqc->c |= 0xffff; |
||
268 | if (mqc->c >= tempc) { |
||
269 | mqc->c -= 0x8000; |
||
270 | } |
||
271 | } |
||
272 | |||
273 | static INLINE int mqc_mpsexchange(opj_mqc_t *const mqc) { |
||
274 | int d; |
||
275 | if (mqc->a < (*mqc->curctx)->qeval) { |
||
276 | d = 1 - (*mqc->curctx)->mps; |
||
277 | *mqc->curctx = (*mqc->curctx)->nlps; |
||
278 | } else { |
||
279 | d = (*mqc->curctx)->mps; |
||
280 | *mqc->curctx = (*mqc->curctx)->nmps; |
||
281 | } |
||
282 | |||
283 | return d; |
||
284 | } |
||
285 | |||
286 | static INLINE int mqc_lpsexchange(opj_mqc_t *const mqc) { |
||
287 | int d; |
||
288 | if (mqc->a < (*mqc->curctx)->qeval) { |
||
289 | mqc->a = (*mqc->curctx)->qeval; |
||
290 | d = (*mqc->curctx)->mps; |
||
291 | *mqc->curctx = (*mqc->curctx)->nmps; |
||
292 | } else { |
||
293 | mqc->a = (*mqc->curctx)->qeval; |
||
294 | d = 1 - (*mqc->curctx)->mps; |
||
295 | *mqc->curctx = (*mqc->curctx)->nlps; |
||
296 | } |
||
297 | |||
298 | return d; |
||
299 | } |
||
300 | |||
301 | #ifdef MQC_PERF_OPT |
||
302 | static INLINE void mqc_bytein(opj_mqc_t *const mqc) { |
||
303 | unsigned int i = *((unsigned int *) mqc->bp); |
||
304 | mqc->c += i & 0xffff00; |
||
305 | mqc->ct = i & 0x0f; |
||
306 | mqc->bp += (i >> 2) & 0x04; |
||
307 | } |
||
308 | #else |
||
309 | static void mqc_bytein(opj_mqc_t *const mqc) { |
||
310 | if (mqc->bp != mqc->end) { |
||
311 | unsigned int c; |
||
312 | if (mqc->bp + 1 != mqc->end) { |
||
313 | c = *(mqc->bp + 1); |
||
314 | } else { |
||
315 | c = 0xff; |
||
316 | } |
||
317 | if (*mqc->bp == 0xff) { |
||
318 | if (c > 0x8f) { |
||
319 | mqc->c += 0xff00; |
||
320 | mqc->ct = 8; |
||
321 | } else { |
||
322 | mqc->bp++; |
||
323 | mqc->c += c << 9; |
||
324 | mqc->ct = 7; |
||
325 | } |
||
326 | } else { |
||
327 | mqc->bp++; |
||
328 | mqc->c += c << 8; |
||
329 | mqc->ct = 8; |
||
330 | } |
||
331 | } else { |
||
332 | mqc->c += 0xff00; |
||
333 | mqc->ct = 8; |
||
334 | } |
||
335 | } |
||
336 | #endif |
||
337 | |||
338 | static INLINE void mqc_renormd(opj_mqc_t *const mqc) { |
||
339 | do { |
||
340 | if (mqc->ct == 0) { |
||
341 | mqc_bytein(mqc); |
||
342 | } |
||
343 | mqc->a <<= 1; |
||
344 | mqc->c <<= 1; |
||
345 | mqc->ct--; |
||
346 | } while (mqc->a < 0x8000); |
||
347 | } |
||
348 | |||
349 | /* |
||
350 | ========================================================== |
||
351 | MQ-Coder interface |
||
352 | ========================================================== |
||
353 | */ |
||
354 | |||
355 | opj_mqc_t* mqc_create(void) { |
||
356 | opj_mqc_t *mqc = (opj_mqc_t*)opj_malloc(sizeof(opj_mqc_t)); |
||
357 | #ifdef MQC_PERF_OPT |
||
358 | mqc->buffer = NULL; |
||
359 | #endif |
||
360 | return mqc; |
||
361 | } |
||
362 | |||
363 | void mqc_destroy(opj_mqc_t *mqc) { |
||
364 | if(mqc) { |
||
365 | #ifdef MQC_PERF_OPT |
||
366 | if (mqc->buffer) { |
||
367 | opj_free(mqc->buffer); |
||
368 | } |
||
369 | #endif |
||
370 | opj_free(mqc); |
||
371 | } |
||
372 | } |
||
373 | |||
374 | int mqc_numbytes(opj_mqc_t *mqc) { |
||
375 | return mqc->bp - mqc->start; |
||
376 | } |
||
377 | |||
378 | void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp) { |
||
379 | mqc_setcurctx(mqc, 0); |
||
380 | mqc->a = 0x8000; |
||
381 | mqc->c = 0; |
||
382 | mqc->bp = bp - 1; |
||
383 | mqc->ct = 12; |
||
384 | if (*mqc->bp == 0xff) { |
||
385 | mqc->ct = 13; |
||
386 | } |
||
387 | mqc->start = bp; |
||
388 | } |
||
389 | |||
390 | void mqc_encode(opj_mqc_t *mqc, int d) { |
||
391 | if ((*mqc->curctx)->mps == d) { |
||
392 | mqc_codemps(mqc); |
||
393 | } else { |
||
394 | mqc_codelps(mqc); |
||
395 | } |
||
396 | } |
||
397 | |||
398 | void mqc_flush(opj_mqc_t *mqc) { |
||
399 | mqc_setbits(mqc); |
||
400 | mqc->c <<= mqc->ct; |
||
401 | mqc_byteout(mqc); |
||
402 | mqc->c <<= mqc->ct; |
||
403 | mqc_byteout(mqc); |
||
404 | |||
405 | if (*mqc->bp != 0xff) { |
||
406 | mqc->bp++; |
||
407 | } |
||
408 | } |
||
409 | |||
410 | void mqc_bypass_init_enc(opj_mqc_t *mqc) { |
||
411 | mqc->c = 0; |
||
412 | mqc->ct = 8; |
||
413 | /*if (*mqc->bp == 0xff) { |
||
414 | mqc->ct = 7; |
||
415 | } */ |
||
416 | } |
||
417 | |||
418 | void mqc_bypass_enc(opj_mqc_t *mqc, int d) { |
||
419 | mqc->ct--; |
||
420 | mqc->c = mqc->c + (d << mqc->ct); |
||
421 | if (mqc->ct == 0) { |
||
422 | mqc->bp++; |
||
423 | *mqc->bp = mqc->c; |
||
424 | mqc->ct = 8; |
||
425 | if (*mqc->bp == 0xff) { |
||
426 | mqc->ct = 7; |
||
427 | } |
||
428 | mqc->c = 0; |
||
429 | } |
||
430 | } |
||
431 | |||
432 | int mqc_bypass_flush_enc(opj_mqc_t *mqc) { |
||
433 | unsigned char bit_padding; |
||
434 | |||
435 | bit_padding = 0; |
||
436 | |||
437 | if (mqc->ct != 0) { |
||
438 | while (mqc->ct > 0) { |
||
439 | mqc->ct--; |
||
440 | mqc->c += bit_padding << mqc->ct; |
||
441 | bit_padding = (bit_padding + 1) & 0x01; |
||
442 | } |
||
443 | mqc->bp++; |
||
444 | *mqc->bp = mqc->c; |
||
445 | mqc->ct = 8; |
||
446 | mqc->c = 0; |
||
447 | } |
||
448 | |||
449 | return 1; |
||
450 | } |
||
451 | |||
452 | void mqc_reset_enc(opj_mqc_t *mqc) { |
||
453 | mqc_resetstates(mqc); |
||
454 | mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46); |
||
455 | mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3); |
||
456 | mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4); |
||
457 | } |
||
458 | |||
459 | int mqc_restart_enc(opj_mqc_t *mqc) { |
||
460 | int correction = 1; |
||
461 | |||
462 | /* |
||
463 | int n = 27 - 15 - mqc->ct; |
||
464 | mqc->c <<= mqc->ct; |
||
465 | while (n > 0) { |
||
466 | mqc_byteout(mqc); |
||
467 | n -= mqc->ct; |
||
468 | mqc->c <<= mqc->ct; |
||
469 | } |
||
470 | mqc_byteout(mqc); |
||
471 | |||
472 | return correction; |
||
473 | } |
||
474 | |||
475 | void mqc_restart_init_enc(opj_mqc_t *mqc) { |
||
476 | /* |
||
477 | mqc_setcurctx(mqc, 0); |
||
478 | mqc->a = 0x8000; |
||
479 | mqc->c = 0; |
||
480 | mqc->ct = 12; |
||
481 | mqc->bp--; |
||
482 | if (*mqc->bp == 0xff) { |
||
483 | mqc->ct = 13; |
||
484 | } |
||
485 | } |
||
486 | |||
487 | void mqc_erterm_enc(opj_mqc_t *mqc) { |
||
488 | int k = 11 - mqc->ct + 1; |
||
489 | |||
490 | while (k > 0) { |
||
491 | mqc->c <<= mqc->ct; |
||
492 | mqc->ct = 0; |
||
493 | mqc_byteout(mqc); |
||
494 | k -= mqc->ct; |
||
495 | } |
||
496 | |||
497 | if (*mqc->bp != 0xff) { |
||
498 | mqc_byteout(mqc); |
||
499 | } |
||
500 | } |
||
501 | |||
502 | void mqc_segmark_enc(opj_mqc_t *mqc) { |
||
503 | int i; |
||
504 | mqc_setcurctx(mqc, 18); |
||
505 | |||
506 | for (i = 1; i < 5; i++) { |
||
507 | mqc_encode(mqc, i % 2); |
||
508 | } |
||
509 | } |
||
510 | |||
511 | void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len) { |
||
512 | mqc_setcurctx(mqc, 0); |
||
513 | mqc->start = bp; |
||
514 | mqc->end = bp + len; |
||
515 | mqc->bp = bp; |
||
516 | if (len==0) mqc->c = 0xff << 16; |
||
517 | else mqc->c = *mqc->bp << 16; |
||
518 | |||
519 | #ifdef MQC_PERF_OPT |
||
520 | { |
||
521 | unsigned int c; |
||
522 | unsigned int *ip; |
||
523 | unsigned char *end = mqc->end - 1; |
||
524 | mqc->buffer = opj_realloc(mqc->buffer, (2 * len + 1) * sizeof(unsigned int)); |
||
525 | ip = (unsigned int *) mqc->buffer; |
||
526 | |||
527 | while (bp != end) { |
||
528 | c = *(bp + 1); |
||
529 | if (*bp == 0xff) { |
||
530 | if (c > 0x8f) { |
||
531 | *ip = 0x0000ff18; |
||
532 | } else { |
||
533 | bp++; |
||
534 | *ip = 0x00000017 | (c << 9); |
||
535 | } |
||
536 | } else { |
||
537 | bp++; |
||
538 | *ip = 0x00000018 | (c << 8); |
||
539 | } |
||
540 | ip++; |
||
541 | } |
||
542 | |||
543 | /* Handle last byte of data */ |
||
544 | c = 0xff; |
||
545 | if (*bp == 0xff) { |
||
546 | *ip = 0x0000ff18; |
||
547 | } else { |
||
548 | bp++; |
||
549 | *ip = 0x00000018 | (c << 8); |
||
550 | } |
||
551 | ip++; |
||
552 | |||
553 | *ip = 0x0000ff08; |
||
554 | mqc->bp = mqc->buffer; |
||
555 | } |
||
556 | #endif |
||
557 | mqc_bytein(mqc); |
||
558 | mqc->c <<= 7; |
||
559 | mqc->ct -= 7; |
||
560 | mqc->a = 0x8000; |
||
561 | } |
||
562 | |||
563 | int mqc_decode(opj_mqc_t *const mqc) { |
||
564 | int d; |
||
565 | mqc->a -= (*mqc->curctx)->qeval; |
||
566 | if ((mqc->c >> 16) < (*mqc->curctx)->qeval) { |
||
567 | d = mqc_lpsexchange(mqc); |
||
568 | mqc_renormd(mqc); |
||
569 | } else { |
||
570 | mqc->c -= (*mqc->curctx)->qeval << 16; |
||
571 | if ((mqc->a & 0x8000) == 0) { |
||
572 | d = mqc_mpsexchange(mqc); |
||
573 | mqc_renormd(mqc); |
||
574 | } else { |
||
575 | d = (*mqc->curctx)->mps; |
||
576 | } |
||
577 | } |
||
578 | |||
579 | return d; |
||
580 | } |
||
581 | |||
582 | void mqc_resetstates(opj_mqc_t *mqc) { |
||
583 | int i; |
||
584 | for (i = 0; i < MQC_NUMCTXS; i++) { |
||
585 | mqc->ctxs[i] = mqc_states; |
||
586 | } |
||
587 | } |
||
588 | |||
589 | void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob) { |
||
590 | mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)]; |
||
591 | }><>>><>>=><=>><>><>><>><>><>>=><=>=><=>=><=>><>><>=><=>=><=>>=><=>=><=>><>><>>>>>=><=>=><=> |
||
592 |