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 Decode significant pass
  64 */
  65 static void t1_dec_sigpass_step(
  66                 opj_t1_t *t1,
  67                 flag_t *flagsp,
  68                 int *datap,
  69                 int orient,
  70                 int oneplushalf,
  71                 char type,
  72                 int vsc);
  73 /**
  74 Encode significant pass
  75 */
  76 static void t1_enc_sigpass(
  77                 opj_t1_t *t1,
  78                 int bpno,
  79                 int orient,
  80                 int *nmsedec,
  81                 char type,
  82                 int cblksty);
  83 /**
  84 Decode significant pass
  85 */
  86 static void t1_dec_sigpass(
  87                 opj_t1_t *t1,
  88                 int bpno,
  89                 int orient,
  90                 char type,
  91                 int cblksty);
  92 /**
  93 Encode refinement pass
  94 */
  95 static void t1_enc_refpass_step(
  96                 opj_t1_t *t1,
  97                 flag_t *flagsp,
  98                 int *datap,
  99                 int bpno,
 100                 int one,
 101                 int *nmsedec,
 102                 char type,
 103                 int vsc);
 104 /**
 105 Decode refinement pass
 106 */
 107 static void t1_dec_refpass_step(
 108                 opj_t1_t *t1,
 109                 flag_t *flagsp,
 110                 int *datap,
 111                 int poshalf,
 112                 int neghalf,
 113                 char type,
 114                 int vsc);
 115 /**
 116 Encode refinement pass
 117 */
 118 static void t1_enc_refpass(
 119                 opj_t1_t *t1,
 120                 int bpno,
 121                 int *nmsedec,
 122                 char type,
 123                 int cblksty);
 124 /**
 125 Decode refinement pass
 126 */
 127 static void t1_dec_refpass(
 128                 opj_t1_t *t1,
 129                 int bpno,
 130                 char type,
 131                 int cblksty);
 132 /**
 133 Encode clean-up pass
 134 */
 135 static void t1_enc_clnpass_step(
 136                 opj_t1_t *t1,
 137                 flag_t *flagsp,
 138                 int *datap,
 139                 int orient,
 140                 int bpno,
 141                 int one,
 142                 int *nmsedec,
 143                 int partial,
 144                 int vsc);
 145 /**
 146 Decode clean-up pass
 147 */
 148 static void t1_dec_clnpass_step(
 149                 opj_t1_t *t1,
 150                 flag_t *flagsp,
 151                 int *datap,
 152                 int orient,
 153                 int oneplushalf,
 154                 int partial,
 155                 int vsc);
 156 /**
 157 Encode clean-up pass
 158 */
 159 static void t1_enc_clnpass(
 160                 opj_t1_t *t1,
 161                 int bpno,
 162                 int orient,
 163                 int *nmsedec,
 164                 int cblksty);
 165 /**
 166 Decode clean-up pass
 167 */
 168 static void t1_dec_clnpass(
 169                 opj_t1_t *t1,
 170                 int bpno,
 171                 int orient,
 172                 int cblksty);
 173 static double t1_getwmsedec(
 174                 int nmsedec,
 175                 int compno,
 176                 int level,
 177                 int orient,
 178                 int bpno,
 179                 int qmfbid,
 180                 double stepsize,
 181                 int numcomps);
 182 /**
 183 Encode 1 code-block
 184 @param t1 T1 handle
 185 @param cblk Code-block coding parameters
 186 @param orient
 187 @param compno Component number
 188 @param level
 189 @param qmfbid
 190 @param stepsize
 191 @param cblksty Code-block style
 192 @param numcomps
 193 @param tile
 194 */
 195 static void t1_encode_cblk(
 196                 opj_t1_t *t1,
 197                 opj_tcd_cblk_t * cblk,
 198                 int orient,
 199                 int compno,
 200                 int level,
 201                 int qmfbid,
 202                 double stepsize,
 203                 int cblksty,
 204                 int numcomps,
 205                 opj_tcd_tile_t * tile);
 206 /**
 207 Decode 1 code-block
 208 @param t1 T1 handle
 209 @param cblk Code-block coding parameters
 210 @param orient
 211 @param roishift Region of interest shifting value
 212 @param cblksty Code-block style
 213 */
 214 static void t1_decode_cblk(
 215                 opj_t1_t *t1,
 216                 opj_tcd_cblk_t * cblk,
 217                 int orient,
 218                 int roishift,
 219                 int cblksty);
 220
 221 /*@}*/
 222
 223 /*@}*/
 224
 225 /* ----------------------------------------------------------------------- */
 226
 227 static char t1_getctxno_zc(int f, int orient) {
 228         return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
 229 }
 230
 231 static char t1_getctxno_sc(int f) {
 232         return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 233 }
 234
 235 static int t1_getctxno_mag(int f) {
 236         int tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
 237         int tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
 238         return (tmp2);
 239 }
 240
 241 static char t1_getspb(int f) {
 242         return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
 243 }
 244
 245 static short t1_getnmsedec_sig(int x, int bitpos) {
 246         if (bitpos > T1_NMSEDEC_FRACBITS) {
 247                 return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 248         }
 249
 250         return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 251 }
 252
 253 static short t1_getnmsedec_ref(int x, int bitpos) {
 254         if (bitpos > T1_NMSEDEC_FRACBITS) {
 255                 return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
 256         }
 257
 258     return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
 259 }
 260
 261 static void t1_updateflags(flag_t *flagsp, int s, int stride) {
 262         flag_t *np = flagsp - stride;
 263         flag_t *sp = flagsp + stride;
 264
 265         static const flag_t mod[] = {
 266                 T1_SIG_S, T1_SIG_S|T1_SGN_S,
 267                 T1_SIG_E, T1_SIG_E|T1_SGN_E,
 268                 T1_SIG_W, T1_SIG_W|T1_SGN_W,
 269                 T1_SIG_N, T1_SIG_N|T1_SGN_N
 270         };
 271
 272         np[-1] |= T1_SIG_SE;
 273         np[0]  |= mod[s];
 274         np[1]  |= T1_SIG_SW;
 275
 276         flagsp[-1] |= mod[s+2];
 277         flagsp[0]  |= T1_SIG;
 278         flagsp[1]  |= mod[s+4];
 279
 280         sp[-1] |= T1_SIG_NE;
 281         sp[0]  |= mod[s+6];
 282         sp[1]  |= T1_SIG_NW;
 283 }
 284
 285 static void t1_enc_sigpass_step(
 286                 opj_t1_t *t1,
 287                 flag_t *flagsp,
 288                 int *datap,
 289                 int orient,
 290                 int bpno,
 291                 int one,
 292                 int *nmsedec,
 293                 char type,
 294                 int vsc)
 295 {
 296         int v, flag;
 297
 298         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 299
 300         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 301         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 302                 v = int_abs(*datap) & one ? 1 : 0;
 303                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));       /* ESSAI */
 304                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 305                         mqc_bypass_enc(mqc, v);
 306                 } else {
 307                         mqc_encode(mqc, v);
 308                 }
 309                 if (v) {
 310                         v = *datap < 0 ? 1 : 0;
 311                         *nmsedec +=     t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 312                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));       /* ESSAI */
 313                         if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 314                                 mqc_bypass_enc(mqc, v);
 315                         } else {
 316                                 mqc_encode(mqc, v ^ t1_getspb(flag));
 317                         }
 318                         t1_updateflags(flagsp, v, t1->flags_stride);
 319                 }
 320                 *flagsp |= T1_VISIT;
 321         }
 322 }
 323
 324 static void t1_dec_sigpass_step(
 325                 opj_t1_t *t1,
 326                 flag_t *flagsp,
 327                 int *datap,
 328                 int orient,
 329                 int oneplushalf,
 330                 char type,
 331                 int vsc)
 332 {
 333         int v, flag;
 334
 335         opj_raw_t *raw = t1->raw;       /* RAW component */
 336         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 337
 338         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 339         if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
 340                 if (type == T1_TYPE_RAW) {
 341                         if (raw_decode(raw)) {
 342                                 v = raw_decode(raw);    /* ESSAI */
 343                                 *datap = v ? -oneplushalf : oneplushalf;
 344                                 t1_updateflags(flagsp, v, t1->flags_stride);
 345                         }
 346                 } else {
 347                         mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 348                         if (mqc_decode(mqc)) {
 349                                 mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 350                                 v = mqc_decode(mqc) ^ t1_getspb(flag);
 351                                 *datap = v ? -oneplushalf : oneplushalf;
 352                                 t1_updateflags(flagsp, v, t1->flags_stride);
 353                         }
 354                 }
 355                 *flagsp |= T1_VISIT;
 356         }
 357 }                               /* VSC and  BYPASS by Antonin */
 358
 359 static void t1_enc_sigpass(
 360                 opj_t1_t *t1,
 361                 int bpno,
 362                 int orient,
 363                 int *nmsedec,
 364                 char type,
 365                 int cblksty)
 366 {
 367         int i, j, k, one, vsc;
 368         *nmsedec = 0;
 369         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 370         for (k = 0; k < t1->h; k += 4) {
 371                 for (i = 0; i < t1->w; ++i) {
 372                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 373                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 374                                 t1_enc_sigpass_step(
 375                                                 t1,
 376                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 377                                                 &t1->data[(j * t1->w) + i],
 378                                                 orient,
 379                                                 bpno,
 380                                                 one,
 381                                                 nmsedec,
 382                                                 type,
 383                                                 vsc);
 384                         }
 385                 }
 386         }
 387 }
 388
 389 static void t1_dec_sigpass(
 390                 opj_t1_t *t1,
 391                 int bpno,
 392                 int orient,
 393                 char type,
 394                 int cblksty)
 395 {
 396         int i, j, k, one, half, oneplushalf, vsc;
 397         one = 1 << bpno;
 398         half = one >> 1;
 399         oneplushalf = one | half;
 400         for (k = 0; k < t1->h; k += 4) {
 401                 for (i = 0; i < t1->w; ++i) {
 402                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 403                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 404                                 t1_dec_sigpass_step(
 405                                                 t1,
 406                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 407                                                 &t1->data[(j * t1->w) + i],
 408                                                 orient,
 409                                                 oneplushalf,
 410                                                 type,
 411                                                 vsc);
 412                         }
 413                 }
 414         }
 415 }                               /* VSC and  BYPASS by Antonin */
 416
 417 static void t1_enc_refpass_step(
 418                 opj_t1_t *t1,
 419                 flag_t *flagsp,
 420                 int *datap,
 421                 int bpno,
 422                 int one,
 423                 int *nmsedec,
 424                 char type,
 425                 int vsc)
 426 {
 427         int v, flag;
 428
 429         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 430
 431         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 432         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 433                 *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 434                 v = int_abs(*datap) & one ? 1 : 0;
 435                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 436                 if (type == T1_TYPE_RAW) {      /* BYPASS/LAZY MODE */
 437                         mqc_bypass_enc(mqc, v);
 438                 } else {
 439                         mqc_encode(mqc, v);
 440                 }
 441                 *flagsp |= T1_REFINE;
 442         }
 443 }
 444
 445 static void t1_dec_refpass_step(
 446                 opj_t1_t *t1,
 447                 flag_t *flagsp,
 448                 int *datap,
 449                 int poshalf,
 450                 int neghalf,
 451                 char type,
 452                 int vsc)
 453 {
 454         int v, t, flag;
 455
 456         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 457         opj_raw_t *raw = t1->raw;       /* RAW component */
 458
 459         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 460         if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
 461                 mqc_setcurctx(mqc, t1_getctxno_mag(flag));      /* ESSAI */
 462                 if (type == T1_TYPE_RAW) {
 463                         v = raw_decode(raw);
 464                 } else {
 465                         v = mqc_decode(mqc);
 466                 }
 467                 t = v ? poshalf : neghalf;
 468                 *datap += *datap < 0 ? -t : t;
 469                 *flagsp |= T1_REFINE;
 470         }
 471 }                               /* VSC and  BYPASS by Antonin  */
 472
 473 static void t1_enc_refpass(
 474                 opj_t1_t *t1,
 475                 int bpno,
 476                 int *nmsedec,
 477                 char type,
 478                 int cblksty)
 479 {
 480         int i, j, k, one, vsc;
 481         *nmsedec = 0;
 482         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 483         for (k = 0; k < t1->h; k += 4) {
 484                 for (i = 0; i < t1->w; ++i) {
 485                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 486                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 487                                 t1_enc_refpass_step(
 488                                                 t1,
 489                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 490                                                 &t1->data[(j * t1->w) + i],
 491                                                 bpno,
 492                                                 one,
 493                                                 nmsedec,
 494                                                 type,
 495                                                 vsc);
 496                         }
 497                 }
 498         }
 499 }
 500
 501 static void t1_dec_refpass(
 502                 opj_t1_t *t1,
 503                 int bpno,
 504                 char type,
 505                 int cblksty)
 506 {
 507         int i, j, k, one, poshalf, neghalf;
 508         int vsc;
 509         one = 1 << bpno;
 510         poshalf = one >> 1;
 511         neghalf = bpno > 0 ? -poshalf : -1;
 512         for (k = 0; k < t1->h; k += 4) {
 513                 for (i = 0; i < t1->w; ++i) {
 514                         for (j = k; j < k + 4 && j < t1->h; ++j) {
 515                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 516                                 t1_dec_refpass_step(
 517                                                 t1,
 518                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 519                                                 &t1->data[(j * t1->w) + i],
 520                                                 poshalf,
 521                                                 neghalf,
 522                                                 type,
 523                                                 vsc);
 524                         }
 525                 }
 526         }
 527 }                               /* VSC and  BYPASS by Antonin */
 528
 529 static void t1_enc_clnpass_step(
 530                 opj_t1_t *t1,
 531                 flag_t *flagsp,
 532                 int *datap,
 533                 int orient,
 534                 int bpno,
 535                 int one,
 536                 int *nmsedec,
 537                 int partial,
 538                 int vsc)
 539 {
 540         int v, flag;
 541
 542         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 543
 544         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 545         if (partial) {
 546                 goto LABEL_PARTIAL;
 547         }
 548         if (!(*flagsp & (T1_SIG | T1_VISIT))) {
 549                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 550                 v = int_abs(*datap) & one ? 1 : 0;
 551                 mqc_encode(mqc, v);
 552                 if (v) {
 553 LABEL_PARTIAL:
 554                         *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
 555                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 556                         v = *datap < 0 ? 1 : 0;
 557                         mqc_encode(mqc, v ^ t1_getspb(flag));
 558                         t1_updateflags(flagsp, v, t1->flags_stride);
 559                 }
 560         }
 561         *flagsp &= ~T1_VISIT;
 562 }
 563
 564 static void t1_dec_clnpass_step(
 565                 opj_t1_t *t1,
 566                 flag_t *flagsp,
 567                 int *datap,
 568                 int orient,
 569                 int oneplushalf,
 570                 int partial,
 571                 int vsc)
 572 {
 573         int v, flag;
 574
 575         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 576
 577         flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
 578         if (partial) {
 579                 goto LABEL_PARTIAL;
 580         }
 581         if (!(flag & (T1_SIG | T1_VISIT))) {
 582                 mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
 583                 if (mqc_decode(mqc)) {
 584 LABEL_PARTIAL:
 585                         mqc_setcurctx(mqc, t1_getctxno_sc(flag));
 586                         v = mqc_decode(mqc) ^ t1_getspb(flag);
 587                         *datap = v ? -oneplushalf : oneplushalf;
 588                         t1_updateflags(flagsp, v, t1->flags_stride);
 589                 }
 590         }
 591         *flagsp &= ~T1_VISIT;
 592 }                               /* VSC and  BYPASS by Antonin */
 593
 594 static void t1_enc_clnpass(
 595                 opj_t1_t *t1,
 596                 int bpno,
 597                 int orient,
 598                 int *nmsedec,
 599                 int cblksty)
 600 {
 601         int i, j, k, one, agg, runlen, vsc;
 602
 603         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 604
 605         *nmsedec = 0;
 606         one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
 607         for (k = 0; k < t1->h; k += 4) {
 608                 for (i = 0; i < t1->w; ++i) {
 609                         if (k + 3 < t1->h) {
 610                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
 611                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 612                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 613                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 614                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
 615                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 616                                 } else {
 617                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 618                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 619                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 620                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 621                                 }
 622                         } else {
 623                                 agg = 0;
 624                         }
 625                         if (agg) {
 626                                 for (runlen = 0; runlen < 4; ++runlen) {
 627                                         if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
 628                                                 break;
 629                                 }
 630                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
 631                                 mqc_encode(mqc, runlen != 4);
 632                                 if (runlen == 4) {
 633                                         continue;
 634                                 }
 635                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
 636                                 mqc_encode(mqc, runlen >> 1);
 637                                 mqc_encode(mqc, runlen & 1);
 638                         } else {
 639                                 runlen = 0;
 640                         }
 641                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
 642                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 643                                 t1_enc_clnpass_step(
 644                                                 t1,
 645                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 646                                                 &t1->data[(j * t1->w) + i],
 647                                                 orient,
 648                                                 bpno,
 649                                                 one,
 650                                                 nmsedec,
 651                                                 agg && (j == k + runlen),
 652                                                 vsc);
 653                         }
 654                 }
 655         }
 656 }
 657
 658 static void t1_dec_clnpass(
 659                 opj_t1_t *t1,
 660                 int bpno,
 661                 int orient,
 662                 int cblksty)
 663 {
 664         int i, j, k, one, half, oneplushalf, agg, runlen, vsc;
 665         int segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
 666
 667         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 668
 669         one = 1 << bpno;
 670         half = one >> 1;
 671         oneplushalf = one | half;
 672         for (k = 0; k < t1->h; k += 4) {
 673                 for (i = 0; i < t1->w; ++i) {
 674                         if (k + 3 < t1->h) {
 675                                 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
 676                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 677                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 678                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 679                                                 || (MACRO_t1_flags(1 + k + 3,1 + i)
 680                                                 & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 681                                 } else {
 682                                         agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 683                                                 || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 684                                                 || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
 685                                                 || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
 686                                 }
 687                         } else {
 688                                 agg = 0;
 689                         }
 690                         if (agg) {
 691                                 mqc_setcurctx(mqc, T1_CTXNO_AGG);
 692                                 if (!mqc_decode(mqc)) {
 693                                         continue;
 694                                 }
 695                                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
 696                                 runlen = mqc_decode(mqc);
 697                                 runlen = (runlen << 1) | mqc_decode(mqc);
 698                         } else {
 699                                 runlen = 0;
 700                         }
 701                         for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
 702                                 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
 703                                 t1_dec_clnpass_step(
 704                                                 t1,
 705                                                 &t1->flags[((j+1) * t1->flags_stride) + i + 1],
 706                                                 &t1->data[(j * t1->w) + i],
 707                                                 orient,
 708                                                 oneplushalf,
 709                                                 agg && (j == k + runlen),
 710                                                 vsc);
 711                         }
 712                 }
 713         }
 714         if (segsym) {
 715                 int v = 0;
 716                 mqc_setcurctx(mqc, T1_CTXNO_UNI);
 717                 v = mqc_decode(mqc);
 718                 v = (v << 1) | mqc_decode(mqc);
 719                 v = (v << 1) | mqc_decode(mqc);
 720                 v = (v << 1) | mqc_decode(mqc);
 721                 /*
 722                 if (v!=0xa) {
 723                         opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
 724                 }
 725                 */
 726         }
 727 }                               /* VSC and  BYPASS by Antonin */
 728
 729
 730 /** mod fixed_quality */
 731 static double t1_getwmsedec(
 732                 int nmsedec,
 733                 int compno,
 734                 int level,
 735                 int orient,
 736                 int bpno,
 737                 int qmfbid,
 738                 double stepsize,
 739                 int numcomps)
 740 {
 741         double w1, w2, wmsedec;
 742         if (qmfbid == 1) {
 743                 w1 = (numcomps > 1) ? mct_getnorm(compno) : 1.0;
 744                 w2 = dwt_getnorm(level, orient);
 745         } else {                        /* if (qmfbid == 0) */
 746                 w1 = (numcomps > 1) ? mct_getnorm_real(compno) : 1.0;
 747                 w2 = dwt_getnorm_real(level, orient);
 748         }
 749         wmsedec = w1 * w2 * stepsize * (1 << bpno);
 750         wmsedec *= wmsedec * nmsedec / 8192.0;
 751
 752         return wmsedec;
 753 }
 754
 755 static bool allocate_buffers(
 756                 opj_t1_t *t1,
 757                 int w,
 758                 int h)
 759 {
 760         int datasize=w * h;
 761         int flagssize;
 762
 763         if(datasize > t1->datasize){
 764                 opj_aligned_free(t1->data);
 765                 t1->data=opj_aligned_malloc(datasize * sizeof(int));
 766                 if(!t1->data){
 767                         return false;
 768                 }
 769                 t1->datasize=datasize;
 770         }
 771         memset(t1->data,0,datasize * sizeof(int));
 772
 773         t1->flags_stride=w+2;
 774         flagssize=t1->flags_stride * (h+2);
 775
 776         if(flagssize > t1->flagssize){
 777                 opj_aligned_free(t1->flags);
 778                 t1->flags=opj_aligned_malloc(flagssize * sizeof(flag_t));
 779                 if(!t1->flags){
 780                         return false;
 781                 }
 782                 t1->flagssize=flagssize;
 783         }
 784         memset(t1->flags,0,flagssize * sizeof(flag_t));
 785
 786         t1->w=w;
 787         t1->h=h;
 788
 789         return true;
 790 }
 791
 792 /** mod fixed_quality */
 793 static void t1_encode_cblk(
 794                 opj_t1_t *t1,
 795                 opj_tcd_cblk_t * cblk,
 796                 int orient,
 797                 int compno,
 798                 int level,
 799                 int qmfbid,
 800                 double stepsize,
 801                 int cblksty,
 802                 int numcomps,
 803                 opj_tcd_tile_t * tile)
 804 {
 805         int i, j;
 806         int passno;
 807         int bpno, passtype;
 808         int max;
 809         int nmsedec = 0;
 810         double cumwmsedec = 0.0;
 811         char type = T1_TYPE_MQ;
 812
 813         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 814
 815         max = 0;
 816         for (j = 0; j < t1->h; ++j) {
 817                 for (i = 0; i < t1->w; ++i) {
 818                         max = int_max(max, int_abs(t1->data[(j * t1->w) + i]));
 819                 }
 820         }
 821
 822         cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
 823
 824         bpno = cblk->numbps - 1;
 825         passtype = 2;
 826
 827         mqc_resetstates(mqc);
 828         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
 829         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
 830         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
 831         mqc_init_enc(mqc, cblk->data);
 832
 833         for (passno = 0; bpno >= 0; ++passno) {
 834                 opj_tcd_pass_t *pass = &cblk->passes[passno];
 835                 int correction = 3;
 836                 type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
 837
 838                 switch (passtype) {
 839                         case 0:
 840                                 t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
 841                                 break;
 842                         case 1:
 843                                 t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
 844                                 break;
 845                         case 2:
 846                                 t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
 847                                 /* code switch SEGMARK (i.e. SEGSYM) */
 848                                 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
 849                                         mqc_segmark_enc(mqc);
 850                                 break;
 851                 }
 852
 853                 /* fixed_quality */
 854                 cumwmsedec += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps);
 855                 tile->distotile += t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps);
 856
 857                 /* Code switch "RESTART" (i.e. TERMALL) */
 858                 if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
 859                         if (type == T1_TYPE_RAW) {
 860                                 mqc_flush(mqc);
 861                                 correction = 1;
 862                                 /* correction = mqc_bypass_flush_enc(); */
 863                         } else {                        /* correction = mqc_restart_enc(); */
 864                                 mqc_flush(mqc);
 865                                 correction = 1;
 866                         }
 867                         pass->term = 1;
 868                 } else {
 869                         if (((bpno < (cblk->numbps - 4) && (passtype > 0))
 870                                 || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
 871                                 if (type == T1_TYPE_RAW) {
 872                                         mqc_flush(mqc);
 873                                         correction = 1;
 874                                         /* correction = mqc_bypass_flush_enc(); */
 875                                 } else {                /* correction = mqc_restart_enc(); */
 876                                         mqc_flush(mqc);
 877                                         correction = 1;
 878                                 }
 879                                 pass->term = 1;
 880                         } else {
 881                                 pass->term = 0;
 882                         }
 883                 }
 884
 885                 if (++passtype == 3) {
 886                         passtype = 0;
 887                         bpno--;
 888                 }
 889
 890                 if (pass->term && bpno > 0) {
 891                         type = ((bpno < (cblk->numbps - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
 892                         if (type == T1_TYPE_RAW)
 893                                 mqc_bypass_init_enc(mqc);
 894                         else
 895                                 mqc_restart_init_enc(mqc);
 896                 }
 897
 898                 pass->distortiondec = cumwmsedec;
 899                 pass->rate = mqc_numbytes(mqc) + correction;    /* FIXME */
 900
 901                 /* Code-switch "RESET" */
 902                 if (cblksty & J2K_CCP_CBLKSTY_RESET)
 903                         mqc_reset_enc(mqc);
 904         }
 905
 906         /* Code switch "ERTERM" (i.e. PTERM) */
 907         if (cblksty & J2K_CCP_CBLKSTY_PTERM)
 908                 mqc_erterm_enc(mqc);
 909         else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
 910                 mqc_flush(mqc);
 911
 912         cblk->totalpasses = passno;
 913
 914         for (passno = 0; passno<cblk->totalpasses; passno++) {
 915                 opj_tcd_pass_t *pass = &cblk->passes[passno];
 916                 if (pass->rate > mqc_numbytes(mqc))
 917                         pass->rate = mqc_numbytes(mqc);
 918                 /*Preventing generation of FF as last data byte of a pass*/
 919                 if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
 920                         pass->rate--;
 921                 }
 922                 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
 923         }
 924 }
 925
 926 static void t1_decode_cblk(
 927                 opj_t1_t *t1,
 928                 opj_tcd_cblk_t * cblk,
 929                 int orient,
 930                 int roishift,
 931                 int cblksty)
 932 {
 933         int bpno, passtype;
 934         int segno, passno;
 935         char type = T1_TYPE_MQ; /* BYPASS mode */
 936
 937         opj_raw_t *raw = t1->raw;       /* RAW component */
 938         opj_mqc_t *mqc = t1->mqc;       /* MQC component */
 939
 940         if(!allocate_buffers(
 941                                 t1,
 942                                 cblk->x1 - cblk->x0,
 943                                 cblk->y1 - cblk->y0))
 944         {
 945                 return;
 946         }
 947
 948         bpno = roishift + cblk->numbps - 1;
 949         passtype = 2;
 950
 951         mqc_resetstates(mqc);
 952         mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
 953         mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
 954         mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
 955
 956         for (segno = 0; segno < cblk->numsegs; ++segno) {
 957                 opj_tcd_seg_t *seg = &cblk->segs[segno];
 958
 959                 /* BYPASS mode */
 960                 type = ((bpno <= (cblk->numbps - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
 961                 if (type == T1_TYPE_RAW) {
 962                         raw_init_dec(raw, seg->data, seg->len);
 963                 } else {
 964                         mqc_init_dec(mqc, seg->data, seg->len);
 965                 }
 966
 967                 for (passno = 0; passno < seg->numpasses; ++passno) {
 968                         switch (passtype) {
 969                                 case 0:
 970                                         t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);
 971                                         break;
 972                                 case 1:
 973                                         t1_dec_refpass(t1, bpno+1, type, cblksty);
 974                                         break;
 975                                 case 2:
 976                                         t1_dec_clnpass(t1, bpno+1, orient, cblksty);
 977                                         break;
 978                         }
 979
 980                         if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
 981                                 mqc_resetstates(mqc);
 982                                 mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
 983                                 mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
 984                                 mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
 985                         }
 986                         if (++passtype == 3) {
 987                                 passtype = 0;
 988                                 bpno--;
 989                         }
 990                 }
 991         }
 992 }
 993
 994 /* ----------------------------------------------------------------------- */
 995
 996 opj_t1_t* t1_create(opj_common_ptr cinfo) {
 997         opj_t1_t *t1 = (opj_t1_t*) malloc(sizeof(opj_t1_t));
 998         if(!t1)
 999                 return NULL;
1000
1001                 t1->cinfo = cinfo;
1002                 /* create MQC and RAW handles */
1003                 t1->mqc = mqc_create();
1004                 t1->raw = raw_create();
1005
1006         t1->datasize=0;
1007         t1->data=NULL;
1008         t1->flagssize=0;
1009         t1->flags=NULL;
1010
1011         return t1;
1012 }
1013
1014 void t1_destroy(opj_t1_t *t1) {
1015         if(t1) {
1016                 /* destroy MQC and RAW handles */
1017                 mqc_destroy(t1->mqc);
1018                 raw_destroy(t1->raw);
1019                 opj_aligned_free(t1->data);
1020                 opj_aligned_free(t1->flags);
1021                 free(t1);
1022         }
1023 }
1024
1025 void t1_encode_cblks(
1026                 opj_t1_t *t1,
1027                 opj_tcd_tile_t *tile,
1028                 opj_tcp_t *tcp)
1029 {
1030         int compno, resno, bandno, precno, cblkno;
1031
1032         tile->distotile = 0;            /* fixed_quality */
1033
1034         for (compno = 0; compno < tile->numcomps; ++compno) {
1035                 opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
1036
1037                 for (resno = 0; resno < tilec->numresolutions; ++resno) {
1038                         opj_tcd_resolution_t *res = &tilec->resolutions[resno];
1039
1040                         for (bandno = 0; bandno < res->numbands; ++bandno) {
1041                                 opj_tcd_band_t *band = &res->bands[bandno];
1042
1043                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1044                                         opj_tcd_precinct_t *prc = &band->precincts[precno];
1045
1046                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1047                                                 int x, y, w, i, j;
1048                                                 opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
1049
1050                                                 x = cblk->x0 - band->x0;
1051                                                 y = cblk->y0 - band->y0;
1052                                                 if (band->bandno & 1) {
1053                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1054                                                         x += pres->x1 - pres->x0;
1055                                                 }
1056                                                 if (band->bandno & 2) {
1057                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1058                                                         y += pres->y1 - pres->y0;
1059                                                 }
1060
1061                                                 if(!allocate_buffers(
1062                                                                         t1,
1063                                                                         cblk->x1 - cblk->x0,
1064                                                                         cblk->y1 - cblk->y0))
1065                                                 {
1066                                                         return;
1067                                                 }
1068
1069                                                 w = tilec->x1 - tilec->x0;
1070                                                 if (tcp->tccps[compno].qmfbid == 1) {
1071                                                         for (j = 0; j < t1->h; ++j) {
1072                                                                 for (i = 0; i < t1->w; ++i) {
1073                                                                         t1->data[(j * t1->w) + i] =
1074                                                                                 tilec->data[(x + i) + (y + j) * w] << T1_NMSEDEC_FRACBITS;
1075                                                                 }
1076                                                         }
1077                                                 } else {                /* if (tcp->tccps[compno].qmfbid == 0) */
1078                                                         for (j = 0; j < t1->h; ++j) {
1079                                                                 for (i = 0; i < t1->w; ++i) {
1080                                                                         t1->data[(j * t1->w) + i] =
1081                                                                                 fix_mul(
1082                                                                                 tilec->data[x + i + (y + j) * w],
1083                                                                                 8192 * 8192 / ((int) floor(band->stepsize * 8192))) >> (11 - T1_NMSEDEC_FRACBITS);
1084                                                                 }
1085                                                         }
1086                                                 }
1087
1088                                                 t1_encode_cblk(
1089                                                                 t1,
1090                                                                 cblk,
1091                                                                 band->bandno,
1092                                                                 compno,
1093                                                                 tilec->numresolutions - 1 - resno,
1094                                                                 tcp->tccps[compno].qmfbid,
1095                                                                 band->stepsize,
1096                                                                 tcp->tccps[compno].cblksty,
1097                                                                 tile->numcomps,
1098                                                                 tile);
1099
1100                                         } /* cblkno */
1101                                 } /* precno */
1102                         } /* bandno */
1103                 } /* resno  */
1104         } /* compno  */
1105 }
1106
1107 void t1_decode_cblks(
1108                 opj_t1_t *t1,
1109                 opj_tcd_tile_t *tile,
1110                 opj_tcp_t *tcp)
1111 {
1112         int compno, resno, bandno, precno, cblkno;
1113
1114         for (compno = 0; compno < tile->numcomps; ++compno) {
1115                 opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
1116
1117                 for (resno = 0; resno < tilec->numresolutions; ++resno) {
1118                         opj_tcd_resolution_t *res = &tilec->resolutions[resno];
1119
1120                         for (bandno = 0; bandno < res->numbands; ++bandno) {
1121                                 opj_tcd_band_t *band = &res->bands[bandno];
1122
1123                                 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1124                                         opj_tcd_precinct_t *prc = &band->precincts[precno];
1125
1126                                         for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
1127                                                 int x, y, w, i, j, cblk_w, cblk_h;
1128                                                 opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
1129
1130                                                 t1_decode_cblk(
1131                                                                 t1,
1132                                                                 cblk,
1133                                                                 band->bandno,
1134                                                                 tcp->tccps[compno].roishift,
1135                                                                 tcp->tccps[compno].cblksty);
1136
1137                                                 x = cblk->x0 - band->x0;
1138                                                 y = cblk->y0 - band->y0;
1139                                                 if (band->bandno & 1) {
1140                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1141                                                         x += pres->x1 - pres->x0;
1142                                                 }
1143                                                 if (band->bandno & 2) {
1144                                                         opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
1145                                                         y += pres->y1 - pres->y0;
1146                                                 }
1147
1148                                                 cblk_w = cblk->x1 - cblk->x0;
1149                                                 cblk_h = cblk->y1 - cblk->y0;
1150
1151                                                 if (tcp->tccps[compno].roishift) {
1152                                                         int thresh = 1 << tcp->tccps[compno].roishift;
1153                                                         for (j = 0; j < cblk_h; ++j) {
1154                                                                 for (i = 0; i < cblk_w; ++i) {
1155                                                                         int val = t1->data[(j * t1->w) + i];
1156                                                                         int mag = int_abs(val);
1157                                                                         if (mag >= thresh) {
1158                                                                                 mag >>= tcp->tccps[compno].roishift;
1159                                                                                 t1->data[(j * t1->w) + i] = val < 0 ? -mag : mag;
1160                                                                         }
1161                                                                 }
1162                                                         }
1163                                                 }
1164
1165                                                 w = tilec->x1 - tilec->x0;
1166                                                 if (tcp->tccps[compno].qmfbid == 1) {
1167                                                         for (j = 0; j < cblk_h; ++j) {
1168                                                                 for (i = 0; i < cblk_w; ++i) {
1169                                                                         tilec->data[x + i + (y + j) * w] = t1->data[(j * t1->w) + i]/2;
1170                                                                 }
1171                                                         }
1172                                                 } else {                /* if (tcp->tccps[compno].qmfbid == 0) */
1173                                                         for (j = 0; j < cblk_h; ++j) {
1174                                                                 for (i = 0; i < cblk_w; ++i) {
1175                                                                         if (t1->data[(j * t1->w) + i] >> 1 == 0) {
1176                                                                                 tilec->data[x + i + (y + j) * w] = 0;
1177                                                                         } else {
1178                                                                                 double tmp = (double)(t1->data[(j * t1->w) + i] * band->stepsize * 4096.0);
1179                                                                                 int tmp2 = ((int) (floor(fabs(tmp)))) + ((int) floor(fabs(tmp*2))%2);
1180                                                                                 tilec->data[x + i + (y + j) * w] = ((tmp<0)?-tmp2:tmp2);
1181                                                                         }
1182                                                                 }
1183                                                         }
1184                                                 }
1185                                         } /* cblkno */
1186                                 } /* precno */
1187                         } /* bandno */
1188                 } /* resno */
1189         } /* compno */
1190 }
1191