src/gdcmopenjpeg/libopenjpeg/mqc.c

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