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