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 void INLINE 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 void INLINE 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 void INLINE 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 Encode 1 code-block
 279 @param t1 T1 handle
 280 @param cblk Code-block coding parameters
 281 @param orient
 282 @param compno Component number
 283 @param level
 284 @param qmfbid
 285 @param stepsize
 286 @param cblksty Code-block style
 287 @param numcomps
 288 @param mct
 289 @param tile
 290 */
 291 static void t1_encode_cblk(
 292                 opj_t1_t *t1,
 293                 opj_tcd_cblk_enc_t* cblk,
 294                 int orient,
 295                 int compno,
 296                 int level,
 297                 int qmfbid,
 298                 double stepsize,
 299                 int cblksty,
 300                 int numcomps,
 301                 int mct,
 302                 opj_tcd_tile_t * tile);
 303 /**
 304 Decode 1 code-block
 305 @param t1 T1 handle
 306 @param cblk Code-block coding parameters
 307 @param orient
 308 @param roishift Region of interest shifting value
 309 @param cblksty Code-block style
 310 */
 311 static void t1_decode_cblk(
 312                 opj_t1_t *t1,
 313                 opj_tcd_cblk_dec_t* cblk,
 314                 int orient,
 315                 int roishift,
 316                 int cblksty);
 317
 318 /*@}*/
 319
 320 /*@}*/
 321
 322 /* ----------------------------------------------------------------------- */
 323
 324 static char t1_getctxno_zc(int f, int orient) {
 325         return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
 326 }
 327
 328 static char t1_getctxno_sc(int f) {
 329         return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 330 }
 331
 332 static int t1_getctxno_mag(int f) {
 333         int tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
 334         int tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
 335         return (tmp2);
 336 }
 337
 338 static char t1_getspb(int f) {
 339         return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 340 }
 341
 342 static short t1_getnmsedec_sig(int x, int bitpos) {
 343         if (bitpos > T1_NMSEDEC_FRACBITS) {
 344                 return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 345         }
 346
 347         return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 348 }
 349
 350 static short t1_getnmsedec_ref(int x, int bitpos) {
 351         if (bitpos > T1_NMSEDEC_FRACBITS) {
 352                 return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 353         }
 354
 355     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 356 }
 357
 358 static void t1_updateflags(flag_t *flagsp, int s, int stride) {
 359         flag_t *np = flagsp - stride;
 360         flag_t *sp = flagsp + stride;
 361
 362         static const flag_t mod[] = {
 363                 T1_SIG_S, T1_SIG_S|T1_SGN_S,
 364                 T1_SIG_E, T1_SIG_E|T1_SGN_E,
 365                 T1_SIG_W, T1_SIG_W|T1_SGN_W,
 366                 T1_SIG_N, T1_SIG_N|T1_SGN_N
 367         };
 368
 369         np[-1] |= T1_SIG_SE;
 370         np[0]  |= mod[s];
 371         np[1]  |= T1_SIG_SW;
 372
 373         flagsp[-1] |= mod[s+2];
 374         flagsp[0]  |= T1_SIG;
 375         flagsp[1]  |= mod[s+4];
 376
 377         sp[-1] |= T1_SIG_NE;
 378         sp[0]  |= mod[s+6];
 379         sp[1]  |= T1_SIG_NW;
 380 }
 381
 382 static void t1_enc_sigpass_step(
 383                 opj_t1_t *t1,
 384                 flag_t *flagsp,
 385                 int *datap,
 386                 int orient,
 387                 int bpno,
 388                 int one,
 389                 int *nmsedec,
 390                 char type,
 391                 int vsc)
 392 {
 393         int v, flag;
 394
 395         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 396
 397         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 398         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 399                 v = int_abs(*datap) & one ? 1 : 0;
 400                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));       /* ESSAI */
 401                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 402                         mqc_bypass_enc(mqc, v);
 403                 } else {
 404                         mqc_encode(mqc, v);
 405                 }
 406                 if (v) {
 407                         v = *datap < 0 ? 1 : 0;
 408                         *nmsedec +=     t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 409                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));       /* ESSAI */
 410                         if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 411                                 mqc_bypass_enc(mqc, v);
 412                         } else {
 413                                 mqc_encode(mqc, v ^ t1_getspb(flag));
 414                         }
 415                         t1_updateflags(flagsp, v, t1->flags_stride);
 416                 }
 417                 *flagsp |= T1_VISIT;
 418         }
 419 }
 420
 421 static INLINE void t1_dec_sigpass_step_raw(
 422                 opj_t1_t *t1,
 423                 flag_t *flagsp,
 424                 int *datap,
 425                 int orient,
 426                 int oneplushalf,
 427                 int vsc)
 428 {
 429         int v, flag;
 430         opj_raw_t *raw = t1->raw;       /* RAW component */
 431
 432         OPJ_ARG_NOT_USED(orient);
 433
 434         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 435         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 436                         if (raw_decode(raw)) {
 437                                 v = raw_decode(raw);    /* ESSAI */
 438                                 *datap = v ? -oneplushalf : oneplushalf;
 439                                 t1_updateflags(flagsp, v, t1->flags_stride);
 440                         }
 441                 *flagsp |= T1_VISIT;
 442         }
 443 }                               /* VSC and  BYPASS by Antonin */
 444
 445 static INLINE void t1_dec_sigpass_step_mqc(
 446                 opj_t1_t *t1,
 447                 flag_t *flagsp,
 448                 int *datap,
 449                 int orient,
 450                 int oneplushalf)
 451 {
 452         int v, flag;
 453
 454         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 455
 456         flag = *flagsp;
 457         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 458                         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 459                         if (mqc_decode(mqc)) {
 460                                 mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 461                                 v = mqc_decode(mqc) ^ t1_getspb(flag);
 462                                 *datap = v ? -oneplushalf : oneplushalf;
 463                                 t1_updateflags(flagsp, v, t1->flags_stride);
 464                         }
 465                 *flagsp |= T1_VISIT;
 466         }
 467 }                               /* VSC and  BYPASS by Antonin */
 468
 469 static INLINE void t1_dec_sigpass_step_mqc_vsc(
 470                 opj_t1_t *t1,
 471                 flag_t *flagsp,
 472                 int *datap,
 473                 int orient,
 474                 int oneplushalf,
 475                 int vsc)
 476 {
 477         int v, flag;
 478
 479         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 480
 481         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 482         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 483                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 484                 if (mqc_decode(mqc)) {
 485                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 486                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 487                         *datap = v ? -oneplushalf : oneplushalf;
 488                         t1_updateflags(flagsp, v, t1->flags_stride);
 489                 }
 490                 *flagsp |= T1_VISIT;
 491         }
 492 }                               /* VSC and  BYPASS by Antonin */
 493
 494 static void t1_enc_sigpass(
 495                 opj_t1_t *t1,
 496                 int bpno,
 497                 int orient,
 498                 int *nmsedec,
 499                 char type,
 500                 int cblksty)
 501 {
 502         int i, j, k, one, vsc;
 503         *nmsedec = 0;
 504         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 505         for (k = 0; k < t1->h; k += 4) {
 506                 for (i = 0; i < t1->w; ++i) {
 507                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 508                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 509                                 t1_enc_sigpass_step(
 510                                                 t1,
 511                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 512                                                 &t1->data[(j * t1->w) + i],
 513                                                 orient,
 514                                                 bpno,
 515                                                 one,
 516                                                 nmsedec,
 517                                                 type,
 518                                                 vsc);
 519                         }
 520                 }
 521         }
 522 }
 523
 524 static void t1_dec_sigpass_raw(
 525                 opj_t1_t *t1,
 526                 int bpno,
 527                 int orient,
 528                 int cblksty)
 529 {
 530         int i, j, k, one, half, oneplushalf, vsc;
 531         one = 1 << bpno;
 532         half = one >> 1;
 533         oneplushalf = one | half;
 534         for (k = 0; k < t1->h; k += 4) {
 535                 for (i = 0; i < t1->w; ++i) {
 536                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 537                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 538                                 t1_dec_sigpass_step_raw(
 539                                                 t1,
 540                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 541                                                 &t1->data[(j * t1->w) + i],
 542                                                 orient,
 543                                                 oneplushalf,
 544                                                 vsc);
 545                         }
 546                 }
 547         }
 548 }                               /* VSC and  BYPASS by Antonin */
 549
 550 static void t1_dec_sigpass_mqc(
 551                 opj_t1_t *t1,
 552                 int bpno,
 553                 int orient)
 554 {
 555         int i, j, k, one, half, oneplushalf;
 556         int *data1 = t1->data;
 557         flag_t *flags1 = &t1->flags[1];
 558         one = 1 << bpno;
 559         half = one >> 1;
 560         oneplushalf = one | half;
 561         for (k = 0; k < (t1->h & ~3); k += 4) {
 562                 for (i = 0; i < t1->w; ++i) {
 563                         int *data2 = data1 + i;
 564                         flag_t *flags2 = flags1 + i;
 565                         flags2 += t1->flags_stride;
 566                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 567                         data2 += t1->w;
 568                         flags2 += t1->flags_stride;
 569                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 570                         data2 += t1->w;
 571                         flags2 += t1->flags_stride;
 572                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 573                         data2 += t1->w;
 574                         flags2 += t1->flags_stride;
 575                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 576                         data2 += t1->w;
 577                 }
 578                 data1 += t1->w << 2;
 579                 flags1 += t1->flags_stride << 2;
 580         }
 581         for (i = 0; i < t1->w; ++i) {
 582                 int *data2 = data1 + i;
 583                 flag_t *flags2 = flags1 + i;
 584                 for (j = k; j < t1->h; ++j) {
 585                         flags2 += t1->flags_stride;
 586                         t1_dec_sigpass_step_mqc(t1, flags2, data2, orient, oneplushalf);
 587                         data2 += t1->w;
 588                 }
 589         }
 590 }                               /* VSC and  BYPASS by Antonin */
 591
 592 static void t1_dec_sigpass_mqc_vsc(
 593                 opj_t1_t *t1,
 594                 int bpno,
 595                 int orient)
 596 {
 597         int i, j, k, one, half, oneplushalf, vsc;
 598         one = 1 << bpno;
 599         half = one >> 1;
 600         oneplushalf = one | half;
 601         for (k = 0; k < t1->h; k += 4) {
 602                 for (i = 0; i < t1->w; ++i) {
 603                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 604                                 vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
 605                                 t1_dec_sigpass_step_mqc_vsc(
 606                                                 t1,
 607                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 608                                                 &t1->data[(j * t1->w) + i],
 609                                                 orient,
 610                                                 oneplushalf,
 611                                                 vsc);
 612                         }
 613                 }
 614         }
 615 }                               /* VSC and  BYPASS by Antonin */
 616
 617 static void t1_enc_refpass_step(
 618                 opj_t1_t *t1,
 619                 flag_t *flagsp,
 620                 int *datap,
 621                 int bpno,
 622                 int one,
 623                 int *nmsedec,
 624                 char type,
 625                 int vsc)
 626 {
 627         int v, flag;
 628
 629         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 630
 631         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 632         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 633                 *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 634                 v = int_abs(*datap) & one ? 1 : 0;
 635                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 636                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 637                         mqc_bypass_enc(mqc, v);
 638                 } else {
 639                         mqc_encode(mqc, v);
 640                 }
 641                 *flagsp |= T1_REFINE;
 642         }
 643 }
 644
 645 static INLINE void t1_dec_refpass_step_raw(
 646                 opj_t1_t *t1,
 647                 flag_t *flagsp,
 648                 int *datap,
 649                 int poshalf,
 650                 int neghalf,
 651                 int vsc)
 652 {
 653         int v, t, flag;
 654
 655         opj_raw_t *raw = t1->raw;       /* RAW component */
 656
 657         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 658         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 659                         v = raw_decode(raw);
 660                 t = v ? poshalf : neghalf;
 661                 *datap += *datap < 0 ? -t : t;
 662                 *flagsp |= T1_REFINE;
 663         }
 664 }                               /* VSC and  BYPASS by Antonin  */
 665
 666 static INLINE void t1_dec_refpass_step_mqc(
 667                 opj_t1_t *t1,
 668                 flag_t *flagsp,
 669                 int *datap,
 670                 int poshalf,
 671                 int neghalf)
 672 {
 673         int v, t, flag;
 674
 675         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 676
 677         flag = *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 INLINE void t1_dec_refpass_step_mqc_vsc(
 688                 opj_t1_t *t1,
 689                 flag_t *flagsp,
 690                 int *datap,
 691                 int poshalf,
 692                 int neghalf,
 693                 int vsc)
 694 {
 695         int v, t, flag;
 696
 697         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 698
 699         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 700         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 701                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 702                 v = mqc_decode(mqc);
 703                 t = v ? poshalf : neghalf;
 704                 *datap += *datap < 0 ? -t : t;
 705                 *flagsp |= T1_REFINE;
 706         }
 707 }                               /* VSC and  BYPASS by Antonin  */
 708
 709 static void t1_enc_refpass(
 710                 opj_t1_t *t1,
 711                 int bpno,
 712                 int *nmsedec,
 713                 char type,
 714                 int cblksty)
 715 {
 716         int i, j, k, one, vsc;
 717         *nmsedec = 0;
 718         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 719         for (k = 0; k < t1->h; k += 4) {
 720                 for (i = 0; i < t1->w; ++i) {
 721                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 722                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 723                                 t1_enc_refpass_step(
 724                                                 t1,
 725                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 726                                                 &t1->data[(j * t1->w) + i],
 727                                                 bpno,
 728                                                 one,
 729                                                 nmsedec,
 730                                                 type,
 731                                                 vsc);
 732                         }
 733                 }
 734         }
 735 }
 736
 737 static void t1_dec_refpass_raw(
 738                 opj_t1_t *t1,
 739                 int bpno,
 740                 int cblksty)
 741 {
 742         int i, j, k, one, poshalf, neghalf;
 743         int vsc;
 744         one = 1 << bpno;
 745         poshalf = one >> 1;
 746         neghalf = bpno > 0 ? -poshalf : -1;
 747         for (k = 0; k < t1->h; k += 4) {
 748                 for (i = 0; i < t1->w; ++i) {
 749                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 750                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 751                                 t1_dec_refpass_step_raw(
 752                                                 t1,
 753                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 754                                                 &t1->data[(j * t1->w) + i],
 755                                                 poshalf,
 756                                                 neghalf,
 757                                                 vsc);
 758                         }
 759                 }
 760         }
 761 }                               /* VSC and  BYPASS by Antonin */
 762
 763 static void t1_dec_refpass_mqc(
 764                 opj_t1_t *t1,
 765                 int bpno)
 766 {
 767         int i, j, k, one, poshalf, neghalf;
 768         int *data1 = t1->data;
 769         flag_t *flags1 = &t1->flags[1];
 770         one = 1 << bpno;
 771         poshalf = one >> 1;
 772         neghalf = bpno > 0 ? -poshalf : -1;
 773         for (k = 0; k < (t1->h & ~3); k += 4) {
 774                 for (i = 0; i < t1->w; ++i) {
 775                         int *data2 = data1 + i;
 776                         flag_t *flags2 = flags1 + i;
 777                         flags2 += t1->flags_stride;
 778                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 779                         data2 += t1->w;
 780                         flags2 += t1->flags_stride;
 781                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 782                         data2 += t1->w;
 783                         flags2 += t1->flags_stride;
 784                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 785                         data2 += t1->w;
 786                         flags2 += t1->flags_stride;
 787                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 788                         data2 += t1->w;
 789                 }
 790                 data1 += t1->w << 2;
 791                 flags1 += t1->flags_stride << 2;
 792         }
 793         for (i = 0; i < t1->w; ++i) {
 794                 int *data2 = data1 + i;
 795                 flag_t *flags2 = flags1 + i;
 796                 for (j = k; j < t1->h; ++j) {
 797                         flags2 += t1->flags_stride;
 798                         t1_dec_refpass_step_mqc(t1, flags2, data2, poshalf, neghalf);
 799                         data2 += t1->w;
 800                 }
 801         }
 802 }                               /* VSC and  BYPASS by Antonin */
 803
 804 static void t1_dec_refpass_mqc_vsc(
 805                 opj_t1_t *t1,
 806                 int bpno)
 807 {
 808         int i, j, k, one, poshalf, neghalf;
 809         int vsc;
 810         one = 1 << bpno;
 811         poshalf = one >> 1;
 812         neghalf = bpno > 0 ? -poshalf : -1;
 813         for (k = 0; k < t1->h; k += 4) {
 814                 for (i = 0; i < t1->w; ++i) {
 815                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 816                                 vsc = ((j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 817                                 t1_dec_refpass_step_mqc_vsc(
 818                                                 t1,
 819                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 820                                                 &t1->data[(j * t1->w) + i],
 821                                                 poshalf,
 822                                                 neghalf,
 823                                                 vsc);
 824                         }
 825                 }
 826         }
 827 }                               /* VSC and  BYPASS by Antonin */
 828
 829 static void t1_enc_clnpass_step(
 830                 opj_t1_t *t1,
 831                 flag_t *flagsp,
 832                 int *datap,
 833                 int orient,
 834                 int bpno,
 835                 int one,
 836                 int *nmsedec,
 837                 int partial,
 838                 int vsc)
 839 {
 840         int v, flag;
 841
 842         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 843
 844         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 845         if (partial) {
 846                 goto LABEL_PARTIAL;
 847         }
 848         if (!(*flagsp & (T1_SIG | T1_VISIT))) {
 849                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 850                 v = int_abs(*datap) & one ? 1 : 0;
 851                 mqc_encode(mqc, v);
 852                 if (v) {
 853 LABEL_PARTIAL:
 854                         *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 855                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 856                         v = *datap < 0 ? 1 : 0;
 857                         mqc_encode(mqc, v ^ t1_getspb(flag));
 858                         t1_updateflags(flagsp, v, t1->flags_stride);
 859                 }
 860         }
 861         *flagsp &= ~T1_VISIT;
 862 }
 863
 864 static void t1_dec_clnpass_step_partial(
 865                 opj_t1_t *t1,
 866                 flag_t *flagsp,
 867                 int *datap,
 868                 int orient,
 869                 int oneplushalf)
 870 {
 871         int v, flag;
 872         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 873
 874         OPJ_ARG_NOT_USED(orient);
 875
 876         flag = *flagsp;
 877         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 878         v = mqc_decode(mqc) ^ t1_getspb(flag);
 879         *datap = v ? -oneplushalf : oneplushalf;
 880         t1_updateflags(flagsp, v, t1->flags_stride);
 881         *flagsp &= ~T1_VISIT;
 882 }                               /* VSC and  BYPASS by Antonin */
 883
 884 static void t1_dec_clnpass_step(
 885                 opj_t1_t *t1,
 886                 flag_t *flagsp,
 887                 int *datap,
 888                 int orient,
 889                 int oneplushalf)
 890 {
 891         int v, flag;
 892
 893         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 894
 895         flag = *flagsp;
 896         if (!(flag & (T1_SIG | T1_VISIT))) {
 897                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 898                 if (mqc_decode(mqc)) {
 899                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 900                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 901                         *datap = v ? -oneplushalf : oneplushalf;
 902                         t1_updateflags(flagsp, v, t1->flags_stride);
 903                 }
 904         }
 905         *flagsp &= ~T1_VISIT;
 906 }                               /* VSC and  BYPASS by Antonin */
 907
 908 static void t1_dec_clnpass_step_vsc(
 909                 opj_t1_t *t1,
 910                 flag_t *flagsp,
 911                 int *datap,
 912                 int orient,
 913                 int oneplushalf,
 914                 int partial,
 915                 int vsc)
 916 {
 917         int v, flag;
 918
 919         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 920
 921         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 922         if (partial) {
 923                 goto LABEL_PARTIAL;
 924         }
 925         if (!(flag & (T1_SIG | T1_VISIT))) {
 926                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 927                 if (mqc_decode(mqc)) {
 928 LABEL_PARTIAL:
 929                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 930                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 931                         *datap = v ? -oneplushalf : oneplushalf;
 932                         t1_updateflags(flagsp, v, t1->flags_stride);
 933                 }
 934         }
 935         *flagsp &= ~T1_VISIT;
 936 }
 937
 938 static void t1_enc_clnpass(
 939                 opj_t1_t *t1,
 940                 int bpno,
 941                 int orient,
 942                 int *nmsedec,
 943                 int cblksty)
 944 {
 945         int i, j, k, one, agg, runlen, vsc;
 946
 947         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 948
 949         *nmsedec = 0;
 950         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 951         for (k = 0; k < t1->h; k += 4) {
 952                 for (i = 0; i < t1->w; ++i) {
 953                         if (k + 3 < t1->h) {
 954                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
 955                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 956                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 957                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 958                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
 959                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 960                                 } else {
 961                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 962                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 963                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 964                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 965                                 }
 966                         } else {
 967                                 agg = 0;
 968                         }
 969                         if (agg) {
 970                                 for (runlen = 0; runlen < 4; ++runlen) {
 971                                         if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
 972                                                 break;
 973                                 }
 974                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
 975                                 mqc_encode(mqc, runlen != 4);
 976                                 if (runlen == 4) {
 977                                         continue;
 978                                 }
 979                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
 980                                 mqc_encode(mqc, runlen >> 1);
 981                                 mqc_encode(mqc, runlen & 1);
 982                         } else {
 983                                 runlen = 0;
 984                         }
 985                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
 986                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 987                                 t1_enc_clnpass_step(
 988                                                 t1,
 989                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 990                                                 &t1->data[(j * t1->w) + i],
 991                                                 orient,
 992                                                 bpno,
 993                                                 one,
 994                                                 nmsedec,
 995                                                 agg && (j == k + runlen),
 996                                                 vsc);
 997                         }
 998                 }
 999         }
1000 }
1001
1002 static void t1_dec_clnpass(
1003                 opj_t1_t *t1,
1004                 int bpno,
1005                 int orient,
1006                 int cblksty)
1007 {
1008         int i, j, k, one, half, oneplushalf, agg, runlen, vsc;
1009         int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
1010
1011         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1012
1013         one = 1 << bpno;
1014         half = one >> 1;
1015         oneplushalf = one | half;
1016         if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1017         for (k = 0; k < t1->h; k += 4) {
1018                 for (i = 0; i < t1->w; ++i) {
1019                         if (k + 3 < t1->h) {
1020                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1021                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1022                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1023                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
1024                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1025                                 } else {
1026                                 agg = 0;
1027                         }
1028                         if (agg) {
1029                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
1030                                 if (!mqc_decode(mqc)) {
1031                                         continue;
1032                                 }
1033                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
1034                                 runlen = mqc_decode(mqc);
1035                                 runlen = (runlen << 1) | mqc_decode(mqc);
1036                         } else {
1037                                 runlen = 0;
1038                         }
1039                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1040                                         vsc = (j == k + 3 || j == t1->h - 1) ? 1 : 0;
1041                                         t1_dec_clnpass_step_vsc(
1042                                                 t1,
1043                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
1044                                                 &t1->data[(j * t1->w) + i],
1045                                                 orient,
1046                                                 oneplushalf,
1047                                                 agg && (j == k + runlen),
1048                                                 vsc);
1049                         }
1050                 }
1051         }
1052         } else {
1053                 int *data1 = t1->data;
1054                 flag_t *flags1 = &t1->flags[1];
1055                 for (k = 0; k < (t1->h & ~3); k += 4) {
1056                         for (i = 0; i < t1->w; ++i) {
1057                                 int *data2 = data1 + i;
1058                                 flag_t *flags2 = flags1 + i;
1059                                 agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1060                                         || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1061                                         || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
1062                                         || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
1063                                 if (agg) {
1064                                         mqc_setcurctx(mqc, T1_CTXNO_AGG);
1065                                         if (!mqc_decode(mqc)) {
1066                                                 continue;
1067                                         }
1068                                         mqc_setcurctx(mqc, T1_CTXNO_UNI);
1069                                         runlen = mqc_decode(mqc);
1070                                         runlen = (runlen << 1) | mqc_decode(mqc);
1071                                         flags2 += runlen * t1->flags_stride;
1072                                         data2 += runlen * t1->w;
1073                                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
1074                                                 flags2 += t1->flags_stride;
1075                                                 if (agg && (j == k + runlen)) {
1076                                                         t1_dec_clnpass_step_partial(t1, flags2, data2, orient, oneplushalf);
1077                                                 } else {
1078                                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1079                                                 }
1080                                                 data2 += t1->w;
1081                                         }
1082                                 } else {
1083                                         flags2 += t1->flags_stride;
1084                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1085                                         data2 += t1->w;
1086                                         flags2 += t1->flags_stride;
1087                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1088                                         data2 += t1->w;
1089                                         flags2 += t1->flags_stride;
1090                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1091                                         data2 += t1->w;
1092                                         flags2 += t1->flags_stride;
1093                                         t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1094                                         data2 += t1->w;
1095                                 }
1096                         }
1097                         data1 += t1->w << 2;
1098                         flags1 += t1->flags_stride << 2;
1099                 }
1100                 for (i = 0; i < t1->w; ++i) {
1101                         int *data2 = data1 + i;
1102                         flag_t *flags2 = flags1 + i;
1103                         for (j = k; j < t1->h; ++j) {
1104                                 flags2 += t1->flags_stride;
1105                                 t1_dec_clnpass_step(t1, flags2, data2, orient, oneplushalf);
1106                                 data2 += t1->w;
1107                         }
1108                 }
1109         }
1110
1111         if (segsym) {
1112                 int v = 0;
1113                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
1114                 v = mqc_decode(mqc);
1115                 v = (v << 1) | mqc_decode(mqc);
1116                 v = (v << 1) | mqc_decode(mqc);
1117                 v = (v << 1) | mqc_decode(mqc);
1118                 /*
1119                 if (v!=0xa) {
1120                         opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
1121                 }
1122                 */
1123         }
1124 }                               /* VSC and  BYPASS by Antonin */
1125
1126
1127 /** mod fixed_quality */
1128 static double t1_getwmsedec(
1129                 int nmsedec,
1130                 int compno,
1131                 int level,
1132                 int orient,
1133                 int bpno,
1134                 int qmfbid,
1135                 double stepsize,
1136                 int numcomps,
1137                 int mct)
1138 {
1139         double w1, w2, wmsedec;
1140         if (qmfbid == 1) {
1141                 w1 = (mct && numcomps==3) ? mct_getnorm(compno) : 1.0;
1142                 w2 = dwt_getnorm(level, orient);
1143         } else {                        /* if (qmfbid == 0) */
1144                 w1 = (mct && numcomps==3) ? mct_getnorm_real(compno) : 1.0;
1145                 w2 = dwt_getnorm_real(level, orient);
1146         }
1147         wmsedec = w1 * w2 * stepsize * (1 << bpno);
1148         wmsedec *= wmsedec * nmsedec / 8192.0;
1149
1150         return wmsedec;
1151 }
1152
1153 static opj_bool allocate_buffers(
1154                 opj_t1_t *t1,
1155                 int w,
1156                 int h)
1157 {
1158         int datasize=w * h;
1159         int flagssize;
1160
1161         if(datasize > t1->datasize){
1162                 opj_aligned_free(t1->data);
1163                 t1->data = (int*) opj_aligned_malloc(datasize * sizeof(int));
1164                 if(!t1->data){
1165                         return OPJ_FALSE;
1166                 }
1167                 t1->datasize=datasize;
1168         }
1169         memset(t1->data,0,datasize * sizeof(int));
1170
1171         t1->flags_stride=w+2;
1172         flagssize=t1->flags_stride * (h+2);
1173
1174         if(flagssize > t1->flagssize){
1175                 opj_aligned_free(t1->flags);
1176                 t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t));
1177                 if(!t1->flags){
1178                         return OPJ_FALSE;
1179                 }
1180                 t1->flagssize=flagssize;
1181         }
1182         memset(t1->flags,0,flagssize * sizeof(flag_t));
1183
1184         t1->w=w;
1185         t1->h=h;
1186
1187         return OPJ_TRUE;
1188 }
1189
1190 /** mod fixed_quality */
1191 static void t1_encode_cblk(
1192                 opj_t1_t *t1,
1193                 opj_tcd_cblk_enc_t* cblk,
1194                 int orient,
1195                 int compno,
1196                 int level,
1197                 int qmfbid,
1198                 double stepsize,
1199                 int cblksty,
1200                 int numcomps,
1201                 int mct,
1202                 opj_tcd_tile_t * tile)
1203 {
1204         double cumwmsedec = 0.0;
1205
1206         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1207
1208         int passno, bpno, passtype;
1209         int nmsedec = 0;
1210         int i, max;
1211         char type = T1_TYPE_MQ;
1212         double tempwmsedec;
1213
1214         max = 0;
1215         for (i = 0; i < t1->w * t1->h; ++i) {
1216                 int tmp = abs(t1->data[i]);
1217                 max = int_max(max, tmp);
1218         }
1219
1220         cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
1221
1222         bpno = cblk->numbps - 1;
1223         passtype = 2;
1224
1225         mqc_resetstates(mqc);
1226         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1227         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1228         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1229         mqc_init_enc(mqc, cblk->data);
1230
1231         for (passno = 0; bpno >= 0; ++passno) {
1232                 opj_tcd_pass_t *pass = &cblk->passes[passno];
1233                 int correction = 3;
1234                 type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1235
1236                 switch (passtype) {
1237                         case 0:
1238                                 t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
1239                                 break;
1240                         case 1:
1241                                 t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
1242                                 break;
1243                         case 2:
1244                                 t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
1245                                 /* code switch SEGMARK (i.e. SEGSYM) */
1246                                 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
1247                                         mqc_segmark_enc(mqc);
1248                                 break;
1249                 }
1250
1251                 /* fixed_quality */
1252                 tempwmsedec = t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps, mct);
1253                 cumwmsedec += tempwmsedec;
1254                 tile->distotile += tempwmsedec;
1255
1256                 /* Code switch "RESTART" (i.e. TERMALL) */
1257                 if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
1258                         if (type == T1_TYPE_RAW) {
1259                                 mqc_flush(mqc);
1260                                 correction = 1;
1261                                 /* correction = mqc_bypass_flush_enc(); */
1262                         } else {                        /* correction = mqc_restart_enc(); */
1263                                 mqc_flush(mqc);
1264                                 correction = 1;
1265                         }
1266                         pass->term = 1;
1267                 } else {
1268                         if (((bpno < (cblk->numbps - 4) && (passtype > 0))
1269                                 || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
1270                                 if (type == T1_TYPE_RAW) {
1271                                         mqc_flush(mqc);
1272                                         correction = 1;
1273                                         /* correction = mqc_bypass_flush_enc(); */
1274                                 } else {                /* correction = mqc_restart_enc(); */
1275                                         mqc_flush(mqc);
1276                                         correction = 1;
1277                                 }
1278                                 pass->term = 1;
1279                         } else {
1280                                 pass->term = 0;
1281                         }
1282                 }
1283
1284                 if (++passtype == 3) {
1285                         passtype = 0;
1286                         bpno--;
1287                 }
1288
1289                 if (pass->term && bpno > 0) {
1290                         type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1291                         if (type == T1_TYPE_RAW)
1292                                 mqc_bypass_init_enc(mqc);
1293                         else
1294                                 mqc_restart_init_enc(mqc);
1295                 }
1296
1297                 pass->distortiondec = cumwmsedec;
1298                 pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */
1299
1300                 /* Code-switch "RESET" */
1301                 if (cblksty & J2K_CCP_CBLKSTY_RESET)
1302                         mqc_reset_enc(mqc);
1303         }
1304
1305         /* Code switch "ERTERM" (i.e. PTERM) */
1306         if (cblksty & J2K_CCP_CBLKSTY_PTERM)
1307                 mqc_erterm_enc(mqc);
1308         else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
1309                 mqc_flush(mqc);
1310
1311         cblk->totalpasses = passno;
1312
1313         for (passno = 0; passno<cblk->totalpasses; passno++) {
1314                 opj_tcd_pass_t *pass = &cblk->passes[passno];
1315                 if (pass->rate > mqc_numbytes(mqc))
1316                         pass->rate = mqc_numbytes(mqc);
1317                 /*Preventing generation of FF as last data byte of a pass*/
1318                 if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
1319                         pass->rate--;
1320                 }
1321                 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
1322         }
1323 }
1324
1325 static void t1_decode_cblk(
1326                 opj_t1_t *t1,
1327                 opj_tcd_cblk_dec_t* cblk,
1328                 int orient,
1329                 int roishift,
1330                 int cblksty)
1331 {
1332         opj_raw_t *raw = t1->raw;       /* RAW component */
1333         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1334
1335         int bpno, passtype;
1336         int segno, passno;
1337         char type = T1_TYPE_MQ; /* BYPASS mode */
1338
1339         if(!allocate_buffers(
1340                                 t1,
1341                                 cblk->x1 - cblk->x0,
1342                                 cblk->y1 - cblk->y0))
1343         {
1344                 return;
1345         }
1346
1347         bpno = roishift + cblk->numbps - 1;
1348         passtype = 2;
1349
1350         mqc_resetstates(mqc);
1351         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1352         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1353         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1354
1355         for (segno = 0; segno < cblk->numsegs; ++segno) {
1356                 opj_tcd_seg_t *seg = &cblk->segs[segno];
1357
1358                 /* BYPASS mode */
1359                 type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1360                 /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
1361                 if(seg->data == NULL){
1362                         continue;
1363                 }
1364                 if (type == T1_TYPE_RAW) {
1365                         raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
1366                 } else {
1367                         mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);
1368                 }
1369
1370                 for (passno = 0; passno < seg->numpasses; ++passno) {
1371                         switch (passtype) {
1372                                 case 0:
1373                                         if (type == T1_TYPE_RAW) {
1374                                                 t1_dec_sigpass_raw(t1, bpno+1, orient, cblksty);
1375                                         } else {
1376                                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1377                                                         t1_dec_sigpass_mqc_vsc(t1, bpno+1, orient);
1378                                                 } else {
1379                                                         t1_dec_sigpass_mqc(t1, bpno+1, orient);
1380                                                 }
1381                                         }
1382                                         break;
1383                                 case 1:
1384                                         if (type == T1_TYPE_RAW) {
1385                                                 t1_dec_refpass_raw(t1, bpno+1, cblksty);
1386                                         } else {
1387                                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1388                                                         t1_dec_refpass_mqc_vsc(t1, bpno+1);
1389                                                 } else {
1390                                                         t1_dec_refpass_mqc(t1, bpno+1);
1391                                                 }
1392                                         }
1393                                         break;
1394                                 case 2:
1395                                         t1_dec_clnpass(t1, bpno+1, orient, cblksty);
1396                                         break;
1397                         }
1398
1399                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
1400                                 mqc_resetstates(mqc);
1401                                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1402                                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1403                                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1404                         }
1405                         if (++passtype == 3) {
1406                                 passtype = 0;
1407                                 bpno--;
1408                         }
1409                 }
1410         }
1411 }
1412
1413 /* ----------------------------------------------------------------------- */
1414
1415 opj_t1_t* t1_create(opj_common_ptr cinfo) {
1416         opj_t1_t *t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
1417         if(!t1)
1418                 return NULL;
1419
1420         t1->cinfo = cinfo;
1421         /* create MQC and RAW handles */
1422         t1->mqc = mqc_create();
1423         t1->raw = raw_create();
1424
1425         t1->data=NULL;
1426         t1->flags=NULL;
1427         t1->datasize=0;
1428         t1->flagssize=0;
1429
1430         return t1;
1431 }
1432
1433 void t1_destroy(opj_t1_t *t1) {
1434         if(t1) {
1435                 /* destroy MQC and RAW handles */
1436                 mqc_destroy(t1->mqc);
1437                 raw_destroy(t1->raw);
1438                 opj_aligned_free(t1->data);
1439                 opj_aligned_free(t1->flags);
1440                 opj_free(t1);
1441         }
1442 }
1443
1444 void t1_encode_cblks(
1445                 opj_t1_t *t1,
1446                 opj_tcd_tile_t *tile,
1447                 opj_tcp_t *tcp)
1448 {
1449         int compno, resno, bandno, precno, cblkno;
1450
1451         tile->distotile = 0;            /* fixed_quality */
1452
1453         for (compno = 0; compno < tile->numcomps; ++compno) {
1454                 opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
1455                 opj_tccp_t* tccp = &tcp->tccps[compno];
1456                 int tile_w = tilec->x1 - tilec->x0;
1457
1458                 for (resno = 0; resno < tilec->numresolutions; ++resno) {
1459                         opj_tcd_resolution_t *res = &tilec->resolutions[resno];
1460
1461                         for (bandno = 0; bandno < res->numbands; ++bandno) {
1462                                 opj_tcd_band_t* restrict band = &res->bands[bandno];
1463         int bandconst = 8192 * 8192 / ((int) floor(band->stepsize * 8192));
1464
1465                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1466                                         opj_tcd_precinct_t *prc = &band->precincts[precno];
1467
1468                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1469                                                 opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
1470                                                 int* restrict datap;
1471                                                 int* restrict tiledp;
1472                                                 int cblk_w;
1473                                                 int cblk_h;
1474                                                 int i, j;
1475
1476                                                 int x = cblk->x0 - band->x0;
1477                                                 int y = cblk->y0 - band->y0;
1478                                                 if (band->bandno & 1) {
1479                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1480                                                         x += pres->x1 - pres->x0;
1481                                                 }
1482                                                 if (band->bandno & 2) {
1483                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1484                                                         y += pres->y1 - pres->y0;
1485                                                 }
1486
1487                                                 if(!allocate_buffers(
1488                                                                         t1,
1489                                                                         cblk->x1 - cblk->x0,
1490                                                                         cblk->y1 - cblk->y0))
1491                                                 {
1492                                                         return;
1493                                                 }
1494
1495                                                 datap=t1->data;
1496                                                 cblk_w = t1->w;
1497                                                 cblk_h = t1->h;
1498
1499                                                 tiledp=&tilec->data[(y * tile_w) + x];
1500                                                 if (tccp->qmfbid == 1) {
1501                                                         for (j = 0; j < cblk_h; ++j) {
1502                                                                 for (i = 0; i < cblk_w; ++i) {
1503                                                                         int tmp = tiledp[(j * tile_w) + i];
1504                                                                         datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;
1505                                                                 }
1506                                                         }
1507                                                 } else {                /* if (tccp->qmfbid == 0) */
1508                                                         for (j = 0; j < cblk_h; ++j) {
1509                                                                 for (i = 0; i < cblk_w; ++i) {
1510                                                                         int tmp = tiledp[(j * tile_w) + i];
1511                                                                         datap[(j * cblk_w) + i] =
1512                                                                                 fix_mul(
1513                                                                                 tmp,
1514                                                                                 bandconst) >> (11 - T1_NMSEDEC_FRACBITS);
1515                                                                 }
1516                                                         }
1517                                                 }
1518
1519                                                 t1_encode_cblk(
1520                                                                 t1,
1521                                                                 cblk,
1522                                                                 band->bandno,
1523                                                                 compno,
1524                                                                 tilec->numresolutions - 1 - resno,
1525                                                                 tccp->qmfbid,
1526                                                                 band->stepsize,
1527                                                                 tccp->cblksty,
1528                                                                 tile->numcomps,
1529                                                                 tcp->mct,
1530                                                                 tile);
1531
1532                                         } /* cblkno */
1533                                 } /* precno */
1534                         } /* bandno */
1535                 } /* resno  */
1536         } /* compno  */
1537 }
1538
1539 void t1_decode_cblks(
1540                 opj_t1_t* t1,
1541                 opj_tcd_tilecomp_t* tilec,
1542                 opj_tccp_t* tccp)
1543 {
1544         int resno, bandno, precno, cblkno;
1545
1546         int tile_w = tilec->x1 - tilec->x0;
1547
1548         for (resno = 0; resno < tilec->numresolutions; ++resno) {
1549                 opj_tcd_resolution_t* res = &tilec->resolutions[resno];
1550
1551                 for (bandno = 0; bandno < res->numbands; ++bandno) {
1552                         opj_tcd_band_t* restrict band = &res->bands[bandno];
1553
1554                         for (precno = 0; precno < res->pw * res->ph; ++precno) {
1555                                 opj_tcd_precinct_t* precinct = &band->precincts[precno];
1556
1557                                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1558                                         opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
1559                                         int* restrict datap;
1560                                         int cblk_w, cblk_h;
1561                                         int x, y;
1562                                         int i, j;
1563
1564                                         t1_decode_cblk(
1565                                                         t1,
1566                                                         cblk,
1567                                                         band->bandno,
1568                                                         tccp->roishift,
1569                                                         tccp->cblksty);
1570
1571                                         x = cblk->x0 - band->x0;
1572                                         y = cblk->y0 - band->y0;
1573                                         if (band->bandno & 1) {
1574                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1575                                                 x += pres->x1 - pres->x0;
1576                                         }
1577                                         if (band->bandno & 2) {
1578                                                 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1579                                                 y += pres->y1 - pres->y0;
1580                                         }
1581
1582                                         datap=t1->data;
1583                                         cblk_w = t1->w;
1584                                         cblk_h = t1->h;
1585
1586                                         if (tccp->roishift) {
1587                                                 int thresh = 1 << tccp->roishift;
1588                                                 for (j = 0; j < cblk_h; ++j) {
1589                                                         for (i = 0; i < cblk_w; ++i) {
1590                                                                 int val = datap[(j * cblk_w) + i];
1591                                                                 int mag = abs(val);
1592                                                                 if (mag >= thresh) {
1593                                                                         mag >>= tccp->roishift;
1594                                                                         datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1595                                                                 }
1596                                                         }
1597                                                 }
1598                                         }
1599
1600                                         if (tccp->qmfbid == 1) {
1601                                                 int* restrict tiledp = &tilec->data[(y * tile_w) + x];
1602                                                 for (j = 0; j < cblk_h; ++j) {
1603                                                         for (i = 0; i < cblk_w; ++i) {
1604                                                                 int tmp = datap[(j * cblk_w) + i];
1605                                                                 ((int*)tiledp)[(j * tile_w) + i] = tmp / 2;
1606                                                         }
1607                                                 }
1608                                         } else {                /* if (tccp->qmfbid == 0) */
1609                                                 float* restrict tiledp = (float*) &tilec->data[(y * tile_w) + x];
1610                                                 for (j = 0; j < cblk_h; ++j) {
1611                                                         float* restrict tiledp2 = tiledp;
1612                                                         for (i = 0; i < cblk_w; ++i) {
1613                                                                 float tmp = *datap * band->stepsize;
1614                                                                 *tiledp2 = tmp;
1615                                                                 datap++;
1616                                                                 tiledp2++;
1617                                                         }
1618                                                         tiledp += tile_w;
1619                                                 }
1620                                         }
1621                                         opj_free(cblk->data);
1622                                         opj_free(cblk->segs);
1623                                 } /* cblkno */
1624                                 opj_free(precinct->cblks.dec);
1625                         } /* precno */
1626                 } /* bandno */
1627         } /* resno */
1628 }
1629
1630
1631
1632 /* ----------------------------------------------------------------------- */
1633 /**
1634  * Creates a new Tier 1 handle
1635  * and initializes the look-up tables of the Tier-1 coder/decoder
1636  * @return a new T1 handle if successful, returns NULL otherwise
1637 */
1638 opj_t1_t* t1_create_v2()
1639 {
1640         opj_t1_t *l_t1 = 00;
1641
1642         l_t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
1643         if
1644                 (!l_t1)
1645         {
1646                 return 00;
1647         }
1648         memset(l_t1,0,sizeof(opj_t1_t));
1649
1650         /* create MQC and RAW handles */
1651         l_t1->mqc = mqc_create();
1652         if
1653                 (! l_t1->mqc)
1654         {
1655                 t1_destroy(l_t1);
1656                 return 00;
1657         }
1658         l_t1->raw = raw_create();
1659         if
1660                 (! l_t1->raw)
1661         {
1662                 t1_destroy(l_t1);
1663                 return 00;
1664         }
1665         return l_t1;
1666 }
1667
1668
1669 /**
1670  * Destroys a previously created T1 handle
1671  *
1672  * @param p_t1 Tier 1 handle to destroy
1673 */
1674 void t1_destroy_v2(opj_t1_t *p_t1)
1675 {
1676         if
1677                 (! p_t1)
1678         {
1679                 return;
1680         }
1681
1682         /* destroy MQC and RAW handles */
1683         mqc_destroy(p_t1->mqc);
1684         p_t1->mqc = 00;
1685         raw_destroy(p_t1->raw);
1686         p_t1->raw = 00;
1687         if
1688                 (p_t1->data)
1689         {
1690                 opj_aligned_free(p_t1->data);
1691                 p_t1->data = 00;
1692         }
1693         if
1694                 (p_t1->flags)
1695         {
1696                 opj_aligned_free(p_t1->flags);
1697                 p_t1->flags = 00;
1698         }
1699         opj_free(p_t1);
1700 }
1701
1702 void t1_decode_cblks_v2(
1703                 opj_t1_t* t1,
1704                 opj_tcd_tilecomp_v2_t* tilec,
1705                 opj_tccp_t* tccp)
1706 {
1707         OPJ_UINT32 resno, bandno, precno, cblkno;
1708         OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;
1709
1710         for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
1711                 opj_tcd_resolution_v2_t* res = &tilec->resolutions[resno];
1712
1713                 for (bandno = 0; bandno < res->numbands; ++bandno) {
1714                         opj_tcd_band_v2_t* restrict band = &res->bands[bandno];
1715
1716                         for (precno = 0; precno < res->pw * res->ph; ++precno) {
1717                                 opj_tcd_precinct_v2_t* precinct = &band->precincts[precno];
1718
1719                                 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1720                                         opj_tcd_cblk_dec_v2_t* cblk = &precinct->cblks.dec[cblkno];
1721                                         OPJ_INT32* restrict datap;
1722                                         void* restrict tiledp;
1723                                         OPJ_UINT32 cblk_w, cblk_h;
1724                                         OPJ_INT32 x, y;
1725                                         OPJ_UINT32 i, j;
1726
1727                                         t1_decode_cblk_v2(
1728                                                         t1,
1729                                                         cblk,
1730                                                         band->bandno,
1731                                                         tccp->roishift,
1732                                                         tccp->cblksty);
1733
1734                                         x = cblk->x0 - band->x0;
1735                                         y = cblk->y0 - band->y0;
1736                                         if (band->bandno & 1) {
1737                                                 opj_tcd_resolution_v2_t* pres = &tilec->resolutions[resno - 1];
1738                                                 x += pres->x1 - pres->x0;
1739                                         }
1740                                         if (band->bandno & 2) {
1741                                                 opj_tcd_resolution_v2_t* pres = &tilec->resolutions[resno - 1];
1742                                                 y += pres->y1 - pres->y0;
1743                                         }
1744
1745                                         datap=t1->data;
1746                                         cblk_w = t1->w;
1747                                         cblk_h = t1->h;
1748
1749                                         if (tccp->roishift) {
1750                                                 OPJ_INT32 thresh = 1 << tccp->roishift;
1751                                                 for (j = 0; j < cblk_h; ++j) {
1752                                                         for (i = 0; i < cblk_w; ++i) {
1753                                                                 OPJ_INT32 val = datap[(j * cblk_w) + i];
1754                                                                 OPJ_INT32 mag = abs(val);
1755                                                                 if (mag >= thresh) {
1756                                                                         mag >>= tccp->roishift;
1757                                                                         datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1758                                                                 }
1759                                                         }
1760                                                 }
1761                                         }
1762
1763                                         tiledp=(void*)&tilec->data[(y * tile_w) + x];
1764                                         if (tccp->qmfbid == 1) {
1765                                                 for (j = 0; j < cblk_h; ++j) {
1766                                                         for (i = 0; i < cblk_w; ++i) {
1767                                                                 OPJ_INT32 tmp = datap[(j * cblk_w) + i];
1768                                                                 ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp / 2;
1769                                                         }
1770                                                 }
1771                                         } else {                /* if (tccp->qmfbid == 0) */
1772                                                 for (j = 0; j < cblk_h; ++j) {
1773                                                         for (i = 0; i < cblk_w; ++i) {
1774                                                                 float tmp = datap[(j * cblk_w) + i] * band->stepsize;
1775                                                                 ((float*)tiledp)[(j * tile_w) + i] = tmp;
1776                                                         }
1777                                                 }
1778                                         }
1779                                         //opj_free(cblk->segs);
1780                                         //cblk->segs = 00;
1781                                 } /* cblkno */
1782                         } /* precno */
1783                 } /* bandno */
1784         } /* resno */
1785 }
1786
1787
1788 static void t1_decode_cblk_v2(
1789                 opj_t1_t *t1,
1790                 opj_tcd_cblk_dec_v2_t* cblk,
1791                 OPJ_UINT32 orient,
1792                 OPJ_UINT32 roishift,
1793                 OPJ_UINT32 cblksty)
1794 {
1795         opj_raw_t *raw = t1->raw;       /* RAW component */
1796         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1797
1798         OPJ_INT32 bpno;
1799         OPJ_UINT32 passtype;
1800         OPJ_UINT32 segno, passno;
1801         OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
1802
1803         if(!allocate_buffers(
1804                                 t1,
1805                                 cblk->x1 - cblk->x0,
1806                                 cblk->y1 - cblk->y0))
1807         {
1808                 return;
1809         }
1810
1811         bpno = roishift + cblk->numbps - 1;
1812         passtype = 2;
1813
1814         mqc_resetstates(mqc);
1815         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1816         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1817         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1818
1819         for (segno = 0; segno < cblk->real_num_segs; ++segno) {
1820                 opj_tcd_seg_t *seg = &cblk->segs[segno];
1821
1822                 /* BYPASS mode */
1823                 type = ((bpno <= ((OPJ_INT32) (cblk->numbps) - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
1824                 /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
1825                 if(seg->data == 00){
1826                         continue;
1827                 }
1828                 if (type == T1_TYPE_RAW) {
1829                         raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
1830                 } else {
1831                         mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);
1832                 }
1833
1834                 for (passno = 0; passno < seg->real_num_passes; ++passno) {
1835                         switch (passtype) {
1836                                 case 0:
1837                                         t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);
1838                                         break;
1839                                 case 1:
1840                                         t1_dec_refpass(t1, bpno+1, type, cblksty);
1841                                         break;
1842                                 case 2:
1843                                         t1_dec_clnpass(t1, bpno+1, orient, cblksty);
1844                                         break;
1845                         }
1846
1847                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
1848                                 mqc_resetstates(mqc);
1849                                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
1850                                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
1851                                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
1852                         }
1853                         if (++passtype == 3) {
1854                                 passtype = 0;
1855                                 bpno--;
1856                         }
1857                 }
1858         }
1859 }
1860
1861 static void t1_dec_refpass(
1862                 opj_t1_t *t1,
1863                 OPJ_INT32 bpno,
1864                 OPJ_BYTE type,
1865                 OPJ_UINT32 cblksty)
1866 {
1867         OPJ_UINT32 i, j, k;
1868         OPJ_INT32 one, poshalf, neghalf;
1869         OPJ_UINT32 vsc;
1870         one = 1 << bpno;
1871         poshalf = one >> 1;
1872         neghalf = bpno > 0 ? -poshalf : -1;
1873         for (k = 0; k < t1->h; k += 4) {
1874                 for (i = 0; i < t1->w; ++i) {
1875                         for (j = k; j < k + 4 && j < t1->h; ++j) {
1876                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
1877                                 t1_dec_refpass_step(
1878                                                 t1,
1879                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
1880                                                 &t1->data[(j * t1->w) + i],
1881                                                 poshalf,
1882                                                 neghalf,
1883                                                 type,
1884                                                 vsc);
1885                         }
1886                 }
1887         }
1888 }                               /* VSC and  BYPASS by Antonin */
1889
1890
1891 static void t1_dec_refpass_step(
1892                 opj_t1_t *t1,
1893                 flag_t *flagsp,
1894                 OPJ_INT32 *datap,
1895                 OPJ_INT32 poshalf,
1896                 OPJ_INT32 neghalf,
1897                 OPJ_BYTE type,
1898                 OPJ_UINT32 vsc)
1899 {
1900         OPJ_INT32  t;
1901         OPJ_UINT32 v,flag;
1902
1903         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1904         opj_raw_t *raw = t1->raw;       /* RAW component */
1905
1906         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
1907         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
1908                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
1909                 if (type == T1_TYPE_RAW) {
1910                         v = raw_decode(raw);
1911                 } else {
1912                         v = mqc_decode(mqc);
1913                 }
1914                 t = v ? poshalf : neghalf;
1915                 *datap += *datap < 0 ? -t : t;
1916                 *flagsp |= T1_REFINE;
1917         }
1918 }                               /* VSC and  BYPASS by Antonin  */
1919
1920 static void t1_dec_sigpass(
1921                 opj_t1_t *t1,
1922                 OPJ_INT32 bpno,
1923                 OPJ_UINT32 orient,
1924                 OPJ_BYTE type,
1925                 OPJ_UINT32 cblksty)
1926 {
1927         OPJ_UINT32 i, j, k, vsc;
1928         OPJ_INT32 one, half, oneplushalf;
1929         one = 1 << bpno;
1930         half = one >> 1;
1931         oneplushalf = one | half;
1932         for (k = 0; k < t1->h; k += 4) {
1933                 for (i = 0; i < t1->w; ++i) {
1934                         for (j = k; j < k + 4 && j < t1->h; ++j) {
1935                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
1936                                 t1_dec_sigpass_step(
1937                                                 t1,
1938                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
1939                                                 &t1->data[(j * t1->w) + i],
1940                                                 orient,
1941                                                 oneplushalf,
1942                                                 type,
1943                                                 vsc);
1944                         }
1945                 }
1946         }
1947 }                               /* VSC and  BYPASS by Antonin */
1948
1949 static void t1_dec_sigpass_step(
1950                 opj_t1_t *t1,
1951                 flag_t *flagsp,
1952                 OPJ_INT32 *datap,
1953                 OPJ_UINT32 orient,
1954                 OPJ_INT32 oneplushalf,
1955                 OPJ_BYTE type,
1956                 OPJ_UINT32 vsc)
1957 {
1958         OPJ_UINT32 v, flag;
1959
1960         opj_raw_t *raw = t1->raw;       /* RAW component */
1961         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
1962
1963         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
1964         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
1965                 if (type == T1_TYPE_RAW) {
1966                         if (raw_decode(raw)) {
1967                                 v = raw_decode(raw);    /* ESSAI */
1968                                 *datap = v ? -oneplushalf : oneplushalf;
1969                                 t1_updateflags(flagsp, v, t1->flags_stride);
1970                         }
1971                 } else {
1972                         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
1973                         if (mqc_decode(mqc)) {
1974                                 mqc_setcurctx(mqc, t1_getctxno_sc(flag));
1975                                 v = mqc_decode(mqc) ^ t1_getspb(flag);
1976                                 *datap = v ? -oneplushalf : oneplushalf;
1977                                 t1_updateflags(flagsp, v, t1->flags_stride);
1978                         }
1979                 }
1980                 *flagsp |= T1_VISIT;
1981         }
1982 }                               /* VSC and  BYPASS by Antonin */
1983