src/lib/openjp2/t1.c

   1 /*
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3  * Copyright (c) 2002-2007, Professor Benoit Macq
   4  * Copyright (c) 2001-2003, David Janssens
   5  * Copyright (c) 2002-2003, Yannick Verschueren
   6  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
   7  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   8  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "opj_includes.h"
  34 #include "t1_luts.h"
  35
  36 /** @defgroup T1 T1 - Implementation of the tier-1 coding */
  37 /*@{*/
  38
  39 /** @name Local static functions */
  40 /*@{*/
  41
  42 static INLINE OPJ_BYTE opj_t1_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient);
  43 static OPJ_BYTE opj_t1_getctxno_sc(OPJ_UINT32 f);
  44 static INLINE OPJ_UINT32 opj_t1_getctxno_mag(OPJ_UINT32 f);
  45 static OPJ_BYTE opj_t1_getspb(OPJ_UINT32 f);
  46 static OPJ_INT16 opj_t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos);
  47 static OPJ_INT16 opj_t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos);
  48 static void opj_t1_updateflags(opj_flag_t *flagsp, OPJ_UINT32 s, OPJ_UINT32 stride);
  49 /**
  50 Encode significant pass
  51 */
  52 static void opj_t1_enc_sigpass_step(opj_t1_t *t1,
  53                                     opj_flag_t *flagsp,
  54                                     OPJ_INT32 *datap,
  55                                     OPJ_UINT32 orient,
  56                                     OPJ_INT32 bpno,
  57                                     OPJ_INT32 one,
  58                                     OPJ_INT32 *nmsedec,
  59                                     OPJ_BYTE type,
  60                                     OPJ_UINT32 vsc);
  61
  62 /**
  63 Decode significant pass
  64 */
  65 #if 0
  66 static void opj_t1_dec_sigpass_step(opj_t1_t *t1,
  67                                     opj_flag_t *flagsp,
  68                                     OPJ_INT32 *datap,
  69                                     OPJ_UINT32 orient,
  70                                     OPJ_INT32 oneplushalf,
  71                                     OPJ_BYTE type,
  72                                     OPJ_UINT32 vsc);
  73 #endif
  74
  75 static INLINE void opj_t1_dec_sigpass_step_raw(
  76                 opj_t1_t *t1,
  77                 opj_flag_t *flagsp,
  78                 OPJ_INT32 *datap,
  79                 OPJ_INT32 orient,
  80                 OPJ_INT32 oneplushalf,
  81                 OPJ_INT32 vsc);
  82 static INLINE void opj_t1_dec_sigpass_step_mqc(
  83                 opj_t1_t *t1,
  84                 opj_flag_t *flagsp,
  85                 OPJ_INT32 *datap,
  86                 OPJ_INT32 orient,
  87                 OPJ_INT32 oneplushalf);
  88 static INLINE void opj_t1_dec_sigpass_step_mqc_vsc(
  89                 opj_t1_t *t1,
  90                 opj_flag_t *flagsp,
  91                 OPJ_INT32 *datap,
  92                 OPJ_INT32 orient,
  93                 OPJ_INT32 oneplushalf,
  94                 OPJ_INT32 vsc);
  95
  96
  97 /**
  98 Encode significant pass
  99 */
 100 static void opj_t1_enc_sigpass( opj_t1_t *t1,
 101                                 OPJ_INT32 bpno,
 102                                 OPJ_UINT32 orient,
 103                                 OPJ_INT32 *nmsedec,
 104                                 OPJ_BYTE type,
 105                                 OPJ_UINT32 cblksty);
 106
 107 /**
 108 Decode significant pass
 109 */
 110 static void opj_t1_dec_sigpass_raw(
 111                 opj_t1_t *t1,
 112                 OPJ_INT32 bpno,
 113                 OPJ_INT32 orient,
 114                 OPJ_INT32 cblksty);
 115 static void opj_t1_dec_sigpass_mqc(
 116                 opj_t1_t *t1,
 117                 OPJ_INT32 bpno,
 118                 OPJ_INT32 orient);
 119 static void opj_t1_dec_sigpass_mqc_vsc(
 120                 opj_t1_t *t1,
 121                 OPJ_INT32 bpno,
 122                 OPJ_INT32 orient);
 123
 124
 125
 126 /**
 127 Encode refinement pass
 128 */
 129 static void opj_t1_enc_refpass_step(opj_t1_t *t1,
 130                                     opj_flag_t *flagsp,
 131                                     OPJ_INT32 *datap,
 132                                     OPJ_INT32 bpno,
 133                                     OPJ_INT32 one,
 134                                     OPJ_INT32 *nmsedec,
 135                                     OPJ_BYTE type,
 136                                     OPJ_UINT32 vsc);
 137
 138
 139 /**
 140 Encode refinement pass
 141 */
 142 static void opj_t1_enc_refpass( opj_t1_t *t1,
 143                                 OPJ_INT32 bpno,
 144                                 OPJ_INT32 *nmsedec,
 145                                 OPJ_BYTE type,
 146                                 OPJ_UINT32 cblksty);
 147
 148 /**
 149 Decode refinement pass
 150 */
 151 static void opj_t1_dec_refpass_raw(
 152                 opj_t1_t *t1,
 153                 OPJ_INT32 bpno,
 154                 OPJ_INT32 cblksty);
 155 static void opj_t1_dec_refpass_mqc(
 156                 opj_t1_t *t1,
 157                 OPJ_INT32 bpno);
 158 static void opj_t1_dec_refpass_mqc_vsc(
 159                 opj_t1_t *t1,
 160                 OPJ_INT32 bpno);
 161
 162
 163 /**
 164 Decode refinement pass
 165 */
 166 #if 0
 167 static void opj_t1_dec_refpass_step(opj_t1_t *t1,
 168                                     opj_flag_t *flagsp,
 169                                     OPJ_INT32 *datap,
 170                                     OPJ_INT32 poshalf,
 171                                     OPJ_INT32 neghalf,
 172                                     OPJ_BYTE type,
 173                                     OPJ_UINT32 vsc);
 174 #endif
 175
 176 static INLINE void  opj_t1_dec_refpass_step_raw(
 177                 opj_t1_t *t1,
 178                 opj_flag_t *flagsp,
 179                 OPJ_INT32 *datap,
 180                 OPJ_INT32 poshalf,
 181                 OPJ_INT32 neghalf,
 182                 OPJ_INT32 vsc);
 183 static INLINE void opj_t1_dec_refpass_step_mqc(
 184                 opj_t1_t *t1,
 185                 opj_flag_t *flagsp,
 186                 OPJ_INT32 *datap,
 187                 OPJ_INT32 poshalf,
 188                 OPJ_INT32 neghalf);
 189 static INLINE void opj_t1_dec_refpass_step_mqc_vsc(
 190                 opj_t1_t *t1,
 191                 opj_flag_t *flagsp,
 192                 OPJ_INT32 *datap,
 193                 OPJ_INT32 poshalf,
 194                 OPJ_INT32 neghalf,
 195                 OPJ_INT32 vsc);
 196
 197
 198
 199 /**
 200 Encode clean-up pass
 201 */
 202 static void opj_t1_enc_clnpass_step(
 203                 opj_t1_t *t1,
 204                 opj_flag_t *flagsp,
 205                 OPJ_INT32 *datap,
 206                 OPJ_UINT32 orient,
 207                 OPJ_INT32 bpno,
 208                 OPJ_INT32 one,
 209                 OPJ_INT32 *nmsedec,
 210                 OPJ_UINT32 partial,
 211                 OPJ_UINT32 vsc);
 212 /**
 213 Decode clean-up pass
 214 */
 215 static void opj_t1_dec_clnpass_step_partial(
 216                 opj_t1_t *t1,
 217                 opj_flag_t *flagsp,
 218                 OPJ_INT32 *datap,
 219                 OPJ_INT32 orient,
 220                 OPJ_INT32 oneplushalf);
 221 static void opj_t1_dec_clnpass_step(
 222                 opj_t1_t *t1,
 223                 opj_flag_t *flagsp,
 224                 OPJ_INT32 *datap,
 225                 OPJ_INT32 orient,
 226                 OPJ_INT32 oneplushalf);
 227 static void opj_t1_dec_clnpass_step_vsc(
 228                 opj_t1_t *t1,
 229                 opj_flag_t *flagsp,
 230                 OPJ_INT32 *datap,
 231                 OPJ_INT32 orient,
 232                 OPJ_INT32 oneplushalf,
 233                 OPJ_INT32 partial,
 234                 OPJ_INT32 vsc);
 235 /**
 236 Encode clean-up pass
 237 */
 238 static void opj_t1_enc_clnpass(
 239                 opj_t1_t *t1,
 240                 OPJ_INT32 bpno,
 241                 OPJ_UINT32 orient,
 242                 OPJ_INT32 *nmsedec,
 243                 OPJ_UINT32 cblksty);
 244 /**
 245 Decode clean-up pass
 246 */
 247 static void opj_t1_dec_clnpass(
 248                 opj_t1_t *t1,
 249                 OPJ_INT32 bpno,
 250                 OPJ_INT32 orient,
 251                 OPJ_INT32 cblksty);
 252
 253 static OPJ_FLOAT64 opj_t1_getwmsedec(
 254                 OPJ_INT32 nmsedec,
 255                 OPJ_UINT32 compno,
 256                 OPJ_UINT32 level,
 257                 OPJ_UINT32 orient,
 258                 OPJ_INT32 bpno,
 259                 OPJ_UINT32 qmfbid,
 260                 OPJ_FLOAT64 stepsize,
 261                 OPJ_UINT32 numcomps,
 262                 const OPJ_FLOAT64 * mct_norms);
 263
 264 static void opj_t1_encode_cblk( opj_t1_t *t1,
 265                                 opj_tcd_cblk_enc_t* cblk,
 266                                 OPJ_UINT32 orient,
 267                                 OPJ_UINT32 compno,
 268                                 OPJ_UINT32 level,
 269                                 OPJ_UINT32 qmfbid,
 270                                 OPJ_FLOAT64 stepsize,
 271                                 OPJ_UINT32 cblksty,
 272                                 OPJ_UINT32 numcomps,
 273                                 opj_tcd_tile_t * tile,
 274                                 const OPJ_FLOAT64 * mct_norms);
 275
 276 /**
 277 Decode 1 code-block
 278 @param t1 T1 handle
 279 @param cblk Code-block coding parameters
 280 @param orient
 281 @param roishift Region of interest shifting value
 282 @param cblksty Code-block style
 283 */
 284 static OPJ_BOOL opj_t1_decode_cblk( opj_t1_t *t1,
 285                                     opj_tcd_cblk_dec_t* cblk,
 286                                     OPJ_UINT32 orient,
 287                                     OPJ_UINT32 roishift,
 288                                     OPJ_UINT32 cblksty);
 289
 290 OPJ_BOOL opj_t1_allocate_buffers(   opj_t1_t *t1,
 291                                     OPJ_UINT32 w,
 292                                     OPJ_UINT32 h);
 293
 294 /*@}*/
 295
 296 /*@}*/
 297
 298 /* ----------------------------------------------------------------------- */
 299
 300 OPJ_BYTE opj_t1_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient) {
 301         return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
 302 }
 303
 304 OPJ_BYTE opj_t1_getctxno_sc(OPJ_UINT32 f) {
 305         return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 306 }
 307
 308 OPJ_UINT32 opj_t1_getctxno_mag(OPJ_UINT32 f) {
 309         OPJ_UINT32 tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
 310         OPJ_UINT32 tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
 311         return (tmp2);
 312 }
 313
 314 OPJ_BYTE opj_t1_getspb(OPJ_UINT32 f) {
 315         return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 316 }
 317
 318 OPJ_INT16 opj_t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos) {
 319         if (bitpos > T1_NMSEDEC_FRACBITS) {
 320                 return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 321         }
 322
 323         return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 324 }
 325
 326 OPJ_INT16 opj_t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos) {
 327         if (bitpos > T1_NMSEDEC_FRACBITS) {
 328                 return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 329         }
 330
 331     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 332 }
 333
 334 void opj_t1_updateflags(opj_flag_t *flagsp, OPJ_UINT32 s, OPJ_UINT32 stride) {
 335         opj_flag_t *np = flagsp - stride;
 336         opj_flag_t *sp = flagsp + stride;
 337
 338         static const opj_flag_t mod[] = {
 339                 T1_SIG_S, T1_SIG_S|T1_SGN_S,
 340                 T1_SIG_E, T1_SIG_E|T1_SGN_E,
 341                 T1_SIG_W, T1_SIG_W|T1_SGN_W,
 342                 T1_SIG_N, T1_SIG_N|T1_SGN_N
 343         };
 344
 345         np[-1] |= T1_SIG_SE;
 346         np[0]  |= mod[s];
 347         np[1]  |= T1_SIG_SW;
 348
 349         flagsp[-1] |= mod[s+2];
 350         flagsp[0]  |= T1_SIG;
 351         flagsp[1]  |= mod[s+4];
 352
 353         sp[-1] |= T1_SIG_NE;
 354         sp[0]  |= mod[s+6];
 355         sp[1]  |= T1_SIG_NW;
 356 }
 357
 358 void opj_t1_enc_sigpass_step(   opj_t1_t *t1,
 359                                 opj_flag_t *flagsp,
 360                                 OPJ_INT32 *datap,
 361                                 OPJ_UINT32 orient,
 362                                 OPJ_INT32 bpno,
 363                                 OPJ_INT32 one,
 364                                 OPJ_INT32 *nmsedec,
 365                                 OPJ_BYTE type,
 366                                 OPJ_UINT32 vsc
 367                                 )
 368 {
 369         OPJ_INT32 v;
 370     OPJ_UINT32 flag;
 371
 372         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 373
 374         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 375         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 376                 v = opj_int_abs(*datap) & one ? 1 : 0;
 377                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));       /* ESSAI */
 378                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 379                         opj_mqc_bypass_enc(mqc, v);
 380                 } else {
 381                         opj_mqc_encode(mqc, v);
 382                 }
 383                 if (v) {
 384                         v = *datap < 0 ? 1 : 0;
 385                         *nmsedec +=     opj_t1_getnmsedec_sig(opj_int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 386                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));       /* ESSAI */
 387                         if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 388                                 opj_mqc_bypass_enc(mqc, v);
 389                         } else {
 390                                 opj_mqc_encode(mqc, v ^ opj_t1_getspb(flag));
 391                         }
 392                         opj_t1_updateflags(flagsp, v, t1->flags_stride);
 393                 }
 394                 *flagsp |= T1_VISIT;
 395         }
 396 }
 397
 398
 399 static INLINE void opj_t1_dec_sigpass_step_raw(
 400                 opj_t1_t *t1,
 401                 opj_flag_t *flagsp,
 402                 OPJ_INT32 *datap,
 403                 OPJ_INT32 orient,
 404                 OPJ_INT32 oneplushalf,
 405                 OPJ_INT32 vsc)
 406 {
 407         OPJ_INT32 v, flag;
 408         opj_raw_t *raw = t1->raw;       /* RAW component */
 409         OPJ_ARG_NOT_USED(orient);
 410
 411         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 412         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 413                         if (opj_raw_decode(raw)) {
 414                                 v = opj_raw_decode(raw);    /* ESSAI */
 415                                 *datap = v ? -oneplushalf : oneplushalf;
 416                                 opj_t1_updateflags(flagsp, v, t1->flags_stride);
 417                         }
 418                 *flagsp |= T1_VISIT;
 419         }
 420 }
 421
 422 INLINE void opj_t1_dec_sigpass_step_mqc(
 423                 opj_t1_t *t1,
 424                 opj_flag_t *flagsp,
 425                 OPJ_INT32 *datap,
 426                 OPJ_INT32 orient,
 427                 OPJ_INT32 oneplushalf)
 428 {
 429         OPJ_INT32 v, flag;
 430
 431         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 432
 433         flag = *flagsp;
 434         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 435                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));
 436                         if (opj_mqc_decode(mqc)) {
 437                                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 438                                 v = opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
 439                                 *datap = v ? -oneplushalf : oneplushalf;
 440                                 opj_t1_updateflags(flagsp, v, t1->flags_stride);
 441                         }
 442                 *flagsp |= T1_VISIT;
 443         }
 444 }                               /* VSC and  BYPASS by Antonin */
 445
 446 INLINE void opj_t1_dec_sigpass_step_mqc_vsc(
 447                 opj_t1_t *t1,
 448                 opj_flag_t *flagsp,
 449                 OPJ_INT32 *datap,
 450                 OPJ_INT32 orient,
 451                 OPJ_INT32 oneplushalf,
 452                 OPJ_INT32 vsc)
 453 {
 454         OPJ_INT32 v, flag;
 455
 456         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 457
 458         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 459         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 460                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));
 461                 if (opj_mqc_decode(mqc)) {
 462                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 463                         v = opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
 464                         *datap = v ? -oneplushalf : oneplushalf;
 465                         opj_t1_updateflags(flagsp, v, t1->flags_stride);
 466                 }
 467                 *flagsp |= T1_VISIT;
 468         }
 469 }                               /* VSC and  BYPASS by Antonin */
 470
 471
 472
 473 void opj_t1_enc_sigpass(opj_t1_t *t1,
 474                         OPJ_INT32 bpno,
 475                         OPJ_UINT32 orient,
 476                         OPJ_INT32 *nmsedec,
 477                         OPJ_BYTE type,
 478                         OPJ_UINT32 cblksty
 479                         )
 480 {
 481         OPJ_UINT32 i, j, k, vsc;
 482     OPJ_INT32 one;
 483
 484         *nmsedec = 0;
 485         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 486         for (k = 0; k < t1->h; k += 4) {
 487                 for (i = 0; i < t1->w; ++i) {
 488                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 489                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 490                                 opj_t1_enc_sigpass_step(
 491                                                 t1,
 492                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 493                                                 &t1->data[(j * t1->w) + i],
 494                                                 orient,
 495                                                 bpno,
 496                                                 one,
 497                                                 nmsedec,
 498                                                 type,
 499                                                 vsc);
 500                         }
 501                 }
 502         }
 503 }
 504
 505 void opj_t1_dec_sigpass_raw(
 506                 opj_t1_t *t1,
 507                 OPJ_INT32 bpno,
 508                 OPJ_INT32 orient,
 509                 OPJ_INT32 cblksty)
 510 {
 511         OPJ_INT32 one, half, oneplushalf, vsc;
 512         OPJ_UINT32 i, j, k;
 513         one = 1 << bpno;
 514         half = one >> 1;
 515         oneplushalf = one | half;
 516         for (k = 0; k < t1->h; k += 4) {
 517                 for (i = 0; i < t1->w; ++i) {
 518                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 519                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 520                                 opj_t1_dec_sigpass_step_raw(
 521                                                 t1,
 522                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 523                                                 &t1->data[(j * t1->w) + i],
 524                                                 orient,
 525                                                 oneplushalf,
 526                                                 vsc);
 527                         }
 528                 }
 529         }
 530 }                               /* VSC and  BYPASS by Antonin */
 531
 532 void opj_t1_dec_sigpass_mqc(
 533                 opj_t1_t *t1,
 534                 OPJ_INT32 bpno,
 535                 OPJ_INT32 orient)
 536 {
 537         OPJ_INT32 one, half, oneplushalf;
 538         OPJ_UINT32 i, j, k;
 539         OPJ_INT32 *data1 = t1->data;
 540         opj_flag_t *flags1 = &t1->flags[1];
 541         one = 1 << bpno;
 542         half = one >> 1;
 543         oneplushalf = one | half;
 544         for (k = 0; k < (t1->h & ~3); k += 4) {
 545                 for (i = 0; i < t1->w; ++i) {
 546                         OPJ_INT32 *data2 = data1 + i;
 547                         opj_flag_t *flags2 = flags1 + i;
 548                         flags2 += t1->flags_stride;
 549                         opj_t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 550                         data2 += t1->w;
 551                         flags2 += t1->flags_stride;
 552                         opj_t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 553                         data2 += t1->w;
 554                         flags2 += t1->flags_stride;
 555                         opj_t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 556                         data2 += t1->w;
 557                         flags2 += t1->flags_stride;
 558                         opj_t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 559                         data2 += t1->w;
 560                 }
 561                 data1 += t1->w << 2;
 562                 flags1 += t1->flags_stride << 2;
 563         }
 564         for (i = 0; i < t1->w; ++i) {
 565                 OPJ_INT32 *data2 = data1 + i;
 566                 opj_flag_t *flags2 = flags1 + i;
 567                 for (j = k; j < t1->h; ++j) {
 568                         flags2 += t1->flags_stride;
 569                         opj_t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 570                         data2 += t1->w;
 571                 }
 572         }
 573 }                               /* VSC and  BYPASS by Antonin */
 574
 575 void opj_t1_dec_sigpass_mqc_vsc(
 576                 opj_t1_t *t1,
 577                 OPJ_INT32 bpno,
 578                 OPJ_INT32 orient)
 579 {
 580         OPJ_INT32 one, half, oneplushalf, vsc;
 581         OPJ_UINT32 i, j, k;
 582         one = 1 << bpno;
 583         half = one >> 1;
 584         oneplushalf = one | half;
 585         for (k = 0; k < t1->h; k += 4) {
 586                 for (i = 0; i < t1->w; ++i) {
 587                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 588                                 vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
 589                                 opj_t1_dec_sigpass_step_mqc_vsc(
 590                                                 t1,
 591                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 592                                                 &t1->data[(j * t1->w) + i],
 593                                                 orient,
 594                                                 oneplushalf,
 595                                                 vsc);
 596                         }
 597                 }
 598         }
 599 }                               /* VSC and  BYPASS by Antonin */
 600
 601
 602
 603 void opj_t1_enc_refpass_step(   opj_t1_t *t1,
 604                                 opj_flag_t *flagsp,
 605                                 OPJ_INT32 *datap,
 606                                 OPJ_INT32 bpno,
 607                                 OPJ_INT32 one,
 608                                 OPJ_INT32 *nmsedec,
 609                                 OPJ_BYTE type,
 610                                 OPJ_UINT32 vsc)
 611 {
 612         OPJ_INT32 v;
 613         OPJ_UINT32 flag;
 614
 615         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 616
 617         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 618         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 619                 *nmsedec += opj_t1_getnmsedec_ref(opj_int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 620                 v = opj_int_abs(*datap) & one ? 1 : 0;
 621                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_mag(flag));      /* ESSAI */
 622                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 623                         opj_mqc_bypass_enc(mqc, v);
 624                 } else {
 625                         opj_mqc_encode(mqc, v);
 626                 }
 627                 *flagsp |= T1_REFINE;
 628         }
 629 }
 630
 631 INLINE void opj_t1_dec_refpass_step_raw(
 632                 opj_t1_t *t1,
 633                 opj_flag_t *flagsp,
 634                 OPJ_INT32 *datap,
 635                 OPJ_INT32 poshalf,
 636                 OPJ_INT32 neghalf,
 637                 OPJ_INT32 vsc)
 638 {
 639         OPJ_INT32 v, t, flag;
 640
 641         opj_raw_t *raw = t1->raw;       /* RAW component */
 642
 643         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 644         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 645                         v = opj_raw_decode(raw);
 646                 t = v ? poshalf : neghalf;
 647                 *datap += *datap < 0 ? -t : t;
 648                 *flagsp |= T1_REFINE;
 649         }
 650 }                               /* VSC and  BYPASS by Antonin  */
 651
 652 INLINE void opj_t1_dec_refpass_step_mqc(
 653                 opj_t1_t *t1,
 654                 opj_flag_t *flagsp,
 655                 OPJ_INT32 *datap,
 656                 OPJ_INT32 poshalf,
 657                 OPJ_INT32 neghalf)
 658 {
 659         OPJ_INT32 v, t, flag;
 660
 661         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 662
 663         flag = *flagsp;
 664         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 665                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_mag(flag));      /* ESSAI */
 666                         v = opj_mqc_decode(mqc);
 667                 t = v ? poshalf : neghalf;
 668                 *datap += *datap < 0 ? -t : t;
 669                 *flagsp |= T1_REFINE;
 670                 }
 671 }                               /* VSC and  BYPASS by Antonin  */
 672
 673 INLINE void opj_t1_dec_refpass_step_mqc_vsc(
 674                 opj_t1_t *t1,
 675                 opj_flag_t *flagsp,
 676                 OPJ_INT32 *datap,
 677                 OPJ_INT32 poshalf,
 678                 OPJ_INT32 neghalf,
 679                 OPJ_INT32 vsc)
 680 {
 681         OPJ_INT32 v, t, flag;
 682
 683         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 684
 685         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 686         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 687                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_mag(flag));      /* ESSAI */
 688                 v = opj_mqc_decode(mqc);
 689                 t = v ? poshalf : neghalf;
 690                 *datap += *datap < 0 ? -t : t;
 691                 *flagsp |= T1_REFINE;
 692         }
 693 }                               /* VSC and  BYPASS by Antonin  */
 694
 695
 696 void opj_t1_enc_refpass(
 697                 opj_t1_t *t1,
 698                 OPJ_INT32 bpno,
 699                 OPJ_INT32 *nmsedec,
 700                 OPJ_BYTE type,
 701                 OPJ_UINT32 cblksty)
 702 {
 703         OPJ_UINT32 i, j, k, vsc;
 704     OPJ_INT32 one;
 705
 706         *nmsedec = 0;
 707         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 708         for (k = 0; k < t1->h; k += 4) {
 709                 for (i = 0; i < t1->w; ++i) {
 710                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 711                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 712                                 opj_t1_enc_refpass_step(
 713                                                 t1,
 714                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 715                                                 &t1->data[(j * t1->w) + i],
 716                                                 bpno,
 717                                                 one,
 718                                                 nmsedec,
 719                                                 type,
 720                                                 vsc);
 721                         }
 722                 }
 723         }
 724 }
 725
 726 void opj_t1_dec_refpass_raw(
 727                 opj_t1_t *t1,
 728                 OPJ_INT32 bpno,
 729                 OPJ_INT32 cblksty)
 730 {
 731         OPJ_INT32 one, poshalf, neghalf;
 732         OPJ_UINT32 i, j, k;
 733         OPJ_INT32 vsc;
 734         one = 1 << bpno;
 735         poshalf = one >> 1;
 736         neghalf = bpno > 0 ? -poshalf : -1;
 737         for (k = 0; k < t1->h; k += 4) {
 738                 for (i = 0; i < t1->w; ++i) {
 739                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 740                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 741                                 opj_t1_dec_refpass_step_raw(
 742                                                 t1,
 743                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 744                                                 &t1->data[(j * t1->w) + i],
 745                                                 poshalf,
 746                                                 neghalf,
 747                                                 vsc);
 748                         }
 749                 }
 750         }
 751 }                               /* VSC and  BYPASS by Antonin */
 752
 753 void opj_t1_dec_refpass_mqc(
 754                 opj_t1_t *t1,
 755                 OPJ_INT32 bpno)
 756 {
 757         OPJ_INT32 one, poshalf, neghalf;
 758         OPJ_UINT32 i, j, k;
 759         OPJ_INT32 *data1 = t1->data;
 760         opj_flag_t *flags1 = &t1->flags[1];
 761         one = 1 << bpno;
 762         poshalf = one >> 1;
 763         neghalf = bpno > 0 ? -poshalf : -1;
 764         for (k = 0; k < (t1->h & ~3); k += 4) {
 765                 for (i = 0; i < t1->w; ++i) {
 766                         OPJ_INT32 *data2 = data1 + i;
 767                         opj_flag_t *flags2 = flags1 + i;
 768                         flags2 += t1->flags_stride;
 769                         opj_t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 770                         data2 += t1->w;
 771                         flags2 += t1->flags_stride;
 772                         opj_t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 773                         data2 += t1->w;
 774                         flags2 += t1->flags_stride;
 775                         opj_t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 776                         data2 += t1->w;
 777                         flags2 += t1->flags_stride;
 778                         opj_t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 779                         data2 += t1->w;
 780                 }
 781                 data1 += t1->w << 2;
 782                 flags1 += t1->flags_stride << 2;
 783         }
 784         for (i = 0; i < t1->w; ++i) {
 785                 OPJ_INT32 *data2 = data1 + i;
 786                 opj_flag_t *flags2 = flags1 + i;
 787                 for (j = k; j < t1->h; ++j) {
 788                         flags2 += t1->flags_stride;
 789                         opj_t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 790                         data2 += t1->w;
 791                 }
 792         }
 793 }                               /* VSC and  BYPASS by Antonin */
 794
 795 void opj_t1_dec_refpass_mqc_vsc(
 796                 opj_t1_t *t1,
 797                 OPJ_INT32 bpno)
 798 {
 799         OPJ_INT32 one, poshalf, neghalf;
 800         OPJ_UINT32 i, j, k;
 801         OPJ_INT32 vsc;
 802         one = 1 << bpno;
 803         poshalf = one >> 1;
 804         neghalf = bpno > 0 ? -poshalf : -1;
 805         for (k = 0; k < t1->h; k += 4) {
 806                 for (i = 0; i < t1->w; ++i) {
 807                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 808                                 vsc = ((j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 809                                 opj_t1_dec_refpass_step_mqc_vsc(
 810                                                 t1,
 811                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 812                                                 &t1->data[(j * t1->w) + i],
 813                                                 poshalf,
 814                                                 neghalf,
 815                                                 vsc);
 816                         }
 817                 }
 818         }
 819 }                               /* VSC and  BYPASS by Antonin */
 820
 821
 822 void opj_t1_enc_clnpass_step(
 823                 opj_t1_t *t1,
 824                 opj_flag_t *flagsp,
 825                 OPJ_INT32 *datap,
 826                 OPJ_UINT32 orient,
 827                 OPJ_INT32 bpno,
 828                 OPJ_INT32 one,
 829                 OPJ_INT32 *nmsedec,
 830                 OPJ_UINT32 partial,
 831                 OPJ_UINT32 vsc)
 832 {
 833         OPJ_INT32 v;
 834         OPJ_UINT32 flag;
 835
 836         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 837
 838         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 839         if (partial) {
 840                 goto LABEL_PARTIAL;
 841         }
 842         if (!(*flagsp & (T1_SIG | T1_VISIT))) {
 843                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));
 844                 v = opj_int_abs(*datap) & one ? 1 : 0;
 845                 opj_mqc_encode(mqc, v);
 846                 if (v) {
 847 LABEL_PARTIAL:
 848                         *nmsedec += opj_t1_getnmsedec_sig(opj_int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 849                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 850                         v = *datap < 0 ? 1 : 0;
 851                         opj_mqc_encode(mqc, v ^ opj_t1_getspb(flag));
 852                         opj_t1_updateflags(flagsp, v, t1->flags_stride);
 853                 }
 854         }
 855         *flagsp &= ~T1_VISIT;
 856 }
 857
 858 static void opj_t1_dec_clnpass_step_partial(
 859                 opj_t1_t *t1,
 860                 opj_flag_t *flagsp,
 861                 OPJ_INT32 *datap,
 862                 OPJ_INT32 orient,
 863                 OPJ_INT32 oneplushalf)
 864 {
 865         OPJ_INT32 v, flag;
 866         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 867
 868         OPJ_ARG_NOT_USED(orient);
 869
 870         flag = *flagsp;
 871         opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 872         v = opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
 873         *datap = v ? -oneplushalf : oneplushalf;
 874         opj_t1_updateflags(flagsp, v, t1->flags_stride);
 875         *flagsp &= ~T1_VISIT;
 876 }                               /* VSC and  BYPASS by Antonin */
 877
 878 static void opj_t1_dec_clnpass_step(
 879                 opj_t1_t *t1,
 880                 opj_flag_t *flagsp,
 881                 OPJ_INT32 *datap,
 882                 OPJ_INT32 orient,
 883                 OPJ_INT32 oneplushalf)
 884 {
 885         OPJ_INT32 v, flag;
 886
 887         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 888
 889         flag = *flagsp;
 890         if (!(flag & (T1_SIG | T1_VISIT))) {
 891                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));
 892                 if (opj_mqc_decode(mqc)) {
 893                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 894                         v = opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
 895                         *datap = v ? -oneplushalf : oneplushalf;
 896                         opj_t1_updateflags(flagsp, v, t1->flags_stride);
 897                 }
 898         }
 899         *flagsp &= ~T1_VISIT;
 900 }                               /* VSC and  BYPASS by Antonin */
 901
 902 static void opj_t1_dec_clnpass_step_vsc(
 903                 opj_t1_t *t1,
 904                 opj_flag_t *flagsp,
 905                 OPJ_INT32 *datap,
 906                 OPJ_INT32 orient,
 907                 OPJ_INT32 oneplushalf,
 908                 OPJ_INT32 partial,
 909                 OPJ_INT32 vsc)
 910 {
 911         OPJ_INT32 v, flag;
 912
 913         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 914
 915         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 916         if (partial) {
 917                 goto LABEL_PARTIAL;
 918         }
 919         if (!(flag & (T1_SIG | T1_VISIT))) {
 920                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));
 921                 if (opj_mqc_decode(mqc)) {
 922 LABEL_PARTIAL:
 923                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 924                         v = opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
 925                         *datap = v ? -oneplushalf : oneplushalf;
 926                         opj_t1_updateflags(flagsp, v, t1->flags_stride);
 927                 }
 928         }
 929         *flagsp &= ~T1_VISIT;
 930 }
 931
 932 void opj_t1_enc_clnpass(
 933                 opj_t1_t *t1,
 934                 OPJ_INT32 bpno,
 935                 OPJ_UINT32 orient,
 936                 OPJ_INT32 *nmsedec,
 937                 OPJ_UINT32 cblksty)
 938 {
 939         OPJ_UINT32 i, j, k;
 940         OPJ_INT32 one;
 941         OPJ_UINT32 agg, runlen, vsc;
 942
 943         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 944
 945         *nmsedec = 0;
 946         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 947         for (k = 0; k < t1->h; k += 4) {
 948                 for (i = 0; i < t1->w; ++i) {
 949                         if (k + 3 < t1->h) {
 950                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
 951                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 952                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 953                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 954                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
 955                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 956                                 } else {
 957                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 958                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 959                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 960                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 961                                 }
 962                         } else {
 963                                 agg = 0;
 964                         }
 965                         if (agg) {
 966                                 for (runlen = 0; runlen < 4; ++runlen) {
 967                                         if (opj_int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
 968                                                 break;
 969                                 }
 970                                 opj_mqc_setcurctx(mqc, T1_CTXNO_AGG);
 971                                 opj_mqc_encode(mqc, runlen != 4);
 972                                 if (runlen == 4) {
 973                                         continue;
 974                                 }
 975                                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
 976                                 opj_mqc_encode(mqc, runlen >> 1);
 977                                 opj_mqc_encode(mqc, runlen & 1);
 978                         } else {
 979                                 runlen = 0;
 980                         }
 981                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
 982                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 983                                 opj_t1_enc_clnpass_step(
 984                                                 t1,
 985                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 986                                                 &t1->data[(j * t1->w) + i],
 987                                                 orient,
 988                                                 bpno,
 989                                                 one,
 990                                                 nmsedec,
 991                                                 agg && (j == k + runlen),
 992                                                 vsc);
 993                         }
 994                 }
 995         }
 996 }
 997
 998 static void opj_t1_dec_clnpass(
 999                 opj_t1_t *t1,
1000                 OPJ_INT32 bpno,
1001                 OPJ_INT32 orient,
1002                 OPJ_INT32 cblksty)
1003 {
1004         OPJ_INT32 one, half, oneplushalf, agg, runlen, vsc;
1005     OPJ_UINT32 i, j, k;
1006         OPJ_INT32 segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
1007
1008         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1009
1010         one = 1 << bpno;
1011         half = one >> 1;
1012         oneplushalf = one | half;
1013         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1014         for (k = 0; k < t1->h; k += 4) {
1015                 for (i = 0; i < t1->w; ++i) {
1016                         if (k + 3 < t1->h) {
1017                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1018                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1019                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1020                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
1021                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1022                                 } else {
1023                                 agg = 0;
1024                         }
1025                         if (agg) {
1026                                 opj_mqc_setcurctx(mqc, T1_CTXNO_AGG);
1027                                 if (!opj_mqc_decode(mqc)) {
1028                                         continue;
1029                                 }
1030                                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
1031                                 runlen = opj_mqc_decode(mqc);
1032                                 runlen = (runlen << 1) | opj_mqc_decode(mqc);
1033                         } else {
1034                                 runlen = 0;
1035                         }
1036                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1037                                         vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
1038                                         opj_t1_dec_clnpass_step_vsc(
1039                                                 t1,
1040                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
1041                                                 &t1->data[(j * t1->w) + i],
1042                                                 orient,
1043                                                 oneplushalf,
1044                                                 agg && (j == k + runlen),
1045                                                 vsc);
1046                         }
1047                 }
1048         }
1049         } else {
1050                 OPJ_INT32 *data1 = t1->data;
1051                 opj_flag_t *flags1 = &t1->flags[1];
1052                 for (k = 0; k < (t1->h & ~3); k += 4) {
1053                         for (i = 0; i < t1->w; ++i) {
1054                                 OPJ_INT32 *data2 = data1 + i;
1055                                 opj_flag_t *flags2 = flags1 + i;
1056                                 agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1057                                         || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1058                                         || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1059                                         || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1060                                 if (agg) {
1061                                         opj_mqc_setcurctx(mqc, T1_CTXNO_AGG);
1062                                         if (!opj_mqc_decode(mqc)) {
1063                                                 continue;
1064                                         }
1065                                         opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
1066                                         runlen = opj_mqc_decode(mqc);
1067                                         runlen = (runlen << 1) | opj_mqc_decode(mqc);
1068                                         flags2 += runlen * t1->flags_stride;
1069                                         data2 += runlen * t1->w;
1070                                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1071                                                 flags2 += t1->flags_stride;
1072                                                 if (agg && (j == k + runlen)) {
1073                                                         opj_t1_dec_clnpass_step_partial(t1, flags2, data2, orient, oneplushalf);
1074                                                 } else {
1075                                                         opj_t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1076                                                 }
1077                                                 data2 += t1->w;
1078                                         }
1079                                 } else {
1080                                         flags2 += t1->flags_stride;
1081                                         opj_t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1082                                         data2 += t1->w;
1083                                         flags2 += t1->flags_stride;
1084                                         opj_t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1085                                         data2 += t1->w;
1086                                         flags2 += t1->flags_stride;
1087                                         opj_t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1088                                         data2 += t1->w;
1089                                         flags2 += t1->flags_stride;
1090                                         opj_t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1091                                         data2 += t1->w;
1092                                 }
1093                         }
1094                         data1 += t1->w << 2;
1095                         flags1 += t1->flags_stride << 2;
1096                 }
1097                 for (i = 0; i < t1->w; ++i) {
1098                         OPJ_INT32 *data2 = data1 + i;
1099                         opj_flag_t *flags2 = flags1 + i;
1100                         for (j = k; j < t1->h; ++j) {
1101                                 flags2 += t1->flags_stride;
1102                                 opj_t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1103                                 data2 += t1->w;
1104                         }
1105                 }
1106         }
1107
1108         if (segsym) {
1109                 OPJ_INT32 v = 0;
1110                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
1111                 v = opj_mqc_decode(mqc);
1112                 v = (v << 1) | opj_mqc_decode(mqc);
1113                 v = (v << 1) | opj_mqc_decode(mqc);
1114                 v = (v << 1) | opj_mqc_decode(mqc);
1115                 /*
1116                 if (v!=0xa) {
1117                         opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
1118                 }
1119                 */
1120         }
1121 }                               /* VSC and  BYPASS by Antonin */
1122
1123
1124 /** mod fixed_quality */
1125 static OPJ_FLOAT64 opj_t1_getwmsedec(
1126                 OPJ_INT32 nmsedec,
1127                 OPJ_UINT32 compno,
1128                 OPJ_UINT32 level,
1129                 OPJ_UINT32 orient,
1130                 OPJ_INT32 bpno,
1131                 OPJ_UINT32 qmfbid,
1132                 OPJ_FLOAT64 stepsize,
1133                 OPJ_UINT32 numcomps,
1134                 const OPJ_FLOAT64 * mct_norms)
1135 {
1136         OPJ_FLOAT64 w1 = 1, w2, wmsedec;
1137     OPJ_ARG_NOT_USED(numcomps);
1138
1139         if (mct_norms) {
1140                 w1 = mct_norms[compno];
1141         }
1142
1143         if (qmfbid == 1) {
1144                 w2 = opj_dwt_getnorm(level, orient);
1145         } else {        /* if (qmfbid == 0) */
1146                 w2 = opj_dwt_getnorm_real(level, orient);
1147         }
1148
1149         wmsedec = w1 * w2 * stepsize * (1 << bpno);
1150         wmsedec *= wmsedec * nmsedec / 8192.0;
1151
1152         return wmsedec;
1153 }
1154
1155 OPJ_BOOL opj_t1_allocate_buffers(
1156                 opj_t1_t *t1,
1157                 OPJ_UINT32 w,
1158                 OPJ_UINT32 h)
1159 {
1160         OPJ_UINT32 datasize=w * h;
1161         OPJ_UINT32 flagssize;
1162
1163         if(datasize > t1->datasize){
1164                 opj_aligned_free(t1->data);
1165                 t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
1166                 if(!t1->data){
1167                         return OPJ_FALSE;
1168                 }
1169                 t1->datasize=datasize;
1170         }
1171         memset(t1->data,0,datasize * sizeof(OPJ_INT32));
1172
1173         t1->flags_stride=w+2;
1174         flagssize=t1->flags_stride * (h+2);
1175
1176         if(flagssize > t1->flagssize){
1177                 opj_aligned_free(t1->flags);
1178                 t1->flags = (opj_flag_t*) opj_aligned_malloc(flagssize * sizeof(opj_flag_t));
1179                 if(!t1->flags){
1180                         return OPJ_FALSE;
1181                 }
1182                 t1->flagssize=flagssize;
1183         }
1184         memset(t1->flags,0,flagssize * sizeof(opj_flag_t));
1185
1186         t1->w=w;
1187         t1->h=h;
1188
1189         return OPJ_TRUE;
1190 }
1191
1192 /* ----------------------------------------------------------------------- */
1193
1194 /* ----------------------------------------------------------------------- */
1195 /**
1196  * Creates a new Tier 1 handle
1197  * and initializes the look-up tables of the Tier-1 coder/decoder
1198  * @return a new T1 handle if successful, returns NULL otherwise
1199 */
1200 opj_t1_t* opj_t1_create()
1201 {
1202         opj_t1_t *l_t1 = 00;
1203
1204         l_t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
1205         if (!l_t1) {
1206                 return 00;
1207         }
1208         memset(l_t1,0,sizeof(opj_t1_t));
1209
1210         /* create MQC and RAW handles */
1211         l_t1->mqc = opj_mqc_create();
1212         if (! l_t1->mqc) {
1213                 opj_t1_destroy(l_t1);
1214                 return 00;
1215         }
1216
1217         l_t1->raw = opj_raw_create();
1218         if (! l_t1->raw) {
1219                 opj_t1_destroy(l_t1);
1220                 return 00;
1221         }
1222
1223         return l_t1;
1224 }
1225
1226
1227 /**
1228  * Destroys a previously created T1 handle
1229  *
1230  * @param p_t1 Tier 1 handle to destroy
1231 */
1232 void opj_t1_destroy(opj_t1_t *p_t1)
1233 {
1234         if (! p_t1) {
1235                 return;
1236         }
1237
1238         /* destroy MQC and RAW handles */
1239         opj_mqc_destroy(p_t1->mqc);
1240         p_t1->mqc = 00;
1241         opj_raw_destroy(p_t1->raw);
1242         p_t1->raw = 00;
1243
1244     if (p_t1->data) {
1245                 opj_aligned_free(p_t1->data);
1246                 p_t1->data = 00;
1247         }
1248
1249         if (p_t1->flags) {
1250                 opj_aligned_free(p_t1->flags);
1251                 p_t1->flags = 00;
1252         }
1253
1254         opj_free(p_t1);
1255 }
1256
1257 OPJ_BOOL opj_t1_decode_cblks(   opj_t1_t* t1,
1258                             opj_tcd_tilecomp_t* tilec,
1259                             opj_tccp_t* tccp
1260                             )
1261 {
1262         OPJ_UINT32 resno, bandno, precno, cblkno;
1263         OPJ_UINT32 tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
1264
1265         for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
1266                 opj_tcd_resolution_t* res = &tilec->resolutions[resno];
1267
1268                 for (bandno = 0; bandno < res->numbands; ++bandno) {
1269                         opj_tcd_band_t* restrict band = &res->bands[bandno];
1270
1271                         for (precno = 0; precno < res->pw * res->ph; ++precno) {
1272                                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
1273
1274                                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1275                                         opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
1276                                         OPJ_INT32* restrict datap;
1277                                         /*void* restrict tiledp;*/
1278                                         OPJ_UINT32 cblk_w, cblk_h;
1279                                         OPJ_INT32 x, y;
1280                                         OPJ_UINT32 i, j;
1281
1282                     if (OPJ_FALSE == opj_t1_decode_cblk(
1283                                             t1,
1284                                             cblk,
1285                                             band->bandno,
1286                                             (OPJ_UINT32)tccp->roishift,
1287                                             tccp->cblksty)) {
1288                             return OPJ_FALSE;
1289                     }
1290
1291                                         x = cblk->x0 - band->x0;
1292                                         y = cblk->y0 - band->y0;
1293                                         if (band->bandno & 1) {
1294                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1295                                                 x += pres->x1 - pres->x0;
1296                                         }
1297                                         if (band->bandno & 2) {
1298                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1299                                                 y += pres->y1 - pres->y0;
1300                                         }
1301
1302                                         datap=t1->data;
1303                                         cblk_w = t1->w;
1304                                         cblk_h = t1->h;
1305
1306                                         if (tccp->roishift) {
1307                                                 OPJ_INT32 thresh = 1 << tccp->roishift;
1308                                                 for (j = 0; j < cblk_h; ++j) {
1309                                                         for (i = 0; i < cblk_w; ++i) {
1310                                                                 OPJ_INT32 val = datap[(j * cblk_w) + i];
1311                                                                 OPJ_INT32 mag = abs(val);
1312                                                                 if (mag >= thresh) {
1313                                                                         mag >>= tccp->roishift;
1314                                                                         datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1315                                                                 }
1316                                                         }
1317                                                 }
1318                                         }
1319
1320                                         /*tiledp=(void*)&tilec->data[(y * tile_w) + x];*/
1321                                         if (tccp->qmfbid == 1) {
1322                         OPJ_INT32* restrict tiledp = &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
1323                                                 for (j = 0; j < cblk_h; ++j) {
1324                                                         for (i = 0; i < cblk_w; ++i) {
1325                                                                 OPJ_INT32 tmp = datap[(j * cblk_w) + i];
1326                                                                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp / 2;
1327                                                         }
1328                                                 }
1329                                         } else {                /* if (tccp->qmfbid == 0) */
1330                         OPJ_FLOAT32* restrict tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
1331                                                 for (j = 0; j < cblk_h; ++j) {
1332                             OPJ_FLOAT32* restrict tiledp2 = tiledp;
1333                                                         for (i = 0; i < cblk_w; ++i) {
1334                                 OPJ_FLOAT32 tmp = (OPJ_FLOAT32)*datap * band->stepsize;
1335                                 *tiledp2 = tmp;
1336                                 datap++;
1337                                 tiledp2++;
1338                                                                 /*float tmp = datap[(j * cblk_w) + i] * band->stepsize;
1339                                                                 ((float*)tiledp)[(j * tile_w) + i] = tmp;*/
1340
1341                                                         }
1342                             tiledp += tile_w;
1343                                                 }
1344                                         }
1345                     /*opj_free(cblk->data);
1346                                         opj_free(cblk->segs);*/
1347                                         /*cblk->segs = 00;*/
1348                                 } /* cblkno */
1349                 /*opj_free(precinct->cblks.dec);*/
1350                         } /* precno */
1351                 } /* bandno */
1352         } /* resno */
1353         return OPJ_TRUE;
1354 }
1355
1356
1357 OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
1358                             opj_tcd_cblk_dec_t* cblk,
1359                             OPJ_UINT32 orient,
1360                             OPJ_UINT32 roishift,
1361                             OPJ_UINT32 cblksty)
1362 {
1363         opj_raw_t *raw = t1->raw;       /* RAW component */
1364         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1365
1366         OPJ_INT32 bpno;
1367         OPJ_UINT32 passtype;
1368         OPJ_UINT32 segno, passno;
1369         OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
1370
1371         if(!opj_t1_allocate_buffers(
1372                                 t1,
1373                                 (OPJ_UINT32)(cblk->x1 - cblk->x0),
1374                                 (OPJ_UINT32)(cblk->y1 - cblk->y0)))
1375         {
1376                 return OPJ_FALSE;
1377         }
1378
1379         bpno = (OPJ_INT32)(roishift + cblk->numbps - 1);
1380         passtype = 2;
1381
1382         opj_mqc_resetstates(mqc);
1383         opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1384         opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1385         opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1386
1387         for (segno = 0; segno < cblk->real_num_segs; ++segno) {
1388                 opj_tcd_seg_t *seg = &cblk->segs[segno];
1389
1390                 /* BYPASS mode */
1391                 type = ((bpno <= ((OPJ_INT32) (cblk->numbps) - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1392                 /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
1393                 if(seg->data == 00){
1394                         continue;
1395                 }
1396                 if (type == T1_TYPE_RAW) {
1397                         opj_raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
1398                 } else {
1399             if (OPJ_FALSE == opj_mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len)) {
1400                     return OPJ_FALSE;
1401             }
1402                 }
1403
1404                 for (passno = 0; passno < seg->real_num_passes; ++passno) {
1405             switch (passtype) {
1406                 case 0:
1407                     if (type == T1_TYPE_RAW) {
1408                         opj_t1_dec_sigpass_raw(t1, bpno+1, (OPJ_INT32)orient, (OPJ_INT32)cblksty);
1409                     } else {
1410                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1411                             opj_t1_dec_sigpass_mqc_vsc(t1, bpno+1, (OPJ_INT32)orient);
1412                         } else {
1413                             opj_t1_dec_sigpass_mqc(t1, bpno+1, (OPJ_INT32)orient);
1414                         }
1415                     }
1416                     break;
1417                 case 1:
1418                     if (type == T1_TYPE_RAW) {
1419                             opj_t1_dec_refpass_raw(t1, bpno+1, (OPJ_INT32)cblksty);
1420                     } else {
1421                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1422                             opj_t1_dec_refpass_mqc_vsc(t1, bpno+1);
1423                         } else {
1424                             opj_t1_dec_refpass_mqc(t1, bpno+1);
1425                         }
1426                     }
1427                     break;
1428                 case 2:
1429                     opj_t1_dec_clnpass(t1, bpno+1, (OPJ_INT32)orient, (OPJ_INT32)cblksty);
1430                     break;
1431             }
1432
1433                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
1434                                 opj_mqc_resetstates(mqc);
1435                                 opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1436                                 opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1437                                 opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1438                         }
1439                         if (++passtype == 3) {
1440                                 passtype = 0;
1441                                 bpno--;
1442                         }
1443                 }
1444         }
1445         return OPJ_TRUE;
1446 }
1447
1448
1449
1450
1451 OPJ_BOOL opj_t1_encode_cblks(   opj_t1_t *t1,
1452                                 opj_tcd_tile_t *tile,
1453                                 opj_tcp_t *tcp,
1454                                 const OPJ_FLOAT64 * mct_norms
1455                                 )
1456 {
1457         OPJ_UINT32 compno, resno, bandno, precno, cblkno;
1458
1459         tile->distotile = 0;            /* fixed_quality */
1460
1461         for (compno = 0; compno < tile->numcomps; ++compno) {
1462                 opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
1463                 opj_tccp_t* tccp = &tcp->tccps[compno];
1464                 OPJ_UINT32 tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
1465
1466                 for (resno = 0; resno < tilec->numresolutions; ++resno) {
1467                         opj_tcd_resolution_t *res = &tilec->resolutions[resno];
1468
1469                         for (bandno = 0; bandno < res->numbands; ++bandno) {
1470                                 opj_tcd_band_t* restrict band = &res->bands[bandno];
1471                 OPJ_INT32 bandconst = 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192));
1472
1473                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1474                                         opj_tcd_precinct_t *prc = &band->precincts[precno];
1475
1476                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1477                                                 opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
1478                                                 OPJ_INT32 * restrict datap;
1479                                                 OPJ_INT32* restrict tiledp;
1480                                                 OPJ_UINT32 cblk_w;
1481                                                 OPJ_UINT32 cblk_h;
1482                                                 OPJ_UINT32 i, j;
1483
1484                                                 OPJ_INT32 x = cblk->x0 - band->x0;
1485                                                 OPJ_INT32 y = cblk->y0 - band->y0;
1486                                                 if (band->bandno & 1) {
1487                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1488                                                         x += pres->x1 - pres->x0;
1489                                                 }
1490                                                 if (band->bandno & 2) {
1491                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1492                                                         y += pres->y1 - pres->y0;
1493                                                 }
1494
1495                                                 if(!opj_t1_allocate_buffers(
1496                                                                         t1,
1497                                                                         (OPJ_UINT32)(cblk->x1 - cblk->x0),
1498                                                                         (OPJ_UINT32)(cblk->y1 - cblk->y0)))
1499                                                 {
1500                                                         return OPJ_FALSE;
1501                                                 }
1502
1503                                                 datap=t1->data;
1504                                                 cblk_w = t1->w;
1505                                                 cblk_h = t1->h;
1506
1507                                                 tiledp=&tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
1508                                                 if (tccp->qmfbid == 1) {
1509                                                         for (j = 0; j < cblk_h; ++j) {
1510                                                                 for (i = 0; i < cblk_w; ++i) {
1511                                                                         OPJ_INT32 tmp = tiledp[(j * tile_w) + i];
1512                                                                         datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;
1513                                                                 }
1514                                                         }
1515                                                 } else {                /* if (tccp->qmfbid == 0) */
1516                                                         for (j = 0; j < cblk_h; ++j) {
1517                                                                 for (i = 0; i < cblk_w; ++i) {
1518                                                                         OPJ_INT32 tmp = tiledp[(j * tile_w) + i];
1519                                                                         datap[(j * cblk_w) + i] =
1520                                                                                 opj_int_fix_mul(
1521                                                                                 tmp,
1522                                                                                 bandconst) >> (11 - T1_NMSEDEC_FRACBITS);
1523                                                                 }
1524                                                         }
1525                                                 }
1526
1527                                                 opj_t1_encode_cblk(
1528                                                                 t1,
1529                                                                 cblk,
1530                                                                 band->bandno,
1531                                                                 compno,
1532                                                                 tilec->numresolutions - 1 - resno,
1533                                                                 tccp->qmfbid,
1534                                                                 band->stepsize,
1535                                                                 tccp->cblksty,
1536                                                                 tile->numcomps,
1537                                                                 tile,
1538                                                                 mct_norms);
1539
1540                                         } /* cblkno */
1541                                 } /* precno */
1542                         } /* bandno */
1543                 } /* resno  */
1544         } /* compno  */
1545         return OPJ_TRUE;
1546 }
1547
1548 /** mod fixed_quality */
1549 void opj_t1_encode_cblk(opj_t1_t *t1,
1550                         opj_tcd_cblk_enc_t* cblk,
1551                         OPJ_UINT32 orient,
1552                         OPJ_UINT32 compno,
1553                         OPJ_UINT32 level,
1554                         OPJ_UINT32 qmfbid,
1555                         OPJ_FLOAT64 stepsize,
1556                         OPJ_UINT32 cblksty,
1557                         OPJ_UINT32 numcomps,
1558                         opj_tcd_tile_t * tile,
1559                         const OPJ_FLOAT64 * mct_norms)
1560 {
1561         OPJ_FLOAT64 cumwmsedec = 0.0;
1562
1563         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1564
1565         OPJ_UINT32 passno;
1566         OPJ_INT32 bpno;
1567         OPJ_UINT32 passtype;
1568         OPJ_INT32 nmsedec = 0;
1569         OPJ_INT32 max;
1570         OPJ_UINT32 i;
1571         OPJ_BYTE type = T1_TYPE_MQ;
1572         OPJ_FLOAT64 tempwmsedec;
1573
1574         max = 0;
1575         for (i = 0; i < t1->w * t1->h; ++i) {
1576                 OPJ_INT32 tmp = abs(t1->data[i]);
1577                 max = opj_int_max(max, tmp);
1578         }
1579
1580         cblk->numbps = max ? (OPJ_UINT32)((opj_int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS) : 0;
1581
1582         bpno = (OPJ_INT32)(cblk->numbps - 1);
1583         passtype = 2;
1584
1585         opj_mqc_resetstates(mqc);
1586         opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1587         opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1588         opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1589         opj_mqc_init_enc(mqc, cblk->data);
1590
1591         for (passno = 0; bpno >= 0; ++passno) {
1592                 opj_tcd_pass_t *pass = &cblk->passes[passno];
1593                 OPJ_UINT32 correction = 3;
1594                 type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1595
1596                 switch (passtype) {
1597                         case 0:
1598                                 opj_t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
1599                                 break;
1600                         case 1:
1601                                 opj_t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
1602                                 break;
1603                         case 2:
1604                                 opj_t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
1605                                 /* code switch SEGMARK (i.e. SEGSYM) */
1606                                 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
1607                                         opj_mqc_segmark_enc(mqc);
1608                                 break;
1609                 }
1610
1611                 /* fixed_quality */
1612                 tempwmsedec = opj_t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps,mct_norms) ;
1613                 cumwmsedec += tempwmsedec;
1614                 tile->distotile += tempwmsedec;
1615
1616                 /* Code switch "RESTART" (i.e. TERMALL) */
1617                 if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
1618                         if (type == T1_TYPE_RAW) {
1619                                 opj_mqc_flush(mqc);
1620                                 correction = 1;
1621                                 /* correction = mqc_bypass_flush_enc(); */
1622                         } else {                        /* correction = mqc_restart_enc(); */
1623                                 opj_mqc_flush(mqc);
1624                                 correction = 1;
1625                         }
1626                         pass->term = 1;
1627                 } else {
1628                         if (((bpno < ((OPJ_INT32) (cblk->numbps) - 4) && (passtype > 0))
1629                                 || ((bpno == ((OPJ_INT32)cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
1630                                 if (type == T1_TYPE_RAW) {
1631                                         opj_mqc_flush(mqc);
1632                                         correction = 1;
1633                                         /* correction = mqc_bypass_flush_enc(); */
1634                                 } else {                /* correction = mqc_restart_enc(); */
1635                                         opj_mqc_flush(mqc);
1636                                         correction = 1;
1637                                 }
1638                                 pass->term = 1;
1639                         } else {
1640                                 pass->term = 0;
1641                         }
1642                 }
1643
1644                 if (++passtype == 3) {
1645                         passtype = 0;
1646                         bpno--;
1647                 }
1648
1649                 if (pass->term && bpno > 0) {
1650                         type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1651                         if (type == T1_TYPE_RAW)
1652                                 opj_mqc_bypass_init_enc(mqc);
1653                         else
1654                                 opj_mqc_restart_init_enc(mqc);
1655                 }
1656
1657                 pass->distortiondec = cumwmsedec;
1658                 pass->rate = opj_mqc_numbytes(mqc) + correction;        /* FIXME */
1659
1660                 /* Code-switch "RESET" */
1661                 if (cblksty & J2K_CCP_CBLKSTY_RESET)
1662                         opj_mqc_reset_enc(mqc);
1663         }
1664
1665         /* Code switch "ERTERM" (i.e. PTERM) */
1666         if (cblksty & J2K_CCP_CBLKSTY_PTERM)
1667                 opj_mqc_erterm_enc(mqc);
1668         else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
1669                 opj_mqc_flush(mqc);
1670
1671         cblk->totalpasses = passno;
1672
1673         for (passno = 0; passno<cblk->totalpasses; passno++) {
1674                 opj_tcd_pass_t *pass = &cblk->passes[passno];
1675                 if (pass->rate > opj_mqc_numbytes(mqc))
1676                         pass->rate = opj_mqc_numbytes(mqc);
1677                 /*Preventing generation of FF as last data byte of a pass*/
1678                 if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
1679                         pass->rate--;
1680                 }
1681                 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
1682         }
1683 }
1684
1685 #if 0
1686 void opj_t1_dec_refpass_step(   opj_t1_t *t1,
1687                                 opj_flag_t *flagsp,
1688                                 OPJ_INT32 *datap,
1689                                 OPJ_INT32 poshalf,
1690                                 OPJ_INT32 neghalf,
1691                                 OPJ_BYTE type,
1692                                 OPJ_UINT32 vsc)
1693 {
1694         OPJ_INT32  t;
1695         OPJ_UINT32 v,flag;
1696
1697         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1698         opj_raw_t *raw = t1->raw;       /* RAW component */
1699
1700         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
1701         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
1702                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_mag(flag));      /* ESSAI */
1703                 if (type == T1_TYPE_RAW) {
1704                         v = opj_raw_decode(raw);
1705                 } else {
1706                         v = opj_mqc_decode(mqc);
1707                 }
1708                 t = v ? poshalf : neghalf;
1709                 *datap += *datap < 0 ? -t : t;
1710                 *flagsp |= T1_REFINE;
1711         }
1712 }                               /* VSC and  BYPASS by Antonin  */
1713 #endif
1714
1715
1716
1717 #if 0
1718 void opj_t1_dec_sigpass_step(   opj_t1_t *t1,
1719                                 opj_flag_t *flagsp,
1720                                 OPJ_INT32 *datap,
1721                                 OPJ_UINT32 orient,
1722                                 OPJ_INT32 oneplushalf,
1723                                 OPJ_BYTE type,
1724                                 OPJ_UINT32 vsc)
1725 {
1726         OPJ_UINT32 v, flag;
1727
1728         opj_raw_t *raw = t1->raw;       /* RAW component */
1729         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1730
1731         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
1732         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
1733                 if (type == T1_TYPE_RAW) {
1734                         if (opj_raw_decode(raw)) {
1735                                 v = opj_raw_decode(raw);        /* ESSAI */
1736                                 *datap = v ? -oneplushalf : oneplushalf;
1737                                 opj_t1_updateflags(flagsp, v, t1->flags_stride);
1738                         }
1739                 } else {
1740                         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(flag, orient));
1741                         if (opj_mqc_decode(mqc)) {
1742                                 opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
1743                                 v = opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
1744                                 *datap = v ? -oneplushalf : oneplushalf;
1745                                 opj_t1_updateflags(flagsp, v, t1->flags_stride);
1746                         }
1747                 }
1748                 *flagsp |= T1_VISIT;
1749         }
1750 }                               /* VSC and  BYPASS by Antonin */
1751 #endif