src/gdcmjasper/src/libjasper/jpc/jpc_dec.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) 1999-2000 Image Power, Inc.
  13  * Copyright (c) 1999-2000 The University of British Columbia
  14  * Copyright (c) 2001-2003 Michael David Adams
  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  * $Id: jpc_dec.c,v 1.1 2005/05/22 18:33:04 malaterre Exp $
  66  */
  67
  68 /******************************************************************************\
  69 * Includes.
  70 \******************************************************************************/
  71
  72 #include <stdio.h>
  73 #include <stdlib.h>
  74 #include <assert.h>
  75
  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"
  81
  82 #include "jpc_fix.h"
  83 #include "jpc_dec.h"
  84 #include "jpc_cs.h"
  85 #include "jpc_mct.h"
  86 #include "jpc_t2dec.h"
  87 #include "jpc_t1dec.h"
  88 #include "jpc_math.h"
  89
  90 /******************************************************************************\
  91 *
  92 \******************************************************************************/
  93
  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. */
  98 #define  JPC_MH    0x0004
  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. */
 106
 107 typedef struct {
 108
 109   uint_fast16_t id;
 110   /* The marker segment type. */
 111
 112   int validstates;
 113   /* The states in which this type of marker segment can be
 114     validly encountered. */
 115
 116   int (*action)(jpc_dec_t *dec, jpc_ms_t *ms);
 117   /* The action to take upon encountering this type of marker segment. */
 118
 119 } jpc_dec_mstabent_t;
 120
 121 /******************************************************************************\
 122 *
 123 \******************************************************************************/
 124
 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
 133
 134 /******************************************************************************\
 135 * Local function prototypes.
 136 \******************************************************************************/
 137
 138 static int jpc_dec_dump(jpc_dec_t *dec, FILE *out);
 139
 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);
 148
 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);
 156
 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);
 174
 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);
 201
 202 static jpc_dec_mstabent_t *jpc_dec_mstab_lookup(uint_fast16_t id);
 203
 204 /******************************************************************************\
 205 * Global data.
 206 \******************************************************************************/
 207
 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},
 225   {JPC_MS_SOP, 0, 0},
 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}
 229 };
 230
 231 /******************************************************************************\
 232 * The main entry point for the JPEG-2000 decoder.
 233 \******************************************************************************/
 234
 235 jas_image_t *jpc_decode(jas_stream_t *in, char *optstr)
 236 {
 237   jpc_dec_importopts_t opts;
 238   jpc_dec_t *dec;
 239   jas_image_t *image;
 240
 241   dec = 0;
 242
 243   if (jpc_dec_parseopts(optstr, &opts)) {
 244     goto error;
 245   }
 246
 247   jpc_initluts();
 248
 249   if (!(dec = jpc_dec_create(&opts, in))) {
 250     goto error;
 251   }
 252
 253   /* Do most of the work. */
 254   if (jpc_dec_decode(dec)) {
 255     goto error;
 256   }
 257
 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));
 266   } else {
 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));
 270   }
 271
 272   /* Save the return value. */
 273   image = dec->image;
 274
 275   /* Stop the image from being discarded. */
 276   dec->image = 0;
 277
 278   /* Destroy decoder. */
 279   jpc_dec_destroy(dec);
 280
 281   return image;
 282
 283 error:
 284   if (dec) {
 285     jpc_dec_destroy(dec);
 286   }
 287   return 0;
 288 }
 289
 290 typedef enum {
 291   OPT_MAXLYRS,
 292   OPT_MAXPKTS,
 293   OPT_DEBUG
 294 } optid_t;
 295
 296 jas_taginfo_t decopts[] = {
 297   {OPT_MAXLYRS, "maxlyrs"},
 298   {OPT_MAXPKTS, "maxpkts"},
 299   {OPT_DEBUG, "debug"},
 300   {-1, 0}
 301 };
 302
 303 static int jpc_dec_parseopts(char *optstr, jpc_dec_importopts_t *opts)
 304 {
 305   jas_tvparser_t *tvp;
 306
 307   opts->debug = 0;
 308   opts->maxlyrs = JPC_MAXLYRS;
 309   opts->maxpkts = -1;
 310
 311   if (!(tvp = jas_tvparser_create(optstr ? optstr : ""))) {
 312     return -1;
 313   }
 314
 315   while (!jas_tvparser_next(tvp)) {
 316     switch (jas_taginfo_nonull(jas_taginfos_lookup(decopts,
 317       jas_tvparser_gettag(tvp)))->id) {
 318     case OPT_MAXLYRS:
 319       opts->maxlyrs = atoi(jas_tvparser_getval(tvp));
 320       break;
 321     case OPT_DEBUG:
 322       opts->debug = atoi(jas_tvparser_getval(tvp));
 323       break;
 324     case OPT_MAXPKTS:
 325       opts->maxpkts = atoi(jas_tvparser_getval(tvp));
 326       break;
 327     default:
 328       fprintf(stderr, "warning: ignoring invalid option %s\n",
 329         jas_tvparser_gettag(tvp));
 330       break;
 331     }
 332   }
 333
 334   jas_tvparser_destroy(tvp);
 335
 336   return 0;
 337 }
 338
 339 /******************************************************************************\
 340 * Code for table-driven code stream decoder.
 341 \******************************************************************************/
 342
 343 static jpc_dec_mstabent_t *jpc_dec_mstab_lookup(uint_fast16_t id)
 344 {
 345   jpc_dec_mstabent_t *mstabent;
 346   for (mstabent = jpc_dec_mstab; mstabent->id != 0; ++mstabent) {
 347     if (mstabent->id == id) {
 348       break;
 349     }
 350   }
 351   return mstabent;
 352 }
 353
 354 static int jpc_dec_decode(jpc_dec_t *dec)
 355 {
 356   jpc_ms_t *ms;
 357   jpc_dec_mstabent_t *mstabent;
 358   int ret;
 359   jpc_cstate_t *cstate;
 360
 361   if (!(cstate = jpc_cstate_create())) {
 362     return -1;
 363   }
 364   dec->cstate = cstate;
 365
 366   /* Initially, we should expect to encounter a SOC marker segment. */
 367   dec->state = JPC_MHSOC;
 368
 369   for (;;) {
 370
 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");
 374       return -1;
 375     }
 376
 377     mstabent = jpc_dec_mstab_lookup(ms->id);
 378     assert(mstabent);
 379
 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");
 384       jpc_ms_destroy(ms);
 385       return -1;
 386     }
 387
 388     /* Process the marker segment. */
 389     if (mstabent->action) {
 390       ret = (*mstabent->action)(dec, ms);
 391     } else {
 392       /* No explicit action is required. */
 393       ret = 0;
 394     }
 395
 396     /* Destroy the marker segment. */
 397     jpc_ms_destroy(ms);
 398
 399     if (ret < 0) {
 400       return -1;
 401     } else if (ret > 0) {
 402       break;
 403     }
 404
 405   }
 406
 407   return 0;
 408 }
 409
 410 static int jpc_dec_process_crg(jpc_dec_t *dec, jpc_ms_t *ms)
 411 {
 412   int cmptno;
 413   jpc_dec_cmpt_t *cmpt;
 414   jpc_crg_t *crg;
 415
 416   crg = &ms->parms.crg;
 417   for (cmptno = 0, cmpt = dec->cmpts; cmptno < dec->numcomps; ++cmptno,
 418     ++cmpt) {
 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
 422       are uncommented.
 423     cmpt->hsubstep = crg->comps[cmptno].hoff;
 424     cmpt->vsubstep = crg->comps[cmptno].voff;
 425     */
 426   }
 427   return 0;
 428 }
 429
 430 static int jpc_dec_process_soc(jpc_dec_t *dec, jpc_ms_t *ms)
 431 {
 432   /* Eliminate warnings about unused variables. */
 433   ms = 0;
 434
 435   /* We should expect to encounter a SIZ marker segment next. */
 436   dec->state = JPC_MHSIZ;
 437
 438   return 0;
 439 }
 440
 441 static int jpc_dec_process_sot(jpc_dec_t *dec, jpc_ms_t *ms)
 442 {
 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;
 448   int cmptno;
 449
 450   if (dec->state == JPC_MH) {
 451
 452     compinfos = jas_malloc(dec->numcomps * sizeof(jas_image_cmptparm_t));
 453     assert(compinfos);
 454     for (cmptno = 0, cmpt = dec->cmpts, compinfo = compinfos;
 455       cmptno < dec->numcomps; ++cmptno, ++cmpt, ++compinfo) {
 456       compinfo->tlx = 0;
 457       compinfo->tly = 0;
 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;
 464     }
 465
 466     if (!(dec->image = jas_image_create(dec->numcomps, compinfos,
 467       JAS_CLRSPC_UNKNOWN))) {
 468       return -1;
 469     }
 470     jas_free(compinfos);
 471
 472     /* Is the packet header information stored in PPM marker segments in
 473       the main header? */
 474     if (dec->ppmstab) {
 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))) {
 478         abort();
 479       }
 480       jpc_ppxstab_destroy(dec->ppmstab);
 481       dec->ppmstab = 0;
 482     }
 483   }
 484
 485   if (sot->len > 0) {
 486     dec->curtileendoff = jas_stream_getrwcount(dec->in) - ms->len -
 487       4 + sot->len;
 488   } else {
 489     dec->curtileendoff = 0;
 490   }
 491
 492   if (JAS_CAST(int, sot->tileno) > dec->numtiles) {
 493     fprintf(stderr, "invalid tile number in SOT marker segment\n");
 494     return -1;
 495   }
 496   /* Set the current tile. */
 497   dec->curtile = &dec->tiles[sot->tileno];
 498   tile = dec->curtile;
 499   /* Ensure that this is the expected part number. */
 500   if (sot->partno != tile->partno) {
 501     return -1;
 502   }
 503   if (tile->numparts > 0 && sot->partno >= tile->numparts) {
 504     return -1;
 505   }
 506   if (!tile->numparts && sot->numparts > 0) {
 507     tile->numparts = sot->numparts;
 508   }
 509
 510   tile->pptstab = 0;
 511
 512   switch (tile->state) {
 513   case JPC_TILE_INIT:
 514     /* This is the first tile-part for this tile. */
 515     tile->state = JPC_TILE_ACTIVE;
 516     assert(!tile->cp);
 517     if (!(tile->cp = jpc_dec_cp_copy(dec->cp))) {
 518       return -1;
 519     }
 520     jpc_dec_cp_resetflags(dec->cp);
 521     break;
 522   default:
 523     if (sot->numparts == sot->partno - 1) {
 524       tile->state = JPC_TILE_ACTIVELAST;
 525     }
 526     break;
 527   }
 528
 529   /* Note: We do not increment the expected tile-part number until
 530     all processing for this tile-part is complete. */
 531
 532   /* We should expect to encounter other tile-part header marker
 533     segments next. */
 534   dec->state = JPC_TPH;
 535
 536   return 0;
 537 }
 538
 539 static int jpc_dec_process_sod(jpc_dec_t *dec, jpc_ms_t *ms)
 540 {
 541   jpc_dec_tile_t *tile;
 542   int pos;
 543
 544   /* Eliminate compiler warnings about unused variables. */
 545   ms = 0;
 546
 547   if (!(tile = dec->curtile)) {
 548     return -1;
 549   }
 550
 551   if (!tile->partno) {
 552     if (!jpc_dec_cp_isvalid(tile->cp)) {
 553       return -1;
 554     }
 555     jpc_dec_cp_prepare(tile->cp);
 556     if (jpc_dec_tileinit(dec, tile)) {
 557       return -1;
 558     }
 559   }
 560
 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
 564       tile-part. */
 565     if (!(tile->pkthdrstream = jpc_streamlist_remove(dec->pkthdrstreams, 0))) {
 566       return -1;
 567     }
 568   }
 569
 570   if (tile->pptstab) {
 571     if (!tile->pkthdrstream) {
 572       if (!(tile->pkthdrstream = jas_stream_memopen(0, 0))) {
 573         return -1;
 574       }
 575     }
 576     pos = jas_stream_tell(tile->pkthdrstream);
 577     jas_stream_seek(tile->pkthdrstream, 0, SEEK_END);
 578     if (jpc_pptstabwrite(tile->pkthdrstream, tile->pptstab)) {
 579       return -1;
 580     }
 581     jas_stream_seek(tile->pkthdrstream, pos, SEEK_SET);
 582     jpc_ppxstab_destroy(tile->pptstab);
 583     tile->pptstab = 0;
 584   }
 585
 586   if (jas_getdbglevel() >= 10) {
 587     jpc_dec_dump(dec, stderr);
 588   }
 589
 590   if (jpc_dec_decodepkts(dec, (tile->pkthdrstream) ? tile->pkthdrstream :
 591     dec->in, dec->in)) {
 592     fprintf(stderr, "jpc_dec_decodepkts failed\n");
 593     return -1;
 594   }
 595
 596   /* Gobble any unconsumed tile data. */
 597   if (dec->curtileendoff > 0) {
 598     long curoff;
 599     uint_fast32_t n;
 600     curoff = jas_stream_getrwcount(dec->in);
 601     if (curoff < dec->curtileendoff) {
 602       n = dec->curtileendoff - curoff;
 603       fprintf(stderr,
 604         "warning: ignoring trailing garbage (%lu bytes)\n",
 605         (unsigned long) n);
 606
 607       while (n-- > 0) {
 608         if (jas_stream_getc(dec->in) == EOF) {
 609           fprintf(stderr, "read error\n");
 610           return -1;
 611         }
 612       }
 613     } else if (curoff > dec->curtileendoff) {
 614       fprintf(stderr,
 615         "warning: not enough tile data (%lu bytes)\n",
 616         (unsigned long) curoff - dec->curtileendoff);
 617     }
 618
 619   }
 620
 621   if (tile->numparts > 0 && tile->partno == tile->numparts - 1) {
 622     if (jpc_dec_tiledecode(dec, tile)) {
 623       return -1;
 624     }
 625     jpc_dec_tilefini(dec, tile);
 626   }
 627
 628   dec->curtile = 0;
 629
 630   /* Increment the expected tile-part number. */
 631   ++tile->partno;
 632
 633   /* We should expect to encounter a SOT marker segment next. */
 634   dec->state = JPC_TPHSOT;
 635
 636   return 0;
 637 }
 638
 639 static int jpc_dec_tileinit(jpc_dec_t *dec, jpc_dec_tile_t *tile)
 640 {
 641   jpc_dec_tcomp_t *tcomp;
 642   int compno;
 643   int rlvlno;
 644   jpc_dec_rlvl_t *rlvl;
 645   jpc_dec_band_t *band;
 646   jpc_dec_prc_t *prc;
 647   int bndno;
 648   jpc_tsfb_band_t *bnd;
 649   int bandno;
 650   jpc_dec_ccp_t *ccp;
 651   int prccnt;
 652   jpc_dec_cblk_t *cblk;
 653   int cblkcnt;
 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;
 678   jpc_dec_cp_t *cp;
 679   jpc_tsfb_band_t bnds[64];
 680   jpc_pchg_t *pchg;
 681   int pchgno;
 682   jpc_dec_cmpt_t *cmpt;
 683
 684   cp = tile->cp;
 685   tile->realmode = 0;
 686   if (cp->mctid == JPC_MCT_ICT) {
 687     tile->realmode = 1;
 688   }
 689
 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) {
 694       tile->realmode = 1;
 695     }
 696     tcomp->numrlvls = ccp->numrlvls;
 697     if (!(tcomp->rlvls = jas_malloc(tcomp->numrlvls *
 698       sizeof(jpc_dec_rlvl_t)))) {
 699       return -1;
 700     }
 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,
 704       cmpt->vstep)))) {
 705       return -1;
 706     }
 707     if (!(tcomp->tsfb = jpc_cod_gettsfb(ccp->qmfbid,
 708       tcomp->numrlvls - 1))) {
 709       return -1;
 710     }
 711 {
 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);
 713 }
 714     for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
 715       ++rlvlno, ++rlvl) {
 716 rlvl->bands = 0;
 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) >>
 736         rlvl->prcwidthexpn;
 737       rlvl->numvprcs = (brprcyend - tlprcystart) >>
 738         rlvl->prcheightexpn;
 739       rlvl->numprcs = rlvl->numhprcs * rlvl->numvprcs;
 740
 741       if (rlvl->xstart >= rlvl->xend || rlvl->ystart >= rlvl->yend) {
 742         rlvl->bands = 0;
 743         rlvl->numprcs = 0;
 744         rlvl->numhprcs = 0;
 745         rlvl->numvprcs = 0;
 746         continue;
 747       }
 748       if (!rlvlno) {
 749         tlcbgxstart = tlprcxstart;
 750         tlcbgystart = tlprcystart;
 751         brcbgxend = brprcxend;
 752         brcbgyend = brprcyend;
 753         rlvl->cbgwidthexpn = rlvl->prcwidthexpn;
 754         rlvl->cbgheightexpn = rlvl->prcheightexpn;
 755       } else {
 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;
 762       }
 763       rlvl->cblkwidthexpn = JAS_MIN(ccp->cblkwidthexpn,
 764         rlvl->cbgwidthexpn);
 765       rlvl->cblkheightexpn = JAS_MIN(ccp->cblkheightexpn,
 766         rlvl->cbgheightexpn);
 767
 768       rlvl->numbands = (!rlvlno) ? 1 : 3;
 769       if (!(rlvl->bands = jas_malloc(rlvl->numbands *
 770         sizeof(jpc_dec_band_t)))) {
 771         return -1;
 772       }
 773       for (bandno = 0, band = rlvl->bands;
 774         bandno < rlvl->numbands; ++bandno, ++band) {
 775         bndno = (!rlvlno) ? 0 : (3 * (rlvlno - 1) +
 776           bandno + 1);
 777         bnd = &bnds[bndno];
 778
 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;
 789         band->data = 0;
 790         band->prcs = 0;
 791         if (bnd->xstart == bnd->xend || bnd->ystart == bnd->yend) {
 792           continue;
 793         }
 794         if (!(band->data = jas_seq2d_create(0, 0, 0, 0))) {
 795           return -1;
 796         }
 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);
 799
 800         assert(rlvl->numprcs);
 801
 802         if (!(band->prcs = jas_malloc(rlvl->numprcs * sizeof(jpc_dec_prc_t)))) {
 803           return -1;
 804         }
 805
 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) >>
 827         rlvl->cblkwidthexpn;
 828       prc->numvcblks = (brcblkyend - tlcblkystart) >>
 829         rlvl->cblkheightexpn;
 830       prc->numcblks = prc->numhcblks * prc->numvcblks;
 831       assert(prc->numcblks > 0);
 832
 833       if (!(prc->incltagtree = jpc_tagtree_create(prc->numhcblks, prc->numvcblks))) {
 834         return -1;
 835       }
 836       if (!(prc->numimsbstagtree = jpc_tagtree_create(prc->numhcblks, prc->numvcblks))) {
 837         return -1;
 838       }
 839       if (!(prc->cblks = jas_malloc(prc->numcblks * sizeof(jpc_dec_cblk_t)))) {
 840         return -1;
 841       }
 842
 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;
 854           cblk->mqdec = 0;
 855           cblk->nulldec = 0;
 856           cblk->flags = 0;
 857           cblk->numpasses = 0;
 858           cblk->segs.head = 0;
 859           cblk->segs.tail = 0;
 860           cblk->curseg = 0;
 861           cblk->numimsbs = 0;
 862           cblk->numlenbits = 3;
 863           cblk->flags = 0;
 864           if (!(cblk->data = jas_seq2d_create(0, 0, 0, 0))) {
 865             return -1;
 866           }
 867           jas_seq2d_bindsub(cblk->data, band->data, tmpxstart, tmpystart, tmpxend, tmpyend);
 868           ++cblk;
 869           --cblkcnt;
 870         }
 871         cblkxstart += 1 << rlvl->cblkwidthexpn;
 872         if (cblkxstart >= cbgxend) {
 873           cblkxstart = cbgxstart;
 874           cblkystart += 1 << rlvl->cblkheightexpn;
 875         }
 876       }
 877
 878     } else {
 879       prc->cblks = 0;
 880       prc->incltagtree = 0;
 881       prc->numimsbstagtree = 0;
 882     }
 883     cbgxstart += 1 << rlvl->cbgwidthexpn;
 884     if (cbgxstart >= brcbgxend) {
 885       cbgxstart = tlcbgxstart;
 886       cbgystart += 1 << rlvl->cbgheightexpn;
 887     }
 888
 889   }
 890 /********************************************/
 891       }
 892     }
 893   }
 894
 895 if (!(tile->pi = jpc_dec_pi_create(dec, tile)))
 896 {
 897   return -1;
 898 }
 899
 900   for (pchgno = 0; pchgno < jpc_pchglist_numpchgs(tile->cp->pchglist);
 901     ++pchgno) {
 902     pchg = jpc_pchg_copy(jpc_pchglist_get(tile->cp->pchglist, pchgno));
 903     assert(pchg);
 904     jpc_pi_addpchg(tile->pi, pchg);
 905   }
 906   jpc_pi_init(tile->pi);
 907
 908   return 0;
 909 }
 910
 911 static int jpc_dec_tilefini(jpc_dec_t *dec, jpc_dec_tile_t *tile)
 912 {
 913   jpc_dec_tcomp_t *tcomp;
 914   int compno;
 915   int bandno;
 916   int rlvlno;
 917   jpc_dec_band_t *band;
 918   jpc_dec_rlvl_t *rlvl;
 919   int prcno;
 920   jpc_dec_prc_t *prc;
 921   jpc_dec_seg_t *seg;
 922   jpc_dec_cblk_t *cblk;
 923   int cblkno;
 924
 925 if (tile->tcomps) {
 926
 927   for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
 928     ++compno, ++tcomp) {
 929     for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
 930       ++rlvlno, ++rlvl) {
 931 if (!rlvl->bands) {
 932   continue;
 933 }
 934       for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; ++bandno, ++band) {
 935 if (band->prcs) {
 936         for (prcno = 0, prc = band->prcs; prcno <
 937           rlvl->numprcs; ++prcno, ++prc) {
 938 if (!prc->cblks) {
 939   continue;
 940 }
 941           for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; ++cblkno, ++cblk) {
 942
 943   while (cblk->segs.head) {
 944     seg = cblk->segs.head;
 945     jpc_seglist_remove(&cblk->segs, seg);
 946     jpc_seg_destroy(seg);
 947   }
 948   jas_matrix_destroy(cblk->data);
 949   if (cblk->mqdec) {
 950     jpc_mqdec_destroy(cblk->mqdec);
 951   }
 952   if (cblk->nulldec) {
 953     jpc_bitstream_close(cblk->nulldec);
 954   }
 955   if (cblk->flags) {
 956     jas_matrix_destroy(cblk->flags);
 957   }
 958           }
 959           if (prc->incltagtree) {
 960             jpc_tagtree_destroy(prc->incltagtree);
 961           }
 962           if (prc->numimsbstagtree) {
 963             jpc_tagtree_destroy(prc->numimsbstagtree);
 964           }
 965           if (prc->cblks) {
 966             jas_free(prc->cblks);
 967           }
 968         }
 969 }
 970         if (band->data) {
 971           jas_matrix_destroy(band->data);
 972         }
 973         if (band->prcs) {
 974           jas_free(band->prcs);
 975         }
 976       }
 977       if (rlvl->bands) {
 978         jas_free(rlvl->bands);
 979       }
 980     }
 981     if (tcomp->rlvls) {
 982       jas_free(tcomp->rlvls);
 983     }
 984     if (tcomp->data) {
 985       jas_matrix_destroy(tcomp->data);
 986     }
 987     if (tcomp->tsfb) {
 988       jpc_tsfb_destroy(tcomp->tsfb);
 989     }
 990   }
 991 }
 992   if (tile->cp) {
 993     jpc_dec_cp_destroy(tile->cp);
 994     tile->cp = 0;
 995   }
 996   if (tile->tcomps) {
 997     jas_free(tile->tcomps);
 998     tile->tcomps = 0;
 999   }
1000   if (tile->pi) {
1001     jpc_pi_destroy(tile->pi);
1002     tile->pi = 0;
1003   }
1004   if (tile->pkthdrstream) {
1005     jas_stream_close(tile->pkthdrstream);
1006     tile->pkthdrstream = 0;
1007   }
1008   if (tile->pptstab) {
1009     jpc_ppxstab_destroy(tile->pptstab);
1010     tile->pptstab = 0;
1011   }
1012
1013   tile->state = JPC_TILE_DONE;
1014
1015   return 0;
1016 }
1017
1018 static int jpc_dec_tiledecode(jpc_dec_t *dec, jpc_dec_tile_t *tile)
1019 {
1020   int i;
1021   int j;
1022   jpc_dec_tcomp_t *tcomp;
1023   jpc_dec_rlvl_t *rlvl;
1024   jpc_dec_band_t *band;
1025   int compno;
1026   int rlvlno;
1027   int bandno;
1028   int adjust;
1029   int v;
1030   jpc_dec_ccp_t *ccp;
1031   jpc_dec_cmpt_t *cmpt;
1032
1033   if (jpc_dec_decodecblks(dec, tile)) {
1034     fprintf(stderr, "jpc_dec_decodecblks failed\n");
1035     return -1;
1036   }
1037
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;
1043       ++rlvlno, ++rlvl) {
1044       if (!rlvl->bands) {
1045         continue;
1046       }
1047       for (bandno = 0, band = rlvl->bands;
1048         bandno < rlvl->numbands; ++bandno, ++band) {
1049         if (!band->data) {
1050           continue;
1051         }
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);
1057         }
1058
1059       }
1060     }
1061   }
1062
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);
1069   }
1070
1071
1072   /* Apply an inverse intercomponent transform if necessary. */
1073   switch (tile->cp->mctid) {
1074   case JPC_MCT_RCT:
1075     assert(dec->numcomps == 3);
1076     jpc_irct(tile->tcomps[0].data, tile->tcomps[1].data,
1077       tile->tcomps[2].data);
1078     break;
1079   case JPC_MCT_ICT:
1080     assert(dec->numcomps == 3);
1081     jpc_iict(tile->tcomps[0].data, tile->tcomps[1].data,
1082       tile->tcomps[2].data);
1083     break;
1084   }
1085
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));
1095         }
1096       }
1097     }
1098   }
1099
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;
1107       }
1108     }
1109   }
1110
1111   /* Perform clipping. */
1112   for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
1113     dec->numcomps; ++compno, ++tcomp, ++cmpt) {
1114     jpc_fix_t mn;
1115     jpc_fix_t mx;
1116     mn = cmpt->sgnd ? (-(1 << (cmpt->prec - 1))) : (0);
1117     mx = cmpt->sgnd ? ((1 << (cmpt->prec - 1)) - 1) : ((1 <<
1118       cmpt->prec) - 1);
1119     jas_matrix_clip(tcomp->data, mn, mx);
1120   }
1121
1122   /* XXX need to free tsfb struct */
1123
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");
1132       return -4;
1133     }
1134   }
1135
1136   return 0;
1137 }
1138
1139 static int jpc_dec_process_eoc(jpc_dec_t *dec, jpc_ms_t *ms)
1140 {
1141   int tileno;
1142   jpc_dec_tile_t *tile;
1143
1144   /* Eliminate compiler warnings about unused variables. */
1145   ms = 0;
1146
1147   for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
1148     ++tile) {
1149     if (tile->state == JPC_TILE_ACTIVE) {
1150       if (jpc_dec_tiledecode(dec, tile)) {
1151         return -1;
1152       }
1153     }
1154     jpc_dec_tilefini(dec, tile);
1155   }
1156
1157   /* We are done processing the code stream. */
1158   dec->state = JPC_MT;
1159
1160   return 1;
1161 }
1162
1163 static int jpc_dec_process_siz(jpc_dec_t *dec, jpc_ms_t *ms)
1164 {
1165   jpc_siz_t *siz = &ms->parms.siz;
1166   int compno;
1167   int tileno;
1168   jpc_dec_tile_t *tile;
1169   jpc_dec_tcomp_t *tcomp;
1170   int htileno;
1171   int vtileno;
1172   jpc_dec_cmpt_t *cmpt;
1173
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))) {
1184     return -1;
1185   }
1186
1187   if (!(dec->cmpts = jas_malloc(dec->numcomps * sizeof(jpc_dec_cmpt_t)))) {
1188     return -1;
1189   }
1190
1191   for (compno = 0, cmpt = dec->cmpts; compno < dec->numcomps; ++compno,
1192     ++cmpt) {
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);
1201     cmpt->hsubstep = 0;
1202     cmpt->vsubstep = 0;
1203   }
1204
1205   dec->image = 0;
1206
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)))) {
1211     return -1;
1212   }
1213
1214   for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
1215     ++tile) {
1216     htileno = tileno % dec->numhtiles;
1217     vtileno = tileno / dec->numhtiles;
1218     tile->realmode = 0;
1219     tile->state = JPC_TILE_INIT;
1220     tile->xstart = JAS_MAX(dec->tilexoff + htileno * dec->tilewidth,
1221       dec->xstart);
1222     tile->ystart = JAS_MAX(dec->tileyoff + vtileno * dec->tileheight,
1223       dec->ystart);
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);
1228     tile->numparts = 0;
1229     tile->partno = 0;
1230     tile->pkthdrstream = 0;
1231     tile->pkthdrstreampos = 0;
1232     tile->pptstab = 0;
1233     tile->cp = 0;
1234     if (!(tile->tcomps = jas_malloc(dec->numcomps *
1235       sizeof(jpc_dec_tcomp_t)))) {
1236       return -1;
1237     }
1238     for (compno = 0, cmpt = dec->cmpts, tcomp = tile->tcomps;
1239       compno < dec->numcomps; ++compno, ++cmpt, ++tcomp) {
1240       tcomp->rlvls = 0;
1241       tcomp->data = 0;
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);
1246       tcomp->tsfb = 0;
1247     }
1248   }
1249
1250   dec->pkthdrstreams = 0;
1251
1252   /* We should expect to encounter other main header marker segments
1253     or an SOT marker segment next. */
1254   dec->state = JPC_MH;
1255
1256   return 0;
1257 }
1258
1259 static int jpc_dec_process_cod(jpc_dec_t *dec, jpc_ms_t *ms)
1260 {
1261   jpc_cod_t *cod = &ms->parms.cod;
1262   jpc_dec_tile_t *tile;
1263
1264   switch (dec->state) {
1265   case JPC_MH:
1266     jpc_dec_cp_setfromcod(dec->cp, cod);
1267     break;
1268   case JPC_TPH:
1269     if (!(tile = dec->curtile)) {
1270       return -1;
1271     }
1272     if (tile->partno != 0) {
1273       return -1;
1274     }
1275     jpc_dec_cp_setfromcod(tile->cp, cod);
1276     break;
1277   }
1278   return 0;
1279 }
1280
1281 static int jpc_dec_process_coc(jpc_dec_t *dec, jpc_ms_t *ms)
1282 {
1283   jpc_coc_t *coc = &ms->parms.coc;
1284   jpc_dec_tile_t *tile;
1285
1286   if (JAS_CAST(int, coc->compno) > dec->numcomps) {
1287     fprintf(stderr,
1288       "invalid component number in COC marker segment\n");
1289     return -1;
1290   }
1291   switch (dec->state) {
1292   case JPC_MH:
1293     jpc_dec_cp_setfromcoc(dec->cp, coc);
1294     break;
1295   case JPC_TPH:
1296     if (!(tile = dec->curtile)) {
1297       return -1;
1298     }
1299     if (tile->partno > 0) {
1300       return -1;
1301     }
1302     jpc_dec_cp_setfromcoc(tile->cp, coc);
1303     break;
1304   }
1305   return 0;
1306 }
1307
1308 static int jpc_dec_process_rgn(jpc_dec_t *dec, jpc_ms_t *ms)
1309 {
1310   jpc_rgn_t *rgn = &ms->parms.rgn;
1311   jpc_dec_tile_t *tile;
1312
1313   if (JAS_CAST(int, rgn->compno) > dec->numcomps) {
1314     fprintf(stderr,
1315       "invalid component number in RGN marker segment\n");
1316     return -1;
1317   }
1318   switch (dec->state) {
1319   case JPC_MH:
1320     jpc_dec_cp_setfromrgn(dec->cp, rgn);
1321     break;
1322   case JPC_TPH:
1323     if (!(tile = dec->curtile)) {
1324       return -1;
1325     }
1326     if (tile->partno > 0) {
1327       return -1;
1328     }
1329     jpc_dec_cp_setfromrgn(tile->cp, rgn);
1330     break;
1331   }
1332
1333   return 0;
1334 }
1335
1336 static int jpc_dec_process_qcd(jpc_dec_t *dec, jpc_ms_t *ms)
1337 {
1338   jpc_qcd_t *qcd = &ms->parms.qcd;
1339   jpc_dec_tile_t *tile;
1340
1341   switch (dec->state) {
1342   case JPC_MH:
1343     jpc_dec_cp_setfromqcd(dec->cp, qcd);
1344     break;
1345   case JPC_TPH:
1346     if (!(tile = dec->curtile)) {
1347       return -1;
1348     }
1349     if (tile->partno > 0) {
1350       return -1;
1351     }
1352     jpc_dec_cp_setfromqcd(tile->cp, qcd);
1353     break;
1354   }
1355   return 0;
1356 }
1357
1358 static int jpc_dec_process_qcc(jpc_dec_t *dec, jpc_ms_t *ms)
1359 {
1360   jpc_qcc_t *qcc = &ms->parms.qcc;
1361   jpc_dec_tile_t *tile;
1362
1363   if (JAS_CAST(int, qcc->compno) > dec->numcomps) {
1364     fprintf(stderr,
1365       "invalid component number in QCC marker segment\n");
1366     return -1;
1367   }
1368   switch (dec->state) {
1369   case JPC_MH:
1370     jpc_dec_cp_setfromqcc(dec->cp, qcc);
1371     break;
1372   case JPC_TPH:
1373     if (!(tile = dec->curtile)) {
1374       return -1;
1375     }
1376     if (tile->partno > 0) {
1377       return -1;
1378     }
1379     jpc_dec_cp_setfromqcc(tile->cp, qcc);
1380     break;
1381   }
1382   return 0;
1383 }
1384
1385 static int jpc_dec_process_poc(jpc_dec_t *dec, jpc_ms_t *ms)
1386 {
1387   jpc_poc_t *poc = &ms->parms.poc;
1388   jpc_dec_tile_t *tile;
1389   switch (dec->state) {
1390   case JPC_MH:
1391     if (jpc_dec_cp_setfrompoc(dec->cp, poc, 1)) {
1392       return -1;
1393     }
1394     break;
1395   case JPC_TPH:
1396     if (!(tile = dec->curtile)) {
1397       return -1;
1398     }
1399     if (!tile->partno) {
1400       if (jpc_dec_cp_setfrompoc(tile->cp, poc, (!tile->partno))) {
1401         return -1;
1402       }
1403     } else {
1404       jpc_pi_addpchgfrompoc(tile->pi, poc);
1405     }
1406     break;
1407   }
1408   return 0;
1409 }
1410
1411 static int jpc_dec_process_ppm(jpc_dec_t *dec, jpc_ms_t *ms)
1412 {
1413   jpc_ppm_t *ppm = &ms->parms.ppm;
1414   jpc_ppxstabent_t *ppmstabent;
1415
1416   if (!dec->ppmstab) {
1417     if (!(dec->ppmstab = jpc_ppxstab_create())) {
1418       return -1;
1419     }
1420   }
1421
1422   if (!(ppmstabent = jpc_ppxstabent_create())) {
1423     return -1;
1424   }
1425   ppmstabent->ind = ppm->ind;
1426   ppmstabent->data = ppm->data;
1427   ppm->data = 0;
1428   ppmstabent->len = ppm->len;
1429   if (jpc_ppxstab_insert(dec->ppmstab, ppmstabent)) {
1430     return -1;
1431   }
1432   return 0;
1433 }
1434
1435 static int jpc_dec_process_ppt(jpc_dec_t *dec, jpc_ms_t *ms)
1436 {
1437   jpc_ppt_t *ppt = &ms->parms.ppt;
1438   jpc_dec_tile_t *tile;
1439   jpc_ppxstabent_t *pptstabent;
1440
1441   tile = dec->curtile;
1442   if (!tile->pptstab) {
1443     if (!(tile->pptstab = jpc_ppxstab_create())) {
1444       return -1;
1445     }
1446   }
1447   if (!(pptstabent = jpc_ppxstabent_create())) {
1448     return -1;
1449   }
1450   pptstabent->ind = ppt->ind;
1451   pptstabent->data = ppt->data;
1452   ppt->data = 0;
1453   pptstabent->len = ppt->len;
1454   if (jpc_ppxstab_insert(tile->pptstab, pptstabent)) {
1455     return -1;
1456   }
1457   return 0;
1458 }
1459
1460 static int jpc_dec_process_com(jpc_dec_t *dec, jpc_ms_t *ms)
1461 {
1462   /* Eliminate compiler warnings about unused variables. */
1463   dec = 0;
1464   ms = 0;
1465
1466   return 0;
1467 }
1468
1469 static int jpc_dec_process_unk(jpc_dec_t *dec, jpc_ms_t *ms)
1470 {
1471   /* Eliminate compiler warnings about unused variables. */
1472   dec = 0;
1473
1474   fprintf(stderr, "warning: ignoring unknown marker segment\n");
1475   jpc_ms_dump(ms, stderr);
1476   return 0;
1477 }
1478
1479 /******************************************************************************\
1480 *
1481 \******************************************************************************/
1482
1483 static jpc_dec_cp_t *jpc_dec_cp_create(uint_fast16_t numcomps)
1484 {
1485   jpc_dec_cp_t *cp;
1486   jpc_dec_ccp_t *ccp;
1487   int compno;
1488
1489   if (!(cp = jas_malloc(sizeof(jpc_dec_cp_t)))) {
1490     return 0;
1491   }
1492   cp->flags = 0;
1493   cp->numcomps = numcomps;
1494   cp->prgord = 0;
1495   cp->numlyrs = 0;
1496   cp->mctid = 0;
1497   cp->csty = 0;
1498   if (!(cp->ccps = jas_malloc(cp->numcomps * sizeof(jpc_dec_ccp_t)))) {
1499     return 0;
1500   }
1501   if (!(cp->pchglist = jpc_pchglist_create())) {
1502     jas_free(cp->ccps);
1503     return 0;
1504   }
1505   for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1506     ++compno, ++ccp) {
1507     ccp->flags = 0;
1508     ccp->numrlvls = 0;
1509     ccp->cblkwidthexpn = 0;
1510     ccp->cblkheightexpn = 0;
1511     ccp->qmfbid = 0;
1512     ccp->numstepsizes = 0;
1513     ccp->numguardbits = 0;
1514     ccp->roishift = 0;
1515     ccp->cblkctx = 0;
1516   }
1517   return cp;
1518 }
1519
1520 static jpc_dec_cp_t *jpc_dec_cp_copy(jpc_dec_cp_t *cp)
1521 {
1522   jpc_dec_cp_t *newcp;
1523   jpc_dec_ccp_t *newccp;
1524   jpc_dec_ccp_t *ccp;
1525   int compno;
1526
1527   if (!(newcp = jpc_dec_cp_create(cp->numcomps))) {
1528     return 0;
1529   }
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))) {
1538     jas_free(newcp);
1539     return 0;
1540   }
1541   for (compno = 0, newccp = newcp->ccps, ccp = cp->ccps;
1542     compno < cp->numcomps;
1543     ++compno, ++newccp, ++ccp) {
1544     *newccp = *ccp;
1545   }
1546   return newcp;
1547 }
1548
1549 static void jpc_dec_cp_resetflags(jpc_dec_cp_t *cp)
1550 {
1551   int compno;
1552   jpc_dec_ccp_t *ccp;
1553   cp->flags &= (JPC_CSET | JPC_QSET);
1554   for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1555     ++compno, ++ccp) {
1556     ccp->flags = 0;
1557   }
1558 }
1559
1560 static void jpc_dec_cp_destroy(jpc_dec_cp_t *cp)
1561 {
1562   if (cp->ccps) {
1563     jas_free(cp->ccps);
1564   }
1565   if (cp->pchglist) {
1566     jpc_pchglist_destroy(cp->pchglist);
1567   }
1568   jas_free(cp);
1569 }
1570
1571 static int jpc_dec_cp_isvalid(jpc_dec_cp_t *cp)
1572 {
1573   uint_fast16_t compcnt;
1574   jpc_dec_ccp_t *ccp;
1575
1576   if (!(cp->flags & JPC_CSET) || !(cp->flags & JPC_QSET)) {
1577     return 0;
1578   }
1579   for (compcnt = cp->numcomps, ccp = cp->ccps; compcnt > 0; --compcnt,
1580     ++ccp) {
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)) {
1585       return 0;
1586     }
1587   }
1588   return 1;
1589 }
1590
1591 static void calcstepsizes(uint_fast16_t refstepsize, int numrlvls,
1592   uint_fast16_t *stepsizes)
1593 {
1594   int bandno;
1595   int numbands;
1596   uint_fast16_t expn;
1597   uint_fast16_t mant;
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))));
1604   }
1605 }
1606
1607 static int jpc_dec_cp_prepare(jpc_dec_cp_t *cp)
1608 {
1609   jpc_dec_ccp_t *ccp;
1610   int compno;
1611   int i;
1612   for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1613     ++compno, ++ccp) {
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;
1618       }
1619     }
1620     if (ccp->qsty == JPC_QCX_SIQNT) {
1621       calcstepsizes(ccp->stepsizes[0], ccp->numrlvls, ccp->stepsizes);
1622     }
1623   }
1624   return 0;
1625 }
1626
1627 static int jpc_dec_cp_setfromcod(jpc_dec_cp_t *cp, jpc_cod_t *cod)
1628 {
1629   jpc_dec_ccp_t *ccp;
1630   int compno;
1631   cp->flags |= JPC_CSET;
1632   cp->prgord = cod->prg;
1633   if (cod->mctrans) {
1634     cp->mctid = (cod->compparms.qmfbid == JPC_COX_INS) ? (JPC_MCT_ICT) : (JPC_MCT_RCT);
1635   } else {
1636     cp->mctid = JPC_MCT_NONE;
1637   }
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;
1641     ++compno, ++ccp) {
1642     jpc_dec_cp_setfromcox(cp, ccp, &cod->compparms, 0);
1643   }
1644   cp->flags |= JPC_CSET;
1645   return 0;
1646 }
1647
1648 static int jpc_dec_cp_setfromcoc(jpc_dec_cp_t *cp, jpc_coc_t *coc)
1649 {
1650   jpc_dec_cp_setfromcox(cp, &cp->ccps[coc->compno], &coc->compparms, JPC_COC);
1651   return 0;
1652 }
1653
1654 static int jpc_dec_cp_setfromcox(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
1655   jpc_coxcp_t *compparms, int flags)
1656 {
1657   int rlvlno;
1658
1659   /* Eliminate compiler warnings about unused variables. */
1660   cp = 0;
1661
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;
1676     }
1677     ccp->flags |= flags | JPC_CSET;
1678   }
1679   return 0;
1680 }
1681
1682 static int jpc_dec_cp_setfromqcd(jpc_dec_cp_t *cp, jpc_qcd_t *qcd)
1683 {
1684   int compno;
1685   jpc_dec_ccp_t *ccp;
1686   for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
1687     ++compno, ++ccp) {
1688     jpc_dec_cp_setfromqcx(cp, ccp, &qcd->compparms, 0);
1689   }
1690   cp->flags |= JPC_QSET;
1691   return 0;
1692 }
1693
1694 static int jpc_dec_cp_setfromqcc(jpc_dec_cp_t *cp, jpc_qcc_t *qcc)
1695 {
1696   return jpc_dec_cp_setfromqcx(cp, &cp->ccps[qcc->compno], &qcc->compparms, JPC_QCC);
1697 }
1698
1699 static int jpc_dec_cp_setfromqcx(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
1700   jpc_qcxcp_t *compparms, int flags)
1701 {
1702   int bandno;
1703
1704   /* Eliminate compiler warnings about unused variables. */
1705   cp = 0;
1706
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];
1711     }
1712     ccp->numstepsizes = compparms->numstepsizes;
1713     ccp->numguardbits = compparms->numguard;
1714     ccp->qsty = compparms->qntsty;
1715   }
1716   return 0;
1717 }
1718
1719 static int jpc_dec_cp_setfromrgn(jpc_dec_cp_t *cp, jpc_rgn_t *rgn)
1720 {
1721   jpc_dec_ccp_t *ccp;
1722   ccp = &cp->ccps[rgn->compno];
1723   ccp->roishift = rgn->roishift;
1724   return 0;
1725 }
1726
1727 static int jpc_pi_addpchgfrompoc(jpc_pi_t *pi, jpc_poc_t *poc)
1728 {
1729   int pchgno;
1730   jpc_pchg_t *pchg;
1731   for (pchgno = 0; pchgno < poc->numpchgs; ++pchgno) {
1732     if (!(pchg = jpc_pchg_copy(&poc->pchgs[pchgno]))) {
1733       return -1;
1734     }
1735     if (jpc_pchglist_insert(pi->pchglist, -1, pchg)) {
1736       return -1;
1737     }
1738   }
1739   return 0;
1740 }
1741
1742 static int jpc_dec_cp_setfrompoc(jpc_dec_cp_t *cp, jpc_poc_t *poc, int reset)
1743 {
1744   int pchgno;
1745   jpc_pchg_t *pchg;
1746   if (reset) {
1747     while (jpc_pchglist_numpchgs(cp->pchglist) > 0) {
1748       pchg = jpc_pchglist_remove(cp->pchglist, 0);
1749       jpc_pchg_destroy(pchg);
1750     }
1751   }
1752   for (pchgno = 0; pchgno < poc->numpchgs; ++pchgno) {
1753     if (!(pchg = jpc_pchg_copy(&poc->pchgs[pchgno]))) {
1754       return -1;
1755     }
1756     if (jpc_pchglist_insert(cp->pchglist, -1, pchg)) {
1757       return -1;
1758     }
1759   }
1760   return 0;
1761 }
1762
1763 static jpc_fix_t jpc_calcabsstepsize(int stepsize, int numbits)
1764 {
1765   jpc_fix_t absstepsize;
1766   int n;
1767
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));
1774   return absstepsize;
1775 }
1776
1777 static void jpc_dequantize(jas_matrix_t *x, jpc_fix_t absstepsize)
1778 {
1779   int i;
1780   int j;
1781   int t;
1782
1783   assert(absstepsize >= 0);
1784   if (absstepsize == jpc_inttofix(1)) {
1785     return;
1786   }
1787
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);
1791       if (t) {
1792         t = jpc_fix_mul(t, absstepsize);
1793       } else {
1794         t = 0;
1795       }
1796       jas_matrix_set(x, i, j, t);
1797     }
1798   }
1799
1800 }
1801
1802 static void jpc_undo_roi(jas_matrix_t *x, int roishift, int bgshift, int numbps)
1803 {
1804   int i;
1805   int j;
1806   int thresh;
1807   jpc_fix_t val;
1808   jpc_fix_t mag;
1809   bool warn;
1810   uint_fast32_t mask;
1811
1812   if (roishift == 0 && bgshift == 0) {
1813     return;
1814   }
1815   thresh = 1 << roishift;
1816
1817   warn = false;
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);
1821       mag = JAS_ABS(val);
1822       if (mag >= thresh) {
1823         /* We are dealing with ROI data. */
1824         mag >>= roishift;
1825         val = (val < 0) ? (-mag) : mag;
1826         jas_matrix_set(x, i, j, val);
1827       } else {
1828         /* We are dealing with non-ROI (i.e., background) data. */
1829         mag <<= bgshift;
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)) {
1836           if (!warn) {
1837             fprintf(stderr,
1838               "warning: possibly corrupt code stream\n");
1839             warn = true;
1840           }
1841           mag &= mask;
1842         }
1843         val = (val < 0) ? (-mag) : mag;
1844         jas_matrix_set(x, i, j, val);
1845       }
1846     }
1847   }
1848 }
1849
1850 static jpc_dec_t *jpc_dec_create(jpc_dec_importopts_t *impopts, jas_stream_t *in)
1851 {
1852   jpc_dec_t *dec;
1853
1854   if (!(dec = jas_malloc(sizeof(jpc_dec_t)))) {
1855     return 0;
1856   }
1857
1858   dec->image = 0;
1859   dec->xstart = 0;
1860   dec->ystart = 0;
1861   dec->xend = 0;
1862   dec->yend = 0;
1863   dec->tilewidth = 0;
1864   dec->tileheight = 0;
1865   dec->tilexoff = 0;
1866   dec->tileyoff = 0;
1867   dec->numhtiles = 0;
1868   dec->numvtiles = 0;
1869   dec->numtiles = 0;
1870   dec->tiles = 0;
1871   dec->curtile = 0;
1872   dec->numcomps = 0;
1873   dec->in = in;
1874   dec->cp = 0;
1875   dec->maxlyrs = impopts->maxlyrs;
1876   dec->maxpkts = impopts->maxpkts;
1877 dec->numpkts = 0;
1878   dec->ppmseqno = 0;
1879   dec->state = 0;
1880   dec->cmpts = 0;
1881   dec->pkthdrstreams = 0;
1882   dec->ppmstab = 0;
1883   dec->curtileendoff = 0;
1884
1885   return dec;
1886 }
1887
1888 static void jpc_dec_destroy(jpc_dec_t *dec)
1889 {
1890   if (dec->cstate) {
1891     jpc_cstate_destroy(dec->cstate);
1892   }
1893   if (dec->pkthdrstreams) {
1894     jpc_streamlist_destroy(dec->pkthdrstreams);
1895   }
1896   if (dec->image) {
1897     jas_image_destroy(dec->image);
1898   }
1899
1900   if (dec->cp) {
1901     jpc_dec_cp_destroy(dec->cp);
1902   }
1903
1904   if (dec->cmpts) {
1905     jas_free(dec->cmpts);
1906   }
1907
1908   if (dec->tiles) {
1909     jas_free(dec->tiles);
1910   }
1911
1912   jas_free(dec);
1913 }
1914
1915 /******************************************************************************\
1916 *
1917 \******************************************************************************/
1918
1919 void jpc_seglist_insert(jpc_dec_seglist_t *list, jpc_dec_seg_t *ins, jpc_dec_seg_t *node)
1920 {
1921   jpc_dec_seg_t *prev;
1922   jpc_dec_seg_t *next;
1923
1924   prev = ins;
1925   node->prev = prev;
1926   next = prev ? (prev->next) : 0;
1927   node->prev = prev;
1928   node->next = next;
1929   if (prev) {
1930     prev->next = node;
1931   } else {
1932     list->head = node;
1933   }
1934   if (next) {
1935     next->prev = node;
1936   } else {
1937     list->tail = node;
1938   }
1939 }
1940
1941 void jpc_seglist_remove(jpc_dec_seglist_t *list, jpc_dec_seg_t *seg)
1942 {
1943   jpc_dec_seg_t *prev;
1944   jpc_dec_seg_t *next;
1945
1946   prev = seg->prev;
1947   next = seg->next;
1948   if (prev) {
1949     prev->next = next;
1950   } else {
1951     list->head = next;
1952   }
1953   if (next) {
1954     next->prev = prev;
1955   } else {
1956     list->tail = prev;
1957   }
1958   seg->prev = 0;
1959   seg->next = 0;
1960 }
1961
1962 jpc_dec_seg_t *jpc_seg_alloc()
1963 {
1964   jpc_dec_seg_t *seg;
1965
1966   if (!(seg = jas_malloc(sizeof(jpc_dec_seg_t)))) {
1967     return 0;
1968   }
1969   seg->prev = 0;
1970   seg->next = 0;
1971   seg->passno = -1;
1972   seg->numpasses = 0;
1973   seg->maxpasses = 0;
1974   seg->type = JPC_SEG_INVALID;
1975   seg->stream = 0;
1976   seg->cnt = 0;
1977   seg->complete = 0;
1978   seg->lyrno = -1;
1979   return seg;
1980 }
1981
1982 void jpc_seg_destroy(jpc_dec_seg_t *seg)
1983 {
1984   if (seg->stream) {
1985     jas_stream_close(seg->stream);
1986   }
1987   jas_free(seg);
1988 }
1989
1990 static int jpc_dec_dump(jpc_dec_t *dec, FILE *out)
1991 {
1992   jpc_dec_tile_t *tile;
1993   int tileno;
1994   jpc_dec_tcomp_t *tcomp;
1995   int compno;
1996   jpc_dec_rlvl_t *rlvl;
1997   int rlvlno;
1998   jpc_dec_band_t *band;
1999   int bandno;
2000   jpc_dec_prc_t *prc;
2001   int prcno;
2002   jpc_dec_cblk_t *cblk;
2003   int cblkno;
2004
2005   for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles;
2006     ++tileno, ++tile) {
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,
2024             ++prc) {
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,
2032               ++cblk) {
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));
2038             }
2039           }
2040         }
2041       }
2042     }
2043   }
2044
2045   return 0;
2046 }
2047
2048 jpc_streamlist_t *jpc_streamlist_create()
2049 {
2050   jpc_streamlist_t *streamlist;
2051   int i;
2052
2053   if (!(streamlist = jas_malloc(sizeof(jpc_streamlist_t)))) {
2054     return 0;
2055   }
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);
2061     return 0;
2062   }
2063   for (i = 0; i < streamlist->maxstreams; ++i) {
2064     streamlist->streams[i] = 0;
2065   }
2066   return streamlist;
2067 }
2068
2069 int jpc_streamlist_insert(jpc_streamlist_t *streamlist, int streamno,
2070   jas_stream_t *stream)
2071 {
2072   jas_stream_t **newstreams;
2073   int newmaxstreams;
2074   int i;
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 *)))) {
2080       return -1;
2081     }
2082     for (i = streamlist->numstreams; i < streamlist->maxstreams; ++i) {
2083       streamlist->streams[i] = 0;
2084     }
2085     streamlist->maxstreams = newmaxstreams;
2086     streamlist->streams = newstreams;
2087   }
2088   if (streamno != streamlist->numstreams) {
2089     /* Can only handle insertion at start of list. */
2090     return -1;
2091   }
2092   streamlist->streams[streamno] = stream;
2093   ++streamlist->numstreams;
2094   return 0;
2095 }
2096
2097 jas_stream_t *jpc_streamlist_remove(jpc_streamlist_t *streamlist, int streamno)
2098 {
2099   jas_stream_t *stream;
2100   int i;
2101   if (streamno >= streamlist->numstreams) {
2102     abort();
2103   }
2104   stream = streamlist->streams[streamno];
2105   for (i = streamno + 1; i < streamlist->numstreams; ++i) {
2106     streamlist->streams[i - 1] = streamlist->streams[i];
2107   }
2108   --streamlist->numstreams;
2109   return stream;
2110 }
2111
2112 void jpc_streamlist_destroy(jpc_streamlist_t *streamlist)
2113 {
2114   int streamno;
2115   if (streamlist->streams) {
2116     for (streamno = 0; streamno < streamlist->numstreams;
2117       ++streamno) {
2118       jas_stream_close(streamlist->streams[streamno]);
2119     }
2120     jas_free(streamlist->streams);
2121   }
2122   jas_free(streamlist);
2123 }
2124
2125 jas_stream_t *jpc_streamlist_get(jpc_streamlist_t *streamlist, int streamno)
2126 {
2127   assert(streamno < streamlist->numstreams);
2128   return streamlist->streams[streamno];
2129 }
2130
2131 int jpc_streamlist_numstreams(jpc_streamlist_t *streamlist)
2132 {
2133   return streamlist->numstreams;
2134 }
2135
2136 jpc_ppxstab_t *jpc_ppxstab_create()
2137 {
2138   jpc_ppxstab_t *tab;
2139
2140   if (!(tab = jas_malloc(sizeof(jpc_ppxstab_t)))) {
2141     return 0;
2142   }
2143   tab->numents = 0;
2144   tab->maxents = 0;
2145   tab->ents = 0;
2146   return tab;
2147 }
2148
2149 void jpc_ppxstab_destroy(jpc_ppxstab_t *tab)
2150 {
2151   int i;
2152   for (i = 0; i < tab->numents; ++i) {
2153     jpc_ppxstabent_destroy(tab->ents[i]);
2154   }
2155   if (tab->ents) {
2156     jas_free(tab->ents);
2157   }
2158   jas_free(tab);
2159 }
2160
2161 int jpc_ppxstab_grow(jpc_ppxstab_t *tab, int maxents)
2162 {
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 *));
2167     if (!newents) {
2168       return -1;
2169     }
2170     tab->ents = newents;
2171     tab->maxents = maxents;
2172   }
2173   return 0;
2174 }
2175
2176 int jpc_ppxstab_insert(jpc_ppxstab_t *tab, jpc_ppxstabent_t *ent)
2177 {
2178   int inspt;
2179   int i;
2180
2181   for (i = 0; i < tab->numents; ++i) {
2182     if (tab->ents[i]->ind > ent->ind) {
2183       break;
2184     }
2185   }
2186   inspt = i;
2187
2188   if (tab->numents >= tab->maxents) {
2189     if (jpc_ppxstab_grow(tab, tab->maxents + 128)) {
2190       return -1;
2191     }
2192   }
2193
2194   for (i = tab->numents; i > inspt; --i) {
2195     tab->ents[i] = tab->ents[i - 1];
2196   }
2197   tab->ents[i] = ent;
2198   ++tab->numents;
2199
2200   return 0;
2201 }
2202
2203 jpc_streamlist_t *jpc_ppmstabtostreams(jpc_ppxstab_t *tab)
2204 {
2205   jpc_streamlist_t *streams;
2206   uchar *dataptr;
2207   uint_fast32_t datacnt;
2208   uint_fast32_t tpcnt;
2209   jpc_ppxstabent_t *ent;
2210   int entno;
2211   jas_stream_t *stream;
2212   int n;
2213
2214   if (!(streams = jpc_streamlist_create())) {
2215     goto error;
2216   }
2217
2218   if (!tab->numents) {
2219     return streams;
2220   }
2221
2222   entno = 0;
2223   ent = tab->ents[entno];
2224   dataptr = ent->data;
2225   datacnt = ent->len;
2226   for (;;) {
2227
2228     /* Get the length of the packet header data for the current
2229       tile-part. */
2230     if (datacnt < 4) {
2231       goto error;
2232     }
2233     if (!(stream = jas_stream_memopen(0, 0))) {
2234       goto error;
2235     }
2236     if (jpc_streamlist_insert(streams, jpc_streamlist_numstreams(streams),
2237       stream)) {
2238       goto error;
2239     }
2240     tpcnt = (dataptr[0] << 24) | (dataptr[1] << 16) | (dataptr[2] << 8)
2241       | dataptr[3];
2242     datacnt -= 4;
2243     dataptr += 4;
2244
2245     /* Get the packet header data for the current tile-part. */
2246     while (tpcnt) {
2247       if (!datacnt) {
2248         if (++entno >= tab->numents) {
2249           goto error;
2250         }
2251         ent = tab->ents[entno];
2252         dataptr = ent->data;
2253         datacnt = ent->len;
2254       }
2255       n = JAS_MIN(tpcnt, datacnt);
2256       if (jas_stream_write(stream, dataptr, n) != n) {
2257         goto error;
2258       }
2259       tpcnt -= n;
2260       dataptr += n;
2261       datacnt -= n;
2262     }
2263     jas_stream_rewind(stream);
2264     if (!datacnt) {
2265       if (++entno >= tab->numents) {
2266         break;
2267       }
2268       ent = tab->ents[entno];
2269       dataptr = ent->data;
2270       datacnt = ent->len;
2271     }
2272   }
2273
2274   return streams;
2275
2276 error:
2277   jpc_streamlist_destroy(streams);
2278   return 0;
2279 }
2280
2281 int jpc_pptstabwrite(jas_stream_t *out, jpc_ppxstab_t *tab)
2282 {
2283   int i;
2284   jpc_ppxstabent_t *ent;
2285   for (i = 0; i < tab->numents; ++i) {
2286     ent = tab->ents[i];
2287     if (jas_stream_write(out, ent->data, ent->len) != JAS_CAST(int, ent->len)) {
2288       return -1;
2289     }
2290   }
2291   return 0;
2292 }
2293
2294 jpc_ppxstabent_t *jpc_ppxstabent_create()
2295 {
2296   jpc_ppxstabent_t *ent;
2297   if (!(ent = jas_malloc(sizeof(jpc_ppxstabent_t)))) {
2298     return 0;
2299   }
2300   ent->data = 0;
2301   ent->len = 0;
2302   ent->ind = 0;
2303   return ent;
2304 }
2305
2306 void jpc_ppxstabent_destroy(jpc_ppxstabent_t *ent)
2307 {
2308   if (ent->data) {
2309     jas_free(ent->data);
2310   }
2311   jas_free(ent);
2312 }