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