← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/3rdparty/libjasper/jpc_t1dec.c

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/3rdparty/libjasper/jpc_t1dec.c
 
1
/*
 
2
 * Copyright (c) 1999-2000 Image Power, Inc. and the University of
 
3
 *   British Columbia.
 
4
 * Copyright (c) 2001-2003 Michael David Adams.
 
5
 * All rights reserved.
 
6
 */
 
7
 
 
8
/* __START_OF_JASPER_LICENSE__
 
9
 *
 
10
 * JasPer License Version 2.0
 
11
 *
 
12
 * Copyright (c) 2001-2006 Michael David Adams
 
13
 * Copyright (c) 1999-2000 Image Power, Inc.
 
14
 * Copyright (c) 1999-2000 The University of British Columbia
 
15
 *
 
16
 * All rights reserved.
 
17
 *
 
18
 * Permission is hereby granted, free of charge, to any person (the
 
19
 * "User") obtaining a copy of this software and associated documentation
 
20
 * files (the "Software"), to deal in the Software without restriction,
 
21
 * including without limitation the rights to use, copy, modify, merge,
 
22
 * publish, distribute, and/or sell copies of the Software, and to permit
 
23
 * persons to whom the Software is furnished to do so, subject to the
 
24
 * following conditions:
 
25
 *
 
26
 * 1.  The above copyright notices and this permission notice (which
 
27
 * includes the disclaimer below) shall be included in all copies or
 
28
 * substantial portions of the Software.
 
29
 *
 
30
 * 2.  The name of a copyright holder shall not be used to endorse or
 
31
 * promote products derived from the Software without specific prior
 
32
 * written permission.
 
33
 *
 
34
 * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
 
35
 * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
 
36
 * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
 
37
 * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 
38
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 
39
 * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
 
40
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
 
41
 * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
 
42
 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 
43
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 
44
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
 
45
 * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
 
46
 * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
 
47
 * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
 
48
 * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
 
49
 * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
 
50
 * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
 
51
 * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
 
52
 * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
 
53
 * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
 
54
 * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
 
55
 * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
 
56
 * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
 
57
 * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
 
58
 * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
 
59
 * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
 
60
 *
 
61
 * __END_OF_JASPER_LICENSE__
 
62
 */
 
63
 
 
64
/*
 
65
 * Tier 1 Decoder
 
66
 *
 
67
 * $Id: jpc_t1dec.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
 
68
 */
 
69
 
 
70
/******************************************************************************\
 
71
* Includes.
 
72
\******************************************************************************/
 
73
 
 
74
#include <stdio.h>
 
75
#include <stdlib.h>
 
76
#include <assert.h>
 
77
 
 
78
#include "jasper/jas_fix.h"
 
79
#include "jasper/jas_stream.h"
 
80
#include "jasper/jas_math.h"
 
81
 
 
82
#include "jpc_bs.h"
 
83
#include "jpc_mqdec.h"
 
84
#include "jpc_t1dec.h"
 
85
#include "jpc_t1cod.h"
 
86
#include "jpc_dec.h"
 
87
 
 
88
/******************************************************************************\
 
89
*
 
90
\******************************************************************************/
 
91
 
 
92
static int jpc_dec_decodecblk(jpc_dec_t *dec, jpc_dec_tile_t *tile, jpc_dec_tcomp_t *tcomp, jpc_dec_band_t *band,
 
93
  jpc_dec_cblk_t *cblk, int dopartial, int maxlyrs);
 
94
static int dec_sigpass(jpc_dec_t *dec, jpc_mqdec_t *mqdec, int bitpos, int orient,
 
95
  int vcausalflag, jas_matrix_t *flags, jas_matrix_t *data);
 
96
static int dec_rawsigpass(jpc_dec_t *dec, jpc_bitstream_t *in, int bitpos,
 
97
  int vcausalflag, jas_matrix_t *flags, jas_matrix_t *data);
 
98
static int dec_refpass(jpc_dec_t *dec, jpc_mqdec_t *mqdec, int bitpos, int vcausalflag,
 
99
  jas_matrix_t *flags, jas_matrix_t *data);
 
100
static int dec_rawrefpass(jpc_dec_t *dec, jpc_bitstream_t *in, int bitpos,
 
101
  int vcausalflag, jas_matrix_t *flags, jas_matrix_t *data);
 
102
static int dec_clnpass(jpc_dec_t *dec, jpc_mqdec_t *mqdec, int bitpos, int orient,
 
103
  int vcausalflag, int segsymflag, jas_matrix_t *flags, jas_matrix_t *data);
 
104
 
 
105
#if defined(DEBUG)
 
106
static long t1dec_cnt = 0;
 
107
#endif
 
108
 
 
109
#if !defined(DEBUG)
 
110
#define JPC_T1D_GETBIT(mqdec, v, passtypename, symtypename) \
 
111
    ((v) = jpc_mqdec_getbit(mqdec))
 
112
#else
 
113
#define JPC_T1D_GETBIT(mqdec, v, passtypename, symtypename) \
 
114
{ \
 
115
    (v) = jpc_mqdec_getbit(mqdec); \
 
116
    if (jas_getdbglevel() >= 100) { \
 
117
        jas_eprintf("index = %ld; passtype = %s; symtype = %s; sym = %d\n", t1dec_cnt, passtypename, symtypename, v); \
 
118
        ++t1dec_cnt; \
 
119
    } \
 
120
}
 
121
#endif
 
122
#define JPC_T1D_GETBITNOSKEW(mqdec, v, passtypename, symtypename) \
 
123
    JPC_T1D_GETBIT(mqdec, v, passtypename, symtypename)
 
124
 
 
125
#if !defined(DEBUG)
 
126
#define JPC_T1D_RAWGETBIT(bitstream, v, passtypename, symtypename) \
 
127
    ((v) = jpc_bitstream_getbit(bitstream))
 
128
#else
 
129
#define JPC_T1D_RAWGETBIT(bitstream, v, passtypename, symtypename) \
 
130
{ \
 
131
    (v) = jpc_bitstream_getbit(bitstream); \
 
132
    if (jas_getdbglevel() >= 100) { \
 
133
        jas_eprintf("index = %ld; passtype = %s; symtype = %s; sym = %d\n", t1dec_cnt, passtypename, symtypename, v); \
 
134
        ++t1dec_cnt; \
 
135
    } \
 
136
}
 
137
#endif
 
138
 
 
139
/******************************************************************************\
 
140
* Code.
 
141
\******************************************************************************/
 
142
 
 
143
int jpc_dec_decodecblks(jpc_dec_t *dec, jpc_dec_tile_t *tile)
 
144
{
 
145
    jpc_dec_tcomp_t *tcomp;
 
146
    int compcnt;
 
147
    jpc_dec_rlvl_t *rlvl;
 
148
    int rlvlcnt;
 
149
    jpc_dec_band_t *band;
 
150
    int bandcnt;
 
151
    jpc_dec_prc_t *prc;
 
152
    int prccnt;
 
153
    jpc_dec_cblk_t *cblk;
 
154
    int cblkcnt;
 
155
 
 
156
    for (compcnt = dec->numcomps, tcomp = tile->tcomps; compcnt > 0;
 
157
      --compcnt, ++tcomp) {
 
158
        for (rlvlcnt = tcomp->numrlvls, rlvl = tcomp->rlvls;
 
159
          rlvlcnt > 0; --rlvlcnt, ++rlvl) {
 
160
            if (!rlvl->bands) {
 
161
                continue;
 
162
            }
 
163
            for (bandcnt = rlvl->numbands, band = rlvl->bands;
 
164
              bandcnt > 0; --bandcnt, ++band) {
 
165
                if (!band->data) {
 
166
                    continue;
 
167
                }
 
168
                for (prccnt = rlvl->numprcs, prc = band->prcs;
 
169
                  prccnt > 0; --prccnt, ++prc) {
 
170
                    if (!prc->cblks) {
 
171
                        continue;
 
172
                    }
 
173
                    for (cblkcnt = prc->numcblks,
 
174
                      cblk = prc->cblks; cblkcnt > 0;
 
175
                      --cblkcnt, ++cblk) {
 
176
                        if (jpc_dec_decodecblk(dec, tile, tcomp,
 
177
                          band, cblk, 1, JPC_MAXLYRS)) {
 
178
                            return -1;
 
179
                        }
 
180
                    }
 
181
                }
 
182
 
 
183
            }
 
184
        }
 
185
    }
 
186
 
 
187
    return 0;
 
188
}
 
189
 
 
190
static int jpc_dec_decodecblk(jpc_dec_t *dec, jpc_dec_tile_t *tile, jpc_dec_tcomp_t *tcomp, jpc_dec_band_t *band,
 
191
  jpc_dec_cblk_t *cblk, int dopartial, int maxlyrs)
 
192
{
 
193
    jpc_dec_seg_t *seg;
 
194
    int i;
 
195
    int bpno;
 
196
    int passtype;
 
197
    int ret;
 
198
    int compno;
 
199
    int filldata;
 
200
    int fillmask;
 
201
    jpc_dec_ccp_t *ccp;
 
202
 
 
203
    compno = tcomp - tile->tcomps;
 
204
 
 
205
    if (!cblk->flags) {
 
206
        /* Note: matrix is assumed to be zeroed */
 
207
        if (!(cblk->flags = jas_matrix_create(jas_matrix_numrows(cblk->data) +
 
208
          2, jas_matrix_numcols(cblk->data) + 2))) {
 
209
            return -1;
 
210
        }
 
211
    }
 
212
 
 
213
    seg = cblk->segs.head;
 
214
    while (seg && (seg != cblk->curseg || dopartial) && (maxlyrs < 0 ||
 
215
      seg->lyrno < maxlyrs)) {
 
216
        assert(seg->numpasses >= seg->maxpasses || dopartial);
 
217
        assert(seg->stream);
 
218
        jas_stream_rewind(seg->stream);
 
219
        jas_stream_setrwcount(seg->stream, 0);
 
220
        if (seg->type == JPC_SEG_MQ) {
 
221
            if (!cblk->mqdec) {
 
222
                if (!(cblk->mqdec = jpc_mqdec_create(JPC_NUMCTXS, 0))) {
 
223
                    return -1;
 
224
                }
 
225
                jpc_mqdec_setctxs(cblk->mqdec, JPC_NUMCTXS, jpc_mqctxs);
 
226
            }
 
227
            jpc_mqdec_setinput(cblk->mqdec, seg->stream);
 
228
            jpc_mqdec_init(cblk->mqdec);
 
229
        } else {
 
230
            assert(seg->type == JPC_SEG_RAW);
 
231
            if (!cblk->nulldec) {
 
232
                if (!(cblk->nulldec = jpc_bitstream_sopen(seg->stream, "r"))) {
 
233
                    assert(0);
 
234
                }
 
235
            }
 
236
        }
 
237
 
 
238
 
 
239
        for (i = 0; i < seg->numpasses; ++i) {
 
240
            if (cblk->numimsbs > band->numbps) {
 
241
                ccp = &tile->cp->ccps[compno];
 
242
                if (ccp->roishift <= 0) {
 
243
                    jas_eprintf("warning: corrupt code stream\n");
 
244
                } else {
 
245
                    if (cblk->numimsbs < ccp->roishift - band->numbps) {
 
246
                        jas_eprintf("warning: corrupt code stream\n");
 
247
                    }
 
248
                }
 
249
            }
 
250
            bpno = band->roishift + band->numbps - 1 - (cblk->numimsbs +
 
251
              (seg->passno + i - cblk->firstpassno + 2) / 3);
 
252
if (bpno < 0) {
 
253
    goto premature_exit;
 
254
}
 
255
#if 1
 
256
            passtype = (seg->passno + i + 2) % 3;
 
257
#else
 
258
            passtype = JPC_PASSTYPE(seg->passno + i + 2);
 
259
#endif
 
260
            assert(bpno >= 0 && bpno < 31);
 
261
            switch (passtype) {
 
262
            case JPC_SIGPASS:
 
263
                ret = (seg->type == JPC_SEG_MQ) ? dec_sigpass(dec,
 
264
                  cblk->mqdec, bpno, band->orient,
 
265
                  (tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
 
266
                  cblk->flags, cblk->data) :
 
267
                  dec_rawsigpass(dec, cblk->nulldec, bpno,
 
268
                  (tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
 
269
                  cblk->flags, cblk->data);
 
270
                break;
 
271
            case JPC_REFPASS:
 
272
                ret = (seg->type == JPC_SEG_MQ) ?
 
273
                  dec_refpass(dec, cblk->mqdec, bpno,
 
274
                  (tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
 
275
                  cblk->flags, cblk->data) :
 
276
                  dec_rawrefpass(dec, cblk->nulldec, bpno,
 
277
                  (tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
 
278
                  cblk->flags, cblk->data);
 
279
                break;
 
280
            case JPC_CLNPASS:
 
281
                assert(seg->type == JPC_SEG_MQ);
 
282
                ret = dec_clnpass(dec, cblk->mqdec, bpno,
 
283
                  band->orient, (tile->cp->ccps[compno].cblkctx &
 
284
                  JPC_COX_VSC) != 0, (tile->cp->ccps[compno].cblkctx &
 
285
                  JPC_COX_SEGSYM) != 0, cblk->flags,
 
286
                  cblk->data);
 
287
                break;
 
288
            default:
 
289
                ret = -1;
 
290
                break;
 
291
            }
 
292
            /* Do we need to reset after each coding pass? */
 
293
            if (tile->cp->ccps[compno].cblkctx & JPC_COX_RESET) {
 
294
                jpc_mqdec_setctxs(cblk->mqdec, JPC_NUMCTXS, jpc_mqctxs);
 
295
            }
 
296
 
 
297
            if (ret) {
 
298
                jas_eprintf("coding pass failed passtype=%d segtype=%d\n", passtype, seg->type);
 
299
                return -1;
 
300
            }
 
301
 
 
302
        }
 
303
 
 
304
        if (seg->type == JPC_SEG_MQ) {
 
305
/* Note: dont destroy mq decoder because context info will be lost */
 
306
        } else {
 
307
            assert(seg->type == JPC_SEG_RAW);
 
308
            if (tile->cp->ccps[compno].cblkctx & JPC_COX_PTERM) {
 
309
                fillmask = 0x7f;
 
310
                filldata = 0x2a;
 
311
            } else {
 
312
                fillmask = 0;
 
313
                filldata = 0;
 
314
            }
 
315
            if ((ret = jpc_bitstream_inalign(cblk->nulldec, fillmask,
 
316
              filldata)) < 0) {
 
317
                return -1;
 
318
            } else if (ret > 0) {
 
319
                jas_eprintf("warning: bad termination pattern detected\n");
 
320
            }
 
321
            jpc_bitstream_close(cblk->nulldec);
 
322
            cblk->nulldec = 0;
 
323
        }
 
324
 
 
325
        cblk->curseg = seg->next;
 
326
        jpc_seglist_remove(&cblk->segs, seg);
 
327
        jpc_seg_destroy(seg);
 
328
        seg = cblk->curseg;
 
329
    }
 
330
 
 
331
    assert(dopartial ? (!cblk->curseg) : 1);
 
332
 
 
333
premature_exit:
 
334
    return 0;
 
335
}
 
336
 
 
337
/******************************************************************************\
 
338
* Code for significance pass.
 
339
\******************************************************************************/
 
340
 
 
341
#define jpc_sigpass_step(fp, frowstep, dp, bitpos, oneplushalf, orient, mqdec, vcausalflag) \
 
342
{ \
 
343
    int f; \
 
344
    int v; \
 
345
    f = *(fp); \
 
346
    if ((f & JPC_OTHSIGMSK) && !(f & (JPC_SIG | JPC_VISIT))) { \
 
347
        jpc_mqdec_setcurctx((mqdec), JPC_GETZCCTXNO(f, (orient))); \
 
348
        JPC_T1D_GETBIT((mqdec), v, "SIG", "ZC"); \
 
349
        if (v) { \
 
350
            jpc_mqdec_setcurctx((mqdec), JPC_GETSCCTXNO(f)); \
 
351
            JPC_T1D_GETBIT((mqdec), v, "SIG", "SC"); \
 
352
            v ^= JPC_GETSPB(f); \
 
353
            JPC_UPDATEFLAGS4((fp), (frowstep), v, (vcausalflag)); \
 
354
            *(fp) |= JPC_SIG; \
 
355
            *(dp) = (v) ? (-(oneplushalf)) : (oneplushalf); \
 
356
        } \
 
357
        *(fp) |= JPC_VISIT; \
 
358
    } \
 
359
}
 
360
 
 
361
static int dec_sigpass(jpc_dec_t *dec, register jpc_mqdec_t *mqdec, int bitpos, int orient,
 
362
  int vcausalflag, jas_matrix_t *flags, jas_matrix_t *data)
 
363
{
 
364
    int i;
 
365
    int j;
 
366
    int one;
 
367
    int half;
 
368
    int oneplushalf;
 
369
    int vscanlen;
 
370
    int width;
 
371
    int height;
 
372
    jpc_fix_t *fp;
 
373
    int frowstep;
 
374
    int fstripestep;
 
375
    jpc_fix_t *fstripestart;
 
376
    jpc_fix_t *fvscanstart;
 
377
    jpc_fix_t *dp;
 
378
    int drowstep;
 
379
    int dstripestep;
 
380
    jpc_fix_t *dstripestart;
 
381
    jpc_fix_t *dvscanstart;
 
382
    int k;
 
383
 
 
384
    /* Avoid compiler warning about unused parameters. */
 
385
    dec = 0;
 
386
 
 
387
    width = jas_matrix_numcols(data);
 
388
    height = jas_matrix_numrows(data);
 
389
    frowstep = jas_matrix_rowstep(flags);
 
390
    drowstep = jas_matrix_rowstep(data);
 
391
    fstripestep = frowstep << 2;
 
392
    dstripestep = drowstep << 2;
 
393
 
 
394
    one = 1 << bitpos;
 
395
    half = one >> 1;
 
396
    oneplushalf = one | half;
 
397
 
 
398
    fstripestart = jas_matrix_getref(flags, 1, 1);
 
399
    dstripestart = jas_matrix_getref(data, 0, 0);
 
400
    for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
 
401
      dstripestart += dstripestep) {
 
402
        fvscanstart = fstripestart;
 
403
        dvscanstart = dstripestart;
 
404
        vscanlen = JAS_MIN(i, 4);
 
405
        for (j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {
 
406
            fp = fvscanstart;
 
407
            dp = dvscanstart;
 
408
            k = vscanlen;
 
409
 
 
410
            /* Process first sample in vertical scan. */
 
411
            jpc_sigpass_step(fp, frowstep, dp, bitpos, oneplushalf,
 
412
              orient, mqdec, vcausalflag);
 
413
            if (--k <= 0) {
 
414
                continue;
 
415
            }
 
416
            fp += frowstep;
 
417
            dp += drowstep;
 
418
 
 
419
            /* Process second sample in vertical scan. */
 
420
            jpc_sigpass_step(fp, frowstep, dp, bitpos, oneplushalf,
 
421
              orient, mqdec, 0);
 
422
            if (--k <= 0) {
 
423
                continue;
 
424
            }
 
425
            fp += frowstep;
 
426
            dp += drowstep;
 
427
 
 
428
            /* Process third sample in vertical scan. */
 
429
            jpc_sigpass_step(fp, frowstep, dp, bitpos, oneplushalf,
 
430
              orient, mqdec, 0);
 
431
            if (--k <= 0) {
 
432
                continue;
 
433
            }
 
434
            fp += frowstep;
 
435
            dp += drowstep;
 
436
 
 
437
            /* Process fourth sample in vertical scan. */
 
438
            jpc_sigpass_step(fp, frowstep, dp, bitpos, oneplushalf,
 
439
              orient, mqdec, 0);
 
440
        }
 
441
    }
 
442
    return 0;
 
443
}
 
444
 
 
445
#define jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf, in, vcausalflag) \
 
446
{ \
 
447
    jpc_fix_t f = *(fp); \
 
448
    jpc_fix_t v; \
 
449
    if ((f & JPC_OTHSIGMSK) && !(f & (JPC_SIG | JPC_VISIT))) { \
 
450
        JPC_T1D_RAWGETBIT(in, v, "SIG", "ZC"); \
 
451
        if (v < 0) { \
 
452
            return -1; \
 
453
        } \
 
454
        if (v) { \
 
455
            JPC_T1D_RAWGETBIT(in, v, "SIG", "SC"); \
 
456
            if (v < 0) { \
 
457
                return -1; \
 
458
            } \
 
459
            JPC_UPDATEFLAGS4((fp), (frowstep), v, (vcausalflag)); \
 
460
            *(fp) |= JPC_SIG; \
 
461
            *(dp) = v ? (-oneplushalf) : (oneplushalf); \
 
462
        } \
 
463
        *(fp) |= JPC_VISIT; \
 
464
    } \
 
465
}
 
466
 
 
467
static int dec_rawsigpass(jpc_dec_t *dec, jpc_bitstream_t *in, int bitpos, int vcausalflag,
 
468
  jas_matrix_t *flags, jas_matrix_t *data)
 
469
{
 
470
    int i;
 
471
    int j;
 
472
    int k;
 
473
    int one;
 
474
    int half;
 
475
    int oneplushalf;
 
476
    int vscanlen;
 
477
    int width;
 
478
    int height;
 
479
    jpc_fix_t *fp;
 
480
    int frowstep;
 
481
    int fstripestep;
 
482
    jpc_fix_t *fstripestart;
 
483
    jpc_fix_t *fvscanstart;
 
484
    jpc_fix_t *dp;
 
485
    int drowstep;
 
486
    int dstripestep;
 
487
    jpc_fix_t *dstripestart;
 
488
    jpc_fix_t *dvscanstart;
 
489
 
 
490
    /* Avoid compiler warning about unused parameters. */
 
491
    dec = 0;
 
492
 
 
493
    width = jas_matrix_numcols(data);
 
494
    height = jas_matrix_numrows(data);
 
495
    frowstep = jas_matrix_rowstep(flags);
 
496
    drowstep = jas_matrix_rowstep(data);
 
497
    fstripestep = frowstep << 2;
 
498
    dstripestep = drowstep << 2;
 
499
 
 
500
    one = 1 << bitpos;
 
501
    half = one >> 1;
 
502
    oneplushalf = one | half;
 
503
 
 
504
    fstripestart = jas_matrix_getref(flags, 1, 1);
 
505
    dstripestart = jas_matrix_getref(data, 0, 0);
 
506
    for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
 
507
      dstripestart += dstripestep) {
 
508
        fvscanstart = fstripestart;
 
509
        dvscanstart = dstripestart;
 
510
        vscanlen = JAS_MIN(i, 4);
 
511
        for (j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {
 
512
            fp = fvscanstart;
 
513
            dp = dvscanstart;
 
514
            k = vscanlen;
 
515
 
 
516
            /* Process first sample in vertical scan. */
 
517
            jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf,
 
518
              in, vcausalflag);
 
519
            if (--k <= 0) {
 
520
                continue;
 
521
            }
 
522
            fp += frowstep;
 
523
            dp += drowstep;
 
524
 
 
525
            /* Process second sample in vertical scan. */
 
526
            jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf,
 
527
              in, 0);
 
528
            if (--k <= 0) {
 
529
                continue;
 
530
            }
 
531
            fp += frowstep;
 
532
            dp += drowstep;
 
533
 
 
534
            /* Process third sample in vertical scan. */
 
535
            jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf,
 
536
              in, 0);
 
537
            if (--k <= 0) {
 
538
                continue;
 
539
            }
 
540
            fp += frowstep;
 
541
            dp += drowstep;
 
542
 
 
543
            /* Process fourth sample in vertical scan. */
 
544
            jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf,
 
545
              in, 0);
 
546
 
 
547
        }
 
548
    }
 
549
    return 0;
 
550
}
 
551
 
 
552
/******************************************************************************\
 
553
* Code for refinement pass.
 
554
\******************************************************************************/
 
555
 
 
556
#define jpc_refpass_step(fp, dp, poshalf, neghalf, mqdec, vcausalflag) \
 
557
{ \
 
558
    int v; \
 
559
    int t; \
 
560
    if (((*(fp)) & (JPC_SIG | JPC_VISIT)) == JPC_SIG) { \
 
561
        jpc_mqdec_setcurctx((mqdec), JPC_GETMAGCTXNO(*(fp))); \
 
562
        JPC_T1D_GETBITNOSKEW((mqdec), v, "REF", "MR"); \
 
563
        t = (v ? (poshalf) : (neghalf)); \
 
564
        *(dp) += (*(dp) < 0) ? (-t) : t; \
 
565
        *(fp) |= JPC_REFINE; \
 
566
    } \
 
567
}
 
568
 
 
569
static int dec_refpass(jpc_dec_t *dec, register jpc_mqdec_t *mqdec, int bitpos,
 
570
  int vcausalflag, jas_matrix_t *flags, jas_matrix_t *data)
 
571
{
 
572
    int i;
 
573
    int j;
 
574
    int vscanlen;
 
575
    int width;
 
576
    int height;
 
577
    int one;
 
578
    int poshalf;
 
579
    int neghalf;
 
580
    jpc_fix_t *fp;
 
581
    int frowstep;
 
582
    int fstripestep;
 
583
    jpc_fix_t *fstripestart;
 
584
    jpc_fix_t *fvscanstart;
 
585
    jpc_fix_t *dp;
 
586
    int drowstep;
 
587
    int dstripestep;
 
588
    jpc_fix_t *dstripestart;
 
589
    jpc_fix_t *dvscanstart;
 
590
    int k;
 
591
 
 
592
    /* Avoid compiler warning about unused parameters. */
 
593
    dec = 0;
 
594
    vcausalflag = 0;
 
595
 
 
596
    width = jas_matrix_numcols(data);
 
597
    height = jas_matrix_numrows(data);
 
598
    frowstep = jas_matrix_rowstep(flags);
 
599
    drowstep = jas_matrix_rowstep(data);
 
600
    fstripestep = frowstep << 2;
 
601
    dstripestep = drowstep << 2;
 
602
 
 
603
    one = 1 << bitpos;
 
604
    poshalf = one >> 1;
 
605
    neghalf = (bitpos > 0) ? (-poshalf) : (-1);
 
606
 
 
607
    fstripestart = jas_matrix_getref(flags, 1, 1);
 
608
    dstripestart = jas_matrix_getref(data, 0, 0);
 
609
    for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
 
610
      dstripestart += dstripestep) {
 
611
        fvscanstart = fstripestart;
 
612
        dvscanstart = dstripestart;
 
613
        vscanlen = JAS_MIN(i, 4);
 
614
        for (j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {
 
615
            fp = fvscanstart;
 
616
            dp = dvscanstart;
 
617
            k = vscanlen;
 
618
 
 
619
            /* Process first sample in vertical scan. */
 
620
            jpc_refpass_step(fp, dp, poshalf, neghalf, mqdec,
 
621
              vcausalflag);
 
622
            if (--k <= 0) {
 
623
                continue;
 
624
            }
 
625
            fp += frowstep;
 
626
            dp += drowstep;
 
627
 
 
628
            /* Process second sample in vertical scan. */
 
629
            jpc_refpass_step(fp, dp, poshalf, neghalf, mqdec, 0);
 
630
            if (--k <= 0) {
 
631
                continue;
 
632
            }
 
633
            fp += frowstep;
 
634
            dp += drowstep;
 
635
 
 
636
            /* Process third sample in vertical scan. */
 
637
            jpc_refpass_step(fp, dp, poshalf, neghalf, mqdec, 0);
 
638
            if (--k <= 0) {
 
639
                continue;
 
640
            }
 
641
            fp += frowstep;
 
642
            dp += drowstep;
 
643
 
 
644
            /* Process fourth sample in vertical scan. */
 
645
            jpc_refpass_step(fp, dp, poshalf, neghalf, mqdec, 0);
 
646
        }
 
647
    }
 
648
 
 
649
    return 0;
 
650
}
 
651
 
 
652
#define jpc_rawrefpass_step(fp, dp, poshalf, neghalf, in, vcausalflag) \
 
653
{ \
 
654
    jpc_fix_t v; \
 
655
    jpc_fix_t t; \
 
656
    if (((*(fp)) & (JPC_SIG | JPC_VISIT)) == JPC_SIG) { \
 
657
        JPC_T1D_RAWGETBIT(in, v, "REF", "MAGREF"); \
 
658
        if (v < 0) { \
 
659
            return -1; \
 
660
        } \
 
661
        t = (v ? poshalf : neghalf); \
 
662
        *(dp) += (*(dp) < 0) ? (-t) : t; \
 
663
        *(fp) |= JPC_REFINE; \
 
664
    } \
 
665
}
 
666
 
 
667
static int dec_rawrefpass(jpc_dec_t *dec, jpc_bitstream_t *in, int bitpos, int vcausalflag,
 
668
  jas_matrix_t *flags, jas_matrix_t *data)
 
669
{
 
670
    int i;
 
671
    int j;
 
672
    int k;
 
673
    int vscanlen;
 
674
    int width;
 
675
    int height;
 
676
    int one;
 
677
    int poshalf;
 
678
    int neghalf;
 
679
    jpc_fix_t *fp;
 
680
    int frowstep;
 
681
    int fstripestep;
 
682
    jpc_fix_t *fstripestart;
 
683
    jpc_fix_t *fvscanstart;
 
684
    jpc_fix_t *dp;
 
685
    int drowstep;
 
686
    int dstripestep;
 
687
    jpc_fix_t *dstripestart;
 
688
    jpc_fix_t *dvscanstart;
 
689
 
 
690
    /* Avoid compiler warning about unused parameters. */
 
691
    dec = 0;
 
692
    vcausalflag = 0;
 
693
 
 
694
    width = jas_matrix_numcols(data);
 
695
    height = jas_matrix_numrows(data);
 
696
    frowstep = jas_matrix_rowstep(flags);
 
697
    drowstep = jas_matrix_rowstep(data);
 
698
    fstripestep = frowstep << 2;
 
699
    dstripestep = drowstep << 2;
 
700
 
 
701
    one = 1 << bitpos;
 
702
    poshalf = one >> 1;
 
703
    neghalf = (bitpos > 0) ? (-poshalf) : (-1);
 
704
 
 
705
    fstripestart = jas_matrix_getref(flags, 1, 1);
 
706
    dstripestart = jas_matrix_getref(data, 0, 0);
 
707
    for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
 
708
      dstripestart += dstripestep) {
 
709
        fvscanstart = fstripestart;
 
710
        dvscanstart = dstripestart;
 
711
        vscanlen = JAS_MIN(i, 4);
 
712
        for (j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {
 
713
            fp = fvscanstart;
 
714
            dp = dvscanstart;
 
715
            k = vscanlen;
 
716
 
 
717
            /* Process first sample in vertical scan. */
 
718
            jpc_rawrefpass_step(fp, dp, poshalf, neghalf, in,
 
719
              vcausalflag);
 
720
            if (--k <= 0) {
 
721
                continue;
 
722
            }
 
723
            fp += frowstep;
 
724
            dp += drowstep;
 
725
 
 
726
            /* Process second sample in vertical scan. */
 
727
            jpc_rawrefpass_step(fp, dp, poshalf, neghalf, in, 0);
 
728
            if (--k <= 0) {
 
729
                continue;
 
730
            }
 
731
            fp += frowstep;
 
732
            dp += drowstep;
 
733
 
 
734
            /* Process third sample in vertical scan. */
 
735
            jpc_rawrefpass_step(fp, dp, poshalf, neghalf, in, 0);
 
736
            if (--k <= 0) {
 
737
                continue;
 
738
            }
 
739
            fp += frowstep;
 
740
            dp += drowstep;
 
741
 
 
742
            /* Process fourth sample in vertical scan. */
 
743
            jpc_rawrefpass_step(fp, dp, poshalf, neghalf, in, 0);
 
744
        }
 
745
    }
 
746
    return 0;
 
747
}
 
748
 
 
749
/******************************************************************************\
 
750
* Code for cleanup pass.
 
751
\******************************************************************************/
 
752
 
 
753
#define jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient, mqdec, flabel, plabel, vcausalflag) \
 
754
{ \
 
755
    int v; \
 
756
flabel \
 
757
    if (!((f) & (JPC_SIG | JPC_VISIT))) { \
 
758
        jpc_mqdec_setcurctx((mqdec), JPC_GETZCCTXNO((f), (orient))); \
 
759
        JPC_T1D_GETBIT((mqdec), v, "CLN", "ZC"); \
 
760
        if (v) { \
 
761
plabel \
 
762
            /* Coefficient is significant. */ \
 
763
            jpc_mqdec_setcurctx((mqdec), JPC_GETSCCTXNO(f)); \
 
764
            JPC_T1D_GETBIT((mqdec), v, "CLN", "SC"); \
 
765
            v ^= JPC_GETSPB(f); \
 
766
            *(dp) = (v) ? (-(oneplushalf)) : (oneplushalf); \
 
767
            JPC_UPDATEFLAGS4((fp), (frowstep), v, (vcausalflag)); \
 
768
            *(fp) |= JPC_SIG; \
 
769
        } \
 
770
    } \
 
771
    /* XXX - Is this correct?  Can aggregation cause some VISIT bits not to be reset?  Check. */ \
 
772
    *(fp) &= ~JPC_VISIT; \
 
773
}
 
774
 
 
775
static int dec_clnpass(jpc_dec_t *dec, register jpc_mqdec_t *mqdec, int bitpos, int orient,
 
776
  int vcausalflag, int segsymflag, jas_matrix_t *flags, jas_matrix_t *data)
 
777
{
 
778
    int i;
 
779
    int j;
 
780
    int k;
 
781
    int vscanlen;
 
782
    int v;
 
783
    int half;
 
784
    int runlen;
 
785
    int f;
 
786
    int width;
 
787
    int height;
 
788
    int one;
 
789
    int oneplushalf;
 
790
 
 
791
    jpc_fix_t *fp;
 
792
    int frowstep;
 
793
    int fstripestep;
 
794
    jpc_fix_t *fstripestart;
 
795
    jpc_fix_t *fvscanstart;
 
796
 
 
797
    jpc_fix_t *dp;
 
798
    int drowstep;
 
799
    int dstripestep;
 
800
    jpc_fix_t *dstripestart;
 
801
    jpc_fix_t *dvscanstart;
 
802
 
 
803
    /* Avoid compiler warning about unused parameters. */
 
804
    dec = 0;
 
805
 
 
806
    one = 1 << bitpos;
 
807
    half = one >> 1;
 
808
    oneplushalf = one | half;
 
809
 
 
810
    width = jas_matrix_numcols(data);
 
811
    height = jas_matrix_numrows(data);
 
812
 
 
813
    frowstep = jas_matrix_rowstep(flags);
 
814
    drowstep = jas_matrix_rowstep(data);
 
815
    fstripestep = frowstep << 2;
 
816
    dstripestep = drowstep << 2;
 
817
 
 
818
    fstripestart = jas_matrix_getref(flags, 1, 1);
 
819
    dstripestart = jas_matrix_getref(data, 0, 0);
 
820
    for (i = 0; i < height; i += 4, fstripestart += fstripestep,
 
821
      dstripestart += dstripestep) {
 
822
        fvscanstart = fstripestart;
 
823
        dvscanstart = dstripestart;
 
824
        vscanlen = JAS_MIN(4, height - i);
 
825
        for (j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {
 
826
            fp = fvscanstart;
 
827
            if (vscanlen >= 4 && (!((*fp) & (JPC_SIG | JPC_VISIT |
 
828
              JPC_OTHSIGMSK))) && (fp += frowstep, !((*fp) & (JPC_SIG |
 
829
              JPC_VISIT | JPC_OTHSIGMSK))) && (fp += frowstep, !((*fp) &
 
830
              (JPC_SIG | JPC_VISIT | JPC_OTHSIGMSK))) && (fp += frowstep,
 
831
              !((*fp) & (JPC_SIG | JPC_VISIT | JPC_OTHSIGMSK)))) {
 
832
 
 
833
                jpc_mqdec_setcurctx(mqdec, JPC_AGGCTXNO);
 
834
                JPC_T1D_GETBIT(mqdec, v, "CLN", "AGG");
 
835
                if (!v) {
 
836
                    continue;
 
837
                }
 
838
                jpc_mqdec_setcurctx(mqdec, JPC_UCTXNO);
 
839
                JPC_T1D_GETBITNOSKEW(mqdec, v, "CLN", "RL");
 
840
                runlen = v;
 
841
                JPC_T1D_GETBITNOSKEW(mqdec, v, "CLN", "RL");
 
842
                runlen = (runlen << 1) | v;
 
843
                f = *(fp = fvscanstart + frowstep * runlen);
 
844
                dp = dvscanstart + drowstep * runlen;
 
845
                k = vscanlen - runlen;
 
846
                switch (runlen) {
 
847
                case 0:
 
848
                    goto clnpass_partial0;
 
849
                    break;
 
850
                case 1:
 
851
                    goto clnpass_partial1;
 
852
                    break;
 
853
                case 2:
 
854
                    goto clnpass_partial2;
 
855
                    break;
 
856
                case 3:
 
857
                    goto clnpass_partial3;
 
858
                    break;
 
859
                }
 
860
            } else {
 
861
                f = *(fp = fvscanstart);
 
862
                dp = dvscanstart;
 
863
                k = vscanlen;
 
864
                goto clnpass_full0;
 
865
            }
 
866
 
 
867
            /* Process first sample in vertical scan. */
 
868
            jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
 
869
              mqdec, clnpass_full0:, clnpass_partial0:,
 
870
              vcausalflag);
 
871
            if (--k <= 0) {
 
872
                continue;
 
873
            }
 
874
            fp += frowstep;
 
875
            dp += drowstep;
 
876
 
 
877
            /* Process second sample in vertical scan. */
 
878
            f = *fp;
 
879
            jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
 
880
                mqdec, ;, clnpass_partial1:, 0);
 
881
            if (--k <= 0) {
 
882
                continue;
 
883
            }
 
884
            fp += frowstep;
 
885
            dp += drowstep;
 
886
 
 
887
            /* Process third sample in vertical scan. */
 
888
            f = *fp;
 
889
            jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
 
890
                mqdec, ;, clnpass_partial2:, 0);
 
891
            if (--k <= 0) {
 
892
                continue;
 
893
            }
 
894
            fp += frowstep;
 
895
            dp += drowstep;
 
896
 
 
897
            /* Process fourth sample in vertical scan. */
 
898
            f = *fp;
 
899
            jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
 
900
                mqdec, ;, clnpass_partial3:, 0);
 
901
        }
 
902
    }
 
903
 
 
904
    if (segsymflag) {
 
905
        int segsymval;
 
906
        segsymval = 0;
 
907
        jpc_mqdec_setcurctx(mqdec, JPC_UCTXNO);
 
908
        JPC_T1D_GETBITNOSKEW(mqdec, v, "CLN", "SEGSYM");
 
909
        segsymval = (segsymval << 1) | (v & 1);
 
910
        JPC_T1D_GETBITNOSKEW(mqdec, v, "CLN", "SEGSYM");
 
911
        segsymval = (segsymval << 1) | (v & 1);
 
912
        JPC_T1D_GETBITNOSKEW(mqdec, v, "CLN", "SEGSYM");
 
913
        segsymval = (segsymval << 1) | (v & 1);
 
914
        JPC_T1D_GETBITNOSKEW(mqdec, v, "CLN", "SEGSYM");
 
915
        segsymval = (segsymval << 1) | (v & 1);
 
916
        if (segsymval != 0xa) {
 
917
            jas_eprintf("warning: bad segmentation symbol\n");
 
918
        }
 
919
    }
 
920
 
 
921
    return 0;
 
922
}