libopenjpeg/t1.c

   1 /*
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3  * Copyright (c) 2002-2007, Professor Benoit Macq
   4  * Copyright (c) 2001-2003, David Janssens
   5  * Copyright (c) 2002-2003, Yannick Verschueren
   6  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
   7  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   8  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "opj_includes.h"
  34 #include "t1_luts.h"
  35
  36 /** @defgroup T1 T1 - Implementation of the tier-1 coding */
  37 /*@{*/
  38
  39 /** @name Local static functions */
  40 /*@{*/
  41
  42 static INLINE char t1_getctxno_zc(int f, int orient);
  43 static char t1_getctxno_sc(int f);
  44 static INLINE int t1_getctxno_mag(int f);
  45 static char t1_getspb(int f);
  46 static short t1_getnmsedec_sig(int x, int bitpos);
  47 static short t1_getnmsedec_ref(int x, int bitpos);
  48 static void t1_updateflags(flag_t *flagsp, int s, int stride);
  49 /**
  50 Encode significant pass
  51 */
  52 static void t1_enc_sigpass_step(
  53                 opj_t1_t *t1,
  54                 flag_t *flagsp,
  55                 int *datap,
  56                 int orient,
  57                 int bpno,
  58                 int one,
  59                 int *nmsedec,
  60                 char type,
  61                 int vsc);
  62
  63 /**
  64 Decode significant pass
  65 */
  66 static void t1_dec_sigpass_step(
  67                 opj_t1_t *t1,
  68                 flag_t *flagsp,
  69                 OPJ_INT32 *datap,
  70                 OPJ_UINT32 orient,
  71                 OPJ_INT32 oneplushalf,
  72                 OPJ_BYTE type,
  73                 OPJ_UINT32 vsc);
  74 /**
  75 Decode significant pass
  76 */
  77 static INLINE void t1_dec_sigpass_step_raw(
  78                 opj_t1_t *t1,
  79                 flag_t *flagsp,
  80                 int *datap,
  81                 int orient,
  82                 int oneplushalf,
  83                 int vsc);
  84 static INLINE void t1_dec_sigpass_step_mqc(
  85                 opj_t1_t *t1,
  86                 flag_t *flagsp,
  87                 int *datap,
  88                 int orient,
  89                 int oneplushalf);
  90 static INLINE void t1_dec_sigpass_step_mqc_vsc(
  91                 opj_t1_t *t1,
  92                 flag_t *flagsp,
  93                 int *datap,
  94                 int orient,
  95                 int oneplushalf,
  96                 int vsc);
  97 /**
  98 Encode significant pass
  99 */
 100 static void t1_enc_sigpass(
 101                 opj_t1_t *t1,
 102                 int bpno,
 103                 int orient,
 104                 int *nmsedec,
 105                 char type,
 106                 int cblksty);
 107
 108 /**
 109 Decode significant pass
 110 */
 111 static void t1_dec_sigpass(
 112                 opj_t1_t *t1,
 113                 OPJ_INT32 bpno,
 114                 OPJ_UINT32 orient,
 115                 OPJ_BYTE type,
 116                 OPJ_UINT32 cblksty);
 117
 118 /**
 119 Decode significant pass
 120 */
 121 static void t1_dec_sigpass_raw(
 122                 opj_t1_t *t1,
 123                 int bpno,
 124                 int orient,
 125                 int cblksty);
 126 static void t1_dec_sigpass_mqc(
 127                 opj_t1_t *t1,
 128                 int bpno,
 129                 int orient);
 130 static void t1_dec_sigpass_mqc_vsc(
 131                 opj_t1_t *t1,
 132                 int bpno,
 133                 int orient);
 134 /**
 135 Encode refinement pass
 136 */
 137 static void t1_enc_refpass_step(
 138                 opj_t1_t *t1,
 139                 flag_t *flagsp,
 140                 int *datap,
 141                 int bpno,
 142                 int one,
 143                 int *nmsedec,
 144                 char type,
 145                 int vsc);
 146 /**
 147 Decode refinement pass
 148 */
 149 static INLINE void t1_dec_refpass_step_raw(
 150                 opj_t1_t *t1,
 151                 flag_t *flagsp,
 152                 int *datap,
 153                 int poshalf,
 154                 int neghalf,
 155                 int vsc);
 156 static INLINE void t1_dec_refpass_step_mqc(
 157                 opj_t1_t *t1,
 158                 flag_t *flagsp,
 159                 int *datap,
 160                 int poshalf,
 161                 int neghalf);
 162 static INLINE void t1_dec_refpass_step_mqc_vsc(
 163                 opj_t1_t *t1,
 164                 flag_t *flagsp,
 165                 int *datap,
 166                 int poshalf,
 167                 int neghalf,
 168                 int vsc);
 169
 170 /**
 171 Encode refinement pass
 172 */
 173 static void t1_enc_refpass(
 174                 opj_t1_t *t1,
 175                 int bpno,
 176                 int *nmsedec,
 177                 char type,
 178                 int cblksty);
 179
 180 /**
 181 Decode refinement pass
 182 */
 183 static void t1_dec_refpass(
 184                 opj_t1_t *t1,
 185                 OPJ_INT32 bpno,
 186                 OPJ_BYTE type,
 187                 OPJ_UINT32 cblksty);
 188
 189 /**
 190 Decode refinement pass
 191 */
 192 static void t1_dec_refpass_step(
 193                 opj_t1_t *t1,
 194                 flag_t *flagsp,
 195                 OPJ_INT32 *datap,
 196                 OPJ_INT32 poshalf,
 197                 OPJ_INT32 neghalf,
 198                 OPJ_BYTE type,
 199                 OPJ_UINT32 vsc);
 200
 201 /**
 202 Decode refinement pass
 203 */
 204 static void t1_dec_refpass_raw(
 205                 opj_t1_t *t1,
 206                 int bpno,
 207                 int cblksty);
 208 static void t1_dec_refpass_mqc(
 209                 opj_t1_t *t1,
 210                 int bpno);
 211 static void t1_dec_refpass_mqc_vsc(
 212                 opj_t1_t *t1,
 213                 int bpno);
 214 /**
 215 Encode clean-up pass
 216 */
 217 static void t1_enc_clnpass_step(
 218                 opj_t1_t *t1,
 219                 flag_t *flagsp,
 220                 int *datap,
 221                 int orient,
 222                 int bpno,
 223                 int one,
 224                 int *nmsedec,
 225                 int partial,
 226                 int vsc);
 227 /**
 228 Decode clean-up pass
 229 */
 230 static void t1_dec_clnpass_step_partial(
 231                 opj_t1_t *t1,
 232                 flag_t *flagsp,
 233                 int *datap,
 234                 int orient,
 235                 int oneplushalf);
 236 static void t1_dec_clnpass_step(
 237                 opj_t1_t *t1,
 238                 flag_t *flagsp,
 239                 int *datap,
 240                 int orient,
 241                 int oneplushalf);
 242 static void t1_dec_clnpass_step_vsc(
 243                 opj_t1_t *t1,
 244                 flag_t *flagsp,
 245                 int *datap,
 246                 int orient,
 247                 int oneplushalf,
 248                 int partial,
 249                 int vsc);
 250 /**
 251 Encode clean-up pass
 252 */
 253 static void t1_enc_clnpass(
 254                 opj_t1_t *t1,
 255                 int bpno,
 256                 int orient,
 257                 int *nmsedec,
 258                 int cblksty);
 259 /**
 260 Decode clean-up pass
 261 */
 262 static void t1_dec_clnpass(
 263                 opj_t1_t *t1,
 264                 int bpno,
 265                 int orient,
 266                 int cblksty);
 267 static double t1_getwmsedec(
 268                 int nmsedec,
 269                 int compno,
 270                 int level,
 271                 int orient,
 272                 int bpno,
 273                 int qmfbid,
 274                 double stepsize,
 275                 int numcomps,
 276                 int mct);
 277
 278 static OPJ_FLOAT64 t1_getwmsedec_v2(
 279                 OPJ_INT32 nmsedec,
 280                 OPJ_UINT32 compno,
 281                 OPJ_UINT32 level,
 282                 OPJ_UINT32 orient,
 283                 OPJ_INT32 bpno,
 284                 OPJ_UINT32 qmfbid,
 285                 OPJ_FLOAT64 stepsize,
 286                 OPJ_UINT32 numcomps,
 287                 const OPJ_FLOAT64 * mct_norms);
 288 /**
 289 Encode 1 code-block
 290 @param t1 T1 handle
 291 @param cblk Code-block coding parameters
 292 @param orient
 293 @param compno Component number
 294 @param level
 295 @param qmfbid
 296 @param stepsize
 297 @param cblksty Code-block style
 298 @param numcomps
 299 @param mct
 300 @param tile
 301 */
 302 static void t1_encode_cblk(
 303                 opj_t1_t *t1,
 304                 opj_tcd_cblk_enc_t* cblk,
 305                 int orient,
 306                 int compno,
 307                 int level,
 308                 int qmfbid,
 309                 double stepsize,
 310                 int cblksty,
 311                 int numcomps,
 312                 int mct,
 313                 opj_tcd_tile_t * tile);
 314
 315 static void t1_encode_cblk_v2(
 316                 opj_t1_t *t1,
 317                 opj_tcd_cblk_enc_v2_t* cblk,
 318                 OPJ_UINT32 orient,
 319                 OPJ_UINT32 compno,
 320                 OPJ_UINT32 level,
 321                 OPJ_UINT32 qmfbid,
 322                 OPJ_FLOAT64 stepsize,
 323                 OPJ_UINT32 cblksty,
 324                 OPJ_UINT32 numcomps,
 325                 opj_tcd_tile_v2_t * tile,
 326                 const OPJ_FLOAT64 * mct_norms);
 327
 328 /**
 329 Decode 1 code-block
 330 @param t1 T1 handle
 331 @param cblk Code-block coding parameters
 332 @param orient
 333 @param roishift Region of interest shifting value
 334 @param cblksty Code-block style
 335 */
 336 static void t1_decode_cblk(
 337                 opj_t1_t *t1,
 338                 opj_tcd_cblk_dec_t* cblk,
 339                 int orient,
 340                 int roishift,
 341                 int cblksty);
 342
 343 /**
 344 Decode 1 code-block
 345 @param t1 T1 handle
 346 @param cblk Code-block coding parameters
 347 @param orient
 348 @param roishift Region of interest shifting value
 349 @param cblksty Code-block style
 350 */
 351 static void t1_decode_cblk_v2(
 352                 opj_t1_t *t1,
 353                 opj_tcd_cblk_dec_v2_t* cblk,
 354                 OPJ_UINT32 orient,
 355                 OPJ_UINT32 roishift,
 356                 OPJ_UINT32 cblksty);
 357
 358 /*@}*/
 359
 360 /*@}*/
 361
 362 /* ----------------------------------------------------------------------- */
 363
 364 static char t1_getctxno_zc(int f, int orient) {
 365         return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
 366 }
 367
 368 static char t1_getctxno_sc(int f) {
 369         return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 370 }
 371
 372 static int t1_getctxno_mag(int f) {
 373         int tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
 374         int tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
 375         return (tmp2);
 376 }
 377
 378 static char t1_getspb(int f) {
 379         return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 380 }
 381
 382 static short t1_getnmsedec_sig(int x, int bitpos) {
 383         if (bitpos > T1_NMSEDEC_FRACBITS) {
 384                 return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 385         }
 386
 387         return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 388 }
 389
 390 static short t1_getnmsedec_ref(int x, int bitpos) {
 391         if (bitpos > T1_NMSEDEC_FRACBITS) {
 392                 return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 393         }
 394
 395     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 396 }
 397
 398 static void t1_updateflags(flag_t *flagsp, int s, int stride) {
 399         flag_t *np = flagsp - stride;
 400         flag_t *sp = flagsp + stride;
 401
 402         static const flag_t mod[] = {
 403                 T1_SIG_S, T1_SIG_S|T1_SGN_S,
 404                 T1_SIG_E, T1_SIG_E|T1_SGN_E,
 405                 T1_SIG_W, T1_SIG_W|T1_SGN_W,
 406                 T1_SIG_N, T1_SIG_N|T1_SGN_N
 407         };
 408
 409         np[-1] |= T1_SIG_SE;
 410         np[0]  |= mod[s];
 411         np[1]  |= T1_SIG_SW;
 412
 413         flagsp[-1] |= mod[s+2];
 414         flagsp[0]  |= T1_SIG;
 415         flagsp[1]  |= mod[s+4];
 416
 417         sp[-1] |= T1_SIG_NE;
 418         sp[0]  |= mod[s+6];
 419         sp[1]  |= T1_SIG_NW;
 420 }
 421
 422 static void t1_enc_sigpass_step(
 423                 opj_t1_t *t1,
 424                 flag_t *flagsp,
 425                 int *datap,
 426                 int orient,
 427                 int bpno,
 428                 int one,
 429                 int *nmsedec,
 430                 char type,
 431                 int vsc)
 432 {
 433         int v, flag;
 434
 435         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 436
 437         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 438         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 439                 v = int_abs(*datap) & one ? 1 : 0;
 440                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));       /* ESSAI */
 441                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 442                         mqc_bypass_enc(mqc, v);
 443                 } else {
 444                         mqc_encode(mqc, v);
 445                 }
 446                 if (v) {
 447                         v = *datap < 0 ? 1 : 0;
 448                         *nmsedec +=     t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 449                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));       /* ESSAI */
 450                         if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 451                                 mqc_bypass_enc(mqc, v);
 452                         } else {
 453                                 mqc_encode(mqc, v ^ t1_getspb(flag));
 454                         }
 455                         t1_updateflags(flagsp, v, t1->flags_stride);
 456                 }
 457                 *flagsp |= T1_VISIT;
 458         }
 459 }
 460
 461 static INLINE void t1_dec_sigpass_step_raw(
 462                 opj_t1_t *t1,
 463                 flag_t *flagsp,
 464                 int *datap,
 465                 int orient,
 466                 int oneplushalf,
 467                 int vsc)
 468 {
 469         int v, flag;
 470         opj_raw_t *raw = t1->raw;       /* RAW component */
 471
 472         OPJ_ARG_NOT_USED(orient);
 473
 474         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 475         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 476                         if (raw_decode(raw)) {
 477                                 v = raw_decode(raw);    /* ESSAI */
 478                                 *datap = v ? -oneplushalf : oneplushalf;
 479                                 t1_updateflags(flagsp, v, t1->flags_stride);
 480                         }
 481                 *flagsp |= T1_VISIT;
 482         }
 483 }                               /* VSC and  BYPASS by Antonin */
 484
 485 static INLINE void t1_dec_sigpass_step_mqc(
 486                 opj_t1_t *t1,
 487                 flag_t *flagsp,
 488                 int *datap,
 489                 int orient,
 490                 int oneplushalf)
 491 {
 492         int v, flag;
 493
 494         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 495
 496         flag = *flagsp;
 497         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 498                         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 499                         if (mqc_decode(mqc)) {
 500                                 mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 501                                 v = mqc_decode(mqc) ^ t1_getspb(flag);
 502                                 *datap = v ? -oneplushalf : oneplushalf;
 503                                 t1_updateflags(flagsp, v, t1->flags_stride);
 504                         }
 505                 *flagsp |= T1_VISIT;
 506         }
 507 }                               /* VSC and  BYPASS by Antonin */
 508
 509 static INLINE void t1_dec_sigpass_step_mqc_vsc(
 510                 opj_t1_t *t1,
 511                 flag_t *flagsp,
 512                 int *datap,
 513                 int orient,
 514                 int oneplushalf,
 515                 int vsc)
 516 {
 517         int v, flag;
 518
 519         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 520
 521         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 522         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 523                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 524                 if (mqc_decode(mqc)) {
 525                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 526                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 527                         *datap = v ? -oneplushalf : oneplushalf;
 528                         t1_updateflags(flagsp, v, t1->flags_stride);
 529                 }
 530                 *flagsp |= T1_VISIT;
 531         }
 532 }                               /* VSC and  BYPASS by Antonin */
 533
 534 static void t1_enc_sigpass(
 535                 opj_t1_t *t1,
 536                 int bpno,
 537                 int orient,
 538                 int *nmsedec,
 539                 char type,
 540                 int cblksty)
 541 {
 542         int i, j, k, one, vsc;
 543         *nmsedec = 0;
 544         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 545         for (k = 0; k < t1->h; k += 4) {
 546                 for (i = 0; i < t1->w; ++i) {
 547                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 548                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 549                                 t1_enc_sigpass_step(
 550                                                 t1,
 551                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 552                                                 &t1->data[(j * t1->w) + i],
 553                                                 orient,
 554                                                 bpno,
 555                                                 one,
 556                                                 nmsedec,
 557                                                 type,
 558                                                 vsc);
 559                         }
 560                 }
 561         }
 562 }
 563
 564 static void t1_dec_sigpass_raw(
 565                 opj_t1_t *t1,
 566                 int bpno,
 567                 int orient,
 568                 int cblksty)
 569 {
 570         int i, j, k, one, half, oneplushalf, vsc;
 571         one = 1 << bpno;
 572         half = one >> 1;
 573         oneplushalf = one | half;
 574         for (k = 0; k < t1->h; k += 4) {
 575                 for (i = 0; i < t1->w; ++i) {
 576                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 577                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 578                                 t1_dec_sigpass_step_raw(
 579                                                 t1,
 580                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 581                                                 &t1->data[(j * t1->w) + i],
 582                                                 orient,
 583                                                 oneplushalf,
 584                                                 vsc);
 585                         }
 586                 }
 587         }
 588 }                               /* VSC and  BYPASS by Antonin */
 589
 590 static void t1_dec_sigpass_mqc(
 591                 opj_t1_t *t1,
 592                 int bpno,
 593                 int orient)
 594 {
 595         int i, j, k, one, half, oneplushalf;
 596         int *data1 = t1->data;
 597         flag_t *flags1 = &t1->flags[1];
 598         one = 1 << bpno;
 599         half = one >> 1;
 600         oneplushalf = one | half;
 601         for (k = 0; k < (t1->h & ~3); k += 4) {
 602                 for (i = 0; i < t1->w; ++i) {
 603                         int *data2 = data1 + i;
 604                         flag_t *flags2 = flags1 + i;
 605                         flags2 += t1->flags_stride;
 606                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 607                         data2 += t1->w;
 608                         flags2 += t1->flags_stride;
 609                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 610                         data2 += t1->w;
 611                         flags2 += t1->flags_stride;
 612                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 613                         data2 += t1->w;
 614                         flags2 += t1->flags_stride;
 615                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 616                         data2 += t1->w;
 617                 }
 618                 data1 += t1->w << 2;
 619                 flags1 += t1->flags_stride << 2;
 620         }
 621         for (i = 0; i < t1->w; ++i) {
 622                 int *data2 = data1 + i;
 623                 flag_t *flags2 = flags1 + i;
 624                 for (j = k; j < t1->h; ++j) {
 625                         flags2 += t1->flags_stride;
 626                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 627                         data2 += t1->w;
 628                 }
 629         }
 630 }                               /* VSC and  BYPASS by Antonin */
 631
 632 static void t1_dec_sigpass_mqc_vsc(
 633                 opj_t1_t *t1,
 634                 int bpno,
 635                 int orient)
 636 {
 637         int i, j, k, one, half, oneplushalf, vsc;
 638         one = 1 << bpno;
 639         half = one >> 1;
 640         oneplushalf = one | half;
 641         for (k = 0; k < t1->h; k += 4) {
 642                 for (i = 0; i < t1->w; ++i) {
 643                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 644                                 vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
 645                                 t1_dec_sigpass_step_mqc_vsc(
 646                                                 t1,
 647                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 648                                                 &t1->data[(j * t1->w) + i],
 649                                                 orient,
 650                                                 oneplushalf,
 651                                                 vsc);
 652                         }
 653                 }
 654         }
 655 }                               /* VSC and  BYPASS by Antonin */
 656
 657 static void t1_enc_refpass_step(
 658                 opj_t1_t *t1,
 659                 flag_t *flagsp,
 660                 int *datap,
 661                 int bpno,
 662                 int one,
 663                 int *nmsedec,
 664                 char type,
 665                 int vsc)
 666 {
 667         int v, flag;
 668
 669         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 670
 671         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 672         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 673                 *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 674                 v = int_abs(*datap) & one ? 1 : 0;
 675                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 676                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 677                         mqc_bypass_enc(mqc, v);
 678                 } else {
 679                         mqc_encode(mqc, v);
 680                 }
 681                 *flagsp |= T1_REFINE;
 682         }
 683 }
 684
 685 static INLINE void t1_dec_refpass_step_raw(
 686                 opj_t1_t *t1,
 687                 flag_t *flagsp,
 688                 int *datap,
 689                 int poshalf,
 690                 int neghalf,
 691                 int vsc)
 692 {
 693         int v, t, flag;
 694
 695         opj_raw_t *raw = t1->raw;       /* RAW component */
 696
 697         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 698         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 699                         v = raw_decode(raw);
 700                 t = v ? poshalf : neghalf;
 701                 *datap += *datap < 0 ? -t : t;
 702                 *flagsp |= T1_REFINE;
 703         }
 704 }                               /* VSC and  BYPASS by Antonin  */
 705
 706 static INLINE void t1_dec_refpass_step_mqc(
 707                 opj_t1_t *t1,
 708                 flag_t *flagsp,
 709                 int *datap,
 710                 int poshalf,
 711                 int neghalf)
 712 {
 713         int v, t, flag;
 714
 715         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 716
 717         flag = *flagsp;
 718         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 719                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 720                         v = mqc_decode(mqc);
 721                 t = v ? poshalf : neghalf;
 722                 *datap += *datap < 0 ? -t : t;
 723                 *flagsp |= T1_REFINE;
 724                 }
 725 }                               /* VSC and  BYPASS by Antonin  */
 726
 727 static INLINE void t1_dec_refpass_step_mqc_vsc(
 728                 opj_t1_t *t1,
 729                 flag_t *flagsp,
 730                 int *datap,
 731                 int poshalf,
 732                 int neghalf,
 733                 int vsc)
 734 {
 735         int v, t, flag;
 736
 737         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 738
 739         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 740         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 741                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 742                 v = mqc_decode(mqc);
 743                 t = v ? poshalf : neghalf;
 744                 *datap += *datap < 0 ? -t : t;
 745                 *flagsp |= T1_REFINE;
 746         }
 747 }                               /* VSC and  BYPASS by Antonin  */
 748
 749 static void t1_enc_refpass(
 750                 opj_t1_t *t1,
 751                 int bpno,
 752                 int *nmsedec,
 753                 char type,
 754                 int cblksty)
 755 {
 756         int i, j, k, one, vsc;
 757         *nmsedec = 0;
 758         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 759         for (k = 0; k < t1->h; k += 4) {
 760                 for (i = 0; i < t1->w; ++i) {
 761                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 762                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 763                                 t1_enc_refpass_step(
 764                                                 t1,
 765                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 766                                                 &t1->data[(j * t1->w) + i],
 767                                                 bpno,
 768                                                 one,
 769                                                 nmsedec,
 770                                                 type,
 771                                                 vsc);
 772                         }
 773                 }
 774         }
 775 }
 776
 777 static void t1_dec_refpass_raw(
 778                 opj_t1_t *t1,
 779                 int bpno,
 780                 int cblksty)
 781 {
 782         int i, j, k, one, poshalf, neghalf;
 783         int vsc;
 784         one = 1 << bpno;
 785         poshalf = one >> 1;
 786         neghalf = bpno > 0 ? -poshalf : -1;
 787         for (k = 0; k < t1->h; k += 4) {
 788                 for (i = 0; i < t1->w; ++i) {
 789                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 790                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 791                                 t1_dec_refpass_step_raw(
 792                                                 t1,
 793                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 794                                                 &t1->data[(j * t1->w) + i],
 795                                                 poshalf,
 796                                                 neghalf,
 797                                                 vsc);
 798                         }
 799                 }
 800         }
 801 }                               /* VSC and  BYPASS by Antonin */
 802
 803 static void t1_dec_refpass_mqc(
 804                 opj_t1_t *t1,
 805                 int bpno)
 806 {
 807         int i, j, k, one, poshalf, neghalf;
 808         int *data1 = t1->data;
 809         flag_t *flags1 = &t1->flags[1];
 810         one = 1 << bpno;
 811         poshalf = one >> 1;
 812         neghalf = bpno > 0 ? -poshalf : -1;
 813         for (k = 0; k < (t1->h & ~3); k += 4) {
 814                 for (i = 0; i < t1->w; ++i) {
 815                         int *data2 = data1 + i;
 816                         flag_t *flags2 = flags1 + i;
 817                         flags2 += t1->flags_stride;
 818                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 819                         data2 += t1->w;
 820                         flags2 += t1->flags_stride;
 821                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 822                         data2 += t1->w;
 823                         flags2 += t1->flags_stride;
 824                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 825                         data2 += t1->w;
 826                         flags2 += t1->flags_stride;
 827                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 828                         data2 += t1->w;
 829                 }
 830                 data1 += t1->w << 2;
 831                 flags1 += t1->flags_stride << 2;
 832         }
 833         for (i = 0; i < t1->w; ++i) {
 834                 int *data2 = data1 + i;
 835                 flag_t *flags2 = flags1 + i;
 836                 for (j = k; j < t1->h; ++j) {
 837                         flags2 += t1->flags_stride;
 838                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 839                         data2 += t1->w;
 840                 }
 841         }
 842 }                               /* VSC and  BYPASS by Antonin */
 843
 844 static void t1_dec_refpass_mqc_vsc(
 845                 opj_t1_t *t1,
 846                 int bpno)
 847 {
 848         int i, j, k, one, poshalf, neghalf;
 849         int vsc;
 850         one = 1 << bpno;
 851         poshalf = one >> 1;
 852         neghalf = bpno > 0 ? -poshalf : -1;
 853         for (k = 0; k < t1->h; k += 4) {
 854                 for (i = 0; i < t1->w; ++i) {
 855                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 856                                 vsc = ((j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 857                                 t1_dec_refpass_step_mqc_vsc(
 858                                                 t1,
 859                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 860                                                 &t1->data[(j * t1->w) + i],
 861                                                 poshalf,
 862                                                 neghalf,
 863                                                 vsc);
 864                         }
 865                 }
 866         }
 867 }                               /* VSC and  BYPASS by Antonin */
 868
 869 static void t1_enc_clnpass_step(
 870                 opj_t1_t *t1,
 871                 flag_t *flagsp,
 872                 int *datap,
 873                 int orient,
 874                 int bpno,
 875                 int one,
 876                 int *nmsedec,
 877                 int partial,
 878                 int vsc)
 879 {
 880         int v, flag;
 881
 882         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 883
 884         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 885         if (partial) {
 886                 goto LABEL_PARTIAL;
 887         }
 888         if (!(*flagsp & (T1_SIG | T1_VISIT))) {
 889                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 890                 v = int_abs(*datap) & one ? 1 : 0;
 891                 mqc_encode(mqc, v);
 892                 if (v) {
 893 LABEL_PARTIAL:
 894                         *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 895                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 896                         v = *datap < 0 ? 1 : 0;
 897                         mqc_encode(mqc, v ^ t1_getspb(flag));
 898                         t1_updateflags(flagsp, v, t1->flags_stride);
 899                 }
 900         }
 901         *flagsp &= ~T1_VISIT;
 902 }
 903
 904 static void t1_dec_clnpass_step_partial(
 905                 opj_t1_t *t1,
 906                 flag_t *flagsp,
 907                 int *datap,
 908                 int orient,
 909                 int oneplushalf)
 910 {
 911         int v, flag;
 912         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 913
 914         OPJ_ARG_NOT_USED(orient);
 915
 916         flag = *flagsp;
 917         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 918         v = mqc_decode(mqc) ^ t1_getspb(flag);
 919         *datap = v ? -oneplushalf : oneplushalf;
 920         t1_updateflags(flagsp, v, t1->flags_stride);
 921         *flagsp &= ~T1_VISIT;
 922 }                               /* VSC and  BYPASS by Antonin */
 923
 924 static void t1_dec_clnpass_step(
 925                 opj_t1_t *t1,
 926                 flag_t *flagsp,
 927                 int *datap,
 928                 int orient,
 929                 int oneplushalf)
 930 {
 931         int v, flag;
 932
 933         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 934
 935         flag = *flagsp;
 936         if (!(flag & (T1_SIG | T1_VISIT))) {
 937                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 938                 if (mqc_decode(mqc)) {
 939                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 940                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 941                         *datap = v ? -oneplushalf : oneplushalf;
 942                         t1_updateflags(flagsp, v, t1->flags_stride);
 943                 }
 944         }
 945         *flagsp &= ~T1_VISIT;
 946 }                               /* VSC and  BYPASS by Antonin */
 947
 948 static void t1_dec_clnpass_step_vsc(
 949                 opj_t1_t *t1,
 950                 flag_t *flagsp,
 951                 int *datap,
 952                 int orient,
 953                 int oneplushalf,
 954                 int partial,
 955                 int vsc)
 956 {
 957         int v, flag;
 958
 959         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 960
 961         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 962         if (partial) {
 963                 goto LABEL_PARTIAL;
 964         }
 965         if (!(flag & (T1_SIG | T1_VISIT))) {
 966                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 967                 if (mqc_decode(mqc)) {
 968 LABEL_PARTIAL:
 969                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 970                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 971                         *datap = v ? -oneplushalf : oneplushalf;
 972                         t1_updateflags(flagsp, v, t1->flags_stride);
 973                 }
 974         }
 975         *flagsp &= ~T1_VISIT;
 976 }
 977
 978 static void t1_enc_clnpass(
 979                 opj_t1_t *t1,
 980                 int bpno,
 981                 int orient,
 982                 int *nmsedec,
 983                 int cblksty)
 984 {
 985         int i, j, k, one, agg, runlen, vsc;
 986
 987         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 988
 989         *nmsedec = 0;
 990         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 991         for (k = 0; k < t1->h; k += 4) {
 992                 for (i = 0; i < t1->w; ++i) {
 993                         if (k + 3 < t1->h) {
 994                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
 995                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 996                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 997                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 998                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
 999                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1000                                 } else {
1001                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1002                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1003                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1004                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1005                                 }
1006                         } else {
1007                                 agg = 0;
1008                         }
1009                         if (agg) {
1010                                 for (runlen = 0; runlen < 4; ++runlen) {
1011                                         if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
1012                                                 break;
1013                                 }
1014                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
1015                                 mqc_encode(mqc, runlen != 4);
1016                                 if (runlen == 4) {
1017                                         continue;
1018                                 }
1019                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
1020                                 mqc_encode(mqc, runlen >> 1);
1021                                 mqc_encode(mqc, runlen & 1);
1022                         } else {
1023                                 runlen = 0;
1024                         }
1025                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1026                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
1027                                 t1_enc_clnpass_step(
1028                                                 t1,
1029                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
1030                                                 &t1->data[(j * t1->w) + i],
1031                                                 orient,
1032                                                 bpno,
1033                                                 one,
1034                                                 nmsedec,
1035                                                 agg && (j == k + runlen),
1036                                                 vsc);
1037                         }
1038                 }
1039         }
1040 }
1041
1042 static void t1_dec_clnpass(
1043                 opj_t1_t *t1,
1044                 int bpno,
1045                 int orient,
1046                 int cblksty)
1047 {
1048         int i, j, k, one, half, oneplushalf, agg, runlen, vsc;
1049         int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
1050
1051         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1052
1053         one = 1 << bpno;
1054         half = one >> 1;
1055         oneplushalf = one | half;
1056         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1057         for (k = 0; k < t1->h; k += 4) {
1058                 for (i = 0; i < t1->w; ++i) {
1059                         if (k + 3 < t1->h) {
1060                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1061                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1062                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1063                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
1064                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1065                                 } else {
1066                                 agg = 0;
1067                         }
1068                         if (agg) {
1069                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
1070                                 if (!mqc_decode(mqc)) {
1071                                         continue;
1072                                 }
1073                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
1074                                 runlen = mqc_decode(mqc);
1075                                 runlen = (runlen << 1) | mqc_decode(mqc);
1076                         } else {
1077                                 runlen = 0;
1078                         }
1079                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1080                                         vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
1081                                         t1_dec_clnpass_step_vsc(
1082                                                 t1,
1083                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
1084                                                 &t1->data[(j * t1->w) + i],
1085                                                 orient,
1086                                                 oneplushalf,
1087                                                 agg && (j == k + runlen),
1088                                                 vsc);
1089                         }
1090                 }
1091         }
1092         } else {
1093                 int *data1 = t1->data;
1094                 flag_t *flags1 = &t1->flags[1];
1095                 for (k = 0; k < (t1->h & ~3); k += 4) {
1096                         for (i = 0; i < t1->w; ++i) {
1097                                 int *data2 = data1 + i;
1098                                 flag_t *flags2 = flags1 + i;
1099                                 agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1100                                         || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1101                                         || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1102                                         || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1103                                 if (agg) {
1104                                         mqc_setcurctx(mqc, T1_CTXNO_AGG);
1105                                         if (!mqc_decode(mqc)) {
1106                                                 continue;
1107                                         }
1108                                         mqc_setcurctx(mqc, T1_CTXNO_UNI);
1109                                         runlen = mqc_decode(mqc);
1110                                         runlen = (runlen << 1) | mqc_decode(mqc);
1111                                         flags2 += runlen * t1->flags_stride;
1112                                         data2 += runlen * t1->w;
1113                                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1114                                                 flags2 += t1->flags_stride;
1115                                                 if (agg && (j == k + runlen)) {
1116                                                         t1_dec_clnpass_step_partial(t1, flags2, data2, orient, oneplushalf);
1117                                                 } else {
1118                                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1119                                                 }
1120                                                 data2 += t1->w;
1121                                         }
1122                                 } else {
1123                                         flags2 += t1->flags_stride;
1124                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1125                                         data2 += t1->w;
1126                                         flags2 += t1->flags_stride;
1127                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1128                                         data2 += t1->w;
1129                                         flags2 += t1->flags_stride;
1130                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1131                                         data2 += t1->w;
1132                                         flags2 += t1->flags_stride;
1133                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1134                                         data2 += t1->w;
1135                                 }
1136                         }
1137                         data1 += t1->w << 2;
1138                         flags1 += t1->flags_stride << 2;
1139                 }
1140                 for (i = 0; i < t1->w; ++i) {
1141                         int *data2 = data1 + i;
1142                         flag_t *flags2 = flags1 + i;
1143                         for (j = k; j < t1->h; ++j) {
1144                                 flags2 += t1->flags_stride;
1145                                 t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1146                                 data2 += t1->w;
1147                         }
1148                 }
1149         }
1150
1151         if (segsym) {
1152                 int v = 0;
1153                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
1154                 v = mqc_decode(mqc);
1155                 v = (v << 1) | mqc_decode(mqc);
1156                 v = (v << 1) | mqc_decode(mqc);
1157                 v = (v << 1) | mqc_decode(mqc);
1158                 /*
1159                 if (v!=0xa) {
1160                         opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
1161                 }
1162                 */
1163         }
1164 }                               /* VSC and  BYPASS by Antonin */
1165
1166
1167 /** mod fixed_quality */
1168 static double t1_getwmsedec(
1169                 int nmsedec,
1170                 int compno,
1171                 int level,
1172                 int orient,
1173                 int bpno,
1174                 int qmfbid,
1175                 double stepsize,
1176                 int numcomps,
1177                 int mct)
1178 {
1179         double w1, w2, wmsedec;
1180         if (qmfbid == 1) {
1181                 w1 = (mct && numcomps==3) ? mct_getnorm(compno) : 1.0;
1182                 w2 = dwt_getnorm(level, orient);
1183         } else {                        /* if (qmfbid == 0) */
1184                 w1 = (mct && numcomps==3) ? mct_getnorm_real(compno) : 1.0;
1185                 w2 = dwt_getnorm_real(level, orient);
1186         }
1187         wmsedec = w1 * w2 * stepsize * (1 << bpno);
1188         wmsedec *= wmsedec * nmsedec / 8192.0;
1189
1190         return wmsedec;
1191 }
1192
1193 /** mod fixed_quality */
1194 static OPJ_FLOAT64 t1_getwmsedec_v2(
1195                 OPJ_INT32 nmsedec,
1196                 OPJ_UINT32 compno,
1197                 OPJ_UINT32 level,
1198                 OPJ_UINT32 orient,
1199                 OPJ_INT32 bpno,
1200                 OPJ_UINT32 qmfbid,
1201                 OPJ_FLOAT64 stepsize,
1202                 OPJ_UINT32 numcomps,
1203                 const OPJ_FLOAT64 * mct_norms)
1204 {
1205         OPJ_FLOAT64 w1 = 1, w2, wmsedec;
1206
1207         if (mct_norms) {
1208                 w1 = mct_norms[compno];
1209         }
1210
1211         if (qmfbid == 1) {
1212                 w2 = dwt_getnorm(level, orient);
1213         } else {        /* if (qmfbid == 0) */
1214                 w2 = dwt_getnorm_real(level, orient);
1215         }
1216
1217         wmsedec = w1 * w2 * stepsize * (1 << bpno);
1218         wmsedec *= wmsedec * nmsedec / 8192.0;
1219
1220         return wmsedec;
1221 }
1222
1223 static opj_bool allocate_buffers(
1224                 opj_t1_t *t1,
1225                 int w,
1226                 int h)
1227 {
1228         int datasize=w * h;
1229         int flagssize;
1230
1231         if(datasize > t1->datasize){
1232                 opj_aligned_free(t1->data);
1233                 t1->data = (int*) opj_aligned_malloc(datasize * sizeof(int));
1234                 if(!t1->data){
1235                         return OPJ_FALSE;
1236                 }
1237                 t1->datasize=datasize;
1238         }
1239         memset(t1->data,0,datasize * sizeof(int));
1240
1241         t1->flags_stride=w+2;
1242         flagssize=t1->flags_stride * (h+2);
1243
1244         if(flagssize > t1->flagssize){
1245                 opj_aligned_free(t1->flags);
1246                 t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t));
1247                 if(!t1->flags){
1248                         return OPJ_FALSE;
1249                 }
1250                 t1->flagssize=flagssize;
1251         }
1252         memset(t1->flags,0,flagssize * sizeof(flag_t));
1253
1254         t1->w=w;
1255         t1->h=h;
1256
1257         return OPJ_TRUE;
1258 }
1259
1260 /** mod fixed_quality */
1261 static void t1_encode_cblk(
1262                 opj_t1_t *t1,
1263                 opj_tcd_cblk_enc_t* cblk,
1264                 int orient,
1265                 int compno,
1266                 int level,
1267                 int qmfbid,
1268                 double stepsize,
1269                 int cblksty,
1270                 int numcomps,
1271                 int mct,
1272                 opj_tcd_tile_t * tile)
1273 {
1274         double cumwmsedec = 0.0;
1275
1276         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1277
1278         int passno, bpno, passtype;
1279         int nmsedec = 0;
1280         int i, max;
1281         char type = T1_TYPE_MQ;
1282         double tempwmsedec;
1283
1284         max = 0;
1285         for (i = 0; i < t1->w * t1->h; ++i) {
1286                 int tmp = abs(t1->data[i]);
1287                 max = int_max(max, tmp);
1288         }
1289
1290         cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
1291
1292         bpno = cblk->numbps - 1;
1293         passtype = 2;
1294
1295         mqc_resetstates(mqc);
1296         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1297         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1298         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1299         mqc_init_enc(mqc, cblk->data);
1300
1301         for (passno = 0; bpno >= 0; ++passno) {
1302                 opj_tcd_pass_t *pass = &cblk->passes[passno];
1303                 int correction = 3;
1304                 type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1305
1306                 switch (passtype) {
1307                         case 0:
1308                                 t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
1309                                 break;
1310                         case 1:
1311                                 t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
1312                                 break;
1313                         case 2:
1314                                 t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
1315                                 /* code switch SEGMARK (i.e. SEGSYM) */
1316                                 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
1317                                         mqc_segmark_enc(mqc);
1318                                 break;
1319                 }
1320
1321                 /* fixed_quality */
1322                 tempwmsedec = t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps, mct);
1323                 cumwmsedec += tempwmsedec;
1324                 tile->distotile += tempwmsedec;
1325
1326                 /* Code switch "RESTART" (i.e. TERMALL) */
1327                 if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
1328                         if (type == T1_TYPE_RAW) {
1329                                 mqc_flush(mqc);
1330                                 correction = 1;
1331                                 /* correction = mqc_bypass_flush_enc(); */
1332                         } else {                        /* correction = mqc_restart_enc(); */
1333                                 mqc_flush(mqc);
1334                                 correction = 1;
1335                         }
1336                         pass->term = 1;
1337                 } else {
1338                         if (((bpno < (cblk->numbps - 4) && (passtype > 0))
1339                                 || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
1340                                 if (type == T1_TYPE_RAW) {
1341                                         mqc_flush(mqc);
1342                                         correction = 1;
1343                                         /* correction = mqc_bypass_flush_enc(); */
1344                                 } else {                /* correction = mqc_restart_enc(); */
1345                                         mqc_flush(mqc);
1346                                         correction = 1;
1347                                 }
1348                                 pass->term = 1;
1349                         } else {
1350                                 pass->term = 0;
1351                         }
1352                 }
1353
1354                 if (++passtype == 3) {
1355                         passtype = 0;
1356                         bpno--;
1357                 }
1358
1359                 if (pass->term && bpno > 0) {
1360                         type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1361                         if (type == T1_TYPE_RAW)
1362                                 mqc_bypass_init_enc(mqc);
1363                         else
1364                                 mqc_restart_init_enc(mqc);
1365                 }
1366
1367                 pass->distortiondec = cumwmsedec;
1368                 pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */
1369
1370                 /* Code-switch "RESET" */
1371                 if (cblksty & J2K_CCP_CBLKSTY_RESET)
1372                         mqc_reset_enc(mqc);
1373         }
1374
1375         /* Code switch "ERTERM" (i.e. PTERM) */
1376         if (cblksty & J2K_CCP_CBLKSTY_PTERM)
1377                 mqc_erterm_enc(mqc);
1378         else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
1379                 mqc_flush(mqc);
1380
1381         cblk->totalpasses = passno;
1382
1383         for (passno = 0; passno<cblk->totalpasses; passno++) {
1384                 opj_tcd_pass_t *pass = &cblk->passes[passno];
1385                 if (pass->rate > mqc_numbytes(mqc))
1386                         pass->rate = mqc_numbytes(mqc);
1387                 /*Preventing generation of FF as last data byte of a pass*/
1388                 if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
1389                         pass->rate--;
1390                 }
1391                 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
1392         }
1393 }
1394
1395 static void t1_decode_cblk(
1396                 opj_t1_t *t1,
1397                 opj_tcd_cblk_dec_t* cblk,
1398                 int orient,
1399                 int roishift,
1400                 int cblksty)
1401 {
1402         opj_raw_t *raw = t1->raw;       /* RAW component */
1403         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1404
1405         int bpno, passtype;
1406         int segno, passno;
1407         char type = T1_TYPE_MQ; /* BYPASS mode */
1408
1409         if(!allocate_buffers(
1410                                 t1,
1411                                 cblk->x1 - cblk->x0,
1412                                 cblk->y1 - cblk->y0))
1413         {
1414                 return;
1415         }
1416
1417         bpno = roishift + cblk->numbps - 1;
1418         passtype = 2;
1419
1420         mqc_resetstates(mqc);
1421         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1422         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1423         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1424
1425         for (segno = 0; segno < cblk->numsegs; ++segno) {
1426                 opj_tcd_seg_t *seg = &cblk->segs[segno];
1427
1428                 /* BYPASS mode */
1429                 type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1430                 /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
1431                 if(seg->data == NULL){
1432                         continue;
1433                 }
1434                 if (type == T1_TYPE_RAW) {
1435                         raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
1436                 } else {
1437                         mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);
1438                 }
1439
1440                 for (passno = 0; passno < seg->numpasses; ++passno) {
1441                         switch (passtype) {
1442                                 case 0:
1443                                         if (type == T1_TYPE_RAW) {
1444                                                 t1_dec_sigpass_raw(t1, bpno+1, orient, cblksty);
1445                                         } else {
1446                                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1447                                                         t1_dec_sigpass_mqc_vsc(t1, bpno+1, orient);
1448                                                 } else {
1449                                                         t1_dec_sigpass_mqc(t1, bpno+1, orient);
1450                                                 }
1451                                         }
1452                                         break;
1453                                 case 1:
1454                                         if (type == T1_TYPE_RAW) {
1455                                                 t1_dec_refpass_raw(t1, bpno+1, cblksty);
1456                                         } else {
1457                                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1458                                                         t1_dec_refpass_mqc_vsc(t1, bpno+1);
1459                                                 } else {
1460                                                         t1_dec_refpass_mqc(t1, bpno+1);
1461                                                 }
1462                                         }
1463                                         break;
1464                                 case 2:
1465                                         t1_dec_clnpass(t1, bpno+1, orient, cblksty);
1466                                         break;
1467                         }
1468
1469                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
1470                                 mqc_resetstates(mqc);
1471                                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1472                                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1473                                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1474                         }
1475                         if (++passtype == 3) {
1476                                 passtype = 0;
1477                                 bpno--;
1478                         }
1479                 }
1480         }
1481 }
1482
1483 /* ----------------------------------------------------------------------- */
1484
1485 opj_t1_t* t1_create(opj_common_ptr cinfo) {
1486         opj_t1_t *t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
1487         if(!t1)
1488                 return NULL;
1489
1490         t1->cinfo = cinfo;
1491         /* create MQC and RAW handles */
1492         t1->mqc = mqc_create();
1493         t1->raw = raw_create();
1494
1495         t1->data=NULL;
1496         t1->flags=NULL;
1497         t1->datasize=0;
1498         t1->flagssize=0;
1499
1500         return t1;
1501 }
1502
1503 void t1_destroy(opj_t1_t *t1) {
1504         if(t1) {
1505                 /* destroy MQC and RAW handles */
1506                 mqc_destroy(t1->mqc);
1507                 raw_destroy(t1->raw);
1508                 opj_aligned_free(t1->data);
1509                 opj_aligned_free(t1->flags);
1510                 opj_free(t1);
1511         }
1512 }
1513
1514 void t1_encode_cblks(
1515                 opj_t1_t *t1,
1516                 opj_tcd_tile_t *tile,
1517                 opj_tcp_t *tcp)
1518 {
1519         int compno, resno, bandno, precno, cblkno;
1520
1521         tile->distotile = 0;            /* fixed_quality */
1522
1523         for (compno = 0; compno < tile->numcomps; ++compno) {
1524                 opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
1525                 opj_tccp_t* tccp = &tcp->tccps[compno];
1526                 int tile_w = tilec->x1 - tilec->x0;
1527
1528                 for (resno = 0; resno < tilec->numresolutions; ++resno) {
1529                         opj_tcd_resolution_t *res = &tilec->resolutions[resno];
1530
1531                         for (bandno = 0; bandno < res->numbands; ++bandno) {
1532                                 opj_tcd_band_t* restrict band = &res->bands[bandno];
1533         int bandconst = 8192 * 8192 / ((int) floor(band->stepsize * 8192));
1534
1535                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1536                                         opj_tcd_precinct_t *prc = &band->precincts[precno];
1537
1538                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1539                                                 opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
1540                                                 int* restrict datap;
1541                                                 int* restrict tiledp;
1542                                                 int cblk_w;
1543                                                 int cblk_h;
1544                                                 int i, j;
1545
1546                                                 int x = cblk->x0 - band->x0;
1547                                                 int y = cblk->y0 - band->y0;
1548                                                 if (band->bandno & 1) {
1549                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1550                                                         x += pres->x1 - pres->x0;
1551                                                 }
1552                                                 if (band->bandno & 2) {
1553                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1554                                                         y += pres->y1 - pres->y0;
1555                                                 }
1556
1557                                                 if(!allocate_buffers(
1558                                                                         t1,
1559                                                                         cblk->x1 - cblk->x0,
1560                                                                         cblk->y1 - cblk->y0))
1561                                                 {
1562                                                         return;
1563                                                 }
1564
1565                                                 datap=t1->data;
1566                                                 cblk_w = t1->w;
1567                                                 cblk_h = t1->h;
1568
1569                                                 tiledp=&tilec->data[(y * tile_w) + x];
1570                                                 if (tccp->qmfbid == 1) {
1571                                                         for (j = 0; j < cblk_h; ++j) {
1572                                                                 for (i = 0; i < cblk_w; ++i) {
1573                                                                         int tmp = tiledp[(j * tile_w) + i];
1574                                                                         datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;
1575                                                                 }
1576                                                         }
1577                                                 } else {                /* if (tccp->qmfbid == 0) */
1578                                                         for (j = 0; j < cblk_h; ++j) {
1579                                                                 for (i = 0; i < cblk_w; ++i) {
1580                                                                         int tmp = tiledp[(j * tile_w) + i];
1581                                                                         datap[(j * cblk_w) + i] =
1582                                                                                 fix_mul(
1583                                                                                 tmp,
1584                                                                                 bandconst) >> (11 - T1_NMSEDEC_FRACBITS);
1585                                                                 }
1586                                                         }
1587                                                 }
1588
1589                                                 t1_encode_cblk(
1590                                                                 t1,
1591                                                                 cblk,
1592                                                                 band->bandno,
1593                                                                 compno,
1594                                                                 tilec->numresolutions - 1 - resno,
1595                                                                 tccp->qmfbid,
1596                                                                 band->stepsize,
1597                                                                 tccp->cblksty,
1598                                                                 tile->numcomps,
1599                                                                 tcp->mct,
1600                                                                 tile);
1601
1602                                         } /* cblkno */
1603                                 } /* precno */
1604                         } /* bandno */
1605                 } /* resno  */
1606         } /* compno  */
1607 }
1608
1609 void t1_decode_cblks(
1610                 opj_t1_t* t1,
1611                 opj_tcd_tilecomp_t* tilec,
1612                 opj_tccp_t* tccp)
1613 {
1614         int resno, bandno, precno, cblkno;
1615
1616         int tile_w = tilec->x1 - tilec->x0;
1617
1618         for (resno = 0; resno < tilec->numresolutions; ++resno) {
1619                 opj_tcd_resolution_t* res = &tilec->resolutions[resno];
1620
1621                 for (bandno = 0; bandno < res->numbands; ++bandno) {
1622                         opj_tcd_band_t* restrict band = &res->bands[bandno];
1623
1624                         for (precno = 0; precno < res->pw * res->ph; ++precno) {
1625                                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
1626
1627                                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1628                                         opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
1629                                         int* restrict datap;
1630                                         int cblk_w, cblk_h;
1631                                         int x, y;
1632                                         int i, j;
1633
1634                                         t1_decode_cblk(
1635                                                         t1,
1636                                                         cblk,
1637                                                         band->bandno,
1638                                                         tccp->roishift,
1639                                                         tccp->cblksty);
1640
1641                                         x = cblk->x0 - band->x0;
1642                                         y = cblk->y0 - band->y0;
1643                                         if (band->bandno & 1) {
1644                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1645                                                 x += pres->x1 - pres->x0;
1646                                         }
1647                                         if (band->bandno & 2) {
1648                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1649                                                 y += pres->y1 - pres->y0;
1650                                         }
1651
1652                                         datap=t1->data;
1653                                         cblk_w = t1->w;
1654                                         cblk_h = t1->h;
1655
1656                                         if (tccp->roishift) {
1657                                                 int thresh = 1 << tccp->roishift;
1658                                                 for (j = 0; j < cblk_h; ++j) {
1659                                                         for (i = 0; i < cblk_w; ++i) {
1660                                                                 int val = datap[(j * cblk_w) + i];
1661                                                                 int mag = abs(val);
1662                                                                 if (mag >= thresh) {
1663                                                                         mag >>= tccp->roishift;
1664                                                                         datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1665                                                                 }
1666                                                         }
1667                                                 }
1668                                         }
1669
1670                                         if (tccp->qmfbid == 1) {
1671                                                 int* restrict tiledp = &tilec->data[(y * tile_w) + x];
1672                                                 for (j = 0; j < cblk_h; ++j) {
1673                                                         for (i = 0; i < cblk_w; ++i) {
1674                                                                 int tmp = datap[(j * cblk_w) + i];
1675                                                                 ((int*)tiledp)[(j * tile_w) + i] = tmp / 2;
1676                                                         }
1677                                                 }
1678                                         } else {                /* if (tccp->qmfbid == 0) */
1679                                                 float* restrict tiledp = (float*) &tilec->data[(y * tile_w) + x];
1680                                                 for (j = 0; j < cblk_h; ++j) {
1681                                                         float* restrict tiledp2 = tiledp;
1682                                                         for (i = 0; i < cblk_w; ++i) {
1683                                                                 float tmp = *datap * band->stepsize;
1684                                                                 *tiledp2 = tmp;
1685                                                                 datap++;
1686                                                                 tiledp2++;
1687                                                         }
1688                                                         tiledp += tile_w;
1689                                                 }
1690                                         }
1691                                         opj_free(cblk->data);
1692                                         opj_free(cblk->segs);
1693                                 } /* cblkno */
1694                                 opj_free(precinct->cblks.dec);
1695                         } /* precno */
1696                 } /* bandno */
1697         } /* resno */
1698 }
1699
1700
1701
1702 /* ----------------------------------------------------------------------- */
1703 /**
1704  * Creates a new Tier 1 handle
1705  * and initializes the look-up tables of the Tier-1 coder/decoder
1706  * @return a new T1 handle if successful, returns NULL otherwise
1707 */
1708 opj_t1_t* t1_create_v2()
1709 {
1710         opj_t1_t *l_t1 = 00;
1711
1712         l_t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
1713         if (!l_t1) {
1714                 return 00;
1715         }
1716         memset(l_t1,0,sizeof(opj_t1_t));
1717
1718         /* create MQC and RAW handles */
1719         l_t1->mqc = mqc_create();
1720         if (! l_t1->mqc) {
1721                 t1_destroy(l_t1);
1722                 return 00;
1723         }
1724
1725         l_t1->raw = raw_create();
1726         if (! l_t1->raw) {
1727                 t1_destroy(l_t1);
1728                 return 00;
1729         }
1730
1731         return l_t1;
1732 }
1733
1734
1735 /**
1736  * Destroys a previously created T1 handle
1737  *
1738  * @param p_t1 Tier 1 handle to destroy
1739 */
1740 void t1_destroy_v2(opj_t1_t *p_t1)
1741 {
1742         if
1743                 (! p_t1)
1744         {
1745                 return;
1746         }
1747
1748         /* destroy MQC and RAW handles */
1749         mqc_destroy(p_t1->mqc);
1750         p_t1->mqc = 00;
1751         raw_destroy(p_t1->raw);
1752         p_t1->raw = 00;
1753         if
1754                 (p_t1->data)
1755         {
1756                 opj_aligned_free(p_t1->data);
1757                 p_t1->data = 00;
1758         }
1759         if
1760                 (p_t1->flags)
1761         {
1762                 opj_aligned_free(p_t1->flags);
1763                 p_t1->flags = 00;
1764         }
1765         opj_free(p_t1);
1766 }
1767
1768 void t1_decode_cblks_v2(
1769                 opj_t1_t* t1,
1770                 opj_tcd_tilecomp_v2_t* tilec,
1771                 opj_tccp_t* tccp)
1772 {
1773         OPJ_UINT32 resno, bandno, precno, cblkno;
1774         OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;
1775
1776         for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
1777                 opj_tcd_resolution_v2_t* res = &tilec->resolutions[resno];
1778
1779                 for (bandno = 0; bandno < res->numbands; ++bandno) {
1780                         opj_tcd_band_v2_t* restrict band = &res->bands[bandno];
1781
1782                         for (precno = 0; precno < res->pw * res->ph; ++precno) {
1783                                 opj_tcd_precinct_v2_t* precinct = &band->precincts[precno];
1784
1785                                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1786                                         opj_tcd_cblk_dec_v2_t* cblk = &precinct->cblks.dec[cblkno];
1787                                         OPJ_INT32* restrict datap;
1788                                         void* restrict tiledp;
1789                                         OPJ_UINT32 cblk_w, cblk_h;
1790                                         OPJ_INT32 x, y;
1791                                         OPJ_UINT32 i, j;
1792
1793                                         t1_decode_cblk_v2(
1794                                                         t1,
1795                                                         cblk,
1796                                                         band->bandno,
1797                                                         tccp->roishift,
1798                                                         tccp->cblksty);
1799
1800                                         x = cblk->x0 - band->x0;
1801                                         y = cblk->y0 - band->y0;
1802                                         if (band->bandno & 1) {
1803                                                 opj_tcd_resolution_v2_t* pres = &tilec->resolutions[resno - 1];
1804                                                 x += pres->x1 - pres->x0;
1805                                         }
1806                                         if (band->bandno & 2) {
1807                                                 opj_tcd_resolution_v2_t* pres = &tilec->resolutions[resno - 1];
1808                                                 y += pres->y1 - pres->y0;
1809                                         }
1810
1811                                         datap=t1->data;
1812                                         cblk_w = t1->w;
1813                                         cblk_h = t1->h;
1814
1815                                         if (tccp->roishift) {
1816                                                 OPJ_INT32 thresh = 1 << tccp->roishift;
1817                                                 for (j = 0; j < cblk_h; ++j) {
1818                                                         for (i = 0; i < cblk_w; ++i) {
1819                                                                 OPJ_INT32 val = datap[(j * cblk_w) + i];
1820                                                                 OPJ_INT32 mag = abs(val);
1821                                                                 if (mag >= thresh) {
1822                                                                         mag >>= tccp->roishift;
1823                                                                         datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1824                                                                 }
1825                                                         }
1826                                                 }
1827                                         }
1828
1829                                         tiledp=(void*)&tilec->data[(y * tile_w) + x];
1830                                         if (tccp->qmfbid == 1) {
1831                                                 for (j = 0; j < cblk_h; ++j) {
1832                                                         for (i = 0; i < cblk_w; ++i) {
1833                                                                 OPJ_INT32 tmp = datap[(j * cblk_w) + i];
1834                                                                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp / 2;
1835                                                         }
1836                                                 }
1837                                         } else {                /* if (tccp->qmfbid == 0) */
1838                                                 for (j = 0; j < cblk_h; ++j) {
1839                                                         for (i = 0; i < cblk_w; ++i) {
1840                                                                 float tmp = datap[(j * cblk_w) + i] * band->stepsize;
1841                                                                 ((float*)tiledp)[(j * tile_w) + i] = tmp;
1842                                                         }
1843                                                 }
1844                                         }
1845                                         //opj_free(cblk->segs);
1846                                         //cblk->segs = 00;
1847                                 } /* cblkno */
1848                         } /* precno */
1849                 } /* bandno */
1850         } /* resno */
1851 }
1852
1853
1854 static void t1_decode_cblk_v2(
1855                 opj_t1_t *t1,
1856                 opj_tcd_cblk_dec_v2_t* cblk,
1857                 OPJ_UINT32 orient,
1858                 OPJ_UINT32 roishift,
1859                 OPJ_UINT32 cblksty)
1860 {
1861         opj_raw_t *raw = t1->raw;       /* RAW component */
1862         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1863
1864         OPJ_INT32 bpno;
1865         OPJ_UINT32 passtype;
1866         OPJ_UINT32 segno, passno;
1867         OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
1868
1869         if(!allocate_buffers(
1870                                 t1,
1871                                 cblk->x1 - cblk->x0,
1872                                 cblk->y1 - cblk->y0))
1873         {
1874                 return;
1875         }
1876
1877         bpno = roishift + cblk->numbps - 1;
1878         passtype = 2;
1879
1880         mqc_resetstates(mqc);
1881         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1882         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1883         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1884
1885         for (segno = 0; segno < cblk->real_num_segs; ++segno) {
1886                 opj_tcd_seg_t *seg = &cblk->segs[segno];
1887
1888                 /* BYPASS mode */
1889                 type = ((bpno <= ((OPJ_INT32) (cblk->numbps) - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1890                 /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
1891                 if(seg->data == 00){
1892                         continue;
1893                 }
1894                 if (type == T1_TYPE_RAW) {
1895                         raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
1896                 } else {
1897                         mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);
1898                 }
1899
1900                 for (passno = 0; passno < seg->real_num_passes; ++passno) {
1901                         switch (passtype) {
1902                                 case 0:
1903                                         t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);
1904                                         break;
1905                                 case 1:
1906                                         t1_dec_refpass(t1, bpno+1, type, cblksty);
1907                                         break;
1908                                 case 2:
1909                                         t1_dec_clnpass(t1, bpno+1, orient, cblksty);
1910                                         break;
1911                         }
1912
1913                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
1914                                 mqc_resetstates(mqc);
1915                                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1916                                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1917                                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1918                         }
1919                         if (++passtype == 3) {
1920                                 passtype = 0;
1921                                 bpno--;
1922                         }
1923                 }
1924         }
1925 }
1926
1927 opj_bool t1_encode_cblks_v2(
1928                 opj_t1_t *t1,
1929                 opj_tcd_tile_v2_t *tile,
1930                 opj_tcp_v2_t *tcp,
1931                 const OPJ_FLOAT64 * mct_norms)
1932 {
1933         OPJ_UINT32 compno, resno, bandno, precno, cblkno;
1934
1935         tile->distotile = 0;            /* fixed_quality */
1936
1937         for (compno = 0; compno < tile->numcomps; ++compno) {
1938                 opj_tcd_tilecomp_v2_t* tilec = &tile->comps[compno];
1939                 opj_tccp_t* tccp = &tcp->tccps[compno];
1940                 OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;
1941
1942                 for (resno = 0; resno < tilec->numresolutions; ++resno) {
1943                         opj_tcd_resolution_v2_t *res = &tilec->resolutions[resno];
1944
1945                         for (bandno = 0; bandno < res->numbands; ++bandno) {
1946                                 opj_tcd_band_v2_t* restrict band = &res->bands[bandno];
1947
1948                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1949                                         opj_tcd_precinct_v2_t *prc = &band->precincts[precno];
1950
1951                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1952                                                 opj_tcd_cblk_enc_v2_t* cblk = &prc->cblks.enc[cblkno];
1953                                                 OPJ_INT32 * restrict datap;
1954                                                 OPJ_INT32* restrict tiledp;
1955                                                 OPJ_UINT32 cblk_w;
1956                                                 OPJ_UINT32 cblk_h;
1957                                                 OPJ_UINT32 i, j;
1958
1959                                                 OPJ_INT32 x = cblk->x0 - band->x0;
1960                                                 OPJ_INT32 y = cblk->y0 - band->y0;
1961                                                 if (band->bandno & 1) {
1962                                                         opj_tcd_resolution_v2_t *pres = &tilec->resolutions[resno - 1];
1963                                                         x += pres->x1 - pres->x0;
1964                                                 }
1965                                                 if (band->bandno & 2) {
1966                                                         opj_tcd_resolution_v2_t *pres = &tilec->resolutions[resno - 1];
1967                                                         y += pres->y1 - pres->y0;
1968                                                 }
1969
1970                                                 if(!allocate_buffers(
1971                                                                         t1,
1972                                                                         cblk->x1 - cblk->x0,
1973                                                                         cblk->y1 - cblk->y0))
1974                                                 {
1975                                                         return OPJ_FALSE;
1976                                                 }
1977
1978                                                 datap=t1->data;
1979                                                 cblk_w = t1->w;
1980                                                 cblk_h = t1->h;
1981
1982                                                 tiledp=&tilec->data[(y * tile_w) + x];
1983                                                 if (tccp->qmfbid == 1) {
1984                                                         for (j = 0; j < cblk_h; ++j) {
1985                                                                 for (i = 0; i < cblk_w; ++i) {
1986                                                                         OPJ_INT32 tmp = tiledp[(j * tile_w) + i];
1987                                                                         datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;
1988                                                                 }
1989                                                         }
1990                                                 } else {                /* if (tccp->qmfbid == 0) */
1991                                                         for (j = 0; j < cblk_h; ++j) {
1992                                                                 for (i = 0; i < cblk_w; ++i) {
1993                                                                         OPJ_INT32 tmp = tiledp[(j * tile_w) + i];
1994                                                                         datap[(j * cblk_w) + i] =
1995                                                                                 fix_mul(
1996                                                                                 tmp,
1997                                                                                 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192))) >> (11 - T1_NMSEDEC_FRACBITS);
1998                                                                 }
1999                                                         }
2000                                                 }
2001
2002                                                 t1_encode_cblk_v2(
2003                                                                 t1,
2004                                                                 cblk,
2005                                                                 band->bandno,
2006                                                                 compno,
2007                                                                 tilec->numresolutions - 1 - resno,
2008                                                                 tccp->qmfbid,
2009                                                                 band->stepsize,
2010                                                                 tccp->cblksty,
2011                                                                 tile->numcomps,
2012                                                                 tile,
2013                                                                 mct_norms);
2014
2015                                         } /* cblkno */
2016                                 } /* precno */
2017                         } /* bandno */
2018                 } /* resno  */
2019         } /* compno  */
2020         return OPJ_TRUE;
2021 }
2022
2023 /** mod fixed_quality */
2024 static void t1_encode_cblk_v2(
2025                 opj_t1_t *t1,
2026                 opj_tcd_cblk_enc_v2_t* cblk,
2027                 OPJ_UINT32 orient,
2028                 OPJ_UINT32 compno,
2029                 OPJ_UINT32 level,
2030                 OPJ_UINT32 qmfbid,
2031                 OPJ_FLOAT64 stepsize,
2032                 OPJ_UINT32 cblksty,
2033                 OPJ_UINT32 numcomps,
2034                 opj_tcd_tile_v2_t * tile,
2035                 const OPJ_FLOAT64 * mct_norms)
2036 {
2037         OPJ_FLOAT64 cumwmsedec = 0.0;
2038
2039         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
2040
2041         OPJ_UINT32 passno;
2042         OPJ_INT32 bpno;
2043         OPJ_UINT32 passtype;
2044         OPJ_INT32 nmsedec = 0;
2045         OPJ_INT32 max;
2046         OPJ_UINT32 i;
2047         OPJ_BYTE type = T1_TYPE_MQ;
2048         OPJ_FLOAT64 tempwmsedec;
2049
2050         max = 0;
2051         for (i = 0; i < t1->w * t1->h; ++i) {
2052                 OPJ_INT32 tmp = abs(t1->data[i]);
2053                 max = int_max(max, tmp);
2054         }
2055
2056         cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
2057
2058         bpno = cblk->numbps - 1;
2059         passtype = 2;
2060
2061         mqc_resetstates(mqc);
2062         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2063         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2064         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2065         mqc_init_enc(mqc, cblk->data);
2066
2067         for (passno = 0; bpno >= 0; ++passno) {
2068                 opj_tcd_pass_v2_t *pass = &cblk->passes[passno];
2069                 OPJ_UINT32 correction = 3;
2070                 type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2071
2072                 switch (passtype) {
2073                         case 0:
2074                                 t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
2075                                 break;
2076                         case 1:
2077                                 t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
2078                                 break;
2079                         case 2:
2080                                 t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
2081                                 /* code switch SEGMARK (i.e. SEGSYM) */
2082                                 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
2083                                         mqc_segmark_enc(mqc);
2084                                 break;
2085                 }
2086
2087                 /* fixed_quality */
2088                 tempwmsedec = t1_getwmsedec_v2(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps,mct_norms) ;
2089                 cumwmsedec += tempwmsedec;
2090                 tile->distotile += tempwmsedec;
2091
2092                 /* Code switch "RESTART" (i.e. TERMALL) */
2093                 if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
2094                         if (type == T1_TYPE_RAW) {
2095                                 mqc_flush(mqc);
2096                                 correction = 1;
2097                                 /* correction = mqc_bypass_flush_enc(); */
2098                         } else {                        /* correction = mqc_restart_enc(); */
2099                                 mqc_flush(mqc);
2100                                 correction = 1;
2101                         }
2102                         pass->term = 1;
2103                 } else {
2104                         if (((bpno < ((OPJ_INT32) (cblk->numbps) - 4) && (passtype > 0))
2105                                 || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
2106                                 if (type == T1_TYPE_RAW) {
2107                                         mqc_flush(mqc);
2108                                         correction = 1;
2109                                         /* correction = mqc_bypass_flush_enc(); */
2110                                 } else {                /* correction = mqc_restart_enc(); */
2111                                         mqc_flush(mqc);
2112                                         correction = 1;
2113                                 }
2114                                 pass->term = 1;
2115                         } else {
2116                                 pass->term = 0;
2117                         }
2118                 }
2119
2120                 if (++passtype == 3) {
2121                         passtype = 0;
2122                         bpno--;
2123                 }
2124
2125                 if (pass->term && bpno > 0) {
2126                         type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2127                         if (type == T1_TYPE_RAW)
2128                                 mqc_bypass_init_enc(mqc);
2129                         else
2130                                 mqc_restart_init_enc(mqc);
2131                 }
2132
2133                 pass->distortiondec = cumwmsedec;
2134                 pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */
2135
2136                 /* Code-switch "RESET" */
2137                 if (cblksty & J2K_CCP_CBLKSTY_RESET)
2138                         mqc_reset_enc(mqc);
2139         }
2140
2141         /* Code switch "ERTERM" (i.e. PTERM) */
2142         if (cblksty & J2K_CCP_CBLKSTY_PTERM)
2143                 mqc_erterm_enc(mqc);
2144         else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
2145                 mqc_flush(mqc);
2146
2147         cblk->totalpasses = passno;
2148
2149         for (passno = 0; passno<cblk->totalpasses; passno++) {
2150                 opj_tcd_pass_v2_t *pass = &cblk->passes[passno];
2151                 if (pass->rate > mqc_numbytes(mqc))
2152                         pass->rate = mqc_numbytes(mqc);
2153                 /*Preventing generation of FF as last data byte of a pass*/
2154                 if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
2155                         pass->rate--;
2156                 }
2157                 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
2158         }
2159 }
2160
2161
2162 static void t1_dec_refpass(
2163                 opj_t1_t *t1,
2164                 OPJ_INT32 bpno,
2165                 OPJ_BYTE type,
2166                 OPJ_UINT32 cblksty)
2167 {
2168         OPJ_UINT32 i, j, k;
2169         OPJ_INT32 one, poshalf, neghalf;
2170         OPJ_UINT32 vsc;
2171         one = 1 << bpno;
2172         poshalf = one >> 1;
2173         neghalf = bpno > 0 ? -poshalf : -1;
2174         for (k = 0; k < t1->h; k += 4) {
2175                 for (i = 0; i < t1->w; ++i) {
2176                         for (j = k; j < k + 4 && j < t1->h; ++j) {
2177                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
2178                                 t1_dec_refpass_step(
2179                                                 t1,
2180                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
2181                                                 &t1->data[(j * t1->w) + i],
2182                                                 poshalf,
2183                                                 neghalf,
2184                                                 type,
2185                                                 vsc);
2186                         }
2187                 }
2188         }
2189 }                               /* VSC and  BYPASS by Antonin */
2190
2191
2192 static void t1_dec_refpass_step(
2193                 opj_t1_t *t1,
2194                 flag_t *flagsp,
2195                 OPJ_INT32 *datap,
2196                 OPJ_INT32 poshalf,
2197                 OPJ_INT32 neghalf,
2198                 OPJ_BYTE type,
2199                 OPJ_UINT32 vsc)
2200 {
2201         OPJ_INT32  t;
2202         OPJ_UINT32 v,flag;
2203
2204         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
2205         opj_raw_t *raw = t1->raw;       /* RAW component */
2206
2207         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
2208         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
2209                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
2210                 if (type == T1_TYPE_RAW) {
2211                         v = raw_decode(raw);
2212                 } else {
2213                         v = mqc_decode(mqc);
2214                 }
2215                 t = v ? poshalf : neghalf;
2216                 *datap += *datap < 0 ? -t : t;
2217                 *flagsp |= T1_REFINE;
2218         }
2219 }                               /* VSC and  BYPASS by Antonin  */
2220
2221 static void t1_dec_sigpass(
2222                 opj_t1_t *t1,
2223                 OPJ_INT32 bpno,
2224                 OPJ_UINT32 orient,
2225                 OPJ_BYTE type,
2226                 OPJ_UINT32 cblksty)
2227 {
2228         OPJ_UINT32 i, j, k, vsc;
2229         OPJ_INT32 one, half, oneplushalf;
2230         one = 1 << bpno;
2231         half = one >> 1;
2232         oneplushalf = one | half;
2233         for (k = 0; k < t1->h; k += 4) {
2234                 for (i = 0; i < t1->w; ++i) {
2235                         for (j = k; j < k + 4 && j < t1->h; ++j) {
2236                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
2237                                 t1_dec_sigpass_step(
2238                                                 t1,
2239                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
2240                                                 &t1->data[(j * t1->w) + i],
2241                                                 orient,
2242                                                 oneplushalf,
2243                                                 type,
2244                                                 vsc);
2245                         }
2246                 }
2247         }
2248 }                               /* VSC and  BYPASS by Antonin */
2249
2250 static void t1_dec_sigpass_step(
2251                 opj_t1_t *t1,
2252                 flag_t *flagsp,
2253                 OPJ_INT32 *datap,
2254                 OPJ_UINT32 orient,
2255                 OPJ_INT32 oneplushalf,
2256                 OPJ_BYTE type,
2257                 OPJ_UINT32 vsc)
2258 {
2259         OPJ_UINT32 v, flag;
2260
2261         opj_raw_t *raw = t1->raw;       /* RAW component */
2262         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
2263
2264         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
2265         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
2266                 if (type == T1_TYPE_RAW) {
2267                         if (raw_decode(raw)) {
2268                                 v = raw_decode(raw);    /* ESSAI */
2269                                 *datap = v ? -oneplushalf : oneplushalf;
2270                                 t1_updateflags(flagsp, v, t1->flags_stride);
2271                         }
2272                 } else {
2273                         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
2274                         if (mqc_decode(mqc)) {
2275                                 mqc_setcurctx(mqc, t1_getctxno_sc(flag));
2276                                 v = mqc_decode(mqc) ^ t1_getspb(flag);
2277                                 *datap = v ? -oneplushalf : oneplushalf;
2278                                 t1_updateflags(flagsp, v, t1->flags_stride);
2279                         }
2280                 }
2281                 *flagsp |= T1_VISIT;
2282         }
2283 }                               /* VSC and  BYPASS by Antonin */
2284