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