src/lib/openmj2/t1.c

   1 /*
   2  * The copyright in this software is being made available under the 2-clauses
   3  * BSD License, included below. This software may be subject to other third
   4  * party and contributor rights, including patent rights, and no such rights
   5  * are granted under this license.
   6  *
   7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   8  * Copyright (c) 2002-2014, Professor Benoit Macq
   9  * Copyright (c) 2001-2003, David Janssens
  10  * Copyright (c) 2002-2003, Yannick Verschueren
  11  * Copyright (c) 2003-2007, Francois-Olivier Devaux
  12  * Copyright (c) 2003-2014, Antonin Descampe
  13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  14  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
  15  * All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions
  19  * are met:
  20  * 1. Redistributions of source code must retain the above copyright
  21  *    notice, this list of conditions and the following disclaimer.
  22  * 2. Redistributions in binary form must reproduce the above copyright
  23  *    notice, this list of conditions and the following disclaimer in the
  24  *    documentation and/or other materials provided with the distribution.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  27  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  30  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 #include "opj_includes.h"
  40 #include "t1_luts.h"
  41
  42 /** @defgroup T1 T1 - Implementation of the tier-1 coding */
  43 /*@{*/
  44
  45 /** @name Local static functions */
  46 /*@{*/
  47
  48 static INLINE char t1_getctxno_zc(int f, int orient);
  49 static char t1_getctxno_sc(int f);
  50 static INLINE int t1_getctxno_mag(int f);
  51 static char t1_getspb(int f);
  52 static short t1_getnmsedec_sig(int x, int bitpos);
  53 static short t1_getnmsedec_ref(int x, int bitpos);
  54 static void t1_updateflags(flag_t *flagsp, int s, int stride);
  55 /**
  56 Encode significant pass
  57 */
  58 static void t1_enc_sigpass_step(
  59     opj_t1_t *t1,
  60     flag_t *flagsp,
  61     int *datap,
  62     int orient,
  63     int bpno,
  64     int one,
  65     int *nmsedec,
  66     char type,
  67     int vsc);
  68 /**
  69 Decode significant pass
  70 */
  71 static INLINE void t1_dec_sigpass_step_raw(
  72     opj_t1_t *t1,
  73     flag_t *flagsp,
  74     int *datap,
  75     int orient,
  76     int oneplushalf,
  77     int vsc);
  78 static INLINE void t1_dec_sigpass_step_mqc(
  79     opj_t1_t *t1,
  80     flag_t *flagsp,
  81     int *datap,
  82     int orient,
  83     int oneplushalf);
  84 static INLINE void t1_dec_sigpass_step_mqc_vsc(
  85     opj_t1_t *t1,
  86     flag_t *flagsp,
  87     int *datap,
  88     int orient,
  89     int oneplushalf,
  90     int vsc);
  91 /**
  92 Encode significant pass
  93 */
  94 static void t1_enc_sigpass(
  95     opj_t1_t *t1,
  96     int bpno,
  97     int orient,
  98     int *nmsedec,
  99     char type,
 100     int cblksty);
 101 /**
 102 Decode significant pass
 103 */
 104 static void t1_dec_sigpass_raw(
 105     opj_t1_t *t1,
 106     int bpno,
 107     int orient,
 108     int cblksty);
 109 static void t1_dec_sigpass_mqc(
 110     opj_t1_t *t1,
 111     int bpno,
 112     int orient);
 113 static void t1_dec_sigpass_mqc_vsc(
 114     opj_t1_t *t1,
 115     int bpno,
 116     int orient);
 117 /**
 118 Encode refinement pass
 119 */
 120 static void t1_enc_refpass_step(
 121     opj_t1_t *t1,
 122     flag_t *flagsp,
 123     int *datap,
 124     int bpno,
 125     int one,
 126     int *nmsedec,
 127     char type,
 128     int vsc);
 129 /**
 130 Decode refinement pass
 131 */
 132 static INLINE void t1_dec_refpass_step_raw(
 133     opj_t1_t *t1,
 134     flag_t *flagsp,
 135     int *datap,
 136     int poshalf,
 137     int neghalf,
 138     int vsc);
 139 static INLINE void t1_dec_refpass_step_mqc(
 140     opj_t1_t *t1,
 141     flag_t *flagsp,
 142     int *datap,
 143     int poshalf,
 144     int neghalf);
 145 static INLINE void t1_dec_refpass_step_mqc_vsc(
 146     opj_t1_t *t1,
 147     flag_t *flagsp,
 148     int *datap,
 149     int poshalf,
 150     int neghalf,
 151     int vsc);
 152
 153 /**
 154 Encode refinement pass
 155 */
 156 static void t1_enc_refpass(
 157     opj_t1_t *t1,
 158     int bpno,
 159     int *nmsedec,
 160     char type,
 161     int cblksty);
 162 /**
 163 Decode refinement pass
 164 */
 165 static void t1_dec_refpass_raw(
 166     opj_t1_t *t1,
 167     int bpno,
 168     int cblksty);
 169 static void t1_dec_refpass_mqc(
 170     opj_t1_t *t1,
 171     int bpno);
 172 static void t1_dec_refpass_mqc_vsc(
 173     opj_t1_t *t1,
 174     int bpno);
 175 /**
 176 Encode clean-up pass
 177 */
 178 static void t1_enc_clnpass_step(
 179     opj_t1_t *t1,
 180     flag_t *flagsp,
 181     int *datap,
 182     int orient,
 183     int bpno,
 184     int one,
 185     int *nmsedec,
 186     int partial,
 187     int vsc);
 188 /**
 189 Decode clean-up pass
 190 */
 191 static void t1_dec_clnpass_step_partial(
 192     opj_t1_t *t1,
 193     flag_t *flagsp,
 194     int *datap,
 195     int orient,
 196     int oneplushalf);
 197 static void t1_dec_clnpass_step(
 198     opj_t1_t *t1,
 199     flag_t *flagsp,
 200     int *datap,
 201     int orient,
 202     int oneplushalf);
 203 static void t1_dec_clnpass_step_vsc(
 204     opj_t1_t *t1,
 205     flag_t *flagsp,
 206     int *datap,
 207     int orient,
 208     int oneplushalf,
 209     int partial,
 210     int vsc);
 211 /**
 212 Encode clean-up pass
 213 */
 214 static void t1_enc_clnpass(
 215     opj_t1_t *t1,
 216     int bpno,
 217     int orient,
 218     int *nmsedec,
 219     int cblksty);
 220 /**
 221 Decode clean-up pass
 222 */
 223 static void t1_dec_clnpass(
 224     opj_t1_t *t1,
 225     int bpno,
 226     int orient,
 227     int cblksty);
 228 static double t1_getwmsedec(
 229     int nmsedec,
 230     int compno,
 231     int level,
 232     int orient,
 233     int bpno,
 234     int qmfbid,
 235     double stepsize,
 236     int numcomps,
 237     int mct);
 238 /**
 239 Encode 1 code-block
 240 @param t1 T1 handle
 241 @param cblk Code-block coding parameters
 242 @param orient
 243 @param compno Component number
 244 @param level
 245 @param qmfbid
 246 @param stepsize
 247 @param cblksty Code-block style
 248 @param numcomps
 249 @param mct
 250 @param tile
 251 */
 252 static void t1_encode_cblk(
 253     opj_t1_t *t1,
 254     opj_tcd_cblk_enc_t* cblk,
 255     int orient,
 256     int compno,
 257     int level,
 258     int qmfbid,
 259     double stepsize,
 260     int cblksty,
 261     int numcomps,
 262     int mct,
 263     opj_tcd_tile_t * tile);
 264 /**
 265 Decode 1 code-block
 266 @param t1 T1 handle
 267 @param cblk Code-block coding parameters
 268 @param orient
 269 @param roishift Region of interest shifting value
 270 @param cblksty Code-block style
 271 */
 272 static void t1_decode_cblk(
 273     opj_t1_t *t1,
 274     opj_tcd_cblk_dec_t* cblk,
 275     int orient,
 276     int roishift,
 277     int cblksty);
 278
 279 /*@}*/
 280
 281 /*@}*/
 282
 283 /* ----------------------------------------------------------------------- */
 284
 285 static char t1_getctxno_zc(int f, int orient)
 286 {
 287     return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
 288 }
 289
 290 static char t1_getctxno_sc(int f)
 291 {
 292     return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 293 }
 294
 295 static int t1_getctxno_mag(int f)
 296 {
 297     int tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
 298     int tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
 299     return (tmp2);
 300 }
 301
 302 static char t1_getspb(int f)
 303 {
 304     return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 305 }
 306
 307 static short t1_getnmsedec_sig(int x, int bitpos)
 308 {
 309     if (bitpos > T1_NMSEDEC_FRACBITS) {
 310         return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((
 311                                                                          1 << T1_NMSEDEC_BITS) - 1)];
 312     }
 313
 314     return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 315 }
 316
 317 static short t1_getnmsedec_ref(int x, int bitpos)
 318 {
 319     if (bitpos > T1_NMSEDEC_FRACBITS) {
 320         return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((
 321                                                                          1 << T1_NMSEDEC_BITS) - 1)];
 322     }
 323
 324     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 325 }
 326
 327 static void t1_updateflags(flag_t *flagsp, int s, int stride)
 328 {
 329     flag_t *np = flagsp - stride;
 330     flag_t *sp = flagsp + stride;
 331
 332     static const flag_t mod[] = {
 333         T1_SIG_S, T1_SIG_S | T1_SGN_S,
 334         T1_SIG_E, T1_SIG_E | T1_SGN_E,
 335         T1_SIG_W, T1_SIG_W | T1_SGN_W,
 336         T1_SIG_N, T1_SIG_N | T1_SGN_N
 337     };
 338
 339     np[-1] |= T1_SIG_SE;
 340     np[0]  |= mod[s];
 341     np[1]  |= T1_SIG_SW;
 342
 343     flagsp[-1] |= mod[s + 2];
 344     flagsp[0]  |= T1_SIG;
 345     flagsp[1]  |= mod[s + 4];
 346
 347     sp[-1] |= T1_SIG_NE;
 348     sp[0]  |= mod[s + 6];
 349     sp[1]  |= T1_SIG_NW;
 350 }
 351
 352 static void t1_enc_sigpass_step(
 353     opj_t1_t *t1,
 354     flag_t *flagsp,
 355     int *datap,
 356     int orient,
 357     int bpno,
 358     int one,
 359     int *nmsedec,
 360     char type,
 361     int vsc)
 362 {
 363     int v, flag;
 364
 365     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 366
 367     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 368            (*flagsp);
 369     if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 370         v = int_abs(*datap) & one ? 1 : 0;
 371         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));   /* ESSAI */
 372         if (type == T1_TYPE_RAW) {  /* BYPASS/LAZY MODE */
 373             mqc_bypass_enc(mqc, v);
 374         } else {
 375             mqc_encode(mqc, v);
 376         }
 377         if (v) {
 378             v = *datap < 0 ? 1 : 0;
 379             *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 380             mqc_setcurctx(mqc, t1_getctxno_sc(flag));   /* ESSAI */
 381             if (type == T1_TYPE_RAW) {  /* BYPASS/LAZY MODE */
 382                 mqc_bypass_enc(mqc, v);
 383             } else {
 384                 mqc_encode(mqc, v ^ t1_getspb(flag));
 385             }
 386             t1_updateflags(flagsp, v, t1->flags_stride);
 387         }
 388         *flagsp |= T1_VISIT;
 389     }
 390 }
 391
 392 static INLINE void t1_dec_sigpass_step_raw(
 393     opj_t1_t *t1,
 394     flag_t *flagsp,
 395     int *datap,
 396     int orient,
 397     int oneplushalf,
 398     int vsc)
 399 {
 400     int v, flag;
 401     opj_raw_t *raw = t1->raw;   /* RAW component */
 402
 403     OPJ_ARG_NOT_USED(orient);
 404
 405     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 406            (*flagsp);
 407     if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 408         if (raw_decode(raw)) {
 409             v = raw_decode(raw);    /* ESSAI */
 410             *datap = v ? -oneplushalf : oneplushalf;
 411             t1_updateflags(flagsp, v, t1->flags_stride);
 412         }
 413         *flagsp |= T1_VISIT;
 414     }
 415 }               /* VSC and  BYPASS by Antonin */
 416
 417 static INLINE void t1_dec_sigpass_step_mqc(
 418     opj_t1_t *t1,
 419     flag_t *flagsp,
 420     int *datap,
 421     int orient,
 422     int oneplushalf)
 423 {
 424     int v, flag;
 425
 426     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 427
 428     flag = *flagsp;
 429     if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 430         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 431         if (mqc_decode(mqc)) {
 432             mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 433             v = mqc_decode(mqc) ^ t1_getspb(flag);
 434             *datap = v ? -oneplushalf : oneplushalf;
 435             t1_updateflags(flagsp, v, t1->flags_stride);
 436         }
 437         *flagsp |= T1_VISIT;
 438     }
 439 }               /* VSC and  BYPASS by Antonin */
 440
 441 static INLINE void t1_dec_sigpass_step_mqc_vsc(
 442     opj_t1_t *t1,
 443     flag_t *flagsp,
 444     int *datap,
 445     int orient,
 446     int oneplushalf,
 447     int vsc)
 448 {
 449     int v, flag;
 450
 451     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 452
 453     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 454            (*flagsp);
 455     if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 456         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 457         if (mqc_decode(mqc)) {
 458             mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 459             v = mqc_decode(mqc) ^ t1_getspb(flag);
 460             *datap = v ? -oneplushalf : oneplushalf;
 461             t1_updateflags(flagsp, v, t1->flags_stride);
 462         }
 463         *flagsp |= T1_VISIT;
 464     }
 465 }               /* VSC and  BYPASS by Antonin */
 466
 467 static void t1_enc_sigpass(
 468     opj_t1_t *t1,
 469     int bpno,
 470     int orient,
 471     int *nmsedec,
 472     char type,
 473     int cblksty)
 474 {
 475     int i, j, k, one, vsc;
 476     *nmsedec = 0;
 477     one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 478     for (k = 0; k < t1->h; k += 4) {
 479         for (i = 0; i < t1->w; ++i) {
 480             for (j = k; j < k + 4 && j < t1->h; ++j) {
 481                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 ||
 482                         j == t1->h - 1)) ? 1 : 0;
 483                 t1_enc_sigpass_step(
 484                     t1,
 485                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 486                     &t1->data[(j * t1->w) + i],
 487                     orient,
 488                     bpno,
 489                     one,
 490                     nmsedec,
 491                     type,
 492                     vsc);
 493             }
 494         }
 495     }
 496 }
 497
 498 static void t1_dec_sigpass_raw(
 499     opj_t1_t *t1,
 500     int bpno,
 501     int orient,
 502     int cblksty)
 503 {
 504     int i, j, k, one, half, oneplushalf, vsc;
 505     one = 1 << bpno;
 506     half = one >> 1;
 507     oneplushalf = one | half;
 508     for (k = 0; k < t1->h; k += 4) {
 509         for (i = 0; i < t1->w; ++i) {
 510             for (j = k; j < k + 4 && j < t1->h; ++j) {
 511                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 ||
 512                         j == t1->h - 1)) ? 1 : 0;
 513                 t1_dec_sigpass_step_raw(
 514                     t1,
 515                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 516                     &t1->data[(j * t1->w) + i],
 517                     orient,
 518                     oneplushalf,
 519                     vsc);
 520             }
 521         }
 522     }
 523 }               /* VSC and  BYPASS by Antonin */
 524
 525 static void t1_dec_sigpass_mqc(
 526     opj_t1_t *t1,
 527     int bpno,
 528     int orient)
 529 {
 530     int i, j, k, one, half, oneplushalf;
 531     int *data1 = t1->data;
 532     flag_t *flags1 = &t1->flags[1];
 533     one = 1 << bpno;
 534     half = one >> 1;
 535     oneplushalf = one | half;
 536     for (k = 0; k < (t1->h & ~3); k += 4) {
 537         for (i = 0; i < t1->w; ++i) {
 538             int *data2 = data1 + i;
 539             flag_t *flags2 = flags1 + i;
 540             flags2 += t1->flags_stride;
 541             t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 542             data2 += t1->w;
 543             flags2 += t1->flags_stride;
 544             t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 545             data2 += t1->w;
 546             flags2 += t1->flags_stride;
 547             t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 548             data2 += t1->w;
 549             flags2 += t1->flags_stride;
 550             t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 551             data2 += t1->w;
 552         }
 553         data1 += t1->w << 2;
 554         flags1 += t1->flags_stride << 2;
 555     }
 556     for (i = 0; i < t1->w; ++i) {
 557         int *data2 = data1 + i;
 558         flag_t *flags2 = flags1 + i;
 559         for (j = k; j < t1->h; ++j) {
 560             flags2 += t1->flags_stride;
 561             t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 562             data2 += t1->w;
 563         }
 564     }
 565 }               /* VSC and  BYPASS by Antonin */
 566
 567 static void t1_dec_sigpass_mqc_vsc(
 568     opj_t1_t *t1,
 569     int bpno,
 570     int orient)
 571 {
 572     int i, j, k, one, half, oneplushalf, vsc;
 573     one = 1 << bpno;
 574     half = one >> 1;
 575     oneplushalf = one | half;
 576     for (k = 0; k < t1->h; k += 4) {
 577         for (i = 0; i < t1->w; ++i) {
 578             for (j = k; j < k + 4 && j < t1->h; ++j) {
 579                 vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
 580                 t1_dec_sigpass_step_mqc_vsc(
 581                     t1,
 582                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 583                     &t1->data[(j * t1->w) + i],
 584                     orient,
 585                     oneplushalf,
 586                     vsc);
 587             }
 588         }
 589     }
 590 }               /* VSC and  BYPASS by Antonin */
 591
 592 static void t1_enc_refpass_step(
 593     opj_t1_t *t1,
 594     flag_t *flagsp,
 595     int *datap,
 596     int bpno,
 597     int one,
 598     int *nmsedec,
 599     char type,
 600     int vsc)
 601 {
 602     int v, flag;
 603
 604     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 605
 606     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 607            (*flagsp);
 608     if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 609         *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 610         v = int_abs(*datap) & one ? 1 : 0;
 611         mqc_setcurctx(mqc, t1_getctxno_mag(flag));  /* ESSAI */
 612         if (type == T1_TYPE_RAW) {  /* BYPASS/LAZY MODE */
 613             mqc_bypass_enc(mqc, v);
 614         } else {
 615             mqc_encode(mqc, v);
 616         }
 617         *flagsp |= T1_REFINE;
 618     }
 619 }
 620
 621 static INLINE void t1_dec_refpass_step_raw(
 622     opj_t1_t *t1,
 623     flag_t *flagsp,
 624     int *datap,
 625     int poshalf,
 626     int neghalf,
 627     int vsc)
 628 {
 629     int v, t, flag;
 630
 631     opj_raw_t *raw = t1->raw;   /* RAW component */
 632
 633     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 634            (*flagsp);
 635     if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 636         v = raw_decode(raw);
 637         t = v ? poshalf : neghalf;
 638         *datap += *datap < 0 ? -t : t;
 639         *flagsp |= T1_REFINE;
 640     }
 641 }               /* VSC and  BYPASS by Antonin  */
 642
 643 static INLINE void t1_dec_refpass_step_mqc(
 644     opj_t1_t *t1,
 645     flag_t *flagsp,
 646     int *datap,
 647     int poshalf,
 648     int neghalf)
 649 {
 650     int v, t, flag;
 651
 652     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 653
 654     flag = *flagsp;
 655     if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 656         mqc_setcurctx(mqc, t1_getctxno_mag(flag));  /* ESSAI */
 657         v = mqc_decode(mqc);
 658         t = v ? poshalf : neghalf;
 659         *datap += *datap < 0 ? -t : t;
 660         *flagsp |= T1_REFINE;
 661     }
 662 }               /* VSC and  BYPASS by Antonin  */
 663
 664 static INLINE void t1_dec_refpass_step_mqc_vsc(
 665     opj_t1_t *t1,
 666     flag_t *flagsp,
 667     int *datap,
 668     int poshalf,
 669     int neghalf,
 670     int vsc)
 671 {
 672     int v, t, flag;
 673
 674     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 675
 676     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 677            (*flagsp);
 678     if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 679         mqc_setcurctx(mqc, t1_getctxno_mag(flag));  /* ESSAI */
 680         v = mqc_decode(mqc);
 681         t = v ? poshalf : neghalf;
 682         *datap += *datap < 0 ? -t : t;
 683         *flagsp |= T1_REFINE;
 684     }
 685 }               /* VSC and  BYPASS by Antonin  */
 686
 687 static void t1_enc_refpass(
 688     opj_t1_t *t1,
 689     int bpno,
 690     int *nmsedec,
 691     char type,
 692     int cblksty)
 693 {
 694     int i, j, k, one, vsc;
 695     *nmsedec = 0;
 696     one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 697     for (k = 0; k < t1->h; k += 4) {
 698         for (i = 0; i < t1->w; ++i) {
 699             for (j = k; j < k + 4 && j < t1->h; ++j) {
 700                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 ||
 701                         j == t1->h - 1)) ? 1 : 0;
 702                 t1_enc_refpass_step(
 703                     t1,
 704                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 705                     &t1->data[(j * t1->w) + i],
 706                     bpno,
 707                     one,
 708                     nmsedec,
 709                     type,
 710                     vsc);
 711             }
 712         }
 713     }
 714 }
 715
 716 static void t1_dec_refpass_raw(
 717     opj_t1_t *t1,
 718     int bpno,
 719     int cblksty)
 720 {
 721     int i, j, k, one, poshalf, neghalf;
 722     int vsc;
 723     one = 1 << bpno;
 724     poshalf = one >> 1;
 725     neghalf = bpno > 0 ? -poshalf : -1;
 726     for (k = 0; k < t1->h; k += 4) {
 727         for (i = 0; i < t1->w; ++i) {
 728             for (j = k; j < k + 4 && j < t1->h; ++j) {
 729                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 ||
 730                         j == t1->h - 1)) ? 1 : 0;
 731                 t1_dec_refpass_step_raw(
 732                     t1,
 733                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 734                     &t1->data[(j * t1->w) + i],
 735                     poshalf,
 736                     neghalf,
 737                     vsc);
 738             }
 739         }
 740     }
 741 }               /* VSC and  BYPASS by Antonin */
 742
 743 static void t1_dec_refpass_mqc(
 744     opj_t1_t *t1,
 745     int bpno)
 746 {
 747     int i, j, k, one, poshalf, neghalf;
 748     int *data1 = t1->data;
 749     flag_t *flags1 = &t1->flags[1];
 750     one = 1 << bpno;
 751     poshalf = one >> 1;
 752     neghalf = bpno > 0 ? -poshalf : -1;
 753     for (k = 0; k < (t1->h & ~3); k += 4) {
 754         for (i = 0; i < t1->w; ++i) {
 755             int *data2 = data1 + i;
 756             flag_t *flags2 = flags1 + i;
 757             flags2 += t1->flags_stride;
 758             t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 759             data2 += t1->w;
 760             flags2 += t1->flags_stride;
 761             t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 762             data2 += t1->w;
 763             flags2 += t1->flags_stride;
 764             t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 765             data2 += t1->w;
 766             flags2 += t1->flags_stride;
 767             t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 768             data2 += t1->w;
 769         }
 770         data1 += t1->w << 2;
 771         flags1 += t1->flags_stride << 2;
 772     }
 773     for (i = 0; i < t1->w; ++i) {
 774         int *data2 = data1 + i;
 775         flag_t *flags2 = flags1 + i;
 776         for (j = k; j < t1->h; ++j) {
 777             flags2 += t1->flags_stride;
 778             t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 779             data2 += t1->w;
 780         }
 781     }
 782 }               /* VSC and  BYPASS by Antonin */
 783
 784 static void t1_dec_refpass_mqc_vsc(
 785     opj_t1_t *t1,
 786     int bpno)
 787 {
 788     int i, j, k, one, poshalf, neghalf;
 789     int vsc;
 790     one = 1 << bpno;
 791     poshalf = one >> 1;
 792     neghalf = bpno > 0 ? -poshalf : -1;
 793     for (k = 0; k < t1->h; k += 4) {
 794         for (i = 0; i < t1->w; ++i) {
 795             for (j = k; j < k + 4 && j < t1->h; ++j) {
 796                 vsc = ((j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 797                 t1_dec_refpass_step_mqc_vsc(
 798                     t1,
 799                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 800                     &t1->data[(j * t1->w) + i],
 801                     poshalf,
 802                     neghalf,
 803                     vsc);
 804             }
 805         }
 806     }
 807 }               /* VSC and  BYPASS by Antonin */
 808
 809 static void t1_enc_clnpass_step(
 810     opj_t1_t *t1,
 811     flag_t *flagsp,
 812     int *datap,
 813     int orient,
 814     int bpno,
 815     int one,
 816     int *nmsedec,
 817     int partial,
 818     int vsc)
 819 {
 820     int v, flag;
 821
 822     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 823
 824     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 825            (*flagsp);
 826     if (partial) {
 827         goto LABEL_PARTIAL;
 828     }
 829     if (!(*flagsp & (T1_SIG | T1_VISIT))) {
 830         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 831         v = int_abs(*datap) & one ? 1 : 0;
 832         mqc_encode(mqc, v);
 833         if (v) {
 834 LABEL_PARTIAL:
 835             *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 836             mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 837             v = *datap < 0 ? 1 : 0;
 838             mqc_encode(mqc, v ^ t1_getspb(flag));
 839             t1_updateflags(flagsp, v, t1->flags_stride);
 840         }
 841     }
 842     *flagsp &= ~T1_VISIT;
 843 }
 844
 845 static void t1_dec_clnpass_step_partial(
 846     opj_t1_t *t1,
 847     flag_t *flagsp,
 848     int *datap,
 849     int orient,
 850     int oneplushalf)
 851 {
 852     int v, flag;
 853     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 854
 855     OPJ_ARG_NOT_USED(orient);
 856
 857     flag = *flagsp;
 858     mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 859     v = mqc_decode(mqc) ^ t1_getspb(flag);
 860     *datap = v ? -oneplushalf : oneplushalf;
 861     t1_updateflags(flagsp, v, t1->flags_stride);
 862     *flagsp &= ~T1_VISIT;
 863 }               /* VSC and  BYPASS by Antonin */
 864
 865 static void t1_dec_clnpass_step(
 866     opj_t1_t *t1,
 867     flag_t *flagsp,
 868     int *datap,
 869     int orient,
 870     int oneplushalf)
 871 {
 872     int v, flag;
 873
 874     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 875
 876     flag = *flagsp;
 877     if (!(flag & (T1_SIG | T1_VISIT))) {
 878         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 879         if (mqc_decode(mqc)) {
 880             mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 881             v = mqc_decode(mqc) ^ t1_getspb(flag);
 882             *datap = v ? -oneplushalf : oneplushalf;
 883             t1_updateflags(flagsp, v, t1->flags_stride);
 884         }
 885     }
 886     *flagsp &= ~T1_VISIT;
 887 }               /* VSC and  BYPASS by Antonin */
 888
 889 static void t1_dec_clnpass_step_vsc(
 890     opj_t1_t *t1,
 891     flag_t *flagsp,
 892     int *datap,
 893     int orient,
 894     int oneplushalf,
 895     int partial,
 896     int vsc)
 897 {
 898     int v, flag;
 899
 900     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 901
 902     flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) :
 903            (*flagsp);
 904     if (partial) {
 905         goto LABEL_PARTIAL;
 906     }
 907     if (!(flag & (T1_SIG | T1_VISIT))) {
 908         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 909         if (mqc_decode(mqc)) {
 910 LABEL_PARTIAL:
 911             mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 912             v = mqc_decode(mqc) ^ t1_getspb(flag);
 913             *datap = v ? -oneplushalf : oneplushalf;
 914             t1_updateflags(flagsp, v, t1->flags_stride);
 915         }
 916     }
 917     *flagsp &= ~T1_VISIT;
 918 }
 919
 920 static void t1_enc_clnpass(
 921     opj_t1_t *t1,
 922     int bpno,
 923     int orient,
 924     int *nmsedec,
 925     int cblksty)
 926 {
 927     int i, j, k, one, agg, runlen, vsc;
 928
 929     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 930
 931     *nmsedec = 0;
 932     one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 933     for (k = 0; k < t1->h; k += 4) {
 934         for (i = 0; i < t1->w; ++i) {
 935             if (k + 3 < t1->h) {
 936                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
 937                     agg = !(MACRO_t1_flags(1 + k, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 938                             || MACRO_t1_flags(1 + k + 1, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 939                             || MACRO_t1_flags(1 + k + 2, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 940                             || (MACRO_t1_flags(1 + k + 3, 1 + i)
 941                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT |
 942                                         T1_SIG_OTH));
 943                 } else {
 944                     agg = !(MACRO_t1_flags(1 + k, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 945                             || MACRO_t1_flags(1 + k + 1, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 946                             || MACRO_t1_flags(1 + k + 2, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 947                             || MACRO_t1_flags(1 + k + 3, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 948                 }
 949             } else {
 950                 agg = 0;
 951             }
 952             if (agg) {
 953                 for (runlen = 0; runlen < 4; ++runlen) {
 954                     if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one) {
 955                         break;
 956                     }
 957                 }
 958                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
 959                 mqc_encode(mqc, runlen != 4);
 960                 if (runlen == 4) {
 961                     continue;
 962                 }
 963                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
 964                 mqc_encode(mqc, runlen >> 1);
 965                 mqc_encode(mqc, runlen & 1);
 966             } else {
 967                 runlen = 0;
 968             }
 969             for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
 970                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 ||
 971                         j == t1->h - 1)) ? 1 : 0;
 972                 t1_enc_clnpass_step(
 973                     t1,
 974                     &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
 975                     &t1->data[(j * t1->w) + i],
 976                     orient,
 977                     bpno,
 978                     one,
 979                     nmsedec,
 980                     agg && (j == k + runlen),
 981                     vsc);
 982             }
 983         }
 984     }
 985 }
 986
 987 static void t1_dec_clnpass(
 988     opj_t1_t *t1,
 989     int bpno,
 990     int orient,
 991     int cblksty)
 992 {
 993     int i, j, k, one, half, oneplushalf, agg, runlen, vsc;
 994     int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
 995
 996     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
 997
 998     one = 1 << bpno;
 999     half = one >> 1;
1000     oneplushalf = one | half;
1001     if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1002         for (k = 0; k < t1->h; k += 4) {
1003             for (i = 0; i < t1->w; ++i) {
1004                 if (k + 3 < t1->h) {
1005                     agg = !(MACRO_t1_flags(1 + k, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1006                             || MACRO_t1_flags(1 + k + 1, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1007                             || MACRO_t1_flags(1 + k + 2, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1008                             || (MACRO_t1_flags(1 + k + 3, 1 + i)
1009                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT |
1010                                         T1_SIG_OTH));
1011                 } else {
1012                     agg = 0;
1013                 }
1014                 if (agg) {
1015                     mqc_setcurctx(mqc, T1_CTXNO_AGG);
1016                     if (!mqc_decode(mqc)) {
1017                         continue;
1018                     }
1019                     mqc_setcurctx(mqc, T1_CTXNO_UNI);
1020                     runlen = mqc_decode(mqc);
1021                     runlen = (runlen << 1) | mqc_decode(mqc);
1022                 } else {
1023                     runlen = 0;
1024                 }
1025                 for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1026                     vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
1027                     t1_dec_clnpass_step_vsc(
1028                         t1,
1029                         &t1->flags[((j + 1) * t1->flags_stride) + i + 1],
1030                         &t1->data[(j * t1->w) + i],
1031                         orient,
1032                         oneplushalf,
1033                         agg && (j == k + runlen),
1034                         vsc);
1035                 }
1036             }
1037         }
1038     } else {
1039         int *data1 = t1->data;
1040         flag_t *flags1 = &t1->flags[1];
1041         for (k = 0; k < (t1->h & ~3); k += 4) {
1042             for (i = 0; i < t1->w; ++i) {
1043                 int *data2 = data1 + i;
1044                 flag_t *flags2 = flags1 + i;
1045                 agg = !(MACRO_t1_flags(1 + k, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1046                         || MACRO_t1_flags(1 + k + 1, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1047                         || MACRO_t1_flags(1 + k + 2, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1048                         || MACRO_t1_flags(1 + k + 3, 1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1049                 if (agg) {
1050                     mqc_setcurctx(mqc, T1_CTXNO_AGG);
1051                     if (!mqc_decode(mqc)) {
1052                         continue;
1053                     }
1054                     mqc_setcurctx(mqc, T1_CTXNO_UNI);
1055                     runlen = mqc_decode(mqc);
1056                     runlen = (runlen << 1) | mqc_decode(mqc);
1057                     flags2 += runlen * t1->flags_stride;
1058                     data2 += runlen * t1->w;
1059                     for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1060                         flags2 += t1->flags_stride;
1061                         if (agg && (j == k + runlen)) {
1062                             t1_dec_clnpass_step_partial(t1, flags2, data2, orient, oneplushalf);
1063                         } else {
1064                             t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1065                         }
1066                         data2 += t1->w;
1067                     }
1068                 } else {
1069                     flags2 += t1->flags_stride;
1070                     t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1071                     data2 += t1->w;
1072                     flags2 += t1->flags_stride;
1073                     t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1074                     data2 += t1->w;
1075                     flags2 += t1->flags_stride;
1076                     t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1077                     data2 += t1->w;
1078                     flags2 += t1->flags_stride;
1079                     t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1080                     data2 += t1->w;
1081                 }
1082             }
1083             data1 += t1->w << 2;
1084             flags1 += t1->flags_stride << 2;
1085         }
1086         for (i = 0; i < t1->w; ++i) {
1087             int *data2 = data1 + i;
1088             flag_t *flags2 = flags1 + i;
1089             for (j = k; j < t1->h; ++j) {
1090                 flags2 += t1->flags_stride;
1091                 t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1092                 data2 += t1->w;
1093             }
1094         }
1095     }
1096
1097     if (segsym) {
1098         int v = 0;
1099         mqc_setcurctx(mqc, T1_CTXNO_UNI);
1100         v = mqc_decode(mqc);
1101         v = (v << 1) | mqc_decode(mqc);
1102         v = (v << 1) | mqc_decode(mqc);
1103         v = (v << 1) | mqc_decode(mqc);
1104         /*
1105         if (v!=0xa) {
1106             opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
1107         }
1108         */
1109     }
1110 }               /* VSC and  BYPASS by Antonin */
1111
1112
1113 /** mod fixed_quality */
1114 static double t1_getwmsedec(
1115     int nmsedec,
1116     int compno,
1117     int level,
1118     int orient,
1119     int bpno,
1120     int qmfbid,
1121     double stepsize,
1122     int numcomps,
1123     int mct)
1124 {
1125     double w1, w2, wmsedec;
1126     if (qmfbid == 1) {
1127         w1 = (mct && numcomps == 3) ? mct_getnorm(compno) : 1.0;
1128         w2 = dwt_getnorm(level, orient);
1129     } else {            /* if (qmfbid == 0) */
1130         w1 = (mct && numcomps == 3) ? mct_getnorm_real(compno) : 1.0;
1131         w2 = dwt_getnorm_real(level, orient);
1132     }
1133     wmsedec = w1 * w2 * stepsize * (1 << bpno);
1134     wmsedec *= wmsedec * nmsedec / 8192.0;
1135
1136     return wmsedec;
1137 }
1138
1139 static opj_bool allocate_buffers(
1140     opj_t1_t *t1,
1141     int w,
1142     int h)
1143 {
1144     int datasize = w * h;
1145     int flagssize;
1146
1147     if (datasize > t1->datasize) {
1148         opj_aligned_free(t1->data);
1149         t1->data = (int*) opj_aligned_malloc(datasize * sizeof(int));
1150         if (!t1->data) {
1151             return OPJ_FALSE;
1152         }
1153         t1->datasize = datasize;
1154     }
1155     memset(t1->data, 0, datasize * sizeof(int));
1156
1157     t1->flags_stride = w + 2;
1158     flagssize = t1->flags_stride * (h + 2);
1159
1160     if (flagssize > t1->flagssize) {
1161         opj_aligned_free(t1->flags);
1162         t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t));
1163         if (!t1->flags) {
1164             return OPJ_FALSE;
1165         }
1166         t1->flagssize = flagssize;
1167     }
1168     memset(t1->flags, 0, flagssize * sizeof(flag_t));
1169
1170     t1->w = w;
1171     t1->h = h;
1172
1173     return OPJ_TRUE;
1174 }
1175
1176 /** mod fixed_quality */
1177 static void t1_encode_cblk(
1178     opj_t1_t *t1,
1179     opj_tcd_cblk_enc_t* cblk,
1180     int orient,
1181     int compno,
1182     int level,
1183     int qmfbid,
1184     double stepsize,
1185     int cblksty,
1186     int numcomps,
1187     int mct,
1188     opj_tcd_tile_t * tile)
1189 {
1190     double cumwmsedec = 0.0;
1191
1192     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1193
1194     int passno, bpno, passtype;
1195     int nmsedec = 0;
1196     int i, max;
1197     char type = T1_TYPE_MQ;
1198     double tempwmsedec;
1199
1200     max = 0;
1201     for (i = 0; i < t1->w * t1->h; ++i) {
1202         int tmp = abs(t1->data[i]);
1203         max = int_max(max, tmp);
1204     }
1205
1206     cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
1207
1208     bpno = cblk->numbps - 1;
1209     passtype = 2;
1210
1211     mqc_resetstates(mqc);
1212     mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1213     mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1214     mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1215     mqc_init_enc(mqc, cblk->data);
1216
1217     for (passno = 0; bpno >= 0; ++passno) {
1218         opj_tcd_pass_t *pass = &cblk->passes[passno];
1219         int correction = 3;
1220         type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) &&
1221                 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1222
1223         switch (passtype) {
1224         case 0:
1225             t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
1226             break;
1227         case 1:
1228             t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
1229             break;
1230         case 2:
1231             t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
1232             /* code switch SEGMARK (i.e. SEGSYM) */
1233             if (cblksty & J2K_CCP_CBLKSTY_SEGSYM) {
1234                 mqc_segmark_enc(mqc);
1235             }
1236             break;
1237         }
1238
1239         /* fixed_quality */
1240         tempwmsedec = t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid,
1241                                     stepsize, numcomps, mct);
1242         cumwmsedec += tempwmsedec;
1243         tile->distotile += tempwmsedec;
1244
1245         /* Code switch "RESTART" (i.e. TERMALL) */
1246         if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) &&
1247                 (bpno - 1 < 0))) {
1248             if (type == T1_TYPE_RAW) {
1249                 mqc_flush(mqc);
1250                 correction = 1;
1251                 /* correction = mqc_bypass_flush_enc(); */
1252             } else {            /* correction = mqc_restart_enc(); */
1253                 mqc_flush(mqc);
1254                 correction = 1;
1255             }
1256             pass->term = 1;
1257         } else {
1258             if (((bpno < (cblk->numbps - 4) && (passtype > 0))
1259                     || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) &&
1260                     (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
1261                 if (type == T1_TYPE_RAW) {
1262                     mqc_flush(mqc);
1263                     correction = 1;
1264                     /* correction = mqc_bypass_flush_enc(); */
1265                 } else {        /* correction = mqc_restart_enc(); */
1266                     mqc_flush(mqc);
1267                     correction = 1;
1268                 }
1269                 pass->term = 1;
1270             } else {
1271                 pass->term = 0;
1272             }
1273         }
1274
1275         if (++passtype == 3) {
1276             passtype = 0;
1277             bpno--;
1278         }
1279
1280         if (pass->term && bpno > 0) {
1281             type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) &&
1282                     (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1283             if (type == T1_TYPE_RAW) {
1284                 mqc_bypass_init_enc(mqc);
1285             } else {
1286                 mqc_restart_init_enc(mqc);
1287             }
1288         }
1289
1290         pass->distortiondec = cumwmsedec;
1291         pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */
1292
1293         /* Code-switch "RESET" */
1294         if (cblksty & J2K_CCP_CBLKSTY_RESET) {
1295             mqc_reset_enc(mqc);
1296         }
1297     }
1298
1299     /* Code switch "ERTERM" (i.e. PTERM) */
1300     if (cblksty & J2K_CCP_CBLKSTY_PTERM) {
1301         mqc_erterm_enc(mqc);
1302     } else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY)) {
1303         mqc_flush(mqc);
1304     }
1305
1306     cblk->totalpasses = passno;
1307
1308     for (passno = 0; passno < cblk->totalpasses; passno++) {
1309         opj_tcd_pass_t *pass = &cblk->passes[passno];
1310         if (pass->rate > mqc_numbytes(mqc)) {
1311             pass->rate = mqc_numbytes(mqc);
1312         }
1313         /*Preventing generation of FF as last data byte of a pass*/
1314         if ((pass->rate > 1) && (cblk->data[pass->rate - 1] == 0xFF)) {
1315             pass->rate--;
1316         }
1317         pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
1318     }
1319 }
1320
1321 static void t1_decode_cblk(
1322     opj_t1_t *t1,
1323     opj_tcd_cblk_dec_t* cblk,
1324     int orient,
1325     int roishift,
1326     int cblksty)
1327 {
1328     opj_raw_t *raw = t1->raw;   /* RAW component */
1329     opj_mqc_t *mqc = t1->mqc;   /* MQC component */
1330
1331     int bpno, passtype;
1332     int segno, passno;
1333     char type = T1_TYPE_MQ; /* BYPASS mode */
1334
1335     if (!allocate_buffers(
1336                 t1,
1337                 cblk->x1 - cblk->x0,
1338                 cblk->y1 - cblk->y0)) {
1339         return;
1340     }
1341
1342     bpno = roishift + cblk->numbps - 1;
1343     passtype = 2;
1344
1345     mqc_resetstates(mqc);
1346     mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1347     mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1348     mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1349
1350     for (segno = 0; segno < cblk->numsegs; ++segno) {
1351         opj_tcd_seg_t *seg = &cblk->segs[segno];
1352
1353         /* BYPASS mode */
1354         type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2) &&
1355                 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1356         /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
1357         if (seg->data == NULL) {
1358             continue;
1359         }
1360         if (type == T1_TYPE_RAW) {
1361             raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
1362         } else {
1363             mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);
1364         }
1365
1366         for (passno = 0; passno < seg->numpasses; ++passno) {
1367             switch (passtype) {
1368             case 0:
1369                 if (type == T1_TYPE_RAW) {
1370                     t1_dec_sigpass_raw(t1, bpno + 1, orient, cblksty);
1371                 } else {
1372                     if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1373                         t1_dec_sigpass_mqc_vsc(t1, bpno + 1, orient);
1374                     } else {
1375                         t1_dec_sigpass_mqc(t1, bpno + 1, orient);
1376                     }
1377                 }
1378                 break;
1379             case 1:
1380                 if (type == T1_TYPE_RAW) {
1381                     t1_dec_refpass_raw(t1, bpno + 1, cblksty);
1382                 } else {
1383                     if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1384                         t1_dec_refpass_mqc_vsc(t1, bpno + 1);
1385                     } else {
1386                         t1_dec_refpass_mqc(t1, bpno + 1);
1387                     }
1388                 }
1389                 break;
1390             case 2:
1391                 t1_dec_clnpass(t1, bpno + 1, orient, cblksty);
1392                 break;
1393             }
1394
1395             if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
1396                 mqc_resetstates(mqc);
1397                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1398                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1399                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1400             }
1401             if (++passtype == 3) {
1402                 passtype = 0;
1403                 bpno--;
1404             }
1405         }
1406     }
1407 }
1408
1409 /* ----------------------------------------------------------------------- */
1410
1411 opj_t1_t* t1_create(opj_common_ptr cinfo)
1412 {
1413     opj_t1_t *t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
1414     if (!t1) {
1415         return NULL;
1416     }
1417
1418     t1->cinfo = cinfo;
1419     /* create MQC and RAW handles */
1420     t1->mqc = mqc_create();
1421     t1->raw = raw_create();
1422
1423     t1->data = NULL;
1424     t1->flags = NULL;
1425     t1->datasize = 0;
1426     t1->flagssize = 0;
1427
1428     return t1;
1429 }
1430
1431 void t1_destroy(opj_t1_t *t1)
1432 {
1433     if (t1) {
1434         /* destroy MQC and RAW handles */
1435         mqc_destroy(t1->mqc);
1436         raw_destroy(t1->raw);
1437         opj_aligned_free(t1->data);
1438         opj_aligned_free(t1->flags);
1439         opj_free(t1);
1440     }
1441 }
1442
1443 void t1_encode_cblks(
1444     opj_t1_t *t1,
1445     opj_tcd_tile_t *tile,
1446     opj_tcp_t *tcp)
1447 {
1448     int compno, resno, bandno, precno, cblkno;
1449
1450     tile->distotile = 0;        /* fixed_quality */
1451
1452     for (compno = 0; compno < tile->numcomps; ++compno) {
1453         opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
1454         opj_tccp_t* tccp = &tcp->tccps[compno];
1455         int tile_w = tilec->x1 - tilec->x0;
1456
1457         for (resno = 0; resno < tilec->numresolutions; ++resno) {
1458             opj_tcd_resolution_t *res = &tilec->resolutions[resno];
1459
1460             for (bandno = 0; bandno < res->numbands; ++bandno) {
1461                 opj_tcd_band_t* restrict band = &res->bands[bandno];
1462                 int bandconst = 8192 * 8192 / ((int) floor(band->stepsize * 8192));
1463
1464                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1465                     opj_tcd_precinct_t *prc = &band->precincts[precno];
1466
1467                     for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1468                         opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
1469                         int* restrict datap;
1470                         int* restrict tiledp;
1471                         int cblk_w;
1472                         int cblk_h;
1473                         int i, j;
1474
1475                         int x = cblk->x0 - band->x0;
1476                         int y = cblk->y0 - band->y0;
1477                         if (band->bandno & 1) {
1478                             opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1479                             x += pres->x1 - pres->x0;
1480                         }
1481                         if (band->bandno & 2) {
1482                             opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1483                             y += pres->y1 - pres->y0;
1484                         }
1485
1486                         if (!allocate_buffers(
1487                                     t1,
1488                                     cblk->x1 - cblk->x0,
1489                                     cblk->y1 - cblk->y0)) {
1490                             return;
1491                         }
1492
1493                         datap = t1->data;
1494                         cblk_w = t1->w;
1495                         cblk_h = t1->h;
1496
1497                         tiledp = &tilec->data[(y * tile_w) + x];
1498                         if (tccp->qmfbid == 1) {
1499                             for (j = 0; j < cblk_h; ++j) {
1500                                 for (i = 0; i < cblk_w; ++i) {
1501                                     int tmp = tiledp[(j * tile_w) + i];
1502                                     datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;
1503                                 }
1504                             }
1505                         } else {        /* if (tccp->qmfbid == 0) */
1506                             for (j = 0; j < cblk_h; ++j) {
1507                                 for (i = 0; i < cblk_w; ++i) {
1508                                     int tmp = tiledp[(j * tile_w) + i];
1509                                     datap[(j * cblk_w) + i] =
1510                                         fix_mul(
1511                                             tmp,
1512                                             bandconst) >> (11 - T1_NMSEDEC_FRACBITS);
1513                                 }
1514                             }
1515                         }
1516
1517                         t1_encode_cblk(
1518                             t1,
1519                             cblk,
1520                             band->bandno,
1521                             compno,
1522                             tilec->numresolutions - 1 - resno,
1523                             tccp->qmfbid,
1524                             band->stepsize,
1525                             tccp->cblksty,
1526                             tile->numcomps,
1527                             tcp->mct,
1528                             tile);
1529
1530                     } /* cblkno */
1531                 } /* precno */
1532             } /* bandno */
1533         } /* resno  */
1534     } /* compno  */
1535 }
1536
1537 void t1_decode_cblks(
1538     opj_t1_t* t1,
1539     opj_tcd_tilecomp_t* tilec,
1540     opj_tccp_t* tccp)
1541 {
1542     int resno, bandno, precno, cblkno;
1543
1544     int tile_w = tilec->x1 - tilec->x0;
1545
1546     for (resno = 0; resno < tilec->numresolutions; ++resno) {
1547         opj_tcd_resolution_t* res = &tilec->resolutions[resno];
1548
1549         for (bandno = 0; bandno < res->numbands; ++bandno) {
1550             opj_tcd_band_t* restrict band = &res->bands[bandno];
1551
1552             for (precno = 0; precno < res->pw * res->ph; ++precno) {
1553                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
1554
1555                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1556                     opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
1557                     int* restrict datap;
1558                     int cblk_w, cblk_h;
1559                     int x, y;
1560                     int i, j;
1561
1562                     t1_decode_cblk(
1563                         t1,
1564                         cblk,
1565                         band->bandno,
1566                         tccp->roishift,
1567                         tccp->cblksty);
1568
1569                     x = cblk->x0 - band->x0;
1570                     y = cblk->y0 - band->y0;
1571                     if (band->bandno & 1) {
1572                         opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1573                         x += pres->x1 - pres->x0;
1574                     }
1575                     if (band->bandno & 2) {
1576                         opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1577                         y += pres->y1 - pres->y0;
1578                     }
1579
1580                     datap = t1->data;
1581                     cblk_w = t1->w;
1582                     cblk_h = t1->h;
1583
1584                     if (tccp->roishift) {
1585                         int thresh = 1 << tccp->roishift;
1586                         for (j = 0; j < cblk_h; ++j) {
1587                             for (i = 0; i < cblk_w; ++i) {
1588                                 int val = datap[(j * cblk_w) + i];
1589                                 int mag = abs(val);
1590                                 if (mag >= thresh) {
1591                                     mag >>= tccp->roishift;
1592                                     datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1593                                 }
1594                             }
1595                         }
1596                     }
1597
1598                     if (tccp->qmfbid == 1) {
1599                         int* restrict tiledp = &tilec->data[(y * tile_w) + x];
1600                         for (j = 0; j < cblk_h; ++j) {
1601                             for (i = 0; i < cblk_w; ++i) {
1602                                 int tmp = datap[(j * cblk_w) + i];
1603                                 ((int*)tiledp)[(j * tile_w) + i] = tmp / 2;
1604                             }
1605                         }
1606                     } else {        /* if (tccp->qmfbid == 0) */
1607                         float* restrict tiledp = (float*) &tilec->data[(y * tile_w) + x];
1608                         for (j = 0; j < cblk_h; ++j) {
1609                             float* restrict tiledp2 = tiledp;
1610                             for (i = 0; i < cblk_w; ++i) {
1611                                 float tmp = *datap * band->stepsize;
1612                                 *tiledp2 = tmp;
1613                                 datap++;
1614                                 tiledp2++;
1615                             }
1616                             tiledp += tile_w;
1617                         }
1618                     }
1619                     opj_free(cblk->data);
1620                     opj_free(cblk->segs);
1621                 } /* cblkno */
1622                 opj_free(precinct->cblks.dec);
1623                 precinct->cblks.dec = NULL;
1624             } /* precno */
1625         } /* bandno */
1626     } /* resno */
1627 }
1628