src/lib/openjp2/t1.c

   1 /*
   2  * The copyright in this software is being made available under the 2-clauses
   3  * BSD License, included below. This software may be subject to other third
   4  * party and contributor rights, including patent rights, and no such rights
   5  * are granted under this license.
   6  *
   7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   8  * Copyright (c) 2002-2014, Professor Benoit Macq
   9  * Copyright (c) 2001-2003, David Janssens
  10  * Copyright (c) 2002-2003, Yannick Verschueren
  11  * Copyright (c) 2003-2007, Francois-Olivier Devaux
  12  * Copyright (c) 2003-2014, Antonin Descampe
  13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  14  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
  15  * Copyright (c) 2012, Carl Hetherington
  16  * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
  17  * All rights reserved.
  18  *
  19  * Redistribution and use in source and binary forms, with or without
  20  * modification, are permitted provided that the following conditions
  21  * are met:
  22  * 1. Redistributions of source code must retain the above copyright
  23  *    notice, this list of conditions and the following disclaimer.
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in the
  26  *    documentation and/or other materials provided with the distribution.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 #include "opj_includes.h"
  42 #include "t1_luts.h"
  43
  44 /* #define CONSISTENCY_CHECK */
  45
  46 /** @defgroup T1 T1 - Implementation of the tier-1 coding */
  47 /*@{*/
  48
  49 #define ENC_FLAGS(x, y) (t1->enc_flags[x + 1 + ((y / 4) + 1) * t1->flags_stride])
  50
  51 /** @name Local static functions */
  52 /*@{*/
  53
  54 static INLINE OPJ_BYTE opj_t1_enc_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient);
  55 static INLINE OPJ_BYTE opj_t1_getctxno_zc(opj_mqc_t *mqc, OPJ_UINT32 f);
  56 static OPJ_BYTE opj_t1_enc_getctxno_sc(OPJ_UINT32 fX, OPJ_UINT32 pfX,
  57                                        OPJ_UINT32 nfX, OPJ_UINT32 ci);
  58 static OPJ_BYTE opj_t1_getctxno_sc(OPJ_UINT32 f);
  59 static INLINE OPJ_UINT32 opj_t1_enc_getctxno_mag(OPJ_UINT32 f);
  60 static OPJ_BYTE opj_t1_enc_getspb(OPJ_UINT32 fX, OPJ_UINT32 pfX, OPJ_UINT32 nfX,
  61                                   OPJ_UINT32 ci);
  62 static OPJ_BYTE opj_t1_getspb(OPJ_UINT32 f);
  63 static OPJ_INT16 opj_t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos);
  64 static OPJ_INT16 opj_t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos);
  65 static INLINE void opj_t1_enc_updateflags(opj_flag_enc_t *flagsp, OPJ_UINT32 ci,
  66         OPJ_UINT32 s, OPJ_UINT32 stride);
  67 static INLINE void opj_t1_updateflags(opj_flag_t *flagsp, OPJ_UINT32 s,
  68                                       OPJ_UINT32 stride);
  69
  70
  71 /**
  72 Decode significant pass
  73 */
  74
  75 static INLINE void opj_t1_dec_sigpass_step_raw(
  76     opj_t1_t *t1,
  77     opj_flag_t *flagsp,
  78     opj_colflag_t* colflagsp,
  79     OPJ_INT32 *datap,
  80     OPJ_INT32 oneplushalf,
  81     OPJ_INT32 vsc,
  82     OPJ_UINT32 row);
  83 static INLINE void opj_t1_dec_sigpass_step_mqc(
  84     opj_t1_t *t1,
  85     opj_flag_t *flagsp,
  86     opj_colflag_t* colflagsp,
  87     OPJ_INT32 *datap,
  88     OPJ_INT32 oneplushalf,
  89     OPJ_UINT32 row,
  90     OPJ_UINT32 flags_stride);
  91 static INLINE void opj_t1_dec_sigpass_step_mqc_vsc(
  92     opj_t1_t *t1,
  93     opj_flag_t *flagsp,
  94     opj_colflag_t* colflagsp,
  95     OPJ_INT32 *datap,
  96     OPJ_INT32 oneplushalf,
  97     OPJ_INT32 vsc,
  98     OPJ_UINT32 row);
  99
 100
 101 /**
 102 Encode significant pass
 103 */
 104 static void opj_t1_enc_sigpass(opj_t1_t *t1,
 105                                OPJ_INT32 bpno,
 106                                OPJ_UINT32 orient,
 107                                OPJ_INT32 *nmsedec,
 108                                OPJ_BYTE type,
 109                                OPJ_UINT32 cblksty);
 110
 111 /**
 112 Decode significant pass
 113 */
 114 static void opj_t1_dec_sigpass_raw(
 115     opj_t1_t *t1,
 116     OPJ_INT32 bpno,
 117     OPJ_INT32 cblksty);
 118 static void opj_t1_dec_sigpass_mqc_vsc(
 119     opj_t1_t *t1,
 120     OPJ_INT32 bpno);
 121
 122
 123
 124 /**
 125 Encode refinement pass
 126 */
 127 static void opj_t1_enc_refpass(opj_t1_t *t1,
 128                                OPJ_INT32 bpno,
 129                                OPJ_INT32 *nmsedec,
 130                                OPJ_BYTE type,
 131                                OPJ_UINT32 cblksty);
 132
 133 /**
 134 Decode refinement pass
 135 */
 136 static void opj_t1_dec_refpass_raw(
 137     opj_t1_t *t1,
 138     OPJ_INT32 bpno);
 139 static void opj_t1_dec_refpass_mqc_vsc(
 140     opj_t1_t *t1,
 141     OPJ_INT32 bpno);
 142
 143
 144 /**
 145 Decode refinement pass
 146 */
 147
 148 static INLINE void  opj_t1_dec_refpass_step_raw(
 149     opj_t1_t *t1,
 150     opj_colflag_t *colflagsp,
 151     OPJ_INT32 *datap,
 152     OPJ_INT32 poshalf,
 153     OPJ_INT32 neghalf,
 154     OPJ_UINT32 row);
 155 static INLINE void opj_t1_dec_refpass_step_mqc(
 156     opj_t1_t *t1,
 157     opj_flag_t *flagsp,
 158     opj_colflag_t *colflagsp,
 159     OPJ_INT32 *datap,
 160     OPJ_INT32 poshalf,
 161     OPJ_INT32 neghalf,
 162     OPJ_UINT32 row);
 163 static INLINE void opj_t1_dec_refpass_step_mqc_vsc(
 164     opj_t1_t *t1,
 165     opj_flag_t *flagsp,
 166     opj_colflag_t *colflagsp,
 167     OPJ_INT32 *datap,
 168     OPJ_INT32 poshalf,
 169     OPJ_INT32 neghalf,
 170     OPJ_INT32 vsc,
 171     OPJ_UINT32 row);
 172
 173
 174 /**
 175 Decode clean-up pass
 176 */
 177 static void opj_t1_dec_clnpass_step_partial(
 178     opj_t1_t *t1,
 179     opj_flag_t *flagsp,
 180     opj_colflag_t *colflagsp,
 181     OPJ_INT32 *datap,
 182     OPJ_INT32 oneplushalf,
 183     OPJ_UINT32 row);
 184 static void opj_t1_dec_clnpass_step(
 185     opj_t1_t *t1,
 186     opj_flag_t *flagsp,
 187     opj_colflag_t *colflagsp,
 188     OPJ_INT32 *datap,
 189     OPJ_INT32 oneplushalf,
 190     OPJ_UINT32 row);
 191 static void opj_t1_dec_clnpass_step_vsc(
 192     opj_t1_t *t1,
 193     opj_flag_t *flagsp,
 194     opj_colflag_t *colflagsp,
 195     OPJ_INT32 *datap,
 196     OPJ_INT32 oneplushalf,
 197     OPJ_INT32 partial,
 198     OPJ_INT32 vsc,
 199     OPJ_UINT32 row);
 200 /**
 201 Encode clean-up pass
 202 */
 203 static void opj_t1_enc_clnpass(
 204     opj_t1_t *t1,
 205     OPJ_INT32 bpno,
 206     OPJ_UINT32 orient,
 207     OPJ_INT32 *nmsedec,
 208     OPJ_UINT32 cblksty);
 209
 210 static OPJ_FLOAT64 opj_t1_getwmsedec(
 211     OPJ_INT32 nmsedec,
 212     OPJ_UINT32 compno,
 213     OPJ_UINT32 level,
 214     OPJ_UINT32 orient,
 215     OPJ_INT32 bpno,
 216     OPJ_UINT32 qmfbid,
 217     OPJ_FLOAT64 stepsize,
 218     OPJ_UINT32 numcomps,
 219     const OPJ_FLOAT64 * mct_norms,
 220     OPJ_UINT32 mct_numcomps);
 221
 222 static void opj_t1_encode_cblk(opj_t1_t *t1,
 223                                opj_tcd_cblk_enc_t* cblk,
 224                                OPJ_UINT32 orient,
 225                                OPJ_UINT32 compno,
 226                                OPJ_UINT32 level,
 227                                OPJ_UINT32 qmfbid,
 228                                OPJ_FLOAT64 stepsize,
 229                                OPJ_UINT32 cblksty,
 230                                OPJ_UINT32 numcomps,
 231                                opj_tcd_tile_t * tile,
 232                                const OPJ_FLOAT64 * mct_norms,
 233                                OPJ_UINT32 mct_numcomps);
 234
 235 /**
 236 Decode 1 code-block
 237 @param t1 T1 handle
 238 @param cblk Code-block coding parameters
 239 @param orient
 240 @param roishift Region of interest shifting value
 241 @param cblksty Code-block style
 242 */
 243 static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
 244                                    opj_tcd_cblk_dec_t* cblk,
 245                                    OPJ_UINT32 orient,
 246                                    OPJ_UINT32 roishift,
 247                                    OPJ_UINT32 cblksty);
 248
 249 static OPJ_BOOL opj_t1_allocate_buffers(opj_t1_t *t1,
 250                                         OPJ_UINT32 w,
 251                                         OPJ_UINT32 h);
 252
 253 /*@}*/
 254
 255 /*@}*/
 256
 257 /* ----------------------------------------------------------------------- */
 258
 259 static INLINE OPJ_BYTE opj_t1_enc_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient)
 260 {
 261     return lut_enc_ctxno_zc[(orient << 9) | (f & T1_SIGMA_NEIGHBOURS)];
 262 }
 263
 264 static OPJ_BYTE opj_t1_getctxno_zc(opj_mqc_t *mqc, OPJ_UINT32 f)
 265 {
 266     return mqc->lut_ctxno_zc_orient[(f & T1_SIG_OTH)];
 267 }
 268
 269
 270 static OPJ_BYTE opj_t1_enc_getctxno_sc(OPJ_UINT32 fX, OPJ_UINT32 pfX,
 271                                        OPJ_UINT32 nfX, OPJ_UINT32 ci)
 272 {
 273     /*
 274       0 pfX T1_CHI_THIS           T1_LUT_CTXNO_SGN_W
 275       1 tfX T1_SIGMA_1            T1_LUT_CTXNO_SIG_N
 276       2 nfX T1_CHI_THIS           T1_LUT_CTXNO_SGN_E
 277       3 tfX T1_SIGMA_3            T1_LUT_CTXNO_SIG_W
 278       4  fX T1_CHI_(THIS - 1)     T1_LUT_CTXNO_SGN_N
 279       5 tfX T1_SIGMA_5            T1_LUT_CTXNO_SIG_E
 280       6  fX T1_CHI_(THIS + 1)     T1_LUT_CTXNO_SGN_S
 281       7 tfX T1_SIGMA_7            T1_LUT_CTXNO_SIG_S
 282     */
 283
 284     OPJ_UINT32 lu = (fX >> (ci * 3)) & (T1_SIGMA_1 | T1_SIGMA_3 | T1_SIGMA_5 |
 285                                         T1_SIGMA_7);
 286
 287     lu |= (pfX >> (T1_CHI_THIS_I      + (ci * 3U))) & (1U << 0);
 288     lu |= (nfX >> (T1_CHI_THIS_I - 2U + (ci * 3U))) & (1U << 2);
 289     if (ci == 0U) {
 290         lu |= (fX >> (T1_CHI_0_I - 4U)) & (1U << 4);
 291     } else {
 292         lu |= (fX >> (T1_CHI_1_I - 4U + ((ci - 1U) * 3U))) & (1U << 4);
 293     }
 294     lu |= (fX >> (T1_CHI_2_I - 6U + (ci * 3U))) & (1U << 6);
 295
 296     return lut_enc_ctxno_sc[lu];
 297 }
 298
 299 static OPJ_BYTE opj_t1_getctxno_sc(OPJ_UINT32 f)
 300 {
 301     return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 302 }
 303
 304 static INLINE OPJ_UINT32 opj_t1_enc_getctxno_mag(OPJ_UINT32 f)
 305 {
 306     OPJ_UINT32 tmp = (f & T1_SIGMA_NEIGHBOURS) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
 307     OPJ_UINT32 tmp2 = (f & T1_MU_0) ? T1_CTXNO_MAG + 2 : tmp;
 308     return tmp2;
 309 }
 310
 311 static OPJ_BYTE opj_t1_enc_getspb(OPJ_UINT32 fX, OPJ_UINT32 pfX, OPJ_UINT32 nfX,
 312                                   OPJ_UINT32 ci)
 313 {
 314     /*
 315       0 pfX T1_CHI_THIS           T1_LUT_SGN_W
 316       1 tfX T1_SIGMA_1            T1_LUT_SIG_N
 317       2 nfX T1_CHI_THIS           T1_LUT_SGN_E
 318       3 tfX T1_SIGMA_3            T1_LUT_SIG_W
 319       4  fX T1_CHI_(THIS - 1)     T1_LUT_SGN_N
 320       5 tfX T1_SIGMA_5            T1_LUT_SIG_E
 321       6  fX T1_CHI_(THIS + 1)     T1_LUT_SGN_S
 322       7 tfX T1_SIGMA_7            T1_LUT_SIG_S
 323     */
 324
 325     int lu = (fX >> (ci * 3U)) & (T1_SIGMA_1 | T1_SIGMA_3 | T1_SIGMA_5 |
 326                                   T1_SIGMA_7);
 327
 328     lu |= (pfX >> (T1_CHI_THIS_I      + (ci * 3U))) & (1U << 0);
 329     lu |= (nfX >> (T1_CHI_THIS_I - 2U + (ci * 3U))) & (1U << 2);
 330     if (ci == 0U) {
 331         lu |= (fX >> (T1_CHI_0_I - 4U)) & (1U << 4);
 332     } else {
 333         lu |= (fX >> (T1_CHI_1_I - 4U + ((ci - 1U) * 3U))) & (1U << 4);
 334     }
 335     lu |= (fX >> (T1_CHI_2_I - 6U + (ci * 3U))) & (1U << 6);
 336
 337     return lut_enc_spb[lu];
 338 }
 339
 340 static OPJ_BYTE opj_t1_getspb(OPJ_UINT32 f)
 341 {
 342     return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 343 }
 344
 345 static OPJ_INT16 opj_t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos)
 346 {
 347     if (bitpos > 0) {
 348         return lut_nmsedec_sig[(x >> (bitpos)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 349     }
 350
 351     return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 352 }
 353
 354 static OPJ_INT16 opj_t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos)
 355 {
 356     if (bitpos > 0) {
 357         return lut_nmsedec_ref[(x >> (bitpos)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 358     }
 359
 360     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 361 }
 362
 363
 364 static INLINE void opj_t1_enc_updateflags(opj_flag_enc_t *flagsp, OPJ_UINT32 ci,
 365         OPJ_UINT32 s, OPJ_UINT32 stride)
 366 {
 367     /* set up to point to the north and south data points' flags words, if required */
 368     opj_flag_enc_t* north;
 369     opj_flag_enc_t* south;
 370
 371     /* mark target as significant */
 372     *flagsp |= T1_SIGMA_4 << (3U * ci);
 373
 374     /* north-west, north, north-east */
 375     if (ci == 0U) {
 376         north = flagsp - stride;
 377         *north |= T1_SIGMA_16;
 378         north[-1] |= T1_SIGMA_17;
 379         north[1] |= T1_SIGMA_15;
 380     }
 381
 382     /* south-west, south, south-east */
 383     if (ci == 3U) {
 384         south = flagsp + stride;
 385         *south |= T1_SIGMA_1;
 386         south[-1] |= T1_SIGMA_2;
 387         south[1] |= T1_SIGMA_0;
 388     }
 389
 390     /* east */
 391     flagsp[-1] |= T1_SIGMA_5 << (3U * ci);
 392
 393     /* west */
 394     flagsp[1] |= T1_SIGMA_3 << (3U * ci);
 395
 396     if (s) {
 397         switch (ci) {
 398         case 0U: {
 399             *flagsp |= T1_CHI_1;
 400             *north |= T1_CHI_5;
 401             break;
 402         }
 403         case 1:
 404             *flagsp |= T1_CHI_2;
 405             break;
 406         case 2:
 407             *flagsp |= T1_CHI_3;
 408             break;
 409         case 3: {
 410             *flagsp |= T1_CHI_4;
 411             *south |= T1_CHI_0;
 412             break;
 413         }
 414
 415         }
 416     }
 417 }
 418
 419 static INLINE void opj_t1_updateflags(opj_flag_t *flagsp, OPJ_UINT32 s,
 420                                       OPJ_UINT32 stride)
 421 {
 422     opj_flag_t *np = flagsp - stride;
 423     opj_flag_t *sp = flagsp + stride;
 424
 425     /* We strongly rely on (T1_SGN_N == 0x0100) == (T1_SIG_N == 0x0010) << 4 */
 426     /* and T1_SIG_E == T1_SIG_N << 1, T1_SIG_W == T1_SIG_N << 2 and T1_SIG_S == T1_SIG_N << 2 */
 427     /* and T1_SGN_E == T1_SGN_N << 1, T1_SGN_W == T1_SGN_N << 2 and T1_SGN_S == T1_SGN_N << 2 */
 428
 429     unsigned int flag_N = T1_SIG_N | ((unsigned int)T1_SIG_N << (4U * s));
 430
 431     np[-1] |= T1_SIG_SE;
 432     np[0]  |= (opj_flag_t)(flag_N << 2U);
 433     np[1]  |= T1_SIG_SW;
 434
 435     flagsp[-1] |= (opj_flag_t)(flag_N << 1U);
 436 #ifdef CONSISTENCY_CHECK
 437     flagsp[0]  |= T1_SIG;
 438 #endif
 439     flagsp[1]  |= (opj_flag_t)(flag_N << 3U);
 440
 441     sp[-1] |= T1_SIG_NE;
 442     sp[0]  = (opj_flag_t)(sp[0] | flag_N);
 443     sp[1]  |= T1_SIG_NW;
 444 }
 445
 446 static INLINE void opj_t1_updateflagscolflags(opj_flag_t *flagsp,
 447         opj_colflag_t *colflagsp, OPJ_UINT32 s, OPJ_UINT32 stride, OPJ_UINT32 row)
 448 {
 449     opj_t1_updateflags(flagsp, s, stride);
 450     if (row == 0U) {
 451         *colflagsp |= (opj_colflag_t)((T1_COLFLAG_SIG_ROW_0 << (T1_COLFLAG_RBS * row)) |
 452                                       (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row + 1U))));
 453         *(colflagsp - 1) |= (opj_colflag_t)((T1_COLFLAG_SIG_OTHER_ROW_0 <<
 454                                              (T1_COLFLAG_RBS * row)) |
 455                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row + 1U))));
 456         *(colflagsp + 1) |= (opj_colflag_t)((T1_COLFLAG_SIG_OTHER_ROW_0 <<
 457                                              (T1_COLFLAG_RBS * row)) |
 458                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row + 1U))));
 459         *(colflagsp - stride - 1) |= (T1_COLFLAG_SIG_OTHER_ROW_3);
 460         *(colflagsp - stride) |= (T1_COLFLAG_SIG_OTHER_ROW_3);
 461         *(colflagsp - stride + 1) |= (T1_COLFLAG_SIG_OTHER_ROW_3);
 462     } else if (row == 3U) {
 463         *colflagsp |= (opj_colflag_t)((T1_COLFLAG_SIG_ROW_0 << (T1_COLFLAG_RBS * row)) |
 464                                       (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row - 1U))));
 465         *(colflagsp - 1) |= (opj_colflag_t)((T1_COLFLAG_SIG_OTHER_ROW_0 <<
 466                                              (T1_COLFLAG_RBS * row)) |
 467                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row - 1U))));
 468         *(colflagsp + 1) |= (opj_colflag_t)((T1_COLFLAG_SIG_OTHER_ROW_0 <<
 469                                              (T1_COLFLAG_RBS * row)) |
 470                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row - 1))));
 471         *(colflagsp + stride - 1) |= (T1_COLFLAG_SIG_OTHER_ROW_0);
 472         *(colflagsp + stride) |= (T1_COLFLAG_SIG_OTHER_ROW_0);
 473         *(colflagsp + stride + 1) |= (T1_COLFLAG_SIG_OTHER_ROW_0);
 474     } else {
 475         *(colflagsp - 1) |= (opj_colflag_t)((T1_COLFLAG_SIG_OTHER_ROW_0 <<
 476                                              (T1_COLFLAG_RBS * row)) |
 477                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row - 1U))) |
 478                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row + 1U))));
 479         *colflagsp |= (opj_colflag_t)((T1_COLFLAG_SIG_ROW_0 << (T1_COLFLAG_RBS * row)) |
 480                                       (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row - 1U))) |
 481                                       (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row + 1U))));
 482         *(colflagsp + 1) |= (opj_colflag_t)((T1_COLFLAG_SIG_OTHER_ROW_0 <<
 483                                              (T1_COLFLAG_RBS * row)) |
 484                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row - 1U))) |
 485                                             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * (row + 1U))));
 486     }
 487 }
 488
 489 /**
 490 Encode significant pass
 491 */
 492 static INLINE void opj_t1_enc_sigpass_step(opj_t1_t *t1,
 493         opj_flag_enc_t *flagsp,
 494         OPJ_INT32 *datap,
 495         OPJ_UINT32 orient,
 496         OPJ_INT32 bpno,
 497         OPJ_INT32 one,
 498         OPJ_INT32 *nmsedec,
 499         OPJ_BYTE type,
 500         OPJ_UINT32 ci,
 501         OPJ_UINT32 vsc
 502                                           )
 503 {
 504     OPJ_INT32 v;
 505
 506     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 507
 508     OPJ_UINT32 vsc_mask = vsc ? ~((T1_SIGMA_SW | T1_SIGMA_S | T1_SIGMA_SE |
 509                                    T1_CHI_S) << (ci * 3U)) : ~0U;
 510     OPJ_UINT32 const flags = *flagsp & vsc_mask;
 511
 512     if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) == 0U &&
 513             (flags & (T1_SIGMA_NEIGHBOURS << (ci * 3U))) != 0U) {
 514         OPJ_UINT32 ctxt1 = opj_t1_enc_getctxno_zc(flags >> (ci * 3U),
 515                            orient);
 516         v = opj_int_abs(*datap) & one ? 1 : 0;
 517 #ifdef DEBUG_ENC_SIG
 518         fprintf(stderr, "   ctxt1=%d\n", ctxt1);
 519 #endif
 520         opj_mqc_setcurctx(mqc, ctxt1);  /* ESSAI */
 521         if (type == T1_TYPE_RAW) {  /* BYPASS/LAZY MODE */
 522             opj_mqc_bypass_enc(mqc, v);
 523         } else {
 524             opj_mqc_encode(mqc, v);
 525         }
 526         if (v) {
 527             OPJ_UINT32 ctxt2 = opj_t1_enc_getctxno_sc(*flagsp & vsc_mask,
 528                                flagsp[-1] & vsc_mask, flagsp[1] & vsc_mask,
 529                                ci);
 530             v = *datap < 0 ? 1 : 0;
 531             *nmsedec += opj_t1_getnmsedec_sig(opj_int_abs(*datap), bpno);
 532 #ifdef DEBUG_ENC_SIG
 533             fprintf(stderr, "   ctxt2=%d\n", ctxt2);
 534 #endif
 535             opj_mqc_setcurctx(mqc, ctxt2); /* ESSAI */
 536             if (type == T1_TYPE_RAW) {  /* BYPASS/LAZY MODE */
 537                 opj_mqc_bypass_enc(mqc, v);
 538             } else {
 539                 OPJ_UINT32 spb = opj_t1_enc_getspb(*flagsp & vsc_mask,
 540                                                    flagsp[-1] & vsc_mask, flagsp[1] & vsc_mask, ci);
 541 #ifdef DEBUG_ENC_SIG
 542                 fprintf(stderr, "   spb=%d\n", spb);
 543 #endif
 544                 opj_mqc_encode(mqc, v ^ spb);
 545             }
 546             opj_t1_enc_updateflags(flagsp, ci, v, t1->flags_stride);
 547         }
 548         *flagsp |= T1_PI_THIS << (ci * 3U);
 549     }
 550 }
 551
 552 static INLINE void opj_t1_dec_sigpass_step_raw(
 553     opj_t1_t *t1,
 554     opj_flag_t *flagsp,
 555     opj_colflag_t* colflagsp,
 556     OPJ_INT32 *datap,
 557     OPJ_INT32 oneplushalf,
 558     OPJ_INT32 vsc,
 559     OPJ_UINT32 row)
 560 {
 561     OPJ_UINT32 v, flag;
 562     opj_raw_t *raw = t1->raw;       /* RAW component */
 563
 564     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 565            (*flagsp);
 566     if ((flag & T1_SIG_OTH) &&
 567             !(*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
 568                             (T1_COLFLAG_RBS * row)))) {
 569         if (opj_raw_decode(raw)) {
 570             v = opj_raw_decode(raw);    /* ESSAI */
 571             *datap = v ? -oneplushalf : oneplushalf;
 572             opj_t1_updateflagscolflags(flagsp, colflagsp, v, t1->flags_stride, row);
 573         }
 574 #ifdef CONSISTENCY_CHECK
 575         *flagsp |= T1_VISIT;
 576 #endif
 577         *colflagsp = (opj_colflag_t)(*colflagsp | (T1_COLFLAG_VISIT_ROW_0 <<
 578                                      (T1_COLFLAG_RBS * row)));
 579     }
 580 }
 581
 582 static INLINE void opj_t1_dec_sigpass_step_mqc(
 583     opj_t1_t *t1,
 584     opj_flag_t *flagsp,
 585     opj_colflag_t* colflagsp,
 586     OPJ_INT32 *datap,
 587     OPJ_INT32 oneplushalf,
 588     OPJ_UINT32 row,
 589     OPJ_UINT32 flags_stride)
 590 {
 591     OPJ_INT32 v, flag;
 592
 593     opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 594 #ifdef CONSISTENCY_CHECK
 595     assert(((*flagsp & T1_SIG_OTH) && !(*flagsp & (T1_SIG | T1_VISIT))) ==
 596            ((*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0 |
 597                             T1_COLFLAG_SIG_OTHER_ROW_0) << (T1_COLFLAG_RBS * row))) ==
 598             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * row))));
 599 #endif
 600     if ((*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0 |
 601                         T1_COLFLAG_SIG_OTHER_ROW_0) << (T1_COLFLAG_RBS * row))) ==
 602             (T1_COLFLAG_SIG_OTHER_ROW_0 << (T1_COLFLAG_RBS * row))) {
 603         flag = *flagsp;
 604         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, (OPJ_UINT32)flag));
 605         if (opj_mqc_decode(mqc)) {
 606             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
 607             v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
 608             *datap = v ? -oneplushalf : oneplushalf;
 609             opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, flags_stride, row);
 610         }
 611 #ifdef CONSISTENCY_CHECK
 612         *flagsp |= T1_VISIT;
 613 #endif
 614         *colflagsp = (opj_colflag_t)(*colflagsp | (T1_COLFLAG_VISIT_ROW_0 <<
 615                                      (T1_COLFLAG_RBS * row)));
 616     }
 617 }                               /* VSC and  BYPASS by Antonin */
 618
 619 static INLINE void opj_t1_dec_sigpass_step_mqc_vsc(
 620     opj_t1_t *t1,
 621     opj_flag_t *flagsp,
 622     opj_colflag_t* colflagsp,
 623     OPJ_INT32 *datap,
 624     OPJ_INT32 oneplushalf,
 625     OPJ_INT32 vsc,
 626     OPJ_UINT32 row)
 627 {
 628     OPJ_UINT32 v, flag;
 629
 630     opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 631
 632     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 633            (*flagsp);
 634     if ((flag & T1_SIG_OTH) &&
 635             !(*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
 636                             (T1_COLFLAG_RBS * row)))) {
 637         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, flag));
 638         if (opj_mqc_decode(mqc)) {
 639             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
 640             v = (OPJ_UINT32)opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
 641             *datap = v ? -oneplushalf : oneplushalf;
 642             opj_t1_updateflagscolflags(flagsp, colflagsp, v, t1->flags_stride, row);
 643         }
 644 #ifdef CONSISTENCY_CHECK
 645         *flagsp |= T1_VISIT;
 646 #endif
 647         *colflagsp = (opj_colflag_t)(*colflagsp | (T1_COLFLAG_VISIT_ROW_0 <<
 648                                      (T1_COLFLAG_RBS * row)));
 649     }
 650 }                               /* VSC and  BYPASS by Antonin */
 651
 652
 653 static void opj_t1_enc_sigpass(opj_t1_t *t1,
 654                                OPJ_INT32 bpno,
 655                                OPJ_UINT32 orient,
 656                                OPJ_INT32 *nmsedec,
 657                                OPJ_BYTE type,
 658                                OPJ_UINT32 cblksty
 659                               )
 660 {
 661     OPJ_UINT32 i, k;
 662     OPJ_INT32 const one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 663     opj_flag_enc_t* f = &ENC_FLAGS(0, 0);
 664     OPJ_UINT32 const extra = t1->flags_stride - t1->w;
 665
 666     *nmsedec = 0;
 667 #ifdef DEBUG_ENC_SIG
 668     fprintf(stderr, "enc_sigpass: bpno=%d\n", bpno);
 669 #endif
 670     for (k = 0; k < (t1->h & ~3U); k += 4) {
 671 #ifdef DEBUG_ENC_SIG
 672         fprintf(stderr, " k=%d\n", k);
 673 #endif
 674         for (i = 0; i < t1->w; ++i) {
 675 #ifdef DEBUG_ENC_SIG
 676             fprintf(stderr, " i=%d\n", i);
 677 #endif
 678             if (*f == 0U) {
 679                 /* Nothing to do for any of the 4 data points */
 680                 f++;
 681                 continue;
 682             }
 683             opj_t1_enc_sigpass_step(
 684                 t1,
 685                 f,
 686                 &t1->data[((k + 0) * t1->data_stride) + i],
 687                 orient,
 688                 bpno,
 689                 one,
 690                 nmsedec,
 691                 type,
 692                 0, 0);
 693             opj_t1_enc_sigpass_step(
 694                 t1,
 695                 f,
 696                 &t1->data[((k + 1) * t1->data_stride) + i],
 697                 orient,
 698                 bpno,
 699                 one,
 700                 nmsedec,
 701                 type,
 702                 1, 0);
 703             opj_t1_enc_sigpass_step(
 704                 t1,
 705                 f,
 706                 &t1->data[((k + 2) * t1->data_stride) + i],
 707                 orient,
 708                 bpno,
 709                 one,
 710                 nmsedec,
 711                 type,
 712                 2, 0);
 713             opj_t1_enc_sigpass_step(
 714                 t1,
 715                 f,
 716                 &t1->data[((k + 3) * t1->data_stride) + i],
 717                 orient,
 718                 bpno,
 719                 one,
 720                 nmsedec,
 721                 type,
 722                 3, cblksty & J2K_CCP_CBLKSTY_VSC);
 723             ++f;
 724         }
 725         f += extra;
 726     }
 727
 728     if (k < t1->h) {
 729         OPJ_UINT32 j;
 730 #ifdef DEBUG_ENC_SIG
 731         fprintf(stderr, " k=%d\n", k);
 732 #endif
 733         for (i = 0; i < t1->w; ++i) {
 734 #ifdef DEBUG_ENC_SIG
 735             fprintf(stderr, " i=%d\n", i);
 736 #endif
 737             if (*f == 0U) {
 738                 /* Nothing to do for any of the 4 data points */
 739                 f++;
 740                 continue;
 741             }
 742             for (j = k; j < t1->h; ++j) {
 743                 opj_t1_enc_sigpass_step(
 744                     t1,
 745                     f,
 746                     &t1->data[(j * t1->data_stride) + i],
 747                     orient,
 748                     bpno,
 749                     one,
 750                     nmsedec,
 751                     type,
 752                     j - k,
 753                     (j == t1->h - 1 && (cblksty & J2K_CCP_CBLKSTY_VSC) != 0));
 754             }
 755             ++f;
 756         }
 757     }
 758 }
 759
 760 static void opj_t1_dec_sigpass_raw(
 761     opj_t1_t *t1,
 762     OPJ_INT32 bpno,
 763     OPJ_INT32 cblksty)
 764 {
 765     OPJ_INT32 one, half, oneplushalf, vsc;
 766     OPJ_UINT32 i, j, k;
 767     opj_colflag_t *colflags1 = &t1->colflags[t1->flags_stride + 1];
 768     one = 1 << bpno;
 769     half = one >> 1;
 770     oneplushalf = one | half;
 771     for (k = 0; k < t1->h; k += 4) {
 772         for (i = 0; i < t1->w; ++i) {
 773             opj_colflag_t *colflags2 = colflags1 + i;
 774             for (j = k; j < k + 4 && j < t1->h; ++j) {
 775                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 ||
 776                         j == t1->h - 1)) ? 1 : 0;
 777                 opj_t1_dec_sigpass_step_raw(
 778                     t1,
 779                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 780                     colflags2,
 781                     &t1->data[(j * t1->w) + i],
 782                     oneplushalf,
 783                     vsc,
 784                     j - k);
 785             }
 786         }
 787         colflags1 += t1->flags_stride;
 788     }
 789 }                               /* VSC and  BYPASS by Antonin */
 790
 791 #define opj_t1_dec_sigpass_mqc_internal(t1, bpno, w, h, flags_stride) \
 792 { \
 793         OPJ_INT32 one, half, oneplushalf; \
 794         OPJ_UINT32 i, j, k; \
 795         OPJ_INT32 *data1 = t1->data; \
 796         opj_flag_t *flags1 = &t1->flags[1]; \
 797         opj_colflag_t *colflags1 = &t1->colflags[flags_stride + 1]; \
 798         one = 1 << bpno; \
 799         half = one >> 1; \
 800         oneplushalf = one | half; \
 801         for (k = 0; k < (h & ~3u); k += 4) { \
 802                 for (i = 0; i < w; ++i) { \
 803                         OPJ_INT32 *data2 = data1 + i; \
 804                         opj_flag_t *flags2 = flags1 + i; \
 805                         opj_colflag_t *colflags2 = colflags1 + i; \
 806                         if( *colflags2 == 0 ) continue; \
 807                         flags2 += flags_stride; \
 808                         opj_t1_dec_sigpass_step_mqc(t1, flags2, colflags2, data2, oneplushalf, 0U, flags_stride); \
 809                         data2 += w; \
 810                         flags2 += flags_stride; \
 811                         opj_t1_dec_sigpass_step_mqc(t1, flags2, colflags2, data2, oneplushalf, 1U, flags_stride); \
 812                         data2 += w; \
 813                         flags2 += flags_stride; \
 814                         opj_t1_dec_sigpass_step_mqc(t1, flags2, colflags2, data2, oneplushalf, 2U, flags_stride); \
 815                         data2 += w; \
 816                         flags2 += flags_stride; \
 817                         opj_t1_dec_sigpass_step_mqc(t1, flags2, colflags2, data2, oneplushalf, 3U, flags_stride); \
 818                         data2 += w; \
 819                 } \
 820                 data1 += w << 2; \
 821                 flags1 += flags_stride << 2; \
 822                 colflags1 += flags_stride; \
 823         } \
 824         for (i = 0; i < w; ++i) { \
 825                 OPJ_INT32 *data2 = data1 + i; \
 826                 opj_flag_t *flags2 = flags1 + i; \
 827                 opj_colflag_t *colflags2 = colflags1 + i; \
 828                 for (j = k; j < h; ++j) { \
 829                         flags2 += flags_stride; \
 830                         opj_t1_dec_sigpass_step_mqc(t1, flags2, colflags2, data2, oneplushalf, j - k, flags_stride); \
 831                         data2 += w; \
 832                 } \
 833         } \
 834 }
 835
 836 static void opj_t1_dec_sigpass_mqc_64x64(
 837     opj_t1_t *t1,
 838     OPJ_INT32 bpno)
 839 {
 840     opj_t1_dec_sigpass_mqc_internal(t1, bpno, 64, 64, 66);
 841 }
 842
 843 static void opj_t1_dec_sigpass_mqc_generic(
 844     opj_t1_t *t1,
 845     OPJ_INT32 bpno)
 846 {
 847     opj_t1_dec_sigpass_mqc_internal(t1, bpno, t1->w, t1->h, t1->flags_stride);
 848 }
 849
 850 /* VSC and  BYPASS by Antonin */
 851 static void opj_t1_dec_sigpass_mqc_vsc(
 852     opj_t1_t *t1,
 853     OPJ_INT32 bpno)
 854 {
 855     OPJ_INT32 one, half, oneplushalf, vsc;
 856     OPJ_UINT32 i, j, k;
 857     OPJ_INT32 *data1 = t1->data;
 858     opj_flag_t *flags1 = &t1->flags[1];
 859     opj_colflag_t *colflags1 = &t1->colflags[t1->flags_stride + 1];
 860     one = 1 << bpno;
 861     half = one >> 1;
 862     oneplushalf = one | half;
 863     for (k = 0; k < (t1->h & ~(OPJ_UINT32)3); k += 4U) {
 864         for (i = 0; i < t1->w; ++i) {
 865             OPJ_INT32 *data2 = data1 + i;
 866             opj_flag_t *flags2 = flags1 + i;
 867             opj_colflag_t *colflags2 = colflags1 + i;
 868             flags2 += t1->flags_stride;
 869             opj_t1_dec_sigpass_step_mqc_vsc(t1, flags2, colflags2, data2, oneplushalf, 0,
 870                                             0U);
 871             data2 += t1->w;
 872             flags2 += t1->flags_stride;
 873             opj_t1_dec_sigpass_step_mqc_vsc(t1, flags2, colflags2, data2, oneplushalf, 0,
 874                                             1U);
 875             data2 += t1->w;
 876             flags2 += t1->flags_stride;
 877             opj_t1_dec_sigpass_step_mqc_vsc(t1, flags2, colflags2, data2, oneplushalf, 0,
 878                                             2U);
 879             data2 += t1->w;
 880             flags2 += t1->flags_stride;
 881             opj_t1_dec_sigpass_step_mqc_vsc(t1, flags2, colflags2, data2, oneplushalf, 1,
 882                                             3U);
 883             data2 += t1->w;
 884         }
 885         data1 += t1->w << 2;
 886         flags1 += t1->flags_stride << 2;
 887         colflags1 += t1->flags_stride;
 888     }
 889     for (i = 0; i < t1->w; ++i) {
 890         opj_colflag_t *colflags2 = colflags1 + i;
 891         for (j = k; j < t1->h; ++j) {
 892             vsc = (j == t1->h - 1) ? 1 : 0;
 893             opj_t1_dec_sigpass_step_mqc_vsc(
 894                 t1,
 895                 &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 896                 colflags2,
 897                 &t1->data[(j * t1->w) + i],
 898                 oneplushalf,
 899                 vsc,
 900                 j - k);
 901         }
 902     }
 903 }                               /* VSC and  BYPASS by Antonin */
 904
 905
 906 /**
 907 Encode refinement pass step
 908 */
 909 static INLINE void opj_t1_enc_refpass_step(opj_t1_t *t1,
 910         opj_flag_enc_t *flagsp,
 911         OPJ_INT32 *datap,
 912         OPJ_INT32 bpno,
 913         OPJ_INT32 one,
 914         OPJ_INT32 *nmsedec,
 915         OPJ_BYTE type,
 916         OPJ_UINT32 ci,
 917         OPJ_UINT32 vsc
 918                                           )
 919 {
 920     OPJ_INT32 v;
 921
 922     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 923
 924     OPJ_UINT32 const shift_flags =
 925         vsc ?
 926         ((*flagsp >> (ci * 3U)) & ~(T1_SIGMA_SW | T1_SIGMA_S | T1_SIGMA_SE | T1_CHI_S))
 927         :
 928         (*flagsp >> (ci * 3U));
 929
 930     if ((shift_flags & (T1_SIGMA_THIS | T1_PI_THIS)) == T1_SIGMA_THIS) {
 931         OPJ_UINT32 ctxt = opj_t1_enc_getctxno_mag(shift_flags);
 932         *nmsedec += opj_t1_getnmsedec_ref(opj_int_abs(*datap), bpno);
 933         v = opj_int_abs(*datap) & one ? 1 : 0;
 934 #ifdef DEBUG_ENC_REF
 935         fprintf(stderr, "  ctxt=%d\n", ctxt);
 936 #endif
 937         opj_mqc_setcurctx(mqc, ctxt);   /* ESSAI */
 938         if (type == T1_TYPE_RAW) {  /* BYPASS/LAZY MODE */
 939             opj_mqc_bypass_enc(mqc, v);
 940         } else {
 941             opj_mqc_encode(mqc, v);
 942         }
 943         *flagsp |= T1_MU_THIS << (ci * 3U);
 944     }
 945 }
 946
 947
 948 static INLINE void opj_t1_dec_refpass_step_raw(
 949     opj_t1_t *t1,
 950     opj_colflag_t *colflagsp,
 951     OPJ_INT32 *datap,
 952     OPJ_INT32 poshalf,
 953     OPJ_INT32 neghalf,
 954     OPJ_UINT32 row)
 955 {
 956     OPJ_INT32 v, t;
 957
 958     opj_raw_t *raw = t1->raw;       /* RAW component */
 959
 960     if ((*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
 961                        (T1_COLFLAG_RBS * row))) ==
 962             ((T1_COLFLAG_SIG_ROW_0) << (T1_COLFLAG_RBS * row))) {
 963         v = (OPJ_INT32)opj_raw_decode(raw);
 964         t = v ? poshalf : neghalf;
 965         *datap += *datap < 0 ? -t : t;
 966         *colflagsp = (opj_colflag_t)(*colflagsp | (T1_COLFLAG_REFINE_ROW_0 <<
 967                                      (T1_COLFLAG_RBS * row)));
 968     }
 969 }                               /* VSC and  BYPASS by Antonin  */
 970
 971 static INLINE void opj_t1_dec_refpass_step_mqc(
 972     opj_t1_t *t1,
 973 #ifdef CONSISTENCY_CHECK
 974     opj_flag_t *flagsp,
 975 #else
 976     opj_flag_t *flagsp_unused,
 977 #endif
 978     opj_colflag_t *colflagsp,
 979     OPJ_INT32 *datap,
 980     OPJ_INT32 poshalf,
 981     OPJ_INT32 neghalf,
 982     OPJ_UINT32 row)
 983 {
 984     OPJ_INT32 v, t;
 985
 986     opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 987 #ifdef CONSISTENCY_CHECK
 988     assert(((*flagsp & (T1_SIG | T1_VISIT)) == T1_SIG) ==
 989            ((*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
 990                            (T1_COLFLAG_RBS * row))) == ((T1_COLFLAG_SIG_ROW_0) << (T1_COLFLAG_RBS *
 991                                    row))));
 992 #else
 993     (void)flagsp_unused;
 994 #endif
 995     if ((*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
 996                        (T1_COLFLAG_RBS * row))) ==
 997             ((T1_COLFLAG_SIG_ROW_0) << (T1_COLFLAG_RBS * row))) {
 998         OPJ_UINT32 tmp1 = (*colflagsp & (T1_COLFLAG_SIG_OTHER_ROW_0 <<
 999                                          (T1_COLFLAG_RBS * row))) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
1000         OPJ_UINT32 tmp2 = (*colflagsp & (T1_COLFLAG_REFINE_ROW_0 <<
1001                                          (T1_COLFLAG_RBS * row))) ? T1_CTXNO_MAG + 2 : tmp1;
1002         opj_mqc_setcurctx(mqc, tmp2);      /* ESSAI */
1003         v = opj_mqc_decode(mqc);
1004         t = v ? poshalf : neghalf;
1005         *datap += *datap < 0 ? -t : t;
1006         *colflagsp = (opj_colflag_t)(*colflagsp | (T1_COLFLAG_REFINE_ROW_0 <<
1007                                      (T1_COLFLAG_RBS * row)));
1008     }
1009 }                               /* VSC and  BYPASS by Antonin  */
1010
1011 static INLINE void opj_t1_dec_refpass_step_mqc_vsc(
1012     opj_t1_t *t1,
1013     opj_flag_t *flagsp,
1014     opj_colflag_t *colflagsp,
1015     OPJ_INT32 *datap,
1016     OPJ_INT32 poshalf,
1017     OPJ_INT32 neghalf,
1018     OPJ_INT32 vsc,
1019     OPJ_UINT32 row)
1020 {
1021     OPJ_UINT32 v;
1022     OPJ_INT32 t;
1023
1024     opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1025
1026     if ((*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
1027                        (T1_COLFLAG_RBS * row))) ==
1028             ((T1_COLFLAG_SIG_ROW_0) << (T1_COLFLAG_RBS * row))) {
1029         OPJ_UINT32 flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW |
1030                                                 T1_SGN_S))) : (*flagsp);
1031         OPJ_UINT32 tmp1 = (flag & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
1032         OPJ_UINT32 tmp2 = (*colflagsp & (T1_COLFLAG_REFINE_ROW_0 <<
1033                                          (T1_COLFLAG_RBS * row))) ? T1_CTXNO_MAG + 2U : tmp1;
1034         opj_mqc_setcurctx(mqc, tmp2);      /* ESSAI */
1035         v = (OPJ_UINT32)opj_mqc_decode(mqc);
1036         t = v ? poshalf : neghalf;
1037         *datap += *datap < 0 ? -t : t;
1038         *colflagsp = (opj_colflag_t)(*colflagsp | (T1_COLFLAG_REFINE_ROW_0 <<
1039                                      (T1_COLFLAG_RBS * row)));
1040     }
1041 }                               /* VSC and  BYPASS by Antonin  */
1042
1043 static void opj_t1_enc_refpass(
1044     opj_t1_t *t1,
1045     OPJ_INT32 bpno,
1046     OPJ_INT32 *nmsedec,
1047     OPJ_BYTE type,
1048     OPJ_UINT32 cblksty)
1049 {
1050     OPJ_UINT32 i, k;
1051     const OPJ_INT32 one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
1052     opj_flag_enc_t* f = &ENC_FLAGS(0, 0);
1053     const OPJ_UINT32 extra = t1->flags_stride - t1->w;
1054
1055     *nmsedec = 0;
1056 #ifdef DEBUG_ENC_REF
1057     fprintf(stderr, "enc_refpass: bpno=%d\n", bpno);
1058 #endif
1059     for (k = 0; k < (t1->h & ~3U); k += 4) {
1060 #ifdef DEBUG_ENC_REF
1061         fprintf(stderr, " k=%d\n", k);
1062 #endif
1063         for (i = 0; i < t1->w; ++i) {
1064 #ifdef DEBUG_ENC_REF
1065             fprintf(stderr, " i=%d\n", i);
1066 #endif
1067             if ((*f & (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13)) == 0) {
1068                 /* none significant */
1069                 f++;
1070                 continue;
1071             }
1072             if ((*f & (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3)) ==
1073                     (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3)) {
1074                 /* all processed by sigpass */
1075                 f++;
1076                 continue;
1077             }
1078
1079             opj_t1_enc_refpass_step(
1080                 t1,
1081                 f,
1082                 &t1->data[((k + 0) * t1->data_stride) + i],
1083                 bpno,
1084                 one,
1085                 nmsedec,
1086                 type,
1087                 0, 0);
1088             opj_t1_enc_refpass_step(
1089                 t1,
1090                 f,
1091                 &t1->data[((k + 1) * t1->data_stride) + i],
1092                 bpno,
1093                 one,
1094                 nmsedec,
1095                 type,
1096                 1, 0);
1097             opj_t1_enc_refpass_step(
1098                 t1,
1099                 f,
1100                 &t1->data[((k + 2) * t1->data_stride) + i],
1101                 bpno,
1102                 one,
1103                 nmsedec,
1104                 type,
1105                 2, 0);
1106             opj_t1_enc_refpass_step(
1107                 t1,
1108                 f,
1109                 &t1->data[((k + 3) * t1->data_stride) + i],
1110                 bpno,
1111                 one,
1112                 nmsedec,
1113                 type,
1114                 3, cblksty & J2K_CCP_CBLKSTY_VSC);
1115             ++f;
1116         }
1117         f += extra;
1118     }
1119
1120     if (k < t1->h) {
1121         OPJ_UINT32 j;
1122 #ifdef DEBUG_ENC_REF
1123         fprintf(stderr, " k=%d\n", k);
1124 #endif
1125         for (i = 0; i < t1->w; ++i) {
1126 #ifdef DEBUG_ENC_REF
1127             fprintf(stderr, " i=%d\n", i);
1128 #endif
1129             if ((*f & (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13)) == 0) {
1130                 /* none significant */
1131                 f++;
1132                 continue;
1133             }
1134             for (j = k; j < t1->h; ++j) {
1135                 opj_t1_enc_refpass_step(
1136                     t1,
1137                     f,
1138                     &t1->data[(j * t1->data_stride) + i],
1139                     bpno,
1140                     one,
1141                     nmsedec,
1142                     type,
1143                     j - k,
1144                     (j == t1->h - 1 && (cblksty & J2K_CCP_CBLKSTY_VSC) != 0));
1145             }
1146             ++f;
1147         }
1148     }
1149 }
1150
1151
1152 static void opj_t1_dec_refpass_raw(
1153     opj_t1_t *t1,
1154     OPJ_INT32 bpno)
1155 {
1156     OPJ_INT32 one, poshalf, neghalf;
1157     OPJ_UINT32 i, j, k;
1158     opj_colflag_t *colflags1 = &t1->colflags[t1->flags_stride + 1];
1159     one = 1 << bpno;
1160     poshalf = one >> 1;
1161     neghalf = bpno > 0 ? -poshalf : -1;
1162     for (k = 0; k < t1->h; k += 4) {
1163         for (i = 0; i < t1->w; ++i) {
1164             opj_colflag_t *colflags2 = colflags1 + i;
1165             for (j = k; j < k + 4 && j < t1->h; ++j) {
1166                 opj_t1_dec_refpass_step_raw(
1167                     t1,
1168                     colflags2,
1169                     &t1->data[(j * t1->w) + i],
1170                     poshalf,
1171                     neghalf, j - k);
1172             }
1173         }
1174         colflags1 += t1->flags_stride;
1175     }
1176 }                               /* VSC and  BYPASS by Antonin */
1177
1178 #define opj_t1_dec_refpass_mqc_internal(t1, bpno, w, h, flags_stride) \
1179 { \
1180         OPJ_INT32 one, poshalf, neghalf; \
1181         OPJ_UINT32 i, j, k; \
1182         OPJ_INT32 *data1 = t1->data; \
1183         opj_flag_t *flags1 = &t1->flags[1]; \
1184         opj_colflag_t *colflags1 = &t1->colflags[flags_stride + 1]; \
1185         one = 1 << bpno; \
1186         poshalf = one >> 1; \
1187         neghalf = bpno > 0 ? -poshalf : -1; \
1188         for (k = 0; k < (h & ~3u); k += 4) { \
1189                 for (i = 0; i < w; ++i) { \
1190                         OPJ_INT32 *data2 = data1 + i; \
1191                         opj_flag_t *flags2 = flags1 + i; \
1192                         opj_colflag_t *colflags2 = colflags1 + i; \
1193                         if( *colflags2 == 0 ) continue; \
1194                         flags2 += flags_stride; \
1195                         opj_t1_dec_refpass_step_mqc(t1, flags2, colflags2, data2, poshalf, neghalf, 0U); \
1196                         data2 += w; \
1197                         flags2 += flags_stride; \
1198                         opj_t1_dec_refpass_step_mqc(t1, flags2, colflags2, data2, poshalf, neghalf, 1U); \
1199                         data2 += w; \
1200                         flags2 += flags_stride; \
1201                         opj_t1_dec_refpass_step_mqc(t1, flags2, colflags2, data2, poshalf, neghalf, 2U); \
1202                         data2 += w; \
1203                         flags2 += flags_stride; \
1204                         opj_t1_dec_refpass_step_mqc(t1, flags2, colflags2, data2, poshalf, neghalf, 3U); \
1205                         data2 += w; \
1206                 } \
1207                 data1 += w << 2; \
1208                 flags1 += flags_stride << 2; \
1209                 colflags1 += flags_stride; \
1210         } \
1211         for (i = 0; i < w; ++i) { \
1212                 OPJ_INT32 *data2 = data1 + i; \
1213                 opj_flag_t *flags2 = flags1 + i; \
1214                 opj_colflag_t *colflags2 = colflags1 + i; \
1215                 for (j = k; j < h; ++j) { \
1216                         flags2 += flags_stride; \
1217                         opj_t1_dec_refpass_step_mqc(t1, flags2, colflags2, data2, poshalf, neghalf, j - k); \
1218                         data2 += w; \
1219                 } \
1220         } \
1221 }
1222
1223 static void opj_t1_dec_refpass_mqc_64x64(
1224     opj_t1_t *t1,
1225     OPJ_INT32 bpno)
1226 {
1227     opj_t1_dec_refpass_mqc_internal(t1, bpno, 64, 64, 66);
1228 }
1229
1230 static void opj_t1_dec_refpass_mqc_generic(
1231     opj_t1_t *t1,
1232     OPJ_INT32 bpno)
1233 {
1234     opj_t1_dec_refpass_mqc_internal(t1, bpno, t1->w, t1->h, t1->flags_stride);
1235 }
1236
1237 /* VSC and  BYPASS by Antonin */
1238 static void opj_t1_dec_refpass_mqc_vsc(
1239     opj_t1_t *t1,
1240     OPJ_INT32 bpno)
1241 {
1242     OPJ_INT32 one, poshalf, neghalf;
1243     OPJ_UINT32 i, j, k;
1244     OPJ_INT32 vsc;
1245     OPJ_INT32 *data1 = t1->data;
1246     opj_flag_t *flags1 = &t1->flags[1];
1247     opj_colflag_t *colflags1 = &t1->colflags[t1->flags_stride + 1];
1248     one = 1 << bpno;
1249     poshalf = one >> 1;
1250     neghalf = bpno > 0 ? -poshalf : -1;
1251     for (k = 0; k < (t1->h & ~(OPJ_UINT32)3U); k += 4U) {
1252         for (i = 0; i < t1->w; ++i) {
1253             OPJ_INT32 *data2 = data1 + i;
1254             opj_flag_t *flags2 = flags1 + i;
1255             opj_colflag_t *colflags2 = colflags1 + i;
1256             flags2 += t1->flags_stride;
1257             opj_t1_dec_refpass_step_mqc_vsc(t1, flags2, colflags2, data2, poshalf, neghalf,
1258                                             0, 0U);
1259             data2 += t1->w;
1260             flags2 += t1->flags_stride;
1261             opj_t1_dec_refpass_step_mqc_vsc(t1, flags2, colflags2, data2, poshalf, neghalf,
1262                                             0, 1U);
1263             data2 += t1->w;
1264             flags2 += t1->flags_stride;
1265             opj_t1_dec_refpass_step_mqc_vsc(t1, flags2, colflags2, data2, poshalf, neghalf,
1266                                             0, 2U);
1267             data2 += t1->w;
1268             flags2 += t1->flags_stride;
1269             opj_t1_dec_refpass_step_mqc_vsc(t1, flags2, colflags2, data2, poshalf, neghalf,
1270                                             1, 3U);
1271             data2 += t1->w;
1272         }
1273         data1 += t1->w << 2;
1274         flags1 += t1->flags_stride << 2;
1275         colflags1 += t1->flags_stride;
1276     }
1277     for (i = 0; i < t1->w; ++i) {
1278         opj_colflag_t *colflags2 = colflags1 + i;
1279         for (j = k; j < t1->h; ++j) {
1280             vsc = (j == t1->h - 1) ? 1 : 0;
1281             opj_t1_dec_refpass_step_mqc_vsc(
1282                 t1,
1283                 &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
1284                 colflags2,
1285                 &t1->data[(j * t1->w) + i],
1286                 poshalf, neghalf,
1287                 vsc,
1288                 j - k);
1289         }
1290     }
1291 }                               /* VSC and  BYPASS by Antonin */
1292
1293 /**
1294 Encode clean-up pass step
1295 */
1296 static void opj_t1_enc_clnpass_step(
1297     opj_t1_t *t1,
1298     opj_flag_enc_t *flagsp,
1299     OPJ_INT32 *datap,
1300     OPJ_UINT32 orient,
1301     OPJ_INT32 bpno,
1302     OPJ_INT32 one,
1303     OPJ_INT32 *nmsedec,
1304     OPJ_UINT32 agg,
1305     OPJ_UINT32 runlen,
1306     OPJ_UINT32 lim,
1307     OPJ_UINT32 cblksty)
1308 {
1309     OPJ_INT32 v;
1310     OPJ_UINT32 ci;
1311     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1312
1313     const OPJ_UINT32 check = (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13 |
1314                               T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1315
1316     if ((*flagsp & check) == check) {
1317         if (runlen == 0) {
1318             *flagsp &= ~(T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1319         } else if (runlen == 1) {
1320             *flagsp &= ~(T1_PI_1 | T1_PI_2 | T1_PI_3);
1321         } else if (runlen == 2) {
1322             *flagsp &= ~(T1_PI_2 | T1_PI_3);
1323         } else if (runlen == 3) {
1324             *flagsp &= ~(T1_PI_3);
1325         }
1326         return;
1327     }
1328
1329     for (ci = runlen; ci < lim; ++ci) {
1330         OPJ_UINT32 vsc;
1331         OPJ_UINT32 vsc_mask;
1332         opj_flag_enc_t flags;
1333
1334         vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (ci == lim - 1)) ? 1 : 0;
1335         vsc_mask = vsc ? ~((T1_SIGMA_SW | T1_SIGMA_S | T1_SIGMA_SE | T1_CHI_S) <<
1336                            (ci * 3U)) : ~0U;
1337
1338         if ((agg != 0) && (ci == runlen)) {
1339             goto LABEL_PARTIAL;
1340         }
1341
1342         flags = *flagsp & vsc_mask;
1343
1344         if (!(flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U)))) {
1345             OPJ_UINT32 ctxt1 = opj_t1_enc_getctxno_zc(flags >> (ci * 3U), orient);
1346 #ifdef DEBUG_ENC_CLN
1347             printf("   ctxt1=%d\n", ctxt1);
1348 #endif
1349             opj_mqc_setcurctx(mqc, ctxt1);
1350             v = opj_int_abs(*datap) & one ? 1 : 0;
1351             opj_mqc_encode(mqc, v);
1352             if (v) {
1353                 OPJ_UINT32 ctxt2, spb;
1354 LABEL_PARTIAL:
1355                 *nmsedec += opj_t1_getnmsedec_sig(opj_int_abs(*datap), bpno);
1356                 ctxt2 = opj_t1_enc_getctxno_sc(*flagsp & vsc_mask,
1357                                                flagsp[-1] & vsc_mask, flagsp[1] & vsc_mask,
1358                                                ci);
1359 #ifdef DEBUG_ENC_CLN
1360                 printf("   ctxt2=%d\n", ctxt2);
1361 #endif
1362                 opj_mqc_setcurctx(mqc, ctxt2);
1363
1364                 v = *datap < 0 ? 1 : 0;
1365                 spb = opj_t1_enc_getspb(*flagsp & vsc_mask,
1366                                         flagsp[-1] & vsc_mask, flagsp[1] & vsc_mask, ci);
1367 #ifdef DEBUG_ENC_CLN
1368                 printf("   spb=%d\n", spb);
1369 #endif
1370                 opj_mqc_encode(mqc, v ^ spb);
1371                 opj_t1_enc_updateflags(flagsp, ci, v, t1->flags_stride);
1372             }
1373         }
1374         *flagsp &= ~(T1_PI_THIS << (3U * ci));
1375         datap += t1->data_stride;
1376     }
1377 }
1378
1379
1380 static void opj_t1_dec_clnpass_step_partial(
1381     opj_t1_t *t1,
1382     opj_flag_t *flagsp,
1383     opj_colflag_t *colflagsp,
1384     OPJ_INT32 *datap,
1385     OPJ_INT32 oneplushalf,
1386     OPJ_UINT32 row)
1387 {
1388     OPJ_INT32 v, flag;
1389     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1390
1391     flag = *flagsp;
1392     opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
1393     v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
1394     *datap = v ? -oneplushalf : oneplushalf;
1395     opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, t1->flags_stride,
1396                                row);
1397 #ifdef CONSISTENCY_CHECK
1398     *flagsp &= ~T1_VISIT;
1399 #endif
1400 }               /* VSC and  BYPASS by Antonin */
1401
1402 static void opj_t1_dec_clnpass_step(
1403     opj_t1_t *t1,
1404     opj_flag_t *flagsp,
1405     opj_colflag_t *colflagsp,
1406     OPJ_INT32 *datap,
1407     OPJ_INT32 oneplushalf,
1408     OPJ_UINT32 row)
1409 {
1410     OPJ_INT32 v, flag;
1411
1412     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1413 #ifdef CONSISTENCY_CHECK
1414     assert((!(*flagsp & (T1_SIG | T1_VISIT))) == (!(*colflagsp & ((
1415                 T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) << (4 * row)))));
1416 #endif
1417     if (!(*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
1418                         (4 * row)))) {
1419         flag = *flagsp;
1420         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, (OPJ_UINT32)flag));
1421         if (opj_mqc_decode(mqc)) {
1422             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
1423             v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
1424             *datap = v ? -oneplushalf : oneplushalf;
1425             opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, t1->flags_stride,
1426                                        row);
1427         }
1428     }
1429 #ifdef CONSISTENCY_CHECK
1430     *flagsp &= ~T1_VISIT;
1431 #endif
1432 }               /* VSC and  BYPASS by Antonin */
1433
1434 static void opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(
1435     opj_t1_t *t1,
1436     opj_flag_t *flagsp,
1437     opj_colflag_t *colflagsp,
1438     OPJ_INT32 *datap,
1439     OPJ_INT32 oneplushalf,
1440     OPJ_UINT32 row,
1441     OPJ_UINT32 flags_stride)
1442 {
1443     OPJ_INT32 v;
1444     OPJ_INT32 flag;
1445
1446     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1447
1448     flag = *flagsp;
1449     /*if (!(flag & (T1_SIG | T1_VISIT)))*/
1450     {
1451         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, (OPJ_UINT32)flag));
1452         if (opj_mqc_decode(mqc)) {
1453             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
1454             v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
1455             *datap = v ? -oneplushalf : oneplushalf;
1456             opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, flags_stride, row);
1457         }
1458     }
1459     /*flagsp &= ~T1_VISIT;*/
1460 }
1461
1462 static void opj_t1_dec_clnpass_step_vsc(
1463     opj_t1_t *t1,
1464     opj_flag_t *flagsp,
1465     opj_colflag_t *colflagsp,
1466     OPJ_INT32 *datap,
1467     OPJ_INT32 oneplushalf,
1468     OPJ_INT32 partial,
1469     OPJ_INT32 vsc,
1470     OPJ_UINT32 row)
1471 {
1472     OPJ_UINT32 v, flag;
1473
1474     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1475
1476     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
1477            (*flagsp);
1478     if (partial) {
1479         goto LABEL_PARTIAL;
1480     }
1481     if (!(*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
1482                         (T1_COLFLAG_RBS * row)))) {
1483         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, flag));
1484         if (opj_mqc_decode(mqc)) {
1485 LABEL_PARTIAL:
1486             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
1487             v = (OPJ_UINT32)opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
1488             *datap = v ? -oneplushalf : oneplushalf;
1489             opj_t1_updateflagscolflags(flagsp, colflagsp, v, t1->flags_stride, row);
1490         }
1491     }
1492 #ifdef CONSISTENCY_CHECK
1493     *flagsp &= ~T1_VISIT;
1494 #endif
1495 }
1496
1497 #define MACRO_t1_enc_flags(x,y) t1->enc_flags[((x)*(t1->flags_stride))+(y)]
1498
1499 static void opj_t1_enc_clnpass(
1500     opj_t1_t *t1,
1501     OPJ_INT32 bpno,
1502     OPJ_UINT32 orient,
1503     OPJ_INT32 *nmsedec,
1504     OPJ_UINT32 cblksty)
1505 {
1506     OPJ_UINT32 i, k;
1507     const OPJ_INT32 one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
1508     OPJ_UINT32 agg, runlen;
1509
1510     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1511
1512     const OPJ_UINT32 agg_mask = (cblksty & J2K_CCP_CBLKSTY_VSC) ?
1513                                 ~(T1_SIGMA_15 | T1_SIGMA_16 | T1_SIGMA_17 | T1_CHI_5) :
1514                                 ~0U;
1515
1516     *nmsedec = 0;
1517 #ifdef DEBUG_ENC_CLN
1518     printf("enc_clnpass: bpno=%d\n", bpno);
1519 #endif
1520     for (k = 0; k < (t1->h & ~3U); k += 4) {
1521 #ifdef DEBUG_ENC_CLN
1522         printf(" k=%d\n", k);
1523 #endif
1524         for (i = 0; i < t1->w; ++i) {
1525 #ifdef DEBUG_ENC_CLN
1526             printf("  i=%d\n", i);
1527 #endif
1528             agg = !(ENC_FLAGS(i, k) & agg_mask);
1529 #ifdef DEBUG_ENC_CLN
1530             printf("   agg=%d\n", agg);
1531 #endif
1532             if (agg) {
1533                 for (runlen = 0; runlen < 4; ++runlen) {
1534                     if (opj_int_abs(t1->data[((k + runlen)*t1->data_stride) + i]) & one) {
1535                         break;
1536                     }
1537                 }
1538                 opj_mqc_setcurctx(mqc, T1_CTXNO_AGG);
1539                 opj_mqc_encode(mqc, runlen != 4);
1540                 if (runlen == 4) {
1541                     continue;
1542                 }
1543                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
1544                 opj_mqc_encode(mqc, runlen >> 1);
1545                 opj_mqc_encode(mqc, runlen & 1);
1546             } else {
1547                 runlen = 0;
1548             }
1549             opj_t1_enc_clnpass_step(
1550                 t1,
1551                 &ENC_FLAGS(i, k),
1552                 &t1->data[((k + runlen) * t1->data_stride) + i],
1553                 orient,
1554                 bpno,
1555                 one,
1556                 nmsedec,
1557                 agg,
1558                 runlen,
1559                 4U,
1560                 cblksty);
1561         }
1562     }
1563     if (k < t1->h) {
1564         agg = 0;
1565         runlen = 0;
1566 #ifdef DEBUG_ENC_CLN
1567         printf(" k=%d\n", k);
1568 #endif
1569         for (i = 0; i < t1->w; ++i) {
1570 #ifdef DEBUG_ENC_CLN
1571             printf("  i=%d\n", i);
1572             printf("   agg=%d\n", agg);
1573 #endif
1574             opj_t1_enc_clnpass_step(
1575                 t1,
1576                 &ENC_FLAGS(i, k),
1577                 &t1->data[((k + runlen) * t1->data_stride) + i],
1578                 orient,
1579                 bpno,
1580                 one,
1581                 nmsedec,
1582                 agg,
1583                 runlen,
1584                 t1->h - k,
1585                 cblksty);
1586         }
1587     }
1588 }
1589
1590
1591 #define MACRO_t1_flags_internal(x,y,flags_stride) t1->flags[((x)*(flags_stride))+(y)]
1592
1593 #ifdef CONSISTENCY_CHECK
1594 #define REMOVE_VISIT_FLAG(flagptr) *(flagptr) &= (opj_flag_t)~T1_VISIT
1595 #define T1_SIG_OR_VISIT            (T1_SIG | T1_VISIT)
1596 #else
1597 #define REMOVE_VISIT_FLAG(flagptr) do {} while(0)
1598 #define T1_SIG_OR_VISIT            0
1599 #endif
1600
1601 #define opj_t1_dec_clnpass_internal(consistency_check, t1, bpno, cblksty, w, h, flags_stride) \
1602 { \
1603     OPJ_INT32 one, half, oneplushalf, agg, runlen, vsc; \
1604     OPJ_UINT32 i, j, k; \
1605     OPJ_INT32 segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM; \
1606      \
1607     opj_mqc_t *mqc = t1->mqc;   /* MQC component */ \
1608      \
1609     one = 1 << bpno; \
1610     half = one >> 1; \
1611     oneplushalf = one | half; \
1612     if (cblksty & J2K_CCP_CBLKSTY_VSC) { \
1613     opj_colflag_t *colflags1 = &t1->colflags[flags_stride + 1]; \
1614     for (k = 0; k < h; k += 4) { \
1615         for (i = 0; i < w; ++i) { \
1616             opj_colflag_t *colflags2 = colflags1 + i; \
1617             if (k + 3 < h) { \
1618                     agg = !((*colflags2 & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_SIG_OTHER_ROW_0 | \
1619                                            T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_SIG_OTHER_ROW_1 | \
1620                                            T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_SIG_OTHER_ROW_2 | \
1621                                            T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3)) || \
1622                           ((MACRO_t1_flags_internal(1 + k + 3,1 + i,flags_stride) \
1623                            & ((~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG_OTH)))); \
1624                 } else { \
1625                 agg = 0; \
1626             } \
1627             if (agg) { \
1628                 opj_mqc_setcurctx(mqc, T1_CTXNO_AGG); \
1629                 if (!opj_mqc_decode(mqc)) { \
1630                     continue; \
1631                 } \
1632                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI); \
1633                 runlen = opj_mqc_decode(mqc); \
1634                 runlen = (runlen << 1) | opj_mqc_decode(mqc); \
1635             } else { \
1636                 runlen = 0; \
1637             } \
1638             for (j = k + (OPJ_UINT32)runlen; j < k + 4 && j < h; ++j) { \
1639                     vsc = (j == k + 3 || j == h - 1) ? 1 : 0; \
1640                     opj_t1_dec_clnpass_step_vsc( \
1641                         t1, \
1642                         &t1->flags[((j+1) * flags_stride) + i + 1], \
1643                         colflags2, \
1644                         &t1->data[(j * w) + i], \
1645                         oneplushalf, \
1646                         agg && (j == k + (OPJ_UINT32)runlen), \
1647                         vsc, j - k); \
1648             } \
1649             *colflags2 &= (opj_colflag_t)~(T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_VISIT_ROW_3); \
1650         } \
1651         colflags1 += flags_stride; \
1652     } \
1653     } else { \
1654         OPJ_INT32 *data1 = t1->data; \
1655         opj_flag_t *flags1 = &t1->flags[1]; \
1656         opj_colflag_t *colflags1 = &t1->colflags[flags_stride + 1]; \
1657         for (k = 0; k < (h & ~3u); k += 4) { \
1658             for (i = 0; i < w; ++i) { \
1659                 OPJ_INT32 *data2 = data1 + i; \
1660                 opj_flag_t *flags2 = flags1 + i; \
1661                 opj_colflag_t *colflags2 = colflags1 + i; \
1662                 opj_colflag_t colflags = *colflags2; \
1663                 agg = !(colflags & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_SIG_OTHER_ROW_0 | \
1664                                      T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_SIG_OTHER_ROW_1 | \
1665                                      T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_SIG_OTHER_ROW_2 | \
1666                                      T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3 | T1_COLFLAG_SIG_OTHER_ROW_3)); \
1667                 if( consistency_check ) { \
1668                     assert( agg == !((MACRO_t1_flags_internal(1 + k, 1 + i,flags_stride) | \
1669                                       MACRO_t1_flags_internal(1 + k + 1, 1 + i,flags_stride) | \
1670                                       MACRO_t1_flags_internal(1 + k + 2, 1 + i,flags_stride) | \
1671                                       MACRO_t1_flags_internal(1 + k + 3, 1 + i,flags_stride)) & (T1_SIG_OR_VISIT | T1_SIG_OTH)) ); \
1672                 } \
1673                 if (agg) { \
1674                     opj_mqc_setcurctx(mqc, T1_CTXNO_AGG); \
1675                     if (!opj_mqc_decode(mqc)) { \
1676                         continue; \
1677                     } \
1678                     opj_mqc_setcurctx(mqc, T1_CTXNO_UNI); \
1679                     runlen = opj_mqc_decode(mqc); \
1680                     runlen = (runlen << 1) | opj_mqc_decode(mqc); \
1681                     flags2 += (OPJ_UINT32)runlen * flags_stride; \
1682                     data2 += (OPJ_UINT32)runlen * w; \
1683                     for (j = (OPJ_UINT32)runlen; j < 4; ++j) { \
1684                         flags2 += flags_stride; \
1685                         if (j == (OPJ_UINT32)runlen) { \
1686                             opj_t1_dec_clnpass_step_partial(t1, flags2, colflags2, data2, oneplushalf, j); \
1687                         } else { \
1688                             opj_t1_dec_clnpass_step(t1, flags2, colflags2, data2, oneplushalf, j); \
1689                         } \
1690                         data2 += w; \
1691                     } \
1692                 } else { \
1693                     flags2 += flags_stride; \
1694                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1695                     if (!(colflags & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0))) {\
1696                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 0U, flags_stride); \
1697                     } \
1698                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1699                     data2 += w; \
1700                     flags2 += flags_stride; \
1701                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1702                     if (!(colflags & (T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1))) {\
1703                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 1U, flags_stride); \
1704                     } \
1705                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1706                     data2 += w; \
1707                     flags2 += flags_stride; \
1708                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1709                     if (!(colflags & (T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2))) {\
1710                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 2U, flags_stride); \
1711                     } \
1712                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1713                     data2 += w; \
1714                     flags2 += flags_stride; \
1715                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1716                     if (!(colflags & (T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3))) {\
1717                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 3U, flags_stride); \
1718                     } \
1719                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1720                     data2 += w; \
1721                 } \
1722                 *colflags2 &= (opj_colflag_t)~(T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_VISIT_ROW_3); \
1723             } \
1724             data1 += w << 2; \
1725             flags1 += flags_stride << 2; \
1726             colflags1 += flags_stride; \
1727         } \
1728         for (i = 0; i < w; ++i) { \
1729             OPJ_INT32 *data2 = data1 + i; \
1730             opj_flag_t *flags2 = flags1 + i; \
1731             opj_colflag_t *colflags2 = colflags1 + i; \
1732             for (j = k; j < h; ++j) { \
1733                 flags2 += flags_stride; \
1734                 opj_t1_dec_clnpass_step(t1, flags2, colflags2, data2, oneplushalf, j - k); \
1735                 data2 += w; \
1736             } \
1737             *colflags2 &= (opj_colflag_t)~(T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_VISIT_ROW_3); \
1738         } \
1739     } \
1740  \
1741     if (segsym) { \
1742         OPJ_INT32 v = 0; \
1743         opj_mqc_setcurctx(mqc, T1_CTXNO_UNI); \
1744         v = opj_mqc_decode(mqc); \
1745         v = (v << 1) | opj_mqc_decode(mqc); \
1746         v = (v << 1) | opj_mqc_decode(mqc); \
1747         v = (v << 1) | opj_mqc_decode(mqc); \
1748         /* \
1749         if (v!=0xa) { \
1750             opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v); \
1751         } \
1752         */ \
1753     } \
1754 }               /* VSC and  BYPASS by Antonin */
1755
1756 static void opj_t1_dec_clnpass_64x64(
1757     opj_t1_t *t1,
1758     OPJ_INT32 bpno,
1759     OPJ_INT32 cblksty)
1760 {
1761 #ifdef CONSISTENCY_CHECK
1762     opj_t1_dec_clnpass_internal(OPJ_TRUE, t1, bpno, cblksty, 64, 64, 66);
1763 #else
1764     opj_t1_dec_clnpass_internal(OPJ_FALSE, t1, bpno, cblksty, 64, 64, 66);
1765 #endif
1766 }
1767
1768 static void opj_t1_dec_clnpass_generic(
1769     opj_t1_t *t1,
1770     OPJ_INT32 bpno,
1771     OPJ_INT32 cblksty)
1772 {
1773 #ifdef CONSISTENCY_CHECK
1774     opj_t1_dec_clnpass_internal(OPJ_TRUE, t1, bpno, cblksty, t1->w, t1->h,
1775                                 t1->flags_stride);
1776 #else
1777     opj_t1_dec_clnpass_internal(OPJ_FALSE, t1, bpno, cblksty, t1->w, t1->h,
1778                                 t1->flags_stride);
1779 #endif
1780 }
1781
1782
1783 /** mod fixed_quality */
1784 static OPJ_FLOAT64 opj_t1_getwmsedec(
1785     OPJ_INT32 nmsedec,
1786     OPJ_UINT32 compno,
1787     OPJ_UINT32 level,
1788     OPJ_UINT32 orient,
1789     OPJ_INT32 bpno,
1790     OPJ_UINT32 qmfbid,
1791     OPJ_FLOAT64 stepsize,
1792     OPJ_UINT32 numcomps,
1793     const OPJ_FLOAT64 * mct_norms,
1794     OPJ_UINT32 mct_numcomps)
1795 {
1796     OPJ_FLOAT64 w1 = 1, w2, wmsedec;
1797     OPJ_ARG_NOT_USED(numcomps);
1798
1799     if (mct_norms && (compno < mct_numcomps)) {
1800         w1 = mct_norms[compno];
1801     }
1802
1803     if (qmfbid == 1) {
1804         w2 = opj_dwt_getnorm(level, orient);
1805     } else {    /* if (qmfbid == 0) */
1806         w2 = opj_dwt_getnorm_real(level, orient);
1807     }
1808
1809     wmsedec = w1 * w2 * stepsize * (1 << bpno);
1810     wmsedec *= wmsedec * nmsedec / 8192.0;
1811
1812     return wmsedec;
1813 }
1814
1815 static OPJ_BOOL opj_t1_allocate_buffers(
1816     opj_t1_t *t1,
1817     OPJ_UINT32 w,
1818     OPJ_UINT32 h)
1819 {
1820     size_t flagssize;
1821
1822     /* encoder uses tile buffer, so no need to allocate */
1823     if (!t1->encoder) {
1824         size_t datasize;
1825
1826 #if (SIZE_MAX / 0xFFFFFFFFU) < 0xFFFFFFFFU /* UINT32_MAX */
1827         /* Overflow check */
1828         if ((w > 0U) && ((size_t)h > (SIZE_MAX / (size_t)w))) {
1829             /* FIXME event manager error callback */
1830             return OPJ_FALSE;
1831         }
1832 #endif
1833         datasize = (size_t)w * h;
1834
1835         /* Overflow check */
1836         if (datasize > (SIZE_MAX / sizeof(OPJ_INT32))) {
1837             /* FIXME event manager error callback */
1838             return OPJ_FALSE;
1839         }
1840
1841         if (datasize > (size_t)t1->datasize) {
1842             opj_aligned_free(t1->data);
1843             t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
1844             if (!t1->data) {
1845                 /* FIXME event manager error callback */
1846                 return OPJ_FALSE;
1847             }
1848 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1849             /* TODO remove this if t1->datasize type changes to size_t */
1850             /* Overflow check */
1851             if (datasize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1852                 /* FIXME event manager error callback */
1853                 return OPJ_FALSE;
1854             }
1855 #endif
1856             t1->datasize = (OPJ_UINT32)datasize;
1857         }
1858         /* memset first arg is declared to never be null by gcc */
1859         if (t1->data != NULL) {
1860             memset(t1->data, 0, datasize * sizeof(OPJ_INT32));
1861         }
1862     }
1863
1864     /* Overflow check */
1865     if (w > (0xFFFFFFFFU /* UINT32_MAX */ - 2U)) {
1866         /* FIXME event manager error callback */
1867         return OPJ_FALSE;
1868     }
1869     t1->flags_stride = w + 2U; /* can't be 0U */
1870
1871 #if (SIZE_MAX - 3U) < 0xFFFFFFFFU /* UINT32_MAX */
1872     /* Overflow check */
1873     if (h > (0xFFFFFFFFU /* UINT32_MAX */ - 3U)) {
1874         /* FIXME event manager error callback */
1875         return OPJ_FALSE;
1876     }
1877 #endif
1878     if (!t1->encoder) {
1879         flagssize = (size_t)h + 2U;
1880     } else {
1881         flagssize = (h + 3U) / 4U + 2U;
1882     }
1883
1884     /* Overflow check */
1885     if (flagssize > (SIZE_MAX / (size_t)t1->flags_stride)) {
1886         /* FIXME event manager error callback */
1887         return OPJ_FALSE;
1888     }
1889     flagssize *= (size_t)t1->flags_stride;
1890
1891     if (!t1->encoder) {
1892
1893         if (flagssize > (size_t)t1->flagssize) {
1894             /* Overflow check */
1895             if (flagssize > (SIZE_MAX / sizeof(opj_flag_t))) {
1896                 /* FIXME event manager error callback */
1897                 return OPJ_FALSE;
1898             }
1899             opj_aligned_free(t1->flags);
1900             t1->flags = (opj_flag_t*) opj_aligned_malloc(flagssize * sizeof(opj_flag_t));
1901             if (!t1->flags) {
1902                 /* FIXME event manager error callback */
1903                 return OPJ_FALSE;
1904             }
1905 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1906             /* TODO remove this if t1->flagssize type changes to size_t */
1907             /* Overflow check */
1908             if (flagssize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1909                 /* FIXME event manager error callback */
1910                 return OPJ_FALSE;
1911             }
1912 #endif
1913         }
1914         t1->flagssize = (OPJ_UINT32)flagssize;
1915
1916         memset(t1->flags, 0, flagssize * sizeof(opj_flag_t));
1917
1918         size_t colflags_size = ((((size_t)h + 3U) / 4U) +
1919                                 2U); /* Can't overflow, h checked against UINT32_MAX - 3U */
1920
1921         /* Overflow check */
1922         if (colflags_size > (SIZE_MAX / (size_t)t1->flags_stride)) {
1923             /* FIXME event manager error callback */
1924             return OPJ_FALSE;
1925         }
1926         colflags_size *= (size_t)t1->flags_stride;
1927
1928         if (colflags_size > (size_t)t1->colflags_size) {
1929             /* Overflow check */
1930             if ((size_t)colflags_size > (SIZE_MAX / sizeof(opj_colflag_t))) {
1931                 /* FIXME event manager error callback */
1932                 return OPJ_FALSE;
1933             }
1934             opj_aligned_free(t1->colflags);
1935             t1->colflags = (opj_colflag_t*) opj_aligned_malloc(colflags_size * sizeof(
1936                                opj_colflag_t));
1937             if (!t1->colflags) {
1938                 /* FIXME event manager error callback */
1939                 return OPJ_FALSE;
1940             }
1941 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1942             /* TODO remove this if t1->colflags_size type changes to size_t */
1943             /* Overflow check */
1944             if (colflags_size > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1945                 /* FIXME event manager error callback */
1946                 return OPJ_FALSE;
1947             }
1948 #endif
1949             t1->colflags_size = (OPJ_UINT32)colflags_size;
1950         }
1951         memset(t1->colflags, 0, colflags_size * sizeof(opj_colflag_t));
1952     } else {
1953         /* BIG FAT XXX */
1954         opj_flag_enc_t* p;
1955         OPJ_UINT32 x;
1956         OPJ_UINT32 flags_height = (h + 3U) / 4U;
1957
1958         if (flagssize > (size_t)t1->flagssize) {
1959             /* Overflow check */
1960             if (flagssize > (SIZE_MAX / sizeof(opj_flag_enc_t))) {
1961                 /* FIXME event manager error callback */
1962                 return OPJ_FALSE;
1963             }
1964             opj_aligned_free(t1->enc_flags);
1965             t1->enc_flags = (opj_flag_enc_t*) opj_aligned_malloc(flagssize * sizeof(
1966                                 opj_flag_enc_t));
1967             if (!t1->enc_flags) {
1968                 /* FIXME event manager error callback */
1969                 return OPJ_FALSE;
1970             }
1971 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1972             /* TODO remove this if t1->flagssize type changes to size_t */
1973             /* Overflow check */
1974             if (flagssize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1975                 /* FIXME event manager error callback */
1976                 return OPJ_FALSE;
1977             }
1978 #endif
1979         }
1980         t1->flagssize = (OPJ_UINT32)flagssize;
1981
1982         memset(t1->enc_flags, 0, flagssize * sizeof(opj_flag_enc_t));
1983
1984         p = &t1->enc_flags[0];
1985         for (x = 0; x < t1->flags_stride; ++x) {
1986             /* magic value to hopefully stop any passes being interested in this entry */
1987             *p++ = (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1988         }
1989
1990         p = &t1->enc_flags[((flags_height + 1) * t1->flags_stride)];
1991         for (x = 0; x < t1->flags_stride; ++x) {
1992             /* magic value to hopefully stop any passes being interested in this entry */
1993             *p++ = (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1994         }
1995
1996         if (h % 4) {
1997             OPJ_UINT32 v = 0;
1998             p = &t1->enc_flags[((flags_height) * t1->flags_stride)];
1999             if (h % 4 == 1) {
2000                 v |= T1_PI_1 | T1_PI_2 | T1_PI_3;
2001             } else if (h % 4 == 2) {
2002                 v |= T1_PI_2 | T1_PI_3;
2003             } else if (h % 4 == 3) {
2004                 v |= T1_PI_3;
2005             }
2006             for (x = 0; x < t1->flags_stride; ++x) {
2007                 *p++ = v;
2008             }
2009         }
2010     }
2011
2012     t1->w = w;
2013     t1->h = h;
2014
2015     return OPJ_TRUE;
2016 }
2017
2018 /* ----------------------------------------------------------------------- */
2019
2020 /* ----------------------------------------------------------------------- */
2021 /**
2022  * Creates a new Tier 1 handle
2023  * and initializes the look-up tables of the Tier-1 coder/decoder
2024  * @return a new T1 handle if successful, returns NULL otherwise
2025 */
2026 opj_t1_t* opj_t1_create(OPJ_BOOL isEncoder)
2027 {
2028     opj_t1_t *l_t1 = 00;
2029
2030     l_t1 = (opj_t1_t*) opj_calloc(1, sizeof(opj_t1_t));
2031     if (!l_t1) {
2032         return 00;
2033     }
2034
2035     /* create MQC and RAW handles */
2036     l_t1->mqc = opj_mqc_create();
2037     if (! l_t1->mqc) {
2038         opj_t1_destroy(l_t1);
2039         return 00;
2040     }
2041
2042     l_t1->raw = opj_raw_create();
2043     if (! l_t1->raw) {
2044         opj_t1_destroy(l_t1);
2045         return 00;
2046     }
2047     l_t1->encoder = isEncoder;
2048
2049     return l_t1;
2050 }
2051
2052
2053 /**
2054  * Destroys a previously created T1 handle
2055  *
2056  * @param p_t1 Tier 1 handle to destroy
2057 */
2058 void opj_t1_destroy(opj_t1_t *p_t1)
2059 {
2060     if (! p_t1) {
2061         return;
2062     }
2063
2064     /* destroy MQC and RAW handles */
2065     opj_mqc_destroy(p_t1->mqc);
2066     p_t1->mqc = 00;
2067     opj_raw_destroy(p_t1->raw);
2068     p_t1->raw = 00;
2069
2070     /* encoder uses tile buffer, so no need to free */
2071     if (!p_t1->encoder && p_t1->data) {
2072         opj_aligned_free(p_t1->data);
2073         p_t1->data = 00;
2074     }
2075
2076     if (p_t1->flags) {
2077         opj_aligned_free(p_t1->flags);
2078         p_t1->flags = 00;
2079     }
2080
2081     if (p_t1->colflags) {
2082         opj_aligned_free(p_t1->colflags);
2083         p_t1->colflags = 00;
2084     }
2085
2086     if (p_t1->enc_flags) {
2087         opj_aligned_free(p_t1->enc_flags);
2088         p_t1->enc_flags = 00;
2089     }
2090     opj_free(p_t1);
2091 }
2092
2093 typedef struct {
2094     OPJ_UINT32 resno;
2095     opj_tcd_cblk_dec_t* cblk;
2096     opj_tcd_band_t* band;
2097     opj_tcd_tilecomp_t* tilec;
2098     opj_tccp_t* tccp;
2099     volatile OPJ_BOOL* pret;
2100 } opj_t1_cblk_decode_processing_job_t;
2101
2102 static void opj_t1_destroy_wrapper(void* t1)
2103 {
2104     opj_t1_destroy((opj_t1_t*) t1);
2105 }
2106
2107 static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
2108 {
2109     opj_tcd_cblk_dec_t* cblk;
2110     opj_tcd_band_t* band;
2111     opj_tcd_tilecomp_t* tilec;
2112     opj_tccp_t* tccp;
2113     OPJ_INT32* OPJ_RESTRICT datap;
2114     OPJ_UINT32 cblk_w, cblk_h;
2115     OPJ_INT32 x, y;
2116     OPJ_UINT32 i, j;
2117     opj_t1_cblk_decode_processing_job_t* job;
2118     opj_t1_t* t1;
2119     OPJ_UINT32 resno;
2120     OPJ_UINT32 tile_w;
2121
2122     job = (opj_t1_cblk_decode_processing_job_t*) user_data;
2123     resno = job->resno;
2124     cblk = job->cblk;
2125     band = job->band;
2126     tilec = job->tilec;
2127     tccp = job->tccp;
2128     tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
2129
2130     if (!*(job->pret)) {
2131         opj_free(job);
2132         return;
2133     }
2134
2135     t1 = (opj_t1_t*) opj_tls_get(tls, OPJ_TLS_KEY_T1);
2136     if (t1 == NULL) {
2137         t1 = opj_t1_create(OPJ_FALSE);
2138         opj_tls_set(tls, OPJ_TLS_KEY_T1, t1, opj_t1_destroy_wrapper);
2139     }
2140
2141     if (OPJ_FALSE == opj_t1_decode_cblk(
2142                 t1,
2143                 cblk,
2144                 band->bandno,
2145                 (OPJ_UINT32)tccp->roishift,
2146                 tccp->cblksty)) {
2147         *(job->pret) = OPJ_FALSE;
2148         opj_free(job);
2149         return;
2150     }
2151
2152     x = cblk->x0 - band->x0;
2153     y = cblk->y0 - band->y0;
2154     if (band->bandno & 1) {
2155         opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
2156         x += pres->x1 - pres->x0;
2157     }
2158     if (band->bandno & 2) {
2159         opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
2160         y += pres->y1 - pres->y0;
2161     }
2162
2163     datap = t1->data;
2164     cblk_w = t1->w;
2165     cblk_h = t1->h;
2166
2167     if (tccp->roishift) {
2168         OPJ_INT32 thresh = 1 << tccp->roishift;
2169         for (j = 0; j < cblk_h; ++j) {
2170             for (i = 0; i < cblk_w; ++i) {
2171                 OPJ_INT32 val = datap[(j * cblk_w) + i];
2172                 OPJ_INT32 mag = abs(val);
2173                 if (mag >= thresh) {
2174                     mag >>= tccp->roishift;
2175                     datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
2176                 }
2177             }
2178         }
2179     }
2180     if (tccp->qmfbid == 1) {
2181         OPJ_INT32* OPJ_RESTRICT tiledp = &tilec->data[(OPJ_UINT32)y * tile_w +
2182                                                        (OPJ_UINT32)x];
2183         for (j = 0; j < cblk_h; ++j) {
2184             i = 0;
2185             for (; i < (cblk_w & ~(OPJ_UINT32)3U); i += 4U) {
2186                 OPJ_INT32 tmp0 = datap[(j * cblk_w) + i + 0U];
2187                 OPJ_INT32 tmp1 = datap[(j * cblk_w) + i + 1U];
2188                 OPJ_INT32 tmp2 = datap[(j * cblk_w) + i + 2U];
2189                 OPJ_INT32 tmp3 = datap[(j * cblk_w) + i + 3U];
2190                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 0U] = tmp0 / 2;
2191                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 1U] = tmp1 / 2;
2192                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 2U] = tmp2 / 2;
2193                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 3U] = tmp3 / 2;
2194             }
2195             for (; i < cblk_w; ++i) {
2196                 OPJ_INT32 tmp = datap[(j * cblk_w) + i];
2197                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp / 2;
2198             }
2199         }
2200     } else {        /* if (tccp->qmfbid == 0) */
2201         OPJ_FLOAT32* OPJ_RESTRICT tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_UINT32)y *
2202                                                          tile_w + (OPJ_UINT32)x];
2203         for (j = 0; j < cblk_h; ++j) {
2204             OPJ_FLOAT32* OPJ_RESTRICT tiledp2 = tiledp;
2205             for (i = 0; i < cblk_w; ++i) {
2206                 OPJ_FLOAT32 tmp = (OPJ_FLOAT32) * datap * band->stepsize;
2207                 *tiledp2 = tmp;
2208                 datap++;
2209                 tiledp2++;
2210             }
2211             tiledp += tile_w;
2212         }
2213     }
2214
2215     opj_free(job);
2216 }
2217
2218
2219 void opj_t1_decode_cblks(opj_thread_pool_t* tp,
2220                          volatile OPJ_BOOL* pret,
2221                          opj_tcd_tilecomp_t* tilec,
2222                          opj_tccp_t* tccp
2223                         )
2224 {
2225     OPJ_UINT32 resno, bandno, precno, cblkno;
2226
2227     for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
2228         opj_tcd_resolution_t* res = &tilec->resolutions[resno];
2229
2230         for (bandno = 0; bandno < res->numbands; ++bandno) {
2231             opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
2232
2233             for (precno = 0; precno < res->pw * res->ph; ++precno) {
2234                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
2235
2236                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
2237                     opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
2238                     opj_t1_cblk_decode_processing_job_t* job;
2239
2240                     job = (opj_t1_cblk_decode_processing_job_t*) opj_calloc(1,
2241                             sizeof(opj_t1_cblk_decode_processing_job_t));
2242                     if (!job) {
2243                         *pret = OPJ_FALSE;
2244                         return;
2245                     }
2246                     job->resno = resno;
2247                     job->cblk = cblk;
2248                     job->band = band;
2249                     job->tilec = tilec;
2250                     job->tccp = tccp;
2251                     job->pret = pret;
2252                     opj_thread_pool_submit_job(tp, opj_t1_clbl_decode_processor, job);
2253                     if (!(*pret)) {
2254                         return;
2255                     }
2256                 } /* cblkno */
2257             } /* precno */
2258         } /* bandno */
2259     } /* resno */
2260
2261     return;
2262 }
2263
2264
2265 static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
2266                                    opj_tcd_cblk_dec_t* cblk,
2267                                    OPJ_UINT32 orient,
2268                                    OPJ_UINT32 roishift,
2269                                    OPJ_UINT32 cblksty)
2270 {
2271     opj_raw_t *raw = t1->raw;   /* RAW component */
2272     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
2273
2274     OPJ_INT32 bpno_plus_one;
2275     OPJ_UINT32 passtype;
2276     OPJ_UINT32 segno, passno;
2277     OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
2278
2279     mqc->lut_ctxno_zc_orient = lut_ctxno_zc + orient * 256;
2280
2281     if (!opj_t1_allocate_buffers(
2282                 t1,
2283                 (OPJ_UINT32)(cblk->x1 - cblk->x0),
2284                 (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
2285         return OPJ_FALSE;
2286     }
2287
2288     bpno_plus_one = (OPJ_INT32)(roishift + cblk->numbps);
2289     passtype = 2;
2290
2291     opj_mqc_resetstates(mqc);
2292     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2293     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2294     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2295
2296     for (segno = 0; segno < cblk->real_num_segs; ++segno) {
2297         opj_tcd_seg_t *seg = &cblk->segs[segno];
2298
2299         /* BYPASS mode */
2300         type = ((bpno_plus_one <= ((OPJ_INT32)(cblk->numbps)) - 4) && (passtype < 2) &&
2301                 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2302         /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
2303         if (seg->data == 00) {
2304             continue;
2305         }
2306         if (type == T1_TYPE_RAW) {
2307             opj_raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
2308         } else {
2309             if (OPJ_FALSE == opj_mqc_init_dec(mqc, (*seg->data) + seg->dataindex,
2310                                               seg->len)) {
2311                 return OPJ_FALSE;
2312             }
2313         }
2314
2315         if (t1->w == 64 && t1->h == 64) {
2316             for (passno = 0; (passno < seg->real_num_passes) &&
2317                     (bpno_plus_one >= 1); ++passno) {
2318                 switch (passtype) {
2319                 case 0:
2320                     if (type == T1_TYPE_RAW) {
2321                         opj_t1_dec_sigpass_raw(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2322                     } else {
2323                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2324                             opj_t1_dec_sigpass_mqc_vsc(t1, bpno_plus_one);
2325                         } else {
2326                             opj_t1_dec_sigpass_mqc_64x64(t1, bpno_plus_one);
2327                         }
2328                     }
2329                     break;
2330                 case 1:
2331                     if (type == T1_TYPE_RAW) {
2332                         opj_t1_dec_refpass_raw(t1, bpno_plus_one);
2333                     } else {
2334                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2335                             opj_t1_dec_refpass_mqc_vsc(t1, bpno_plus_one);
2336                         } else {
2337                             opj_t1_dec_refpass_mqc_64x64(t1, bpno_plus_one);
2338                         }
2339                     }
2340                     break;
2341                 case 2:
2342                     opj_t1_dec_clnpass_64x64(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2343                     break;
2344                 }
2345
2346                 if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
2347                     opj_mqc_resetstates(mqc);
2348                     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2349                     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2350                     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2351                 }
2352                 if (++passtype == 3) {
2353                     passtype = 0;
2354                     bpno_plus_one--;
2355                 }
2356             }
2357         } else {
2358             for (passno = 0; (passno < seg->real_num_passes) &&
2359                     (bpno_plus_one >= 1); ++passno) {
2360                 switch (passtype) {
2361                 case 0:
2362                     if (type == T1_TYPE_RAW) {
2363                         opj_t1_dec_sigpass_raw(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2364                     } else {
2365                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2366                             opj_t1_dec_sigpass_mqc_vsc(t1, bpno_plus_one);
2367                         } else {
2368                             opj_t1_dec_sigpass_mqc_generic(t1, bpno_plus_one);
2369                         }
2370                     }
2371                     break;
2372                 case 1:
2373                     if (type == T1_TYPE_RAW) {
2374                         opj_t1_dec_refpass_raw(t1, bpno_plus_one);
2375                     } else {
2376                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2377                             opj_t1_dec_refpass_mqc_vsc(t1, bpno_plus_one);
2378                         } else {
2379                             opj_t1_dec_refpass_mqc_generic(t1, bpno_plus_one);
2380                         }
2381                     }
2382                     break;
2383                 case 2:
2384                     opj_t1_dec_clnpass_generic(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2385                     break;
2386                 }
2387
2388                 if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
2389                     opj_mqc_resetstates(mqc);
2390                     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2391                     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2392                     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2393                 }
2394                 if (++passtype == 3) {
2395                     passtype = 0;
2396                     bpno_plus_one--;
2397                 }
2398             }
2399         }
2400     }
2401     return OPJ_TRUE;
2402 }
2403
2404
2405
2406
2407 OPJ_BOOL opj_t1_encode_cblks(opj_t1_t *t1,
2408                              opj_tcd_tile_t *tile,
2409                              opj_tcp_t *tcp,
2410                              const OPJ_FLOAT64 * mct_norms,
2411                              OPJ_UINT32 mct_numcomps
2412                             )
2413 {
2414     OPJ_UINT32 compno, resno, bandno, precno, cblkno;
2415
2416     tile->distotile = 0;        /* fixed_quality */
2417
2418     for (compno = 0; compno < tile->numcomps; ++compno) {
2419         opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
2420         opj_tccp_t* tccp = &tcp->tccps[compno];
2421         OPJ_UINT32 tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
2422
2423         for (resno = 0; resno < tilec->numresolutions; ++resno) {
2424             opj_tcd_resolution_t *res = &tilec->resolutions[resno];
2425
2426             for (bandno = 0; bandno < res->numbands; ++bandno) {
2427                 opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
2428                 OPJ_INT32 bandconst = 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192));
2429
2430                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
2431                     opj_tcd_precinct_t *prc = &band->precincts[precno];
2432
2433                     for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
2434                         opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
2435                         OPJ_INT32* OPJ_RESTRICT tiledp;
2436                         OPJ_UINT32 cblk_w;
2437                         OPJ_UINT32 cblk_h;
2438                         OPJ_UINT32 i, j, tileIndex = 0, tileLineAdvance;
2439
2440                         OPJ_INT32 x = cblk->x0 - band->x0;
2441                         OPJ_INT32 y = cblk->y0 - band->y0;
2442                         if (band->bandno & 1) {
2443                             opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
2444                             x += pres->x1 - pres->x0;
2445                         }
2446                         if (band->bandno & 2) {
2447                             opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
2448                             y += pres->y1 - pres->y0;
2449                         }
2450
2451                         if (!opj_t1_allocate_buffers(
2452                                     t1,
2453                                     (OPJ_UINT32)(cblk->x1 - cblk->x0),
2454                                     (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
2455                             return OPJ_FALSE;
2456                         }
2457
2458                         cblk_w = t1->w;
2459                         cblk_h = t1->h;
2460                         tileLineAdvance = tile_w - cblk_w;
2461
2462                         tiledp = &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
2463                         t1->data = tiledp;
2464                         t1->data_stride = tile_w;
2465                         if (tccp->qmfbid == 1) {
2466                             for (j = 0; j < cblk_h; ++j) {
2467                                 for (i = 0; i < cblk_w; ++i) {
2468                                     tiledp[tileIndex] *= (1 << T1_NMSEDEC_FRACBITS);
2469                                     tileIndex++;
2470                                 }
2471                                 tileIndex += tileLineAdvance;
2472                             }
2473                         } else {        /* if (tccp->qmfbid == 0) */
2474                             for (j = 0; j < cblk_h; ++j) {
2475                                 for (i = 0; i < cblk_w; ++i) {
2476                                     OPJ_INT32 tmp = tiledp[tileIndex];
2477                                     tiledp[tileIndex] =
2478                                         opj_int_fix_mul_t1(
2479                                             tmp,
2480                                             bandconst);
2481                                     tileIndex++;
2482                                 }
2483                                 tileIndex += tileLineAdvance;
2484                             }
2485                         }
2486
2487                         opj_t1_encode_cblk(
2488                             t1,
2489                             cblk,
2490                             band->bandno,
2491                             compno,
2492                             tilec->numresolutions - 1 - resno,
2493                             tccp->qmfbid,
2494                             band->stepsize,
2495                             tccp->cblksty,
2496                             tile->numcomps,
2497                             tile,
2498                             mct_norms,
2499                             mct_numcomps);
2500
2501                     } /* cblkno */
2502                 } /* precno */
2503             } /* bandno */
2504         } /* resno  */
2505     } /* compno  */
2506     return OPJ_TRUE;
2507 }
2508
2509 /** mod fixed_quality */
2510 static void opj_t1_encode_cblk(opj_t1_t *t1,
2511                                opj_tcd_cblk_enc_t* cblk,
2512                                OPJ_UINT32 orient,
2513                                OPJ_UINT32 compno,
2514                                OPJ_UINT32 level,
2515                                OPJ_UINT32 qmfbid,
2516                                OPJ_FLOAT64 stepsize,
2517                                OPJ_UINT32 cblksty,
2518                                OPJ_UINT32 numcomps,
2519                                opj_tcd_tile_t * tile,
2520                                const OPJ_FLOAT64 * mct_norms,
2521                                OPJ_UINT32 mct_numcomps)
2522 {
2523     OPJ_FLOAT64 cumwmsedec = 0.0;
2524
2525     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
2526
2527     OPJ_UINT32 passno;
2528     OPJ_INT32 bpno;
2529     OPJ_UINT32 passtype;
2530     OPJ_INT32 nmsedec = 0;
2531     OPJ_INT32 max;
2532     OPJ_UINT32 i, j;
2533     OPJ_BYTE type = T1_TYPE_MQ;
2534     OPJ_FLOAT64 tempwmsedec;
2535
2536     mqc->lut_ctxno_zc_orient = lut_ctxno_zc + orient * 256;
2537
2538     max = 0;
2539     for (i = 0; i < t1->w; ++i) {
2540         for (j = 0; j < t1->h; ++j) {
2541             OPJ_INT32 tmp = abs(t1->data[i + j * t1->data_stride]);
2542             max = opj_int_max(max, tmp);
2543         }
2544     }
2545
2546     cblk->numbps = max ? (OPJ_UINT32)((opj_int_floorlog2(max) + 1) -
2547                                       T1_NMSEDEC_FRACBITS) : 0;
2548
2549     bpno = (OPJ_INT32)(cblk->numbps - 1);
2550     passtype = 2;
2551
2552     opj_mqc_resetstates(mqc);
2553     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2554     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2555     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2556     opj_mqc_init_enc(mqc, cblk->data);
2557
2558     for (passno = 0; bpno >= 0; ++passno) {
2559         opj_tcd_pass_t *pass = &cblk->passes[passno];
2560         OPJ_UINT32 correction = 3;
2561         type = ((bpno < ((OPJ_INT32)(cblk->numbps) - 4)) && (passtype < 2) &&
2562                 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2563
2564         switch (passtype) {
2565         case 0:
2566             opj_t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
2567             break;
2568         case 1:
2569             opj_t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
2570             break;
2571         case 2:
2572             opj_t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
2573             /* code switch SEGMARK (i.e. SEGSYM) */
2574             if (cblksty & J2K_CCP_CBLKSTY_SEGSYM) {
2575                 opj_mqc_segmark_enc(mqc);
2576             }
2577             break;
2578         }
2579
2580         /* fixed_quality */
2581         tempwmsedec = opj_t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid,
2582                                         stepsize, numcomps, mct_norms, mct_numcomps) ;
2583         cumwmsedec += tempwmsedec;
2584         tile->distotile += tempwmsedec;
2585
2586         /* Code switch "RESTART" (i.e. TERMALL) */
2587         if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) &&
2588                 (bpno - 1 < 0))) {
2589             if (type == T1_TYPE_RAW) {
2590                 opj_mqc_flush(mqc);
2591                 correction = 1;
2592                 /* correction = mqc_bypass_flush_enc(); */
2593             } else {            /* correction = mqc_restart_enc(); */
2594                 opj_mqc_flush(mqc);
2595                 correction = 1;
2596             }
2597             pass->term = 1;
2598         } else {
2599             if (((bpno < ((OPJ_INT32)(cblk->numbps) - 4) && (passtype > 0))
2600                     || ((bpno == ((OPJ_INT32)cblk->numbps - 4)) && (passtype == 2))) &&
2601                     (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
2602                 if (type == T1_TYPE_RAW) {
2603                     opj_mqc_flush(mqc);
2604                     correction = 1;
2605                     /* correction = mqc_bypass_flush_enc(); */
2606                 } else {        /* correction = mqc_restart_enc(); */
2607                     opj_mqc_flush(mqc);
2608                     correction = 1;
2609                 }
2610                 pass->term = 1;
2611             } else {
2612                 pass->term = 0;
2613             }
2614         }
2615
2616         if (++passtype == 3) {
2617             passtype = 0;
2618             bpno--;
2619         }
2620
2621         if (pass->term && bpno > 0) {
2622             type = ((bpno < ((OPJ_INT32)(cblk->numbps) - 4)) && (passtype < 2) &&
2623                     (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2624             if (type == T1_TYPE_RAW) {
2625                 opj_mqc_bypass_init_enc(mqc);
2626             } else {
2627                 opj_mqc_restart_init_enc(mqc);
2628             }
2629         }
2630
2631         pass->distortiondec = cumwmsedec;
2632         pass->rate = opj_mqc_numbytes(mqc) + correction;    /* FIXME */
2633
2634         /* Code-switch "RESET" */
2635         if (cblksty & J2K_CCP_CBLKSTY_RESET) {
2636             opj_mqc_reset_enc(mqc);
2637         }
2638     }
2639
2640     /* Code switch "ERTERM" (i.e. PTERM) */
2641     if (cblksty & J2K_CCP_CBLKSTY_PTERM) {
2642         opj_mqc_erterm_enc(mqc);
2643     } else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY)) {
2644         opj_mqc_flush(mqc);
2645     }
2646
2647     cblk->totalpasses = passno;
2648
2649     for (passno = 0; passno < cblk->totalpasses; passno++) {
2650         opj_tcd_pass_t *pass = &cblk->passes[passno];
2651         if (pass->rate > opj_mqc_numbytes(mqc)) {
2652             pass->rate = opj_mqc_numbytes(mqc);
2653         }
2654         /*Preventing generation of FF as last data byte of a pass*/
2655         if ((pass->rate > 1) && (cblk->data[pass->rate - 1] == 0xFF)) {
2656             pass->rate--;
2657         }
2658         pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
2659     }
2660 }