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 x,
1307     OPJ_UINT32 y,
1308     OPJ_UINT32 cblksty)
1309 {
1310     OPJ_INT32 v;
1311     OPJ_UINT32 ci;
1312     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1313
1314     OPJ_UINT32 lim;
1315     if ((cblksty & J2K_CCP_CBLKSTY_VSC) == 0) {
1316         const OPJ_UINT32 check = (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13 |
1317                                   T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1318
1319         if ((*flagsp & check) == check) {
1320             if (runlen == 0) {
1321                 *flagsp &= ~(T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1322             } else if (runlen == 1) {
1323                 *flagsp &= ~(T1_PI_1 | T1_PI_2 | T1_PI_3);
1324             } else if (runlen == 2) {
1325                 *flagsp &= ~(T1_PI_2 | T1_PI_3);
1326             } else if (runlen == 3) {
1327                 *flagsp &= ~(T1_PI_3);
1328             }
1329             return;
1330         }
1331     }
1332
1333     lim = 4U < (t1->h - y) ? 4U : (t1->h - y);
1334     for (ci = runlen; ci < lim; ++ci) {
1335         OPJ_UINT32 vsc;
1336         OPJ_UINT32 vsc_mask;
1337         opj_flag_enc_t flags;
1338
1339         vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (ci == lim - 1)) ? 1 : 0;
1340         vsc_mask = vsc ? ~((T1_SIGMA_SW | T1_SIGMA_S | T1_SIGMA_SE | T1_CHI_S) <<
1341                            (ci * 3U)) : ~0U;
1342
1343         if ((agg != 0) && (ci == runlen)) {
1344             goto LABEL_PARTIAL;
1345         }
1346
1347         flags = *flagsp & vsc_mask;
1348
1349         if (!(flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U)))) {
1350             OPJ_UINT32 ctxt1 = opj_t1_enc_getctxno_zc(flags >> (ci * 3U), orient);
1351 #ifdef DEBUG_ENC_CLN
1352             printf("   ctxt1=%d\n", ctxt1);
1353 #endif
1354             opj_mqc_setcurctx(mqc, ctxt1);
1355             v = opj_int_abs(*datap) & one ? 1 : 0;
1356             opj_mqc_encode(mqc, v);
1357             if (v) {
1358                 OPJ_UINT32 ctxt2, spb;
1359 LABEL_PARTIAL:
1360                 *nmsedec += opj_t1_getnmsedec_sig(opj_int_abs(*datap), bpno);
1361                 ctxt2 = opj_t1_enc_getctxno_sc(*flagsp & vsc_mask,
1362                                                flagsp[-1] & vsc_mask, flagsp[1] & vsc_mask,
1363                                                ci);
1364 #ifdef DEBUG_ENC_CLN
1365                 printf("   ctxt2=%d\n", ctxt2);
1366 #endif
1367                 opj_mqc_setcurctx(mqc, ctxt2);
1368
1369                 v = *datap < 0 ? 1 : 0;
1370                 spb = opj_t1_enc_getspb(*flagsp & vsc_mask,
1371                                         flagsp[-1] & vsc_mask, flagsp[1] & vsc_mask, ci);
1372 #ifdef DEBUG_ENC_CLN
1373                 printf("   spb=%d\n", spb);
1374 #endif
1375                 opj_mqc_encode(mqc, v ^ spb);
1376                 opj_t1_enc_updateflags(flagsp, ci, v, t1->flags_stride);
1377             }
1378         }
1379         *flagsp &= ~(T1_PI_THIS << (3U * ci));
1380         datap += t1->data_stride;
1381     }
1382 }
1383
1384
1385 static void opj_t1_dec_clnpass_step_partial(
1386     opj_t1_t *t1,
1387     opj_flag_t *flagsp,
1388     opj_colflag_t *colflagsp,
1389     OPJ_INT32 *datap,
1390     OPJ_INT32 oneplushalf,
1391     OPJ_UINT32 row)
1392 {
1393     OPJ_INT32 v, flag;
1394     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1395
1396     flag = *flagsp;
1397     opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
1398     v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
1399     *datap = v ? -oneplushalf : oneplushalf;
1400     opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, t1->flags_stride,
1401                                row);
1402 #ifdef CONSISTENCY_CHECK
1403     *flagsp &= ~T1_VISIT;
1404 #endif
1405 }               /* VSC and  BYPASS by Antonin */
1406
1407 static void opj_t1_dec_clnpass_step(
1408     opj_t1_t *t1,
1409     opj_flag_t *flagsp,
1410     opj_colflag_t *colflagsp,
1411     OPJ_INT32 *datap,
1412     OPJ_INT32 oneplushalf,
1413     OPJ_UINT32 row)
1414 {
1415     OPJ_INT32 v, flag;
1416
1417     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1418 #ifdef CONSISTENCY_CHECK
1419     assert((!(*flagsp & (T1_SIG | T1_VISIT))) == (!(*colflagsp & ((
1420                 T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) << (4 * row)))));
1421 #endif
1422     if (!(*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
1423                         (4 * row)))) {
1424         flag = *flagsp;
1425         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, (OPJ_UINT32)flag));
1426         if (opj_mqc_decode(mqc)) {
1427             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
1428             v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
1429             *datap = v ? -oneplushalf : oneplushalf;
1430             opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, t1->flags_stride,
1431                                        row);
1432         }
1433     }
1434 #ifdef CONSISTENCY_CHECK
1435     *flagsp &= ~T1_VISIT;
1436 #endif
1437 }               /* VSC and  BYPASS by Antonin */
1438
1439 static void opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(
1440     opj_t1_t *t1,
1441     opj_flag_t *flagsp,
1442     opj_colflag_t *colflagsp,
1443     OPJ_INT32 *datap,
1444     OPJ_INT32 oneplushalf,
1445     OPJ_UINT32 row,
1446     OPJ_UINT32 flags_stride)
1447 {
1448     OPJ_INT32 v;
1449     OPJ_INT32 flag;
1450
1451     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1452
1453     flag = *flagsp;
1454     /*if (!(flag & (T1_SIG | T1_VISIT)))*/
1455     {
1456         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, (OPJ_UINT32)flag));
1457         if (opj_mqc_decode(mqc)) {
1458             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc((OPJ_UINT32)flag));
1459             v = opj_mqc_decode(mqc) ^ opj_t1_getspb((OPJ_UINT32)flag);
1460             *datap = v ? -oneplushalf : oneplushalf;
1461             opj_t1_updateflagscolflags(flagsp, colflagsp, (OPJ_UINT32)v, flags_stride, row);
1462         }
1463     }
1464     /*flagsp &= ~T1_VISIT;*/
1465 }
1466
1467 static void opj_t1_dec_clnpass_step_vsc(
1468     opj_t1_t *t1,
1469     opj_flag_t *flagsp,
1470     opj_colflag_t *colflagsp,
1471     OPJ_INT32 *datap,
1472     OPJ_INT32 oneplushalf,
1473     OPJ_INT32 partial,
1474     OPJ_INT32 vsc,
1475     OPJ_UINT32 row)
1476 {
1477     OPJ_UINT32 v, flag;
1478
1479     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1480
1481     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
1482            (*flagsp);
1483     if (partial) {
1484         goto LABEL_PARTIAL;
1485     }
1486     if (!(*colflagsp & ((T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0) <<
1487                         (T1_COLFLAG_RBS * row)))) {
1488         opj_mqc_setcurctx(mqc, opj_t1_getctxno_zc(mqc, flag));
1489         if (opj_mqc_decode(mqc)) {
1490 LABEL_PARTIAL:
1491             opj_mqc_setcurctx(mqc, opj_t1_getctxno_sc(flag));
1492             v = (OPJ_UINT32)opj_mqc_decode(mqc) ^ opj_t1_getspb(flag);
1493             *datap = v ? -oneplushalf : oneplushalf;
1494             opj_t1_updateflagscolflags(flagsp, colflagsp, v, t1->flags_stride, row);
1495         }
1496     }
1497 #ifdef CONSISTENCY_CHECK
1498     *flagsp &= ~T1_VISIT;
1499 #endif
1500 }
1501
1502 #define MACRO_t1_enc_flags(x,y) t1->enc_flags[((x)*(t1->flags_stride))+(y)]
1503
1504 static void opj_t1_enc_clnpass(
1505     opj_t1_t *t1,
1506     OPJ_INT32 bpno,
1507     OPJ_UINT32 orient,
1508     OPJ_INT32 *nmsedec,
1509     OPJ_UINT32 cblksty)
1510 {
1511     OPJ_UINT32 i, k;
1512     const OPJ_INT32 one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
1513     OPJ_UINT32 agg, runlen;
1514
1515     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1516
1517     *nmsedec = 0;
1518 #ifdef DEBUG_ENC_CLN
1519     printf("enc_clnpass: bpno=%d\n", bpno);
1520 #endif
1521     for (k = 0; k < t1->h; k += 4) {
1522 #ifdef DEBUG_ENC_CLN
1523         printf(" k=%d\n", k);
1524 #endif
1525         for (i = 0; i < t1->w; ++i) {
1526 #ifdef DEBUG_ENC_CLN
1527             printf("  i=%d\n", i);
1528 #endif
1529             if (k + 3 < t1->h) {
1530                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1531                     agg = !(ENC_FLAGS(i, k) & ~(T1_SIGMA_15 | T1_SIGMA_16 | T1_SIGMA_17 |
1532                                                 T1_CHI_5));
1533                 } else {
1534                     agg = !ENC_FLAGS(i, k);
1535                 }
1536             } else {
1537                 agg = 0;
1538             }
1539 #ifdef DEBUG_ENC_CLN
1540             printf("   agg=%d\n", agg);
1541 #endif
1542             if (agg) {
1543                 for (runlen = 0; runlen < 4; ++runlen) {
1544                     if (opj_int_abs(t1->data[((k + runlen)*t1->data_stride) + i]) & one) {
1545                         break;
1546                     }
1547                 }
1548                 opj_mqc_setcurctx(mqc, T1_CTXNO_AGG);
1549                 opj_mqc_encode(mqc, runlen != 4);
1550                 if (runlen == 4) {
1551                     continue;
1552                 }
1553                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
1554                 opj_mqc_encode(mqc, runlen >> 1);
1555                 opj_mqc_encode(mqc, runlen & 1);
1556             } else {
1557                 runlen = 0;
1558             }
1559             opj_t1_enc_clnpass_step(
1560                 t1,
1561                 &ENC_FLAGS(i, k),
1562                 &t1->data[((k + runlen) * t1->data_stride) + i],
1563                 orient,
1564                 bpno,
1565                 one,
1566                 nmsedec,
1567                 agg,
1568                 runlen,
1569                 i,
1570                 k,
1571                 cblksty);
1572         }
1573     }
1574 }
1575
1576
1577 #define MACRO_t1_flags_internal(x,y,flags_stride) t1->flags[((x)*(flags_stride))+(y)]
1578
1579 #ifdef CONSISTENCY_CHECK
1580 #define REMOVE_VISIT_FLAG(flagptr) *(flagptr) &= (opj_flag_t)~T1_VISIT
1581 #define T1_SIG_OR_VISIT            (T1_SIG | T1_VISIT)
1582 #else
1583 #define REMOVE_VISIT_FLAG(flagptr) do {} while(0)
1584 #define T1_SIG_OR_VISIT            0
1585 #endif
1586
1587 #define opj_t1_dec_clnpass_internal(consistency_check, t1, bpno, cblksty, w, h, flags_stride) \
1588 { \
1589     OPJ_INT32 one, half, oneplushalf, agg, runlen, vsc; \
1590     OPJ_UINT32 i, j, k; \
1591     OPJ_INT32 segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM; \
1592      \
1593     opj_mqc_t *mqc = t1->mqc;   /* MQC component */ \
1594      \
1595     one = 1 << bpno; \
1596     half = one >> 1; \
1597     oneplushalf = one | half; \
1598     if (cblksty & J2K_CCP_CBLKSTY_VSC) { \
1599     opj_colflag_t *colflags1 = &t1->colflags[flags_stride + 1]; \
1600     for (k = 0; k < h; k += 4) { \
1601         for (i = 0; i < w; ++i) { \
1602             opj_colflag_t *colflags2 = colflags1 + i; \
1603             if (k + 3 < h) { \
1604                     agg = !((*colflags2 & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_SIG_OTHER_ROW_0 | \
1605                                            T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_SIG_OTHER_ROW_1 | \
1606                                            T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_SIG_OTHER_ROW_2 | \
1607                                            T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3)) || \
1608                           ((MACRO_t1_flags_internal(1 + k + 3,1 + i,flags_stride) \
1609                            & ((~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG_OTH)))); \
1610                 } else { \
1611                 agg = 0; \
1612             } \
1613             if (agg) { \
1614                 opj_mqc_setcurctx(mqc, T1_CTXNO_AGG); \
1615                 if (!opj_mqc_decode(mqc)) { \
1616                     continue; \
1617                 } \
1618                 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI); \
1619                 runlen = opj_mqc_decode(mqc); \
1620                 runlen = (runlen << 1) | opj_mqc_decode(mqc); \
1621             } else { \
1622                 runlen = 0; \
1623             } \
1624             for (j = k + (OPJ_UINT32)runlen; j < k + 4 && j < h; ++j) { \
1625                     vsc = (j == k + 3 || j == h - 1) ? 1 : 0; \
1626                     opj_t1_dec_clnpass_step_vsc( \
1627                         t1, \
1628                         &t1->flags[((j+1) * flags_stride) + i + 1], \
1629                         colflags2, \
1630                         &t1->data[(j * w) + i], \
1631                         oneplushalf, \
1632                         agg && (j == k + (OPJ_UINT32)runlen), \
1633                         vsc, j - k); \
1634             } \
1635             *colflags2 &= (opj_colflag_t)~(T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_VISIT_ROW_3); \
1636         } \
1637         colflags1 += flags_stride; \
1638     } \
1639     } else { \
1640         OPJ_INT32 *data1 = t1->data; \
1641         opj_flag_t *flags1 = &t1->flags[1]; \
1642         opj_colflag_t *colflags1 = &t1->colflags[flags_stride + 1]; \
1643         for (k = 0; k < (h & ~3u); k += 4) { \
1644             for (i = 0; i < w; ++i) { \
1645                 OPJ_INT32 *data2 = data1 + i; \
1646                 opj_flag_t *flags2 = flags1 + i; \
1647                 opj_colflag_t *colflags2 = colflags1 + i; \
1648                 opj_colflag_t colflags = *colflags2; \
1649                 agg = !(colflags & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_SIG_OTHER_ROW_0 | \
1650                                      T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_SIG_OTHER_ROW_1 | \
1651                                      T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_SIG_OTHER_ROW_2 | \
1652                                      T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3 | T1_COLFLAG_SIG_OTHER_ROW_3)); \
1653                 if( consistency_check ) { \
1654                     assert( agg == !((MACRO_t1_flags_internal(1 + k, 1 + i,flags_stride) | \
1655                                       MACRO_t1_flags_internal(1 + k + 1, 1 + i,flags_stride) | \
1656                                       MACRO_t1_flags_internal(1 + k + 2, 1 + i,flags_stride) | \
1657                                       MACRO_t1_flags_internal(1 + k + 3, 1 + i,flags_stride)) & (T1_SIG_OR_VISIT | T1_SIG_OTH)) ); \
1658                 } \
1659                 if (agg) { \
1660                     opj_mqc_setcurctx(mqc, T1_CTXNO_AGG); \
1661                     if (!opj_mqc_decode(mqc)) { \
1662                         continue; \
1663                     } \
1664                     opj_mqc_setcurctx(mqc, T1_CTXNO_UNI); \
1665                     runlen = opj_mqc_decode(mqc); \
1666                     runlen = (runlen << 1) | opj_mqc_decode(mqc); \
1667                     flags2 += (OPJ_UINT32)runlen * flags_stride; \
1668                     data2 += (OPJ_UINT32)runlen * w; \
1669                     for (j = (OPJ_UINT32)runlen; j < 4; ++j) { \
1670                         flags2 += flags_stride; \
1671                         if (j == (OPJ_UINT32)runlen) { \
1672                             opj_t1_dec_clnpass_step_partial(t1, flags2, colflags2, data2, oneplushalf, j); \
1673                         } else { \
1674                             opj_t1_dec_clnpass_step(t1, flags2, colflags2, data2, oneplushalf, j); \
1675                         } \
1676                         data2 += w; \
1677                     } \
1678                 } else { \
1679                     flags2 += flags_stride; \
1680                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1681                     if (!(colflags & (T1_COLFLAG_SIG_ROW_0 | T1_COLFLAG_VISIT_ROW_0))) {\
1682                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 0U, flags_stride); \
1683                     } \
1684                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1685                     data2 += w; \
1686                     flags2 += flags_stride; \
1687                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1688                     if (!(colflags & (T1_COLFLAG_SIG_ROW_1 | T1_COLFLAG_VISIT_ROW_1))) {\
1689                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 1U, flags_stride); \
1690                     } \
1691                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1692                     data2 += w; \
1693                     flags2 += flags_stride; \
1694                     if( consistency_check ) { assert( (!(colflags & (T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1695                     if (!(colflags & (T1_COLFLAG_SIG_ROW_2 | T1_COLFLAG_VISIT_ROW_2))) {\
1696                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 2U, 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_3 | T1_COLFLAG_VISIT_ROW_3))) == (!(*flags2 & (T1_SIG_OR_VISIT))) ); } \
1702                     if (!(colflags & (T1_COLFLAG_SIG_ROW_3 | T1_COLFLAG_VISIT_ROW_3))) {\
1703                         opj_t1_dec_clnpass_step_only_if_flag_not_sig_visit(t1, flags2, colflags2, data2, oneplushalf, 3U, flags_stride); \
1704                     } \
1705                     if( consistency_check ) REMOVE_VISIT_FLAG(*flags2); \
1706                     data2 += w; \
1707                 } \
1708                 *colflags2 &= (opj_colflag_t)~(T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_VISIT_ROW_3); \
1709             } \
1710             data1 += w << 2; \
1711             flags1 += flags_stride << 2; \
1712             colflags1 += flags_stride; \
1713         } \
1714         for (i = 0; i < w; ++i) { \
1715             OPJ_INT32 *data2 = data1 + i; \
1716             opj_flag_t *flags2 = flags1 + i; \
1717             opj_colflag_t *colflags2 = colflags1 + i; \
1718             for (j = k; j < h; ++j) { \
1719                 flags2 += flags_stride; \
1720                 opj_t1_dec_clnpass_step(t1, flags2, colflags2, data2, oneplushalf, j - k); \
1721                 data2 += w; \
1722             } \
1723             *colflags2 &= (opj_colflag_t)~(T1_COLFLAG_VISIT_ROW_0 | T1_COLFLAG_VISIT_ROW_1 | T1_COLFLAG_VISIT_ROW_2 | T1_COLFLAG_VISIT_ROW_3); \
1724         } \
1725     } \
1726  \
1727     if (segsym) { \
1728         OPJ_INT32 v = 0; \
1729         opj_mqc_setcurctx(mqc, T1_CTXNO_UNI); \
1730         v = opj_mqc_decode(mqc); \
1731         v = (v << 1) | opj_mqc_decode(mqc); \
1732         v = (v << 1) | opj_mqc_decode(mqc); \
1733         v = (v << 1) | opj_mqc_decode(mqc); \
1734         /* \
1735         if (v!=0xa) { \
1736             opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v); \
1737         } \
1738         */ \
1739     } \
1740 }               /* VSC and  BYPASS by Antonin */
1741
1742 static void opj_t1_dec_clnpass_64x64(
1743     opj_t1_t *t1,
1744     OPJ_INT32 bpno,
1745     OPJ_INT32 cblksty)
1746 {
1747 #ifdef CONSISTENCY_CHECK
1748     opj_t1_dec_clnpass_internal(OPJ_TRUE, t1, bpno, cblksty, 64, 64, 66);
1749 #else
1750     opj_t1_dec_clnpass_internal(OPJ_FALSE, t1, bpno, cblksty, 64, 64, 66);
1751 #endif
1752 }
1753
1754 static void opj_t1_dec_clnpass_generic(
1755     opj_t1_t *t1,
1756     OPJ_INT32 bpno,
1757     OPJ_INT32 cblksty)
1758 {
1759 #ifdef CONSISTENCY_CHECK
1760     opj_t1_dec_clnpass_internal(OPJ_TRUE, t1, bpno, cblksty, t1->w, t1->h,
1761                                 t1->flags_stride);
1762 #else
1763     opj_t1_dec_clnpass_internal(OPJ_FALSE, t1, bpno, cblksty, t1->w, t1->h,
1764                                 t1->flags_stride);
1765 #endif
1766 }
1767
1768
1769 /** mod fixed_quality */
1770 static OPJ_FLOAT64 opj_t1_getwmsedec(
1771     OPJ_INT32 nmsedec,
1772     OPJ_UINT32 compno,
1773     OPJ_UINT32 level,
1774     OPJ_UINT32 orient,
1775     OPJ_INT32 bpno,
1776     OPJ_UINT32 qmfbid,
1777     OPJ_FLOAT64 stepsize,
1778     OPJ_UINT32 numcomps,
1779     const OPJ_FLOAT64 * mct_norms,
1780     OPJ_UINT32 mct_numcomps)
1781 {
1782     OPJ_FLOAT64 w1 = 1, w2, wmsedec;
1783     OPJ_ARG_NOT_USED(numcomps);
1784
1785     if (mct_norms && (compno < mct_numcomps)) {
1786         w1 = mct_norms[compno];
1787     }
1788
1789     if (qmfbid == 1) {
1790         w2 = opj_dwt_getnorm(level, orient);
1791     } else {    /* if (qmfbid == 0) */
1792         w2 = opj_dwt_getnorm_real(level, orient);
1793     }
1794
1795     wmsedec = w1 * w2 * stepsize * (1 << bpno);
1796     wmsedec *= wmsedec * nmsedec / 8192.0;
1797
1798     return wmsedec;
1799 }
1800
1801 static OPJ_BOOL opj_t1_allocate_buffers(
1802     opj_t1_t *t1,
1803     OPJ_UINT32 w,
1804     OPJ_UINT32 h)
1805 {
1806     size_t flagssize;
1807
1808     /* encoder uses tile buffer, so no need to allocate */
1809     if (!t1->encoder) {
1810         size_t datasize;
1811
1812 #if (SIZE_MAX / 0xFFFFFFFFU) < 0xFFFFFFFFU /* UINT32_MAX */
1813         /* Overflow check */
1814         if ((w > 0U) && ((size_t)h > (SIZE_MAX / (size_t)w))) {
1815             /* FIXME event manager error callback */
1816             return OPJ_FALSE;
1817         }
1818 #endif
1819         datasize = (size_t)w * h;
1820
1821         /* Overflow check */
1822         if (datasize > (SIZE_MAX / sizeof(OPJ_INT32))) {
1823             /* FIXME event manager error callback */
1824             return OPJ_FALSE;
1825         }
1826
1827         if (datasize > (size_t)t1->datasize) {
1828             opj_aligned_free(t1->data);
1829             t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
1830             if (!t1->data) {
1831                 /* FIXME event manager error callback */
1832                 return OPJ_FALSE;
1833             }
1834 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1835             /* TODO remove this if t1->datasize type changes to size_t */
1836             /* Overflow check */
1837             if (datasize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1838                 /* FIXME event manager error callback */
1839                 return OPJ_FALSE;
1840             }
1841 #endif
1842             t1->datasize = (OPJ_UINT32)datasize;
1843         }
1844         /* memset first arg is declared to never be null by gcc */
1845         if (t1->data != NULL) {
1846             memset(t1->data, 0, datasize * sizeof(OPJ_INT32));
1847         }
1848     }
1849
1850     /* Overflow check */
1851     if (w > (0xFFFFFFFFU /* UINT32_MAX */ - 2U)) {
1852         /* FIXME event manager error callback */
1853         return OPJ_FALSE;
1854     }
1855     t1->flags_stride = w + 2U; /* can't be 0U */
1856
1857 #if (SIZE_MAX - 3U) < 0xFFFFFFFFU /* UINT32_MAX */
1858     /* Overflow check */
1859     if (h > (0xFFFFFFFFU /* UINT32_MAX */ - 3U)) {
1860         /* FIXME event manager error callback */
1861         return OPJ_FALSE;
1862     }
1863 #endif
1864     if (!t1->encoder) {
1865         flagssize = (size_t)h + 2U;
1866     } else {
1867         flagssize = (h + 3U) / 4U + 2U;
1868     }
1869
1870     /* Overflow check */
1871     if (flagssize > (SIZE_MAX / (size_t)t1->flags_stride)) {
1872         /* FIXME event manager error callback */
1873         return OPJ_FALSE;
1874     }
1875     flagssize *= (size_t)t1->flags_stride;
1876
1877     if (!t1->encoder) {
1878
1879         if (flagssize > (size_t)t1->flagssize) {
1880             /* Overflow check */
1881             if (flagssize > (SIZE_MAX / sizeof(opj_flag_t))) {
1882                 /* FIXME event manager error callback */
1883                 return OPJ_FALSE;
1884             }
1885             opj_aligned_free(t1->flags);
1886             t1->flags = (opj_flag_t*) opj_aligned_malloc(flagssize * sizeof(opj_flag_t));
1887             if (!t1->flags) {
1888                 /* FIXME event manager error callback */
1889                 return OPJ_FALSE;
1890             }
1891 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1892             /* TODO remove this if t1->flagssize type changes to size_t */
1893             /* Overflow check */
1894             if (flagssize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1895                 /* FIXME event manager error callback */
1896                 return OPJ_FALSE;
1897             }
1898 #endif
1899         }
1900         t1->flagssize = (OPJ_UINT32)flagssize;
1901
1902         memset(t1->flags, 0, flagssize * sizeof(opj_flag_t));
1903
1904         size_t colflags_size = ((((size_t)h + 3U) / 4U) +
1905                                 2U); /* Can't overflow, h checked against UINT32_MAX - 3U */
1906
1907         /* Overflow check */
1908         if (colflags_size > (SIZE_MAX / (size_t)t1->flags_stride)) {
1909             /* FIXME event manager error callback */
1910             return OPJ_FALSE;
1911         }
1912         colflags_size *= (size_t)t1->flags_stride;
1913
1914         if (colflags_size > (size_t)t1->colflags_size) {
1915             /* Overflow check */
1916             if ((size_t)colflags_size > (SIZE_MAX / sizeof(opj_colflag_t))) {
1917                 /* FIXME event manager error callback */
1918                 return OPJ_FALSE;
1919             }
1920             opj_aligned_free(t1->colflags);
1921             t1->colflags = (opj_colflag_t*) opj_aligned_malloc(colflags_size * sizeof(
1922                                opj_colflag_t));
1923             if (!t1->colflags) {
1924                 /* FIXME event manager error callback */
1925                 return OPJ_FALSE;
1926             }
1927 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1928             /* TODO remove this if t1->colflags_size type changes to size_t */
1929             /* Overflow check */
1930             if (colflags_size > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1931                 /* FIXME event manager error callback */
1932                 return OPJ_FALSE;
1933             }
1934 #endif
1935             t1->colflags_size = (OPJ_UINT32)colflags_size;
1936         }
1937         memset(t1->colflags, 0, colflags_size * sizeof(opj_colflag_t));
1938     } else {
1939         /* BIG FAT XXX */
1940         opj_flag_enc_t* p;
1941         OPJ_UINT32 x;
1942         OPJ_UINT32 flags_height = (h + 3U) / 4U;
1943
1944         if (flagssize > (size_t)t1->flagssize) {
1945             /* Overflow check */
1946             if (flagssize > (SIZE_MAX / sizeof(opj_flag_enc_t))) {
1947                 /* FIXME event manager error callback */
1948                 return OPJ_FALSE;
1949             }
1950             opj_aligned_free(t1->enc_flags);
1951             t1->enc_flags = (opj_flag_enc_t*) opj_aligned_malloc(flagssize * sizeof(
1952                                 opj_flag_enc_t));
1953             if (!t1->enc_flags) {
1954                 /* FIXME event manager error callback */
1955                 return OPJ_FALSE;
1956             }
1957 #if SIZE_MAX > 0xFFFFFFFFU /* UINT32_MAX */
1958             /* TODO remove this if t1->flagssize type changes to size_t */
1959             /* Overflow check */
1960             if (flagssize > (size_t)0xFFFFFFFFU /* UINT32_MAX */) {
1961                 /* FIXME event manager error callback */
1962                 return OPJ_FALSE;
1963             }
1964 #endif
1965         }
1966         t1->flagssize = (OPJ_UINT32)flagssize;
1967
1968         memset(t1->enc_flags, 0, flagssize * sizeof(opj_flag_enc_t));
1969
1970         p = &t1->enc_flags[0];
1971         for (x = 0; x < t1->flags_stride; ++x) {
1972             /* magic value to hopefully stop any passes being interested in this entry */
1973             *p++ = (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1974         }
1975
1976         p = &t1->enc_flags[((flags_height + 1) * t1->flags_stride)];
1977         for (x = 0; x < t1->flags_stride; ++x) {
1978             /* magic value to hopefully stop any passes being interested in this entry */
1979             *p++ = (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1980         }
1981
1982         if (h % 4) {
1983             OPJ_UINT32 v = 0;
1984             p = &t1->enc_flags[((flags_height) * t1->flags_stride)];
1985             if (h % 4 == 1) {
1986                 v |= T1_PI_1 | T1_PI_2 | T1_PI_3;
1987             } else if (h % 4 == 2) {
1988                 v |= T1_PI_2 | T1_PI_3;
1989             } else if (h % 4 == 3) {
1990                 v |= T1_PI_3;
1991             }
1992             for (x = 0; x < t1->flags_stride; ++x) {
1993                 *p++ = v;
1994             }
1995         }
1996     }
1997
1998     t1->w = w;
1999     t1->h = h;
2000
2001     return OPJ_TRUE;
2002 }
2003
2004 /* ----------------------------------------------------------------------- */
2005
2006 /* ----------------------------------------------------------------------- */
2007 /**
2008  * Creates a new Tier 1 handle
2009  * and initializes the look-up tables of the Tier-1 coder/decoder
2010  * @return a new T1 handle if successful, returns NULL otherwise
2011 */
2012 opj_t1_t* opj_t1_create(OPJ_BOOL isEncoder)
2013 {
2014     opj_t1_t *l_t1 = 00;
2015
2016     l_t1 = (opj_t1_t*) opj_calloc(1, sizeof(opj_t1_t));
2017     if (!l_t1) {
2018         return 00;
2019     }
2020
2021     /* create MQC and RAW handles */
2022     l_t1->mqc = opj_mqc_create();
2023     if (! l_t1->mqc) {
2024         opj_t1_destroy(l_t1);
2025         return 00;
2026     }
2027
2028     l_t1->raw = opj_raw_create();
2029     if (! l_t1->raw) {
2030         opj_t1_destroy(l_t1);
2031         return 00;
2032     }
2033     l_t1->encoder = isEncoder;
2034
2035     return l_t1;
2036 }
2037
2038
2039 /**
2040  * Destroys a previously created T1 handle
2041  *
2042  * @param p_t1 Tier 1 handle to destroy
2043 */
2044 void opj_t1_destroy(opj_t1_t *p_t1)
2045 {
2046     if (! p_t1) {
2047         return;
2048     }
2049
2050     /* destroy MQC and RAW handles */
2051     opj_mqc_destroy(p_t1->mqc);
2052     p_t1->mqc = 00;
2053     opj_raw_destroy(p_t1->raw);
2054     p_t1->raw = 00;
2055
2056     /* encoder uses tile buffer, so no need to free */
2057     if (!p_t1->encoder && p_t1->data) {
2058         opj_aligned_free(p_t1->data);
2059         p_t1->data = 00;
2060     }
2061
2062     if (p_t1->flags) {
2063         opj_aligned_free(p_t1->flags);
2064         p_t1->flags = 00;
2065     }
2066
2067     if (p_t1->colflags) {
2068         opj_aligned_free(p_t1->colflags);
2069         p_t1->colflags = 00;
2070     }
2071
2072     if (p_t1->enc_flags) {
2073         opj_aligned_free(p_t1->enc_flags);
2074         p_t1->enc_flags = 00;
2075     }
2076     opj_free(p_t1);
2077 }
2078
2079 typedef struct {
2080     OPJ_UINT32 resno;
2081     opj_tcd_cblk_dec_t* cblk;
2082     opj_tcd_band_t* band;
2083     opj_tcd_tilecomp_t* tilec;
2084     opj_tccp_t* tccp;
2085     volatile OPJ_BOOL* pret;
2086 } opj_t1_cblk_decode_processing_job_t;
2087
2088 static void opj_t1_destroy_wrapper(void* t1)
2089 {
2090     opj_t1_destroy((opj_t1_t*) t1);
2091 }
2092
2093 static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
2094 {
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     OPJ_INT32* OPJ_RESTRICT datap;
2100     OPJ_UINT32 cblk_w, cblk_h;
2101     OPJ_INT32 x, y;
2102     OPJ_UINT32 i, j;
2103     opj_t1_cblk_decode_processing_job_t* job;
2104     opj_t1_t* t1;
2105     OPJ_UINT32 resno;
2106     OPJ_UINT32 tile_w;
2107
2108     job = (opj_t1_cblk_decode_processing_job_t*) user_data;
2109     resno = job->resno;
2110     cblk = job->cblk;
2111     band = job->band;
2112     tilec = job->tilec;
2113     tccp = job->tccp;
2114     tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
2115
2116     if (!*(job->pret)) {
2117         opj_free(job);
2118         return;
2119     }
2120
2121     t1 = (opj_t1_t*) opj_tls_get(tls, OPJ_TLS_KEY_T1);
2122     if (t1 == NULL) {
2123         t1 = opj_t1_create(OPJ_FALSE);
2124         opj_tls_set(tls, OPJ_TLS_KEY_T1, t1, opj_t1_destroy_wrapper);
2125     }
2126
2127     if (OPJ_FALSE == opj_t1_decode_cblk(
2128                 t1,
2129                 cblk,
2130                 band->bandno,
2131                 (OPJ_UINT32)tccp->roishift,
2132                 tccp->cblksty)) {
2133         *(job->pret) = OPJ_FALSE;
2134         opj_free(job);
2135         return;
2136     }
2137
2138     x = cblk->x0 - band->x0;
2139     y = cblk->y0 - band->y0;
2140     if (band->bandno & 1) {
2141         opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
2142         x += pres->x1 - pres->x0;
2143     }
2144     if (band->bandno & 2) {
2145         opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
2146         y += pres->y1 - pres->y0;
2147     }
2148
2149     datap = t1->data;
2150     cblk_w = t1->w;
2151     cblk_h = t1->h;
2152
2153     if (tccp->roishift) {
2154         OPJ_INT32 thresh = 1 << tccp->roishift;
2155         for (j = 0; j < cblk_h; ++j) {
2156             for (i = 0; i < cblk_w; ++i) {
2157                 OPJ_INT32 val = datap[(j * cblk_w) + i];
2158                 OPJ_INT32 mag = abs(val);
2159                 if (mag >= thresh) {
2160                     mag >>= tccp->roishift;
2161                     datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
2162                 }
2163             }
2164         }
2165     }
2166     if (tccp->qmfbid == 1) {
2167         OPJ_INT32* OPJ_RESTRICT tiledp = &tilec->data[(OPJ_UINT32)y * tile_w +
2168                                                        (OPJ_UINT32)x];
2169         for (j = 0; j < cblk_h; ++j) {
2170             i = 0;
2171             for (; i < (cblk_w & ~(OPJ_UINT32)3U); i += 4U) {
2172                 OPJ_INT32 tmp0 = datap[(j * cblk_w) + i + 0U];
2173                 OPJ_INT32 tmp1 = datap[(j * cblk_w) + i + 1U];
2174                 OPJ_INT32 tmp2 = datap[(j * cblk_w) + i + 2U];
2175                 OPJ_INT32 tmp3 = datap[(j * cblk_w) + i + 3U];
2176                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 0U] = tmp0 / 2;
2177                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 1U] = tmp1 / 2;
2178                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 2U] = tmp2 / 2;
2179                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i + 3U] = tmp3 / 2;
2180             }
2181             for (; i < cblk_w; ++i) {
2182                 OPJ_INT32 tmp = datap[(j * cblk_w) + i];
2183                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp / 2;
2184             }
2185         }
2186     } else {        /* if (tccp->qmfbid == 0) */
2187         OPJ_FLOAT32* OPJ_RESTRICT tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_UINT32)y *
2188                                                          tile_w + (OPJ_UINT32)x];
2189         for (j = 0; j < cblk_h; ++j) {
2190             OPJ_FLOAT32* OPJ_RESTRICT tiledp2 = tiledp;
2191             for (i = 0; i < cblk_w; ++i) {
2192                 OPJ_FLOAT32 tmp = (OPJ_FLOAT32) * datap * band->stepsize;
2193                 *tiledp2 = tmp;
2194                 datap++;
2195                 tiledp2++;
2196             }
2197             tiledp += tile_w;
2198         }
2199     }
2200
2201     opj_free(job);
2202 }
2203
2204
2205 void opj_t1_decode_cblks(opj_thread_pool_t* tp,
2206                          volatile OPJ_BOOL* pret,
2207                          opj_tcd_tilecomp_t* tilec,
2208                          opj_tccp_t* tccp
2209                         )
2210 {
2211     OPJ_UINT32 resno, bandno, precno, cblkno;
2212
2213     for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
2214         opj_tcd_resolution_t* res = &tilec->resolutions[resno];
2215
2216         for (bandno = 0; bandno < res->numbands; ++bandno) {
2217             opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
2218
2219             for (precno = 0; precno < res->pw * res->ph; ++precno) {
2220                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
2221
2222                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
2223                     opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
2224                     opj_t1_cblk_decode_processing_job_t* job;
2225
2226                     job = (opj_t1_cblk_decode_processing_job_t*) opj_calloc(1,
2227                             sizeof(opj_t1_cblk_decode_processing_job_t));
2228                     if (!job) {
2229                         *pret = OPJ_FALSE;
2230                         return;
2231                     }
2232                     job->resno = resno;
2233                     job->cblk = cblk;
2234                     job->band = band;
2235                     job->tilec = tilec;
2236                     job->tccp = tccp;
2237                     job->pret = pret;
2238                     opj_thread_pool_submit_job(tp, opj_t1_clbl_decode_processor, job);
2239                     if (!(*pret)) {
2240                         return;
2241                     }
2242                 } /* cblkno */
2243             } /* precno */
2244         } /* bandno */
2245     } /* resno */
2246
2247     return;
2248 }
2249
2250
2251 static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
2252                                    opj_tcd_cblk_dec_t* cblk,
2253                                    OPJ_UINT32 orient,
2254                                    OPJ_UINT32 roishift,
2255                                    OPJ_UINT32 cblksty)
2256 {
2257     opj_raw_t *raw = t1->raw;   /* RAW component */
2258     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
2259
2260     OPJ_INT32 bpno_plus_one;
2261     OPJ_UINT32 passtype;
2262     OPJ_UINT32 segno, passno;
2263     OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
2264
2265     mqc->lut_ctxno_zc_orient = lut_ctxno_zc + orient * 256;
2266
2267     if (!opj_t1_allocate_buffers(
2268                 t1,
2269                 (OPJ_UINT32)(cblk->x1 - cblk->x0),
2270                 (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
2271         return OPJ_FALSE;
2272     }
2273
2274     bpno_plus_one = (OPJ_INT32)(roishift + cblk->numbps);
2275     passtype = 2;
2276
2277     opj_mqc_resetstates(mqc);
2278     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2279     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2280     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2281
2282     for (segno = 0; segno < cblk->real_num_segs; ++segno) {
2283         opj_tcd_seg_t *seg = &cblk->segs[segno];
2284
2285         /* BYPASS mode */
2286         type = ((bpno_plus_one <= ((OPJ_INT32)(cblk->numbps)) - 4) && (passtype < 2) &&
2287                 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2288         /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
2289         if (seg->data == 00) {
2290             continue;
2291         }
2292         if (type == T1_TYPE_RAW) {
2293             opj_raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
2294         } else {
2295             if (OPJ_FALSE == opj_mqc_init_dec(mqc, (*seg->data) + seg->dataindex,
2296                                               seg->len)) {
2297                 return OPJ_FALSE;
2298             }
2299         }
2300
2301         if (t1->w == 64 && t1->h == 64) {
2302             for (passno = 0; (passno < seg->real_num_passes) &&
2303                     (bpno_plus_one >= 1); ++passno) {
2304                 switch (passtype) {
2305                 case 0:
2306                     if (type == T1_TYPE_RAW) {
2307                         opj_t1_dec_sigpass_raw(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2308                     } else {
2309                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2310                             opj_t1_dec_sigpass_mqc_vsc(t1, bpno_plus_one);
2311                         } else {
2312                             opj_t1_dec_sigpass_mqc_64x64(t1, bpno_plus_one);
2313                         }
2314                     }
2315                     break;
2316                 case 1:
2317                     if (type == T1_TYPE_RAW) {
2318                         opj_t1_dec_refpass_raw(t1, bpno_plus_one);
2319                     } else {
2320                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2321                             opj_t1_dec_refpass_mqc_vsc(t1, bpno_plus_one);
2322                         } else {
2323                             opj_t1_dec_refpass_mqc_64x64(t1, bpno_plus_one);
2324                         }
2325                     }
2326                     break;
2327                 case 2:
2328                     opj_t1_dec_clnpass_64x64(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2329                     break;
2330                 }
2331
2332                 if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
2333                     opj_mqc_resetstates(mqc);
2334                     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2335                     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2336                     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2337                 }
2338                 if (++passtype == 3) {
2339                     passtype = 0;
2340                     bpno_plus_one--;
2341                 }
2342             }
2343         } else {
2344             for (passno = 0; (passno < seg->real_num_passes) &&
2345                     (bpno_plus_one >= 1); ++passno) {
2346                 switch (passtype) {
2347                 case 0:
2348                     if (type == T1_TYPE_RAW) {
2349                         opj_t1_dec_sigpass_raw(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2350                     } else {
2351                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2352                             opj_t1_dec_sigpass_mqc_vsc(t1, bpno_plus_one);
2353                         } else {
2354                             opj_t1_dec_sigpass_mqc_generic(t1, bpno_plus_one);
2355                         }
2356                     }
2357                     break;
2358                 case 1:
2359                     if (type == T1_TYPE_RAW) {
2360                         opj_t1_dec_refpass_raw(t1, bpno_plus_one);
2361                     } else {
2362                         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
2363                             opj_t1_dec_refpass_mqc_vsc(t1, bpno_plus_one);
2364                         } else {
2365                             opj_t1_dec_refpass_mqc_generic(t1, bpno_plus_one);
2366                         }
2367                     }
2368                     break;
2369                 case 2:
2370                     opj_t1_dec_clnpass_generic(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2371                     break;
2372                 }
2373
2374                 if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
2375                     opj_mqc_resetstates(mqc);
2376                     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2377                     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2378                     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2379                 }
2380                 if (++passtype == 3) {
2381                     passtype = 0;
2382                     bpno_plus_one--;
2383                 }
2384             }
2385         }
2386     }
2387     return OPJ_TRUE;
2388 }
2389
2390
2391
2392
2393 OPJ_BOOL opj_t1_encode_cblks(opj_t1_t *t1,
2394                              opj_tcd_tile_t *tile,
2395                              opj_tcp_t *tcp,
2396                              const OPJ_FLOAT64 * mct_norms,
2397                              OPJ_UINT32 mct_numcomps
2398                             )
2399 {
2400     OPJ_UINT32 compno, resno, bandno, precno, cblkno;
2401
2402     tile->distotile = 0;        /* fixed_quality */
2403
2404     for (compno = 0; compno < tile->numcomps; ++compno) {
2405         opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
2406         opj_tccp_t* tccp = &tcp->tccps[compno];
2407         OPJ_UINT32 tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
2408
2409         for (resno = 0; resno < tilec->numresolutions; ++resno) {
2410             opj_tcd_resolution_t *res = &tilec->resolutions[resno];
2411
2412             for (bandno = 0; bandno < res->numbands; ++bandno) {
2413                 opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
2414                 OPJ_INT32 bandconst = 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192));
2415
2416                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
2417                     opj_tcd_precinct_t *prc = &band->precincts[precno];
2418
2419                     for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
2420                         opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
2421                         OPJ_INT32* OPJ_RESTRICT tiledp;
2422                         OPJ_UINT32 cblk_w;
2423                         OPJ_UINT32 cblk_h;
2424                         OPJ_UINT32 i, j, tileIndex = 0, tileLineAdvance;
2425
2426                         OPJ_INT32 x = cblk->x0 - band->x0;
2427                         OPJ_INT32 y = cblk->y0 - band->y0;
2428                         if (band->bandno & 1) {
2429                             opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
2430                             x += pres->x1 - pres->x0;
2431                         }
2432                         if (band->bandno & 2) {
2433                             opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
2434                             y += pres->y1 - pres->y0;
2435                         }
2436
2437                         if (!opj_t1_allocate_buffers(
2438                                     t1,
2439                                     (OPJ_UINT32)(cblk->x1 - cblk->x0),
2440                                     (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
2441                             return OPJ_FALSE;
2442                         }
2443
2444                         cblk_w = t1->w;
2445                         cblk_h = t1->h;
2446                         tileLineAdvance = tile_w - cblk_w;
2447
2448                         tiledp = &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
2449                         t1->data = tiledp;
2450                         t1->data_stride = tile_w;
2451                         if (tccp->qmfbid == 1) {
2452                             for (j = 0; j < cblk_h; ++j) {
2453                                 for (i = 0; i < cblk_w; ++i) {
2454                                     tiledp[tileIndex] *= (1 << T1_NMSEDEC_FRACBITS);
2455                                     tileIndex++;
2456                                 }
2457                                 tileIndex += tileLineAdvance;
2458                             }
2459                         } else {        /* if (tccp->qmfbid == 0) */
2460                             for (j = 0; j < cblk_h; ++j) {
2461                                 for (i = 0; i < cblk_w; ++i) {
2462                                     OPJ_INT32 tmp = tiledp[tileIndex];
2463                                     tiledp[tileIndex] =
2464                                         opj_int_fix_mul_t1(
2465                                             tmp,
2466                                             bandconst);
2467                                     tileIndex++;
2468                                 }
2469                                 tileIndex += tileLineAdvance;
2470                             }
2471                         }
2472
2473                         opj_t1_encode_cblk(
2474                             t1,
2475                             cblk,
2476                             band->bandno,
2477                             compno,
2478                             tilec->numresolutions - 1 - resno,
2479                             tccp->qmfbid,
2480                             band->stepsize,
2481                             tccp->cblksty,
2482                             tile->numcomps,
2483                             tile,
2484                             mct_norms,
2485                             mct_numcomps);
2486
2487                     } /* cblkno */
2488                 } /* precno */
2489             } /* bandno */
2490         } /* resno  */
2491     } /* compno  */
2492     return OPJ_TRUE;
2493 }
2494
2495 /** mod fixed_quality */
2496 static void opj_t1_encode_cblk(opj_t1_t *t1,
2497                                opj_tcd_cblk_enc_t* cblk,
2498                                OPJ_UINT32 orient,
2499                                OPJ_UINT32 compno,
2500                                OPJ_UINT32 level,
2501                                OPJ_UINT32 qmfbid,
2502                                OPJ_FLOAT64 stepsize,
2503                                OPJ_UINT32 cblksty,
2504                                OPJ_UINT32 numcomps,
2505                                opj_tcd_tile_t * tile,
2506                                const OPJ_FLOAT64 * mct_norms,
2507                                OPJ_UINT32 mct_numcomps)
2508 {
2509     OPJ_FLOAT64 cumwmsedec = 0.0;
2510
2511     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
2512
2513     OPJ_UINT32 passno;
2514     OPJ_INT32 bpno;
2515     OPJ_UINT32 passtype;
2516     OPJ_INT32 nmsedec = 0;
2517     OPJ_INT32 max;
2518     OPJ_UINT32 i, j;
2519     OPJ_BYTE type = T1_TYPE_MQ;
2520     OPJ_FLOAT64 tempwmsedec;
2521
2522     mqc->lut_ctxno_zc_orient = lut_ctxno_zc + orient * 256;
2523
2524     max = 0;
2525     for (i = 0; i < t1->w; ++i) {
2526         for (j = 0; j < t1->h; ++j) {
2527             OPJ_INT32 tmp = abs(t1->data[i + j * t1->data_stride]);
2528             max = opj_int_max(max, tmp);
2529         }
2530     }
2531
2532     cblk->numbps = max ? (OPJ_UINT32)((opj_int_floorlog2(max) + 1) -
2533                                       T1_NMSEDEC_FRACBITS) : 0;
2534
2535     bpno = (OPJ_INT32)(cblk->numbps - 1);
2536     passtype = 2;
2537
2538     opj_mqc_resetstates(mqc);
2539     opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2540     opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2541     opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2542     opj_mqc_init_enc(mqc, cblk->data);
2543
2544     for (passno = 0; bpno >= 0; ++passno) {
2545         opj_tcd_pass_t *pass = &cblk->passes[passno];
2546         OPJ_UINT32 correction = 3;
2547         type = ((bpno < ((OPJ_INT32)(cblk->numbps) - 4)) && (passtype < 2) &&
2548                 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2549
2550         switch (passtype) {
2551         case 0:
2552             opj_t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
2553             break;
2554         case 1:
2555             opj_t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
2556             break;
2557         case 2:
2558             opj_t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
2559             /* code switch SEGMARK (i.e. SEGSYM) */
2560             if (cblksty & J2K_CCP_CBLKSTY_SEGSYM) {
2561                 opj_mqc_segmark_enc(mqc);
2562             }
2563             break;
2564         }
2565
2566         /* fixed_quality */
2567         tempwmsedec = opj_t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid,
2568                                         stepsize, numcomps, mct_norms, mct_numcomps) ;
2569         cumwmsedec += tempwmsedec;
2570         tile->distotile += tempwmsedec;
2571
2572         /* Code switch "RESTART" (i.e. TERMALL) */
2573         if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) &&
2574                 (bpno - 1 < 0))) {
2575             if (type == T1_TYPE_RAW) {
2576                 opj_mqc_flush(mqc);
2577                 correction = 1;
2578                 /* correction = mqc_bypass_flush_enc(); */
2579             } else {            /* correction = mqc_restart_enc(); */
2580                 opj_mqc_flush(mqc);
2581                 correction = 1;
2582             }
2583             pass->term = 1;
2584         } else {
2585             if (((bpno < ((OPJ_INT32)(cblk->numbps) - 4) && (passtype > 0))
2586                     || ((bpno == ((OPJ_INT32)cblk->numbps - 4)) && (passtype == 2))) &&
2587                     (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
2588                 if (type == T1_TYPE_RAW) {
2589                     opj_mqc_flush(mqc);
2590                     correction = 1;
2591                     /* correction = mqc_bypass_flush_enc(); */
2592                 } else {        /* correction = mqc_restart_enc(); */
2593                     opj_mqc_flush(mqc);
2594                     correction = 1;
2595                 }
2596                 pass->term = 1;
2597             } else {
2598                 pass->term = 0;
2599             }
2600         }
2601
2602         if (++passtype == 3) {
2603             passtype = 0;
2604             bpno--;
2605         }
2606
2607         if (pass->term && bpno > 0) {
2608             type = ((bpno < ((OPJ_INT32)(cblk->numbps) - 4)) && (passtype < 2) &&
2609                     (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2610             if (type == T1_TYPE_RAW) {
2611                 opj_mqc_bypass_init_enc(mqc);
2612             } else {
2613                 opj_mqc_restart_init_enc(mqc);
2614             }
2615         }
2616
2617         pass->distortiondec = cumwmsedec;
2618         pass->rate = opj_mqc_numbytes(mqc) + correction;    /* FIXME */
2619
2620         /* Code-switch "RESET" */
2621         if (cblksty & J2K_CCP_CBLKSTY_RESET) {
2622             opj_mqc_reset_enc(mqc);
2623         }
2624     }
2625
2626     /* Code switch "ERTERM" (i.e. PTERM) */
2627     if (cblksty & J2K_CCP_CBLKSTY_PTERM) {
2628         opj_mqc_erterm_enc(mqc);
2629     } else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY)) {
2630         opj_mqc_flush(mqc);
2631     }
2632
2633     cblk->totalpasses = passno;
2634
2635     for (passno = 0; passno < cblk->totalpasses; passno++) {
2636         opj_tcd_pass_t *pass = &cblk->passes[passno];
2637         if (pass->rate > opj_mqc_numbytes(mqc)) {
2638             pass->rate = opj_mqc_numbytes(mqc);
2639         }
2640         /*Preventing generation of FF as last data byte of a pass*/
2641         if ((pass->rate > 1) && (cblk->data[pass->rate - 1] == 0xFF)) {
2642             pass->rate--;
2643         }
2644         pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
2645     }
2646 }