jpc_t2dec.c (15905B)
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 * Tier 2 Decoder 66 * 67 * $Id: jpc_t2dec.c 1918 2005-07-24 14:12:08Z baford $ 68 */ 69 70 /******************************************************************************\ 71 * Includes. 72 \******************************************************************************/ 73 74 #include <stdio.h> 75 #include <stdlib.h> 76 #include <assert.h> 77 78 #include "jasper/jas_types.h" 79 #include "jasper/jas_fix.h" 80 #include "jasper/jas_malloc.h" 81 #include "jasper/jas_math.h" 82 #include "jasper/jas_stream.h" 83 #include "jasper/jas_debug.h" 84 85 #include "jpc_bs.h" 86 #include "jpc_dec.h" 87 #include "jpc_cs.h" 88 #include "jpc_mqdec.h" 89 #include "jpc_t2dec.h" 90 #include "jpc_t1cod.h" 91 #include "jpc_math.h" 92 93 /******************************************************************************\ 94 * 95 \******************************************************************************/ 96 97 long jpc_dec_lookahead(jas_stream_t *in); 98 static int jpc_getcommacode(jpc_bitstream_t *in); 99 static int jpc_getnumnewpasses(jpc_bitstream_t *in); 100 static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int lvlno, 101 int prcno, int lyrno); 102 103 /******************************************************************************\ 104 * Code. 105 \******************************************************************************/ 106 107 static int jpc_getcommacode(jpc_bitstream_t *in) 108 { 109 int n; 110 int v; 111 112 n = 0; 113 for (;;) { 114 if ((v = jpc_bitstream_getbit(in)) < 0) { 115 return -1; 116 } 117 if (jpc_bitstream_eof(in)) { 118 return -1; 119 } 120 if (!v) { 121 break; 122 } 123 ++n; 124 } 125 126 return n; 127 } 128 129 static int jpc_getnumnewpasses(jpc_bitstream_t *in) 130 { 131 int n; 132 133 if ((n = jpc_bitstream_getbit(in)) > 0) { 134 if ((n = jpc_bitstream_getbit(in)) > 0) { 135 if ((n = jpc_bitstream_getbits(in, 2)) == 3) { 136 if ((n = jpc_bitstream_getbits(in, 5)) == 31) { 137 if ((n = jpc_bitstream_getbits(in, 7)) >= 0) { 138 n += 36 + 1; 139 } 140 } else if (n >= 0) { 141 n += 5 + 1; 142 } 143 } else if (n >= 0) { 144 n += 2 + 1; 145 } 146 } else if (!n) { 147 n += 2; 148 } 149 } else if (!n) { 150 ++n; 151 } 152 153 return n; 154 } 155 156 static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int rlvlno, 157 int prcno, int lyrno) 158 { 159 jpc_bitstream_t *inb; 160 jpc_dec_tcomp_t *tcomp; 161 jpc_dec_rlvl_t *rlvl; 162 jpc_dec_band_t *band; 163 jpc_dec_cblk_t *cblk; 164 int n; 165 int m; 166 int i; 167 jpc_tagtreenode_t *leaf; 168 int included; 169 int ret; 170 int numnewpasses; 171 jpc_dec_seg_t *seg; 172 int len; 173 int present; 174 int savenumnewpasses; 175 int mycounter; 176 jpc_ms_t *ms; 177 jpc_dec_tile_t *tile; 178 jpc_dec_ccp_t *ccp; 179 jpc_dec_cp_t *cp; 180 int bandno; 181 jpc_dec_prc_t *prc; 182 int usedcblkcnt; 183 int cblkno; 184 uint_fast32_t bodylen; 185 bool discard; 186 int passno; 187 int maxpasses; 188 int hdrlen; 189 int hdroffstart; 190 int hdroffend; 191 192 /* Avoid compiler warning about possible use of uninitialized 193 variable. */ 194 bodylen = 0; 195 196 discard = (lyrno >= dec->maxlyrs); 197 198 tile = dec->curtile; 199 cp = tile->cp; 200 ccp = &cp->ccps[compno]; 201 202 /* 203 * Decode the packet header. 204 */ 205 206 /* Decode the SOP marker segment if present. */ 207 if (cp->csty & JPC_COD_SOP) { 208 if (jpc_dec_lookahead(in) == JPC_MS_SOP) { 209 if (!(ms = jpc_getms(in, dec->cstate))) { 210 return -1; 211 } 212 if (jpc_ms_gettype(ms) != JPC_MS_SOP) { 213 jpc_ms_destroy(ms); 214 fprintf(stderr, "missing SOP marker segment\n"); 215 return -1; 216 } 217 jpc_ms_destroy(ms); 218 } 219 } 220 221 hdroffstart = jas_stream_getrwcount(pkthdrstream); 222 223 if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) { 224 return -1; 225 } 226 227 if ((present = jpc_bitstream_getbit(inb)) < 0) { 228 return 1; 229 } 230 JAS_DBGLOG(10, ("\n", present)); 231 JAS_DBGLOG(10, ("present=%d ", present)); 232 233 /* Is the packet non-empty? */ 234 if (present) { 235 /* The packet is non-empty. */ 236 tcomp = &tile->tcomps[compno]; 237 rlvl = &tcomp->rlvls[rlvlno]; 238 bodylen = 0; 239 for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; 240 ++bandno, ++band) { 241 if (!band->data) { 242 continue; 243 } 244 prc = &band->prcs[prcno]; 245 if (!prc->cblks) { 246 continue; 247 } 248 usedcblkcnt = 0; 249 for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; 250 ++cblkno, ++cblk) { 251 ++usedcblkcnt; 252 if (!cblk->numpasses) { 253 leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1); 254 if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) { 255 return -1; 256 } 257 } else { 258 if ((included = jpc_bitstream_getbit(inb)) < 0) { 259 return -1; 260 } 261 } 262 JAS_DBGLOG(10, ("\n")); 263 JAS_DBGLOG(10, ("included=%d ", included)); 264 if (!included) { 265 continue; 266 } 267 if (!cblk->numpasses) { 268 i = 1; 269 leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1); 270 for (;;) { 271 if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) { 272 return -1; 273 } 274 if (ret) { 275 break; 276 } 277 ++i; 278 } 279 cblk->numimsbs = i - 1; 280 cblk->firstpassno = cblk->numimsbs * 3; 281 } 282 if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) { 283 return -1; 284 } 285 JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses)); 286 seg = cblk->curseg; 287 savenumnewpasses = numnewpasses; 288 mycounter = 0; 289 if (numnewpasses > 0) { 290 if ((m = jpc_getcommacode(inb)) < 0) { 291 return -1; 292 } 293 cblk->numlenbits += m; 294 JAS_DBGLOG(10, ("increment=%d ", m)); 295 while (numnewpasses > 0) { 296 passno = cblk->firstpassno + cblk->numpasses + mycounter; 297 /* XXX - the maxpasses is not set precisely but this doesn't matter... */ 298 maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0); 299 if (!discard && !seg) { 300 if (!(seg = jpc_seg_alloc())) { 301 return -1; 302 } 303 jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg); 304 if (!cblk->curseg) { 305 cblk->curseg = seg; 306 } 307 seg->passno = passno; 308 seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0); 309 seg->maxpasses = maxpasses; 310 } 311 n = JAS_MIN(numnewpasses, maxpasses); 312 mycounter += n; 313 numnewpasses -= n; 314 if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) { 315 return -1; 316 } 317 JAS_DBGLOG(10, ("len=%d ", len)); 318 if (!discard) { 319 seg->lyrno = lyrno; 320 seg->numpasses += n; 321 seg->cnt = len; 322 seg = seg->next; 323 } 324 bodylen += len; 325 } 326 } 327 cblk->numpasses += savenumnewpasses; 328 } 329 } 330 331 jpc_bitstream_inalign(inb, 0, 0); 332 333 } else { 334 if (jpc_bitstream_inalign(inb, 0x7f, 0)) { 335 fprintf(stderr, "alignment failed\n"); 336 return -1; 337 } 338 } 339 jpc_bitstream_close(inb); 340 341 hdroffend = jas_stream_getrwcount(pkthdrstream); 342 hdrlen = hdroffend - hdroffstart; 343 if (jas_getdbglevel() >= 5) { 344 fprintf(stderr, "hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen, 345 (unsigned long) bodylen); 346 } 347 348 if (cp->csty & JPC_COD_EPH) { 349 if (jpc_dec_lookahead(pkthdrstream) == JPC_MS_EPH) { 350 if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) { 351 fprintf(stderr, "cannot get (EPH) marker segment\n"); 352 return -1; 353 } 354 if (jpc_ms_gettype(ms) != JPC_MS_EPH) { 355 jpc_ms_destroy(ms); 356 fprintf(stderr, "missing EPH marker segment\n"); 357 return -1; 358 } 359 jpc_ms_destroy(ms); 360 } 361 } 362 363 /* decode the packet body. */ 364 365 if (jas_getdbglevel() >= 1) { 366 fprintf(stderr, "packet body offset=%06ld\n", (long) jas_stream_getrwcount(in)); 367 } 368 369 if (!discard) { 370 tcomp = &tile->tcomps[compno]; 371 rlvl = &tcomp->rlvls[rlvlno]; 372 for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; 373 ++bandno, ++band) { 374 if (!band->data) { 375 continue; 376 } 377 prc = &band->prcs[prcno]; 378 if (!prc->cblks) { 379 continue; 380 } 381 for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; 382 ++cblkno, ++cblk) { 383 seg = cblk->curseg; 384 while (seg) { 385 if (!seg->stream) { 386 if (!(seg->stream = jas_stream_memopen(0, 0))) { 387 return -1; 388 } 389 } 390 #if 0 391 fprintf(stderr, "lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, cblkno=%02d, passno=%02d numpasses=%02d cnt=%d numbps=%d, numimsbs=%d\n", lyrno, compno, rlvlno, prcno, band - rlvl->bands, cblk - prc->cblks, seg->passno, seg->numpasses, seg->cnt, band->numbps, cblk->numimsbs); 392 #endif 393 if (seg->cnt > 0) { 394 if (jpc_getdata(in, seg->stream, seg->cnt) < 0) { 395 return -1; 396 } 397 seg->cnt = 0; 398 } 399 if (seg->numpasses >= seg->maxpasses) { 400 cblk->curseg = seg->next; 401 } 402 seg = seg->next; 403 } 404 } 405 } 406 } else { 407 if (jas_stream_gobble(in, bodylen) != JAS_CAST(int, bodylen)) { 408 return -1; 409 } 410 } 411 return 0; 412 } 413 414 /********************************************************************************************/ 415 /********************************************************************************************/ 416 417 int jpc_dec_decodepkts(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in) 418 { 419 jpc_dec_tile_t *tile; 420 jpc_pi_t *pi; 421 int ret; 422 423 tile = dec->curtile; 424 pi = tile->pi; 425 for (;;) { 426 if (!tile->pkthdrstream || jas_stream_peekc(tile->pkthdrstream) == EOF) { 427 switch (jpc_dec_lookahead(in)) { 428 case JPC_MS_EOC: 429 case JPC_MS_SOT: 430 return 0; 431 break; 432 case JPC_MS_SOP: 433 case JPC_MS_EPH: 434 case 0: 435 break; 436 default: 437 return -1; 438 break; 439 } 440 } 441 if ((ret = jpc_pi_next(pi))) { 442 return ret; 443 } 444 if (dec->maxpkts >= 0 && dec->numpkts >= dec->maxpkts) { 445 fprintf(stderr, "warning: stopping decode prematurely as requested\n"); 446 return 0; 447 } 448 if (jas_getdbglevel() >= 1) { 449 fprintf(stderr, "packet offset=%08ld prg=%d cmptno=%02d " 450 "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long) 451 jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi), 452 jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi)); 453 } 454 if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi), 455 jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) { 456 return -1; 457 } 458 ++dec->numpkts; 459 } 460 461 return 0; 462 } 463 464 jpc_pi_t *jpc_dec_pi_create(jpc_dec_t *dec, jpc_dec_tile_t *tile) 465 { 466 jpc_pi_t *pi; 467 int compno; 468 jpc_picomp_t *picomp; 469 jpc_pirlvl_t *pirlvl; 470 jpc_dec_tcomp_t *tcomp; 471 int rlvlno; 472 jpc_dec_rlvl_t *rlvl; 473 int prcno; 474 int *prclyrno; 475 jpc_dec_cmpt_t *cmpt; 476 477 if (!(pi = jpc_pi_create0())) { 478 return 0; 479 } 480 pi->numcomps = dec->numcomps; 481 if (!(pi->picomps = jas_malloc(pi->numcomps * sizeof(jpc_picomp_t)))) { 482 jpc_pi_destroy(pi); 483 return 0; 484 } 485 for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno, 486 ++picomp) { 487 picomp->pirlvls = 0; 488 } 489 490 for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps; 491 compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { 492 picomp->numrlvls = tcomp->numrlvls; 493 if (!(picomp->pirlvls = jas_malloc(picomp->numrlvls * 494 sizeof(jpc_pirlvl_t)))) { 495 jpc_pi_destroy(pi); 496 return 0; 497 } 498 for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < 499 picomp->numrlvls; ++rlvlno, ++pirlvl) { 500 pirlvl->prclyrnos = 0; 501 } 502 for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; 503 rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { 504 /* XXX sizeof(long) should be sizeof different type */ 505 pirlvl->numprcs = rlvl->numprcs; 506 if (!(pirlvl->prclyrnos = jas_malloc(pirlvl->numprcs * 507 sizeof(long)))) { 508 jpc_pi_destroy(pi); 509 return 0; 510 } 511 } 512 } 513 514 pi->maxrlvls = 0; 515 for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt = 516 dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp, 517 ++cmpt) { 518 picomp->hsamp = cmpt->hstep; 519 picomp->vsamp = cmpt->vstep; 520 for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; 521 rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { 522 pirlvl->prcwidthexpn = rlvl->prcwidthexpn; 523 pirlvl->prcheightexpn = rlvl->prcheightexpn; 524 for (prcno = 0, prclyrno = pirlvl->prclyrnos; 525 prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { 526 *prclyrno = 0; 527 } 528 pirlvl->numhprcs = rlvl->numhprcs; 529 } 530 if (pi->maxrlvls < tcomp->numrlvls) { 531 pi->maxrlvls = tcomp->numrlvls; 532 } 533 } 534 535 pi->numlyrs = tile->cp->numlyrs; 536 pi->xstart = tile->xstart; 537 pi->ystart = tile->ystart; 538 pi->xend = tile->xend; 539 pi->yend = tile->yend; 540 541 pi->picomp = 0; 542 pi->pirlvl = 0; 543 pi->x = 0; 544 pi->y = 0; 545 pi->compno = 0; 546 pi->rlvlno = 0; 547 pi->prcno = 0; 548 pi->lyrno = 0; 549 pi->xstep = 0; 550 pi->ystep = 0; 551 552 pi->pchgno = -1; 553 554 pi->defaultpchg.prgord = tile->cp->prgord; 555 pi->defaultpchg.compnostart = 0; 556 pi->defaultpchg.compnoend = pi->numcomps; 557 pi->defaultpchg.rlvlnostart = 0; 558 pi->defaultpchg.rlvlnoend = pi->maxrlvls; 559 pi->defaultpchg.lyrnoend = pi->numlyrs; 560 pi->pchg = 0; 561 562 pi->valid = 0; 563 564 return pi; 565 } 566 567 long jpc_dec_lookahead(jas_stream_t *in) 568 { 569 uint_fast16_t x; 570 if (jpc_getuint16(in, &x)) { 571 return -1; 572 } 573 if (jas_stream_ungetc(in, x & 0xff) == EOF || 574 jas_stream_ungetc(in, x >> 8) == EOF) { 575 return -1; 576 } 577 if (x >= JPC_MS_INMIN && x <= JPC_MS_INMAX) { 578 return x; 579 } 580 return 0; 581 }