mj2/libopenjpeg_097/pi.c

   1 /*\r
   2  * Copyright (c) 2001-2002, David Janssens\r
   3  * Copyright (c) 2003-2004, Yannick Verschueren\r
   4  * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\r
   5  * All rights reserved.\r
   6  *\r
   7  * Redistribution and use in source and binary forms, with or without\r
   8  * modification, are permitted provided that the following conditions\r
   9  * are met:\r
  10  * 1. Redistributions of source code must retain the above copyright\r
  11  *    notice, this list of conditions and the following disclaimer.\r
  12  * 2. Redistributions in binary form must reproduce the above copyright\r
  13  *    notice, this list of conditions and the following disclaimer in the\r
  14  *    documentation and/or other materials provided with the distribution.\r
  15  *\r
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
  26  * POSSIBILITY OF SUCH DAMAGE.\r
  27  */\r
  28 \r
  29 #include "pi.h"\r
  30 #include "int.h"\r
  31 #include <stdlib.h>\r
  32 #include <stdio.h>\r
  33 \r
  34 /* <summary>\r
  35  * Create a packet iterator.\r
  36  * </summary> */\r
  37 pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno)\r
  38 {\r
  39   int p, q, i;\r
  40   int compno, resno, pino;\r
  41   int maxres = 0;\r
  42   pi_iterator_t *pi;\r
  43   j2k_tcp_t *tcp;\r
  44   j2k_tccp_t *tccp;\r
  45 \r
  46   tcp = &cp->tcps[tileno];\r
  47   pi = (pi_iterator_t *) malloc((tcp->numpocs + 1) *\r
  48                                 sizeof(pi_iterator_t));\r
  49 \r
  50   for (pino = 0; pino < tcp->numpocs + 1; pino++) {     /* change */\r
  51     p = tileno % cp->tw;\r
  52     q = tileno / cp->tw;\r
  53 \r
  54     pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, img->x0);\r
  55     pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, img->y0);\r
  56     pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);\r
  57     pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);\r
  58     pi[pino].numcomps = img->numcomps;\r
  59     pi[pino].comps =\r
  60       (pi_comp_t *) malloc(img->numcomps * sizeof(pi_comp_t));\r
  61 \r
  62     for (compno = 0; compno < pi->numcomps; compno++) {\r
  63       int tcx0, tcy0, tcx1, tcy1;\r
  64       pi_comp_t *comp = &pi[pino].comps[compno];\r
  65       tccp = &tcp->tccps[compno];\r
  66       comp->dx = img->comps[compno].dx;\r
  67       comp->dy = img->comps[compno].dy;\r
  68       comp->numresolutions = tccp->numresolutions;\r
  69       comp->resolutions =\r
  70         (pi_resolution_t *) malloc(comp->numresolutions *\r
  71                                    sizeof(pi_resolution_t));\r
  72       tcx0 = int_ceildiv(pi->tx0, comp->dx);\r
  73       tcy0 = int_ceildiv(pi->ty0, comp->dy);\r
  74       tcx1 = int_ceildiv(pi->tx1, comp->dx);\r
  75       tcy1 = int_ceildiv(pi->ty1, comp->dy);\r
  76       if (comp->numresolutions > maxres) {\r
  77         maxres = comp->numresolutions;\r
  78       }\r
  79       for (resno = 0; resno < comp->numresolutions; resno++) {\r
  80         int levelno;\r
  81         int rx0, ry0, rx1, ry1;\r
  82         int px0, py0, px1, py1;\r
  83         pi_resolution_t *res = &comp->resolutions[resno];\r
  84         if (tccp->csty & J2K_CCP_CSTY_PRT) {\r
  85           res->pdx = tccp->prcw[resno];\r
  86           res->pdy = tccp->prch[resno];\r
  87         } else {\r
  88           res->pdx = 15;\r
  89           res->pdy = 15;\r
  90         }\r
  91         levelno = comp->numresolutions - 1 - resno;\r
  92         rx0 = int_ceildivpow2(tcx0, levelno);\r
  93         ry0 = int_ceildivpow2(tcy0, levelno);\r
  94         rx1 = int_ceildivpow2(tcx1, levelno);\r
  95         ry1 = int_ceildivpow2(tcy1, levelno);\r
  96         px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;\r
  97         py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;\r
  98         px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;\r
  99         py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;\r
 100  res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx); /*Mod Antonin : sizebug1*/\r
 101  res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy); /*Mod Antonin : sizebug1*/\r
 102       }\r
 103     }\r
 104 \r
 105     tccp = &tcp->tccps[0];\r
 106     pi[pino].step_p = 1;\r
 107     pi[pino].step_c = 100 * pi[pino].step_p;\r
 108     pi[pino].step_r = img->numcomps * pi[pino].step_c;\r
 109     pi[pino].step_l = maxres * pi[pino].step_r;\r
 110 \r
 111     if (pino == 0) {\r
 112       pi[pino].include =\r
 113         (short int *) malloc(img->numcomps * maxres *\r
 114                              tcp->numlayers * 100 * sizeof(short int));\r
 115       for (i = 0; i < img->numcomps * maxres * tcp->numlayers * 100; i++)\r
 116         pi[pino].include[i] = 0;\r
 117     }\r
 118     /* pi[pino].include=(short int*)calloc(img->numcomps*maxres*tcp->numlayers*1000,sizeof(short int)); */\r
 119     else\r
 120       pi[pino].include = pi[pino - 1].include;\r
 121 \r
 122     if (tcp->POC == 0) {\r
 123       pi[pino].first = 1;\r
 124       pi[pino].poc.resno0 = 0;\r
 125       pi[pino].poc.compno0 = 0;\r
 126       pi[pino].poc.layno1 = tcp->numlayers;\r
 127       pi[pino].poc.resno1 = maxres;\r
 128       pi[pino].poc.compno1 = img->numcomps;\r
 129       pi[pino].poc.prg = tcp->prg;\r
 130     } else {\r
 131       pi[pino].first = 1;\r
 132       pi[pino].poc.resno0 = tcp->pocs[pino].resno0;\r
 133       pi[pino].poc.compno0 = tcp->pocs[pino].compno0;\r
 134       pi[pino].poc.layno1 = tcp->pocs[pino].layno1;\r
 135       pi[pino].poc.resno1 = tcp->pocs[pino].resno1;\r
 136       pi[pino].poc.compno1 = tcp->pocs[pino].compno1;\r
 137       pi[pino].poc.prg = tcp->pocs[pino].prg;\r
 138     }\r
 139   }\r
 140   return pi;\r
 141 }\r
 142 \r
 143 /* <summary>\r
 144  * Get next packet in layer-resolution-component-precinct order.\r
 145  * \r
 146  * pi: packet iterator to modify\r
 147  * </summary> */\r
 148 int pi_next_lrcp(pi_iterator_t * pi)\r
 149 {\r
 150   pi_comp_t *comp;\r
 151   pi_resolution_t *res;\r
 152 \r
 153   if (!pi->first) {\r
 154     comp = &pi->comps[pi->compno];\r
 155     res = &comp->resolutions[pi->resno];\r
 156     goto skip;\r
 157   } else {\r
 158     pi->first = 0;\r
 159   }\r
 160   for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
 161     for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;\r
 162          pi->resno++) {\r
 163       for (pi->compno = pi->poc.compno0;\r
 164            pi->compno < pi->poc.compno1; pi->compno++) {\r
 165         comp = &pi->comps[pi->compno];\r
 166         if (pi->resno >= comp->numresolutions) {\r
 167           continue;\r
 168         }\r
 169         res = &comp->resolutions[pi->resno];\r
 170         for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {\r
 171           if (!pi->\r
 172               include[pi->layno * pi->step_l +\r
 173                       pi->resno * pi->step_r +\r
 174                       pi->compno * pi->step_c + pi->precno * pi->step_p]) {\r
 175             pi->include[pi->layno * pi->step_l +\r
 176                         pi->resno * pi->step_r +\r
 177                         pi->compno * pi->step_c +\r
 178                         pi->precno * pi->step_p] = 1;\r
 179             return 1;\r
 180           }\r
 181         skip:;\r
 182         }\r
 183       }\r
 184     }\r
 185   }\r
 186   return 0;\r
 187 }\r
 188 \r
 189 /* <summary>\r
 190  * Get next packet in resolution-layer-component-precinct order.\r
 191  *\r
 192  * pi: packet iterator to modify\r
 193  * </summary> */\r
 194 int pi_next_rlcp(pi_iterator_t * pi)\r
 195 {\r
 196   pi_comp_t *comp;\r
 197   pi_resolution_t *res;\r
 198   if (!pi->first) {\r
 199     comp = &pi->comps[pi->compno];\r
 200     res = &comp->resolutions[pi->resno];\r
 201     goto skip;\r
 202   } else {\r
 203     pi->first = 0;\r
 204   }\r
 205   for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {\r
 206     for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
 207       for (pi->compno = pi->poc.compno0;\r
 208            pi->compno < pi->poc.compno1; pi->compno++) {\r
 209         comp = &pi->comps[pi->compno];\r
 210         if (pi->resno >= comp->numresolutions) {\r
 211           continue;\r
 212         }\r
 213         res = &comp->resolutions[pi->resno];\r
 214         for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {\r
 215           if (!pi->\r
 216               include[pi->layno * pi->step_l +\r
 217                       pi->resno * pi->step_r +\r
 218                       pi->compno * pi->step_c + pi->precno * pi->step_p]) {\r
 219             pi->include[pi->layno * pi->step_l +\r
 220                         pi->resno * pi->step_r +\r
 221                         pi->compno * pi->step_c +\r
 222                         pi->precno * pi->step_p] = 1;\r
 223             return 1;\r
 224           }\r
 225         skip:;\r
 226         }\r
 227       }\r
 228     }\r
 229   }\r
 230   return 0;\r
 231 }\r
 232 \r
 233 /* <summary>\r
 234  * Get next packet in resolution-precinct-component-layer order.\r
 235  *\r
 236  * pi: packet iterator to modify\r
 237  * </summary> */\r
 238 int pi_next_rpcl(pi_iterator_t * pi)\r
 239 {\r
 240   pi_comp_t *comp;\r
 241   pi_resolution_t *res;\r
 242   if (!pi->first) {\r
 243     goto skip;\r
 244   } else {\r
 245     int compno, resno;\r
 246     pi->first = 0;\r
 247     pi->dx = 0;\r
 248     pi->dy = 0;\r
 249     for (compno = 0; compno < pi->numcomps; compno++) {\r
 250       comp = &pi->comps[compno];\r
 251       for (resno = 0; resno < comp->numresolutions; resno++) {\r
 252         int dx, dy;\r
 253         res = &comp->resolutions[resno];\r
 254         dx = comp->dx *\r
 255           (1 << (res->pdx + comp->numresolutions - 1 - resno));\r
 256         dy = comp->dy *\r
 257           (1 << (res->pdy + comp->numresolutions - 1 - resno));\r
 258         pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);\r
 259         pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);\r
 260       }\r
 261     }\r
 262   }\r
 263   for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {\r
 264     for (pi->y = pi->ty0; pi->y < pi->ty1;\r
 265          pi->y += pi->dy - (pi->y % pi->dy)) {\r
 266       for (pi->x = pi->tx0; pi->x < pi->tx1;\r
 267            pi->x += pi->dx - (pi->x % pi->dx)) {\r
 268         for (pi->compno = pi->poc.compno0;\r
 269              pi->compno < pi->poc.compno1; pi->compno++) {\r
 270           int levelno;\r
 271           int trx0, try0;\r
 272    int trx1, try1;/* Add antonin pcrl*/\r
 273           int rpx, rpy;\r
 274           int prci, prcj;\r
 275           comp = &pi->comps[pi->compno];\r
 276           if (pi->resno >= comp->numresolutions) {\r
 277             continue;\r
 278           }\r
 279           res = &comp->resolutions[pi->resno];\r
 280           levelno = comp->numresolutions - 1 - pi->resno;\r
 281           trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);\r
 282           try0 = int_ceildiv(pi->ty0, comp->dy << levelno);\r
 283    trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);/* Add antonin pcrl*/\r
 284    try1 = int_ceildiv(pi->ty1, comp->dy << levelno);/* Add antonin pcrl*/\r
 285           rpx = res->pdx + levelno;\r
 286           rpy = res->pdy + levelno;\r
 287           if (!\r
 288               (pi->x % (comp->dx << rpx) == 0\r
 289                || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {\r
 290             continue;\r
 291           }\r
 292           if (!\r
 293               (pi->y % (comp->dy << rpy) == 0\r
 294                || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {\r
 295             continue;\r
 296           }\r
 297 \r
 298    /*Add Antonin : sizebug1*/\r
 299           if ((res->pw==0)||(res->pw==0)) continue;\r
 300    /*ddA*/\r
 301 \r
 302    /*Add Antonin : pcrl*/\r
 303           if ((trx0==trx1)||(try0==try1)) continue;\r
 304    /*ddA*/\r
 305 \r
 306           prci =\r
 307             int_floordivpow2(int_ceildiv\r
 308                              (pi->x, comp->dx << levelno),\r
 309                              res->pdx) - int_floordivpow2(trx0, res->pdx);\r
 310           prcj =\r
 311             int_floordivpow2(int_ceildiv\r
 312                              (pi->y, comp->dy << levelno),\r
 313                              res->pdy) - int_floordivpow2(try0, res->pdy);\r
 314           pi->precno = prci + prcj * res->pw;\r
 315           for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
 316             if (!pi->\r
 317                 include[pi->layno * pi->step_l +\r
 318                         pi->resno * pi->step_r +\r
 319                         pi->compno * pi->step_c +\r
 320                         pi->precno * pi->step_p]) {\r
 321               pi->include[pi->layno * pi->step_l +\r
 322                           pi->resno * pi->step_r +\r
 323                           pi->compno * pi->step_c +\r
 324                           pi->precno * pi->step_p] = 1;\r
 325               return 1;\r
 326             }\r
 327           skip:;\r
 328           }\r
 329         }\r
 330       }\r
 331     }\r
 332   }\r
 333   return 0;\r
 334 }\r
 335 \r
 336 /* <summary>\r
 337  * Get next packet in precinct-component-resolution-layer order.\r
 338  *\r
 339  * pi: packet iterator to modify\r
 340  * </summary> */\r
 341 int pi_next_pcrl(pi_iterator_t * pi)\r
 342 {\r
 343   pi_comp_t *comp;\r
 344   pi_resolution_t *res;\r
 345   if (!pi->first) {\r
 346     comp = &pi->comps[pi->compno];\r
 347     goto skip;\r
 348   } else {\r
 349     int compno, resno;\r
 350     pi->first = 0;\r
 351     pi->dx = 0;\r
 352     pi->dy = 0;\r
 353     for (compno = 0; compno < pi->numcomps; compno++) {\r
 354       comp = &pi->comps[compno];\r
 355       for (resno = 0; resno < comp->numresolutions; resno++) {\r
 356         int dx, dy;\r
 357         res = &comp->resolutions[resno];\r
 358         dx = comp->dx *\r
 359           (1 << (res->pdx + comp->numresolutions - 1 - resno));\r
 360         dy = comp->dy *\r
 361           (1 << (res->pdy + comp->numresolutions - 1 - resno));\r
 362         pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);\r
 363         pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);\r
 364       }\r
 365     }\r
 366   }\r
 367   for (pi->y = pi->ty0; pi->y < pi->ty1;\r
 368   pi->y += pi->dy - (pi->y % pi->dy)) {\r
 369     for (pi->x = pi->tx0; pi->x < pi->tx1;\r
 370     pi->x += pi->dx - (pi->x % pi->dx)) {\r
 371       for (pi->compno = pi->poc.compno0;\r
 372       pi->compno < pi->poc.compno1; pi->compno++) {\r
 373         comp = &pi->comps[pi->compno];\r
 374         for (pi->resno = pi->poc.resno0;\r
 375         pi->resno < int_min(pi->poc.resno1,\r
 376           comp->numresolutions); pi->resno++) {\r
 377           int levelno;\r
 378           int trx0, try0;\r
 379    int trx1, try1;/* Add antonin pcrl*/\r
 380           int rpx, rpy;\r
 381           int prci, prcj;\r
 382           res = &comp->resolutions[pi->resno];\r
 383           levelno = comp->numresolutions - 1 - pi->resno;\r
 384           trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);\r
 385           try0 = int_ceildiv(pi->ty0, comp->dy << levelno);\r
 386    trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);/* Add antonin pcrl*/\r
 387    try1 = int_ceildiv(pi->ty1, comp->dy << levelno);/* Add antonin pcrl*/\r
 388           rpx = res->pdx + levelno;\r
 389           rpy = res->pdy + levelno;\r
 390           if (!\r
 391             (pi->x % (comp->dx << rpx) == 0\r
 392             || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {\r
 393             continue;\r
 394           }\r
 395           if (!\r
 396             (pi->y % (comp->dy << rpy) == 0\r
 397             || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {\r
 398             continue;\r
 399           }\r
 400           \r
 401    /*Add Antonin : sizebug1*/\r
 402           if ((res->pw==0)||(res->pw==0)) continue;\r
 403    /*ddA*/\r
 404 \r
 405    /*Add Antonin : pcrl*/\r
 406           if ((trx0==trx1)||(try0==try1)) continue;\r
 407    /*ddA*/\r
 408           \r
 409           prci =\r
 410             int_floordivpow2(int_ceildiv\r
 411             (pi->x, comp->dx << levelno),\r
 412             res->pdx) - int_floordivpow2(trx0, res->pdx);\r
 413           prcj =\r
 414             int_floordivpow2(int_ceildiv\r
 415             (pi->y, comp->dy << levelno),\r
 416             res->pdy) - int_floordivpow2(try0, res->pdy);\r
 417           pi->precno = prci + prcj * res->pw;\r
 418           for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
 419             if (!pi->\r
 420               include[pi->layno * pi->step_l +\r
 421               pi->resno * pi->step_r +\r
 422               pi->compno * pi->step_c +\r
 423               pi->precno * pi->step_p]) {\r
 424               pi->include[pi->layno * pi->step_l +\r
 425                 pi->resno * pi->step_r +\r
 426                 pi->compno * pi->step_c +\r
 427                 pi->precno * pi->step_p] = 1;\r
 428               return 1;\r
 429             }\r
 430 skip:;\r
 431           }\r
 432         }\r
 433       }\r
 434     }\r
 435   }\r
 436   return 0;\r
 437 }\r
 438 \r
 439 /* <summary>\r
 440  * Get next packet in component-precinct-resolution-layer order.\r
 441  *\r
 442  * pi: packet iterator to modify\r
 443  * </summary> */\r
 444 int pi_next_cprl(pi_iterator_t * pi)\r
 445 {\r
 446   pi_comp_t *comp;\r
 447   pi_resolution_t *res;\r
 448   if (!pi->first) {\r
 449     comp = &pi->comps[pi->compno];\r
 450     goto skip;\r
 451   } else {\r
 452     pi->first = 0;\r
 453   }\r
 454   for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;\r
 455        pi->compno++) {\r
 456     int resno;\r
 457     comp = &pi->comps[pi->compno];\r
 458     pi->dx = 0;\r
 459     pi->dy = 0;\r
 460     for (resno = 0; resno < comp->numresolutions; resno++) {\r
 461       int dx, dy;\r
 462       res = &comp->resolutions[resno];\r
 463       dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));\r
 464       dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));\r
 465       pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);\r
 466       pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);\r
 467     }\r
 468     for (pi->y = pi->ty0; pi->y < pi->ty1;\r
 469          pi->y += pi->dy - (pi->y % pi->dy)) {\r
 470       for (pi->x = pi->tx0; pi->x < pi->tx1;\r
 471            pi->x += pi->dx - (pi->x % pi->dx)) {\r
 472         for (pi->resno = pi->poc.resno0;\r
 473              pi->resno < int_min(pi->poc.resno1,\r
 474                                  comp->numresolutions); pi->resno++) {\r
 475           int levelno;\r
 476           int trx0, try0;\r
 477    int trx1, try1;/* Add antonin pcrl*/\r
 478           int rpx, rpy;\r
 479           int prci, prcj;\r
 480           res = &comp->resolutions[pi->resno];\r
 481           levelno = comp->numresolutions - 1 - pi->resno;\r
 482           trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);\r
 483           try0 = int_ceildiv(pi->ty0, comp->dy << levelno);\r
 484    trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);/* Add antonin pcrl*/\r
 485    try1 = int_ceildiv(pi->ty1, comp->dy << levelno);/* Add antonin pcrl*/\r
 486           rpx = res->pdx + levelno;\r
 487           rpy = res->pdy + levelno;\r
 488           if (!\r
 489               (pi->x % (comp->dx << rpx) == 0\r
 490                || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {\r
 491             continue;\r
 492           }\r
 493           if (!\r
 494               (pi->y % (comp->dy << rpy) == 0\r
 495                || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {\r
 496             continue;\r
 497           }\r
 498 \r
 499    /*Add Antonin : sizebug1*/\r
 500           if ((res->pw==0)||(res->pw==0)) continue;\r
 501    /*ddA*/\r
 502 \r
 503    /*Add Antonin : pcrl*/\r
 504           if ((trx0==trx1)||(try0==try1)) continue;\r
 505    /*ddA*/\r
 506 \r
 507           prci =\r
 508             int_floordivpow2(int_ceildiv\r
 509                              (pi->x, comp->dx << levelno),\r
 510                              res->pdx) - int_floordivpow2(trx0, res->pdx);\r
 511           prcj =\r
 512             int_floordivpow2(int_ceildiv\r
 513                              (pi->y, comp->dy << levelno),\r
 514                              res->pdy) - int_floordivpow2(try0, res->pdy);\r
 515           pi->precno = prci + prcj * res->pw;\r
 516           for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {\r
 517             if (!pi->\r
 518                 include[pi->layno * pi->step_l +\r
 519                         pi->resno * pi->step_r +\r
 520                         pi->compno * pi->step_c +\r
 521                         pi->precno * pi->step_p]) {\r
 522               pi->include[pi->layno * pi->step_l +\r
 523                           pi->resno * pi->step_r +\r
 524                           pi->compno * pi->step_c +\r
 525                           pi->precno * pi->step_p] = 1;\r
 526               return 1;\r
 527             }\r
 528           skip:;\r
 529           }\r
 530         }\r
 531       }\r
 532     }\r
 533   }\r
 534   return 0;\r
 535 }\r
 536 \r
 537 /* <summary>\r
 538  * Get next packet.\r
 539   *\r
 540   * pi: packet iterator to modify\r
 541   * </summary> */\r
 542 int pi_next(pi_iterator_t * pi)\r
 543 {\r
 544   switch (pi->poc.prg) {\r
 545   case 0:\r
 546     return pi_next_lrcp(pi);\r
 547   case 1:\r
 548     return pi_next_rlcp(pi);\r
 549   case 2:\r
 550     return pi_next_rpcl(pi);\r
 551   case 3:\r
 552     return pi_next_pcrl(pi);\r
 553   case 4:\r
 554     return pi_next_cprl(pi);\r
 555   }\r
 556   return 0;\r
 557 }\r