git.maemo.org Git - opencv/blob - 3rdparty/libjasper/jpc_t2cod.c

   1 /*
   2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
   3  *   British Columbia.
   4  * Copyright (c) 2001-2003 Michael David Adams.
   5  * All rights reserved.
   6  */
   7
   8 /* __START_OF_JASPER_LICENSE__
   9  *
  10  * JasPer License Version 2.0
  11  *
  12  * Copyright (c) 2001-2006 Michael David Adams
  13  * Copyright (c) 1999-2000 Image Power, Inc.
  14  * Copyright (c) 1999-2000 The University of British Columbia
  15  *
  16  * All rights reserved.
  17  *
  18  * Permission is hereby granted, free of charge, to any person (the
  19  * "User") obtaining a copy of this software and associated documentation
  20  * files (the "Software"), to deal in the Software without restriction,
  21  * including without limitation the rights to use, copy, modify, merge,
  22  * publish, distribute, and/or sell copies of the Software, and to permit
  23  * persons to whom the Software is furnished to do so, subject to the
  24  * following conditions:
  25  *
  26  * 1.  The above copyright notices and this permission notice (which
  27  * includes the disclaimer below) shall be included in all copies or
  28  * substantial portions of the Software.
  29  *
  30  * 2.  The name of a copyright holder shall not be used to endorse or
  31  * promote products derived from the Software without specific prior
  32  * written permission.
  33  *
  34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
  37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
  40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
  41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
  42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
  45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
  46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
  47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
  48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
  49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
  50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
  51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
  52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
  53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
  54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
  55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
  56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
  57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
  60  *
  61  * __END_OF_JASPER_LICENSE__
  62  */
  63
  64 /*
  65  * Tier-2 Coding Library
  66  *
  67  * $Id: jpc_t2cod.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
  68  */
  69
  70 #include "jasper/jas_math.h"
  71 #include "jasper/jas_malloc.h"
  72 #include "jasper/jas_math.h"
  73
  74 #include "jpc_cs.h"
  75 #include "jpc_t2cod.h"
  76 #include "jpc_math.h"
  77
  78 static int jpc_pi_nextlrcp(jpc_pi_t *pi);
  79 static int jpc_pi_nextrlcp(jpc_pi_t *pi);
  80 static int jpc_pi_nextrpcl(jpc_pi_t *pi);
  81 static int jpc_pi_nextpcrl(jpc_pi_t *pi);
  82 static int jpc_pi_nextcprl(jpc_pi_t *pi);
  83
  84 int jpc_pi_next(jpc_pi_t *pi)
  85 {
  86         jpc_pchg_t *pchg;
  87         int ret;
  88
  89
  90         for (;;) {
  91
  92                 pi->valid = false;
  93
  94                 if (!pi->pchg) {
  95                         ++pi->pchgno;
  96                         pi->compno = 0;
  97                         pi->rlvlno = 0;
  98                         pi->prcno = 0;
  99                         pi->lyrno = 0;
 100                         pi->prgvolfirst = true;
 101                         if (pi->pchgno < jpc_pchglist_numpchgs(pi->pchglist)) {
 102                                 pi->pchg = jpc_pchglist_get(pi->pchglist, pi->pchgno);
 103                         } else if (pi->pchgno == jpc_pchglist_numpchgs(pi->pchglist)) {
 104                                 pi->pchg = &pi->defaultpchg;
 105                         } else {
 106                                 return 1;
 107                         }
 108                 }
 109
 110                 pchg = pi->pchg;
 111                 switch (pchg->prgord) {
 112                 case JPC_COD_LRCPPRG:
 113                         ret = jpc_pi_nextlrcp(pi);
 114                         break;
 115                 case JPC_COD_RLCPPRG:
 116                         ret = jpc_pi_nextrlcp(pi);
 117                         break;
 118                 case JPC_COD_RPCLPRG:
 119                         ret = jpc_pi_nextrpcl(pi);
 120                         break;
 121                 case JPC_COD_PCRLPRG:
 122                         ret = jpc_pi_nextpcrl(pi);
 123                         break;
 124                 case JPC_COD_CPRLPRG:
 125                         ret = jpc_pi_nextcprl(pi);
 126                         break;
 127                 default:
 128                         ret = -1;
 129                         break;
 130                 }
 131                 if (!ret) {
 132                         pi->valid = true;
 133                         ++pi->pktno;
 134                         return 0;
 135                 }
 136                 pi->pchg = 0;
 137         }
 138 }
 139
 140 static int jpc_pi_nextlrcp(register jpc_pi_t *pi)
 141 {
 142         jpc_pchg_t *pchg;
 143         int *prclyrno;
 144
 145         pchg = pi->pchg;
 146         if (!pi->prgvolfirst) {
 147                 prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
 148                 goto skip;
 149         } else {
 150                 pi->prgvolfirst = false;
 151         }
 152
 153         for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno <
 154           JAS_CAST(int, pchg->lyrnoend); ++pi->lyrno) {
 155                 for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls &&
 156                   pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) {
 157                         for (pi->compno = pchg->compnostart, pi->picomp =
 158                           &pi->picomps[pi->compno]; pi->compno < pi->numcomps
 159                           && pi->compno < JAS_CAST(int, pchg->compnoend); ++pi->compno,
 160                           ++pi->picomp) {
 161                                 if (pi->rlvlno >= pi->picomp->numrlvls) {
 162                                         continue;
 163                                 }
 164                                 pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
 165                                 for (pi->prcno = 0, prclyrno =
 166                                   pi->pirlvl->prclyrnos; pi->prcno <
 167                                   pi->pirlvl->numprcs; ++pi->prcno,
 168                                   ++prclyrno) {
 169                                         if (pi->lyrno >= *prclyrno) {
 170                                                 *prclyrno = pi->lyrno;
 171                                                 ++(*prclyrno);
 172                                                 return 0;
 173                                         }
 174 skip:
 175                                         ;
 176                                 }
 177                         }
 178                 }
 179         }
 180         return 1;
 181 }
 182
 183 static int jpc_pi_nextrlcp(register jpc_pi_t *pi)
 184 {
 185         jpc_pchg_t *pchg;
 186         int *prclyrno;
 187
 188         pchg = pi->pchg;
 189         if (!pi->prgvolfirst) {
 190                 assert(pi->prcno < pi->pirlvl->numprcs);
 191                 prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
 192                 goto skip;
 193         } else {
 194                 pi->prgvolfirst = 0;
 195         }
 196
 197         for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls &&
 198           pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) {
 199                 for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno <
 200                   JAS_CAST(int, pchg->lyrnoend); ++pi->lyrno) {
 201                         for (pi->compno = pchg->compnostart, pi->picomp =
 202                           &pi->picomps[pi->compno]; pi->compno < pi->numcomps &&
 203                           pi->compno < JAS_CAST(int, pchg->compnoend); ++pi->compno, ++pi->picomp) {
 204                                 if (pi->rlvlno >= pi->picomp->numrlvls) {
 205                                         continue;
 206                                 }
 207                                 pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
 208                                 for (pi->prcno = 0, prclyrno = pi->pirlvl->prclyrnos;
 209                                   pi->prcno < pi->pirlvl->numprcs; ++pi->prcno, ++prclyrno) {
 210                                         if (pi->lyrno >= *prclyrno) {
 211                                                 *prclyrno = pi->lyrno;
 212                                                 ++(*prclyrno);
 213                                                 return 0;
 214                                         }
 215 skip:
 216                                         ;
 217                                 }
 218                         }
 219                 }
 220         }
 221         return 1;
 222 }
 223
 224 static int jpc_pi_nextrpcl(register jpc_pi_t *pi)
 225 {
 226         int rlvlno;
 227         jpc_pirlvl_t *pirlvl;
 228         jpc_pchg_t *pchg;
 229         int prchind;
 230         int prcvind;
 231         int *prclyrno;
 232         int compno;
 233         jpc_picomp_t *picomp;
 234         int xstep;
 235         int ystep;
 236         uint_fast32_t r;
 237         uint_fast32_t rpx;
 238         uint_fast32_t rpy;
 239         uint_fast32_t trx0;
 240         uint_fast32_t try0;
 241
 242         pchg = pi->pchg;
 243         if (!pi->prgvolfirst) {
 244                 goto skip;
 245         } else {
 246                 pi->xstep = 0;
 247                 pi->ystep = 0;
 248                 for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
 249                   ++compno, ++picomp) {
 250                         for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
 251                           picomp->numrlvls; ++rlvlno, ++pirlvl) {
 252                                 xstep = picomp->hsamp * (1 << (pirlvl->prcwidthexpn +
 253                                   picomp->numrlvls - rlvlno - 1));
 254                                 ystep = picomp->vsamp * (1 << (pirlvl->prcheightexpn +
 255                                   picomp->numrlvls - rlvlno - 1));
 256                                 pi->xstep = (!pi->xstep) ? xstep : JAS_MIN(pi->xstep, xstep);
 257                                 pi->ystep = (!pi->ystep) ? ystep : JAS_MIN(pi->ystep, ystep);
 258                         }
 259                 }
 260                 pi->prgvolfirst = 0;
 261         }
 262
 263         for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pchg->rlvlnoend &&
 264           pi->rlvlno < pi->maxrlvls; ++pi->rlvlno) {
 265                 for (pi->y = pi->ystart; pi->y < pi->yend; pi->y +=
 266                   pi->ystep - (pi->y % pi->ystep)) {
 267                         for (pi->x = pi->xstart; pi->x < pi->xend; pi->x +=
 268                           pi->xstep - (pi->x % pi->xstep)) {
 269                                 for (pi->compno = pchg->compnostart,
 270                                   pi->picomp = &pi->picomps[pi->compno];
 271                                   pi->compno < JAS_CAST(int, pchg->compnoend) && pi->compno <
 272                                   pi->numcomps; ++pi->compno, ++pi->picomp) {
 273                                         if (pi->rlvlno >= pi->picomp->numrlvls) {
 274                                                 continue;
 275                                         }
 276                                         pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
 277                                         if (pi->pirlvl->numprcs == 0) {
 278                                                 continue;
 279                                         }
 280                                         r = pi->picomp->numrlvls - 1 - pi->rlvlno;
 281                                         rpx = r + pi->pirlvl->prcwidthexpn;
 282                                         rpy = r + pi->pirlvl->prcheightexpn;
 283                                         trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r);
 284                                         try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r);
 285                                         if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx)))
 286                                           || !(pi->x % (1 << rpx))) &&
 287                                           ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy)))
 288                                           || !(pi->y % (1 << rpy)))) {
 289                                                 prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp
 290                                                   << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0,
 291                                                   pi->pirlvl->prcwidthexpn);
 292                                                 prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp
 293                                                   << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0,
 294                                                   pi->pirlvl->prcheightexpn);
 295                                                 pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind;
 296
 297                                                 assert(pi->prcno < pi->pirlvl->numprcs);
 298                                                 for (pi->lyrno = 0; pi->lyrno <
 299                                                   pi->numlyrs && pi->lyrno < JAS_CAST(int, pchg->lyrnoend); ++pi->lyrno) {
 300                                                         prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
 301                                                         if (pi->lyrno >= *prclyrno) {
 302                                                                 ++(*prclyrno);
 303                                                                 return 0;
 304                                                         }
 305 skip:
 306                                                         ;
 307                                                 }
 308                                         }
 309                                 }
 310                         }
 311                 }
 312         }
 313         return 1;
 314 }
 315
 316 static int jpc_pi_nextpcrl(register jpc_pi_t *pi)
 317 {
 318         int rlvlno;
 319         jpc_pirlvl_t *pirlvl;
 320         jpc_pchg_t *pchg;
 321         int prchind;
 322         int prcvind;
 323         int *prclyrno;
 324         int compno;
 325         jpc_picomp_t *picomp;
 326         int xstep;
 327         int ystep;
 328         uint_fast32_t trx0;
 329         uint_fast32_t try0;
 330         uint_fast32_t r;
 331         uint_fast32_t rpx;
 332         uint_fast32_t rpy;
 333
 334         pchg = pi->pchg;
 335         if (!pi->prgvolfirst) {
 336                 goto skip;
 337         } else {
 338                 pi->xstep = 0;
 339                 pi->ystep = 0;
 340                 for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
 341                   ++compno, ++picomp) {
 342                         for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
 343                           picomp->numrlvls; ++rlvlno, ++pirlvl) {
 344                                 xstep = picomp->hsamp * (1 <<
 345                                   (pirlvl->prcwidthexpn + picomp->numrlvls -
 346                                   rlvlno - 1));
 347                                 ystep = picomp->vsamp * (1 <<
 348                                   (pirlvl->prcheightexpn + picomp->numrlvls -
 349                                   rlvlno - 1));
 350                                 pi->xstep = (!pi->xstep) ? xstep :
 351                                   JAS_MIN(pi->xstep, xstep);
 352                                 pi->ystep = (!pi->ystep) ? ystep :
 353                                   JAS_MIN(pi->ystep, ystep);
 354                         }
 355                 }
 356                 pi->prgvolfirst = 0;
 357         }
 358
 359         for (pi->y = pi->ystart; pi->y < pi->yend; pi->y += pi->ystep -
 360           (pi->y % pi->ystep)) {
 361                 for (pi->x = pi->xstart; pi->x < pi->xend; pi->x += pi->xstep -
 362                   (pi->x % pi->xstep)) {
 363                         for (pi->compno = pchg->compnostart, pi->picomp =
 364                           &pi->picomps[pi->compno]; pi->compno < pi->numcomps
 365                           && pi->compno < JAS_CAST(int, pchg->compnoend); ++pi->compno,
 366                           ++pi->picomp) {
 367                                 for (pi->rlvlno = pchg->rlvlnostart,
 368                                   pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
 369                                   pi->rlvlno < pi->picomp->numrlvls &&
 370                                   pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno,
 371                                   ++pi->pirlvl) {
 372                                         if (pi->pirlvl->numprcs == 0) {
 373                                                 continue;
 374                                         }
 375                                         r = pi->picomp->numrlvls - 1 - pi->rlvlno;
 376                                         trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r);
 377                                         try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r);
 378                                         rpx = r + pi->pirlvl->prcwidthexpn;
 379                                         rpy = r + pi->pirlvl->prcheightexpn;
 380                                         if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) ||
 381                                           !(pi->x % (pi->picomp->hsamp << rpx))) &&
 382                                           ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) ||
 383                                           !(pi->y % (pi->picomp->vsamp << rpy)))) {
 384                                                 prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp
 385                                                   << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0,
 386                                                   pi->pirlvl->prcwidthexpn);
 387                                                 prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp
 388                                                   << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0,
 389                                                   pi->pirlvl->prcheightexpn);
 390                                                 pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind;
 391                                                 assert(pi->prcno < pi->pirlvl->numprcs);
 392                                                 for (pi->lyrno = 0; pi->lyrno < pi->numlyrs &&
 393                                                   pi->lyrno < JAS_CAST(int, pchg->lyrnoend); ++pi->lyrno) {
 394                                                         prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
 395                                                         if (pi->lyrno >= *prclyrno) {
 396                                                                 ++(*prclyrno);
 397                                                                 return 0;
 398                                                         }
 399 skip:
 400                                                         ;
 401                                                 }
 402                                         }
 403                                 }
 404                         }
 405                 }
 406         }
 407         return 1;
 408 }
 409
 410 static int jpc_pi_nextcprl(register jpc_pi_t *pi)
 411 {
 412         int rlvlno;
 413         jpc_pirlvl_t *pirlvl;
 414         jpc_pchg_t *pchg;
 415         int prchind;
 416         int prcvind;
 417         int *prclyrno;
 418         uint_fast32_t trx0;
 419         uint_fast32_t try0;
 420         uint_fast32_t r;
 421         uint_fast32_t rpx;
 422         uint_fast32_t rpy;
 423
 424         pchg = pi->pchg;
 425         if (!pi->prgvolfirst) {
 426                 goto skip;
 427         } else {
 428                 pi->prgvolfirst = 0;
 429         }
 430
 431         for (pi->compno = pchg->compnostart, pi->picomp =
 432           &pi->picomps[pi->compno]; pi->compno < JAS_CAST(int, pchg->compnoend); ++pi->compno,
 433           ++pi->picomp) {
 434                 pirlvl = pi->picomp->pirlvls;
 435                 pi->xstep = pi->picomp->hsamp * (1 << (pirlvl->prcwidthexpn +
 436                   pi->picomp->numrlvls - 1));
 437                 pi->ystep = pi->picomp->vsamp * (1 << (pirlvl->prcheightexpn +
 438                   pi->picomp->numrlvls - 1));
 439                 for (rlvlno = 1, pirlvl = &pi->picomp->pirlvls[1];
 440                   rlvlno < pi->picomp->numrlvls; ++rlvlno, ++pirlvl) {
 441                         pi->xstep = JAS_MIN(pi->xstep, pi->picomp->hsamp * (1 <<
 442                           (pirlvl->prcwidthexpn + pi->picomp->numrlvls -
 443                           rlvlno - 1)));
 444                         pi->ystep = JAS_MIN(pi->ystep, pi->picomp->vsamp * (1 <<
 445                           (pirlvl->prcheightexpn + pi->picomp->numrlvls -
 446                           rlvlno - 1)));
 447                 }
 448                 for (pi->y = pi->ystart; pi->y < pi->yend;
 449                   pi->y += pi->ystep - (pi->y % pi->ystep)) {
 450                         for (pi->x = pi->xstart; pi->x < pi->xend;
 451                           pi->x += pi->xstep - (pi->x % pi->xstep)) {
 452                                 for (pi->rlvlno = pchg->rlvlnostart,
 453                                   pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
 454                                   pi->rlvlno < pi->picomp->numrlvls && pi->rlvlno <
 455                                   pchg->rlvlnoend; ++pi->rlvlno, ++pi->pirlvl) {
 456                                         if (pi->pirlvl->numprcs == 0) {
 457                                                 continue;
 458                                         }
 459                                         r = pi->picomp->numrlvls - 1 - pi->rlvlno;
 460                                         trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r);
 461                                         try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r);
 462                                         rpx = r + pi->pirlvl->prcwidthexpn;
 463                                         rpy = r + pi->pirlvl->prcheightexpn;
 464                                         if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) ||
 465                                           !(pi->x % (pi->picomp->hsamp << rpx))) &&
 466                                           ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) ||
 467                                           !(pi->y % (pi->picomp->vsamp << rpy)))) {
 468                                                 prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp
 469                                                   << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0,
 470                                                   pi->pirlvl->prcwidthexpn);
 471                                                 prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp
 472                                                   << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0,
 473                                                   pi->pirlvl->prcheightexpn);
 474                                                 pi->prcno = prcvind *
 475                                                   pi->pirlvl->numhprcs +
 476                                                   prchind;
 477                                                 assert(pi->prcno <
 478                                                   pi->pirlvl->numprcs);
 479                                                 for (pi->lyrno = 0; pi->lyrno <
 480                                                   pi->numlyrs && pi->lyrno < JAS_CAST(int, pchg->lyrnoend); ++pi->lyrno) {
 481                                                         prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
 482                                                         if (pi->lyrno >= *prclyrno) {
 483                                                                 ++(*prclyrno);
 484                                                                 return 0;
 485                                                         }
 486 skip:
 487                                                         ;
 488                                                 }
 489                                         }
 490                                 }
 491                         }
 492                 }
 493         }
 494         return 1;
 495 }
 496
 497 static void pirlvl_destroy(jpc_pirlvl_t *rlvl)
 498 {
 499         if (rlvl->prclyrnos) {
 500                 jas_free(rlvl->prclyrnos);
 501         }
 502 }
 503
 504 static void jpc_picomp_destroy(jpc_picomp_t *picomp)
 505 {
 506         int rlvlno;
 507         jpc_pirlvl_t *pirlvl;
 508         if (picomp->pirlvls) {
 509                 for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
 510                   picomp->numrlvls; ++rlvlno, ++pirlvl) {
 511                         pirlvl_destroy(pirlvl);
 512                 }
 513                 jas_free(picomp->pirlvls);
 514         }
 515 }
 516
 517 void jpc_pi_destroy(jpc_pi_t *pi)
 518 {
 519         jpc_picomp_t *picomp;
 520         int compno;
 521         if (pi->picomps) {
 522                 for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
 523                   ++compno, ++picomp) {
 524                         jpc_picomp_destroy(picomp);
 525                 }
 526                 jas_free(pi->picomps);
 527         }
 528         if (pi->pchglist) {
 529                 jpc_pchglist_destroy(pi->pchglist);
 530         }
 531         jas_free(pi);
 532 }
 533
 534 jpc_pi_t *jpc_pi_create0()
 535 {
 536         jpc_pi_t *pi;
 537         if (!(pi = jas_malloc(sizeof(jpc_pi_t)))) {
 538                 return 0;
 539         }
 540         pi->picomps = 0;
 541         pi->pchgno = 0;
 542         if (!(pi->pchglist = jpc_pchglist_create())) {
 543                 jas_free(pi);
 544                 return 0;
 545         }
 546         return pi;
 547 }
 548
 549 int jpc_pi_addpchg(jpc_pi_t *pi, jpc_pocpchg_t *pchg)
 550 {
 551         return jpc_pchglist_insert(pi->pchglist, -1, pchg);
 552 }
 553
 554 jpc_pchglist_t *jpc_pchglist_create()
 555 {
 556         jpc_pchglist_t *pchglist;
 557         if (!(pchglist = jas_malloc(sizeof(jpc_pchglist_t)))) {
 558                 return 0;
 559         }
 560         pchglist->numpchgs = 0;
 561         pchglist->maxpchgs = 0;
 562         pchglist->pchgs = 0;
 563         return pchglist;
 564 }
 565
 566 int jpc_pchglist_insert(jpc_pchglist_t *pchglist, int pchgno, jpc_pchg_t *pchg)
 567 {
 568         int i;
 569         int newmaxpchgs;
 570         jpc_pchg_t **newpchgs;
 571         if (pchgno < 0) {
 572                 pchgno = pchglist->numpchgs;
 573         }
 574         if (pchglist->numpchgs >= pchglist->maxpchgs) {
 575                 newmaxpchgs = pchglist->maxpchgs + 128;
 576                 if (!(newpchgs = jas_realloc(pchglist->pchgs, newmaxpchgs * sizeof(jpc_pchg_t *)))) {
 577                         return -1;
 578                 }
 579                 pchglist->maxpchgs = newmaxpchgs;
 580                 pchglist->pchgs = newpchgs;
 581         }
 582         for (i = pchglist->numpchgs; i > pchgno; --i) {
 583                 pchglist->pchgs[i] = pchglist->pchgs[i - 1];
 584         }
 585         pchglist->pchgs[pchgno] = pchg;
 586         ++pchglist->numpchgs;
 587         return 0;
 588 }
 589
 590 jpc_pchg_t *jpc_pchglist_remove(jpc_pchglist_t *pchglist, int pchgno)
 591 {
 592         int i;
 593         jpc_pchg_t *pchg;
 594         assert(pchgno < pchglist->numpchgs);
 595         pchg = pchglist->pchgs[pchgno];
 596         for (i = pchgno + 1; i < pchglist->numpchgs; ++i) {
 597                 pchglist->pchgs[i - 1] = pchglist->pchgs[i];
 598         }
 599         --pchglist->numpchgs;
 600         return pchg;
 601 }
 602
 603 jpc_pchg_t *jpc_pchg_copy(jpc_pchg_t *pchg)
 604 {
 605         jpc_pchg_t *newpchg;
 606         if (!(newpchg = jas_malloc(sizeof(jpc_pchg_t)))) {
 607                 return 0;
 608         }
 609         *newpchg = *pchg;
 610         return newpchg;
 611 }
 612
 613 jpc_pchglist_t *jpc_pchglist_copy(jpc_pchglist_t *pchglist)
 614 {
 615         jpc_pchglist_t *newpchglist;
 616         jpc_pchg_t *newpchg;
 617         int pchgno;
 618         if (!(newpchglist = jpc_pchglist_create())) {
 619                 return 0;
 620         }
 621         for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) {
 622                 if (!(newpchg = jpc_pchg_copy(pchglist->pchgs[pchgno])) ||
 623                   jpc_pchglist_insert(newpchglist, -1, newpchg)) {
 624                         jpc_pchglist_destroy(newpchglist);
 625                         return 0;
 626                 }
 627         }
 628         return newpchglist;
 629 }
 630
 631 void jpc_pchglist_destroy(jpc_pchglist_t *pchglist)
 632 {
 633         int pchgno;
 634         if (pchglist->pchgs) {
 635                 for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) {
 636                         jpc_pchg_destroy(pchglist->pchgs[pchgno]);
 637                 }
 638                 jas_free(pchglist->pchgs);
 639         }
 640         jas_free(pchglist);
 641 }
 642
 643 void jpc_pchg_destroy(jpc_pchg_t *pchg)
 644 {
 645         jas_free(pchg);
 646 }
 647
 648 jpc_pchg_t *jpc_pchglist_get(jpc_pchglist_t *pchglist, int pchgno)
 649 {
 650         return pchglist->pchgs[pchgno];
 651 }
 652
 653 int jpc_pchglist_numpchgs(jpc_pchglist_t *pchglist)
 654 {
 655         return pchglist->numpchgs;
 656 }
 657
 658 int jpc_pi_init(jpc_pi_t *pi)
 659 {
 660         int compno;
 661         int rlvlno;
 662         int prcno;
 663         jpc_picomp_t *picomp;
 664         jpc_pirlvl_t *pirlvl;
 665         int *prclyrno;
 666
 667         pi->prgvolfirst = 0;
 668         pi->valid = 0;
 669         pi->pktno = -1;
 670         pi->pchgno = -1;
 671         pi->pchg = 0;
 672
 673         for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
 674           ++compno, ++picomp) {
 675                 for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
 676                   picomp->numrlvls; ++rlvlno, ++pirlvl) {
 677                         for (prcno = 0, prclyrno = pirlvl->prclyrnos;
 678                           prcno < pirlvl->numprcs; ++prcno, ++prclyrno) {
 679                                 *prclyrno = 0;
 680                         }
 681                 }
 682         }
 683         return 0;
 684 }