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