Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/openjpeg/src/lib/openjp2/t1.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /*
2 * The copyright in this software is being made available under the 2-clauses
3 * BSD License, included below. This software may be subject to other third
4 * party and contributor rights, including patent rights, and no such rights
5 * are granted under this license.
6 *
7 * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
8 * Copyright (c) 2002-2014, Professor Benoit Macq
9 * Copyright (c) 2001-2003, David Janssens
10 * Copyright (c) 2002-2003, Yannick Verschueren
11 * Copyright (c) 2003-2007, Francois-Olivier Devaux
12 * Copyright (c) 2003-2014, Antonin Descampe
13 * Copyright (c) 2005, Herve Drolon, FreeImage Team
14 * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
15 * Copyright (c) 2012, Carl Hetherington
16 * Copyright (c) 2017, IntoPIX SA <support@intopix.com>
17 * All rights reserved.
18 *
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions
21 * are met:
22 * 1. Redistributions of source code must retain the above copyright
23 * notice, this list of conditions and the following disclaimer.
24 * 2. Redistributions in binary form must reproduce the above copyright
25 * notice, this list of conditions and the following disclaimer in the
26 * documentation and/or other materials provided with the distribution.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
29 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
32 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38 * POSSIBILITY OF SUCH DAMAGE.
39 */
40
41 #define OPJ_SKIP_POISON
42 #include "opj_includes.h"
43
44 #ifdef __SSE__
45 #include <xmmintrin.h>
46 #endif
47 #ifdef __SSE2__
48 #include <emmintrin.h>
49 #endif
50 #if (defined(__AVX2__) || defined(__AVX512F__))
51 #include <immintrin.h>
52 #endif
53
54 #if defined(__GNUC__)
55 #pragma GCC poison malloc calloc realloc free
56 #endif
57
58 #include "t1_luts.h"
59
60 /** @defgroup T1 T1 - Implementation of the tier-1 coding */
61 /*@{*/
62
63 #define T1_FLAGS(x, y) (t1->flags[x + 1 + ((y / 4) + 1) * (t1->w+2)])
64
65 #define opj_t1_setcurctx(curctx, ctxno) curctx = &(mqc)->ctxs[(OPJ_UINT32)(ctxno)]
66
67 /* Macros to deal with signed integer with just MSB bit set for
68 * negative values (smr = signed magnitude representation) */
69 #define opj_smr_abs(x) (((OPJ_UINT32)(x)) & 0x7FFFFFFFU)
70 #define opj_smr_sign(x) (((OPJ_UINT32)(x)) >> 31)
71 #define opj_to_smr(x) ((x) >= 0 ? (OPJ_UINT32)(x) : ((OPJ_UINT32)(-x) | 0x80000000U))
72
73
74 /** @name Local static functions */
75 /*@{*/
76
77 static INLINE OPJ_BYTE opj_t1_getctxno_zc(opj_mqc_t *mqc, OPJ_UINT32 f);
78 static INLINE OPJ_UINT32 opj_t1_getctxno_mag(OPJ_UINT32 f);
79 static OPJ_INT16 opj_t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos);
80 static OPJ_INT16 opj_t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos);
81 static INLINE void opj_t1_update_flags(opj_flag_t *flagsp, OPJ_UINT32 ci,
82 OPJ_UINT32 s, OPJ_UINT32 stride,
83 OPJ_UINT32 vsc);
84
85
86 /**
87 Decode significant pass
88 */
89
90 static INLINE void opj_t1_dec_sigpass_step_raw(
91 opj_t1_t *t1,
92 opj_flag_t *flagsp,
93 OPJ_INT32 *datap,
94 OPJ_INT32 oneplushalf,
95 OPJ_UINT32 vsc,
96 OPJ_UINT32 row);
97 static INLINE void opj_t1_dec_sigpass_step_mqc(
98 opj_t1_t *t1,
99 opj_flag_t *flagsp,
100 OPJ_INT32 *datap,
101 OPJ_INT32 oneplushalf,
102 OPJ_UINT32 row,
103 OPJ_UINT32 flags_stride,
104 OPJ_UINT32 vsc);
105
106 /**
107 Encode significant pass
108 */
109 static void opj_t1_enc_sigpass(opj_t1_t *t1,
110 OPJ_INT32 bpno,
111 OPJ_INT32 *nmsedec,
112 OPJ_BYTE type,
113 OPJ_UINT32 cblksty);
114
115 /**
116 Decode significant pass
117 */
118 static void opj_t1_dec_sigpass_raw(
119 opj_t1_t *t1,
120 OPJ_INT32 bpno,
121 OPJ_INT32 cblksty);
122
123 /**
124 Encode refinement pass
125 */
126 static void opj_t1_enc_refpass(opj_t1_t *t1,
127 OPJ_INT32 bpno,
128 OPJ_INT32 *nmsedec,
129 OPJ_BYTE type);
130
131 /**
132 Decode refinement pass
133 */
134 static void opj_t1_dec_refpass_raw(
135 opj_t1_t *t1,
136 OPJ_INT32 bpno);
137
138
139 /**
140 Decode refinement pass
141 */
142
143 static INLINE void opj_t1_dec_refpass_step_raw(
144 opj_t1_t *t1,
145 opj_flag_t *flagsp,
146 OPJ_INT32 *datap,
147 OPJ_INT32 poshalf,
148 OPJ_UINT32 row);
149 static INLINE void opj_t1_dec_refpass_step_mqc(
150 opj_t1_t *t1,
151 opj_flag_t *flagsp,
152 OPJ_INT32 *datap,
153 OPJ_INT32 poshalf,
154 OPJ_UINT32 row);
155
156
157 /**
158 Decode clean-up pass
159 */
160
161 static void opj_t1_dec_clnpass_step(
162 opj_t1_t *t1,
163 opj_flag_t *flagsp,
164 OPJ_INT32 *datap,
165 OPJ_INT32 oneplushalf,
166 OPJ_UINT32 row,
167 OPJ_UINT32 vsc);
168
169 /**
170 Encode clean-up pass
171 */
172 static void opj_t1_enc_clnpass(
173 opj_t1_t *t1,
174 OPJ_INT32 bpno,
175 OPJ_INT32 *nmsedec,
176 OPJ_UINT32 cblksty);
177
178 static OPJ_FLOAT64 opj_t1_getwmsedec(
179 OPJ_INT32 nmsedec,
180 OPJ_UINT32 compno,
181 OPJ_UINT32 level,
182 OPJ_UINT32 orient,
183 OPJ_INT32 bpno,
184 OPJ_UINT32 qmfbid,
185 OPJ_FLOAT64 stepsize,
186 OPJ_UINT32 numcomps,
187 const OPJ_FLOAT64 * mct_norms,
188 OPJ_UINT32 mct_numcomps);
189
190 /** Return "cumwmsedec" that should be used to increase tile->distotile */
191 static double opj_t1_encode_cblk(opj_t1_t *t1,
192 opj_tcd_cblk_enc_t* cblk,
193 OPJ_UINT32 orient,
194 OPJ_UINT32 compno,
195 OPJ_UINT32 level,
196 OPJ_UINT32 qmfbid,
197 OPJ_FLOAT64 stepsize,
198 OPJ_UINT32 cblksty,
199 OPJ_UINT32 numcomps,
200 const OPJ_FLOAT64 * mct_norms,
201 OPJ_UINT32 mct_numcomps);
202
203 /**
204 Decode 1 code-block
205 @param t1 T1 handle
206 @param cblk Code-block coding parameters
207 @param orient
208 @param roishift Region of interest shifting value
209 @param cblksty Code-block style
210 @param p_manager the event manager
211 @param p_manager_mutex mutex for the event manager
212 @param check_pterm whether PTERM correct termination should be checked
213 */
214 static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
215 opj_tcd_cblk_dec_t* cblk,
216 OPJ_UINT32 orient,
217 OPJ_UINT32 roishift,
218 OPJ_UINT32 cblksty,
219 opj_event_mgr_t *p_manager,
220 opj_mutex_t* p_manager_mutex,
221 OPJ_BOOL check_pterm);
222
223 /**
224 Decode 1 HT code-block
225 @param t1 T1 handle
226 @param cblk Code-block coding parameters
227 @param orient
228 @param roishift Region of interest shifting value
229 @param cblksty Code-block style
230 @param p_manager the event manager
231 @param p_manager_mutex mutex for the event manager
232 @param check_pterm whether PTERM correct termination should be checked
233 */
234 OPJ_BOOL opj_t1_ht_decode_cblk(opj_t1_t *t1,
235 opj_tcd_cblk_dec_t* cblk,
236 OPJ_UINT32 orient,
237 OPJ_UINT32 roishift,
238 OPJ_UINT32 cblksty,
239 opj_event_mgr_t *p_manager,
240 opj_mutex_t* p_manager_mutex,
241 OPJ_BOOL check_pterm);
242
243
244 static OPJ_BOOL opj_t1_allocate_buffers(opj_t1_t *t1,
245 OPJ_UINT32 w,
246 OPJ_UINT32 h);
247
248 /*@}*/
249
250 /*@}*/
251
252 /* ----------------------------------------------------------------------- */
253
254 static INLINE OPJ_BYTE opj_t1_getctxno_zc(opj_mqc_t *mqc, OPJ_UINT32 f)
255 {
256 return mqc->lut_ctxno_zc_orient[(f & T1_SIGMA_NEIGHBOURS)];
257 }
258
259 static INLINE OPJ_UINT32 opj_t1_getctxtno_sc_or_spb_index(OPJ_UINT32 fX,
260 OPJ_UINT32 pfX,
261 OPJ_UINT32 nfX,
262 OPJ_UINT32 ci)
263 {
264 /*
265 0 pfX T1_CHI_THIS T1_LUT_SGN_W
266 1 tfX T1_SIGMA_1 T1_LUT_SIG_N
267 2 nfX T1_CHI_THIS T1_LUT_SGN_E
268 3 tfX T1_SIGMA_3 T1_LUT_SIG_W
269 4 fX T1_CHI_(THIS - 1) T1_LUT_SGN_N
270 5 tfX T1_SIGMA_5 T1_LUT_SIG_E
271 6 fX T1_CHI_(THIS + 1) T1_LUT_SGN_S
272 7 tfX T1_SIGMA_7 T1_LUT_SIG_S
273 */
274
275 OPJ_UINT32 lu = (fX >> (ci * 3U)) & (T1_SIGMA_1 | T1_SIGMA_3 | T1_SIGMA_5 |
276 T1_SIGMA_7);
277
278 lu |= (pfX >> (T1_CHI_THIS_I + (ci * 3U))) & (1U << 0);
279 lu |= (nfX >> (T1_CHI_THIS_I - 2U + (ci * 3U))) & (1U << 2);
280 if (ci == 0U) {
281 lu |= (fX >> (T1_CHI_0_I - 4U)) & (1U << 4);
282 } else {
283 lu |= (fX >> (T1_CHI_1_I - 4U + ((ci - 1U) * 3U))) & (1U << 4);
284 }
285 lu |= (fX >> (T1_CHI_2_I - 6U + (ci * 3U))) & (1U << 6);
286 return lu;
287 }
288
289 static INLINE OPJ_BYTE opj_t1_getctxno_sc(OPJ_UINT32 lu)
290 {
291 return lut_ctxno_sc[lu];
292 }
293
294 static INLINE OPJ_UINT32 opj_t1_getctxno_mag(OPJ_UINT32 f)
295 {
296 OPJ_UINT32 tmp = (f & T1_SIGMA_NEIGHBOURS) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
297 OPJ_UINT32 tmp2 = (f & T1_MU_0) ? T1_CTXNO_MAG + 2 : tmp;
298 return tmp2;
299 }
300
301 static INLINE OPJ_BYTE opj_t1_getspb(OPJ_UINT32 lu)
302 {
303 return lut_spb[lu];
304 }
305
306 static OPJ_INT16 opj_t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos)
307 {
308 if (bitpos > 0) {
309 return lut_nmsedec_sig[(x >> (bitpos)) & ((1 << T1_NMSEDEC_BITS) - 1)];
310 }
311
312 return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
313 }
314
315 static OPJ_INT16 opj_t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos)
316 {
317 if (bitpos > 0) {
318 return lut_nmsedec_ref[(x >> (bitpos)) & ((1 << T1_NMSEDEC_BITS) - 1)];
319 }
320
321 return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
322 }
323
324 #define opj_t1_update_flags_macro(flags, flagsp, ci, s, stride, vsc) \
325 { \
326 /* east */ \
327 flagsp[-1] |= T1_SIGMA_5 << (3U * ci); \
328 \
329 /* mark target as significant */ \
330 flags |= ((s << T1_CHI_1_I) | T1_SIGMA_4) << (3U * ci); \
331 \
332 /* west */ \
333 flagsp[1] |= T1_SIGMA_3 << (3U * ci); \
334 \
335 /* north-west, north, north-east */ \
336 if (ci == 0U && !(vsc)) { \
337 opj_flag_t* north = flagsp - (stride); \
338 *north |= (s << T1_CHI_5_I) | T1_SIGMA_16; \
339 north[-1] |= T1_SIGMA_17; \
340 north[1] |= T1_SIGMA_15; \
341 } \
342 \
343 /* south-west, south, south-east */ \
344 if (ci == 3U) { \
345 opj_flag_t* south = flagsp + (stride); \
346 *south |= (s << T1_CHI_0_I) | T1_SIGMA_1; \
347 south[-1] |= T1_SIGMA_2; \
348 south[1] |= T1_SIGMA_0; \
349 } \
350 }
351
352
353 static INLINE void opj_t1_update_flags(opj_flag_t *flagsp, OPJ_UINT32 ci,
354 OPJ_UINT32 s, OPJ_UINT32 stride,
355 OPJ_UINT32 vsc)
356 {
357 opj_t1_update_flags_macro(*flagsp, flagsp, ci, s, stride, vsc);
358 }
359
360 /**
361 Encode significant pass
362 */
363 #define opj_t1_enc_sigpass_step_macro(mqc, curctx, a, c, ct, flagspIn, datapIn, bpno, one, nmsedec, type, ciIn, vscIn) \
364 { \
365 OPJ_UINT32 v; \
366 const OPJ_UINT32 ci = (ciIn); \
367 const OPJ_UINT32 vsc = (vscIn); \
368 const OPJ_INT32* l_datap = (datapIn); \
369 opj_flag_t* flagsp = (flagspIn); \
370 OPJ_UINT32 const flags = *flagsp; \
371 if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) == 0U && \
372 (flags & (T1_SIGMA_NEIGHBOURS << (ci * 3U))) != 0U) { \
373 OPJ_UINT32 ctxt1 = opj_t1_getctxno_zc(mqc, flags >> (ci * 3U)); \
374 v = (opj_smr_abs(*l_datap) & (OPJ_UINT32)one) ? 1 : 0; \
375 /* #ifdef DEBUG_ENC_SIG */ \
376 /* fprintf(stderr, " ctxt1=%d\n", ctxt1); */ \
377 /* #endif */ \
378 opj_t1_setcurctx(curctx, ctxt1); \
379 if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */ \
380 opj_mqc_bypass_enc_macro(mqc, c, ct, v); \
381 } else { \
382 opj_mqc_encode_macro(mqc, curctx, a, c, ct, v); \
383 } \
384 if (v) { \
385 OPJ_UINT32 lu = opj_t1_getctxtno_sc_or_spb_index( \
386 *flagsp, \
387 flagsp[-1], flagsp[1], \
388 ci); \
389 OPJ_UINT32 ctxt2 = opj_t1_getctxno_sc(lu); \
390 v = opj_smr_sign(*l_datap); \
391 *nmsedec += opj_t1_getnmsedec_sig(opj_smr_abs(*l_datap), \
392 (OPJ_UINT32)bpno); \
393 /* #ifdef DEBUG_ENC_SIG */ \
394 /* fprintf(stderr, " ctxt2=%d\n", ctxt2); */ \
395 /* #endif */ \
396 opj_t1_setcurctx(curctx, ctxt2); \
397 if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */ \
398 opj_mqc_bypass_enc_macro(mqc, c, ct, v); \
399 } else { \
400 OPJ_UINT32 spb = opj_t1_getspb(lu); \
401 /* #ifdef DEBUG_ENC_SIG */ \
402 /* fprintf(stderr, " spb=%d\n", spb); */ \
403 /* #endif */ \
404 opj_mqc_encode_macro(mqc, curctx, a, c, ct, v ^ spb); \
405 } \
406 opj_t1_update_flags(flagsp, ci, v, t1->w + 2, vsc); \
407 } \
408 *flagsp |= T1_PI_THIS << (ci * 3U); \
409 } \
410 }
411
412 static INLINE void opj_t1_dec_sigpass_step_raw(
413 opj_t1_t *t1,
414 opj_flag_t *flagsp,
415 OPJ_INT32 *datap,
416 OPJ_INT32 oneplushalf,
417 OPJ_UINT32 vsc,
418 OPJ_UINT32 ci)
419 {
420 OPJ_UINT32 v;
421 opj_mqc_t *mqc = &(t1->mqc); /* RAW component */
422
423 OPJ_UINT32 const flags = *flagsp;
424
425 if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) == 0U &&
426 (flags & (T1_SIGMA_NEIGHBOURS << (ci * 3U))) != 0U) {
427 if (opj_mqc_raw_decode(mqc)) {
428 v = opj_mqc_raw_decode(mqc);
429 *datap = v ? -oneplushalf : oneplushalf;
430 opj_t1_update_flags(flagsp, ci, v, t1->w + 2, vsc);
431 }
432 *flagsp |= T1_PI_THIS << (ci * 3U);
433 }
434 }
435
436 #define opj_t1_dec_sigpass_step_mqc_macro(flags, flagsp, flags_stride, data, \
437 data_stride, ci, mqc, curctx, \
438 v, a, c, ct, oneplushalf, vsc) \
439 { \
440 if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) == 0U && \
441 (flags & (T1_SIGMA_NEIGHBOURS << (ci * 3U))) != 0U) { \
442 OPJ_UINT32 ctxt1 = opj_t1_getctxno_zc(mqc, flags >> (ci * 3U)); \
443 opj_t1_setcurctx(curctx, ctxt1); \
444 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
445 if (v) { \
446 OPJ_UINT32 lu = opj_t1_getctxtno_sc_or_spb_index( \
447 flags, \
448 flagsp[-1], flagsp[1], \
449 ci); \
450 OPJ_UINT32 ctxt2 = opj_t1_getctxno_sc(lu); \
451 OPJ_UINT32 spb = opj_t1_getspb(lu); \
452 opj_t1_setcurctx(curctx, ctxt2); \
453 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
454 v = v ^ spb; \
455 data[ci*data_stride] = v ? -oneplushalf : oneplushalf; \
456 opj_t1_update_flags_macro(flags, flagsp, ci, v, flags_stride, vsc); \
457 } \
458 flags |= T1_PI_THIS << (ci * 3U); \
459 } \
460 }
461
462 static INLINE void opj_t1_dec_sigpass_step_mqc(
463 opj_t1_t *t1,
464 opj_flag_t *flagsp,
465 OPJ_INT32 *datap,
466 OPJ_INT32 oneplushalf,
467 OPJ_UINT32 ci,
468 OPJ_UINT32 flags_stride,
469 OPJ_UINT32 vsc)
470 {
471 OPJ_UINT32 v;
472
473 opj_mqc_t *mqc = &(t1->mqc); /* MQC component */
474 opj_t1_dec_sigpass_step_mqc_macro(*flagsp, flagsp, flags_stride, datap,
475 0, ci, mqc, mqc->curctx,
476 v, mqc->a, mqc->c, mqc->ct, oneplushalf, vsc);
477 }
478
479 static void opj_t1_enc_sigpass(opj_t1_t *t1,
480 OPJ_INT32 bpno,
481 OPJ_INT32 *nmsedec,
482 OPJ_BYTE type,
483 OPJ_UINT32 cblksty
484 )
485 {
486 OPJ_UINT32 i, k;
487 OPJ_INT32 const one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
488 opj_flag_t* f = &T1_FLAGS(0, 0);
489 OPJ_UINT32 const extra = 2;
490 opj_mqc_t* mqc = &(t1->mqc);
491 DOWNLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct);
492 const OPJ_INT32* datap = t1->data;
493
494 *nmsedec = 0;
495 #ifdef DEBUG_ENC_SIG
496 fprintf(stderr, "enc_sigpass: bpno=%d\n", bpno);
497 #endif
498 for (k = 0; k < (t1->h & ~3U); k += 4, f += extra) {
499 const OPJ_UINT32 w = t1->w;
500 #ifdef DEBUG_ENC_SIG
501 fprintf(stderr, " k=%d\n", k);
502 #endif
503 for (i = 0; i < w; ++i, ++f, datap += 4) {
504 #ifdef DEBUG_ENC_SIG
505 fprintf(stderr, " i=%d\n", i);
506 #endif
507 if (*f == 0U) {
508 /* Nothing to do for any of the 4 data points */
509 continue;
510 }
511 opj_t1_enc_sigpass_step_macro(
512 mqc, curctx, a, c, ct,
513 f,
514 &datap[0],
515 bpno,
516 one,
517 nmsedec,
518 type,
519 0, cblksty & J2K_CCP_CBLKSTY_VSC);
520 opj_t1_enc_sigpass_step_macro(
521 mqc, curctx, a, c, ct,
522 f,
523 &datap[1],
524 bpno,
525 one,
526 nmsedec,
527 type,
528 1, 0);
529 opj_t1_enc_sigpass_step_macro(
530 mqc, curctx, a, c, ct,
531 f,
532 &datap[2],
533 bpno,
534 one,
535 nmsedec,
536 type,
537 2, 0);
538 opj_t1_enc_sigpass_step_macro(
539 mqc, curctx, a, c, ct,
540 f,
541 &datap[3],
542 bpno,
543 one,
544 nmsedec,
545 type,
546 3, 0);
547 }
548 }
549
550 if (k < t1->h) {
551 OPJ_UINT32 j;
552 #ifdef DEBUG_ENC_SIG
553 fprintf(stderr, " k=%d\n", k);
554 #endif
555 for (i = 0; i < t1->w; ++i, ++f) {
556 #ifdef DEBUG_ENC_SIG
557 fprintf(stderr, " i=%d\n", i);
558 #endif
559 if (*f == 0U) {
560 /* Nothing to do for any of the 4 data points */
561 datap += (t1->h - k);
562 continue;
563 }
564 for (j = k; j < t1->h; ++j, ++datap) {
565 opj_t1_enc_sigpass_step_macro(
566 mqc, curctx, a, c, ct,
567 f,
568 &datap[0],
569 bpno,
570 one,
571 nmsedec,
572 type,
573 j - k,
574 (j == k && (cblksty & J2K_CCP_CBLKSTY_VSC) != 0));
575 }
576 }
577 }
578
579 UPLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct);
580 }
581
582 static void opj_t1_dec_sigpass_raw(
583 opj_t1_t *t1,
584 OPJ_INT32 bpno,
585 OPJ_INT32 cblksty)
586 {
587 OPJ_INT32 one, half, oneplushalf;
588 OPJ_UINT32 i, j, k;
589 OPJ_INT32 *data = t1->data;
590 opj_flag_t *flagsp = &T1_FLAGS(0, 0);
591 const OPJ_UINT32 l_w = t1->w;
592 one = 1 << bpno;
593 half = one >> 1;
594 oneplushalf = one | half;
595
596 for (k = 0; k < (t1->h & ~3U); k += 4, flagsp += 2, data += 3 * l_w) {
597 for (i = 0; i < l_w; ++i, ++flagsp, ++data) {
598 opj_flag_t flags = *flagsp;
599 if (flags != 0) {
600 opj_t1_dec_sigpass_step_raw(
601 t1,
602 flagsp,
603 data,
604 oneplushalf,
605 cblksty & J2K_CCP_CBLKSTY_VSC, /* vsc */
606 0U);
607 opj_t1_dec_sigpass_step_raw(
608 t1,
609 flagsp,
610 data + l_w,
611 oneplushalf,
612 OPJ_FALSE, /* vsc */
613 1U);
614 opj_t1_dec_sigpass_step_raw(
615 t1,
616 flagsp,
617 data + 2 * l_w,
618 oneplushalf,
619 OPJ_FALSE, /* vsc */
620 2U);
621 opj_t1_dec_sigpass_step_raw(
622 t1,
623 flagsp,
624 data + 3 * l_w,
625 oneplushalf,
626 OPJ_FALSE, /* vsc */
627 3U);
628 }
629 }
630 }
631 if (k < t1->h) {
632 for (i = 0; i < l_w; ++i, ++flagsp, ++data) {
633 for (j = 0; j < t1->h - k; ++j) {
634 opj_t1_dec_sigpass_step_raw(
635 t1,
636 flagsp,
637 data + j * l_w,
638 oneplushalf,
639 cblksty & J2K_CCP_CBLKSTY_VSC, /* vsc */
640 j);
641 }
642 }
643 }
644 }
645
646 #define opj_t1_dec_sigpass_mqc_internal(t1, bpno, vsc, w, h, flags_stride) \
647 { \
648 OPJ_INT32 one, half, oneplushalf; \
649 OPJ_UINT32 i, j, k; \
650 register OPJ_INT32 *data = t1->data; \
651 register opj_flag_t *flagsp = &t1->flags[(flags_stride) + 1]; \
652 const OPJ_UINT32 l_w = w; \
653 opj_mqc_t* mqc = &(t1->mqc); \
654 DOWNLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct); \
655 register OPJ_UINT32 v; \
656 one = 1 << bpno; \
657 half = one >> 1; \
658 oneplushalf = one | half; \
659 for (k = 0; k < (h & ~3u); k += 4, data += 3*l_w, flagsp += 2) { \
660 for (i = 0; i < l_w; ++i, ++data, ++flagsp) { \
661 opj_flag_t flags = *flagsp; \
662 if( flags != 0 ) { \
663 opj_t1_dec_sigpass_step_mqc_macro( \
664 flags, flagsp, flags_stride, data, \
665 l_w, 0, mqc, curctx, v, a, c, ct, oneplushalf, vsc); \
666 opj_t1_dec_sigpass_step_mqc_macro( \
667 flags, flagsp, flags_stride, data, \
668 l_w, 1, mqc, curctx, v, a, c, ct, oneplushalf, OPJ_FALSE); \
669 opj_t1_dec_sigpass_step_mqc_macro( \
670 flags, flagsp, flags_stride, data, \
671 l_w, 2, mqc, curctx, v, a, c, ct, oneplushalf, OPJ_FALSE); \
672 opj_t1_dec_sigpass_step_mqc_macro( \
673 flags, flagsp, flags_stride, data, \
674 l_w, 3, mqc, curctx, v, a, c, ct, oneplushalf, OPJ_FALSE); \
675 *flagsp = flags; \
676 } \
677 } \
678 } \
679 UPLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct); \
680 if( k < h ) { \
681 for (i = 0; i < l_w; ++i, ++data, ++flagsp) { \
682 for (j = 0; j < h - k; ++j) { \
683 opj_t1_dec_sigpass_step_mqc(t1, flagsp, \
684 data + j * l_w, oneplushalf, j, flags_stride, vsc); \
685 } \
686 } \
687 } \
688 }
689
690 static void opj_t1_dec_sigpass_mqc_64x64_novsc(
691 opj_t1_t *t1,
692 OPJ_INT32 bpno)
693 {
694 opj_t1_dec_sigpass_mqc_internal(t1, bpno, OPJ_FALSE, 64, 64, 66);
695 }
696
697 static void opj_t1_dec_sigpass_mqc_64x64_vsc(
698 opj_t1_t *t1,
699 OPJ_INT32 bpno)
700 {
701 opj_t1_dec_sigpass_mqc_internal(t1, bpno, OPJ_TRUE, 64, 64, 66);
702 }
703
704 static void opj_t1_dec_sigpass_mqc_generic_novsc(
705 opj_t1_t *t1,
706 OPJ_INT32 bpno)
707 {
708 opj_t1_dec_sigpass_mqc_internal(t1, bpno, OPJ_FALSE, t1->w, t1->h,
709 t1->w + 2U);
710 }
711
712 static void opj_t1_dec_sigpass_mqc_generic_vsc(
713 opj_t1_t *t1,
714 OPJ_INT32 bpno)
715 {
716 opj_t1_dec_sigpass_mqc_internal(t1, bpno, OPJ_TRUE, t1->w, t1->h,
717 t1->w + 2U);
718 }
719
720 static void opj_t1_dec_sigpass_mqc(
721 opj_t1_t *t1,
722 OPJ_INT32 bpno,
723 OPJ_INT32 cblksty)
724 {
725 if (t1->w == 64 && t1->h == 64) {
726 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
727 opj_t1_dec_sigpass_mqc_64x64_vsc(t1, bpno);
728 } else {
729 opj_t1_dec_sigpass_mqc_64x64_novsc(t1, bpno);
730 }
731 } else {
732 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
733 opj_t1_dec_sigpass_mqc_generic_vsc(t1, bpno);
734 } else {
735 opj_t1_dec_sigpass_mqc_generic_novsc(t1, bpno);
736 }
737 }
738 }
739
740 /**
741 Encode refinement pass step
742 */
743 #define opj_t1_enc_refpass_step_macro(mqc, curctx, a, c, ct, flags, flagsUpdated, datap, bpno, one, nmsedec, type, ci) \
744 {\
745 OPJ_UINT32 v; \
746 if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << ((ci) * 3U))) == (T1_SIGMA_THIS << ((ci) * 3U))) { \
747 const OPJ_UINT32 shift_flags = (flags >> ((ci) * 3U)); \
748 OPJ_UINT32 ctxt = opj_t1_getctxno_mag(shift_flags); \
749 OPJ_UINT32 abs_data = opj_smr_abs(*datap); \
750 *nmsedec += opj_t1_getnmsedec_ref(abs_data, \
751 (OPJ_UINT32)bpno); \
752 v = ((OPJ_INT32)abs_data & one) ? 1 : 0; \
753 /* #ifdef DEBUG_ENC_REF */ \
754 /* fprintf(stderr, " ctxt=%d\n", ctxt); */ \
755 /* #endif */ \
756 opj_t1_setcurctx(curctx, ctxt); \
757 if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */ \
758 opj_mqc_bypass_enc_macro(mqc, c, ct, v); \
759 } else { \
760 opj_mqc_encode_macro(mqc, curctx, a, c, ct, v); \
761 } \
762 flagsUpdated |= T1_MU_THIS << ((ci) * 3U); \
763 } \
764 }
765
766
767 static INLINE void opj_t1_dec_refpass_step_raw(
768 opj_t1_t *t1,
769 opj_flag_t *flagsp,
770 OPJ_INT32 *datap,
771 OPJ_INT32 poshalf,
772 OPJ_UINT32 ci)
773 {
774 OPJ_UINT32 v;
775
776 opj_mqc_t *mqc = &(t1->mqc); /* RAW component */
777
778 if ((*flagsp & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) ==
779 (T1_SIGMA_THIS << (ci * 3U))) {
780 v = opj_mqc_raw_decode(mqc);
781 *datap += (v ^ (*datap < 0)) ? poshalf : -poshalf;
782 *flagsp |= T1_MU_THIS << (ci * 3U);
783 }
784 }
785
786 #define opj_t1_dec_refpass_step_mqc_macro(flags, data, data_stride, ci, \
787 mqc, curctx, v, a, c, ct, poshalf) \
788 { \
789 if ((flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U))) == \
790 (T1_SIGMA_THIS << (ci * 3U))) { \
791 OPJ_UINT32 ctxt = opj_t1_getctxno_mag(flags >> (ci * 3U)); \
792 opj_t1_setcurctx(curctx, ctxt); \
793 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
794 data[ci*data_stride] += (v ^ (data[ci*data_stride] < 0)) ? poshalf : -poshalf; \
795 flags |= T1_MU_THIS << (ci * 3U); \
796 } \
797 }
798
799 static INLINE void opj_t1_dec_refpass_step_mqc(
800 opj_t1_t *t1,
801 opj_flag_t *flagsp,
802 OPJ_INT32 *datap,
803 OPJ_INT32 poshalf,
804 OPJ_UINT32 ci)
805 {
806 OPJ_UINT32 v;
807
808 opj_mqc_t *mqc = &(t1->mqc); /* MQC component */
809 opj_t1_dec_refpass_step_mqc_macro(*flagsp, datap, 0, ci,
810 mqc, mqc->curctx, v, mqc->a, mqc->c,
811 mqc->ct, poshalf);
812 }
813
814 static void opj_t1_enc_refpass(
815 opj_t1_t *t1,
816 OPJ_INT32 bpno,
817 OPJ_INT32 *nmsedec,
818 OPJ_BYTE type)
819 {
820 OPJ_UINT32 i, k;
821 const OPJ_INT32 one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
822 opj_flag_t* f = &T1_FLAGS(0, 0);
823 const OPJ_UINT32 extra = 2U;
824 opj_mqc_t* mqc = &(t1->mqc);
825 DOWNLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct);
826 const OPJ_INT32* datap = t1->data;
827
828 *nmsedec = 0;
829 #ifdef DEBUG_ENC_REF
830 fprintf(stderr, "enc_refpass: bpno=%d\n", bpno);
831 #endif
832 for (k = 0; k < (t1->h & ~3U); k += 4, f += extra) {
833 #ifdef DEBUG_ENC_REF
834 fprintf(stderr, " k=%d\n", k);
835 #endif
836 for (i = 0; i < t1->w; ++i, f++, datap += 4) {
837 const OPJ_UINT32 flags = *f;
838 OPJ_UINT32 flagsUpdated = flags;
839 #ifdef DEBUG_ENC_REF
840 fprintf(stderr, " i=%d\n", i);
841 #endif
842 if ((flags & (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13)) == 0) {
843 /* none significant */
844 continue;
845 }
846 if ((flags & (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3)) ==
847 (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3)) {
848 /* all processed by sigpass */
849 continue;
850 }
851
852 opj_t1_enc_refpass_step_macro(
853 mqc, curctx, a, c, ct,
854 flags, flagsUpdated,
855 &datap[0],
856 bpno,
857 one,
858 nmsedec,
859 type,
860 0);
861 opj_t1_enc_refpass_step_macro(
862 mqc, curctx, a, c, ct,
863 flags, flagsUpdated,
864 &datap[1],
865 bpno,
866 one,
867 nmsedec,
868 type,
869 1);
870 opj_t1_enc_refpass_step_macro(
871 mqc, curctx, a, c, ct,
872 flags, flagsUpdated,
873 &datap[2],
874 bpno,
875 one,
876 nmsedec,
877 type,
878 2);
879 opj_t1_enc_refpass_step_macro(
880 mqc, curctx, a, c, ct,
881 flags, flagsUpdated,
882 &datap[3],
883 bpno,
884 one,
885 nmsedec,
886 type,
887 3);
888 *f = flagsUpdated;
889 }
890 }
891
892 if (k < t1->h) {
893 OPJ_UINT32 j;
894 const OPJ_UINT32 remaining_lines = t1->h - k;
895 #ifdef DEBUG_ENC_REF
896 fprintf(stderr, " k=%d\n", k);
897 #endif
898 for (i = 0; i < t1->w; ++i, ++f) {
899 #ifdef DEBUG_ENC_REF
900 fprintf(stderr, " i=%d\n", i);
901 #endif
902 if ((*f & (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13)) == 0) {
903 /* none significant */
904 datap += remaining_lines;
905 continue;
906 }
907 for (j = 0; j < remaining_lines; ++j, datap ++) {
908 opj_t1_enc_refpass_step_macro(
909 mqc, curctx, a, c, ct,
910 *f, *f,
911 &datap[0],
912 bpno,
913 one,
914 nmsedec,
915 type,
916 j);
917 }
918 }
919 }
920
921 UPLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct);
922 }
923
924
925 static void opj_t1_dec_refpass_raw(
926 opj_t1_t *t1,
927 OPJ_INT32 bpno)
928 {
929 OPJ_INT32 one, poshalf;
930 OPJ_UINT32 i, j, k;
931 OPJ_INT32 *data = t1->data;
932 opj_flag_t *flagsp = &T1_FLAGS(0, 0);
933 const OPJ_UINT32 l_w = t1->w;
934 one = 1 << bpno;
935 poshalf = one >> 1;
936 for (k = 0; k < (t1->h & ~3U); k += 4, flagsp += 2, data += 3 * l_w) {
937 for (i = 0; i < l_w; ++i, ++flagsp, ++data) {
938 opj_flag_t flags = *flagsp;
939 if (flags != 0) {
940 opj_t1_dec_refpass_step_raw(
941 t1,
942 flagsp,
943 data,
944 poshalf,
945 0U);
946 opj_t1_dec_refpass_step_raw(
947 t1,
948 flagsp,
949 data + l_w,
950 poshalf,
951 1U);
952 opj_t1_dec_refpass_step_raw(
953 t1,
954 flagsp,
955 data + 2 * l_w,
956 poshalf,
957 2U);
958 opj_t1_dec_refpass_step_raw(
959 t1,
960 flagsp,
961 data + 3 * l_w,
962 poshalf,
963 3U);
964 }
965 }
966 }
967 if (k < t1->h) {
968 for (i = 0; i < l_w; ++i, ++flagsp, ++data) {
969 for (j = 0; j < t1->h - k; ++j) {
970 opj_t1_dec_refpass_step_raw(
971 t1,
972 flagsp,
973 data + j * l_w,
974 poshalf,
975 j);
976 }
977 }
978 }
979 }
980
981 #define opj_t1_dec_refpass_mqc_internal(t1, bpno, w, h, flags_stride) \
982 { \
983 OPJ_INT32 one, poshalf; \
984 OPJ_UINT32 i, j, k; \
985 register OPJ_INT32 *data = t1->data; \
986 register opj_flag_t *flagsp = &t1->flags[flags_stride + 1]; \
987 const OPJ_UINT32 l_w = w; \
988 opj_mqc_t* mqc = &(t1->mqc); \
989 DOWNLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct); \
990 register OPJ_UINT32 v; \
991 one = 1 << bpno; \
992 poshalf = one >> 1; \
993 for (k = 0; k < (h & ~3u); k += 4, data += 3*l_w, flagsp += 2) { \
994 for (i = 0; i < l_w; ++i, ++data, ++flagsp) { \
995 opj_flag_t flags = *flagsp; \
996 if( flags != 0 ) { \
997 opj_t1_dec_refpass_step_mqc_macro( \
998 flags, data, l_w, 0, \
999 mqc, curctx, v, a, c, ct, poshalf); \
1000 opj_t1_dec_refpass_step_mqc_macro( \
1001 flags, data, l_w, 1, \
1002 mqc, curctx, v, a, c, ct, poshalf); \
1003 opj_t1_dec_refpass_step_mqc_macro( \
1004 flags, data, l_w, 2, \
1005 mqc, curctx, v, a, c, ct, poshalf); \
1006 opj_t1_dec_refpass_step_mqc_macro( \
1007 flags, data, l_w, 3, \
1008 mqc, curctx, v, a, c, ct, poshalf); \
1009 *flagsp = flags; \
1010 } \
1011 } \
1012 } \
1013 UPLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct); \
1014 if( k < h ) { \
1015 for (i = 0; i < l_w; ++i, ++data, ++flagsp) { \
1016 for (j = 0; j < h - k; ++j) { \
1017 opj_t1_dec_refpass_step_mqc(t1, flagsp, data + j * l_w, poshalf, j); \
1018 } \
1019 } \
1020 } \
1021 }
1022
1023 static void opj_t1_dec_refpass_mqc_64x64(
1024 opj_t1_t *t1,
1025 OPJ_INT32 bpno)
1026 {
1027 opj_t1_dec_refpass_mqc_internal(t1, bpno, 64, 64, 66);
1028 }
1029
1030 static void opj_t1_dec_refpass_mqc_generic(
1031 opj_t1_t *t1,
1032 OPJ_INT32 bpno)
1033 {
1034 opj_t1_dec_refpass_mqc_internal(t1, bpno, t1->w, t1->h, t1->w + 2U);
1035 }
1036
1037 static void opj_t1_dec_refpass_mqc(
1038 opj_t1_t *t1,
1039 OPJ_INT32 bpno)
1040 {
1041 if (t1->w == 64 && t1->h == 64) {
1042 opj_t1_dec_refpass_mqc_64x64(t1, bpno);
1043 } else {
1044 opj_t1_dec_refpass_mqc_generic(t1, bpno);
1045 }
1046 }
1047
1048 /**
1049 Encode clean-up pass step
1050 */
1051 #define opj_t1_enc_clnpass_step_macro(mqc, curctx, a, c, ct, flagspIn, datapIn, bpno, one, nmsedec, agg, runlen, lim, cblksty) \
1052 { \
1053 OPJ_UINT32 v; \
1054 OPJ_UINT32 ci; \
1055 opj_flag_t* const flagsp = (flagspIn); \
1056 const OPJ_INT32* l_datap = (datapIn); \
1057 const OPJ_UINT32 check = (T1_SIGMA_4 | T1_SIGMA_7 | T1_SIGMA_10 | T1_SIGMA_13 | \
1058 T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3); \
1059 \
1060 if ((*flagsp & check) == check) { \
1061 if (runlen == 0) { \
1062 *flagsp &= ~(T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3); \
1063 } else if (runlen == 1) { \
1064 *flagsp &= ~(T1_PI_1 | T1_PI_2 | T1_PI_3); \
1065 } else if (runlen == 2) { \
1066 *flagsp &= ~(T1_PI_2 | T1_PI_3); \
1067 } else if (runlen == 3) { \
1068 *flagsp &= ~(T1_PI_3); \
1069 } \
1070 } \
1071 else \
1072 for (ci = runlen; ci < lim; ++ci) { \
1073 OPJ_BOOL goto_PARTIAL = OPJ_FALSE; \
1074 if ((agg != 0) && (ci == runlen)) { \
1075 goto_PARTIAL = OPJ_TRUE; \
1076 } \
1077 else if (!(*flagsp & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U)))) { \
1078 OPJ_UINT32 ctxt1 = opj_t1_getctxno_zc(mqc, *flagsp >> (ci * 3U)); \
1079 /* #ifdef DEBUG_ENC_CLN */ \
1080 /* printf(" ctxt1=%d\n", ctxt1); */ \
1081 /* #endif */ \
1082 opj_t1_setcurctx(curctx, ctxt1); \
1083 v = (opj_smr_abs(*l_datap) & (OPJ_UINT32)one) ? 1 : 0; \
1084 opj_mqc_encode_macro(mqc, curctx, a, c, ct, v); \
1085 if (v) { \
1086 goto_PARTIAL = OPJ_TRUE; \
1087 } \
1088 } \
1089 if( goto_PARTIAL ) { \
1090 OPJ_UINT32 vsc; \
1091 OPJ_UINT32 ctxt2, spb; \
1092 OPJ_UINT32 lu = opj_t1_getctxtno_sc_or_spb_index( \
1093 *flagsp, \
1094 flagsp[-1], flagsp[1], \
1095 ci); \
1096 *nmsedec += opj_t1_getnmsedec_sig(opj_smr_abs(*l_datap), \
1097 (OPJ_UINT32)bpno); \
1098 ctxt2 = opj_t1_getctxno_sc(lu); \
1099 /* #ifdef DEBUG_ENC_CLN */ \
1100 /* printf(" ctxt2=%d\n", ctxt2); */ \
1101 /* #endif */ \
1102 opj_t1_setcurctx(curctx, ctxt2); \
1103 \
1104 v = opj_smr_sign(*l_datap); \
1105 spb = opj_t1_getspb(lu); \
1106 /* #ifdef DEBUG_ENC_CLN */ \
1107 /* printf(" spb=%d\n", spb); */\
1108 /* #endif */ \
1109 opj_mqc_encode_macro(mqc, curctx, a, c, ct, v ^ spb); \
1110 vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (ci == 0)) ? 1 : 0; \
1111 opj_t1_update_flags(flagsp, ci, v, t1->w + 2U, vsc); \
1112 } \
1113 *flagsp &= ~(T1_PI_THIS << (3U * ci)); \
1114 l_datap ++; \
1115 } \
1116 }
1117
1118 #define opj_t1_dec_clnpass_step_macro(check_flags, partial, \
1119 flags, flagsp, flags_stride, data, \
1120 data_stride, ci, mqc, curctx, \
1121 v, a, c, ct, oneplushalf, vsc) \
1122 { \
1123 if ( !check_flags || !(flags & ((T1_SIGMA_THIS | T1_PI_THIS) << (ci * 3U)))) {\
1124 do { \
1125 if( !partial ) { \
1126 OPJ_UINT32 ctxt1 = opj_t1_getctxno_zc(mqc, flags >> (ci * 3U)); \
1127 opj_t1_setcurctx(curctx, ctxt1); \
1128 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
1129 if( !v ) \
1130 break; \
1131 } \
1132 { \
1133 OPJ_UINT32 lu = opj_t1_getctxtno_sc_or_spb_index( \
1134 flags, flagsp[-1], flagsp[1], \
1135 ci); \
1136 opj_t1_setcurctx(curctx, opj_t1_getctxno_sc(lu)); \
1137 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
1138 v = v ^ opj_t1_getspb(lu); \
1139 data[ci*data_stride] = v ? -oneplushalf : oneplushalf; \
1140 opj_t1_update_flags_macro(flags, flagsp, ci, v, flags_stride, vsc); \
1141 } \
1142 } while(0); \
1143 } \
1144 }
1145
1146 static void opj_t1_dec_clnpass_step(
1147 opj_t1_t *t1,
1148 opj_flag_t *flagsp,
1149 OPJ_INT32 *datap,
1150 OPJ_INT32 oneplushalf,
1151 OPJ_UINT32 ci,
1152 OPJ_UINT32 vsc)
1153 {
1154 OPJ_UINT32 v;
1155
1156 opj_mqc_t *mqc = &(t1->mqc); /* MQC component */
1157 opj_t1_dec_clnpass_step_macro(OPJ_TRUE, OPJ_FALSE,
1158 *flagsp, flagsp, t1->w + 2U, datap,
1159 0, ci, mqc, mqc->curctx,
1160 v, mqc->a, mqc->c, mqc->ct, oneplushalf, vsc);
1161 }
1162
1163 static void opj_t1_enc_clnpass(
1164 opj_t1_t *t1,
1165 OPJ_INT32 bpno,
1166 OPJ_INT32 *nmsedec,
1167 OPJ_UINT32 cblksty)
1168 {
1169 OPJ_UINT32 i, k;
1170 const OPJ_INT32 one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
1171 opj_mqc_t* mqc = &(t1->mqc);
1172 DOWNLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct);
1173 const OPJ_INT32* datap = t1->data;
1174 opj_flag_t *f = &T1_FLAGS(0, 0);
1175 const OPJ_UINT32 extra = 2U;
1176
1177 *nmsedec = 0;
1178 #ifdef DEBUG_ENC_CLN
1179 printf("enc_clnpass: bpno=%d\n", bpno);
1180 #endif
1181 for (k = 0; k < (t1->h & ~3U); k += 4, f += extra) {
1182 #ifdef DEBUG_ENC_CLN
1183 printf(" k=%d\n", k);
1184 #endif
1185 for (i = 0; i < t1->w; ++i, f++) {
1186 OPJ_UINT32 agg, runlen;
1187 #ifdef DEBUG_ENC_CLN
1188 printf(" i=%d\n", i);
1189 #endif
1190 agg = !*f;
1191 #ifdef DEBUG_ENC_CLN
1192 printf(" agg=%d\n", agg);
1193 #endif
1194 if (agg) {
1195 for (runlen = 0; runlen < 4; ++runlen, ++datap) {
1196 if (opj_smr_abs(*datap) & (OPJ_UINT32)one) {
1197 break;
1198 }
1199 }
1200 opj_t1_setcurctx(curctx, T1_CTXNO_AGG);
1201 opj_mqc_encode_macro(mqc, curctx, a, c, ct, runlen != 4);
1202 if (runlen == 4) {
1203 continue;
1204 }
1205 opj_t1_setcurctx(curctx, T1_CTXNO_UNI);
1206 opj_mqc_encode_macro(mqc, curctx, a, c, ct, runlen >> 1);
1207 opj_mqc_encode_macro(mqc, curctx, a, c, ct, runlen & 1);
1208 } else {
1209 runlen = 0;
1210 }
1211 opj_t1_enc_clnpass_step_macro(
1212 mqc, curctx, a, c, ct,
1213 f,
1214 datap,
1215 bpno,
1216 one,
1217 nmsedec,
1218 agg,
1219 runlen,
1220 4U,
1221 cblksty);
1222 datap += 4 - runlen;
1223 }
1224 }
1225 if (k < t1->h) {
1226 const OPJ_UINT32 agg = 0;
1227 const OPJ_UINT32 runlen = 0;
1228 #ifdef DEBUG_ENC_CLN
1229 printf(" k=%d\n", k);
1230 #endif
1231 for (i = 0; i < t1->w; ++i, f++) {
1232 #ifdef DEBUG_ENC_CLN
1233 printf(" i=%d\n", i);
1234 printf(" agg=%d\n", agg);
1235 #endif
1236 opj_t1_enc_clnpass_step_macro(
1237 mqc, curctx, a, c, ct,
1238 f,
1239 datap,
1240 bpno,
1241 one,
1242 nmsedec,
1243 agg,
1244 runlen,
1245 t1->h - k,
1246 cblksty);
1247 datap += t1->h - k;
1248 }
1249 }
1250
1251 UPLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct);
1252 }
1253
1254 #define opj_t1_dec_clnpass_internal(t1, bpno, vsc, w, h, flags_stride) \
1255 { \
1256 OPJ_INT32 one, half, oneplushalf; \
1257 OPJ_UINT32 runlen; \
1258 OPJ_UINT32 i, j, k; \
1259 const OPJ_UINT32 l_w = w; \
1260 opj_mqc_t* mqc = &(t1->mqc); \
1261 register OPJ_INT32 *data = t1->data; \
1262 register opj_flag_t *flagsp = &t1->flags[flags_stride + 1]; \
1263 DOWNLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct); \
1264 register OPJ_UINT32 v; \
1265 one = 1 << bpno; \
1266 half = one >> 1; \
1267 oneplushalf = one | half; \
1268 for (k = 0; k < (h & ~3u); k += 4, data += 3*l_w, flagsp += 2) { \
1269 for (i = 0; i < l_w; ++i, ++data, ++flagsp) { \
1270 opj_flag_t flags = *flagsp; \
1271 if (flags == 0) { \
1272 OPJ_UINT32 partial = OPJ_TRUE; \
1273 opj_t1_setcurctx(curctx, T1_CTXNO_AGG); \
1274 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
1275 if (!v) { \
1276 continue; \
1277 } \
1278 opj_t1_setcurctx(curctx, T1_CTXNO_UNI); \
1279 opj_mqc_decode_macro(runlen, mqc, curctx, a, c, ct); \
1280 opj_mqc_decode_macro(v, mqc, curctx, a, c, ct); \
1281 runlen = (runlen << 1) | v; \
1282 switch(runlen) { \
1283 case 0: \
1284 opj_t1_dec_clnpass_step_macro(OPJ_FALSE, OPJ_TRUE,\
1285 flags, flagsp, flags_stride, data, \
1286 l_w, 0, mqc, curctx, \
1287 v, a, c, ct, oneplushalf, vsc); \
1288 partial = OPJ_FALSE; \
1289 /* FALLTHRU */ \
1290 case 1: \
1291 opj_t1_dec_clnpass_step_macro(OPJ_FALSE, partial,\
1292 flags, flagsp, flags_stride, data, \
1293 l_w, 1, mqc, curctx, \
1294 v, a, c, ct, oneplushalf, OPJ_FALSE); \
1295 partial = OPJ_FALSE; \
1296 /* FALLTHRU */ \
1297 case 2: \
1298 opj_t1_dec_clnpass_step_macro(OPJ_FALSE, partial,\
1299 flags, flagsp, flags_stride, data, \
1300 l_w, 2, mqc, curctx, \
1301 v, a, c, ct, oneplushalf, OPJ_FALSE); \
1302 partial = OPJ_FALSE; \
1303 /* FALLTHRU */ \
1304 case 3: \
1305 opj_t1_dec_clnpass_step_macro(OPJ_FALSE, partial,\
1306 flags, flagsp, flags_stride, data, \
1307 l_w, 3, mqc, curctx, \
1308 v, a, c, ct, oneplushalf, OPJ_FALSE); \
1309 break; \
1310 } \
1311 } else { \
1312 opj_t1_dec_clnpass_step_macro(OPJ_TRUE, OPJ_FALSE, \
1313 flags, flagsp, flags_stride, data, \
1314 l_w, 0, mqc, curctx, \
1315 v, a, c, ct, oneplushalf, vsc); \
1316 opj_t1_dec_clnpass_step_macro(OPJ_TRUE, OPJ_FALSE, \
1317 flags, flagsp, flags_stride, data, \
1318 l_w, 1, mqc, curctx, \
1319 v, a, c, ct, oneplushalf, OPJ_FALSE); \
1320 opj_t1_dec_clnpass_step_macro(OPJ_TRUE, OPJ_FALSE, \
1321 flags, flagsp, flags_stride, data, \
1322 l_w, 2, mqc, curctx, \
1323 v, a, c, ct, oneplushalf, OPJ_FALSE); \
1324 opj_t1_dec_clnpass_step_macro(OPJ_TRUE, OPJ_FALSE, \
1325 flags, flagsp, flags_stride, data, \
1326 l_w, 3, mqc, curctx, \
1327 v, a, c, ct, oneplushalf, OPJ_FALSE); \
1328 } \
1329 *flagsp = flags & ~(T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3); \
1330 } \
1331 } \
1332 UPLOAD_MQC_VARIABLES(mqc, curctx, a, c, ct); \
1333 if( k < h ) { \
1334 for (i = 0; i < l_w; ++i, ++flagsp, ++data) { \
1335 for (j = 0; j < h - k; ++j) { \
1336 opj_t1_dec_clnpass_step(t1, flagsp, data + j * l_w, oneplushalf, j, vsc); \
1337 } \
1338 *flagsp &= ~(T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3); \
1339 } \
1340 } \
1341 }
1342
1343 static void opj_t1_dec_clnpass_check_segsym(opj_t1_t *t1, OPJ_INT32 cblksty)
1344 {
1345 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM) {
1346 opj_mqc_t* mqc = &(t1->mqc);
1347 OPJ_UINT32 v, v2;
1348 opj_mqc_setcurctx(mqc, T1_CTXNO_UNI);
1349 opj_mqc_decode(v, mqc);
1350 opj_mqc_decode(v2, mqc);
1351 v = (v << 1) | v2;
1352 opj_mqc_decode(v2, mqc);
1353 v = (v << 1) | v2;
1354 opj_mqc_decode(v2, mqc);
1355 v = (v << 1) | v2;
1356 /*
1357 if (v!=0xa) {
1358 opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
1359 }
1360 */
1361 }
1362 }
1363
1364 static void opj_t1_dec_clnpass_64x64_novsc(
1365 opj_t1_t *t1,
1366 OPJ_INT32 bpno)
1367 {
1368 opj_t1_dec_clnpass_internal(t1, bpno, OPJ_FALSE, 64, 64, 66);
1369 }
1370
1371 static void opj_t1_dec_clnpass_64x64_vsc(
1372 opj_t1_t *t1,
1373 OPJ_INT32 bpno)
1374 {
1375 opj_t1_dec_clnpass_internal(t1, bpno, OPJ_TRUE, 64, 64, 66);
1376 }
1377
1378 static void opj_t1_dec_clnpass_generic_novsc(
1379 opj_t1_t *t1,
1380 OPJ_INT32 bpno)
1381 {
1382 opj_t1_dec_clnpass_internal(t1, bpno, OPJ_FALSE, t1->w, t1->h,
1383 t1->w + 2U);
1384 }
1385
1386 static void opj_t1_dec_clnpass_generic_vsc(
1387 opj_t1_t *t1,
1388 OPJ_INT32 bpno)
1389 {
1390 opj_t1_dec_clnpass_internal(t1, bpno, OPJ_TRUE, t1->w, t1->h,
1391 t1->w + 2U);
1392 }
1393
1394 static void opj_t1_dec_clnpass(
1395 opj_t1_t *t1,
1396 OPJ_INT32 bpno,
1397 OPJ_INT32 cblksty)
1398 {
1399 if (t1->w == 64 && t1->h == 64) {
1400 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1401 opj_t1_dec_clnpass_64x64_vsc(t1, bpno);
1402 } else {
1403 opj_t1_dec_clnpass_64x64_novsc(t1, bpno);
1404 }
1405 } else {
1406 if (cblksty & J2K_CCP_CBLKSTY_VSC) {
1407 opj_t1_dec_clnpass_generic_vsc(t1, bpno);
1408 } else {
1409 opj_t1_dec_clnpass_generic_novsc(t1, bpno);
1410 }
1411 }
1412 opj_t1_dec_clnpass_check_segsym(t1, cblksty);
1413 }
1414
1415
1416 static OPJ_FLOAT64 opj_t1_getwmsedec(
1417 OPJ_INT32 nmsedec,
1418 OPJ_UINT32 compno,
1419 OPJ_UINT32 level,
1420 OPJ_UINT32 orient,
1421 OPJ_INT32 bpno,
1422 OPJ_UINT32 qmfbid,
1423 OPJ_FLOAT64 stepsize,
1424 OPJ_UINT32 numcomps,
1425 const OPJ_FLOAT64 * mct_norms,
1426 OPJ_UINT32 mct_numcomps)
1427 {
1428 OPJ_FLOAT64 w1 = 1, w2, wmsedec;
1429 OPJ_ARG_NOT_USED(numcomps);
1430
1431 if (mct_norms && (compno < mct_numcomps)) {
1432 w1 = mct_norms[compno];
1433 }
1434
1435 if (qmfbid == 1) {
1436 w2 = opj_dwt_getnorm(level, orient);
1437 } else { /* if (qmfbid == 0) */
1438 const OPJ_INT32 log2_gain = (orient == 0) ? 0 :
1439 (orient == 3) ? 2 : 1;
1440 w2 = opj_dwt_getnorm_real(level, orient);
1441 /* Not sure this is right. But preserves past behaviour */
1442 stepsize /= (1 << log2_gain);
1443 }
1444
1445 wmsedec = w1 * w2 * stepsize * (1 << bpno);
1446 wmsedec *= wmsedec * nmsedec / 8192.0;
1447
1448 return wmsedec;
1449 }
1450
1451 static OPJ_BOOL opj_t1_allocate_buffers(
1452 opj_t1_t *t1,
1453 OPJ_UINT32 w,
1454 OPJ_UINT32 h)
1455 {
1456 OPJ_UINT32 flagssize;
1457 OPJ_UINT32 flags_stride;
1458
1459 /* No risk of overflow. Prior checks ensure those assert are met */
1460 /* They are per the specification */
1461 assert(w <= 1024);
1462 assert(h <= 1024);
1463 assert(w * h <= 4096);
1464
1465 /* encoder uses tile buffer, so no need to allocate */
1466 {
1467 OPJ_UINT32 datasize = w * h;
1468
1469 if (datasize > t1->datasize) {
1470 opj_aligned_free(t1->data);
1471 t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
1472 if (!t1->data) {
1473 /* FIXME event manager error callback */
1474 return OPJ_FALSE;
1475 }
1476 t1->datasize = datasize;
1477 }
1478 /* memset first arg is declared to never be null by gcc */
1479 if (t1->data != NULL) {
1480 memset(t1->data, 0, datasize * sizeof(OPJ_INT32));
1481 }
1482 }
1483
1484 flags_stride = w + 2U; /* can't be 0U */
1485
1486 flagssize = (h + 3U) / 4U + 2U;
1487
1488 flagssize *= flags_stride;
1489 {
1490 opj_flag_t* p;
1491 OPJ_UINT32 x;
1492 OPJ_UINT32 flags_height = (h + 3U) / 4U;
1493
1494 if (flagssize > t1->flagssize) {
1495
1496 opj_aligned_free(t1->flags);
1497 t1->flags = (opj_flag_t*) opj_aligned_malloc(flagssize * sizeof(
1498 opj_flag_t));
1499 if (!t1->flags) {
1500 /* FIXME event manager error callback */
1501 return OPJ_FALSE;
1502 }
1503 }
1504 t1->flagssize = flagssize;
1505
1506 memset(t1->flags, 0, flagssize * sizeof(opj_flag_t));
1507
1508 p = &t1->flags[0];
1509 for (x = 0; x < flags_stride; ++x) {
1510 /* magic value to hopefully stop any passes being interested in this entry */
1511 *p++ = (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1512 }
1513
1514 p = &t1->flags[((flags_height + 1) * flags_stride)];
1515 for (x = 0; x < flags_stride; ++x) {
1516 /* magic value to hopefully stop any passes being interested in this entry */
1517 *p++ = (T1_PI_0 | T1_PI_1 | T1_PI_2 | T1_PI_3);
1518 }
1519
1520 if (h % 4) {
1521 OPJ_UINT32 v = 0;
1522 p = &t1->flags[((flags_height) * flags_stride)];
1523 if (h % 4 == 1) {
1524 v |= T1_PI_1 | T1_PI_2 | T1_PI_3;
1525 } else if (h % 4 == 2) {
1526 v |= T1_PI_2 | T1_PI_3;
1527 } else if (h % 4 == 3) {
1528 v |= T1_PI_3;
1529 }
1530 for (x = 0; x < flags_stride; ++x) {
1531 *p++ = v;
1532 }
1533 }
1534 }
1535
1536 t1->w = w;
1537 t1->h = h;
1538
1539 return OPJ_TRUE;
1540 }
1541
1542 /* ----------------------------------------------------------------------- */
1543
1544 /* ----------------------------------------------------------------------- */
1545 /**
1546 * Creates a new Tier 1 handle
1547 * and initializes the look-up tables of the Tier-1 coder/decoder
1548 * @return a new T1 handle if successful, returns NULL otherwise
1549 */
1550 opj_t1_t* opj_t1_create(OPJ_BOOL isEncoder)
1551 {
1552 opj_t1_t *l_t1 = 00;
1553
1554 l_t1 = (opj_t1_t*) opj_calloc(1, sizeof(opj_t1_t));
1555 if (!l_t1) {
1556 return 00;
1557 }
1558
1559 l_t1->encoder = isEncoder;
1560
1561 return l_t1;
1562 }
1563
1564
1565 /**
1566 * Destroys a previously created T1 handle
1567 *
1568 * @param p_t1 Tier 1 handle to destroy
1569 */
1570 void opj_t1_destroy(opj_t1_t *p_t1)
1571 {
1572 if (! p_t1) {
1573 return;
1574 }
1575
1576 if (p_t1->data) {
1577 opj_aligned_free(p_t1->data);
1578 p_t1->data = 00;
1579 }
1580
1581 if (p_t1->flags) {
1582 opj_aligned_free(p_t1->flags);
1583 p_t1->flags = 00;
1584 }
1585
1586 opj_free(p_t1->cblkdatabuffer);
1587
1588 opj_free(p_t1);
1589 }
1590
1591 typedef struct {
1592 OPJ_BOOL whole_tile_decoding;
1593 OPJ_UINT32 resno;
1594 opj_tcd_cblk_dec_t* cblk;
1595 opj_tcd_band_t* band;
1596 opj_tcd_tilecomp_t* tilec;
1597 opj_tccp_t* tccp;
1598 OPJ_BOOL mustuse_cblkdatabuffer;
1599 volatile OPJ_BOOL* pret;
1600 opj_event_mgr_t *p_manager;
1601 opj_mutex_t* p_manager_mutex;
1602 OPJ_BOOL check_pterm;
1603 } opj_t1_cblk_decode_processing_job_t;
1604
1605 static void opj_t1_destroy_wrapper(void* t1)
1606 {
1607 opj_t1_destroy((opj_t1_t*) t1);
1608 }
1609
1610 static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
1611 {
1612 opj_tcd_cblk_dec_t* cblk;
1613 opj_tcd_band_t* band;
1614 opj_tcd_tilecomp_t* tilec;
1615 opj_tccp_t* tccp;
1616 OPJ_INT32* OPJ_RESTRICT datap;
1617 OPJ_UINT32 cblk_w, cblk_h;
1618 OPJ_INT32 x, y;
1619 OPJ_UINT32 i, j;
1620 opj_t1_cblk_decode_processing_job_t* job;
1621 opj_t1_t* t1;
1622 OPJ_UINT32 resno;
1623 OPJ_UINT32 tile_w;
1624
1625 job = (opj_t1_cblk_decode_processing_job_t*) user_data;
1626
1627 cblk = job->cblk;
1628
1629 if (!job->whole_tile_decoding) {
1630 cblk_w = (OPJ_UINT32)(cblk->x1 - cblk->x0);
1631 cblk_h = (OPJ_UINT32)(cblk->y1 - cblk->y0);
1632
1633 cblk->decoded_data = (OPJ_INT32*)opj_aligned_malloc(sizeof(OPJ_INT32) *
1634 cblk_w * cblk_h);
1635 if (cblk->decoded_data == NULL) {
1636 if (job->p_manager_mutex) {
1637 opj_mutex_lock(job->p_manager_mutex);
1638 }
1639 opj_event_msg(job->p_manager, EVT_ERROR,
1640 "Cannot allocate cblk->decoded_data\n");
1641 if (job->p_manager_mutex) {
1642 opj_mutex_unlock(job->p_manager_mutex);
1643 }
1644 *(job->pret) = OPJ_FALSE;
1645 opj_free(job);
1646 return;
1647 }
1648 /* Zero-init required */
1649 memset(cblk->decoded_data, 0, sizeof(OPJ_INT32) * cblk_w * cblk_h);
1650 } else if (cblk->decoded_data) {
1651 /* Not sure if that code path can happen, but better be */
1652 /* safe than sorry */
1653 opj_aligned_free(cblk->decoded_data);
1654 cblk->decoded_data = NULL;
1655 }
1656
1657 resno = job->resno;
1658 band = job->band;
1659 tilec = job->tilec;
1660 tccp = job->tccp;
1661 tile_w = (OPJ_UINT32)(tilec->resolutions[tilec->minimum_num_resolutions - 1].x1
1662 -
1663 tilec->resolutions[tilec->minimum_num_resolutions - 1].x0);
1664
1665 if (!*(job->pret)) {
1666 opj_free(job);
1667 return;
1668 }
1669
1670 t1 = (opj_t1_t*) opj_tls_get(tls, OPJ_TLS_KEY_T1);
1671 if (t1 == NULL) {
1672 t1 = opj_t1_create(OPJ_FALSE);
1673 if (t1 == NULL) {
1674 opj_event_msg(job->p_manager, EVT_ERROR,
1675 "Cannot allocate Tier 1 handle\n");
1676 *(job->pret) = OPJ_FALSE;
1677 opj_free(job);
1678 return;
1679 }
1680 if (!opj_tls_set(tls, OPJ_TLS_KEY_T1, t1, opj_t1_destroy_wrapper)) {
1681 opj_event_msg(job->p_manager, EVT_ERROR,
1682 "Unable to set t1 handle as TLS\n");
1683 opj_t1_destroy(t1);
1684 *(job->pret) = OPJ_FALSE;
1685 opj_free(job);
1686 return;
1687 }
1688 }
1689 t1->mustuse_cblkdatabuffer = job->mustuse_cblkdatabuffer;
1690
1691 if ((tccp->cblksty & J2K_CCP_CBLKSTY_HT) != 0) {
1692 if (OPJ_FALSE == opj_t1_ht_decode_cblk(
1693 t1,
1694 cblk,
1695 band->bandno,
1696 (OPJ_UINT32)tccp->roishift,
1697 tccp->cblksty,
1698 job->p_manager,
1699 job->p_manager_mutex,
1700 job->check_pterm)) {
1701 *(job->pret) = OPJ_FALSE;
1702 opj_free(job);
1703 return;
1704 }
1705 } else {
1706 if (OPJ_FALSE == opj_t1_decode_cblk(
1707 t1,
1708 cblk,
1709 band->bandno,
1710 (OPJ_UINT32)tccp->roishift,
1711 tccp->cblksty,
1712 job->p_manager,
1713 job->p_manager_mutex,
1714 job->check_pterm)) {
1715 *(job->pret) = OPJ_FALSE;
1716 opj_free(job);
1717 return;
1718 }
1719 }
1720
1721 x = cblk->x0 - band->x0;
1722 y = cblk->y0 - band->y0;
1723 if (band->bandno & 1) {
1724 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1725 x += pres->x1 - pres->x0;
1726 }
1727 if (band->bandno & 2) {
1728 opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
1729 y += pres->y1 - pres->y0;
1730 }
1731
1732 datap = cblk->decoded_data ? cblk->decoded_data : t1->data;
1733 cblk_w = t1->w;
1734 cblk_h = t1->h;
1735
1736 if (tccp->roishift) {
1737 if (tccp->roishift >= 31) {
1738 for (j = 0; j < cblk_h; ++j) {
1739 for (i = 0; i < cblk_w; ++i) {
1740 datap[(j * cblk_w) + i] = 0;
1741 }
1742 }
1743 } else {
1744 OPJ_INT32 thresh = 1 << tccp->roishift;
1745 for (j = 0; j < cblk_h; ++j) {
1746 for (i = 0; i < cblk_w; ++i) {
1747 OPJ_INT32 val = datap[(j * cblk_w) + i];
1748 OPJ_INT32 mag = abs(val);
1749 if (mag >= thresh) {
1750 mag >>= tccp->roishift;
1751 datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
1752 }
1753 }
1754 }
1755 }
1756 }
1757
1758 /* Both can be non NULL if for example decoding a full tile and then */
1759 /* partially a tile. In which case partial decoding should be the */
1760 /* priority */
1761 assert((cblk->decoded_data != NULL) || (tilec->data != NULL));
1762
1763 if (cblk->decoded_data) {
1764 OPJ_UINT32 cblk_size = cblk_w * cblk_h;
1765 if (tccp->qmfbid == 1) {
1766 for (i = 0; i < cblk_size; ++i) {
1767 datap[i] /= 2;
1768 }
1769 } else { /* if (tccp->qmfbid == 0) */
1770 const float stepsize = 0.5f * band->stepsize;
1771 i = 0;
1772 #ifdef __SSE2__
1773 {
1774 const __m128 xmm_stepsize = _mm_set1_ps(stepsize);
1775 for (; i < (cblk_size & ~15U); i += 16) {
1776 __m128 xmm0_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
1777 datap + 0)));
1778 __m128 xmm1_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
1779 datap + 4)));
1780 __m128 xmm2_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
1781 datap + 8)));
1782 __m128 xmm3_data = _mm_cvtepi32_ps(_mm_load_si128((__m128i * const)(
1783 datap + 12)));
1784 _mm_store_ps((float*)(datap + 0), _mm_mul_ps(xmm0_data, xmm_stepsize));
1785 _mm_store_ps((float*)(datap + 4), _mm_mul_ps(xmm1_data, xmm_stepsize));
1786 _mm_store_ps((float*)(datap + 8), _mm_mul_ps(xmm2_data, xmm_stepsize));
1787 _mm_store_ps((float*)(datap + 12), _mm_mul_ps(xmm3_data, xmm_stepsize));
1788 datap += 16;
1789 }
1790 }
1791 #endif
1792 for (; i < cblk_size; ++i) {
1793 OPJ_FLOAT32 tmp = ((OPJ_FLOAT32)(*datap)) * stepsize;
1794 memcpy(datap, &tmp, sizeof(tmp));
1795 datap++;
1796 }
1797 }
1798 } else if (tccp->qmfbid == 1) {
1799 OPJ_INT32* OPJ_RESTRICT tiledp = &tilec->data[(OPJ_SIZE_T)y * tile_w +
1800 (OPJ_SIZE_T)x];
1801 for (j = 0; j < cblk_h; ++j) {
1802 //positive -> round down aka. (83)/2 = 41.5 -> 41
1803 //negative -> round up aka. (-83)/2 = -41.5 -> -41
1804 #if defined(__AVX512F__)
1805 OPJ_INT32* ptr_in = datap + (j * cblk_w);
1806 OPJ_INT32* ptr_out = tiledp + (j * (OPJ_SIZE_T)tile_w);
1807 for (i = 0; i < cblk_w / 16; ++i) {
1808 __m512i in_avx = _mm512_loadu_si512((__m512i*)(ptr_in));
1809 const __m512i add_avx = _mm512_srli_epi32(in_avx, 31);
1810 in_avx = _mm512_add_epi32(in_avx, add_avx);
1811 _mm512_storeu_si512((__m512i*)(ptr_out), _mm512_srai_epi32(in_avx, 1));
1812 ptr_in += 16;
1813 ptr_out += 16;
1814 }
1815
1816 for (i = 0; i < cblk_w % 16; ++i) {
1817 ptr_out[i] = ptr_in[i] / 2;
1818 }
1819 #elif defined(__AVX2__)
1820 OPJ_INT32* ptr_in = datap + (j * cblk_w);
1821 OPJ_INT32* ptr_out = tiledp + (j * (OPJ_SIZE_T)tile_w);
1822 for (i = 0; i < cblk_w / 8; ++i) {
1823 __m256i in_avx = _mm256_loadu_si256((__m256i*)(ptr_in));
1824 const __m256i add_avx = _mm256_srli_epi32(in_avx, 31);
1825 in_avx = _mm256_add_epi32(in_avx, add_avx);
1826 _mm256_storeu_si256((__m256i*)(ptr_out), _mm256_srai_epi32(in_avx, 1));
1827 ptr_in += 8;
1828 ptr_out += 8;
1829 }
1830
1831 for (i = 0; i < cblk_w % 8; ++i) {
1832 ptr_out[i] = ptr_in[i] / 2;
1833 }
1834 #else
1835 i = 0;
1836 for (; i < (cblk_w & ~(OPJ_UINT32)3U); i += 4U) {
1837 OPJ_INT32 tmp0 = datap[(j * cblk_w) + i + 0U];
1838 OPJ_INT32 tmp1 = datap[(j * cblk_w) + i + 1U];
1839 OPJ_INT32 tmp2 = datap[(j * cblk_w) + i + 2U];
1840 OPJ_INT32 tmp3 = datap[(j * cblk_w) + i + 3U];
1841 ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 0U] = tmp0 / 2;
1842 ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 1U] = tmp1 / 2;
1843 ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 2U] = tmp2 / 2;
1844 ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i + 3U] = tmp3 / 2;
1845 }
1846 for (; i < cblk_w; ++i) {
1847 OPJ_INT32 tmp = datap[(j * cblk_w) + i];
1848 ((OPJ_INT32*)tiledp)[(j * (OPJ_SIZE_T)tile_w) + i] = tmp / 2;
1849 }
1850 #endif
1851 }
1852 } else { /* if (tccp->qmfbid == 0) */
1853 const float stepsize = 0.5f * band->stepsize;
1854 OPJ_FLOAT32* OPJ_RESTRICT tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_SIZE_T)y *
1855 tile_w + (OPJ_SIZE_T)x];
1856 for (j = 0; j < cblk_h; ++j) {
1857 OPJ_FLOAT32* OPJ_RESTRICT tiledp2 = tiledp;
1858 for (i = 0; i < cblk_w; ++i) {
1859 OPJ_FLOAT32 tmp = (OPJ_FLOAT32) * datap * stepsize;
1860 *tiledp2 = tmp;
1861 datap++;
1862 tiledp2++;
1863 }
1864 tiledp += tile_w;
1865 }
1866 }
1867
1868 opj_free(job);
1869 }
1870
1871
1872 void opj_t1_decode_cblks(opj_tcd_t* tcd,
1873 volatile OPJ_BOOL* pret,
1874 opj_tcd_tilecomp_t* tilec,
1875 opj_tccp_t* tccp,
1876 opj_event_mgr_t *p_manager,
1877 opj_mutex_t* p_manager_mutex,
1878 OPJ_BOOL check_pterm
1879 )
1880 {
1881 opj_thread_pool_t* tp = tcd->thread_pool;
1882 OPJ_UINT32 resno, bandno, precno, cblkno;
1883
1884 #ifdef DEBUG_VERBOSE
1885 OPJ_UINT32 codeblocks_decoded = 0;
1886 printf("Enter opj_t1_decode_cblks()\n");
1887 #endif
1888
1889 for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
1890 opj_tcd_resolution_t* res = &tilec->resolutions[resno];
1891
1892 for (bandno = 0; bandno < res->numbands; ++bandno) {
1893 opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
1894
1895 for (precno = 0; precno < res->pw * res->ph; ++precno) {
1896 opj_tcd_precinct_t* precinct = &band->precincts[precno];
1897
1898 if (!opj_tcd_is_subband_area_of_interest(tcd,
1899 tilec->compno,
1900 resno,
1901 band->bandno,
1902 (OPJ_UINT32)precinct->x0,
1903 (OPJ_UINT32)precinct->y0,
1904 (OPJ_UINT32)precinct->x1,
1905 (OPJ_UINT32)precinct->y1)) {
1906 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1907 opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
1908 if (cblk->decoded_data) {
1909 #ifdef DEBUG_VERBOSE
1910 printf("Discarding codeblock %d,%d at resno=%d, bandno=%d\n",
1911 cblk->x0, cblk->y0, resno, bandno);
1912 #endif
1913 opj_aligned_free(cblk->decoded_data);
1914 cblk->decoded_data = NULL;
1915 }
1916 }
1917 continue;
1918 }
1919
1920 for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
1921 opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
1922 opj_t1_cblk_decode_processing_job_t* job;
1923
1924 if (!opj_tcd_is_subband_area_of_interest(tcd,
1925 tilec->compno,
1926 resno,
1927 band->bandno,
1928 (OPJ_UINT32)cblk->x0,
1929 (OPJ_UINT32)cblk->y0,
1930 (OPJ_UINT32)cblk->x1,
1931 (OPJ_UINT32)cblk->y1)) {
1932 if (cblk->decoded_data) {
1933 #ifdef DEBUG_VERBOSE
1934 printf("Discarding codeblock %d,%d at resno=%d, bandno=%d\n",
1935 cblk->x0, cblk->y0, resno, bandno);
1936 #endif
1937 opj_aligned_free(cblk->decoded_data);
1938 cblk->decoded_data = NULL;
1939 }
1940 continue;
1941 }
1942
1943 if (!tcd->whole_tile_decoding) {
1944 OPJ_UINT32 cblk_w = (OPJ_UINT32)(cblk->x1 - cblk->x0);
1945 OPJ_UINT32 cblk_h = (OPJ_UINT32)(cblk->y1 - cblk->y0);
1946 if (cblk->decoded_data != NULL) {
1947 #ifdef DEBUG_VERBOSE
1948 printf("Reusing codeblock %d,%d at resno=%d, bandno=%d\n",
1949 cblk->x0, cblk->y0, resno, bandno);
1950 #endif
1951 continue;
1952 }
1953 if (cblk_w == 0 || cblk_h == 0) {
1954 continue;
1955 }
1956 #ifdef DEBUG_VERBOSE
1957 printf("Decoding codeblock %d,%d at resno=%d, bandno=%d\n",
1958 cblk->x0, cblk->y0, resno, bandno);
1959 #endif
1960 }
1961
1962 job = (opj_t1_cblk_decode_processing_job_t*) opj_calloc(1,
1963 sizeof(opj_t1_cblk_decode_processing_job_t));
1964 if (!job) {
1965 *pret = OPJ_FALSE;
1966 return;
1967 }
1968 job->whole_tile_decoding = tcd->whole_tile_decoding;
1969 job->resno = resno;
1970 job->cblk = cblk;
1971 job->band = band;
1972 job->tilec = tilec;
1973 job->tccp = tccp;
1974 job->pret = pret;
1975 job->p_manager_mutex = p_manager_mutex;
1976 job->p_manager = p_manager;
1977 job->check_pterm = check_pterm;
1978 job->mustuse_cblkdatabuffer = opj_thread_pool_get_thread_count(tp) > 1;
1979 opj_thread_pool_submit_job(tp, opj_t1_clbl_decode_processor, job);
1980 #ifdef DEBUG_VERBOSE
1981 codeblocks_decoded ++;
1982 #endif
1983 if (!(*pret)) {
1984 return;
1985 }
1986 } /* cblkno */
1987 } /* precno */
1988 } /* bandno */
1989 } /* resno */
1990
1991 #ifdef DEBUG_VERBOSE
1992 printf("Leave opj_t1_decode_cblks(). Number decoded: %d\n", codeblocks_decoded);
1993 #endif
1994 return;
1995 }
1996
1997
1998 static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
1999 opj_tcd_cblk_dec_t* cblk,
2000 OPJ_UINT32 orient,
2001 OPJ_UINT32 roishift,
2002 OPJ_UINT32 cblksty,
2003 opj_event_mgr_t *p_manager,
2004 opj_mutex_t* p_manager_mutex,
2005 OPJ_BOOL check_pterm)
2006 {
2007 opj_mqc_t *mqc = &(t1->mqc); /* MQC component */
2008
2009 OPJ_INT32 bpno_plus_one;
2010 OPJ_UINT32 passtype;
2011 OPJ_UINT32 segno, passno;
2012 OPJ_BYTE* cblkdata = NULL;
2013 OPJ_UINT32 cblkdataindex = 0;
2014 OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
2015 OPJ_INT32* original_t1_data = NULL;
2016
2017 mqc->lut_ctxno_zc_orient = lut_ctxno_zc + (orient << 9);
2018
2019 if (!opj_t1_allocate_buffers(
2020 t1,
2021 (OPJ_UINT32)(cblk->x1 - cblk->x0),
2022 (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
2023 return OPJ_FALSE;
2024 }
2025
2026 bpno_plus_one = (OPJ_INT32)(roishift + cblk->numbps);
2027 if (bpno_plus_one >= 31) {
2028 if (p_manager_mutex) {
2029 opj_mutex_lock(p_manager_mutex);
2030 }
2031 opj_event_msg(p_manager, EVT_WARNING,
2032 "opj_t1_decode_cblk(): unsupported bpno_plus_one = %d >= 31\n",
2033 bpno_plus_one);
2034 if (p_manager_mutex) {
2035 opj_mutex_unlock(p_manager_mutex);
2036 }
2037 return OPJ_FALSE;
2038 }
2039 passtype = 2;
2040
2041 opj_mqc_resetstates(mqc);
2042 opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2043 opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2044 opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2045
2046 if (cblk->corrupted) {
2047 assert(cblk->numchunks == 0);
2048 return OPJ_TRUE;
2049 }
2050
2051 /* Even if we have a single chunk, in multi-threaded decoding */
2052 /* the insertion of our synthetic marker might potentially override */
2053 /* valid codestream of other codeblocks decoded in parallel. */
2054 if (cblk->numchunks > 1 || (t1->mustuse_cblkdatabuffer &&
2055 cblk->numchunks > 0)) {
2056 OPJ_UINT32 i;
2057 OPJ_UINT32 cblk_len;
2058
2059 /* Compute whole codeblock length from chunk lengths */
2060 cblk_len = 0;
2061 for (i = 0; i < cblk->numchunks; i++) {
2062 cblk_len += cblk->chunks[i].len;
2063 }
2064
2065 /* Allocate temporary memory if needed */
2066 if (cblk_len + OPJ_COMMON_CBLK_DATA_EXTRA > t1->cblkdatabuffersize) {
2067 cblkdata = (OPJ_BYTE*)opj_realloc(t1->cblkdatabuffer,
2068 cblk_len + OPJ_COMMON_CBLK_DATA_EXTRA);
2069 if (cblkdata == NULL) {
2070 return OPJ_FALSE;
2071 }
2072 t1->cblkdatabuffer = cblkdata;
2073 memset(t1->cblkdatabuffer + cblk_len, 0, OPJ_COMMON_CBLK_DATA_EXTRA);
2074 t1->cblkdatabuffersize = cblk_len + OPJ_COMMON_CBLK_DATA_EXTRA;
2075 }
2076
2077 /* Concatenate all chunks */
2078 cblkdata = t1->cblkdatabuffer;
2079 cblk_len = 0;
2080 for (i = 0; i < cblk->numchunks; i++) {
2081 memcpy(cblkdata + cblk_len, cblk->chunks[i].data, cblk->chunks[i].len);
2082 cblk_len += cblk->chunks[i].len;
2083 }
2084 } else if (cblk->numchunks == 1) {
2085 cblkdata = cblk->chunks[0].data;
2086 } else {
2087 /* Not sure if that can happen in practice, but avoid Coverity to */
2088 /* think we will dereference a null cblkdta pointer */
2089 return OPJ_TRUE;
2090 }
2091
2092 /* For subtile decoding, directly decode in the decoded_data buffer of */
2093 /* the code-block. Hack t1->data to point to it, and restore it later */
2094 if (cblk->decoded_data) {
2095 original_t1_data = t1->data;
2096 t1->data = cblk->decoded_data;
2097 }
2098
2099 for (segno = 0; segno < cblk->real_num_segs; ++segno) {
2100 opj_tcd_seg_t *seg = &cblk->segs[segno];
2101
2102 /* BYPASS mode */
2103 type = ((bpno_plus_one <= ((OPJ_INT32)(cblk->numbps)) - 4) && (passtype < 2) &&
2104 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2105
2106 if (type == T1_TYPE_RAW) {
2107 opj_mqc_raw_init_dec(mqc, cblkdata + cblkdataindex, seg->len,
2108 OPJ_COMMON_CBLK_DATA_EXTRA);
2109 } else {
2110 opj_mqc_init_dec(mqc, cblkdata + cblkdataindex, seg->len,
2111 OPJ_COMMON_CBLK_DATA_EXTRA);
2112 }
2113 cblkdataindex += seg->len;
2114
2115 for (passno = 0; (passno < seg->real_num_passes) &&
2116 (bpno_plus_one >= 1); ++passno) {
2117 switch (passtype) {
2118 case 0:
2119 if (type == T1_TYPE_RAW) {
2120 opj_t1_dec_sigpass_raw(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2121 } else {
2122 opj_t1_dec_sigpass_mqc(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2123 }
2124 break;
2125 case 1:
2126 if (type == T1_TYPE_RAW) {
2127 opj_t1_dec_refpass_raw(t1, bpno_plus_one);
2128 } else {
2129 opj_t1_dec_refpass_mqc(t1, bpno_plus_one);
2130 }
2131 break;
2132 case 2:
2133 opj_t1_dec_clnpass(t1, bpno_plus_one, (OPJ_INT32)cblksty);
2134 break;
2135 }
2136
2137 if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
2138 opj_mqc_resetstates(mqc);
2139 opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2140 opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2141 opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2142 }
2143 if (++passtype == 3) {
2144 passtype = 0;
2145 bpno_plus_one--;
2146 }
2147 }
2148
2149 opq_mqc_finish_dec(mqc);
2150 }
2151
2152 if (check_pterm) {
2153 if (mqc->bp + 2 < mqc->end) {
2154 if (p_manager_mutex) {
2155 opj_mutex_lock(p_manager_mutex);
2156 }
2157 opj_event_msg(p_manager, EVT_WARNING,
2158 "PTERM check failure: %d remaining bytes in code block (%d used / %d)\n",
2159 (int)(mqc->end - mqc->bp) - 2,
2160 (int)(mqc->bp - mqc->start),
2161 (int)(mqc->end - mqc->start));
2162 if (p_manager_mutex) {
2163 opj_mutex_unlock(p_manager_mutex);
2164 }
2165 } else if (mqc->end_of_byte_stream_counter > 2) {
2166 if (p_manager_mutex) {
2167 opj_mutex_lock(p_manager_mutex);
2168 }
2169 opj_event_msg(p_manager, EVT_WARNING,
2170 "PTERM check failure: %d synthesized 0xFF markers read\n",
2171 mqc->end_of_byte_stream_counter);
2172 if (p_manager_mutex) {
2173 opj_mutex_unlock(p_manager_mutex);
2174 }
2175 }
2176 }
2177
2178 /* Restore original t1->data is needed */
2179 if (cblk->decoded_data) {
2180 t1->data = original_t1_data;
2181 }
2182
2183 return OPJ_TRUE;
2184 }
2185
2186
2187 typedef struct {
2188 OPJ_UINT32 compno;
2189 OPJ_UINT32 resno;
2190 opj_tcd_cblk_enc_t* cblk;
2191 opj_tcd_tile_t *tile;
2192 opj_tcd_band_t* band;
2193 opj_tcd_tilecomp_t* tilec;
2194 opj_tccp_t* tccp;
2195 const OPJ_FLOAT64 * mct_norms;
2196 OPJ_UINT32 mct_numcomps;
2197 volatile OPJ_BOOL* pret;
2198 opj_mutex_t* mutex;
2199 } opj_t1_cblk_encode_processing_job_t;
2200
2201 /** Procedure to deal with a asynchronous code-block encoding job.
2202 *
2203 * @param user_data Pointer to a opj_t1_cblk_encode_processing_job_t* structure
2204 * @param tls TLS handle.
2205 */
2206 static void opj_t1_cblk_encode_processor(void* user_data, opj_tls_t* tls)
2207 {
2208 opj_t1_cblk_encode_processing_job_t* job =
2209 (opj_t1_cblk_encode_processing_job_t*)user_data;
2210 opj_tcd_cblk_enc_t* cblk = job->cblk;
2211 const opj_tcd_band_t* band = job->band;
2212 const opj_tcd_tilecomp_t* tilec = job->tilec;
2213 const opj_tccp_t* tccp = job->tccp;
2214 const OPJ_UINT32 resno = job->resno;
2215 opj_t1_t* t1;
2216 const OPJ_UINT32 tile_w = (OPJ_UINT32)(tilec->x1 - tilec->x0);
2217
2218 OPJ_INT32* OPJ_RESTRICT tiledp;
2219 OPJ_UINT32 cblk_w;
2220 OPJ_UINT32 cblk_h;
2221 OPJ_UINT32 i, j;
2222
2223 OPJ_INT32 x = cblk->x0 - band->x0;
2224 OPJ_INT32 y = cblk->y0 - band->y0;
2225
2226 if (!*(job->pret)) {
2227 opj_free(job);
2228 return;
2229 }
2230
2231 t1 = (opj_t1_t*) opj_tls_get(tls, OPJ_TLS_KEY_T1);
2232 if (t1 == NULL) {
2233 t1 = opj_t1_create(OPJ_TRUE); /* OPJ_TRUE == T1 for encoding */
2234 opj_tls_set(tls, OPJ_TLS_KEY_T1, t1, opj_t1_destroy_wrapper);
2235 }
2236
2237 if (band->bandno & 1) {
2238 opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
2239 x += pres->x1 - pres->x0;
2240 }
2241 if (band->bandno & 2) {
2242 opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
2243 y += pres->y1 - pres->y0;
2244 }
2245
2246 if (!opj_t1_allocate_buffers(
2247 t1,
2248 (OPJ_UINT32)(cblk->x1 - cblk->x0),
2249 (OPJ_UINT32)(cblk->y1 - cblk->y0))) {
2250 *(job->pret) = OPJ_FALSE;
2251 opj_free(job);
2252 return;
2253 }
2254
2255 cblk_w = t1->w;
2256 cblk_h = t1->h;
2257
2258 tiledp = &tilec->data[(OPJ_SIZE_T)y * tile_w + (OPJ_SIZE_T)x];
2259
2260 if (tccp->qmfbid == 1) {
2261 /* Do multiplication on unsigned type, even if the
2262 * underlying type is signed, to avoid potential
2263 * int overflow on large value (the output will be
2264 * incorrect in such situation, but whatever...)
2265 * This assumes complement-to-2 signed integer
2266 * representation
2267 * Fixes https://github.com/uclouvain/openjpeg/issues/1053
2268 */
2269 OPJ_UINT32* OPJ_RESTRICT tiledp_u = (OPJ_UINT32*) tiledp;
2270 OPJ_UINT32* OPJ_RESTRICT t1data = (OPJ_UINT32*) t1->data;
2271 /* Change from "natural" order to "zigzag" order of T1 passes */
2272 for (j = 0; j < (cblk_h & ~3U); j += 4) {
2273 #if defined(__AVX512F__)
2274 const __m512i perm1 = _mm512_setr_epi64(2, 3, 10, 11, 4, 5, 12, 13);
2275 const __m512i perm2 = _mm512_setr_epi64(6, 7, 14, 15, 0, 0, 0, 0);
2276 OPJ_UINT32* ptr = tiledp_u;
2277 for (i = 0; i < cblk_w / 16; ++i) {
2278 // INPUT OUTPUT
2279 // 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
2280 // 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
2281 // 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
2282 // 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
2283 __m512i in1 = _mm512_slli_epi32(_mm512_loadu_si512((__m512i*)(ptr +
2284 (j + 0) * tile_w)), T1_NMSEDEC_FRACBITS);
2285 __m512i in2 = _mm512_slli_epi32(_mm512_loadu_si512((__m512i*)(ptr +
2286 (j + 1) * tile_w)), T1_NMSEDEC_FRACBITS);
2287 __m512i in3 = _mm512_slli_epi32(_mm512_loadu_si512((__m512i*)(ptr +
2288 (j + 2) * tile_w)), T1_NMSEDEC_FRACBITS);
2289 __m512i in4 = _mm512_slli_epi32(_mm512_loadu_si512((__m512i*)(ptr +
2290 (j + 3) * tile_w)), T1_NMSEDEC_FRACBITS);
2291
2292 __m512i tmp1 = _mm512_unpacklo_epi32(in1, in2);
2293 __m512i tmp2 = _mm512_unpacklo_epi32(in3, in4);
2294 __m512i tmp3 = _mm512_unpackhi_epi32(in1, in2);
2295 __m512i tmp4 = _mm512_unpackhi_epi32(in3, in4);
2296
2297 in1 = _mm512_unpacklo_epi64(tmp1, tmp2);
2298 in2 = _mm512_unpacklo_epi64(tmp3, tmp4);
2299 in3 = _mm512_unpackhi_epi64(tmp1, tmp2);
2300 in4 = _mm512_unpackhi_epi64(tmp3, tmp4);
2301
2302 _mm_storeu_si128((__m128i*)(t1data + 0), _mm512_castsi512_si128(in1));
2303 _mm_storeu_si128((__m128i*)(t1data + 4), _mm512_castsi512_si128(in3));
2304 _mm_storeu_si128((__m128i*)(t1data + 8), _mm512_castsi512_si128(in2));
2305 _mm_storeu_si128((__m128i*)(t1data + 12), _mm512_castsi512_si128(in4));
2306
2307 tmp1 = _mm512_permutex2var_epi64(in1, perm1, in3);
2308 tmp2 = _mm512_permutex2var_epi64(in2, perm1, in4);
2309
2310 _mm256_storeu_si256((__m256i*)(t1data + 16), _mm512_castsi512_si256(tmp1));
2311 _mm256_storeu_si256((__m256i*)(t1data + 24), _mm512_castsi512_si256(tmp2));
2312 _mm256_storeu_si256((__m256i*)(t1data + 32), _mm512_extracti64x4_epi64(tmp1,
2313 0x1));
2314 _mm256_storeu_si256((__m256i*)(t1data + 40), _mm512_extracti64x4_epi64(tmp2,
2315 0x1));
2316 _mm256_storeu_si256((__m256i*)(t1data + 48),
2317 _mm512_castsi512_si256(_mm512_permutex2var_epi64(in1, perm2, in3)));
2318 _mm256_storeu_si256((__m256i*)(t1data + 56),
2319 _mm512_castsi512_si256(_mm512_permutex2var_epi64(in2, perm2, in4)));
2320 t1data += 64;
2321 ptr += 16;
2322 }
2323 for (i = 0; i < cblk_w % 16; ++i) {
2324 t1data[0] = ptr[(j + 0) * tile_w] << T1_NMSEDEC_FRACBITS;
2325 t1data[1] = ptr[(j + 1) * tile_w] << T1_NMSEDEC_FRACBITS;
2326 t1data[2] = ptr[(j + 2) * tile_w] << T1_NMSEDEC_FRACBITS;
2327 t1data[3] = ptr[(j + 3) * tile_w] << T1_NMSEDEC_FRACBITS;
2328 t1data += 4;
2329 ptr += 1;
2330 }
2331 #elif defined(__AVX2__)
2332 OPJ_UINT32* ptr = tiledp_u;
2333 for (i = 0; i < cblk_w / 8; ++i) {
2334 // INPUT OUTPUT
2335 // 00 01 02 03 04 05 06 07 00 10 20 30 01 11 21 31
2336 // 10 11 12 13 14 15 16 17 02 12 22 32 03 13 23 33
2337 // 20 21 22 23 24 25 26 27 04 14 24 34 05 15 25 35
2338 // 30 31 32 33 34 35 36 37 06 16 26 36 07 17 27 37
2339 __m256i in1 = _mm256_slli_epi32(_mm256_loadu_si256((__m256i*)(ptr +
2340 (j + 0) * tile_w)), T1_NMSEDEC_FRACBITS);
2341 __m256i in2 = _mm256_slli_epi32(_mm256_loadu_si256((__m256i*)(ptr +
2342 (j + 1) * tile_w)), T1_NMSEDEC_FRACBITS);
2343 __m256i in3 = _mm256_slli_epi32(_mm256_loadu_si256((__m256i*)(ptr +
2344 (j + 2) * tile_w)), T1_NMSEDEC_FRACBITS);
2345 __m256i in4 = _mm256_slli_epi32(_mm256_loadu_si256((__m256i*)(ptr +
2346 (j + 3) * tile_w)), T1_NMSEDEC_FRACBITS);
2347
2348 __m256i tmp1 = _mm256_unpacklo_epi32(in1, in2);
2349 __m256i tmp2 = _mm256_unpacklo_epi32(in3, in4);
2350 __m256i tmp3 = _mm256_unpackhi_epi32(in1, in2);
2351 __m256i tmp4 = _mm256_unpackhi_epi32(in3, in4);
2352
2353 in1 = _mm256_unpacklo_epi64(tmp1, tmp2);
2354 in2 = _mm256_unpacklo_epi64(tmp3, tmp4);
2355 in3 = _mm256_unpackhi_epi64(tmp1, tmp2);
2356 in4 = _mm256_unpackhi_epi64(tmp3, tmp4);
2357
2358 _mm_storeu_si128((__m128i*)(t1data + 0), _mm256_castsi256_si128(in1));
2359 _mm_storeu_si128((__m128i*)(t1data + 4), _mm256_castsi256_si128(in3));
2360 _mm_storeu_si128((__m128i*)(t1data + 8), _mm256_castsi256_si128(in2));
2361 _mm_storeu_si128((__m128i*)(t1data + 12), _mm256_castsi256_si128(in4));
2362 _mm256_storeu_si256((__m256i*)(t1data + 16), _mm256_permute2x128_si256(in1, in3,
2363 0x31));
2364 _mm256_storeu_si256((__m256i*)(t1data + 24), _mm256_permute2x128_si256(in2, in4,
2365 0x31));
2366 t1data += 32;
2367 ptr += 8;
2368 }
2369 for (i = 0; i < cblk_w % 8; ++i) {
2370 t1data[0] = ptr[(j + 0) * tile_w] << T1_NMSEDEC_FRACBITS;
2371 t1data[1] = ptr[(j + 1) * tile_w] << T1_NMSEDEC_FRACBITS;
2372 t1data[2] = ptr[(j + 2) * tile_w] << T1_NMSEDEC_FRACBITS;
2373 t1data[3] = ptr[(j + 3) * tile_w] << T1_NMSEDEC_FRACBITS;
2374 t1data += 4;
2375 ptr += 1;
2376 }
2377 #else
2378 for (i = 0; i < cblk_w; ++i) {
2379 t1data[0] = tiledp_u[(j + 0) * tile_w + i] << T1_NMSEDEC_FRACBITS;
2380 t1data[1] = tiledp_u[(j + 1) * tile_w + i] << T1_NMSEDEC_FRACBITS;
2381 t1data[2] = tiledp_u[(j + 2) * tile_w + i] << T1_NMSEDEC_FRACBITS;
2382 t1data[3] = tiledp_u[(j + 3) * tile_w + i] << T1_NMSEDEC_FRACBITS;
2383 t1data += 4;
2384 }
2385 #endif
2386 }
2387 if (j < cblk_h) {
2388 for (i = 0; i < cblk_w; ++i) {
2389 OPJ_UINT32 k;
2390 for (k = j; k < cblk_h; k++) {
2391 t1data[0] = tiledp_u[k * tile_w + i] << T1_NMSEDEC_FRACBITS;
2392 t1data ++;
2393 }
2394 }
2395 }
2396 } else { /* if (tccp->qmfbid == 0) */
2397 OPJ_FLOAT32* OPJ_RESTRICT tiledp_f = (OPJ_FLOAT32*) tiledp;
2398 OPJ_INT32* OPJ_RESTRICT t1data = t1->data;
2399 /* Change from "natural" order to "zigzag" order of T1 passes */
2400 for (j = 0; j < (cblk_h & ~3U); j += 4) {
2401 for (i = 0; i < cblk_w; ++i) {
2402 t1data[0] = (OPJ_INT32)opj_lrintf((tiledp_f[(j + 0) * tile_w + i] /
2403 band->stepsize) * (1 << T1_NMSEDEC_FRACBITS));
2404 t1data[1] = (OPJ_INT32)opj_lrintf((tiledp_f[(j + 1) * tile_w + i] /
2405 band->stepsize) * (1 << T1_NMSEDEC_FRACBITS));
2406 t1data[2] = (OPJ_INT32)opj_lrintf((tiledp_f[(j + 2) * tile_w + i] /
2407 band->stepsize) * (1 << T1_NMSEDEC_FRACBITS));
2408 t1data[3] = (OPJ_INT32)opj_lrintf((tiledp_f[(j + 3) * tile_w + i] /
2409 band->stepsize) * (1 << T1_NMSEDEC_FRACBITS));
2410 t1data += 4;
2411 }
2412 }
2413 if (j < cblk_h) {
2414 for (i = 0; i < cblk_w; ++i) {
2415 OPJ_UINT32 k;
2416 for (k = j; k < cblk_h; k++) {
2417 t1data[0] = (OPJ_INT32)opj_lrintf((tiledp_f[k * tile_w + i] / band->stepsize)
2418 * (1 << T1_NMSEDEC_FRACBITS));
2419 t1data ++;
2420 }
2421 }
2422 }
2423 }
2424
2425 {
2426 OPJ_FLOAT64 cumwmsedec =
2427 opj_t1_encode_cblk(
2428 t1,
2429 cblk,
2430 band->bandno,
2431 job->compno,
2432 tilec->numresolutions - 1 - resno,
2433 tccp->qmfbid,
2434 band->stepsize,
2435 tccp->cblksty,
2436 job->tile->numcomps,
2437 job->mct_norms,
2438 job->mct_numcomps);
2439 if (job->mutex) {
2440 opj_mutex_lock(job->mutex);
2441 }
2442 job->tile->distotile += cumwmsedec;
2443 if (job->mutex) {
2444 opj_mutex_unlock(job->mutex);
2445 }
2446 }
2447
2448 opj_free(job);
2449 }
2450
2451
2452 OPJ_BOOL opj_t1_encode_cblks(opj_tcd_t* tcd,
2453 opj_tcd_tile_t *tile,
2454 opj_tcp_t *tcp,
2455 const OPJ_FLOAT64 * mct_norms,
2456 OPJ_UINT32 mct_numcomps
2457 )
2458 {
2459 volatile OPJ_BOOL ret = OPJ_TRUE;
2460 opj_thread_pool_t* tp = tcd->thread_pool;
2461 OPJ_UINT32 compno, resno, bandno, precno, cblkno;
2462 opj_mutex_t* mutex = opj_mutex_create();
2463
2464 tile->distotile = 0;
2465
2466 for (compno = 0; compno < tile->numcomps; ++compno) {
2467 opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
2468 opj_tccp_t* tccp = &tcp->tccps[compno];
2469
2470 for (resno = 0; resno < tilec->numresolutions; ++resno) {
2471 opj_tcd_resolution_t *res = &tilec->resolutions[resno];
2472
2473 for (bandno = 0; bandno < res->numbands; ++bandno) {
2474 opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
2475
2476 /* Skip empty bands */
2477 if (opj_tcd_is_band_empty(band)) {
2478 continue;
2479 }
2480 for (precno = 0; precno < res->pw * res->ph; ++precno) {
2481 opj_tcd_precinct_t *prc = &band->precincts[precno];
2482
2483 for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
2484 opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
2485
2486 opj_t1_cblk_encode_processing_job_t* job =
2487 (opj_t1_cblk_encode_processing_job_t*) opj_calloc(1,
2488 sizeof(opj_t1_cblk_encode_processing_job_t));
2489 if (!job) {
2490 ret = OPJ_FALSE;
2491 goto end;
2492 }
2493 job->compno = compno;
2494 job->tile = tile;
2495 job->resno = resno;
2496 job->cblk = cblk;
2497 job->band = band;
2498 job->tilec = tilec;
2499 job->tccp = tccp;
2500 job->mct_norms = mct_norms;
2501 job->mct_numcomps = mct_numcomps;
2502 job->pret = &ret;
2503 job->mutex = mutex;
2504 opj_thread_pool_submit_job(tp, opj_t1_cblk_encode_processor, job);
2505
2506 } /* cblkno */
2507 } /* precno */
2508 } /* bandno */
2509 } /* resno */
2510 } /* compno */
2511
2512 end:
2513 opj_thread_pool_wait_completion(tcd->thread_pool, 0);
2514 if (mutex) {
2515 opj_mutex_destroy(mutex);
2516 }
2517
2518 return ret;
2519 }
2520
2521 /* Returns whether the pass (bpno, passtype) is terminated */
2522 static int opj_t1_enc_is_term_pass(opj_tcd_cblk_enc_t* cblk,
2523 OPJ_UINT32 cblksty,
2524 OPJ_INT32 bpno,
2525 OPJ_UINT32 passtype)
2526 {
2527 /* Is it the last cleanup pass ? */
2528 if (passtype == 2 && bpno == 0) {
2529 return OPJ_TRUE;
2530 }
2531
2532 if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
2533 return OPJ_TRUE;
2534 }
2535
2536 if ((cblksty & J2K_CCP_CBLKSTY_LAZY)) {
2537 /* For bypass arithmetic bypass, terminate the 4th cleanup pass */
2538 if ((bpno == ((OPJ_INT32)cblk->numbps - 4)) && (passtype == 2)) {
2539 return OPJ_TRUE;
2540 }
2541 /* and beyond terminate all the magnitude refinement passes (in raw) */
2542 /* and cleanup passes (in MQC) */
2543 if ((bpno < ((OPJ_INT32)(cblk->numbps) - 4)) && (passtype > 0)) {
2544 return OPJ_TRUE;
2545 }
2546 }
2547
2548 return OPJ_FALSE;
2549 }
2550
2551
2552 static OPJ_FLOAT64 opj_t1_encode_cblk(opj_t1_t *t1,
2553 opj_tcd_cblk_enc_t* cblk,
2554 OPJ_UINT32 orient,
2555 OPJ_UINT32 compno,
2556 OPJ_UINT32 level,
2557 OPJ_UINT32 qmfbid,
2558 OPJ_FLOAT64 stepsize,
2559 OPJ_UINT32 cblksty,
2560 OPJ_UINT32 numcomps,
2561 const OPJ_FLOAT64 * mct_norms,
2562 OPJ_UINT32 mct_numcomps)
2563 {
2564 OPJ_FLOAT64 cumwmsedec = 0.0;
2565
2566 opj_mqc_t *mqc = &(t1->mqc); /* MQC component */
2567
2568 OPJ_UINT32 passno;
2569 OPJ_INT32 bpno;
2570 OPJ_UINT32 passtype;
2571 OPJ_INT32 nmsedec = 0;
2572 OPJ_INT32 max;
2573 OPJ_UINT32 i, j;
2574 OPJ_BYTE type = T1_TYPE_MQ;
2575 OPJ_FLOAT64 tempwmsedec;
2576 OPJ_INT32* datap;
2577
2578 #ifdef EXTRA_DEBUG
2579 printf("encode_cblk(x=%d,y=%d,x1=%d,y1=%d,orient=%d,compno=%d,level=%d\n",
2580 cblk->x0, cblk->y0, cblk->x1, cblk->y1, orient, compno, level);
2581 #endif
2582
2583 mqc->lut_ctxno_zc_orient = lut_ctxno_zc + (orient << 9);
2584
2585 max = 0;
2586 datap = t1->data;
2587 for (j = 0; j < t1->h; ++j) {
2588 const OPJ_UINT32 w = t1->w;
2589 for (i = 0; i < w; ++i, ++datap) {
2590 OPJ_INT32 tmp = *datap;
2591 if (tmp < 0) {
2592 OPJ_UINT32 tmp_unsigned;
2593 if (tmp == INT_MIN) {
2594 /* To avoid undefined behaviour when negating INT_MIN */
2595 /* but if we go here, it means we have supplied an input */
2596 /* with more bit depth than we we can really support. */
2597 /* Cf https://github.com/uclouvain/openjpeg/issues/1432 */
2598 tmp = INT_MIN + 1;
2599 }
2600 max = opj_int_max(max, -tmp);
2601 tmp_unsigned = opj_to_smr(tmp);
2602 memcpy(datap, &tmp_unsigned, sizeof(OPJ_INT32));
2603 } else {
2604 max = opj_int_max(max, tmp);
2605 }
2606 }
2607 }
2608
2609 cblk->numbps = max ? (OPJ_UINT32)((opj_int_floorlog2(max) + 1) -
2610 T1_NMSEDEC_FRACBITS) : 0;
2611 if (cblk->numbps == 0) {
2612 cblk->totalpasses = 0;
2613 return cumwmsedec;
2614 }
2615
2616 bpno = (OPJ_INT32)(cblk->numbps - 1);
2617 passtype = 2;
2618
2619 opj_mqc_resetstates(mqc);
2620 opj_mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
2621 opj_mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
2622 opj_mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
2623 opj_mqc_init_enc(mqc, cblk->data);
2624
2625 for (passno = 0; bpno >= 0; ++passno) {
2626 opj_tcd_pass_t *pass = &cblk->passes[passno];
2627 type = ((bpno < ((OPJ_INT32)(cblk->numbps) - 4)) && (passtype < 2) &&
2628 (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
2629
2630 /* If the previous pass was terminating, we need to reset the encoder */
2631 if (passno > 0 && cblk->passes[passno - 1].term) {
2632 if (type == T1_TYPE_RAW) {
2633 opj_mqc_bypass_init_enc(mqc);
2634 } else {
2635 opj_mqc_restart_init_enc(mqc);
2636 }
2637 }
2638
2639 switch (passtype) {
2640 case 0:
2641 opj_t1_enc_sigpass(t1, bpno, &nmsedec, type, cblksty);
2642 break;
2643 case 1:
2644 opj_t1_enc_refpass(t1, bpno, &nmsedec, type);
2645 break;
2646 case 2:
2647 opj_t1_enc_clnpass(t1, bpno, &nmsedec, cblksty);
2648 /* code switch SEGMARK (i.e. SEGSYM) */
2649 if (cblksty & J2K_CCP_CBLKSTY_SEGSYM) {
2650 opj_mqc_segmark_enc(mqc);
2651 }
2652 break;
2653 }
2654
2655 tempwmsedec = opj_t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid,
2656 stepsize, numcomps, mct_norms, mct_numcomps) ;
2657 cumwmsedec += tempwmsedec;
2658 pass->distortiondec = cumwmsedec;
2659
2660 if (opj_t1_enc_is_term_pass(cblk, cblksty, bpno, passtype)) {
2661 /* If it is a terminated pass, terminate it */
2662 if (type == T1_TYPE_RAW) {
2663 opj_mqc_bypass_flush_enc(mqc, cblksty & J2K_CCP_CBLKSTY_PTERM);
2664 } else {
2665 if (cblksty & J2K_CCP_CBLKSTY_PTERM) {
2666 opj_mqc_erterm_enc(mqc);
2667 } else {
2668 opj_mqc_flush(mqc);
2669 }
2670 }
2671 pass->term = 1;
2672 pass->rate = opj_mqc_numbytes(mqc);
2673 } else {
2674 /* Non terminated pass */
2675 OPJ_UINT32 rate_extra_bytes;
2676 if (type == T1_TYPE_RAW) {
2677 rate_extra_bytes = opj_mqc_bypass_get_extra_bytes(
2678 mqc, (cblksty & J2K_CCP_CBLKSTY_PTERM));
2679 } else {
2680 rate_extra_bytes = 3;
2681 }
2682 pass->term = 0;
2683 pass->rate = opj_mqc_numbytes(mqc) + rate_extra_bytes;
2684 }
2685
2686 if (++passtype == 3) {
2687 passtype = 0;
2688 bpno--;
2689 }
2690
2691 /* Code-switch "RESET" */
2692 if (cblksty & J2K_CCP_CBLKSTY_RESET) {
2693 opj_mqc_reset_enc(mqc);
2694 }
2695 }
2696
2697 cblk->totalpasses = passno;
2698
2699 if (cblk->totalpasses) {
2700 /* Make sure that pass rates are increasing */
2701 OPJ_UINT32 last_pass_rate = opj_mqc_numbytes(mqc);
2702 for (passno = cblk->totalpasses; passno > 0;) {
2703 opj_tcd_pass_t *pass = &cblk->passes[--passno];
2704 if (pass->rate > last_pass_rate) {
2705 pass->rate = last_pass_rate;
2706 } else {
2707 last_pass_rate = pass->rate;
2708 }
2709 }
2710 }
2711
2712 for (passno = 0; passno < cblk->totalpasses; passno++) {
2713 opj_tcd_pass_t *pass = &cblk->passes[passno];
2714
2715 /* Prevent generation of FF as last data byte of a pass*/
2716 /* For terminating passes, the flushing procedure ensured this already */
2717 assert(pass->rate > 0);
2718 if (cblk->data[pass->rate - 1] == 0xFF) {
2719 pass->rate--;
2720 }
2721 pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
2722 }
2723
2724 #ifdef EXTRA_DEBUG
2725 printf(" len=%d\n", (cblk->totalpasses) ? opj_mqc_numbytes(mqc) : 0);
2726
2727 /* Check that there not 0xff >=0x90 sequences */
2728 if (cblk->totalpasses) {
2729 OPJ_UINT32 i;
2730 OPJ_UINT32 len = opj_mqc_numbytes(mqc);
2731 for (i = 1; i < len; ++i) {
2732 if (cblk->data[i - 1] == 0xff && cblk->data[i] >= 0x90) {
2733 printf("0xff %02x at offset %d\n", cblk->data[i], i - 1);
2734 abort();
2735 }
2736 }
2737 }
2738 #endif
2739
2740 return cumwmsedec;
2741 }