v2/libopenjpeg/t1.c

   1 /*\r
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium\r
   3  * Copyright (c) 2002-2007, Professor Benoit Macq\r
   4  * Copyright (c) 2001-2003, David Janssens\r
   5  * Copyright (c) 2002-2003, Yannick Verschueren\r
   6  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe\r
   7  * Copyright (c) 2005, Herve Drolon, FreeImage Team\r
   8  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>\r
   9  * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>\r
  10  * All rights reserved.\r
  11  *\r
  12  * Redistribution and use in source and binary forms, with or without\r
  13  * modification, are permitted provided that the following conditions\r
  14  * are met:\r
  15  * 1. Redistributions of source code must retain the above copyright\r
  16  *    notice, this list of conditions and the following disclaimer.\r
  17  * 2. Redistributions in binary form must reproduce the above copyright\r
  18  *    notice, this list of conditions and the following disclaimer in the\r
  19  *    documentation and/or other materials provided with the distribution.\r
  20  *\r
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
  31  * POSSIBILITY OF SUCH DAMAGE.\r
  32  */\r
  33 \r
  34 #include "t1.h"\r
  35 #include "t1_luts.h"\r
  36 #include "opj_includes.h"\r
  37 #include "j2k.h"\r
  38 #include "tcd.h"\r
  39 #include "mqc.h"\r
  40 #include "raw.h"\r
  41 #include "opj_malloc.h"\r
  42 #include "int.h"\r
  43 #include "dwt.h"\r
  44 #include "fix.h"\r
  45 /** @defgroup T1 T1 - Implementation of the tier-1 coding */\r
  46 /*@{*/\r
  47 \r
  48 /** @name Local static functions */\r
  49 /*@{*/\r
  50 \r
  51 static INLINE OPJ_BYTE t1_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient);\r
  52 static OPJ_BYTE t1_getctxno_sc(OPJ_UINT32 f);\r
  53 static INLINE OPJ_UINT32 t1_getctxno_mag(OPJ_UINT32 f);\r
  54 static OPJ_BYTE t1_getspb(OPJ_UINT32 f);\r
  55 static OPJ_INT16 t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos);\r
  56 static OPJ_INT16 t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos);\r
  57 static void t1_updateflags(flag_t *flagsp, OPJ_UINT32 s, OPJ_UINT32 stride);\r
  58 /**\r
  59 Encode significant pass\r
  60 */\r
  61 static void t1_enc_sigpass_step(\r
  62                 opj_t1_t *t1,\r
  63                 flag_t *flagsp,\r
  64                 OPJ_INT32 *datap,\r
  65                 OPJ_UINT32 orient,\r
  66                 OPJ_INT32 bpno,\r
  67                 OPJ_INT32 one,\r
  68                 OPJ_INT32 *nmsedec,\r
  69                 OPJ_BYTE type,\r
  70                 OPJ_UINT32 vsc);\r
  71 /**\r
  72 Decode significant pass\r
  73 */\r
  74 static void t1_dec_sigpass_step(\r
  75                 opj_t1_t *t1,\r
  76                 flag_t *flagsp,\r
  77                 OPJ_INT32 *datap,\r
  78                 OPJ_UINT32 orient,\r
  79                 OPJ_INT32 oneplushalf,\r
  80                 OPJ_BYTE type,\r
  81                 OPJ_UINT32 vsc);\r
  82 /**\r
  83 Encode significant pass\r
  84 */\r
  85 static void t1_enc_sigpass(\r
  86                 opj_t1_t *t1,\r
  87                 OPJ_INT32 bpno,\r
  88                 OPJ_UINT32 orient,\r
  89                 OPJ_INT32 *nmsedec,\r
  90                 OPJ_BYTE type,\r
  91                 OPJ_UINT32 cblksty);\r
  92 /**\r
  93 Decode significant pass\r
  94 */\r
  95 static void t1_dec_sigpass(\r
  96                 opj_t1_t *t1,\r
  97                 OPJ_INT32 bpno,\r
  98                 OPJ_UINT32 orient,\r
  99                 OPJ_BYTE type,\r
 100                 OPJ_UINT32 cblksty);\r
 101 /**\r
 102 Encode refinement pass\r
 103 */\r
 104 static void t1_enc_refpass_step(\r
 105                 opj_t1_t *t1,\r
 106                 flag_t *flagsp,\r
 107                 OPJ_INT32 *datap,\r
 108                 OPJ_INT32 bpno,\r
 109                 OPJ_INT32 one,\r
 110                 OPJ_INT32 *nmsedec,\r
 111                 OPJ_BYTE type,\r
 112                 OPJ_UINT32 vsc);\r
 113 /**\r
 114 Decode refinement pass\r
 115 */\r
 116 static void t1_dec_refpass_step(\r
 117                 opj_t1_t *t1,\r
 118                 flag_t *flagsp,\r
 119                 OPJ_INT32 *datap,\r
 120                 OPJ_INT32 poshalf,\r
 121                 OPJ_INT32 neghalf,\r
 122                 OPJ_BYTE type,\r
 123                 OPJ_UINT32 vsc);\r
 124 /**\r
 125 Encode refinement pass\r
 126 */\r
 127 static void t1_enc_refpass(\r
 128                 opj_t1_t *t1,\r
 129                 OPJ_INT32 bpno,\r
 130                 OPJ_INT32 *nmsedec,\r
 131                 OPJ_BYTE type,\r
 132                 OPJ_UINT32 cblksty);\r
 133 /**\r
 134 Decode refinement pass\r
 135 */\r
 136 static void t1_dec_refpass(\r
 137                 opj_t1_t *t1,\r
 138                 OPJ_INT32 bpno,\r
 139                 OPJ_BYTE type,\r
 140                 OPJ_UINT32 cblksty);\r
 141 /**\r
 142 Encode clean-up pass\r
 143 */\r
 144 static void t1_enc_clnpass_step(\r
 145                 opj_t1_t *t1,\r
 146                 flag_t *flagsp,\r
 147                 OPJ_INT32 *datap,\r
 148                 OPJ_UINT32 orient,\r
 149                 OPJ_INT32 bpno,\r
 150                 OPJ_INT32 one,\r
 151                 OPJ_INT32 *nmsedec,\r
 152                 OPJ_UINT32 partial,\r
 153                 OPJ_UINT32 vsc);\r
 154 /**\r
 155 Decode clean-up pass\r
 156 */\r
 157 static void t1_dec_clnpass_step(\r
 158                 opj_t1_t *t1,\r
 159                 flag_t *flagsp,\r
 160                 OPJ_INT32 *datap,\r
 161                 OPJ_UINT32 orient,\r
 162                 OPJ_INT32 oneplushalf,\r
 163                 OPJ_UINT32 partial,\r
 164                 OPJ_UINT32 vsc);\r
 165 /**\r
 166 Encode clean-up pass\r
 167 */\r
 168 static void t1_enc_clnpass(\r
 169                 opj_t1_t *t1,\r
 170                 OPJ_INT32 bpno,\r
 171                 OPJ_UINT32 orient,\r
 172                 OPJ_INT32 *nmsedec,\r
 173                 OPJ_UINT32 cblksty);\r
 174 /**\r
 175 Decode clean-up pass\r
 176 */\r
 177 static void t1_dec_clnpass(\r
 178                 opj_t1_t *t1,\r
 179                 OPJ_INT32 bpno,\r
 180                 OPJ_UINT32 orient,\r
 181                 OPJ_UINT32 cblksty);\r
 182 \r
 183 static OPJ_FLOAT64 t1_getwmsedec(\r
 184                 OPJ_INT32 nmsedec,\r
 185                 OPJ_UINT32 compno,\r
 186                 OPJ_UINT32 level,\r
 187                 OPJ_UINT32 orient,\r
 188                 OPJ_INT32 bpno,\r
 189                 OPJ_UINT32 qmfbid,\r
 190                 OPJ_FLOAT64 stepsize,\r
 191                 OPJ_UINT32 numcomps,\r
 192                 const OPJ_FLOAT64 * mct_norms);\r
 193 /**\r
 194 Encode 1 code-block\r
 195 @param t1 T1 handle\r
 196 @param cblk Code-block coding parameters\r
 197 @param orient\r
 198 @param compno Component number\r
 199 @param level\r
 200 @param qmfbid\r
 201 @param stepsize\r
 202 @param cblksty Code-block style\r
 203 @param numcomps\r
 204 @param tile\r
 205 */\r
 206 static void t1_encode_cblk(\r
 207                 opj_t1_t *t1,\r
 208                 opj_tcd_cblk_enc_t* cblk,\r
 209                 OPJ_UINT32 orient,\r
 210                 OPJ_UINT32 compno,\r
 211                 OPJ_UINT32 level,\r
 212                 OPJ_UINT32 qmfbid,\r
 213                 OPJ_FLOAT64 stepsize,\r
 214                 OPJ_UINT32 cblksty,\r
 215                 OPJ_UINT32 numcomps,\r
 216                 opj_tcd_tile_t * tile,\r
 217                 const OPJ_FLOAT64 * mct_norms);\r
 218 /**\r
 219 Decode 1 code-block\r
 220 @param t1 T1 handle\r
 221 @param cblk Code-block coding parameters\r
 222 @param orient\r
 223 @param roishift Region of interest shifting value\r
 224 @param cblksty Code-block style\r
 225 */\r
 226 static void t1_decode_cblk(\r
 227                 opj_t1_t *t1,\r
 228                 opj_tcd_cblk_dec_t* cblk,\r
 229                 OPJ_UINT32 orient,\r
 230                 OPJ_UINT32 roishift,\r
 231                 OPJ_UINT32 cblksty);\r
 232 \r
 233 /*@}*/\r
 234 \r
 235 /*@}*/\r
 236 \r
 237 /* ----------------------------------------------------------------------- */\r
 238 \r
 239 static OPJ_BYTE t1_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient) {\r
 240         return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];\r
 241 }\r
 242 \r
 243 static OPJ_BYTE t1_getctxno_sc(OPJ_UINT32 f) {\r
 244         return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];\r
 245 }\r
 246 \r
 247 static OPJ_UINT32 t1_getctxno_mag(OPJ_UINT32 f) {\r
 248         OPJ_UINT32 tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;\r
 249         OPJ_UINT32 tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;\r
 250         return (tmp2);\r
 251 }\r
 252 \r
 253 static OPJ_BYTE t1_getspb(OPJ_UINT32 f) {\r
 254         return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];\r
 255 }\r
 256 \r
 257 static OPJ_INT16 t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos) \r
 258 {\r
 259         if (bitpos > T1_NMSEDEC_FRACBITS) {\r
 260                 return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];\r
 261         }\r
 262         \r
 263         return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];\r
 264 }\r
 265 \r
 266 static OPJ_INT16 t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos) {\r
 267         if (bitpos > T1_NMSEDEC_FRACBITS) {\r
 268                 return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];\r
 269         }\r
 270 \r
 271     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];\r
 272 }\r
 273 \r
 274 static void t1_updateflags(flag_t *flagsp, OPJ_UINT32 s, OPJ_UINT32 stride) {\r
 275         flag_t *np = flagsp - stride;\r
 276         flag_t *sp = flagsp + stride;\r
 277 \r
 278         static const flag_t mod[] = {\r
 279                 T1_SIG_S, T1_SIG_S|T1_SGN_S,\r
 280                 T1_SIG_E, T1_SIG_E|T1_SGN_E,\r
 281                 T1_SIG_W, T1_SIG_W|T1_SGN_W,\r
 282                 T1_SIG_N, T1_SIG_N|T1_SGN_N\r
 283         };\r
 284 \r
 285         np[-1] |= T1_SIG_SE;\r
 286         np[0]  |= mod[s];\r
 287         np[1]  |= T1_SIG_SW;\r
 288 \r
 289         flagsp[-1] |= mod[s+2];\r
 290         flagsp[0]  |= T1_SIG;\r
 291         flagsp[1]  |= mod[s+4];\r
 292 \r
 293         sp[-1] |= T1_SIG_NE;\r
 294         sp[0]  |= mod[s+6];\r
 295         sp[1]  |= T1_SIG_NW;\r
 296 }\r
 297 \r
 298 static void t1_enc_sigpass_step(\r
 299                 opj_t1_t *t1,\r
 300                 flag_t *flagsp,\r
 301                 OPJ_INT32 *datap,\r
 302                 OPJ_UINT32 orient,\r
 303                 OPJ_INT32 bpno,\r
 304                 OPJ_INT32 one,\r
 305                 OPJ_INT32 *nmsedec,\r
 306                 OPJ_BYTE type,\r
 307                 OPJ_UINT32 vsc)\r
 308 {\r
 309         OPJ_INT32 v;\r
 310         OPJ_UINT32 flag;\r
 311         \r
 312         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 313         \r
 314         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);\r
 315         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {\r
 316                 v = int_abs(*datap) & one ? 1 : 0;\r
 317                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));       /* ESSAI */\r
 318                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */\r
 319                         mqc_bypass_enc(mqc, v);\r
 320                 } else {\r
 321                         mqc_encode(mqc, v);\r
 322                 }\r
 323                 if (v) {\r
 324                         v = *datap < 0 ? 1 : 0;\r
 325                         *nmsedec +=     t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);\r
 326                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));       /* ESSAI */\r
 327                         if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */\r
 328                                 mqc_bypass_enc(mqc, v);\r
 329                         } else {\r
 330                                 mqc_encode(mqc, v ^ t1_getspb(flag));\r
 331                         }\r
 332                         t1_updateflags(flagsp, v, t1->flags_stride);\r
 333                 }\r
 334                 *flagsp |= T1_VISIT;\r
 335         }\r
 336 }\r
 337 \r
 338 static void t1_dec_sigpass_step(\r
 339                 opj_t1_t *t1,\r
 340                 flag_t *flagsp,\r
 341                 OPJ_INT32 *datap,\r
 342                 OPJ_UINT32 orient,\r
 343                 OPJ_INT32 oneplushalf,\r
 344                 OPJ_BYTE type,\r
 345                 OPJ_UINT32 vsc)\r
 346 {\r
 347         OPJ_UINT32 v, flag;\r
 348         \r
 349         opj_raw_t *raw = t1->raw;       /* RAW component */\r
 350         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 351         \r
 352         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);\r
 353         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {\r
 354                 if (type == T1_TYPE_RAW) {\r
 355                         if (raw_decode(raw)) {\r
 356                                 v = raw_decode(raw);    /* ESSAI */\r
 357                                 *datap = v ? -oneplushalf : oneplushalf;\r
 358                                 t1_updateflags(flagsp, v, t1->flags_stride);\r
 359                         }\r
 360                 } else {\r
 361                         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));\r
 362                         if (mqc_decode(mqc)) {\r
 363                                 mqc_setcurctx(mqc, t1_getctxno_sc(flag));\r
 364                                 v = mqc_decode(mqc) ^ t1_getspb(flag);\r
 365                                 *datap = v ? -oneplushalf : oneplushalf;\r
 366                                 t1_updateflags(flagsp, v, t1->flags_stride);\r
 367                         }\r
 368                 }\r
 369                 *flagsp |= T1_VISIT;\r
 370         }\r
 371 }                               /* VSC and  BYPASS by Antonin */\r
 372 \r
 373 static void t1_enc_sigpass(\r
 374                 opj_t1_t *t1,\r
 375                 OPJ_INT32 bpno,\r
 376                 OPJ_UINT32 orient,\r
 377                 OPJ_INT32 *nmsedec,\r
 378                 OPJ_BYTE type,\r
 379                 OPJ_UINT32 cblksty)\r
 380 {\r
 381         OPJ_UINT32 i, j, k, vsc;\r
 382         OPJ_INT32 one;\r
 383 \r
 384         *nmsedec = 0;\r
 385         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);\r
 386         for (k = 0; k < t1->h; k += 4) {\r
 387                 for (i = 0; i < t1->w; ++i) {\r
 388                         for (j = k; j < k + 4 && j < t1->h; ++j) {\r
 389                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;\r
 390                                 t1_enc_sigpass_step(\r
 391                                                 t1,\r
 392                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],\r
 393                                                 &t1->data[(j * t1->w) + i],\r
 394                                                 orient,\r
 395                                                 bpno,\r
 396                                                 one,\r
 397                                                 nmsedec,\r
 398                                                 type,\r
 399                                                 vsc);\r
 400                         }\r
 401                 }\r
 402         }\r
 403 }\r
 404 \r
 405 static void t1_dec_sigpass(\r
 406                 opj_t1_t *t1,\r
 407                 OPJ_INT32 bpno,\r
 408                 OPJ_UINT32 orient,\r
 409                 OPJ_BYTE type,\r
 410                 OPJ_UINT32 cblksty)\r
 411 {\r
 412         OPJ_UINT32 i, j, k, vsc;\r
 413         OPJ_INT32 one, half, oneplushalf;\r
 414         one = 1 << bpno;\r
 415         half = one >> 1;\r
 416         oneplushalf = one | half;\r
 417         for (k = 0; k < t1->h; k += 4) {\r
 418                 for (i = 0; i < t1->w; ++i) {\r
 419                         for (j = k; j < k + 4 && j < t1->h; ++j) {\r
 420                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;\r
 421                                 t1_dec_sigpass_step(\r
 422                                                 t1,\r
 423                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],\r
 424                                                 &t1->data[(j * t1->w) + i],\r
 425                                                 orient,\r
 426                                                 oneplushalf,\r
 427                                                 type,\r
 428                                                 vsc);\r
 429                         }\r
 430                 }\r
 431         }\r
 432 }                               /* VSC and  BYPASS by Antonin */\r
 433 \r
 434 static void t1_enc_refpass_step(\r
 435                 opj_t1_t *t1,\r
 436                 flag_t *flagsp,\r
 437                 OPJ_INT32 *datap,\r
 438                 OPJ_INT32 bpno,\r
 439                 OPJ_INT32 one,\r
 440                 OPJ_INT32 *nmsedec,\r
 441                 OPJ_BYTE type,\r
 442                 OPJ_UINT32 vsc)\r
 443 {\r
 444         OPJ_INT32 v;\r
 445         OPJ_UINT32 flag;\r
 446         \r
 447         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 448         \r
 449         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);\r
 450         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {\r
 451                 *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);\r
 452                 v = int_abs(*datap) & one ? 1 : 0;\r
 453                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */\r
 454                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */\r
 455                         mqc_bypass_enc(mqc, v);\r
 456                 } else {\r
 457                         mqc_encode(mqc, v);\r
 458                 }\r
 459                 *flagsp |= T1_REFINE;\r
 460         }\r
 461 }\r
 462 \r
 463 static void t1_dec_refpass_step(\r
 464                 opj_t1_t *t1,\r
 465                 flag_t *flagsp,\r
 466                 OPJ_INT32 *datap,\r
 467                 OPJ_INT32 poshalf,\r
 468                 OPJ_INT32 neghalf,\r
 469                 OPJ_BYTE type,\r
 470                 OPJ_UINT32 vsc)\r
 471 {\r
 472         OPJ_INT32  t;\r
 473         OPJ_UINT32 v,flag;\r
 474         \r
 475         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 476         opj_raw_t *raw = t1->raw;       /* RAW component */\r
 477         \r
 478         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);\r
 479         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {\r
 480                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */\r
 481                 if (type == T1_TYPE_RAW) {\r
 482                         v = raw_decode(raw);\r
 483                 } else {\r
 484                         v = mqc_decode(mqc);\r
 485                 }\r
 486                 t = v ? poshalf : neghalf;\r
 487                 *datap += *datap < 0 ? -t : t;\r
 488                 *flagsp |= T1_REFINE;\r
 489         }\r
 490 }                               /* VSC and  BYPASS by Antonin  */\r
 491 \r
 492 static void t1_enc_refpass(\r
 493                 opj_t1_t *t1,\r
 494                 OPJ_INT32 bpno,\r
 495                 OPJ_INT32 *nmsedec,\r
 496                 OPJ_BYTE type,\r
 497                 OPJ_UINT32 cblksty)\r
 498 {\r
 499         OPJ_UINT32 i, j, k, vsc;\r
 500         OPJ_INT32 one;\r
 501 \r
 502         *nmsedec = 0;\r
 503         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);\r
 504         for (k = 0; k < t1->h; k += 4) {\r
 505                 for (i = 0; i < t1->w; ++i) {\r
 506                         for (j = k; j < k + 4 && j < t1->h; ++j) {\r
 507                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;\r
 508                                 t1_enc_refpass_step(\r
 509                                                 t1,\r
 510                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],\r
 511                                                 &t1->data[(j * t1->w) + i],\r
 512                                                 bpno,\r
 513                                                 one,\r
 514                                                 nmsedec,\r
 515                                                 type,\r
 516                                                 vsc);\r
 517                         }\r
 518                 }\r
 519         }\r
 520 }\r
 521 \r
 522 static void t1_dec_refpass(\r
 523                 opj_t1_t *t1,\r
 524                 OPJ_INT32 bpno,\r
 525                 OPJ_BYTE type,\r
 526                 OPJ_UINT32 cblksty)\r
 527 {\r
 528         OPJ_UINT32 i, j, k;\r
 529         OPJ_INT32 one, poshalf, neghalf;\r
 530         OPJ_UINT32 vsc;\r
 531         one = 1 << bpno;\r
 532         poshalf = one >> 1;\r
 533         neghalf = bpno > 0 ? -poshalf : -1;\r
 534         for (k = 0; k < t1->h; k += 4) {\r
 535                 for (i = 0; i < t1->w; ++i) {\r
 536                         for (j = k; j < k + 4 && j < t1->h; ++j) {\r
 537                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;\r
 538                                 t1_dec_refpass_step(\r
 539                                                 t1,\r
 540                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],\r
 541                                                 &t1->data[(j * t1->w) + i],\r
 542                                                 poshalf,\r
 543                                                 neghalf,\r
 544                                                 type,\r
 545                                                 vsc);\r
 546                         }\r
 547                 }\r
 548         }\r
 549 }                               /* VSC and  BYPASS by Antonin */\r
 550 \r
 551 static void t1_enc_clnpass_step(\r
 552                 opj_t1_t *t1,\r
 553                 flag_t *flagsp,\r
 554                 OPJ_INT32 *datap,\r
 555                 OPJ_UINT32 orient,\r
 556                 OPJ_INT32 bpno,\r
 557                 OPJ_INT32 one,\r
 558                 OPJ_INT32 *nmsedec,\r
 559                 OPJ_UINT32 partial,\r
 560                 OPJ_UINT32 vsc)\r
 561 {\r
 562         OPJ_INT32 v;\r
 563         OPJ_UINT32 flag;\r
 564         \r
 565         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 566         \r
 567         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);\r
 568         if (partial) {\r
 569                 goto LABEL_PARTIAL;\r
 570         }\r
 571         if (!(*flagsp & (T1_SIG | T1_VISIT))) {\r
 572                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));\r
 573                 v = int_abs(*datap) & one ? 1 : 0;\r
 574                 mqc_encode(mqc, v);\r
 575                 if (v) {\r
 576 LABEL_PARTIAL:\r
 577                         *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);\r
 578                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));\r
 579                         v = *datap < 0 ? 1 : 0;\r
 580                         mqc_encode(mqc, v ^ t1_getspb(flag));\r
 581                         t1_updateflags(flagsp, v, t1->flags_stride);\r
 582                 }\r
 583         }\r
 584         *flagsp &= ~T1_VISIT;\r
 585 }\r
 586 \r
 587 static void t1_dec_clnpass_step(\r
 588                 opj_t1_t *t1,\r
 589                 flag_t *flagsp,\r
 590                 OPJ_INT32 *datap,\r
 591                 OPJ_UINT32 orient,\r
 592                 OPJ_INT32 oneplushalf,\r
 593                 OPJ_UINT32 partial,\r
 594                 OPJ_UINT32 vsc)\r
 595 {\r
 596         OPJ_INT32 v;\r
 597         OPJ_UINT32 flag;\r
 598         \r
 599         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 600         \r
 601         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);\r
 602         if (partial) {\r
 603                 goto LABEL_PARTIAL;\r
 604         }\r
 605         if (!(flag & (T1_SIG | T1_VISIT))) {\r
 606                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));\r
 607                 if (mqc_decode(mqc)) {\r
 608 LABEL_PARTIAL:\r
 609                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));\r
 610                         v = mqc_decode(mqc) ^ t1_getspb(flag);\r
 611                         *datap = v ? -oneplushalf : oneplushalf;\r
 612                         t1_updateflags(flagsp, v, t1->flags_stride);\r
 613                 }\r
 614         }\r
 615         *flagsp &= ~T1_VISIT;\r
 616 }                               /* VSC and  BYPASS by Antonin */\r
 617 \r
 618 static void t1_enc_clnpass(\r
 619                 opj_t1_t *t1,\r
 620                 OPJ_INT32 bpno,\r
 621                 OPJ_UINT32 orient,\r
 622                 OPJ_INT32 *nmsedec,\r
 623                 OPJ_UINT32 cblksty)\r
 624 {\r
 625         OPJ_UINT32 i, j, k;\r
 626         OPJ_INT32 one;\r
 627         OPJ_UINT32 agg, runlen, vsc;\r
 628         \r
 629         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 630         \r
 631         *nmsedec = 0;\r
 632         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);\r
 633         for (k = 0; k < t1->h; k += 4) {\r
 634                 for (i = 0; i < t1->w; ++i) {\r
 635                         if (k + 3 < t1->h) {\r
 636                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {\r
 637                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 638                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 639                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 640                                                 || (MACRO_t1_flags(1 + k + 3,1 + i) \r
 641                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));\r
 642                                 } else {\r
 643                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 644                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 645                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 646                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));\r
 647                                 }\r
 648                         } else {\r
 649                                 agg = 0;\r
 650                         }\r
 651                         if (agg) {\r
 652                                 for (runlen = 0; runlen < 4; ++runlen) {\r
 653                                         if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)\r
 654                                                 break;\r
 655                                 }\r
 656                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);\r
 657                                 mqc_encode(mqc, runlen != 4);\r
 658                                 if (runlen == 4) {\r
 659                                         continue;\r
 660                                 }\r
 661                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);\r
 662                                 mqc_encode(mqc, runlen >> 1);\r
 663                                 mqc_encode(mqc, runlen & 1);\r
 664                         } else {\r
 665                                 runlen = 0;\r
 666                         }\r
 667                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {\r
 668                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;\r
 669                                 t1_enc_clnpass_step(\r
 670                                                 t1,\r
 671                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],\r
 672                                                 &t1->data[(j * t1->w) + i],\r
 673                                                 orient,\r
 674                                                 bpno,\r
 675                                                 one,\r
 676                                                 nmsedec,\r
 677                                                 agg && (j == k + runlen),\r
 678                                                 vsc);\r
 679                         }\r
 680                 }\r
 681         }\r
 682 }\r
 683 \r
 684 static void t1_dec_clnpass(\r
 685                 opj_t1_t *t1,\r
 686                 OPJ_INT32 bpno,\r
 687                 OPJ_UINT32 orient,\r
 688                 OPJ_UINT32 cblksty)\r
 689 {\r
 690         OPJ_UINT32 i, j, k, one;\r
 691         OPJ_INT32 half, oneplushalf;\r
 692         OPJ_UINT32 agg, runlen, vsc;\r
 693         OPJ_UINT32 segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;\r
 694         \r
 695         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 696         \r
 697         one = 1 << bpno;\r
 698         half = one >> 1;\r
 699         oneplushalf = one | half;\r
 700         for (k = 0; k < t1->h; k += 4) {\r
 701                 for (i = 0; i < t1->w; ++i) {\r
 702                         if (k + 3 < t1->h) {\r
 703                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {\r
 704                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 705                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 706                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 707                                                 || (MACRO_t1_flags(1 + k + 3,1 + i) \r
 708                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));\r
 709                                 } else {\r
 710                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 711                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 712                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)\r
 713                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));\r
 714                                 }\r
 715                         } else {\r
 716                                 agg = 0;\r
 717                         }\r
 718                         if (agg) {\r
 719                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);\r
 720                                 if (!mqc_decode(mqc)) {\r
 721                                         continue;\r
 722                                 }\r
 723                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);\r
 724                                 runlen = mqc_decode(mqc);\r
 725                                 runlen = (runlen << 1) | mqc_decode(mqc);\r
 726                         } else {\r
 727                                 runlen = 0;\r
 728                         }\r
 729                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {\r
 730                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;\r
 731                                 t1_dec_clnpass_step(\r
 732                                                 t1,\r
 733                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],\r
 734                                                 &t1->data[(j * t1->w) + i],\r
 735                                                 orient,\r
 736                                                 oneplushalf,\r
 737                                                 agg && (j == k + runlen),\r
 738                                                 vsc);\r
 739                         }\r
 740                 }\r
 741         }\r
 742         if (segsym) {\r
 743                 OPJ_UINT32 v = 0;\r
 744                 mqc_setcurctx(mqc, T1_CTXNO_UNI);\r
 745                 v = mqc_decode(mqc);\r
 746                 v = (v << 1) | mqc_decode(mqc);\r
 747                 v = (v << 1) | mqc_decode(mqc);\r
 748                 v = (v << 1) | mqc_decode(mqc);\r
 749                 /*\r
 750                 if (v!=0xa) {\r
 751                         opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);\r
 752                 } \r
 753                 */\r
 754         }\r
 755 }                               /* VSC and  BYPASS by Antonin */\r
 756 \r
 757 \r
 758 /** mod fixed_quality */\r
 759 static OPJ_FLOAT64 t1_getwmsedec(\r
 760                 OPJ_INT32 nmsedec,\r
 761                 OPJ_UINT32 compno,\r
 762                 OPJ_UINT32 level,\r
 763                 OPJ_UINT32 orient,\r
 764                 OPJ_INT32 bpno,\r
 765                 OPJ_UINT32 qmfbid,\r
 766                 OPJ_FLOAT64 stepsize,\r
 767                 OPJ_UINT32 numcomps,\r
 768                 const OPJ_FLOAT64 * mct_norms)\r
 769 {\r
 770         OPJ_FLOAT64 w1 = 1, w2, wmsedec;\r
 771         if\r
 772                 (mct_norms)\r
 773         {\r
 774                 w1 = mct_norms[compno];\r
 775         }\r
 776         if (qmfbid == 1) \r
 777         {\r
 778                 w2 = dwt_getnorm(level, orient);\r
 779         } else {                        /* if (qmfbid == 0) */\r
 780                 w2 = dwt_getnorm_real(level, orient);\r
 781         }\r
 782         wmsedec = w1 * w2 * stepsize * (1 << bpno);\r
 783         wmsedec *= wmsedec * nmsedec / 8192.0;\r
 784         return wmsedec;\r
 785 }\r
 786 \r
 787 static bool allocate_buffers(\r
 788                 opj_t1_t *t1,\r
 789                 OPJ_UINT32 w,\r
 790                 OPJ_UINT32 h)\r
 791 {\r
 792         OPJ_UINT32 datasize=w * h;\r
 793         OPJ_UINT32 flagssize;\r
 794 \r
 795         if(datasize > t1->datasize){\r
 796                 opj_aligned_free(t1->data);\r
 797                 t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));\r
 798                 if(!t1->data){\r
 799                         return false;\r
 800                 }\r
 801                 t1->datasize=datasize;\r
 802         }\r
 803         memset(t1->data,0,datasize * sizeof(OPJ_INT32));\r
 804 \r
 805         t1->flags_stride=w+2;\r
 806         flagssize=t1->flags_stride * (h+2);\r
 807 \r
 808         if(flagssize > t1->flagssize){\r
 809                 opj_aligned_free(t1->flags);\r
 810                 t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t));\r
 811                 if(!t1->flags){\r
 812                         return false;\r
 813                 }\r
 814                 t1->flagssize=flagssize;\r
 815         }\r
 816         memset(t1->flags,0,flagssize * sizeof(flag_t));\r
 817 \r
 818         t1->w=w;\r
 819         t1->h=h;\r
 820 \r
 821         return true;\r
 822 }\r
 823 \r
 824 /** mod fixed_quality */\r
 825 static void t1_encode_cblk(\r
 826                 opj_t1_t *t1,\r
 827                 opj_tcd_cblk_enc_t* cblk,\r
 828                 OPJ_UINT32 orient,\r
 829                 OPJ_UINT32 compno,\r
 830                 OPJ_UINT32 level,\r
 831                 OPJ_UINT32 qmfbid,\r
 832                 OPJ_FLOAT64 stepsize,\r
 833                 OPJ_UINT32 cblksty,\r
 834                 OPJ_UINT32 numcomps,\r
 835                 opj_tcd_tile_t * tile,\r
 836                 const OPJ_FLOAT64 * mct_norms)\r
 837 {\r
 838         OPJ_FLOAT64 cumwmsedec = 0.0;\r
 839 \r
 840         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 841 \r
 842         OPJ_UINT32 passno;\r
 843         OPJ_INT32 bpno;\r
 844         OPJ_UINT32 passtype;\r
 845         OPJ_INT32 nmsedec = 0;\r
 846         OPJ_INT32 max;\r
 847         OPJ_UINT32 i;\r
 848         OPJ_BYTE type = T1_TYPE_MQ;\r
 849         OPJ_FLOAT64 tempwmsedec;\r
 850 \r
 851         max = 0;\r
 852         for (i = 0; i < t1->w * t1->h; ++i) {\r
 853                 OPJ_INT32 tmp = abs(t1->data[i]);\r
 854                 max = int_max(max, tmp);\r
 855         }\r
 856 \r
 857         cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;\r
 858         \r
 859         bpno = cblk->numbps - 1;\r
 860         passtype = 2;\r
 861         \r
 862         mqc_resetstates(mqc);\r
 863         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);\r
 864         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);\r
 865         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);\r
 866         mqc_init_enc(mqc, cblk->data);\r
 867         \r
 868         for (passno = 0; bpno >= 0; ++passno) {\r
 869                 opj_tcd_pass_t *pass = &cblk->passes[passno];\r
 870                 OPJ_UINT32 correction = 3;\r
 871                 type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;\r
 872                 \r
 873                 switch (passtype) {\r
 874                         case 0:\r
 875                                 t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);\r
 876                                 break;\r
 877                         case 1:\r
 878                                 t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);\r
 879                                 break;\r
 880                         case 2:\r
 881                                 t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);\r
 882                                 /* code switch SEGMARK (i.e. SEGSYM) */\r
 883                                 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)\r
 884                                         mqc_segmark_enc(mqc);\r
 885                                 break;\r
 886                 }\r
 887                 \r
 888                 /* fixed_quality */\r
 889                 tempwmsedec = t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps,mct_norms) ;\r
 890                 cumwmsedec += tempwmsedec;\r
 891                 tile->distotile += tempwmsedec;\r
 892                 \r
 893                 /* Code switch "RESTART" (i.e. TERMALL) */\r
 894                 if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {\r
 895                         if (type == T1_TYPE_RAW) {\r
 896                                 mqc_flush(mqc);\r
 897                                 correction = 1;\r
 898                                 /* correction = mqc_bypass_flush_enc(); */\r
 899                         } else {                        /* correction = mqc_restart_enc(); */\r
 900                                 mqc_flush(mqc);\r
 901                                 correction = 1;\r
 902                         }\r
 903                         pass->term = 1;\r
 904                 } else {\r
 905                         if (((bpno < ((OPJ_INT32) (cblk->numbps) - 4) && (passtype > 0)) \r
 906                                 || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {\r
 907                                 if (type == T1_TYPE_RAW) {\r
 908                                         mqc_flush(mqc);\r
 909                                         correction = 1;\r
 910                                         /* correction = mqc_bypass_flush_enc(); */\r
 911                                 } else {                /* correction = mqc_restart_enc(); */\r
 912                                         mqc_flush(mqc);\r
 913                                         correction = 1;\r
 914                                 }\r
 915                                 pass->term = 1;\r
 916                         } else {\r
 917                                 pass->term = 0;\r
 918                         }\r
 919                 }\r
 920                 \r
 921                 if (++passtype == 3) {\r
 922                         passtype = 0;\r
 923                         bpno--;\r
 924                 }\r
 925                 \r
 926                 if (pass->term && bpno > 0) {\r
 927                         type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;\r
 928                         if (type == T1_TYPE_RAW)\r
 929                                 mqc_bypass_init_enc(mqc);\r
 930                         else\r
 931                                 mqc_restart_init_enc(mqc);\r
 932                 }\r
 933                 \r
 934                 pass->distortiondec = cumwmsedec;\r
 935                 pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */\r
 936                 \r
 937                 /* Code-switch "RESET" */\r
 938                 if (cblksty & J2K_CCP_CBLKSTY_RESET)\r
 939                         mqc_reset_enc(mqc);\r
 940         }\r
 941         \r
 942         /* Code switch "ERTERM" (i.e. PTERM) */\r
 943         if (cblksty & J2K_CCP_CBLKSTY_PTERM)\r
 944                 mqc_erterm_enc(mqc);\r
 945         else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))\r
 946                 mqc_flush(mqc);\r
 947         \r
 948         cblk->totalpasses = passno;\r
 949 \r
 950         for (passno = 0; passno<cblk->totalpasses; passno++) {\r
 951                 opj_tcd_pass_t *pass = &cblk->passes[passno];\r
 952                 if (pass->rate > mqc_numbytes(mqc))\r
 953                         pass->rate = mqc_numbytes(mqc);\r
 954                 /*Preventing generation of FF as last data byte of a pass*/\r
 955                 if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){\r
 956                         pass->rate--;\r
 957                 }\r
 958                 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);             \r
 959         }\r
 960 }\r
 961 \r
 962 static void t1_decode_cblk(\r
 963                 opj_t1_t *t1,\r
 964                 opj_tcd_cblk_dec_t* cblk,\r
 965                 OPJ_UINT32 orient,\r
 966                 OPJ_UINT32 roishift,\r
 967                 OPJ_UINT32 cblksty)\r
 968 {\r
 969         opj_raw_t *raw = t1->raw;       /* RAW component */\r
 970         opj_mqc_t *mqc = t1->mqc;       /* MQC component */\r
 971 \r
 972         OPJ_INT32 bpno;\r
 973         OPJ_UINT32 passtype;\r
 974         OPJ_UINT32 segno, passno;\r
 975         OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */\r
 976 \r
 977         if(!allocate_buffers(\r
 978                                 t1,\r
 979                                 cblk->x1 - cblk->x0,\r
 980                                 cblk->y1 - cblk->y0))\r
 981         {\r
 982                 return;\r
 983         }\r
 984 \r
 985         bpno = roishift + cblk->numbps - 1;\r
 986         passtype = 2;\r
 987         \r
 988         mqc_resetstates(mqc);\r
 989         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);\r
 990         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);\r
 991         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);\r
 992         \r
 993         for (segno = 0; segno < cblk->real_num_segs; ++segno) {\r
 994                 opj_tcd_seg_t *seg = &cblk->segs[segno];\r
 995                 \r
 996                 /* BYPASS mode */\r
 997                 type = ((bpno <= ((OPJ_INT32) (cblk->numbps) - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;\r
 998                 /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */\r
 999                 if(seg->data == 00){\r
1000                         continue;\r
1001                 }\r
1002                 if (type == T1_TYPE_RAW) {\r
1003                         raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);\r
1004                 } else {\r
1005                         mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);\r
1006                 }\r
1007                 \r
1008                 for (passno = 0; passno < seg->real_num_passes; ++passno) {\r
1009                         switch (passtype) {\r
1010                                 case 0:\r
1011                                         t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);\r
1012                                         break;\r
1013                                 case 1:\r
1014                                         t1_dec_refpass(t1, bpno+1, type, cblksty);\r
1015                                         break;\r
1016                                 case 2:\r
1017                                         t1_dec_clnpass(t1, bpno+1, orient, cblksty);\r
1018                                         break;\r
1019                         }\r
1020                         \r
1021                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {\r
1022                                 mqc_resetstates(mqc);\r
1023                                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);                         \r
1024                                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);\r
1025                                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);\r
1026                         }\r
1027                         if (++passtype == 3) {\r
1028                                 passtype = 0;\r
1029                                 bpno--;\r
1030                         }\r
1031                 }\r
1032         }\r
1033 }\r
1034 \r
1035 /* ----------------------------------------------------------------------- */\r
1036 /**\r
1037  * Creates a new Tier 1 handle \r
1038  * and initializes the look-up tables of the Tier-1 coder/decoder\r
1039  * @return a new T1 handle if successful, returns NULL otherwise\r
1040 */\r
1041 opj_t1_t* t1_create()\r
1042 {\r
1043         opj_t1_t *l_t1 = 00;\r
1044 \r
1045         l_t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));\r
1046         if\r
1047                 (!l_t1)\r
1048         {\r
1049                 return 00;\r
1050         }\r
1051         memset(l_t1,0,sizeof(opj_t1_t));\r
1052 \r
1053         /* create MQC and RAW handles */\r
1054         l_t1->mqc = mqc_create();\r
1055         if\r
1056                 (! l_t1->mqc)\r
1057         {\r
1058                 t1_destroy(l_t1);\r
1059                 return 00;\r
1060         }\r
1061         l_t1->raw = raw_create();\r
1062         if\r
1063                 (! l_t1->raw)\r
1064         {\r
1065                 t1_destroy(l_t1);\r
1066                 return 00;\r
1067         }\r
1068         return l_t1;\r
1069 }\r
1070 \r
1071 /**\r
1072  * Destroys a previously created T1 handle\r
1073  * \r
1074  * @param p_t1 Tier 1 handle to destroy\r
1075 */\r
1076 void t1_destroy(opj_t1_t *p_t1) \r
1077 {\r
1078         if\r
1079                 (! p_t1) \r
1080         {\r
1081                 return;\r
1082         }\r
1083         \r
1084         /* destroy MQC and RAW handles */\r
1085         mqc_destroy(p_t1->mqc);\r
1086         p_t1->mqc = 00;\r
1087         raw_destroy(p_t1->raw);\r
1088         p_t1->raw = 00;\r
1089         if\r
1090                 (p_t1->data)\r
1091         {\r
1092                 opj_aligned_free(p_t1->data);\r
1093                 p_t1->data = 00;\r
1094         }\r
1095         if\r
1096                 (p_t1->flags)\r
1097         {\r
1098                 opj_aligned_free(p_t1->flags);\r
1099                 p_t1->flags = 00;\r
1100         }\r
1101         opj_free(p_t1);\r
1102 }\r
1103 \r
1104 bool t1_encode_cblks(\r
1105                 opj_t1_t *t1,\r
1106                 opj_tcd_tile_t *tile,\r
1107                 opj_tcp_t *tcp,\r
1108                 const OPJ_FLOAT64 * mct_norms)\r
1109 {\r
1110         OPJ_UINT32 compno, resno, bandno, precno, cblkno;\r
1111 \r
1112         tile->distotile = 0;            /* fixed_quality */\r
1113 \r
1114         for (compno = 0; compno < tile->numcomps; ++compno) {\r
1115                 opj_tcd_tilecomp_t* tilec = &tile->comps[compno];\r
1116                 opj_tccp_t* tccp = &tcp->tccps[compno];\r
1117                 OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;\r
1118 \r
1119                 for (resno = 0; resno < tilec->numresolutions; ++resno) {\r
1120                         opj_tcd_resolution_t *res = &tilec->resolutions[resno];\r
1121 \r
1122                         for (bandno = 0; bandno < res->numbands; ++bandno) {\r
1123                                 opj_tcd_band_t* restrict band = &res->bands[bandno];\r
1124 \r
1125                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {\r
1126                                         opj_tcd_precinct_t *prc = &band->precincts[precno];\r
1127 \r
1128                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {\r
1129                                                 opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];\r
1130                                                 OPJ_INT32 * restrict datap;\r
1131                                                 OPJ_INT32* restrict tiledp;\r
1132                                                 OPJ_UINT32 cblk_w;\r
1133                                                 OPJ_UINT32 cblk_h;\r
1134                                                 OPJ_UINT32 i, j;\r
1135 \r
1136                                                 OPJ_INT32 x = cblk->x0 - band->x0;\r
1137                                                 OPJ_INT32 y = cblk->y0 - band->y0;\r
1138                                                 if (band->bandno & 1) {\r
1139                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
1140                                                         x += pres->x1 - pres->x0;\r
1141                                                 }\r
1142                                                 if (band->bandno & 2) {\r
1143                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];\r
1144                                                         y += pres->y1 - pres->y0;\r
1145                                                 }\r
1146 \r
1147                                                 if(!allocate_buffers(\r
1148                                                                         t1,\r
1149                                                                         cblk->x1 - cblk->x0,\r
1150                                                                         cblk->y1 - cblk->y0))\r
1151                                                 {\r
1152                                                         return false;\r
1153                                                 }\r
1154 \r
1155                                                 datap=t1->data;\r
1156                                                 cblk_w = t1->w;\r
1157                                                 cblk_h = t1->h;\r
1158 \r
1159                                                 tiledp=&tilec->data[(y * tile_w) + x];\r
1160                                                 if (tccp->qmfbid == 1) {\r
1161                                                         for (j = 0; j < cblk_h; ++j) {\r
1162                                                                 for (i = 0; i < cblk_w; ++i) {\r
1163                                                                         OPJ_INT32 tmp = tiledp[(j * tile_w) + i];\r
1164                                                                         datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;\r
1165                                                                 }\r
1166                                                         }\r
1167                                                 } else {                /* if (tccp->qmfbid == 0) */\r
1168                                                         for (j = 0; j < cblk_h; ++j) {\r
1169                                                                 for (i = 0; i < cblk_w; ++i) {\r
1170                                                                         OPJ_INT32 tmp = tiledp[(j * tile_w) + i];\r
1171                                                                         datap[(j * cblk_w) + i] =\r
1172                                                                                 fix_mul(\r
1173                                                                                 tmp,\r
1174                                                                                 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192))) >> (11 - T1_NMSEDEC_FRACBITS);\r
1175                                                                 }\r
1176                                                         }\r
1177                                                 }\r
1178 \r
1179                                                 t1_encode_cblk(\r
1180                                                                 t1,\r
1181                                                                 cblk,\r
1182                                                                 band->bandno,\r
1183                                                                 compno,\r
1184                                                                 tilec->numresolutions - 1 - resno,\r
1185                                                                 tccp->qmfbid,\r
1186                                                                 band->stepsize,\r
1187                                                                 tccp->cblksty,\r
1188                                                                 tile->numcomps,\r
1189                                                                 tile,\r
1190                                                                 mct_norms);\r
1191 \r
1192                                         } /* cblkno */\r
1193                                 } /* precno */\r
1194                         } /* bandno */\r
1195                 } /* resno  */\r
1196         } /* compno  */\r
1197         return true;\r
1198 }\r
1199 \r
1200 void t1_decode_cblks(\r
1201                 opj_t1_t* t1,\r
1202                 opj_tcd_tilecomp_t* tilec,\r
1203                 opj_tccp_t* tccp)\r
1204 {\r
1205         OPJ_UINT32 resno, bandno, precno, cblkno;\r
1206 \r
1207         OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;\r
1208 \r
1209         for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {\r
1210                 opj_tcd_resolution_t* res = &tilec->resolutions[resno];\r
1211 \r
1212                 for (bandno = 0; bandno < res->numbands; ++bandno) {\r
1213                         opj_tcd_band_t* restrict band = &res->bands[bandno];\r
1214 \r
1215                         for (precno = 0; precno < res->pw * res->ph; ++precno) {\r
1216                                 opj_tcd_precinct_t* precinct = &band->precincts[precno];\r
1217 \r
1218                                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {\r
1219                                         opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];\r
1220                                         OPJ_INT32* restrict datap;\r
1221                                         void* restrict tiledp;\r
1222                                         OPJ_UINT32 cblk_w, cblk_h;\r
1223                                         OPJ_INT32 x, y;\r
1224                                         OPJ_UINT32 i, j;\r
1225 \r
1226                                         t1_decode_cblk(\r
1227                                                         t1,\r
1228                                                         cblk,\r
1229                                                         band->bandno,\r
1230                                                         tccp->roishift,\r
1231                                                         tccp->cblksty);\r
1232 \r
1233                                         x = cblk->x0 - band->x0;\r
1234                                         y = cblk->y0 - band->y0;\r
1235                                         if (band->bandno & 1) {\r
1236                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];\r
1237                                                 x += pres->x1 - pres->x0;\r
1238                                         }\r
1239                                         if (band->bandno & 2) {\r
1240                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];\r
1241                                                 y += pres->y1 - pres->y0;\r
1242                                         }\r
1243 \r
1244                                         datap=t1->data;\r
1245                                         cblk_w = t1->w;\r
1246                                         cblk_h = t1->h;\r
1247 \r
1248                                         if (tccp->roishift) {\r
1249                                                 OPJ_INT32 thresh = 1 << tccp->roishift;\r
1250                                                 for (j = 0; j < cblk_h; ++j) {\r
1251                                                         for (i = 0; i < cblk_w; ++i) {\r
1252                                                                 OPJ_INT32 val = datap[(j * cblk_w) + i];\r
1253                                                                 OPJ_INT32 mag = abs(val);\r
1254                                                                 if (mag >= thresh) {\r
1255                                                                         mag >>= tccp->roishift;\r
1256                                                                         datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;\r
1257                                                                 }\r
1258                                                         }\r
1259                                                 }\r
1260                                         }\r
1261 \r
1262                                         tiledp=(void*)&tilec->data[(y * tile_w) + x];\r
1263                                         if (tccp->qmfbid == 1) {\r
1264                                                 for (j = 0; j < cblk_h; ++j) {\r
1265                                                         for (i = 0; i < cblk_w; ++i) {\r
1266                                                                 OPJ_INT32 tmp = datap[(j * cblk_w) + i];\r
1267                                                                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp >> 1;\r
1268                                                         }\r
1269                                                 }\r
1270                                         } else {                /* if (tccp->qmfbid == 0) */\r
1271                                                 for (j = 0; j < cblk_h; ++j) {\r
1272                                                         for (i = 0; i < cblk_w; ++i) {\r
1273                                                                 float tmp = datap[(j * cblk_w) + i] * band->stepsize;\r
1274                                                                 ((float*)tiledp)[(j * tile_w) + i] = tmp;\r
1275                                                         }\r
1276                                                 }\r
1277                                         }\r
1278                                         //opj_free(cblk->segs);\r
1279                                         //cblk->segs = 00;\r
1280                                 } /* cblkno */\r
1281                         } /* precno */\r
1282                 } /* bandno */\r
1283         } /* resno */\r
1284 }\r
1285 \r
1286 \r