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