src/lib/openjp3d/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, Herve 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 Exchange MPS with LPS\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 Exchange LPS with MPS\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 void mqc_reset_enc_3(opj_mqc_t *mqc) {\r
 447         mqc_resetstates(mqc);\r
 448         mqc_setstate(mqc, T1_3D_CTXNO_UNI, 0, 46);\r
 449         mqc_setstate(mqc, T1_3D_CTXNO_AGG, 0, 3);\r
 450         mqc_setstate(mqc, T1_3D_CTXNO_ZC, 0, 4);\r
 451 }\r
 452 \r
 453 int mqc_restart_enc(opj_mqc_t *mqc) {\r
 454         int correction = 1;\r
 455         \r
 456         /* <flush part> */\r
 457         int n = 27 - 15 - mqc->ct;\r
 458         mqc->c <<= mqc->ct;\r
 459         while (n > 0) {\r
 460                 mqc_byteout(mqc);\r
 461                 n -= mqc->ct;\r
 462                 mqc->c <<= mqc->ct;\r
 463         }\r
 464         mqc_byteout(mqc);\r
 465         \r
 466         return correction;\r
 467 }\r
 468 \r
 469 void mqc_restart_init_enc(opj_mqc_t *mqc) {\r
 470         /* <Re-init part> */\r
 471         mqc_setcurctx(mqc, 0);\r
 472         mqc->a = 0x8000;\r
 473         mqc->c = 0;\r
 474         mqc->ct = 12;\r
 475         mqc->bp--;\r
 476         if (*mqc->bp == 0xff) {\r
 477                 mqc->ct = 13;\r
 478         }\r
 479 }\r
 480 \r
 481 void mqc_erterm_enc(opj_mqc_t *mqc) {\r
 482         int k = 11 - mqc->ct + 1;\r
 483         \r
 484         while (k > 0) {\r
 485                 mqc->c <<= mqc->ct;\r
 486                 mqc->ct = 0;\r
 487                 mqc_byteout(mqc);\r
 488                 k -= mqc->ct;\r
 489         }\r
 490         \r
 491         if (*mqc->bp != 0xff) {\r
 492                 mqc_byteout(mqc);\r
 493         }\r
 494 }\r
 495 \r
 496 void mqc_segmark_enc(opj_mqc_t *mqc) {\r
 497         int i;\r
 498         mqc_setcurctx(mqc, 18);\r
 499         \r
 500         for (i = 1; i < 5; i++) {\r
 501                 mqc_encode(mqc, i % 2);\r
 502         }\r
 503 }\r
 504 \r
 505 void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len) {\r
 506         mqc_setcurctx(mqc, 0);\r
 507         mqc->start = bp;\r
 508         mqc->end = bp + len;\r
 509         mqc->bp = bp;\r
 510         if (len==0) mqc->c = 0xff << 16;\r
 511         else mqc->c = *mqc->bp << 16;\r
 512         mqc_bytein(mqc);\r
 513         mqc->c <<= 7;\r
 514         mqc->ct -= 7;\r
 515         mqc->a = 0x8000;\r
 516 }\r
 517 \r
 518 int mqc_decode(opj_mqc_t *mqc) {\r
 519         int d;\r
 520         mqc->a -= (*mqc->curctx)->qeval;\r
 521         if ((mqc->c >> 16) < (*mqc->curctx)->qeval) {\r
 522                 d = mqc_lpsexchange(mqc);\r
 523                 mqc_renormd(mqc);\r
 524         } else {\r
 525                 mqc->c -= (*mqc->curctx)->qeval << 16;\r
 526                 if ((mqc->a & 0x8000) == 0) {\r
 527                         d = mqc_mpsexchange(mqc);\r
 528                         mqc_renormd(mqc);\r
 529                 } else {\r
 530                         d = (*mqc->curctx)->mps;\r
 531                 }\r
 532         }\r
 533 \r
 534         return d;\r
 535 }\r
 536 \r
 537 void mqc_resetstates(opj_mqc_t *mqc) {\r
 538         int i;\r
 539         for (i = 0; i < MQC_NUMCTXS; i++) {\r
 540                 mqc->ctxs[i] = mqc_states;\r
 541         }\r
 542 }\r
 543 \r
 544 void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob) {\r
 545         mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];\r
 546 }\r
 547 \r
 548 \r