2 * Copyright (c) 1999-2000 Image Power, Inc. and the University of
4 * Copyright (c) 2001-2003 Michael David Adams.
8 /* __START_OF_JASPER_LICENSE__
10 * JasPer License Version 2.0
12 * Copyright (c) 1999-2000 Image Power, Inc.
13 * Copyright (c) 1999-2000 The University of British Columbia
14 * Copyright (c) 2001-2003 Michael David Adams
16 * All rights reserved.
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:
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.
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
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.
61 * __END_OF_JASPER_LICENSE__
65 * $Id: jpc_dec.c,v 1.1 2005/05/22 18:33:04 malaterre Exp $
68 /******************************************************************************\
70 \******************************************************************************/
76 #include "jasper/jas_types.h"
77 #include "jasper/jas_math.h"
78 #include "jasper/jas_tvp.h"
79 #include "jasper/jas_malloc.h"
80 #include "jasper/jas_debug.h"
86 #include "jpc_t2dec.h"
87 #include "jpc_t1dec.h"
90 /******************************************************************************\
92 \******************************************************************************/
94 #define JPC_MHSOC 0x0001
95 /* In the main header, expecting a SOC marker segment. */
96 #define JPC_MHSIZ 0x0002
97 /* In the main header, expecting a SIZ marker segment. */
99 /* In the main header, expecting "other" marker segments. */
100 #define JPC_TPHSOT 0x0008
101 /* In a tile-part header, expecting a SOT marker segment. */
102 #define JPC_TPH 0x0010
103 /* In a tile-part header, expecting "other" marker segments. */
104 #define JPC_MT 0x0020
105 /* In the main trailer. */
110 /* The marker segment type. */
113 /* The states in which this type of marker segment can be
114 validly encountered. */
116 int (*action)(jpc_dec_t *dec, jpc_ms_t *ms);
117 /* The action to take upon encountering this type of marker segment. */
119 } jpc_dec_mstabent_t;
121 /******************************************************************************\
123 \******************************************************************************/
125 /* COD/COC parameters have been specified. */
126 #define JPC_CSET 0x0001
127 /* QCD/QCC parameters have been specified. */
128 #define JPC_QSET 0x0002
129 /* COD/COC parameters set from a COC marker segment. */
130 #define JPC_COC 0x0004
131 /* QCD/QCC parameters set from a QCC marker segment. */
132 #define JPC_QCC 0x0008
134 /******************************************************************************\
135 * Local function prototypes.
136 \******************************************************************************/
138 static int jpc_dec_dump(jpc_dec_t *dec, FILE *out);
140 jpc_ppxstab_t *jpc_ppxstab_create(void);
141 void jpc_ppxstab_destroy(jpc_ppxstab_t *tab);
142 int jpc_ppxstab_grow(jpc_ppxstab_t *tab, int maxents);
143 int jpc_ppxstab_insert(jpc_ppxstab_t *tab, jpc_ppxstabent_t *ent);
144 jpc_streamlist_t *jpc_ppmstabtostreams(jpc_ppxstab_t *tab);
145 int jpc_pptstabwrite(jas_stream_t *out, jpc_ppxstab_t *tab);
146 jpc_ppxstabent_t *jpc_ppxstabent_create(void);
147 void jpc_ppxstabent_destroy(jpc_ppxstabent_t *ent);
149 int jpc_streamlist_numstreams(jpc_streamlist_t *streamlist);
150 jpc_streamlist_t *jpc_streamlist_create(void);
151 int jpc_streamlist_insert(jpc_streamlist_t *streamlist, int streamno,
152 jas_stream_t *stream);
153 jas_stream_t *jpc_streamlist_remove(jpc_streamlist_t *streamlist, int streamno);
154 void jpc_streamlist_destroy(jpc_streamlist_t *streamlist);
155 jas_stream_t *jpc_streamlist_get(jpc_streamlist_t *streamlist, int streamno);
157 static void jpc_dec_cp_resetflags(jpc_dec_cp_t *cp);
158 static jpc_dec_cp_t *jpc_dec_cp_create(uint_fast16_t numcomps);
159 static int jpc_dec_cp_isvalid(jpc_dec_cp_t *cp);
160 static jpc_dec_cp_t *jpc_dec_cp_copy(jpc_dec_cp_t *cp);
161 static int jpc_dec_cp_setfromcod(jpc_dec_cp_t *cp, jpc_cod_t *cod);
162 static int jpc_dec_cp_setfromcoc(jpc_dec_cp_t *cp, jpc_coc_t *coc);
163 static int jpc_dec_cp_setfromcox(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
164 jpc_coxcp_t *compparms, int flags);
165 static int jpc_dec_cp_setfromqcd(jpc_dec_cp_t *cp, jpc_qcd_t *qcd);
166 static int jpc_dec_cp_setfromqcc(jpc_dec_cp_t *cp, jpc_qcc_t *qcc);
167 static int jpc_dec_cp_setfromqcx(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
168 jpc_qcxcp_t *compparms, int flags);
169 static int jpc_dec_cp_setfromrgn(jpc_dec_cp_t *cp, jpc_rgn_t *rgn);
170 static int jpc_dec_cp_prepare(jpc_dec_cp_t *cp);
171 static void jpc_dec_cp_destroy(jpc_dec_cp_t *cp);
172 static int jpc_dec_cp_setfrompoc(jpc_dec_cp_t *cp, jpc_poc_t *poc, int reset);
173 static int jpc_pi_addpchgfrompoc(jpc_pi_t *pi, jpc_poc_t *poc);
175 static int jpc_dec_decode(jpc_dec_t *dec);
176 static jpc_dec_t *jpc_dec_create(jpc_dec_importopts_t *impopts, jas_stream_t *in);
177 static void jpc_dec_destroy(jpc_dec_t *dec);
178 static void jpc_dequantize(jas_matrix_t *x, jpc_fix_t absstepsize);
179 static void jpc_undo_roi(jas_matrix_t *x, int roishift, int bgshift, int numbps);
180 static jpc_fix_t jpc_calcabsstepsize(int stepsize, int numbits);
181 static int jpc_dec_tiledecode(jpc_dec_t *dec, jpc_dec_tile_t *tile);
182 static int jpc_dec_tileinit(jpc_dec_t *dec, jpc_dec_tile_t *tile);
183 static int jpc_dec_tilefini(jpc_dec_t *dec, jpc_dec_tile_t *tile);
184 static int jpc_dec_process_soc(jpc_dec_t *dec, jpc_ms_t *ms);
185 static int jpc_dec_process_sot(jpc_dec_t *dec, jpc_ms_t *ms);
186 static int jpc_dec_process_sod(jpc_dec_t *dec, jpc_ms_t *ms);
187 static int jpc_dec_process_eoc(jpc_dec_t *dec, jpc_ms_t *ms);
188 static int jpc_dec_process_siz(jpc_dec_t *dec, jpc_ms_t *ms);
189 static int jpc_dec_process_cod(jpc_dec_t *dec, jpc_ms_t *ms);
190 static int jpc_dec_process_coc(jpc_dec_t *dec, jpc_ms_t *ms);
191 static int jpc_dec_process_rgn(jpc_dec_t *dec, jpc_ms_t *ms);
192 static int jpc_dec_process_qcd(jpc_dec_t *dec, jpc_ms_t *ms);
193 static int jpc_dec_process_qcc(jpc_dec_t *dec, jpc_ms_t *ms);
194 static int jpc_dec_process_poc(jpc_dec_t *dec, jpc_ms_t *ms);
195 static int jpc_dec_process_ppm(jpc_dec_t *dec, jpc_ms_t *ms);
196 static int jpc_dec_process_ppt(jpc_dec_t *dec, jpc_ms_t *ms);
197 static int jpc_dec_process_com(jpc_dec_t *dec, jpc_ms_t *ms);
198 static int jpc_dec_process_unk(jpc_dec_t *dec, jpc_ms_t *ms);
199 static int jpc_dec_process_crg(jpc_dec_t *dec, jpc_ms_t *ms);
200 static int jpc_dec_parseopts(char *optstr, jpc_dec_importopts_t *opts);
202 static jpc_dec_mstabent_t *jpc_dec_mstab_lookup(uint_fast16_t id);
204 /******************************************************************************\
206 \******************************************************************************/
208 jpc_dec_mstabent_t jpc_dec_mstab[] = {
209 {JPC_MS_SOC, JPC_MHSOC, jpc_dec_process_soc},
210 {JPC_MS_SOT, JPC_MH | JPC_TPHSOT, jpc_dec_process_sot},
211 {JPC_MS_SOD, JPC_TPH, jpc_dec_process_sod},
212 {JPC_MS_EOC, JPC_TPHSOT, jpc_dec_process_eoc},
213 {JPC_MS_SIZ, JPC_MHSIZ, jpc_dec_process_siz},
214 {JPC_MS_COD, JPC_MH | JPC_TPH, jpc_dec_process_cod},
215 {JPC_MS_COC, JPC_MH | JPC_TPH, jpc_dec_process_coc},
216 {JPC_MS_RGN, JPC_MH | JPC_TPH, jpc_dec_process_rgn},
217 {JPC_MS_QCD, JPC_MH | JPC_TPH, jpc_dec_process_qcd},
218 {JPC_MS_QCC, JPC_MH | JPC_TPH, jpc_dec_process_qcc},
219 {JPC_MS_POC, JPC_MH | JPC_TPH, jpc_dec_process_poc},
220 {JPC_MS_TLM, JPC_MH, 0},
221 {JPC_MS_PLM, JPC_MH, 0},
222 {JPC_MS_PLT, JPC_TPH, 0},
223 {JPC_MS_PPM, JPC_MH, jpc_dec_process_ppm},
224 {JPC_MS_PPT, JPC_TPH, jpc_dec_process_ppt},
226 {JPC_MS_CRG, JPC_MH, jpc_dec_process_crg},
227 {JPC_MS_COM, JPC_MH | JPC_TPH, jpc_dec_process_com},
228 {0, JPC_MH | JPC_TPH, jpc_dec_process_unk}
231 /******************************************************************************\
232 * The main entry point for the JPEG-2000 decoder.
233 \******************************************************************************/
235 jas_image_t *jpc_decode(jas_stream_t *in, char *optstr)
237 jpc_dec_importopts_t opts;
243 if (jpc_dec_parseopts(optstr, &opts)) {
249 if (!(dec = jpc_dec_create(&opts, in))) {
253 /* Do most of the work. */
254 if (jpc_dec_decode(dec)) {
258 if (jas_image_numcmpts(dec->image) >= 3) {
259 jas_image_setclrspc(dec->image, JAS_CLRSPC_SRGB);
260 jas_image_setcmpttype(dec->image, 0,
261 JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
262 jas_image_setcmpttype(dec->image, 1,
263 JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
264 jas_image_setcmpttype(dec->image, 2,
265 JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
267 jas_image_setclrspc(dec->image, JAS_CLRSPC_SGRAY);
268 jas_image_setcmpttype(dec->image, 0,
269 JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
272 /* Save the return value. */
275 /* Stop the image from being discarded. */
278 /* Destroy decoder. */
279 jpc_dec_destroy(dec);
285 jpc_dec_destroy(dec);
296 jas_taginfo_t decopts[] = {
297 {OPT_MAXLYRS, "maxlyrs"},
298 {OPT_MAXPKTS, "maxpkts"},
299 {OPT_DEBUG, "debug"},
303 static int jpc_dec_parseopts(char *optstr, jpc_dec_importopts_t *opts)
308 opts->maxlyrs = JPC_MAXLYRS;
311 if (!(tvp = jas_tvparser_create(optstr ? optstr : ""))) {
315 while (!jas_tvparser_next(tvp)) {
316 switch (jas_taginfo_nonull(jas_taginfos_lookup(decopts,
317 jas_tvparser_gettag(tvp)))->id) {
319 opts->maxlyrs = atoi(jas_tvparser_getval(tvp));
322 opts->debug = atoi(jas_tvparser_getval(tvp));
325 opts->maxpkts = atoi(jas_tvparser_getval(tvp));
328 fprintf(stderr, "warning: ignoring invalid option %s\n",
329 jas_tvparser_gettag(tvp));
334 jas_tvparser_destroy(tvp);
339 /******************************************************************************\
340 * Code for table-driven code stream decoder.
341 \******************************************************************************/
343 static jpc_dec_mstabent_t *jpc_dec_mstab_lookup(uint_fast16_t id)
345 jpc_dec_mstabent_t *mstabent;
346 for (mstabent = jpc_dec_mstab; mstabent->id != 0; ++mstabent) {
347 if (mstabent->id == id) {
354 static int jpc_dec_decode(jpc_dec_t *dec)
357 jpc_dec_mstabent_t *mstabent;
359 jpc_cstate_t *cstate;
361 if (!(cstate = jpc_cstate_create())) {
364 dec->cstate = cstate;
366 /* Initially, we should expect to encounter a SOC marker segment. */
367 dec->state = JPC_MHSOC;
371 /* Get the next marker segment in the code stream. */
372 if (!(ms = jpc_getms(dec->in, cstate))) {
373 fprintf(stderr, "cannot get marker segment\n");
377 mstabent = jpc_dec_mstab_lookup(ms->id);
380 /* Ensure that this type of marker segment is permitted
381 at this point in the code stream. */
382 if (!(dec->state & mstabent->validstates)) {
383 fprintf(stderr, "unexpected marker segment type\n");
388 /* Process the marker segment. */
389 if (mstabent->action) {
390 ret = (*mstabent->action)(dec, ms);
392 /* No explicit action is required. */
396 /* Destroy the marker segment. */
401 } else if (ret > 0) {
410 static int jpc_dec_process_crg(jpc_dec_t *dec, jpc_ms_t *ms)
413 jpc_dec_cmpt_t *cmpt;
416 crg = &ms->parms.crg;
417 for (cmptno = 0, cmpt = dec->cmpts; cmptno < dec->numcomps; ++cmptno,
419 /* Ignore the information in the CRG marker segment for now.
420 This information serves no useful purpose for decoding anyhow.
421 Some other parts of the code need to be changed if these lines
423 cmpt->hsubstep = crg->comps[cmptno].hoff;
424 cmpt->vsubstep = crg->comps[cmptno].voff;
430 static int jpc_dec_process_soc(jpc_dec_t *dec, jpc_ms_t *ms)
432 /* Eliminate warnings about unused variables. */
435 /* We should expect to encounter a SIZ marker segment next. */
436 dec->state = JPC_MHSIZ;
441 static int jpc_dec_process_sot(jpc_dec_t *dec, jpc_ms_t *ms)
443 jpc_dec_tile_t *tile;
444 jpc_sot_t *sot = &ms->parms.sot;
445 jas_image_cmptparm_t *compinfos;
446 jas_image_cmptparm_t *compinfo;
447 jpc_dec_cmpt_t *cmpt;
450 if (dec->state == JPC_MH) {
452 compinfos = jas_malloc(dec->numcomps * sizeof(jas_image_cmptparm_t));
454 for (cmptno = 0, cmpt = dec->cmpts, compinfo = compinfos;
455 cmptno < dec->numcomps; ++cmptno, ++cmpt, ++compinfo) {
458 compinfo->prec = cmpt->prec;
459 compinfo->sgnd = cmpt->sgnd;
460 compinfo->width = cmpt->width;
461 compinfo->height = cmpt->height;
462 compinfo->hstep = cmpt->hstep;
463 compinfo->vstep = cmpt->vstep;
466 if (!(dec->image = jas_image_create(dec->numcomps, compinfos,
467 JAS_CLRSPC_UNKNOWN))) {
472 /* Is the packet header information stored in PPM marker segments in
475 /* Convert the PPM marker segment data into a collection of streams
476 (one stream per tile-part). */
477 if (!(dec->pkthdrstreams = jpc_ppmstabtostreams(dec->ppmstab))) {
480 jpc_ppxstab_destroy(dec->ppmstab);
486 dec->curtileendoff = jas_stream_getrwcount(dec->in) - ms->len -
489 dec->curtileendoff = 0;
492 if (JAS_CAST(int, sot->tileno) > dec->numtiles) {
493 fprintf(stderr, "invalid tile number in SOT marker segment\n");
496 /* Set the current tile. */
497 dec->curtile = &dec->tiles[sot->tileno];
499 /* Ensure that this is the expected part number. */
500 if (sot->partno != tile->partno) {
503 if (tile->numparts > 0 && sot->partno >= tile->numparts) {
506 if (!tile->numparts && sot->numparts > 0) {
507 tile->numparts = sot->numparts;
512 switch (tile->state) {
514 /* This is the first tile-part for this tile. */
515 tile->state = JPC_TILE_ACTIVE;
517 if (!(tile->cp = jpc_dec_cp_copy(dec->cp))) {
520 jpc_dec_cp_resetflags(dec->cp);
523 if (sot->numparts == sot->partno - 1) {
524 tile->state = JPC_TILE_ACTIVELAST;
529 /* Note: We do not increment the expected tile-part number until
530 all processing for this tile-part is complete. */
532 /* We should expect to encounter other tile-part header marker
534 dec->state = JPC_TPH;
539 static int jpc_dec_process_sod(jpc_dec_t *dec, jpc_ms_t *ms)
541 jpc_dec_tile_t *tile;
544 /* Eliminate compiler warnings about unused variables. */
547 if (!(tile = dec->curtile)) {
552 if (!jpc_dec_cp_isvalid(tile->cp)) {
555 jpc_dec_cp_prepare(tile->cp);
556 if (jpc_dec_tileinit(dec, tile)) {
561 /* Are packet headers stored in the main header or tile-part header? */
562 if (dec->pkthdrstreams) {
563 /* Get the stream containing the packet header data for this
565 if (!(tile->pkthdrstream = jpc_streamlist_remove(dec->pkthdrstreams, 0))) {
571 if (!tile->pkthdrstream) {
572 if (!(tile->pkthdrstream = jas_stream_memopen(0, 0))) {
576 pos = jas_stream_tell(tile->pkthdrstream);
577 jas_stream_seek(tile->pkthdrstream, 0, SEEK_END);
578 if (jpc_pptstabwrite(tile->pkthdrstream, tile->pptstab)) {
581 jas_stream_seek(tile->pkthdrstream, pos, SEEK_SET);
582 jpc_ppxstab_destroy(tile->pptstab);
586 if (jas_getdbglevel() >= 10) {
587 jpc_dec_dump(dec, stderr);
590 if (jpc_dec_decodepkts(dec, (tile->pkthdrstream) ? tile->pkthdrstream :
592 fprintf(stderr, "jpc_dec_decodepkts failed\n");
596 /* Gobble any unconsumed tile data. */
597 if (dec->curtileendoff > 0) {
600 curoff = jas_stream_getrwcount(dec->in);
601 if (curoff < dec->curtileendoff) {
602 n = dec->curtileendoff - curoff;
604 "warning: ignoring trailing garbage (%lu bytes)\n",
608 if (jas_stream_getc(dec->in) == EOF) {
609 fprintf(stderr, "read error\n");
613 } else if (curoff > dec->curtileendoff) {
615 "warning: not enough tile data (%lu bytes)\n",
616 (unsigned long) curoff - dec->curtileendoff);
621 if (tile->numparts > 0 && tile->partno == tile->numparts - 1) {
622 if (jpc_dec_tiledecode(dec, tile)) {
625 jpc_dec_tilefini(dec, tile);
630 /* Increment the expected tile-part number. */
633 /* We should expect to encounter a SOT marker segment next. */
634 dec->state = JPC_TPHSOT;
639 static int jpc_dec_tileinit(jpc_dec_t *dec, jpc_dec_tile_t *tile)
641 jpc_dec_tcomp_t *tcomp;
644 jpc_dec_rlvl_t *rlvl;
645 jpc_dec_band_t *band;
648 jpc_tsfb_band_t *bnd;
652 jpc_dec_cblk_t *cblk;
654 uint_fast32_t tlprcxstart;
655 uint_fast32_t tlprcystart;
656 uint_fast32_t brprcxend;
657 uint_fast32_t brprcyend;
658 uint_fast32_t tlcbgxstart;
659 uint_fast32_t tlcbgystart;
660 uint_fast32_t brcbgxend;
661 uint_fast32_t brcbgyend;
662 uint_fast32_t cbgxstart;
663 uint_fast32_t cbgystart;
664 uint_fast32_t cbgxend;
665 uint_fast32_t cbgyend;
666 uint_fast32_t tlcblkxstart;
667 uint_fast32_t tlcblkystart;
668 uint_fast32_t brcblkxend;
669 uint_fast32_t brcblkyend;
670 uint_fast32_t cblkxstart;
671 uint_fast32_t cblkystart;
672 uint_fast32_t cblkxend;
673 uint_fast32_t cblkyend;
674 uint_fast32_t tmpxstart;
675 uint_fast32_t tmpystart;
676 uint_fast32_t tmpxend;
677 uint_fast32_t tmpyend;
679 jpc_tsfb_band_t bnds[64];
682 jpc_dec_cmpt_t *cmpt;
686 if (cp->mctid == JPC_MCT_ICT) {
690 for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
691 dec->numcomps; ++compno, ++tcomp, ++cmpt) {
692 ccp = &tile->cp->ccps[compno];
693 if (ccp->qmfbid == JPC_COX_INS) {
696 tcomp->numrlvls = ccp->numrlvls;
697 if (!(tcomp->rlvls = jas_malloc(tcomp->numrlvls *
698 sizeof(jpc_dec_rlvl_t)))) {
701 if (!(tcomp->data = jas_seq2d_create(JPC_CEILDIV(tile->xstart,
702 cmpt->hstep), JPC_CEILDIV(tile->ystart, cmpt->vstep),
703 JPC_CEILDIV(tile->xend, cmpt->hstep), JPC_CEILDIV(tile->yend,
707 if (!(tcomp->tsfb = jpc_cod_gettsfb(ccp->qmfbid,
708 tcomp->numrlvls - 1))) {
712 jpc_tsfb_getbands(tcomp->tsfb, jas_seq2d_xstart(tcomp->data), jas_seq2d_ystart(tcomp->data), jas_seq2d_xend(tcomp->data), jas_seq2d_yend(tcomp->data), bnds);
714 for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
717 rlvl->xstart = JPC_CEILDIVPOW2(tcomp->xstart,
718 tcomp->numrlvls - 1 - rlvlno);
719 rlvl->ystart = JPC_CEILDIVPOW2(tcomp->ystart,
720 tcomp->numrlvls - 1 - rlvlno);
721 rlvl->xend = JPC_CEILDIVPOW2(tcomp->xend,
722 tcomp->numrlvls - 1 - rlvlno);
723 rlvl->yend = JPC_CEILDIVPOW2(tcomp->yend,
724 tcomp->numrlvls - 1 - rlvlno);
725 rlvl->prcwidthexpn = ccp->prcwidthexpns[rlvlno];
726 rlvl->prcheightexpn = ccp->prcheightexpns[rlvlno];
727 tlprcxstart = JPC_FLOORDIVPOW2(rlvl->xstart,
728 rlvl->prcwidthexpn) << rlvl->prcwidthexpn;
729 tlprcystart = JPC_FLOORDIVPOW2(rlvl->ystart,
730 rlvl->prcheightexpn) << rlvl->prcheightexpn;
731 brprcxend = JPC_CEILDIVPOW2(rlvl->xend,
732 rlvl->prcwidthexpn) << rlvl->prcwidthexpn;
733 brprcyend = JPC_CEILDIVPOW2(rlvl->yend,
734 rlvl->prcheightexpn) << rlvl->prcheightexpn;
735 rlvl->numhprcs = (brprcxend - tlprcxstart) >>
737 rlvl->numvprcs = (brprcyend - tlprcystart) >>
739 rlvl->numprcs = rlvl->numhprcs * rlvl->numvprcs;
741 if (rlvl->xstart >= rlvl->xend || rlvl->ystart >= rlvl->yend) {
749 tlcbgxstart = tlprcxstart;
750 tlcbgystart = tlprcystart;
751 brcbgxend = brprcxend;
752 brcbgyend = brprcyend;
753 rlvl->cbgwidthexpn = rlvl->prcwidthexpn;
754 rlvl->cbgheightexpn = rlvl->prcheightexpn;
756 tlcbgxstart = JPC_CEILDIVPOW2(tlprcxstart, 1);
757 tlcbgystart = JPC_CEILDIVPOW2(tlprcystart, 1);
758 brcbgxend = JPC_CEILDIVPOW2(brprcxend, 1);
759 brcbgyend = JPC_CEILDIVPOW2(brprcyend, 1);
760 rlvl->cbgwidthexpn = rlvl->prcwidthexpn - 1;
761 rlvl->cbgheightexpn = rlvl->prcheightexpn - 1;
763 rlvl->cblkwidthexpn = JAS_MIN(ccp->cblkwidthexpn,
765 rlvl->cblkheightexpn = JAS_MIN(ccp->cblkheightexpn,
766 rlvl->cbgheightexpn);
768 rlvl->numbands = (!rlvlno) ? 1 : 3;
769 if (!(rlvl->bands = jas_malloc(rlvl->numbands *
770 sizeof(jpc_dec_band_t)))) {
773 for (bandno = 0, band = rlvl->bands;
774 bandno < rlvl->numbands; ++bandno, ++band) {
775 bndno = (!rlvlno) ? 0 : (3 * (rlvlno - 1) +
779 band->orient = bnd->orient;
780 band->stepsize = ccp->stepsizes[bndno];
781 band->analgain = JPC_NOMINALGAIN(ccp->qmfbid,
782 tcomp->numrlvls - 1, rlvlno, band->orient);
783 band->absstepsize = jpc_calcabsstepsize(band->stepsize,
784 cmpt->prec + band->analgain);
785 band->numbps = ccp->numguardbits +
786 JPC_QCX_GETEXPN(band->stepsize) - 1;
787 band->roishift = (ccp->roishift + band->numbps >= JPC_PREC) ?
788 (JPC_PREC - 1 - band->numbps) : ccp->roishift;
791 if (bnd->xstart == bnd->xend || bnd->ystart == bnd->yend) {
794 if (!(band->data = jas_seq2d_create(0, 0, 0, 0))) {
797 jas_seq2d_bindsub(band->data, tcomp->data, bnd->locxstart, bnd->locystart, bnd->locxend, bnd->locyend);
798 jas_seq2d_setshift(band->data, bnd->xstart, bnd->ystart);
800 assert(rlvl->numprcs);
802 if (!(band->prcs = jas_malloc(rlvl->numprcs * sizeof(jpc_dec_prc_t)))) {
806 /************************************************/
807 cbgxstart = tlcbgxstart;
808 cbgystart = tlcbgystart;
809 for (prccnt = rlvl->numprcs, prc = band->prcs;
810 prccnt > 0; --prccnt, ++prc) {
811 cbgxend = cbgxstart + (1 << rlvl->cbgwidthexpn);
812 cbgyend = cbgystart + (1 << rlvl->cbgheightexpn);
813 prc->xstart = JAS_MAX(cbgxstart, JAS_CAST(uint_fast32_t, jas_seq2d_xstart(band->data)));
814 prc->ystart = JAS_MAX(cbgystart, JAS_CAST(uint_fast32_t, jas_seq2d_ystart(band->data)));
815 prc->xend = JAS_MIN(cbgxend, JAS_CAST(uint_fast32_t, jas_seq2d_xend(band->data)));
816 prc->yend = JAS_MIN(cbgyend, JAS_CAST(uint_fast32_t, jas_seq2d_yend(band->data)));
817 if (prc->xend > prc->xstart && prc->yend > prc->ystart) {
818 tlcblkxstart = JPC_FLOORDIVPOW2(prc->xstart,
819 rlvl->cblkwidthexpn) << rlvl->cblkwidthexpn;
820 tlcblkystart = JPC_FLOORDIVPOW2(prc->ystart,
821 rlvl->cblkheightexpn) << rlvl->cblkheightexpn;
822 brcblkxend = JPC_CEILDIVPOW2(prc->xend,
823 rlvl->cblkwidthexpn) << rlvl->cblkwidthexpn;
824 brcblkyend = JPC_CEILDIVPOW2(prc->yend,
825 rlvl->cblkheightexpn) << rlvl->cblkheightexpn;
826 prc->numhcblks = (brcblkxend - tlcblkxstart) >>
828 prc->numvcblks = (brcblkyend - tlcblkystart) >>
829 rlvl->cblkheightexpn;
830 prc->numcblks = prc->numhcblks * prc->numvcblks;
831 assert(prc->numcblks > 0);
833 if (!(prc->incltagtree = jpc_tagtree_create(prc->numhcblks, prc->numvcblks))) {
836 if (!(prc->numimsbstagtree = jpc_tagtree_create(prc->numhcblks, prc->numvcblks))) {
839 if (!(prc->cblks = jas_malloc(prc->numcblks * sizeof(jpc_dec_cblk_t)))) {
843 cblkxstart = cbgxstart;
844 cblkystart = cbgystart;
845 for (cblkcnt = prc->numcblks, cblk = prc->cblks; cblkcnt > 0;) {
846 cblkxend = cblkxstart + (1 << rlvl->cblkwidthexpn);
847 cblkyend = cblkystart + (1 << rlvl->cblkheightexpn);
848 tmpxstart = JAS_MAX(cblkxstart, prc->xstart);
849 tmpystart = JAS_MAX(cblkystart, prc->ystart);
850 tmpxend = JAS_MIN(cblkxend, prc->xend);
851 tmpyend = JAS_MIN(cblkyend, prc->yend);
852 if (tmpxend > tmpxstart && tmpyend > tmpystart) {
853 cblk->firstpassno = -1;
862 cblk->numlenbits = 3;
864 if (!(cblk->data = jas_seq2d_create(0, 0, 0, 0))) {
867 jas_seq2d_bindsub(cblk->data, band->data, tmpxstart, tmpystart, tmpxend, tmpyend);
871 cblkxstart += 1 << rlvl->cblkwidthexpn;
872 if (cblkxstart >= cbgxend) {
873 cblkxstart = cbgxstart;
874 cblkystart += 1 << rlvl->cblkheightexpn;
880 prc->incltagtree = 0;
881 prc->numimsbstagtree = 0;
883 cbgxstart += 1 << rlvl->cbgwidthexpn;
884 if (cbgxstart >= brcbgxend) {
885 cbgxstart = tlcbgxstart;
886 cbgystart += 1 << rlvl->cbgheightexpn;
890 /********************************************/
895 if (!(tile->pi = jpc_dec_pi_create(dec, tile)))
900 for (pchgno = 0; pchgno < jpc_pchglist_numpchgs(tile->cp->pchglist);
902 pchg = jpc_pchg_copy(jpc_pchglist_get(tile->cp->pchglist, pchgno));
904 jpc_pi_addpchg(tile->pi, pchg);
906 jpc_pi_init(tile->pi);
911 static int jpc_dec_tilefini(jpc_dec_t *dec, jpc_dec_tile_t *tile)
913 jpc_dec_tcomp_t *tcomp;
917 jpc_dec_band_t *band;
918 jpc_dec_rlvl_t *rlvl;
922 jpc_dec_cblk_t *cblk;
927 for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
929 for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
934 for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; ++bandno, ++band) {
936 for (prcno = 0, prc = band->prcs; prcno <
937 rlvl->numprcs; ++prcno, ++prc) {
941 for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; ++cblkno, ++cblk) {
943 while (cblk->segs.head) {
944 seg = cblk->segs.head;
945 jpc_seglist_remove(&cblk->segs, seg);
946 jpc_seg_destroy(seg);
948 jas_matrix_destroy(cblk->data);
950 jpc_mqdec_destroy(cblk->mqdec);
953 jpc_bitstream_close(cblk->nulldec);
956 jas_matrix_destroy(cblk->flags);
959 if (prc->incltagtree) {
960 jpc_tagtree_destroy(prc->incltagtree);
962 if (prc->numimsbstagtree) {
963 jpc_tagtree_destroy(prc->numimsbstagtree);
966 jas_free(prc->cblks);
971 jas_matrix_destroy(band->data);
974 jas_free(band->prcs);
978 jas_free(rlvl->bands);
982 jas_free(tcomp->rlvls);
985 jas_matrix_destroy(tcomp->data);
988 jpc_tsfb_destroy(tcomp->tsfb);
993 jpc_dec_cp_destroy(tile->cp);
997 jas_free(tile->tcomps);
1001 jpc_pi_destroy(tile->pi);
1004 if (tile->pkthdrstream) {
1005 jas_stream_close(tile->pkthdrstream);
1006 tile->pkthdrstream = 0;
1008 if (tile->pptstab) {
1009 jpc_ppxstab_destroy(tile->pptstab);
1013 tile->state = JPC_TILE_DONE;
1018 static int jpc_dec_tiledecode(jpc_dec_t *dec, jpc_dec_tile_t *tile)
1022 jpc_dec_tcomp_t *tcomp;
1023 jpc_dec_rlvl_t *rlvl;
1024 jpc_dec_band_t *band;
1031 jpc_dec_cmpt_t *cmpt;
1033 if (jpc_dec_decodecblks(dec, tile)) {
1034 fprintf(stderr, "jpc_dec_decodecblks failed\n");
1038 /* Perform dequantization. */
1039 for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
1040 ++compno, ++tcomp) {
1041 ccp = &tile->cp->ccps[compno];
1042 for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
1047 for (bandno = 0, band = rlvl->bands;
1048 bandno < rlvl->numbands; ++bandno, ++band) {
1052 jpc_undo_roi(band->data, band->roishift, ccp->roishift -
1053 band->roishift, band->numbps);
1054 if (tile->realmode) {
1055 jas_matrix_asl(band->data, JPC_FIX_FRACBITS);
1056 jpc_dequantize(band->data, band->absstepsize);
1063 /* Apply an inverse wavelet transform if necessary. */
1064 for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
1065 ++compno, ++tcomp) {
1066 ccp = &tile->cp->ccps[compno];
1067 jpc_tsfb_synthesize(tcomp->tsfb, ((ccp->qmfbid ==
1068 JPC_COX_RFT) ? JPC_TSFB_RITIMODE : 0), tcomp->data);
1072 /* Apply an inverse intercomponent transform if necessary. */
1073 switch (tile->cp->mctid) {
1075 assert(dec->numcomps == 3);
1076 jpc_irct(tile->tcomps[0].data, tile->tcomps[1].data,
1077 tile->tcomps[2].data);
1080 assert(dec->numcomps == 3);
1081 jpc_iict(tile->tcomps[0].data, tile->tcomps[1].data,
1082 tile->tcomps[2].data);
1086 /* Perform rounding and convert to integer values. */
1087 if (tile->realmode) {
1088 for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
1089 ++compno, ++tcomp) {
1090 for (i = 0; i < jas_matrix_numrows(tcomp->data); ++i) {
1091 for (j = 0; j < jas_matrix_numcols(tcomp->data); ++j) {
1092 v = jas_matrix_get(tcomp->data, i, j);
1093 v = jpc_fix_round(v);
1094 jas_matrix_set(tcomp->data, i, j, jpc_fixtoint(v));
1100 /* Perform level shift. */
1101 for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
1102 dec->numcomps; ++compno, ++tcomp, ++cmpt) {
1103 adjust = cmpt->sgnd ? 0 : (1 << (cmpt->prec - 1));
1104 for (i = 0; i < jas_matrix_numrows(tcomp->data); ++i) {
1105 for (j = 0; j < jas_matrix_numcols(tcomp->data); ++j) {
1106 *jas_matrix_getref(tcomp->data, i, j) += adjust;
1111 /* Perform clipping. */
1112 for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
1113 dec->numcomps; ++compno, ++tcomp, ++cmpt) {
1116 mn = cmpt->sgnd ? (-(1 << (cmpt->prec - 1))) : (0);
1117 mx = cmpt->sgnd ? ((1 << (cmpt->prec - 1)) - 1) : ((1 <<
1119 jas_matrix_clip(tcomp->data, mn, mx);
1122 /* XXX need to free tsfb struct */
1124 /* Write the data for each component of the image. */
1125 for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
1126 dec->numcomps; ++compno, ++tcomp, ++cmpt) {
1127 if (jas_image_writecmpt(dec->image, compno, tcomp->xstart -
1128 JPC_CEILDIV(dec->xstart, cmpt->hstep), tcomp->ystart -
1129 JPC_CEILDIV(dec->ystart, cmpt->vstep), jas_matrix_numcols(
1130 tcomp->data), jas_matrix_numrows(tcomp->data), tcomp->data)) {
1131 fprintf(stderr, "write component failed\n");
1139 static int jpc_dec_process_eoc(jpc_dec_t *dec, jpc_ms_t *ms)
1142 jpc_dec_tile_t *tile;
1144 /* Eliminate compiler warnings about unused variables. */
1147 for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
1149 if (tile->state == JPC_TILE_ACTIVE) {
1150 if (jpc_dec_tiledecode(dec, tile)) {
1154 jpc_dec_tilefini(dec, tile);
1157 /* We are done processing the code stream. */
1158 dec->state = JPC_MT;
1163 static int jpc_dec_process_siz(jpc_dec_t *dec, jpc_ms_t *ms)
1165 jpc_siz_t *siz = &ms->parms.siz;
1168 jpc_dec_tile_t *tile;
1169 jpc_dec_tcomp_t *tcomp;
1172 jpc_dec_cmpt_t *cmpt;
1174 dec->xstart = siz->xoff;
1175 dec->ystart = siz->yoff;
1176 dec->xend = siz->width;
1177 dec->yend = siz->height;
1178 dec->tilewidth = siz->tilewidth;
1179 dec->tileheight = siz->tileheight;
1180 dec->tilexoff = siz->tilexoff;
1181 dec->tileyoff = siz->tileyoff;
1182 dec->numcomps = siz->numcomps;
1183 if (!(dec->cp = jpc_dec_cp_create(dec->numcomps))) {
1187 if (!(dec->cmpts = jas_malloc(dec->numcomps * sizeof(jpc_dec_cmpt_t)))) {
1191 for (compno = 0, cmpt = dec->cmpts; compno < dec->numcomps; ++compno,
1193 cmpt->prec = siz->comps[compno].prec;
1194 cmpt->sgnd = siz->comps[compno].sgnd;
1195 cmpt->hstep = siz->comps[compno].hsamp;
1196 cmpt->vstep = siz->comps[compno].vsamp;
1197 cmpt->width = JPC_CEILDIV(dec->xend, cmpt->hstep) -
1198 JPC_CEILDIV(dec->xstart, cmpt->hstep);
1199 cmpt->height = JPC_CEILDIV(dec->yend, cmpt->vstep) -
1200 JPC_CEILDIV(dec->ystart, cmpt->vstep);
1207 dec->numhtiles = JPC_CEILDIV(dec->xend - dec->tilexoff, dec->tilewidth);
1208 dec->numvtiles = JPC_CEILDIV(dec->yend - dec->tileyoff, dec->tileheight);
1209 dec->numtiles = dec->numhtiles * dec->numvtiles;
1210 if (!(dec->tiles = jas_malloc(dec->numtiles * sizeof(jpc_dec_tile_t)))) {
1214 for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
1216 htileno = tileno % dec->numhtiles;
1217 vtileno = tileno / dec->numhtiles;
1219 tile->state = JPC_TILE_INIT;
1220 tile->xstart = JAS_MAX(dec->tilexoff + htileno * dec->tilewidth,
1222 tile->ystart = JAS_MAX(dec->tileyoff + vtileno * dec->tileheight,
1224 tile->xend = JAS_MIN(dec->tilexoff + (htileno + 1) *
1225 dec->tilewidth, dec->xend);
1226 tile->yend = JAS_MIN(dec->tileyoff + (vtileno + 1) *
1227 dec->tileheight, dec->yend);
1230 tile->pkthdrstream = 0;
1231 tile->pkthdrstreampos = 0;
1234 if (!(tile->tcomps = jas_malloc(dec->numcomps *
1235 sizeof(jpc_dec_tcomp_t)))) {
1238 for (compno = 0, cmpt = dec->cmpts, tcomp = tile->tcomps;
1239 compno < dec->numcomps; ++compno, ++cmpt, ++tcomp) {
1242 tcomp->xstart = JPC_CEILDIV(tile->xstart, cmpt->hstep);
1243 tcomp->ystart = JPC_CEILDIV(tile->ystart, cmpt->vstep);
1244 tcomp->xend = JPC_CEILDIV(tile->xend, cmpt->hstep);
1245 tcomp->yend = JPC_CEILDIV(tile->yend, cmpt->vstep);
1250 dec->pkthdrstreams = 0;
1252 /* We should expect to encounter other main header marker segments
1253 or an SOT marker segment next. */
1254 dec->state = JPC_MH;
1259 static int jpc_dec_process_cod(jpc_dec_t *dec, jpc_ms_t *ms)
1261 jpc_cod_t *cod = &ms->parms.cod;
1262 jpc_dec_tile_t *tile;
1264 switch (dec->state) {
1266 jpc_dec_cp_setfromcod(dec->cp, cod);
1269 if (!(tile = dec->curtile)) {
1272 if (tile->partno != 0) {
1275 jpc_dec_cp_setfromcod(tile->cp, cod);
1281 static int jpc_dec_process_coc(jpc_dec_t *dec, jpc_ms_t *ms)
1283 jpc_coc_t *coc = &ms->parms.coc;
1284 jpc_dec_tile_t *tile;
1286 if (JAS_CAST(int, coc->compno) > dec->numcomps) {
1288 "invalid component number in COC marker segment\n");
1291 switch (dec->state) {
1293 jpc_dec_cp_setfromcoc(dec->cp, coc);
1296 if (!(tile = dec->curtile)) {
1299 if (tile->partno > 0) {
1302 jpc_dec_cp_setfromcoc(tile->cp, coc);
1308 static int jpc_dec_process_rgn(jpc_dec_t *dec, jpc_ms_t *ms)
1310 jpc_rgn_t *rgn = &ms->parms.rgn;
1311 jpc_dec_tile_t *tile;
1313 if (JAS_CAST(int, rgn->compno) > dec->numcomps) {
1315 "invalid component number in RGN marker segment\n");
1318 switch (dec->state) {
1320 jpc_dec_cp_setfromrgn(dec->cp, rgn);
1323 if (!(tile = dec->curtile)) {
1326 if (tile->partno > 0) {
1329 jpc_dec_cp_setfromrgn(tile->cp, rgn);
1336 static int jpc_dec_process_qcd(jpc_dec_t *dec, jpc_ms_t *ms)
1338 jpc_qcd_t *qcd = &ms->parms.qcd;
1339 jpc_dec_tile_t *tile;
1341 switch (dec->state) {
1343 jpc_dec_cp_setfromqcd(dec->cp, qcd);
1346 if (!(tile = dec->curtile)) {
1349 if (tile->partno > 0) {
1352 jpc_dec_cp_setfromqcd(tile->cp, qcd);
1358 static int jpc_dec_process_qcc(jpc_dec_t *dec, jpc_ms_t *ms)
1360 jpc_qcc_t *qcc = &ms->parms.qcc;
1361 jpc_dec_tile_t *tile;
1363 if (JAS_CAST(int, qcc->compno) > dec->numcomps) {
1365 "invalid component number in QCC marker segment\n");
1368 switch (dec->state) {
1370 jpc_dec_cp_setfromqcc(dec->cp, qcc);
1373 if (!(tile = dec->curtile)) {
1376 if (tile->partno > 0) {
1379 jpc_dec_cp_setfromqcc(tile->cp, qcc);
1385 static int jpc_dec_process_poc(jpc_dec_t *dec, jpc_ms_t *ms)
1387 jpc_poc_t *poc = &ms->parms.poc;
1388 jpc_dec_tile_t *tile;
1389 switch (dec->state) {
1391 if (jpc_dec_cp_setfrompoc(dec->cp, poc, 1)) {
1396 if (!(tile = dec->curtile)) {
1399 if (!tile->partno) {
1400 if (jpc_dec_cp_setfrompoc(tile->cp, poc, (!tile->partno))) {
1404 jpc_pi_addpchgfrompoc(tile->pi, poc);
1411 static int jpc_dec_process_ppm(jpc_dec_t *dec, jpc_ms_t *ms)
1413 jpc_ppm_t *ppm = &ms->parms.ppm;
1414 jpc_ppxstabent_t *ppmstabent;
1416 if (!dec->ppmstab) {
1417 if (!(dec->ppmstab = jpc_ppxstab_create())) {
1422 if (!(ppmstabent = jpc_ppxstabent_create())) {
1425 ppmstabent->ind = ppm->ind;
1426 ppmstabent->data = ppm->data;
1428 ppmstabent->len = ppm->len;
1429 if (jpc_ppxstab_insert(dec->ppmstab, ppmstabent)) {
1435 static int jpc_dec_process_ppt(jpc_dec_t *dec, jpc_ms_t *ms)
1437 jpc_ppt_t *ppt = &ms->parms.ppt;
1438 jpc_dec_tile_t *tile;
1439 jpc_ppxstabent_t *pptstabent;
1441 tile = dec->curtile;
1442 if (!tile->pptstab) {
1443 if (!(tile->pptstab = jpc_ppxstab_create())) {
1447 if (!(pptstabent = jpc_ppxstabent_create())) {
1450 pptstabent->ind = ppt->ind;
1451 pptstabent->data = ppt->data;
1453 pptstabent->len = ppt->len;
1454 if (jpc_ppxstab_insert(tile->pptstab, pptstabent)) {
1460 static int jpc_dec_process_com(jpc_dec_t *dec, jpc_ms_t *ms)
1462 /* Eliminate compiler warnings about unused variables. */
1469 static int jpc_dec_process_unk(jpc_dec_t *dec, jpc_ms_t *ms)
1471 /* Eliminate compiler warnings about unused variables. */
1474 fprintf(stderr, "warning: ignoring unknown marker segment\n");
1475 jpc_ms_dump(ms, stderr);
1479 /******************************************************************************\
1481 \******************************************************************************/
1483 static jpc_dec_cp_t *jpc_dec_cp_create(uint_fast16_t numcomps)
1489 if (!(cp = jas_malloc(sizeof(jpc_dec_cp_t)))) {
1493 cp->numcomps = numcomps;
1498 if (!(cp->ccps = jas_malloc(cp->numcomps * sizeof(jpc_dec_ccp_t)))) {
1501 if (!(cp->pchglist = jpc_pchglist_create())) {
1505 for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1509 ccp->cblkwidthexpn = 0;
1510 ccp->cblkheightexpn = 0;
1512 ccp->numstepsizes = 0;
1513 ccp->numguardbits = 0;
1520 static jpc_dec_cp_t *jpc_dec_cp_copy(jpc_dec_cp_t *cp)
1522 jpc_dec_cp_t *newcp;
1523 jpc_dec_ccp_t *newccp;
1527 if (!(newcp = jpc_dec_cp_create(cp->numcomps))) {
1530 newcp->flags = cp->flags;
1531 newcp->prgord = cp->prgord;
1532 newcp->numlyrs = cp->numlyrs;
1533 newcp->mctid = cp->mctid;
1534 newcp->csty = cp->csty;
1535 jpc_pchglist_destroy(newcp->pchglist);
1536 newcp->pchglist = 0;
1537 if (!(newcp->pchglist = jpc_pchglist_copy(cp->pchglist))) {
1541 for (compno = 0, newccp = newcp->ccps, ccp = cp->ccps;
1542 compno < cp->numcomps;
1543 ++compno, ++newccp, ++ccp) {
1549 static void jpc_dec_cp_resetflags(jpc_dec_cp_t *cp)
1553 cp->flags &= (JPC_CSET | JPC_QSET);
1554 for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1560 static void jpc_dec_cp_destroy(jpc_dec_cp_t *cp)
1566 jpc_pchglist_destroy(cp->pchglist);
1571 static int jpc_dec_cp_isvalid(jpc_dec_cp_t *cp)
1573 uint_fast16_t compcnt;
1576 if (!(cp->flags & JPC_CSET) || !(cp->flags & JPC_QSET)) {
1579 for (compcnt = cp->numcomps, ccp = cp->ccps; compcnt > 0; --compcnt,
1581 /* Is there enough step sizes for the number of bands? */
1582 if ((ccp->qsty != JPC_QCX_SIQNT && JAS_CAST(int, ccp->numstepsizes) < 3 *
1583 ccp->numrlvls - 2) || (ccp->qsty == JPC_QCX_SIQNT &&
1584 ccp->numstepsizes != 1)) {
1591 static void calcstepsizes(uint_fast16_t refstepsize, int numrlvls,
1592 uint_fast16_t *stepsizes)
1598 expn = JPC_QCX_GETEXPN(refstepsize);
1599 mant = JPC_QCX_GETMANT(refstepsize);
1600 numbands = 3 * numrlvls - 2;
1601 for (bandno = 0; bandno < numbands; ++bandno) {
1602 stepsizes[bandno] = JPC_QCX_MANT(mant) | JPC_QCX_EXPN(expn +
1603 (numrlvls - 1) - (numrlvls - 1 - ((bandno > 0) ? ((bandno + 2) / 3) : (0))));
1607 static int jpc_dec_cp_prepare(jpc_dec_cp_t *cp)
1612 for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1614 if (!(ccp->csty & JPC_COX_PRT)) {
1615 for (i = 0; i < JPC_MAXRLVLS; ++i) {
1616 ccp->prcwidthexpns[i] = 15;
1617 ccp->prcheightexpns[i] = 15;
1620 if (ccp->qsty == JPC_QCX_SIQNT) {
1621 calcstepsizes(ccp->stepsizes[0], ccp->numrlvls, ccp->stepsizes);
1627 static int jpc_dec_cp_setfromcod(jpc_dec_cp_t *cp, jpc_cod_t *cod)
1631 cp->flags |= JPC_CSET;
1632 cp->prgord = cod->prg;
1634 cp->mctid = (cod->compparms.qmfbid == JPC_COX_INS) ? (JPC_MCT_ICT) : (JPC_MCT_RCT);
1636 cp->mctid = JPC_MCT_NONE;
1638 cp->numlyrs = cod->numlyrs;
1639 cp->csty = cod->csty & (JPC_COD_SOP | JPC_COD_EPH);
1640 for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1642 jpc_dec_cp_setfromcox(cp, ccp, &cod->compparms, 0);
1644 cp->flags |= JPC_CSET;
1648 static int jpc_dec_cp_setfromcoc(jpc_dec_cp_t *cp, jpc_coc_t *coc)
1650 jpc_dec_cp_setfromcox(cp, &cp->ccps[coc->compno], &coc->compparms, JPC_COC);
1654 static int jpc_dec_cp_setfromcox(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
1655 jpc_coxcp_t *compparms, int flags)
1659 /* Eliminate compiler warnings about unused variables. */
1662 if ((flags & JPC_COC) || !(ccp->flags & JPC_COC)) {
1663 ccp->numrlvls = compparms->numdlvls + 1;
1664 ccp->cblkwidthexpn = JPC_COX_GETCBLKSIZEEXPN(
1665 compparms->cblkwidthval);
1666 ccp->cblkheightexpn = JPC_COX_GETCBLKSIZEEXPN(
1667 compparms->cblkheightval);
1668 ccp->qmfbid = compparms->qmfbid;
1669 ccp->cblkctx = compparms->cblksty;
1670 ccp->csty = compparms->csty & JPC_COX_PRT;
1671 for (rlvlno = 0; rlvlno < compparms->numrlvls; ++rlvlno) {
1672 ccp->prcwidthexpns[rlvlno] =
1673 compparms->rlvls[rlvlno].parwidthval;
1674 ccp->prcheightexpns[rlvlno] =
1675 compparms->rlvls[rlvlno].parheightval;
1677 ccp->flags |= flags | JPC_CSET;
1682 static int jpc_dec_cp_setfromqcd(jpc_dec_cp_t *cp, jpc_qcd_t *qcd)
1686 for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1688 jpc_dec_cp_setfromqcx(cp, ccp, &qcd->compparms, 0);
1690 cp->flags |= JPC_QSET;
1694 static int jpc_dec_cp_setfromqcc(jpc_dec_cp_t *cp, jpc_qcc_t *qcc)
1696 return jpc_dec_cp_setfromqcx(cp, &cp->ccps[qcc->compno], &qcc->compparms, JPC_QCC);
1699 static int jpc_dec_cp_setfromqcx(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
1700 jpc_qcxcp_t *compparms, int flags)
1704 /* Eliminate compiler warnings about unused variables. */
1707 if ((flags & JPC_QCC) || !(ccp->flags & JPC_QCC)) {
1708 ccp->flags |= flags | JPC_QSET;
1709 for (bandno = 0; bandno < compparms->numstepsizes; ++bandno) {
1710 ccp->stepsizes[bandno] = compparms->stepsizes[bandno];
1712 ccp->numstepsizes = compparms->numstepsizes;
1713 ccp->numguardbits = compparms->numguard;
1714 ccp->qsty = compparms->qntsty;
1719 static int jpc_dec_cp_setfromrgn(jpc_dec_cp_t *cp, jpc_rgn_t *rgn)
1722 ccp = &cp->ccps[rgn->compno];
1723 ccp->roishift = rgn->roishift;
1727 static int jpc_pi_addpchgfrompoc(jpc_pi_t *pi, jpc_poc_t *poc)
1731 for (pchgno = 0; pchgno < poc->numpchgs; ++pchgno) {
1732 if (!(pchg = jpc_pchg_copy(&poc->pchgs[pchgno]))) {
1735 if (jpc_pchglist_insert(pi->pchglist, -1, pchg)) {
1742 static int jpc_dec_cp_setfrompoc(jpc_dec_cp_t *cp, jpc_poc_t *poc, int reset)
1747 while (jpc_pchglist_numpchgs(cp->pchglist) > 0) {
1748 pchg = jpc_pchglist_remove(cp->pchglist, 0);
1749 jpc_pchg_destroy(pchg);
1752 for (pchgno = 0; pchgno < poc->numpchgs; ++pchgno) {
1753 if (!(pchg = jpc_pchg_copy(&poc->pchgs[pchgno]))) {
1756 if (jpc_pchglist_insert(cp->pchglist, -1, pchg)) {
1763 static jpc_fix_t jpc_calcabsstepsize(int stepsize, int numbits)
1765 jpc_fix_t absstepsize;
1768 absstepsize = jpc_inttofix(1);
1769 n = JPC_FIX_FRACBITS - 11;
1770 absstepsize |= (n >= 0) ? (JPC_QCX_GETMANT(stepsize) << n) :
1771 (JPC_QCX_GETMANT(stepsize) >> (-n));
1772 n = numbits - JPC_QCX_GETEXPN(stepsize);
1773 absstepsize = (n >= 0) ? (absstepsize << n) : (absstepsize >> (-n));
1777 static void jpc_dequantize(jas_matrix_t *x, jpc_fix_t absstepsize)
1783 assert(absstepsize >= 0);
1784 if (absstepsize == jpc_inttofix(1)) {
1788 for (i = 0; i < jas_matrix_numrows(x); ++i) {
1789 for (j = 0; j < jas_matrix_numcols(x); ++j) {
1790 t = jas_matrix_get(x, i, j);
1792 t = jpc_fix_mul(t, absstepsize);
1796 jas_matrix_set(x, i, j, t);
1802 static void jpc_undo_roi(jas_matrix_t *x, int roishift, int bgshift, int numbps)
1812 if (roishift == 0 && bgshift == 0) {
1815 thresh = 1 << roishift;
1818 for (i = 0; i < jas_matrix_numrows(x); ++i) {
1819 for (j = 0; j < jas_matrix_numcols(x); ++j) {
1820 val = jas_matrix_get(x, i, j);
1822 if (mag >= thresh) {
1823 /* We are dealing with ROI data. */
1825 val = (val < 0) ? (-mag) : mag;
1826 jas_matrix_set(x, i, j, val);
1828 /* We are dealing with non-ROI (i.e., background) data. */
1830 mask = (1 << numbps) - 1;
1831 /* Perform a basic sanity check on the sample value. */
1832 /* Some implementations write garbage in the unused
1833 most-significant bit planes introduced by ROI shifting.
1834 Here we ensure that any such bits are masked off. */
1835 if (mag & (~mask)) {
1838 "warning: possibly corrupt code stream\n");
1843 val = (val < 0) ? (-mag) : mag;
1844 jas_matrix_set(x, i, j, val);
1850 static jpc_dec_t *jpc_dec_create(jpc_dec_importopts_t *impopts, jas_stream_t *in)
1854 if (!(dec = jas_malloc(sizeof(jpc_dec_t)))) {
1864 dec->tileheight = 0;
1875 dec->maxlyrs = impopts->maxlyrs;
1876 dec->maxpkts = impopts->maxpkts;
1881 dec->pkthdrstreams = 0;
1883 dec->curtileendoff = 0;
1888 static void jpc_dec_destroy(jpc_dec_t *dec)
1891 jpc_cstate_destroy(dec->cstate);
1893 if (dec->pkthdrstreams) {
1894 jpc_streamlist_destroy(dec->pkthdrstreams);
1897 jas_image_destroy(dec->image);
1901 jpc_dec_cp_destroy(dec->cp);
1905 jas_free(dec->cmpts);
1909 jas_free(dec->tiles);
1915 /******************************************************************************\
1917 \******************************************************************************/
1919 void jpc_seglist_insert(jpc_dec_seglist_t *list, jpc_dec_seg_t *ins, jpc_dec_seg_t *node)
1921 jpc_dec_seg_t *prev;
1922 jpc_dec_seg_t *next;
1926 next = prev ? (prev->next) : 0;
1941 void jpc_seglist_remove(jpc_dec_seglist_t *list, jpc_dec_seg_t *seg)
1943 jpc_dec_seg_t *prev;
1944 jpc_dec_seg_t *next;
1962 jpc_dec_seg_t *jpc_seg_alloc()
1966 if (!(seg = jas_malloc(sizeof(jpc_dec_seg_t)))) {
1974 seg->type = JPC_SEG_INVALID;
1982 void jpc_seg_destroy(jpc_dec_seg_t *seg)
1985 jas_stream_close(seg->stream);
1990 static int jpc_dec_dump(jpc_dec_t *dec, FILE *out)
1992 jpc_dec_tile_t *tile;
1994 jpc_dec_tcomp_t *tcomp;
1996 jpc_dec_rlvl_t *rlvl;
1998 jpc_dec_band_t *band;
2002 jpc_dec_cblk_t *cblk;
2005 for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles;
2007 for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
2008 ++compno, ++tcomp) {
2009 for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno <
2010 tcomp->numrlvls; ++rlvlno, ++rlvl) {
2011 fprintf(out, "RESOLUTION LEVEL %d\n", rlvlno);
2012 fprintf(out, "xs =%d, ys = %d, xe = %d, ye = %d, w = %d, h = %d\n",
2013 rlvl->xstart, rlvl->ystart, rlvl->xend, rlvl->yend, rlvl->xend -
2014 rlvl->xstart, rlvl->yend - rlvl->ystart);
2015 for (bandno = 0, band = rlvl->bands;
2016 bandno < rlvl->numbands; ++bandno, ++band) {
2017 fprintf(out, "BAND %d\n", bandno);
2018 fprintf(out, "xs =%d, ys = %d, xe = %d, ye = %d, w = %d, h = %d\n",
2019 jas_seq2d_xstart(band->data), jas_seq2d_ystart(band->data), jas_seq2d_xend(band->data),
2020 jas_seq2d_yend(band->data), jas_seq2d_xend(band->data) - jas_seq2d_xstart(band->data),
2021 jas_seq2d_yend(band->data) - jas_seq2d_ystart(band->data));
2022 for (prcno = 0, prc = band->prcs;
2023 prcno < rlvl->numprcs; ++prcno,
2025 fprintf(out, "CODE BLOCK GROUP %d\n", prcno);
2026 fprintf(out, "xs =%d, ys = %d, xe = %d, ye = %d, w = %d, h = %d\n",
2027 prc->xstart, prc->ystart, prc->xend, prc->yend, prc->xend -
2028 prc->xstart, prc->yend - prc->ystart);
2029 for (cblkno = 0, cblk =
2030 prc->cblks; cblkno <
2031 prc->numcblks; ++cblkno,
2033 fprintf(out, "CODE BLOCK %d\n", cblkno);
2034 fprintf(out, "xs =%d, ys = %d, xe = %d, ye = %d, w = %d, h = %d\n",
2035 jas_seq2d_xstart(cblk->data), jas_seq2d_ystart(cblk->data), jas_seq2d_xend(cblk->data),
2036 jas_seq2d_yend(cblk->data), jas_seq2d_xend(cblk->data) - jas_seq2d_xstart(cblk->data),
2037 jas_seq2d_yend(cblk->data) - jas_seq2d_ystart(cblk->data));
2048 jpc_streamlist_t *jpc_streamlist_create()
2050 jpc_streamlist_t *streamlist;
2053 if (!(streamlist = jas_malloc(sizeof(jpc_streamlist_t)))) {
2056 streamlist->numstreams = 0;
2057 streamlist->maxstreams = 100;
2058 if (!(streamlist->streams = jas_malloc(streamlist->maxstreams *
2059 sizeof(jas_stream_t *)))) {
2060 jas_free(streamlist);
2063 for (i = 0; i < streamlist->maxstreams; ++i) {
2064 streamlist->streams[i] = 0;
2069 int jpc_streamlist_insert(jpc_streamlist_t *streamlist, int streamno,
2070 jas_stream_t *stream)
2072 jas_stream_t **newstreams;
2075 /* Grow the array of streams if necessary. */
2076 if (streamlist->numstreams >= streamlist->maxstreams) {
2077 newmaxstreams = streamlist->maxstreams + 1024;
2078 if (!(newstreams = jas_realloc(streamlist->streams,
2079 (newmaxstreams + 1024) * sizeof(jas_stream_t *)))) {
2082 for (i = streamlist->numstreams; i < streamlist->maxstreams; ++i) {
2083 streamlist->streams[i] = 0;
2085 streamlist->maxstreams = newmaxstreams;
2086 streamlist->streams = newstreams;
2088 if (streamno != streamlist->numstreams) {
2089 /* Can only handle insertion at start of list. */
2092 streamlist->streams[streamno] = stream;
2093 ++streamlist->numstreams;
2097 jas_stream_t *jpc_streamlist_remove(jpc_streamlist_t *streamlist, int streamno)
2099 jas_stream_t *stream;
2101 if (streamno >= streamlist->numstreams) {
2104 stream = streamlist->streams[streamno];
2105 for (i = streamno + 1; i < streamlist->numstreams; ++i) {
2106 streamlist->streams[i - 1] = streamlist->streams[i];
2108 --streamlist->numstreams;
2112 void jpc_streamlist_destroy(jpc_streamlist_t *streamlist)
2115 if (streamlist->streams) {
2116 for (streamno = 0; streamno < streamlist->numstreams;
2118 jas_stream_close(streamlist->streams[streamno]);
2120 jas_free(streamlist->streams);
2122 jas_free(streamlist);
2125 jas_stream_t *jpc_streamlist_get(jpc_streamlist_t *streamlist, int streamno)
2127 assert(streamno < streamlist->numstreams);
2128 return streamlist->streams[streamno];
2131 int jpc_streamlist_numstreams(jpc_streamlist_t *streamlist)
2133 return streamlist->numstreams;
2136 jpc_ppxstab_t *jpc_ppxstab_create()
2140 if (!(tab = jas_malloc(sizeof(jpc_ppxstab_t)))) {
2149 void jpc_ppxstab_destroy(jpc_ppxstab_t *tab)
2152 for (i = 0; i < tab->numents; ++i) {
2153 jpc_ppxstabent_destroy(tab->ents[i]);
2156 jas_free(tab->ents);
2161 int jpc_ppxstab_grow(jpc_ppxstab_t *tab, int maxents)
2163 jpc_ppxstabent_t **newents;
2164 if (tab->maxents < maxents) {
2165 newents = (tab->ents) ? jas_realloc(tab->ents, maxents *
2166 sizeof(jpc_ppxstabent_t *)) : jas_malloc(maxents * sizeof(jpc_ppxstabent_t *));
2170 tab->ents = newents;
2171 tab->maxents = maxents;
2176 int jpc_ppxstab_insert(jpc_ppxstab_t *tab, jpc_ppxstabent_t *ent)
2181 for (i = 0; i < tab->numents; ++i) {
2182 if (tab->ents[i]->ind > ent->ind) {
2188 if (tab->numents >= tab->maxents) {
2189 if (jpc_ppxstab_grow(tab, tab->maxents + 128)) {
2194 for (i = tab->numents; i > inspt; --i) {
2195 tab->ents[i] = tab->ents[i - 1];
2203 jpc_streamlist_t *jpc_ppmstabtostreams(jpc_ppxstab_t *tab)
2205 jpc_streamlist_t *streams;
2207 uint_fast32_t datacnt;
2208 uint_fast32_t tpcnt;
2209 jpc_ppxstabent_t *ent;
2211 jas_stream_t *stream;
2214 if (!(streams = jpc_streamlist_create())) {
2218 if (!tab->numents) {
2223 ent = tab->ents[entno];
2224 dataptr = ent->data;
2228 /* Get the length of the packet header data for the current
2233 if (!(stream = jas_stream_memopen(0, 0))) {
2236 if (jpc_streamlist_insert(streams, jpc_streamlist_numstreams(streams),
2240 tpcnt = (dataptr[0] << 24) | (dataptr[1] << 16) | (dataptr[2] << 8)
2245 /* Get the packet header data for the current tile-part. */
2248 if (++entno >= tab->numents) {
2251 ent = tab->ents[entno];
2252 dataptr = ent->data;
2255 n = JAS_MIN(tpcnt, datacnt);
2256 if (jas_stream_write(stream, dataptr, n) != n) {
2263 jas_stream_rewind(stream);
2265 if (++entno >= tab->numents) {
2268 ent = tab->ents[entno];
2269 dataptr = ent->data;
2277 jpc_streamlist_destroy(streams);
2281 int jpc_pptstabwrite(jas_stream_t *out, jpc_ppxstab_t *tab)
2284 jpc_ppxstabent_t *ent;
2285 for (i = 0; i < tab->numents; ++i) {
2287 if (jas_stream_write(out, ent->data, ent->len) != JAS_CAST(int, ent->len)) {
2294 jpc_ppxstabent_t *jpc_ppxstabent_create()
2296 jpc_ppxstabent_t *ent;
2297 if (!(ent = jas_malloc(sizeof(jpc_ppxstabent_t)))) {
2306 void jpc_ppxstabent_destroy(jpc_ppxstabent_t *ent)
2309 jas_free(ent->data);